1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "dictionary.h"
38 #include "cp-support.h"
40 #include "user-regs.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
50 extern int overload_debug
;
51 /* Local functions. */
53 static int typecmp (int staticp
, int varargs
, int nargs
,
54 struct field t1
[], struct value
*t2
[]);
56 static struct value
*search_struct_field (char *, struct value
*,
57 int, struct type
*, int);
59 static struct value
*search_struct_method (char *, struct value
**,
61 int, int *, struct type
*);
63 static int find_oload_champ_namespace (struct type
**, int,
64 const char *, const char *,
66 struct badness_vector
**);
69 int find_oload_champ_namespace_loop (struct type
**, int,
70 const char *, const char *,
71 int, struct symbol
***,
72 struct badness_vector
**, int *);
74 static int find_oload_champ (struct type
**, int, int, int,
75 struct fn_field
*, struct symbol
**,
76 struct badness_vector
**);
78 static int oload_method_static (int, struct fn_field
*, int);
80 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
83 oload_classification
classify_oload_match (struct badness_vector
*,
86 static struct value
*value_struct_elt_for_reference (struct type
*,
92 static struct value
*value_namespace_elt (const struct type
*,
93 char *, int , enum noside
);
95 static struct value
*value_maybe_namespace_elt (const struct type
*,
99 static CORE_ADDR
allocate_space_in_inferior (int);
101 static struct value
*cast_into_complex (struct type
*, struct value
*);
103 static struct fn_field
*find_method_list (struct value
**, char *,
104 int, struct type
*, int *,
105 struct type
**, int *);
107 void _initialize_valops (void);
110 /* Flag for whether we want to abandon failed expression evals by
113 static int auto_abandon
= 0;
116 int overload_resolution
= 0;
118 show_overload_resolution (struct ui_file
*file
, int from_tty
,
119 struct cmd_list_element
*c
,
122 fprintf_filtered (file
, _("\
123 Overload resolution in evaluating C++ functions is %s.\n"),
127 /* Find the address of function name NAME in the inferior. If OBJF_P
128 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
132 find_function_in_inferior (const char *name
, struct objfile
**objf_p
)
135 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
138 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
140 error (_("\"%s\" exists in this program but is not a function."),
145 *objf_p
= SYMBOL_SYMTAB (sym
)->objfile
;
147 return value_of_variable (sym
, NULL
);
151 struct minimal_symbol
*msymbol
=
152 lookup_minimal_symbol (name
, NULL
, NULL
);
155 struct objfile
*objfile
= msymbol_objfile (msymbol
);
156 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
160 type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_char
);
161 type
= lookup_function_type (type
);
162 type
= lookup_pointer_type (type
);
163 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
168 return value_from_pointer (type
, maddr
);
172 if (!target_has_execution
)
173 error (_("evaluation of this expression requires the target program to be active"));
175 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name
);
180 /* Allocate NBYTES of space in the inferior using the inferior's
181 malloc and return a value that is a pointer to the allocated
185 value_allocate_space_in_inferior (int len
)
187 struct objfile
*objf
;
188 struct value
*val
= find_function_in_inferior ("malloc", &objf
);
189 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
190 struct value
*blocklen
;
192 blocklen
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, len
);
193 val
= call_function_by_hand (val
, 1, &blocklen
);
194 if (value_logical_not (val
))
196 if (!target_has_execution
)
197 error (_("No memory available to program now: you need to start the target first"));
199 error (_("No memory available to program: call to malloc failed"));
205 allocate_space_in_inferior (int len
)
207 return value_as_long (value_allocate_space_in_inferior (len
));
210 /* Cast struct value VAL to type TYPE and return as a value.
211 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
212 for this to work. Typedef to one of the codes is permitted.
213 Returns NULL if the cast is neither an upcast nor a downcast. */
215 static struct value
*
216 value_cast_structs (struct type
*type
, struct value
*v2
)
222 gdb_assert (type
!= NULL
&& v2
!= NULL
);
224 t1
= check_typedef (type
);
225 t2
= check_typedef (value_type (v2
));
227 /* Check preconditions. */
228 gdb_assert ((TYPE_CODE (t1
) == TYPE_CODE_STRUCT
229 || TYPE_CODE (t1
) == TYPE_CODE_UNION
)
230 && !!"Precondition is that type is of STRUCT or UNION kind.");
231 gdb_assert ((TYPE_CODE (t2
) == TYPE_CODE_STRUCT
232 || TYPE_CODE (t2
) == TYPE_CODE_UNION
)
233 && !!"Precondition is that value is of STRUCT or UNION kind");
235 if (TYPE_NAME (t1
) != NULL
236 && TYPE_NAME (t2
) != NULL
237 && !strcmp (TYPE_NAME (t1
), TYPE_NAME (t2
)))
240 /* Upcasting: look in the type of the source to see if it contains the
241 type of the target as a superclass. If so, we'll need to
242 offset the pointer rather than just change its type. */
243 if (TYPE_NAME (t1
) != NULL
)
245 v
= search_struct_field (type_name_no_tag (t1
),
251 /* Downcasting: look in the type of the target to see if it contains the
252 type of the source as a superclass. If so, we'll need to
253 offset the pointer rather than just change its type. */
254 if (TYPE_NAME (t2
) != NULL
)
256 /* Try downcasting using the run-time type of the value. */
257 int full
, top
, using_enc
;
258 struct type
*real_type
;
260 real_type
= value_rtti_type (v2
, &full
, &top
, &using_enc
);
263 v
= value_full_object (v2
, real_type
, full
, top
, using_enc
);
264 v
= value_at_lazy (real_type
, value_address (v
));
266 /* We might be trying to cast to the outermost enclosing
267 type, in which case search_struct_field won't work. */
268 if (TYPE_NAME (real_type
) != NULL
269 && !strcmp (TYPE_NAME (real_type
), TYPE_NAME (t1
)))
272 v
= search_struct_field (type_name_no_tag (t2
), v
, 0, real_type
, 1);
277 /* Try downcasting using information from the destination type
278 T2. This wouldn't work properly for classes with virtual
279 bases, but those were handled above. */
280 v
= search_struct_field (type_name_no_tag (t2
),
281 value_zero (t1
, not_lval
), 0, t1
, 1);
284 /* Downcasting is possible (t1 is superclass of v2). */
285 CORE_ADDR addr2
= value_address (v2
);
286 addr2
-= value_address (v
) + value_embedded_offset (v
);
287 return value_at (type
, addr2
);
294 /* Cast one pointer or reference type to another. Both TYPE and
295 the type of ARG2 should be pointer types, or else both should be
296 reference types. Returns the new pointer or reference. */
299 value_cast_pointers (struct type
*type
, struct value
*arg2
)
301 struct type
*type1
= check_typedef (type
);
302 struct type
*type2
= check_typedef (value_type (arg2
));
303 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
304 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
306 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
307 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
308 && !value_logical_not (arg2
))
312 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
313 v2
= coerce_ref (arg2
);
315 v2
= value_ind (arg2
);
316 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
))) == TYPE_CODE_STRUCT
317 && !!"Why did coercion fail?");
318 v2
= value_cast_structs (t1
, v2
);
319 /* At this point we have what we can have, un-dereference if needed. */
322 struct value
*v
= value_addr (v2
);
323 deprecated_set_value_type (v
, type
);
328 /* No superclass found, just change the pointer type. */
329 arg2
= value_copy (arg2
);
330 deprecated_set_value_type (arg2
, type
);
331 arg2
= value_change_enclosing_type (arg2
, type
);
332 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
336 /* Cast value ARG2 to type TYPE and return as a value.
337 More general than a C cast: accepts any two types of the same length,
338 and if ARG2 is an lvalue it can be cast into anything at all. */
339 /* In C++, casts may change pointer or object representations. */
342 value_cast (struct type
*type
, struct value
*arg2
)
344 enum type_code code1
;
345 enum type_code code2
;
349 int convert_to_boolean
= 0;
351 if (value_type (arg2
) == type
)
354 code1
= TYPE_CODE (check_typedef (type
));
356 /* Check if we are casting struct reference to struct reference. */
357 if (code1
== TYPE_CODE_REF
)
359 /* We dereference type; then we recurse and finally
360 we generate value of the given reference. Nothing wrong with
362 struct type
*t1
= check_typedef (type
);
363 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
364 struct value
*val
= value_cast (dereftype
, arg2
);
365 return value_ref (val
);
368 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
370 if (code2
== TYPE_CODE_REF
)
371 /* We deref the value and then do the cast. */
372 return value_cast (type
, coerce_ref (arg2
));
374 CHECK_TYPEDEF (type
);
375 code1
= TYPE_CODE (type
);
376 arg2
= coerce_ref (arg2
);
377 type2
= check_typedef (value_type (arg2
));
379 /* You can't cast to a reference type. See value_cast_pointers
381 gdb_assert (code1
!= TYPE_CODE_REF
);
383 /* A cast to an undetermined-length array_type, such as
384 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
385 where N is sizeof(OBJECT)/sizeof(TYPE). */
386 if (code1
== TYPE_CODE_ARRAY
)
388 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
389 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
390 if (element_length
> 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
392 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
393 int val_length
= TYPE_LENGTH (type2
);
394 LONGEST low_bound
, high_bound
, new_length
;
395 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
396 low_bound
= 0, high_bound
= 0;
397 new_length
= val_length
/ element_length
;
398 if (val_length
% element_length
!= 0)
399 warning (_("array element type size does not divide object size in cast"));
400 /* FIXME-type-allocation: need a way to free this type when
401 we are done with it. */
402 range_type
= create_range_type ((struct type
*) NULL
,
403 TYPE_TARGET_TYPE (range_type
),
405 new_length
+ low_bound
- 1);
406 deprecated_set_value_type (arg2
,
407 create_array_type ((struct type
*) NULL
,
414 if (current_language
->c_style_arrays
415 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
416 arg2
= value_coerce_array (arg2
);
418 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
419 arg2
= value_coerce_function (arg2
);
421 type2
= check_typedef (value_type (arg2
));
422 code2
= TYPE_CODE (type2
);
424 if (code1
== TYPE_CODE_COMPLEX
)
425 return cast_into_complex (type
, arg2
);
426 if (code1
== TYPE_CODE_BOOL
)
428 code1
= TYPE_CODE_INT
;
429 convert_to_boolean
= 1;
431 if (code1
== TYPE_CODE_CHAR
)
432 code1
= TYPE_CODE_INT
;
433 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
434 code2
= TYPE_CODE_INT
;
436 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
437 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
438 || code2
== TYPE_CODE_RANGE
);
440 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
441 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
442 && TYPE_NAME (type
) != 0)
444 struct value
*v
= value_cast_structs (type
, arg2
);
449 if (code1
== TYPE_CODE_FLT
&& scalar
)
450 return value_from_double (type
, value_as_double (arg2
));
451 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
453 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
454 int dec_len
= TYPE_LENGTH (type
);
457 if (code2
== TYPE_CODE_FLT
)
458 decimal_from_floating (arg2
, dec
, dec_len
, byte_order
);
459 else if (code2
== TYPE_CODE_DECFLOAT
)
460 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
461 byte_order
, dec
, dec_len
, byte_order
);
463 /* The only option left is an integral type. */
464 decimal_from_integral (arg2
, dec
, dec_len
, byte_order
);
466 return value_from_decfloat (type
, dec
);
468 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
469 || code1
== TYPE_CODE_RANGE
)
470 && (scalar
|| code2
== TYPE_CODE_PTR
471 || code2
== TYPE_CODE_MEMBERPTR
))
475 /* When we cast pointers to integers, we mustn't use
476 gdbarch_pointer_to_address to find the address the pointer
477 represents, as value_as_long would. GDB should evaluate
478 expressions just as the compiler would --- and the compiler
479 sees a cast as a simple reinterpretation of the pointer's
481 if (code2
== TYPE_CODE_PTR
)
482 longest
= extract_unsigned_integer
483 (value_contents (arg2
), TYPE_LENGTH (type2
),
484 gdbarch_byte_order (get_type_arch (type2
)));
486 longest
= value_as_long (arg2
);
487 return value_from_longest (type
, convert_to_boolean
?
488 (LONGEST
) (longest
? 1 : 0) : longest
);
490 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
491 || code2
== TYPE_CODE_ENUM
492 || code2
== TYPE_CODE_RANGE
))
494 /* TYPE_LENGTH (type) is the length of a pointer, but we really
495 want the length of an address! -- we are really dealing with
496 addresses (i.e., gdb representations) not pointers (i.e.,
497 target representations) here.
499 This allows things like "print *(int *)0x01000234" to work
500 without printing a misleading message -- which would
501 otherwise occur when dealing with a target having two byte
502 pointers and four byte addresses. */
504 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
506 LONGEST longest
= value_as_long (arg2
);
507 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
509 if (longest
>= ((LONGEST
) 1 << addr_bit
)
510 || longest
<= -((LONGEST
) 1 << addr_bit
))
511 warning (_("value truncated"));
513 return value_from_longest (type
, longest
);
515 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
516 && value_as_long (arg2
) == 0)
518 struct value
*result
= allocate_value (type
);
519 cplus_make_method_ptr (type
, value_contents_writeable (result
), 0, 0);
522 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
523 && value_as_long (arg2
) == 0)
525 /* The Itanium C++ ABI represents NULL pointers to members as
526 minus one, instead of biasing the normal case. */
527 return value_from_longest (type
, -1);
529 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
531 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
532 return value_cast_pointers (type
, arg2
);
534 arg2
= value_copy (arg2
);
535 deprecated_set_value_type (arg2
, type
);
536 arg2
= value_change_enclosing_type (arg2
, type
);
537 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
540 else if (VALUE_LVAL (arg2
) == lval_memory
)
541 return value_at_lazy (type
, value_address (arg2
));
542 else if (code1
== TYPE_CODE_VOID
)
544 return value_zero (type
, not_lval
);
548 error (_("Invalid cast."));
553 /* The C++ reinterpret_cast operator. */
556 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
558 struct value
*result
;
559 struct type
*real_type
= check_typedef (type
);
560 struct type
*arg_type
, *dest_type
;
562 enum type_code dest_code
, arg_code
;
564 /* Do reference, function, and array conversion. */
565 arg
= coerce_array (arg
);
567 /* Attempt to preserve the type the user asked for. */
570 /* If we are casting to a reference type, transform
571 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
572 if (TYPE_CODE (real_type
) == TYPE_CODE_REF
)
575 arg
= value_addr (arg
);
576 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
577 real_type
= lookup_pointer_type (real_type
);
580 arg_type
= value_type (arg
);
582 dest_code
= TYPE_CODE (real_type
);
583 arg_code
= TYPE_CODE (arg_type
);
585 /* We can convert pointer types, or any pointer type to int, or int
587 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
588 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
589 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
590 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
591 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
592 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
593 || (dest_code
== arg_code
594 && (dest_code
== TYPE_CODE_PTR
595 || dest_code
== TYPE_CODE_METHODPTR
596 || dest_code
== TYPE_CODE_MEMBERPTR
)))
597 result
= value_cast (dest_type
, arg
);
599 error (_("Invalid reinterpret_cast"));
602 result
= value_cast (type
, value_ref (value_ind (result
)));
607 /* A helper for value_dynamic_cast. This implements the first of two
608 runtime checks: we iterate over all the base classes of the value's
609 class which are equal to the desired class; if only one of these
610 holds the value, then it is the answer. */
613 dynamic_cast_check_1 (struct type
*desired_type
,
614 const bfd_byte
*contents
,
616 struct type
*search_type
,
618 struct type
*arg_type
,
619 struct value
**result
)
621 int i
, result_count
= 0;
623 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
625 int offset
= baseclass_offset (search_type
, i
, contents
, address
);
627 error (_("virtual baseclass botch"));
628 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
630 if (address
+ offset
>= arg_addr
631 && address
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
635 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
640 result_count
+= dynamic_cast_check_1 (desired_type
,
643 TYPE_BASECLASS (search_type
, i
),
652 /* A helper for value_dynamic_cast. This implements the second of two
653 runtime checks: we look for a unique public sibling class of the
654 argument's declared class. */
657 dynamic_cast_check_2 (struct type
*desired_type
,
658 const bfd_byte
*contents
,
660 struct type
*search_type
,
661 struct value
**result
)
663 int i
, result_count
= 0;
665 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
669 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
672 offset
= baseclass_offset (search_type
, i
, contents
, address
);
674 error (_("virtual baseclass botch"));
675 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
679 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
683 result_count
+= dynamic_cast_check_2 (desired_type
,
686 TYPE_BASECLASS (search_type
, i
),
693 /* The C++ dynamic_cast operator. */
696 value_dynamic_cast (struct type
*type
, struct value
*arg
)
698 int unambiguous
= 0, full
, top
, using_enc
;
699 struct type
*resolved_type
= check_typedef (type
);
700 struct type
*arg_type
= check_typedef (value_type (arg
));
701 struct type
*class_type
, *rtti_type
;
702 struct value
*result
, *tem
, *original_arg
= arg
;
704 int is_ref
= TYPE_CODE (resolved_type
) == TYPE_CODE_REF
;
706 if (TYPE_CODE (resolved_type
) != TYPE_CODE_PTR
707 && TYPE_CODE (resolved_type
) != TYPE_CODE_REF
)
708 error (_("Argument to dynamic_cast must be a pointer or reference type"));
709 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_VOID
710 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_CLASS
)
711 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
713 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
714 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
716 if (TYPE_CODE (arg_type
) != TYPE_CODE_PTR
717 && ! (TYPE_CODE (arg_type
) == TYPE_CODE_INT
718 && value_as_long (arg
) == 0))
719 error (_("Argument to dynamic_cast does not have pointer type"));
720 if (TYPE_CODE (arg_type
) == TYPE_CODE_PTR
)
722 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
723 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
724 error (_("Argument to dynamic_cast does not have pointer to class type"));
727 /* Handle NULL pointers. */
728 if (value_as_long (arg
) == 0)
729 return value_zero (type
, not_lval
);
731 arg
= value_ind (arg
);
735 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
736 error (_("Argument to dynamic_cast does not have class type"));
739 /* If the classes are the same, just return the argument. */
740 if (class_types_same_p (class_type
, arg_type
))
741 return value_cast (type
, arg
);
743 /* If the target type is a unique base class of the argument's
744 declared type, just cast it. */
745 if (is_ancestor (class_type
, arg_type
))
747 if (is_unique_ancestor (class_type
, arg
))
748 return value_cast (type
, original_arg
);
749 error (_("Ambiguous dynamic_cast"));
752 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
754 error (_("Couldn't determine value's most derived type for dynamic_cast"));
756 /* Compute the most derived object's address. */
757 addr
= value_address (arg
);
765 addr
+= top
+ value_embedded_offset (arg
);
767 /* dynamic_cast<void *> means to return a pointer to the
768 most-derived object. */
769 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
770 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) == TYPE_CODE_VOID
)
771 return value_at_lazy (type
, addr
);
773 tem
= value_at (type
, addr
);
775 /* The first dynamic check specified in 5.2.7. */
776 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
778 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
781 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
782 value_contents (tem
), value_address (tem
),
786 return value_cast (type
,
787 is_ref
? value_ref (result
) : value_addr (result
));
790 /* The second dynamic check specified in 5.2.7. */
792 if (is_public_ancestor (arg_type
, rtti_type
)
793 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
794 value_contents (tem
), value_address (tem
),
795 rtti_type
, &result
) == 1)
796 return value_cast (type
,
797 is_ref
? value_ref (result
) : value_addr (result
));
799 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
800 return value_zero (type
, not_lval
);
802 error (_("dynamic_cast failed"));
805 /* Create a value of type TYPE that is zero, and return it. */
808 value_zero (struct type
*type
, enum lval_type lv
)
810 struct value
*val
= allocate_value (type
);
811 VALUE_LVAL (val
) = lv
;
816 /* Create a value of numeric type TYPE that is one, and return it. */
819 value_one (struct type
*type
, enum lval_type lv
)
821 struct type
*type1
= check_typedef (type
);
824 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
826 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
828 decimal_from_string (v
, TYPE_LENGTH (type
), byte_order
, "1");
829 val
= value_from_decfloat (type
, v
);
831 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
833 val
= value_from_double (type
, (DOUBLEST
) 1);
835 else if (is_integral_type (type1
))
837 val
= value_from_longest (type
, (LONGEST
) 1);
841 error (_("Not a numeric type."));
844 VALUE_LVAL (val
) = lv
;
848 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
850 static struct value
*
851 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
855 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
856 error (_("Attempt to dereference a generic pointer."));
860 val
= allocate_value_lazy (type
);
864 val
= allocate_value (type
);
865 read_memory (addr
, value_contents_all_raw (val
), TYPE_LENGTH (type
));
868 VALUE_LVAL (val
) = lval_memory
;
869 set_value_address (val
, addr
);
874 /* Return a value with type TYPE located at ADDR.
876 Call value_at only if the data needs to be fetched immediately;
877 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
878 value_at_lazy instead. value_at_lazy simply records the address of
879 the data and sets the lazy-evaluation-required flag. The lazy flag
880 is tested in the value_contents macro, which is used if and when
881 the contents are actually required.
883 Note: value_at does *NOT* handle embedded offsets; perform such
884 adjustments before or after calling it. */
887 value_at (struct type
*type
, CORE_ADDR addr
)
889 return get_value_at (type
, addr
, 0);
892 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
895 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
897 return get_value_at (type
, addr
, 1);
900 /* Called only from the value_contents and value_contents_all()
901 macros, if the current data for a variable needs to be loaded into
902 value_contents(VAL). Fetches the data from the user's process, and
903 clears the lazy flag to indicate that the data in the buffer is
906 If the value is zero-length, we avoid calling read_memory, which
907 would abort. We mark the value as fetched anyway -- all 0 bytes of
910 This function returns a value because it is used in the
911 value_contents macro as part of an expression, where a void would
912 not work. The value is ignored. */
915 value_fetch_lazy (struct value
*val
)
917 gdb_assert (value_lazy (val
));
918 allocate_value_contents (val
);
919 if (value_bitsize (val
))
921 /* To read a lazy bitfield, read the entire enclosing value. This
922 prevents reading the same block of (possibly volatile) memory once
923 per bitfield. It would be even better to read only the containing
924 word, but we have no way to record that just specific bits of a
925 value have been fetched. */
926 struct type
*type
= check_typedef (value_type (val
));
927 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
928 struct value
*parent
= value_parent (val
);
929 LONGEST offset
= value_offset (val
);
930 LONGEST num
= unpack_bits_as_long (value_type (val
),
931 value_contents (parent
) + offset
,
933 value_bitsize (val
));
934 int length
= TYPE_LENGTH (type
);
935 store_signed_integer (value_contents_raw (val
), length
, byte_order
, num
);
937 else if (VALUE_LVAL (val
) == lval_memory
)
939 CORE_ADDR addr
= value_address (val
);
940 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
944 if (value_stack (val
))
945 read_stack (addr
, value_contents_all_raw (val
), length
);
947 read_memory (addr
, value_contents_all_raw (val
), length
);
950 else if (VALUE_LVAL (val
) == lval_register
)
952 struct frame_info
*frame
;
954 struct type
*type
= check_typedef (value_type (val
));
955 struct value
*new_val
= val
, *mark
= value_mark ();
957 /* Offsets are not supported here; lazy register values must
958 refer to the entire register. */
959 gdb_assert (value_offset (val
) == 0);
961 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
963 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
964 regnum
= VALUE_REGNUM (new_val
);
966 gdb_assert (frame
!= NULL
);
968 /* Convertible register routines are used for multi-register
969 values and for interpretation in different types
970 (e.g. float or int from a double register). Lazy
971 register values should have the register's natural type,
972 so they do not apply. */
973 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
976 new_val
= get_frame_register_value (frame
, regnum
);
979 /* If it's still lazy (for instance, a saved register on the
981 if (value_lazy (new_val
))
982 value_fetch_lazy (new_val
);
984 /* If the register was not saved, mark it unavailable. */
985 if (value_optimized_out (new_val
))
986 set_value_optimized_out (val
, 1);
988 memcpy (value_contents_raw (val
), value_contents (new_val
),
993 struct gdbarch
*gdbarch
;
994 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
995 regnum
= VALUE_REGNUM (val
);
996 gdbarch
= get_frame_arch (frame
);
998 fprintf_unfiltered (gdb_stdlog
, "\
999 { value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
1000 frame_relative_level (frame
), regnum
,
1001 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1003 fprintf_unfiltered (gdb_stdlog
, "->");
1004 if (value_optimized_out (new_val
))
1005 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1009 const gdb_byte
*buf
= value_contents (new_val
);
1011 if (VALUE_LVAL (new_val
) == lval_register
)
1012 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1013 VALUE_REGNUM (new_val
));
1014 else if (VALUE_LVAL (new_val
) == lval_memory
)
1015 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1017 value_address (new_val
)));
1019 fprintf_unfiltered (gdb_stdlog
, " computed");
1021 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1022 fprintf_unfiltered (gdb_stdlog
, "[");
1023 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1024 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1025 fprintf_unfiltered (gdb_stdlog
, "]");
1028 fprintf_unfiltered (gdb_stdlog
, " }\n");
1031 /* Dispose of the intermediate values. This prevents
1032 watchpoints from trying to watch the saved frame pointer. */
1033 value_free_to_mark (mark
);
1035 else if (VALUE_LVAL (val
) == lval_computed
)
1036 value_computed_funcs (val
)->read (val
);
1038 internal_error (__FILE__
, __LINE__
, "Unexpected lazy value type.");
1040 set_value_lazy (val
, 0);
1045 /* Store the contents of FROMVAL into the location of TOVAL.
1046 Return a new value with the location of TOVAL and contents of FROMVAL. */
1049 value_assign (struct value
*toval
, struct value
*fromval
)
1053 struct frame_id old_frame
;
1055 if (!deprecated_value_modifiable (toval
))
1056 error (_("Left operand of assignment is not a modifiable lvalue."));
1058 toval
= coerce_ref (toval
);
1060 type
= value_type (toval
);
1061 if (VALUE_LVAL (toval
) != lval_internalvar
)
1063 toval
= value_coerce_to_target (toval
);
1064 fromval
= value_cast (type
, fromval
);
1068 /* Coerce arrays and functions to pointers, except for arrays
1069 which only live in GDB's storage. */
1070 if (!value_must_coerce_to_target (fromval
))
1071 fromval
= coerce_array (fromval
);
1074 CHECK_TYPEDEF (type
);
1076 /* Since modifying a register can trash the frame chain, and
1077 modifying memory can trash the frame cache, we save the old frame
1078 and then restore the new frame afterwards. */
1079 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1081 switch (VALUE_LVAL (toval
))
1083 case lval_internalvar
:
1084 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1085 val
= value_copy (fromval
);
1086 val
= value_change_enclosing_type (val
,
1087 value_enclosing_type (fromval
));
1088 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1089 set_value_pointed_to_offset (val
,
1090 value_pointed_to_offset (fromval
));
1093 case lval_internalvar_component
:
1094 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1095 value_offset (toval
),
1096 value_bitpos (toval
),
1097 value_bitsize (toval
),
1103 const gdb_byte
*dest_buffer
;
1104 CORE_ADDR changed_addr
;
1106 gdb_byte buffer
[sizeof (LONGEST
)];
1108 if (value_bitsize (toval
))
1110 struct value
*parent
= value_parent (toval
);
1111 changed_addr
= value_address (parent
) + value_offset (toval
);
1113 changed_len
= (value_bitpos (toval
)
1114 + value_bitsize (toval
)
1115 + HOST_CHAR_BIT
- 1)
1118 /* If we can read-modify-write exactly the size of the
1119 containing type (e.g. short or int) then do so. This
1120 is safer for volatile bitfields mapped to hardware
1122 if (changed_len
< TYPE_LENGTH (type
)
1123 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1124 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1125 changed_len
= TYPE_LENGTH (type
);
1127 if (changed_len
> (int) sizeof (LONGEST
))
1128 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1129 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1131 read_memory (changed_addr
, buffer
, changed_len
);
1132 modify_field (type
, buffer
, value_as_long (fromval
),
1133 value_bitpos (toval
), value_bitsize (toval
));
1134 dest_buffer
= buffer
;
1138 changed_addr
= value_address (toval
);
1139 changed_len
= TYPE_LENGTH (type
);
1140 dest_buffer
= value_contents (fromval
);
1143 write_memory (changed_addr
, dest_buffer
, changed_len
);
1144 observer_notify_memory_changed (changed_addr
, changed_len
,
1151 struct frame_info
*frame
;
1152 struct gdbarch
*gdbarch
;
1155 /* Figure out which frame this is in currently. */
1156 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1157 value_reg
= VALUE_REGNUM (toval
);
1160 error (_("Value being assigned to is no longer active."));
1162 gdbarch
= get_frame_arch (frame
);
1163 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
), type
))
1165 /* If TOVAL is a special machine register requiring
1166 conversion of program values to a special raw
1168 gdbarch_value_to_register (gdbarch
, frame
,
1169 VALUE_REGNUM (toval
), type
,
1170 value_contents (fromval
));
1174 if (value_bitsize (toval
))
1176 struct value
*parent
= value_parent (toval
);
1177 int offset
= value_offset (parent
) + value_offset (toval
);
1179 gdb_byte buffer
[sizeof (LONGEST
)];
1181 changed_len
= (value_bitpos (toval
)
1182 + value_bitsize (toval
)
1183 + HOST_CHAR_BIT
- 1)
1186 if (changed_len
> (int) sizeof (LONGEST
))
1187 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1188 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1190 get_frame_register_bytes (frame
, value_reg
, offset
,
1191 changed_len
, buffer
);
1193 modify_field (type
, buffer
, value_as_long (fromval
),
1194 value_bitpos (toval
), value_bitsize (toval
));
1196 put_frame_register_bytes (frame
, value_reg
, offset
,
1197 changed_len
, buffer
);
1201 put_frame_register_bytes (frame
, value_reg
,
1202 value_offset (toval
),
1204 value_contents (fromval
));
1208 if (deprecated_register_changed_hook
)
1209 deprecated_register_changed_hook (-1);
1210 observer_notify_target_changed (¤t_target
);
1216 struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1218 funcs
->write (toval
, fromval
);
1223 error (_("Left operand of assignment is not an lvalue."));
1226 /* Assigning to the stack pointer, frame pointer, and other
1227 (architecture and calling convention specific) registers may
1228 cause the frame cache to be out of date. Assigning to memory
1229 also can. We just do this on all assignments to registers or
1230 memory, for simplicity's sake; I doubt the slowdown matters. */
1231 switch (VALUE_LVAL (toval
))
1236 reinit_frame_cache ();
1238 /* Having destroyed the frame cache, restore the selected
1241 /* FIXME: cagney/2002-11-02: There has to be a better way of
1242 doing this. Instead of constantly saving/restoring the
1243 frame. Why not create a get_selected_frame() function that,
1244 having saved the selected frame's ID can automatically
1245 re-find the previously selected frame automatically. */
1248 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1258 /* If the field does not entirely fill a LONGEST, then zero the sign
1259 bits. If the field is signed, and is negative, then sign
1261 if ((value_bitsize (toval
) > 0)
1262 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1264 LONGEST fieldval
= value_as_long (fromval
);
1265 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1267 fieldval
&= valmask
;
1268 if (!TYPE_UNSIGNED (type
)
1269 && (fieldval
& (valmask
^ (valmask
>> 1))))
1270 fieldval
|= ~valmask
;
1272 fromval
= value_from_longest (type
, fieldval
);
1275 val
= value_copy (toval
);
1276 memcpy (value_contents_raw (val
), value_contents (fromval
),
1277 TYPE_LENGTH (type
));
1278 deprecated_set_value_type (val
, type
);
1279 val
= value_change_enclosing_type (val
,
1280 value_enclosing_type (fromval
));
1281 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1282 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1287 /* Extend a value VAL to COUNT repetitions of its type. */
1290 value_repeat (struct value
*arg1
, int count
)
1294 if (VALUE_LVAL (arg1
) != lval_memory
)
1295 error (_("Only values in memory can be extended with '@'."));
1297 error (_("Invalid number %d of repetitions."), count
);
1299 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1301 read_memory (value_address (arg1
),
1302 value_contents_all_raw (val
),
1303 TYPE_LENGTH (value_enclosing_type (val
)));
1304 VALUE_LVAL (val
) = lval_memory
;
1305 set_value_address (val
, value_address (arg1
));
1311 value_of_variable (struct symbol
*var
, struct block
*b
)
1314 struct frame_info
*frame
;
1316 if (!symbol_read_needs_frame (var
))
1319 frame
= get_selected_frame (_("No frame selected."));
1322 frame
= block_innermost_frame (b
);
1325 if (BLOCK_FUNCTION (b
) && !block_inlined_p (b
)
1326 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
1327 error (_("No frame is currently executing in block %s."),
1328 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
1330 error (_("No frame is currently executing in specified block"));
1334 val
= read_var_value (var
, frame
);
1336 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
1342 address_of_variable (struct symbol
*var
, struct block
*b
)
1344 struct type
*type
= SYMBOL_TYPE (var
);
1347 /* Evaluate it first; if the result is a memory address, we're fine.
1348 Lazy evaluation pays off here. */
1350 val
= value_of_variable (var
, b
);
1352 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1353 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1355 CORE_ADDR addr
= value_address (val
);
1356 return value_from_pointer (lookup_pointer_type (type
), addr
);
1359 /* Not a memory address; check what the problem was. */
1360 switch (VALUE_LVAL (val
))
1364 struct frame_info
*frame
;
1365 const char *regname
;
1367 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1370 regname
= gdbarch_register_name (get_frame_arch (frame
),
1371 VALUE_REGNUM (val
));
1372 gdb_assert (regname
&& *regname
);
1374 error (_("Address requested for identifier "
1375 "\"%s\" which is in register $%s"),
1376 SYMBOL_PRINT_NAME (var
), regname
);
1381 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1382 SYMBOL_PRINT_NAME (var
));
1389 /* Return one if VAL does not live in target memory, but should in order
1390 to operate on it. Otherwise return zero. */
1393 value_must_coerce_to_target (struct value
*val
)
1395 struct type
*valtype
;
1397 /* The only lval kinds which do not live in target memory. */
1398 if (VALUE_LVAL (val
) != not_lval
1399 && VALUE_LVAL (val
) != lval_internalvar
)
1402 valtype
= check_typedef (value_type (val
));
1404 switch (TYPE_CODE (valtype
))
1406 case TYPE_CODE_ARRAY
:
1407 case TYPE_CODE_STRING
:
1414 /* Make sure that VAL lives in target memory if it's supposed to. For instance,
1415 strings are constructed as character arrays in GDB's storage, and this
1416 function copies them to the target. */
1419 value_coerce_to_target (struct value
*val
)
1424 if (!value_must_coerce_to_target (val
))
1427 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1428 addr
= allocate_space_in_inferior (length
);
1429 write_memory (addr
, value_contents (val
), length
);
1430 return value_at_lazy (value_type (val
), addr
);
1433 /* Given a value which is an array, return a value which is a pointer
1434 to its first element, regardless of whether or not the array has a
1435 nonzero lower bound.
1437 FIXME: A previous comment here indicated that this routine should
1438 be substracting the array's lower bound. It's not clear to me that
1439 this is correct. Given an array subscripting operation, it would
1440 certainly work to do the adjustment here, essentially computing:
1442 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1444 However I believe a more appropriate and logical place to account
1445 for the lower bound is to do so in value_subscript, essentially
1448 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1450 As further evidence consider what would happen with operations
1451 other than array subscripting, where the caller would get back a
1452 value that had an address somewhere before the actual first element
1453 of the array, and the information about the lower bound would be
1454 lost because of the coercion to pointer type.
1458 value_coerce_array (struct value
*arg1
)
1460 struct type
*type
= check_typedef (value_type (arg1
));
1462 /* If the user tries to do something requiring a pointer with an
1463 array that has not yet been pushed to the target, then this would
1464 be a good time to do so. */
1465 arg1
= value_coerce_to_target (arg1
);
1467 if (VALUE_LVAL (arg1
) != lval_memory
)
1468 error (_("Attempt to take address of value not located in memory."));
1470 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1471 value_address (arg1
));
1474 /* Given a value which is a function, return a value which is a pointer
1478 value_coerce_function (struct value
*arg1
)
1480 struct value
*retval
;
1482 if (VALUE_LVAL (arg1
) != lval_memory
)
1483 error (_("Attempt to take address of value not located in memory."));
1485 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1486 value_address (arg1
));
1490 /* Return a pointer value for the object for which ARG1 is the
1494 value_addr (struct value
*arg1
)
1498 struct type
*type
= check_typedef (value_type (arg1
));
1499 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1501 /* Copy the value, but change the type from (T&) to (T*). We
1502 keep the same location information, which is efficient, and
1503 allows &(&X) to get the location containing the reference. */
1504 arg2
= value_copy (arg1
);
1505 deprecated_set_value_type (arg2
,
1506 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1509 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1510 return value_coerce_function (arg1
);
1512 /* If this is an array that has not yet been pushed to the target,
1513 then this would be a good time to force it to memory. */
1514 arg1
= value_coerce_to_target (arg1
);
1516 if (VALUE_LVAL (arg1
) != lval_memory
)
1517 error (_("Attempt to take address of value not located in memory."));
1519 /* Get target memory address */
1520 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1521 (value_address (arg1
)
1522 + value_embedded_offset (arg1
)));
1524 /* This may be a pointer to a base subobject; so remember the
1525 full derived object's type ... */
1526 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (value_enclosing_type (arg1
)));
1527 /* ... and also the relative position of the subobject in the full
1529 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1533 /* Return a reference value for the object for which ARG1 is the
1537 value_ref (struct value
*arg1
)
1541 struct type
*type
= check_typedef (value_type (arg1
));
1542 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1545 arg2
= value_addr (arg1
);
1546 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1550 /* Given a value of a pointer type, apply the C unary * operator to
1554 value_ind (struct value
*arg1
)
1556 struct type
*base_type
;
1559 arg1
= coerce_array (arg1
);
1561 base_type
= check_typedef (value_type (arg1
));
1563 if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1565 struct type
*enc_type
;
1566 /* We may be pointing to something embedded in a larger object.
1567 Get the real type of the enclosing object. */
1568 enc_type
= check_typedef (value_enclosing_type (arg1
));
1569 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1571 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1572 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1573 /* For functions, go through find_function_addr, which knows
1574 how to handle function descriptors. */
1575 arg2
= value_at_lazy (enc_type
,
1576 find_function_addr (arg1
, NULL
));
1578 /* Retrieve the enclosing object pointed to */
1579 arg2
= value_at_lazy (enc_type
,
1580 (value_as_address (arg1
)
1581 - value_pointed_to_offset (arg1
)));
1583 /* Re-adjust type. */
1584 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1585 /* Add embedding info. */
1586 arg2
= value_change_enclosing_type (arg2
, enc_type
);
1587 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1589 /* We may be pointing to an object of some derived type. */
1590 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1594 error (_("Attempt to take contents of a non-pointer value."));
1595 return 0; /* For lint -- never reached. */
1598 /* Create a value for an array by allocating space in GDB, copying
1599 copying the data into that space, and then setting up an array
1602 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1603 is populated from the values passed in ELEMVEC.
1605 The element type of the array is inherited from the type of the
1606 first element, and all elements must have the same size (though we
1607 don't currently enforce any restriction on their types). */
1610 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1614 unsigned int typelength
;
1616 struct type
*arraytype
;
1619 /* Validate that the bounds are reasonable and that each of the
1620 elements have the same size. */
1622 nelem
= highbound
- lowbound
+ 1;
1625 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1627 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1628 for (idx
= 1; idx
< nelem
; idx
++)
1630 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1632 error (_("array elements must all be the same size"));
1636 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1637 lowbound
, highbound
);
1639 if (!current_language
->c_style_arrays
)
1641 val
= allocate_value (arraytype
);
1642 for (idx
= 0; idx
< nelem
; idx
++)
1644 memcpy (value_contents_all_raw (val
) + (idx
* typelength
),
1645 value_contents_all (elemvec
[idx
]),
1651 /* Allocate space to store the array, and then initialize it by
1652 copying in each element. */
1654 val
= allocate_value (arraytype
);
1655 for (idx
= 0; idx
< nelem
; idx
++)
1656 memcpy (value_contents_writeable (val
) + (idx
* typelength
),
1657 value_contents_all (elemvec
[idx
]),
1663 value_cstring (char *ptr
, int len
, struct type
*char_type
)
1666 int lowbound
= current_language
->string_lower_bound
;
1667 int highbound
= len
/ TYPE_LENGTH (char_type
);
1668 struct type
*stringtype
1669 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1671 val
= allocate_value (stringtype
);
1672 memcpy (value_contents_raw (val
), ptr
, len
);
1676 /* Create a value for a string constant by allocating space in the
1677 inferior, copying the data into that space, and returning the
1678 address with type TYPE_CODE_STRING. PTR points to the string
1679 constant data; LEN is number of characters.
1681 Note that string types are like array of char types with a lower
1682 bound of zero and an upper bound of LEN - 1. Also note that the
1683 string may contain embedded null bytes. */
1686 value_string (char *ptr
, int len
, struct type
*char_type
)
1689 int lowbound
= current_language
->string_lower_bound
;
1690 int highbound
= len
/ TYPE_LENGTH (char_type
);
1691 struct type
*stringtype
1692 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1694 val
= allocate_value (stringtype
);
1695 memcpy (value_contents_raw (val
), ptr
, len
);
1700 value_bitstring (char *ptr
, int len
, struct type
*index_type
)
1703 struct type
*domain_type
1704 = create_range_type (NULL
, index_type
, 0, len
- 1);
1705 struct type
*type
= create_set_type (NULL
, domain_type
);
1706 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1707 val
= allocate_value (type
);
1708 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1712 /* See if we can pass arguments in T2 to a function which takes
1713 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1714 a NULL-terminated vector. If some arguments need coercion of some
1715 sort, then the coerced values are written into T2. Return value is
1716 0 if the arguments could be matched, or the position at which they
1719 STATICP is nonzero if the T1 argument list came from a static
1720 member function. T2 will still include the ``this'' pointer, but
1723 For non-static member functions, we ignore the first argument,
1724 which is the type of the instance variable. This is because we
1725 want to handle calls with objects from derived classes. This is
1726 not entirely correct: we should actually check to make sure that a
1727 requested operation is type secure, shouldn't we? FIXME. */
1730 typecmp (int staticp
, int varargs
, int nargs
,
1731 struct field t1
[], struct value
*t2
[])
1736 internal_error (__FILE__
, __LINE__
,
1737 _("typecmp: no argument list"));
1739 /* Skip ``this'' argument if applicable. T2 will always include
1745 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1748 struct type
*tt1
, *tt2
;
1753 tt1
= check_typedef (t1
[i
].type
);
1754 tt2
= check_typedef (value_type (t2
[i
]));
1756 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1757 /* We should be doing hairy argument matching, as below. */
1758 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1760 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1761 t2
[i
] = value_coerce_array (t2
[i
]);
1763 t2
[i
] = value_ref (t2
[i
]);
1767 /* djb - 20000715 - Until the new type structure is in the
1768 place, and we can attempt things like implicit conversions,
1769 we need to do this so you can take something like a map<const
1770 char *>, and properly access map["hello"], because the
1771 argument to [] will be a reference to a pointer to a char,
1772 and the argument will be a pointer to a char. */
1773 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1774 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1776 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1778 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1779 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1780 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1782 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1784 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1786 /* Array to pointer is a `trivial conversion' according to the
1789 /* We should be doing much hairier argument matching (see
1790 section 13.2 of the ARM), but as a quick kludge, just check
1791 for the same type code. */
1792 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1795 if (varargs
|| t2
[i
] == NULL
)
1800 /* Helper function used by value_struct_elt to recurse through
1801 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1802 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1803 TYPE. If found, return value, else return NULL.
1805 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1806 fields, look for a baseclass named NAME. */
1808 static struct value
*
1809 search_struct_field (char *name
, struct value
*arg1
, int offset
,
1810 struct type
*type
, int looking_for_baseclass
)
1815 CHECK_TYPEDEF (type
);
1816 nbases
= TYPE_N_BASECLASSES (type
);
1818 if (!looking_for_baseclass
)
1819 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1821 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1823 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1826 if (field_is_static (&TYPE_FIELD (type
, i
)))
1828 v
= value_static_field (type
, i
);
1830 error (_("field %s is nonexistent or has been optimised out"),
1835 v
= value_primitive_field (arg1
, offset
, i
, type
);
1837 error (_("there is no field named %s"), name
);
1843 && (t_field_name
[0] == '\0'
1844 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1845 && (strcmp_iw (t_field_name
, "else") == 0))))
1847 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1848 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1849 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1851 /* Look for a match through the fields of an anonymous
1852 union, or anonymous struct. C++ provides anonymous
1855 In the GNU Chill (now deleted from GDB)
1856 implementation of variant record types, each
1857 <alternative field> has an (anonymous) union type,
1858 each member of the union represents a <variant
1859 alternative>. Each <variant alternative> is
1860 represented as a struct, with a member for each
1864 int new_offset
= offset
;
1866 /* This is pretty gross. In G++, the offset in an
1867 anonymous union is relative to the beginning of the
1868 enclosing struct. In the GNU Chill (now deleted
1869 from GDB) implementation of variant records, the
1870 bitpos is zero in an anonymous union field, so we
1871 have to add the offset of the union here. */
1872 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1873 || (TYPE_NFIELDS (field_type
) > 0
1874 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1875 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1877 v
= search_struct_field (name
, arg1
, new_offset
,
1879 looking_for_baseclass
);
1886 for (i
= 0; i
< nbases
; i
++)
1889 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1890 /* If we are looking for baseclasses, this is what we get when
1891 we hit them. But it could happen that the base part's member
1892 name is not yet filled in. */
1893 int found_baseclass
= (looking_for_baseclass
1894 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1895 && (strcmp_iw (name
,
1896 TYPE_BASECLASS_NAME (type
,
1899 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1904 boffset
= baseclass_offset (type
, i
,
1905 value_contents (arg1
) + offset
,
1906 value_address (arg1
) + offset
);
1908 error (_("virtual baseclass botch"));
1910 /* The virtual base class pointer might have been clobbered
1911 by the user program. Make sure that it still points to a
1912 valid memory location. */
1915 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
1917 CORE_ADDR base_addr
;
1919 v2
= allocate_value (basetype
);
1920 base_addr
= value_address (arg1
) + boffset
;
1921 if (target_read_memory (base_addr
,
1922 value_contents_raw (v2
),
1923 TYPE_LENGTH (basetype
)) != 0)
1924 error (_("virtual baseclass botch"));
1925 VALUE_LVAL (v2
) = lval_memory
;
1926 set_value_address (v2
, base_addr
);
1930 if (VALUE_LVAL (arg1
) == lval_memory
&& value_lazy (arg1
))
1931 v2
= allocate_value_lazy (basetype
);
1934 v2
= allocate_value (basetype
);
1935 memcpy (value_contents_raw (v2
),
1936 value_contents_raw (arg1
) + boffset
,
1937 TYPE_LENGTH (basetype
));
1939 set_value_component_location (v2
, arg1
);
1940 VALUE_FRAME_ID (v2
) = VALUE_FRAME_ID (arg1
);
1941 set_value_offset (v2
, value_offset (arg1
) + boffset
);
1944 if (found_baseclass
)
1946 v
= search_struct_field (name
, v2
, 0,
1947 TYPE_BASECLASS (type
, i
),
1948 looking_for_baseclass
);
1950 else if (found_baseclass
)
1951 v
= value_primitive_field (arg1
, offset
, i
, type
);
1953 v
= search_struct_field (name
, arg1
,
1954 offset
+ TYPE_BASECLASS_BITPOS (type
,
1956 basetype
, looking_for_baseclass
);
1963 /* Helper function used by value_struct_elt to recurse through
1964 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1965 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1968 If found, return value, else if name matched and args not return
1969 (value) -1, else return NULL. */
1971 static struct value
*
1972 search_struct_method (char *name
, struct value
**arg1p
,
1973 struct value
**args
, int offset
,
1974 int *static_memfuncp
, struct type
*type
)
1978 int name_matched
= 0;
1979 char dem_opname
[64];
1981 CHECK_TYPEDEF (type
);
1982 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1984 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1985 /* FIXME! May need to check for ARM demangling here */
1986 if (strncmp (t_field_name
, "__", 2) == 0 ||
1987 strncmp (t_field_name
, "op", 2) == 0 ||
1988 strncmp (t_field_name
, "type", 4) == 0)
1990 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1991 t_field_name
= dem_opname
;
1992 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1993 t_field_name
= dem_opname
;
1995 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1997 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1998 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2001 check_stub_method_group (type
, i
);
2002 if (j
> 0 && args
== 0)
2003 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name
);
2004 else if (j
== 0 && args
== 0)
2006 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2013 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2014 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
2015 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
2016 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2018 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2019 return value_virtual_fn_field (arg1p
, f
, j
,
2021 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2023 *static_memfuncp
= 1;
2024 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2033 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2037 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2039 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2040 const gdb_byte
*base_valaddr
;
2042 /* The virtual base class pointer might have been
2043 clobbered by the user program. Make sure that it
2044 still points to a valid memory location. */
2046 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2048 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
2049 if (target_read_memory (value_address (*arg1p
) + offset
,
2050 tmp
, TYPE_LENGTH (baseclass
)) != 0)
2051 error (_("virtual baseclass botch"));
2055 base_valaddr
= value_contents (*arg1p
) + offset
;
2057 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2058 value_address (*arg1p
) + offset
);
2059 if (base_offset
== -1)
2060 error (_("virtual baseclass botch"));
2064 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2066 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2067 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2068 if (v
== (struct value
*) - 1)
2074 /* FIXME-bothner: Why is this commented out? Why is it here? */
2075 /* *arg1p = arg1_tmp; */
2080 return (struct value
*) - 1;
2085 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2086 extract the component named NAME from the ultimate target
2087 structure/union and return it as a value with its appropriate type.
2088 ERR is used in the error message if *ARGP's type is wrong.
2090 C++: ARGS is a list of argument types to aid in the selection of
2091 an appropriate method. Also, handle derived types.
2093 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2094 where the truthvalue of whether the function that was resolved was
2095 a static member function or not is stored.
2097 ERR is an error message to be printed in case the field is not
2101 value_struct_elt (struct value
**argp
, struct value
**args
,
2102 char *name
, int *static_memfuncp
, char *err
)
2107 *argp
= coerce_array (*argp
);
2109 t
= check_typedef (value_type (*argp
));
2111 /* Follow pointers until we get to a non-pointer. */
2113 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2115 *argp
= value_ind (*argp
);
2116 /* Don't coerce fn pointer to fn and then back again! */
2117 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2118 *argp
= coerce_array (*argp
);
2119 t
= check_typedef (value_type (*argp
));
2122 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2123 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2124 error (_("Attempt to extract a component of a value that is not a %s."), err
);
2126 /* Assume it's not, unless we see that it is. */
2127 if (static_memfuncp
)
2128 *static_memfuncp
= 0;
2132 /* if there are no arguments ...do this... */
2134 /* Try as a field first, because if we succeed, there is less
2136 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2140 /* C++: If it was not found as a data field, then try to
2141 return it as a pointer to a method. */
2142 v
= search_struct_method (name
, argp
, args
, 0,
2143 static_memfuncp
, t
);
2145 if (v
== (struct value
*) - 1)
2146 error (_("Cannot take address of method %s."), name
);
2149 if (TYPE_NFN_FIELDS (t
))
2150 error (_("There is no member or method named %s."), name
);
2152 error (_("There is no member named %s."), name
);
2157 v
= search_struct_method (name
, argp
, args
, 0,
2158 static_memfuncp
, t
);
2160 if (v
== (struct value
*) - 1)
2162 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name
);
2166 /* See if user tried to invoke data as function. If so, hand it
2167 back. If it's not callable (i.e., a pointer to function),
2168 gdb should give an error. */
2169 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2170 /* If we found an ordinary field, then it is not a method call.
2171 So, treat it as if it were a static member function. */
2172 if (v
&& static_memfuncp
)
2173 *static_memfuncp
= 1;
2177 error (_("Structure has no component named %s."), name
);
2181 /* Search through the methods of an object (and its bases) to find a
2182 specified method. Return the pointer to the fn_field list of
2183 overloaded instances.
2185 Helper function for value_find_oload_list.
2186 ARGP is a pointer to a pointer to a value (the object).
2187 METHOD is a string containing the method name.
2188 OFFSET is the offset within the value.
2189 TYPE is the assumed type of the object.
2190 NUM_FNS is the number of overloaded instances.
2191 BASETYPE is set to the actual type of the subobject where the
2193 BOFFSET is the offset of the base subobject where the method is found.
2196 static struct fn_field
*
2197 find_method_list (struct value
**argp
, char *method
,
2198 int offset
, struct type
*type
, int *num_fns
,
2199 struct type
**basetype
, int *boffset
)
2203 CHECK_TYPEDEF (type
);
2207 /* First check in object itself. */
2208 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2210 /* pai: FIXME What about operators and type conversions? */
2211 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2212 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2214 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2215 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2221 /* Resolve any stub methods. */
2222 check_stub_method_group (type
, i
);
2228 /* Not found in object, check in base subobjects. */
2229 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2232 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2234 base_offset
= value_offset (*argp
) + offset
;
2235 base_offset
= baseclass_offset (type
, i
,
2236 value_contents (*argp
) + base_offset
,
2237 value_address (*argp
) + base_offset
);
2238 if (base_offset
== -1)
2239 error (_("virtual baseclass botch"));
2241 else /* Non-virtual base, simply use bit position from debug
2244 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2246 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2247 TYPE_BASECLASS (type
, i
), num_fns
,
2255 /* Return the list of overloaded methods of a specified name.
2257 ARGP is a pointer to a pointer to a value (the object).
2258 METHOD is the method name.
2259 OFFSET is the offset within the value contents.
2260 NUM_FNS is the number of overloaded instances.
2261 BASETYPE is set to the type of the base subobject that defines the
2263 BOFFSET is the offset of the base subobject which defines the method.
2267 value_find_oload_method_list (struct value
**argp
, char *method
,
2268 int offset
, int *num_fns
,
2269 struct type
**basetype
, int *boffset
)
2273 t
= check_typedef (value_type (*argp
));
2275 /* Code snarfed from value_struct_elt. */
2276 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2278 *argp
= value_ind (*argp
);
2279 /* Don't coerce fn pointer to fn and then back again! */
2280 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2281 *argp
= coerce_array (*argp
);
2282 t
= check_typedef (value_type (*argp
));
2285 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2286 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2287 error (_("Attempt to extract a component of a value that is not a struct or union"));
2289 return find_method_list (argp
, method
, 0, t
, num_fns
,
2293 /* Given an array of argument types (ARGTYPES) (which includes an
2294 entry for "this" in the case of C++ methods), the number of
2295 arguments NARGS, the NAME of a function whether it's a method or
2296 not (METHOD), and the degree of laxness (LAX) in conforming to
2297 overload resolution rules in ANSI C++, find the best function that
2298 matches on the argument types according to the overload resolution
2301 In the case of class methods, the parameter OBJ is an object value
2302 in which to search for overloaded methods.
2304 In the case of non-method functions, the parameter FSYM is a symbol
2305 corresponding to one of the overloaded functions.
2307 Return value is an integer: 0 -> good match, 10 -> debugger applied
2308 non-standard coercions, 100 -> incompatible.
2310 If a method is being searched for, VALP will hold the value.
2311 If a non-method is being searched for, SYMP will hold the symbol
2314 If a method is being searched for, and it is a static method,
2315 then STATICP will point to a non-zero value.
2317 Note: This function does *not* check the value of
2318 overload_resolution. Caller must check it to see whether overload
2319 resolution is permitted.
2323 find_overload_match (struct type
**arg_types
, int nargs
,
2324 char *name
, int method
, int lax
,
2325 struct value
**objp
, struct symbol
*fsym
,
2326 struct value
**valp
, struct symbol
**symp
,
2329 struct value
*obj
= (objp
? *objp
: NULL
);
2330 /* Index of best overloaded function. */
2332 /* The measure for the current best match. */
2333 struct badness_vector
*oload_champ_bv
= NULL
;
2334 struct value
*temp
= obj
;
2335 /* For methods, the list of overloaded methods. */
2336 struct fn_field
*fns_ptr
= NULL
;
2337 /* For non-methods, the list of overloaded function symbols. */
2338 struct symbol
**oload_syms
= NULL
;
2339 /* Number of overloaded instances being considered. */
2341 struct type
*basetype
= NULL
;
2345 struct cleanup
*old_cleanups
= NULL
;
2347 const char *obj_type_name
= NULL
;
2348 char *func_name
= NULL
;
2349 enum oload_classification match_quality
;
2351 /* Get the list of overloaded methods or functions. */
2355 obj_type_name
= TYPE_NAME (value_type (obj
));
2356 /* Hack: evaluate_subexp_standard often passes in a pointer
2357 value rather than the object itself, so try again. */
2358 if ((!obj_type_name
|| !*obj_type_name
)
2359 && (TYPE_CODE (value_type (obj
)) == TYPE_CODE_PTR
))
2360 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj
)));
2362 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2364 &basetype
, &boffset
);
2365 if (!fns_ptr
|| !num_fns
)
2366 error (_("Couldn't find method %s%s%s"),
2368 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2370 /* If we are dealing with stub method types, they should have
2371 been resolved by find_method_list via
2372 value_find_oload_method_list above. */
2373 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2374 oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
2376 oload_syms
, &oload_champ_bv
);
2380 const char *qualified_name
= SYMBOL_CPLUS_DEMANGLED_NAME (fsym
);
2382 /* If we have a C++ name, try to extract just the function
2385 func_name
= cp_func_name (qualified_name
);
2387 /* If there was no C++ name, this must be a C-style function.
2388 Just return the same symbol. Do the same if cp_func_name
2389 fails for some reason. */
2390 if (func_name
== NULL
)
2396 old_cleanups
= make_cleanup (xfree
, func_name
);
2397 make_cleanup (xfree
, oload_syms
);
2398 make_cleanup (xfree
, oload_champ_bv
);
2400 oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
2407 /* Check how bad the best match is. */
2410 classify_oload_match (oload_champ_bv
, nargs
,
2411 oload_method_static (method
, fns_ptr
,
2414 if (match_quality
== INCOMPATIBLE
)
2417 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2419 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2422 error (_("Cannot resolve function %s to any overloaded instance"),
2425 else if (match_quality
== NON_STANDARD
)
2428 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2430 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2433 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2439 if (staticp
!= NULL
)
2440 *staticp
= oload_method_static (method
, fns_ptr
, oload_champ
);
2441 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2442 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
,
2445 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
,
2450 *symp
= oload_syms
[oload_champ
];
2455 struct type
*temp_type
= check_typedef (value_type (temp
));
2456 struct type
*obj_type
= check_typedef (value_type (*objp
));
2457 if (TYPE_CODE (temp_type
) != TYPE_CODE_PTR
2458 && (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
2459 || TYPE_CODE (obj_type
) == TYPE_CODE_REF
))
2461 temp
= value_addr (temp
);
2465 if (old_cleanups
!= NULL
)
2466 do_cleanups (old_cleanups
);
2468 switch (match_quality
)
2474 default: /* STANDARD */
2479 /* Find the best overload match, searching for FUNC_NAME in namespaces
2480 contained in QUALIFIED_NAME until it either finds a good match or
2481 runs out of namespaces. It stores the overloaded functions in
2482 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2483 calling function is responsible for freeing *OLOAD_SYMS and
2487 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2488 const char *func_name
,
2489 const char *qualified_name
,
2490 struct symbol
***oload_syms
,
2491 struct badness_vector
**oload_champ_bv
)
2495 find_oload_champ_namespace_loop (arg_types
, nargs
,
2498 oload_syms
, oload_champ_bv
,
2504 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2505 how deep we've looked for namespaces, and the champ is stored in
2506 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2509 It is the caller's responsibility to free *OLOAD_SYMS and
2513 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2514 const char *func_name
,
2515 const char *qualified_name
,
2517 struct symbol
***oload_syms
,
2518 struct badness_vector
**oload_champ_bv
,
2521 int next_namespace_len
= namespace_len
;
2522 int searched_deeper
= 0;
2524 struct cleanup
*old_cleanups
;
2525 int new_oload_champ
;
2526 struct symbol
**new_oload_syms
;
2527 struct badness_vector
*new_oload_champ_bv
;
2528 char *new_namespace
;
2530 if (next_namespace_len
!= 0)
2532 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2533 next_namespace_len
+= 2;
2535 next_namespace_len
+=
2536 cp_find_first_component (qualified_name
+ next_namespace_len
);
2538 /* Initialize these to values that can safely be xfree'd. */
2540 *oload_champ_bv
= NULL
;
2542 /* First, see if we have a deeper namespace we can search in.
2543 If we get a good match there, use it. */
2545 if (qualified_name
[next_namespace_len
] == ':')
2547 searched_deeper
= 1;
2549 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2550 func_name
, qualified_name
,
2552 oload_syms
, oload_champ_bv
,
2559 /* If we reach here, either we're in the deepest namespace or we
2560 didn't find a good match in a deeper namespace. But, in the
2561 latter case, we still have a bad match in a deeper namespace;
2562 note that we might not find any match at all in the current
2563 namespace. (There's always a match in the deepest namespace,
2564 because this overload mechanism only gets called if there's a
2565 function symbol to start off with.) */
2567 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2568 old_cleanups
= make_cleanup (xfree
, *oload_champ_bv
);
2569 new_namespace
= alloca (namespace_len
+ 1);
2570 strncpy (new_namespace
, qualified_name
, namespace_len
);
2571 new_namespace
[namespace_len
] = '\0';
2572 new_oload_syms
= make_symbol_overload_list (func_name
,
2574 while (new_oload_syms
[num_fns
])
2577 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2578 NULL
, new_oload_syms
,
2579 &new_oload_champ_bv
);
2581 /* Case 1: We found a good match. Free earlier matches (if any),
2582 and return it. Case 2: We didn't find a good match, but we're
2583 not the deepest function. Then go with the bad match that the
2584 deeper function found. Case 3: We found a bad match, and we're
2585 the deepest function. Then return what we found, even though
2586 it's a bad match. */
2588 if (new_oload_champ
!= -1
2589 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2591 *oload_syms
= new_oload_syms
;
2592 *oload_champ
= new_oload_champ
;
2593 *oload_champ_bv
= new_oload_champ_bv
;
2594 do_cleanups (old_cleanups
);
2597 else if (searched_deeper
)
2599 xfree (new_oload_syms
);
2600 xfree (new_oload_champ_bv
);
2601 discard_cleanups (old_cleanups
);
2606 gdb_assert (new_oload_champ
!= -1);
2607 *oload_syms
= new_oload_syms
;
2608 *oload_champ
= new_oload_champ
;
2609 *oload_champ_bv
= new_oload_champ_bv
;
2610 discard_cleanups (old_cleanups
);
2615 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2616 the best match from among the overloaded methods or functions
2617 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2618 The number of methods/functions in the list is given by NUM_FNS.
2619 Return the index of the best match; store an indication of the
2620 quality of the match in OLOAD_CHAMP_BV.
2622 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2625 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2626 int num_fns
, struct fn_field
*fns_ptr
,
2627 struct symbol
**oload_syms
,
2628 struct badness_vector
**oload_champ_bv
)
2631 /* A measure of how good an overloaded instance is. */
2632 struct badness_vector
*bv
;
2633 /* Index of best overloaded function. */
2634 int oload_champ
= -1;
2635 /* Current ambiguity state for overload resolution. */
2636 int oload_ambiguous
= 0;
2637 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2639 *oload_champ_bv
= NULL
;
2641 /* Consider each candidate in turn. */
2642 for (ix
= 0; ix
< num_fns
; ix
++)
2645 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2647 struct type
**parm_types
;
2651 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2655 /* If it's not a method, this is the proper place. */
2656 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2659 /* Prepare array of parameter types. */
2660 parm_types
= (struct type
**)
2661 xmalloc (nparms
* (sizeof (struct type
*)));
2662 for (jj
= 0; jj
< nparms
; jj
++)
2663 parm_types
[jj
] = (method
2664 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2665 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2668 /* Compare parameter types to supplied argument types. Skip
2669 THIS for static methods. */
2670 bv
= rank_function (parm_types
, nparms
,
2671 arg_types
+ static_offset
,
2672 nargs
- static_offset
);
2674 if (!*oload_champ_bv
)
2676 *oload_champ_bv
= bv
;
2679 else /* See whether current candidate is better or worse than
2681 switch (compare_badness (bv
, *oload_champ_bv
))
2683 case 0: /* Top two contenders are equally good. */
2684 oload_ambiguous
= 1;
2686 case 1: /* Incomparable top contenders. */
2687 oload_ambiguous
= 2;
2689 case 2: /* New champion, record details. */
2690 *oload_champ_bv
= bv
;
2691 oload_ambiguous
= 0;
2702 fprintf_filtered (gdb_stderr
,
2703 "Overloaded method instance %s, # of parms %d\n",
2704 fns_ptr
[ix
].physname
, nparms
);
2706 fprintf_filtered (gdb_stderr
,
2707 "Overloaded function instance %s # of parms %d\n",
2708 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
2710 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2711 fprintf_filtered (gdb_stderr
,
2712 "...Badness @ %d : %d\n",
2714 fprintf_filtered (gdb_stderr
,
2715 "Overload resolution champion is %d, ambiguous? %d\n",
2716 oload_champ
, oload_ambiguous
);
2723 /* Return 1 if we're looking at a static method, 0 if we're looking at
2724 a non-static method or a function that isn't a method. */
2727 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
2729 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
2735 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2737 static enum oload_classification
2738 classify_oload_match (struct badness_vector
*oload_champ_bv
,
2744 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2746 if (oload_champ_bv
->rank
[ix
] >= 100)
2747 return INCOMPATIBLE
; /* Truly mismatched types. */
2748 else if (oload_champ_bv
->rank
[ix
] >= 10)
2749 return NON_STANDARD
; /* Non-standard type conversions
2753 return STANDARD
; /* Only standard conversions needed. */
2756 /* C++: return 1 is NAME is a legitimate name for the destructor of
2757 type TYPE. If TYPE does not have a destructor, or if NAME is
2758 inappropriate for TYPE, an error is signaled. */
2760 destructor_name_p (const char *name
, const struct type
*type
)
2764 char *dname
= type_name_no_tag (type
);
2765 char *cp
= strchr (dname
, '<');
2768 /* Do not compare the template part for template classes. */
2770 len
= strlen (dname
);
2773 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
2774 error (_("name of destructor must equal name of class"));
2781 /* Given TYPE, a structure/union,
2782 return 1 if the component named NAME from the ultimate target
2783 structure/union is defined, otherwise, return 0. */
2786 check_field (struct type
*type
, const char *name
)
2790 /* The type may be a stub. */
2791 CHECK_TYPEDEF (type
);
2793 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2795 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2796 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2800 /* C++: If it was not found as a data field, then try to return it
2801 as a pointer to a method. */
2803 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2805 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2809 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2810 if (check_field (TYPE_BASECLASS (type
, i
), name
))
2816 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2817 return the appropriate member (or the address of the member, if
2818 WANT_ADDRESS). This function is used to resolve user expressions
2819 of the form "DOMAIN::NAME". For more details on what happens, see
2820 the comment before value_struct_elt_for_reference. */
2823 value_aggregate_elt (struct type
*curtype
, char *name
,
2824 struct type
*expect_type
, int want_address
,
2827 switch (TYPE_CODE (curtype
))
2829 case TYPE_CODE_STRUCT
:
2830 case TYPE_CODE_UNION
:
2831 return value_struct_elt_for_reference (curtype
, 0, curtype
,
2833 want_address
, noside
);
2834 case TYPE_CODE_NAMESPACE
:
2835 return value_namespace_elt (curtype
, name
,
2836 want_address
, noside
);
2838 internal_error (__FILE__
, __LINE__
,
2839 _("non-aggregate type in value_aggregate_elt"));
2843 /* Compares the two method/function types T1 and T2 for "equality"
2844 with respect to the the methods' parameters. If the types of the
2845 two parameter lists are the same, returns 1; 0 otherwise. This
2846 comparison may ignore any artificial parameters in T1 if
2847 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
2848 the first artificial parameter in T1, assumed to be a 'this' pointer.
2850 The type T2 is expected to have come from make_params (in eval.c). */
2853 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
2857 if (TYPE_FIELD_ARTIFICIAL (t1
, 0))
2860 /* If skipping artificial fields, find the first real field
2862 if (skip_artificial
)
2864 while (start
< TYPE_NFIELDS (t1
)
2865 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
2869 /* Now compare parameters */
2871 /* Special case: a method taking void. T1 will contain no
2872 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
2873 if ((TYPE_NFIELDS (t1
) - start
) == 0 && TYPE_NFIELDS (t2
) == 1
2874 && TYPE_CODE (TYPE_FIELD_TYPE (t2
, 0)) == TYPE_CODE_VOID
)
2877 if ((TYPE_NFIELDS (t1
) - start
) == TYPE_NFIELDS (t2
))
2880 for (i
= 0; i
< TYPE_NFIELDS (t2
); ++i
)
2882 if (rank_one_type (TYPE_FIELD_TYPE (t1
, start
+ i
),
2883 TYPE_FIELD_TYPE (t2
, i
))
2894 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2895 return the address of this member as a "pointer to member" type.
2896 If INTYPE is non-null, then it will be the type of the member we
2897 are looking for. This will help us resolve "pointers to member
2898 functions". This function is used to resolve user expressions of
2899 the form "DOMAIN::NAME". */
2901 static struct value
*
2902 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2903 struct type
*curtype
, char *name
,
2904 struct type
*intype
,
2908 struct type
*t
= curtype
;
2910 struct value
*v
, *result
;
2912 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2913 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2914 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2916 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2918 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2920 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2922 if (field_is_static (&TYPE_FIELD (t
, i
)))
2924 v
= value_static_field (t
, i
);
2926 error (_("static field %s has been optimized out"),
2932 if (TYPE_FIELD_PACKED (t
, i
))
2933 error (_("pointers to bitfield members not allowed"));
2936 return value_from_longest
2937 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
2938 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2939 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2940 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
2942 error (_("Cannot reference non-static field \"%s\""), name
);
2946 /* C++: If it was not found as a data field, then try to return it
2947 as a pointer to a method. */
2949 /* Perform all necessary dereferencing. */
2950 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2951 intype
= TYPE_TARGET_TYPE (intype
);
2953 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2955 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2956 char dem_opname
[64];
2958 if (strncmp (t_field_name
, "__", 2) == 0
2959 || strncmp (t_field_name
, "op", 2) == 0
2960 || strncmp (t_field_name
, "type", 4) == 0)
2962 if (cplus_demangle_opname (t_field_name
,
2963 dem_opname
, DMGL_ANSI
))
2964 t_field_name
= dem_opname
;
2965 else if (cplus_demangle_opname (t_field_name
,
2967 t_field_name
= dem_opname
;
2969 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2972 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2973 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2975 check_stub_method_group (t
, i
);
2979 for (j
= 0; j
< len
; ++j
)
2981 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
2982 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 1))
2987 error (_("no member function matches that type instantiation"));
2994 for (ii
= 0; ii
< TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2997 /* Skip artificial methods. This is necessary if,
2998 for example, the user wants to "print
2999 subclass::subclass" with only one user-defined
3000 constructor. There is no ambiguity in this
3002 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3005 /* Desired method is ambiguous if more than one
3006 method is defined. */
3008 error (_("non-unique member `%s' requires type instantiation"), name
);
3014 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3017 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3023 return value_addr (read_var_value (s
, 0));
3025 return read_var_value (s
, 0);
3028 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3032 result
= allocate_value
3033 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3034 cplus_make_method_ptr (value_type (result
),
3035 value_contents_writeable (result
),
3036 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3038 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3039 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3041 error (_("Cannot reference virtual member function \"%s\""),
3047 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3052 v
= read_var_value (s
, 0);
3057 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3058 cplus_make_method_ptr (value_type (result
),
3059 value_contents_writeable (result
),
3060 value_address (v
), 0);
3066 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3071 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3074 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3075 v
= value_struct_elt_for_reference (domain
,
3076 offset
+ base_offset
,
3077 TYPE_BASECLASS (t
, i
),
3079 want_address
, noside
);
3084 /* As a last chance, pretend that CURTYPE is a namespace, and look
3085 it up that way; this (frequently) works for types nested inside
3088 return value_maybe_namespace_elt (curtype
, name
,
3089 want_address
, noside
);
3092 /* C++: Return the member NAME of the namespace given by the type
3095 static struct value
*
3096 value_namespace_elt (const struct type
*curtype
,
3097 char *name
, int want_address
,
3100 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3105 error (_("No symbol \"%s\" in namespace \"%s\"."),
3106 name
, TYPE_TAG_NAME (curtype
));
3111 /* A helper function used by value_namespace_elt and
3112 value_struct_elt_for_reference. It looks up NAME inside the
3113 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3114 is a class and NAME refers to a type in CURTYPE itself (as opposed
3115 to, say, some base class of CURTYPE). */
3117 static struct value
*
3118 value_maybe_namespace_elt (const struct type
*curtype
,
3119 char *name
, int want_address
,
3122 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
3124 struct value
*result
;
3126 sym
= cp_lookup_symbol_namespace (namespace_name
, name
, NULL
,
3127 get_selected_block (0),
3132 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3133 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
3134 result
= allocate_value (SYMBOL_TYPE (sym
));
3136 result
= value_of_variable (sym
, get_selected_block (0));
3138 if (result
&& want_address
)
3139 result
= value_addr (result
);
3144 /* Given a pointer value V, find the real (RTTI) type of the object it
3147 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3148 and refer to the values computed for the object pointed to. */
3151 value_rtti_target_type (struct value
*v
, int *full
,
3152 int *top
, int *using_enc
)
3154 struct value
*target
;
3156 target
= value_ind (v
);
3158 return value_rtti_type (target
, full
, top
, using_enc
);
3161 /* Given a value pointed to by ARGP, check its real run-time type, and
3162 if that is different from the enclosing type, create a new value
3163 using the real run-time type as the enclosing type (and of the same
3164 type as ARGP) and return it, with the embedded offset adjusted to
3165 be the correct offset to the enclosed object. RTYPE is the type,
3166 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3167 by value_rtti_type(). If these are available, they can be supplied
3168 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3169 NULL if they're not available. */
3172 value_full_object (struct value
*argp
,
3174 int xfull
, int xtop
,
3177 struct type
*real_type
;
3181 struct value
*new_val
;
3188 using_enc
= xusing_enc
;
3191 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3193 /* If no RTTI data, or if object is already complete, do nothing. */
3194 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3197 /* If we have the full object, but for some reason the enclosing
3198 type is wrong, set it. */
3199 /* pai: FIXME -- sounds iffy */
3202 argp
= value_change_enclosing_type (argp
, real_type
);
3206 /* Check if object is in memory */
3207 if (VALUE_LVAL (argp
) != lval_memory
)
3209 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
3210 TYPE_NAME (real_type
));
3215 /* All other cases -- retrieve the complete object. */
3216 /* Go back by the computed top_offset from the beginning of the
3217 object, adjusting for the embedded offset of argp if that's what
3218 value_rtti_type used for its computation. */
3219 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3220 (using_enc
? 0 : value_embedded_offset (argp
)));
3221 deprecated_set_value_type (new_val
, value_type (argp
));
3222 set_value_embedded_offset (new_val
, (using_enc
3223 ? top
+ value_embedded_offset (argp
)
3229 /* Return the value of the local variable, if one exists.
3230 Flag COMPLAIN signals an error if the request is made in an
3231 inappropriate context. */
3234 value_of_local (const char *name
, int complain
)
3236 struct symbol
*func
, *sym
;
3239 struct frame_info
*frame
;
3242 frame
= get_selected_frame (_("no frame selected"));
3245 frame
= deprecated_safe_get_selected_frame ();
3250 func
= get_frame_function (frame
);
3254 error (_("no `%s' in nameless context"), name
);
3259 b
= SYMBOL_BLOCK_VALUE (func
);
3260 if (dict_empty (BLOCK_DICT (b
)))
3263 error (_("no args, no `%s'"), name
);
3268 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3269 symbol instead of the LOC_ARG one (if both exist). */
3270 sym
= lookup_block_symbol (b
, name
, NULL
, VAR_DOMAIN
);
3274 error (_("current stack frame does not contain a variable named `%s'"),
3280 ret
= read_var_value (sym
, frame
);
3281 if (ret
== 0 && complain
)
3282 error (_("`%s' argument unreadable"), name
);
3286 /* C++/Objective-C: return the value of the class instance variable,
3287 if one exists. Flag COMPLAIN signals an error if the request is
3288 made in an inappropriate context. */
3291 value_of_this (int complain
)
3293 if (!current_language
->la_name_of_this
)
3295 return value_of_local (current_language
->la_name_of_this
, complain
);
3298 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3299 elements long, starting at LOWBOUND. The result has the same lower
3300 bound as the original ARRAY. */
3303 value_slice (struct value
*array
, int lowbound
, int length
)
3305 struct type
*slice_range_type
, *slice_type
, *range_type
;
3306 LONGEST lowerbound
, upperbound
;
3307 struct value
*slice
;
3308 struct type
*array_type
;
3310 array_type
= check_typedef (value_type (array
));
3311 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3312 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3313 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3314 error (_("cannot take slice of non-array"));
3316 range_type
= TYPE_INDEX_TYPE (array_type
);
3317 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3318 error (_("slice from bad array or bitstring"));
3320 if (lowbound
< lowerbound
|| length
< 0
3321 || lowbound
+ length
- 1 > upperbound
)
3322 error (_("slice out of range"));
3324 /* FIXME-type-allocation: need a way to free this type when we are
3326 slice_range_type
= create_range_type ((struct type
*) NULL
,
3327 TYPE_TARGET_TYPE (range_type
),
3329 lowbound
+ length
- 1);
3330 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3334 slice_type
= create_set_type ((struct type
*) NULL
,
3336 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3337 slice
= value_zero (slice_type
, not_lval
);
3339 for (i
= 0; i
< length
; i
++)
3341 int element
= value_bit_index (array_type
,
3342 value_contents (array
),
3345 error (_("internal error accessing bitstring"));
3346 else if (element
> 0)
3348 int j
= i
% TARGET_CHAR_BIT
;
3349 if (gdbarch_bits_big_endian (get_type_arch (array_type
)))
3350 j
= TARGET_CHAR_BIT
- 1 - j
;
3351 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3354 /* We should set the address, bitssize, and bitspos, so the
3355 slice can be used on the LHS, but that may require extensions
3356 to value_assign. For now, just leave as a non_lval.
3361 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3363 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3365 slice_type
= create_array_type ((struct type
*) NULL
,
3368 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3370 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3371 slice
= allocate_value_lazy (slice_type
);
3374 slice
= allocate_value (slice_type
);
3375 memcpy (value_contents_writeable (slice
),
3376 value_contents (array
) + offset
,
3377 TYPE_LENGTH (slice_type
));
3380 set_value_component_location (slice
, array
);
3381 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
3382 set_value_offset (slice
, value_offset (array
) + offset
);
3387 /* Create a value for a FORTRAN complex number. Currently most of the
3388 time values are coerced to COMPLEX*16 (i.e. a complex number
3389 composed of 2 doubles. This really should be a smarter routine
3390 that figures out precision inteligently as opposed to assuming
3391 doubles. FIXME: fmb */
3394 value_literal_complex (struct value
*arg1
,
3399 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3401 val
= allocate_value (type
);
3402 arg1
= value_cast (real_type
, arg1
);
3403 arg2
= value_cast (real_type
, arg2
);
3405 memcpy (value_contents_raw (val
),
3406 value_contents (arg1
), TYPE_LENGTH (real_type
));
3407 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3408 value_contents (arg2
), TYPE_LENGTH (real_type
));
3412 /* Cast a value into the appropriate complex data type. */
3414 static struct value
*
3415 cast_into_complex (struct type
*type
, struct value
*val
)
3417 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3419 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3421 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3422 struct value
*re_val
= allocate_value (val_real_type
);
3423 struct value
*im_val
= allocate_value (val_real_type
);
3425 memcpy (value_contents_raw (re_val
),
3426 value_contents (val
), TYPE_LENGTH (val_real_type
));
3427 memcpy (value_contents_raw (im_val
),
3428 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3429 TYPE_LENGTH (val_real_type
));
3431 return value_literal_complex (re_val
, im_val
, type
);
3433 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3434 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3435 return value_literal_complex (val
,
3436 value_zero (real_type
, not_lval
),
3439 error (_("cannot cast non-number to complex"));
3443 _initialize_valops (void)
3445 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3446 &overload_resolution
, _("\
3447 Set overload resolution in evaluating C++ functions."), _("\
3448 Show overload resolution in evaluating C++ functions."),
3450 show_overload_resolution
,
3451 &setlist
, &showlist
);
3452 overload_resolution
= 1;