1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2021 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"
37 #include "target-float.h"
38 #include "tracepoint.h"
39 #include "observable.h"
41 #include "extension.h"
43 #include "gdbsupport/byte-vector.h"
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 (gdb::array_view
<value
*> args
,
58 const char *, const char *,
59 std::vector
<symbol
*> *oload_syms
,
63 static int find_oload_champ_namespace_loop (gdb::array_view
<value
*> args
,
64 const char *, const char *,
65 int, std::vector
<symbol
*> *oload_syms
,
66 badness_vector
*, int *,
69 static int find_oload_champ (gdb::array_view
<value
*> args
,
72 xmethod_worker_up
*xmethods
,
74 badness_vector
*oload_champ_bv
);
76 static int oload_method_static_p (struct fn_field
*, int);
78 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
80 static enum oload_classification classify_oload_match
81 (const badness_vector
&, int, int);
83 static struct value
*value_struct_elt_for_reference (struct type
*,
89 static struct value
*value_namespace_elt (const struct type
*,
90 const char *, int , enum noside
);
92 static struct value
*value_maybe_namespace_elt (const struct type
*,
96 static CORE_ADDR
allocate_space_in_inferior (int);
98 static struct value
*cast_into_complex (struct type
*, struct value
*);
100 bool overload_resolution
= false;
102 show_overload_resolution (struct ui_file
*file
, int from_tty
,
103 struct cmd_list_element
*c
,
106 fprintf_filtered (file
, _("Overload resolution in evaluating "
107 "C++ functions is %s.\n"),
111 /* Find the address of function name NAME in the inferior. If OBJF_P
112 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
116 find_function_in_inferior (const char *name
, struct objfile
**objf_p
)
118 struct block_symbol sym
;
120 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
121 if (sym
.symbol
!= NULL
)
123 if (SYMBOL_CLASS (sym
.symbol
) != LOC_BLOCK
)
125 error (_("\"%s\" exists in this program but is not a function."),
130 *objf_p
= symbol_objfile (sym
.symbol
);
132 return value_of_variable (sym
.symbol
, sym
.block
);
136 struct bound_minimal_symbol msymbol
=
137 lookup_bound_minimal_symbol (name
);
139 if (msymbol
.minsym
!= NULL
)
141 struct objfile
*objfile
= msymbol
.objfile
;
142 struct gdbarch
*gdbarch
= objfile
->arch ();
146 type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_char
);
147 type
= lookup_function_type (type
);
148 type
= lookup_pointer_type (type
);
149 maddr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
154 return value_from_pointer (type
, maddr
);
158 if (!target_has_execution ())
159 error (_("evaluation of this expression "
160 "requires the target program to be active"));
162 error (_("evaluation of this expression requires the "
163 "program to have a function \"%s\"."),
169 /* Allocate NBYTES of space in the inferior using the inferior's
170 malloc and return a value that is a pointer to the allocated
174 value_allocate_space_in_inferior (int len
)
176 struct objfile
*objf
;
177 struct value
*val
= find_function_in_inferior ("malloc", &objf
);
178 struct gdbarch
*gdbarch
= objf
->arch ();
179 struct value
*blocklen
;
181 blocklen
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, len
);
182 val
= call_function_by_hand (val
, NULL
, blocklen
);
183 if (value_logical_not (val
))
185 if (!target_has_execution ())
186 error (_("No memory available to program now: "
187 "you need to start the target first"));
189 error (_("No memory available to program: call to malloc failed"));
195 allocate_space_in_inferior (int len
)
197 return value_as_long (value_allocate_space_in_inferior (len
));
200 /* Cast struct value VAL to type TYPE and return as a value.
201 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
202 for this to work. Typedef to one of the codes is permitted.
203 Returns NULL if the cast is neither an upcast nor a downcast. */
205 static struct value
*
206 value_cast_structs (struct type
*type
, struct value
*v2
)
212 gdb_assert (type
!= NULL
&& v2
!= NULL
);
214 t1
= check_typedef (type
);
215 t2
= check_typedef (value_type (v2
));
217 /* Check preconditions. */
218 gdb_assert ((t1
->code () == TYPE_CODE_STRUCT
219 || t1
->code () == TYPE_CODE_UNION
)
220 && !!"Precondition is that type is of STRUCT or UNION kind.");
221 gdb_assert ((t2
->code () == TYPE_CODE_STRUCT
222 || t2
->code () == TYPE_CODE_UNION
)
223 && !!"Precondition is that value is of STRUCT or UNION kind");
225 if (t1
->name () != NULL
226 && t2
->name () != NULL
227 && !strcmp (t1
->name (), t2
->name ()))
230 /* Upcasting: look in the type of the source to see if it contains the
231 type of the target as a superclass. If so, we'll need to
232 offset the pointer rather than just change its type. */
233 if (t1
->name () != NULL
)
235 v
= search_struct_field (t1
->name (),
241 /* Downcasting: look in the type of the target to see if it contains the
242 type of the source as a superclass. If so, we'll need to
243 offset the pointer rather than just change its type. */
244 if (t2
->name () != NULL
)
246 /* Try downcasting using the run-time type of the value. */
249 struct type
*real_type
;
251 real_type
= value_rtti_type (v2
, &full
, &top
, &using_enc
);
254 v
= value_full_object (v2
, real_type
, full
, top
, using_enc
);
255 v
= value_at_lazy (real_type
, value_address (v
));
256 real_type
= value_type (v
);
258 /* We might be trying to cast to the outermost enclosing
259 type, in which case search_struct_field won't work. */
260 if (real_type
->name () != NULL
261 && !strcmp (real_type
->name (), t1
->name ()))
264 v
= search_struct_field (t2
->name (), v
, real_type
, 1);
269 /* Try downcasting using information from the destination type
270 T2. This wouldn't work properly for classes with virtual
271 bases, but those were handled above. */
272 v
= search_struct_field (t2
->name (),
273 value_zero (t1
, not_lval
), t1
, 1);
276 /* Downcasting is possible (t1 is superclass of v2). */
277 CORE_ADDR addr2
= value_address (v2
);
279 addr2
-= value_address (v
) + value_embedded_offset (v
);
280 return value_at (type
, addr2
);
287 /* Cast one pointer or reference type to another. Both TYPE and
288 the type of ARG2 should be pointer types, or else both should be
289 reference types. If SUBCLASS_CHECK is non-zero, this will force a
290 check to see whether TYPE is a superclass of ARG2's type. If
291 SUBCLASS_CHECK is zero, then the subclass check is done only when
292 ARG2 is itself non-zero. Returns the new pointer or reference. */
295 value_cast_pointers (struct type
*type
, struct value
*arg2
,
298 struct type
*type1
= check_typedef (type
);
299 struct type
*type2
= check_typedef (value_type (arg2
));
300 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type1
));
301 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
303 if (t1
->code () == TYPE_CODE_STRUCT
304 && t2
->code () == TYPE_CODE_STRUCT
305 && (subclass_check
|| !value_logical_not (arg2
)))
309 if (TYPE_IS_REFERENCE (type2
))
310 v2
= coerce_ref (arg2
);
312 v2
= value_ind (arg2
);
313 gdb_assert (check_typedef (value_type (v2
))->code ()
314 == TYPE_CODE_STRUCT
&& !!"Why did coercion fail?");
315 v2
= value_cast_structs (t1
, v2
);
316 /* At this point we have what we can have, un-dereference if needed. */
319 struct value
*v
= value_addr (v2
);
321 deprecated_set_value_type (v
, type
);
326 /* No superclass found, just change the pointer type. */
327 arg2
= value_copy (arg2
);
328 deprecated_set_value_type (arg2
, type
);
329 set_value_enclosing_type (arg2
, type
);
330 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
337 value_to_gdb_mpq (struct value
*value
)
339 struct type
*type
= check_typedef (value_type (value
));
342 if (is_floating_type (type
))
344 double d
= target_float_to_host_double (value_contents (value
),
346 mpq_set_d (result
.val
, d
);
350 gdb_assert (is_integral_type (type
)
351 || is_fixed_point_type (type
));
354 vz
.read (gdb::make_array_view (value_contents (value
),
356 type_byte_order (type
), type
->is_unsigned ());
357 mpq_set_z (result
.val
, vz
.val
);
359 if (is_fixed_point_type (type
))
360 mpq_mul (result
.val
, result
.val
,
361 type
->fixed_point_scaling_factor ().val
);
367 /* Assuming that TO_TYPE is a fixed point type, return a value
368 corresponding to the cast of FROM_VAL to that type. */
370 static struct value
*
371 value_cast_to_fixed_point (struct type
*to_type
, struct value
*from_val
)
373 struct type
*from_type
= value_type (from_val
);
375 if (from_type
== to_type
)
378 if (!is_floating_type (from_type
)
379 && !is_integral_type (from_type
)
380 && !is_fixed_point_type (from_type
))
381 error (_("Invalid conversion from type %s to fixed point type %s"),
382 from_type
->name (), to_type
->name ());
384 gdb_mpq vq
= value_to_gdb_mpq (from_val
);
386 /* Divide that value by the scaling factor to obtain the unscaled
387 value, first in rational form, and then in integer form. */
389 mpq_div (vq
.val
, vq
.val
, to_type
->fixed_point_scaling_factor ().val
);
390 gdb_mpz unscaled
= vq
.get_rounded ();
392 /* Finally, create the result value, and pack the unscaled value
394 struct value
*result
= allocate_value (to_type
);
395 unscaled
.write (gdb::make_array_view (value_contents_raw (result
),
396 TYPE_LENGTH (to_type
)),
397 type_byte_order (to_type
),
398 to_type
->is_unsigned ());
403 /* Cast value ARG2 to type TYPE and return as a value.
404 More general than a C cast: accepts any two types of the same length,
405 and if ARG2 is an lvalue it can be cast into anything at all. */
406 /* In C++, casts may change pointer or object representations. */
409 value_cast (struct type
*type
, struct value
*arg2
)
411 enum type_code code1
;
412 enum type_code code2
;
416 int convert_to_boolean
= 0;
418 if (value_type (arg2
) == type
)
421 if (is_fixed_point_type (type
))
422 return value_cast_to_fixed_point (type
, arg2
);
424 /* Check if we are casting struct reference to struct reference. */
425 if (TYPE_IS_REFERENCE (check_typedef (type
)))
427 /* We dereference type; then we recurse and finally
428 we generate value of the given reference. Nothing wrong with
430 struct type
*t1
= check_typedef (type
);
431 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
432 struct value
*val
= value_cast (dereftype
, arg2
);
434 return value_ref (val
, t1
->code ());
437 if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2
))))
438 /* We deref the value and then do the cast. */
439 return value_cast (type
, coerce_ref (arg2
));
441 /* Strip typedefs / resolve stubs in order to get at the type's
442 code/length, but remember the original type, to use as the
443 resulting type of the cast, in case it was a typedef. */
444 struct type
*to_type
= type
;
446 type
= check_typedef (type
);
447 code1
= type
->code ();
448 arg2
= coerce_ref (arg2
);
449 type2
= check_typedef (value_type (arg2
));
451 /* You can't cast to a reference type. See value_cast_pointers
453 gdb_assert (!TYPE_IS_REFERENCE (type
));
455 /* A cast to an undetermined-length array_type, such as
456 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
457 where N is sizeof(OBJECT)/sizeof(TYPE). */
458 if (code1
== TYPE_CODE_ARRAY
)
460 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
461 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
463 if (element_length
> 0 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
465 struct type
*range_type
= type
->index_type ();
466 int val_length
= TYPE_LENGTH (type2
);
467 LONGEST low_bound
, high_bound
, new_length
;
469 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
470 low_bound
= 0, high_bound
= 0;
471 new_length
= val_length
/ element_length
;
472 if (val_length
% element_length
!= 0)
473 warning (_("array element type size does not "
474 "divide object size in cast"));
475 /* FIXME-type-allocation: need a way to free this type when
476 we are done with it. */
477 range_type
= create_static_range_type (NULL
,
478 TYPE_TARGET_TYPE (range_type
),
480 new_length
+ low_bound
- 1);
481 deprecated_set_value_type (arg2
,
482 create_array_type (NULL
,
489 if (current_language
->c_style_arrays_p ()
490 && type2
->code () == TYPE_CODE_ARRAY
491 && !type2
->is_vector ())
492 arg2
= value_coerce_array (arg2
);
494 if (type2
->code () == TYPE_CODE_FUNC
)
495 arg2
= value_coerce_function (arg2
);
497 type2
= check_typedef (value_type (arg2
));
498 code2
= type2
->code ();
500 if (code1
== TYPE_CODE_COMPLEX
)
501 return cast_into_complex (to_type
, arg2
);
502 if (code1
== TYPE_CODE_BOOL
)
504 code1
= TYPE_CODE_INT
;
505 convert_to_boolean
= 1;
507 if (code1
== TYPE_CODE_CHAR
)
508 code1
= TYPE_CODE_INT
;
509 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
510 code2
= TYPE_CODE_INT
;
512 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
513 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
514 || code2
== TYPE_CODE_RANGE
515 || is_fixed_point_type (type2
));
517 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
518 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
519 && type
->name () != 0)
521 struct value
*v
= value_cast_structs (to_type
, arg2
);
527 if (is_floating_type (type
) && scalar
)
529 if (is_floating_value (arg2
))
531 struct value
*v
= allocate_value (to_type
);
532 target_float_convert (value_contents (arg2
), type2
,
533 value_contents_raw (v
), type
);
536 else if (is_fixed_point_type (type2
))
540 fp_val
.read_fixed_point
541 (gdb::make_array_view (value_contents (arg2
), TYPE_LENGTH (type2
)),
542 type_byte_order (type2
), type2
->is_unsigned (),
543 type2
->fixed_point_scaling_factor ());
545 struct value
*v
= allocate_value (to_type
);
546 target_float_from_host_double (value_contents_raw (v
),
547 to_type
, mpq_get_d (fp_val
.val
));
551 /* The only option left is an integral type. */
552 if (type2
->is_unsigned ())
553 return value_from_ulongest (to_type
, value_as_long (arg2
));
555 return value_from_longest (to_type
, value_as_long (arg2
));
557 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
558 || code1
== TYPE_CODE_RANGE
)
559 && (scalar
|| code2
== TYPE_CODE_PTR
560 || code2
== TYPE_CODE_MEMBERPTR
))
564 /* When we cast pointers to integers, we mustn't use
565 gdbarch_pointer_to_address to find the address the pointer
566 represents, as value_as_long would. GDB should evaluate
567 expressions just as the compiler would --- and the compiler
568 sees a cast as a simple reinterpretation of the pointer's
570 if (code2
== TYPE_CODE_PTR
)
571 longest
= extract_unsigned_integer
572 (value_contents (arg2
), TYPE_LENGTH (type2
),
573 type_byte_order (type2
));
575 longest
= value_as_long (arg2
);
576 return value_from_longest (to_type
, convert_to_boolean
?
577 (LONGEST
) (longest
? 1 : 0) : longest
);
579 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
580 || code2
== TYPE_CODE_ENUM
581 || code2
== TYPE_CODE_RANGE
))
583 /* TYPE_LENGTH (type) is the length of a pointer, but we really
584 want the length of an address! -- we are really dealing with
585 addresses (i.e., gdb representations) not pointers (i.e.,
586 target representations) here.
588 This allows things like "print *(int *)0x01000234" to work
589 without printing a misleading message -- which would
590 otherwise occur when dealing with a target having two byte
591 pointers and four byte addresses. */
593 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
594 LONGEST longest
= value_as_long (arg2
);
596 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
598 if (longest
>= ((LONGEST
) 1 << addr_bit
)
599 || longest
<= -((LONGEST
) 1 << addr_bit
))
600 warning (_("value truncated"));
602 return value_from_longest (to_type
, longest
);
604 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
605 && value_as_long (arg2
) == 0)
607 struct value
*result
= allocate_value (to_type
);
609 cplus_make_method_ptr (to_type
, value_contents_writeable (result
), 0, 0);
612 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
613 && value_as_long (arg2
) == 0)
615 /* The Itanium C++ ABI represents NULL pointers to members as
616 minus one, instead of biasing the normal case. */
617 return value_from_longest (to_type
, -1);
619 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector ()
620 && code2
== TYPE_CODE_ARRAY
&& type2
->is_vector ()
621 && TYPE_LENGTH (type
) != TYPE_LENGTH (type2
))
622 error (_("Cannot convert between vector values of different sizes"));
623 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector () && scalar
624 && TYPE_LENGTH (type
) != TYPE_LENGTH (type2
))
625 error (_("can only cast scalar to vector of same size"));
626 else if (code1
== TYPE_CODE_VOID
)
628 return value_zero (to_type
, not_lval
);
630 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
632 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
633 return value_cast_pointers (to_type
, arg2
, 0);
635 arg2
= value_copy (arg2
);
636 deprecated_set_value_type (arg2
, to_type
);
637 set_value_enclosing_type (arg2
, to_type
);
638 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
641 else if (VALUE_LVAL (arg2
) == lval_memory
)
642 return value_at_lazy (to_type
, value_address (arg2
));
645 if (current_language
->la_language
== language_ada
)
646 error (_("Invalid type conversion."));
647 error (_("Invalid cast."));
651 /* The C++ reinterpret_cast operator. */
654 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
656 struct value
*result
;
657 struct type
*real_type
= check_typedef (type
);
658 struct type
*arg_type
, *dest_type
;
660 enum type_code dest_code
, arg_code
;
662 /* Do reference, function, and array conversion. */
663 arg
= coerce_array (arg
);
665 /* Attempt to preserve the type the user asked for. */
668 /* If we are casting to a reference type, transform
669 reinterpret_cast<T&[&]>(V) to *reinterpret_cast<T*>(&V). */
670 if (TYPE_IS_REFERENCE (real_type
))
673 arg
= value_addr (arg
);
674 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
675 real_type
= lookup_pointer_type (real_type
);
678 arg_type
= value_type (arg
);
680 dest_code
= real_type
->code ();
681 arg_code
= arg_type
->code ();
683 /* We can convert pointer types, or any pointer type to int, or int
685 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
686 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
687 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
688 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
689 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
690 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
691 || (dest_code
== arg_code
692 && (dest_code
== TYPE_CODE_PTR
693 || dest_code
== TYPE_CODE_METHODPTR
694 || dest_code
== TYPE_CODE_MEMBERPTR
)))
695 result
= value_cast (dest_type
, arg
);
697 error (_("Invalid reinterpret_cast"));
700 result
= value_cast (type
, value_ref (value_ind (result
),
706 /* A helper for value_dynamic_cast. This implements the first of two
707 runtime checks: we iterate over all the base classes of the value's
708 class which are equal to the desired class; if only one of these
709 holds the value, then it is the answer. */
712 dynamic_cast_check_1 (struct type
*desired_type
,
713 const gdb_byte
*valaddr
,
714 LONGEST embedded_offset
,
717 struct type
*search_type
,
719 struct type
*arg_type
,
720 struct value
**result
)
722 int i
, result_count
= 0;
724 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
726 LONGEST offset
= baseclass_offset (search_type
, i
, valaddr
,
730 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
732 if (address
+ embedded_offset
+ offset
>= arg_addr
733 && address
+ embedded_offset
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
737 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
738 address
+ embedded_offset
+ offset
);
742 result_count
+= dynamic_cast_check_1 (desired_type
,
744 embedded_offset
+ offset
,
746 TYPE_BASECLASS (search_type
, i
),
755 /* A helper for value_dynamic_cast. This implements the second of two
756 runtime checks: we look for a unique public sibling class of the
757 argument's declared class. */
760 dynamic_cast_check_2 (struct type
*desired_type
,
761 const gdb_byte
*valaddr
,
762 LONGEST embedded_offset
,
765 struct type
*search_type
,
766 struct value
**result
)
768 int i
, result_count
= 0;
770 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
774 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
777 offset
= baseclass_offset (search_type
, i
, valaddr
, embedded_offset
,
779 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
783 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
784 address
+ embedded_offset
+ offset
);
787 result_count
+= dynamic_cast_check_2 (desired_type
,
789 embedded_offset
+ offset
,
791 TYPE_BASECLASS (search_type
, i
),
798 /* The C++ dynamic_cast operator. */
801 value_dynamic_cast (struct type
*type
, struct value
*arg
)
805 struct type
*resolved_type
= check_typedef (type
);
806 struct type
*arg_type
= check_typedef (value_type (arg
));
807 struct type
*class_type
, *rtti_type
;
808 struct value
*result
, *tem
, *original_arg
= arg
;
810 int is_ref
= TYPE_IS_REFERENCE (resolved_type
);
812 if (resolved_type
->code () != TYPE_CODE_PTR
813 && !TYPE_IS_REFERENCE (resolved_type
))
814 error (_("Argument to dynamic_cast must be a pointer or reference type"));
815 if (TYPE_TARGET_TYPE (resolved_type
)->code () != TYPE_CODE_VOID
816 && TYPE_TARGET_TYPE (resolved_type
)->code () != TYPE_CODE_STRUCT
)
817 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
819 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
820 if (resolved_type
->code () == TYPE_CODE_PTR
)
822 if (arg_type
->code () != TYPE_CODE_PTR
823 && ! (arg_type
->code () == TYPE_CODE_INT
824 && value_as_long (arg
) == 0))
825 error (_("Argument to dynamic_cast does not have pointer type"));
826 if (arg_type
->code () == TYPE_CODE_PTR
)
828 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
829 if (arg_type
->code () != TYPE_CODE_STRUCT
)
830 error (_("Argument to dynamic_cast does "
831 "not have pointer to class type"));
834 /* Handle NULL pointers. */
835 if (value_as_long (arg
) == 0)
836 return value_zero (type
, not_lval
);
838 arg
= value_ind (arg
);
842 if (arg_type
->code () != TYPE_CODE_STRUCT
)
843 error (_("Argument to dynamic_cast does not have class type"));
846 /* If the classes are the same, just return the argument. */
847 if (class_types_same_p (class_type
, arg_type
))
848 return value_cast (type
, arg
);
850 /* If the target type is a unique base class of the argument's
851 declared type, just cast it. */
852 if (is_ancestor (class_type
, arg_type
))
854 if (is_unique_ancestor (class_type
, arg
))
855 return value_cast (type
, original_arg
);
856 error (_("Ambiguous dynamic_cast"));
859 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
861 error (_("Couldn't determine value's most derived type for dynamic_cast"));
863 /* Compute the most derived object's address. */
864 addr
= value_address (arg
);
872 addr
+= top
+ value_embedded_offset (arg
);
874 /* dynamic_cast<void *> means to return a pointer to the
875 most-derived object. */
876 if (resolved_type
->code () == TYPE_CODE_PTR
877 && TYPE_TARGET_TYPE (resolved_type
)->code () == TYPE_CODE_VOID
)
878 return value_at_lazy (type
, addr
);
880 tem
= value_at (type
, addr
);
881 type
= value_type (tem
);
883 /* The first dynamic check specified in 5.2.7. */
884 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
886 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
889 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
890 value_contents_for_printing (tem
),
891 value_embedded_offset (tem
),
892 value_address (tem
), tem
,
896 return value_cast (type
,
898 ? value_ref (result
, resolved_type
->code ())
899 : value_addr (result
));
902 /* The second dynamic check specified in 5.2.7. */
904 if (is_public_ancestor (arg_type
, rtti_type
)
905 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
906 value_contents_for_printing (tem
),
907 value_embedded_offset (tem
),
908 value_address (tem
), tem
,
909 rtti_type
, &result
) == 1)
910 return value_cast (type
,
912 ? value_ref (result
, resolved_type
->code ())
913 : value_addr (result
));
915 if (resolved_type
->code () == TYPE_CODE_PTR
)
916 return value_zero (type
, not_lval
);
918 error (_("dynamic_cast failed"));
921 /* Create a value of type TYPE that is zero, and return it. */
924 value_zero (struct type
*type
, enum lval_type lv
)
926 struct value
*val
= allocate_value (type
);
928 VALUE_LVAL (val
) = (lv
== lval_computed
? not_lval
: lv
);
932 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
935 value_one (struct type
*type
)
937 struct type
*type1
= check_typedef (type
);
940 if (is_integral_type (type1
) || is_floating_type (type1
))
942 val
= value_from_longest (type
, (LONGEST
) 1);
944 else if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
946 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type1
));
948 LONGEST low_bound
, high_bound
;
951 if (!get_array_bounds (type1
, &low_bound
, &high_bound
))
952 error (_("Could not determine the vector bounds"));
954 val
= allocate_value (type
);
955 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
957 tmp
= value_one (eltype
);
958 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
959 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
964 error (_("Not a numeric type."));
967 /* value_one result is never used for assignments to. */
968 gdb_assert (VALUE_LVAL (val
) == not_lval
);
973 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
974 The type of the created value may differ from the passed type TYPE.
975 Make sure to retrieve the returned values's new type after this call
976 e.g. in case the type is a variable length array. */
978 static struct value
*
979 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
983 if (check_typedef (type
)->code () == TYPE_CODE_VOID
)
984 error (_("Attempt to dereference a generic pointer."));
986 val
= value_from_contents_and_address (type
, NULL
, addr
);
989 value_fetch_lazy (val
);
994 /* Return a value with type TYPE located at ADDR.
996 Call value_at only if the data needs to be fetched immediately;
997 if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
998 value_at_lazy instead. value_at_lazy simply records the address of
999 the data and sets the lazy-evaluation-required flag. The lazy flag
1000 is tested in the value_contents macro, which is used if and when
1001 the contents are actually required. The type of the created value
1002 may differ from the passed type TYPE. Make sure to retrieve the
1003 returned values's new type after this call e.g. in case the type
1004 is a variable length array.
1006 Note: value_at does *NOT* handle embedded offsets; perform such
1007 adjustments before or after calling it. */
1010 value_at (struct type
*type
, CORE_ADDR addr
)
1012 return get_value_at (type
, addr
, 0);
1015 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
1016 The type of the created value may differ from the passed type TYPE.
1017 Make sure to retrieve the returned values's new type after this call
1018 e.g. in case the type is a variable length array. */
1021 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
1023 return get_value_at (type
, addr
, 1);
1027 read_value_memory (struct value
*val
, LONGEST bit_offset
,
1028 int stack
, CORE_ADDR memaddr
,
1029 gdb_byte
*buffer
, size_t length
)
1031 ULONGEST xfered_total
= 0;
1032 struct gdbarch
*arch
= get_value_arch (val
);
1033 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
1034 enum target_object object
;
1036 object
= stack
? TARGET_OBJECT_STACK_MEMORY
: TARGET_OBJECT_MEMORY
;
1038 while (xfered_total
< length
)
1040 enum target_xfer_status status
;
1041 ULONGEST xfered_partial
;
1043 status
= target_xfer_partial (current_top_target (),
1045 buffer
+ xfered_total
* unit_size
, NULL
,
1046 memaddr
+ xfered_total
,
1047 length
- xfered_total
,
1050 if (status
== TARGET_XFER_OK
)
1052 else if (status
== TARGET_XFER_UNAVAILABLE
)
1053 mark_value_bits_unavailable (val
, (xfered_total
* HOST_CHAR_BIT
1055 xfered_partial
* HOST_CHAR_BIT
);
1056 else if (status
== TARGET_XFER_EOF
)
1057 memory_error (TARGET_XFER_E_IO
, memaddr
+ xfered_total
);
1059 memory_error (status
, memaddr
+ xfered_total
);
1061 xfered_total
+= xfered_partial
;
1066 /* Store the contents of FROMVAL into the location of TOVAL.
1067 Return a new value with the location of TOVAL and contents of FROMVAL. */
1070 value_assign (struct value
*toval
, struct value
*fromval
)
1074 struct frame_id old_frame
;
1076 if (!deprecated_value_modifiable (toval
))
1077 error (_("Left operand of assignment is not a modifiable lvalue."));
1079 toval
= coerce_ref (toval
);
1081 type
= value_type (toval
);
1082 if (VALUE_LVAL (toval
) != lval_internalvar
)
1083 fromval
= value_cast (type
, fromval
);
1086 /* Coerce arrays and functions to pointers, except for arrays
1087 which only live in GDB's storage. */
1088 if (!value_must_coerce_to_target (fromval
))
1089 fromval
= coerce_array (fromval
);
1092 type
= check_typedef (type
);
1094 /* Since modifying a register can trash the frame chain, and
1095 modifying memory can trash the frame cache, we save the old frame
1096 and then restore the new frame afterwards. */
1097 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1099 switch (VALUE_LVAL (toval
))
1101 case lval_internalvar
:
1102 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1103 return value_of_internalvar (get_type_arch (type
),
1104 VALUE_INTERNALVAR (toval
));
1106 case lval_internalvar_component
:
1108 LONGEST offset
= value_offset (toval
);
1110 /* Are we dealing with a bitfield?
1112 It is important to mention that `value_parent (toval)' is
1113 non-NULL iff `value_bitsize (toval)' is non-zero. */
1114 if (value_bitsize (toval
))
1116 /* VALUE_INTERNALVAR below refers to the parent value, while
1117 the offset is relative to this parent value. */
1118 gdb_assert (value_parent (value_parent (toval
)) == NULL
);
1119 offset
+= value_offset (value_parent (toval
));
1122 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1124 value_bitpos (toval
),
1125 value_bitsize (toval
),
1132 const gdb_byte
*dest_buffer
;
1133 CORE_ADDR changed_addr
;
1135 gdb_byte buffer
[sizeof (LONGEST
)];
1137 if (value_bitsize (toval
))
1139 struct value
*parent
= value_parent (toval
);
1141 changed_addr
= value_address (parent
) + value_offset (toval
);
1142 changed_len
= (value_bitpos (toval
)
1143 + value_bitsize (toval
)
1144 + HOST_CHAR_BIT
- 1)
1147 /* If we can read-modify-write exactly the size of the
1148 containing type (e.g. short or int) then do so. This
1149 is safer for volatile bitfields mapped to hardware
1151 if (changed_len
< TYPE_LENGTH (type
)
1152 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1153 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1154 changed_len
= TYPE_LENGTH (type
);
1156 if (changed_len
> (int) sizeof (LONGEST
))
1157 error (_("Can't handle bitfields which "
1158 "don't fit in a %d bit word."),
1159 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1161 read_memory (changed_addr
, buffer
, changed_len
);
1162 modify_field (type
, buffer
, value_as_long (fromval
),
1163 value_bitpos (toval
), value_bitsize (toval
));
1164 dest_buffer
= buffer
;
1168 changed_addr
= value_address (toval
);
1169 changed_len
= type_length_units (type
);
1170 dest_buffer
= value_contents (fromval
);
1173 write_memory_with_notification (changed_addr
, dest_buffer
, changed_len
);
1179 struct frame_info
*frame
;
1180 struct gdbarch
*gdbarch
;
1183 /* Figure out which frame this is in currently.
1185 We use VALUE_FRAME_ID for obtaining the value's frame id instead of
1186 VALUE_NEXT_FRAME_ID due to requiring a frame which may be passed to
1187 put_frame_register_bytes() below. That function will (eventually)
1188 perform the necessary unwind operation by first obtaining the next
1190 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1192 value_reg
= VALUE_REGNUM (toval
);
1195 error (_("Value being assigned to is no longer active."));
1197 gdbarch
= get_frame_arch (frame
);
1199 if (value_bitsize (toval
))
1201 struct value
*parent
= value_parent (toval
);
1202 LONGEST offset
= value_offset (parent
) + value_offset (toval
);
1204 gdb_byte buffer
[sizeof (LONGEST
)];
1207 changed_len
= (value_bitpos (toval
)
1208 + value_bitsize (toval
)
1209 + HOST_CHAR_BIT
- 1)
1212 if (changed_len
> sizeof (LONGEST
))
1213 error (_("Can't handle bitfields which "
1214 "don't fit in a %d bit word."),
1215 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1217 if (!get_frame_register_bytes (frame
, value_reg
, offset
,
1218 {buffer
, changed_len
},
1222 throw_error (OPTIMIZED_OUT_ERROR
,
1223 _("value has been optimized out"));
1225 throw_error (NOT_AVAILABLE_ERROR
,
1226 _("value is not available"));
1229 modify_field (type
, buffer
, value_as_long (fromval
),
1230 value_bitpos (toval
), value_bitsize (toval
));
1232 put_frame_register_bytes (frame
, value_reg
, offset
,
1233 {buffer
, changed_len
});
1237 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
),
1240 /* If TOVAL is a special machine register requiring
1241 conversion of program values to a special raw
1243 gdbarch_value_to_register (gdbarch
, frame
,
1244 VALUE_REGNUM (toval
), type
,
1245 value_contents (fromval
));
1249 gdb::array_view
<const gdb_byte
> contents
1250 = gdb::make_array_view (value_contents (fromval
),
1251 TYPE_LENGTH (type
));
1252 put_frame_register_bytes (frame
, value_reg
,
1253 value_offset (toval
),
1258 gdb::observers::register_changed
.notify (frame
, value_reg
);
1264 const struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1266 if (funcs
->write
!= NULL
)
1268 funcs
->write (toval
, fromval
);
1275 error (_("Left operand of assignment is not an lvalue."));
1278 /* Assigning to the stack pointer, frame pointer, and other
1279 (architecture and calling convention specific) registers may
1280 cause the frame cache and regcache to be out of date. Assigning to memory
1281 also can. We just do this on all assignments to registers or
1282 memory, for simplicity's sake; I doubt the slowdown matters. */
1283 switch (VALUE_LVAL (toval
))
1289 gdb::observers::target_changed
.notify (current_top_target ());
1291 /* Having destroyed the frame cache, restore the selected
1294 /* FIXME: cagney/2002-11-02: There has to be a better way of
1295 doing this. Instead of constantly saving/restoring the
1296 frame. Why not create a get_selected_frame() function that,
1297 having saved the selected frame's ID can automatically
1298 re-find the previously selected frame automatically. */
1301 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1312 /* If the field does not entirely fill a LONGEST, then zero the sign
1313 bits. If the field is signed, and is negative, then sign
1315 if ((value_bitsize (toval
) > 0)
1316 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1318 LONGEST fieldval
= value_as_long (fromval
);
1319 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1321 fieldval
&= valmask
;
1322 if (!type
->is_unsigned ()
1323 && (fieldval
& (valmask
^ (valmask
>> 1))))
1324 fieldval
|= ~valmask
;
1326 fromval
= value_from_longest (type
, fieldval
);
1329 /* The return value is a copy of TOVAL so it shares its location
1330 information, but its contents are updated from FROMVAL. This
1331 implies the returned value is not lazy, even if TOVAL was. */
1332 val
= value_copy (toval
);
1333 set_value_lazy (val
, 0);
1334 memcpy (value_contents_raw (val
), value_contents (fromval
),
1335 TYPE_LENGTH (type
));
1337 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1338 in the case of pointer types. For object types, the enclosing type
1339 and embedded offset must *not* be copied: the target object refered
1340 to by TOVAL retains its original dynamic type after assignment. */
1341 if (type
->code () == TYPE_CODE_PTR
)
1343 set_value_enclosing_type (val
, value_enclosing_type (fromval
));
1344 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1350 /* Extend a value ARG1 to COUNT repetitions of its type. */
1353 value_repeat (struct value
*arg1
, int count
)
1357 if (VALUE_LVAL (arg1
) != lval_memory
)
1358 error (_("Only values in memory can be extended with '@'."));
1360 error (_("Invalid number %d of repetitions."), count
);
1362 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1364 VALUE_LVAL (val
) = lval_memory
;
1365 set_value_address (val
, value_address (arg1
));
1367 read_value_memory (val
, 0, value_stack (val
), value_address (val
),
1368 value_contents_all_raw (val
),
1369 type_length_units (value_enclosing_type (val
)));
1375 value_of_variable (struct symbol
*var
, const struct block
*b
)
1377 struct frame_info
*frame
= NULL
;
1379 if (symbol_read_needs_frame (var
))
1380 frame
= get_selected_frame (_("No frame selected."));
1382 return read_var_value (var
, b
, frame
);
1386 address_of_variable (struct symbol
*var
, const struct block
*b
)
1388 struct type
*type
= SYMBOL_TYPE (var
);
1391 /* Evaluate it first; if the result is a memory address, we're fine.
1392 Lazy evaluation pays off here. */
1394 val
= value_of_variable (var
, b
);
1395 type
= value_type (val
);
1397 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1398 || type
->code () == TYPE_CODE_FUNC
)
1400 CORE_ADDR addr
= value_address (val
);
1402 return value_from_pointer (lookup_pointer_type (type
), addr
);
1405 /* Not a memory address; check what the problem was. */
1406 switch (VALUE_LVAL (val
))
1410 struct frame_info
*frame
;
1411 const char *regname
;
1413 frame
= frame_find_by_id (VALUE_NEXT_FRAME_ID (val
));
1416 regname
= gdbarch_register_name (get_frame_arch (frame
),
1417 VALUE_REGNUM (val
));
1418 gdb_assert (regname
&& *regname
);
1420 error (_("Address requested for identifier "
1421 "\"%s\" which is in register $%s"),
1422 var
->print_name (), regname
);
1427 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1428 var
->print_name ());
1438 value_must_coerce_to_target (struct value
*val
)
1440 struct type
*valtype
;
1442 /* The only lval kinds which do not live in target memory. */
1443 if (VALUE_LVAL (val
) != not_lval
1444 && VALUE_LVAL (val
) != lval_internalvar
1445 && VALUE_LVAL (val
) != lval_xcallable
)
1448 valtype
= check_typedef (value_type (val
));
1450 switch (valtype
->code ())
1452 case TYPE_CODE_ARRAY
:
1453 return valtype
->is_vector () ? 0 : 1;
1454 case TYPE_CODE_STRING
:
1461 /* Make sure that VAL lives in target memory if it's supposed to. For
1462 instance, strings are constructed as character arrays in GDB's
1463 storage, and this function copies them to the target. */
1466 value_coerce_to_target (struct value
*val
)
1471 if (!value_must_coerce_to_target (val
))
1474 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1475 addr
= allocate_space_in_inferior (length
);
1476 write_memory (addr
, value_contents (val
), length
);
1477 return value_at_lazy (value_type (val
), addr
);
1480 /* Given a value which is an array, return a value which is a pointer
1481 to its first element, regardless of whether or not the array has a
1482 nonzero lower bound.
1484 FIXME: A previous comment here indicated that this routine should
1485 be substracting the array's lower bound. It's not clear to me that
1486 this is correct. Given an array subscripting operation, it would
1487 certainly work to do the adjustment here, essentially computing:
1489 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1491 However I believe a more appropriate and logical place to account
1492 for the lower bound is to do so in value_subscript, essentially
1495 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1497 As further evidence consider what would happen with operations
1498 other than array subscripting, where the caller would get back a
1499 value that had an address somewhere before the actual first element
1500 of the array, and the information about the lower bound would be
1501 lost because of the coercion to pointer type. */
1504 value_coerce_array (struct value
*arg1
)
1506 struct type
*type
= check_typedef (value_type (arg1
));
1508 /* If the user tries to do something requiring a pointer with an
1509 array that has not yet been pushed to the target, then this would
1510 be a good time to do so. */
1511 arg1
= value_coerce_to_target (arg1
);
1513 if (VALUE_LVAL (arg1
) != lval_memory
)
1514 error (_("Attempt to take address of value not located in memory."));
1516 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1517 value_address (arg1
));
1520 /* Given a value which is a function, return a value which is a pointer
1524 value_coerce_function (struct value
*arg1
)
1526 struct value
*retval
;
1528 if (VALUE_LVAL (arg1
) != lval_memory
)
1529 error (_("Attempt to take address of value not located in memory."));
1531 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1532 value_address (arg1
));
1536 /* Return a pointer value for the object for which ARG1 is the
1540 value_addr (struct value
*arg1
)
1543 struct type
*type
= check_typedef (value_type (arg1
));
1545 if (TYPE_IS_REFERENCE (type
))
1547 if (value_bits_synthetic_pointer (arg1
, value_embedded_offset (arg1
),
1548 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1549 arg1
= coerce_ref (arg1
);
1552 /* Copy the value, but change the type from (T&) to (T*). We
1553 keep the same location information, which is efficient, and
1554 allows &(&X) to get the location containing the reference.
1555 Do the same to its enclosing type for consistency. */
1556 struct type
*type_ptr
1557 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1558 struct type
*enclosing_type
1559 = check_typedef (value_enclosing_type (arg1
));
1560 struct type
*enclosing_type_ptr
1561 = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type
));
1563 arg2
= value_copy (arg1
);
1564 deprecated_set_value_type (arg2
, type_ptr
);
1565 set_value_enclosing_type (arg2
, enclosing_type_ptr
);
1570 if (type
->code () == TYPE_CODE_FUNC
)
1571 return value_coerce_function (arg1
);
1573 /* If this is an array that has not yet been pushed to the target,
1574 then this would be a good time to force it to memory. */
1575 arg1
= value_coerce_to_target (arg1
);
1577 if (VALUE_LVAL (arg1
) != lval_memory
)
1578 error (_("Attempt to take address of value not located in memory."));
1580 /* Get target memory address. */
1581 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1582 (value_address (arg1
)
1583 + value_embedded_offset (arg1
)));
1585 /* This may be a pointer to a base subobject; so remember the
1586 full derived object's type ... */
1587 set_value_enclosing_type (arg2
,
1588 lookup_pointer_type (value_enclosing_type (arg1
)));
1589 /* ... and also the relative position of the subobject in the full
1591 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1595 /* Return a reference value for the object for which ARG1 is the
1599 value_ref (struct value
*arg1
, enum type_code refcode
)
1602 struct type
*type
= check_typedef (value_type (arg1
));
1604 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
1606 if ((type
->code () == TYPE_CODE_REF
1607 || type
->code () == TYPE_CODE_RVALUE_REF
)
1608 && type
->code () == refcode
)
1611 arg2
= value_addr (arg1
);
1612 deprecated_set_value_type (arg2
, lookup_reference_type (type
, refcode
));
1616 /* Given a value of a pointer type, apply the C unary * operator to
1620 value_ind (struct value
*arg1
)
1622 struct type
*base_type
;
1625 arg1
= coerce_array (arg1
);
1627 base_type
= check_typedef (value_type (arg1
));
1629 if (VALUE_LVAL (arg1
) == lval_computed
)
1631 const struct lval_funcs
*funcs
= value_computed_funcs (arg1
);
1633 if (funcs
->indirect
)
1635 struct value
*result
= funcs
->indirect (arg1
);
1642 if (base_type
->code () == TYPE_CODE_PTR
)
1644 struct type
*enc_type
;
1646 /* We may be pointing to something embedded in a larger object.
1647 Get the real type of the enclosing object. */
1648 enc_type
= check_typedef (value_enclosing_type (arg1
));
1649 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1651 CORE_ADDR base_addr
;
1652 if (check_typedef (enc_type
)->code () == TYPE_CODE_FUNC
1653 || check_typedef (enc_type
)->code () == TYPE_CODE_METHOD
)
1655 /* For functions, go through find_function_addr, which knows
1656 how to handle function descriptors. */
1657 base_addr
= find_function_addr (arg1
, NULL
);
1661 /* Retrieve the enclosing object pointed to. */
1662 base_addr
= (value_as_address (arg1
)
1663 - value_pointed_to_offset (arg1
));
1665 arg2
= value_at_lazy (enc_type
, base_addr
);
1666 enc_type
= value_type (arg2
);
1667 return readjust_indirect_value_type (arg2
, enc_type
, base_type
,
1671 error (_("Attempt to take contents of a non-pointer value."));
1674 /* Create a value for an array by allocating space in GDB, copying the
1675 data into that space, and then setting up an array value.
1677 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1678 is populated from the values passed in ELEMVEC.
1680 The element type of the array is inherited from the type of the
1681 first element, and all elements must have the same size (though we
1682 don't currently enforce any restriction on their types). */
1685 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1689 ULONGEST typelength
;
1691 struct type
*arraytype
;
1693 /* Validate that the bounds are reasonable and that each of the
1694 elements have the same size. */
1696 nelem
= highbound
- lowbound
+ 1;
1699 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1701 typelength
= type_length_units (value_enclosing_type (elemvec
[0]));
1702 for (idx
= 1; idx
< nelem
; idx
++)
1704 if (type_length_units (value_enclosing_type (elemvec
[idx
]))
1707 error (_("array elements must all be the same size"));
1711 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1712 lowbound
, highbound
);
1714 if (!current_language
->c_style_arrays_p ())
1716 val
= allocate_value (arraytype
);
1717 for (idx
= 0; idx
< nelem
; idx
++)
1718 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0,
1723 /* Allocate space to store the array, and then initialize it by
1724 copying in each element. */
1726 val
= allocate_value (arraytype
);
1727 for (idx
= 0; idx
< nelem
; idx
++)
1728 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0, typelength
);
1733 value_cstring (const char *ptr
, ssize_t len
, struct type
*char_type
)
1736 int lowbound
= current_language
->string_lower_bound ();
1737 ssize_t highbound
= len
/ TYPE_LENGTH (char_type
);
1738 struct type
*stringtype
1739 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1741 val
= allocate_value (stringtype
);
1742 memcpy (value_contents_raw (val
), ptr
, len
);
1746 /* Create a value for a string constant by allocating space in the
1747 inferior, copying the data into that space, and returning the
1748 address with type TYPE_CODE_STRING. PTR points to the string
1749 constant data; LEN is number of characters.
1751 Note that string types are like array of char types with a lower
1752 bound of zero and an upper bound of LEN - 1. Also note that the
1753 string may contain embedded null bytes. */
1756 value_string (const char *ptr
, ssize_t len
, struct type
*char_type
)
1759 int lowbound
= current_language
->string_lower_bound ();
1760 ssize_t highbound
= len
/ TYPE_LENGTH (char_type
);
1761 struct type
*stringtype
1762 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1764 val
= allocate_value (stringtype
);
1765 memcpy (value_contents_raw (val
), ptr
, len
);
1770 /* See if we can pass arguments in T2 to a function which takes
1771 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1772 a NULL-terminated vector. If some arguments need coercion of some
1773 sort, then the coerced values are written into T2. Return value is
1774 0 if the arguments could be matched, or the position at which they
1777 STATICP is nonzero if the T1 argument list came from a static
1778 member function. T2 will still include the ``this'' pointer, but
1781 For non-static member functions, we ignore the first argument,
1782 which is the type of the instance variable. This is because we
1783 want to handle calls with objects from derived classes. This is
1784 not entirely correct: we should actually check to make sure that a
1785 requested operation is type secure, shouldn't we? FIXME. */
1788 typecmp (int staticp
, int varargs
, int nargs
,
1789 struct field t1
[], struct value
*t2
[])
1794 internal_error (__FILE__
, __LINE__
,
1795 _("typecmp: no argument list"));
1797 /* Skip ``this'' argument if applicable. T2 will always include
1803 (i
< nargs
) && t1
[i
].type ()->code () != TYPE_CODE_VOID
;
1806 struct type
*tt1
, *tt2
;
1811 tt1
= check_typedef (t1
[i
].type ());
1812 tt2
= check_typedef (value_type (t2
[i
]));
1814 if (TYPE_IS_REFERENCE (tt1
)
1815 /* We should be doing hairy argument matching, as below. */
1816 && (check_typedef (TYPE_TARGET_TYPE (tt1
))->code ()
1819 if (tt2
->code () == TYPE_CODE_ARRAY
)
1820 t2
[i
] = value_coerce_array (t2
[i
]);
1822 t2
[i
] = value_ref (t2
[i
], tt1
->code ());
1826 /* djb - 20000715 - Until the new type structure is in the
1827 place, and we can attempt things like implicit conversions,
1828 we need to do this so you can take something like a map<const
1829 char *>, and properly access map["hello"], because the
1830 argument to [] will be a reference to a pointer to a char,
1831 and the argument will be a pointer to a char. */
1832 while (TYPE_IS_REFERENCE (tt1
) || tt1
->code () == TYPE_CODE_PTR
)
1834 tt1
= check_typedef ( TYPE_TARGET_TYPE (tt1
) );
1836 while (tt2
->code () == TYPE_CODE_ARRAY
1837 || tt2
->code () == TYPE_CODE_PTR
1838 || TYPE_IS_REFERENCE (tt2
))
1840 tt2
= check_typedef (TYPE_TARGET_TYPE (tt2
));
1842 if (tt1
->code () == tt2
->code ())
1844 /* Array to pointer is a `trivial conversion' according to the
1847 /* We should be doing much hairier argument matching (see
1848 section 13.2 of the ARM), but as a quick kludge, just check
1849 for the same type code. */
1850 if (t1
[i
].type ()->code () != value_type (t2
[i
])->code ())
1853 if (varargs
|| t2
[i
] == NULL
)
1858 /* Helper class for search_struct_field that keeps track of found
1859 results and possibly throws an exception if the search yields
1860 ambiguous results. See search_struct_field for description of
1861 LOOKING_FOR_BASECLASS. */
1863 struct struct_field_searcher
1865 /* A found field. */
1868 /* Path to the structure where the field was found. */
1869 std::vector
<struct type
*> path
;
1871 /* The field found. */
1872 struct value
*field_value
;
1875 /* See corresponding fields for description of parameters. */
1876 struct_field_searcher (const char *name
,
1877 struct type
*outermost_type
,
1878 bool looking_for_baseclass
)
1880 m_looking_for_baseclass (looking_for_baseclass
),
1881 m_outermost_type (outermost_type
)
1885 /* The search entry point. If LOOKING_FOR_BASECLASS is true and the
1886 base class search yields ambiguous results, this throws an
1887 exception. If LOOKING_FOR_BASECLASS is false, the found fields
1888 are accumulated and the caller (search_struct_field) takes care
1889 of throwing an error if the field search yields ambiguous
1890 results. The latter is done that way so that the error message
1891 can include a list of all the found candidates. */
1892 void search (struct value
*arg
, LONGEST offset
, struct type
*type
);
1894 const std::vector
<found_field
> &fields ()
1899 struct value
*baseclass ()
1905 /* Update results to include V, a found field/baseclass. */
1906 void update_result (struct value
*v
, LONGEST boffset
);
1908 /* The name of the field/baseclass we're searching for. */
1911 /* Whether we're looking for a baseclass, or a field. */
1912 const bool m_looking_for_baseclass
;
1914 /* The offset of the baseclass containing the field/baseclass we
1916 LONGEST m_last_boffset
= 0;
1918 /* If looking for a baseclass, then the result is stored here. */
1919 struct value
*m_baseclass
= nullptr;
1921 /* When looking for fields, the found candidates are stored
1923 std::vector
<found_field
> m_fields
;
1925 /* The type of the initial type passed to search_struct_field; this
1926 is used for error reporting when the lookup is ambiguous. */
1927 struct type
*m_outermost_type
;
1929 /* The full path to the struct being inspected. E.g. for field 'x'
1930 defined in class B inherited by class A, we have A and B pushed
1932 std::vector
<struct type
*> m_struct_path
;
1936 struct_field_searcher::update_result (struct value
*v
, LONGEST boffset
)
1940 if (m_looking_for_baseclass
)
1942 if (m_baseclass
!= nullptr
1943 /* The result is not ambiguous if all the classes that are
1944 found occupy the same space. */
1945 && m_last_boffset
!= boffset
)
1946 error (_("base class '%s' is ambiguous in type '%s'"),
1947 m_name
, TYPE_SAFE_NAME (m_outermost_type
));
1950 m_last_boffset
= boffset
;
1954 /* The field is not ambiguous if it occupies the same
1956 if (m_fields
.empty () || m_last_boffset
!= boffset
)
1957 m_fields
.push_back ({m_struct_path
, v
});
1962 /* A helper for search_struct_field. This does all the work; most
1963 arguments are as passed to search_struct_field. */
1966 struct_field_searcher::search (struct value
*arg1
, LONGEST offset
,
1972 m_struct_path
.push_back (type
);
1973 SCOPE_EXIT
{ m_struct_path
.pop_back (); };
1975 type
= check_typedef (type
);
1976 nbases
= TYPE_N_BASECLASSES (type
);
1978 if (!m_looking_for_baseclass
)
1979 for (i
= type
->num_fields () - 1; i
>= nbases
; i
--)
1981 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1983 if (t_field_name
&& (strcmp_iw (t_field_name
, m_name
) == 0))
1987 if (field_is_static (&type
->field (i
)))
1988 v
= value_static_field (type
, i
);
1990 v
= value_primitive_field (arg1
, offset
, i
, type
);
1992 update_result (v
, offset
);
1997 && t_field_name
[0] == '\0')
1999 struct type
*field_type
= type
->field (i
).type ();
2001 if (field_type
->code () == TYPE_CODE_UNION
2002 || field_type
->code () == TYPE_CODE_STRUCT
)
2004 /* Look for a match through the fields of an anonymous
2005 union, or anonymous struct. C++ provides anonymous
2008 In the GNU Chill (now deleted from GDB)
2009 implementation of variant record types, each
2010 <alternative field> has an (anonymous) union type,
2011 each member of the union represents a <variant
2012 alternative>. Each <variant alternative> is
2013 represented as a struct, with a member for each
2016 LONGEST new_offset
= offset
;
2018 /* This is pretty gross. In G++, the offset in an
2019 anonymous union is relative to the beginning of the
2020 enclosing struct. In the GNU Chill (now deleted
2021 from GDB) implementation of variant records, the
2022 bitpos is zero in an anonymous union field, so we
2023 have to add the offset of the union here. */
2024 if (field_type
->code () == TYPE_CODE_STRUCT
2025 || (field_type
->num_fields () > 0
2026 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2027 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2029 search (arg1
, new_offset
, field_type
);
2034 for (i
= 0; i
< nbases
; i
++)
2036 struct value
*v
= NULL
;
2037 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2038 /* If we are looking for baseclasses, this is what we get when
2039 we hit them. But it could happen that the base part's member
2040 name is not yet filled in. */
2041 int found_baseclass
= (m_looking_for_baseclass
2042 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2043 && (strcmp_iw (m_name
,
2044 TYPE_BASECLASS_NAME (type
,
2046 LONGEST boffset
= value_embedded_offset (arg1
) + offset
;
2048 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2052 boffset
= baseclass_offset (type
, i
,
2053 value_contents_for_printing (arg1
),
2054 value_embedded_offset (arg1
) + offset
,
2055 value_address (arg1
),
2058 /* The virtual base class pointer might have been clobbered
2059 by the user program. Make sure that it still points to a
2060 valid memory location. */
2062 boffset
+= value_embedded_offset (arg1
) + offset
;
2064 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
2066 CORE_ADDR base_addr
;
2068 base_addr
= value_address (arg1
) + boffset
;
2069 v2
= value_at_lazy (basetype
, base_addr
);
2070 if (target_read_memory (base_addr
,
2071 value_contents_raw (v2
),
2072 TYPE_LENGTH (value_type (v2
))) != 0)
2073 error (_("virtual baseclass botch"));
2077 v2
= value_copy (arg1
);
2078 deprecated_set_value_type (v2
, basetype
);
2079 set_value_embedded_offset (v2
, boffset
);
2082 if (found_baseclass
)
2085 search (v2
, 0, TYPE_BASECLASS (type
, i
));
2087 else if (found_baseclass
)
2088 v
= value_primitive_field (arg1
, offset
, i
, type
);
2091 search (arg1
, offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2095 update_result (v
, boffset
);
2099 /* Helper function used by value_struct_elt to recurse through
2100 baseclasses. Look for a field NAME in ARG1. Search in it assuming
2101 it has (class) type TYPE. If found, return value, else return NULL.
2103 If LOOKING_FOR_BASECLASS, then instead of looking for struct
2104 fields, look for a baseclass named NAME. */
2106 static struct value
*
2107 search_struct_field (const char *name
, struct value
*arg1
,
2108 struct type
*type
, int looking_for_baseclass
)
2110 struct_field_searcher
searcher (name
, type
, looking_for_baseclass
);
2112 searcher
.search (arg1
, 0, type
);
2114 if (!looking_for_baseclass
)
2116 const auto &fields
= searcher
.fields ();
2118 if (fields
.empty ())
2120 else if (fields
.size () == 1)
2121 return fields
[0].field_value
;
2124 std::string candidates
;
2126 for (auto &&candidate
: fields
)
2128 gdb_assert (!candidate
.path
.empty ());
2130 struct type
*field_type
= value_type (candidate
.field_value
);
2131 struct type
*struct_type
= candidate
.path
.back ();
2135 for (struct type
*t
: candidate
.path
)
2144 candidates
+= string_printf ("\n '%s %s::%s' (%s)",
2145 TYPE_SAFE_NAME (field_type
),
2146 TYPE_SAFE_NAME (struct_type
),
2151 error (_("Request for member '%s' is ambiguous in type '%s'."
2152 " Candidates are:%s"),
2153 name
, TYPE_SAFE_NAME (type
),
2154 candidates
.c_str ());
2158 return searcher
.baseclass ();
2161 /* Helper function used by value_struct_elt to recurse through
2162 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2163 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2166 If found, return value, else if name matched and args not return
2167 (value) -1, else return NULL. */
2169 static struct value
*
2170 search_struct_method (const char *name
, struct value
**arg1p
,
2171 struct value
**args
, LONGEST offset
,
2172 int *static_memfuncp
, struct type
*type
)
2176 int name_matched
= 0;
2178 type
= check_typedef (type
);
2179 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2181 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2183 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2185 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2186 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2189 check_stub_method_group (type
, i
);
2190 if (j
> 0 && args
== 0)
2191 error (_("cannot resolve overloaded method "
2192 "`%s': no arguments supplied"), name
);
2193 else if (j
== 0 && args
== 0)
2195 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2202 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2203 TYPE_FN_FIELD_TYPE (f
, j
)->has_varargs (),
2204 TYPE_FN_FIELD_TYPE (f
, j
)->num_fields (),
2205 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2207 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2208 return value_virtual_fn_field (arg1p
, f
, j
,
2210 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2212 *static_memfuncp
= 1;
2213 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2222 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2224 LONGEST base_offset
;
2225 LONGEST this_offset
;
2227 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2229 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2230 struct value
*base_val
;
2231 const gdb_byte
*base_valaddr
;
2233 /* The virtual base class pointer might have been
2234 clobbered by the user program. Make sure that it
2235 still points to a valid memory location. */
2237 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2241 gdb::byte_vector
tmp (TYPE_LENGTH (baseclass
));
2242 address
= value_address (*arg1p
);
2244 if (target_read_memory (address
+ offset
,
2245 tmp
.data (), TYPE_LENGTH (baseclass
)) != 0)
2246 error (_("virtual baseclass botch"));
2248 base_val
= value_from_contents_and_address (baseclass
,
2251 base_valaddr
= value_contents_for_printing (base_val
);
2257 base_valaddr
= value_contents_for_printing (*arg1p
);
2258 this_offset
= offset
;
2261 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2262 this_offset
, value_address (base_val
),
2267 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2269 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2270 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2271 if (v
== (struct value
*) - 1)
2277 /* FIXME-bothner: Why is this commented out? Why is it here? */
2278 /* *arg1p = arg1_tmp; */
2283 return (struct value
*) - 1;
2288 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2289 extract the component named NAME from the ultimate target
2290 structure/union and return it as a value with its appropriate type.
2291 ERR is used in the error message if *ARGP's type is wrong.
2293 C++: ARGS is a list of argument types to aid in the selection of
2294 an appropriate method. Also, handle derived types.
2296 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2297 where the truthvalue of whether the function that was resolved was
2298 a static member function or not is stored.
2300 ERR is an error message to be printed in case the field is not
2304 value_struct_elt (struct value
**argp
, struct value
**args
,
2305 const char *name
, int *static_memfuncp
, const char *err
)
2310 *argp
= coerce_array (*argp
);
2312 t
= check_typedef (value_type (*argp
));
2314 /* Follow pointers until we get to a non-pointer. */
2316 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2318 *argp
= value_ind (*argp
);
2319 /* Don't coerce fn pointer to fn and then back again! */
2320 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2321 *argp
= coerce_array (*argp
);
2322 t
= check_typedef (value_type (*argp
));
2325 if (t
->code () != TYPE_CODE_STRUCT
2326 && t
->code () != TYPE_CODE_UNION
)
2327 error (_("Attempt to extract a component of a value that is not a %s."),
2330 /* Assume it's not, unless we see that it is. */
2331 if (static_memfuncp
)
2332 *static_memfuncp
= 0;
2336 /* if there are no arguments ...do this... */
2338 /* Try as a field first, because if we succeed, there is less
2340 v
= search_struct_field (name
, *argp
, t
, 0);
2344 /* C++: If it was not found as a data field, then try to
2345 return it as a pointer to a method. */
2346 v
= search_struct_method (name
, argp
, args
, 0,
2347 static_memfuncp
, t
);
2349 if (v
== (struct value
*) - 1)
2350 error (_("Cannot take address of method %s."), name
);
2353 if (TYPE_NFN_FIELDS (t
))
2354 error (_("There is no member or method named %s."), name
);
2356 error (_("There is no member named %s."), name
);
2361 v
= search_struct_method (name
, argp
, args
, 0,
2362 static_memfuncp
, t
);
2364 if (v
== (struct value
*) - 1)
2366 error (_("One of the arguments you tried to pass to %s could not "
2367 "be converted to what the function wants."), name
);
2371 /* See if user tried to invoke data as function. If so, hand it
2372 back. If it's not callable (i.e., a pointer to function),
2373 gdb should give an error. */
2374 v
= search_struct_field (name
, *argp
, t
, 0);
2375 /* If we found an ordinary field, then it is not a method call.
2376 So, treat it as if it were a static member function. */
2377 if (v
&& static_memfuncp
)
2378 *static_memfuncp
= 1;
2382 throw_error (NOT_FOUND_ERROR
,
2383 _("Structure has no component named %s."), name
);
2387 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2388 to a structure or union, extract and return its component (field) of
2389 type FTYPE at the specified BITPOS.
2390 Throw an exception on error. */
2393 value_struct_elt_bitpos (struct value
**argp
, int bitpos
, struct type
*ftype
,
2399 *argp
= coerce_array (*argp
);
2401 t
= check_typedef (value_type (*argp
));
2403 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2405 *argp
= value_ind (*argp
);
2406 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2407 *argp
= coerce_array (*argp
);
2408 t
= check_typedef (value_type (*argp
));
2411 if (t
->code () != TYPE_CODE_STRUCT
2412 && t
->code () != TYPE_CODE_UNION
)
2413 error (_("Attempt to extract a component of a value that is not a %s."),
2416 for (i
= TYPE_N_BASECLASSES (t
); i
< t
->num_fields (); i
++)
2418 if (!field_is_static (&t
->field (i
))
2419 && bitpos
== TYPE_FIELD_BITPOS (t
, i
)
2420 && types_equal (ftype
, t
->field (i
).type ()))
2421 return value_primitive_field (*argp
, 0, i
, t
);
2424 error (_("No field with matching bitpos and type."));
2430 /* Search through the methods of an object (and its bases) to find a
2431 specified method. Return a reference to the fn_field list METHODS of
2432 overloaded instances defined in the source language. If available
2433 and matching, a vector of matching xmethods defined in extension
2434 languages are also returned in XMETHODS.
2436 Helper function for value_find_oload_list.
2437 ARGP is a pointer to a pointer to a value (the object).
2438 METHOD is a string containing the method name.
2439 OFFSET is the offset within the value.
2440 TYPE is the assumed type of the object.
2441 METHODS is a pointer to the matching overloaded instances defined
2442 in the source language. Since this is a recursive function,
2443 *METHODS should be set to NULL when calling this function.
2444 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2445 0 when calling this function.
2446 XMETHODS is the vector of matching xmethod workers. *XMETHODS
2447 should also be set to NULL when calling this function.
2448 BASETYPE is set to the actual type of the subobject where the
2450 BOFFSET is the offset of the base subobject where the method is found. */
2453 find_method_list (struct value
**argp
, const char *method
,
2454 LONGEST offset
, struct type
*type
,
2455 gdb::array_view
<fn_field
> *methods
,
2456 std::vector
<xmethod_worker_up
> *xmethods
,
2457 struct type
**basetype
, LONGEST
*boffset
)
2460 struct fn_field
*f
= NULL
;
2462 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2463 type
= check_typedef (type
);
2465 /* First check in object itself.
2466 This function is called recursively to search through base classes.
2467 If there is a source method match found at some stage, then we need not
2468 look for source methods in consequent recursive calls. */
2469 if (methods
->empty ())
2471 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2473 /* pai: FIXME What about operators and type conversions? */
2474 const char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2476 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2478 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2479 f
= TYPE_FN_FIELDLIST1 (type
, i
);
2480 *methods
= gdb::make_array_view (f
, len
);
2485 /* Resolve any stub methods. */
2486 check_stub_method_group (type
, i
);
2493 /* Unlike source methods, xmethods can be accumulated over successive
2494 recursive calls. In other words, an xmethod named 'm' in a class
2495 will not hide an xmethod named 'm' in its base class(es). We want
2496 it to be this way because xmethods are after all convenience functions
2497 and hence there is no point restricting them with something like method
2498 hiding. Moreover, if hiding is done for xmethods as well, then we will
2499 have to provide a mechanism to un-hide (like the 'using' construct). */
2500 get_matching_xmethod_workers (type
, method
, xmethods
);
2502 /* If source methods are not found in current class, look for them in the
2503 base classes. We also have to go through the base classes to gather
2504 extension methods. */
2505 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2507 LONGEST base_offset
;
2509 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2511 base_offset
= baseclass_offset (type
, i
,
2512 value_contents_for_printing (*argp
),
2513 value_offset (*argp
) + offset
,
2514 value_address (*argp
), *argp
);
2516 else /* Non-virtual base, simply use bit position from debug
2519 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2522 find_method_list (argp
, method
, base_offset
+ offset
,
2523 TYPE_BASECLASS (type
, i
), methods
,
2524 xmethods
, basetype
, boffset
);
2528 /* Return the list of overloaded methods of a specified name. The methods
2529 could be those GDB finds in the binary, or xmethod. Methods found in
2530 the binary are returned in METHODS, and xmethods are returned in
2533 ARGP is a pointer to a pointer to a value (the object).
2534 METHOD is the method name.
2535 OFFSET is the offset within the value contents.
2536 METHODS is the list of matching overloaded instances defined in
2537 the source language.
2538 XMETHODS is the vector of matching xmethod workers defined in
2539 extension languages.
2540 BASETYPE is set to the type of the base subobject that defines the
2542 BOFFSET is the offset of the base subobject which defines the method. */
2545 value_find_oload_method_list (struct value
**argp
, const char *method
,
2547 gdb::array_view
<fn_field
> *methods
,
2548 std::vector
<xmethod_worker_up
> *xmethods
,
2549 struct type
**basetype
, LONGEST
*boffset
)
2553 t
= check_typedef (value_type (*argp
));
2555 /* Code snarfed from value_struct_elt. */
2556 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2558 *argp
= value_ind (*argp
);
2559 /* Don't coerce fn pointer to fn and then back again! */
2560 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2561 *argp
= coerce_array (*argp
);
2562 t
= check_typedef (value_type (*argp
));
2565 if (t
->code () != TYPE_CODE_STRUCT
2566 && t
->code () != TYPE_CODE_UNION
)
2567 error (_("Attempt to extract a component of a "
2568 "value that is not a struct or union"));
2570 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2572 /* Clear the lists. */
2576 find_method_list (argp
, method
, 0, t
, methods
, xmethods
,
2580 /* Given an array of arguments (ARGS) (which includes an entry for
2581 "this" in the case of C++ methods), the NAME of a function, and
2582 whether it's a method or not (METHOD), find the best function that
2583 matches on the argument types according to the overload resolution
2586 METHOD can be one of three values:
2587 NON_METHOD for non-member functions.
2588 METHOD: for member functions.
2589 BOTH: used for overload resolution of operators where the
2590 candidates are expected to be either member or non member
2591 functions. In this case the first argument ARGTYPES
2592 (representing 'this') is expected to be a reference to the
2593 target object, and will be dereferenced when attempting the
2596 In the case of class methods, the parameter OBJ is an object value
2597 in which to search for overloaded methods.
2599 In the case of non-method functions, the parameter FSYM is a symbol
2600 corresponding to one of the overloaded functions.
2602 Return value is an integer: 0 -> good match, 10 -> debugger applied
2603 non-standard coercions, 100 -> incompatible.
2605 If a method is being searched for, VALP will hold the value.
2606 If a non-method is being searched for, SYMP will hold the symbol
2609 If a method is being searched for, and it is a static method,
2610 then STATICP will point to a non-zero value.
2612 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2613 ADL overload candidates when performing overload resolution for a fully
2616 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2617 read while picking the best overload match (it may be all zeroes and thus
2618 not have a vtable pointer), in which case skip virtual function lookup.
2619 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2622 Note: This function does *not* check the value of
2623 overload_resolution. Caller must check it to see whether overload
2624 resolution is permitted. */
2627 find_overload_match (gdb::array_view
<value
*> args
,
2628 const char *name
, enum oload_search_type method
,
2629 struct value
**objp
, struct symbol
*fsym
,
2630 struct value
**valp
, struct symbol
**symp
,
2631 int *staticp
, const int no_adl
,
2632 const enum noside noside
)
2634 struct value
*obj
= (objp
? *objp
: NULL
);
2635 struct type
*obj_type
= obj
? value_type (obj
) : NULL
;
2636 /* Index of best overloaded function. */
2637 int func_oload_champ
= -1;
2638 int method_oload_champ
= -1;
2639 int src_method_oload_champ
= -1;
2640 int ext_method_oload_champ
= -1;
2642 /* The measure for the current best match. */
2643 badness_vector method_badness
;
2644 badness_vector func_badness
;
2645 badness_vector ext_method_badness
;
2646 badness_vector src_method_badness
;
2648 struct value
*temp
= obj
;
2649 /* For methods, the list of overloaded methods. */
2650 gdb::array_view
<fn_field
> methods
;
2651 /* For non-methods, the list of overloaded function symbols. */
2652 std::vector
<symbol
*> functions
;
2653 /* For xmethods, the vector of xmethod workers. */
2654 std::vector
<xmethod_worker_up
> xmethods
;
2655 struct type
*basetype
= NULL
;
2658 const char *obj_type_name
= NULL
;
2659 const char *func_name
= NULL
;
2660 gdb::unique_xmalloc_ptr
<char> temp_func
;
2661 enum oload_classification match_quality
;
2662 enum oload_classification method_match_quality
= INCOMPATIBLE
;
2663 enum oload_classification src_method_match_quality
= INCOMPATIBLE
;
2664 enum oload_classification ext_method_match_quality
= INCOMPATIBLE
;
2665 enum oload_classification func_match_quality
= INCOMPATIBLE
;
2667 /* Get the list of overloaded methods or functions. */
2668 if (method
== METHOD
|| method
== BOTH
)
2672 /* OBJ may be a pointer value rather than the object itself. */
2673 obj
= coerce_ref (obj
);
2674 while (check_typedef (value_type (obj
))->code () == TYPE_CODE_PTR
)
2675 obj
= coerce_ref (value_ind (obj
));
2676 obj_type_name
= value_type (obj
)->name ();
2678 /* First check whether this is a data member, e.g. a pointer to
2680 if (check_typedef (value_type (obj
))->code () == TYPE_CODE_STRUCT
)
2682 *valp
= search_struct_field (name
, obj
,
2683 check_typedef (value_type (obj
)), 0);
2691 /* Retrieve the list of methods with the name NAME. */
2692 value_find_oload_method_list (&temp
, name
, 0, &methods
,
2693 &xmethods
, &basetype
, &boffset
);
2694 /* If this is a method only search, and no methods were found
2695 the search has failed. */
2696 if (method
== METHOD
&& methods
.empty () && xmethods
.empty ())
2697 error (_("Couldn't find method %s%s%s"),
2699 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2701 /* If we are dealing with stub method types, they should have
2702 been resolved by find_method_list via
2703 value_find_oload_method_list above. */
2704 if (!methods
.empty ())
2706 gdb_assert (TYPE_SELF_TYPE (methods
[0].type
) != NULL
);
2708 src_method_oload_champ
2709 = find_oload_champ (args
,
2711 methods
.data (), NULL
, NULL
,
2712 &src_method_badness
);
2714 src_method_match_quality
= classify_oload_match
2715 (src_method_badness
, args
.size (),
2716 oload_method_static_p (methods
.data (), src_method_oload_champ
));
2719 if (!xmethods
.empty ())
2721 ext_method_oload_champ
2722 = find_oload_champ (args
,
2724 NULL
, xmethods
.data (), NULL
,
2725 &ext_method_badness
);
2726 ext_method_match_quality
= classify_oload_match (ext_method_badness
,
2730 if (src_method_oload_champ
>= 0 && ext_method_oload_champ
>= 0)
2732 switch (compare_badness (ext_method_badness
, src_method_badness
))
2734 case 0: /* Src method and xmethod are equally good. */
2735 /* If src method and xmethod are equally good, then
2736 xmethod should be the winner. Hence, fall through to the
2737 case where a xmethod is better than the source
2738 method, except when the xmethod match quality is
2741 case 1: /* Src method and ext method are incompatible. */
2742 /* If ext method match is not standard, then let source method
2743 win. Otherwise, fallthrough to let xmethod win. */
2744 if (ext_method_match_quality
!= STANDARD
)
2746 method_oload_champ
= src_method_oload_champ
;
2747 method_badness
= src_method_badness
;
2748 ext_method_oload_champ
= -1;
2749 method_match_quality
= src_method_match_quality
;
2753 case 2: /* Ext method is champion. */
2754 method_oload_champ
= ext_method_oload_champ
;
2755 method_badness
= ext_method_badness
;
2756 src_method_oload_champ
= -1;
2757 method_match_quality
= ext_method_match_quality
;
2759 case 3: /* Src method is champion. */
2760 method_oload_champ
= src_method_oload_champ
;
2761 method_badness
= src_method_badness
;
2762 ext_method_oload_champ
= -1;
2763 method_match_quality
= src_method_match_quality
;
2766 gdb_assert_not_reached ("Unexpected overload comparison "
2771 else if (src_method_oload_champ
>= 0)
2773 method_oload_champ
= src_method_oload_champ
;
2774 method_badness
= src_method_badness
;
2775 method_match_quality
= src_method_match_quality
;
2777 else if (ext_method_oload_champ
>= 0)
2779 method_oload_champ
= ext_method_oload_champ
;
2780 method_badness
= ext_method_badness
;
2781 method_match_quality
= ext_method_match_quality
;
2785 if (method
== NON_METHOD
|| method
== BOTH
)
2787 const char *qualified_name
= NULL
;
2789 /* If the overload match is being search for both as a method
2790 and non member function, the first argument must now be
2793 args
[0] = value_ind (args
[0]);
2797 qualified_name
= fsym
->natural_name ();
2799 /* If we have a function with a C++ name, try to extract just
2800 the function part. Do not try this for non-functions (e.g.
2801 function pointers). */
2803 && (check_typedef (SYMBOL_TYPE (fsym
))->code ()
2806 temp_func
= cp_func_name (qualified_name
);
2808 /* If cp_func_name did not remove anything, the name of the
2809 symbol did not include scope or argument types - it was
2810 probably a C-style function. */
2811 if (temp_func
!= nullptr)
2813 if (strcmp (temp_func
.get (), qualified_name
) == 0)
2816 func_name
= temp_func
.get ();
2823 qualified_name
= name
;
2826 /* If there was no C++ name, this must be a C-style function or
2827 not a function at all. Just return the same symbol. Do the
2828 same if cp_func_name fails for some reason. */
2829 if (func_name
== NULL
)
2835 func_oload_champ
= find_oload_champ_namespace (args
,
2842 if (func_oload_champ
>= 0)
2843 func_match_quality
= classify_oload_match (func_badness
,
2847 /* Did we find a match ? */
2848 if (method_oload_champ
== -1 && func_oload_champ
== -1)
2849 throw_error (NOT_FOUND_ERROR
,
2850 _("No symbol \"%s\" in current context."),
2853 /* If we have found both a method match and a function
2854 match, find out which one is better, and calculate match
2856 if (method_oload_champ
>= 0 && func_oload_champ
>= 0)
2858 switch (compare_badness (func_badness
, method_badness
))
2860 case 0: /* Top two contenders are equally good. */
2861 /* FIXME: GDB does not support the general ambiguous case.
2862 All candidates should be collected and presented the
2864 error (_("Ambiguous overload resolution"));
2866 case 1: /* Incomparable top contenders. */
2867 /* This is an error incompatible candidates
2868 should not have been proposed. */
2869 error (_("Internal error: incompatible "
2870 "overload candidates proposed"));
2872 case 2: /* Function champion. */
2873 method_oload_champ
= -1;
2874 match_quality
= func_match_quality
;
2876 case 3: /* Method champion. */
2877 func_oload_champ
= -1;
2878 match_quality
= method_match_quality
;
2881 error (_("Internal error: unexpected overload comparison result"));
2887 /* We have either a method match or a function match. */
2888 if (method_oload_champ
>= 0)
2889 match_quality
= method_match_quality
;
2891 match_quality
= func_match_quality
;
2894 if (match_quality
== INCOMPATIBLE
)
2896 if (method
== METHOD
)
2897 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2899 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2902 error (_("Cannot resolve function %s to any overloaded instance"),
2905 else if (match_quality
== NON_STANDARD
)
2907 if (method
== METHOD
)
2908 warning (_("Using non-standard conversion to match "
2909 "method %s%s%s to supplied arguments"),
2911 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2914 warning (_("Using non-standard conversion to match "
2915 "function %s to supplied arguments"),
2919 if (staticp
!= NULL
)
2920 *staticp
= oload_method_static_p (methods
.data (), method_oload_champ
);
2922 if (method_oload_champ
>= 0)
2924 if (src_method_oload_champ
>= 0)
2926 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, method_oload_champ
)
2927 && noside
!= EVAL_AVOID_SIDE_EFFECTS
)
2929 *valp
= value_virtual_fn_field (&temp
, methods
.data (),
2930 method_oload_champ
, basetype
,
2934 *valp
= value_fn_field (&temp
, methods
.data (),
2935 method_oload_champ
, basetype
, boffset
);
2938 *valp
= value_from_xmethod
2939 (std::move (xmethods
[ext_method_oload_champ
]));
2942 *symp
= functions
[func_oload_champ
];
2946 struct type
*temp_type
= check_typedef (value_type (temp
));
2947 struct type
*objtype
= check_typedef (obj_type
);
2949 if (temp_type
->code () != TYPE_CODE_PTR
2950 && (objtype
->code () == TYPE_CODE_PTR
2951 || TYPE_IS_REFERENCE (objtype
)))
2953 temp
= value_addr (temp
);
2958 switch (match_quality
)
2964 default: /* STANDARD */
2969 /* Find the best overload match, searching for FUNC_NAME in namespaces
2970 contained in QUALIFIED_NAME until it either finds a good match or
2971 runs out of namespaces. It stores the overloaded functions in
2972 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
2973 argument dependent lookup is not performed. */
2976 find_oload_champ_namespace (gdb::array_view
<value
*> args
,
2977 const char *func_name
,
2978 const char *qualified_name
,
2979 std::vector
<symbol
*> *oload_syms
,
2980 badness_vector
*oload_champ_bv
,
2985 find_oload_champ_namespace_loop (args
,
2988 oload_syms
, oload_champ_bv
,
2995 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2996 how deep we've looked for namespaces, and the champ is stored in
2997 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2998 if it isn't. Other arguments are the same as in
2999 find_oload_champ_namespace. */
3002 find_oload_champ_namespace_loop (gdb::array_view
<value
*> args
,
3003 const char *func_name
,
3004 const char *qualified_name
,
3006 std::vector
<symbol
*> *oload_syms
,
3007 badness_vector
*oload_champ_bv
,
3011 int next_namespace_len
= namespace_len
;
3012 int searched_deeper
= 0;
3013 int new_oload_champ
;
3014 char *new_namespace
;
3016 if (next_namespace_len
!= 0)
3018 gdb_assert (qualified_name
[next_namespace_len
] == ':');
3019 next_namespace_len
+= 2;
3021 next_namespace_len
+=
3022 cp_find_first_component (qualified_name
+ next_namespace_len
);
3024 /* First, see if we have a deeper namespace we can search in.
3025 If we get a good match there, use it. */
3027 if (qualified_name
[next_namespace_len
] == ':')
3029 searched_deeper
= 1;
3031 if (find_oload_champ_namespace_loop (args
,
3032 func_name
, qualified_name
,
3034 oload_syms
, oload_champ_bv
,
3035 oload_champ
, no_adl
))
3041 /* If we reach here, either we're in the deepest namespace or we
3042 didn't find a good match in a deeper namespace. But, in the
3043 latter case, we still have a bad match in a deeper namespace;
3044 note that we might not find any match at all in the current
3045 namespace. (There's always a match in the deepest namespace,
3046 because this overload mechanism only gets called if there's a
3047 function symbol to start off with.) */
3049 new_namespace
= (char *) alloca (namespace_len
+ 1);
3050 strncpy (new_namespace
, qualified_name
, namespace_len
);
3051 new_namespace
[namespace_len
] = '\0';
3053 std::vector
<symbol
*> new_oload_syms
3054 = make_symbol_overload_list (func_name
, new_namespace
);
3056 /* If we have reached the deepest level perform argument
3057 determined lookup. */
3058 if (!searched_deeper
&& !no_adl
)
3061 struct type
**arg_types
;
3063 /* Prepare list of argument types for overload resolution. */
3064 arg_types
= (struct type
**)
3065 alloca (args
.size () * (sizeof (struct type
*)));
3066 for (ix
= 0; ix
< args
.size (); ix
++)
3067 arg_types
[ix
] = value_type (args
[ix
]);
3068 add_symbol_overload_list_adl ({arg_types
, args
.size ()}, func_name
,
3072 badness_vector new_oload_champ_bv
;
3073 new_oload_champ
= find_oload_champ (args
,
3074 new_oload_syms
.size (),
3075 NULL
, NULL
, new_oload_syms
.data (),
3076 &new_oload_champ_bv
);
3078 /* Case 1: We found a good match. Free earlier matches (if any),
3079 and return it. Case 2: We didn't find a good match, but we're
3080 not the deepest function. Then go with the bad match that the
3081 deeper function found. Case 3: We found a bad match, and we're
3082 the deepest function. Then return what we found, even though
3083 it's a bad match. */
3085 if (new_oload_champ
!= -1
3086 && classify_oload_match (new_oload_champ_bv
, args
.size (), 0) == STANDARD
)
3088 *oload_syms
= std::move (new_oload_syms
);
3089 *oload_champ
= new_oload_champ
;
3090 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3093 else if (searched_deeper
)
3099 *oload_syms
= std::move (new_oload_syms
);
3100 *oload_champ
= new_oload_champ
;
3101 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3106 /* Look for a function to take ARGS. Find the best match from among
3107 the overloaded methods or functions given by METHODS or FUNCTIONS
3108 or XMETHODS, respectively. One, and only one of METHODS, FUNCTIONS
3109 and XMETHODS can be non-NULL.
3111 NUM_FNS is the length of the array pointed at by METHODS, FUNCTIONS
3112 or XMETHODS, whichever is non-NULL.
3114 Return the index of the best match; store an indication of the
3115 quality of the match in OLOAD_CHAMP_BV. */
3118 find_oload_champ (gdb::array_view
<value
*> args
,
3121 xmethod_worker_up
*xmethods
,
3123 badness_vector
*oload_champ_bv
)
3125 /* A measure of how good an overloaded instance is. */
3127 /* Index of best overloaded function. */
3128 int oload_champ
= -1;
3129 /* Current ambiguity state for overload resolution. */
3130 int oload_ambiguous
= 0;
3131 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3133 /* A champion can be found among methods alone, or among functions
3134 alone, or in xmethods alone, but not in more than one of these
3136 gdb_assert ((methods
!= NULL
) + (functions
!= NULL
) + (xmethods
!= NULL
)
3139 /* Consider each candidate in turn. */
3140 for (size_t ix
= 0; ix
< num_fns
; ix
++)
3143 int static_offset
= 0;
3144 std::vector
<type
*> parm_types
;
3146 if (xmethods
!= NULL
)
3147 parm_types
= xmethods
[ix
]->get_arg_types ();
3152 if (methods
!= NULL
)
3154 nparms
= TYPE_FN_FIELD_TYPE (methods
, ix
)->num_fields ();
3155 static_offset
= oload_method_static_p (methods
, ix
);
3158 nparms
= SYMBOL_TYPE (functions
[ix
])->num_fields ();
3160 parm_types
.reserve (nparms
);
3161 for (jj
= 0; jj
< nparms
; jj
++)
3163 type
*t
= (methods
!= NULL
3164 ? (TYPE_FN_FIELD_ARGS (methods
, ix
)[jj
].type ())
3165 : SYMBOL_TYPE (functions
[ix
])->field (jj
).type ());
3166 parm_types
.push_back (t
);
3170 /* Compare parameter types to supplied argument types. Skip
3171 THIS for static methods. */
3172 bv
= rank_function (parm_types
,
3173 args
.slice (static_offset
));
3177 if (methods
!= NULL
)
3178 fprintf_filtered (gdb_stderr
,
3179 "Overloaded method instance %s, # of parms %d\n",
3180 methods
[ix
].physname
, (int) parm_types
.size ());
3181 else if (xmethods
!= NULL
)
3182 fprintf_filtered (gdb_stderr
,
3183 "Xmethod worker, # of parms %d\n",
3184 (int) parm_types
.size ());
3186 fprintf_filtered (gdb_stderr
,
3187 "Overloaded function instance "
3188 "%s # of parms %d\n",
3189 functions
[ix
]->demangled_name (),
3190 (int) parm_types
.size ());
3192 fprintf_filtered (gdb_stderr
,
3193 "...Badness of length : {%d, %d}\n",
3194 bv
[0].rank
, bv
[0].subrank
);
3196 for (jj
= 1; jj
< bv
.size (); jj
++)
3197 fprintf_filtered (gdb_stderr
,
3198 "...Badness of arg %d : {%d, %d}\n",
3199 jj
, bv
[jj
].rank
, bv
[jj
].subrank
);
3202 if (oload_champ_bv
->empty ())
3204 *oload_champ_bv
= std::move (bv
);
3207 else /* See whether current candidate is better or worse than
3209 switch (compare_badness (bv
, *oload_champ_bv
))
3211 case 0: /* Top two contenders are equally good. */
3212 oload_ambiguous
= 1;
3214 case 1: /* Incomparable top contenders. */
3215 oload_ambiguous
= 2;
3217 case 2: /* New champion, record details. */
3218 *oload_champ_bv
= std::move (bv
);
3219 oload_ambiguous
= 0;
3227 fprintf_filtered (gdb_stderr
, "Overload resolution "
3228 "champion is %d, ambiguous? %d\n",
3229 oload_champ
, oload_ambiguous
);
3235 /* Return 1 if we're looking at a static method, 0 if we're looking at
3236 a non-static method or a function that isn't a method. */
3239 oload_method_static_p (struct fn_field
*fns_ptr
, int index
)
3241 if (fns_ptr
&& index
>= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
3247 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3249 static enum oload_classification
3250 classify_oload_match (const badness_vector
&oload_champ_bv
,
3255 enum oload_classification worst
= STANDARD
;
3257 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
3259 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3260 or worse return INCOMPATIBLE. */
3261 if (compare_ranks (oload_champ_bv
[ix
],
3262 INCOMPATIBLE_TYPE_BADNESS
) <= 0)
3263 return INCOMPATIBLE
; /* Truly mismatched types. */
3264 /* Otherwise If this conversion is as bad as
3265 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3266 else if (compare_ranks (oload_champ_bv
[ix
],
3267 NS_POINTER_CONVERSION_BADNESS
) <= 0)
3268 worst
= NON_STANDARD
; /* Non-standard type conversions
3272 /* If no INCOMPATIBLE classification was found, return the worst one
3273 that was found (if any). */
3277 /* C++: return 1 is NAME is a legitimate name for the destructor of
3278 type TYPE. If TYPE does not have a destructor, or if NAME is
3279 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3280 have CHECK_TYPEDEF applied, this function will apply it itself. */
3283 destructor_name_p (const char *name
, struct type
*type
)
3287 const char *dname
= type_name_or_error (type
);
3288 const char *cp
= strchr (dname
, '<');
3291 /* Do not compare the template part for template classes. */
3293 len
= strlen (dname
);
3296 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
3297 error (_("name of destructor must equal name of class"));
3304 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3305 class". If the name is found, return a value representing it;
3306 otherwise throw an exception. */
3308 static struct value
*
3309 enum_constant_from_type (struct type
*type
, const char *name
)
3312 int name_len
= strlen (name
);
3314 gdb_assert (type
->code () == TYPE_CODE_ENUM
3315 && TYPE_DECLARED_CLASS (type
));
3317 for (i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); ++i
)
3319 const char *fname
= TYPE_FIELD_NAME (type
, i
);
3322 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_ENUMVAL
3326 /* Look for the trailing "::NAME", since enum class constant
3327 names are qualified here. */
3328 len
= strlen (fname
);
3329 if (len
+ 2 >= name_len
3330 && fname
[len
- name_len
- 2] == ':'
3331 && fname
[len
- name_len
- 1] == ':'
3332 && strcmp (&fname
[len
- name_len
], name
) == 0)
3333 return value_from_longest (type
, TYPE_FIELD_ENUMVAL (type
, i
));
3336 error (_("no constant named \"%s\" in enum \"%s\""),
3337 name
, type
->name ());
3340 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3341 return the appropriate member (or the address of the member, if
3342 WANT_ADDRESS). This function is used to resolve user expressions
3343 of the form "DOMAIN::NAME". For more details on what happens, see
3344 the comment before value_struct_elt_for_reference. */
3347 value_aggregate_elt (struct type
*curtype
, const char *name
,
3348 struct type
*expect_type
, int want_address
,
3351 switch (curtype
->code ())
3353 case TYPE_CODE_STRUCT
:
3354 case TYPE_CODE_UNION
:
3355 return value_struct_elt_for_reference (curtype
, 0, curtype
,
3357 want_address
, noside
);
3358 case TYPE_CODE_NAMESPACE
:
3359 return value_namespace_elt (curtype
, name
,
3360 want_address
, noside
);
3362 case TYPE_CODE_ENUM
:
3363 return enum_constant_from_type (curtype
, name
);
3366 internal_error (__FILE__
, __LINE__
,
3367 _("non-aggregate type in value_aggregate_elt"));
3371 /* Compares the two method/function types T1 and T2 for "equality"
3372 with respect to the methods' parameters. If the types of the
3373 two parameter lists are the same, returns 1; 0 otherwise. This
3374 comparison may ignore any artificial parameters in T1 if
3375 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3376 the first artificial parameter in T1, assumed to be a 'this' pointer.
3378 The type T2 is expected to have come from make_params (in eval.c). */
3381 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
3385 if (t1
->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1
, 0))
3388 /* If skipping artificial fields, find the first real field
3390 if (skip_artificial
)
3392 while (start
< t1
->num_fields ()
3393 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
3397 /* Now compare parameters. */
3399 /* Special case: a method taking void. T1 will contain no
3400 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3401 if ((t1
->num_fields () - start
) == 0 && t2
->num_fields () == 1
3402 && t2
->field (0).type ()->code () == TYPE_CODE_VOID
)
3405 if ((t1
->num_fields () - start
) == t2
->num_fields ())
3409 for (i
= 0; i
< t2
->num_fields (); ++i
)
3411 if (compare_ranks (rank_one_type (t1
->field (start
+ i
).type (),
3412 t2
->field (i
).type (), NULL
),
3413 EXACT_MATCH_BADNESS
) != 0)
3423 /* C++: Given an aggregate type VT, and a class type CLS, search
3424 recursively for CLS using value V; If found, store the offset
3425 which is either fetched from the virtual base pointer if CLS
3426 is virtual or accumulated offset of its parent classes if
3427 CLS is non-virtual in *BOFFS, set ISVIRT to indicate if CLS
3428 is virtual, and return true. If not found, return false. */
3431 get_baseclass_offset (struct type
*vt
, struct type
*cls
,
3432 struct value
*v
, int *boffs
, bool *isvirt
)
3434 for (int i
= 0; i
< TYPE_N_BASECLASSES (vt
); i
++)
3436 struct type
*t
= vt
->field (i
).type ();
3437 if (types_equal (t
, cls
))
3439 if (BASETYPE_VIA_VIRTUAL (vt
, i
))
3441 const gdb_byte
*adr
= value_contents_for_printing (v
);
3442 *boffs
= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3443 value_as_long (v
), v
);
3451 if (get_baseclass_offset (check_typedef (t
), cls
, v
, boffs
, isvirt
))
3453 if (*isvirt
== false) /* Add non-virtual base offset. */
3455 const gdb_byte
*adr
= value_contents_for_printing (v
);
3456 *boffs
+= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3457 value_as_long (v
), v
);
3466 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3467 return the address of this member as a "pointer to member" type.
3468 If INTYPE is non-null, then it will be the type of the member we
3469 are looking for. This will help us resolve "pointers to member
3470 functions". This function is used to resolve user expressions of
3471 the form "DOMAIN::NAME". */
3473 static struct value
*
3474 value_struct_elt_for_reference (struct type
*domain
, int offset
,
3475 struct type
*curtype
, const char *name
,
3476 struct type
*intype
,
3480 struct type
*t
= check_typedef (curtype
);
3482 struct value
*result
;
3484 if (t
->code () != TYPE_CODE_STRUCT
3485 && t
->code () != TYPE_CODE_UNION
)
3486 error (_("Internal error: non-aggregate type "
3487 "to value_struct_elt_for_reference"));
3489 for (i
= t
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3491 const char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
3493 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3495 if (field_is_static (&t
->field (i
)))
3497 struct value
*v
= value_static_field (t
, i
);
3502 if (TYPE_FIELD_PACKED (t
, i
))
3503 error (_("pointers to bitfield members not allowed"));
3506 return value_from_longest
3507 (lookup_memberptr_type (t
->field (i
).type (), domain
),
3508 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
3509 else if (noside
!= EVAL_NORMAL
)
3510 return allocate_value (t
->field (i
).type ());
3513 /* Try to evaluate NAME as a qualified name with implicit
3514 this pointer. In this case, attempt to return the
3515 equivalent to `this->*(&TYPE::NAME)'. */
3516 struct value
*v
= value_of_this_silent (current_language
);
3519 struct value
*ptr
, *this_v
= v
;
3521 struct type
*type
, *tmp
;
3523 ptr
= value_aggregate_elt (domain
, name
, NULL
, 1, noside
);
3524 type
= check_typedef (value_type (ptr
));
3525 gdb_assert (type
!= NULL
3526 && type
->code () == TYPE_CODE_MEMBERPTR
);
3527 tmp
= lookup_pointer_type (TYPE_SELF_TYPE (type
));
3528 v
= value_cast_pointers (tmp
, v
, 1);
3529 mem_offset
= value_as_long (ptr
);
3530 if (domain
!= curtype
)
3532 /* Find class offset of type CURTYPE from either its
3533 parent type DOMAIN or the type of implied this. */
3535 bool isvirt
= false;
3536 if (get_baseclass_offset (domain
, curtype
, v
, &boff
,
3541 struct type
*p
= check_typedef (value_type (this_v
));
3542 p
= check_typedef (TYPE_TARGET_TYPE (p
));
3543 if (get_baseclass_offset (p
, curtype
, this_v
,
3548 tmp
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
3549 result
= value_from_pointer (tmp
,
3550 value_as_long (v
) + mem_offset
);
3551 return value_ind (result
);
3554 error (_("Cannot reference non-static field \"%s\""), name
);
3559 /* C++: If it was not found as a data field, then try to return it
3560 as a pointer to a method. */
3562 /* Perform all necessary dereferencing. */
3563 while (intype
&& intype
->code () == TYPE_CODE_PTR
)
3564 intype
= TYPE_TARGET_TYPE (intype
);
3566 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3568 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3570 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3573 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3574 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3576 check_stub_method_group (t
, i
);
3580 for (j
= 0; j
< len
; ++j
)
3582 if (TYPE_CONST (intype
) != TYPE_FN_FIELD_CONST (f
, j
))
3584 if (TYPE_VOLATILE (intype
) != TYPE_FN_FIELD_VOLATILE (f
, j
))
3587 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3588 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
),
3594 error (_("no member function matches "
3595 "that type instantiation"));
3602 for (ii
= 0; ii
< len
; ++ii
)
3604 /* Skip artificial methods. This is necessary if,
3605 for example, the user wants to "print
3606 subclass::subclass" with only one user-defined
3607 constructor. There is no ambiguity in this case.
3608 We are careful here to allow artificial methods
3609 if they are the unique result. */
3610 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3617 /* Desired method is ambiguous if more than one
3618 method is defined. */
3619 if (j
!= -1 && !TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
3620 error (_("non-unique member `%s' requires "
3621 "type instantiation"), name
);
3627 error (_("no matching member function"));
3630 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3633 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3634 0, VAR_DOMAIN
, 0).symbol
;
3640 return value_addr (read_var_value (s
, 0, 0));
3642 return read_var_value (s
, 0, 0);
3645 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3649 result
= allocate_value
3650 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3651 cplus_make_method_ptr (value_type (result
),
3652 value_contents_writeable (result
),
3653 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3655 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3656 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3658 error (_("Cannot reference virtual member function \"%s\""),
3664 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3665 0, VAR_DOMAIN
, 0).symbol
;
3670 struct value
*v
= read_var_value (s
, 0, 0);
3675 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3676 cplus_make_method_ptr (value_type (result
),
3677 value_contents_writeable (result
),
3678 value_address (v
), 0);
3684 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3689 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3692 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3693 v
= value_struct_elt_for_reference (domain
,
3694 offset
+ base_offset
,
3695 TYPE_BASECLASS (t
, i
),
3697 want_address
, noside
);
3702 /* As a last chance, pretend that CURTYPE is a namespace, and look
3703 it up that way; this (frequently) works for types nested inside
3706 return value_maybe_namespace_elt (curtype
, name
,
3707 want_address
, noside
);
3710 /* C++: Return the member NAME of the namespace given by the type
3713 static struct value
*
3714 value_namespace_elt (const struct type
*curtype
,
3715 const char *name
, int want_address
,
3718 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3723 error (_("No symbol \"%s\" in namespace \"%s\"."),
3724 name
, curtype
->name ());
3729 /* A helper function used by value_namespace_elt and
3730 value_struct_elt_for_reference. It looks up NAME inside the
3731 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3732 is a class and NAME refers to a type in CURTYPE itself (as opposed
3733 to, say, some base class of CURTYPE). */
3735 static struct value
*
3736 value_maybe_namespace_elt (const struct type
*curtype
,
3737 const char *name
, int want_address
,
3740 const char *namespace_name
= curtype
->name ();
3741 struct block_symbol sym
;
3742 struct value
*result
;
3744 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3745 get_selected_block (0), VAR_DOMAIN
);
3747 if (sym
.symbol
== NULL
)
3749 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3750 && (SYMBOL_CLASS (sym
.symbol
) == LOC_TYPEDEF
))
3751 result
= allocate_value (SYMBOL_TYPE (sym
.symbol
));
3753 result
= value_of_variable (sym
.symbol
, sym
.block
);
3756 result
= value_addr (result
);
3761 /* Given a pointer or a reference value V, find its real (RTTI) type.
3763 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3764 and refer to the values computed for the object pointed to. */
3767 value_rtti_indirect_type (struct value
*v
, int *full
,
3768 LONGEST
*top
, int *using_enc
)
3770 struct value
*target
= NULL
;
3771 struct type
*type
, *real_type
, *target_type
;
3773 type
= value_type (v
);
3774 type
= check_typedef (type
);
3775 if (TYPE_IS_REFERENCE (type
))
3776 target
= coerce_ref (v
);
3777 else if (type
->code () == TYPE_CODE_PTR
)
3782 target
= value_ind (v
);
3784 catch (const gdb_exception_error
&except
)
3786 if (except
.error
== MEMORY_ERROR
)
3788 /* value_ind threw a memory error. The pointer is NULL or
3789 contains an uninitialized value: we can't determine any
3799 real_type
= value_rtti_type (target
, full
, top
, using_enc
);
3803 /* Copy qualifiers to the referenced object. */
3804 target_type
= value_type (target
);
3805 real_type
= make_cv_type (TYPE_CONST (target_type
),
3806 TYPE_VOLATILE (target_type
), real_type
, NULL
);
3807 if (TYPE_IS_REFERENCE (type
))
3808 real_type
= lookup_reference_type (real_type
, type
->code ());
3809 else if (type
->code () == TYPE_CODE_PTR
)
3810 real_type
= lookup_pointer_type (real_type
);
3812 internal_error (__FILE__
, __LINE__
, _("Unexpected value type."));
3814 /* Copy qualifiers to the pointer/reference. */
3815 real_type
= make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
),
3822 /* Given a value pointed to by ARGP, check its real run-time type, and
3823 if that is different from the enclosing type, create a new value
3824 using the real run-time type as the enclosing type (and of the same
3825 type as ARGP) and return it, with the embedded offset adjusted to
3826 be the correct offset to the enclosed object. RTYPE is the type,
3827 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3828 by value_rtti_type(). If these are available, they can be supplied
3829 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3830 NULL if they're not available. */
3833 value_full_object (struct value
*argp
,
3835 int xfull
, int xtop
,
3838 struct type
*real_type
;
3842 struct value
*new_val
;
3849 using_enc
= xusing_enc
;
3852 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3854 /* If no RTTI data, or if object is already complete, do nothing. */
3855 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3858 /* In a destructor we might see a real type that is a superclass of
3859 the object's type. In this case it is better to leave the object
3862 && TYPE_LENGTH (real_type
) < TYPE_LENGTH (value_enclosing_type (argp
)))
3865 /* If we have the full object, but for some reason the enclosing
3866 type is wrong, set it. */
3867 /* pai: FIXME -- sounds iffy */
3870 argp
= value_copy (argp
);
3871 set_value_enclosing_type (argp
, real_type
);
3875 /* Check if object is in memory. */
3876 if (VALUE_LVAL (argp
) != lval_memory
)
3878 warning (_("Couldn't retrieve complete object of RTTI "
3879 "type %s; object may be in register(s)."),
3880 real_type
->name ());
3885 /* All other cases -- retrieve the complete object. */
3886 /* Go back by the computed top_offset from the beginning of the
3887 object, adjusting for the embedded offset of argp if that's what
3888 value_rtti_type used for its computation. */
3889 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3890 (using_enc
? 0 : value_embedded_offset (argp
)));
3891 deprecated_set_value_type (new_val
, value_type (argp
));
3892 set_value_embedded_offset (new_val
, (using_enc
3893 ? top
+ value_embedded_offset (argp
)
3899 /* Return the value of the local variable, if one exists. Throw error
3900 otherwise, such as if the request is made in an inappropriate context. */
3903 value_of_this (const struct language_defn
*lang
)
3905 struct block_symbol sym
;
3906 const struct block
*b
;
3907 struct frame_info
*frame
;
3909 if (lang
->name_of_this () == NULL
)
3910 error (_("no `this' in current language"));
3912 frame
= get_selected_frame (_("no frame selected"));
3914 b
= get_frame_block (frame
, NULL
);
3916 sym
= lookup_language_this (lang
, b
);
3917 if (sym
.symbol
== NULL
)
3918 error (_("current stack frame does not contain a variable named `%s'"),
3919 lang
->name_of_this ());
3921 return read_var_value (sym
.symbol
, sym
.block
, frame
);
3924 /* Return the value of the local variable, if one exists. Return NULL
3925 otherwise. Never throw error. */
3928 value_of_this_silent (const struct language_defn
*lang
)
3930 struct value
*ret
= NULL
;
3934 ret
= value_of_this (lang
);
3936 catch (const gdb_exception_error
&except
)
3943 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3944 elements long, starting at LOWBOUND. The result has the same lower
3945 bound as the original ARRAY. */
3948 value_slice (struct value
*array
, int lowbound
, int length
)
3950 struct type
*slice_range_type
, *slice_type
, *range_type
;
3951 LONGEST lowerbound
, upperbound
;
3952 struct value
*slice
;
3953 struct type
*array_type
;
3955 array_type
= check_typedef (value_type (array
));
3956 if (array_type
->code () != TYPE_CODE_ARRAY
3957 && array_type
->code () != TYPE_CODE_STRING
)
3958 error (_("cannot take slice of non-array"));
3960 if (type_not_allocated (array_type
))
3961 error (_("array not allocated"));
3962 if (type_not_associated (array_type
))
3963 error (_("array not associated"));
3965 range_type
= array_type
->index_type ();
3966 if (!get_discrete_bounds (range_type
, &lowerbound
, &upperbound
))
3967 error (_("slice from bad array or bitstring"));
3969 if (lowbound
< lowerbound
|| length
< 0
3970 || lowbound
+ length
- 1 > upperbound
)
3971 error (_("slice out of range"));
3973 /* FIXME-type-allocation: need a way to free this type when we are
3975 slice_range_type
= create_static_range_type (NULL
,
3976 TYPE_TARGET_TYPE (range_type
),
3978 lowbound
+ length
- 1);
3981 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3983 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3985 slice_type
= create_array_type (NULL
,
3988 slice_type
->set_code (array_type
->code ());
3990 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3991 slice
= allocate_value_lazy (slice_type
);
3994 slice
= allocate_value (slice_type
);
3995 value_contents_copy (slice
, 0, array
, offset
,
3996 type_length_units (slice_type
));
3999 set_value_component_location (slice
, array
);
4000 set_value_offset (slice
, value_offset (array
) + offset
);
4009 value_literal_complex (struct value
*arg1
,
4014 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
4016 val
= allocate_value (type
);
4017 arg1
= value_cast (real_type
, arg1
);
4018 arg2
= value_cast (real_type
, arg2
);
4020 memcpy (value_contents_raw (val
),
4021 value_contents (arg1
), TYPE_LENGTH (real_type
));
4022 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
4023 value_contents (arg2
), TYPE_LENGTH (real_type
));
4030 value_real_part (struct value
*value
)
4032 struct type
*type
= check_typedef (value_type (value
));
4033 struct type
*ttype
= TYPE_TARGET_TYPE (type
);
4035 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4036 return value_from_component (value
, ttype
, 0);
4042 value_imaginary_part (struct value
*value
)
4044 struct type
*type
= check_typedef (value_type (value
));
4045 struct type
*ttype
= TYPE_TARGET_TYPE (type
);
4047 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4048 return value_from_component (value
, ttype
,
4049 TYPE_LENGTH (check_typedef (ttype
)));
4052 /* Cast a value into the appropriate complex data type. */
4054 static struct value
*
4055 cast_into_complex (struct type
*type
, struct value
*val
)
4057 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
4059 if (value_type (val
)->code () == TYPE_CODE_COMPLEX
)
4061 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
4062 struct value
*re_val
= allocate_value (val_real_type
);
4063 struct value
*im_val
= allocate_value (val_real_type
);
4065 memcpy (value_contents_raw (re_val
),
4066 value_contents (val
), TYPE_LENGTH (val_real_type
));
4067 memcpy (value_contents_raw (im_val
),
4068 value_contents (val
) + TYPE_LENGTH (val_real_type
),
4069 TYPE_LENGTH (val_real_type
));
4071 return value_literal_complex (re_val
, im_val
, type
);
4073 else if (value_type (val
)->code () == TYPE_CODE_FLT
4074 || value_type (val
)->code () == TYPE_CODE_INT
)
4075 return value_literal_complex (val
,
4076 value_zero (real_type
, not_lval
),
4079 error (_("cannot cast non-number to complex"));
4082 void _initialize_valops ();
4084 _initialize_valops ()
4086 add_setshow_boolean_cmd ("overload-resolution", class_support
,
4087 &overload_resolution
, _("\
4088 Set overload resolution in evaluating C++ functions."), _("\
4089 Show overload resolution in evaluating C++ functions."),
4091 show_overload_resolution
,
4092 &setlist
, &showlist
);
4093 overload_resolution
= 1;