1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "dictionary.h"
36 #include "cp-support.h"
38 #include "user-regs.h"
39 #include "tracepoint.h"
41 #include "gdb_string.h"
42 #include "gdb_assert.h"
43 #include "cp-support.h"
47 #include "exceptions.h"
49 extern int overload_debug
;
50 /* Local functions. */
52 static int typecmp (int staticp
, int varargs
, int nargs
,
53 struct field t1
[], struct value
*t2
[]);
55 static struct value
*search_struct_field (const char *, struct value
*,
56 int, struct type
*, int);
58 static struct value
*search_struct_method (const char *, struct value
**,
60 int, int *, struct type
*);
62 static int find_oload_champ_namespace (struct value
**, int,
63 const char *, const char *,
65 struct badness_vector
**,
69 int find_oload_champ_namespace_loop (struct value
**, int,
70 const char *, const char *,
71 int, struct symbol
***,
72 struct badness_vector
**, int *,
75 static int find_oload_champ (struct value
**, int, int, int,
76 struct fn_field
*, struct symbol
**,
77 struct badness_vector
**);
79 static int oload_method_static (int, struct fn_field
*, int);
81 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
84 oload_classification
classify_oload_match (struct badness_vector
*,
87 static struct value
*value_struct_elt_for_reference (struct type
*,
93 static struct value
*value_namespace_elt (const struct type
*,
94 char *, int , enum noside
);
96 static struct value
*value_maybe_namespace_elt (const struct type
*,
100 static CORE_ADDR
allocate_space_in_inferior (int);
102 static struct value
*cast_into_complex (struct type
*, struct value
*);
104 static struct fn_field
*find_method_list (struct value
**, const char *,
105 int, struct type
*, int *,
106 struct type
**, int *);
108 void _initialize_valops (void);
111 /* Flag for whether we want to abandon failed expression evals by
114 static int auto_abandon
= 0;
117 int overload_resolution
= 0;
119 show_overload_resolution (struct ui_file
*file
, int from_tty
,
120 struct cmd_list_element
*c
,
123 fprintf_filtered (file
, _("Overload resolution in evaluating "
124 "C++ functions is %s.\n"),
128 /* Find the address of function name NAME in the inferior. If OBJF_P
129 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
133 find_function_in_inferior (const char *name
, struct objfile
**objf_p
)
137 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
140 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
142 error (_("\"%s\" exists in this program but is not a function."),
147 *objf_p
= SYMBOL_SYMTAB (sym
)->objfile
;
149 return value_of_variable (sym
, NULL
);
153 struct minimal_symbol
*msymbol
=
154 lookup_minimal_symbol (name
, NULL
, NULL
);
158 struct objfile
*objfile
= msymbol_objfile (msymbol
);
159 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
163 type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_char
);
164 type
= lookup_function_type (type
);
165 type
= lookup_pointer_type (type
);
166 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
171 return value_from_pointer (type
, maddr
);
175 if (!target_has_execution
)
176 error (_("evaluation of this expression "
177 "requires the target program to be active"));
179 error (_("evaluation of this expression requires the "
180 "program to have a function \"%s\"."),
186 /* Allocate NBYTES of space in the inferior using the inferior's
187 malloc and return a value that is a pointer to the allocated
191 value_allocate_space_in_inferior (int len
)
193 struct objfile
*objf
;
194 struct value
*val
= find_function_in_inferior ("malloc", &objf
);
195 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
196 struct value
*blocklen
;
198 blocklen
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, len
);
199 val
= call_function_by_hand (val
, 1, &blocklen
);
200 if (value_logical_not (val
))
202 if (!target_has_execution
)
203 error (_("No memory available to program now: "
204 "you need to start the target first"));
206 error (_("No memory available to program: call to malloc failed"));
212 allocate_space_in_inferior (int len
)
214 return value_as_long (value_allocate_space_in_inferior (len
));
217 /* Cast struct value VAL to type TYPE and return as a value.
218 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
219 for this to work. Typedef to one of the codes is permitted.
220 Returns NULL if the cast is neither an upcast nor a downcast. */
222 static struct value
*
223 value_cast_structs (struct type
*type
, struct value
*v2
)
229 gdb_assert (type
!= NULL
&& v2
!= NULL
);
231 t1
= check_typedef (type
);
232 t2
= check_typedef (value_type (v2
));
234 /* Check preconditions. */
235 gdb_assert ((TYPE_CODE (t1
) == TYPE_CODE_STRUCT
236 || TYPE_CODE (t1
) == TYPE_CODE_UNION
)
237 && !!"Precondition is that type is of STRUCT or UNION kind.");
238 gdb_assert ((TYPE_CODE (t2
) == TYPE_CODE_STRUCT
239 || TYPE_CODE (t2
) == TYPE_CODE_UNION
)
240 && !!"Precondition is that value is of STRUCT or UNION kind");
242 if (TYPE_NAME (t1
) != NULL
243 && TYPE_NAME (t2
) != NULL
244 && !strcmp (TYPE_NAME (t1
), TYPE_NAME (t2
)))
247 /* Upcasting: look in the type of the source to see if it contains the
248 type of the target as a superclass. If so, we'll need to
249 offset the pointer rather than just change its type. */
250 if (TYPE_NAME (t1
) != NULL
)
252 v
= search_struct_field (type_name_no_tag (t1
),
258 /* Downcasting: look in the type of the target to see if it contains the
259 type of the source as a superclass. If so, we'll need to
260 offset the pointer rather than just change its type. */
261 if (TYPE_NAME (t2
) != NULL
)
263 /* Try downcasting using the run-time type of the value. */
264 int full
, top
, using_enc
;
265 struct type
*real_type
;
267 real_type
= value_rtti_type (v2
, &full
, &top
, &using_enc
);
270 v
= value_full_object (v2
, real_type
, full
, top
, using_enc
);
271 v
= value_at_lazy (real_type
, value_address (v
));
273 /* We might be trying to cast to the outermost enclosing
274 type, in which case search_struct_field won't work. */
275 if (TYPE_NAME (real_type
) != NULL
276 && !strcmp (TYPE_NAME (real_type
), TYPE_NAME (t1
)))
279 v
= search_struct_field (type_name_no_tag (t2
), v
, 0, real_type
, 1);
284 /* Try downcasting using information from the destination type
285 T2. This wouldn't work properly for classes with virtual
286 bases, but those were handled above. */
287 v
= search_struct_field (type_name_no_tag (t2
),
288 value_zero (t1
, not_lval
), 0, t1
, 1);
291 /* Downcasting is possible (t1 is superclass of v2). */
292 CORE_ADDR addr2
= value_address (v2
);
294 addr2
-= value_address (v
) + value_embedded_offset (v
);
295 return value_at (type
, addr2
);
302 /* Cast one pointer or reference type to another. Both TYPE and
303 the type of ARG2 should be pointer types, or else both should be
304 reference types. Returns the new pointer or reference. */
307 value_cast_pointers (struct type
*type
, struct value
*arg2
)
309 struct type
*type1
= check_typedef (type
);
310 struct type
*type2
= check_typedef (value_type (arg2
));
311 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type1
));
312 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
314 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
315 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
316 && !value_logical_not (arg2
))
320 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
321 v2
= coerce_ref (arg2
);
323 v2
= value_ind (arg2
);
324 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
)))
325 == TYPE_CODE_STRUCT
&& !!"Why did coercion fail?");
326 v2
= value_cast_structs (t1
, v2
);
327 /* At this point we have what we can have, un-dereference if needed. */
330 struct value
*v
= value_addr (v2
);
332 deprecated_set_value_type (v
, type
);
337 /* No superclass found, just change the pointer type. */
338 arg2
= value_copy (arg2
);
339 deprecated_set_value_type (arg2
, type
);
340 set_value_enclosing_type (arg2
, type
);
341 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
345 /* Cast value ARG2 to type TYPE and return as a value.
346 More general than a C cast: accepts any two types of the same length,
347 and if ARG2 is an lvalue it can be cast into anything at all. */
348 /* In C++, casts may change pointer or object representations. */
351 value_cast (struct type
*type
, struct value
*arg2
)
353 enum type_code code1
;
354 enum type_code code2
;
358 int convert_to_boolean
= 0;
360 if (value_type (arg2
) == type
)
363 code1
= TYPE_CODE (check_typedef (type
));
365 /* Check if we are casting struct reference to struct reference. */
366 if (code1
== TYPE_CODE_REF
)
368 /* We dereference type; then we recurse and finally
369 we generate value of the given reference. Nothing wrong with
371 struct type
*t1
= check_typedef (type
);
372 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
373 struct value
*val
= value_cast (dereftype
, arg2
);
375 return value_ref (val
);
378 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
380 if (code2
== TYPE_CODE_REF
)
381 /* We deref the value and then do the cast. */
382 return value_cast (type
, coerce_ref (arg2
));
384 CHECK_TYPEDEF (type
);
385 code1
= TYPE_CODE (type
);
386 arg2
= coerce_ref (arg2
);
387 type2
= check_typedef (value_type (arg2
));
389 /* You can't cast to a reference type. See value_cast_pointers
391 gdb_assert (code1
!= TYPE_CODE_REF
);
393 /* A cast to an undetermined-length array_type, such as
394 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
395 where N is sizeof(OBJECT)/sizeof(TYPE). */
396 if (code1
== TYPE_CODE_ARRAY
)
398 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
399 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
401 if (element_length
> 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
403 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
404 int val_length
= TYPE_LENGTH (type2
);
405 LONGEST low_bound
, high_bound
, new_length
;
407 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
408 low_bound
= 0, high_bound
= 0;
409 new_length
= val_length
/ element_length
;
410 if (val_length
% element_length
!= 0)
411 warning (_("array element type size does not "
412 "divide object size in cast"));
413 /* FIXME-type-allocation: need a way to free this type when
414 we are done with it. */
415 range_type
= create_range_type ((struct type
*) NULL
,
416 TYPE_TARGET_TYPE (range_type
),
418 new_length
+ low_bound
- 1);
419 deprecated_set_value_type (arg2
,
420 create_array_type ((struct type
*) NULL
,
427 if (current_language
->c_style_arrays
428 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
429 && !TYPE_VECTOR (type2
))
430 arg2
= value_coerce_array (arg2
);
432 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
433 arg2
= value_coerce_function (arg2
);
435 type2
= check_typedef (value_type (arg2
));
436 code2
= TYPE_CODE (type2
);
438 if (code1
== TYPE_CODE_COMPLEX
)
439 return cast_into_complex (type
, arg2
);
440 if (code1
== TYPE_CODE_BOOL
)
442 code1
= TYPE_CODE_INT
;
443 convert_to_boolean
= 1;
445 if (code1
== TYPE_CODE_CHAR
)
446 code1
= TYPE_CODE_INT
;
447 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
448 code2
= TYPE_CODE_INT
;
450 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
451 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
452 || code2
== TYPE_CODE_RANGE
);
454 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
455 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
456 && TYPE_NAME (type
) != 0)
458 struct value
*v
= value_cast_structs (type
, arg2
);
464 if (code1
== TYPE_CODE_FLT
&& scalar
)
465 return value_from_double (type
, value_as_double (arg2
));
466 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
468 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
469 int dec_len
= TYPE_LENGTH (type
);
472 if (code2
== TYPE_CODE_FLT
)
473 decimal_from_floating (arg2
, dec
, dec_len
, byte_order
);
474 else if (code2
== TYPE_CODE_DECFLOAT
)
475 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
476 byte_order
, dec
, dec_len
, byte_order
);
478 /* The only option left is an integral type. */
479 decimal_from_integral (arg2
, dec
, dec_len
, byte_order
);
481 return value_from_decfloat (type
, dec
);
483 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
484 || code1
== TYPE_CODE_RANGE
)
485 && (scalar
|| code2
== TYPE_CODE_PTR
486 || code2
== TYPE_CODE_MEMBERPTR
))
490 /* When we cast pointers to integers, we mustn't use
491 gdbarch_pointer_to_address to find the address the pointer
492 represents, as value_as_long would. GDB should evaluate
493 expressions just as the compiler would --- and the compiler
494 sees a cast as a simple reinterpretation of the pointer's
496 if (code2
== TYPE_CODE_PTR
)
497 longest
= extract_unsigned_integer
498 (value_contents (arg2
), TYPE_LENGTH (type2
),
499 gdbarch_byte_order (get_type_arch (type2
)));
501 longest
= value_as_long (arg2
);
502 return value_from_longest (type
, convert_to_boolean
?
503 (LONGEST
) (longest
? 1 : 0) : longest
);
505 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
506 || code2
== TYPE_CODE_ENUM
507 || code2
== TYPE_CODE_RANGE
))
509 /* TYPE_LENGTH (type) is the length of a pointer, but we really
510 want the length of an address! -- we are really dealing with
511 addresses (i.e., gdb representations) not pointers (i.e.,
512 target representations) here.
514 This allows things like "print *(int *)0x01000234" to work
515 without printing a misleading message -- which would
516 otherwise occur when dealing with a target having two byte
517 pointers and four byte addresses. */
519 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
520 LONGEST longest
= value_as_long (arg2
);
522 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
524 if (longest
>= ((LONGEST
) 1 << addr_bit
)
525 || longest
<= -((LONGEST
) 1 << addr_bit
))
526 warning (_("value truncated"));
528 return value_from_longest (type
, longest
);
530 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
531 && value_as_long (arg2
) == 0)
533 struct value
*result
= allocate_value (type
);
535 cplus_make_method_ptr (type
, value_contents_writeable (result
), 0, 0);
538 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
539 && value_as_long (arg2
) == 0)
541 /* The Itanium C++ ABI represents NULL pointers to members as
542 minus one, instead of biasing the normal case. */
543 return value_from_longest (type
, -1);
545 else if (code1
== TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
) && scalar
)
547 /* Widen the scalar to a vector. */
550 LONGEST low_bound
, high_bound
;
553 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
554 error (_("Could not determine the vector bounds"));
556 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
557 arg2
= value_cast (eltype
, arg2
);
558 val
= allocate_value (type
);
560 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
562 /* Duplicate the contents of arg2 into the destination vector. */
563 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
564 value_contents_all (arg2
), TYPE_LENGTH (eltype
));
568 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
570 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
571 return value_cast_pointers (type
, arg2
);
573 arg2
= value_copy (arg2
);
574 deprecated_set_value_type (arg2
, type
);
575 set_value_enclosing_type (arg2
, type
);
576 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
579 else if (VALUE_LVAL (arg2
) == lval_memory
)
580 return value_at_lazy (type
, value_address (arg2
));
581 else if (code1
== TYPE_CODE_VOID
)
583 return value_zero (type
, not_lval
);
587 error (_("Invalid cast."));
592 /* The C++ reinterpret_cast operator. */
595 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
597 struct value
*result
;
598 struct type
*real_type
= check_typedef (type
);
599 struct type
*arg_type
, *dest_type
;
601 enum type_code dest_code
, arg_code
;
603 /* Do reference, function, and array conversion. */
604 arg
= coerce_array (arg
);
606 /* Attempt to preserve the type the user asked for. */
609 /* If we are casting to a reference type, transform
610 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
611 if (TYPE_CODE (real_type
) == TYPE_CODE_REF
)
614 arg
= value_addr (arg
);
615 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
616 real_type
= lookup_pointer_type (real_type
);
619 arg_type
= value_type (arg
);
621 dest_code
= TYPE_CODE (real_type
);
622 arg_code
= TYPE_CODE (arg_type
);
624 /* We can convert pointer types, or any pointer type to int, or int
626 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
627 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
628 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
629 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
630 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
631 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
632 || (dest_code
== arg_code
633 && (dest_code
== TYPE_CODE_PTR
634 || dest_code
== TYPE_CODE_METHODPTR
635 || dest_code
== TYPE_CODE_MEMBERPTR
)))
636 result
= value_cast (dest_type
, arg
);
638 error (_("Invalid reinterpret_cast"));
641 result
= value_cast (type
, value_ref (value_ind (result
)));
646 /* A helper for value_dynamic_cast. This implements the first of two
647 runtime checks: we iterate over all the base classes of the value's
648 class which are equal to the desired class; if only one of these
649 holds the value, then it is the answer. */
652 dynamic_cast_check_1 (struct type
*desired_type
,
653 const gdb_byte
*valaddr
,
657 struct type
*search_type
,
659 struct type
*arg_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
)
666 int offset
= baseclass_offset (search_type
, i
, valaddr
, embedded_offset
,
669 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
671 if (address
+ embedded_offset
+ offset
>= arg_addr
672 && address
+ embedded_offset
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
676 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
677 address
+ embedded_offset
+ offset
);
681 result_count
+= dynamic_cast_check_1 (desired_type
,
683 embedded_offset
+ offset
,
685 TYPE_BASECLASS (search_type
, i
),
694 /* A helper for value_dynamic_cast. This implements the second of two
695 runtime checks: we look for a unique public sibling class of the
696 argument's declared class. */
699 dynamic_cast_check_2 (struct type
*desired_type
,
700 const gdb_byte
*valaddr
,
704 struct type
*search_type
,
705 struct value
**result
)
707 int i
, result_count
= 0;
709 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
713 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
716 offset
= baseclass_offset (search_type
, i
, valaddr
, embedded_offset
,
718 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
722 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
723 address
+ embedded_offset
+ offset
);
726 result_count
+= dynamic_cast_check_2 (desired_type
,
728 embedded_offset
+ offset
,
730 TYPE_BASECLASS (search_type
, i
),
737 /* The C++ dynamic_cast operator. */
740 value_dynamic_cast (struct type
*type
, struct value
*arg
)
742 int full
, top
, using_enc
;
743 struct type
*resolved_type
= check_typedef (type
);
744 struct type
*arg_type
= check_typedef (value_type (arg
));
745 struct type
*class_type
, *rtti_type
;
746 struct value
*result
, *tem
, *original_arg
= arg
;
748 int is_ref
= TYPE_CODE (resolved_type
) == TYPE_CODE_REF
;
750 if (TYPE_CODE (resolved_type
) != TYPE_CODE_PTR
751 && TYPE_CODE (resolved_type
) != TYPE_CODE_REF
)
752 error (_("Argument to dynamic_cast must be a pointer or reference type"));
753 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_VOID
754 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_CLASS
)
755 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
757 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
758 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
760 if (TYPE_CODE (arg_type
) != TYPE_CODE_PTR
761 && ! (TYPE_CODE (arg_type
) == TYPE_CODE_INT
762 && value_as_long (arg
) == 0))
763 error (_("Argument to dynamic_cast does not have pointer type"));
764 if (TYPE_CODE (arg_type
) == TYPE_CODE_PTR
)
766 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
767 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
768 error (_("Argument to dynamic_cast does "
769 "not have pointer to class type"));
772 /* Handle NULL pointers. */
773 if (value_as_long (arg
) == 0)
774 return value_zero (type
, not_lval
);
776 arg
= value_ind (arg
);
780 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
781 error (_("Argument to dynamic_cast does not have class type"));
784 /* If the classes are the same, just return the argument. */
785 if (class_types_same_p (class_type
, arg_type
))
786 return value_cast (type
, arg
);
788 /* If the target type is a unique base class of the argument's
789 declared type, just cast it. */
790 if (is_ancestor (class_type
, arg_type
))
792 if (is_unique_ancestor (class_type
, arg
))
793 return value_cast (type
, original_arg
);
794 error (_("Ambiguous dynamic_cast"));
797 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
799 error (_("Couldn't determine value's most derived type for dynamic_cast"));
801 /* Compute the most derived object's address. */
802 addr
= value_address (arg
);
810 addr
+= top
+ value_embedded_offset (arg
);
812 /* dynamic_cast<void *> means to return a pointer to the
813 most-derived object. */
814 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
815 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) == TYPE_CODE_VOID
)
816 return value_at_lazy (type
, addr
);
818 tem
= value_at (type
, addr
);
820 /* The first dynamic check specified in 5.2.7. */
821 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
823 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
826 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
827 value_contents_for_printing (tem
),
828 value_embedded_offset (tem
),
829 value_address (tem
), tem
,
833 return value_cast (type
,
834 is_ref
? value_ref (result
) : value_addr (result
));
837 /* The second dynamic check specified in 5.2.7. */
839 if (is_public_ancestor (arg_type
, rtti_type
)
840 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
841 value_contents_for_printing (tem
),
842 value_embedded_offset (tem
),
843 value_address (tem
), tem
,
844 rtti_type
, &result
) == 1)
845 return value_cast (type
,
846 is_ref
? value_ref (result
) : value_addr (result
));
848 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
849 return value_zero (type
, not_lval
);
851 error (_("dynamic_cast failed"));
854 /* Create a value of type TYPE that is zero, and return it. */
857 value_zero (struct type
*type
, enum lval_type lv
)
859 struct value
*val
= allocate_value (type
);
861 VALUE_LVAL (val
) = (lv
== lval_computed
? not_lval
: lv
);
865 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
868 value_one (struct type
*type
)
870 struct type
*type1
= check_typedef (type
);
873 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
875 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
878 decimal_from_string (v
, TYPE_LENGTH (type
), byte_order
, "1");
879 val
= value_from_decfloat (type
, v
);
881 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
883 val
= value_from_double (type
, (DOUBLEST
) 1);
885 else if (is_integral_type (type1
))
887 val
= value_from_longest (type
, (LONGEST
) 1);
889 else if (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
891 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type1
));
893 LONGEST low_bound
, high_bound
;
896 if (!get_array_bounds (type1
, &low_bound
, &high_bound
))
897 error (_("Could not determine the vector bounds"));
899 val
= allocate_value (type
);
900 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
902 tmp
= value_one (eltype
);
903 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
904 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
909 error (_("Not a numeric type."));
912 /* value_one result is never used for assignments to. */
913 gdb_assert (VALUE_LVAL (val
) == not_lval
);
918 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
920 static struct value
*
921 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
925 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
926 error (_("Attempt to dereference a generic pointer."));
928 val
= value_from_contents_and_address (type
, NULL
, addr
);
931 value_fetch_lazy (val
);
936 /* Return a value with type TYPE located at ADDR.
938 Call value_at only if the data needs to be fetched immediately;
939 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
940 value_at_lazy instead. value_at_lazy simply records the address of
941 the data and sets the lazy-evaluation-required flag. The lazy flag
942 is tested in the value_contents macro, which is used if and when
943 the contents are actually required.
945 Note: value_at does *NOT* handle embedded offsets; perform such
946 adjustments before or after calling it. */
949 value_at (struct type
*type
, CORE_ADDR addr
)
951 return get_value_at (type
, addr
, 0);
954 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
957 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
959 return get_value_at (type
, addr
, 1);
962 /* Called only from the value_contents and value_contents_all()
963 macros, if the current data for a variable needs to be loaded into
964 value_contents(VAL). Fetches the data from the user's process, and
965 clears the lazy flag to indicate that the data in the buffer is
968 If the value is zero-length, we avoid calling read_memory, which
969 would abort. We mark the value as fetched anyway -- all 0 bytes of
972 This function returns a value because it is used in the
973 value_contents macro as part of an expression, where a void would
974 not work. The value is ignored. */
977 value_fetch_lazy (struct value
*val
)
979 gdb_assert (value_lazy (val
));
980 allocate_value_contents (val
);
981 if (value_bitsize (val
))
983 /* To read a lazy bitfield, read the entire enclosing value. This
984 prevents reading the same block of (possibly volatile) memory once
985 per bitfield. It would be even better to read only the containing
986 word, but we have no way to record that just specific bits of a
987 value have been fetched. */
988 struct type
*type
= check_typedef (value_type (val
));
989 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
990 struct value
*parent
= value_parent (val
);
991 LONGEST offset
= value_offset (val
);
993 int length
= TYPE_LENGTH (type
);
995 if (!value_bits_valid (val
,
996 TARGET_CHAR_BIT
* offset
+ value_bitpos (val
),
997 value_bitsize (val
)))
998 error (_("value has been optimized out"));
1000 if (!unpack_value_bits_as_long (value_type (val
),
1001 value_contents_for_printing (parent
),
1004 value_bitsize (val
), parent
, &num
))
1005 mark_value_bytes_unavailable (val
,
1006 value_embedded_offset (val
),
1009 store_signed_integer (value_contents_raw (val
), length
,
1012 else if (VALUE_LVAL (val
) == lval_memory
)
1014 CORE_ADDR addr
= value_address (val
);
1015 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
1018 read_value_memory (val
, 0, value_stack (val
),
1019 addr
, value_contents_all_raw (val
), length
);
1021 else if (VALUE_LVAL (val
) == lval_register
)
1023 struct frame_info
*frame
;
1025 struct type
*type
= check_typedef (value_type (val
));
1026 struct value
*new_val
= val
, *mark
= value_mark ();
1028 /* Offsets are not supported here; lazy register values must
1029 refer to the entire register. */
1030 gdb_assert (value_offset (val
) == 0);
1032 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
1034 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
1035 regnum
= VALUE_REGNUM (new_val
);
1037 gdb_assert (frame
!= NULL
);
1039 /* Convertible register routines are used for multi-register
1040 values and for interpretation in different types
1041 (e.g. float or int from a double register). Lazy
1042 register values should have the register's natural type,
1043 so they do not apply. */
1044 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
1047 new_val
= get_frame_register_value (frame
, regnum
);
1050 /* If it's still lazy (for instance, a saved register on the
1051 stack), fetch it. */
1052 if (value_lazy (new_val
))
1053 value_fetch_lazy (new_val
);
1055 /* If the register was not saved, mark it optimized out. */
1056 if (value_optimized_out (new_val
))
1057 set_value_optimized_out (val
, 1);
1060 set_value_lazy (val
, 0);
1061 value_contents_copy (val
, value_embedded_offset (val
),
1062 new_val
, value_embedded_offset (new_val
),
1063 TYPE_LENGTH (type
));
1068 struct gdbarch
*gdbarch
;
1069 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1070 regnum
= VALUE_REGNUM (val
);
1071 gdbarch
= get_frame_arch (frame
);
1073 fprintf_unfiltered (gdb_stdlog
,
1074 "{ value_fetch_lazy "
1075 "(frame=%d,regnum=%d(%s),...) ",
1076 frame_relative_level (frame
), regnum
,
1077 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1079 fprintf_unfiltered (gdb_stdlog
, "->");
1080 if (value_optimized_out (new_val
))
1081 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1085 const gdb_byte
*buf
= value_contents (new_val
);
1087 if (VALUE_LVAL (new_val
) == lval_register
)
1088 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1089 VALUE_REGNUM (new_val
));
1090 else if (VALUE_LVAL (new_val
) == lval_memory
)
1091 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1093 value_address (new_val
)));
1095 fprintf_unfiltered (gdb_stdlog
, " computed");
1097 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1098 fprintf_unfiltered (gdb_stdlog
, "[");
1099 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1100 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1101 fprintf_unfiltered (gdb_stdlog
, "]");
1104 fprintf_unfiltered (gdb_stdlog
, " }\n");
1107 /* Dispose of the intermediate values. This prevents
1108 watchpoints from trying to watch the saved frame pointer. */
1109 value_free_to_mark (mark
);
1111 else if (VALUE_LVAL (val
) == lval_computed
1112 && value_computed_funcs (val
)->read
!= NULL
)
1113 value_computed_funcs (val
)->read (val
);
1114 else if (value_optimized_out (val
))
1115 /* Keep it optimized out. */;
1117 internal_error (__FILE__
, __LINE__
, _("Unexpected lazy value type."));
1119 set_value_lazy (val
, 0);
1124 read_value_memory (struct value
*val
, int embedded_offset
,
1125 int stack
, CORE_ADDR memaddr
,
1126 gdb_byte
*buffer
, size_t length
)
1130 VEC(mem_range_s
) *available_memory
;
1132 if (get_traceframe_number () < 0
1133 || !traceframe_available_memory (&available_memory
, memaddr
, length
))
1136 read_stack (memaddr
, buffer
, length
);
1138 read_memory (memaddr
, buffer
, length
);
1142 struct target_section_table
*table
;
1143 struct cleanup
*old_chain
;
1148 /* Fallback to reading from read-only sections. */
1149 table
= target_get_section_table (&exec_ops
);
1151 section_table_available_memory (available_memory
,
1154 table
->sections_end
);
1156 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
),
1159 normalize_mem_ranges (available_memory
);
1161 /* Mark which bytes are unavailable, and read those which
1167 VEC_iterate (mem_range_s
, available_memory
, i
, r
);
1170 if (mem_ranges_overlap (r
->start
, r
->length
,
1173 CORE_ADDR lo1
, hi1
, lo2
, hi2
;
1174 CORE_ADDR start
, end
;
1176 /* Get the intersection window. */
1178 hi1
= memaddr
+ length
;
1180 hi2
= r
->start
+ r
->length
;
1181 start
= max (lo1
, lo2
);
1182 end
= min (hi1
, hi2
);
1184 gdb_assert (end
- memaddr
<= length
);
1186 if (start
> unavail
)
1187 mark_value_bytes_unavailable (val
,
1189 + unavail
- memaddr
),
1193 read_memory (start
, buffer
+ start
- memaddr
, end
- start
);
1197 if (unavail
!= memaddr
+ length
)
1198 mark_value_bytes_unavailable (val
,
1199 embedded_offset
+ unavail
- memaddr
,
1200 (memaddr
+ length
) - unavail
);
1202 do_cleanups (old_chain
);
1207 /* Store the contents of FROMVAL into the location of TOVAL.
1208 Return a new value with the location of TOVAL and contents of FROMVAL. */
1211 value_assign (struct value
*toval
, struct value
*fromval
)
1215 struct frame_id old_frame
;
1217 if (!deprecated_value_modifiable (toval
))
1218 error (_("Left operand of assignment is not a modifiable lvalue."));
1220 toval
= coerce_ref (toval
);
1222 type
= value_type (toval
);
1223 if (VALUE_LVAL (toval
) != lval_internalvar
)
1224 fromval
= value_cast (type
, fromval
);
1227 /* Coerce arrays and functions to pointers, except for arrays
1228 which only live in GDB's storage. */
1229 if (!value_must_coerce_to_target (fromval
))
1230 fromval
= coerce_array (fromval
);
1233 CHECK_TYPEDEF (type
);
1235 /* Since modifying a register can trash the frame chain, and
1236 modifying memory can trash the frame cache, we save the old frame
1237 and then restore the new frame afterwards. */
1238 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1240 switch (VALUE_LVAL (toval
))
1242 case lval_internalvar
:
1243 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1244 return value_of_internalvar (get_type_arch (type
),
1245 VALUE_INTERNALVAR (toval
));
1247 case lval_internalvar_component
:
1248 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1249 value_offset (toval
),
1250 value_bitpos (toval
),
1251 value_bitsize (toval
),
1257 const gdb_byte
*dest_buffer
;
1258 CORE_ADDR changed_addr
;
1260 gdb_byte buffer
[sizeof (LONGEST
)];
1262 if (value_bitsize (toval
))
1264 struct value
*parent
= value_parent (toval
);
1266 changed_addr
= value_address (parent
) + value_offset (toval
);
1267 changed_len
= (value_bitpos (toval
)
1268 + value_bitsize (toval
)
1269 + HOST_CHAR_BIT
- 1)
1272 /* If we can read-modify-write exactly the size of the
1273 containing type (e.g. short or int) then do so. This
1274 is safer for volatile bitfields mapped to hardware
1276 if (changed_len
< TYPE_LENGTH (type
)
1277 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1278 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1279 changed_len
= TYPE_LENGTH (type
);
1281 if (changed_len
> (int) sizeof (LONGEST
))
1282 error (_("Can't handle bitfields which "
1283 "don't fit in a %d bit word."),
1284 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1286 read_memory (changed_addr
, buffer
, changed_len
);
1287 modify_field (type
, buffer
, value_as_long (fromval
),
1288 value_bitpos (toval
), value_bitsize (toval
));
1289 dest_buffer
= buffer
;
1293 changed_addr
= value_address (toval
);
1294 changed_len
= TYPE_LENGTH (type
);
1295 dest_buffer
= value_contents (fromval
);
1298 write_memory (changed_addr
, dest_buffer
, changed_len
);
1299 observer_notify_memory_changed (changed_addr
, changed_len
,
1306 struct frame_info
*frame
;
1307 struct gdbarch
*gdbarch
;
1310 /* Figure out which frame this is in currently. */
1311 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1312 value_reg
= VALUE_REGNUM (toval
);
1315 error (_("Value being assigned to is no longer active."));
1317 gdbarch
= get_frame_arch (frame
);
1318 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
), type
))
1320 /* If TOVAL is a special machine register requiring
1321 conversion of program values to a special raw
1323 gdbarch_value_to_register (gdbarch
, frame
,
1324 VALUE_REGNUM (toval
), type
,
1325 value_contents (fromval
));
1329 if (value_bitsize (toval
))
1331 struct value
*parent
= value_parent (toval
);
1332 int offset
= value_offset (parent
) + value_offset (toval
);
1334 gdb_byte buffer
[sizeof (LONGEST
)];
1337 changed_len
= (value_bitpos (toval
)
1338 + value_bitsize (toval
)
1339 + HOST_CHAR_BIT
- 1)
1342 if (changed_len
> (int) sizeof (LONGEST
))
1343 error (_("Can't handle bitfields which "
1344 "don't fit in a %d bit word."),
1345 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1347 if (!get_frame_register_bytes (frame
, value_reg
, offset
,
1348 changed_len
, buffer
,
1352 error (_("value has been optimized out"));
1354 throw_error (NOT_AVAILABLE_ERROR
,
1355 _("value is not available"));
1358 modify_field (type
, buffer
, value_as_long (fromval
),
1359 value_bitpos (toval
), value_bitsize (toval
));
1361 put_frame_register_bytes (frame
, value_reg
, offset
,
1362 changed_len
, buffer
);
1366 put_frame_register_bytes (frame
, value_reg
,
1367 value_offset (toval
),
1369 value_contents (fromval
));
1373 if (deprecated_register_changed_hook
)
1374 deprecated_register_changed_hook (-1);
1375 observer_notify_target_changed (¤t_target
);
1381 const struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1383 if (funcs
->write
!= NULL
)
1385 funcs
->write (toval
, fromval
);
1392 error (_("Left operand of assignment is not an lvalue."));
1395 /* Assigning to the stack pointer, frame pointer, and other
1396 (architecture and calling convention specific) registers may
1397 cause the frame cache to be out of date. Assigning to memory
1398 also can. We just do this on all assignments to registers or
1399 memory, for simplicity's sake; I doubt the slowdown matters. */
1400 switch (VALUE_LVAL (toval
))
1406 reinit_frame_cache ();
1408 /* Having destroyed the frame cache, restore the selected
1411 /* FIXME: cagney/2002-11-02: There has to be a better way of
1412 doing this. Instead of constantly saving/restoring the
1413 frame. Why not create a get_selected_frame() function that,
1414 having saved the selected frame's ID can automatically
1415 re-find the previously selected frame automatically. */
1418 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1429 /* If the field does not entirely fill a LONGEST, then zero the sign
1430 bits. If the field is signed, and is negative, then sign
1432 if ((value_bitsize (toval
) > 0)
1433 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1435 LONGEST fieldval
= value_as_long (fromval
);
1436 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1438 fieldval
&= valmask
;
1439 if (!TYPE_UNSIGNED (type
)
1440 && (fieldval
& (valmask
^ (valmask
>> 1))))
1441 fieldval
|= ~valmask
;
1443 fromval
= value_from_longest (type
, fieldval
);
1446 /* The return value is a copy of TOVAL so it shares its location
1447 information, but its contents are updated from FROMVAL. This
1448 implies the returned value is not lazy, even if TOVAL was. */
1449 val
= value_copy (toval
);
1450 set_value_lazy (val
, 0);
1451 memcpy (value_contents_raw (val
), value_contents (fromval
),
1452 TYPE_LENGTH (type
));
1454 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1455 in the case of pointer types. For object types, the enclosing type
1456 and embedded offset must *not* be copied: the target object refered
1457 to by TOVAL retains its original dynamic type after assignment. */
1458 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1460 set_value_enclosing_type (val
, value_enclosing_type (fromval
));
1461 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1467 /* Extend a value VAL to COUNT repetitions of its type. */
1470 value_repeat (struct value
*arg1
, int count
)
1474 if (VALUE_LVAL (arg1
) != lval_memory
)
1475 error (_("Only values in memory can be extended with '@'."));
1477 error (_("Invalid number %d of repetitions."), count
);
1479 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1481 VALUE_LVAL (val
) = lval_memory
;
1482 set_value_address (val
, value_address (arg1
));
1484 read_value_memory (val
, 0, value_stack (val
), value_address (val
),
1485 value_contents_all_raw (val
),
1486 TYPE_LENGTH (value_enclosing_type (val
)));
1492 value_of_variable (struct symbol
*var
, const struct block
*b
)
1494 struct frame_info
*frame
;
1496 if (!symbol_read_needs_frame (var
))
1499 frame
= get_selected_frame (_("No frame selected."));
1502 frame
= block_innermost_frame (b
);
1505 if (BLOCK_FUNCTION (b
) && !block_inlined_p (b
)
1506 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
1507 error (_("No frame is currently executing in block %s."),
1508 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
1510 error (_("No frame is currently executing in specified block"));
1514 return read_var_value (var
, frame
);
1518 address_of_variable (struct symbol
*var
, struct block
*b
)
1520 struct type
*type
= SYMBOL_TYPE (var
);
1523 /* Evaluate it first; if the result is a memory address, we're fine.
1524 Lazy evaluation pays off here. */
1526 val
= value_of_variable (var
, b
);
1528 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1529 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1531 CORE_ADDR addr
= value_address (val
);
1533 return value_from_pointer (lookup_pointer_type (type
), addr
);
1536 /* Not a memory address; check what the problem was. */
1537 switch (VALUE_LVAL (val
))
1541 struct frame_info
*frame
;
1542 const char *regname
;
1544 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1547 regname
= gdbarch_register_name (get_frame_arch (frame
),
1548 VALUE_REGNUM (val
));
1549 gdb_assert (regname
&& *regname
);
1551 error (_("Address requested for identifier "
1552 "\"%s\" which is in register $%s"),
1553 SYMBOL_PRINT_NAME (var
), regname
);
1558 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1559 SYMBOL_PRINT_NAME (var
));
1566 /* Return one if VAL does not live in target memory, but should in order
1567 to operate on it. Otherwise return zero. */
1570 value_must_coerce_to_target (struct value
*val
)
1572 struct type
*valtype
;
1574 /* The only lval kinds which do not live in target memory. */
1575 if (VALUE_LVAL (val
) != not_lval
1576 && VALUE_LVAL (val
) != lval_internalvar
)
1579 valtype
= check_typedef (value_type (val
));
1581 switch (TYPE_CODE (valtype
))
1583 case TYPE_CODE_ARRAY
:
1584 return TYPE_VECTOR (valtype
) ? 0 : 1;
1585 case TYPE_CODE_STRING
:
1592 /* Make sure that VAL lives in target memory if it's supposed to. For
1593 instance, strings are constructed as character arrays in GDB's
1594 storage, and this function copies them to the target. */
1597 value_coerce_to_target (struct value
*val
)
1602 if (!value_must_coerce_to_target (val
))
1605 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1606 addr
= allocate_space_in_inferior (length
);
1607 write_memory (addr
, value_contents (val
), length
);
1608 return value_at_lazy (value_type (val
), addr
);
1611 /* Given a value which is an array, return a value which is a pointer
1612 to its first element, regardless of whether or not the array has a
1613 nonzero lower bound.
1615 FIXME: A previous comment here indicated that this routine should
1616 be substracting the array's lower bound. It's not clear to me that
1617 this is correct. Given an array subscripting operation, it would
1618 certainly work to do the adjustment here, essentially computing:
1620 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1622 However I believe a more appropriate and logical place to account
1623 for the lower bound is to do so in value_subscript, essentially
1626 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1628 As further evidence consider what would happen with operations
1629 other than array subscripting, where the caller would get back a
1630 value that had an address somewhere before the actual first element
1631 of the array, and the information about the lower bound would be
1632 lost because of the coercion to pointer type. */
1635 value_coerce_array (struct value
*arg1
)
1637 struct type
*type
= check_typedef (value_type (arg1
));
1639 /* If the user tries to do something requiring a pointer with an
1640 array that has not yet been pushed to the target, then this would
1641 be a good time to do so. */
1642 arg1
= value_coerce_to_target (arg1
);
1644 if (VALUE_LVAL (arg1
) != lval_memory
)
1645 error (_("Attempt to take address of value not located in memory."));
1647 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1648 value_address (arg1
));
1651 /* Given a value which is a function, return a value which is a pointer
1655 value_coerce_function (struct value
*arg1
)
1657 struct value
*retval
;
1659 if (VALUE_LVAL (arg1
) != lval_memory
)
1660 error (_("Attempt to take address of value not located in memory."));
1662 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1663 value_address (arg1
));
1667 /* Return a pointer value for the object for which ARG1 is the
1671 value_addr (struct value
*arg1
)
1674 struct type
*type
= check_typedef (value_type (arg1
));
1676 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1678 /* Copy the value, but change the type from (T&) to (T*). We
1679 keep the same location information, which is efficient, and
1680 allows &(&X) to get the location containing the reference. */
1681 arg2
= value_copy (arg1
);
1682 deprecated_set_value_type (arg2
,
1683 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1686 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1687 return value_coerce_function (arg1
);
1689 /* If this is an array that has not yet been pushed to the target,
1690 then this would be a good time to force it to memory. */
1691 arg1
= value_coerce_to_target (arg1
);
1693 if (VALUE_LVAL (arg1
) != lval_memory
)
1694 error (_("Attempt to take address of value not located in memory."));
1696 /* Get target memory address. */
1697 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1698 (value_address (arg1
)
1699 + value_embedded_offset (arg1
)));
1701 /* This may be a pointer to a base subobject; so remember the
1702 full derived object's type ... */
1703 set_value_enclosing_type (arg2
,
1704 lookup_pointer_type (value_enclosing_type (arg1
)));
1705 /* ... and also the relative position of the subobject in the full
1707 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1711 /* Return a reference value for the object for which ARG1 is the
1715 value_ref (struct value
*arg1
)
1718 struct type
*type
= check_typedef (value_type (arg1
));
1720 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1723 arg2
= value_addr (arg1
);
1724 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1728 /* Given a value of a pointer type, apply the C unary * operator to
1732 value_ind (struct value
*arg1
)
1734 struct type
*base_type
;
1737 arg1
= coerce_array (arg1
);
1739 base_type
= check_typedef (value_type (arg1
));
1741 if (VALUE_LVAL (arg1
) == lval_computed
)
1743 const struct lval_funcs
*funcs
= value_computed_funcs (arg1
);
1745 if (funcs
->indirect
)
1747 struct value
*result
= funcs
->indirect (arg1
);
1754 if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1756 struct type
*enc_type
;
1758 /* We may be pointing to something embedded in a larger object.
1759 Get the real type of the enclosing object. */
1760 enc_type
= check_typedef (value_enclosing_type (arg1
));
1761 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1763 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1764 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1765 /* For functions, go through find_function_addr, which knows
1766 how to handle function descriptors. */
1767 arg2
= value_at_lazy (enc_type
,
1768 find_function_addr (arg1
, NULL
));
1770 /* Retrieve the enclosing object pointed to. */
1771 arg2
= value_at_lazy (enc_type
,
1772 (value_as_address (arg1
)
1773 - value_pointed_to_offset (arg1
)));
1775 /* Re-adjust type. */
1776 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1777 /* Add embedding info. */
1778 set_value_enclosing_type (arg2
, enc_type
);
1779 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1781 /* We may be pointing to an object of some derived type. */
1782 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1786 error (_("Attempt to take contents of a non-pointer value."));
1787 return 0; /* For lint -- never reached. */
1790 /* Create a value for an array by allocating space in GDB, copying the
1791 data into that space, and then setting up an array value.
1793 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1794 is populated from the values passed in ELEMVEC.
1796 The element type of the array is inherited from the type of the
1797 first element, and all elements must have the same size (though we
1798 don't currently enforce any restriction on their types). */
1801 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1805 unsigned int typelength
;
1807 struct type
*arraytype
;
1809 /* Validate that the bounds are reasonable and that each of the
1810 elements have the same size. */
1812 nelem
= highbound
- lowbound
+ 1;
1815 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1817 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1818 for (idx
= 1; idx
< nelem
; idx
++)
1820 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1822 error (_("array elements must all be the same size"));
1826 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1827 lowbound
, highbound
);
1829 if (!current_language
->c_style_arrays
)
1831 val
= allocate_value (arraytype
);
1832 for (idx
= 0; idx
< nelem
; idx
++)
1833 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0,
1838 /* Allocate space to store the array, and then initialize it by
1839 copying in each element. */
1841 val
= allocate_value (arraytype
);
1842 for (idx
= 0; idx
< nelem
; idx
++)
1843 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0, typelength
);
1848 value_cstring (char *ptr
, int len
, struct type
*char_type
)
1851 int lowbound
= current_language
->string_lower_bound
;
1852 int highbound
= len
/ TYPE_LENGTH (char_type
);
1853 struct type
*stringtype
1854 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1856 val
= allocate_value (stringtype
);
1857 memcpy (value_contents_raw (val
), ptr
, len
);
1861 /* Create a value for a string constant by allocating space in the
1862 inferior, copying the data into that space, and returning the
1863 address with type TYPE_CODE_STRING. PTR points to the string
1864 constant data; LEN is number of characters.
1866 Note that string types are like array of char types with a lower
1867 bound of zero and an upper bound of LEN - 1. Also note that the
1868 string may contain embedded null bytes. */
1871 value_string (char *ptr
, int len
, struct type
*char_type
)
1874 int lowbound
= current_language
->string_lower_bound
;
1875 int highbound
= len
/ TYPE_LENGTH (char_type
);
1876 struct type
*stringtype
1877 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1879 val
= allocate_value (stringtype
);
1880 memcpy (value_contents_raw (val
), ptr
, len
);
1885 value_bitstring (char *ptr
, int len
, struct type
*index_type
)
1888 struct type
*domain_type
1889 = create_range_type (NULL
, index_type
, 0, len
- 1);
1890 struct type
*type
= create_set_type (NULL
, domain_type
);
1892 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1893 val
= allocate_value (type
);
1894 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1898 /* See if we can pass arguments in T2 to a function which takes
1899 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1900 a NULL-terminated vector. If some arguments need coercion of some
1901 sort, then the coerced values are written into T2. Return value is
1902 0 if the arguments could be matched, or the position at which they
1905 STATICP is nonzero if the T1 argument list came from a static
1906 member function. T2 will still include the ``this'' pointer, but
1909 For non-static member functions, we ignore the first argument,
1910 which is the type of the instance variable. This is because we
1911 want to handle calls with objects from derived classes. This is
1912 not entirely correct: we should actually check to make sure that a
1913 requested operation is type secure, shouldn't we? FIXME. */
1916 typecmp (int staticp
, int varargs
, int nargs
,
1917 struct field t1
[], struct value
*t2
[])
1922 internal_error (__FILE__
, __LINE__
,
1923 _("typecmp: no argument list"));
1925 /* Skip ``this'' argument if applicable. T2 will always include
1931 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1934 struct type
*tt1
, *tt2
;
1939 tt1
= check_typedef (t1
[i
].type
);
1940 tt2
= check_typedef (value_type (t2
[i
]));
1942 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1943 /* We should be doing hairy argument matching, as below. */
1944 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
)))
1945 == TYPE_CODE (tt2
)))
1947 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1948 t2
[i
] = value_coerce_array (t2
[i
]);
1950 t2
[i
] = value_ref (t2
[i
]);
1954 /* djb - 20000715 - Until the new type structure is in the
1955 place, and we can attempt things like implicit conversions,
1956 we need to do this so you can take something like a map<const
1957 char *>, and properly access map["hello"], because the
1958 argument to [] will be a reference to a pointer to a char,
1959 and the argument will be a pointer to a char. */
1960 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1961 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1963 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1965 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1966 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1967 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1969 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1971 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1973 /* Array to pointer is a `trivial conversion' according to the
1976 /* We should be doing much hairier argument matching (see
1977 section 13.2 of the ARM), but as a quick kludge, just check
1978 for the same type code. */
1979 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1982 if (varargs
|| t2
[i
] == NULL
)
1987 /* Helper function used by value_struct_elt to recurse through
1988 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1989 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1990 TYPE. If found, return value, else return NULL.
1992 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1993 fields, look for a baseclass named NAME. */
1995 static struct value
*
1996 search_struct_field (const char *name
, struct value
*arg1
, int offset
,
1997 struct type
*type
, int looking_for_baseclass
)
2002 CHECK_TYPEDEF (type
);
2003 nbases
= TYPE_N_BASECLASSES (type
);
2005 if (!looking_for_baseclass
)
2006 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
2008 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2010 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2014 if (field_is_static (&TYPE_FIELD (type
, i
)))
2016 v
= value_static_field (type
, i
);
2018 error (_("field %s is nonexistent or "
2019 "has been optimized out"),
2024 v
= value_primitive_field (arg1
, offset
, i
, type
);
2026 error (_("there is no field named %s"), name
);
2032 && (t_field_name
[0] == '\0'
2033 || (TYPE_CODE (type
) == TYPE_CODE_UNION
2034 && (strcmp_iw (t_field_name
, "else") == 0))))
2036 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
2038 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
2039 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
2041 /* Look for a match through the fields of an anonymous
2042 union, or anonymous struct. C++ provides anonymous
2045 In the GNU Chill (now deleted from GDB)
2046 implementation of variant record types, each
2047 <alternative field> has an (anonymous) union type,
2048 each member of the union represents a <variant
2049 alternative>. Each <variant alternative> is
2050 represented as a struct, with a member for each
2054 int new_offset
= offset
;
2056 /* This is pretty gross. In G++, the offset in an
2057 anonymous union is relative to the beginning of the
2058 enclosing struct. In the GNU Chill (now deleted
2059 from GDB) implementation of variant records, the
2060 bitpos is zero in an anonymous union field, so we
2061 have to add the offset of the union here. */
2062 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
2063 || (TYPE_NFIELDS (field_type
) > 0
2064 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2065 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2067 v
= search_struct_field (name
, arg1
, new_offset
,
2069 looking_for_baseclass
);
2076 for (i
= 0; i
< nbases
; i
++)
2079 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2080 /* If we are looking for baseclasses, this is what we get when
2081 we hit them. But it could happen that the base part's member
2082 name is not yet filled in. */
2083 int found_baseclass
= (looking_for_baseclass
2084 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2085 && (strcmp_iw (name
,
2086 TYPE_BASECLASS_NAME (type
,
2089 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2094 boffset
= baseclass_offset (type
, i
,
2095 value_contents_for_printing (arg1
),
2096 value_embedded_offset (arg1
) + offset
,
2097 value_address (arg1
),
2100 /* The virtual base class pointer might have been clobbered
2101 by the user program. Make sure that it still points to a
2102 valid memory location. */
2104 boffset
+= value_embedded_offset (arg1
) + offset
;
2106 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
2108 CORE_ADDR base_addr
;
2110 v2
= allocate_value (basetype
);
2111 base_addr
= value_address (arg1
) + boffset
;
2112 if (target_read_memory (base_addr
,
2113 value_contents_raw (v2
),
2114 TYPE_LENGTH (basetype
)) != 0)
2115 error (_("virtual baseclass botch"));
2116 VALUE_LVAL (v2
) = lval_memory
;
2117 set_value_address (v2
, base_addr
);
2121 v2
= value_copy (arg1
);
2122 deprecated_set_value_type (v2
, basetype
);
2123 set_value_embedded_offset (v2
, boffset
);
2126 if (found_baseclass
)
2128 v
= search_struct_field (name
, v2
, 0,
2129 TYPE_BASECLASS (type
, i
),
2130 looking_for_baseclass
);
2132 else if (found_baseclass
)
2133 v
= value_primitive_field (arg1
, offset
, i
, type
);
2135 v
= search_struct_field (name
, arg1
,
2136 offset
+ TYPE_BASECLASS_BITPOS (type
,
2138 basetype
, looking_for_baseclass
);
2145 /* Helper function used by value_struct_elt to recurse through
2146 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2147 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2150 If found, return value, else if name matched and args not return
2151 (value) -1, else return NULL. */
2153 static struct value
*
2154 search_struct_method (const char *name
, struct value
**arg1p
,
2155 struct value
**args
, int offset
,
2156 int *static_memfuncp
, struct type
*type
)
2160 int name_matched
= 0;
2161 char dem_opname
[64];
2163 CHECK_TYPEDEF (type
);
2164 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2166 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2168 /* FIXME! May need to check for ARM demangling here. */
2169 if (strncmp (t_field_name
, "__", 2) == 0 ||
2170 strncmp (t_field_name
, "op", 2) == 0 ||
2171 strncmp (t_field_name
, "type", 4) == 0)
2173 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2174 t_field_name
= dem_opname
;
2175 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2176 t_field_name
= dem_opname
;
2178 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2180 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2181 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2184 check_stub_method_group (type
, i
);
2185 if (j
> 0 && args
== 0)
2186 error (_("cannot resolve overloaded method "
2187 "`%s': no arguments supplied"), name
);
2188 else if (j
== 0 && args
== 0)
2190 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2197 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2198 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
2199 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
2200 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2202 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2203 return value_virtual_fn_field (arg1p
, f
, j
,
2205 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2207 *static_memfuncp
= 1;
2208 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2217 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2223 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2225 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2226 struct value
*base_val
;
2227 const gdb_byte
*base_valaddr
;
2229 /* The virtual base class pointer might have been
2230 clobbered by the user program. Make sure that it
2231 still points to a valid memory location. */
2233 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2235 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
2236 CORE_ADDR address
= value_address (*arg1p
);
2238 if (target_read_memory (address
+ offset
,
2239 tmp
, TYPE_LENGTH (baseclass
)) != 0)
2240 error (_("virtual baseclass botch"));
2242 base_val
= value_from_contents_and_address (baseclass
,
2245 base_valaddr
= value_contents_for_printing (base_val
);
2251 base_valaddr
= value_contents_for_printing (*arg1p
);
2252 this_offset
= offset
;
2255 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2256 this_offset
, value_address (base_val
),
2261 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2263 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2264 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2265 if (v
== (struct value
*) - 1)
2271 /* FIXME-bothner: Why is this commented out? Why is it here? */
2272 /* *arg1p = arg1_tmp; */
2277 return (struct value
*) - 1;
2282 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2283 extract the component named NAME from the ultimate target
2284 structure/union and return it as a value with its appropriate type.
2285 ERR is used in the error message if *ARGP's type is wrong.
2287 C++: ARGS is a list of argument types to aid in the selection of
2288 an appropriate method. Also, handle derived types.
2290 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2291 where the truthvalue of whether the function that was resolved was
2292 a static member function or not is stored.
2294 ERR is an error message to be printed in case the field is not
2298 value_struct_elt (struct value
**argp
, struct value
**args
,
2299 const char *name
, int *static_memfuncp
, const char *err
)
2304 *argp
= coerce_array (*argp
);
2306 t
= check_typedef (value_type (*argp
));
2308 /* Follow pointers until we get to a non-pointer. */
2310 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2312 *argp
= value_ind (*argp
);
2313 /* Don't coerce fn pointer to fn and then back again! */
2314 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2315 *argp
= coerce_array (*argp
);
2316 t
= check_typedef (value_type (*argp
));
2319 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2320 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2321 error (_("Attempt to extract a component of a value that is not a %s."),
2324 /* Assume it's not, unless we see that it is. */
2325 if (static_memfuncp
)
2326 *static_memfuncp
= 0;
2330 /* if there are no arguments ...do this... */
2332 /* Try as a field first, because if we succeed, there is less
2334 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2338 /* C++: If it was not found as a data field, then try to
2339 return it as a pointer to a method. */
2340 v
= search_struct_method (name
, argp
, args
, 0,
2341 static_memfuncp
, t
);
2343 if (v
== (struct value
*) - 1)
2344 error (_("Cannot take address of method %s."), name
);
2347 if (TYPE_NFN_FIELDS (t
))
2348 error (_("There is no member or method named %s."), name
);
2350 error (_("There is no member named %s."), name
);
2355 v
= search_struct_method (name
, argp
, args
, 0,
2356 static_memfuncp
, t
);
2358 if (v
== (struct value
*) - 1)
2360 error (_("One of the arguments you tried to pass to %s could not "
2361 "be converted to what the function wants."), name
);
2365 /* See if user tried to invoke data as function. If so, hand it
2366 back. If it's not callable (i.e., a pointer to function),
2367 gdb should give an error. */
2368 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2369 /* If we found an ordinary field, then it is not a method call.
2370 So, treat it as if it were a static member function. */
2371 if (v
&& static_memfuncp
)
2372 *static_memfuncp
= 1;
2376 throw_error (NOT_FOUND_ERROR
,
2377 _("Structure has no component named %s."), name
);
2381 /* Search through the methods of an object (and its bases) to find a
2382 specified method. Return the pointer to the fn_field list of
2383 overloaded instances.
2385 Helper function for value_find_oload_list.
2386 ARGP is a pointer to a pointer to a value (the object).
2387 METHOD is a string containing the method name.
2388 OFFSET is the offset within the value.
2389 TYPE is the assumed type of the object.
2390 NUM_FNS is the number of overloaded instances.
2391 BASETYPE is set to the actual type of the subobject where the
2393 BOFFSET is the offset of the base subobject where the method is found. */
2395 static struct fn_field
*
2396 find_method_list (struct value
**argp
, const char *method
,
2397 int offset
, struct type
*type
, int *num_fns
,
2398 struct type
**basetype
, int *boffset
)
2402 CHECK_TYPEDEF (type
);
2406 /* First check in object itself. */
2407 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2409 /* pai: FIXME What about operators and type conversions? */
2410 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2412 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2414 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2415 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2421 /* Resolve any stub methods. */
2422 check_stub_method_group (type
, i
);
2428 /* Not found in object, check in base subobjects. */
2429 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2433 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2435 base_offset
= baseclass_offset (type
, i
,
2436 value_contents_for_printing (*argp
),
2437 value_offset (*argp
) + offset
,
2438 value_address (*argp
), *argp
);
2440 else /* Non-virtual base, simply use bit position from debug
2443 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2445 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2446 TYPE_BASECLASS (type
, i
), num_fns
,
2454 /* Return the list of overloaded methods of a specified name.
2456 ARGP is a pointer to a pointer to a value (the object).
2457 METHOD is the method name.
2458 OFFSET is the offset within the value contents.
2459 NUM_FNS is the number of overloaded instances.
2460 BASETYPE is set to the type of the base subobject that defines the
2462 BOFFSET is the offset of the base subobject which defines the method. */
2465 value_find_oload_method_list (struct value
**argp
, const char *method
,
2466 int offset
, int *num_fns
,
2467 struct type
**basetype
, int *boffset
)
2471 t
= check_typedef (value_type (*argp
));
2473 /* Code snarfed from value_struct_elt. */
2474 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2476 *argp
= value_ind (*argp
);
2477 /* Don't coerce fn pointer to fn and then back again! */
2478 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2479 *argp
= coerce_array (*argp
);
2480 t
= check_typedef (value_type (*argp
));
2483 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2484 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2485 error (_("Attempt to extract a component of a "
2486 "value that is not a struct or union"));
2488 return find_method_list (argp
, method
, 0, t
, num_fns
,
2492 /* Given an array of arguments (ARGS) (which includes an
2493 entry for "this" in the case of C++ methods), the number of
2494 arguments NARGS, the NAME of a function whether it's a method or
2495 not (METHOD), and the degree of laxness (LAX) in conforming to
2496 overload resolution rules in ANSI C++, find the best function that
2497 matches on the argument types according to the overload resolution
2500 METHOD can be one of three values:
2501 NON_METHOD for non-member functions.
2502 METHOD: for member functions.
2503 BOTH: used for overload resolution of operators where the
2504 candidates are expected to be either member or non member
2505 functions. In this case the first argument ARGTYPES
2506 (representing 'this') is expected to be a reference to the
2507 target object, and will be dereferenced when attempting the
2510 In the case of class methods, the parameter OBJ is an object value
2511 in which to search for overloaded methods.
2513 In the case of non-method functions, the parameter FSYM is a symbol
2514 corresponding to one of the overloaded functions.
2516 Return value is an integer: 0 -> good match, 10 -> debugger applied
2517 non-standard coercions, 100 -> incompatible.
2519 If a method is being searched for, VALP will hold the value.
2520 If a non-method is being searched for, SYMP will hold the symbol
2523 If a method is being searched for, and it is a static method,
2524 then STATICP will point to a non-zero value.
2526 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2527 ADL overload candidates when performing overload resolution for a fully
2530 Note: This function does *not* check the value of
2531 overload_resolution. Caller must check it to see whether overload
2532 resolution is permitted. */
2535 find_overload_match (struct value
**args
, int nargs
,
2536 const char *name
, enum oload_search_type method
,
2537 int lax
, struct value
**objp
, struct symbol
*fsym
,
2538 struct value
**valp
, struct symbol
**symp
,
2539 int *staticp
, const int no_adl
)
2541 struct value
*obj
= (objp
? *objp
: NULL
);
2542 struct type
*obj_type
= obj
? value_type (obj
) : NULL
;
2543 /* Index of best overloaded function. */
2544 int func_oload_champ
= -1;
2545 int method_oload_champ
= -1;
2547 /* The measure for the current best match. */
2548 struct badness_vector
*method_badness
= NULL
;
2549 struct badness_vector
*func_badness
= NULL
;
2551 struct value
*temp
= obj
;
2552 /* For methods, the list of overloaded methods. */
2553 struct fn_field
*fns_ptr
= NULL
;
2554 /* For non-methods, the list of overloaded function symbols. */
2555 struct symbol
**oload_syms
= NULL
;
2556 /* Number of overloaded instances being considered. */
2558 struct type
*basetype
= NULL
;
2561 struct cleanup
*all_cleanups
= make_cleanup (null_cleanup
, NULL
);
2563 const char *obj_type_name
= NULL
;
2564 const char *func_name
= NULL
;
2565 enum oload_classification match_quality
;
2566 enum oload_classification method_match_quality
= INCOMPATIBLE
;
2567 enum oload_classification func_match_quality
= INCOMPATIBLE
;
2569 /* Get the list of overloaded methods or functions. */
2570 if (method
== METHOD
|| method
== BOTH
)
2574 /* OBJ may be a pointer value rather than the object itself. */
2575 obj
= coerce_ref (obj
);
2576 while (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_PTR
)
2577 obj
= coerce_ref (value_ind (obj
));
2578 obj_type_name
= TYPE_NAME (value_type (obj
));
2580 /* First check whether this is a data member, e.g. a pointer to
2582 if (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_STRUCT
)
2584 *valp
= search_struct_field (name
, obj
, 0,
2585 check_typedef (value_type (obj
)), 0);
2589 do_cleanups (all_cleanups
);
2594 /* Retrieve the list of methods with the name NAME. */
2595 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2597 &basetype
, &boffset
);
2598 /* If this is a method only search, and no methods were found
2599 the search has faild. */
2600 if (method
== METHOD
&& (!fns_ptr
|| !num_fns
))
2601 error (_("Couldn't find method %s%s%s"),
2603 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2605 /* If we are dealing with stub method types, they should have
2606 been resolved by find_method_list via
2607 value_find_oload_method_list above. */
2610 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2611 method_oload_champ
= find_oload_champ (args
, nargs
, method
,
2613 oload_syms
, &method_badness
);
2615 method_match_quality
=
2616 classify_oload_match (method_badness
, nargs
,
2617 oload_method_static (method
, fns_ptr
,
2618 method_oload_champ
));
2620 make_cleanup (xfree
, method_badness
);
2625 if (method
== NON_METHOD
|| method
== BOTH
)
2627 const char *qualified_name
= NULL
;
2629 /* If the overload match is being search for both as a method
2630 and non member function, the first argument must now be
2633 deprecated_set_value_type (args
[0],
2634 TYPE_TARGET_TYPE (value_type (args
[0])));
2638 qualified_name
= SYMBOL_NATURAL_NAME (fsym
);
2640 /* If we have a function with a C++ name, try to extract just
2641 the function part. Do not try this for non-functions (e.g.
2642 function pointers). */
2644 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym
)))
2649 temp
= cp_func_name (qualified_name
);
2651 /* If cp_func_name did not remove anything, the name of the
2652 symbol did not include scope or argument types - it was
2653 probably a C-style function. */
2656 make_cleanup (xfree
, temp
);
2657 if (strcmp (temp
, qualified_name
) == 0)
2667 qualified_name
= name
;
2670 /* If there was no C++ name, this must be a C-style function or
2671 not a function at all. Just return the same symbol. Do the
2672 same if cp_func_name fails for some reason. */
2673 if (func_name
== NULL
)
2676 do_cleanups (all_cleanups
);
2680 func_oload_champ
= find_oload_champ_namespace (args
, nargs
,
2687 if (func_oload_champ
>= 0)
2688 func_match_quality
= classify_oload_match (func_badness
, nargs
, 0);
2690 make_cleanup (xfree
, oload_syms
);
2691 make_cleanup (xfree
, func_badness
);
2694 /* Did we find a match ? */
2695 if (method_oload_champ
== -1 && func_oload_champ
== -1)
2696 throw_error (NOT_FOUND_ERROR
,
2697 _("No symbol \"%s\" in current context."),
2700 /* If we have found both a method match and a function
2701 match, find out which one is better, and calculate match
2703 if (method_oload_champ
>= 0 && func_oload_champ
>= 0)
2705 switch (compare_badness (func_badness
, method_badness
))
2707 case 0: /* Top two contenders are equally good. */
2708 /* FIXME: GDB does not support the general ambiguous case.
2709 All candidates should be collected and presented the
2711 error (_("Ambiguous overload resolution"));
2713 case 1: /* Incomparable top contenders. */
2714 /* This is an error incompatible candidates
2715 should not have been proposed. */
2716 error (_("Internal error: incompatible "
2717 "overload candidates proposed"));
2719 case 2: /* Function champion. */
2720 method_oload_champ
= -1;
2721 match_quality
= func_match_quality
;
2723 case 3: /* Method champion. */
2724 func_oload_champ
= -1;
2725 match_quality
= method_match_quality
;
2728 error (_("Internal error: unexpected overload comparison result"));
2734 /* We have either a method match or a function match. */
2735 if (method_oload_champ
>= 0)
2736 match_quality
= method_match_quality
;
2738 match_quality
= func_match_quality
;
2741 if (match_quality
== INCOMPATIBLE
)
2743 if (method
== METHOD
)
2744 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2746 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2749 error (_("Cannot resolve function %s to any overloaded instance"),
2752 else if (match_quality
== NON_STANDARD
)
2754 if (method
== METHOD
)
2755 warning (_("Using non-standard conversion to match "
2756 "method %s%s%s to supplied arguments"),
2758 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2761 warning (_("Using non-standard conversion to match "
2762 "function %s to supplied arguments"),
2766 if (staticp
!= NULL
)
2767 *staticp
= oload_method_static (method
, fns_ptr
, method_oload_champ
);
2769 if (method_oload_champ
>= 0)
2771 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, method_oload_champ
))
2772 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, method_oload_champ
,
2775 *valp
= value_fn_field (&temp
, fns_ptr
, method_oload_champ
,
2779 *symp
= oload_syms
[func_oload_champ
];
2783 struct type
*temp_type
= check_typedef (value_type (temp
));
2784 struct type
*objtype
= check_typedef (obj_type
);
2786 if (TYPE_CODE (temp_type
) != TYPE_CODE_PTR
2787 && (TYPE_CODE (objtype
) == TYPE_CODE_PTR
2788 || TYPE_CODE (objtype
) == TYPE_CODE_REF
))
2790 temp
= value_addr (temp
);
2795 do_cleanups (all_cleanups
);
2797 switch (match_quality
)
2803 default: /* STANDARD */
2808 /* Find the best overload match, searching for FUNC_NAME in namespaces
2809 contained in QUALIFIED_NAME until it either finds a good match or
2810 runs out of namespaces. It stores the overloaded functions in
2811 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2812 calling function is responsible for freeing *OLOAD_SYMS and
2813 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2817 find_oload_champ_namespace (struct value
**args
, int nargs
,
2818 const char *func_name
,
2819 const char *qualified_name
,
2820 struct symbol
***oload_syms
,
2821 struct badness_vector
**oload_champ_bv
,
2826 find_oload_champ_namespace_loop (args
, nargs
,
2829 oload_syms
, oload_champ_bv
,
2836 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2837 how deep we've looked for namespaces, and the champ is stored in
2838 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2839 if it isn't. Other arguments are the same as in
2840 find_oload_champ_namespace
2842 It is the caller's responsibility to free *OLOAD_SYMS and
2846 find_oload_champ_namespace_loop (struct value
**args
, int nargs
,
2847 const char *func_name
,
2848 const char *qualified_name
,
2850 struct symbol
***oload_syms
,
2851 struct badness_vector
**oload_champ_bv
,
2855 int next_namespace_len
= namespace_len
;
2856 int searched_deeper
= 0;
2858 struct cleanup
*old_cleanups
;
2859 int new_oload_champ
;
2860 struct symbol
**new_oload_syms
;
2861 struct badness_vector
*new_oload_champ_bv
;
2862 char *new_namespace
;
2864 if (next_namespace_len
!= 0)
2866 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2867 next_namespace_len
+= 2;
2869 next_namespace_len
+=
2870 cp_find_first_component (qualified_name
+ next_namespace_len
);
2872 /* Initialize these to values that can safely be xfree'd. */
2874 *oload_champ_bv
= NULL
;
2876 /* First, see if we have a deeper namespace we can search in.
2877 If we get a good match there, use it. */
2879 if (qualified_name
[next_namespace_len
] == ':')
2881 searched_deeper
= 1;
2883 if (find_oload_champ_namespace_loop (args
, nargs
,
2884 func_name
, qualified_name
,
2886 oload_syms
, oload_champ_bv
,
2887 oload_champ
, no_adl
))
2893 /* If we reach here, either we're in the deepest namespace or we
2894 didn't find a good match in a deeper namespace. But, in the
2895 latter case, we still have a bad match in a deeper namespace;
2896 note that we might not find any match at all in the current
2897 namespace. (There's always a match in the deepest namespace,
2898 because this overload mechanism only gets called if there's a
2899 function symbol to start off with.) */
2901 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2902 make_cleanup (xfree
, *oload_champ_bv
);
2903 new_namespace
= alloca (namespace_len
+ 1);
2904 strncpy (new_namespace
, qualified_name
, namespace_len
);
2905 new_namespace
[namespace_len
] = '\0';
2906 new_oload_syms
= make_symbol_overload_list (func_name
,
2909 /* If we have reached the deepest level perform argument
2910 determined lookup. */
2911 if (!searched_deeper
&& !no_adl
)
2914 struct type
**arg_types
;
2916 /* Prepare list of argument types for overload resolution. */
2917 arg_types
= (struct type
**)
2918 alloca (nargs
* (sizeof (struct type
*)));
2919 for (ix
= 0; ix
< nargs
; ix
++)
2920 arg_types
[ix
] = value_type (args
[ix
]);
2921 make_symbol_overload_list_adl (arg_types
, nargs
, func_name
);
2924 while (new_oload_syms
[num_fns
])
2927 new_oload_champ
= find_oload_champ (args
, nargs
, 0, num_fns
,
2928 NULL
, new_oload_syms
,
2929 &new_oload_champ_bv
);
2931 /* Case 1: We found a good match. Free earlier matches (if any),
2932 and return it. Case 2: We didn't find a good match, but we're
2933 not the deepest function. Then go with the bad match that the
2934 deeper function found. Case 3: We found a bad match, and we're
2935 the deepest function. Then return what we found, even though
2936 it's a bad match. */
2938 if (new_oload_champ
!= -1
2939 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2941 *oload_syms
= new_oload_syms
;
2942 *oload_champ
= new_oload_champ
;
2943 *oload_champ_bv
= new_oload_champ_bv
;
2944 do_cleanups (old_cleanups
);
2947 else if (searched_deeper
)
2949 xfree (new_oload_syms
);
2950 xfree (new_oload_champ_bv
);
2951 discard_cleanups (old_cleanups
);
2956 *oload_syms
= new_oload_syms
;
2957 *oload_champ
= new_oload_champ
;
2958 *oload_champ_bv
= new_oload_champ_bv
;
2959 do_cleanups (old_cleanups
);
2964 /* Look for a function to take NARGS args of ARGS. Find
2965 the best match from among the overloaded methods or functions
2966 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2967 The number of methods/functions in the list is given by NUM_FNS.
2968 Return the index of the best match; store an indication of the
2969 quality of the match in OLOAD_CHAMP_BV.
2971 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2974 find_oload_champ (struct value
**args
, int nargs
, int method
,
2975 int num_fns
, struct fn_field
*fns_ptr
,
2976 struct symbol
**oload_syms
,
2977 struct badness_vector
**oload_champ_bv
)
2980 /* A measure of how good an overloaded instance is. */
2981 struct badness_vector
*bv
;
2982 /* Index of best overloaded function. */
2983 int oload_champ
= -1;
2984 /* Current ambiguity state for overload resolution. */
2985 int oload_ambiguous
= 0;
2986 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2988 *oload_champ_bv
= NULL
;
2990 /* Consider each candidate in turn. */
2991 for (ix
= 0; ix
< num_fns
; ix
++)
2994 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2996 struct type
**parm_types
;
3000 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
3004 /* If it's not a method, this is the proper place. */
3005 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
3008 /* Prepare array of parameter types. */
3009 parm_types
= (struct type
**)
3010 xmalloc (nparms
* (sizeof (struct type
*)));
3011 for (jj
= 0; jj
< nparms
; jj
++)
3012 parm_types
[jj
] = (method
3013 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
3014 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
3017 /* Compare parameter types to supplied argument types. Skip
3018 THIS for static methods. */
3019 bv
= rank_function (parm_types
, nparms
,
3020 args
+ static_offset
,
3021 nargs
- static_offset
);
3023 if (!*oload_champ_bv
)
3025 *oload_champ_bv
= bv
;
3028 else /* See whether current candidate is better or worse than
3030 switch (compare_badness (bv
, *oload_champ_bv
))
3032 case 0: /* Top two contenders are equally good. */
3033 oload_ambiguous
= 1;
3035 case 1: /* Incomparable top contenders. */
3036 oload_ambiguous
= 2;
3038 case 2: /* New champion, record details. */
3039 *oload_champ_bv
= bv
;
3040 oload_ambiguous
= 0;
3051 fprintf_filtered (gdb_stderr
,
3052 "Overloaded method instance %s, # of parms %d\n",
3053 fns_ptr
[ix
].physname
, nparms
);
3055 fprintf_filtered (gdb_stderr
,
3056 "Overloaded function instance "
3057 "%s # of parms %d\n",
3058 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
3060 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
3061 fprintf_filtered (gdb_stderr
,
3062 "...Badness @ %d : %d\n",
3063 jj
, bv
->rank
[jj
].rank
);
3064 fprintf_filtered (gdb_stderr
, "Overload resolution "
3065 "champion is %d, ambiguous? %d\n",
3066 oload_champ
, oload_ambiguous
);
3073 /* Return 1 if we're looking at a static method, 0 if we're looking at
3074 a non-static method or a function that isn't a method. */
3077 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
3079 if (method
&& fns_ptr
&& index
>= 0
3080 && TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
3086 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3088 static enum oload_classification
3089 classify_oload_match (struct badness_vector
*oload_champ_bv
,
3094 enum oload_classification worst
= STANDARD
;
3096 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
3098 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3099 or worse return INCOMPATIBLE. */
3100 if (compare_ranks (oload_champ_bv
->rank
[ix
],
3101 INCOMPATIBLE_TYPE_BADNESS
) <= 0)
3102 return INCOMPATIBLE
; /* Truly mismatched types. */
3103 /* Otherwise If this conversion is as bad as
3104 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3105 else if (compare_ranks (oload_champ_bv
->rank
[ix
],
3106 NS_POINTER_CONVERSION_BADNESS
) <= 0)
3107 worst
= NON_STANDARD
; /* Non-standard type conversions
3111 /* If no INCOMPATIBLE classification was found, return the worst one
3112 that was found (if any). */
3116 /* C++: return 1 is NAME is a legitimate name for the destructor of
3117 type TYPE. If TYPE does not have a destructor, or if NAME is
3118 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3119 have CHECK_TYPEDEF applied, this function will apply it itself. */
3122 destructor_name_p (const char *name
, struct type
*type
)
3126 const char *dname
= type_name_no_tag_or_error (type
);
3127 const char *cp
= strchr (dname
, '<');
3130 /* Do not compare the template part for template classes. */
3132 len
= strlen (dname
);
3135 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
3136 error (_("name of destructor must equal name of class"));
3143 /* Given TYPE, a structure/union,
3144 return 1 if the component named NAME from the ultimate target
3145 structure/union is defined, otherwise, return 0. */
3148 check_field (struct type
*type
, const char *name
)
3152 /* The type may be a stub. */
3153 CHECK_TYPEDEF (type
);
3155 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
3157 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
3159 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
3163 /* C++: If it was not found as a data field, then try to return it
3164 as a pointer to a method. */
3166 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
3168 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
3172 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
3173 if (check_field (TYPE_BASECLASS (type
, i
), name
))
3179 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3180 return the appropriate member (or the address of the member, if
3181 WANT_ADDRESS). This function is used to resolve user expressions
3182 of the form "DOMAIN::NAME". For more details on what happens, see
3183 the comment before value_struct_elt_for_reference. */
3186 value_aggregate_elt (struct type
*curtype
, char *name
,
3187 struct type
*expect_type
, int want_address
,
3190 switch (TYPE_CODE (curtype
))
3192 case TYPE_CODE_STRUCT
:
3193 case TYPE_CODE_UNION
:
3194 return value_struct_elt_for_reference (curtype
, 0, curtype
,
3196 want_address
, noside
);
3197 case TYPE_CODE_NAMESPACE
:
3198 return value_namespace_elt (curtype
, name
,
3199 want_address
, noside
);
3201 internal_error (__FILE__
, __LINE__
,
3202 _("non-aggregate type in value_aggregate_elt"));
3206 /* Compares the two method/function types T1 and T2 for "equality"
3207 with respect to the methods' parameters. If the types of the
3208 two parameter lists are the same, returns 1; 0 otherwise. This
3209 comparison may ignore any artificial parameters in T1 if
3210 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3211 the first artificial parameter in T1, assumed to be a 'this' pointer.
3213 The type T2 is expected to have come from make_params (in eval.c). */
3216 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
3220 if (TYPE_NFIELDS (t1
) > 0 && TYPE_FIELD_ARTIFICIAL (t1
, 0))
3223 /* If skipping artificial fields, find the first real field
3225 if (skip_artificial
)
3227 while (start
< TYPE_NFIELDS (t1
)
3228 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
3232 /* Now compare parameters. */
3234 /* Special case: a method taking void. T1 will contain no
3235 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3236 if ((TYPE_NFIELDS (t1
) - start
) == 0 && TYPE_NFIELDS (t2
) == 1
3237 && TYPE_CODE (TYPE_FIELD_TYPE (t2
, 0)) == TYPE_CODE_VOID
)
3240 if ((TYPE_NFIELDS (t1
) - start
) == TYPE_NFIELDS (t2
))
3244 for (i
= 0; i
< TYPE_NFIELDS (t2
); ++i
)
3246 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1
, start
+ i
),
3247 TYPE_FIELD_TYPE (t2
, i
), NULL
),
3248 EXACT_MATCH_BADNESS
) != 0)
3258 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3259 return the address of this member as a "pointer to member" type.
3260 If INTYPE is non-null, then it will be the type of the member we
3261 are looking for. This will help us resolve "pointers to member
3262 functions". This function is used to resolve user expressions of
3263 the form "DOMAIN::NAME". */
3265 static struct value
*
3266 value_struct_elt_for_reference (struct type
*domain
, int offset
,
3267 struct type
*curtype
, char *name
,
3268 struct type
*intype
,
3272 struct type
*t
= curtype
;
3274 struct value
*v
, *result
;
3276 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
3277 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
3278 error (_("Internal error: non-aggregate type "
3279 "to value_struct_elt_for_reference"));
3281 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3283 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
3285 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3287 if (field_is_static (&TYPE_FIELD (t
, i
)))
3289 v
= value_static_field (t
, i
);
3291 error (_("static field %s has been optimized out"),
3297 if (TYPE_FIELD_PACKED (t
, i
))
3298 error (_("pointers to bitfield members not allowed"));
3301 return value_from_longest
3302 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
3303 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
3304 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3305 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
3307 error (_("Cannot reference non-static field \"%s\""), name
);
3311 /* C++: If it was not found as a data field, then try to return it
3312 as a pointer to a method. */
3314 /* Perform all necessary dereferencing. */
3315 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
3316 intype
= TYPE_TARGET_TYPE (intype
);
3318 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3320 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3321 char dem_opname
[64];
3323 if (strncmp (t_field_name
, "__", 2) == 0
3324 || strncmp (t_field_name
, "op", 2) == 0
3325 || strncmp (t_field_name
, "type", 4) == 0)
3327 if (cplus_demangle_opname (t_field_name
,
3328 dem_opname
, DMGL_ANSI
))
3329 t_field_name
= dem_opname
;
3330 else if (cplus_demangle_opname (t_field_name
,
3332 t_field_name
= dem_opname
;
3334 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3337 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3338 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3340 check_stub_method_group (t
, i
);
3344 for (j
= 0; j
< len
; ++j
)
3346 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3347 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
),
3353 error (_("no member function matches "
3354 "that type instantiation"));
3361 for (ii
= 0; ii
< len
; ++ii
)
3363 /* Skip artificial methods. This is necessary if,
3364 for example, the user wants to "print
3365 subclass::subclass" with only one user-defined
3366 constructor. There is no ambiguity in this case.
3367 We are careful here to allow artificial methods
3368 if they are the unique result. */
3369 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3376 /* Desired method is ambiguous if more than one
3377 method is defined. */
3378 if (j
!= -1 && !TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
3379 error (_("non-unique member `%s' requires "
3380 "type instantiation"), name
);
3386 error (_("no matching member function"));
3389 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3392 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3399 return value_addr (read_var_value (s
, 0));
3401 return read_var_value (s
, 0);
3404 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3408 result
= allocate_value
3409 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3410 cplus_make_method_ptr (value_type (result
),
3411 value_contents_writeable (result
),
3412 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3414 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3415 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3417 error (_("Cannot reference virtual member function \"%s\""),
3423 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3429 v
= read_var_value (s
, 0);
3434 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3435 cplus_make_method_ptr (value_type (result
),
3436 value_contents_writeable (result
),
3437 value_address (v
), 0);
3443 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3448 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3451 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3452 v
= value_struct_elt_for_reference (domain
,
3453 offset
+ base_offset
,
3454 TYPE_BASECLASS (t
, i
),
3456 want_address
, noside
);
3461 /* As a last chance, pretend that CURTYPE is a namespace, and look
3462 it up that way; this (frequently) works for types nested inside
3465 return value_maybe_namespace_elt (curtype
, name
,
3466 want_address
, noside
);
3469 /* C++: Return the member NAME of the namespace given by the type
3472 static struct value
*
3473 value_namespace_elt (const struct type
*curtype
,
3474 char *name
, int want_address
,
3477 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3482 error (_("No symbol \"%s\" in namespace \"%s\"."),
3483 name
, TYPE_TAG_NAME (curtype
));
3488 /* A helper function used by value_namespace_elt and
3489 value_struct_elt_for_reference. It looks up NAME inside the
3490 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3491 is a class and NAME refers to a type in CURTYPE itself (as opposed
3492 to, say, some base class of CURTYPE). */
3494 static struct value
*
3495 value_maybe_namespace_elt (const struct type
*curtype
,
3496 char *name
, int want_address
,
3499 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
3501 struct value
*result
;
3503 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3504 get_selected_block (0), VAR_DOMAIN
);
3508 char *concatenated_name
= alloca (strlen (namespace_name
) + 2
3509 + strlen (name
) + 1);
3511 sprintf (concatenated_name
, "%s::%s", namespace_name
, name
);
3512 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
3517 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3518 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
3519 result
= allocate_value (SYMBOL_TYPE (sym
));
3521 result
= value_of_variable (sym
, get_selected_block (0));
3523 if (result
&& want_address
)
3524 result
= value_addr (result
);
3529 /* Given a pointer value V, find the real (RTTI) type of the object it
3532 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3533 and refer to the values computed for the object pointed to. */
3536 value_rtti_target_type (struct value
*v
, int *full
,
3537 int *top
, int *using_enc
)
3539 struct value
*target
;
3541 target
= value_ind (v
);
3543 return value_rtti_type (target
, full
, top
, using_enc
);
3546 /* Given a value pointed to by ARGP, check its real run-time type, and
3547 if that is different from the enclosing type, create a new value
3548 using the real run-time type as the enclosing type (and of the same
3549 type as ARGP) and return it, with the embedded offset adjusted to
3550 be the correct offset to the enclosed object. RTYPE is the type,
3551 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3552 by value_rtti_type(). If these are available, they can be supplied
3553 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3554 NULL if they're not available. */
3557 value_full_object (struct value
*argp
,
3559 int xfull
, int xtop
,
3562 struct type
*real_type
;
3566 struct value
*new_val
;
3573 using_enc
= xusing_enc
;
3576 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3578 /* If no RTTI data, or if object is already complete, do nothing. */
3579 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3582 /* In a destructor we might see a real type that is a superclass of
3583 the object's type. In this case it is better to leave the object
3586 && TYPE_LENGTH (real_type
) < TYPE_LENGTH (value_enclosing_type (argp
)))
3589 /* If we have the full object, but for some reason the enclosing
3590 type is wrong, set it. */
3591 /* pai: FIXME -- sounds iffy */
3594 argp
= value_copy (argp
);
3595 set_value_enclosing_type (argp
, real_type
);
3599 /* Check if object is in memory. */
3600 if (VALUE_LVAL (argp
) != lval_memory
)
3602 warning (_("Couldn't retrieve complete object of RTTI "
3603 "type %s; object may be in register(s)."),
3604 TYPE_NAME (real_type
));
3609 /* All other cases -- retrieve the complete object. */
3610 /* Go back by the computed top_offset from the beginning of the
3611 object, adjusting for the embedded offset of argp if that's what
3612 value_rtti_type used for its computation. */
3613 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3614 (using_enc
? 0 : value_embedded_offset (argp
)));
3615 deprecated_set_value_type (new_val
, value_type (argp
));
3616 set_value_embedded_offset (new_val
, (using_enc
3617 ? top
+ value_embedded_offset (argp
)
3623 /* Return the value of the local variable, if one exists. Throw error
3624 otherwise, such as if the request is made in an inappropriate context. */
3627 value_of_this (const struct language_defn
*lang
)
3631 struct frame_info
*frame
;
3633 if (!lang
->la_name_of_this
)
3634 error (_("no `this' in current language"));
3636 frame
= get_selected_frame (_("no frame selected"));
3638 b
= get_frame_block (frame
, NULL
);
3640 sym
= lookup_language_this (lang
, b
);
3642 error (_("current stack frame does not contain a variable named `%s'"),
3643 lang
->la_name_of_this
);
3645 return read_var_value (sym
, frame
);
3648 /* Return the value of the local variable, if one exists. Return NULL
3649 otherwise. Never throw error. */
3652 value_of_this_silent (const struct language_defn
*lang
)
3654 struct value
*ret
= NULL
;
3655 volatile struct gdb_exception except
;
3657 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3659 ret
= value_of_this (lang
);
3665 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3666 elements long, starting at LOWBOUND. The result has the same lower
3667 bound as the original ARRAY. */
3670 value_slice (struct value
*array
, int lowbound
, int length
)
3672 struct type
*slice_range_type
, *slice_type
, *range_type
;
3673 LONGEST lowerbound
, upperbound
;
3674 struct value
*slice
;
3675 struct type
*array_type
;
3677 array_type
= check_typedef (value_type (array
));
3678 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3679 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3680 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3681 error (_("cannot take slice of non-array"));
3683 range_type
= TYPE_INDEX_TYPE (array_type
);
3684 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3685 error (_("slice from bad array or bitstring"));
3687 if (lowbound
< lowerbound
|| length
< 0
3688 || lowbound
+ length
- 1 > upperbound
)
3689 error (_("slice out of range"));
3691 /* FIXME-type-allocation: need a way to free this type when we are
3693 slice_range_type
= create_range_type ((struct type
*) NULL
,
3694 TYPE_TARGET_TYPE (range_type
),
3696 lowbound
+ length
- 1);
3697 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3701 slice_type
= create_set_type ((struct type
*) NULL
,
3703 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3704 slice
= value_zero (slice_type
, not_lval
);
3706 for (i
= 0; i
< length
; i
++)
3708 int element
= value_bit_index (array_type
,
3709 value_contents (array
),
3713 error (_("internal error accessing bitstring"));
3714 else if (element
> 0)
3716 int j
= i
% TARGET_CHAR_BIT
;
3718 if (gdbarch_bits_big_endian (get_type_arch (array_type
)))
3719 j
= TARGET_CHAR_BIT
- 1 - j
;
3720 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3723 /* We should set the address, bitssize, and bitspos, so the
3724 slice can be used on the LHS, but that may require extensions
3725 to value_assign. For now, just leave as a non_lval.
3730 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3732 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3734 slice_type
= create_array_type ((struct type
*) NULL
,
3737 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3739 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3740 slice
= allocate_value_lazy (slice_type
);
3743 slice
= allocate_value (slice_type
);
3744 value_contents_copy (slice
, 0, array
, offset
,
3745 TYPE_LENGTH (slice_type
));
3748 set_value_component_location (slice
, array
);
3749 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
3750 set_value_offset (slice
, value_offset (array
) + offset
);
3755 /* Create a value for a FORTRAN complex number. Currently most of the
3756 time values are coerced to COMPLEX*16 (i.e. a complex number
3757 composed of 2 doubles. This really should be a smarter routine
3758 that figures out precision inteligently as opposed to assuming
3759 doubles. FIXME: fmb */
3762 value_literal_complex (struct value
*arg1
,
3767 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3769 val
= allocate_value (type
);
3770 arg1
= value_cast (real_type
, arg1
);
3771 arg2
= value_cast (real_type
, arg2
);
3773 memcpy (value_contents_raw (val
),
3774 value_contents (arg1
), TYPE_LENGTH (real_type
));
3775 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3776 value_contents (arg2
), TYPE_LENGTH (real_type
));
3780 /* Cast a value into the appropriate complex data type. */
3782 static struct value
*
3783 cast_into_complex (struct type
*type
, struct value
*val
)
3785 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3787 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3789 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3790 struct value
*re_val
= allocate_value (val_real_type
);
3791 struct value
*im_val
= allocate_value (val_real_type
);
3793 memcpy (value_contents_raw (re_val
),
3794 value_contents (val
), TYPE_LENGTH (val_real_type
));
3795 memcpy (value_contents_raw (im_val
),
3796 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3797 TYPE_LENGTH (val_real_type
));
3799 return value_literal_complex (re_val
, im_val
, type
);
3801 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3802 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3803 return value_literal_complex (val
,
3804 value_zero (real_type
, not_lval
),
3807 error (_("cannot cast non-number to complex"));
3811 _initialize_valops (void)
3813 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3814 &overload_resolution
, _("\
3815 Set overload resolution in evaluating C++ functions."), _("\
3816 Show overload resolution in evaluating C++ functions."),
3818 show_overload_resolution
,
3819 &setlist
, &showlist
);
3820 overload_resolution
= 1;