1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2014 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 "tracepoint.h"
42 #include "exceptions.h"
43 #include "extension.h"
45 extern unsigned int overload_debug;
46 /* Local functions. */
48 static int typecmp (int staticp, int varargs, int nargs,
49 struct field t1[], struct value *t2[]);
51 static struct value *search_struct_field (const char *, struct value *,
52 int, struct type *, int);
54 static struct value *search_struct_method (const char *, struct value **,
56 int, int *, struct type *);
58 static int find_oload_champ_namespace (struct value **, int,
59 const char *, const char *,
61 struct badness_vector **,
65 int find_oload_champ_namespace_loop (struct value **, int,
66 const char *, const char *,
67 int, struct symbol ***,
68 struct badness_vector **, int *,
71 static int find_oload_champ (struct value **, int, int,
72 struct fn_field *, VEC (xmethod_worker_ptr) *,
73 struct symbol **, struct badness_vector **);
75 static int oload_method_static_p (struct fn_field *, int);
77 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
80 oload_classification classify_oload_match (struct badness_vector *,
83 static struct value *value_struct_elt_for_reference (struct type *,
89 static struct value *value_namespace_elt (const struct type *,
90 const char *, int , enum noside);
92 static struct value *value_maybe_namespace_elt (const struct type *,
96 static CORE_ADDR allocate_space_in_inferior (int);
98 static struct value *cast_into_complex (struct type *, struct value *);
100 static void find_method_list (struct value **, const char *,
101 int, struct type *, struct fn_field **, int *,
102 VEC (xmethod_worker_ptr) **,
103 struct type **, int *);
105 void _initialize_valops (void);
108 /* Flag for whether we want to abandon failed expression evals by
111 static int auto_abandon = 0;
114 int overload_resolution = 0;
116 show_overload_resolution (struct ui_file *file, int from_tty,
117 struct cmd_list_element *c,
120 fprintf_filtered (file, _("Overload resolution in evaluating "
121 "C++ functions is %s.\n"),
125 /* Find the address of function name NAME in the inferior. If OBJF_P
126 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
130 find_function_in_inferior (const char *name, struct objfile **objf_p)
134 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
137 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
139 error (_("\"%s\" exists in this program but is not a function."),
144 *objf_p = SYMBOL_SYMTAB (sym)->objfile;
146 return value_of_variable (sym, NULL);
150 struct bound_minimal_symbol msymbol =
151 lookup_bound_minimal_symbol (name);
153 if (msymbol.minsym != NULL)
155 struct objfile *objfile = msymbol.objfile;
156 struct gdbarch *gdbarch = get_objfile_arch (objfile);
160 type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
161 type = lookup_function_type (type);
162 type = lookup_pointer_type (type);
163 maddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
168 return value_from_pointer (type, maddr);
172 if (!target_has_execution)
173 error (_("evaluation of this expression "
174 "requires the target program to be active"));
176 error (_("evaluation of this expression requires the "
177 "program to have a function \"%s\"."),
183 /* Allocate NBYTES of space in the inferior using the inferior's
184 malloc and return a value that is a pointer to the allocated
188 value_allocate_space_in_inferior (int len)
190 struct objfile *objf;
191 struct value *val = find_function_in_inferior ("malloc", &objf);
192 struct gdbarch *gdbarch = get_objfile_arch (objf);
193 struct value *blocklen;
195 blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
196 val = call_function_by_hand (val, 1, &blocklen);
197 if (value_logical_not (val))
199 if (!target_has_execution)
200 error (_("No memory available to program now: "
201 "you need to start the target first"));
203 error (_("No memory available to program: call to malloc failed"));
209 allocate_space_in_inferior (int len)
211 return value_as_long (value_allocate_space_in_inferior (len));
214 /* Cast struct value VAL to type TYPE and return as a value.
215 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
216 for this to work. Typedef to one of the codes is permitted.
217 Returns NULL if the cast is neither an upcast nor a downcast. */
219 static struct value *
220 value_cast_structs (struct type *type, struct value *v2)
226 gdb_assert (type != NULL && v2 != NULL);
228 t1 = check_typedef (type);
229 t2 = check_typedef (value_type (v2));
231 /* Check preconditions. */
232 gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
233 || TYPE_CODE (t1) == TYPE_CODE_UNION)
234 && !!"Precondition is that type is of STRUCT or UNION kind.");
235 gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
236 || TYPE_CODE (t2) == TYPE_CODE_UNION)
237 && !!"Precondition is that value is of STRUCT or UNION kind");
239 if (TYPE_NAME (t1) != NULL
240 && TYPE_NAME (t2) != NULL
241 && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
244 /* Upcasting: look in the type of the source to see if it contains the
245 type of the target as a superclass. If so, we'll need to
246 offset the pointer rather than just change its type. */
247 if (TYPE_NAME (t1) != NULL)
249 v = search_struct_field (type_name_no_tag (t1),
255 /* Downcasting: look in the type of the target to see if it contains the
256 type of the source as a superclass. If so, we'll need to
257 offset the pointer rather than just change its type. */
258 if (TYPE_NAME (t2) != NULL)
260 /* Try downcasting using the run-time type of the value. */
261 int full, top, using_enc;
262 struct type *real_type;
264 real_type = value_rtti_type (v2, &full, &top, &using_enc);
267 v = value_full_object (v2, real_type, full, top, using_enc);
268 v = value_at_lazy (real_type, value_address (v));
269 real_type = value_type (v);
271 /* We might be trying to cast to the outermost enclosing
272 type, in which case search_struct_field won't work. */
273 if (TYPE_NAME (real_type) != NULL
274 && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
277 v = search_struct_field (type_name_no_tag (t2), v, 0, real_type, 1);
282 /* Try downcasting using information from the destination type
283 T2. This wouldn't work properly for classes with virtual
284 bases, but those were handled above. */
285 v = search_struct_field (type_name_no_tag (t2),
286 value_zero (t1, not_lval), 0, t1, 1);
289 /* Downcasting is possible (t1 is superclass of v2). */
290 CORE_ADDR addr2 = value_address (v2);
292 addr2 -= value_address (v) + value_embedded_offset (v);
293 return value_at (type, addr2);
300 /* Cast one pointer or reference type to another. Both TYPE and
301 the type of ARG2 should be pointer types, or else both should be
302 reference types. If SUBCLASS_CHECK is non-zero, this will force a
303 check to see whether TYPE is a superclass of ARG2's type. If
304 SUBCLASS_CHECK is zero, then the subclass check is done only when
305 ARG2 is itself non-zero. Returns the new pointer or reference. */
308 value_cast_pointers (struct type *type, struct value *arg2,
311 struct type *type1 = check_typedef (type);
312 struct type *type2 = check_typedef (value_type (arg2));
313 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
314 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
316 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
317 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
318 && (subclass_check || !value_logical_not (arg2)))
322 if (TYPE_CODE (type2) == TYPE_CODE_REF)
323 v2 = coerce_ref (arg2);
325 v2 = value_ind (arg2);
326 gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
327 == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
328 v2 = value_cast_structs (t1, v2);
329 /* At this point we have what we can have, un-dereference if needed. */
332 struct value *v = value_addr (v2);
334 deprecated_set_value_type (v, type);
339 /* No superclass found, just change the pointer type. */
340 arg2 = value_copy (arg2);
341 deprecated_set_value_type (arg2, type);
342 set_value_enclosing_type (arg2, type);
343 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
347 /* Cast value ARG2 to type TYPE and return as a value.
348 More general than a C cast: accepts any two types of the same length,
349 and if ARG2 is an lvalue it can be cast into anything at all. */
350 /* In C++, casts may change pointer or object representations. */
353 value_cast (struct type *type, struct value *arg2)
355 enum type_code code1;
356 enum type_code code2;
360 int convert_to_boolean = 0;
362 if (value_type (arg2) == type)
365 code1 = TYPE_CODE (check_typedef (type));
367 /* Check if we are casting struct reference to struct reference. */
368 if (code1 == TYPE_CODE_REF)
370 /* We dereference type; then we recurse and finally
371 we generate value of the given reference. Nothing wrong with
373 struct type *t1 = check_typedef (type);
374 struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
375 struct value *val = value_cast (dereftype, arg2);
377 return value_ref (val);
380 code2 = TYPE_CODE (check_typedef (value_type (arg2)));
382 if (code2 == TYPE_CODE_REF)
383 /* We deref the value and then do the cast. */
384 return value_cast (type, coerce_ref (arg2));
386 CHECK_TYPEDEF (type);
387 code1 = TYPE_CODE (type);
388 arg2 = coerce_ref (arg2);
389 type2 = check_typedef (value_type (arg2));
391 /* You can't cast to a reference type. See value_cast_pointers
393 gdb_assert (code1 != TYPE_CODE_REF);
395 /* A cast to an undetermined-length array_type, such as
396 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
397 where N is sizeof(OBJECT)/sizeof(TYPE). */
398 if (code1 == TYPE_CODE_ARRAY)
400 struct type *element_type = TYPE_TARGET_TYPE (type);
401 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
403 if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
405 struct type *range_type = TYPE_INDEX_TYPE (type);
406 int val_length = TYPE_LENGTH (type2);
407 LONGEST low_bound, high_bound, new_length;
409 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
410 low_bound = 0, high_bound = 0;
411 new_length = val_length / element_length;
412 if (val_length % element_length != 0)
413 warning (_("array element type size does not "
414 "divide object size in cast"));
415 /* FIXME-type-allocation: need a way to free this type when
416 we are done with it. */
417 range_type = create_static_range_type ((struct type *) NULL,
418 TYPE_TARGET_TYPE (range_type),
420 new_length + low_bound - 1);
421 deprecated_set_value_type (arg2,
422 create_array_type ((struct type *) NULL,
429 if (current_language->c_style_arrays
430 && TYPE_CODE (type2) == TYPE_CODE_ARRAY
431 && !TYPE_VECTOR (type2))
432 arg2 = value_coerce_array (arg2);
434 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
435 arg2 = value_coerce_function (arg2);
437 type2 = check_typedef (value_type (arg2));
438 code2 = TYPE_CODE (type2);
440 if (code1 == TYPE_CODE_COMPLEX)
441 return cast_into_complex (type, arg2);
442 if (code1 == TYPE_CODE_BOOL)
444 code1 = TYPE_CODE_INT;
445 convert_to_boolean = 1;
447 if (code1 == TYPE_CODE_CHAR)
448 code1 = TYPE_CODE_INT;
449 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
450 code2 = TYPE_CODE_INT;
452 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
453 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
454 || code2 == TYPE_CODE_RANGE);
456 if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
457 && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
458 && TYPE_NAME (type) != 0)
460 struct value *v = value_cast_structs (type, arg2);
466 if (code1 == TYPE_CODE_FLT && scalar)
467 return value_from_double (type, value_as_double (arg2));
468 else if (code1 == TYPE_CODE_DECFLOAT && scalar)
470 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
471 int dec_len = TYPE_LENGTH (type);
474 if (code2 == TYPE_CODE_FLT)
475 decimal_from_floating (arg2, dec, dec_len, byte_order);
476 else if (code2 == TYPE_CODE_DECFLOAT)
477 decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
478 byte_order, dec, dec_len, byte_order);
480 /* The only option left is an integral type. */
481 decimal_from_integral (arg2, dec, dec_len, byte_order);
483 return value_from_decfloat (type, dec);
485 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
486 || code1 == TYPE_CODE_RANGE)
487 && (scalar || code2 == TYPE_CODE_PTR
488 || code2 == TYPE_CODE_MEMBERPTR))
492 /* When we cast pointers to integers, we mustn't use
493 gdbarch_pointer_to_address to find the address the pointer
494 represents, as value_as_long would. GDB should evaluate
495 expressions just as the compiler would --- and the compiler
496 sees a cast as a simple reinterpretation of the pointer's
498 if (code2 == TYPE_CODE_PTR)
499 longest = extract_unsigned_integer
500 (value_contents (arg2), TYPE_LENGTH (type2),
501 gdbarch_byte_order (get_type_arch (type2)));
503 longest = value_as_long (arg2);
504 return value_from_longest (type, convert_to_boolean ?
505 (LONGEST) (longest ? 1 : 0) : longest);
507 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
508 || code2 == TYPE_CODE_ENUM
509 || code2 == TYPE_CODE_RANGE))
511 /* TYPE_LENGTH (type) is the length of a pointer, but we really
512 want the length of an address! -- we are really dealing with
513 addresses (i.e., gdb representations) not pointers (i.e.,
514 target representations) here.
516 This allows things like "print *(int *)0x01000234" to work
517 without printing a misleading message -- which would
518 otherwise occur when dealing with a target having two byte
519 pointers and four byte addresses. */
521 int addr_bit = gdbarch_addr_bit (get_type_arch (type2));
522 LONGEST longest = value_as_long (arg2);
524 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
526 if (longest >= ((LONGEST) 1 << addr_bit)
527 || longest <= -((LONGEST) 1 << addr_bit))
528 warning (_("value truncated"));
530 return value_from_longest (type, longest);
532 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
533 && value_as_long (arg2) == 0)
535 struct value *result = allocate_value (type);
537 cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0);
540 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
541 && value_as_long (arg2) == 0)
543 /* The Itanium C++ ABI represents NULL pointers to members as
544 minus one, instead of biasing the normal case. */
545 return value_from_longest (type, -1);
547 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
548 && code2 == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)
549 && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
550 error (_("Cannot convert between vector values of different sizes"));
551 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && scalar
552 && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
553 error (_("can only cast scalar to vector of same size"));
554 else if (code1 == TYPE_CODE_VOID)
556 return value_zero (type, not_lval);
558 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
560 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
561 return value_cast_pointers (type, arg2, 0);
563 arg2 = value_copy (arg2);
564 deprecated_set_value_type (arg2, type);
565 set_value_enclosing_type (arg2, type);
566 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
569 else if (VALUE_LVAL (arg2) == lval_memory)
570 return value_at_lazy (type, value_address (arg2));
573 error (_("Invalid cast."));
578 /* The C++ reinterpret_cast operator. */
581 value_reinterpret_cast (struct type *type, struct value *arg)
583 struct value *result;
584 struct type *real_type = check_typedef (type);
585 struct type *arg_type, *dest_type;
587 enum type_code dest_code, arg_code;
589 /* Do reference, function, and array conversion. */
590 arg = coerce_array (arg);
592 /* Attempt to preserve the type the user asked for. */
595 /* If we are casting to a reference type, transform
596 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
597 if (TYPE_CODE (real_type) == TYPE_CODE_REF)
600 arg = value_addr (arg);
601 dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
602 real_type = lookup_pointer_type (real_type);
605 arg_type = value_type (arg);
607 dest_code = TYPE_CODE (real_type);
608 arg_code = TYPE_CODE (arg_type);
610 /* We can convert pointer types, or any pointer type to int, or int
612 if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
613 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
614 || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
615 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
616 || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
617 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
618 || (dest_code == arg_code
619 && (dest_code == TYPE_CODE_PTR
620 || dest_code == TYPE_CODE_METHODPTR
621 || dest_code == TYPE_CODE_MEMBERPTR)))
622 result = value_cast (dest_type, arg);
624 error (_("Invalid reinterpret_cast"));
627 result = value_cast (type, value_ref (value_ind (result)));
632 /* A helper for value_dynamic_cast. This implements the first of two
633 runtime checks: we iterate over all the base classes of the value's
634 class which are equal to the desired class; if only one of these
635 holds the value, then it is the answer. */
638 dynamic_cast_check_1 (struct type *desired_type,
639 const gdb_byte *valaddr,
643 struct type *search_type,
645 struct type *arg_type,
646 struct value **result)
648 int i, result_count = 0;
650 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
652 int offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
655 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
657 if (address + embedded_offset + offset >= arg_addr
658 && address + embedded_offset + offset < arg_addr + TYPE_LENGTH (arg_type))
662 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
663 address + embedded_offset + offset);
667 result_count += dynamic_cast_check_1 (desired_type,
669 embedded_offset + offset,
671 TYPE_BASECLASS (search_type, i),
680 /* A helper for value_dynamic_cast. This implements the second of two
681 runtime checks: we look for a unique public sibling class of the
682 argument's declared class. */
685 dynamic_cast_check_2 (struct type *desired_type,
686 const gdb_byte *valaddr,
690 struct type *search_type,
691 struct value **result)
693 int i, result_count = 0;
695 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
699 if (! BASETYPE_VIA_PUBLIC (search_type, i))
702 offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
704 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
708 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
709 address + embedded_offset + offset);
712 result_count += dynamic_cast_check_2 (desired_type,
714 embedded_offset + offset,
716 TYPE_BASECLASS (search_type, i),
723 /* The C++ dynamic_cast operator. */
726 value_dynamic_cast (struct type *type, struct value *arg)
728 int full, top, using_enc;
729 struct type *resolved_type = check_typedef (type);
730 struct type *arg_type = check_typedef (value_type (arg));
731 struct type *class_type, *rtti_type;
732 struct value *result, *tem, *original_arg = arg;
734 int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF;
736 if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
737 && TYPE_CODE (resolved_type) != TYPE_CODE_REF)
738 error (_("Argument to dynamic_cast must be a pointer or reference type"));
739 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
740 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_CLASS)
741 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
743 class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
744 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
746 if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
747 && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
748 && value_as_long (arg) == 0))
749 error (_("Argument to dynamic_cast does not have pointer type"));
750 if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
752 arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
753 if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
754 error (_("Argument to dynamic_cast does "
755 "not have pointer to class type"));
758 /* Handle NULL pointers. */
759 if (value_as_long (arg) == 0)
760 return value_zero (type, not_lval);
762 arg = value_ind (arg);
766 if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
767 error (_("Argument to dynamic_cast does not have class type"));
770 /* If the classes are the same, just return the argument. */
771 if (class_types_same_p (class_type, arg_type))
772 return value_cast (type, arg);
774 /* If the target type is a unique base class of the argument's
775 declared type, just cast it. */
776 if (is_ancestor (class_type, arg_type))
778 if (is_unique_ancestor (class_type, arg))
779 return value_cast (type, original_arg);
780 error (_("Ambiguous dynamic_cast"));
783 rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
785 error (_("Couldn't determine value's most derived type for dynamic_cast"));
787 /* Compute the most derived object's address. */
788 addr = value_address (arg);
796 addr += top + value_embedded_offset (arg);
798 /* dynamic_cast<void *> means to return a pointer to the
799 most-derived object. */
800 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
801 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
802 return value_at_lazy (type, addr);
804 tem = value_at (type, addr);
805 type = value_type (tem);
807 /* The first dynamic check specified in 5.2.7. */
808 if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
810 if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
813 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
814 value_contents_for_printing (tem),
815 value_embedded_offset (tem),
816 value_address (tem), tem,
820 return value_cast (type,
821 is_ref ? value_ref (result) : value_addr (result));
824 /* The second dynamic check specified in 5.2.7. */
826 if (is_public_ancestor (arg_type, rtti_type)
827 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
828 value_contents_for_printing (tem),
829 value_embedded_offset (tem),
830 value_address (tem), tem,
831 rtti_type, &result) == 1)
832 return value_cast (type,
833 is_ref ? value_ref (result) : value_addr (result));
835 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
836 return value_zero (type, not_lval);
838 error (_("dynamic_cast failed"));
841 /* Create a value of type TYPE that is zero, and return it. */
844 value_zero (struct type *type, enum lval_type lv)
846 struct value *val = allocate_value (type);
848 VALUE_LVAL (val) = (lv == lval_computed ? not_lval : lv);
852 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
855 value_one (struct type *type)
857 struct type *type1 = check_typedef (type);
860 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
862 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
865 decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
866 val = value_from_decfloat (type, v);
868 else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
870 val = value_from_double (type, (DOUBLEST) 1);
872 else if (is_integral_type (type1))
874 val = value_from_longest (type, (LONGEST) 1);
876 else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
878 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
880 LONGEST low_bound, high_bound;
883 if (!get_array_bounds (type1, &low_bound, &high_bound))
884 error (_("Could not determine the vector bounds"));
886 val = allocate_value (type);
887 for (i = 0; i < high_bound - low_bound + 1; i++)
889 tmp = value_one (eltype);
890 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
891 value_contents_all (tmp), TYPE_LENGTH (eltype));
896 error (_("Not a numeric type."));
899 /* value_one result is never used for assignments to. */
900 gdb_assert (VALUE_LVAL (val) == not_lval);
905 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
906 The type of the created value may differ from the passed type TYPE.
907 Make sure to retrieve the returned values's new type after this call
908 e.g. in case the type is a variable length array. */
910 static struct value *
911 get_value_at (struct type *type, CORE_ADDR addr, int lazy)
915 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
916 error (_("Attempt to dereference a generic pointer."));
918 val = value_from_contents_and_address (type, NULL, addr);
921 value_fetch_lazy (val);
926 /* Return a value with type TYPE located at ADDR.
928 Call value_at only if the data needs to be fetched immediately;
929 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
930 value_at_lazy instead. value_at_lazy simply records the address of
931 the data and sets the lazy-evaluation-required flag. The lazy flag
932 is tested in the value_contents macro, which is used if and when
933 the contents are actually required. The type of the created value
934 may differ from the passed type TYPE. Make sure to retrieve the
935 returned values's new type after this call e.g. in case the type
936 is a variable length array.
938 Note: value_at does *NOT* handle embedded offsets; perform such
939 adjustments before or after calling it. */
942 value_at (struct type *type, CORE_ADDR addr)
944 return get_value_at (type, addr, 0);
947 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
948 The type of the created value may differ from the passed type TYPE.
949 Make sure to retrieve the returned values's new type after this call
950 e.g. in case the type is a variable length array. */
953 value_at_lazy (struct type *type, CORE_ADDR addr)
955 return get_value_at (type, addr, 1);
959 read_value_memory (struct value *val, int embedded_offset,
960 int stack, CORE_ADDR memaddr,
961 gdb_byte *buffer, size_t length)
965 while (xfered < length)
967 enum target_xfer_status status;
970 status = target_xfer_partial (current_target.beneath,
971 TARGET_OBJECT_MEMORY, NULL,
972 buffer + xfered, NULL,
973 memaddr + xfered, length - xfered,
976 if (status == TARGET_XFER_OK)
978 else if (status == TARGET_XFER_UNAVAILABLE)
979 mark_value_bytes_unavailable (val, embedded_offset + xfered,
981 else if (status == TARGET_XFER_EOF)
982 memory_error (TARGET_XFER_E_IO, memaddr + xfered);
984 memory_error (status, memaddr + xfered);
986 xfered += xfered_len;
991 /* Store the contents of FROMVAL into the location of TOVAL.
992 Return a new value with the location of TOVAL and contents of FROMVAL. */
995 value_assign (struct value *toval, struct value *fromval)
999 struct frame_id old_frame;
1001 if (!deprecated_value_modifiable (toval))
1002 error (_("Left operand of assignment is not a modifiable lvalue."));
1004 toval = coerce_ref (toval);
1006 type = value_type (toval);
1007 if (VALUE_LVAL (toval) != lval_internalvar)
1008 fromval = value_cast (type, fromval);
1011 /* Coerce arrays and functions to pointers, except for arrays
1012 which only live in GDB's storage. */
1013 if (!value_must_coerce_to_target (fromval))
1014 fromval = coerce_array (fromval);
1017 CHECK_TYPEDEF (type);
1019 /* Since modifying a register can trash the frame chain, and
1020 modifying memory can trash the frame cache, we save the old frame
1021 and then restore the new frame afterwards. */
1022 old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
1024 switch (VALUE_LVAL (toval))
1026 case lval_internalvar:
1027 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1028 return value_of_internalvar (get_type_arch (type),
1029 VALUE_INTERNALVAR (toval));
1031 case lval_internalvar_component:
1033 int offset = value_offset (toval);
1035 /* Are we dealing with a bitfield?
1037 It is important to mention that `value_parent (toval)' is
1038 non-NULL iff `value_bitsize (toval)' is non-zero. */
1039 if (value_bitsize (toval))
1041 /* VALUE_INTERNALVAR below refers to the parent value, while
1042 the offset is relative to this parent value. */
1043 gdb_assert (value_parent (value_parent (toval)) == NULL);
1044 offset += value_offset (value_parent (toval));
1047 set_internalvar_component (VALUE_INTERNALVAR (toval),
1049 value_bitpos (toval),
1050 value_bitsize (toval),
1057 const gdb_byte *dest_buffer;
1058 CORE_ADDR changed_addr;
1060 gdb_byte buffer[sizeof (LONGEST)];
1062 if (value_bitsize (toval))
1064 struct value *parent = value_parent (toval);
1066 changed_addr = value_address (parent) + value_offset (toval);
1067 changed_len = (value_bitpos (toval)
1068 + value_bitsize (toval)
1069 + HOST_CHAR_BIT - 1)
1072 /* If we can read-modify-write exactly the size of the
1073 containing type (e.g. short or int) then do so. This
1074 is safer for volatile bitfields mapped to hardware
1076 if (changed_len < TYPE_LENGTH (type)
1077 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
1078 && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0)
1079 changed_len = TYPE_LENGTH (type);
1081 if (changed_len > (int) sizeof (LONGEST))
1082 error (_("Can't handle bitfields which "
1083 "don't fit in a %d bit word."),
1084 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1086 read_memory (changed_addr, buffer, changed_len);
1087 modify_field (type, buffer, value_as_long (fromval),
1088 value_bitpos (toval), value_bitsize (toval));
1089 dest_buffer = buffer;
1093 changed_addr = value_address (toval);
1094 changed_len = TYPE_LENGTH (type);
1095 dest_buffer = value_contents (fromval);
1098 write_memory_with_notification (changed_addr, dest_buffer, changed_len);
1104 struct frame_info *frame;
1105 struct gdbarch *gdbarch;
1108 /* Figure out which frame this is in currently. */
1109 frame = frame_find_by_id (VALUE_FRAME_ID (toval));
1110 value_reg = VALUE_REGNUM (toval);
1113 error (_("Value being assigned to is no longer active."));
1115 gdbarch = get_frame_arch (frame);
1116 if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), type))
1118 /* If TOVAL is a special machine register requiring
1119 conversion of program values to a special raw
1121 gdbarch_value_to_register (gdbarch, frame,
1122 VALUE_REGNUM (toval), type,
1123 value_contents (fromval));
1127 if (value_bitsize (toval))
1129 struct value *parent = value_parent (toval);
1130 int offset = value_offset (parent) + value_offset (toval);
1132 gdb_byte buffer[sizeof (LONGEST)];
1135 changed_len = (value_bitpos (toval)
1136 + value_bitsize (toval)
1137 + HOST_CHAR_BIT - 1)
1140 if (changed_len > (int) sizeof (LONGEST))
1141 error (_("Can't handle bitfields which "
1142 "don't fit in a %d bit word."),
1143 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1145 if (!get_frame_register_bytes (frame, value_reg, offset,
1146 changed_len, buffer,
1150 throw_error (OPTIMIZED_OUT_ERROR,
1151 _("value has been optimized out"));
1153 throw_error (NOT_AVAILABLE_ERROR,
1154 _("value is not available"));
1157 modify_field (type, buffer, value_as_long (fromval),
1158 value_bitpos (toval), value_bitsize (toval));
1160 put_frame_register_bytes (frame, value_reg, offset,
1161 changed_len, buffer);
1165 put_frame_register_bytes (frame, value_reg,
1166 value_offset (toval),
1168 value_contents (fromval));
1172 if (deprecated_register_changed_hook)
1173 deprecated_register_changed_hook (-1);
1179 const struct lval_funcs *funcs = value_computed_funcs (toval);
1181 if (funcs->write != NULL)
1183 funcs->write (toval, fromval);
1190 error (_("Left operand of assignment is not an lvalue."));
1193 /* Assigning to the stack pointer, frame pointer, and other
1194 (architecture and calling convention specific) registers may
1195 cause the frame cache and regcache to be out of date. Assigning to memory
1196 also can. We just do this on all assignments to registers or
1197 memory, for simplicity's sake; I doubt the slowdown matters. */
1198 switch (VALUE_LVAL (toval))
1204 observer_notify_target_changed (¤t_target);
1206 /* Having destroyed the frame cache, restore the selected
1209 /* FIXME: cagney/2002-11-02: There has to be a better way of
1210 doing this. Instead of constantly saving/restoring the
1211 frame. Why not create a get_selected_frame() function that,
1212 having saved the selected frame's ID can automatically
1213 re-find the previously selected frame automatically. */
1216 struct frame_info *fi = frame_find_by_id (old_frame);
1227 /* If the field does not entirely fill a LONGEST, then zero the sign
1228 bits. If the field is signed, and is negative, then sign
1230 if ((value_bitsize (toval) > 0)
1231 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1233 LONGEST fieldval = value_as_long (fromval);
1234 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1236 fieldval &= valmask;
1237 if (!TYPE_UNSIGNED (type)
1238 && (fieldval & (valmask ^ (valmask >> 1))))
1239 fieldval |= ~valmask;
1241 fromval = value_from_longest (type, fieldval);
1244 /* The return value is a copy of TOVAL so it shares its location
1245 information, but its contents are updated from FROMVAL. This
1246 implies the returned value is not lazy, even if TOVAL was. */
1247 val = value_copy (toval);
1248 set_value_lazy (val, 0);
1249 memcpy (value_contents_raw (val), value_contents (fromval),
1250 TYPE_LENGTH (type));
1252 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1253 in the case of pointer types. For object types, the enclosing type
1254 and embedded offset must *not* be copied: the target object refered
1255 to by TOVAL retains its original dynamic type after assignment. */
1256 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1258 set_value_enclosing_type (val, value_enclosing_type (fromval));
1259 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
1265 /* Extend a value VAL to COUNT repetitions of its type. */
1268 value_repeat (struct value *arg1, int count)
1272 if (VALUE_LVAL (arg1) != lval_memory)
1273 error (_("Only values in memory can be extended with '@'."));
1275 error (_("Invalid number %d of repetitions."), count);
1277 val = allocate_repeat_value (value_enclosing_type (arg1), count);
1279 VALUE_LVAL (val) = lval_memory;
1280 set_value_address (val, value_address (arg1));
1282 read_value_memory (val, 0, value_stack (val), value_address (val),
1283 value_contents_all_raw (val),
1284 TYPE_LENGTH (value_enclosing_type (val)));
1290 value_of_variable (struct symbol *var, const struct block *b)
1292 struct frame_info *frame;
1294 if (!symbol_read_needs_frame (var))
1297 frame = get_selected_frame (_("No frame selected."));
1300 frame = block_innermost_frame (b);
1303 if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
1304 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
1305 error (_("No frame is currently executing in block %s."),
1306 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
1308 error (_("No frame is currently executing in specified block"));
1312 return read_var_value (var, frame);
1316 address_of_variable (struct symbol *var, const struct block *b)
1318 struct type *type = SYMBOL_TYPE (var);
1321 /* Evaluate it first; if the result is a memory address, we're fine.
1322 Lazy evaluation pays off here. */
1324 val = value_of_variable (var, b);
1325 type = value_type (val);
1327 if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1328 || TYPE_CODE (type) == TYPE_CODE_FUNC)
1330 CORE_ADDR addr = value_address (val);
1332 return value_from_pointer (lookup_pointer_type (type), addr);
1335 /* Not a memory address; check what the problem was. */
1336 switch (VALUE_LVAL (val))
1340 struct frame_info *frame;
1341 const char *regname;
1343 frame = frame_find_by_id (VALUE_FRAME_ID (val));
1346 regname = gdbarch_register_name (get_frame_arch (frame),
1347 VALUE_REGNUM (val));
1348 gdb_assert (regname && *regname);
1350 error (_("Address requested for identifier "
1351 "\"%s\" which is in register $%s"),
1352 SYMBOL_PRINT_NAME (var), regname);
1357 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1358 SYMBOL_PRINT_NAME (var));
1365 /* Return one if VAL does not live in target memory, but should in order
1366 to operate on it. Otherwise return zero. */
1369 value_must_coerce_to_target (struct value *val)
1371 struct type *valtype;
1373 /* The only lval kinds which do not live in target memory. */
1374 if (VALUE_LVAL (val) != not_lval
1375 && VALUE_LVAL (val) != lval_internalvar
1376 && VALUE_LVAL (val) != lval_xcallable)
1379 valtype = check_typedef (value_type (val));
1381 switch (TYPE_CODE (valtype))
1383 case TYPE_CODE_ARRAY:
1384 return TYPE_VECTOR (valtype) ? 0 : 1;
1385 case TYPE_CODE_STRING:
1392 /* Make sure that VAL lives in target memory if it's supposed to. For
1393 instance, strings are constructed as character arrays in GDB's
1394 storage, and this function copies them to the target. */
1397 value_coerce_to_target (struct value *val)
1402 if (!value_must_coerce_to_target (val))
1405 length = TYPE_LENGTH (check_typedef (value_type (val)));
1406 addr = allocate_space_in_inferior (length);
1407 write_memory (addr, value_contents (val), length);
1408 return value_at_lazy (value_type (val), addr);
1411 /* Given a value which is an array, return a value which is a pointer
1412 to its first element, regardless of whether or not the array has a
1413 nonzero lower bound.
1415 FIXME: A previous comment here indicated that this routine should
1416 be substracting the array's lower bound. It's not clear to me that
1417 this is correct. Given an array subscripting operation, it would
1418 certainly work to do the adjustment here, essentially computing:
1420 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1422 However I believe a more appropriate and logical place to account
1423 for the lower bound is to do so in value_subscript, essentially
1426 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1428 As further evidence consider what would happen with operations
1429 other than array subscripting, where the caller would get back a
1430 value that had an address somewhere before the actual first element
1431 of the array, and the information about the lower bound would be
1432 lost because of the coercion to pointer type. */
1435 value_coerce_array (struct value *arg1)
1437 struct type *type = check_typedef (value_type (arg1));
1439 /* If the user tries to do something requiring a pointer with an
1440 array that has not yet been pushed to the target, then this would
1441 be a good time to do so. */
1442 arg1 = value_coerce_to_target (arg1);
1444 if (VALUE_LVAL (arg1) != lval_memory)
1445 error (_("Attempt to take address of value not located in memory."));
1447 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1448 value_address (arg1));
1451 /* Given a value which is a function, return a value which is a pointer
1455 value_coerce_function (struct value *arg1)
1457 struct value *retval;
1459 if (VALUE_LVAL (arg1) != lval_memory)
1460 error (_("Attempt to take address of value not located in memory."));
1462 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1463 value_address (arg1));
1467 /* Return a pointer value for the object for which ARG1 is the
1471 value_addr (struct value *arg1)
1474 struct type *type = check_typedef (value_type (arg1));
1476 if (TYPE_CODE (type) == TYPE_CODE_REF)
1478 /* Copy the value, but change the type from (T&) to (T*). We
1479 keep the same location information, which is efficient, and
1480 allows &(&X) to get the location containing the reference. */
1481 arg2 = value_copy (arg1);
1482 deprecated_set_value_type (arg2,
1483 lookup_pointer_type (TYPE_TARGET_TYPE (type)));
1486 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1487 return value_coerce_function (arg1);
1489 /* If this is an array that has not yet been pushed to the target,
1490 then this would be a good time to force it to memory. */
1491 arg1 = value_coerce_to_target (arg1);
1493 if (VALUE_LVAL (arg1) != lval_memory)
1494 error (_("Attempt to take address of value not located in memory."));
1496 /* Get target memory address. */
1497 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1498 (value_address (arg1)
1499 + value_embedded_offset (arg1)));
1501 /* This may be a pointer to a base subobject; so remember the
1502 full derived object's type ... */
1503 set_value_enclosing_type (arg2,
1504 lookup_pointer_type (value_enclosing_type (arg1)));
1505 /* ... and also the relative position of the subobject in the full
1507 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
1511 /* Return a reference value for the object for which ARG1 is the
1515 value_ref (struct value *arg1)
1518 struct type *type = check_typedef (value_type (arg1));
1520 if (TYPE_CODE (type) == TYPE_CODE_REF)
1523 arg2 = value_addr (arg1);
1524 deprecated_set_value_type (arg2, lookup_reference_type (type));
1528 /* Given a value of a pointer type, apply the C unary * operator to
1532 value_ind (struct value *arg1)
1534 struct type *base_type;
1537 arg1 = coerce_array (arg1);
1539 base_type = check_typedef (value_type (arg1));
1541 if (VALUE_LVAL (arg1) == lval_computed)
1543 const struct lval_funcs *funcs = value_computed_funcs (arg1);
1545 if (funcs->indirect)
1547 struct value *result = funcs->indirect (arg1);
1554 if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
1556 struct type *enc_type;
1558 /* We may be pointing to something embedded in a larger object.
1559 Get the real type of the enclosing object. */
1560 enc_type = check_typedef (value_enclosing_type (arg1));
1561 enc_type = TYPE_TARGET_TYPE (enc_type);
1563 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
1564 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
1565 /* For functions, go through find_function_addr, which knows
1566 how to handle function descriptors. */
1567 arg2 = value_at_lazy (enc_type,
1568 find_function_addr (arg1, NULL));
1570 /* Retrieve the enclosing object pointed to. */
1571 arg2 = value_at_lazy (enc_type,
1572 (value_as_address (arg1)
1573 - value_pointed_to_offset (arg1)));
1575 enc_type = value_type (arg2);
1576 return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
1579 error (_("Attempt to take contents of a non-pointer value."));
1580 return 0; /* For lint -- never reached. */
1583 /* Create a value for an array by allocating space in GDB, copying the
1584 data into that space, and then setting up an array value.
1586 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1587 is populated from the values passed in ELEMVEC.
1589 The element type of the array is inherited from the type of the
1590 first element, and all elements must have the same size (though we
1591 don't currently enforce any restriction on their types). */
1594 value_array (int lowbound, int highbound, struct value **elemvec)
1598 unsigned int typelength;
1600 struct type *arraytype;
1602 /* Validate that the bounds are reasonable and that each of the
1603 elements have the same size. */
1605 nelem = highbound - lowbound + 1;
1608 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1610 typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1611 for (idx = 1; idx < nelem; idx++)
1613 if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1615 error (_("array elements must all be the same size"));
1619 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1620 lowbound, highbound);
1622 if (!current_language->c_style_arrays)
1624 val = allocate_value (arraytype);
1625 for (idx = 0; idx < nelem; idx++)
1626 value_contents_copy (val, idx * typelength, elemvec[idx], 0,
1631 /* Allocate space to store the array, and then initialize it by
1632 copying in each element. */
1634 val = allocate_value (arraytype);
1635 for (idx = 0; idx < nelem; idx++)
1636 value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength);
1641 value_cstring (char *ptr, ssize_t len, struct type *char_type)
1644 int lowbound = current_language->string_lower_bound;
1645 ssize_t highbound = len / TYPE_LENGTH (char_type);
1646 struct type *stringtype
1647 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1649 val = allocate_value (stringtype);
1650 memcpy (value_contents_raw (val), ptr, len);
1654 /* Create a value for a string constant by allocating space in the
1655 inferior, copying the data into that space, and returning the
1656 address with type TYPE_CODE_STRING. PTR points to the string
1657 constant data; LEN is number of characters.
1659 Note that string types are like array of char types with a lower
1660 bound of zero and an upper bound of LEN - 1. Also note that the
1661 string may contain embedded null bytes. */
1664 value_string (char *ptr, ssize_t len, struct type *char_type)
1667 int lowbound = current_language->string_lower_bound;
1668 ssize_t highbound = len / TYPE_LENGTH (char_type);
1669 struct type *stringtype
1670 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1672 val = allocate_value (stringtype);
1673 memcpy (value_contents_raw (val), ptr, len);
1678 /* See if we can pass arguments in T2 to a function which takes
1679 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1680 a NULL-terminated vector. If some arguments need coercion of some
1681 sort, then the coerced values are written into T2. Return value is
1682 0 if the arguments could be matched, or the position at which they
1685 STATICP is nonzero if the T1 argument list came from a static
1686 member function. T2 will still include the ``this'' pointer, but
1689 For non-static member functions, we ignore the first argument,
1690 which is the type of the instance variable. This is because we
1691 want to handle calls with objects from derived classes. This is
1692 not entirely correct: we should actually check to make sure that a
1693 requested operation is type secure, shouldn't we? FIXME. */
1696 typecmp (int staticp, int varargs, int nargs,
1697 struct field t1[], struct value *t2[])
1702 internal_error (__FILE__, __LINE__,
1703 _("typecmp: no argument list"));
1705 /* Skip ``this'' argument if applicable. T2 will always include
1711 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1714 struct type *tt1, *tt2;
1719 tt1 = check_typedef (t1[i].type);
1720 tt2 = check_typedef (value_type (t2[i]));
1722 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1723 /* We should be doing hairy argument matching, as below. */
1724 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
1725 == TYPE_CODE (tt2)))
1727 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1728 t2[i] = value_coerce_array (t2[i]);
1730 t2[i] = value_ref (t2[i]);
1734 /* djb - 20000715 - Until the new type structure is in the
1735 place, and we can attempt things like implicit conversions,
1736 we need to do this so you can take something like a map<const
1737 char *>, and properly access map["hello"], because the
1738 argument to [] will be a reference to a pointer to a char,
1739 and the argument will be a pointer to a char. */
1740 while (TYPE_CODE(tt1) == TYPE_CODE_REF
1741 || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1743 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1745 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1746 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1747 || TYPE_CODE(tt2) == TYPE_CODE_REF)
1749 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1751 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1753 /* Array to pointer is a `trivial conversion' according to the
1756 /* We should be doing much hairier argument matching (see
1757 section 13.2 of the ARM), but as a quick kludge, just check
1758 for the same type code. */
1759 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1762 if (varargs || t2[i] == NULL)
1767 /* Helper class for do_search_struct_field that updates *RESULT_PTR
1768 and *LAST_BOFFSET, and possibly throws an exception if the field
1769 search has yielded ambiguous results. */
1772 update_search_result (struct value **result_ptr, struct value *v,
1773 int *last_boffset, int boffset,
1774 const char *name, struct type *type)
1778 if (*result_ptr != NULL
1779 /* The result is not ambiguous if all the classes that are
1780 found occupy the same space. */
1781 && *last_boffset != boffset)
1782 error (_("base class '%s' is ambiguous in type '%s'"),
1783 name, TYPE_SAFE_NAME (type));
1785 *last_boffset = boffset;
1789 /* A helper for search_struct_field. This does all the work; most
1790 arguments are as passed to search_struct_field. The result is
1791 stored in *RESULT_PTR, which must be initialized to NULL.
1792 OUTERMOST_TYPE is the type of the initial type passed to
1793 search_struct_field; this is used for error reporting when the
1794 lookup is ambiguous. */
1797 do_search_struct_field (const char *name, struct value *arg1, int offset,
1798 struct type *type, int looking_for_baseclass,
1799 struct value **result_ptr,
1801 struct type *outermost_type)
1806 CHECK_TYPEDEF (type);
1807 nbases = TYPE_N_BASECLASSES (type);
1809 if (!looking_for_baseclass)
1810 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1812 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1814 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1818 if (field_is_static (&TYPE_FIELD (type, i)))
1819 v = value_static_field (type, i);
1821 v = value_primitive_field (arg1, offset, i, type);
1827 && (t_field_name[0] == '\0'
1828 || (TYPE_CODE (type) == TYPE_CODE_UNION
1829 && (strcmp_iw (t_field_name, "else") == 0))))
1831 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1833 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1834 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1836 /* Look for a match through the fields of an anonymous
1837 union, or anonymous struct. C++ provides anonymous
1840 In the GNU Chill (now deleted from GDB)
1841 implementation of variant record types, each
1842 <alternative field> has an (anonymous) union type,
1843 each member of the union represents a <variant
1844 alternative>. Each <variant alternative> is
1845 represented as a struct, with a member for each
1848 struct value *v = NULL;
1849 int new_offset = offset;
1851 /* This is pretty gross. In G++, the offset in an
1852 anonymous union is relative to the beginning of the
1853 enclosing struct. In the GNU Chill (now deleted
1854 from GDB) implementation of variant records, the
1855 bitpos is zero in an anonymous union field, so we
1856 have to add the offset of the union here. */
1857 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1858 || (TYPE_NFIELDS (field_type) > 0
1859 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1860 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1862 do_search_struct_field (name, arg1, new_offset,
1864 looking_for_baseclass, &v,
1876 for (i = 0; i < nbases; i++)
1878 struct value *v = NULL;
1879 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1880 /* If we are looking for baseclasses, this is what we get when
1881 we hit them. But it could happen that the base part's member
1882 name is not yet filled in. */
1883 int found_baseclass = (looking_for_baseclass
1884 && TYPE_BASECLASS_NAME (type, i) != NULL
1885 && (strcmp_iw (name,
1886 TYPE_BASECLASS_NAME (type,
1888 int boffset = value_embedded_offset (arg1) + offset;
1890 if (BASETYPE_VIA_VIRTUAL (type, i))
1894 boffset = baseclass_offset (type, i,
1895 value_contents_for_printing (arg1),
1896 value_embedded_offset (arg1) + offset,
1897 value_address (arg1),
1900 /* The virtual base class pointer might have been clobbered
1901 by the user program. Make sure that it still points to a
1902 valid memory location. */
1904 boffset += value_embedded_offset (arg1) + offset;
1906 || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
1908 CORE_ADDR base_addr;
1910 base_addr = value_address (arg1) + boffset;
1911 v2 = value_at_lazy (basetype, base_addr);
1912 if (target_read_memory (base_addr,
1913 value_contents_raw (v2),
1914 TYPE_LENGTH (value_type (v2))) != 0)
1915 error (_("virtual baseclass botch"));
1919 v2 = value_copy (arg1);
1920 deprecated_set_value_type (v2, basetype);
1921 set_value_embedded_offset (v2, boffset);
1924 if (found_baseclass)
1928 do_search_struct_field (name, v2, 0,
1929 TYPE_BASECLASS (type, i),
1930 looking_for_baseclass,
1931 result_ptr, last_boffset,
1935 else if (found_baseclass)
1936 v = value_primitive_field (arg1, offset, i, type);
1939 do_search_struct_field (name, arg1,
1940 offset + TYPE_BASECLASS_BITPOS (type,
1942 basetype, looking_for_baseclass,
1943 result_ptr, last_boffset,
1947 update_search_result (result_ptr, v, last_boffset,
1948 boffset, name, outermost_type);
1952 /* Helper function used by value_struct_elt to recurse through
1953 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1954 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1955 TYPE. If found, return value, else return NULL.
1957 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1958 fields, look for a baseclass named NAME. */
1960 static struct value *
1961 search_struct_field (const char *name, struct value *arg1, int offset,
1962 struct type *type, int looking_for_baseclass)
1964 struct value *result = NULL;
1967 do_search_struct_field (name, arg1, offset, type, looking_for_baseclass,
1968 &result, &boffset, type);
1972 /* Helper function used by value_struct_elt to recurse through
1973 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1974 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1977 If found, return value, else if name matched and args not return
1978 (value) -1, else return NULL. */
1980 static struct value *
1981 search_struct_method (const char *name, struct value **arg1p,
1982 struct value **args, int offset,
1983 int *static_memfuncp, struct type *type)
1987 int name_matched = 0;
1988 char dem_opname[64];
1990 CHECK_TYPEDEF (type);
1991 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1993 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1995 /* FIXME! May need to check for ARM demangling here. */
1996 if (strncmp (t_field_name, "__", 2) == 0 ||
1997 strncmp (t_field_name, "op", 2) == 0 ||
1998 strncmp (t_field_name, "type", 4) == 0)
2000 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2001 t_field_name = dem_opname;
2002 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2003 t_field_name = dem_opname;
2005 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2007 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2008 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2011 check_stub_method_group (type, i);
2012 if (j > 0 && args == 0)
2013 error (_("cannot resolve overloaded method "
2014 "`%s': no arguments supplied"), name);
2015 else if (j == 0 && args == 0)
2017 v = value_fn_field (arg1p, f, j, type, offset);
2024 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2025 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2026 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2027 TYPE_FN_FIELD_ARGS (f, j), args))
2029 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2030 return value_virtual_fn_field (arg1p, f, j,
2032 if (TYPE_FN_FIELD_STATIC_P (f, j)
2034 *static_memfuncp = 1;
2035 v = value_fn_field (arg1p, f, j, type, offset);
2044 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2049 if (BASETYPE_VIA_VIRTUAL (type, i))
2051 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2052 struct value *base_val;
2053 const gdb_byte *base_valaddr;
2055 /* The virtual base class pointer might have been
2056 clobbered by the user program. Make sure that it
2057 still points to a valid memory location. */
2059 if (offset < 0 || offset >= TYPE_LENGTH (type))
2062 struct cleanup *back_to;
2065 tmp = xmalloc (TYPE_LENGTH (baseclass));
2066 back_to = make_cleanup (xfree, tmp);
2067 address = value_address (*arg1p);
2069 if (target_read_memory (address + offset,
2070 tmp, TYPE_LENGTH (baseclass)) != 0)
2071 error (_("virtual baseclass botch"));
2073 base_val = value_from_contents_and_address (baseclass,
2076 base_valaddr = value_contents_for_printing (base_val);
2078 do_cleanups (back_to);
2083 base_valaddr = value_contents_for_printing (*arg1p);
2084 this_offset = offset;
2087 base_offset = baseclass_offset (type, i, base_valaddr,
2088 this_offset, value_address (base_val),
2093 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2095 v = search_struct_method (name, arg1p, args, base_offset + offset,
2096 static_memfuncp, TYPE_BASECLASS (type, i));
2097 if (v == (struct value *) - 1)
2103 /* FIXME-bothner: Why is this commented out? Why is it here? */
2104 /* *arg1p = arg1_tmp; */
2109 return (struct value *) - 1;
2114 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2115 extract the component named NAME from the ultimate target
2116 structure/union and return it as a value with its appropriate type.
2117 ERR is used in the error message if *ARGP's type is wrong.
2119 C++: ARGS is a list of argument types to aid in the selection of
2120 an appropriate method. Also, handle derived types.
2122 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2123 where the truthvalue of whether the function that was resolved was
2124 a static member function or not is stored.
2126 ERR is an error message to be printed in case the field is not
2130 value_struct_elt (struct value **argp, struct value **args,
2131 const char *name, int *static_memfuncp, const char *err)
2136 *argp = coerce_array (*argp);
2138 t = check_typedef (value_type (*argp));
2140 /* Follow pointers until we get to a non-pointer. */
2142 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2144 *argp = value_ind (*argp);
2145 /* Don't coerce fn pointer to fn and then back again! */
2146 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2147 *argp = coerce_array (*argp);
2148 t = check_typedef (value_type (*argp));
2151 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2152 && TYPE_CODE (t) != TYPE_CODE_UNION)
2153 error (_("Attempt to extract a component of a value that is not a %s."),
2156 /* Assume it's not, unless we see that it is. */
2157 if (static_memfuncp)
2158 *static_memfuncp = 0;
2162 /* if there are no arguments ...do this... */
2164 /* Try as a field first, because if we succeed, there is less
2166 v = search_struct_field (name, *argp, 0, t, 0);
2170 /* C++: If it was not found as a data field, then try to
2171 return it as a pointer to a method. */
2172 v = search_struct_method (name, argp, args, 0,
2173 static_memfuncp, t);
2175 if (v == (struct value *) - 1)
2176 error (_("Cannot take address of method %s."), name);
2179 if (TYPE_NFN_FIELDS (t))
2180 error (_("There is no member or method named %s."), name);
2182 error (_("There is no member named %s."), name);
2187 v = search_struct_method (name, argp, args, 0,
2188 static_memfuncp, t);
2190 if (v == (struct value *) - 1)
2192 error (_("One of the arguments you tried to pass to %s could not "
2193 "be converted to what the function wants."), name);
2197 /* See if user tried to invoke data as function. If so, hand it
2198 back. If it's not callable (i.e., a pointer to function),
2199 gdb should give an error. */
2200 v = search_struct_field (name, *argp, 0, t, 0);
2201 /* If we found an ordinary field, then it is not a method call.
2202 So, treat it as if it were a static member function. */
2203 if (v && static_memfuncp)
2204 *static_memfuncp = 1;
2208 throw_error (NOT_FOUND_ERROR,
2209 _("Structure has no component named %s."), name);
2213 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2214 to a structure or union, extract and return its component (field) of
2215 type FTYPE at the specified BITPOS.
2216 Throw an exception on error. */
2219 value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
2227 *argp = coerce_array (*argp);
2229 t = check_typedef (value_type (*argp));
2231 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2233 *argp = value_ind (*argp);
2234 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2235 *argp = coerce_array (*argp);
2236 t = check_typedef (value_type (*argp));
2239 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2240 && TYPE_CODE (t) != TYPE_CODE_UNION)
2241 error (_("Attempt to extract a component of a value that is not a %s."),
2244 for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++)
2246 if (!field_is_static (&TYPE_FIELD (t, i))
2247 && bitpos == TYPE_FIELD_BITPOS (t, i)
2248 && types_equal (ftype, TYPE_FIELD_TYPE (t, i)))
2249 return value_primitive_field (*argp, 0, i, t);
2252 error (_("No field with matching bitpos and type."));
2258 /* Search through the methods of an object (and its bases) to find a
2259 specified method. Return the pointer to the fn_field list FN_LIST of
2260 overloaded instances defined in the source language. If available
2261 and matching, a vector of matching xmethods defined in extension
2262 languages are also returned in XM_WORKER_VEC
2264 Helper function for value_find_oload_list.
2265 ARGP is a pointer to a pointer to a value (the object).
2266 METHOD is a string containing the method name.
2267 OFFSET is the offset within the value.
2268 TYPE is the assumed type of the object.
2269 FN_LIST is the pointer to matching overloaded instances defined in
2270 source language. Since this is a recursive function, *FN_LIST
2271 should be set to NULL when calling this function.
2272 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2273 0 when calling this function.
2274 XM_WORKER_VEC is the vector of matching xmethod workers. *XM_WORKER_VEC
2275 should also be set to NULL when calling this function.
2276 BASETYPE is set to the actual type of the subobject where the
2278 BOFFSET is the offset of the base subobject where the method is found. */
2281 find_method_list (struct value **argp, const char *method,
2282 int offset, struct type *type,
2283 struct fn_field **fn_list, int *num_fns,
2284 VEC (xmethod_worker_ptr) **xm_worker_vec,
2285 struct type **basetype, int *boffset)
2288 struct fn_field *f = NULL;
2289 VEC (xmethod_worker_ptr) *worker_vec = NULL, *new_vec = NULL;
2291 gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2292 CHECK_TYPEDEF (type);
2294 /* First check in object itself.
2295 This function is called recursively to search through base classes.
2296 If there is a source method match found at some stage, then we need not
2297 look for source methods in consequent recursive calls. */
2298 if ((*fn_list) == NULL)
2300 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2302 /* pai: FIXME What about operators and type conversions? */
2303 const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2305 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2307 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2308 f = TYPE_FN_FIELDLIST1 (type, i);
2315 /* Resolve any stub methods. */
2316 check_stub_method_group (type, i);
2323 /* Unlike source methods, xmethods can be accumulated over successive
2324 recursive calls. In other words, an xmethod named 'm' in a class
2325 will not hide an xmethod named 'm' in its base class(es). We want
2326 it to be this way because xmethods are after all convenience functions
2327 and hence there is no point restricting them with something like method
2328 hiding. Moreover, if hiding is done for xmethods as well, then we will
2329 have to provide a mechanism to un-hide (like the 'using' construct). */
2330 worker_vec = get_matching_xmethod_workers (type, method);
2331 new_vec = VEC_merge (xmethod_worker_ptr, *xm_worker_vec, worker_vec);
2333 VEC_free (xmethod_worker_ptr, *xm_worker_vec);
2334 VEC_free (xmethod_worker_ptr, worker_vec);
2335 *xm_worker_vec = new_vec;
2337 /* If source methods are not found in current class, look for them in the
2338 base classes. We also have to go through the base classes to gather
2339 extension methods. */
2340 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2344 if (BASETYPE_VIA_VIRTUAL (type, i))
2346 base_offset = baseclass_offset (type, i,
2347 value_contents_for_printing (*argp),
2348 value_offset (*argp) + offset,
2349 value_address (*argp), *argp);
2351 else /* Non-virtual base, simply use bit position from debug
2354 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2357 find_method_list (argp, method, base_offset + offset,
2358 TYPE_BASECLASS (type, i), fn_list, num_fns,
2359 xm_worker_vec, basetype, boffset);
2363 /* Return the list of overloaded methods of a specified name. The methods
2364 could be those GDB finds in the binary, or xmethod. Methods found in
2365 the binary are returned in FN_LIST, and xmethods are returned in
2368 ARGP is a pointer to a pointer to a value (the object).
2369 METHOD is the method name.
2370 OFFSET is the offset within the value contents.
2371 FN_LIST is the pointer to matching overloaded instances defined in
2373 NUM_FNS is the number of overloaded instances.
2374 XM_WORKER_VEC is the vector of matching xmethod workers defined in
2375 extension languages.
2376 BASETYPE is set to the type of the base subobject that defines the
2378 BOFFSET is the offset of the base subobject which defines the method. */
2381 value_find_oload_method_list (struct value **argp, const char *method,
2382 int offset, struct fn_field **fn_list,
2384 VEC (xmethod_worker_ptr) **xm_worker_vec,
2385 struct type **basetype, int *boffset)
2389 t = check_typedef (value_type (*argp));
2391 /* Code snarfed from value_struct_elt. */
2392 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2394 *argp = value_ind (*argp);
2395 /* Don't coerce fn pointer to fn and then back again! */
2396 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2397 *argp = coerce_array (*argp);
2398 t = check_typedef (value_type (*argp));
2401 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2402 && TYPE_CODE (t) != TYPE_CODE_UNION)
2403 error (_("Attempt to extract a component of a "
2404 "value that is not a struct or union"));
2406 gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2408 /* Clear the lists. */
2411 *xm_worker_vec = NULL;
2413 find_method_list (argp, method, 0, t, fn_list, num_fns, xm_worker_vec,
2417 /* Given an array of arguments (ARGS) (which includes an
2418 entry for "this" in the case of C++ methods), the number of
2419 arguments NARGS, the NAME of a function, and whether it's a method or
2420 not (METHOD), find the best function that matches on the argument types
2421 according to the overload resolution rules.
2423 METHOD can be one of three values:
2424 NON_METHOD for non-member functions.
2425 METHOD: for member functions.
2426 BOTH: used for overload resolution of operators where the
2427 candidates are expected to be either member or non member
2428 functions. In this case the first argument ARGTYPES
2429 (representing 'this') is expected to be a reference to the
2430 target object, and will be dereferenced when attempting the
2433 In the case of class methods, the parameter OBJ is an object value
2434 in which to search for overloaded methods.
2436 In the case of non-method functions, the parameter FSYM is a symbol
2437 corresponding to one of the overloaded functions.
2439 Return value is an integer: 0 -> good match, 10 -> debugger applied
2440 non-standard coercions, 100 -> incompatible.
2442 If a method is being searched for, VALP will hold the value.
2443 If a non-method is being searched for, SYMP will hold the symbol
2446 If a method is being searched for, and it is a static method,
2447 then STATICP will point to a non-zero value.
2449 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2450 ADL overload candidates when performing overload resolution for a fully
2453 Note: This function does *not* check the value of
2454 overload_resolution. Caller must check it to see whether overload
2455 resolution is permitted. */
2458 find_overload_match (struct value **args, int nargs,
2459 const char *name, enum oload_search_type method,
2460 struct value **objp, struct symbol *fsym,
2461 struct value **valp, struct symbol **symp,
2462 int *staticp, const int no_adl)
2464 struct value *obj = (objp ? *objp : NULL);
2465 struct type *obj_type = obj ? value_type (obj) : NULL;
2466 /* Index of best overloaded function. */
2467 int func_oload_champ = -1;
2468 int method_oload_champ = -1;
2469 int src_method_oload_champ = -1;
2470 int ext_method_oload_champ = -1;
2471 int src_and_ext_equal = 0;
2473 /* The measure for the current best match. */
2474 struct badness_vector *method_badness = NULL;
2475 struct badness_vector *func_badness = NULL;
2476 struct badness_vector *ext_method_badness = NULL;
2477 struct badness_vector *src_method_badness = NULL;
2479 struct value *temp = obj;
2480 /* For methods, the list of overloaded methods. */
2481 struct fn_field *fns_ptr = NULL;
2482 /* For non-methods, the list of overloaded function symbols. */
2483 struct symbol **oload_syms = NULL;
2484 /* For xmethods, the VEC of xmethod workers. */
2485 VEC (xmethod_worker_ptr) *xm_worker_vec = NULL;
2486 /* Number of overloaded instances being considered. */
2488 struct type *basetype = NULL;
2491 struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2493 const char *obj_type_name = NULL;
2494 const char *func_name = NULL;
2495 enum oload_classification match_quality;
2496 enum oload_classification method_match_quality = INCOMPATIBLE;
2497 enum oload_classification src_method_match_quality = INCOMPATIBLE;
2498 enum oload_classification ext_method_match_quality = INCOMPATIBLE;
2499 enum oload_classification func_match_quality = INCOMPATIBLE;
2501 /* Get the list of overloaded methods or functions. */
2502 if (method == METHOD || method == BOTH)
2506 /* OBJ may be a pointer value rather than the object itself. */
2507 obj = coerce_ref (obj);
2508 while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2509 obj = coerce_ref (value_ind (obj));
2510 obj_type_name = TYPE_NAME (value_type (obj));
2512 /* First check whether this is a data member, e.g. a pointer to
2514 if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2516 *valp = search_struct_field (name, obj, 0,
2517 check_typedef (value_type (obj)), 0);
2521 do_cleanups (all_cleanups);
2526 /* Retrieve the list of methods with the name NAME. */
2527 value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns,
2528 &xm_worker_vec, &basetype, &boffset);
2529 /* If this is a method only search, and no methods were found
2530 the search has faild. */
2531 if (method == METHOD && (!fns_ptr || !num_fns) && !xm_worker_vec)
2532 error (_("Couldn't find method %s%s%s"),
2534 (obj_type_name && *obj_type_name) ? "::" : "",
2536 /* If we are dealing with stub method types, they should have
2537 been resolved by find_method_list via
2538 value_find_oload_method_list above. */
2541 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2543 src_method_oload_champ = find_oload_champ (args, nargs,
2544 num_fns, fns_ptr, NULL,
2545 NULL, &src_method_badness);
2547 src_method_match_quality = classify_oload_match
2548 (src_method_badness, nargs,
2549 oload_method_static_p (fns_ptr, src_method_oload_champ));
2551 make_cleanup (xfree, src_method_badness);
2554 if (VEC_length (xmethod_worker_ptr, xm_worker_vec) > 0)
2556 ext_method_oload_champ = find_oload_champ (args, nargs,
2557 0, NULL, xm_worker_vec,
2558 NULL, &ext_method_badness);
2559 ext_method_match_quality = classify_oload_match (ext_method_badness,
2561 make_cleanup (xfree, ext_method_badness);
2562 make_cleanup (free_xmethod_worker_vec, xm_worker_vec);
2565 if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0)
2567 switch (compare_badness (ext_method_badness, src_method_badness))
2569 case 0: /* Src method and xmethod are equally good. */
2570 src_and_ext_equal = 1;
2571 /* If src method and xmethod are equally good, then
2572 xmethod should be the winner. Hence, fall through to the
2573 case where a xmethod is better than the source
2574 method, except when the xmethod match quality is
2577 case 1: /* Src method and ext method are incompatible. */
2578 /* If ext method match is not standard, then let source method
2579 win. Otherwise, fallthrough to let xmethod win. */
2580 if (ext_method_match_quality != STANDARD)
2582 method_oload_champ = src_method_oload_champ;
2583 method_badness = src_method_badness;
2584 ext_method_oload_champ = -1;
2585 method_match_quality = src_method_match_quality;
2589 case 2: /* Ext method is champion. */
2590 method_oload_champ = ext_method_oload_champ;
2591 method_badness = ext_method_badness;
2592 src_method_oload_champ = -1;
2593 method_match_quality = ext_method_match_quality;
2595 case 3: /* Src method is champion. */
2596 method_oload_champ = src_method_oload_champ;
2597 method_badness = src_method_badness;
2598 ext_method_oload_champ = -1;
2599 method_match_quality = src_method_match_quality;
2602 gdb_assert_not_reached ("Unexpected overload comparison "
2607 else if (src_method_oload_champ >= 0)
2609 method_oload_champ = src_method_oload_champ;
2610 method_badness = src_method_badness;
2611 method_match_quality = src_method_match_quality;
2613 else if (ext_method_oload_champ >= 0)
2615 method_oload_champ = ext_method_oload_champ;
2616 method_badness = ext_method_badness;
2617 method_match_quality = ext_method_match_quality;
2621 if (method == NON_METHOD || method == BOTH)
2623 const char *qualified_name = NULL;
2625 /* If the overload match is being search for both as a method
2626 and non member function, the first argument must now be
2629 args[0] = value_ind (args[0]);
2633 qualified_name = SYMBOL_NATURAL_NAME (fsym);
2635 /* If we have a function with a C++ name, try to extract just
2636 the function part. Do not try this for non-functions (e.g.
2637 function pointers). */
2639 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
2644 temp = cp_func_name (qualified_name);
2646 /* If cp_func_name did not remove anything, the name of the
2647 symbol did not include scope or argument types - it was
2648 probably a C-style function. */
2651 make_cleanup (xfree, temp);
2652 if (strcmp (temp, qualified_name) == 0)
2662 qualified_name = name;
2665 /* If there was no C++ name, this must be a C-style function or
2666 not a function at all. Just return the same symbol. Do the
2667 same if cp_func_name fails for some reason. */
2668 if (func_name == NULL)
2671 do_cleanups (all_cleanups);
2675 func_oload_champ = find_oload_champ_namespace (args, nargs,
2682 if (func_oload_champ >= 0)
2683 func_match_quality = classify_oload_match (func_badness, nargs, 0);
2685 make_cleanup (xfree, oload_syms);
2686 make_cleanup (xfree, func_badness);
2689 /* Did we find a match ? */
2690 if (method_oload_champ == -1 && func_oload_champ == -1)
2691 throw_error (NOT_FOUND_ERROR,
2692 _("No symbol \"%s\" in current context."),
2695 /* If we have found both a method match and a function
2696 match, find out which one is better, and calculate match
2698 if (method_oload_champ >= 0 && func_oload_champ >= 0)
2700 switch (compare_badness (func_badness, method_badness))
2702 case 0: /* Top two contenders are equally good. */
2703 /* FIXME: GDB does not support the general ambiguous case.
2704 All candidates should be collected and presented the
2706 error (_("Ambiguous overload resolution"));
2708 case 1: /* Incomparable top contenders. */
2709 /* This is an error incompatible candidates
2710 should not have been proposed. */
2711 error (_("Internal error: incompatible "
2712 "overload candidates proposed"));
2714 case 2: /* Function champion. */
2715 method_oload_champ = -1;
2716 match_quality = func_match_quality;
2718 case 3: /* Method champion. */
2719 func_oload_champ = -1;
2720 match_quality = method_match_quality;
2723 error (_("Internal error: unexpected overload comparison result"));
2729 /* We have either a method match or a function match. */
2730 if (method_oload_champ >= 0)
2731 match_quality = method_match_quality;
2733 match_quality = func_match_quality;
2736 if (match_quality == INCOMPATIBLE)
2738 if (method == METHOD)
2739 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2741 (obj_type_name && *obj_type_name) ? "::" : "",
2744 error (_("Cannot resolve function %s to any overloaded instance"),
2747 else if (match_quality == NON_STANDARD)
2749 if (method == METHOD)
2750 warning (_("Using non-standard conversion to match "
2751 "method %s%s%s to supplied arguments"),
2753 (obj_type_name && *obj_type_name) ? "::" : "",
2756 warning (_("Using non-standard conversion to match "
2757 "function %s to supplied arguments"),
2761 if (staticp != NULL)
2762 *staticp = oload_method_static_p (fns_ptr, method_oload_champ);
2764 if (method_oload_champ >= 0)
2766 if (src_method_oload_champ >= 0)
2768 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ))
2769 *valp = value_virtual_fn_field (&temp, fns_ptr, method_oload_champ,
2772 *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2777 *valp = value_of_xmethod (clone_xmethod_worker
2778 (VEC_index (xmethod_worker_ptr, xm_worker_vec,
2779 ext_method_oload_champ)));
2783 *symp = oload_syms[func_oload_champ];
2787 struct type *temp_type = check_typedef (value_type (temp));
2788 struct type *objtype = check_typedef (obj_type);
2790 if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2791 && (TYPE_CODE (objtype) == TYPE_CODE_PTR
2792 || TYPE_CODE (objtype) == TYPE_CODE_REF))
2794 temp = value_addr (temp);
2799 do_cleanups (all_cleanups);
2801 switch (match_quality)
2807 default: /* STANDARD */
2812 /* Find the best overload match, searching for FUNC_NAME in namespaces
2813 contained in QUALIFIED_NAME until it either finds a good match or
2814 runs out of namespaces. It stores the overloaded functions in
2815 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2816 calling function is responsible for freeing *OLOAD_SYMS and
2817 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2821 find_oload_champ_namespace (struct value **args, int nargs,
2822 const char *func_name,
2823 const char *qualified_name,
2824 struct symbol ***oload_syms,
2825 struct badness_vector **oload_champ_bv,
2830 find_oload_champ_namespace_loop (args, nargs,
2833 oload_syms, oload_champ_bv,
2840 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2841 how deep we've looked for namespaces, and the champ is stored in
2842 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2843 if it isn't. Other arguments are the same as in
2844 find_oload_champ_namespace
2846 It is the caller's responsibility to free *OLOAD_SYMS and
2850 find_oload_champ_namespace_loop (struct value **args, int nargs,
2851 const char *func_name,
2852 const char *qualified_name,
2854 struct symbol ***oload_syms,
2855 struct badness_vector **oload_champ_bv,
2859 int next_namespace_len = namespace_len;
2860 int searched_deeper = 0;
2862 struct cleanup *old_cleanups;
2863 int new_oload_champ;
2864 struct symbol **new_oload_syms;
2865 struct badness_vector *new_oload_champ_bv;
2866 char *new_namespace;
2868 if (next_namespace_len != 0)
2870 gdb_assert (qualified_name[next_namespace_len] == ':');
2871 next_namespace_len += 2;
2873 next_namespace_len +=
2874 cp_find_first_component (qualified_name + next_namespace_len);
2876 /* Initialize these to values that can safely be xfree'd. */
2878 *oload_champ_bv = NULL;
2880 /* First, see if we have a deeper namespace we can search in.
2881 If we get a good match there, use it. */
2883 if (qualified_name[next_namespace_len] == ':')
2885 searched_deeper = 1;
2887 if (find_oload_champ_namespace_loop (args, nargs,
2888 func_name, qualified_name,
2890 oload_syms, oload_champ_bv,
2891 oload_champ, no_adl))
2897 /* If we reach here, either we're in the deepest namespace or we
2898 didn't find a good match in a deeper namespace. But, in the
2899 latter case, we still have a bad match in a deeper namespace;
2900 note that we might not find any match at all in the current
2901 namespace. (There's always a match in the deepest namespace,
2902 because this overload mechanism only gets called if there's a
2903 function symbol to start off with.) */
2905 old_cleanups = make_cleanup (xfree, *oload_syms);
2906 make_cleanup (xfree, *oload_champ_bv);
2907 new_namespace = alloca (namespace_len + 1);
2908 strncpy (new_namespace, qualified_name, namespace_len);
2909 new_namespace[namespace_len] = '\0';
2910 new_oload_syms = make_symbol_overload_list (func_name,
2913 /* If we have reached the deepest level perform argument
2914 determined lookup. */
2915 if (!searched_deeper && !no_adl)
2918 struct type **arg_types;
2920 /* Prepare list of argument types for overload resolution. */
2921 arg_types = (struct type **)
2922 alloca (nargs * (sizeof (struct type *)));
2923 for (ix = 0; ix < nargs; ix++)
2924 arg_types[ix] = value_type (args[ix]);
2925 make_symbol_overload_list_adl (arg_types, nargs, func_name);
2928 while (new_oload_syms[num_fns])
2931 new_oload_champ = find_oload_champ (args, nargs, num_fns,
2932 NULL, NULL, new_oload_syms,
2933 &new_oload_champ_bv);
2935 /* Case 1: We found a good match. Free earlier matches (if any),
2936 and return it. Case 2: We didn't find a good match, but we're
2937 not the deepest function. Then go with the bad match that the
2938 deeper function found. Case 3: We found a bad match, and we're
2939 the deepest function. Then return what we found, even though
2940 it's a bad match. */
2942 if (new_oload_champ != -1
2943 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2945 *oload_syms = new_oload_syms;
2946 *oload_champ = new_oload_champ;
2947 *oload_champ_bv = new_oload_champ_bv;
2948 do_cleanups (old_cleanups);
2951 else if (searched_deeper)
2953 xfree (new_oload_syms);
2954 xfree (new_oload_champ_bv);
2955 discard_cleanups (old_cleanups);
2960 *oload_syms = new_oload_syms;
2961 *oload_champ = new_oload_champ;
2962 *oload_champ_bv = new_oload_champ_bv;
2963 do_cleanups (old_cleanups);
2968 /* Look for a function to take NARGS args of ARGS. Find
2969 the best match from among the overloaded methods or functions
2970 given by FNS_PTR or OLOAD_SYMS or XM_WORKER_VEC, respectively.
2971 One, and only one of FNS_PTR, OLOAD_SYMS and XM_WORKER_VEC can be
2974 If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR
2975 or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS.
2977 Return the index of the best match; store an indication of the
2978 quality of the match in OLOAD_CHAMP_BV.
2980 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2983 find_oload_champ (struct value **args, int nargs,
2984 int num_fns, struct fn_field *fns_ptr,
2985 VEC (xmethod_worker_ptr) *xm_worker_vec,
2986 struct symbol **oload_syms,
2987 struct badness_vector **oload_champ_bv)
2991 int xm_worker_vec_n = VEC_length (xmethod_worker_ptr, xm_worker_vec);
2992 /* A measure of how good an overloaded instance is. */
2993 struct badness_vector *bv;
2994 /* Index of best overloaded function. */
2995 int oload_champ = -1;
2996 /* Current ambiguity state for overload resolution. */
2997 int oload_ambiguous = 0;
2998 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3000 /* A champion can be found among methods alone, or among functions
3001 alone, or in xmethods alone, but not in more than one of these
3003 gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL)
3006 *oload_champ_bv = NULL;
3008 fn_count = (xm_worker_vec != NULL
3009 ? VEC_length (xmethod_worker_ptr, xm_worker_vec)
3011 /* Consider each candidate in turn. */
3012 for (ix = 0; ix < fn_count; ix++)
3015 int static_offset = 0;
3017 struct type **parm_types;
3018 struct xmethod_worker *worker = NULL;
3020 if (xm_worker_vec != NULL)
3022 worker = VEC_index (xmethod_worker_ptr, xm_worker_vec, ix);
3023 parm_types = get_xmethod_arg_types (worker, &nparms);
3027 if (fns_ptr != NULL)
3029 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
3030 static_offset = oload_method_static_p (fns_ptr, ix);
3033 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
3035 parm_types = (struct type **)
3036 xmalloc (nparms * (sizeof (struct type *)));
3037 for (jj = 0; jj < nparms; jj++)
3038 parm_types[jj] = (fns_ptr != NULL
3039 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
3040 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
3044 /* Compare parameter types to supplied argument types. Skip
3045 THIS for static methods. */
3046 bv = rank_function (parm_types, nparms,
3047 args + static_offset,
3048 nargs - static_offset);
3050 if (!*oload_champ_bv)
3052 *oload_champ_bv = bv;
3055 else /* See whether current candidate is better or worse than
3057 switch (compare_badness (bv, *oload_champ_bv))
3059 case 0: /* Top two contenders are equally good. */
3060 oload_ambiguous = 1;
3062 case 1: /* Incomparable top contenders. */
3063 oload_ambiguous = 2;
3065 case 2: /* New champion, record details. */
3066 *oload_champ_bv = bv;
3067 oload_ambiguous = 0;
3077 if (fns_ptr != NULL)
3078 fprintf_filtered (gdb_stderr,
3079 "Overloaded method instance %s, # of parms %d\n",
3080 fns_ptr[ix].physname, nparms);
3081 else if (xm_worker_vec != NULL)
3082 fprintf_filtered (gdb_stderr,
3083 "Xmethod worker, # of parms %d\n",
3086 fprintf_filtered (gdb_stderr,
3087 "Overloaded function instance "
3088 "%s # of parms %d\n",
3089 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
3091 for (jj = 0; jj < nargs - static_offset; jj++)
3092 fprintf_filtered (gdb_stderr,
3093 "...Badness @ %d : %d\n",
3094 jj, bv->rank[jj].rank);
3095 fprintf_filtered (gdb_stderr, "Overload resolution "
3096 "champion is %d, ambiguous? %d\n",
3097 oload_champ, oload_ambiguous);
3104 /* Return 1 if we're looking at a static method, 0 if we're looking at
3105 a non-static method or a function that isn't a method. */
3108 oload_method_static_p (struct fn_field *fns_ptr, int index)
3110 if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3116 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3118 static enum oload_classification
3119 classify_oload_match (struct badness_vector *oload_champ_bv,
3124 enum oload_classification worst = STANDARD;
3126 for (ix = 1; ix <= nargs - static_offset; ix++)
3128 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3129 or worse return INCOMPATIBLE. */
3130 if (compare_ranks (oload_champ_bv->rank[ix],
3131 INCOMPATIBLE_TYPE_BADNESS) <= 0)
3132 return INCOMPATIBLE; /* Truly mismatched types. */
3133 /* Otherwise If this conversion is as bad as
3134 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3135 else if (compare_ranks (oload_champ_bv->rank[ix],
3136 NS_POINTER_CONVERSION_BADNESS) <= 0)
3137 worst = NON_STANDARD; /* Non-standard type conversions
3141 /* If no INCOMPATIBLE classification was found, return the worst one
3142 that was found (if any). */
3146 /* C++: return 1 is NAME is a legitimate name for the destructor of
3147 type TYPE. If TYPE does not have a destructor, or if NAME is
3148 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3149 have CHECK_TYPEDEF applied, this function will apply it itself. */
3152 destructor_name_p (const char *name, struct type *type)
3156 const char *dname = type_name_no_tag_or_error (type);
3157 const char *cp = strchr (dname, '<');
3160 /* Do not compare the template part for template classes. */
3162 len = strlen (dname);
3165 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3166 error (_("name of destructor must equal name of class"));
3173 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3174 class". If the name is found, return a value representing it;
3175 otherwise throw an exception. */
3177 static struct value *
3178 enum_constant_from_type (struct type *type, const char *name)
3181 int name_len = strlen (name);
3183 gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM
3184 && TYPE_DECLARED_CLASS (type));
3186 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
3188 const char *fname = TYPE_FIELD_NAME (type, i);
3191 if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL
3195 /* Look for the trailing "::NAME", since enum class constant
3196 names are qualified here. */
3197 len = strlen (fname);
3198 if (len + 2 >= name_len
3199 && fname[len - name_len - 2] == ':'
3200 && fname[len - name_len - 1] == ':'
3201 && strcmp (&fname[len - name_len], name) == 0)
3202 return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, i));
3205 error (_("no constant named \"%s\" in enum \"%s\""),
3206 name, TYPE_TAG_NAME (type));
3209 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3210 return the appropriate member (or the address of the member, if
3211 WANT_ADDRESS). This function is used to resolve user expressions
3212 of the form "DOMAIN::NAME". For more details on what happens, see
3213 the comment before value_struct_elt_for_reference. */
3216 value_aggregate_elt (struct type *curtype, const char *name,
3217 struct type *expect_type, int want_address,
3220 switch (TYPE_CODE (curtype))
3222 case TYPE_CODE_STRUCT:
3223 case TYPE_CODE_UNION:
3224 return value_struct_elt_for_reference (curtype, 0, curtype,
3226 want_address, noside);
3227 case TYPE_CODE_NAMESPACE:
3228 return value_namespace_elt (curtype, name,
3229 want_address, noside);
3231 case TYPE_CODE_ENUM:
3232 return enum_constant_from_type (curtype, name);
3235 internal_error (__FILE__, __LINE__,
3236 _("non-aggregate type in value_aggregate_elt"));
3240 /* Compares the two method/function types T1 and T2 for "equality"
3241 with respect to the methods' parameters. If the types of the
3242 two parameter lists are the same, returns 1; 0 otherwise. This
3243 comparison may ignore any artificial parameters in T1 if
3244 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3245 the first artificial parameter in T1, assumed to be a 'this' pointer.
3247 The type T2 is expected to have come from make_params (in eval.c). */
3250 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3254 if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3257 /* If skipping artificial fields, find the first real field
3259 if (skip_artificial)
3261 while (start < TYPE_NFIELDS (t1)
3262 && TYPE_FIELD_ARTIFICIAL (t1, start))
3266 /* Now compare parameters. */
3268 /* Special case: a method taking void. T1 will contain no
3269 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3270 if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3271 && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3274 if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3278 for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3280 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3281 TYPE_FIELD_TYPE (t2, i), NULL),
3282 EXACT_MATCH_BADNESS) != 0)
3292 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3293 return the address of this member as a "pointer to member" type.
3294 If INTYPE is non-null, then it will be the type of the member we
3295 are looking for. This will help us resolve "pointers to member
3296 functions". This function is used to resolve user expressions of
3297 the form "DOMAIN::NAME". */
3299 static struct value *
3300 value_struct_elt_for_reference (struct type *domain, int offset,
3301 struct type *curtype, const char *name,
3302 struct type *intype,
3306 struct type *t = curtype;
3308 struct value *v, *result;
3310 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3311 && TYPE_CODE (t) != TYPE_CODE_UNION)
3312 error (_("Internal error: non-aggregate type "
3313 "to value_struct_elt_for_reference"));
3315 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3317 const char *t_field_name = TYPE_FIELD_NAME (t, i);
3319 if (t_field_name && strcmp (t_field_name, name) == 0)
3321 if (field_is_static (&TYPE_FIELD (t, i)))
3323 v = value_static_field (t, i);
3328 if (TYPE_FIELD_PACKED (t, i))
3329 error (_("pointers to bitfield members not allowed"));
3332 return value_from_longest
3333 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3334 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3335 else if (noside != EVAL_NORMAL)
3336 return allocate_value (TYPE_FIELD_TYPE (t, i));
3339 /* Try to evaluate NAME as a qualified name with implicit
3340 this pointer. In this case, attempt to return the
3341 equivalent to `this->*(&TYPE::NAME)'. */
3342 v = value_of_this_silent (current_language);
3347 struct type *type, *tmp;
3349 ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
3350 type = check_typedef (value_type (ptr));
3351 gdb_assert (type != NULL
3352 && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
3353 tmp = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
3354 v = value_cast_pointers (tmp, v, 1);
3355 mem_offset = value_as_long (ptr);
3356 tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type));
3357 result = value_from_pointer (tmp,
3358 value_as_long (v) + mem_offset);
3359 return value_ind (result);
3362 error (_("Cannot reference non-static field \"%s\""), name);
3367 /* C++: If it was not found as a data field, then try to return it
3368 as a pointer to a method. */
3370 /* Perform all necessary dereferencing. */
3371 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3372 intype = TYPE_TARGET_TYPE (intype);
3374 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3376 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3377 char dem_opname[64];
3379 if (strncmp (t_field_name, "__", 2) == 0
3380 || strncmp (t_field_name, "op", 2) == 0
3381 || strncmp (t_field_name, "type", 4) == 0)
3383 if (cplus_demangle_opname (t_field_name,
3384 dem_opname, DMGL_ANSI))
3385 t_field_name = dem_opname;
3386 else if (cplus_demangle_opname (t_field_name,
3388 t_field_name = dem_opname;
3390 if (t_field_name && strcmp (t_field_name, name) == 0)
3393 int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3394 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3396 check_stub_method_group (t, i);
3400 for (j = 0; j < len; ++j)
3402 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3403 || compare_parameters (TYPE_FN_FIELD_TYPE (f, j),
3409 error (_("no member function matches "
3410 "that type instantiation"));
3417 for (ii = 0; ii < len; ++ii)
3419 /* Skip artificial methods. This is necessary if,
3420 for example, the user wants to "print
3421 subclass::subclass" with only one user-defined
3422 constructor. There is no ambiguity in this case.
3423 We are careful here to allow artificial methods
3424 if they are the unique result. */
3425 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3432 /* Desired method is ambiguous if more than one
3433 method is defined. */
3434 if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3435 error (_("non-unique member `%s' requires "
3436 "type instantiation"), name);
3442 error (_("no matching member function"));
3445 if (TYPE_FN_FIELD_STATIC_P (f, j))
3448 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3455 return value_addr (read_var_value (s, 0));
3457 return read_var_value (s, 0);
3460 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3464 result = allocate_value
3465 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3466 cplus_make_method_ptr (value_type (result),
3467 value_contents_writeable (result),
3468 TYPE_FN_FIELD_VOFFSET (f, j), 1);
3470 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3471 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3473 error (_("Cannot reference virtual member function \"%s\""),
3479 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3485 v = read_var_value (s, 0);
3490 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3491 cplus_make_method_ptr (value_type (result),
3492 value_contents_writeable (result),
3493 value_address (v), 0);
3499 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3504 if (BASETYPE_VIA_VIRTUAL (t, i))
3507 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3508 v = value_struct_elt_for_reference (domain,
3509 offset + base_offset,
3510 TYPE_BASECLASS (t, i),
3512 want_address, noside);
3517 /* As a last chance, pretend that CURTYPE is a namespace, and look
3518 it up that way; this (frequently) works for types nested inside
3521 return value_maybe_namespace_elt (curtype, name,
3522 want_address, noside);
3525 /* C++: Return the member NAME of the namespace given by the type
3528 static struct value *
3529 value_namespace_elt (const struct type *curtype,
3530 const char *name, int want_address,
3533 struct value *retval = value_maybe_namespace_elt (curtype, name,
3538 error (_("No symbol \"%s\" in namespace \"%s\"."),
3539 name, TYPE_TAG_NAME (curtype));
3544 /* A helper function used by value_namespace_elt and
3545 value_struct_elt_for_reference. It looks up NAME inside the
3546 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3547 is a class and NAME refers to a type in CURTYPE itself (as opposed
3548 to, say, some base class of CURTYPE). */
3550 static struct value *
3551 value_maybe_namespace_elt (const struct type *curtype,
3552 const char *name, int want_address,
3555 const char *namespace_name = TYPE_TAG_NAME (curtype);
3557 struct value *result;
3559 sym = cp_lookup_symbol_namespace (namespace_name, name,
3560 get_selected_block (0), VAR_DOMAIN);
3564 char *concatenated_name = alloca (strlen (namespace_name) + 2
3565 + strlen (name) + 1);
3567 sprintf (concatenated_name, "%s::%s", namespace_name, name);
3568 sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
3573 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3574 && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3575 result = allocate_value (SYMBOL_TYPE (sym));
3577 result = value_of_variable (sym, get_selected_block (0));
3579 if (result && want_address)
3580 result = value_addr (result);
3585 /* Given a pointer or a reference value V, find its real (RTTI) type.
3587 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3588 and refer to the values computed for the object pointed to. */
3591 value_rtti_indirect_type (struct value *v, int *full,
3592 int *top, int *using_enc)
3594 struct value *target;
3595 struct type *type, *real_type, *target_type;
3597 type = value_type (v);
3598 type = check_typedef (type);
3599 if (TYPE_CODE (type) == TYPE_CODE_REF)
3600 target = coerce_ref (v);
3601 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3602 target = value_ind (v);
3606 real_type = value_rtti_type (target, full, top, using_enc);
3610 /* Copy qualifiers to the referenced object. */
3611 target_type = value_type (target);
3612 real_type = make_cv_type (TYPE_CONST (target_type),
3613 TYPE_VOLATILE (target_type), real_type, NULL);
3614 if (TYPE_CODE (type) == TYPE_CODE_REF)
3615 real_type = lookup_reference_type (real_type);
3616 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3617 real_type = lookup_pointer_type (real_type);
3619 internal_error (__FILE__, __LINE__, _("Unexpected value type."));
3621 /* Copy qualifiers to the pointer/reference. */
3622 real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3629 /* Given a value pointed to by ARGP, check its real run-time type, and
3630 if that is different from the enclosing type, create a new value
3631 using the real run-time type as the enclosing type (and of the same
3632 type as ARGP) and return it, with the embedded offset adjusted to
3633 be the correct offset to the enclosed object. RTYPE is the type,
3634 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3635 by value_rtti_type(). If these are available, they can be supplied
3636 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3637 NULL if they're not available. */
3640 value_full_object (struct value *argp,
3642 int xfull, int xtop,
3645 struct type *real_type;
3649 struct value *new_val;
3656 using_enc = xusing_enc;
3659 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3661 /* If no RTTI data, or if object is already complete, do nothing. */
3662 if (!real_type || real_type == value_enclosing_type (argp))
3665 /* In a destructor we might see a real type that is a superclass of
3666 the object's type. In this case it is better to leave the object
3669 && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp)))
3672 /* If we have the full object, but for some reason the enclosing
3673 type is wrong, set it. */
3674 /* pai: FIXME -- sounds iffy */
3677 argp = value_copy (argp);
3678 set_value_enclosing_type (argp, real_type);
3682 /* Check if object is in memory. */
3683 if (VALUE_LVAL (argp) != lval_memory)
3685 warning (_("Couldn't retrieve complete object of RTTI "
3686 "type %s; object may be in register(s)."),
3687 TYPE_NAME (real_type));
3692 /* All other cases -- retrieve the complete object. */
3693 /* Go back by the computed top_offset from the beginning of the
3694 object, adjusting for the embedded offset of argp if that's what
3695 value_rtti_type used for its computation. */
3696 new_val = value_at_lazy (real_type, value_address (argp) - top +
3697 (using_enc ? 0 : value_embedded_offset (argp)));
3698 deprecated_set_value_type (new_val, value_type (argp));
3699 set_value_embedded_offset (new_val, (using_enc
3700 ? top + value_embedded_offset (argp)
3706 /* Return the value of the local variable, if one exists. Throw error
3707 otherwise, such as if the request is made in an inappropriate context. */
3710 value_of_this (const struct language_defn *lang)
3713 const struct block *b;
3714 struct frame_info *frame;
3716 if (!lang->la_name_of_this)
3717 error (_("no `this' in current language"));
3719 frame = get_selected_frame (_("no frame selected"));
3721 b = get_frame_block (frame, NULL);
3723 sym = lookup_language_this (lang, b);
3725 error (_("current stack frame does not contain a variable named `%s'"),
3726 lang->la_name_of_this);
3728 return read_var_value (sym, frame);
3731 /* Return the value of the local variable, if one exists. Return NULL
3732 otherwise. Never throw error. */
3735 value_of_this_silent (const struct language_defn *lang)
3737 struct value *ret = NULL;
3738 volatile struct gdb_exception except;
3740 TRY_CATCH (except, RETURN_MASK_ERROR)
3742 ret = value_of_this (lang);
3748 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3749 elements long, starting at LOWBOUND. The result has the same lower
3750 bound as the original ARRAY. */
3753 value_slice (struct value *array, int lowbound, int length)
3755 struct type *slice_range_type, *slice_type, *range_type;
3756 LONGEST lowerbound, upperbound;
3757 struct value *slice;
3758 struct type *array_type;
3760 array_type = check_typedef (value_type (array));
3761 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3762 && TYPE_CODE (array_type) != TYPE_CODE_STRING)
3763 error (_("cannot take slice of non-array"));
3765 range_type = TYPE_INDEX_TYPE (array_type);
3766 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3767 error (_("slice from bad array or bitstring"));
3769 if (lowbound < lowerbound || length < 0
3770 || lowbound + length - 1 > upperbound)
3771 error (_("slice out of range"));
3773 /* FIXME-type-allocation: need a way to free this type when we are
3775 slice_range_type = create_static_range_type ((struct type *) NULL,
3776 TYPE_TARGET_TYPE (range_type),
3778 lowbound + length - 1);
3781 struct type *element_type = TYPE_TARGET_TYPE (array_type);
3783 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3785 slice_type = create_array_type ((struct type *) NULL,
3788 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3790 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3791 slice = allocate_value_lazy (slice_type);
3794 slice = allocate_value (slice_type);
3795 value_contents_copy (slice, 0, array, offset,
3796 TYPE_LENGTH (slice_type));
3799 set_value_component_location (slice, array);
3800 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3801 set_value_offset (slice, value_offset (array) + offset);
3807 /* Create a value for a FORTRAN complex number. Currently most of the
3808 time values are coerced to COMPLEX*16 (i.e. a complex number
3809 composed of 2 doubles. This really should be a smarter routine
3810 that figures out precision inteligently as opposed to assuming
3811 doubles. FIXME: fmb */
3814 value_literal_complex (struct value *arg1,
3819 struct type *real_type = TYPE_TARGET_TYPE (type);
3821 val = allocate_value (type);
3822 arg1 = value_cast (real_type, arg1);
3823 arg2 = value_cast (real_type, arg2);
3825 memcpy (value_contents_raw (val),
3826 value_contents (arg1), TYPE_LENGTH (real_type));
3827 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3828 value_contents (arg2), TYPE_LENGTH (real_type));
3832 /* Cast a value into the appropriate complex data type. */
3834 static struct value *
3835 cast_into_complex (struct type *type, struct value *val)
3837 struct type *real_type = TYPE_TARGET_TYPE (type);
3839 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3841 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3842 struct value *re_val = allocate_value (val_real_type);
3843 struct value *im_val = allocate_value (val_real_type);
3845 memcpy (value_contents_raw (re_val),
3846 value_contents (val), TYPE_LENGTH (val_real_type));
3847 memcpy (value_contents_raw (im_val),
3848 value_contents (val) + TYPE_LENGTH (val_real_type),
3849 TYPE_LENGTH (val_real_type));
3851 return value_literal_complex (re_val, im_val, type);
3853 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3854 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3855 return value_literal_complex (val,
3856 value_zero (real_type, not_lval),
3859 error (_("cannot cast non-number to complex"));
3863 _initialize_valops (void)
3865 add_setshow_boolean_cmd ("overload-resolution", class_support,
3866 &overload_resolution, _("\
3867 Set overload resolution in evaluating C++ functions."), _("\
3868 Show overload resolution in evaluating C++ functions."),
3870 show_overload_resolution,
3871 &setlist, &showlist);
3872 overload_resolution = 1;