1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2020 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 */
334 /* Assuming that TO_TYPE is a fixed point type, return a value
335 corresponding to the cast of FROM_VAL to that type. */
337 static struct value
*
338 value_cast_to_fixed_point (struct type
*to_type
, struct value
*from_val
)
340 struct type
*from_type
= value_type (from_val
);
342 if (from_type
== to_type
)
347 /* Extract the value as a rational number. */
349 if (is_floating_type (from_type
))
351 double d
= target_float_to_host_double (value_contents (from_val
),
353 mpq_set_d (vq
.val
, d
);
356 else if (is_integral_type (from_type
) || is_fixed_point_type (from_type
))
360 vz
.read (gdb::make_array_view (value_contents (from_val
),
361 TYPE_LENGTH (from_type
)),
362 type_byte_order (from_type
), from_type
->is_unsigned ());
363 mpq_set_z (vq
.val
, vz
.val
);
365 if (is_fixed_point_type (from_type
))
366 mpq_mul (vq
.val
, vq
.val
, from_type
->fixed_point_scaling_factor ().val
);
370 error (_("Invalid conversion from type %s to fixed point type %s"),
371 from_type
->name (), to_type
->name ());
373 /* Divide that value by the scaling factor to obtain the unscaled
374 value, first in rational form, and then in integer form. */
376 mpq_div (vq
.val
, vq
.val
, to_type
->fixed_point_scaling_factor ().val
);
377 gdb_mpz unscaled
= vq
.get_rounded ();
379 /* Finally, create the result value, and pack the unscaled value
381 struct value
*result
= allocate_value (to_type
);
382 unscaled
.write (gdb::make_array_view (value_contents_raw (result
),
383 TYPE_LENGTH (to_type
)),
384 type_byte_order (to_type
),
385 to_type
->is_unsigned ());
390 /* Cast value ARG2 to type TYPE and return as a value.
391 More general than a C cast: accepts any two types of the same length,
392 and if ARG2 is an lvalue it can be cast into anything at all. */
393 /* In C++, casts may change pointer or object representations. */
396 value_cast (struct type
*type
, struct value
*arg2
)
398 enum type_code code1
;
399 enum type_code code2
;
403 int convert_to_boolean
= 0;
405 if (value_type (arg2
) == type
)
408 if (is_fixed_point_type (type
))
409 return value_cast_to_fixed_point (type
, arg2
);
411 /* Check if we are casting struct reference to struct reference. */
412 if (TYPE_IS_REFERENCE (check_typedef (type
)))
414 /* We dereference type; then we recurse and finally
415 we generate value of the given reference. Nothing wrong with
417 struct type
*t1
= check_typedef (type
);
418 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
419 struct value
*val
= value_cast (dereftype
, arg2
);
421 return value_ref (val
, t1
->code ());
424 if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2
))))
425 /* We deref the value and then do the cast. */
426 return value_cast (type
, coerce_ref (arg2
));
428 /* Strip typedefs / resolve stubs in order to get at the type's
429 code/length, but remember the original type, to use as the
430 resulting type of the cast, in case it was a typedef. */
431 struct type
*to_type
= type
;
433 type
= check_typedef (type
);
434 code1
= type
->code ();
435 arg2
= coerce_ref (arg2
);
436 type2
= check_typedef (value_type (arg2
));
438 /* You can't cast to a reference type. See value_cast_pointers
440 gdb_assert (!TYPE_IS_REFERENCE (type
));
442 /* A cast to an undetermined-length array_type, such as
443 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
444 where N is sizeof(OBJECT)/sizeof(TYPE). */
445 if (code1
== TYPE_CODE_ARRAY
)
447 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
448 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
450 if (element_length
> 0 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
452 struct type
*range_type
= type
->index_type ();
453 int val_length
= TYPE_LENGTH (type2
);
454 LONGEST low_bound
, high_bound
, new_length
;
456 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
457 low_bound
= 0, high_bound
= 0;
458 new_length
= val_length
/ element_length
;
459 if (val_length
% element_length
!= 0)
460 warning (_("array element type size does not "
461 "divide object size in cast"));
462 /* FIXME-type-allocation: need a way to free this type when
463 we are done with it. */
464 range_type
= create_static_range_type (NULL
,
465 TYPE_TARGET_TYPE (range_type
),
467 new_length
+ low_bound
- 1);
468 deprecated_set_value_type (arg2
,
469 create_array_type (NULL
,
476 if (current_language
->c_style_arrays_p ()
477 && type2
->code () == TYPE_CODE_ARRAY
478 && !type2
->is_vector ())
479 arg2
= value_coerce_array (arg2
);
481 if (type2
->code () == TYPE_CODE_FUNC
)
482 arg2
= value_coerce_function (arg2
);
484 type2
= check_typedef (value_type (arg2
));
485 code2
= type2
->code ();
487 if (code1
== TYPE_CODE_COMPLEX
)
488 return cast_into_complex (to_type
, arg2
);
489 if (code1
== TYPE_CODE_BOOL
)
491 code1
= TYPE_CODE_INT
;
492 convert_to_boolean
= 1;
494 if (code1
== TYPE_CODE_CHAR
)
495 code1
= TYPE_CODE_INT
;
496 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
497 code2
= TYPE_CODE_INT
;
499 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
500 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
501 || code2
== TYPE_CODE_RANGE
502 || is_fixed_point_type (type2
));
504 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
505 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
506 && type
->name () != 0)
508 struct value
*v
= value_cast_structs (to_type
, arg2
);
514 if (is_floating_type (type
) && scalar
)
516 if (is_floating_value (arg2
))
518 struct value
*v
= allocate_value (to_type
);
519 target_float_convert (value_contents (arg2
), type2
,
520 value_contents_raw (v
), type
);
523 else if (is_fixed_point_type (type2
))
527 fp_val
.read_fixed_point
528 (gdb::make_array_view (value_contents (arg2
), TYPE_LENGTH (type2
)),
529 type_byte_order (type2
), type2
->is_unsigned (),
530 type2
->fixed_point_scaling_factor ());
532 struct value
*v
= allocate_value (to_type
);
533 target_float_from_host_double (value_contents_raw (v
),
534 to_type
, mpq_get_d (fp_val
.val
));
538 /* The only option left is an integral type. */
539 if (type2
->is_unsigned ())
540 return value_from_ulongest (to_type
, value_as_long (arg2
));
542 return value_from_longest (to_type
, value_as_long (arg2
));
544 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
545 || code1
== TYPE_CODE_RANGE
)
546 && (scalar
|| code2
== TYPE_CODE_PTR
547 || code2
== TYPE_CODE_MEMBERPTR
))
551 /* When we cast pointers to integers, we mustn't use
552 gdbarch_pointer_to_address to find the address the pointer
553 represents, as value_as_long would. GDB should evaluate
554 expressions just as the compiler would --- and the compiler
555 sees a cast as a simple reinterpretation of the pointer's
557 if (code2
== TYPE_CODE_PTR
)
558 longest
= extract_unsigned_integer
559 (value_contents (arg2
), TYPE_LENGTH (type2
),
560 type_byte_order (type2
));
562 longest
= value_as_long (arg2
);
563 return value_from_longest (to_type
, convert_to_boolean
?
564 (LONGEST
) (longest
? 1 : 0) : longest
);
566 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
567 || code2
== TYPE_CODE_ENUM
568 || code2
== TYPE_CODE_RANGE
))
570 /* TYPE_LENGTH (type) is the length of a pointer, but we really
571 want the length of an address! -- we are really dealing with
572 addresses (i.e., gdb representations) not pointers (i.e.,
573 target representations) here.
575 This allows things like "print *(int *)0x01000234" to work
576 without printing a misleading message -- which would
577 otherwise occur when dealing with a target having two byte
578 pointers and four byte addresses. */
580 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
581 LONGEST longest
= value_as_long (arg2
);
583 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
585 if (longest
>= ((LONGEST
) 1 << addr_bit
)
586 || longest
<= -((LONGEST
) 1 << addr_bit
))
587 warning (_("value truncated"));
589 return value_from_longest (to_type
, longest
);
591 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
592 && value_as_long (arg2
) == 0)
594 struct value
*result
= allocate_value (to_type
);
596 cplus_make_method_ptr (to_type
, value_contents_writeable (result
), 0, 0);
599 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
600 && value_as_long (arg2
) == 0)
602 /* The Itanium C++ ABI represents NULL pointers to members as
603 minus one, instead of biasing the normal case. */
604 return value_from_longest (to_type
, -1);
606 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector ()
607 && code2
== TYPE_CODE_ARRAY
&& type2
->is_vector ()
608 && TYPE_LENGTH (type
) != TYPE_LENGTH (type2
))
609 error (_("Cannot convert between vector values of different sizes"));
610 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector () && scalar
611 && TYPE_LENGTH (type
) != TYPE_LENGTH (type2
))
612 error (_("can only cast scalar to vector of same size"));
613 else if (code1
== TYPE_CODE_VOID
)
615 return value_zero (to_type
, not_lval
);
617 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
619 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
620 return value_cast_pointers (to_type
, arg2
, 0);
622 arg2
= value_copy (arg2
);
623 deprecated_set_value_type (arg2
, to_type
);
624 set_value_enclosing_type (arg2
, to_type
);
625 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
628 else if (VALUE_LVAL (arg2
) == lval_memory
)
629 return value_at_lazy (to_type
, value_address (arg2
));
632 if (current_language
->la_language
== language_ada
)
633 error (_("Invalid type conversion."));
634 error (_("Invalid cast."));
638 /* The C++ reinterpret_cast operator. */
641 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
643 struct value
*result
;
644 struct type
*real_type
= check_typedef (type
);
645 struct type
*arg_type
, *dest_type
;
647 enum type_code dest_code
, arg_code
;
649 /* Do reference, function, and array conversion. */
650 arg
= coerce_array (arg
);
652 /* Attempt to preserve the type the user asked for. */
655 /* If we are casting to a reference type, transform
656 reinterpret_cast<T&[&]>(V) to *reinterpret_cast<T*>(&V). */
657 if (TYPE_IS_REFERENCE (real_type
))
660 arg
= value_addr (arg
);
661 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
662 real_type
= lookup_pointer_type (real_type
);
665 arg_type
= value_type (arg
);
667 dest_code
= real_type
->code ();
668 arg_code
= arg_type
->code ();
670 /* We can convert pointer types, or any pointer type to int, or int
672 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
673 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
674 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
675 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
676 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
677 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
678 || (dest_code
== arg_code
679 && (dest_code
== TYPE_CODE_PTR
680 || dest_code
== TYPE_CODE_METHODPTR
681 || dest_code
== TYPE_CODE_MEMBERPTR
)))
682 result
= value_cast (dest_type
, arg
);
684 error (_("Invalid reinterpret_cast"));
687 result
= value_cast (type
, value_ref (value_ind (result
),
693 /* A helper for value_dynamic_cast. This implements the first of two
694 runtime checks: we iterate over all the base classes of the value's
695 class which are equal to the desired class; if only one of these
696 holds the value, then it is the answer. */
699 dynamic_cast_check_1 (struct type
*desired_type
,
700 const gdb_byte
*valaddr
,
701 LONGEST embedded_offset
,
704 struct type
*search_type
,
706 struct type
*arg_type
,
707 struct value
**result
)
709 int i
, result_count
= 0;
711 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
713 LONGEST offset
= baseclass_offset (search_type
, i
, valaddr
,
717 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
719 if (address
+ embedded_offset
+ offset
>= arg_addr
720 && address
+ embedded_offset
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
724 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
725 address
+ embedded_offset
+ offset
);
729 result_count
+= dynamic_cast_check_1 (desired_type
,
731 embedded_offset
+ offset
,
733 TYPE_BASECLASS (search_type
, i
),
742 /* A helper for value_dynamic_cast. This implements the second of two
743 runtime checks: we look for a unique public sibling class of the
744 argument's declared class. */
747 dynamic_cast_check_2 (struct type
*desired_type
,
748 const gdb_byte
*valaddr
,
749 LONGEST embedded_offset
,
752 struct type
*search_type
,
753 struct value
**result
)
755 int i
, result_count
= 0;
757 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
761 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
764 offset
= baseclass_offset (search_type
, i
, valaddr
, embedded_offset
,
766 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
770 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
771 address
+ embedded_offset
+ offset
);
774 result_count
+= dynamic_cast_check_2 (desired_type
,
776 embedded_offset
+ offset
,
778 TYPE_BASECLASS (search_type
, i
),
785 /* The C++ dynamic_cast operator. */
788 value_dynamic_cast (struct type
*type
, struct value
*arg
)
792 struct type
*resolved_type
= check_typedef (type
);
793 struct type
*arg_type
= check_typedef (value_type (arg
));
794 struct type
*class_type
, *rtti_type
;
795 struct value
*result
, *tem
, *original_arg
= arg
;
797 int is_ref
= TYPE_IS_REFERENCE (resolved_type
);
799 if (resolved_type
->code () != TYPE_CODE_PTR
800 && !TYPE_IS_REFERENCE (resolved_type
))
801 error (_("Argument to dynamic_cast must be a pointer or reference type"));
802 if (TYPE_TARGET_TYPE (resolved_type
)->code () != TYPE_CODE_VOID
803 && TYPE_TARGET_TYPE (resolved_type
)->code () != TYPE_CODE_STRUCT
)
804 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
806 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
807 if (resolved_type
->code () == TYPE_CODE_PTR
)
809 if (arg_type
->code () != TYPE_CODE_PTR
810 && ! (arg_type
->code () == TYPE_CODE_INT
811 && value_as_long (arg
) == 0))
812 error (_("Argument to dynamic_cast does not have pointer type"));
813 if (arg_type
->code () == TYPE_CODE_PTR
)
815 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
816 if (arg_type
->code () != TYPE_CODE_STRUCT
)
817 error (_("Argument to dynamic_cast does "
818 "not have pointer to class type"));
821 /* Handle NULL pointers. */
822 if (value_as_long (arg
) == 0)
823 return value_zero (type
, not_lval
);
825 arg
= value_ind (arg
);
829 if (arg_type
->code () != TYPE_CODE_STRUCT
)
830 error (_("Argument to dynamic_cast does not have class type"));
833 /* If the classes are the same, just return the argument. */
834 if (class_types_same_p (class_type
, arg_type
))
835 return value_cast (type
, arg
);
837 /* If the target type is a unique base class of the argument's
838 declared type, just cast it. */
839 if (is_ancestor (class_type
, arg_type
))
841 if (is_unique_ancestor (class_type
, arg
))
842 return value_cast (type
, original_arg
);
843 error (_("Ambiguous dynamic_cast"));
846 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
848 error (_("Couldn't determine value's most derived type for dynamic_cast"));
850 /* Compute the most derived object's address. */
851 addr
= value_address (arg
);
859 addr
+= top
+ value_embedded_offset (arg
);
861 /* dynamic_cast<void *> means to return a pointer to the
862 most-derived object. */
863 if (resolved_type
->code () == TYPE_CODE_PTR
864 && TYPE_TARGET_TYPE (resolved_type
)->code () == TYPE_CODE_VOID
)
865 return value_at_lazy (type
, addr
);
867 tem
= value_at (type
, addr
);
868 type
= value_type (tem
);
870 /* The first dynamic check specified in 5.2.7. */
871 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
873 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
876 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
877 value_contents_for_printing (tem
),
878 value_embedded_offset (tem
),
879 value_address (tem
), tem
,
883 return value_cast (type
,
885 ? value_ref (result
, resolved_type
->code ())
886 : value_addr (result
));
889 /* The second dynamic check specified in 5.2.7. */
891 if (is_public_ancestor (arg_type
, rtti_type
)
892 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
893 value_contents_for_printing (tem
),
894 value_embedded_offset (tem
),
895 value_address (tem
), tem
,
896 rtti_type
, &result
) == 1)
897 return value_cast (type
,
899 ? value_ref (result
, resolved_type
->code ())
900 : value_addr (result
));
902 if (resolved_type
->code () == TYPE_CODE_PTR
)
903 return value_zero (type
, not_lval
);
905 error (_("dynamic_cast failed"));
908 /* Create a value of type TYPE that is zero, and return it. */
911 value_zero (struct type
*type
, enum lval_type lv
)
913 struct value
*val
= allocate_value (type
);
915 VALUE_LVAL (val
) = (lv
== lval_computed
? not_lval
: lv
);
919 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
922 value_one (struct type
*type
)
924 struct type
*type1
= check_typedef (type
);
927 if (is_integral_type (type1
) || is_floating_type (type1
))
929 val
= value_from_longest (type
, (LONGEST
) 1);
931 else if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
933 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type1
));
935 LONGEST low_bound
, high_bound
;
938 if (!get_array_bounds (type1
, &low_bound
, &high_bound
))
939 error (_("Could not determine the vector bounds"));
941 val
= allocate_value (type
);
942 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
944 tmp
= value_one (eltype
);
945 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
946 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
951 error (_("Not a numeric type."));
954 /* value_one result is never used for assignments to. */
955 gdb_assert (VALUE_LVAL (val
) == not_lval
);
960 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
961 The type of the created value may differ from the passed type TYPE.
962 Make sure to retrieve the returned values's new type after this call
963 e.g. in case the type is a variable length array. */
965 static struct value
*
966 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
970 if (check_typedef (type
)->code () == TYPE_CODE_VOID
)
971 error (_("Attempt to dereference a generic pointer."));
973 val
= value_from_contents_and_address (type
, NULL
, addr
);
976 value_fetch_lazy (val
);
981 /* Return a value with type TYPE located at ADDR.
983 Call value_at only if the data needs to be fetched immediately;
984 if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
985 value_at_lazy instead. value_at_lazy simply records the address of
986 the data and sets the lazy-evaluation-required flag. The lazy flag
987 is tested in the value_contents macro, which is used if and when
988 the contents are actually required. The type of the created value
989 may differ from the passed type TYPE. Make sure to retrieve the
990 returned values's new type after this call e.g. in case the type
991 is a variable length array.
993 Note: value_at does *NOT* handle embedded offsets; perform such
994 adjustments before or after calling it. */
997 value_at (struct type
*type
, CORE_ADDR addr
)
999 return get_value_at (type
, addr
, 0);
1002 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
1003 The type of the created value may differ from the passed type TYPE.
1004 Make sure to retrieve the returned values's new type after this call
1005 e.g. in case the type is a variable length array. */
1008 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
1010 return get_value_at (type
, addr
, 1);
1014 read_value_memory (struct value
*val
, LONGEST bit_offset
,
1015 int stack
, CORE_ADDR memaddr
,
1016 gdb_byte
*buffer
, size_t length
)
1018 ULONGEST xfered_total
= 0;
1019 struct gdbarch
*arch
= get_value_arch (val
);
1020 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
1021 enum target_object object
;
1023 object
= stack
? TARGET_OBJECT_STACK_MEMORY
: TARGET_OBJECT_MEMORY
;
1025 while (xfered_total
< length
)
1027 enum target_xfer_status status
;
1028 ULONGEST xfered_partial
;
1030 status
= target_xfer_partial (current_top_target (),
1032 buffer
+ xfered_total
* unit_size
, NULL
,
1033 memaddr
+ xfered_total
,
1034 length
- xfered_total
,
1037 if (status
== TARGET_XFER_OK
)
1039 else if (status
== TARGET_XFER_UNAVAILABLE
)
1040 mark_value_bits_unavailable (val
, (xfered_total
* HOST_CHAR_BIT
1042 xfered_partial
* HOST_CHAR_BIT
);
1043 else if (status
== TARGET_XFER_EOF
)
1044 memory_error (TARGET_XFER_E_IO
, memaddr
+ xfered_total
);
1046 memory_error (status
, memaddr
+ xfered_total
);
1048 xfered_total
+= xfered_partial
;
1053 /* Store the contents of FROMVAL into the location of TOVAL.
1054 Return a new value with the location of TOVAL and contents of FROMVAL. */
1057 value_assign (struct value
*toval
, struct value
*fromval
)
1061 struct frame_id old_frame
;
1063 if (!deprecated_value_modifiable (toval
))
1064 error (_("Left operand of assignment is not a modifiable lvalue."));
1066 toval
= coerce_ref (toval
);
1068 type
= value_type (toval
);
1069 if (VALUE_LVAL (toval
) != lval_internalvar
)
1070 fromval
= value_cast (type
, fromval
);
1073 /* Coerce arrays and functions to pointers, except for arrays
1074 which only live in GDB's storage. */
1075 if (!value_must_coerce_to_target (fromval
))
1076 fromval
= coerce_array (fromval
);
1079 type
= check_typedef (type
);
1081 /* Since modifying a register can trash the frame chain, and
1082 modifying memory can trash the frame cache, we save the old frame
1083 and then restore the new frame afterwards. */
1084 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1086 switch (VALUE_LVAL (toval
))
1088 case lval_internalvar
:
1089 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1090 return value_of_internalvar (get_type_arch (type
),
1091 VALUE_INTERNALVAR (toval
));
1093 case lval_internalvar_component
:
1095 LONGEST offset
= value_offset (toval
);
1097 /* Are we dealing with a bitfield?
1099 It is important to mention that `value_parent (toval)' is
1100 non-NULL iff `value_bitsize (toval)' is non-zero. */
1101 if (value_bitsize (toval
))
1103 /* VALUE_INTERNALVAR below refers to the parent value, while
1104 the offset is relative to this parent value. */
1105 gdb_assert (value_parent (value_parent (toval
)) == NULL
);
1106 offset
+= value_offset (value_parent (toval
));
1109 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1111 value_bitpos (toval
),
1112 value_bitsize (toval
),
1119 const gdb_byte
*dest_buffer
;
1120 CORE_ADDR changed_addr
;
1122 gdb_byte buffer
[sizeof (LONGEST
)];
1124 if (value_bitsize (toval
))
1126 struct value
*parent
= value_parent (toval
);
1128 changed_addr
= value_address (parent
) + value_offset (toval
);
1129 changed_len
= (value_bitpos (toval
)
1130 + value_bitsize (toval
)
1131 + HOST_CHAR_BIT
- 1)
1134 /* If we can read-modify-write exactly the size of the
1135 containing type (e.g. short or int) then do so. This
1136 is safer for volatile bitfields mapped to hardware
1138 if (changed_len
< TYPE_LENGTH (type
)
1139 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1140 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1141 changed_len
= TYPE_LENGTH (type
);
1143 if (changed_len
> (int) sizeof (LONGEST
))
1144 error (_("Can't handle bitfields which "
1145 "don't fit in a %d bit word."),
1146 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1148 read_memory (changed_addr
, buffer
, changed_len
);
1149 modify_field (type
, buffer
, value_as_long (fromval
),
1150 value_bitpos (toval
), value_bitsize (toval
));
1151 dest_buffer
= buffer
;
1155 changed_addr
= value_address (toval
);
1156 changed_len
= type_length_units (type
);
1157 dest_buffer
= value_contents (fromval
);
1160 write_memory_with_notification (changed_addr
, dest_buffer
, changed_len
);
1166 struct frame_info
*frame
;
1167 struct gdbarch
*gdbarch
;
1170 /* Figure out which frame this is in currently.
1172 We use VALUE_FRAME_ID for obtaining the value's frame id instead of
1173 VALUE_NEXT_FRAME_ID due to requiring a frame which may be passed to
1174 put_frame_register_bytes() below. That function will (eventually)
1175 perform the necessary unwind operation by first obtaining the next
1177 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1179 value_reg
= VALUE_REGNUM (toval
);
1182 error (_("Value being assigned to is no longer active."));
1184 gdbarch
= get_frame_arch (frame
);
1186 if (value_bitsize (toval
))
1188 struct value
*parent
= value_parent (toval
);
1189 LONGEST offset
= value_offset (parent
) + value_offset (toval
);
1191 gdb_byte buffer
[sizeof (LONGEST
)];
1194 changed_len
= (value_bitpos (toval
)
1195 + value_bitsize (toval
)
1196 + HOST_CHAR_BIT
- 1)
1199 if (changed_len
> (int) sizeof (LONGEST
))
1200 error (_("Can't handle bitfields which "
1201 "don't fit in a %d bit word."),
1202 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1204 if (!get_frame_register_bytes (frame
, value_reg
, offset
,
1205 changed_len
, buffer
,
1209 throw_error (OPTIMIZED_OUT_ERROR
,
1210 _("value has been optimized out"));
1212 throw_error (NOT_AVAILABLE_ERROR
,
1213 _("value is not available"));
1216 modify_field (type
, buffer
, value_as_long (fromval
),
1217 value_bitpos (toval
), value_bitsize (toval
));
1219 put_frame_register_bytes (frame
, value_reg
, offset
,
1220 changed_len
, buffer
);
1224 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
),
1227 /* If TOVAL is a special machine register requiring
1228 conversion of program values to a special raw
1230 gdbarch_value_to_register (gdbarch
, frame
,
1231 VALUE_REGNUM (toval
), type
,
1232 value_contents (fromval
));
1236 put_frame_register_bytes (frame
, value_reg
,
1237 value_offset (toval
),
1239 value_contents (fromval
));
1243 gdb::observers::register_changed
.notify (frame
, value_reg
);
1249 const struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1251 if (funcs
->write
!= NULL
)
1253 funcs
->write (toval
, fromval
);
1260 error (_("Left operand of assignment is not an lvalue."));
1263 /* Assigning to the stack pointer, frame pointer, and other
1264 (architecture and calling convention specific) registers may
1265 cause the frame cache and regcache to be out of date. Assigning to memory
1266 also can. We just do this on all assignments to registers or
1267 memory, for simplicity's sake; I doubt the slowdown matters. */
1268 switch (VALUE_LVAL (toval
))
1274 gdb::observers::target_changed
.notify (current_top_target ());
1276 /* Having destroyed the frame cache, restore the selected
1279 /* FIXME: cagney/2002-11-02: There has to be a better way of
1280 doing this. Instead of constantly saving/restoring the
1281 frame. Why not create a get_selected_frame() function that,
1282 having saved the selected frame's ID can automatically
1283 re-find the previously selected frame automatically. */
1286 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1297 /* If the field does not entirely fill a LONGEST, then zero the sign
1298 bits. If the field is signed, and is negative, then sign
1300 if ((value_bitsize (toval
) > 0)
1301 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1303 LONGEST fieldval
= value_as_long (fromval
);
1304 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1306 fieldval
&= valmask
;
1307 if (!type
->is_unsigned ()
1308 && (fieldval
& (valmask
^ (valmask
>> 1))))
1309 fieldval
|= ~valmask
;
1311 fromval
= value_from_longest (type
, fieldval
);
1314 /* The return value is a copy of TOVAL so it shares its location
1315 information, but its contents are updated from FROMVAL. This
1316 implies the returned value is not lazy, even if TOVAL was. */
1317 val
= value_copy (toval
);
1318 set_value_lazy (val
, 0);
1319 memcpy (value_contents_raw (val
), value_contents (fromval
),
1320 TYPE_LENGTH (type
));
1322 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1323 in the case of pointer types. For object types, the enclosing type
1324 and embedded offset must *not* be copied: the target object refered
1325 to by TOVAL retains its original dynamic type after assignment. */
1326 if (type
->code () == TYPE_CODE_PTR
)
1328 set_value_enclosing_type (val
, value_enclosing_type (fromval
));
1329 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1335 /* Extend a value ARG1 to COUNT repetitions of its type. */
1338 value_repeat (struct value
*arg1
, int count
)
1342 if (VALUE_LVAL (arg1
) != lval_memory
)
1343 error (_("Only values in memory can be extended with '@'."));
1345 error (_("Invalid number %d of repetitions."), count
);
1347 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1349 VALUE_LVAL (val
) = lval_memory
;
1350 set_value_address (val
, value_address (arg1
));
1352 read_value_memory (val
, 0, value_stack (val
), value_address (val
),
1353 value_contents_all_raw (val
),
1354 type_length_units (value_enclosing_type (val
)));
1360 value_of_variable (struct symbol
*var
, const struct block
*b
)
1362 struct frame_info
*frame
= NULL
;
1364 if (symbol_read_needs_frame (var
))
1365 frame
= get_selected_frame (_("No frame selected."));
1367 return read_var_value (var
, b
, frame
);
1371 address_of_variable (struct symbol
*var
, const struct block
*b
)
1373 struct type
*type
= SYMBOL_TYPE (var
);
1376 /* Evaluate it first; if the result is a memory address, we're fine.
1377 Lazy evaluation pays off here. */
1379 val
= value_of_variable (var
, b
);
1380 type
= value_type (val
);
1382 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1383 || type
->code () == TYPE_CODE_FUNC
)
1385 CORE_ADDR addr
= value_address (val
);
1387 return value_from_pointer (lookup_pointer_type (type
), addr
);
1390 /* Not a memory address; check what the problem was. */
1391 switch (VALUE_LVAL (val
))
1395 struct frame_info
*frame
;
1396 const char *regname
;
1398 frame
= frame_find_by_id (VALUE_NEXT_FRAME_ID (val
));
1401 regname
= gdbarch_register_name (get_frame_arch (frame
),
1402 VALUE_REGNUM (val
));
1403 gdb_assert (regname
&& *regname
);
1405 error (_("Address requested for identifier "
1406 "\"%s\" which is in register $%s"),
1407 var
->print_name (), regname
);
1412 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1413 var
->print_name ());
1423 value_must_coerce_to_target (struct value
*val
)
1425 struct type
*valtype
;
1427 /* The only lval kinds which do not live in target memory. */
1428 if (VALUE_LVAL (val
) != not_lval
1429 && VALUE_LVAL (val
) != lval_internalvar
1430 && VALUE_LVAL (val
) != lval_xcallable
)
1433 valtype
= check_typedef (value_type (val
));
1435 switch (valtype
->code ())
1437 case TYPE_CODE_ARRAY
:
1438 return valtype
->is_vector () ? 0 : 1;
1439 case TYPE_CODE_STRING
:
1446 /* Make sure that VAL lives in target memory if it's supposed to. For
1447 instance, strings are constructed as character arrays in GDB's
1448 storage, and this function copies them to the target. */
1451 value_coerce_to_target (struct value
*val
)
1456 if (!value_must_coerce_to_target (val
))
1459 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1460 addr
= allocate_space_in_inferior (length
);
1461 write_memory (addr
, value_contents (val
), length
);
1462 return value_at_lazy (value_type (val
), addr
);
1465 /* Given a value which is an array, return a value which is a pointer
1466 to its first element, regardless of whether or not the array has a
1467 nonzero lower bound.
1469 FIXME: A previous comment here indicated that this routine should
1470 be substracting the array's lower bound. It's not clear to me that
1471 this is correct. Given an array subscripting operation, it would
1472 certainly work to do the adjustment here, essentially computing:
1474 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1476 However I believe a more appropriate and logical place to account
1477 for the lower bound is to do so in value_subscript, essentially
1480 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1482 As further evidence consider what would happen with operations
1483 other than array subscripting, where the caller would get back a
1484 value that had an address somewhere before the actual first element
1485 of the array, and the information about the lower bound would be
1486 lost because of the coercion to pointer type. */
1489 value_coerce_array (struct value
*arg1
)
1491 struct type
*type
= check_typedef (value_type (arg1
));
1493 /* If the user tries to do something requiring a pointer with an
1494 array that has not yet been pushed to the target, then this would
1495 be a good time to do so. */
1496 arg1
= value_coerce_to_target (arg1
);
1498 if (VALUE_LVAL (arg1
) != lval_memory
)
1499 error (_("Attempt to take address of value not located in memory."));
1501 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1502 value_address (arg1
));
1505 /* Given a value which is a function, return a value which is a pointer
1509 value_coerce_function (struct value
*arg1
)
1511 struct value
*retval
;
1513 if (VALUE_LVAL (arg1
) != lval_memory
)
1514 error (_("Attempt to take address of value not located in memory."));
1516 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1517 value_address (arg1
));
1521 /* Return a pointer value for the object for which ARG1 is the
1525 value_addr (struct value
*arg1
)
1528 struct type
*type
= check_typedef (value_type (arg1
));
1530 if (TYPE_IS_REFERENCE (type
))
1532 if (value_bits_synthetic_pointer (arg1
, value_embedded_offset (arg1
),
1533 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1534 arg1
= coerce_ref (arg1
);
1537 /* Copy the value, but change the type from (T&) to (T*). We
1538 keep the same location information, which is efficient, and
1539 allows &(&X) to get the location containing the reference.
1540 Do the same to its enclosing type for consistency. */
1541 struct type
*type_ptr
1542 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1543 struct type
*enclosing_type
1544 = check_typedef (value_enclosing_type (arg1
));
1545 struct type
*enclosing_type_ptr
1546 = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type
));
1548 arg2
= value_copy (arg1
);
1549 deprecated_set_value_type (arg2
, type_ptr
);
1550 set_value_enclosing_type (arg2
, enclosing_type_ptr
);
1555 if (type
->code () == TYPE_CODE_FUNC
)
1556 return value_coerce_function (arg1
);
1558 /* If this is an array that has not yet been pushed to the target,
1559 then this would be a good time to force it to memory. */
1560 arg1
= value_coerce_to_target (arg1
);
1562 if (VALUE_LVAL (arg1
) != lval_memory
)
1563 error (_("Attempt to take address of value not located in memory."));
1565 /* Get target memory address. */
1566 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1567 (value_address (arg1
)
1568 + value_embedded_offset (arg1
)));
1570 /* This may be a pointer to a base subobject; so remember the
1571 full derived object's type ... */
1572 set_value_enclosing_type (arg2
,
1573 lookup_pointer_type (value_enclosing_type (arg1
)));
1574 /* ... and also the relative position of the subobject in the full
1576 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1580 /* Return a reference value for the object for which ARG1 is the
1584 value_ref (struct value
*arg1
, enum type_code refcode
)
1587 struct type
*type
= check_typedef (value_type (arg1
));
1589 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
1591 if ((type
->code () == TYPE_CODE_REF
1592 || type
->code () == TYPE_CODE_RVALUE_REF
)
1593 && type
->code () == refcode
)
1596 arg2
= value_addr (arg1
);
1597 deprecated_set_value_type (arg2
, lookup_reference_type (type
, refcode
));
1601 /* Given a value of a pointer type, apply the C unary * operator to
1605 value_ind (struct value
*arg1
)
1607 struct type
*base_type
;
1610 arg1
= coerce_array (arg1
);
1612 base_type
= check_typedef (value_type (arg1
));
1614 if (VALUE_LVAL (arg1
) == lval_computed
)
1616 const struct lval_funcs
*funcs
= value_computed_funcs (arg1
);
1618 if (funcs
->indirect
)
1620 struct value
*result
= funcs
->indirect (arg1
);
1627 if (base_type
->code () == TYPE_CODE_PTR
)
1629 struct type
*enc_type
;
1631 /* We may be pointing to something embedded in a larger object.
1632 Get the real type of the enclosing object. */
1633 enc_type
= check_typedef (value_enclosing_type (arg1
));
1634 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1636 CORE_ADDR base_addr
;
1637 if (check_typedef (enc_type
)->code () == TYPE_CODE_FUNC
1638 || check_typedef (enc_type
)->code () == TYPE_CODE_METHOD
)
1640 /* For functions, go through find_function_addr, which knows
1641 how to handle function descriptors. */
1642 base_addr
= find_function_addr (arg1
, NULL
);
1646 /* Retrieve the enclosing object pointed to. */
1647 base_addr
= (value_as_address (arg1
)
1648 - value_pointed_to_offset (arg1
));
1650 arg2
= value_at_lazy (enc_type
, base_addr
);
1651 enc_type
= value_type (arg2
);
1652 return readjust_indirect_value_type (arg2
, enc_type
, base_type
,
1656 error (_("Attempt to take contents of a non-pointer value."));
1659 /* Create a value for an array by allocating space in GDB, copying the
1660 data into that space, and then setting up an array value.
1662 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1663 is populated from the values passed in ELEMVEC.
1665 The element type of the array is inherited from the type of the
1666 first element, and all elements must have the same size (though we
1667 don't currently enforce any restriction on their types). */
1670 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1674 ULONGEST typelength
;
1676 struct type
*arraytype
;
1678 /* Validate that the bounds are reasonable and that each of the
1679 elements have the same size. */
1681 nelem
= highbound
- lowbound
+ 1;
1684 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1686 typelength
= type_length_units (value_enclosing_type (elemvec
[0]));
1687 for (idx
= 1; idx
< nelem
; idx
++)
1689 if (type_length_units (value_enclosing_type (elemvec
[idx
]))
1692 error (_("array elements must all be the same size"));
1696 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1697 lowbound
, highbound
);
1699 if (!current_language
->c_style_arrays_p ())
1701 val
= allocate_value (arraytype
);
1702 for (idx
= 0; idx
< nelem
; idx
++)
1703 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0,
1708 /* Allocate space to store the array, and then initialize it by
1709 copying in each element. */
1711 val
= allocate_value (arraytype
);
1712 for (idx
= 0; idx
< nelem
; idx
++)
1713 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0, typelength
);
1718 value_cstring (const char *ptr
, ssize_t len
, struct type
*char_type
)
1721 int lowbound
= current_language
->string_lower_bound ();
1722 ssize_t highbound
= len
/ TYPE_LENGTH (char_type
);
1723 struct type
*stringtype
1724 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1726 val
= allocate_value (stringtype
);
1727 memcpy (value_contents_raw (val
), ptr
, len
);
1731 /* Create a value for a string constant by allocating space in the
1732 inferior, copying the data into that space, and returning the
1733 address with type TYPE_CODE_STRING. PTR points to the string
1734 constant data; LEN is number of characters.
1736 Note that string types are like array of char types with a lower
1737 bound of zero and an upper bound of LEN - 1. Also note that the
1738 string may contain embedded null bytes. */
1741 value_string (const char *ptr
, ssize_t len
, struct type
*char_type
)
1744 int lowbound
= current_language
->string_lower_bound ();
1745 ssize_t highbound
= len
/ TYPE_LENGTH (char_type
);
1746 struct type
*stringtype
1747 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1749 val
= allocate_value (stringtype
);
1750 memcpy (value_contents_raw (val
), ptr
, len
);
1755 /* See if we can pass arguments in T2 to a function which takes
1756 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1757 a NULL-terminated vector. If some arguments need coercion of some
1758 sort, then the coerced values are written into T2. Return value is
1759 0 if the arguments could be matched, or the position at which they
1762 STATICP is nonzero if the T1 argument list came from a static
1763 member function. T2 will still include the ``this'' pointer, but
1766 For non-static member functions, we ignore the first argument,
1767 which is the type of the instance variable. This is because we
1768 want to handle calls with objects from derived classes. This is
1769 not entirely correct: we should actually check to make sure that a
1770 requested operation is type secure, shouldn't we? FIXME. */
1773 typecmp (int staticp
, int varargs
, int nargs
,
1774 struct field t1
[], struct value
*t2
[])
1779 internal_error (__FILE__
, __LINE__
,
1780 _("typecmp: no argument list"));
1782 /* Skip ``this'' argument if applicable. T2 will always include
1788 (i
< nargs
) && t1
[i
].type ()->code () != TYPE_CODE_VOID
;
1791 struct type
*tt1
, *tt2
;
1796 tt1
= check_typedef (t1
[i
].type ());
1797 tt2
= check_typedef (value_type (t2
[i
]));
1799 if (TYPE_IS_REFERENCE (tt1
)
1800 /* We should be doing hairy argument matching, as below. */
1801 && (check_typedef (TYPE_TARGET_TYPE (tt1
))->code ()
1804 if (tt2
->code () == TYPE_CODE_ARRAY
)
1805 t2
[i
] = value_coerce_array (t2
[i
]);
1807 t2
[i
] = value_ref (t2
[i
], tt1
->code ());
1811 /* djb - 20000715 - Until the new type structure is in the
1812 place, and we can attempt things like implicit conversions,
1813 we need to do this so you can take something like a map<const
1814 char *>, and properly access map["hello"], because the
1815 argument to [] will be a reference to a pointer to a char,
1816 and the argument will be a pointer to a char. */
1817 while (TYPE_IS_REFERENCE (tt1
) || tt1
->code () == TYPE_CODE_PTR
)
1819 tt1
= check_typedef ( TYPE_TARGET_TYPE (tt1
) );
1821 while (tt2
->code () == TYPE_CODE_ARRAY
1822 || tt2
->code () == TYPE_CODE_PTR
1823 || TYPE_IS_REFERENCE (tt2
))
1825 tt2
= check_typedef (TYPE_TARGET_TYPE (tt2
));
1827 if (tt1
->code () == tt2
->code ())
1829 /* Array to pointer is a `trivial conversion' according to the
1832 /* We should be doing much hairier argument matching (see
1833 section 13.2 of the ARM), but as a quick kludge, just check
1834 for the same type code. */
1835 if (t1
[i
].type ()->code () != value_type (t2
[i
])->code ())
1838 if (varargs
|| t2
[i
] == NULL
)
1843 /* Helper class for search_struct_field that keeps track of found
1844 results and possibly throws an exception if the search yields
1845 ambiguous results. See search_struct_field for description of
1846 LOOKING_FOR_BASECLASS. */
1848 struct struct_field_searcher
1850 /* A found field. */
1853 /* Path to the structure where the field was found. */
1854 std::vector
<struct type
*> path
;
1856 /* The field found. */
1857 struct value
*field_value
;
1860 /* See corresponding fields for description of parameters. */
1861 struct_field_searcher (const char *name
,
1862 struct type
*outermost_type
,
1863 bool looking_for_baseclass
)
1865 m_looking_for_baseclass (looking_for_baseclass
),
1866 m_outermost_type (outermost_type
)
1870 /* The search entry point. If LOOKING_FOR_BASECLASS is true and the
1871 base class search yields ambiguous results, this throws an
1872 exception. If LOOKING_FOR_BASECLASS is false, the found fields
1873 are accumulated and the caller (search_struct_field) takes care
1874 of throwing an error if the field search yields ambiguous
1875 results. The latter is done that way so that the error message
1876 can include a list of all the found candidates. */
1877 void search (struct value
*arg
, LONGEST offset
, struct type
*type
);
1879 const std::vector
<found_field
> &fields ()
1884 struct value
*baseclass ()
1890 /* Update results to include V, a found field/baseclass. */
1891 void update_result (struct value
*v
, LONGEST boffset
);
1893 /* The name of the field/baseclass we're searching for. */
1896 /* Whether we're looking for a baseclass, or a field. */
1897 const bool m_looking_for_baseclass
;
1899 /* The offset of the baseclass containing the field/baseclass we
1901 LONGEST m_last_boffset
= 0;
1903 /* If looking for a baseclass, then the result is stored here. */
1904 struct value
*m_baseclass
= nullptr;
1906 /* When looking for fields, the found candidates are stored
1908 std::vector
<found_field
> m_fields
;
1910 /* The type of the initial type passed to search_struct_field; this
1911 is used for error reporting when the lookup is ambiguous. */
1912 struct type
*m_outermost_type
;
1914 /* The full path to the struct being inspected. E.g. for field 'x'
1915 defined in class B inherited by class A, we have A and B pushed
1917 std::vector
<struct type
*> m_struct_path
;
1921 struct_field_searcher::update_result (struct value
*v
, LONGEST boffset
)
1925 if (m_looking_for_baseclass
)
1927 if (m_baseclass
!= nullptr
1928 /* The result is not ambiguous if all the classes that are
1929 found occupy the same space. */
1930 && m_last_boffset
!= boffset
)
1931 error (_("base class '%s' is ambiguous in type '%s'"),
1932 m_name
, TYPE_SAFE_NAME (m_outermost_type
));
1935 m_last_boffset
= boffset
;
1939 /* The field is not ambiguous if it occupies the same
1941 if (m_fields
.empty () || m_last_boffset
!= boffset
)
1942 m_fields
.push_back ({m_struct_path
, v
});
1947 /* A helper for search_struct_field. This does all the work; most
1948 arguments are as passed to search_struct_field. */
1951 struct_field_searcher::search (struct value
*arg1
, LONGEST offset
,
1957 m_struct_path
.push_back (type
);
1958 SCOPE_EXIT
{ m_struct_path
.pop_back (); };
1960 type
= check_typedef (type
);
1961 nbases
= TYPE_N_BASECLASSES (type
);
1963 if (!m_looking_for_baseclass
)
1964 for (i
= type
->num_fields () - 1; i
>= nbases
; i
--)
1966 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1968 if (t_field_name
&& (strcmp_iw (t_field_name
, m_name
) == 0))
1972 if (field_is_static (&type
->field (i
)))
1973 v
= value_static_field (type
, i
);
1975 v
= value_primitive_field (arg1
, offset
, i
, type
);
1977 update_result (v
, offset
);
1982 && t_field_name
[0] == '\0')
1984 struct type
*field_type
= type
->field (i
).type ();
1986 if (field_type
->code () == TYPE_CODE_UNION
1987 || field_type
->code () == TYPE_CODE_STRUCT
)
1989 /* Look for a match through the fields of an anonymous
1990 union, or anonymous struct. C++ provides anonymous
1993 In the GNU Chill (now deleted from GDB)
1994 implementation of variant record types, each
1995 <alternative field> has an (anonymous) union type,
1996 each member of the union represents a <variant
1997 alternative>. Each <variant alternative> is
1998 represented as a struct, with a member for each
2001 LONGEST new_offset
= offset
;
2003 /* This is pretty gross. In G++, the offset in an
2004 anonymous union is relative to the beginning of the
2005 enclosing struct. In the GNU Chill (now deleted
2006 from GDB) implementation of variant records, the
2007 bitpos is zero in an anonymous union field, so we
2008 have to add the offset of the union here. */
2009 if (field_type
->code () == TYPE_CODE_STRUCT
2010 || (field_type
->num_fields () > 0
2011 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2012 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2014 search (arg1
, new_offset
, field_type
);
2019 for (i
= 0; i
< nbases
; i
++)
2021 struct value
*v
= NULL
;
2022 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2023 /* If we are looking for baseclasses, this is what we get when
2024 we hit them. But it could happen that the base part's member
2025 name is not yet filled in. */
2026 int found_baseclass
= (m_looking_for_baseclass
2027 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2028 && (strcmp_iw (m_name
,
2029 TYPE_BASECLASS_NAME (type
,
2031 LONGEST boffset
= value_embedded_offset (arg1
) + offset
;
2033 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2037 boffset
= baseclass_offset (type
, i
,
2038 value_contents_for_printing (arg1
),
2039 value_embedded_offset (arg1
) + offset
,
2040 value_address (arg1
),
2043 /* The virtual base class pointer might have been clobbered
2044 by the user program. Make sure that it still points to a
2045 valid memory location. */
2047 boffset
+= value_embedded_offset (arg1
) + offset
;
2049 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
2051 CORE_ADDR base_addr
;
2053 base_addr
= value_address (arg1
) + boffset
;
2054 v2
= value_at_lazy (basetype
, base_addr
);
2055 if (target_read_memory (base_addr
,
2056 value_contents_raw (v2
),
2057 TYPE_LENGTH (value_type (v2
))) != 0)
2058 error (_("virtual baseclass botch"));
2062 v2
= value_copy (arg1
);
2063 deprecated_set_value_type (v2
, basetype
);
2064 set_value_embedded_offset (v2
, boffset
);
2067 if (found_baseclass
)
2070 search (v2
, 0, TYPE_BASECLASS (type
, i
));
2072 else if (found_baseclass
)
2073 v
= value_primitive_field (arg1
, offset
, i
, type
);
2076 search (arg1
, offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2080 update_result (v
, boffset
);
2084 /* Helper function used by value_struct_elt to recurse through
2085 baseclasses. Look for a field NAME in ARG1. Search in it assuming
2086 it has (class) type TYPE. If found, return value, else return NULL.
2088 If LOOKING_FOR_BASECLASS, then instead of looking for struct
2089 fields, look for a baseclass named NAME. */
2091 static struct value
*
2092 search_struct_field (const char *name
, struct value
*arg1
,
2093 struct type
*type
, int looking_for_baseclass
)
2095 struct_field_searcher
searcher (name
, type
, looking_for_baseclass
);
2097 searcher
.search (arg1
, 0, type
);
2099 if (!looking_for_baseclass
)
2101 const auto &fields
= searcher
.fields ();
2103 if (fields
.empty ())
2105 else if (fields
.size () == 1)
2106 return fields
[0].field_value
;
2109 std::string candidates
;
2111 for (auto &&candidate
: fields
)
2113 gdb_assert (!candidate
.path
.empty ());
2115 struct type
*field_type
= value_type (candidate
.field_value
);
2116 struct type
*struct_type
= candidate
.path
.back ();
2120 for (struct type
*t
: candidate
.path
)
2129 candidates
+= string_printf ("\n '%s %s::%s' (%s)",
2130 TYPE_SAFE_NAME (field_type
),
2131 TYPE_SAFE_NAME (struct_type
),
2136 error (_("Request for member '%s' is ambiguous in type '%s'."
2137 " Candidates are:%s"),
2138 name
, TYPE_SAFE_NAME (type
),
2139 candidates
.c_str ());
2143 return searcher
.baseclass ();
2146 /* Helper function used by value_struct_elt to recurse through
2147 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2148 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2151 If found, return value, else if name matched and args not return
2152 (value) -1, else return NULL. */
2154 static struct value
*
2155 search_struct_method (const char *name
, struct value
**arg1p
,
2156 struct value
**args
, LONGEST offset
,
2157 int *static_memfuncp
, struct type
*type
)
2161 int name_matched
= 0;
2163 type
= check_typedef (type
);
2164 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2166 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2168 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2170 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2171 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2174 check_stub_method_group (type
, i
);
2175 if (j
> 0 && args
== 0)
2176 error (_("cannot resolve overloaded method "
2177 "`%s': no arguments supplied"), name
);
2178 else if (j
== 0 && args
== 0)
2180 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2187 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2188 TYPE_FN_FIELD_TYPE (f
, j
)->has_varargs (),
2189 TYPE_FN_FIELD_TYPE (f
, j
)->num_fields (),
2190 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2192 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2193 return value_virtual_fn_field (arg1p
, f
, j
,
2195 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2197 *static_memfuncp
= 1;
2198 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2207 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2209 LONGEST base_offset
;
2210 LONGEST this_offset
;
2212 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2214 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2215 struct value
*base_val
;
2216 const gdb_byte
*base_valaddr
;
2218 /* The virtual base class pointer might have been
2219 clobbered by the user program. Make sure that it
2220 still points to a valid memory location. */
2222 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2226 gdb::byte_vector
tmp (TYPE_LENGTH (baseclass
));
2227 address
= value_address (*arg1p
);
2229 if (target_read_memory (address
+ offset
,
2230 tmp
.data (), TYPE_LENGTH (baseclass
)) != 0)
2231 error (_("virtual baseclass botch"));
2233 base_val
= value_from_contents_and_address (baseclass
,
2236 base_valaddr
= value_contents_for_printing (base_val
);
2242 base_valaddr
= value_contents_for_printing (*arg1p
);
2243 this_offset
= offset
;
2246 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2247 this_offset
, value_address (base_val
),
2252 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2254 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2255 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2256 if (v
== (struct value
*) - 1)
2262 /* FIXME-bothner: Why is this commented out? Why is it here? */
2263 /* *arg1p = arg1_tmp; */
2268 return (struct value
*) - 1;
2273 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2274 extract the component named NAME from the ultimate target
2275 structure/union and return it as a value with its appropriate type.
2276 ERR is used in the error message if *ARGP's type is wrong.
2278 C++: ARGS is a list of argument types to aid in the selection of
2279 an appropriate method. Also, handle derived types.
2281 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2282 where the truthvalue of whether the function that was resolved was
2283 a static member function or not is stored.
2285 ERR is an error message to be printed in case the field is not
2289 value_struct_elt (struct value
**argp
, struct value
**args
,
2290 const char *name
, int *static_memfuncp
, const char *err
)
2295 *argp
= coerce_array (*argp
);
2297 t
= check_typedef (value_type (*argp
));
2299 /* Follow pointers until we get to a non-pointer. */
2301 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2303 *argp
= value_ind (*argp
);
2304 /* Don't coerce fn pointer to fn and then back again! */
2305 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2306 *argp
= coerce_array (*argp
);
2307 t
= check_typedef (value_type (*argp
));
2310 if (t
->code () != TYPE_CODE_STRUCT
2311 && t
->code () != TYPE_CODE_UNION
)
2312 error (_("Attempt to extract a component of a value that is not a %s."),
2315 /* Assume it's not, unless we see that it is. */
2316 if (static_memfuncp
)
2317 *static_memfuncp
= 0;
2321 /* if there are no arguments ...do this... */
2323 /* Try as a field first, because if we succeed, there is less
2325 v
= search_struct_field (name
, *argp
, t
, 0);
2329 /* C++: If it was not found as a data field, then try to
2330 return it as a pointer to a method. */
2331 v
= search_struct_method (name
, argp
, args
, 0,
2332 static_memfuncp
, t
);
2334 if (v
== (struct value
*) - 1)
2335 error (_("Cannot take address of method %s."), name
);
2338 if (TYPE_NFN_FIELDS (t
))
2339 error (_("There is no member or method named %s."), name
);
2341 error (_("There is no member named %s."), name
);
2346 v
= search_struct_method (name
, argp
, args
, 0,
2347 static_memfuncp
, t
);
2349 if (v
== (struct value
*) - 1)
2351 error (_("One of the arguments you tried to pass to %s could not "
2352 "be converted to what the function wants."), name
);
2356 /* See if user tried to invoke data as function. If so, hand it
2357 back. If it's not callable (i.e., a pointer to function),
2358 gdb should give an error. */
2359 v
= search_struct_field (name
, *argp
, t
, 0);
2360 /* If we found an ordinary field, then it is not a method call.
2361 So, treat it as if it were a static member function. */
2362 if (v
&& static_memfuncp
)
2363 *static_memfuncp
= 1;
2367 throw_error (NOT_FOUND_ERROR
,
2368 _("Structure has no component named %s."), name
);
2372 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2373 to a structure or union, extract and return its component (field) of
2374 type FTYPE at the specified BITPOS.
2375 Throw an exception on error. */
2378 value_struct_elt_bitpos (struct value
**argp
, int bitpos
, struct type
*ftype
,
2384 *argp
= coerce_array (*argp
);
2386 t
= check_typedef (value_type (*argp
));
2388 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2390 *argp
= value_ind (*argp
);
2391 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2392 *argp
= coerce_array (*argp
);
2393 t
= check_typedef (value_type (*argp
));
2396 if (t
->code () != TYPE_CODE_STRUCT
2397 && t
->code () != TYPE_CODE_UNION
)
2398 error (_("Attempt to extract a component of a value that is not a %s."),
2401 for (i
= TYPE_N_BASECLASSES (t
); i
< t
->num_fields (); i
++)
2403 if (!field_is_static (&t
->field (i
))
2404 && bitpos
== TYPE_FIELD_BITPOS (t
, i
)
2405 && types_equal (ftype
, t
->field (i
).type ()))
2406 return value_primitive_field (*argp
, 0, i
, t
);
2409 error (_("No field with matching bitpos and type."));
2415 /* Search through the methods of an object (and its bases) to find a
2416 specified method. Return a reference to the fn_field list METHODS of
2417 overloaded instances defined in the source language. If available
2418 and matching, a vector of matching xmethods defined in extension
2419 languages are also returned in XMETHODS.
2421 Helper function for value_find_oload_list.
2422 ARGP is a pointer to a pointer to a value (the object).
2423 METHOD is a string containing the method name.
2424 OFFSET is the offset within the value.
2425 TYPE is the assumed type of the object.
2426 METHODS is a pointer to the matching overloaded instances defined
2427 in the source language. Since this is a recursive function,
2428 *METHODS should be set to NULL when calling this function.
2429 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2430 0 when calling this function.
2431 XMETHODS is the vector of matching xmethod workers. *XMETHODS
2432 should also be set to NULL when calling this function.
2433 BASETYPE is set to the actual type of the subobject where the
2435 BOFFSET is the offset of the base subobject where the method is found. */
2438 find_method_list (struct value
**argp
, const char *method
,
2439 LONGEST offset
, struct type
*type
,
2440 gdb::array_view
<fn_field
> *methods
,
2441 std::vector
<xmethod_worker_up
> *xmethods
,
2442 struct type
**basetype
, LONGEST
*boffset
)
2445 struct fn_field
*f
= NULL
;
2447 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2448 type
= check_typedef (type
);
2450 /* First check in object itself.
2451 This function is called recursively to search through base classes.
2452 If there is a source method match found at some stage, then we need not
2453 look for source methods in consequent recursive calls. */
2454 if (methods
->empty ())
2456 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2458 /* pai: FIXME What about operators and type conversions? */
2459 const char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2461 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2463 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2464 f
= TYPE_FN_FIELDLIST1 (type
, i
);
2465 *methods
= gdb::make_array_view (f
, len
);
2470 /* Resolve any stub methods. */
2471 check_stub_method_group (type
, i
);
2478 /* Unlike source methods, xmethods can be accumulated over successive
2479 recursive calls. In other words, an xmethod named 'm' in a class
2480 will not hide an xmethod named 'm' in its base class(es). We want
2481 it to be this way because xmethods are after all convenience functions
2482 and hence there is no point restricting them with something like method
2483 hiding. Moreover, if hiding is done for xmethods as well, then we will
2484 have to provide a mechanism to un-hide (like the 'using' construct). */
2485 get_matching_xmethod_workers (type
, method
, xmethods
);
2487 /* If source methods are not found in current class, look for them in the
2488 base classes. We also have to go through the base classes to gather
2489 extension methods. */
2490 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2492 LONGEST base_offset
;
2494 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2496 base_offset
= baseclass_offset (type
, i
,
2497 value_contents_for_printing (*argp
),
2498 value_offset (*argp
) + offset
,
2499 value_address (*argp
), *argp
);
2501 else /* Non-virtual base, simply use bit position from debug
2504 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2507 find_method_list (argp
, method
, base_offset
+ offset
,
2508 TYPE_BASECLASS (type
, i
), methods
,
2509 xmethods
, basetype
, boffset
);
2513 /* Return the list of overloaded methods of a specified name. The methods
2514 could be those GDB finds in the binary, or xmethod. Methods found in
2515 the binary are returned in METHODS, and xmethods are returned in
2518 ARGP is a pointer to a pointer to a value (the object).
2519 METHOD is the method name.
2520 OFFSET is the offset within the value contents.
2521 METHODS is the list of matching overloaded instances defined in
2522 the source language.
2523 XMETHODS is the vector of matching xmethod workers defined in
2524 extension languages.
2525 BASETYPE is set to the type of the base subobject that defines the
2527 BOFFSET is the offset of the base subobject which defines the method. */
2530 value_find_oload_method_list (struct value
**argp
, const char *method
,
2532 gdb::array_view
<fn_field
> *methods
,
2533 std::vector
<xmethod_worker_up
> *xmethods
,
2534 struct type
**basetype
, LONGEST
*boffset
)
2538 t
= check_typedef (value_type (*argp
));
2540 /* Code snarfed from value_struct_elt. */
2541 while (t
->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (t
))
2543 *argp
= value_ind (*argp
);
2544 /* Don't coerce fn pointer to fn and then back again! */
2545 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2546 *argp
= coerce_array (*argp
);
2547 t
= check_typedef (value_type (*argp
));
2550 if (t
->code () != TYPE_CODE_STRUCT
2551 && t
->code () != TYPE_CODE_UNION
)
2552 error (_("Attempt to extract a component of a "
2553 "value that is not a struct or union"));
2555 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2557 /* Clear the lists. */
2561 find_method_list (argp
, method
, 0, t
, methods
, xmethods
,
2565 /* Given an array of arguments (ARGS) (which includes an entry for
2566 "this" in the case of C++ methods), the NAME of a function, and
2567 whether it's a method or not (METHOD), find the best function that
2568 matches on the argument types according to the overload resolution
2571 METHOD can be one of three values:
2572 NON_METHOD for non-member functions.
2573 METHOD: for member functions.
2574 BOTH: used for overload resolution of operators where the
2575 candidates are expected to be either member or non member
2576 functions. In this case the first argument ARGTYPES
2577 (representing 'this') is expected to be a reference to the
2578 target object, and will be dereferenced when attempting the
2581 In the case of class methods, the parameter OBJ is an object value
2582 in which to search for overloaded methods.
2584 In the case of non-method functions, the parameter FSYM is a symbol
2585 corresponding to one of the overloaded functions.
2587 Return value is an integer: 0 -> good match, 10 -> debugger applied
2588 non-standard coercions, 100 -> incompatible.
2590 If a method is being searched for, VALP will hold the value.
2591 If a non-method is being searched for, SYMP will hold the symbol
2594 If a method is being searched for, and it is a static method,
2595 then STATICP will point to a non-zero value.
2597 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2598 ADL overload candidates when performing overload resolution for a fully
2601 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2602 read while picking the best overload match (it may be all zeroes and thus
2603 not have a vtable pointer), in which case skip virtual function lookup.
2604 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2607 Note: This function does *not* check the value of
2608 overload_resolution. Caller must check it to see whether overload
2609 resolution is permitted. */
2612 find_overload_match (gdb::array_view
<value
*> args
,
2613 const char *name
, enum oload_search_type method
,
2614 struct value
**objp
, struct symbol
*fsym
,
2615 struct value
**valp
, struct symbol
**symp
,
2616 int *staticp
, const int no_adl
,
2617 const enum noside noside
)
2619 struct value
*obj
= (objp
? *objp
: NULL
);
2620 struct type
*obj_type
= obj
? value_type (obj
) : NULL
;
2621 /* Index of best overloaded function. */
2622 int func_oload_champ
= -1;
2623 int method_oload_champ
= -1;
2624 int src_method_oload_champ
= -1;
2625 int ext_method_oload_champ
= -1;
2627 /* The measure for the current best match. */
2628 badness_vector method_badness
;
2629 badness_vector func_badness
;
2630 badness_vector ext_method_badness
;
2631 badness_vector src_method_badness
;
2633 struct value
*temp
= obj
;
2634 /* For methods, the list of overloaded methods. */
2635 gdb::array_view
<fn_field
> methods
;
2636 /* For non-methods, the list of overloaded function symbols. */
2637 std::vector
<symbol
*> functions
;
2638 /* For xmethods, the vector of xmethod workers. */
2639 std::vector
<xmethod_worker_up
> xmethods
;
2640 struct type
*basetype
= NULL
;
2643 const char *obj_type_name
= NULL
;
2644 const char *func_name
= NULL
;
2645 gdb::unique_xmalloc_ptr
<char> temp_func
;
2646 enum oload_classification match_quality
;
2647 enum oload_classification method_match_quality
= INCOMPATIBLE
;
2648 enum oload_classification src_method_match_quality
= INCOMPATIBLE
;
2649 enum oload_classification ext_method_match_quality
= INCOMPATIBLE
;
2650 enum oload_classification func_match_quality
= INCOMPATIBLE
;
2652 /* Get the list of overloaded methods or functions. */
2653 if (method
== METHOD
|| method
== BOTH
)
2657 /* OBJ may be a pointer value rather than the object itself. */
2658 obj
= coerce_ref (obj
);
2659 while (check_typedef (value_type (obj
))->code () == TYPE_CODE_PTR
)
2660 obj
= coerce_ref (value_ind (obj
));
2661 obj_type_name
= value_type (obj
)->name ();
2663 /* First check whether this is a data member, e.g. a pointer to
2665 if (check_typedef (value_type (obj
))->code () == TYPE_CODE_STRUCT
)
2667 *valp
= search_struct_field (name
, obj
,
2668 check_typedef (value_type (obj
)), 0);
2676 /* Retrieve the list of methods with the name NAME. */
2677 value_find_oload_method_list (&temp
, name
, 0, &methods
,
2678 &xmethods
, &basetype
, &boffset
);
2679 /* If this is a method only search, and no methods were found
2680 the search has failed. */
2681 if (method
== METHOD
&& methods
.empty () && xmethods
.empty ())
2682 error (_("Couldn't find method %s%s%s"),
2684 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2686 /* If we are dealing with stub method types, they should have
2687 been resolved by find_method_list via
2688 value_find_oload_method_list above. */
2689 if (!methods
.empty ())
2691 gdb_assert (TYPE_SELF_TYPE (methods
[0].type
) != NULL
);
2693 src_method_oload_champ
2694 = find_oload_champ (args
,
2696 methods
.data (), NULL
, NULL
,
2697 &src_method_badness
);
2699 src_method_match_quality
= classify_oload_match
2700 (src_method_badness
, args
.size (),
2701 oload_method_static_p (methods
.data (), src_method_oload_champ
));
2704 if (!xmethods
.empty ())
2706 ext_method_oload_champ
2707 = find_oload_champ (args
,
2709 NULL
, xmethods
.data (), NULL
,
2710 &ext_method_badness
);
2711 ext_method_match_quality
= classify_oload_match (ext_method_badness
,
2715 if (src_method_oload_champ
>= 0 && ext_method_oload_champ
>= 0)
2717 switch (compare_badness (ext_method_badness
, src_method_badness
))
2719 case 0: /* Src method and xmethod are equally good. */
2720 /* If src method and xmethod are equally good, then
2721 xmethod should be the winner. Hence, fall through to the
2722 case where a xmethod is better than the source
2723 method, except when the xmethod match quality is
2726 case 1: /* Src method and ext method are incompatible. */
2727 /* If ext method match is not standard, then let source method
2728 win. Otherwise, fallthrough to let xmethod win. */
2729 if (ext_method_match_quality
!= STANDARD
)
2731 method_oload_champ
= src_method_oload_champ
;
2732 method_badness
= src_method_badness
;
2733 ext_method_oload_champ
= -1;
2734 method_match_quality
= src_method_match_quality
;
2738 case 2: /* Ext method is champion. */
2739 method_oload_champ
= ext_method_oload_champ
;
2740 method_badness
= ext_method_badness
;
2741 src_method_oload_champ
= -1;
2742 method_match_quality
= ext_method_match_quality
;
2744 case 3: /* Src method is champion. */
2745 method_oload_champ
= src_method_oload_champ
;
2746 method_badness
= src_method_badness
;
2747 ext_method_oload_champ
= -1;
2748 method_match_quality
= src_method_match_quality
;
2751 gdb_assert_not_reached ("Unexpected overload comparison "
2756 else if (src_method_oload_champ
>= 0)
2758 method_oload_champ
= src_method_oload_champ
;
2759 method_badness
= src_method_badness
;
2760 method_match_quality
= src_method_match_quality
;
2762 else if (ext_method_oload_champ
>= 0)
2764 method_oload_champ
= ext_method_oload_champ
;
2765 method_badness
= ext_method_badness
;
2766 method_match_quality
= ext_method_match_quality
;
2770 if (method
== NON_METHOD
|| method
== BOTH
)
2772 const char *qualified_name
= NULL
;
2774 /* If the overload match is being search for both as a method
2775 and non member function, the first argument must now be
2778 args
[0] = value_ind (args
[0]);
2782 qualified_name
= fsym
->natural_name ();
2784 /* If we have a function with a C++ name, try to extract just
2785 the function part. Do not try this for non-functions (e.g.
2786 function pointers). */
2788 && (check_typedef (SYMBOL_TYPE (fsym
))->code ()
2791 temp_func
= cp_func_name (qualified_name
);
2793 /* If cp_func_name did not remove anything, the name of the
2794 symbol did not include scope or argument types - it was
2795 probably a C-style function. */
2796 if (temp_func
!= nullptr)
2798 if (strcmp (temp_func
.get (), qualified_name
) == 0)
2801 func_name
= temp_func
.get ();
2808 qualified_name
= name
;
2811 /* If there was no C++ name, this must be a C-style function or
2812 not a function at all. Just return the same symbol. Do the
2813 same if cp_func_name fails for some reason. */
2814 if (func_name
== NULL
)
2820 func_oload_champ
= find_oload_champ_namespace (args
,
2827 if (func_oload_champ
>= 0)
2828 func_match_quality
= classify_oload_match (func_badness
,
2832 /* Did we find a match ? */
2833 if (method_oload_champ
== -1 && func_oload_champ
== -1)
2834 throw_error (NOT_FOUND_ERROR
,
2835 _("No symbol \"%s\" in current context."),
2838 /* If we have found both a method match and a function
2839 match, find out which one is better, and calculate match
2841 if (method_oload_champ
>= 0 && func_oload_champ
>= 0)
2843 switch (compare_badness (func_badness
, method_badness
))
2845 case 0: /* Top two contenders are equally good. */
2846 /* FIXME: GDB does not support the general ambiguous case.
2847 All candidates should be collected and presented the
2849 error (_("Ambiguous overload resolution"));
2851 case 1: /* Incomparable top contenders. */
2852 /* This is an error incompatible candidates
2853 should not have been proposed. */
2854 error (_("Internal error: incompatible "
2855 "overload candidates proposed"));
2857 case 2: /* Function champion. */
2858 method_oload_champ
= -1;
2859 match_quality
= func_match_quality
;
2861 case 3: /* Method champion. */
2862 func_oload_champ
= -1;
2863 match_quality
= method_match_quality
;
2866 error (_("Internal error: unexpected overload comparison result"));
2872 /* We have either a method match or a function match. */
2873 if (method_oload_champ
>= 0)
2874 match_quality
= method_match_quality
;
2876 match_quality
= func_match_quality
;
2879 if (match_quality
== INCOMPATIBLE
)
2881 if (method
== METHOD
)
2882 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2884 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2887 error (_("Cannot resolve function %s to any overloaded instance"),
2890 else if (match_quality
== NON_STANDARD
)
2892 if (method
== METHOD
)
2893 warning (_("Using non-standard conversion to match "
2894 "method %s%s%s to supplied arguments"),
2896 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2899 warning (_("Using non-standard conversion to match "
2900 "function %s to supplied arguments"),
2904 if (staticp
!= NULL
)
2905 *staticp
= oload_method_static_p (methods
.data (), method_oload_champ
);
2907 if (method_oload_champ
>= 0)
2909 if (src_method_oload_champ
>= 0)
2911 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, method_oload_champ
)
2912 && noside
!= EVAL_AVOID_SIDE_EFFECTS
)
2914 *valp
= value_virtual_fn_field (&temp
, methods
.data (),
2915 method_oload_champ
, basetype
,
2919 *valp
= value_fn_field (&temp
, methods
.data (),
2920 method_oload_champ
, basetype
, boffset
);
2923 *valp
= value_from_xmethod
2924 (std::move (xmethods
[ext_method_oload_champ
]));
2927 *symp
= functions
[func_oload_champ
];
2931 struct type
*temp_type
= check_typedef (value_type (temp
));
2932 struct type
*objtype
= check_typedef (obj_type
);
2934 if (temp_type
->code () != TYPE_CODE_PTR
2935 && (objtype
->code () == TYPE_CODE_PTR
2936 || TYPE_IS_REFERENCE (objtype
)))
2938 temp
= value_addr (temp
);
2943 switch (match_quality
)
2949 default: /* STANDARD */
2954 /* Find the best overload match, searching for FUNC_NAME in namespaces
2955 contained in QUALIFIED_NAME until it either finds a good match or
2956 runs out of namespaces. It stores the overloaded functions in
2957 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
2958 argument dependent lookup is not performed. */
2961 find_oload_champ_namespace (gdb::array_view
<value
*> args
,
2962 const char *func_name
,
2963 const char *qualified_name
,
2964 std::vector
<symbol
*> *oload_syms
,
2965 badness_vector
*oload_champ_bv
,
2970 find_oload_champ_namespace_loop (args
,
2973 oload_syms
, oload_champ_bv
,
2980 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2981 how deep we've looked for namespaces, and the champ is stored in
2982 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2983 if it isn't. Other arguments are the same as in
2984 find_oload_champ_namespace. */
2987 find_oload_champ_namespace_loop (gdb::array_view
<value
*> args
,
2988 const char *func_name
,
2989 const char *qualified_name
,
2991 std::vector
<symbol
*> *oload_syms
,
2992 badness_vector
*oload_champ_bv
,
2996 int next_namespace_len
= namespace_len
;
2997 int searched_deeper
= 0;
2998 int new_oload_champ
;
2999 char *new_namespace
;
3001 if (next_namespace_len
!= 0)
3003 gdb_assert (qualified_name
[next_namespace_len
] == ':');
3004 next_namespace_len
+= 2;
3006 next_namespace_len
+=
3007 cp_find_first_component (qualified_name
+ next_namespace_len
);
3009 /* First, see if we have a deeper namespace we can search in.
3010 If we get a good match there, use it. */
3012 if (qualified_name
[next_namespace_len
] == ':')
3014 searched_deeper
= 1;
3016 if (find_oload_champ_namespace_loop (args
,
3017 func_name
, qualified_name
,
3019 oload_syms
, oload_champ_bv
,
3020 oload_champ
, no_adl
))
3026 /* If we reach here, either we're in the deepest namespace or we
3027 didn't find a good match in a deeper namespace. But, in the
3028 latter case, we still have a bad match in a deeper namespace;
3029 note that we might not find any match at all in the current
3030 namespace. (There's always a match in the deepest namespace,
3031 because this overload mechanism only gets called if there's a
3032 function symbol to start off with.) */
3034 new_namespace
= (char *) alloca (namespace_len
+ 1);
3035 strncpy (new_namespace
, qualified_name
, namespace_len
);
3036 new_namespace
[namespace_len
] = '\0';
3038 std::vector
<symbol
*> new_oload_syms
3039 = make_symbol_overload_list (func_name
, new_namespace
);
3041 /* If we have reached the deepest level perform argument
3042 determined lookup. */
3043 if (!searched_deeper
&& !no_adl
)
3046 struct type
**arg_types
;
3048 /* Prepare list of argument types for overload resolution. */
3049 arg_types
= (struct type
**)
3050 alloca (args
.size () * (sizeof (struct type
*)));
3051 for (ix
= 0; ix
< args
.size (); ix
++)
3052 arg_types
[ix
] = value_type (args
[ix
]);
3053 add_symbol_overload_list_adl ({arg_types
, args
.size ()}, func_name
,
3057 badness_vector new_oload_champ_bv
;
3058 new_oload_champ
= find_oload_champ (args
,
3059 new_oload_syms
.size (),
3060 NULL
, NULL
, new_oload_syms
.data (),
3061 &new_oload_champ_bv
);
3063 /* Case 1: We found a good match. Free earlier matches (if any),
3064 and return it. Case 2: We didn't find a good match, but we're
3065 not the deepest function. Then go with the bad match that the
3066 deeper function found. Case 3: We found a bad match, and we're
3067 the deepest function. Then return what we found, even though
3068 it's a bad match. */
3070 if (new_oload_champ
!= -1
3071 && classify_oload_match (new_oload_champ_bv
, args
.size (), 0) == STANDARD
)
3073 *oload_syms
= std::move (new_oload_syms
);
3074 *oload_champ
= new_oload_champ
;
3075 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3078 else if (searched_deeper
)
3084 *oload_syms
= std::move (new_oload_syms
);
3085 *oload_champ
= new_oload_champ
;
3086 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3091 /* Look for a function to take ARGS. Find the best match from among
3092 the overloaded methods or functions given by METHODS or FUNCTIONS
3093 or XMETHODS, respectively. One, and only one of METHODS, FUNCTIONS
3094 and XMETHODS can be non-NULL.
3096 NUM_FNS is the length of the array pointed at by METHODS, FUNCTIONS
3097 or XMETHODS, whichever is non-NULL.
3099 Return the index of the best match; store an indication of the
3100 quality of the match in OLOAD_CHAMP_BV. */
3103 find_oload_champ (gdb::array_view
<value
*> args
,
3106 xmethod_worker_up
*xmethods
,
3108 badness_vector
*oload_champ_bv
)
3110 /* A measure of how good an overloaded instance is. */
3112 /* Index of best overloaded function. */
3113 int oload_champ
= -1;
3114 /* Current ambiguity state for overload resolution. */
3115 int oload_ambiguous
= 0;
3116 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3118 /* A champion can be found among methods alone, or among functions
3119 alone, or in xmethods alone, but not in more than one of these
3121 gdb_assert ((methods
!= NULL
) + (functions
!= NULL
) + (xmethods
!= NULL
)
3124 /* Consider each candidate in turn. */
3125 for (size_t ix
= 0; ix
< num_fns
; ix
++)
3128 int static_offset
= 0;
3129 std::vector
<type
*> parm_types
;
3131 if (xmethods
!= NULL
)
3132 parm_types
= xmethods
[ix
]->get_arg_types ();
3137 if (methods
!= NULL
)
3139 nparms
= TYPE_FN_FIELD_TYPE (methods
, ix
)->num_fields ();
3140 static_offset
= oload_method_static_p (methods
, ix
);
3143 nparms
= SYMBOL_TYPE (functions
[ix
])->num_fields ();
3145 parm_types
.reserve (nparms
);
3146 for (jj
= 0; jj
< nparms
; jj
++)
3148 type
*t
= (methods
!= NULL
3149 ? (TYPE_FN_FIELD_ARGS (methods
, ix
)[jj
].type ())
3150 : SYMBOL_TYPE (functions
[ix
])->field (jj
).type ());
3151 parm_types
.push_back (t
);
3155 /* Compare parameter types to supplied argument types. Skip
3156 THIS for static methods. */
3157 bv
= rank_function (parm_types
,
3158 args
.slice (static_offset
));
3162 if (methods
!= NULL
)
3163 fprintf_filtered (gdb_stderr
,
3164 "Overloaded method instance %s, # of parms %d\n",
3165 methods
[ix
].physname
, (int) parm_types
.size ());
3166 else if (xmethods
!= NULL
)
3167 fprintf_filtered (gdb_stderr
,
3168 "Xmethod worker, # of parms %d\n",
3169 (int) parm_types
.size ());
3171 fprintf_filtered (gdb_stderr
,
3172 "Overloaded function instance "
3173 "%s # of parms %d\n",
3174 functions
[ix
]->demangled_name (),
3175 (int) parm_types
.size ());
3177 fprintf_filtered (gdb_stderr
,
3178 "...Badness of length : {%d, %d}\n",
3179 bv
[0].rank
, bv
[0].subrank
);
3181 for (jj
= 1; jj
< bv
.size (); jj
++)
3182 fprintf_filtered (gdb_stderr
,
3183 "...Badness of arg %d : {%d, %d}\n",
3184 jj
, bv
[jj
].rank
, bv
[jj
].subrank
);
3187 if (oload_champ_bv
->empty ())
3189 *oload_champ_bv
= std::move (bv
);
3192 else /* See whether current candidate is better or worse than
3194 switch (compare_badness (bv
, *oload_champ_bv
))
3196 case 0: /* Top two contenders are equally good. */
3197 oload_ambiguous
= 1;
3199 case 1: /* Incomparable top contenders. */
3200 oload_ambiguous
= 2;
3202 case 2: /* New champion, record details. */
3203 *oload_champ_bv
= std::move (bv
);
3204 oload_ambiguous
= 0;
3212 fprintf_filtered (gdb_stderr
, "Overload resolution "
3213 "champion is %d, ambiguous? %d\n",
3214 oload_champ
, oload_ambiguous
);
3220 /* Return 1 if we're looking at a static method, 0 if we're looking at
3221 a non-static method or a function that isn't a method. */
3224 oload_method_static_p (struct fn_field
*fns_ptr
, int index
)
3226 if (fns_ptr
&& index
>= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
3232 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3234 static enum oload_classification
3235 classify_oload_match (const badness_vector
&oload_champ_bv
,
3240 enum oload_classification worst
= STANDARD
;
3242 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
3244 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3245 or worse return INCOMPATIBLE. */
3246 if (compare_ranks (oload_champ_bv
[ix
],
3247 INCOMPATIBLE_TYPE_BADNESS
) <= 0)
3248 return INCOMPATIBLE
; /* Truly mismatched types. */
3249 /* Otherwise If this conversion is as bad as
3250 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3251 else if (compare_ranks (oload_champ_bv
[ix
],
3252 NS_POINTER_CONVERSION_BADNESS
) <= 0)
3253 worst
= NON_STANDARD
; /* Non-standard type conversions
3257 /* If no INCOMPATIBLE classification was found, return the worst one
3258 that was found (if any). */
3262 /* C++: return 1 is NAME is a legitimate name for the destructor of
3263 type TYPE. If TYPE does not have a destructor, or if NAME is
3264 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3265 have CHECK_TYPEDEF applied, this function will apply it itself. */
3268 destructor_name_p (const char *name
, struct type
*type
)
3272 const char *dname
= type_name_or_error (type
);
3273 const char *cp
= strchr (dname
, '<');
3276 /* Do not compare the template part for template classes. */
3278 len
= strlen (dname
);
3281 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
3282 error (_("name of destructor must equal name of class"));
3289 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3290 class". If the name is found, return a value representing it;
3291 otherwise throw an exception. */
3293 static struct value
*
3294 enum_constant_from_type (struct type
*type
, const char *name
)
3297 int name_len
= strlen (name
);
3299 gdb_assert (type
->code () == TYPE_CODE_ENUM
3300 && TYPE_DECLARED_CLASS (type
));
3302 for (i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); ++i
)
3304 const char *fname
= TYPE_FIELD_NAME (type
, i
);
3307 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_ENUMVAL
3311 /* Look for the trailing "::NAME", since enum class constant
3312 names are qualified here. */
3313 len
= strlen (fname
);
3314 if (len
+ 2 >= name_len
3315 && fname
[len
- name_len
- 2] == ':'
3316 && fname
[len
- name_len
- 1] == ':'
3317 && strcmp (&fname
[len
- name_len
], name
) == 0)
3318 return value_from_longest (type
, TYPE_FIELD_ENUMVAL (type
, i
));
3321 error (_("no constant named \"%s\" in enum \"%s\""),
3322 name
, type
->name ());
3325 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3326 return the appropriate member (or the address of the member, if
3327 WANT_ADDRESS). This function is used to resolve user expressions
3328 of the form "DOMAIN::NAME". For more details on what happens, see
3329 the comment before value_struct_elt_for_reference. */
3332 value_aggregate_elt (struct type
*curtype
, const char *name
,
3333 struct type
*expect_type
, int want_address
,
3336 switch (curtype
->code ())
3338 case TYPE_CODE_STRUCT
:
3339 case TYPE_CODE_UNION
:
3340 return value_struct_elt_for_reference (curtype
, 0, curtype
,
3342 want_address
, noside
);
3343 case TYPE_CODE_NAMESPACE
:
3344 return value_namespace_elt (curtype
, name
,
3345 want_address
, noside
);
3347 case TYPE_CODE_ENUM
:
3348 return enum_constant_from_type (curtype
, name
);
3351 internal_error (__FILE__
, __LINE__
,
3352 _("non-aggregate type in value_aggregate_elt"));
3356 /* Compares the two method/function types T1 and T2 for "equality"
3357 with respect to the methods' parameters. If the types of the
3358 two parameter lists are the same, returns 1; 0 otherwise. This
3359 comparison may ignore any artificial parameters in T1 if
3360 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3361 the first artificial parameter in T1, assumed to be a 'this' pointer.
3363 The type T2 is expected to have come from make_params (in eval.c). */
3366 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
3370 if (t1
->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1
, 0))
3373 /* If skipping artificial fields, find the first real field
3375 if (skip_artificial
)
3377 while (start
< t1
->num_fields ()
3378 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
3382 /* Now compare parameters. */
3384 /* Special case: a method taking void. T1 will contain no
3385 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3386 if ((t1
->num_fields () - start
) == 0 && t2
->num_fields () == 1
3387 && t2
->field (0).type ()->code () == TYPE_CODE_VOID
)
3390 if ((t1
->num_fields () - start
) == t2
->num_fields ())
3394 for (i
= 0; i
< t2
->num_fields (); ++i
)
3396 if (compare_ranks (rank_one_type (t1
->field (start
+ i
).type (),
3397 t2
->field (i
).type (), NULL
),
3398 EXACT_MATCH_BADNESS
) != 0)
3408 /* C++: Given an aggregate type VT, and a class type CLS, search
3409 recursively for CLS using value V; If found, store the offset
3410 which is either fetched from the virtual base pointer if CLS
3411 is virtual or accumulated offset of its parent classes if
3412 CLS is non-virtual in *BOFFS, set ISVIRT to indicate if CLS
3413 is virtual, and return true. If not found, return false. */
3416 get_baseclass_offset (struct type
*vt
, struct type
*cls
,
3417 struct value
*v
, int *boffs
, bool *isvirt
)
3419 for (int i
= 0; i
< TYPE_N_BASECLASSES (vt
); i
++)
3421 struct type
*t
= vt
->field (i
).type ();
3422 if (types_equal (t
, cls
))
3424 if (BASETYPE_VIA_VIRTUAL (vt
, i
))
3426 const gdb_byte
*adr
= value_contents_for_printing (v
);
3427 *boffs
= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3428 value_as_long (v
), v
);
3436 if (get_baseclass_offset (check_typedef (t
), cls
, v
, boffs
, isvirt
))
3438 if (*isvirt
== false) /* Add non-virtual base offset. */
3440 const gdb_byte
*adr
= value_contents_for_printing (v
);
3441 *boffs
+= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3442 value_as_long (v
), v
);
3451 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3452 return the address of this member as a "pointer to member" type.
3453 If INTYPE is non-null, then it will be the type of the member we
3454 are looking for. This will help us resolve "pointers to member
3455 functions". This function is used to resolve user expressions of
3456 the form "DOMAIN::NAME". */
3458 static struct value
*
3459 value_struct_elt_for_reference (struct type
*domain
, int offset
,
3460 struct type
*curtype
, const char *name
,
3461 struct type
*intype
,
3465 struct type
*t
= check_typedef (curtype
);
3467 struct value
*result
;
3469 if (t
->code () != TYPE_CODE_STRUCT
3470 && t
->code () != TYPE_CODE_UNION
)
3471 error (_("Internal error: non-aggregate type "
3472 "to value_struct_elt_for_reference"));
3474 for (i
= t
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3476 const char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
3478 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3480 if (field_is_static (&t
->field (i
)))
3482 struct value
*v
= value_static_field (t
, i
);
3487 if (TYPE_FIELD_PACKED (t
, i
))
3488 error (_("pointers to bitfield members not allowed"));
3491 return value_from_longest
3492 (lookup_memberptr_type (t
->field (i
).type (), domain
),
3493 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
3494 else if (noside
!= EVAL_NORMAL
)
3495 return allocate_value (t
->field (i
).type ());
3498 /* Try to evaluate NAME as a qualified name with implicit
3499 this pointer. In this case, attempt to return the
3500 equivalent to `this->*(&TYPE::NAME)'. */
3501 struct value
*v
= value_of_this_silent (current_language
);
3504 struct value
*ptr
, *this_v
= v
;
3506 struct type
*type
, *tmp
;
3508 ptr
= value_aggregate_elt (domain
, name
, NULL
, 1, noside
);
3509 type
= check_typedef (value_type (ptr
));
3510 gdb_assert (type
!= NULL
3511 && type
->code () == TYPE_CODE_MEMBERPTR
);
3512 tmp
= lookup_pointer_type (TYPE_SELF_TYPE (type
));
3513 v
= value_cast_pointers (tmp
, v
, 1);
3514 mem_offset
= value_as_long (ptr
);
3515 if (domain
!= curtype
)
3517 /* Find class offset of type CURTYPE from either its
3518 parent type DOMAIN or the type of implied this. */
3520 bool isvirt
= false;
3521 if (get_baseclass_offset (domain
, curtype
, v
, &boff
,
3526 struct type
*p
= check_typedef (value_type (this_v
));
3527 p
= check_typedef (TYPE_TARGET_TYPE (p
));
3528 if (get_baseclass_offset (p
, curtype
, this_v
,
3533 tmp
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
3534 result
= value_from_pointer (tmp
,
3535 value_as_long (v
) + mem_offset
);
3536 return value_ind (result
);
3539 error (_("Cannot reference non-static field \"%s\""), name
);
3544 /* C++: If it was not found as a data field, then try to return it
3545 as a pointer to a method. */
3547 /* Perform all necessary dereferencing. */
3548 while (intype
&& intype
->code () == TYPE_CODE_PTR
)
3549 intype
= TYPE_TARGET_TYPE (intype
);
3551 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3553 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3555 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3558 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3559 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3561 check_stub_method_group (t
, i
);
3565 for (j
= 0; j
< len
; ++j
)
3567 if (TYPE_CONST (intype
) != TYPE_FN_FIELD_CONST (f
, j
))
3569 if (TYPE_VOLATILE (intype
) != TYPE_FN_FIELD_VOLATILE (f
, j
))
3572 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3573 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
),
3579 error (_("no member function matches "
3580 "that type instantiation"));
3587 for (ii
= 0; ii
< len
; ++ii
)
3589 /* Skip artificial methods. This is necessary if,
3590 for example, the user wants to "print
3591 subclass::subclass" with only one user-defined
3592 constructor. There is no ambiguity in this case.
3593 We are careful here to allow artificial methods
3594 if they are the unique result. */
3595 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3602 /* Desired method is ambiguous if more than one
3603 method is defined. */
3604 if (j
!= -1 && !TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
3605 error (_("non-unique member `%s' requires "
3606 "type instantiation"), name
);
3612 error (_("no matching member function"));
3615 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3618 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3619 0, VAR_DOMAIN
, 0).symbol
;
3625 return value_addr (read_var_value (s
, 0, 0));
3627 return read_var_value (s
, 0, 0);
3630 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3634 result
= allocate_value
3635 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3636 cplus_make_method_ptr (value_type (result
),
3637 value_contents_writeable (result
),
3638 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3640 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3641 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3643 error (_("Cannot reference virtual member function \"%s\""),
3649 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3650 0, VAR_DOMAIN
, 0).symbol
;
3655 struct value
*v
= read_var_value (s
, 0, 0);
3660 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3661 cplus_make_method_ptr (value_type (result
),
3662 value_contents_writeable (result
),
3663 value_address (v
), 0);
3669 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3674 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3677 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3678 v
= value_struct_elt_for_reference (domain
,
3679 offset
+ base_offset
,
3680 TYPE_BASECLASS (t
, i
),
3682 want_address
, noside
);
3687 /* As a last chance, pretend that CURTYPE is a namespace, and look
3688 it up that way; this (frequently) works for types nested inside
3691 return value_maybe_namespace_elt (curtype
, name
,
3692 want_address
, noside
);
3695 /* C++: Return the member NAME of the namespace given by the type
3698 static struct value
*
3699 value_namespace_elt (const struct type
*curtype
,
3700 const char *name
, int want_address
,
3703 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3708 error (_("No symbol \"%s\" in namespace \"%s\"."),
3709 name
, curtype
->name ());
3714 /* A helper function used by value_namespace_elt and
3715 value_struct_elt_for_reference. It looks up NAME inside the
3716 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3717 is a class and NAME refers to a type in CURTYPE itself (as opposed
3718 to, say, some base class of CURTYPE). */
3720 static struct value
*
3721 value_maybe_namespace_elt (const struct type
*curtype
,
3722 const char *name
, int want_address
,
3725 const char *namespace_name
= curtype
->name ();
3726 struct block_symbol sym
;
3727 struct value
*result
;
3729 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3730 get_selected_block (0), VAR_DOMAIN
);
3732 if (sym
.symbol
== NULL
)
3734 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3735 && (SYMBOL_CLASS (sym
.symbol
) == LOC_TYPEDEF
))
3736 result
= allocate_value (SYMBOL_TYPE (sym
.symbol
));
3738 result
= value_of_variable (sym
.symbol
, sym
.block
);
3741 result
= value_addr (result
);
3746 /* Given a pointer or a reference value V, find its real (RTTI) type.
3748 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3749 and refer to the values computed for the object pointed to. */
3752 value_rtti_indirect_type (struct value
*v
, int *full
,
3753 LONGEST
*top
, int *using_enc
)
3755 struct value
*target
= NULL
;
3756 struct type
*type
, *real_type
, *target_type
;
3758 type
= value_type (v
);
3759 type
= check_typedef (type
);
3760 if (TYPE_IS_REFERENCE (type
))
3761 target
= coerce_ref (v
);
3762 else if (type
->code () == TYPE_CODE_PTR
)
3767 target
= value_ind (v
);
3769 catch (const gdb_exception_error
&except
)
3771 if (except
.error
== MEMORY_ERROR
)
3773 /* value_ind threw a memory error. The pointer is NULL or
3774 contains an uninitialized value: we can't determine any
3784 real_type
= value_rtti_type (target
, full
, top
, using_enc
);
3788 /* Copy qualifiers to the referenced object. */
3789 target_type
= value_type (target
);
3790 real_type
= make_cv_type (TYPE_CONST (target_type
),
3791 TYPE_VOLATILE (target_type
), real_type
, NULL
);
3792 if (TYPE_IS_REFERENCE (type
))
3793 real_type
= lookup_reference_type (real_type
, type
->code ());
3794 else if (type
->code () == TYPE_CODE_PTR
)
3795 real_type
= lookup_pointer_type (real_type
);
3797 internal_error (__FILE__
, __LINE__
, _("Unexpected value type."));
3799 /* Copy qualifiers to the pointer/reference. */
3800 real_type
= make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
),
3807 /* Given a value pointed to by ARGP, check its real run-time type, and
3808 if that is different from the enclosing type, create a new value
3809 using the real run-time type as the enclosing type (and of the same
3810 type as ARGP) and return it, with the embedded offset adjusted to
3811 be the correct offset to the enclosed object. RTYPE is the type,
3812 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3813 by value_rtti_type(). If these are available, they can be supplied
3814 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3815 NULL if they're not available. */
3818 value_full_object (struct value
*argp
,
3820 int xfull
, int xtop
,
3823 struct type
*real_type
;
3827 struct value
*new_val
;
3834 using_enc
= xusing_enc
;
3837 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3839 /* If no RTTI data, or if object is already complete, do nothing. */
3840 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3843 /* In a destructor we might see a real type that is a superclass of
3844 the object's type. In this case it is better to leave the object
3847 && TYPE_LENGTH (real_type
) < TYPE_LENGTH (value_enclosing_type (argp
)))
3850 /* If we have the full object, but for some reason the enclosing
3851 type is wrong, set it. */
3852 /* pai: FIXME -- sounds iffy */
3855 argp
= value_copy (argp
);
3856 set_value_enclosing_type (argp
, real_type
);
3860 /* Check if object is in memory. */
3861 if (VALUE_LVAL (argp
) != lval_memory
)
3863 warning (_("Couldn't retrieve complete object of RTTI "
3864 "type %s; object may be in register(s)."),
3865 real_type
->name ());
3870 /* All other cases -- retrieve the complete object. */
3871 /* Go back by the computed top_offset from the beginning of the
3872 object, adjusting for the embedded offset of argp if that's what
3873 value_rtti_type used for its computation. */
3874 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3875 (using_enc
? 0 : value_embedded_offset (argp
)));
3876 deprecated_set_value_type (new_val
, value_type (argp
));
3877 set_value_embedded_offset (new_val
, (using_enc
3878 ? top
+ value_embedded_offset (argp
)
3884 /* Return the value of the local variable, if one exists. Throw error
3885 otherwise, such as if the request is made in an inappropriate context. */
3888 value_of_this (const struct language_defn
*lang
)
3890 struct block_symbol sym
;
3891 const struct block
*b
;
3892 struct frame_info
*frame
;
3894 if (lang
->name_of_this () == NULL
)
3895 error (_("no `this' in current language"));
3897 frame
= get_selected_frame (_("no frame selected"));
3899 b
= get_frame_block (frame
, NULL
);
3901 sym
= lookup_language_this (lang
, b
);
3902 if (sym
.symbol
== NULL
)
3903 error (_("current stack frame does not contain a variable named `%s'"),
3904 lang
->name_of_this ());
3906 return read_var_value (sym
.symbol
, sym
.block
, frame
);
3909 /* Return the value of the local variable, if one exists. Return NULL
3910 otherwise. Never throw error. */
3913 value_of_this_silent (const struct language_defn
*lang
)
3915 struct value
*ret
= NULL
;
3919 ret
= value_of_this (lang
);
3921 catch (const gdb_exception_error
&except
)
3928 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3929 elements long, starting at LOWBOUND. The result has the same lower
3930 bound as the original ARRAY. */
3933 value_slice (struct value
*array
, int lowbound
, int length
)
3935 struct type
*slice_range_type
, *slice_type
, *range_type
;
3936 LONGEST lowerbound
, upperbound
;
3937 struct value
*slice
;
3938 struct type
*array_type
;
3940 array_type
= check_typedef (value_type (array
));
3941 if (array_type
->code () != TYPE_CODE_ARRAY
3942 && array_type
->code () != TYPE_CODE_STRING
)
3943 error (_("cannot take slice of non-array"));
3945 if (type_not_allocated (array_type
))
3946 error (_("array not allocated"));
3947 if (type_not_associated (array_type
))
3948 error (_("array not associated"));
3950 range_type
= array_type
->index_type ();
3951 if (!get_discrete_bounds (range_type
, &lowerbound
, &upperbound
))
3952 error (_("slice from bad array or bitstring"));
3954 if (lowbound
< lowerbound
|| length
< 0
3955 || lowbound
+ length
- 1 > upperbound
)
3956 error (_("slice out of range"));
3958 /* FIXME-type-allocation: need a way to free this type when we are
3960 slice_range_type
= create_static_range_type (NULL
,
3961 TYPE_TARGET_TYPE (range_type
),
3963 lowbound
+ length
- 1);
3966 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3968 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3970 slice_type
= create_array_type (NULL
,
3973 slice_type
->set_code (array_type
->code ());
3975 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3976 slice
= allocate_value_lazy (slice_type
);
3979 slice
= allocate_value (slice_type
);
3980 value_contents_copy (slice
, 0, array
, offset
,
3981 type_length_units (slice_type
));
3984 set_value_component_location (slice
, array
);
3985 set_value_offset (slice
, value_offset (array
) + offset
);
3994 value_literal_complex (struct value
*arg1
,
3999 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
4001 val
= allocate_value (type
);
4002 arg1
= value_cast (real_type
, arg1
);
4003 arg2
= value_cast (real_type
, arg2
);
4005 memcpy (value_contents_raw (val
),
4006 value_contents (arg1
), TYPE_LENGTH (real_type
));
4007 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
4008 value_contents (arg2
), TYPE_LENGTH (real_type
));
4015 value_real_part (struct value
*value
)
4017 struct type
*type
= check_typedef (value_type (value
));
4018 struct type
*ttype
= TYPE_TARGET_TYPE (type
);
4020 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4021 return value_from_component (value
, ttype
, 0);
4027 value_imaginary_part (struct value
*value
)
4029 struct type
*type
= check_typedef (value_type (value
));
4030 struct type
*ttype
= TYPE_TARGET_TYPE (type
);
4032 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4033 return value_from_component (value
, ttype
,
4034 TYPE_LENGTH (check_typedef (ttype
)));
4037 /* Cast a value into the appropriate complex data type. */
4039 static struct value
*
4040 cast_into_complex (struct type
*type
, struct value
*val
)
4042 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
4044 if (value_type (val
)->code () == TYPE_CODE_COMPLEX
)
4046 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
4047 struct value
*re_val
= allocate_value (val_real_type
);
4048 struct value
*im_val
= allocate_value (val_real_type
);
4050 memcpy (value_contents_raw (re_val
),
4051 value_contents (val
), TYPE_LENGTH (val_real_type
));
4052 memcpy (value_contents_raw (im_val
),
4053 value_contents (val
) + TYPE_LENGTH (val_real_type
),
4054 TYPE_LENGTH (val_real_type
));
4056 return value_literal_complex (re_val
, im_val
, type
);
4058 else if (value_type (val
)->code () == TYPE_CODE_FLT
4059 || value_type (val
)->code () == TYPE_CODE_INT
)
4060 return value_literal_complex (val
,
4061 value_zero (real_type
, not_lval
),
4064 error (_("cannot cast non-number to complex"));
4067 void _initialize_valops ();
4069 _initialize_valops ()
4071 add_setshow_boolean_cmd ("overload-resolution", class_support
,
4072 &overload_resolution
, _("\
4073 Set overload resolution in evaluating C++ functions."), _("\
4074 Show overload resolution in evaluating C++ functions."),
4076 show_overload_resolution
,
4077 &setlist
, &showlist
);
4078 overload_resolution
= 1;