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 (const char *, struct value
*,
57 int, struct type
*, int);
59 static struct value
*search_struct_method (const 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
**, const 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
*type2
= check_typedef (value_type (arg2
));
302 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
303 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
305 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
306 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
307 && !value_logical_not (arg2
))
311 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
312 v2
= coerce_ref (arg2
);
314 v2
= value_ind (arg2
);
315 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
))) == TYPE_CODE_STRUCT
316 && !!"Why did coercion fail?");
317 v2
= value_cast_structs (t1
, v2
);
318 /* At this point we have what we can have, un-dereference if needed. */
321 struct value
*v
= value_addr (v2
);
322 deprecated_set_value_type (v
, type
);
327 /* No superclass found, just change the pointer type. */
328 arg2
= value_copy (arg2
);
329 deprecated_set_value_type (arg2
, type
);
330 arg2
= value_change_enclosing_type (arg2
, type
);
331 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
335 /* Cast value ARG2 to type TYPE and return as a value.
336 More general than a C cast: accepts any two types of the same length,
337 and if ARG2 is an lvalue it can be cast into anything at all. */
338 /* In C++, casts may change pointer or object representations. */
341 value_cast (struct type
*type
, struct value
*arg2
)
343 enum type_code code1
;
344 enum type_code code2
;
348 int convert_to_boolean
= 0;
350 if (value_type (arg2
) == type
)
353 code1
= TYPE_CODE (check_typedef (type
));
355 /* Check if we are casting struct reference to struct reference. */
356 if (code1
== TYPE_CODE_REF
)
358 /* We dereference type; then we recurse and finally
359 we generate value of the given reference. Nothing wrong with
361 struct type
*t1
= check_typedef (type
);
362 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
363 struct value
*val
= value_cast (dereftype
, arg2
);
364 return value_ref (val
);
367 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
369 if (code2
== TYPE_CODE_REF
)
370 /* We deref the value and then do the cast. */
371 return value_cast (type
, coerce_ref (arg2
));
373 CHECK_TYPEDEF (type
);
374 code1
= TYPE_CODE (type
);
375 arg2
= coerce_ref (arg2
);
376 type2
= check_typedef (value_type (arg2
));
378 /* You can't cast to a reference type. See value_cast_pointers
380 gdb_assert (code1
!= TYPE_CODE_REF
);
382 /* A cast to an undetermined-length array_type, such as
383 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
384 where N is sizeof(OBJECT)/sizeof(TYPE). */
385 if (code1
== TYPE_CODE_ARRAY
)
387 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
388 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
389 if (element_length
> 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
391 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
392 int val_length
= TYPE_LENGTH (type2
);
393 LONGEST low_bound
, high_bound
, new_length
;
394 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
395 low_bound
= 0, high_bound
= 0;
396 new_length
= val_length
/ element_length
;
397 if (val_length
% element_length
!= 0)
398 warning (_("array element type size does not divide object size in cast"));
399 /* FIXME-type-allocation: need a way to free this type when
400 we are done with it. */
401 range_type
= create_range_type ((struct type
*) NULL
,
402 TYPE_TARGET_TYPE (range_type
),
404 new_length
+ low_bound
- 1);
405 deprecated_set_value_type (arg2
,
406 create_array_type ((struct type
*) NULL
,
413 if (current_language
->c_style_arrays
414 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
415 arg2
= value_coerce_array (arg2
);
417 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
418 arg2
= value_coerce_function (arg2
);
420 type2
= check_typedef (value_type (arg2
));
421 code2
= TYPE_CODE (type2
);
423 if (code1
== TYPE_CODE_COMPLEX
)
424 return cast_into_complex (type
, arg2
);
425 if (code1
== TYPE_CODE_BOOL
)
427 code1
= TYPE_CODE_INT
;
428 convert_to_boolean
= 1;
430 if (code1
== TYPE_CODE_CHAR
)
431 code1
= TYPE_CODE_INT
;
432 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
433 code2
= TYPE_CODE_INT
;
435 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
436 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
437 || code2
== TYPE_CODE_RANGE
);
439 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
440 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
441 && TYPE_NAME (type
) != 0)
443 struct value
*v
= value_cast_structs (type
, arg2
);
448 if (code1
== TYPE_CODE_FLT
&& scalar
)
449 return value_from_double (type
, value_as_double (arg2
));
450 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
452 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
453 int dec_len
= TYPE_LENGTH (type
);
456 if (code2
== TYPE_CODE_FLT
)
457 decimal_from_floating (arg2
, dec
, dec_len
, byte_order
);
458 else if (code2
== TYPE_CODE_DECFLOAT
)
459 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
460 byte_order
, dec
, dec_len
, byte_order
);
462 /* The only option left is an integral type. */
463 decimal_from_integral (arg2
, dec
, dec_len
, byte_order
);
465 return value_from_decfloat (type
, dec
);
467 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
468 || code1
== TYPE_CODE_RANGE
)
469 && (scalar
|| code2
== TYPE_CODE_PTR
470 || code2
== TYPE_CODE_MEMBERPTR
))
474 /* When we cast pointers to integers, we mustn't use
475 gdbarch_pointer_to_address to find the address the pointer
476 represents, as value_as_long would. GDB should evaluate
477 expressions just as the compiler would --- and the compiler
478 sees a cast as a simple reinterpretation of the pointer's
480 if (code2
== TYPE_CODE_PTR
)
481 longest
= extract_unsigned_integer
482 (value_contents (arg2
), TYPE_LENGTH (type2
),
483 gdbarch_byte_order (get_type_arch (type2
)));
485 longest
= value_as_long (arg2
);
486 return value_from_longest (type
, convert_to_boolean
?
487 (LONGEST
) (longest
? 1 : 0) : longest
);
489 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
490 || code2
== TYPE_CODE_ENUM
491 || code2
== TYPE_CODE_RANGE
))
493 /* TYPE_LENGTH (type) is the length of a pointer, but we really
494 want the length of an address! -- we are really dealing with
495 addresses (i.e., gdb representations) not pointers (i.e.,
496 target representations) here.
498 This allows things like "print *(int *)0x01000234" to work
499 without printing a misleading message -- which would
500 otherwise occur when dealing with a target having two byte
501 pointers and four byte addresses. */
503 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
505 LONGEST longest
= value_as_long (arg2
);
506 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
508 if (longest
>= ((LONGEST
) 1 << addr_bit
)
509 || longest
<= -((LONGEST
) 1 << addr_bit
))
510 warning (_("value truncated"));
512 return value_from_longest (type
, longest
);
514 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
515 && value_as_long (arg2
) == 0)
517 struct value
*result
= allocate_value (type
);
518 cplus_make_method_ptr (type
, value_contents_writeable (result
), 0, 0);
521 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
522 && value_as_long (arg2
) == 0)
524 /* The Itanium C++ ABI represents NULL pointers to members as
525 minus one, instead of biasing the normal case. */
526 return value_from_longest (type
, -1);
528 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
530 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
531 return value_cast_pointers (type
, arg2
);
533 arg2
= value_copy (arg2
);
534 deprecated_set_value_type (arg2
, type
);
535 arg2
= value_change_enclosing_type (arg2
, type
);
536 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
539 else if (VALUE_LVAL (arg2
) == lval_memory
)
540 return value_at_lazy (type
, value_address (arg2
));
541 else if (code1
== TYPE_CODE_VOID
)
543 return value_zero (type
, not_lval
);
547 error (_("Invalid cast."));
552 /* The C++ reinterpret_cast operator. */
555 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
557 struct value
*result
;
558 struct type
*real_type
= check_typedef (type
);
559 struct type
*arg_type
, *dest_type
;
561 enum type_code dest_code
, arg_code
;
563 /* Do reference, function, and array conversion. */
564 arg
= coerce_array (arg
);
566 /* Attempt to preserve the type the user asked for. */
569 /* If we are casting to a reference type, transform
570 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
571 if (TYPE_CODE (real_type
) == TYPE_CODE_REF
)
574 arg
= value_addr (arg
);
575 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
576 real_type
= lookup_pointer_type (real_type
);
579 arg_type
= value_type (arg
);
581 dest_code
= TYPE_CODE (real_type
);
582 arg_code
= TYPE_CODE (arg_type
);
584 /* We can convert pointer types, or any pointer type to int, or int
586 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
587 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
588 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
589 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
590 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
591 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
592 || (dest_code
== arg_code
593 && (dest_code
== TYPE_CODE_PTR
594 || dest_code
== TYPE_CODE_METHODPTR
595 || dest_code
== TYPE_CODE_MEMBERPTR
)))
596 result
= value_cast (dest_type
, arg
);
598 error (_("Invalid reinterpret_cast"));
601 result
= value_cast (type
, value_ref (value_ind (result
)));
606 /* A helper for value_dynamic_cast. This implements the first of two
607 runtime checks: we iterate over all the base classes of the value's
608 class which are equal to the desired class; if only one of these
609 holds the value, then it is the answer. */
612 dynamic_cast_check_1 (struct type
*desired_type
,
613 const bfd_byte
*contents
,
615 struct type
*search_type
,
617 struct type
*arg_type
,
618 struct value
**result
)
620 int i
, result_count
= 0;
622 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
624 int offset
= baseclass_offset (search_type
, i
, contents
, address
);
626 error (_("virtual baseclass botch"));
627 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
629 if (address
+ offset
>= arg_addr
630 && address
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
634 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
639 result_count
+= dynamic_cast_check_1 (desired_type
,
642 TYPE_BASECLASS (search_type
, i
),
651 /* A helper for value_dynamic_cast. This implements the second of two
652 runtime checks: we look for a unique public sibling class of the
653 argument's declared class. */
656 dynamic_cast_check_2 (struct type
*desired_type
,
657 const bfd_byte
*contents
,
659 struct type
*search_type
,
660 struct value
**result
)
662 int i
, result_count
= 0;
664 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
668 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
671 offset
= baseclass_offset (search_type
, i
, contents
, address
);
673 error (_("virtual baseclass botch"));
674 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
678 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
682 result_count
+= dynamic_cast_check_2 (desired_type
,
685 TYPE_BASECLASS (search_type
, i
),
692 /* The C++ dynamic_cast operator. */
695 value_dynamic_cast (struct type
*type
, struct value
*arg
)
697 int full
, top
, using_enc
;
698 struct type
*resolved_type
= check_typedef (type
);
699 struct type
*arg_type
= check_typedef (value_type (arg
));
700 struct type
*class_type
, *rtti_type
;
701 struct value
*result
, *tem
, *original_arg
= arg
;
703 int is_ref
= TYPE_CODE (resolved_type
) == TYPE_CODE_REF
;
705 if (TYPE_CODE (resolved_type
) != TYPE_CODE_PTR
706 && TYPE_CODE (resolved_type
) != TYPE_CODE_REF
)
707 error (_("Argument to dynamic_cast must be a pointer or reference type"));
708 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_VOID
709 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_CLASS
)
710 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
712 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
713 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
715 if (TYPE_CODE (arg_type
) != TYPE_CODE_PTR
716 && ! (TYPE_CODE (arg_type
) == TYPE_CODE_INT
717 && value_as_long (arg
) == 0))
718 error (_("Argument to dynamic_cast does not have pointer type"));
719 if (TYPE_CODE (arg_type
) == TYPE_CODE_PTR
)
721 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
722 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
723 error (_("Argument to dynamic_cast does not have pointer to class type"));
726 /* Handle NULL pointers. */
727 if (value_as_long (arg
) == 0)
728 return value_zero (type
, not_lval
);
730 arg
= value_ind (arg
);
734 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
735 error (_("Argument to dynamic_cast does not have class type"));
738 /* If the classes are the same, just return the argument. */
739 if (class_types_same_p (class_type
, arg_type
))
740 return value_cast (type
, arg
);
742 /* If the target type is a unique base class of the argument's
743 declared type, just cast it. */
744 if (is_ancestor (class_type
, arg_type
))
746 if (is_unique_ancestor (class_type
, arg
))
747 return value_cast (type
, original_arg
);
748 error (_("Ambiguous dynamic_cast"));
751 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
753 error (_("Couldn't determine value's most derived type for dynamic_cast"));
755 /* Compute the most derived object's address. */
756 addr
= value_address (arg
);
764 addr
+= top
+ value_embedded_offset (arg
);
766 /* dynamic_cast<void *> means to return a pointer to the
767 most-derived object. */
768 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
769 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) == TYPE_CODE_VOID
)
770 return value_at_lazy (type
, addr
);
772 tem
= value_at (type
, addr
);
774 /* The first dynamic check specified in 5.2.7. */
775 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
777 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
780 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
781 value_contents (tem
), value_address (tem
),
785 return value_cast (type
,
786 is_ref
? value_ref (result
) : value_addr (result
));
789 /* The second dynamic check specified in 5.2.7. */
791 if (is_public_ancestor (arg_type
, rtti_type
)
792 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
793 value_contents (tem
), value_address (tem
),
794 rtti_type
, &result
) == 1)
795 return value_cast (type
,
796 is_ref
? value_ref (result
) : value_addr (result
));
798 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
799 return value_zero (type
, not_lval
);
801 error (_("dynamic_cast failed"));
804 /* Create a value of type TYPE that is zero, and return it. */
807 value_zero (struct type
*type
, enum lval_type lv
)
809 struct value
*val
= allocate_value (type
);
810 VALUE_LVAL (val
) = lv
;
815 /* Create a value of numeric type TYPE that is one, and return it. */
818 value_one (struct type
*type
, enum lval_type lv
)
820 struct type
*type1
= check_typedef (type
);
823 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
825 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
827 decimal_from_string (v
, TYPE_LENGTH (type
), byte_order
, "1");
828 val
= value_from_decfloat (type
, v
);
830 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
832 val
= value_from_double (type
, (DOUBLEST
) 1);
834 else if (is_integral_type (type1
))
836 val
= value_from_longest (type
, (LONGEST
) 1);
840 error (_("Not a numeric type."));
843 VALUE_LVAL (val
) = lv
;
847 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
849 static struct value
*
850 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
854 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
855 error (_("Attempt to dereference a generic pointer."));
859 val
= allocate_value_lazy (type
);
863 val
= allocate_value (type
);
864 read_memory (addr
, value_contents_all_raw (val
), TYPE_LENGTH (type
));
867 VALUE_LVAL (val
) = lval_memory
;
868 set_value_address (val
, addr
);
873 /* Return a value with type TYPE located at ADDR.
875 Call value_at only if the data needs to be fetched immediately;
876 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
877 value_at_lazy instead. value_at_lazy simply records the address of
878 the data and sets the lazy-evaluation-required flag. The lazy flag
879 is tested in the value_contents macro, which is used if and when
880 the contents are actually required.
882 Note: value_at does *NOT* handle embedded offsets; perform such
883 adjustments before or after calling it. */
886 value_at (struct type
*type
, CORE_ADDR addr
)
888 return get_value_at (type
, addr
, 0);
891 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
894 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
896 return get_value_at (type
, addr
, 1);
899 /* Called only from the value_contents and value_contents_all()
900 macros, if the current data for a variable needs to be loaded into
901 value_contents(VAL). Fetches the data from the user's process, and
902 clears the lazy flag to indicate that the data in the buffer is
905 If the value is zero-length, we avoid calling read_memory, which
906 would abort. We mark the value as fetched anyway -- all 0 bytes of
909 This function returns a value because it is used in the
910 value_contents macro as part of an expression, where a void would
911 not work. The value is ignored. */
914 value_fetch_lazy (struct value
*val
)
916 gdb_assert (value_lazy (val
));
917 allocate_value_contents (val
);
918 if (value_bitsize (val
))
920 /* To read a lazy bitfield, read the entire enclosing value. This
921 prevents reading the same block of (possibly volatile) memory once
922 per bitfield. It would be even better to read only the containing
923 word, but we have no way to record that just specific bits of a
924 value have been fetched. */
925 struct type
*type
= check_typedef (value_type (val
));
926 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
927 struct value
*parent
= value_parent (val
);
928 LONGEST offset
= value_offset (val
);
929 LONGEST num
= unpack_bits_as_long (value_type (val
),
930 value_contents (parent
) + offset
,
932 value_bitsize (val
));
933 int length
= TYPE_LENGTH (type
);
934 store_signed_integer (value_contents_raw (val
), length
, byte_order
, num
);
936 else if (VALUE_LVAL (val
) == lval_memory
)
938 CORE_ADDR addr
= value_address (val
);
939 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
943 if (value_stack (val
))
944 read_stack (addr
, value_contents_all_raw (val
), length
);
946 read_memory (addr
, value_contents_all_raw (val
), length
);
949 else if (VALUE_LVAL (val
) == lval_register
)
951 struct frame_info
*frame
;
953 struct type
*type
= check_typedef (value_type (val
));
954 struct value
*new_val
= val
, *mark
= value_mark ();
956 /* Offsets are not supported here; lazy register values must
957 refer to the entire register. */
958 gdb_assert (value_offset (val
) == 0);
960 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
962 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
963 regnum
= VALUE_REGNUM (new_val
);
965 gdb_assert (frame
!= NULL
);
967 /* Convertible register routines are used for multi-register
968 values and for interpretation in different types
969 (e.g. float or int from a double register). Lazy
970 register values should have the register's natural type,
971 so they do not apply. */
972 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
975 new_val
= get_frame_register_value (frame
, regnum
);
978 /* If it's still lazy (for instance, a saved register on the
980 if (value_lazy (new_val
))
981 value_fetch_lazy (new_val
);
983 /* If the register was not saved, mark it unavailable. */
984 if (value_optimized_out (new_val
))
985 set_value_optimized_out (val
, 1);
987 memcpy (value_contents_raw (val
), value_contents (new_val
),
992 struct gdbarch
*gdbarch
;
993 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
994 regnum
= VALUE_REGNUM (val
);
995 gdbarch
= get_frame_arch (frame
);
997 fprintf_unfiltered (gdb_stdlog
, "\
998 { value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
999 frame_relative_level (frame
), regnum
,
1000 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1002 fprintf_unfiltered (gdb_stdlog
, "->");
1003 if (value_optimized_out (new_val
))
1004 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1008 const gdb_byte
*buf
= value_contents (new_val
);
1010 if (VALUE_LVAL (new_val
) == lval_register
)
1011 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1012 VALUE_REGNUM (new_val
));
1013 else if (VALUE_LVAL (new_val
) == lval_memory
)
1014 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1016 value_address (new_val
)));
1018 fprintf_unfiltered (gdb_stdlog
, " computed");
1020 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1021 fprintf_unfiltered (gdb_stdlog
, "[");
1022 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1023 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1024 fprintf_unfiltered (gdb_stdlog
, "]");
1027 fprintf_unfiltered (gdb_stdlog
, " }\n");
1030 /* Dispose of the intermediate values. This prevents
1031 watchpoints from trying to watch the saved frame pointer. */
1032 value_free_to_mark (mark
);
1034 else if (VALUE_LVAL (val
) == lval_computed
)
1035 value_computed_funcs (val
)->read (val
);
1037 internal_error (__FILE__
, __LINE__
, "Unexpected lazy value type.");
1039 set_value_lazy (val
, 0);
1044 /* Store the contents of FROMVAL into the location of TOVAL.
1045 Return a new value with the location of TOVAL and contents of FROMVAL. */
1048 value_assign (struct value
*toval
, struct value
*fromval
)
1052 struct frame_id old_frame
;
1054 if (!deprecated_value_modifiable (toval
))
1055 error (_("Left operand of assignment is not a modifiable lvalue."));
1057 toval
= coerce_ref (toval
);
1059 type
= value_type (toval
);
1060 if (VALUE_LVAL (toval
) != lval_internalvar
)
1062 toval
= value_coerce_to_target (toval
);
1063 fromval
= value_cast (type
, fromval
);
1067 /* Coerce arrays and functions to pointers, except for arrays
1068 which only live in GDB's storage. */
1069 if (!value_must_coerce_to_target (fromval
))
1070 fromval
= coerce_array (fromval
);
1073 CHECK_TYPEDEF (type
);
1075 /* Since modifying a register can trash the frame chain, and
1076 modifying memory can trash the frame cache, we save the old frame
1077 and then restore the new frame afterwards. */
1078 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1080 switch (VALUE_LVAL (toval
))
1082 case lval_internalvar
:
1083 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1084 val
= value_copy (fromval
);
1085 val
= value_change_enclosing_type (val
,
1086 value_enclosing_type (fromval
));
1087 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1088 set_value_pointed_to_offset (val
,
1089 value_pointed_to_offset (fromval
));
1092 case lval_internalvar_component
:
1093 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1094 value_offset (toval
),
1095 value_bitpos (toval
),
1096 value_bitsize (toval
),
1102 const gdb_byte
*dest_buffer
;
1103 CORE_ADDR changed_addr
;
1105 gdb_byte buffer
[sizeof (LONGEST
)];
1107 if (value_bitsize (toval
))
1109 struct value
*parent
= value_parent (toval
);
1110 changed_addr
= value_address (parent
) + value_offset (toval
);
1112 changed_len
= (value_bitpos (toval
)
1113 + value_bitsize (toval
)
1114 + HOST_CHAR_BIT
- 1)
1117 /* If we can read-modify-write exactly the size of the
1118 containing type (e.g. short or int) then do so. This
1119 is safer for volatile bitfields mapped to hardware
1121 if (changed_len
< TYPE_LENGTH (type
)
1122 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1123 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1124 changed_len
= TYPE_LENGTH (type
);
1126 if (changed_len
> (int) sizeof (LONGEST
))
1127 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1128 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1130 read_memory (changed_addr
, buffer
, changed_len
);
1131 modify_field (type
, buffer
, value_as_long (fromval
),
1132 value_bitpos (toval
), value_bitsize (toval
));
1133 dest_buffer
= buffer
;
1137 changed_addr
= value_address (toval
);
1138 changed_len
= TYPE_LENGTH (type
);
1139 dest_buffer
= value_contents (fromval
);
1142 write_memory (changed_addr
, dest_buffer
, changed_len
);
1143 observer_notify_memory_changed (changed_addr
, changed_len
,
1150 struct frame_info
*frame
;
1151 struct gdbarch
*gdbarch
;
1154 /* Figure out which frame this is in currently. */
1155 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1156 value_reg
= VALUE_REGNUM (toval
);
1159 error (_("Value being assigned to is no longer active."));
1161 gdbarch
= get_frame_arch (frame
);
1162 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
), type
))
1164 /* If TOVAL is a special machine register requiring
1165 conversion of program values to a special raw
1167 gdbarch_value_to_register (gdbarch
, frame
,
1168 VALUE_REGNUM (toval
), type
,
1169 value_contents (fromval
));
1173 if (value_bitsize (toval
))
1175 struct value
*parent
= value_parent (toval
);
1176 int offset
= value_offset (parent
) + value_offset (toval
);
1178 gdb_byte buffer
[sizeof (LONGEST
)];
1180 changed_len
= (value_bitpos (toval
)
1181 + value_bitsize (toval
)
1182 + HOST_CHAR_BIT
- 1)
1185 if (changed_len
> (int) sizeof (LONGEST
))
1186 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1187 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1189 get_frame_register_bytes (frame
, value_reg
, offset
,
1190 changed_len
, buffer
);
1192 modify_field (type
, buffer
, value_as_long (fromval
),
1193 value_bitpos (toval
), value_bitsize (toval
));
1195 put_frame_register_bytes (frame
, value_reg
, offset
,
1196 changed_len
, buffer
);
1200 put_frame_register_bytes (frame
, value_reg
,
1201 value_offset (toval
),
1203 value_contents (fromval
));
1207 if (deprecated_register_changed_hook
)
1208 deprecated_register_changed_hook (-1);
1209 observer_notify_target_changed (¤t_target
);
1215 struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1217 funcs
->write (toval
, fromval
);
1222 error (_("Left operand of assignment is not an lvalue."));
1225 /* Assigning to the stack pointer, frame pointer, and other
1226 (architecture and calling convention specific) registers may
1227 cause the frame cache to be out of date. Assigning to memory
1228 also can. We just do this on all assignments to registers or
1229 memory, for simplicity's sake; I doubt the slowdown matters. */
1230 switch (VALUE_LVAL (toval
))
1235 reinit_frame_cache ();
1237 /* Having destroyed the frame cache, restore the selected
1240 /* FIXME: cagney/2002-11-02: There has to be a better way of
1241 doing this. Instead of constantly saving/restoring the
1242 frame. Why not create a get_selected_frame() function that,
1243 having saved the selected frame's ID can automatically
1244 re-find the previously selected frame automatically. */
1247 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1257 /* If the field does not entirely fill a LONGEST, then zero the sign
1258 bits. If the field is signed, and is negative, then sign
1260 if ((value_bitsize (toval
) > 0)
1261 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1263 LONGEST fieldval
= value_as_long (fromval
);
1264 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1266 fieldval
&= valmask
;
1267 if (!TYPE_UNSIGNED (type
)
1268 && (fieldval
& (valmask
^ (valmask
>> 1))))
1269 fieldval
|= ~valmask
;
1271 fromval
= value_from_longest (type
, fieldval
);
1274 val
= value_copy (toval
);
1275 memcpy (value_contents_raw (val
), value_contents (fromval
),
1276 TYPE_LENGTH (type
));
1277 deprecated_set_value_type (val
, type
);
1278 val
= value_change_enclosing_type (val
,
1279 value_enclosing_type (fromval
));
1280 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1281 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1286 /* Extend a value VAL to COUNT repetitions of its type. */
1289 value_repeat (struct value
*arg1
, int count
)
1293 if (VALUE_LVAL (arg1
) != lval_memory
)
1294 error (_("Only values in memory can be extended with '@'."));
1296 error (_("Invalid number %d of repetitions."), count
);
1298 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1300 read_memory (value_address (arg1
),
1301 value_contents_all_raw (val
),
1302 TYPE_LENGTH (value_enclosing_type (val
)));
1303 VALUE_LVAL (val
) = lval_memory
;
1304 set_value_address (val
, value_address (arg1
));
1310 value_of_variable (struct symbol
*var
, struct block
*b
)
1313 struct frame_info
*frame
;
1315 if (!symbol_read_needs_frame (var
))
1318 frame
= get_selected_frame (_("No frame selected."));
1321 frame
= block_innermost_frame (b
);
1324 if (BLOCK_FUNCTION (b
) && !block_inlined_p (b
)
1325 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
1326 error (_("No frame is currently executing in block %s."),
1327 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
1329 error (_("No frame is currently executing in specified block"));
1333 val
= read_var_value (var
, frame
);
1335 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
1341 address_of_variable (struct symbol
*var
, struct block
*b
)
1343 struct type
*type
= SYMBOL_TYPE (var
);
1346 /* Evaluate it first; if the result is a memory address, we're fine.
1347 Lazy evaluation pays off here. */
1349 val
= value_of_variable (var
, b
);
1351 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1352 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1354 CORE_ADDR addr
= value_address (val
);
1355 return value_from_pointer (lookup_pointer_type (type
), addr
);
1358 /* Not a memory address; check what the problem was. */
1359 switch (VALUE_LVAL (val
))
1363 struct frame_info
*frame
;
1364 const char *regname
;
1366 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1369 regname
= gdbarch_register_name (get_frame_arch (frame
),
1370 VALUE_REGNUM (val
));
1371 gdb_assert (regname
&& *regname
);
1373 error (_("Address requested for identifier "
1374 "\"%s\" which is in register $%s"),
1375 SYMBOL_PRINT_NAME (var
), regname
);
1380 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1381 SYMBOL_PRINT_NAME (var
));
1388 /* Return one if VAL does not live in target memory, but should in order
1389 to operate on it. Otherwise return zero. */
1392 value_must_coerce_to_target (struct value
*val
)
1394 struct type
*valtype
;
1396 /* The only lval kinds which do not live in target memory. */
1397 if (VALUE_LVAL (val
) != not_lval
1398 && VALUE_LVAL (val
) != lval_internalvar
)
1401 valtype
= check_typedef (value_type (val
));
1403 switch (TYPE_CODE (valtype
))
1405 case TYPE_CODE_ARRAY
:
1406 case TYPE_CODE_STRING
:
1413 /* Make sure that VAL lives in target memory if it's supposed to. For instance,
1414 strings are constructed as character arrays in GDB's storage, and this
1415 function copies them to the target. */
1418 value_coerce_to_target (struct value
*val
)
1423 if (!value_must_coerce_to_target (val
))
1426 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1427 addr
= allocate_space_in_inferior (length
);
1428 write_memory (addr
, value_contents (val
), length
);
1429 return value_at_lazy (value_type (val
), addr
);
1432 /* Given a value which is an array, return a value which is a pointer
1433 to its first element, regardless of whether or not the array has a
1434 nonzero lower bound.
1436 FIXME: A previous comment here indicated that this routine should
1437 be substracting the array's lower bound. It's not clear to me that
1438 this is correct. Given an array subscripting operation, it would
1439 certainly work to do the adjustment here, essentially computing:
1441 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1443 However I believe a more appropriate and logical place to account
1444 for the lower bound is to do so in value_subscript, essentially
1447 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1449 As further evidence consider what would happen with operations
1450 other than array subscripting, where the caller would get back a
1451 value that had an address somewhere before the actual first element
1452 of the array, and the information about the lower bound would be
1453 lost because of the coercion to pointer type.
1457 value_coerce_array (struct value
*arg1
)
1459 struct type
*type
= check_typedef (value_type (arg1
));
1461 /* If the user tries to do something requiring a pointer with an
1462 array that has not yet been pushed to the target, then this would
1463 be a good time to do so. */
1464 arg1
= value_coerce_to_target (arg1
);
1466 if (VALUE_LVAL (arg1
) != lval_memory
)
1467 error (_("Attempt to take address of value not located in memory."));
1469 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1470 value_address (arg1
));
1473 /* Given a value which is a function, return a value which is a pointer
1477 value_coerce_function (struct value
*arg1
)
1479 struct value
*retval
;
1481 if (VALUE_LVAL (arg1
) != lval_memory
)
1482 error (_("Attempt to take address of value not located in memory."));
1484 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1485 value_address (arg1
));
1489 /* Return a pointer value for the object for which ARG1 is the
1493 value_addr (struct value
*arg1
)
1497 struct type
*type
= check_typedef (value_type (arg1
));
1498 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1500 /* Copy the value, but change the type from (T&) to (T*). We
1501 keep the same location information, which is efficient, and
1502 allows &(&X) to get the location containing the reference. */
1503 arg2
= value_copy (arg1
);
1504 deprecated_set_value_type (arg2
,
1505 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1508 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1509 return value_coerce_function (arg1
);
1511 /* If this is an array that has not yet been pushed to the target,
1512 then this would be a good time to force it to memory. */
1513 arg1
= value_coerce_to_target (arg1
);
1515 if (VALUE_LVAL (arg1
) != lval_memory
)
1516 error (_("Attempt to take address of value not located in memory."));
1518 /* Get target memory address */
1519 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1520 (value_address (arg1
)
1521 + value_embedded_offset (arg1
)));
1523 /* This may be a pointer to a base subobject; so remember the
1524 full derived object's type ... */
1525 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (value_enclosing_type (arg1
)));
1526 /* ... and also the relative position of the subobject in the full
1528 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1532 /* Return a reference value for the object for which ARG1 is the
1536 value_ref (struct value
*arg1
)
1540 struct type
*type
= check_typedef (value_type (arg1
));
1541 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1544 arg2
= value_addr (arg1
);
1545 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1549 /* Given a value of a pointer type, apply the C unary * operator to
1553 value_ind (struct value
*arg1
)
1555 struct type
*base_type
;
1558 arg1
= coerce_array (arg1
);
1560 base_type
= check_typedef (value_type (arg1
));
1562 if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1564 struct type
*enc_type
;
1565 /* We may be pointing to something embedded in a larger object.
1566 Get the real type of the enclosing object. */
1567 enc_type
= check_typedef (value_enclosing_type (arg1
));
1568 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1570 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1571 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1572 /* For functions, go through find_function_addr, which knows
1573 how to handle function descriptors. */
1574 arg2
= value_at_lazy (enc_type
,
1575 find_function_addr (arg1
, NULL
));
1577 /* Retrieve the enclosing object pointed to */
1578 arg2
= value_at_lazy (enc_type
,
1579 (value_as_address (arg1
)
1580 - value_pointed_to_offset (arg1
)));
1582 /* Re-adjust type. */
1583 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1584 /* Add embedding info. */
1585 arg2
= value_change_enclosing_type (arg2
, enc_type
);
1586 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1588 /* We may be pointing to an object of some derived type. */
1589 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1593 error (_("Attempt to take contents of a non-pointer value."));
1594 return 0; /* For lint -- never reached. */
1597 /* Create a value for an array by allocating space in GDB, copying
1598 copying the data into that space, and then setting up an array
1601 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1602 is populated from the values passed in ELEMVEC.
1604 The element type of the array is inherited from the type of the
1605 first element, and all elements must have the same size (though we
1606 don't currently enforce any restriction on their types). */
1609 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1613 unsigned int typelength
;
1615 struct type
*arraytype
;
1617 /* Validate that the bounds are reasonable and that each of the
1618 elements have the same size. */
1620 nelem
= highbound
- lowbound
+ 1;
1623 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1625 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1626 for (idx
= 1; idx
< nelem
; idx
++)
1628 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1630 error (_("array elements must all be the same size"));
1634 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1635 lowbound
, highbound
);
1637 if (!current_language
->c_style_arrays
)
1639 val
= allocate_value (arraytype
);
1640 for (idx
= 0; idx
< nelem
; idx
++)
1642 memcpy (value_contents_all_raw (val
) + (idx
* typelength
),
1643 value_contents_all (elemvec
[idx
]),
1649 /* Allocate space to store the array, and then initialize it by
1650 copying in each element. */
1652 val
= allocate_value (arraytype
);
1653 for (idx
= 0; idx
< nelem
; idx
++)
1654 memcpy (value_contents_writeable (val
) + (idx
* typelength
),
1655 value_contents_all (elemvec
[idx
]),
1661 value_cstring (char *ptr
, int len
, struct type
*char_type
)
1664 int lowbound
= current_language
->string_lower_bound
;
1665 int highbound
= len
/ TYPE_LENGTH (char_type
);
1666 struct type
*stringtype
1667 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1669 val
= allocate_value (stringtype
);
1670 memcpy (value_contents_raw (val
), ptr
, len
);
1674 /* Create a value for a string constant by allocating space in the
1675 inferior, copying the data into that space, and returning the
1676 address with type TYPE_CODE_STRING. PTR points to the string
1677 constant data; LEN is number of characters.
1679 Note that string types are like array of char types with a lower
1680 bound of zero and an upper bound of LEN - 1. Also note that the
1681 string may contain embedded null bytes. */
1684 value_string (char *ptr
, int len
, struct type
*char_type
)
1687 int lowbound
= current_language
->string_lower_bound
;
1688 int highbound
= len
/ TYPE_LENGTH (char_type
);
1689 struct type
*stringtype
1690 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1692 val
= allocate_value (stringtype
);
1693 memcpy (value_contents_raw (val
), ptr
, len
);
1698 value_bitstring (char *ptr
, int len
, struct type
*index_type
)
1701 struct type
*domain_type
1702 = create_range_type (NULL
, index_type
, 0, len
- 1);
1703 struct type
*type
= create_set_type (NULL
, domain_type
);
1704 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1705 val
= allocate_value (type
);
1706 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1710 /* See if we can pass arguments in T2 to a function which takes
1711 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1712 a NULL-terminated vector. If some arguments need coercion of some
1713 sort, then the coerced values are written into T2. Return value is
1714 0 if the arguments could be matched, or the position at which they
1717 STATICP is nonzero if the T1 argument list came from a static
1718 member function. T2 will still include the ``this'' pointer, but
1721 For non-static member functions, we ignore the first argument,
1722 which is the type of the instance variable. This is because we
1723 want to handle calls with objects from derived classes. This is
1724 not entirely correct: we should actually check to make sure that a
1725 requested operation is type secure, shouldn't we? FIXME. */
1728 typecmp (int staticp
, int varargs
, int nargs
,
1729 struct field t1
[], struct value
*t2
[])
1734 internal_error (__FILE__
, __LINE__
,
1735 _("typecmp: no argument list"));
1737 /* Skip ``this'' argument if applicable. T2 will always include
1743 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1746 struct type
*tt1
, *tt2
;
1751 tt1
= check_typedef (t1
[i
].type
);
1752 tt2
= check_typedef (value_type (t2
[i
]));
1754 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1755 /* We should be doing hairy argument matching, as below. */
1756 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1758 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1759 t2
[i
] = value_coerce_array (t2
[i
]);
1761 t2
[i
] = value_ref (t2
[i
]);
1765 /* djb - 20000715 - Until the new type structure is in the
1766 place, and we can attempt things like implicit conversions,
1767 we need to do this so you can take something like a map<const
1768 char *>, and properly access map["hello"], because the
1769 argument to [] will be a reference to a pointer to a char,
1770 and the argument will be a pointer to a char. */
1771 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1772 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1774 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1776 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1777 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1778 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1780 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1782 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1784 /* Array to pointer is a `trivial conversion' according to the
1787 /* We should be doing much hairier argument matching (see
1788 section 13.2 of the ARM), but as a quick kludge, just check
1789 for the same type code. */
1790 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1793 if (varargs
|| t2
[i
] == NULL
)
1798 /* Helper function used by value_struct_elt to recurse through
1799 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1800 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1801 TYPE. If found, return value, else return NULL.
1803 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1804 fields, look for a baseclass named NAME. */
1806 static struct value
*
1807 search_struct_field (const char *name
, struct value
*arg1
, int offset
,
1808 struct type
*type
, int looking_for_baseclass
)
1813 CHECK_TYPEDEF (type
);
1814 nbases
= TYPE_N_BASECLASSES (type
);
1816 if (!looking_for_baseclass
)
1817 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1819 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1821 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1824 if (field_is_static (&TYPE_FIELD (type
, i
)))
1826 v
= value_static_field (type
, i
);
1828 error (_("field %s is nonexistent or has been optimised out"),
1833 v
= value_primitive_field (arg1
, offset
, i
, type
);
1835 error (_("there is no field named %s"), name
);
1841 && (t_field_name
[0] == '\0'
1842 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1843 && (strcmp_iw (t_field_name
, "else") == 0))))
1845 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1846 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1847 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1849 /* Look for a match through the fields of an anonymous
1850 union, or anonymous struct. C++ provides anonymous
1853 In the GNU Chill (now deleted from GDB)
1854 implementation of variant record types, each
1855 <alternative field> has an (anonymous) union type,
1856 each member of the union represents a <variant
1857 alternative>. Each <variant alternative> is
1858 represented as a struct, with a member for each
1862 int new_offset
= offset
;
1864 /* This is pretty gross. In G++, the offset in an
1865 anonymous union is relative to the beginning of the
1866 enclosing struct. In the GNU Chill (now deleted
1867 from GDB) implementation of variant records, the
1868 bitpos is zero in an anonymous union field, so we
1869 have to add the offset of the union here. */
1870 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1871 || (TYPE_NFIELDS (field_type
) > 0
1872 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1873 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1875 v
= search_struct_field (name
, arg1
, new_offset
,
1877 looking_for_baseclass
);
1884 for (i
= 0; i
< nbases
; i
++)
1887 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1888 /* If we are looking for baseclasses, this is what we get when
1889 we hit them. But it could happen that the base part's member
1890 name is not yet filled in. */
1891 int found_baseclass
= (looking_for_baseclass
1892 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1893 && (strcmp_iw (name
,
1894 TYPE_BASECLASS_NAME (type
,
1897 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1902 boffset
= baseclass_offset (type
, i
,
1903 value_contents (arg1
) + offset
,
1904 value_address (arg1
)
1905 + value_embedded_offset (arg1
)
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. */
1914 boffset
+= value_embedded_offset (arg1
) + offset
;
1916 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
1918 CORE_ADDR base_addr
;
1920 v2
= allocate_value (basetype
);
1921 base_addr
= value_address (arg1
) + boffset
;
1922 if (target_read_memory (base_addr
,
1923 value_contents_raw (v2
),
1924 TYPE_LENGTH (basetype
)) != 0)
1925 error (_("virtual baseclass botch"));
1926 VALUE_LVAL (v2
) = lval_memory
;
1927 set_value_address (v2
, base_addr
);
1931 v2
= value_copy (arg1
);
1932 deprecated_set_value_type (v2
, basetype
);
1933 set_value_embedded_offset (v2
, boffset
);
1936 if (found_baseclass
)
1938 v
= search_struct_field (name
, v2
, 0,
1939 TYPE_BASECLASS (type
, i
),
1940 looking_for_baseclass
);
1942 else if (found_baseclass
)
1943 v
= value_primitive_field (arg1
, offset
, i
, type
);
1945 v
= search_struct_field (name
, arg1
,
1946 offset
+ TYPE_BASECLASS_BITPOS (type
,
1948 basetype
, looking_for_baseclass
);
1955 /* Helper function used by value_struct_elt to recurse through
1956 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1957 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1960 If found, return value, else if name matched and args not return
1961 (value) -1, else return NULL. */
1963 static struct value
*
1964 search_struct_method (const char *name
, struct value
**arg1p
,
1965 struct value
**args
, int offset
,
1966 int *static_memfuncp
, struct type
*type
)
1970 int name_matched
= 0;
1971 char dem_opname
[64];
1973 CHECK_TYPEDEF (type
);
1974 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1976 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1977 /* FIXME! May need to check for ARM demangling here */
1978 if (strncmp (t_field_name
, "__", 2) == 0 ||
1979 strncmp (t_field_name
, "op", 2) == 0 ||
1980 strncmp (t_field_name
, "type", 4) == 0)
1982 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1983 t_field_name
= dem_opname
;
1984 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1985 t_field_name
= dem_opname
;
1987 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1989 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1990 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1993 check_stub_method_group (type
, i
);
1994 if (j
> 0 && args
== 0)
1995 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name
);
1996 else if (j
== 0 && args
== 0)
1998 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2005 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2006 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
2007 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
2008 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2010 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2011 return value_virtual_fn_field (arg1p
, f
, j
,
2013 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2015 *static_memfuncp
= 1;
2016 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2025 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2029 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2031 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2032 const gdb_byte
*base_valaddr
;
2034 /* The virtual base class pointer might have been
2035 clobbered by the user program. Make sure that it
2036 still points to a valid memory location. */
2038 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2040 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
2041 if (target_read_memory (value_address (*arg1p
) + offset
,
2042 tmp
, TYPE_LENGTH (baseclass
)) != 0)
2043 error (_("virtual baseclass botch"));
2047 base_valaddr
= value_contents (*arg1p
) + offset
;
2049 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2050 value_address (*arg1p
) + offset
);
2051 if (base_offset
== -1)
2052 error (_("virtual baseclass botch"));
2056 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2058 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2059 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2060 if (v
== (struct value
*) - 1)
2066 /* FIXME-bothner: Why is this commented out? Why is it here? */
2067 /* *arg1p = arg1_tmp; */
2072 return (struct value
*) - 1;
2077 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2078 extract the component named NAME from the ultimate target
2079 structure/union and return it as a value with its appropriate type.
2080 ERR is used in the error message if *ARGP's type is wrong.
2082 C++: ARGS is a list of argument types to aid in the selection of
2083 an appropriate method. Also, handle derived types.
2085 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2086 where the truthvalue of whether the function that was resolved was
2087 a static member function or not is stored.
2089 ERR is an error message to be printed in case the field is not
2093 value_struct_elt (struct value
**argp
, struct value
**args
,
2094 const char *name
, int *static_memfuncp
, const char *err
)
2099 *argp
= coerce_array (*argp
);
2101 t
= check_typedef (value_type (*argp
));
2103 /* Follow pointers until we get to a non-pointer. */
2105 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2107 *argp
= value_ind (*argp
);
2108 /* Don't coerce fn pointer to fn and then back again! */
2109 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2110 *argp
= coerce_array (*argp
);
2111 t
= check_typedef (value_type (*argp
));
2114 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2115 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2116 error (_("Attempt to extract a component of a value that is not a %s."), err
);
2118 /* Assume it's not, unless we see that it is. */
2119 if (static_memfuncp
)
2120 *static_memfuncp
= 0;
2124 /* if there are no arguments ...do this... */
2126 /* Try as a field first, because if we succeed, there is less
2128 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2132 /* C++: If it was not found as a data field, then try to
2133 return it as a pointer to a method. */
2134 v
= search_struct_method (name
, argp
, args
, 0,
2135 static_memfuncp
, t
);
2137 if (v
== (struct value
*) - 1)
2138 error (_("Cannot take address of method %s."), name
);
2141 if (TYPE_NFN_FIELDS (t
))
2142 error (_("There is no member or method named %s."), name
);
2144 error (_("There is no member named %s."), name
);
2149 v
= search_struct_method (name
, argp
, args
, 0,
2150 static_memfuncp
, t
);
2152 if (v
== (struct value
*) - 1)
2154 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name
);
2158 /* See if user tried to invoke data as function. If so, hand it
2159 back. If it's not callable (i.e., a pointer to function),
2160 gdb should give an error. */
2161 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2162 /* If we found an ordinary field, then it is not a method call.
2163 So, treat it as if it were a static member function. */
2164 if (v
&& static_memfuncp
)
2165 *static_memfuncp
= 1;
2169 error (_("Structure has no component named %s."), name
);
2173 /* Search through the methods of an object (and its bases) to find a
2174 specified method. Return the pointer to the fn_field list of
2175 overloaded instances.
2177 Helper function for value_find_oload_list.
2178 ARGP is a pointer to a pointer to a value (the object).
2179 METHOD is a string containing the method name.
2180 OFFSET is the offset within the value.
2181 TYPE is the assumed type of the object.
2182 NUM_FNS is the number of overloaded instances.
2183 BASETYPE is set to the actual type of the subobject where the
2185 BOFFSET is the offset of the base subobject where the method is found.
2188 static struct fn_field
*
2189 find_method_list (struct value
**argp
, const char *method
,
2190 int offset
, struct type
*type
, int *num_fns
,
2191 struct type
**basetype
, int *boffset
)
2195 CHECK_TYPEDEF (type
);
2199 /* First check in object itself. */
2200 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2202 /* pai: FIXME What about operators and type conversions? */
2203 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2204 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2206 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2207 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2213 /* Resolve any stub methods. */
2214 check_stub_method_group (type
, i
);
2220 /* Not found in object, check in base subobjects. */
2221 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2224 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2226 base_offset
= value_offset (*argp
) + offset
;
2227 base_offset
= baseclass_offset (type
, i
,
2228 value_contents (*argp
) + base_offset
,
2229 value_address (*argp
) + base_offset
);
2230 if (base_offset
== -1)
2231 error (_("virtual baseclass botch"));
2233 else /* Non-virtual base, simply use bit position from debug
2236 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2238 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2239 TYPE_BASECLASS (type
, i
), num_fns
,
2247 /* Return the list of overloaded methods of a specified name.
2249 ARGP is a pointer to a pointer to a value (the object).
2250 METHOD is the method name.
2251 OFFSET is the offset within the value contents.
2252 NUM_FNS is the number of overloaded instances.
2253 BASETYPE is set to the type of the base subobject that defines the
2255 BOFFSET is the offset of the base subobject which defines the method.
2259 value_find_oload_method_list (struct value
**argp
, const char *method
,
2260 int offset
, int *num_fns
,
2261 struct type
**basetype
, int *boffset
)
2265 t
= check_typedef (value_type (*argp
));
2267 /* Code snarfed from value_struct_elt. */
2268 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2270 *argp
= value_ind (*argp
);
2271 /* Don't coerce fn pointer to fn and then back again! */
2272 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2273 *argp
= coerce_array (*argp
);
2274 t
= check_typedef (value_type (*argp
));
2277 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2278 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2279 error (_("Attempt to extract a component of a value that is not a struct or union"));
2281 return find_method_list (argp
, method
, 0, t
, num_fns
,
2285 /* Given an array of argument types (ARGTYPES) (which includes an
2286 entry for "this" in the case of C++ methods), the number of
2287 arguments NARGS, the NAME of a function whether it's a method or
2288 not (METHOD), and the degree of laxness (LAX) in conforming to
2289 overload resolution rules in ANSI C++, find the best function that
2290 matches on the argument types according to the overload resolution
2293 In the case of class methods, the parameter OBJ is an object value
2294 in which to search for overloaded methods.
2296 In the case of non-method functions, the parameter FSYM is a symbol
2297 corresponding to one of the overloaded functions.
2299 Return value is an integer: 0 -> good match, 10 -> debugger applied
2300 non-standard coercions, 100 -> incompatible.
2302 If a method is being searched for, VALP will hold the value.
2303 If a non-method is being searched for, SYMP will hold the symbol
2306 If a method is being searched for, and it is a static method,
2307 then STATICP will point to a non-zero value.
2309 Note: This function does *not* check the value of
2310 overload_resolution. Caller must check it to see whether overload
2311 resolution is permitted.
2315 find_overload_match (struct type
**arg_types
, int nargs
,
2316 const char *name
, int method
, int lax
,
2317 struct value
**objp
, struct symbol
*fsym
,
2318 struct value
**valp
, struct symbol
**symp
,
2321 struct value
*obj
= (objp
? *objp
: NULL
);
2322 /* Index of best overloaded function. */
2324 /* The measure for the current best match. */
2325 struct badness_vector
*oload_champ_bv
= NULL
;
2326 struct value
*temp
= obj
;
2327 /* For methods, the list of overloaded methods. */
2328 struct fn_field
*fns_ptr
= NULL
;
2329 /* For non-methods, the list of overloaded function symbols. */
2330 struct symbol
**oload_syms
= NULL
;
2331 /* Number of overloaded instances being considered. */
2333 struct type
*basetype
= NULL
;
2335 struct cleanup
*old_cleanups
= NULL
;
2337 const char *obj_type_name
= NULL
;
2338 char *func_name
= NULL
;
2339 enum oload_classification match_quality
;
2341 /* Get the list of overloaded methods or functions. */
2346 /* OBJ may be a pointer value rather than the object itself. */
2347 obj
= coerce_ref (obj
);
2348 while (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_PTR
)
2349 obj
= coerce_ref (value_ind (obj
));
2350 obj_type_name
= TYPE_NAME (value_type (obj
));
2352 /* First check whether this is a data member, e.g. a pointer to
2354 if (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_STRUCT
)
2356 *valp
= search_struct_field (name
, obj
, 0,
2357 check_typedef (value_type (obj
)), 0);
2365 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2367 &basetype
, &boffset
);
2368 if (!fns_ptr
|| !num_fns
)
2369 error (_("Couldn't find method %s%s%s"),
2371 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2373 /* If we are dealing with stub method types, they should have
2374 been resolved by find_method_list via
2375 value_find_oload_method_list above. */
2376 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2377 oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
2379 oload_syms
, &oload_champ_bv
);
2383 const char *qualified_name
= SYMBOL_NATURAL_NAME (fsym
);
2385 /* If we have a function with a C++ name, try to extract just
2386 the function part. Do not try this for non-functions (e.g.
2387 function pointers). */
2389 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym
))) == TYPE_CODE_FUNC
)
2391 func_name
= cp_func_name (qualified_name
);
2393 /* If cp_func_name did not remove anything, the name of the
2394 symbol did not include scope or argument types - it was
2395 probably a C-style function. */
2396 if (func_name
&& strcmp (func_name
, qualified_name
) == 0)
2403 /* If there was no C++ name, this must be a C-style function or
2404 not a function at all. Just return the same symbol. Do the
2405 same if cp_func_name fails for some reason. */
2406 if (func_name
== NULL
)
2412 old_cleanups
= make_cleanup (xfree
, func_name
);
2413 make_cleanup (xfree
, oload_syms
);
2414 make_cleanup (xfree
, oload_champ_bv
);
2416 oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
2423 /* Check how bad the best match is. */
2426 classify_oload_match (oload_champ_bv
, nargs
,
2427 oload_method_static (method
, fns_ptr
,
2430 if (match_quality
== INCOMPATIBLE
)
2433 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2435 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2438 error (_("Cannot resolve function %s to any overloaded instance"),
2441 else if (match_quality
== NON_STANDARD
)
2444 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2446 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2449 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2455 if (staticp
!= NULL
)
2456 *staticp
= oload_method_static (method
, fns_ptr
, oload_champ
);
2457 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2458 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
,
2461 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
,
2466 *symp
= oload_syms
[oload_champ
];
2471 struct type
*temp_type
= check_typedef (value_type (temp
));
2472 struct type
*obj_type
= check_typedef (value_type (*objp
));
2473 if (TYPE_CODE (temp_type
) != TYPE_CODE_PTR
2474 && (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
2475 || TYPE_CODE (obj_type
) == TYPE_CODE_REF
))
2477 temp
= value_addr (temp
);
2481 if (old_cleanups
!= NULL
)
2482 do_cleanups (old_cleanups
);
2484 switch (match_quality
)
2490 default: /* STANDARD */
2495 /* Find the best overload match, searching for FUNC_NAME in namespaces
2496 contained in QUALIFIED_NAME until it either finds a good match or
2497 runs out of namespaces. It stores the overloaded functions in
2498 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2499 calling function is responsible for freeing *OLOAD_SYMS and
2503 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2504 const char *func_name
,
2505 const char *qualified_name
,
2506 struct symbol
***oload_syms
,
2507 struct badness_vector
**oload_champ_bv
)
2511 find_oload_champ_namespace_loop (arg_types
, nargs
,
2514 oload_syms
, oload_champ_bv
,
2520 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2521 how deep we've looked for namespaces, and the champ is stored in
2522 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2525 It is the caller's responsibility to free *OLOAD_SYMS and
2529 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2530 const char *func_name
,
2531 const char *qualified_name
,
2533 struct symbol
***oload_syms
,
2534 struct badness_vector
**oload_champ_bv
,
2537 int next_namespace_len
= namespace_len
;
2538 int searched_deeper
= 0;
2540 struct cleanup
*old_cleanups
;
2541 int new_oload_champ
;
2542 struct symbol
**new_oload_syms
;
2543 struct badness_vector
*new_oload_champ_bv
;
2544 char *new_namespace
;
2546 if (next_namespace_len
!= 0)
2548 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2549 next_namespace_len
+= 2;
2551 next_namespace_len
+=
2552 cp_find_first_component (qualified_name
+ next_namespace_len
);
2554 /* Initialize these to values that can safely be xfree'd. */
2556 *oload_champ_bv
= NULL
;
2558 /* First, see if we have a deeper namespace we can search in.
2559 If we get a good match there, use it. */
2561 if (qualified_name
[next_namespace_len
] == ':')
2563 searched_deeper
= 1;
2565 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2566 func_name
, qualified_name
,
2568 oload_syms
, oload_champ_bv
,
2575 /* If we reach here, either we're in the deepest namespace or we
2576 didn't find a good match in a deeper namespace. But, in the
2577 latter case, we still have a bad match in a deeper namespace;
2578 note that we might not find any match at all in the current
2579 namespace. (There's always a match in the deepest namespace,
2580 because this overload mechanism only gets called if there's a
2581 function symbol to start off with.) */
2583 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2584 old_cleanups
= make_cleanup (xfree
, *oload_champ_bv
);
2585 new_namespace
= alloca (namespace_len
+ 1);
2586 strncpy (new_namespace
, qualified_name
, namespace_len
);
2587 new_namespace
[namespace_len
] = '\0';
2588 new_oload_syms
= make_symbol_overload_list (func_name
,
2590 while (new_oload_syms
[num_fns
])
2593 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2594 NULL
, new_oload_syms
,
2595 &new_oload_champ_bv
);
2597 /* Case 1: We found a good match. Free earlier matches (if any),
2598 and return it. Case 2: We didn't find a good match, but we're
2599 not the deepest function. Then go with the bad match that the
2600 deeper function found. Case 3: We found a bad match, and we're
2601 the deepest function. Then return what we found, even though
2602 it's a bad match. */
2604 if (new_oload_champ
!= -1
2605 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2607 *oload_syms
= new_oload_syms
;
2608 *oload_champ
= new_oload_champ
;
2609 *oload_champ_bv
= new_oload_champ_bv
;
2610 do_cleanups (old_cleanups
);
2613 else if (searched_deeper
)
2615 xfree (new_oload_syms
);
2616 xfree (new_oload_champ_bv
);
2617 discard_cleanups (old_cleanups
);
2622 gdb_assert (new_oload_champ
!= -1);
2623 *oload_syms
= new_oload_syms
;
2624 *oload_champ
= new_oload_champ
;
2625 *oload_champ_bv
= new_oload_champ_bv
;
2626 discard_cleanups (old_cleanups
);
2631 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2632 the best match from among the overloaded methods or functions
2633 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2634 The number of methods/functions in the list is given by NUM_FNS.
2635 Return the index of the best match; store an indication of the
2636 quality of the match in OLOAD_CHAMP_BV.
2638 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2641 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2642 int num_fns
, struct fn_field
*fns_ptr
,
2643 struct symbol
**oload_syms
,
2644 struct badness_vector
**oload_champ_bv
)
2647 /* A measure of how good an overloaded instance is. */
2648 struct badness_vector
*bv
;
2649 /* Index of best overloaded function. */
2650 int oload_champ
= -1;
2651 /* Current ambiguity state for overload resolution. */
2652 int oload_ambiguous
= 0;
2653 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2655 *oload_champ_bv
= NULL
;
2657 /* Consider each candidate in turn. */
2658 for (ix
= 0; ix
< num_fns
; ix
++)
2661 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2663 struct type
**parm_types
;
2667 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2671 /* If it's not a method, this is the proper place. */
2672 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2675 /* Prepare array of parameter types. */
2676 parm_types
= (struct type
**)
2677 xmalloc (nparms
* (sizeof (struct type
*)));
2678 for (jj
= 0; jj
< nparms
; jj
++)
2679 parm_types
[jj
] = (method
2680 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2681 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2684 /* Compare parameter types to supplied argument types. Skip
2685 THIS for static methods. */
2686 bv
= rank_function (parm_types
, nparms
,
2687 arg_types
+ static_offset
,
2688 nargs
- static_offset
);
2690 if (!*oload_champ_bv
)
2692 *oload_champ_bv
= bv
;
2695 else /* See whether current candidate is better or worse than
2697 switch (compare_badness (bv
, *oload_champ_bv
))
2699 case 0: /* Top two contenders are equally good. */
2700 oload_ambiguous
= 1;
2702 case 1: /* Incomparable top contenders. */
2703 oload_ambiguous
= 2;
2705 case 2: /* New champion, record details. */
2706 *oload_champ_bv
= bv
;
2707 oload_ambiguous
= 0;
2718 fprintf_filtered (gdb_stderr
,
2719 "Overloaded method instance %s, # of parms %d\n",
2720 fns_ptr
[ix
].physname
, nparms
);
2722 fprintf_filtered (gdb_stderr
,
2723 "Overloaded function instance %s # of parms %d\n",
2724 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
2726 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2727 fprintf_filtered (gdb_stderr
,
2728 "...Badness @ %d : %d\n",
2730 fprintf_filtered (gdb_stderr
,
2731 "Overload resolution champion is %d, ambiguous? %d\n",
2732 oload_champ
, oload_ambiguous
);
2739 /* Return 1 if we're looking at a static method, 0 if we're looking at
2740 a non-static method or a function that isn't a method. */
2743 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
2745 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
2751 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2753 static enum oload_classification
2754 classify_oload_match (struct badness_vector
*oload_champ_bv
,
2760 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2762 if (oload_champ_bv
->rank
[ix
] >= 100)
2763 return INCOMPATIBLE
; /* Truly mismatched types. */
2764 else if (oload_champ_bv
->rank
[ix
] >= 10)
2765 return NON_STANDARD
; /* Non-standard type conversions
2769 return STANDARD
; /* Only standard conversions needed. */
2772 /* C++: return 1 is NAME is a legitimate name for the destructor of
2773 type TYPE. If TYPE does not have a destructor, or if NAME is
2774 inappropriate for TYPE, an error is signaled. */
2776 destructor_name_p (const char *name
, const struct type
*type
)
2780 char *dname
= type_name_no_tag (type
);
2781 char *cp
= strchr (dname
, '<');
2784 /* Do not compare the template part for template classes. */
2786 len
= strlen (dname
);
2789 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
2790 error (_("name of destructor must equal name of class"));
2797 /* Given TYPE, a structure/union,
2798 return 1 if the component named NAME from the ultimate target
2799 structure/union is defined, otherwise, return 0. */
2802 check_field (struct type
*type
, const char *name
)
2806 /* The type may be a stub. */
2807 CHECK_TYPEDEF (type
);
2809 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2811 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2812 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2816 /* C++: If it was not found as a data field, then try to return it
2817 as a pointer to a method. */
2819 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2821 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2825 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2826 if (check_field (TYPE_BASECLASS (type
, i
), name
))
2832 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2833 return the appropriate member (or the address of the member, if
2834 WANT_ADDRESS). This function is used to resolve user expressions
2835 of the form "DOMAIN::NAME". For more details on what happens, see
2836 the comment before value_struct_elt_for_reference. */
2839 value_aggregate_elt (struct type
*curtype
, char *name
,
2840 struct type
*expect_type
, int want_address
,
2843 switch (TYPE_CODE (curtype
))
2845 case TYPE_CODE_STRUCT
:
2846 case TYPE_CODE_UNION
:
2847 return value_struct_elt_for_reference (curtype
, 0, curtype
,
2849 want_address
, noside
);
2850 case TYPE_CODE_NAMESPACE
:
2851 return value_namespace_elt (curtype
, name
,
2852 want_address
, noside
);
2854 internal_error (__FILE__
, __LINE__
,
2855 _("non-aggregate type in value_aggregate_elt"));
2859 /* Compares the two method/function types T1 and T2 for "equality"
2860 with respect to the the methods' parameters. If the types of the
2861 two parameter lists are the same, returns 1; 0 otherwise. This
2862 comparison may ignore any artificial parameters in T1 if
2863 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
2864 the first artificial parameter in T1, assumed to be a 'this' pointer.
2866 The type T2 is expected to have come from make_params (in eval.c). */
2869 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
2873 if (TYPE_FIELD_ARTIFICIAL (t1
, 0))
2876 /* If skipping artificial fields, find the first real field
2878 if (skip_artificial
)
2880 while (start
< TYPE_NFIELDS (t1
)
2881 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
2885 /* Now compare parameters */
2887 /* Special case: a method taking void. T1 will contain no
2888 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
2889 if ((TYPE_NFIELDS (t1
) - start
) == 0 && TYPE_NFIELDS (t2
) == 1
2890 && TYPE_CODE (TYPE_FIELD_TYPE (t2
, 0)) == TYPE_CODE_VOID
)
2893 if ((TYPE_NFIELDS (t1
) - start
) == TYPE_NFIELDS (t2
))
2896 for (i
= 0; i
< TYPE_NFIELDS (t2
); ++i
)
2898 if (rank_one_type (TYPE_FIELD_TYPE (t1
, start
+ i
),
2899 TYPE_FIELD_TYPE (t2
, i
))
2910 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2911 return the address of this member as a "pointer to member" type.
2912 If INTYPE is non-null, then it will be the type of the member we
2913 are looking for. This will help us resolve "pointers to member
2914 functions". This function is used to resolve user expressions of
2915 the form "DOMAIN::NAME". */
2917 static struct value
*
2918 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2919 struct type
*curtype
, char *name
,
2920 struct type
*intype
,
2924 struct type
*t
= curtype
;
2926 struct value
*v
, *result
;
2928 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2929 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2930 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2932 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2934 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2936 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2938 if (field_is_static (&TYPE_FIELD (t
, i
)))
2940 v
= value_static_field (t
, i
);
2942 error (_("static field %s has been optimized out"),
2948 if (TYPE_FIELD_PACKED (t
, i
))
2949 error (_("pointers to bitfield members not allowed"));
2952 return value_from_longest
2953 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
2954 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2955 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2956 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
2958 error (_("Cannot reference non-static field \"%s\""), name
);
2962 /* C++: If it was not found as a data field, then try to return it
2963 as a pointer to a method. */
2965 /* Perform all necessary dereferencing. */
2966 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2967 intype
= TYPE_TARGET_TYPE (intype
);
2969 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2971 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2972 char dem_opname
[64];
2974 if (strncmp (t_field_name
, "__", 2) == 0
2975 || strncmp (t_field_name
, "op", 2) == 0
2976 || strncmp (t_field_name
, "type", 4) == 0)
2978 if (cplus_demangle_opname (t_field_name
,
2979 dem_opname
, DMGL_ANSI
))
2980 t_field_name
= dem_opname
;
2981 else if (cplus_demangle_opname (t_field_name
,
2983 t_field_name
= dem_opname
;
2985 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2988 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2989 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2991 check_stub_method_group (t
, i
);
2995 for (j
= 0; j
< len
; ++j
)
2997 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
2998 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 1))
3003 error (_("no member function matches that type instantiation"));
3010 for (ii
= 0; ii
< TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3013 /* Skip artificial methods. This is necessary if,
3014 for example, the user wants to "print
3015 subclass::subclass" with only one user-defined
3016 constructor. There is no ambiguity in this
3018 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3021 /* Desired method is ambiguous if more than one
3022 method is defined. */
3024 error (_("non-unique member `%s' requires type instantiation"), name
);
3030 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3033 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3039 return value_addr (read_var_value (s
, 0));
3041 return read_var_value (s
, 0);
3044 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3048 result
= allocate_value
3049 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3050 cplus_make_method_ptr (value_type (result
),
3051 value_contents_writeable (result
),
3052 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3054 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3055 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3057 error (_("Cannot reference virtual member function \"%s\""),
3063 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3068 v
= read_var_value (s
, 0);
3073 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3074 cplus_make_method_ptr (value_type (result
),
3075 value_contents_writeable (result
),
3076 value_address (v
), 0);
3082 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3087 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3090 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3091 v
= value_struct_elt_for_reference (domain
,
3092 offset
+ base_offset
,
3093 TYPE_BASECLASS (t
, i
),
3095 want_address
, noside
);
3100 /* As a last chance, pretend that CURTYPE is a namespace, and look
3101 it up that way; this (frequently) works for types nested inside
3104 return value_maybe_namespace_elt (curtype
, name
,
3105 want_address
, noside
);
3108 /* C++: Return the member NAME of the namespace given by the type
3111 static struct value
*
3112 value_namespace_elt (const struct type
*curtype
,
3113 char *name
, int want_address
,
3116 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3121 error (_("No symbol \"%s\" in namespace \"%s\"."),
3122 name
, TYPE_TAG_NAME (curtype
));
3127 /* A helper function used by value_namespace_elt and
3128 value_struct_elt_for_reference. It looks up NAME inside the
3129 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3130 is a class and NAME refers to a type in CURTYPE itself (as opposed
3131 to, say, some base class of CURTYPE). */
3133 static struct value
*
3134 value_maybe_namespace_elt (const struct type
*curtype
,
3135 char *name
, int want_address
,
3138 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
3140 struct value
*result
;
3142 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3143 get_selected_block (0),
3148 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3149 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
3150 result
= allocate_value (SYMBOL_TYPE (sym
));
3152 result
= value_of_variable (sym
, get_selected_block (0));
3154 if (result
&& want_address
)
3155 result
= value_addr (result
);
3160 /* Given a pointer value V, find the real (RTTI) type of the object it
3163 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3164 and refer to the values computed for the object pointed to. */
3167 value_rtti_target_type (struct value
*v
, int *full
,
3168 int *top
, int *using_enc
)
3170 struct value
*target
;
3172 target
= value_ind (v
);
3174 return value_rtti_type (target
, full
, top
, using_enc
);
3177 /* Given a value pointed to by ARGP, check its real run-time type, and
3178 if that is different from the enclosing type, create a new value
3179 using the real run-time type as the enclosing type (and of the same
3180 type as ARGP) and return it, with the embedded offset adjusted to
3181 be the correct offset to the enclosed object. RTYPE is the type,
3182 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3183 by value_rtti_type(). If these are available, they can be supplied
3184 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3185 NULL if they're not available. */
3188 value_full_object (struct value
*argp
,
3190 int xfull
, int xtop
,
3193 struct type
*real_type
;
3197 struct value
*new_val
;
3204 using_enc
= xusing_enc
;
3207 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3209 /* If no RTTI data, or if object is already complete, do nothing. */
3210 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3213 /* If we have the full object, but for some reason the enclosing
3214 type is wrong, set it. */
3215 /* pai: FIXME -- sounds iffy */
3218 argp
= value_change_enclosing_type (argp
, real_type
);
3222 /* Check if object is in memory */
3223 if (VALUE_LVAL (argp
) != lval_memory
)
3225 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
3226 TYPE_NAME (real_type
));
3231 /* All other cases -- retrieve the complete object. */
3232 /* Go back by the computed top_offset from the beginning of the
3233 object, adjusting for the embedded offset of argp if that's what
3234 value_rtti_type used for its computation. */
3235 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3236 (using_enc
? 0 : value_embedded_offset (argp
)));
3237 deprecated_set_value_type (new_val
, value_type (argp
));
3238 set_value_embedded_offset (new_val
, (using_enc
3239 ? top
+ value_embedded_offset (argp
)
3245 /* Return the value of the local variable, if one exists.
3246 Flag COMPLAIN signals an error if the request is made in an
3247 inappropriate context. */
3250 value_of_local (const char *name
, int complain
)
3252 struct symbol
*func
, *sym
;
3255 struct frame_info
*frame
;
3258 frame
= get_selected_frame (_("no frame selected"));
3261 frame
= deprecated_safe_get_selected_frame ();
3266 func
= get_frame_function (frame
);
3270 error (_("no `%s' in nameless context"), name
);
3275 b
= SYMBOL_BLOCK_VALUE (func
);
3276 if (dict_empty (BLOCK_DICT (b
)))
3279 error (_("no args, no `%s'"), name
);
3284 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3285 symbol instead of the LOC_ARG one (if both exist). */
3286 sym
= lookup_block_symbol (b
, name
, VAR_DOMAIN
);
3290 error (_("current stack frame does not contain a variable named `%s'"),
3296 ret
= read_var_value (sym
, frame
);
3297 if (ret
== 0 && complain
)
3298 error (_("`%s' argument unreadable"), name
);
3302 /* C++/Objective-C: return the value of the class instance variable,
3303 if one exists. Flag COMPLAIN signals an error if the request is
3304 made in an inappropriate context. */
3307 value_of_this (int complain
)
3309 if (!current_language
->la_name_of_this
)
3311 return value_of_local (current_language
->la_name_of_this
, complain
);
3314 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3315 elements long, starting at LOWBOUND. The result has the same lower
3316 bound as the original ARRAY. */
3319 value_slice (struct value
*array
, int lowbound
, int length
)
3321 struct type
*slice_range_type
, *slice_type
, *range_type
;
3322 LONGEST lowerbound
, upperbound
;
3323 struct value
*slice
;
3324 struct type
*array_type
;
3326 array_type
= check_typedef (value_type (array
));
3327 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3328 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3329 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3330 error (_("cannot take slice of non-array"));
3332 range_type
= TYPE_INDEX_TYPE (array_type
);
3333 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3334 error (_("slice from bad array or bitstring"));
3336 if (lowbound
< lowerbound
|| length
< 0
3337 || lowbound
+ length
- 1 > upperbound
)
3338 error (_("slice out of range"));
3340 /* FIXME-type-allocation: need a way to free this type when we are
3342 slice_range_type
= create_range_type ((struct type
*) NULL
,
3343 TYPE_TARGET_TYPE (range_type
),
3345 lowbound
+ length
- 1);
3346 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3350 slice_type
= create_set_type ((struct type
*) NULL
,
3352 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3353 slice
= value_zero (slice_type
, not_lval
);
3355 for (i
= 0; i
< length
; i
++)
3357 int element
= value_bit_index (array_type
,
3358 value_contents (array
),
3361 error (_("internal error accessing bitstring"));
3362 else if (element
> 0)
3364 int j
= i
% TARGET_CHAR_BIT
;
3365 if (gdbarch_bits_big_endian (get_type_arch (array_type
)))
3366 j
= TARGET_CHAR_BIT
- 1 - j
;
3367 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3370 /* We should set the address, bitssize, and bitspos, so the
3371 slice can be used on the LHS, but that may require extensions
3372 to value_assign. For now, just leave as a non_lval.
3377 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3379 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3381 slice_type
= create_array_type ((struct type
*) NULL
,
3384 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3386 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3387 slice
= allocate_value_lazy (slice_type
);
3390 slice
= allocate_value (slice_type
);
3391 memcpy (value_contents_writeable (slice
),
3392 value_contents (array
) + offset
,
3393 TYPE_LENGTH (slice_type
));
3396 set_value_component_location (slice
, array
);
3397 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
3398 set_value_offset (slice
, value_offset (array
) + offset
);
3403 /* Create a value for a FORTRAN complex number. Currently most of the
3404 time values are coerced to COMPLEX*16 (i.e. a complex number
3405 composed of 2 doubles. This really should be a smarter routine
3406 that figures out precision inteligently as opposed to assuming
3407 doubles. FIXME: fmb */
3410 value_literal_complex (struct value
*arg1
,
3415 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3417 val
= allocate_value (type
);
3418 arg1
= value_cast (real_type
, arg1
);
3419 arg2
= value_cast (real_type
, arg2
);
3421 memcpy (value_contents_raw (val
),
3422 value_contents (arg1
), TYPE_LENGTH (real_type
));
3423 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3424 value_contents (arg2
), TYPE_LENGTH (real_type
));
3428 /* Cast a value into the appropriate complex data type. */
3430 static struct value
*
3431 cast_into_complex (struct type
*type
, struct value
*val
)
3433 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3435 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3437 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3438 struct value
*re_val
= allocate_value (val_real_type
);
3439 struct value
*im_val
= allocate_value (val_real_type
);
3441 memcpy (value_contents_raw (re_val
),
3442 value_contents (val
), TYPE_LENGTH (val_real_type
));
3443 memcpy (value_contents_raw (im_val
),
3444 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3445 TYPE_LENGTH (val_real_type
));
3447 return value_literal_complex (re_val
, im_val
, type
);
3449 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3450 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3451 return value_literal_complex (val
,
3452 value_zero (real_type
, not_lval
),
3455 error (_("cannot cast non-number to complex"));
3459 _initialize_valops (void)
3461 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3462 &overload_resolution
, _("\
3463 Set overload resolution in evaluating C++ functions."), _("\
3464 Show overload resolution in evaluating C++ functions."),
3466 show_overload_resolution
,
3467 &setlist
, &showlist
);
3468 overload_resolution
= 1;