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 return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
1778 error (_("Attempt to take contents of a non-pointer value."));
1779 return 0; /* For lint -- never reached. */
1782 /* Create a value for an array by allocating space in GDB, copying the
1783 data into that space, and then setting up an array value.
1785 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1786 is populated from the values passed in ELEMVEC.
1788 The element type of the array is inherited from the type of the
1789 first element, and all elements must have the same size (though we
1790 don't currently enforce any restriction on their types). */
1793 value_array (int lowbound, int highbound, struct value **elemvec)
1797 unsigned int typelength;
1799 struct type *arraytype;
1801 /* Validate that the bounds are reasonable and that each of the
1802 elements have the same size. */
1804 nelem = highbound - lowbound + 1;
1807 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1809 typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1810 for (idx = 1; idx < nelem; idx++)
1812 if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1814 error (_("array elements must all be the same size"));
1818 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1819 lowbound, highbound);
1821 if (!current_language->c_style_arrays)
1823 val = allocate_value (arraytype);
1824 for (idx = 0; idx < nelem; idx++)
1825 value_contents_copy (val, idx * typelength, elemvec[idx], 0,
1830 /* Allocate space to store the array, and then initialize it by
1831 copying in each element. */
1833 val = allocate_value (arraytype);
1834 for (idx = 0; idx < nelem; idx++)
1835 value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength);
1840 value_cstring (char *ptr, int len, struct type *char_type)
1843 int lowbound = current_language->string_lower_bound;
1844 int highbound = len / TYPE_LENGTH (char_type);
1845 struct type *stringtype
1846 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1848 val = allocate_value (stringtype);
1849 memcpy (value_contents_raw (val), ptr, len);
1853 /* Create a value for a string constant by allocating space in the
1854 inferior, copying the data into that space, and returning the
1855 address with type TYPE_CODE_STRING. PTR points to the string
1856 constant data; LEN is number of characters.
1858 Note that string types are like array of char types with a lower
1859 bound of zero and an upper bound of LEN - 1. Also note that the
1860 string may contain embedded null bytes. */
1863 value_string (char *ptr, int len, struct type *char_type)
1866 int lowbound = current_language->string_lower_bound;
1867 int highbound = len / TYPE_LENGTH (char_type);
1868 struct type *stringtype
1869 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1871 val = allocate_value (stringtype);
1872 memcpy (value_contents_raw (val), ptr, len);
1877 value_bitstring (char *ptr, int len, struct type *index_type)
1880 struct type *domain_type
1881 = create_range_type (NULL, index_type, 0, len - 1);
1882 struct type *type = create_set_type (NULL, domain_type);
1884 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1885 val = allocate_value (type);
1886 memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
1890 /* See if we can pass arguments in T2 to a function which takes
1891 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1892 a NULL-terminated vector. If some arguments need coercion of some
1893 sort, then the coerced values are written into T2. Return value is
1894 0 if the arguments could be matched, or the position at which they
1897 STATICP is nonzero if the T1 argument list came from a static
1898 member function. T2 will still include the ``this'' pointer, but
1901 For non-static member functions, we ignore the first argument,
1902 which is the type of the instance variable. This is because we
1903 want to handle calls with objects from derived classes. This is
1904 not entirely correct: we should actually check to make sure that a
1905 requested operation is type secure, shouldn't we? FIXME. */
1908 typecmp (int staticp, int varargs, int nargs,
1909 struct field t1[], struct value *t2[])
1914 internal_error (__FILE__, __LINE__,
1915 _("typecmp: no argument list"));
1917 /* Skip ``this'' argument if applicable. T2 will always include
1923 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1926 struct type *tt1, *tt2;
1931 tt1 = check_typedef (t1[i].type);
1932 tt2 = check_typedef (value_type (t2[i]));
1934 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1935 /* We should be doing hairy argument matching, as below. */
1936 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
1937 == TYPE_CODE (tt2)))
1939 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1940 t2[i] = value_coerce_array (t2[i]);
1942 t2[i] = value_ref (t2[i]);
1946 /* djb - 20000715 - Until the new type structure is in the
1947 place, and we can attempt things like implicit conversions,
1948 we need to do this so you can take something like a map<const
1949 char *>, and properly access map["hello"], because the
1950 argument to [] will be a reference to a pointer to a char,
1951 and the argument will be a pointer to a char. */
1952 while (TYPE_CODE(tt1) == TYPE_CODE_REF
1953 || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1955 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1957 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1958 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1959 || TYPE_CODE(tt2) == TYPE_CODE_REF)
1961 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1963 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1965 /* Array to pointer is a `trivial conversion' according to the
1968 /* We should be doing much hairier argument matching (see
1969 section 13.2 of the ARM), but as a quick kludge, just check
1970 for the same type code. */
1971 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1974 if (varargs || t2[i] == NULL)
1979 /* Helper function used by value_struct_elt to recurse through
1980 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1981 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1982 TYPE. If found, return value, else return NULL.
1984 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1985 fields, look for a baseclass named NAME. */
1987 static struct value *
1988 search_struct_field (const char *name, struct value *arg1, int offset,
1989 struct type *type, int looking_for_baseclass)
1994 CHECK_TYPEDEF (type);
1995 nbases = TYPE_N_BASECLASSES (type);
1997 if (!looking_for_baseclass)
1998 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
2000 const char *t_field_name = TYPE_FIELD_NAME (type, i);
2002 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2006 if (field_is_static (&TYPE_FIELD (type, i)))
2008 v = value_static_field (type, i);
2010 error (_("field %s is nonexistent or "
2011 "has been optimized out"),
2016 v = value_primitive_field (arg1, offset, i, type);
2018 error (_("there is no field named %s"), name);
2024 && (t_field_name[0] == '\0'
2025 || (TYPE_CODE (type) == TYPE_CODE_UNION
2026 && (strcmp_iw (t_field_name, "else") == 0))))
2028 struct type *field_type = TYPE_FIELD_TYPE (type, i);
2030 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
2031 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
2033 /* Look for a match through the fields of an anonymous
2034 union, or anonymous struct. C++ provides anonymous
2037 In the GNU Chill (now deleted from GDB)
2038 implementation of variant record types, each
2039 <alternative field> has an (anonymous) union type,
2040 each member of the union represents a <variant
2041 alternative>. Each <variant alternative> is
2042 represented as a struct, with a member for each
2046 int new_offset = offset;
2048 /* This is pretty gross. In G++, the offset in an
2049 anonymous union is relative to the beginning of the
2050 enclosing struct. In the GNU Chill (now deleted
2051 from GDB) implementation of variant records, the
2052 bitpos is zero in an anonymous union field, so we
2053 have to add the offset of the union here. */
2054 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
2055 || (TYPE_NFIELDS (field_type) > 0
2056 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
2057 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
2059 v = search_struct_field (name, arg1, new_offset,
2061 looking_for_baseclass);
2068 for (i = 0; i < nbases; i++)
2071 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2072 /* If we are looking for baseclasses, this is what we get when
2073 we hit them. But it could happen that the base part's member
2074 name is not yet filled in. */
2075 int found_baseclass = (looking_for_baseclass
2076 && TYPE_BASECLASS_NAME (type, i) != NULL
2077 && (strcmp_iw (name,
2078 TYPE_BASECLASS_NAME (type,
2081 if (BASETYPE_VIA_VIRTUAL (type, i))
2086 boffset = baseclass_offset (type, i,
2087 value_contents_for_printing (arg1),
2088 value_embedded_offset (arg1) + offset,
2089 value_address (arg1),
2092 /* The virtual base class pointer might have been clobbered
2093 by the user program. Make sure that it still points to a
2094 valid memory location. */
2096 boffset += value_embedded_offset (arg1) + offset;
2098 || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
2100 CORE_ADDR base_addr;
2102 v2 = allocate_value (basetype);
2103 base_addr = value_address (arg1) + boffset;
2104 if (target_read_memory (base_addr,
2105 value_contents_raw (v2),
2106 TYPE_LENGTH (basetype)) != 0)
2107 error (_("virtual baseclass botch"));
2108 VALUE_LVAL (v2) = lval_memory;
2109 set_value_address (v2, base_addr);
2113 v2 = value_copy (arg1);
2114 deprecated_set_value_type (v2, basetype);
2115 set_value_embedded_offset (v2, boffset);
2118 if (found_baseclass)
2120 v = search_struct_field (name, v2, 0,
2121 TYPE_BASECLASS (type, i),
2122 looking_for_baseclass);
2124 else if (found_baseclass)
2125 v = value_primitive_field (arg1, offset, i, type);
2127 v = search_struct_field (name, arg1,
2128 offset + TYPE_BASECLASS_BITPOS (type,
2130 basetype, looking_for_baseclass);
2137 /* Helper function used by value_struct_elt to recurse through
2138 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2139 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2142 If found, return value, else if name matched and args not return
2143 (value) -1, else return NULL. */
2145 static struct value *
2146 search_struct_method (const char *name, struct value **arg1p,
2147 struct value **args, int offset,
2148 int *static_memfuncp, struct type *type)
2152 int name_matched = 0;
2153 char dem_opname[64];
2155 CHECK_TYPEDEF (type);
2156 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2158 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2160 /* FIXME! May need to check for ARM demangling here. */
2161 if (strncmp (t_field_name, "__", 2) == 0 ||
2162 strncmp (t_field_name, "op", 2) == 0 ||
2163 strncmp (t_field_name, "type", 4) == 0)
2165 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2166 t_field_name = dem_opname;
2167 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2168 t_field_name = dem_opname;
2170 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2172 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2173 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2176 check_stub_method_group (type, i);
2177 if (j > 0 && args == 0)
2178 error (_("cannot resolve overloaded method "
2179 "`%s': no arguments supplied"), name);
2180 else if (j == 0 && args == 0)
2182 v = value_fn_field (arg1p, f, j, type, offset);
2189 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2190 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2191 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2192 TYPE_FN_FIELD_ARGS (f, j), args))
2194 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2195 return value_virtual_fn_field (arg1p, f, j,
2197 if (TYPE_FN_FIELD_STATIC_P (f, j)
2199 *static_memfuncp = 1;
2200 v = value_fn_field (arg1p, f, j, type, offset);
2209 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2215 if (BASETYPE_VIA_VIRTUAL (type, i))
2217 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2218 struct value *base_val;
2219 const gdb_byte *base_valaddr;
2221 /* The virtual base class pointer might have been
2222 clobbered by the user program. Make sure that it
2223 still points to a valid memory location. */
2225 if (offset < 0 || offset >= TYPE_LENGTH (type))
2227 gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
2228 CORE_ADDR address = value_address (*arg1p);
2230 if (target_read_memory (address + offset,
2231 tmp, TYPE_LENGTH (baseclass)) != 0)
2232 error (_("virtual baseclass botch"));
2234 base_val = value_from_contents_and_address (baseclass,
2237 base_valaddr = value_contents_for_printing (base_val);
2243 base_valaddr = value_contents_for_printing (*arg1p);
2244 this_offset = offset;
2247 base_offset = baseclass_offset (type, i, base_valaddr,
2248 this_offset, value_address (base_val),
2253 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2255 v = search_struct_method (name, arg1p, args, base_offset + offset,
2256 static_memfuncp, TYPE_BASECLASS (type, i));
2257 if (v == (struct value *) - 1)
2263 /* FIXME-bothner: Why is this commented out? Why is it here? */
2264 /* *arg1p = arg1_tmp; */
2269 return (struct value *) - 1;
2274 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2275 extract the component named NAME from the ultimate target
2276 structure/union and return it as a value with its appropriate type.
2277 ERR is used in the error message if *ARGP's type is wrong.
2279 C++: ARGS is a list of argument types to aid in the selection of
2280 an appropriate method. Also, handle derived types.
2282 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2283 where the truthvalue of whether the function that was resolved was
2284 a static member function or not is stored.
2286 ERR is an error message to be printed in case the field is not
2290 value_struct_elt (struct value **argp, struct value **args,
2291 const char *name, int *static_memfuncp, const char *err)
2296 *argp = coerce_array (*argp);
2298 t = check_typedef (value_type (*argp));
2300 /* Follow pointers until we get to a non-pointer. */
2302 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2304 *argp = value_ind (*argp);
2305 /* Don't coerce fn pointer to fn and then back again! */
2306 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2307 *argp = coerce_array (*argp);
2308 t = check_typedef (value_type (*argp));
2311 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2312 && TYPE_CODE (t) != TYPE_CODE_UNION)
2313 error (_("Attempt to extract a component of a value that is not a %s."),
2316 /* Assume it's not, unless we see that it is. */
2317 if (static_memfuncp)
2318 *static_memfuncp = 0;
2322 /* if there are no arguments ...do this... */
2324 /* Try as a field first, because if we succeed, there is less
2326 v = search_struct_field (name, *argp, 0, t, 0);
2330 /* C++: If it was not found as a data field, then try to
2331 return it as a pointer to a method. */
2332 v = search_struct_method (name, argp, args, 0,
2333 static_memfuncp, t);
2335 if (v == (struct value *) - 1)
2336 error (_("Cannot take address of method %s."), name);
2339 if (TYPE_NFN_FIELDS (t))
2340 error (_("There is no member or method named %s."), name);
2342 error (_("There is no member named %s."), name);
2347 v = search_struct_method (name, argp, args, 0,
2348 static_memfuncp, t);
2350 if (v == (struct value *) - 1)
2352 error (_("One of the arguments you tried to pass to %s could not "
2353 "be converted to what the function wants."), name);
2357 /* See if user tried to invoke data as function. If so, hand it
2358 back. If it's not callable (i.e., a pointer to function),
2359 gdb should give an error. */
2360 v = search_struct_field (name, *argp, 0, t, 0);
2361 /* If we found an ordinary field, then it is not a method call.
2362 So, treat it as if it were a static member function. */
2363 if (v && static_memfuncp)
2364 *static_memfuncp = 1;
2368 throw_error (NOT_FOUND_ERROR,
2369 _("Structure has no component named %s."), name);
2373 /* Search through the methods of an object (and its bases) to find a
2374 specified method. Return the pointer to the fn_field list of
2375 overloaded instances.
2377 Helper function for value_find_oload_list.
2378 ARGP is a pointer to a pointer to a value (the object).
2379 METHOD is a string containing the method name.
2380 OFFSET is the offset within the value.
2381 TYPE is the assumed type of the object.
2382 NUM_FNS is the number of overloaded instances.
2383 BASETYPE is set to the actual type of the subobject where the
2385 BOFFSET is the offset of the base subobject where the method is found. */
2387 static struct fn_field *
2388 find_method_list (struct value **argp, const char *method,
2389 int offset, struct type *type, int *num_fns,
2390 struct type **basetype, int *boffset)
2394 CHECK_TYPEDEF (type);
2398 /* First check in object itself. */
2399 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2401 /* pai: FIXME What about operators and type conversions? */
2402 const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2404 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2406 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2407 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2413 /* Resolve any stub methods. */
2414 check_stub_method_group (type, i);
2420 /* Not found in object, check in base subobjects. */
2421 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2425 if (BASETYPE_VIA_VIRTUAL (type, i))
2427 base_offset = baseclass_offset (type, i,
2428 value_contents_for_printing (*argp),
2429 value_offset (*argp) + offset,
2430 value_address (*argp), *argp);
2432 else /* Non-virtual base, simply use bit position from debug
2435 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2437 f = find_method_list (argp, method, base_offset + offset,
2438 TYPE_BASECLASS (type, i), num_fns,
2446 /* Return the list of overloaded methods of a specified name.
2448 ARGP is a pointer to a pointer to a value (the object).
2449 METHOD is the method name.
2450 OFFSET is the offset within the value contents.
2451 NUM_FNS is the number of overloaded instances.
2452 BASETYPE is set to the type of the base subobject that defines the
2454 BOFFSET is the offset of the base subobject which defines the method. */
2457 value_find_oload_method_list (struct value **argp, const char *method,
2458 int offset, int *num_fns,
2459 struct type **basetype, int *boffset)
2463 t = check_typedef (value_type (*argp));
2465 /* Code snarfed from value_struct_elt. */
2466 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2468 *argp = value_ind (*argp);
2469 /* Don't coerce fn pointer to fn and then back again! */
2470 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2471 *argp = coerce_array (*argp);
2472 t = check_typedef (value_type (*argp));
2475 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2476 && TYPE_CODE (t) != TYPE_CODE_UNION)
2477 error (_("Attempt to extract a component of a "
2478 "value that is not a struct or union"));
2480 return find_method_list (argp, method, 0, t, num_fns,
2484 /* Given an array of arguments (ARGS) (which includes an
2485 entry for "this" in the case of C++ methods), the number of
2486 arguments NARGS, the NAME of a function whether it's a method or
2487 not (METHOD), and the degree of laxness (LAX) in conforming to
2488 overload resolution rules in ANSI C++, find the best function that
2489 matches on the argument types according to the overload resolution
2492 METHOD can be one of three values:
2493 NON_METHOD for non-member functions.
2494 METHOD: for member functions.
2495 BOTH: used for overload resolution of operators where the
2496 candidates are expected to be either member or non member
2497 functions. In this case the first argument ARGTYPES
2498 (representing 'this') is expected to be a reference to the
2499 target object, and will be dereferenced when attempting the
2502 In the case of class methods, the parameter OBJ is an object value
2503 in which to search for overloaded methods.
2505 In the case of non-method functions, the parameter FSYM is a symbol
2506 corresponding to one of the overloaded functions.
2508 Return value is an integer: 0 -> good match, 10 -> debugger applied
2509 non-standard coercions, 100 -> incompatible.
2511 If a method is being searched for, VALP will hold the value.
2512 If a non-method is being searched for, SYMP will hold the symbol
2515 If a method is being searched for, and it is a static method,
2516 then STATICP will point to a non-zero value.
2518 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2519 ADL overload candidates when performing overload resolution for a fully
2522 Note: This function does *not* check the value of
2523 overload_resolution. Caller must check it to see whether overload
2524 resolution is permitted. */
2527 find_overload_match (struct value **args, int nargs,
2528 const char *name, enum oload_search_type method,
2529 int lax, struct value **objp, struct symbol *fsym,
2530 struct value **valp, struct symbol **symp,
2531 int *staticp, const int no_adl)
2533 struct value *obj = (objp ? *objp : NULL);
2534 struct type *obj_type = obj ? value_type (obj) : NULL;
2535 /* Index of best overloaded function. */
2536 int func_oload_champ = -1;
2537 int method_oload_champ = -1;
2539 /* The measure for the current best match. */
2540 struct badness_vector *method_badness = NULL;
2541 struct badness_vector *func_badness = NULL;
2543 struct value *temp = obj;
2544 /* For methods, the list of overloaded methods. */
2545 struct fn_field *fns_ptr = NULL;
2546 /* For non-methods, the list of overloaded function symbols. */
2547 struct symbol **oload_syms = NULL;
2548 /* Number of overloaded instances being considered. */
2550 struct type *basetype = NULL;
2553 struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2555 const char *obj_type_name = NULL;
2556 const char *func_name = NULL;
2557 enum oload_classification match_quality;
2558 enum oload_classification method_match_quality = INCOMPATIBLE;
2559 enum oload_classification func_match_quality = INCOMPATIBLE;
2561 /* Get the list of overloaded methods or functions. */
2562 if (method == METHOD || method == BOTH)
2566 /* OBJ may be a pointer value rather than the object itself. */
2567 obj = coerce_ref (obj);
2568 while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2569 obj = coerce_ref (value_ind (obj));
2570 obj_type_name = TYPE_NAME (value_type (obj));
2572 /* First check whether this is a data member, e.g. a pointer to
2574 if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2576 *valp = search_struct_field (name, obj, 0,
2577 check_typedef (value_type (obj)), 0);
2581 do_cleanups (all_cleanups);
2586 /* Retrieve the list of methods with the name NAME. */
2587 fns_ptr = value_find_oload_method_list (&temp, name,
2589 &basetype, &boffset);
2590 /* If this is a method only search, and no methods were found
2591 the search has faild. */
2592 if (method == METHOD && (!fns_ptr || !num_fns))
2593 error (_("Couldn't find method %s%s%s"),
2595 (obj_type_name && *obj_type_name) ? "::" : "",
2597 /* If we are dealing with stub method types, they should have
2598 been resolved by find_method_list via
2599 value_find_oload_method_list above. */
2602 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2603 method_oload_champ = find_oload_champ (args, nargs, method,
2605 oload_syms, &method_badness);
2607 method_match_quality =
2608 classify_oload_match (method_badness, nargs,
2609 oload_method_static (method, fns_ptr,
2610 method_oload_champ));
2612 make_cleanup (xfree, method_badness);
2617 if (method == NON_METHOD || method == BOTH)
2619 const char *qualified_name = NULL;
2621 /* If the overload match is being search for both as a method
2622 and non member function, the first argument must now be
2625 deprecated_set_value_type (args[0],
2626 TYPE_TARGET_TYPE (value_type (args[0])));
2630 qualified_name = SYMBOL_NATURAL_NAME (fsym);
2632 /* If we have a function with a C++ name, try to extract just
2633 the function part. Do not try this for non-functions (e.g.
2634 function pointers). */
2636 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
2641 temp = cp_func_name (qualified_name);
2643 /* If cp_func_name did not remove anything, the name of the
2644 symbol did not include scope or argument types - it was
2645 probably a C-style function. */
2648 make_cleanup (xfree, temp);
2649 if (strcmp (temp, qualified_name) == 0)
2659 qualified_name = name;
2662 /* If there was no C++ name, this must be a C-style function or
2663 not a function at all. Just return the same symbol. Do the
2664 same if cp_func_name fails for some reason. */
2665 if (func_name == NULL)
2668 do_cleanups (all_cleanups);
2672 func_oload_champ = find_oload_champ_namespace (args, nargs,
2679 if (func_oload_champ >= 0)
2680 func_match_quality = classify_oload_match (func_badness, nargs, 0);
2682 make_cleanup (xfree, oload_syms);
2683 make_cleanup (xfree, func_badness);
2686 /* Did we find a match ? */
2687 if (method_oload_champ == -1 && func_oload_champ == -1)
2688 throw_error (NOT_FOUND_ERROR,
2689 _("No symbol \"%s\" in current context."),
2692 /* If we have found both a method match and a function
2693 match, find out which one is better, and calculate match
2695 if (method_oload_champ >= 0 && func_oload_champ >= 0)
2697 switch (compare_badness (func_badness, method_badness))
2699 case 0: /* Top two contenders are equally good. */
2700 /* FIXME: GDB does not support the general ambiguous case.
2701 All candidates should be collected and presented the
2703 error (_("Ambiguous overload resolution"));
2705 case 1: /* Incomparable top contenders. */
2706 /* This is an error incompatible candidates
2707 should not have been proposed. */
2708 error (_("Internal error: incompatible "
2709 "overload candidates proposed"));
2711 case 2: /* Function champion. */
2712 method_oload_champ = -1;
2713 match_quality = func_match_quality;
2715 case 3: /* Method champion. */
2716 func_oload_champ = -1;
2717 match_quality = method_match_quality;
2720 error (_("Internal error: unexpected overload comparison result"));
2726 /* We have either a method match or a function match. */
2727 if (method_oload_champ >= 0)
2728 match_quality = method_match_quality;
2730 match_quality = func_match_quality;
2733 if (match_quality == INCOMPATIBLE)
2735 if (method == METHOD)
2736 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2738 (obj_type_name && *obj_type_name) ? "::" : "",
2741 error (_("Cannot resolve function %s to any overloaded instance"),
2744 else if (match_quality == NON_STANDARD)
2746 if (method == METHOD)
2747 warning (_("Using non-standard conversion to match "
2748 "method %s%s%s to supplied arguments"),
2750 (obj_type_name && *obj_type_name) ? "::" : "",
2753 warning (_("Using non-standard conversion to match "
2754 "function %s to supplied arguments"),
2758 if (staticp != NULL)
2759 *staticp = oload_method_static (method, fns_ptr, method_oload_champ);
2761 if (method_oload_champ >= 0)
2763 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ))
2764 *valp = value_virtual_fn_field (&temp, fns_ptr, method_oload_champ,
2767 *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2771 *symp = oload_syms[func_oload_champ];
2775 struct type *temp_type = check_typedef (value_type (temp));
2776 struct type *objtype = check_typedef (obj_type);
2778 if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2779 && (TYPE_CODE (objtype) == TYPE_CODE_PTR
2780 || TYPE_CODE (objtype) == TYPE_CODE_REF))
2782 temp = value_addr (temp);
2787 do_cleanups (all_cleanups);
2789 switch (match_quality)
2795 default: /* STANDARD */
2800 /* Find the best overload match, searching for FUNC_NAME in namespaces
2801 contained in QUALIFIED_NAME until it either finds a good match or
2802 runs out of namespaces. It stores the overloaded functions in
2803 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2804 calling function is responsible for freeing *OLOAD_SYMS and
2805 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2809 find_oload_champ_namespace (struct value **args, int nargs,
2810 const char *func_name,
2811 const char *qualified_name,
2812 struct symbol ***oload_syms,
2813 struct badness_vector **oload_champ_bv,
2818 find_oload_champ_namespace_loop (args, nargs,
2821 oload_syms, oload_champ_bv,
2828 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2829 how deep we've looked for namespaces, and the champ is stored in
2830 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2831 if it isn't. Other arguments are the same as in
2832 find_oload_champ_namespace
2834 It is the caller's responsibility to free *OLOAD_SYMS and
2838 find_oload_champ_namespace_loop (struct value **args, int nargs,
2839 const char *func_name,
2840 const char *qualified_name,
2842 struct symbol ***oload_syms,
2843 struct badness_vector **oload_champ_bv,
2847 int next_namespace_len = namespace_len;
2848 int searched_deeper = 0;
2850 struct cleanup *old_cleanups;
2851 int new_oload_champ;
2852 struct symbol **new_oload_syms;
2853 struct badness_vector *new_oload_champ_bv;
2854 char *new_namespace;
2856 if (next_namespace_len != 0)
2858 gdb_assert (qualified_name[next_namespace_len] == ':');
2859 next_namespace_len += 2;
2861 next_namespace_len +=
2862 cp_find_first_component (qualified_name + next_namespace_len);
2864 /* Initialize these to values that can safely be xfree'd. */
2866 *oload_champ_bv = NULL;
2868 /* First, see if we have a deeper namespace we can search in.
2869 If we get a good match there, use it. */
2871 if (qualified_name[next_namespace_len] == ':')
2873 searched_deeper = 1;
2875 if (find_oload_champ_namespace_loop (args, nargs,
2876 func_name, qualified_name,
2878 oload_syms, oload_champ_bv,
2879 oload_champ, no_adl))
2885 /* If we reach here, either we're in the deepest namespace or we
2886 didn't find a good match in a deeper namespace. But, in the
2887 latter case, we still have a bad match in a deeper namespace;
2888 note that we might not find any match at all in the current
2889 namespace. (There's always a match in the deepest namespace,
2890 because this overload mechanism only gets called if there's a
2891 function symbol to start off with.) */
2893 old_cleanups = make_cleanup (xfree, *oload_syms);
2894 make_cleanup (xfree, *oload_champ_bv);
2895 new_namespace = alloca (namespace_len + 1);
2896 strncpy (new_namespace, qualified_name, namespace_len);
2897 new_namespace[namespace_len] = '\0';
2898 new_oload_syms = make_symbol_overload_list (func_name,
2901 /* If we have reached the deepest level perform argument
2902 determined lookup. */
2903 if (!searched_deeper && !no_adl)
2906 struct type **arg_types;
2908 /* Prepare list of argument types for overload resolution. */
2909 arg_types = (struct type **)
2910 alloca (nargs * (sizeof (struct type *)));
2911 for (ix = 0; ix < nargs; ix++)
2912 arg_types[ix] = value_type (args[ix]);
2913 make_symbol_overload_list_adl (arg_types, nargs, func_name);
2916 while (new_oload_syms[num_fns])
2919 new_oload_champ = find_oload_champ (args, nargs, 0, num_fns,
2920 NULL, new_oload_syms,
2921 &new_oload_champ_bv);
2923 /* Case 1: We found a good match. Free earlier matches (if any),
2924 and return it. Case 2: We didn't find a good match, but we're
2925 not the deepest function. Then go with the bad match that the
2926 deeper function found. Case 3: We found a bad match, and we're
2927 the deepest function. Then return what we found, even though
2928 it's a bad match. */
2930 if (new_oload_champ != -1
2931 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2933 *oload_syms = new_oload_syms;
2934 *oload_champ = new_oload_champ;
2935 *oload_champ_bv = new_oload_champ_bv;
2936 do_cleanups (old_cleanups);
2939 else if (searched_deeper)
2941 xfree (new_oload_syms);
2942 xfree (new_oload_champ_bv);
2943 discard_cleanups (old_cleanups);
2948 *oload_syms = new_oload_syms;
2949 *oload_champ = new_oload_champ;
2950 *oload_champ_bv = new_oload_champ_bv;
2951 do_cleanups (old_cleanups);
2956 /* Look for a function to take NARGS args of ARGS. Find
2957 the best match from among the overloaded methods or functions
2958 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2959 The number of methods/functions in the list is given by NUM_FNS.
2960 Return the index of the best match; store an indication of the
2961 quality of the match in OLOAD_CHAMP_BV.
2963 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2966 find_oload_champ (struct value **args, int nargs, int method,
2967 int num_fns, struct fn_field *fns_ptr,
2968 struct symbol **oload_syms,
2969 struct badness_vector **oload_champ_bv)
2972 /* A measure of how good an overloaded instance is. */
2973 struct badness_vector *bv;
2974 /* Index of best overloaded function. */
2975 int oload_champ = -1;
2976 /* Current ambiguity state for overload resolution. */
2977 int oload_ambiguous = 0;
2978 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2980 *oload_champ_bv = NULL;
2982 /* Consider each candidate in turn. */
2983 for (ix = 0; ix < num_fns; ix++)
2986 int static_offset = oload_method_static (method, fns_ptr, ix);
2988 struct type **parm_types;
2992 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2996 /* If it's not a method, this is the proper place. */
2997 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
3000 /* Prepare array of parameter types. */
3001 parm_types = (struct type **)
3002 xmalloc (nparms * (sizeof (struct type *)));
3003 for (jj = 0; jj < nparms; jj++)
3004 parm_types[jj] = (method
3005 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
3006 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
3009 /* Compare parameter types to supplied argument types. Skip
3010 THIS for static methods. */
3011 bv = rank_function (parm_types, nparms,
3012 args + static_offset,
3013 nargs - static_offset);
3015 if (!*oload_champ_bv)
3017 *oload_champ_bv = bv;
3020 else /* See whether current candidate is better or worse than
3022 switch (compare_badness (bv, *oload_champ_bv))
3024 case 0: /* Top two contenders are equally good. */
3025 oload_ambiguous = 1;
3027 case 1: /* Incomparable top contenders. */
3028 oload_ambiguous = 2;
3030 case 2: /* New champion, record details. */
3031 *oload_champ_bv = bv;
3032 oload_ambiguous = 0;
3043 fprintf_filtered (gdb_stderr,
3044 "Overloaded method instance %s, # of parms %d\n",
3045 fns_ptr[ix].physname, nparms);
3047 fprintf_filtered (gdb_stderr,
3048 "Overloaded function instance "
3049 "%s # of parms %d\n",
3050 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
3052 for (jj = 0; jj < nargs - static_offset; jj++)
3053 fprintf_filtered (gdb_stderr,
3054 "...Badness @ %d : %d\n",
3055 jj, bv->rank[jj].rank);
3056 fprintf_filtered (gdb_stderr, "Overload resolution "
3057 "champion is %d, ambiguous? %d\n",
3058 oload_champ, oload_ambiguous);
3065 /* Return 1 if we're looking at a static method, 0 if we're looking at
3066 a non-static method or a function that isn't a method. */
3069 oload_method_static (int method, struct fn_field *fns_ptr, int index)
3071 if (method && fns_ptr && index >= 0
3072 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3078 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3080 static enum oload_classification
3081 classify_oload_match (struct badness_vector *oload_champ_bv,
3086 enum oload_classification worst = STANDARD;
3088 for (ix = 1; ix <= nargs - static_offset; ix++)
3090 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3091 or worse return INCOMPATIBLE. */
3092 if (compare_ranks (oload_champ_bv->rank[ix],
3093 INCOMPATIBLE_TYPE_BADNESS) <= 0)
3094 return INCOMPATIBLE; /* Truly mismatched types. */
3095 /* Otherwise If this conversion is as bad as
3096 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3097 else if (compare_ranks (oload_champ_bv->rank[ix],
3098 NS_POINTER_CONVERSION_BADNESS) <= 0)
3099 worst = NON_STANDARD; /* Non-standard type conversions
3103 /* If no INCOMPATIBLE classification was found, return the worst one
3104 that was found (if any). */
3108 /* C++: return 1 is NAME is a legitimate name for the destructor of
3109 type TYPE. If TYPE does not have a destructor, or if NAME is
3110 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3111 have CHECK_TYPEDEF applied, this function will apply it itself. */
3114 destructor_name_p (const char *name, struct type *type)
3118 const char *dname = type_name_no_tag_or_error (type);
3119 const char *cp = strchr (dname, '<');
3122 /* Do not compare the template part for template classes. */
3124 len = strlen (dname);
3127 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3128 error (_("name of destructor must equal name of class"));
3135 /* Given TYPE, a structure/union,
3136 return 1 if the component named NAME from the ultimate target
3137 structure/union is defined, otherwise, return 0. */
3140 check_field (struct type *type, const char *name)
3144 /* The type may be a stub. */
3145 CHECK_TYPEDEF (type);
3147 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
3149 const char *t_field_name = TYPE_FIELD_NAME (type, i);
3151 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
3155 /* C++: If it was not found as a data field, then try to return it
3156 as a pointer to a method. */
3158 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
3160 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
3164 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
3165 if (check_field (TYPE_BASECLASS (type, i), name))
3171 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3172 return the appropriate member (or the address of the member, if
3173 WANT_ADDRESS). This function is used to resolve user expressions
3174 of the form "DOMAIN::NAME". For more details on what happens, see
3175 the comment before value_struct_elt_for_reference. */
3178 value_aggregate_elt (struct type *curtype, char *name,
3179 struct type *expect_type, int want_address,
3182 switch (TYPE_CODE (curtype))
3184 case TYPE_CODE_STRUCT:
3185 case TYPE_CODE_UNION:
3186 return value_struct_elt_for_reference (curtype, 0, curtype,
3188 want_address, noside);
3189 case TYPE_CODE_NAMESPACE:
3190 return value_namespace_elt (curtype, name,
3191 want_address, noside);
3193 internal_error (__FILE__, __LINE__,
3194 _("non-aggregate type in value_aggregate_elt"));
3198 /* Compares the two method/function types T1 and T2 for "equality"
3199 with respect to the methods' parameters. If the types of the
3200 two parameter lists are the same, returns 1; 0 otherwise. This
3201 comparison may ignore any artificial parameters in T1 if
3202 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3203 the first artificial parameter in T1, assumed to be a 'this' pointer.
3205 The type T2 is expected to have come from make_params (in eval.c). */
3208 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3212 if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3215 /* If skipping artificial fields, find the first real field
3217 if (skip_artificial)
3219 while (start < TYPE_NFIELDS (t1)
3220 && TYPE_FIELD_ARTIFICIAL (t1, start))
3224 /* Now compare parameters. */
3226 /* Special case: a method taking void. T1 will contain no
3227 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3228 if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3229 && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3232 if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3236 for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3238 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3239 TYPE_FIELD_TYPE (t2, i), NULL),
3240 EXACT_MATCH_BADNESS) != 0)
3250 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3251 return the address of this member as a "pointer to member" type.
3252 If INTYPE is non-null, then it will be the type of the member we
3253 are looking for. This will help us resolve "pointers to member
3254 functions". This function is used to resolve user expressions of
3255 the form "DOMAIN::NAME". */
3257 static struct value *
3258 value_struct_elt_for_reference (struct type *domain, int offset,
3259 struct type *curtype, char *name,
3260 struct type *intype,
3264 struct type *t = curtype;
3266 struct value *v, *result;
3268 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3269 && TYPE_CODE (t) != TYPE_CODE_UNION)
3270 error (_("Internal error: non-aggregate type "
3271 "to value_struct_elt_for_reference"));
3273 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3275 const char *t_field_name = TYPE_FIELD_NAME (t, i);
3277 if (t_field_name && strcmp (t_field_name, name) == 0)
3279 if (field_is_static (&TYPE_FIELD (t, i)))
3281 v = value_static_field (t, i);
3283 error (_("static field %s has been optimized out"),
3289 if (TYPE_FIELD_PACKED (t, i))
3290 error (_("pointers to bitfield members not allowed"));
3293 return value_from_longest
3294 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3295 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3296 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3297 return allocate_value (TYPE_FIELD_TYPE (t, i));
3299 error (_("Cannot reference non-static field \"%s\""), name);
3303 /* C++: If it was not found as a data field, then try to return it
3304 as a pointer to a method. */
3306 /* Perform all necessary dereferencing. */
3307 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3308 intype = TYPE_TARGET_TYPE (intype);
3310 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3312 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3313 char dem_opname[64];
3315 if (strncmp (t_field_name, "__", 2) == 0
3316 || strncmp (t_field_name, "op", 2) == 0
3317 || strncmp (t_field_name, "type", 4) == 0)
3319 if (cplus_demangle_opname (t_field_name,
3320 dem_opname, DMGL_ANSI))
3321 t_field_name = dem_opname;
3322 else if (cplus_demangle_opname (t_field_name,
3324 t_field_name = dem_opname;
3326 if (t_field_name && strcmp (t_field_name, name) == 0)
3329 int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3330 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3332 check_stub_method_group (t, i);
3336 for (j = 0; j < len; ++j)
3338 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3339 || compare_parameters (TYPE_FN_FIELD_TYPE (f, j),
3345 error (_("no member function matches "
3346 "that type instantiation"));
3353 for (ii = 0; ii < len; ++ii)
3355 /* Skip artificial methods. This is necessary if,
3356 for example, the user wants to "print
3357 subclass::subclass" with only one user-defined
3358 constructor. There is no ambiguity in this case.
3359 We are careful here to allow artificial methods
3360 if they are the unique result. */
3361 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3368 /* Desired method is ambiguous if more than one
3369 method is defined. */
3370 if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3371 error (_("non-unique member `%s' requires "
3372 "type instantiation"), name);
3378 error (_("no matching member function"));
3381 if (TYPE_FN_FIELD_STATIC_P (f, j))
3384 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3391 return value_addr (read_var_value (s, 0));
3393 return read_var_value (s, 0);
3396 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3400 result = allocate_value
3401 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3402 cplus_make_method_ptr (value_type (result),
3403 value_contents_writeable (result),
3404 TYPE_FN_FIELD_VOFFSET (f, j), 1);
3406 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3407 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3409 error (_("Cannot reference virtual member function \"%s\""),
3415 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3421 v = read_var_value (s, 0);
3426 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3427 cplus_make_method_ptr (value_type (result),
3428 value_contents_writeable (result),
3429 value_address (v), 0);
3435 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3440 if (BASETYPE_VIA_VIRTUAL (t, i))
3443 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3444 v = value_struct_elt_for_reference (domain,
3445 offset + base_offset,
3446 TYPE_BASECLASS (t, i),
3448 want_address, noside);
3453 /* As a last chance, pretend that CURTYPE is a namespace, and look
3454 it up that way; this (frequently) works for types nested inside
3457 return value_maybe_namespace_elt (curtype, name,
3458 want_address, noside);
3461 /* C++: Return the member NAME of the namespace given by the type
3464 static struct value *
3465 value_namespace_elt (const struct type *curtype,
3466 char *name, int want_address,
3469 struct value *retval = value_maybe_namespace_elt (curtype, name,
3474 error (_("No symbol \"%s\" in namespace \"%s\"."),
3475 name, TYPE_TAG_NAME (curtype));
3480 /* A helper function used by value_namespace_elt and
3481 value_struct_elt_for_reference. It looks up NAME inside the
3482 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3483 is a class and NAME refers to a type in CURTYPE itself (as opposed
3484 to, say, some base class of CURTYPE). */
3486 static struct value *
3487 value_maybe_namespace_elt (const struct type *curtype,
3488 char *name, int want_address,
3491 const char *namespace_name = TYPE_TAG_NAME (curtype);
3493 struct value *result;
3495 sym = cp_lookup_symbol_namespace (namespace_name, name,
3496 get_selected_block (0), VAR_DOMAIN);
3500 char *concatenated_name = alloca (strlen (namespace_name) + 2
3501 + strlen (name) + 1);
3503 sprintf (concatenated_name, "%s::%s", namespace_name, name);
3504 sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
3509 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3510 && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3511 result = allocate_value (SYMBOL_TYPE (sym));
3513 result = value_of_variable (sym, get_selected_block (0));
3515 if (result && want_address)
3516 result = value_addr (result);
3521 /* Given a pointer or a reference value V, find its real (RTTI) type.
3523 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3524 and refer to the values computed for the object pointed to. */
3527 value_rtti_indirect_type (struct value *v, int *full,
3528 int *top, int *using_enc)
3530 struct value *target;
3531 struct type *type, *real_type, *target_type;
3533 type = value_type (v);
3534 type = check_typedef (type);
3535 if (TYPE_CODE (type) == TYPE_CODE_REF)
3536 target = coerce_ref (v);
3537 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3538 target = value_ind (v);
3542 real_type = value_rtti_type (target, full, top, using_enc);
3546 /* Copy qualifiers to the referenced object. */
3547 target_type = value_type (target);
3548 real_type = make_cv_type (TYPE_CONST (target_type),
3549 TYPE_VOLATILE (target_type), real_type, NULL);
3550 if (TYPE_CODE (type) == TYPE_CODE_REF)
3551 real_type = lookup_reference_type (real_type);
3552 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3553 real_type = lookup_pointer_type (real_type);
3555 internal_error (__FILE__, __LINE__, _("Unexpected value type."));
3557 /* Copy qualifiers to the pointer/reference. */
3558 real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3565 /* Given a value pointed to by ARGP, check its real run-time type, and
3566 if that is different from the enclosing type, create a new value
3567 using the real run-time type as the enclosing type (and of the same
3568 type as ARGP) and return it, with the embedded offset adjusted to
3569 be the correct offset to the enclosed object. RTYPE is the type,
3570 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3571 by value_rtti_type(). If these are available, they can be supplied
3572 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3573 NULL if they're not available. */
3576 value_full_object (struct value *argp,
3578 int xfull, int xtop,
3581 struct type *real_type;
3585 struct value *new_val;
3592 using_enc = xusing_enc;
3595 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3597 /* If no RTTI data, or if object is already complete, do nothing. */
3598 if (!real_type || real_type == value_enclosing_type (argp))
3601 /* In a destructor we might see a real type that is a superclass of
3602 the object's type. In this case it is better to leave the object
3605 && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp)))
3608 /* If we have the full object, but for some reason the enclosing
3609 type is wrong, set it. */
3610 /* pai: FIXME -- sounds iffy */
3613 argp = value_copy (argp);
3614 set_value_enclosing_type (argp, real_type);
3618 /* Check if object is in memory. */
3619 if (VALUE_LVAL (argp) != lval_memory)
3621 warning (_("Couldn't retrieve complete object of RTTI "
3622 "type %s; object may be in register(s)."),
3623 TYPE_NAME (real_type));
3628 /* All other cases -- retrieve the complete object. */
3629 /* Go back by the computed top_offset from the beginning of the
3630 object, adjusting for the embedded offset of argp if that's what
3631 value_rtti_type used for its computation. */
3632 new_val = value_at_lazy (real_type, value_address (argp) - top +
3633 (using_enc ? 0 : value_embedded_offset (argp)));
3634 deprecated_set_value_type (new_val, value_type (argp));
3635 set_value_embedded_offset (new_val, (using_enc
3636 ? top + value_embedded_offset (argp)
3642 /* Return the value of the local variable, if one exists. Throw error
3643 otherwise, such as if the request is made in an inappropriate context. */
3646 value_of_this (const struct language_defn *lang)
3650 struct frame_info *frame;
3652 if (!lang->la_name_of_this)
3653 error (_("no `this' in current language"));
3655 frame = get_selected_frame (_("no frame selected"));
3657 b = get_frame_block (frame, NULL);
3659 sym = lookup_language_this (lang, b);
3661 error (_("current stack frame does not contain a variable named `%s'"),
3662 lang->la_name_of_this);
3664 return read_var_value (sym, frame);
3667 /* Return the value of the local variable, if one exists. Return NULL
3668 otherwise. Never throw error. */
3671 value_of_this_silent (const struct language_defn *lang)
3673 struct value *ret = NULL;
3674 volatile struct gdb_exception except;
3676 TRY_CATCH (except, RETURN_MASK_ERROR)
3678 ret = value_of_this (lang);
3684 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3685 elements long, starting at LOWBOUND. The result has the same lower
3686 bound as the original ARRAY. */
3689 value_slice (struct value *array, int lowbound, int length)
3691 struct type *slice_range_type, *slice_type, *range_type;
3692 LONGEST lowerbound, upperbound;
3693 struct value *slice;
3694 struct type *array_type;
3696 array_type = check_typedef (value_type (array));
3697 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3698 && TYPE_CODE (array_type) != TYPE_CODE_STRING
3699 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3700 error (_("cannot take slice of non-array"));
3702 range_type = TYPE_INDEX_TYPE (array_type);
3703 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3704 error (_("slice from bad array or bitstring"));
3706 if (lowbound < lowerbound || length < 0
3707 || lowbound + length - 1 > upperbound)
3708 error (_("slice out of range"));
3710 /* FIXME-type-allocation: need a way to free this type when we are
3712 slice_range_type = create_range_type ((struct type *) NULL,
3713 TYPE_TARGET_TYPE (range_type),
3715 lowbound + length - 1);
3716 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3720 slice_type = create_set_type ((struct type *) NULL,
3722 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3723 slice = value_zero (slice_type, not_lval);
3725 for (i = 0; i < length; i++)
3727 int element = value_bit_index (array_type,
3728 value_contents (array),
3732 error (_("internal error accessing bitstring"));
3733 else if (element > 0)
3735 int j = i % TARGET_CHAR_BIT;
3737 if (gdbarch_bits_big_endian (get_type_arch (array_type)))
3738 j = TARGET_CHAR_BIT - 1 - j;
3739 value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3742 /* We should set the address, bitssize, and bitspos, so the
3743 slice can be used on the LHS, but that may require extensions
3744 to value_assign. For now, just leave as a non_lval.
3749 struct type *element_type = TYPE_TARGET_TYPE (array_type);
3751 (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3753 slice_type = create_array_type ((struct type *) NULL,
3756 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3758 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3759 slice = allocate_value_lazy (slice_type);
3762 slice = allocate_value (slice_type);
3763 value_contents_copy (slice, 0, array, offset,
3764 TYPE_LENGTH (slice_type));
3767 set_value_component_location (slice, array);
3768 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3769 set_value_offset (slice, value_offset (array) + offset);
3774 /* Create a value for a FORTRAN complex number. Currently most of the
3775 time values are coerced to COMPLEX*16 (i.e. a complex number
3776 composed of 2 doubles. This really should be a smarter routine
3777 that figures out precision inteligently as opposed to assuming
3778 doubles. FIXME: fmb */
3781 value_literal_complex (struct value *arg1,
3786 struct type *real_type = TYPE_TARGET_TYPE (type);
3788 val = allocate_value (type);
3789 arg1 = value_cast (real_type, arg1);
3790 arg2 = value_cast (real_type, arg2);
3792 memcpy (value_contents_raw (val),
3793 value_contents (arg1), TYPE_LENGTH (real_type));
3794 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3795 value_contents (arg2), TYPE_LENGTH (real_type));
3799 /* Cast a value into the appropriate complex data type. */
3801 static struct value *
3802 cast_into_complex (struct type *type, struct value *val)
3804 struct type *real_type = TYPE_TARGET_TYPE (type);
3806 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3808 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3809 struct value *re_val = allocate_value (val_real_type);
3810 struct value *im_val = allocate_value (val_real_type);
3812 memcpy (value_contents_raw (re_val),
3813 value_contents (val), TYPE_LENGTH (val_real_type));
3814 memcpy (value_contents_raw (im_val),
3815 value_contents (val) + TYPE_LENGTH (val_real_type),
3816 TYPE_LENGTH (val_real_type));
3818 return value_literal_complex (re_val, im_val, type);
3820 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3821 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3822 return value_literal_complex (val,
3823 value_zero (real_type, not_lval),
3826 error (_("cannot cast non-number to complex"));
3830 _initialize_valops (void)
3832 add_setshow_boolean_cmd ("overload-resolution", class_support,
3833 &overload_resolution, _("\
3834 Set overload resolution in evaluating C++ functions."), _("\
3835 Show overload resolution in evaluating C++ functions."),
3837 show_overload_resolution,
3838 &setlist, &showlist);
3839 overload_resolution = 1;