1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2017 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"
41 #include "extension.h"
42 #include "byte-vector.h"
44 extern unsigned int overload_debug;
45 /* Local functions. */
47 static int typecmp (int staticp, int varargs, int nargs,
48 struct field t1[], struct value *t2[]);
50 static struct value *search_struct_field (const char *, struct value *,
53 static struct value *search_struct_method (const char *, struct value **,
55 LONGEST, int *, struct type *);
57 static int find_oload_champ_namespace (struct value **, int,
58 const char *, const char *,
60 struct badness_vector **,
64 int find_oload_champ_namespace_loop (struct value **, int,
65 const char *, const char *,
66 int, struct symbol ***,
67 struct badness_vector **, int *,
70 static int find_oload_champ (struct value **, int, int,
71 struct fn_field *, VEC (xmethod_worker_ptr) *,
72 struct symbol **, struct badness_vector **);
74 static int oload_method_static_p (struct fn_field *, int);
76 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
79 oload_classification classify_oload_match (struct badness_vector *,
82 static struct value *value_struct_elt_for_reference (struct type *,
88 static struct value *value_namespace_elt (const struct type *,
89 const char *, int , enum noside);
91 static struct value *value_maybe_namespace_elt (const struct type *,
95 static CORE_ADDR allocate_space_in_inferior (int);
97 static struct value *cast_into_complex (struct type *, struct value *);
99 static void find_method_list (struct value **, const char *,
100 LONGEST, struct type *, struct fn_field **, int *,
101 VEC (xmethod_worker_ptr) **,
102 struct type **, LONGEST *);
105 /* Flag for whether we want to abandon failed expression evals by
108 static int auto_abandon = 0;
111 int overload_resolution = 0;
113 show_overload_resolution (struct ui_file *file, int from_tty,
114 struct cmd_list_element *c,
117 fprintf_filtered (file, _("Overload resolution in evaluating "
118 "C++ functions is %s.\n"),
122 /* Find the address of function name NAME in the inferior. If OBJF_P
123 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
127 find_function_in_inferior (const char *name, struct objfile **objf_p)
129 struct block_symbol sym;
131 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
132 if (sym.symbol != NULL)
134 if (SYMBOL_CLASS (sym.symbol) != LOC_BLOCK)
136 error (_("\"%s\" exists in this program but is not a function."),
141 *objf_p = symbol_objfile (sym.symbol);
143 return value_of_variable (sym.symbol, sym.block);
147 struct bound_minimal_symbol msymbol =
148 lookup_bound_minimal_symbol (name);
150 if (msymbol.minsym != NULL)
152 struct objfile *objfile = msymbol.objfile;
153 struct gdbarch *gdbarch = get_objfile_arch (objfile);
157 type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
158 type = lookup_function_type (type);
159 type = lookup_pointer_type (type);
160 maddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
165 return value_from_pointer (type, maddr);
169 if (!target_has_execution)
170 error (_("evaluation of this expression "
171 "requires the target program to be active"));
173 error (_("evaluation of this expression requires the "
174 "program to have a function \"%s\"."),
180 /* Allocate NBYTES of space in the inferior using the inferior's
181 malloc and return a value that is a pointer to the allocated
185 value_allocate_space_in_inferior (int len)
187 struct objfile *objf;
188 struct value *val = find_function_in_inferior ("malloc", &objf);
189 struct gdbarch *gdbarch = get_objfile_arch (objf);
190 struct value *blocklen;
192 blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
193 val = call_function_by_hand (val, NULL, 1, &blocklen);
194 if (value_logical_not (val))
196 if (!target_has_execution)
197 error (_("No memory available to program now: "
198 "you need to start the target first"));
200 error (_("No memory available to program: call to malloc failed"));
206 allocate_space_in_inferior (int len)
208 return value_as_long (value_allocate_space_in_inferior (len));
211 /* Cast struct value VAL to type TYPE and return as a value.
212 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
213 for this to work. Typedef to one of the codes is permitted.
214 Returns NULL if the cast is neither an upcast nor a downcast. */
216 static struct value *
217 value_cast_structs (struct type *type, struct value *v2)
223 gdb_assert (type != NULL && v2 != NULL);
225 t1 = check_typedef (type);
226 t2 = check_typedef (value_type (v2));
228 /* Check preconditions. */
229 gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
230 || TYPE_CODE (t1) == TYPE_CODE_UNION)
231 && !!"Precondition is that type is of STRUCT or UNION kind.");
232 gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
233 || TYPE_CODE (t2) == TYPE_CODE_UNION)
234 && !!"Precondition is that value is of STRUCT or UNION kind");
236 if (TYPE_NAME (t1) != NULL
237 && TYPE_NAME (t2) != NULL
238 && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
241 /* Upcasting: look in the type of the source to see if it contains the
242 type of the target as a superclass. If so, we'll need to
243 offset the pointer rather than just change its type. */
244 if (TYPE_NAME (t1) != NULL)
246 v = search_struct_field (type_name_no_tag (t1),
252 /* Downcasting: look in the type of the target to see if it contains the
253 type of the source as a superclass. If so, we'll need to
254 offset the pointer rather than just change its type. */
255 if (TYPE_NAME (t2) != NULL)
257 /* Try downcasting using the run-time type of the value. */
260 struct type *real_type;
262 real_type = value_rtti_type (v2, &full, &top, &using_enc);
265 v = value_full_object (v2, real_type, full, top, using_enc);
266 v = value_at_lazy (real_type, value_address (v));
267 real_type = value_type (v);
269 /* We might be trying to cast to the outermost enclosing
270 type, in which case search_struct_field won't work. */
271 if (TYPE_NAME (real_type) != NULL
272 && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
275 v = search_struct_field (type_name_no_tag (t2), v, real_type, 1);
280 /* Try downcasting using information from the destination type
281 T2. This wouldn't work properly for classes with virtual
282 bases, but those were handled above. */
283 v = search_struct_field (type_name_no_tag (t2),
284 value_zero (t1, not_lval), t1, 1);
287 /* Downcasting is possible (t1 is superclass of v2). */
288 CORE_ADDR addr2 = value_address (v2);
290 addr2 -= value_address (v) + value_embedded_offset (v);
291 return value_at (type, addr2);
298 /* Cast one pointer or reference type to another. Both TYPE and
299 the type of ARG2 should be pointer types, or else both should be
300 reference types. If SUBCLASS_CHECK is non-zero, this will force a
301 check to see whether TYPE is a superclass of ARG2's type. If
302 SUBCLASS_CHECK is zero, then the subclass check is done only when
303 ARG2 is itself non-zero. Returns the new pointer or reference. */
306 value_cast_pointers (struct type *type, struct value *arg2,
309 struct type *type1 = check_typedef (type);
310 struct type *type2 = check_typedef (value_type (arg2));
311 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
312 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
314 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
315 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
316 && (subclass_check || !value_logical_not (arg2)))
320 if (TYPE_IS_REFERENCE (type2))
321 v2 = coerce_ref (arg2);
323 v2 = value_ind (arg2);
324 gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
325 == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
326 v2 = value_cast_structs (t1, v2);
327 /* At this point we have what we can have, un-dereference if needed. */
330 struct value *v = value_addr (v2);
332 deprecated_set_value_type (v, type);
337 /* No superclass found, just change the pointer type. */
338 arg2 = value_copy (arg2);
339 deprecated_set_value_type (arg2, type);
340 set_value_enclosing_type (arg2, type);
341 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
345 /* Cast value ARG2 to type TYPE and return as a value.
346 More general than a C cast: accepts any two types of the same length,
347 and if ARG2 is an lvalue it can be cast into anything at all. */
348 /* In C++, casts may change pointer or object representations. */
351 value_cast (struct type *type, struct value *arg2)
353 enum type_code code1;
354 enum type_code code2;
358 int convert_to_boolean = 0;
360 if (value_type (arg2) == type)
363 /* Check if we are casting struct reference to struct reference. */
364 if (TYPE_IS_REFERENCE (check_typedef (type)))
366 /* We dereference type; then we recurse and finally
367 we generate value of the given reference. Nothing wrong with
369 struct type *t1 = check_typedef (type);
370 struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
371 struct value *val = value_cast (dereftype, arg2);
373 return value_ref (val, TYPE_CODE (t1));
376 if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2))))
377 /* We deref the value and then do the cast. */
378 return value_cast (type, coerce_ref (arg2));
380 /* Strip typedefs / resolve stubs in order to get at the type's
381 code/length, but remember the original type, to use as the
382 resulting type of the cast, in case it was a typedef. */
383 struct type *to_type = type;
385 type = check_typedef (type);
386 code1 = TYPE_CODE (type);
387 arg2 = coerce_ref (arg2);
388 type2 = check_typedef (value_type (arg2));
390 /* You can't cast to a reference type. See value_cast_pointers
392 gdb_assert (!TYPE_IS_REFERENCE (type));
394 /* A cast to an undetermined-length array_type, such as
395 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
396 where N is sizeof(OBJECT)/sizeof(TYPE). */
397 if (code1 == TYPE_CODE_ARRAY)
399 struct type *element_type = TYPE_TARGET_TYPE (type);
400 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
402 if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
404 struct type *range_type = TYPE_INDEX_TYPE (type);
405 int val_length = TYPE_LENGTH (type2);
406 LONGEST low_bound, high_bound, new_length;
408 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
409 low_bound = 0, high_bound = 0;
410 new_length = val_length / element_length;
411 if (val_length % element_length != 0)
412 warning (_("array element type size does not "
413 "divide object size in cast"));
414 /* FIXME-type-allocation: need a way to free this type when
415 we are done with it. */
416 range_type = create_static_range_type ((struct type *) NULL,
417 TYPE_TARGET_TYPE (range_type),
419 new_length + low_bound - 1);
420 deprecated_set_value_type (arg2,
421 create_array_type ((struct type *) NULL,
428 if (current_language->c_style_arrays
429 && TYPE_CODE (type2) == TYPE_CODE_ARRAY
430 && !TYPE_VECTOR (type2))
431 arg2 = value_coerce_array (arg2);
433 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
434 arg2 = value_coerce_function (arg2);
436 type2 = check_typedef (value_type (arg2));
437 code2 = TYPE_CODE (type2);
439 if (code1 == TYPE_CODE_COMPLEX)
440 return cast_into_complex (to_type, arg2);
441 if (code1 == TYPE_CODE_BOOL)
443 code1 = TYPE_CODE_INT;
444 convert_to_boolean = 1;
446 if (code1 == TYPE_CODE_CHAR)
447 code1 = TYPE_CODE_INT;
448 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
449 code2 = TYPE_CODE_INT;
451 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
452 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
453 || code2 == TYPE_CODE_RANGE);
455 if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
456 && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
457 && TYPE_NAME (type) != 0)
459 struct value *v = value_cast_structs (to_type, arg2);
465 if (code1 == TYPE_CODE_FLT && scalar)
466 return value_from_double (to_type, value_as_double (arg2));
467 else if (code1 == TYPE_CODE_DECFLOAT && scalar)
469 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
470 int dec_len = TYPE_LENGTH (type);
473 if (code2 == TYPE_CODE_FLT)
474 decimal_from_floating (arg2, dec, dec_len, byte_order);
475 else if (code2 == TYPE_CODE_DECFLOAT)
476 decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
477 byte_order, dec, dec_len, byte_order);
479 /* The only option left is an integral type. */
480 decimal_from_integral (arg2, dec, dec_len, byte_order);
482 return value_from_decfloat (to_type, dec);
484 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
485 || code1 == TYPE_CODE_RANGE)
486 && (scalar || code2 == TYPE_CODE_PTR
487 || code2 == TYPE_CODE_MEMBERPTR))
491 /* When we cast pointers to integers, we mustn't use
492 gdbarch_pointer_to_address to find the address the pointer
493 represents, as value_as_long would. GDB should evaluate
494 expressions just as the compiler would --- and the compiler
495 sees a cast as a simple reinterpretation of the pointer's
497 if (code2 == TYPE_CODE_PTR)
498 longest = extract_unsigned_integer
499 (value_contents (arg2), TYPE_LENGTH (type2),
500 gdbarch_byte_order (get_type_arch (type2)));
502 longest = value_as_long (arg2);
503 return value_from_longest (to_type, convert_to_boolean ?
504 (LONGEST) (longest ? 1 : 0) : longest);
506 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
507 || code2 == TYPE_CODE_ENUM
508 || code2 == TYPE_CODE_RANGE))
510 /* TYPE_LENGTH (type) is the length of a pointer, but we really
511 want the length of an address! -- we are really dealing with
512 addresses (i.e., gdb representations) not pointers (i.e.,
513 target representations) here.
515 This allows things like "print *(int *)0x01000234" to work
516 without printing a misleading message -- which would
517 otherwise occur when dealing with a target having two byte
518 pointers and four byte addresses. */
520 int addr_bit = gdbarch_addr_bit (get_type_arch (type2));
521 LONGEST longest = value_as_long (arg2);
523 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
525 if (longest >= ((LONGEST) 1 << addr_bit)
526 || longest <= -((LONGEST) 1 << addr_bit))
527 warning (_("value truncated"));
529 return value_from_longest (to_type, longest);
531 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
532 && value_as_long (arg2) == 0)
534 struct value *result = allocate_value (to_type);
536 cplus_make_method_ptr (to_type, value_contents_writeable (result), 0, 0);
539 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
540 && value_as_long (arg2) == 0)
542 /* The Itanium C++ ABI represents NULL pointers to members as
543 minus one, instead of biasing the normal case. */
544 return value_from_longest (to_type, -1);
546 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
547 && code2 == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)
548 && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
549 error (_("Cannot convert between vector values of different sizes"));
550 else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && scalar
551 && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
552 error (_("can only cast scalar to vector of same size"));
553 else if (code1 == TYPE_CODE_VOID)
555 return value_zero (to_type, not_lval);
557 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
559 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
560 return value_cast_pointers (to_type, arg2, 0);
562 arg2 = value_copy (arg2);
563 deprecated_set_value_type (arg2, to_type);
564 set_value_enclosing_type (arg2, to_type);
565 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
568 else if (VALUE_LVAL (arg2) == lval_memory)
569 return value_at_lazy (to_type, value_address (arg2));
572 error (_("Invalid cast."));
577 /* The C++ reinterpret_cast operator. */
580 value_reinterpret_cast (struct type *type, struct value *arg)
582 struct value *result;
583 struct type *real_type = check_typedef (type);
584 struct type *arg_type, *dest_type;
586 enum type_code dest_code, arg_code;
588 /* Do reference, function, and array conversion. */
589 arg = coerce_array (arg);
591 /* Attempt to preserve the type the user asked for. */
594 /* If we are casting to a reference type, transform
595 reinterpret_cast<T&[&]>(V) to *reinterpret_cast<T*>(&V). */
596 if (TYPE_IS_REFERENCE (real_type))
599 arg = value_addr (arg);
600 dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
601 real_type = lookup_pointer_type (real_type);
604 arg_type = value_type (arg);
606 dest_code = TYPE_CODE (real_type);
607 arg_code = TYPE_CODE (arg_type);
609 /* We can convert pointer types, or any pointer type to int, or int
611 if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
612 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
613 || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
614 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
615 || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
616 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
617 || (dest_code == arg_code
618 && (dest_code == TYPE_CODE_PTR
619 || dest_code == TYPE_CODE_METHODPTR
620 || dest_code == TYPE_CODE_MEMBERPTR)))
621 result = value_cast (dest_type, arg);
623 error (_("Invalid reinterpret_cast"));
626 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,
640 LONGEST embedded_offset,
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 LONGEST offset = baseclass_offset (search_type, i, valaddr,
656 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
658 if (address + embedded_offset + offset >= arg_addr
659 && address + embedded_offset + offset < arg_addr + TYPE_LENGTH (arg_type))
663 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
664 address + embedded_offset + offset);
668 result_count += dynamic_cast_check_1 (desired_type,
670 embedded_offset + offset,
672 TYPE_BASECLASS (search_type, i),
681 /* A helper for value_dynamic_cast. This implements the second of two
682 runtime checks: we look for a unique public sibling class of the
683 argument's declared class. */
686 dynamic_cast_check_2 (struct type *desired_type,
687 const gdb_byte *valaddr,
688 LONGEST embedded_offset,
691 struct type *search_type,
692 struct value **result)
694 int i, result_count = 0;
696 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
700 if (! BASETYPE_VIA_PUBLIC (search_type, i))
703 offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
705 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
709 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
710 address + embedded_offset + offset);
713 result_count += dynamic_cast_check_2 (desired_type,
715 embedded_offset + offset,
717 TYPE_BASECLASS (search_type, i),
724 /* The C++ dynamic_cast operator. */
727 value_dynamic_cast (struct type *type, struct value *arg)
731 struct type *resolved_type = check_typedef (type);
732 struct type *arg_type = check_typedef (value_type (arg));
733 struct type *class_type, *rtti_type;
734 struct value *result, *tem, *original_arg = arg;
736 int is_ref = TYPE_IS_REFERENCE (resolved_type);
738 if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
739 && !TYPE_IS_REFERENCE (resolved_type))
740 error (_("Argument to dynamic_cast must be a pointer or reference type"));
741 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
742 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT)
743 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
745 class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
746 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
748 if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
749 && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
750 && value_as_long (arg) == 0))
751 error (_("Argument to dynamic_cast does not have pointer type"));
752 if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
754 arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
755 if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
756 error (_("Argument to dynamic_cast does "
757 "not have pointer to class type"));
760 /* Handle NULL pointers. */
761 if (value_as_long (arg) == 0)
762 return value_zero (type, not_lval);
764 arg = value_ind (arg);
768 if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
769 error (_("Argument to dynamic_cast does not have class type"));
772 /* If the classes are the same, just return the argument. */
773 if (class_types_same_p (class_type, arg_type))
774 return value_cast (type, arg);
776 /* If the target type is a unique base class of the argument's
777 declared type, just cast it. */
778 if (is_ancestor (class_type, arg_type))
780 if (is_unique_ancestor (class_type, arg))
781 return value_cast (type, original_arg);
782 error (_("Ambiguous dynamic_cast"));
785 rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
787 error (_("Couldn't determine value's most derived type for dynamic_cast"));
789 /* Compute the most derived object's address. */
790 addr = value_address (arg);
798 addr += top + value_embedded_offset (arg);
800 /* dynamic_cast<void *> means to return a pointer to the
801 most-derived object. */
802 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
803 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
804 return value_at_lazy (type, addr);
806 tem = value_at (type, addr);
807 type = value_type (tem);
809 /* The first dynamic check specified in 5.2.7. */
810 if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
812 if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
815 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
816 value_contents_for_printing (tem),
817 value_embedded_offset (tem),
818 value_address (tem), tem,
822 return value_cast (type,
824 ? value_ref (result, TYPE_CODE (resolved_type))
825 : value_addr (result));
828 /* The second dynamic check specified in 5.2.7. */
830 if (is_public_ancestor (arg_type, rtti_type)
831 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
832 value_contents_for_printing (tem),
833 value_embedded_offset (tem),
834 value_address (tem), tem,
835 rtti_type, &result) == 1)
836 return value_cast (type,
838 ? value_ref (result, TYPE_CODE (resolved_type))
839 : value_addr (result));
841 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
842 return value_zero (type, not_lval);
844 error (_("dynamic_cast failed"));
847 /* Create a value of type TYPE that is zero, and return it. */
850 value_zero (struct type *type, enum lval_type lv)
852 struct value *val = allocate_value (type);
854 VALUE_LVAL (val) = (lv == lval_computed ? not_lval : lv);
858 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
861 value_one (struct type *type)
863 struct type *type1 = check_typedef (type);
866 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
868 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
871 decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
872 val = value_from_decfloat (type, v);
874 else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
876 val = value_from_double (type, (DOUBLEST) 1);
878 else if (is_integral_type (type1))
880 val = value_from_longest (type, (LONGEST) 1);
882 else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
884 struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
886 LONGEST low_bound, high_bound;
889 if (!get_array_bounds (type1, &low_bound, &high_bound))
890 error (_("Could not determine the vector bounds"));
892 val = allocate_value (type);
893 for (i = 0; i < high_bound - low_bound + 1; i++)
895 tmp = value_one (eltype);
896 memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
897 value_contents_all (tmp), TYPE_LENGTH (eltype));
902 error (_("Not a numeric type."));
905 /* value_one result is never used for assignments to. */
906 gdb_assert (VALUE_LVAL (val) == not_lval);
911 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
912 The type of the created value may differ from the passed type TYPE.
913 Make sure to retrieve the returned values's new type after this call
914 e.g. in case the type is a variable length array. */
916 static struct value *
917 get_value_at (struct type *type, CORE_ADDR addr, int lazy)
921 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
922 error (_("Attempt to dereference a generic pointer."));
924 val = value_from_contents_and_address (type, NULL, addr);
927 value_fetch_lazy (val);
932 /* Return a value with type TYPE located at ADDR.
934 Call value_at only if the data needs to be fetched immediately;
935 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
936 value_at_lazy instead. value_at_lazy simply records the address of
937 the data and sets the lazy-evaluation-required flag. The lazy flag
938 is tested in the value_contents macro, which is used if and when
939 the contents are actually required. The type of the created value
940 may differ from the passed type TYPE. Make sure to retrieve the
941 returned values's new type after this call e.g. in case the type
942 is a variable length array.
944 Note: value_at does *NOT* handle embedded offsets; perform such
945 adjustments before or after calling it. */
948 value_at (struct type *type, CORE_ADDR addr)
950 return get_value_at (type, addr, 0);
953 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
954 The type of the created value may differ from the passed type TYPE.
955 Make sure to retrieve the returned values's new type after this call
956 e.g. in case the type is a variable length array. */
959 value_at_lazy (struct type *type, CORE_ADDR addr)
961 return get_value_at (type, addr, 1);
965 read_value_memory (struct value *val, LONGEST bit_offset,
966 int stack, CORE_ADDR memaddr,
967 gdb_byte *buffer, size_t length)
969 ULONGEST xfered_total = 0;
970 struct gdbarch *arch = get_value_arch (val);
971 int unit_size = gdbarch_addressable_memory_unit_size (arch);
972 enum target_object object;
974 object = stack ? TARGET_OBJECT_STACK_MEMORY : TARGET_OBJECT_MEMORY;
976 while (xfered_total < length)
978 enum target_xfer_status status;
979 ULONGEST xfered_partial;
981 status = target_xfer_partial (current_target.beneath,
983 buffer + xfered_total * unit_size, NULL,
984 memaddr + xfered_total,
985 length - xfered_total,
988 if (status == TARGET_XFER_OK)
990 else if (status == TARGET_XFER_UNAVAILABLE)
991 mark_value_bits_unavailable (val, (xfered_total * HOST_CHAR_BIT
993 xfered_partial * HOST_CHAR_BIT);
994 else if (status == TARGET_XFER_EOF)
995 memory_error (TARGET_XFER_E_IO, memaddr + xfered_total);
997 memory_error (status, memaddr + xfered_total);
999 xfered_total += xfered_partial;
1004 /* Store the contents of FROMVAL into the location of TOVAL.
1005 Return a new value with the location of TOVAL and contents of FROMVAL. */
1008 value_assign (struct value *toval, struct value *fromval)
1012 struct frame_id old_frame;
1014 if (!deprecated_value_modifiable (toval))
1015 error (_("Left operand of assignment is not a modifiable lvalue."));
1017 toval = coerce_ref (toval);
1019 type = value_type (toval);
1020 if (VALUE_LVAL (toval) != lval_internalvar)
1021 fromval = value_cast (type, fromval);
1024 /* Coerce arrays and functions to pointers, except for arrays
1025 which only live in GDB's storage. */
1026 if (!value_must_coerce_to_target (fromval))
1027 fromval = coerce_array (fromval);
1030 type = check_typedef (type);
1032 /* Since modifying a register can trash the frame chain, and
1033 modifying memory can trash the frame cache, we save the old frame
1034 and then restore the new frame afterwards. */
1035 old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
1037 switch (VALUE_LVAL (toval))
1039 case lval_internalvar:
1040 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1041 return value_of_internalvar (get_type_arch (type),
1042 VALUE_INTERNALVAR (toval));
1044 case lval_internalvar_component:
1046 LONGEST offset = value_offset (toval);
1048 /* Are we dealing with a bitfield?
1050 It is important to mention that `value_parent (toval)' is
1051 non-NULL iff `value_bitsize (toval)' is non-zero. */
1052 if (value_bitsize (toval))
1054 /* VALUE_INTERNALVAR below refers to the parent value, while
1055 the offset is relative to this parent value. */
1056 gdb_assert (value_parent (value_parent (toval)) == NULL);
1057 offset += value_offset (value_parent (toval));
1060 set_internalvar_component (VALUE_INTERNALVAR (toval),
1062 value_bitpos (toval),
1063 value_bitsize (toval),
1070 const gdb_byte *dest_buffer;
1071 CORE_ADDR changed_addr;
1073 gdb_byte buffer[sizeof (LONGEST)];
1075 if (value_bitsize (toval))
1077 struct value *parent = value_parent (toval);
1079 changed_addr = value_address (parent) + value_offset (toval);
1080 changed_len = (value_bitpos (toval)
1081 + value_bitsize (toval)
1082 + HOST_CHAR_BIT - 1)
1085 /* If we can read-modify-write exactly the size of the
1086 containing type (e.g. short or int) then do so. This
1087 is safer for volatile bitfields mapped to hardware
1089 if (changed_len < TYPE_LENGTH (type)
1090 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
1091 && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0)
1092 changed_len = TYPE_LENGTH (type);
1094 if (changed_len > (int) sizeof (LONGEST))
1095 error (_("Can't handle bitfields which "
1096 "don't fit in a %d bit word."),
1097 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1099 read_memory (changed_addr, buffer, changed_len);
1100 modify_field (type, buffer, value_as_long (fromval),
1101 value_bitpos (toval), value_bitsize (toval));
1102 dest_buffer = buffer;
1106 changed_addr = value_address (toval);
1107 changed_len = type_length_units (type);
1108 dest_buffer = value_contents (fromval);
1111 write_memory_with_notification (changed_addr, dest_buffer, changed_len);
1117 struct frame_info *frame;
1118 struct gdbarch *gdbarch;
1121 /* Figure out which frame this is in currently.
1123 We use VALUE_FRAME_ID for obtaining the value's frame id instead of
1124 VALUE_NEXT_FRAME_ID due to requiring a frame which may be passed to
1125 put_frame_register_bytes() below. That function will (eventually)
1126 perform the necessary unwind operation by first obtaining the next
1128 frame = frame_find_by_id (VALUE_FRAME_ID (toval));
1130 value_reg = VALUE_REGNUM (toval);
1133 error (_("Value being assigned to is no longer active."));
1135 gdbarch = get_frame_arch (frame);
1137 if (value_bitsize (toval))
1139 struct value *parent = value_parent (toval);
1140 LONGEST offset = value_offset (parent) + value_offset (toval);
1142 gdb_byte buffer[sizeof (LONGEST)];
1145 changed_len = (value_bitpos (toval)
1146 + value_bitsize (toval)
1147 + HOST_CHAR_BIT - 1)
1150 if (changed_len > (int) sizeof (LONGEST))
1151 error (_("Can't handle bitfields which "
1152 "don't fit in a %d bit word."),
1153 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1155 if (!get_frame_register_bytes (frame, value_reg, offset,
1156 changed_len, buffer,
1160 throw_error (OPTIMIZED_OUT_ERROR,
1161 _("value has been optimized out"));
1163 throw_error (NOT_AVAILABLE_ERROR,
1164 _("value is not available"));
1167 modify_field (type, buffer, value_as_long (fromval),
1168 value_bitpos (toval), value_bitsize (toval));
1170 put_frame_register_bytes (frame, value_reg, offset,
1171 changed_len, buffer);
1175 if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval),
1178 /* If TOVAL is a special machine register requiring
1179 conversion of program values to a special raw
1181 gdbarch_value_to_register (gdbarch, frame,
1182 VALUE_REGNUM (toval), type,
1183 value_contents (fromval));
1187 put_frame_register_bytes (frame, value_reg,
1188 value_offset (toval),
1190 value_contents (fromval));
1194 observer_notify_register_changed (frame, value_reg);
1200 const struct lval_funcs *funcs = value_computed_funcs (toval);
1202 if (funcs->write != NULL)
1204 funcs->write (toval, fromval);
1211 error (_("Left operand of assignment is not an lvalue."));
1214 /* Assigning to the stack pointer, frame pointer, and other
1215 (architecture and calling convention specific) registers may
1216 cause the frame cache and regcache to be out of date. Assigning to memory
1217 also can. We just do this on all assignments to registers or
1218 memory, for simplicity's sake; I doubt the slowdown matters. */
1219 switch (VALUE_LVAL (toval))
1225 observer_notify_target_changed (¤t_target);
1227 /* Having destroyed the frame cache, restore the selected
1230 /* FIXME: cagney/2002-11-02: There has to be a better way of
1231 doing this. Instead of constantly saving/restoring the
1232 frame. Why not create a get_selected_frame() function that,
1233 having saved the selected frame's ID can automatically
1234 re-find the previously selected frame automatically. */
1237 struct frame_info *fi = frame_find_by_id (old_frame);
1248 /* If the field does not entirely fill a LONGEST, then zero the sign
1249 bits. If the field is signed, and is negative, then sign
1251 if ((value_bitsize (toval) > 0)
1252 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1254 LONGEST fieldval = value_as_long (fromval);
1255 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1257 fieldval &= valmask;
1258 if (!TYPE_UNSIGNED (type)
1259 && (fieldval & (valmask ^ (valmask >> 1))))
1260 fieldval |= ~valmask;
1262 fromval = value_from_longest (type, fieldval);
1265 /* The return value is a copy of TOVAL so it shares its location
1266 information, but its contents are updated from FROMVAL. This
1267 implies the returned value is not lazy, even if TOVAL was. */
1268 val = value_copy (toval);
1269 set_value_lazy (val, 0);
1270 memcpy (value_contents_raw (val), value_contents (fromval),
1271 TYPE_LENGTH (type));
1273 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1274 in the case of pointer types. For object types, the enclosing type
1275 and embedded offset must *not* be copied: the target object refered
1276 to by TOVAL retains its original dynamic type after assignment. */
1277 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1279 set_value_enclosing_type (val, value_enclosing_type (fromval));
1280 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
1286 /* Extend a value VAL to COUNT repetitions of its type. */
1289 value_repeat (struct value *arg1, int count)
1293 if (VALUE_LVAL (arg1) != lval_memory)
1294 error (_("Only values in memory can be extended with '@'."));
1296 error (_("Invalid number %d of repetitions."), count);
1298 val = allocate_repeat_value (value_enclosing_type (arg1), count);
1300 VALUE_LVAL (val) = lval_memory;
1301 set_value_address (val, value_address (arg1));
1303 read_value_memory (val, 0, value_stack (val), value_address (val),
1304 value_contents_all_raw (val),
1305 type_length_units (value_enclosing_type (val)));
1311 value_of_variable (struct symbol *var, const struct block *b)
1313 struct frame_info *frame = NULL;
1315 if (symbol_read_needs_frame (var))
1316 frame = get_selected_frame (_("No frame selected."));
1318 return read_var_value (var, b, frame);
1322 address_of_variable (struct symbol *var, const struct block *b)
1324 struct type *type = SYMBOL_TYPE (var);
1327 /* Evaluate it first; if the result is a memory address, we're fine.
1328 Lazy evaluation pays off here. */
1330 val = value_of_variable (var, b);
1331 type = value_type (val);
1333 if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1334 || TYPE_CODE (type) == TYPE_CODE_FUNC)
1336 CORE_ADDR addr = value_address (val);
1338 return value_from_pointer (lookup_pointer_type (type), addr);
1341 /* Not a memory address; check what the problem was. */
1342 switch (VALUE_LVAL (val))
1346 struct frame_info *frame;
1347 const char *regname;
1349 frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val));
1352 regname = gdbarch_register_name (get_frame_arch (frame),
1353 VALUE_REGNUM (val));
1354 gdb_assert (regname && *regname);
1356 error (_("Address requested for identifier "
1357 "\"%s\" which is in register $%s"),
1358 SYMBOL_PRINT_NAME (var), regname);
1363 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1364 SYMBOL_PRINT_NAME (var));
1371 /* Return one if VAL does not live in target memory, but should in order
1372 to operate on it. Otherwise return zero. */
1375 value_must_coerce_to_target (struct value *val)
1377 struct type *valtype;
1379 /* The only lval kinds which do not live in target memory. */
1380 if (VALUE_LVAL (val) != not_lval
1381 && VALUE_LVAL (val) != lval_internalvar
1382 && VALUE_LVAL (val) != lval_xcallable)
1385 valtype = check_typedef (value_type (val));
1387 switch (TYPE_CODE (valtype))
1389 case TYPE_CODE_ARRAY:
1390 return TYPE_VECTOR (valtype) ? 0 : 1;
1391 case TYPE_CODE_STRING:
1398 /* Make sure that VAL lives in target memory if it's supposed to. For
1399 instance, strings are constructed as character arrays in GDB's
1400 storage, and this function copies them to the target. */
1403 value_coerce_to_target (struct value *val)
1408 if (!value_must_coerce_to_target (val))
1411 length = TYPE_LENGTH (check_typedef (value_type (val)));
1412 addr = allocate_space_in_inferior (length);
1413 write_memory (addr, value_contents (val), length);
1414 return value_at_lazy (value_type (val), addr);
1417 /* Given a value which is an array, return a value which is a pointer
1418 to its first element, regardless of whether or not the array has a
1419 nonzero lower bound.
1421 FIXME: A previous comment here indicated that this routine should
1422 be substracting the array's lower bound. It's not clear to me that
1423 this is correct. Given an array subscripting operation, it would
1424 certainly work to do the adjustment here, essentially computing:
1426 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1428 However I believe a more appropriate and logical place to account
1429 for the lower bound is to do so in value_subscript, essentially
1432 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1434 As further evidence consider what would happen with operations
1435 other than array subscripting, where the caller would get back a
1436 value that had an address somewhere before the actual first element
1437 of the array, and the information about the lower bound would be
1438 lost because of the coercion to pointer type. */
1441 value_coerce_array (struct value *arg1)
1443 struct type *type = check_typedef (value_type (arg1));
1445 /* If the user tries to do something requiring a pointer with an
1446 array that has not yet been pushed to the target, then this would
1447 be a good time to do so. */
1448 arg1 = value_coerce_to_target (arg1);
1450 if (VALUE_LVAL (arg1) != lval_memory)
1451 error (_("Attempt to take address of value not located in memory."));
1453 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1454 value_address (arg1));
1457 /* Given a value which is a function, return a value which is a pointer
1461 value_coerce_function (struct value *arg1)
1463 struct value *retval;
1465 if (VALUE_LVAL (arg1) != lval_memory)
1466 error (_("Attempt to take address of value not located in memory."));
1468 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1469 value_address (arg1));
1473 /* Return a pointer value for the object for which ARG1 is the
1477 value_addr (struct value *arg1)
1480 struct type *type = check_typedef (value_type (arg1));
1482 if (TYPE_IS_REFERENCE (type))
1484 if (value_bits_synthetic_pointer (arg1, value_embedded_offset (arg1),
1485 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
1486 arg1 = coerce_ref (arg1);
1489 /* Copy the value, but change the type from (T&) to (T*). We
1490 keep the same location information, which is efficient, and
1491 allows &(&X) to get the location containing the reference.
1492 Do the same to its enclosing type for consistency. */
1493 struct type *type_ptr
1494 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1495 struct type *enclosing_type
1496 = check_typedef (value_enclosing_type (arg1));
1497 struct type *enclosing_type_ptr
1498 = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type));
1500 arg2 = value_copy (arg1);
1501 deprecated_set_value_type (arg2, type_ptr);
1502 set_value_enclosing_type (arg2, enclosing_type_ptr);
1507 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1508 return value_coerce_function (arg1);
1510 /* If this is an array that has not yet been pushed to the target,
1511 then this would be a good time to force it to memory. */
1512 arg1 = value_coerce_to_target (arg1);
1514 if (VALUE_LVAL (arg1) != lval_memory)
1515 error (_("Attempt to take address of value not located in memory."));
1517 /* Get target memory address. */
1518 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1519 (value_address (arg1)
1520 + value_embedded_offset (arg1)));
1522 /* This may be a pointer to a base subobject; so remember the
1523 full derived object's type ... */
1524 set_value_enclosing_type (arg2,
1525 lookup_pointer_type (value_enclosing_type (arg1)));
1526 /* ... and also the relative position of the subobject in the full
1528 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
1532 /* Return a reference value for the object for which ARG1 is the
1536 value_ref (struct value *arg1, enum type_code refcode)
1539 struct type *type = check_typedef (value_type (arg1));
1541 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
1543 if ((TYPE_CODE (type) == TYPE_CODE_REF
1544 || TYPE_CODE (type) == TYPE_CODE_RVALUE_REF)
1545 && TYPE_CODE (type) == refcode)
1548 arg2 = value_addr (arg1);
1549 deprecated_set_value_type (arg2, lookup_reference_type (type, refcode));
1553 /* Given a value of a pointer type, apply the C unary * operator to
1557 value_ind (struct value *arg1)
1559 struct type *base_type;
1562 arg1 = coerce_array (arg1);
1564 base_type = check_typedef (value_type (arg1));
1566 if (VALUE_LVAL (arg1) == lval_computed)
1568 const struct lval_funcs *funcs = value_computed_funcs (arg1);
1570 if (funcs->indirect)
1572 struct value *result = funcs->indirect (arg1);
1579 if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
1581 struct type *enc_type;
1583 /* We may be pointing to something embedded in a larger object.
1584 Get the real type of the enclosing object. */
1585 enc_type = check_typedef (value_enclosing_type (arg1));
1586 enc_type = TYPE_TARGET_TYPE (enc_type);
1588 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
1589 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
1590 /* For functions, go through find_function_addr, which knows
1591 how to handle function descriptors. */
1592 arg2 = value_at_lazy (enc_type,
1593 find_function_addr (arg1, NULL));
1595 /* Retrieve the enclosing object pointed to. */
1596 arg2 = value_at_lazy (enc_type,
1597 (value_as_address (arg1)
1598 - value_pointed_to_offset (arg1)));
1600 enc_type = value_type (arg2);
1601 return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
1604 error (_("Attempt to take contents of a non-pointer value."));
1605 return 0; /* For lint -- never reached. */
1608 /* Create a value for an array by allocating space in GDB, copying the
1609 data into that space, and then setting up an array value.
1611 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1612 is populated from the values passed in ELEMVEC.
1614 The element type of the array is inherited from the type of the
1615 first element, and all elements must have the same size (though we
1616 don't currently enforce any restriction on their types). */
1619 value_array (int lowbound, int highbound, struct value **elemvec)
1623 ULONGEST typelength;
1625 struct type *arraytype;
1627 /* Validate that the bounds are reasonable and that each of the
1628 elements have the same size. */
1630 nelem = highbound - lowbound + 1;
1633 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1635 typelength = type_length_units (value_enclosing_type (elemvec[0]));
1636 for (idx = 1; idx < nelem; idx++)
1638 if (type_length_units (value_enclosing_type (elemvec[idx]))
1641 error (_("array elements must all be the same size"));
1645 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1646 lowbound, highbound);
1648 if (!current_language->c_style_arrays)
1650 val = allocate_value (arraytype);
1651 for (idx = 0; idx < nelem; idx++)
1652 value_contents_copy (val, idx * typelength, elemvec[idx], 0,
1657 /* Allocate space to store the array, and then initialize it by
1658 copying in each element. */
1660 val = allocate_value (arraytype);
1661 for (idx = 0; idx < nelem; idx++)
1662 value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength);
1667 value_cstring (const char *ptr, ssize_t len, struct type *char_type)
1670 int lowbound = current_language->string_lower_bound;
1671 ssize_t highbound = len / TYPE_LENGTH (char_type);
1672 struct type *stringtype
1673 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1675 val = allocate_value (stringtype);
1676 memcpy (value_contents_raw (val), ptr, len);
1680 /* Create a value for a string constant by allocating space in the
1681 inferior, copying the data into that space, and returning the
1682 address with type TYPE_CODE_STRING. PTR points to the string
1683 constant data; LEN is number of characters.
1685 Note that string types are like array of char types with a lower
1686 bound of zero and an upper bound of LEN - 1. Also note that the
1687 string may contain embedded null bytes. */
1690 value_string (const char *ptr, ssize_t len, struct type *char_type)
1693 int lowbound = current_language->string_lower_bound;
1694 ssize_t highbound = len / TYPE_LENGTH (char_type);
1695 struct type *stringtype
1696 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1698 val = allocate_value (stringtype);
1699 memcpy (value_contents_raw (val), ptr, len);
1704 /* See if we can pass arguments in T2 to a function which takes
1705 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1706 a NULL-terminated vector. If some arguments need coercion of some
1707 sort, then the coerced values are written into T2. Return value is
1708 0 if the arguments could be matched, or the position at which they
1711 STATICP is nonzero if the T1 argument list came from a static
1712 member function. T2 will still include the ``this'' pointer, but
1715 For non-static member functions, we ignore the first argument,
1716 which is the type of the instance variable. This is because we
1717 want to handle calls with objects from derived classes. This is
1718 not entirely correct: we should actually check to make sure that a
1719 requested operation is type secure, shouldn't we? FIXME. */
1722 typecmp (int staticp, int varargs, int nargs,
1723 struct field t1[], struct value *t2[])
1728 internal_error (__FILE__, __LINE__,
1729 _("typecmp: no argument list"));
1731 /* Skip ``this'' argument if applicable. T2 will always include
1737 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1740 struct type *tt1, *tt2;
1745 tt1 = check_typedef (t1[i].type);
1746 tt2 = check_typedef (value_type (t2[i]));
1748 if (TYPE_IS_REFERENCE (tt1)
1749 /* We should be doing hairy argument matching, as below. */
1750 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
1751 == TYPE_CODE (tt2)))
1753 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1754 t2[i] = value_coerce_array (t2[i]);
1756 t2[i] = value_ref (t2[i], TYPE_CODE (tt1));
1760 /* djb - 20000715 - Until the new type structure is in the
1761 place, and we can attempt things like implicit conversions,
1762 we need to do this so you can take something like a map<const
1763 char *>, and properly access map["hello"], because the
1764 argument to [] will be a reference to a pointer to a char,
1765 and the argument will be a pointer to a char. */
1766 while (TYPE_IS_REFERENCE (tt1) || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1768 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1770 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1771 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1772 || TYPE_IS_REFERENCE (tt2))
1774 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1776 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1778 /* Array to pointer is a `trivial conversion' according to the
1781 /* We should be doing much hairier argument matching (see
1782 section 13.2 of the ARM), but as a quick kludge, just check
1783 for the same type code. */
1784 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1787 if (varargs || t2[i] == NULL)
1792 /* Helper class for do_search_struct_field that updates *RESULT_PTR
1793 and *LAST_BOFFSET, and possibly throws an exception if the field
1794 search has yielded ambiguous results. */
1797 update_search_result (struct value **result_ptr, struct value *v,
1798 LONGEST *last_boffset, LONGEST boffset,
1799 const char *name, struct type *type)
1803 if (*result_ptr != NULL
1804 /* The result is not ambiguous if all the classes that are
1805 found occupy the same space. */
1806 && *last_boffset != boffset)
1807 error (_("base class '%s' is ambiguous in type '%s'"),
1808 name, TYPE_SAFE_NAME (type));
1810 *last_boffset = boffset;
1814 /* A helper for search_struct_field. This does all the work; most
1815 arguments are as passed to search_struct_field. The result is
1816 stored in *RESULT_PTR, which must be initialized to NULL.
1817 OUTERMOST_TYPE is the type of the initial type passed to
1818 search_struct_field; this is used for error reporting when the
1819 lookup is ambiguous. */
1822 do_search_struct_field (const char *name, struct value *arg1, LONGEST offset,
1823 struct type *type, int looking_for_baseclass,
1824 struct value **result_ptr,
1825 LONGEST *last_boffset,
1826 struct type *outermost_type)
1831 type = check_typedef (type);
1832 nbases = TYPE_N_BASECLASSES (type);
1834 if (!looking_for_baseclass)
1835 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1837 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1839 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1843 if (field_is_static (&TYPE_FIELD (type, i)))
1844 v = value_static_field (type, i);
1846 v = value_primitive_field (arg1, offset, i, type);
1852 && t_field_name[0] == '\0')
1854 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1856 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1857 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1859 /* Look for a match through the fields of an anonymous
1860 union, or anonymous struct. C++ provides anonymous
1863 In the GNU Chill (now deleted from GDB)
1864 implementation of variant record types, each
1865 <alternative field> has an (anonymous) union type,
1866 each member of the union represents a <variant
1867 alternative>. Each <variant alternative> is
1868 represented as a struct, with a member for each
1871 struct value *v = NULL;
1872 LONGEST new_offset = offset;
1874 /* This is pretty gross. In G++, the offset in an
1875 anonymous union is relative to the beginning of the
1876 enclosing struct. In the GNU Chill (now deleted
1877 from GDB) implementation of variant records, the
1878 bitpos is zero in an anonymous union field, so we
1879 have to add the offset of the union here. */
1880 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1881 || (TYPE_NFIELDS (field_type) > 0
1882 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1883 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1885 do_search_struct_field (name, arg1, new_offset,
1887 looking_for_baseclass, &v,
1899 for (i = 0; i < nbases; i++)
1901 struct value *v = NULL;
1902 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1903 /* If we are looking for baseclasses, this is what we get when
1904 we hit them. But it could happen that the base part's member
1905 name is not yet filled in. */
1906 int found_baseclass = (looking_for_baseclass
1907 && TYPE_BASECLASS_NAME (type, i) != NULL
1908 && (strcmp_iw (name,
1909 TYPE_BASECLASS_NAME (type,
1911 LONGEST boffset = value_embedded_offset (arg1) + offset;
1913 if (BASETYPE_VIA_VIRTUAL (type, i))
1917 boffset = baseclass_offset (type, i,
1918 value_contents_for_printing (arg1),
1919 value_embedded_offset (arg1) + offset,
1920 value_address (arg1),
1923 /* The virtual base class pointer might have been clobbered
1924 by the user program. Make sure that it still points to a
1925 valid memory location. */
1927 boffset += value_embedded_offset (arg1) + offset;
1929 || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
1931 CORE_ADDR base_addr;
1933 base_addr = value_address (arg1) + boffset;
1934 v2 = value_at_lazy (basetype, base_addr);
1935 if (target_read_memory (base_addr,
1936 value_contents_raw (v2),
1937 TYPE_LENGTH (value_type (v2))) != 0)
1938 error (_("virtual baseclass botch"));
1942 v2 = value_copy (arg1);
1943 deprecated_set_value_type (v2, basetype);
1944 set_value_embedded_offset (v2, boffset);
1947 if (found_baseclass)
1951 do_search_struct_field (name, v2, 0,
1952 TYPE_BASECLASS (type, i),
1953 looking_for_baseclass,
1954 result_ptr, last_boffset,
1958 else if (found_baseclass)
1959 v = value_primitive_field (arg1, offset, i, type);
1962 do_search_struct_field (name, arg1,
1963 offset + TYPE_BASECLASS_BITPOS (type,
1965 basetype, looking_for_baseclass,
1966 result_ptr, last_boffset,
1970 update_search_result (result_ptr, v, last_boffset,
1971 boffset, name, outermost_type);
1975 /* Helper function used by value_struct_elt to recurse through
1976 baseclasses. Look for a field NAME in ARG1. Search in it assuming
1977 it has (class) type TYPE. If found, return value, else return NULL.
1979 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1980 fields, look for a baseclass named NAME. */
1982 static struct value *
1983 search_struct_field (const char *name, struct value *arg1,
1984 struct type *type, int looking_for_baseclass)
1986 struct value *result = NULL;
1987 LONGEST boffset = 0;
1989 do_search_struct_field (name, arg1, 0, type, looking_for_baseclass,
1990 &result, &boffset, type);
1994 /* Helper function used by value_struct_elt to recurse through
1995 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1996 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1999 If found, return value, else if name matched and args not return
2000 (value) -1, else return NULL. */
2002 static struct value *
2003 search_struct_method (const char *name, struct value **arg1p,
2004 struct value **args, LONGEST offset,
2005 int *static_memfuncp, struct type *type)
2009 int name_matched = 0;
2010 char dem_opname[64];
2012 type = check_typedef (type);
2013 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2015 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2017 /* FIXME! May need to check for ARM demangling here. */
2018 if (startswith (t_field_name, "__") ||
2019 startswith (t_field_name, "op") ||
2020 startswith (t_field_name, "type"))
2022 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2023 t_field_name = dem_opname;
2024 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2025 t_field_name = dem_opname;
2027 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2029 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2030 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2033 check_stub_method_group (type, i);
2034 if (j > 0 && args == 0)
2035 error (_("cannot resolve overloaded method "
2036 "`%s': no arguments supplied"), name);
2037 else if (j == 0 && args == 0)
2039 v = value_fn_field (arg1p, f, j, type, offset);
2046 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2047 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2048 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2049 TYPE_FN_FIELD_ARGS (f, j), args))
2051 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2052 return value_virtual_fn_field (arg1p, f, j,
2054 if (TYPE_FN_FIELD_STATIC_P (f, j)
2056 *static_memfuncp = 1;
2057 v = value_fn_field (arg1p, f, j, type, offset);
2066 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2068 LONGEST base_offset;
2069 LONGEST this_offset;
2071 if (BASETYPE_VIA_VIRTUAL (type, i))
2073 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2074 struct value *base_val;
2075 const gdb_byte *base_valaddr;
2077 /* The virtual base class pointer might have been
2078 clobbered by the user program. Make sure that it
2079 still points to a valid memory location. */
2081 if (offset < 0 || offset >= TYPE_LENGTH (type))
2085 gdb::byte_vector tmp (TYPE_LENGTH (baseclass));
2086 address = value_address (*arg1p);
2088 if (target_read_memory (address + offset,
2089 tmp.data (), TYPE_LENGTH (baseclass)) != 0)
2090 error (_("virtual baseclass botch"));
2092 base_val = value_from_contents_and_address (baseclass,
2095 base_valaddr = value_contents_for_printing (base_val);
2101 base_valaddr = value_contents_for_printing (*arg1p);
2102 this_offset = offset;
2105 base_offset = baseclass_offset (type, i, base_valaddr,
2106 this_offset, value_address (base_val),
2111 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2113 v = search_struct_method (name, arg1p, args, base_offset + offset,
2114 static_memfuncp, TYPE_BASECLASS (type, i));
2115 if (v == (struct value *) - 1)
2121 /* FIXME-bothner: Why is this commented out? Why is it here? */
2122 /* *arg1p = arg1_tmp; */
2127 return (struct value *) - 1;
2132 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2133 extract the component named NAME from the ultimate target
2134 structure/union and return it as a value with its appropriate type.
2135 ERR is used in the error message if *ARGP's type is wrong.
2137 C++: ARGS is a list of argument types to aid in the selection of
2138 an appropriate method. Also, handle derived types.
2140 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2141 where the truthvalue of whether the function that was resolved was
2142 a static member function or not is stored.
2144 ERR is an error message to be printed in case the field is not
2148 value_struct_elt (struct value **argp, struct value **args,
2149 const char *name, int *static_memfuncp, const char *err)
2154 *argp = coerce_array (*argp);
2156 t = check_typedef (value_type (*argp));
2158 /* Follow pointers until we get to a non-pointer. */
2160 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
2162 *argp = value_ind (*argp);
2163 /* Don't coerce fn pointer to fn and then back again! */
2164 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2165 *argp = coerce_array (*argp);
2166 t = check_typedef (value_type (*argp));
2169 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2170 && TYPE_CODE (t) != TYPE_CODE_UNION)
2171 error (_("Attempt to extract a component of a value that is not a %s."),
2174 /* Assume it's not, unless we see that it is. */
2175 if (static_memfuncp)
2176 *static_memfuncp = 0;
2180 /* if there are no arguments ...do this... */
2182 /* Try as a field first, because if we succeed, there is less
2184 v = search_struct_field (name, *argp, t, 0);
2188 /* C++: If it was not found as a data field, then try to
2189 return it as a pointer to a method. */
2190 v = search_struct_method (name, argp, args, 0,
2191 static_memfuncp, t);
2193 if (v == (struct value *) - 1)
2194 error (_("Cannot take address of method %s."), name);
2197 if (TYPE_NFN_FIELDS (t))
2198 error (_("There is no member or method named %s."), name);
2200 error (_("There is no member named %s."), name);
2205 v = search_struct_method (name, argp, args, 0,
2206 static_memfuncp, t);
2208 if (v == (struct value *) - 1)
2210 error (_("One of the arguments you tried to pass to %s could not "
2211 "be converted to what the function wants."), name);
2215 /* See if user tried to invoke data as function. If so, hand it
2216 back. If it's not callable (i.e., a pointer to function),
2217 gdb should give an error. */
2218 v = search_struct_field (name, *argp, t, 0);
2219 /* If we found an ordinary field, then it is not a method call.
2220 So, treat it as if it were a static member function. */
2221 if (v && static_memfuncp)
2222 *static_memfuncp = 1;
2226 throw_error (NOT_FOUND_ERROR,
2227 _("Structure has no component named %s."), name);
2231 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2232 to a structure or union, extract and return its component (field) of
2233 type FTYPE at the specified BITPOS.
2234 Throw an exception on error. */
2237 value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
2243 *argp = coerce_array (*argp);
2245 t = check_typedef (value_type (*argp));
2247 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
2249 *argp = value_ind (*argp);
2250 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2251 *argp = coerce_array (*argp);
2252 t = check_typedef (value_type (*argp));
2255 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2256 && TYPE_CODE (t) != TYPE_CODE_UNION)
2257 error (_("Attempt to extract a component of a value that is not a %s."),
2260 for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++)
2262 if (!field_is_static (&TYPE_FIELD (t, i))
2263 && bitpos == TYPE_FIELD_BITPOS (t, i)
2264 && types_equal (ftype, TYPE_FIELD_TYPE (t, i)))
2265 return value_primitive_field (*argp, 0, i, t);
2268 error (_("No field with matching bitpos and type."));
2274 /* Search through the methods of an object (and its bases) to find a
2275 specified method. Return the pointer to the fn_field list FN_LIST of
2276 overloaded instances defined in the source language. If available
2277 and matching, a vector of matching xmethods defined in extension
2278 languages are also returned in XM_WORKER_VEC
2280 Helper function for value_find_oload_list.
2281 ARGP is a pointer to a pointer to a value (the object).
2282 METHOD is a string containing the method name.
2283 OFFSET is the offset within the value.
2284 TYPE is the assumed type of the object.
2285 FN_LIST is the pointer to matching overloaded instances defined in
2286 source language. Since this is a recursive function, *FN_LIST
2287 should be set to NULL when calling this function.
2288 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2289 0 when calling this function.
2290 XM_WORKER_VEC is the vector of matching xmethod workers. *XM_WORKER_VEC
2291 should also be set to NULL when calling this function.
2292 BASETYPE is set to the actual type of the subobject where the
2294 BOFFSET is the offset of the base subobject where the method is found. */
2297 find_method_list (struct value **argp, const char *method,
2298 LONGEST offset, struct type *type,
2299 struct fn_field **fn_list, int *num_fns,
2300 VEC (xmethod_worker_ptr) **xm_worker_vec,
2301 struct type **basetype, LONGEST *boffset)
2304 struct fn_field *f = NULL;
2305 VEC (xmethod_worker_ptr) *worker_vec = NULL, *new_vec = NULL;
2307 gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2308 type = check_typedef (type);
2310 /* First check in object itself.
2311 This function is called recursively to search through base classes.
2312 If there is a source method match found at some stage, then we need not
2313 look for source methods in consequent recursive calls. */
2314 if ((*fn_list) == NULL)
2316 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2318 /* pai: FIXME What about operators and type conversions? */
2319 const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2321 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2323 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2324 f = TYPE_FN_FIELDLIST1 (type, i);
2331 /* Resolve any stub methods. */
2332 check_stub_method_group (type, i);
2339 /* Unlike source methods, xmethods can be accumulated over successive
2340 recursive calls. In other words, an xmethod named 'm' in a class
2341 will not hide an xmethod named 'm' in its base class(es). We want
2342 it to be this way because xmethods are after all convenience functions
2343 and hence there is no point restricting them with something like method
2344 hiding. Moreover, if hiding is done for xmethods as well, then we will
2345 have to provide a mechanism to un-hide (like the 'using' construct). */
2346 worker_vec = get_matching_xmethod_workers (type, method);
2347 new_vec = VEC_merge (xmethod_worker_ptr, *xm_worker_vec, worker_vec);
2349 VEC_free (xmethod_worker_ptr, *xm_worker_vec);
2350 VEC_free (xmethod_worker_ptr, worker_vec);
2351 *xm_worker_vec = new_vec;
2353 /* If source methods are not found in current class, look for them in the
2354 base classes. We also have to go through the base classes to gather
2355 extension methods. */
2356 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2358 LONGEST base_offset;
2360 if (BASETYPE_VIA_VIRTUAL (type, i))
2362 base_offset = baseclass_offset (type, i,
2363 value_contents_for_printing (*argp),
2364 value_offset (*argp) + offset,
2365 value_address (*argp), *argp);
2367 else /* Non-virtual base, simply use bit position from debug
2370 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2373 find_method_list (argp, method, base_offset + offset,
2374 TYPE_BASECLASS (type, i), fn_list, num_fns,
2375 xm_worker_vec, basetype, boffset);
2379 /* Return the list of overloaded methods of a specified name. The methods
2380 could be those GDB finds in the binary, or xmethod. Methods found in
2381 the binary are returned in FN_LIST, and xmethods are returned in
2384 ARGP is a pointer to a pointer to a value (the object).
2385 METHOD is the method name.
2386 OFFSET is the offset within the value contents.
2387 FN_LIST is the pointer to matching overloaded instances defined in
2389 NUM_FNS is the number of overloaded instances.
2390 XM_WORKER_VEC is the vector of matching xmethod workers defined in
2391 extension languages.
2392 BASETYPE is set to the type of the base subobject that defines the
2394 BOFFSET is the offset of the base subobject which defines the method. */
2397 value_find_oload_method_list (struct value **argp, const char *method,
2398 LONGEST offset, struct fn_field **fn_list,
2400 VEC (xmethod_worker_ptr) **xm_worker_vec,
2401 struct type **basetype, LONGEST *boffset)
2405 t = check_typedef (value_type (*argp));
2407 /* Code snarfed from value_struct_elt. */
2408 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
2410 *argp = value_ind (*argp);
2411 /* Don't coerce fn pointer to fn and then back again! */
2412 if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2413 *argp = coerce_array (*argp);
2414 t = check_typedef (value_type (*argp));
2417 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2418 && TYPE_CODE (t) != TYPE_CODE_UNION)
2419 error (_("Attempt to extract a component of a "
2420 "value that is not a struct or union"));
2422 gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2424 /* Clear the lists. */
2427 *xm_worker_vec = NULL;
2429 find_method_list (argp, method, 0, t, fn_list, num_fns, xm_worker_vec,
2433 /* Given an array of arguments (ARGS) (which includes an
2434 entry for "this" in the case of C++ methods), the number of
2435 arguments NARGS, the NAME of a function, and whether it's a method or
2436 not (METHOD), find the best function that matches on the argument types
2437 according to the overload resolution rules.
2439 METHOD can be one of three values:
2440 NON_METHOD for non-member functions.
2441 METHOD: for member functions.
2442 BOTH: used for overload resolution of operators where the
2443 candidates are expected to be either member or non member
2444 functions. In this case the first argument ARGTYPES
2445 (representing 'this') is expected to be a reference to the
2446 target object, and will be dereferenced when attempting the
2449 In the case of class methods, the parameter OBJ is an object value
2450 in which to search for overloaded methods.
2452 In the case of non-method functions, the parameter FSYM is a symbol
2453 corresponding to one of the overloaded functions.
2455 Return value is an integer: 0 -> good match, 10 -> debugger applied
2456 non-standard coercions, 100 -> incompatible.
2458 If a method is being searched for, VALP will hold the value.
2459 If a non-method is being searched for, SYMP will hold the symbol
2462 If a method is being searched for, and it is a static method,
2463 then STATICP will point to a non-zero value.
2465 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2466 ADL overload candidates when performing overload resolution for a fully
2469 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2470 read while picking the best overload match (it may be all zeroes and thus
2471 not have a vtable pointer), in which case skip virtual function lookup.
2472 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2475 Note: This function does *not* check the value of
2476 overload_resolution. Caller must check it to see whether overload
2477 resolution is permitted. */
2480 find_overload_match (struct value **args, int nargs,
2481 const char *name, enum oload_search_type method,
2482 struct value **objp, struct symbol *fsym,
2483 struct value **valp, struct symbol **symp,
2484 int *staticp, const int no_adl,
2485 const enum noside noside)
2487 struct value *obj = (objp ? *objp : NULL);
2488 struct type *obj_type = obj ? value_type (obj) : NULL;
2489 /* Index of best overloaded function. */
2490 int func_oload_champ = -1;
2491 int method_oload_champ = -1;
2492 int src_method_oload_champ = -1;
2493 int ext_method_oload_champ = -1;
2495 /* The measure for the current best match. */
2496 struct badness_vector *method_badness = NULL;
2497 struct badness_vector *func_badness = NULL;
2498 struct badness_vector *ext_method_badness = NULL;
2499 struct badness_vector *src_method_badness = NULL;
2501 struct value *temp = obj;
2502 /* For methods, the list of overloaded methods. */
2503 struct fn_field *fns_ptr = NULL;
2504 /* For non-methods, the list of overloaded function symbols. */
2505 struct symbol **oload_syms = NULL;
2506 /* For xmethods, the VEC of xmethod workers. */
2507 VEC (xmethod_worker_ptr) *xm_worker_vec = NULL;
2508 /* Number of overloaded instances being considered. */
2510 struct type *basetype = NULL;
2513 struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2515 const char *obj_type_name = NULL;
2516 const char *func_name = NULL;
2517 enum oload_classification match_quality;
2518 enum oload_classification method_match_quality = INCOMPATIBLE;
2519 enum oload_classification src_method_match_quality = INCOMPATIBLE;
2520 enum oload_classification ext_method_match_quality = INCOMPATIBLE;
2521 enum oload_classification func_match_quality = INCOMPATIBLE;
2523 /* Get the list of overloaded methods or functions. */
2524 if (method == METHOD || method == BOTH)
2528 /* OBJ may be a pointer value rather than the object itself. */
2529 obj = coerce_ref (obj);
2530 while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2531 obj = coerce_ref (value_ind (obj));
2532 obj_type_name = TYPE_NAME (value_type (obj));
2534 /* First check whether this is a data member, e.g. a pointer to
2536 if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2538 *valp = search_struct_field (name, obj,
2539 check_typedef (value_type (obj)), 0);
2543 do_cleanups (all_cleanups);
2548 /* Retrieve the list of methods with the name NAME. */
2549 value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns,
2550 &xm_worker_vec, &basetype, &boffset);
2551 /* If this is a method only search, and no methods were found
2552 the search has faild. */
2553 if (method == METHOD && (!fns_ptr || !num_fns) && !xm_worker_vec)
2554 error (_("Couldn't find method %s%s%s"),
2556 (obj_type_name && *obj_type_name) ? "::" : "",
2558 /* If we are dealing with stub method types, they should have
2559 been resolved by find_method_list via
2560 value_find_oload_method_list above. */
2563 gdb_assert (TYPE_SELF_TYPE (fns_ptr[0].type) != NULL);
2565 src_method_oload_champ = find_oload_champ (args, nargs,
2566 num_fns, fns_ptr, NULL,
2567 NULL, &src_method_badness);
2569 src_method_match_quality = classify_oload_match
2570 (src_method_badness, nargs,
2571 oload_method_static_p (fns_ptr, src_method_oload_champ));
2573 make_cleanup (xfree, src_method_badness);
2576 if (VEC_length (xmethod_worker_ptr, xm_worker_vec) > 0)
2578 ext_method_oload_champ = find_oload_champ (args, nargs,
2579 0, NULL, xm_worker_vec,
2580 NULL, &ext_method_badness);
2581 ext_method_match_quality = classify_oload_match (ext_method_badness,
2583 make_cleanup (xfree, ext_method_badness);
2584 make_cleanup (free_xmethod_worker_vec, xm_worker_vec);
2587 if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0)
2589 switch (compare_badness (ext_method_badness, src_method_badness))
2591 case 0: /* Src method and xmethod are equally good. */
2592 /* If src method and xmethod are equally good, then
2593 xmethod should be the winner. Hence, fall through to the
2594 case where a xmethod is better than the source
2595 method, except when the xmethod match quality is
2598 case 1: /* Src method and ext method are incompatible. */
2599 /* If ext method match is not standard, then let source method
2600 win. Otherwise, fallthrough to let xmethod win. */
2601 if (ext_method_match_quality != STANDARD)
2603 method_oload_champ = src_method_oload_champ;
2604 method_badness = src_method_badness;
2605 ext_method_oload_champ = -1;
2606 method_match_quality = src_method_match_quality;
2610 case 2: /* Ext method is champion. */
2611 method_oload_champ = ext_method_oload_champ;
2612 method_badness = ext_method_badness;
2613 src_method_oload_champ = -1;
2614 method_match_quality = ext_method_match_quality;
2616 case 3: /* Src method is champion. */
2617 method_oload_champ = src_method_oload_champ;
2618 method_badness = src_method_badness;
2619 ext_method_oload_champ = -1;
2620 method_match_quality = src_method_match_quality;
2623 gdb_assert_not_reached ("Unexpected overload comparison "
2628 else if (src_method_oload_champ >= 0)
2630 method_oload_champ = src_method_oload_champ;
2631 method_badness = src_method_badness;
2632 method_match_quality = src_method_match_quality;
2634 else if (ext_method_oload_champ >= 0)
2636 method_oload_champ = ext_method_oload_champ;
2637 method_badness = ext_method_badness;
2638 method_match_quality = ext_method_match_quality;
2642 if (method == NON_METHOD || method == BOTH)
2644 const char *qualified_name = NULL;
2646 /* If the overload match is being search for both as a method
2647 and non member function, the first argument must now be
2650 args[0] = value_ind (args[0]);
2654 qualified_name = SYMBOL_NATURAL_NAME (fsym);
2656 /* If we have a function with a C++ name, try to extract just
2657 the function part. Do not try this for non-functions (e.g.
2658 function pointers). */
2660 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
2665 temp = cp_func_name (qualified_name);
2667 /* If cp_func_name did not remove anything, the name of the
2668 symbol did not include scope or argument types - it was
2669 probably a C-style function. */
2672 make_cleanup (xfree, temp);
2673 if (strcmp (temp, qualified_name) == 0)
2683 qualified_name = name;
2686 /* If there was no C++ name, this must be a C-style function or
2687 not a function at all. Just return the same symbol. Do the
2688 same if cp_func_name fails for some reason. */
2689 if (func_name == NULL)
2692 do_cleanups (all_cleanups);
2696 func_oload_champ = find_oload_champ_namespace (args, nargs,
2703 if (func_oload_champ >= 0)
2704 func_match_quality = classify_oload_match (func_badness, nargs, 0);
2706 make_cleanup (xfree, oload_syms);
2707 make_cleanup (xfree, func_badness);
2710 /* Did we find a match ? */
2711 if (method_oload_champ == -1 && func_oload_champ == -1)
2712 throw_error (NOT_FOUND_ERROR,
2713 _("No symbol \"%s\" in current context."),
2716 /* If we have found both a method match and a function
2717 match, find out which one is better, and calculate match
2719 if (method_oload_champ >= 0 && func_oload_champ >= 0)
2721 switch (compare_badness (func_badness, method_badness))
2723 case 0: /* Top two contenders are equally good. */
2724 /* FIXME: GDB does not support the general ambiguous case.
2725 All candidates should be collected and presented the
2727 error (_("Ambiguous overload resolution"));
2729 case 1: /* Incomparable top contenders. */
2730 /* This is an error incompatible candidates
2731 should not have been proposed. */
2732 error (_("Internal error: incompatible "
2733 "overload candidates proposed"));
2735 case 2: /* Function champion. */
2736 method_oload_champ = -1;
2737 match_quality = func_match_quality;
2739 case 3: /* Method champion. */
2740 func_oload_champ = -1;
2741 match_quality = method_match_quality;
2744 error (_("Internal error: unexpected overload comparison result"));
2750 /* We have either a method match or a function match. */
2751 if (method_oload_champ >= 0)
2752 match_quality = method_match_quality;
2754 match_quality = func_match_quality;
2757 if (match_quality == INCOMPATIBLE)
2759 if (method == METHOD)
2760 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2762 (obj_type_name && *obj_type_name) ? "::" : "",
2765 error (_("Cannot resolve function %s to any overloaded instance"),
2768 else if (match_quality == NON_STANDARD)
2770 if (method == METHOD)
2771 warning (_("Using non-standard conversion to match "
2772 "method %s%s%s to supplied arguments"),
2774 (obj_type_name && *obj_type_name) ? "::" : "",
2777 warning (_("Using non-standard conversion to match "
2778 "function %s to supplied arguments"),
2782 if (staticp != NULL)
2783 *staticp = oload_method_static_p (fns_ptr, method_oload_champ);
2785 if (method_oload_champ >= 0)
2787 if (src_method_oload_champ >= 0)
2789 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ)
2790 && noside != EVAL_AVOID_SIDE_EFFECTS)
2792 *valp = value_virtual_fn_field (&temp, fns_ptr,
2793 method_oload_champ, basetype,
2797 *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2802 *valp = value_of_xmethod (clone_xmethod_worker
2803 (VEC_index (xmethod_worker_ptr, xm_worker_vec,
2804 ext_method_oload_champ)));
2808 *symp = oload_syms[func_oload_champ];
2812 struct type *temp_type = check_typedef (value_type (temp));
2813 struct type *objtype = check_typedef (obj_type);
2815 if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2816 && (TYPE_CODE (objtype) == TYPE_CODE_PTR
2817 || TYPE_IS_REFERENCE (objtype)))
2819 temp = value_addr (temp);
2824 do_cleanups (all_cleanups);
2826 switch (match_quality)
2832 default: /* STANDARD */
2837 /* Find the best overload match, searching for FUNC_NAME in namespaces
2838 contained in QUALIFIED_NAME until it either finds a good match or
2839 runs out of namespaces. It stores the overloaded functions in
2840 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2841 calling function is responsible for freeing *OLOAD_SYMS and
2842 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2846 find_oload_champ_namespace (struct value **args, int nargs,
2847 const char *func_name,
2848 const char *qualified_name,
2849 struct symbol ***oload_syms,
2850 struct badness_vector **oload_champ_bv,
2855 find_oload_champ_namespace_loop (args, nargs,
2858 oload_syms, oload_champ_bv,
2865 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2866 how deep we've looked for namespaces, and the champ is stored in
2867 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2868 if it isn't. Other arguments are the same as in
2869 find_oload_champ_namespace
2871 It is the caller's responsibility to free *OLOAD_SYMS and
2875 find_oload_champ_namespace_loop (struct value **args, int nargs,
2876 const char *func_name,
2877 const char *qualified_name,
2879 struct symbol ***oload_syms,
2880 struct badness_vector **oload_champ_bv,
2884 int next_namespace_len = namespace_len;
2885 int searched_deeper = 0;
2887 struct cleanup *old_cleanups;
2888 int new_oload_champ;
2889 struct symbol **new_oload_syms;
2890 struct badness_vector *new_oload_champ_bv;
2891 char *new_namespace;
2893 if (next_namespace_len != 0)
2895 gdb_assert (qualified_name[next_namespace_len] == ':');
2896 next_namespace_len += 2;
2898 next_namespace_len +=
2899 cp_find_first_component (qualified_name + next_namespace_len);
2901 /* Initialize these to values that can safely be xfree'd. */
2903 *oload_champ_bv = NULL;
2905 /* First, see if we have a deeper namespace we can search in.
2906 If we get a good match there, use it. */
2908 if (qualified_name[next_namespace_len] == ':')
2910 searched_deeper = 1;
2912 if (find_oload_champ_namespace_loop (args, nargs,
2913 func_name, qualified_name,
2915 oload_syms, oload_champ_bv,
2916 oload_champ, no_adl))
2922 /* If we reach here, either we're in the deepest namespace or we
2923 didn't find a good match in a deeper namespace. But, in the
2924 latter case, we still have a bad match in a deeper namespace;
2925 note that we might not find any match at all in the current
2926 namespace. (There's always a match in the deepest namespace,
2927 because this overload mechanism only gets called if there's a
2928 function symbol to start off with.) */
2930 old_cleanups = make_cleanup (xfree, *oload_syms);
2931 make_cleanup (xfree, *oload_champ_bv);
2932 new_namespace = (char *) alloca (namespace_len + 1);
2933 strncpy (new_namespace, qualified_name, namespace_len);
2934 new_namespace[namespace_len] = '\0';
2935 new_oload_syms = make_symbol_overload_list (func_name,
2938 /* If we have reached the deepest level perform argument
2939 determined lookup. */
2940 if (!searched_deeper && !no_adl)
2943 struct type **arg_types;
2945 /* Prepare list of argument types for overload resolution. */
2946 arg_types = (struct type **)
2947 alloca (nargs * (sizeof (struct type *)));
2948 for (ix = 0; ix < nargs; ix++)
2949 arg_types[ix] = value_type (args[ix]);
2950 make_symbol_overload_list_adl (arg_types, nargs, func_name);
2953 while (new_oload_syms[num_fns])
2956 new_oload_champ = find_oload_champ (args, nargs, num_fns,
2957 NULL, NULL, new_oload_syms,
2958 &new_oload_champ_bv);
2960 /* Case 1: We found a good match. Free earlier matches (if any),
2961 and return it. Case 2: We didn't find a good match, but we're
2962 not the deepest function. Then go with the bad match that the
2963 deeper function found. Case 3: We found a bad match, and we're
2964 the deepest function. Then return what we found, even though
2965 it's a bad match. */
2967 if (new_oload_champ != -1
2968 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2970 *oload_syms = new_oload_syms;
2971 *oload_champ = new_oload_champ;
2972 *oload_champ_bv = new_oload_champ_bv;
2973 do_cleanups (old_cleanups);
2976 else if (searched_deeper)
2978 xfree (new_oload_syms);
2979 xfree (new_oload_champ_bv);
2980 discard_cleanups (old_cleanups);
2985 *oload_syms = new_oload_syms;
2986 *oload_champ = new_oload_champ;
2987 *oload_champ_bv = new_oload_champ_bv;
2988 do_cleanups (old_cleanups);
2993 /* Look for a function to take NARGS args of ARGS. Find
2994 the best match from among the overloaded methods or functions
2995 given by FNS_PTR or OLOAD_SYMS or XM_WORKER_VEC, respectively.
2996 One, and only one of FNS_PTR, OLOAD_SYMS and XM_WORKER_VEC can be
2999 If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR
3000 or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS.
3002 Return the index of the best match; store an indication of the
3003 quality of the match in OLOAD_CHAMP_BV.
3005 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
3008 find_oload_champ (struct value **args, int nargs,
3009 int num_fns, struct fn_field *fns_ptr,
3010 VEC (xmethod_worker_ptr) *xm_worker_vec,
3011 struct symbol **oload_syms,
3012 struct badness_vector **oload_champ_bv)
3016 /* A measure of how good an overloaded instance is. */
3017 struct badness_vector *bv;
3018 /* Index of best overloaded function. */
3019 int oload_champ = -1;
3020 /* Current ambiguity state for overload resolution. */
3021 int oload_ambiguous = 0;
3022 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3024 /* A champion can be found among methods alone, or among functions
3025 alone, or in xmethods alone, but not in more than one of these
3027 gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL)
3030 *oload_champ_bv = NULL;
3032 fn_count = (xm_worker_vec != NULL
3033 ? VEC_length (xmethod_worker_ptr, xm_worker_vec)
3035 /* Consider each candidate in turn. */
3036 for (ix = 0; ix < fn_count; ix++)
3039 int static_offset = 0;
3041 struct type **parm_types;
3042 struct xmethod_worker *worker = NULL;
3044 if (xm_worker_vec != NULL)
3046 worker = VEC_index (xmethod_worker_ptr, xm_worker_vec, ix);
3047 parm_types = get_xmethod_arg_types (worker, &nparms);
3051 if (fns_ptr != NULL)
3053 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
3054 static_offset = oload_method_static_p (fns_ptr, ix);
3057 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
3059 parm_types = XNEWVEC (struct type *, nparms);
3060 for (jj = 0; jj < nparms; jj++)
3061 parm_types[jj] = (fns_ptr != NULL
3062 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
3063 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
3067 /* Compare parameter types to supplied argument types. Skip
3068 THIS for static methods. */
3069 bv = rank_function (parm_types, nparms,
3070 args + static_offset,
3071 nargs - static_offset);
3073 if (!*oload_champ_bv)
3075 *oload_champ_bv = bv;
3078 else /* See whether current candidate is better or worse than
3080 switch (compare_badness (bv, *oload_champ_bv))
3082 case 0: /* Top two contenders are equally good. */
3083 oload_ambiguous = 1;
3085 case 1: /* Incomparable top contenders. */
3086 oload_ambiguous = 2;
3088 case 2: /* New champion, record details. */
3089 *oload_champ_bv = bv;
3090 oload_ambiguous = 0;
3100 if (fns_ptr != NULL)
3101 fprintf_filtered (gdb_stderr,
3102 "Overloaded method instance %s, # of parms %d\n",
3103 fns_ptr[ix].physname, nparms);
3104 else if (xm_worker_vec != NULL)
3105 fprintf_filtered (gdb_stderr,
3106 "Xmethod worker, # of parms %d\n",
3109 fprintf_filtered (gdb_stderr,
3110 "Overloaded function instance "
3111 "%s # of parms %d\n",
3112 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
3114 for (jj = 0; jj < nargs - static_offset; jj++)
3115 fprintf_filtered (gdb_stderr,
3116 "...Badness @ %d : %d\n",
3117 jj, bv->rank[jj].rank);
3118 fprintf_filtered (gdb_stderr, "Overload resolution "
3119 "champion is %d, ambiguous? %d\n",
3120 oload_champ, oload_ambiguous);
3127 /* Return 1 if we're looking at a static method, 0 if we're looking at
3128 a non-static method or a function that isn't a method. */
3131 oload_method_static_p (struct fn_field *fns_ptr, int index)
3133 if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3139 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3141 static enum oload_classification
3142 classify_oload_match (struct badness_vector *oload_champ_bv,
3147 enum oload_classification worst = STANDARD;
3149 for (ix = 1; ix <= nargs - static_offset; ix++)
3151 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3152 or worse return INCOMPATIBLE. */
3153 if (compare_ranks (oload_champ_bv->rank[ix],
3154 INCOMPATIBLE_TYPE_BADNESS) <= 0)
3155 return INCOMPATIBLE; /* Truly mismatched types. */
3156 /* Otherwise If this conversion is as bad as
3157 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3158 else if (compare_ranks (oload_champ_bv->rank[ix],
3159 NS_POINTER_CONVERSION_BADNESS) <= 0)
3160 worst = NON_STANDARD; /* Non-standard type conversions
3164 /* If no INCOMPATIBLE classification was found, return the worst one
3165 that was found (if any). */
3169 /* C++: return 1 is NAME is a legitimate name for the destructor of
3170 type TYPE. If TYPE does not have a destructor, or if NAME is
3171 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3172 have CHECK_TYPEDEF applied, this function will apply it itself. */
3175 destructor_name_p (const char *name, struct type *type)
3179 const char *dname = type_name_no_tag_or_error (type);
3180 const char *cp = strchr (dname, '<');
3183 /* Do not compare the template part for template classes. */
3185 len = strlen (dname);
3188 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3189 error (_("name of destructor must equal name of class"));
3196 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3197 class". If the name is found, return a value representing it;
3198 otherwise throw an exception. */
3200 static struct value *
3201 enum_constant_from_type (struct type *type, const char *name)
3204 int name_len = strlen (name);
3206 gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM
3207 && TYPE_DECLARED_CLASS (type));
3209 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
3211 const char *fname = TYPE_FIELD_NAME (type, i);
3214 if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL
3218 /* Look for the trailing "::NAME", since enum class constant
3219 names are qualified here. */
3220 len = strlen (fname);
3221 if (len + 2 >= name_len
3222 && fname[len - name_len - 2] == ':'
3223 && fname[len - name_len - 1] == ':'
3224 && strcmp (&fname[len - name_len], name) == 0)
3225 return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, i));
3228 error (_("no constant named \"%s\" in enum \"%s\""),
3229 name, TYPE_TAG_NAME (type));
3232 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3233 return the appropriate member (or the address of the member, if
3234 WANT_ADDRESS). This function is used to resolve user expressions
3235 of the form "DOMAIN::NAME". For more details on what happens, see
3236 the comment before value_struct_elt_for_reference. */
3239 value_aggregate_elt (struct type *curtype, const char *name,
3240 struct type *expect_type, int want_address,
3243 switch (TYPE_CODE (curtype))
3245 case TYPE_CODE_STRUCT:
3246 case TYPE_CODE_UNION:
3247 return value_struct_elt_for_reference (curtype, 0, curtype,
3249 want_address, noside);
3250 case TYPE_CODE_NAMESPACE:
3251 return value_namespace_elt (curtype, name,
3252 want_address, noside);
3254 case TYPE_CODE_ENUM:
3255 return enum_constant_from_type (curtype, name);
3258 internal_error (__FILE__, __LINE__,
3259 _("non-aggregate type in value_aggregate_elt"));
3263 /* Compares the two method/function types T1 and T2 for "equality"
3264 with respect to the methods' parameters. If the types of the
3265 two parameter lists are the same, returns 1; 0 otherwise. This
3266 comparison may ignore any artificial parameters in T1 if
3267 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3268 the first artificial parameter in T1, assumed to be a 'this' pointer.
3270 The type T2 is expected to have come from make_params (in eval.c). */
3273 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3277 if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3280 /* If skipping artificial fields, find the first real field
3282 if (skip_artificial)
3284 while (start < TYPE_NFIELDS (t1)
3285 && TYPE_FIELD_ARTIFICIAL (t1, start))
3289 /* Now compare parameters. */
3291 /* Special case: a method taking void. T1 will contain no
3292 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3293 if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3294 && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3297 if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3301 for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3303 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3304 TYPE_FIELD_TYPE (t2, i), NULL),
3305 EXACT_MATCH_BADNESS) != 0)
3315 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3316 return the address of this member as a "pointer to member" type.
3317 If INTYPE is non-null, then it will be the type of the member we
3318 are looking for. This will help us resolve "pointers to member
3319 functions". This function is used to resolve user expressions of
3320 the form "DOMAIN::NAME". */
3322 static struct value *
3323 value_struct_elt_for_reference (struct type *domain, int offset,
3324 struct type *curtype, const char *name,
3325 struct type *intype,
3329 struct type *t = curtype;
3331 struct value *v, *result;
3333 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3334 && TYPE_CODE (t) != TYPE_CODE_UNION)
3335 error (_("Internal error: non-aggregate type "
3336 "to value_struct_elt_for_reference"));
3338 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3340 const char *t_field_name = TYPE_FIELD_NAME (t, i);
3342 if (t_field_name && strcmp (t_field_name, name) == 0)
3344 if (field_is_static (&TYPE_FIELD (t, i)))
3346 v = value_static_field (t, i);
3351 if (TYPE_FIELD_PACKED (t, i))
3352 error (_("pointers to bitfield members not allowed"));
3355 return value_from_longest
3356 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3357 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3358 else if (noside != EVAL_NORMAL)
3359 return allocate_value (TYPE_FIELD_TYPE (t, i));
3362 /* Try to evaluate NAME as a qualified name with implicit
3363 this pointer. In this case, attempt to return the
3364 equivalent to `this->*(&TYPE::NAME)'. */
3365 v = value_of_this_silent (current_language);
3370 struct type *type, *tmp;
3372 ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
3373 type = check_typedef (value_type (ptr));
3374 gdb_assert (type != NULL
3375 && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
3376 tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
3377 v = value_cast_pointers (tmp, v, 1);
3378 mem_offset = value_as_long (ptr);
3379 tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type));
3380 result = value_from_pointer (tmp,
3381 value_as_long (v) + mem_offset);
3382 return value_ind (result);
3385 error (_("Cannot reference non-static field \"%s\""), name);
3390 /* C++: If it was not found as a data field, then try to return it
3391 as a pointer to a method. */
3393 /* Perform all necessary dereferencing. */
3394 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3395 intype = TYPE_TARGET_TYPE (intype);
3397 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3399 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3400 char dem_opname[64];
3402 if (startswith (t_field_name, "__")
3403 || startswith (t_field_name, "op")
3404 || startswith (t_field_name, "type"))
3406 if (cplus_demangle_opname (t_field_name,
3407 dem_opname, DMGL_ANSI))
3408 t_field_name = dem_opname;
3409 else if (cplus_demangle_opname (t_field_name,
3411 t_field_name = dem_opname;
3413 if (t_field_name && strcmp (t_field_name, name) == 0)
3416 int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3417 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3419 check_stub_method_group (t, i);
3423 for (j = 0; j < len; ++j)
3425 if (TYPE_CONST (intype) != TYPE_FN_FIELD_CONST (f, j))
3427 if (TYPE_VOLATILE (intype) != TYPE_FN_FIELD_VOLATILE (f, j))
3430 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3431 || compare_parameters (TYPE_FN_FIELD_TYPE (f, j),
3437 error (_("no member function matches "
3438 "that type instantiation"));
3445 for (ii = 0; ii < len; ++ii)
3447 /* Skip artificial methods. This is necessary if,
3448 for example, the user wants to "print
3449 subclass::subclass" with only one user-defined
3450 constructor. There is no ambiguity in this case.
3451 We are careful here to allow artificial methods
3452 if they are the unique result. */
3453 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3460 /* Desired method is ambiguous if more than one
3461 method is defined. */
3462 if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3463 error (_("non-unique member `%s' requires "
3464 "type instantiation"), name);
3470 error (_("no matching member function"));
3473 if (TYPE_FN_FIELD_STATIC_P (f, j))
3476 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3477 0, VAR_DOMAIN, 0).symbol;
3483 return value_addr (read_var_value (s, 0, 0));
3485 return read_var_value (s, 0, 0);
3488 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3492 result = allocate_value
3493 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3494 cplus_make_method_ptr (value_type (result),
3495 value_contents_writeable (result),
3496 TYPE_FN_FIELD_VOFFSET (f, j), 1);
3498 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3499 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3501 error (_("Cannot reference virtual member function \"%s\""),
3507 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3508 0, VAR_DOMAIN, 0).symbol;
3513 v = read_var_value (s, 0, 0);
3518 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3519 cplus_make_method_ptr (value_type (result),
3520 value_contents_writeable (result),
3521 value_address (v), 0);
3527 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3532 if (BASETYPE_VIA_VIRTUAL (t, i))
3535 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3536 v = value_struct_elt_for_reference (domain,
3537 offset + base_offset,
3538 TYPE_BASECLASS (t, i),
3540 want_address, noside);
3545 /* As a last chance, pretend that CURTYPE is a namespace, and look
3546 it up that way; this (frequently) works for types nested inside
3549 return value_maybe_namespace_elt (curtype, name,
3550 want_address, noside);
3553 /* C++: Return the member NAME of the namespace given by the type
3556 static struct value *
3557 value_namespace_elt (const struct type *curtype,
3558 const char *name, int want_address,
3561 struct value *retval = value_maybe_namespace_elt (curtype, name,
3566 error (_("No symbol \"%s\" in namespace \"%s\"."),
3567 name, TYPE_TAG_NAME (curtype));
3572 /* A helper function used by value_namespace_elt and
3573 value_struct_elt_for_reference. It looks up NAME inside the
3574 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3575 is a class and NAME refers to a type in CURTYPE itself (as opposed
3576 to, say, some base class of CURTYPE). */
3578 static struct value *
3579 value_maybe_namespace_elt (const struct type *curtype,
3580 const char *name, int want_address,
3583 const char *namespace_name = TYPE_TAG_NAME (curtype);
3584 struct block_symbol sym;
3585 struct value *result;
3587 sym = cp_lookup_symbol_namespace (namespace_name, name,
3588 get_selected_block (0), VAR_DOMAIN);
3590 if (sym.symbol == NULL)
3592 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3593 && (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF))
3594 result = allocate_value (SYMBOL_TYPE (sym.symbol));
3596 result = value_of_variable (sym.symbol, sym.block);
3599 result = value_addr (result);
3604 /* Given a pointer or a reference value V, find its real (RTTI) type.
3606 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3607 and refer to the values computed for the object pointed to. */
3610 value_rtti_indirect_type (struct value *v, int *full,
3611 LONGEST *top, int *using_enc)
3613 struct value *target = NULL;
3614 struct type *type, *real_type, *target_type;
3616 type = value_type (v);
3617 type = check_typedef (type);
3618 if (TYPE_IS_REFERENCE (type))
3619 target = coerce_ref (v);
3620 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3625 target = value_ind (v);
3627 CATCH (except, RETURN_MASK_ERROR)
3629 if (except.error == MEMORY_ERROR)
3631 /* value_ind threw a memory error. The pointer is NULL or
3632 contains an uninitialized value: we can't determine any
3636 throw_exception (except);
3643 real_type = value_rtti_type (target, full, top, using_enc);
3647 /* Copy qualifiers to the referenced object. */
3648 target_type = value_type (target);
3649 real_type = make_cv_type (TYPE_CONST (target_type),
3650 TYPE_VOLATILE (target_type), real_type, NULL);
3651 if (TYPE_IS_REFERENCE (type))
3652 real_type = lookup_reference_type (real_type, TYPE_CODE (type));
3653 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3654 real_type = lookup_pointer_type (real_type);
3656 internal_error (__FILE__, __LINE__, _("Unexpected value type."));
3658 /* Copy qualifiers to the pointer/reference. */
3659 real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3666 /* Given a value pointed to by ARGP, check its real run-time type, and
3667 if that is different from the enclosing type, create a new value
3668 using the real run-time type as the enclosing type (and of the same
3669 type as ARGP) and return it, with the embedded offset adjusted to
3670 be the correct offset to the enclosed object. RTYPE is the type,
3671 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3672 by value_rtti_type(). If these are available, they can be supplied
3673 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3674 NULL if they're not available. */
3677 value_full_object (struct value *argp,
3679 int xfull, int xtop,
3682 struct type *real_type;
3686 struct value *new_val;
3693 using_enc = xusing_enc;
3696 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3698 /* If no RTTI data, or if object is already complete, do nothing. */
3699 if (!real_type || real_type == value_enclosing_type (argp))
3702 /* In a destructor we might see a real type that is a superclass of
3703 the object's type. In this case it is better to leave the object
3706 && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp)))
3709 /* If we have the full object, but for some reason the enclosing
3710 type is wrong, set it. */
3711 /* pai: FIXME -- sounds iffy */
3714 argp = value_copy (argp);
3715 set_value_enclosing_type (argp, real_type);
3719 /* Check if object is in memory. */
3720 if (VALUE_LVAL (argp) != lval_memory)
3722 warning (_("Couldn't retrieve complete object of RTTI "
3723 "type %s; object may be in register(s)."),
3724 TYPE_NAME (real_type));
3729 /* All other cases -- retrieve the complete object. */
3730 /* Go back by the computed top_offset from the beginning of the
3731 object, adjusting for the embedded offset of argp if that's what
3732 value_rtti_type used for its computation. */
3733 new_val = value_at_lazy (real_type, value_address (argp) - top +
3734 (using_enc ? 0 : value_embedded_offset (argp)));
3735 deprecated_set_value_type (new_val, value_type (argp));
3736 set_value_embedded_offset (new_val, (using_enc
3737 ? top + value_embedded_offset (argp)
3743 /* Return the value of the local variable, if one exists. Throw error
3744 otherwise, such as if the request is made in an inappropriate context. */
3747 value_of_this (const struct language_defn *lang)
3749 struct block_symbol sym;
3750 const struct block *b;
3751 struct frame_info *frame;
3753 if (!lang->la_name_of_this)
3754 error (_("no `this' in current language"));
3756 frame = get_selected_frame (_("no frame selected"));
3758 b = get_frame_block (frame, NULL);
3760 sym = lookup_language_this (lang, b);
3761 if (sym.symbol == NULL)
3762 error (_("current stack frame does not contain a variable named `%s'"),
3763 lang->la_name_of_this);
3765 return read_var_value (sym.symbol, sym.block, frame);
3768 /* Return the value of the local variable, if one exists. Return NULL
3769 otherwise. Never throw error. */
3772 value_of_this_silent (const struct language_defn *lang)
3774 struct value *ret = NULL;
3778 ret = value_of_this (lang);
3780 CATCH (except, RETURN_MASK_ERROR)
3788 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3789 elements long, starting at LOWBOUND. The result has the same lower
3790 bound as the original ARRAY. */
3793 value_slice (struct value *array, int lowbound, int length)
3795 struct type *slice_range_type, *slice_type, *range_type;
3796 LONGEST lowerbound, upperbound;
3797 struct value *slice;
3798 struct type *array_type;
3800 array_type = check_typedef (value_type (array));
3801 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3802 && TYPE_CODE (array_type) != TYPE_CODE_STRING)
3803 error (_("cannot take slice of non-array"));
3805 range_type = TYPE_INDEX_TYPE (array_type);
3806 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3807 error (_("slice from bad array or bitstring"));
3809 if (lowbound < lowerbound || length < 0
3810 || lowbound + length - 1 > upperbound)
3811 error (_("slice out of range"));
3813 /* FIXME-type-allocation: need a way to free this type when we are
3815 slice_range_type = create_static_range_type ((struct type *) NULL,
3816 TYPE_TARGET_TYPE (range_type),
3818 lowbound + length - 1);
3821 struct type *element_type = TYPE_TARGET_TYPE (array_type);
3823 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3825 slice_type = create_array_type ((struct type *) NULL,
3828 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3830 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3831 slice = allocate_value_lazy (slice_type);
3834 slice = allocate_value (slice_type);
3835 value_contents_copy (slice, 0, array, offset,
3836 type_length_units (slice_type));
3839 set_value_component_location (slice, array);
3840 set_value_offset (slice, value_offset (array) + offset);
3846 /* Create a value for a FORTRAN complex number. Currently most of the
3847 time values are coerced to COMPLEX*16 (i.e. a complex number
3848 composed of 2 doubles. This really should be a smarter routine
3849 that figures out precision inteligently as opposed to assuming
3850 doubles. FIXME: fmb */
3853 value_literal_complex (struct value *arg1,
3858 struct type *real_type = TYPE_TARGET_TYPE (type);
3860 val = allocate_value (type);
3861 arg1 = value_cast (real_type, arg1);
3862 arg2 = value_cast (real_type, arg2);
3864 memcpy (value_contents_raw (val),
3865 value_contents (arg1), TYPE_LENGTH (real_type));
3866 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3867 value_contents (arg2), TYPE_LENGTH (real_type));
3871 /* Cast a value into the appropriate complex data type. */
3873 static struct value *
3874 cast_into_complex (struct type *type, struct value *val)
3876 struct type *real_type = TYPE_TARGET_TYPE (type);
3878 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3880 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3881 struct value *re_val = allocate_value (val_real_type);
3882 struct value *im_val = allocate_value (val_real_type);
3884 memcpy (value_contents_raw (re_val),
3885 value_contents (val), TYPE_LENGTH (val_real_type));
3886 memcpy (value_contents_raw (im_val),
3887 value_contents (val) + TYPE_LENGTH (val_real_type),
3888 TYPE_LENGTH (val_real_type));
3890 return value_literal_complex (re_val, im_val, type);
3892 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3893 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3894 return value_literal_complex (val,
3895 value_zero (real_type, not_lval),
3898 error (_("cannot cast non-number to complex"));
3902 _initialize_valops (void)
3904 add_setshow_boolean_cmd ("overload-resolution", class_support,
3905 &overload_resolution, _("\
3906 Set overload resolution in evaluating C++ functions."), _("\
3907 Show overload resolution in evaluating C++ functions."),
3909 show_overload_resolution,
3910 &setlist, &showlist);
3911 overload_resolution = 1;