1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986-2022 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 (bool staticp
, bool varargs
, int nargs
,
48 struct field t1
[], const gdb::array_view
<value
*> t2
);
50 static struct value
*search_struct_field (const char *, struct value
*,
53 static struct value
*search_struct_method (const char *, struct value
**,
54 gdb::optional
<gdb::array_view
<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 gdb_printf (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 (sym
.symbol
->aclass () != LOC_BLOCK
)
125 error (_("\"%s\" exists in this program but is not a function."),
130 *objf_p
= sym
.symbol
->objfile ();
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
= msymbol
.value_address ();
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
) + value_embedded_offset (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 (type1
->target_type ());
301 struct type
*t2
= check_typedef (type2
->target_type ());
303 if (t1
->code () == TYPE_CODE_STRUCT
304 && t2
->code () == TYPE_CODE_STRUCT
305 && (subclass_check
|| !value_logical_not (arg2
)))
309 if (TYPE_IS_REFERENCE (type2
))
310 v2
= coerce_ref (arg2
);
312 v2
= value_ind (arg2
);
313 gdb_assert (check_typedef (value_type (v2
))->code ()
314 == TYPE_CODE_STRUCT
&& !!"Why did coercion fail?");
315 v2
= value_cast_structs (t1
, v2
);
316 /* At this point we have what we can have, un-dereference if needed. */
319 struct value
*v
= value_addr (v2
);
321 deprecated_set_value_type (v
, type
);
326 /* No superclass found, just change the pointer type. */
327 arg2
= value_copy (arg2
);
328 deprecated_set_value_type (arg2
, type
);
329 set_value_enclosing_type (arg2
, type
);
330 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
337 value_to_gdb_mpq (struct value
*value
)
339 struct type
*type
= check_typedef (value_type (value
));
342 if (is_floating_type (type
))
344 double d
= target_float_to_host_double (value_contents (value
).data (),
346 mpq_set_d (result
.val
, d
);
350 gdb_assert (is_integral_type (type
)
351 || is_fixed_point_type (type
));
354 vz
.read (value_contents (value
), type_byte_order (type
),
355 type
->is_unsigned ());
356 mpq_set_z (result
.val
, vz
.val
);
358 if (is_fixed_point_type (type
))
359 mpq_mul (result
.val
, result
.val
,
360 type
->fixed_point_scaling_factor ().val
);
366 /* Assuming that TO_TYPE is a fixed point type, return a value
367 corresponding to the cast of FROM_VAL to that type. */
369 static struct value
*
370 value_cast_to_fixed_point (struct type
*to_type
, struct value
*from_val
)
372 struct type
*from_type
= value_type (from_val
);
374 if (from_type
== to_type
)
377 if (!is_floating_type (from_type
)
378 && !is_integral_type (from_type
)
379 && !is_fixed_point_type (from_type
))
380 error (_("Invalid conversion from type %s to fixed point type %s"),
381 from_type
->name (), to_type
->name ());
383 gdb_mpq vq
= value_to_gdb_mpq (from_val
);
385 /* Divide that value by the scaling factor to obtain the unscaled
386 value, first in rational form, and then in integer form. */
388 mpq_div (vq
.val
, vq
.val
, to_type
->fixed_point_scaling_factor ().val
);
389 gdb_mpz unscaled
= vq
.get_rounded ();
391 /* Finally, create the result value, and pack the unscaled value
393 struct value
*result
= allocate_value (to_type
);
394 unscaled
.write (value_contents_raw (result
),
395 type_byte_order (to_type
),
396 to_type
->is_unsigned ());
401 /* Cast value ARG2 to type TYPE and return as a value.
402 More general than a C cast: accepts any two types of the same length,
403 and if ARG2 is an lvalue it can be cast into anything at all. */
404 /* In C++, casts may change pointer or object representations. */
407 value_cast (struct type
*type
, struct value
*arg2
)
409 enum type_code code1
;
410 enum type_code code2
;
414 int convert_to_boolean
= 0;
416 /* TYPE might be equal in meaning to the existing type of ARG2, but for
417 many reasons, might be a different type object (e.g. TYPE might be a
418 gdbarch owned type, while VALUE_TYPE (ARG2) could be an objfile owned
421 In this case we want to preserve the LVAL of ARG2 as this allows the
422 resulting value to be used in more places. We do this by calling
423 VALUE_COPY if appropriate. */
424 if (types_deeply_equal (value_type (arg2
), type
))
426 /* If the types are exactly equal then we can avoid creating a new
428 if (value_type (arg2
) != type
)
430 arg2
= value_copy (arg2
);
431 deprecated_set_value_type (arg2
, type
);
436 if (is_fixed_point_type (type
))
437 return value_cast_to_fixed_point (type
, arg2
);
439 /* Check if we are casting struct reference to struct reference. */
440 if (TYPE_IS_REFERENCE (check_typedef (type
)))
442 /* We dereference type; then we recurse and finally
443 we generate value of the given reference. Nothing wrong with
445 struct type
*t1
= check_typedef (type
);
446 struct type
*dereftype
= check_typedef (t1
->target_type ());
447 struct value
*val
= value_cast (dereftype
, arg2
);
449 return value_ref (val
, t1
->code ());
452 if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2
))))
453 /* We deref the value and then do the cast. */
454 return value_cast (type
, coerce_ref (arg2
));
456 /* Strip typedefs / resolve stubs in order to get at the type's
457 code/length, but remember the original type, to use as the
458 resulting type of the cast, in case it was a typedef. */
459 struct type
*to_type
= type
;
461 type
= check_typedef (type
);
462 code1
= type
->code ();
463 arg2
= coerce_ref (arg2
);
464 type2
= check_typedef (value_type (arg2
));
466 /* You can't cast to a reference type. See value_cast_pointers
468 gdb_assert (!TYPE_IS_REFERENCE (type
));
470 /* A cast to an undetermined-length array_type, such as
471 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
472 where N is sizeof(OBJECT)/sizeof(TYPE). */
473 if (code1
== TYPE_CODE_ARRAY
)
475 struct type
*element_type
= type
->target_type ();
476 unsigned element_length
= check_typedef (element_type
)->length ();
478 if (element_length
> 0 && type
->bounds ()->high
.kind () == PROP_UNDEFINED
)
480 struct type
*range_type
= type
->index_type ();
481 int val_length
= type2
->length ();
482 LONGEST low_bound
, high_bound
, new_length
;
484 if (!get_discrete_bounds (range_type
, &low_bound
, &high_bound
))
485 low_bound
= 0, high_bound
= 0;
486 new_length
= val_length
/ element_length
;
487 if (val_length
% element_length
!= 0)
488 warning (_("array element type size does not "
489 "divide object size in cast"));
490 /* FIXME-type-allocation: need a way to free this type when
491 we are done with it. */
492 range_type
= create_static_range_type (NULL
,
493 range_type
->target_type (),
495 new_length
+ low_bound
- 1);
496 deprecated_set_value_type (arg2
,
497 create_array_type (NULL
,
504 if (current_language
->c_style_arrays_p ()
505 && type2
->code () == TYPE_CODE_ARRAY
506 && !type2
->is_vector ())
507 arg2
= value_coerce_array (arg2
);
509 if (type2
->code () == TYPE_CODE_FUNC
)
510 arg2
= value_coerce_function (arg2
);
512 type2
= check_typedef (value_type (arg2
));
513 code2
= type2
->code ();
515 if (code1
== TYPE_CODE_COMPLEX
)
516 return cast_into_complex (to_type
, arg2
);
517 if (code1
== TYPE_CODE_BOOL
)
519 code1
= TYPE_CODE_INT
;
520 convert_to_boolean
= 1;
522 if (code1
== TYPE_CODE_CHAR
)
523 code1
= TYPE_CODE_INT
;
524 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
525 code2
= TYPE_CODE_INT
;
527 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
528 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
529 || code2
== TYPE_CODE_RANGE
530 || is_fixed_point_type (type2
));
532 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
533 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
534 && type
->name () != 0)
536 struct value
*v
= value_cast_structs (to_type
, arg2
);
542 if (is_floating_type (type
) && scalar
)
544 if (is_floating_value (arg2
))
546 struct value
*v
= allocate_value (to_type
);
547 target_float_convert (value_contents (arg2
).data (), type2
,
548 value_contents_raw (v
).data (), type
);
551 else if (is_fixed_point_type (type2
))
555 fp_val
.read_fixed_point (value_contents (arg2
),
556 type_byte_order (type2
),
557 type2
->is_unsigned (),
558 type2
->fixed_point_scaling_factor ());
560 struct value
*v
= allocate_value (to_type
);
561 target_float_from_host_double (value_contents_raw (v
).data (),
562 to_type
, mpq_get_d (fp_val
.val
));
566 /* The only option left is an integral type. */
567 if (type2
->is_unsigned ())
568 return value_from_ulongest (to_type
, value_as_long (arg2
));
570 return value_from_longest (to_type
, value_as_long (arg2
));
572 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
573 || code1
== TYPE_CODE_RANGE
)
574 && (scalar
|| code2
== TYPE_CODE_PTR
575 || code2
== TYPE_CODE_MEMBERPTR
))
579 /* When we cast pointers to integers, we mustn't use
580 gdbarch_pointer_to_address to find the address the pointer
581 represents, as value_as_long would. GDB should evaluate
582 expressions just as the compiler would --- and the compiler
583 sees a cast as a simple reinterpretation of the pointer's
585 if (code2
== TYPE_CODE_PTR
)
586 longest
= extract_unsigned_integer
587 (value_contents (arg2
), type_byte_order (type2
));
589 longest
= value_as_long (arg2
);
590 return value_from_longest (to_type
, convert_to_boolean
?
591 (LONGEST
) (longest
? 1 : 0) : longest
);
593 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
594 || code2
== TYPE_CODE_ENUM
595 || code2
== TYPE_CODE_RANGE
))
597 /* type->length () is the length of a pointer, but we really
598 want the length of an address! -- we are really dealing with
599 addresses (i.e., gdb representations) not pointers (i.e.,
600 target representations) here.
602 This allows things like "print *(int *)0x01000234" to work
603 without printing a misleading message -- which would
604 otherwise occur when dealing with a target having two byte
605 pointers and four byte addresses. */
607 int addr_bit
= gdbarch_addr_bit (type2
->arch ());
608 LONGEST longest
= value_as_long (arg2
);
610 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
612 if (longest
>= ((LONGEST
) 1 << addr_bit
)
613 || longest
<= -((LONGEST
) 1 << addr_bit
))
614 warning (_("value truncated"));
616 return value_from_longest (to_type
, longest
);
618 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
619 && value_as_long (arg2
) == 0)
621 struct value
*result
= allocate_value (to_type
);
623 cplus_make_method_ptr (to_type
,
624 value_contents_writeable (result
).data (), 0, 0);
627 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
628 && value_as_long (arg2
) == 0)
630 /* The Itanium C++ ABI represents NULL pointers to members as
631 minus one, instead of biasing the normal case. */
632 return value_from_longest (to_type
, -1);
634 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector ()
635 && code2
== TYPE_CODE_ARRAY
&& type2
->is_vector ()
636 && type
->length () != type2
->length ())
637 error (_("Cannot convert between vector values of different sizes"));
638 else if (code1
== TYPE_CODE_ARRAY
&& type
->is_vector () && scalar
639 && type
->length () != type2
->length ())
640 error (_("can only cast scalar to vector of same size"));
641 else if (code1
== TYPE_CODE_VOID
)
643 return value_zero (to_type
, not_lval
);
645 else if (type
->length () == type2
->length ())
647 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
648 return value_cast_pointers (to_type
, arg2
, 0);
650 arg2
= value_copy (arg2
);
651 deprecated_set_value_type (arg2
, to_type
);
652 set_value_enclosing_type (arg2
, to_type
);
653 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
656 else if (VALUE_LVAL (arg2
) == lval_memory
)
657 return value_at_lazy (to_type
, value_address (arg2
));
660 if (current_language
->la_language
== language_ada
)
661 error (_("Invalid type conversion."));
662 error (_("Invalid cast."));
666 /* The C++ reinterpret_cast operator. */
669 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
671 struct value
*result
;
672 struct type
*real_type
= check_typedef (type
);
673 struct type
*arg_type
, *dest_type
;
675 enum type_code dest_code
, arg_code
;
677 /* Do reference, function, and array conversion. */
678 arg
= coerce_array (arg
);
680 /* Attempt to preserve the type the user asked for. */
683 /* If we are casting to a reference type, transform
684 reinterpret_cast<T&[&]>(V) to *reinterpret_cast<T*>(&V). */
685 if (TYPE_IS_REFERENCE (real_type
))
688 arg
= value_addr (arg
);
689 dest_type
= lookup_pointer_type (dest_type
->target_type ());
690 real_type
= lookup_pointer_type (real_type
);
693 arg_type
= value_type (arg
);
695 dest_code
= real_type
->code ();
696 arg_code
= arg_type
->code ();
698 /* We can convert pointer types, or any pointer type to int, or int
700 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
701 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
702 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
703 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
704 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
705 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
706 || (dest_code
== arg_code
707 && (dest_code
== TYPE_CODE_PTR
708 || dest_code
== TYPE_CODE_METHODPTR
709 || dest_code
== TYPE_CODE_MEMBERPTR
)))
710 result
= value_cast (dest_type
, arg
);
712 error (_("Invalid reinterpret_cast"));
715 result
= value_cast (type
, value_ref (value_ind (result
),
721 /* A helper for value_dynamic_cast. This implements the first of two
722 runtime checks: we iterate over all the base classes of the value's
723 class which are equal to the desired class; if only one of these
724 holds the value, then it is the answer. */
727 dynamic_cast_check_1 (struct type
*desired_type
,
728 const gdb_byte
*valaddr
,
729 LONGEST embedded_offset
,
732 struct type
*search_type
,
734 struct type
*arg_type
,
735 struct value
**result
)
737 int i
, result_count
= 0;
739 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
741 LONGEST offset
= baseclass_offset (search_type
, i
, valaddr
,
745 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
747 if (address
+ embedded_offset
+ offset
>= arg_addr
748 && address
+ embedded_offset
+ offset
< arg_addr
+ arg_type
->length ())
752 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
753 address
+ embedded_offset
+ offset
);
757 result_count
+= dynamic_cast_check_1 (desired_type
,
759 embedded_offset
+ offset
,
761 TYPE_BASECLASS (search_type
, i
),
770 /* A helper for value_dynamic_cast. This implements the second of two
771 runtime checks: we look for a unique public sibling class of the
772 argument's declared class. */
775 dynamic_cast_check_2 (struct type
*desired_type
,
776 const gdb_byte
*valaddr
,
777 LONGEST embedded_offset
,
780 struct type
*search_type
,
781 struct value
**result
)
783 int i
, result_count
= 0;
785 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
789 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
792 offset
= baseclass_offset (search_type
, i
, valaddr
, embedded_offset
,
794 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
798 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
799 address
+ embedded_offset
+ offset
);
802 result_count
+= dynamic_cast_check_2 (desired_type
,
804 embedded_offset
+ offset
,
806 TYPE_BASECLASS (search_type
, i
),
813 /* The C++ dynamic_cast operator. */
816 value_dynamic_cast (struct type
*type
, struct value
*arg
)
820 struct type
*resolved_type
= check_typedef (type
);
821 struct type
*arg_type
= check_typedef (value_type (arg
));
822 struct type
*class_type
, *rtti_type
;
823 struct value
*result
, *tem
, *original_arg
= arg
;
825 int is_ref
= TYPE_IS_REFERENCE (resolved_type
);
827 if (resolved_type
->code () != TYPE_CODE_PTR
828 && !TYPE_IS_REFERENCE (resolved_type
))
829 error (_("Argument to dynamic_cast must be a pointer or reference type"));
830 if (resolved_type
->target_type ()->code () != TYPE_CODE_VOID
831 && resolved_type
->target_type ()->code () != TYPE_CODE_STRUCT
)
832 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
834 class_type
= check_typedef (resolved_type
->target_type ());
835 if (resolved_type
->code () == TYPE_CODE_PTR
)
837 if (arg_type
->code () != TYPE_CODE_PTR
838 && ! (arg_type
->code () == TYPE_CODE_INT
839 && value_as_long (arg
) == 0))
840 error (_("Argument to dynamic_cast does not have pointer type"));
841 if (arg_type
->code () == TYPE_CODE_PTR
)
843 arg_type
= check_typedef (arg_type
->target_type ());
844 if (arg_type
->code () != TYPE_CODE_STRUCT
)
845 error (_("Argument to dynamic_cast does "
846 "not have pointer to class type"));
849 /* Handle NULL pointers. */
850 if (value_as_long (arg
) == 0)
851 return value_zero (type
, not_lval
);
853 arg
= value_ind (arg
);
857 if (arg_type
->code () != TYPE_CODE_STRUCT
)
858 error (_("Argument to dynamic_cast does not have class type"));
861 /* If the classes are the same, just return the argument. */
862 if (class_types_same_p (class_type
, arg_type
))
863 return value_cast (type
, arg
);
865 /* If the target type is a unique base class of the argument's
866 declared type, just cast it. */
867 if (is_ancestor (class_type
, arg_type
))
869 if (is_unique_ancestor (class_type
, arg
))
870 return value_cast (type
, original_arg
);
871 error (_("Ambiguous dynamic_cast"));
874 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
876 error (_("Couldn't determine value's most derived type for dynamic_cast"));
878 /* Compute the most derived object's address. */
879 addr
= value_address (arg
);
887 addr
+= top
+ value_embedded_offset (arg
);
889 /* dynamic_cast<void *> means to return a pointer to the
890 most-derived object. */
891 if (resolved_type
->code () == TYPE_CODE_PTR
892 && resolved_type
->target_type ()->code () == TYPE_CODE_VOID
)
893 return value_at_lazy (type
, addr
);
895 tem
= value_at (type
, addr
);
896 type
= value_type (tem
);
898 /* The first dynamic check specified in 5.2.7. */
899 if (is_public_ancestor (arg_type
, resolved_type
->target_type ()))
901 if (class_types_same_p (rtti_type
, resolved_type
->target_type ()))
904 if (dynamic_cast_check_1 (resolved_type
->target_type (),
905 value_contents_for_printing (tem
).data (),
906 value_embedded_offset (tem
),
907 value_address (tem
), tem
,
911 return value_cast (type
,
913 ? value_ref (result
, resolved_type
->code ())
914 : value_addr (result
));
917 /* The second dynamic check specified in 5.2.7. */
919 if (is_public_ancestor (arg_type
, rtti_type
)
920 && dynamic_cast_check_2 (resolved_type
->target_type (),
921 value_contents_for_printing (tem
).data (),
922 value_embedded_offset (tem
),
923 value_address (tem
), tem
,
924 rtti_type
, &result
) == 1)
925 return value_cast (type
,
927 ? value_ref (result
, resolved_type
->code ())
928 : value_addr (result
));
930 if (resolved_type
->code () == TYPE_CODE_PTR
)
931 return value_zero (type
, not_lval
);
933 error (_("dynamic_cast failed"));
936 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
939 value_one (struct type
*type
)
941 struct type
*type1
= check_typedef (type
);
944 if (is_integral_type (type1
) || is_floating_type (type1
))
946 val
= value_from_longest (type
, (LONGEST
) 1);
948 else if (type1
->code () == TYPE_CODE_ARRAY
&& type1
->is_vector ())
950 struct type
*eltype
= check_typedef (type1
->target_type ());
952 LONGEST low_bound
, high_bound
;
954 if (!get_array_bounds (type1
, &low_bound
, &high_bound
))
955 error (_("Could not determine the vector bounds"));
957 val
= allocate_value (type
);
958 gdb::array_view
<gdb_byte
> val_contents
= value_contents_writeable (val
);
959 int elt_len
= eltype
->length ();
961 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
963 value
*tmp
= value_one (eltype
);
964 copy (value_contents_all (tmp
),
965 val_contents
.slice (i
* elt_len
, elt_len
));
970 error (_("Not a numeric type."));
973 /* value_one result is never used for assignments to. */
974 gdb_assert (VALUE_LVAL (val
) == not_lval
);
979 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
980 The type of the created value may differ from the passed type TYPE.
981 Make sure to retrieve the returned values's new type after this call
982 e.g. in case the type is a variable length array. */
984 static struct value
*
985 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
989 if (check_typedef (type
)->code () == TYPE_CODE_VOID
)
990 error (_("Attempt to dereference a generic pointer."));
992 val
= value_from_contents_and_address (type
, NULL
, addr
);
995 value_fetch_lazy (val
);
1000 /* Return a value with type TYPE located at ADDR.
1002 Call value_at only if the data needs to be fetched immediately;
1003 if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
1004 value_at_lazy instead. value_at_lazy simply records the address of
1005 the data and sets the lazy-evaluation-required flag. The lazy flag
1006 is tested in the value_contents macro, which is used if and when
1007 the contents are actually required. The type of the created value
1008 may differ from the passed type TYPE. Make sure to retrieve the
1009 returned values's new type after this call e.g. in case the type
1010 is a variable length array.
1012 Note: value_at does *NOT* handle embedded offsets; perform such
1013 adjustments before or after calling it. */
1016 value_at (struct type
*type
, CORE_ADDR addr
)
1018 return get_value_at (type
, addr
, 0);
1021 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
1022 The type of the created value may differ from the passed type TYPE.
1023 Make sure to retrieve the returned values's new type after this call
1024 e.g. in case the type is a variable length array. */
1027 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
1029 return get_value_at (type
, addr
, 1);
1033 read_value_memory (struct value
*val
, LONGEST bit_offset
,
1034 int stack
, CORE_ADDR memaddr
,
1035 gdb_byte
*buffer
, size_t length
)
1037 ULONGEST xfered_total
= 0;
1038 struct gdbarch
*arch
= get_value_arch (val
);
1039 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
1040 enum target_object object
;
1042 object
= stack
? TARGET_OBJECT_STACK_MEMORY
: TARGET_OBJECT_MEMORY
;
1044 while (xfered_total
< length
)
1046 enum target_xfer_status status
;
1047 ULONGEST xfered_partial
;
1049 status
= target_xfer_partial (current_inferior ()->top_target (),
1051 buffer
+ xfered_total
* unit_size
, NULL
,
1052 memaddr
+ xfered_total
,
1053 length
- xfered_total
,
1056 if (status
== TARGET_XFER_OK
)
1058 else if (status
== TARGET_XFER_UNAVAILABLE
)
1059 mark_value_bits_unavailable (val
, (xfered_total
* HOST_CHAR_BIT
1061 xfered_partial
* HOST_CHAR_BIT
);
1062 else if (status
== TARGET_XFER_EOF
)
1063 memory_error (TARGET_XFER_E_IO
, memaddr
+ xfered_total
);
1065 memory_error (status
, memaddr
+ xfered_total
);
1067 xfered_total
+= xfered_partial
;
1072 /* Store the contents of FROMVAL into the location of TOVAL.
1073 Return a new value with the location of TOVAL and contents of FROMVAL. */
1076 value_assign (struct value
*toval
, struct value
*fromval
)
1080 struct frame_id old_frame
;
1082 if (!deprecated_value_modifiable (toval
))
1083 error (_("Left operand of assignment is not a modifiable lvalue."));
1085 toval
= coerce_ref (toval
);
1087 type
= value_type (toval
);
1088 if (VALUE_LVAL (toval
) != lval_internalvar
)
1089 fromval
= value_cast (type
, fromval
);
1092 /* Coerce arrays and functions to pointers, except for arrays
1093 which only live in GDB's storage. */
1094 if (!value_must_coerce_to_target (fromval
))
1095 fromval
= coerce_array (fromval
);
1098 type
= check_typedef (type
);
1100 /* Since modifying a register can trash the frame chain, and
1101 modifying memory can trash the frame cache, we save the old frame
1102 and then restore the new frame afterwards. */
1103 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1105 switch (VALUE_LVAL (toval
))
1107 case lval_internalvar
:
1108 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1109 return value_of_internalvar (type
->arch (),
1110 VALUE_INTERNALVAR (toval
));
1112 case lval_internalvar_component
:
1114 LONGEST offset
= value_offset (toval
);
1116 /* Are we dealing with a bitfield?
1118 It is important to mention that `value_parent (toval)' is
1119 non-NULL iff `value_bitsize (toval)' is non-zero. */
1120 if (value_bitsize (toval
))
1122 /* VALUE_INTERNALVAR below refers to the parent value, while
1123 the offset is relative to this parent value. */
1124 gdb_assert (value_parent (value_parent (toval
)) == NULL
);
1125 offset
+= value_offset (value_parent (toval
));
1128 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1130 value_bitpos (toval
),
1131 value_bitsize (toval
),
1138 const gdb_byte
*dest_buffer
;
1139 CORE_ADDR changed_addr
;
1141 gdb_byte buffer
[sizeof (LONGEST
)];
1143 if (value_bitsize (toval
))
1145 struct value
*parent
= value_parent (toval
);
1147 changed_addr
= value_address (parent
) + value_offset (toval
);
1148 changed_len
= (value_bitpos (toval
)
1149 + value_bitsize (toval
)
1150 + HOST_CHAR_BIT
- 1)
1153 /* If we can read-modify-write exactly the size of the
1154 containing type (e.g. short or int) then do so. This
1155 is safer for volatile bitfields mapped to hardware
1157 if (changed_len
< type
->length ()
1158 && type
->length () <= (int) sizeof (LONGEST
)
1159 && ((LONGEST
) changed_addr
% type
->length ()) == 0)
1160 changed_len
= type
->length ();
1162 if (changed_len
> (int) sizeof (LONGEST
))
1163 error (_("Can't handle bitfields which "
1164 "don't fit in a %d bit word."),
1165 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1167 read_memory (changed_addr
, buffer
, changed_len
);
1168 modify_field (type
, buffer
, value_as_long (fromval
),
1169 value_bitpos (toval
), value_bitsize (toval
));
1170 dest_buffer
= buffer
;
1174 changed_addr
= value_address (toval
);
1175 changed_len
= type_length_units (type
);
1176 dest_buffer
= value_contents (fromval
).data ();
1179 write_memory_with_notification (changed_addr
, dest_buffer
, changed_len
);
1185 frame_info_ptr frame
;
1186 struct gdbarch
*gdbarch
;
1189 /* Figure out which frame this register value is in. The value
1190 holds the frame_id for the next frame, that is the frame this
1191 register value was unwound from.
1193 Below we will call put_frame_register_bytes which requires that
1194 we pass it the actual frame in which the register value is
1195 valid, i.e. not the next frame. */
1196 frame
= frame_find_by_id (VALUE_NEXT_FRAME_ID (toval
));
1197 frame
= get_prev_frame_always (frame
);
1199 value_reg
= VALUE_REGNUM (toval
);
1202 error (_("Value being assigned to is no longer active."));
1204 gdbarch
= get_frame_arch (frame
);
1206 if (value_bitsize (toval
))
1208 struct value
*parent
= value_parent (toval
);
1209 LONGEST offset
= value_offset (parent
) + value_offset (toval
);
1211 gdb_byte buffer
[sizeof (LONGEST
)];
1214 changed_len
= (value_bitpos (toval
)
1215 + value_bitsize (toval
)
1216 + HOST_CHAR_BIT
- 1)
1219 if (changed_len
> sizeof (LONGEST
))
1220 error (_("Can't handle bitfields which "
1221 "don't fit in a %d bit word."),
1222 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1224 if (!get_frame_register_bytes (frame
, value_reg
, offset
,
1225 {buffer
, changed_len
},
1229 throw_error (OPTIMIZED_OUT_ERROR
,
1230 _("value has been optimized out"));
1232 throw_error (NOT_AVAILABLE_ERROR
,
1233 _("value is not available"));
1236 modify_field (type
, buffer
, value_as_long (fromval
),
1237 value_bitpos (toval
), value_bitsize (toval
));
1239 put_frame_register_bytes (frame
, value_reg
, offset
,
1240 {buffer
, changed_len
});
1244 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
),
1247 /* If TOVAL is a special machine register requiring
1248 conversion of program values to a special raw
1250 gdbarch_value_to_register (gdbarch
, frame
,
1251 VALUE_REGNUM (toval
), type
,
1252 value_contents (fromval
).data ());
1255 put_frame_register_bytes (frame
, value_reg
,
1256 value_offset (toval
),
1257 value_contents (fromval
));
1260 gdb::observers::register_changed
.notify (frame
, value_reg
);
1266 const struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1268 if (funcs
->write
!= NULL
)
1270 funcs
->write (toval
, fromval
);
1277 error (_("Left operand of assignment is not an lvalue."));
1280 /* Assigning to the stack pointer, frame pointer, and other
1281 (architecture and calling convention specific) registers may
1282 cause the frame cache and regcache to be out of date. Assigning to memory
1283 also can. We just do this on all assignments to registers or
1284 memory, for simplicity's sake; I doubt the slowdown matters. */
1285 switch (VALUE_LVAL (toval
))
1291 gdb::observers::target_changed
.notify
1292 (current_inferior ()->top_target ());
1294 /* Having destroyed the frame cache, restore the selected
1297 /* FIXME: cagney/2002-11-02: There has to be a better way of
1298 doing this. Instead of constantly saving/restoring the
1299 frame. Why not create a get_selected_frame() function that,
1300 having saved the selected frame's ID can automatically
1301 re-find the previously selected frame automatically. */
1304 frame_info_ptr fi
= frame_find_by_id (old_frame
);
1315 /* If the field does not entirely fill a LONGEST, then zero the sign
1316 bits. If the field is signed, and is negative, then sign
1318 if ((value_bitsize (toval
) > 0)
1319 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1321 LONGEST fieldval
= value_as_long (fromval
);
1322 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1324 fieldval
&= valmask
;
1325 if (!type
->is_unsigned ()
1326 && (fieldval
& (valmask
^ (valmask
>> 1))))
1327 fieldval
|= ~valmask
;
1329 fromval
= value_from_longest (type
, fieldval
);
1332 /* The return value is a copy of TOVAL so it shares its location
1333 information, but its contents are updated from FROMVAL. This
1334 implies the returned value is not lazy, even if TOVAL was. */
1335 val
= value_copy (toval
);
1336 set_value_lazy (val
, 0);
1337 copy (value_contents (fromval
), value_contents_raw (val
));
1339 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1340 in the case of pointer types. For object types, the enclosing type
1341 and embedded offset must *not* be copied: the target object refered
1342 to by TOVAL retains its original dynamic type after assignment. */
1343 if (type
->code () == TYPE_CODE_PTR
)
1345 set_value_enclosing_type (val
, value_enclosing_type (fromval
));
1346 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1352 /* Extend a value ARG1 to COUNT repetitions of its type. */
1355 value_repeat (struct value
*arg1
, int count
)
1359 if (VALUE_LVAL (arg1
) != lval_memory
)
1360 error (_("Only values in memory can be extended with '@'."));
1362 error (_("Invalid number %d of repetitions."), count
);
1364 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1366 VALUE_LVAL (val
) = lval_memory
;
1367 set_value_address (val
, value_address (arg1
));
1369 read_value_memory (val
, 0, value_stack (val
), value_address (val
),
1370 value_contents_all_raw (val
).data (),
1371 type_length_units (value_enclosing_type (val
)));
1377 value_of_variable (struct symbol
*var
, const struct block
*b
)
1379 frame_info_ptr frame
= NULL
;
1381 if (symbol_read_needs_frame (var
))
1382 frame
= get_selected_frame (_("No frame selected."));
1384 return read_var_value (var
, b
, frame
);
1388 address_of_variable (struct symbol
*var
, const struct block
*b
)
1390 struct type
*type
= var
->type ();
1393 /* Evaluate it first; if the result is a memory address, we're fine.
1394 Lazy evaluation pays off here. */
1396 val
= value_of_variable (var
, b
);
1397 type
= value_type (val
);
1399 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1400 || type
->code () == TYPE_CODE_FUNC
)
1402 CORE_ADDR addr
= value_address (val
);
1404 return value_from_pointer (lookup_pointer_type (type
), addr
);
1407 /* Not a memory address; check what the problem was. */
1408 switch (VALUE_LVAL (val
))
1412 frame_info_ptr frame
;
1413 const char *regname
;
1415 frame
= frame_find_by_id (VALUE_NEXT_FRAME_ID (val
));
1418 regname
= gdbarch_register_name (get_frame_arch (frame
),
1419 VALUE_REGNUM (val
));
1420 gdb_assert (regname
!= nullptr && *regname
!= '\0');
1422 error (_("Address requested for identifier "
1423 "\"%s\" which is in register $%s"),
1424 var
->print_name (), regname
);
1429 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1430 var
->print_name ());
1440 value_must_coerce_to_target (struct value
*val
)
1442 struct type
*valtype
;
1444 /* The only lval kinds which do not live in target memory. */
1445 if (VALUE_LVAL (val
) != not_lval
1446 && VALUE_LVAL (val
) != lval_internalvar
1447 && VALUE_LVAL (val
) != lval_xcallable
)
1450 valtype
= check_typedef (value_type (val
));
1452 switch (valtype
->code ())
1454 case TYPE_CODE_ARRAY
:
1455 return valtype
->is_vector () ? 0 : 1;
1456 case TYPE_CODE_STRING
:
1463 /* Make sure that VAL lives in target memory if it's supposed to. For
1464 instance, strings are constructed as character arrays in GDB's
1465 storage, and this function copies them to the target. */
1468 value_coerce_to_target (struct value
*val
)
1473 if (!value_must_coerce_to_target (val
))
1476 length
= check_typedef (value_type (val
))->length ();
1477 addr
= allocate_space_in_inferior (length
);
1478 write_memory (addr
, value_contents (val
).data (), length
);
1479 return value_at_lazy (value_type (val
), addr
);
1482 /* Given a value which is an array, return a value which is a pointer
1483 to its first element, regardless of whether or not the array has a
1484 nonzero lower bound.
1486 FIXME: A previous comment here indicated that this routine should
1487 be substracting the array's lower bound. It's not clear to me that
1488 this is correct. Given an array subscripting operation, it would
1489 certainly work to do the adjustment here, essentially computing:
1491 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1493 However I believe a more appropriate and logical place to account
1494 for the lower bound is to do so in value_subscript, essentially
1497 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1499 As further evidence consider what would happen with operations
1500 other than array subscripting, where the caller would get back a
1501 value that had an address somewhere before the actual first element
1502 of the array, and the information about the lower bound would be
1503 lost because of the coercion to pointer type. */
1506 value_coerce_array (struct value
*arg1
)
1508 struct type
*type
= check_typedef (value_type (arg1
));
1510 /* If the user tries to do something requiring a pointer with an
1511 array that has not yet been pushed to the target, then this would
1512 be a good time to do so. */
1513 arg1
= value_coerce_to_target (arg1
);
1515 if (VALUE_LVAL (arg1
) != lval_memory
)
1516 error (_("Attempt to take address of value not located in memory."));
1518 return value_from_pointer (lookup_pointer_type (type
->target_type ()),
1519 value_address (arg1
));
1522 /* Given a value which is a function, return a value which is a pointer
1526 value_coerce_function (struct value
*arg1
)
1528 struct value
*retval
;
1530 if (VALUE_LVAL (arg1
) != lval_memory
)
1531 error (_("Attempt to take address of value not located in memory."));
1533 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1534 value_address (arg1
));
1538 /* Return a pointer value for the object for which ARG1 is the
1542 value_addr (struct value
*arg1
)
1545 struct type
*type
= check_typedef (value_type (arg1
));
1547 if (TYPE_IS_REFERENCE (type
))
1549 if (value_bits_synthetic_pointer (arg1
, value_embedded_offset (arg1
),
1550 TARGET_CHAR_BIT
* type
->length ()))
1551 arg1
= coerce_ref (arg1
);
1554 /* Copy the value, but change the type from (T&) to (T*). We
1555 keep the same location information, which is efficient, and
1556 allows &(&X) to get the location containing the reference.
1557 Do the same to its enclosing type for consistency. */
1558 struct type
*type_ptr
1559 = lookup_pointer_type (type
->target_type ());
1560 struct type
*enclosing_type
1561 = check_typedef (value_enclosing_type (arg1
));
1562 struct type
*enclosing_type_ptr
1563 = lookup_pointer_type (enclosing_type
->target_type ());
1565 arg2
= value_copy (arg1
);
1566 deprecated_set_value_type (arg2
, type_ptr
);
1567 set_value_enclosing_type (arg2
, enclosing_type_ptr
);
1572 if (type
->code () == TYPE_CODE_FUNC
)
1573 return value_coerce_function (arg1
);
1575 /* If this is an array that has not yet been pushed to the target,
1576 then this would be a good time to force it to memory. */
1577 arg1
= value_coerce_to_target (arg1
);
1579 if (VALUE_LVAL (arg1
) != lval_memory
)
1580 error (_("Attempt to take address of value not located in memory."));
1582 /* Get target memory address. */
1583 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1584 (value_address (arg1
)
1585 + value_embedded_offset (arg1
)));
1587 /* This may be a pointer to a base subobject; so remember the
1588 full derived object's type ... */
1589 set_value_enclosing_type (arg2
,
1590 lookup_pointer_type (value_enclosing_type (arg1
)));
1591 /* ... and also the relative position of the subobject in the full
1593 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1597 /* Return a reference value for the object for which ARG1 is the
1601 value_ref (struct value
*arg1
, enum type_code refcode
)
1604 struct type
*type
= check_typedef (value_type (arg1
));
1606 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
1608 if ((type
->code () == TYPE_CODE_REF
1609 || type
->code () == TYPE_CODE_RVALUE_REF
)
1610 && type
->code () == refcode
)
1613 arg2
= value_addr (arg1
);
1614 deprecated_set_value_type (arg2
, lookup_reference_type (type
, refcode
));
1618 /* Given a value of a pointer type, apply the C unary * operator to
1622 value_ind (struct value
*arg1
)
1624 struct type
*base_type
;
1627 arg1
= coerce_array (arg1
);
1629 base_type
= check_typedef (value_type (arg1
));
1631 if (VALUE_LVAL (arg1
) == lval_computed
)
1633 const struct lval_funcs
*funcs
= value_computed_funcs (arg1
);
1635 if (funcs
->indirect
)
1637 struct value
*result
= funcs
->indirect (arg1
);
1644 if (base_type
->code () == TYPE_CODE_PTR
)
1646 struct type
*enc_type
;
1648 /* We may be pointing to something embedded in a larger object.
1649 Get the real type of the enclosing object. */
1650 enc_type
= check_typedef (value_enclosing_type (arg1
));
1651 enc_type
= enc_type
->target_type ();
1653 CORE_ADDR base_addr
;
1654 if (check_typedef (enc_type
)->code () == TYPE_CODE_FUNC
1655 || check_typedef (enc_type
)->code () == TYPE_CODE_METHOD
)
1657 /* For functions, go through find_function_addr, which knows
1658 how to handle function descriptors. */
1659 base_addr
= find_function_addr (arg1
, NULL
);
1663 /* Retrieve the enclosing object pointed to. */
1664 base_addr
= (value_as_address (arg1
)
1665 - value_pointed_to_offset (arg1
));
1667 arg2
= value_at_lazy (enc_type
, base_addr
);
1668 enc_type
= value_type (arg2
);
1669 return readjust_indirect_value_type (arg2
, enc_type
, base_type
,
1673 error (_("Attempt to take contents of a non-pointer value."));
1676 /* Create a value for an array by allocating space in GDB, copying the
1677 data into that space, and then setting up an array value.
1679 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1680 is populated from the values passed in ELEMVEC.
1682 The element type of the array is inherited from the type of the
1683 first element, and all elements must have the same size (though we
1684 don't currently enforce any restriction on their types). */
1687 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1691 ULONGEST typelength
;
1693 struct type
*arraytype
;
1695 /* Validate that the bounds are reasonable and that each of the
1696 elements have the same size. */
1698 nelem
= highbound
- lowbound
+ 1;
1701 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1703 typelength
= type_length_units (value_enclosing_type (elemvec
[0]));
1704 for (idx
= 1; idx
< nelem
; idx
++)
1706 if (type_length_units (value_enclosing_type (elemvec
[idx
]))
1709 error (_("array elements must all be the same size"));
1713 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1714 lowbound
, highbound
);
1716 if (!current_language
->c_style_arrays_p ())
1718 val
= allocate_value (arraytype
);
1719 for (idx
= 0; idx
< nelem
; idx
++)
1720 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0,
1725 /* Allocate space to store the array, and then initialize it by
1726 copying in each element. */
1728 val
= allocate_value (arraytype
);
1729 for (idx
= 0; idx
< nelem
; idx
++)
1730 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0, typelength
);
1735 value_cstring (const char *ptr
, ssize_t len
, struct type
*char_type
)
1738 int lowbound
= current_language
->string_lower_bound ();
1739 ssize_t highbound
= len
/ char_type
->length ();
1740 struct type
*stringtype
1741 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1743 val
= allocate_value (stringtype
);
1744 memcpy (value_contents_raw (val
).data (), ptr
, len
);
1748 /* Create a value for a string constant by allocating space in the
1749 inferior, copying the data into that space, and returning the
1750 address with type TYPE_CODE_STRING. PTR points to the string
1751 constant data; LEN is number of characters.
1753 Note that string types are like array of char types with a lower
1754 bound of zero and an upper bound of LEN - 1. Also note that the
1755 string may contain embedded null bytes. */
1758 value_string (const char *ptr
, ssize_t len
, struct type
*char_type
)
1761 int lowbound
= current_language
->string_lower_bound ();
1762 ssize_t highbound
= len
/ char_type
->length ();
1763 struct type
*stringtype
1764 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1766 val
= allocate_value (stringtype
);
1767 memcpy (value_contents_raw (val
).data (), ptr
, len
);
1772 /* See if we can pass arguments in T2 to a function which takes arguments
1773 of types T1. T1 is a list of NARGS arguments, and T2 is an array_view
1774 of the values we're trying to pass. If some arguments need coercion of
1775 some sort, then the coerced values are written into T2. Return value is
1776 0 if the arguments could be matched, or the position at which they
1779 STATICP is nonzero if the T1 argument list came from a static
1780 member function. T2 must still include the ``this'' pointer, but
1783 For non-static member functions, we ignore the first argument,
1784 which is the type of the instance variable. This is because we
1785 want to handle calls with objects from derived classes. This is
1786 not entirely correct: we should actually check to make sure that a
1787 requested operation is type secure, shouldn't we? FIXME. */
1790 typecmp (bool staticp
, bool varargs
, int nargs
,
1791 struct field t1
[], gdb::array_view
<value
*> t2
)
1795 /* Skip ``this'' argument if applicable. T2 will always include
1801 (i
< nargs
) && t1
[i
].type ()->code () != TYPE_CODE_VOID
;
1804 struct type
*tt1
, *tt2
;
1806 if (i
== t2
.size ())
1809 tt1
= check_typedef (t1
[i
].type ());
1810 tt2
= check_typedef (value_type (t2
[i
]));
1812 if (TYPE_IS_REFERENCE (tt1
)
1813 /* We should be doing hairy argument matching, as below. */
1814 && (check_typedef (tt1
->target_type ())->code ()
1817 if (tt2
->code () == TYPE_CODE_ARRAY
)
1818 t2
[i
] = value_coerce_array (t2
[i
]);
1820 t2
[i
] = value_ref (t2
[i
], tt1
->code ());
1824 /* djb - 20000715 - Until the new type structure is in the
1825 place, and we can attempt things like implicit conversions,
1826 we need to do this so you can take something like a map<const
1827 char *>, and properly access map["hello"], because the
1828 argument to [] will be a reference to a pointer to a char,
1829 and the argument will be a pointer to a char. */
1830 while (TYPE_IS_REFERENCE (tt1
) || tt1
->code () == TYPE_CODE_PTR
)
1832 tt1
= check_typedef ( tt1
->target_type () );
1834 while (tt2
->code () == TYPE_CODE_ARRAY
1835 || tt2
->code () == TYPE_CODE_PTR
1836 || TYPE_IS_REFERENCE (tt2
))
1838 tt2
= check_typedef (tt2
->target_type ());
1840 if (tt1
->code () == tt2
->code ())
1842 /* Array to pointer is a `trivial conversion' according to the
1845 /* We should be doing much hairier argument matching (see
1846 section 13.2 of the ARM), but as a quick kludge, just check
1847 for the same type code. */
1848 if (t1
[i
].type ()->code () != value_type (t2
[i
])->code ())
1851 if (varargs
|| i
== t2
.size ())
1856 /* Helper class for search_struct_field that keeps track of found
1857 results and possibly throws an exception if the search yields
1858 ambiguous results. See search_struct_field for description of
1859 LOOKING_FOR_BASECLASS. */
1861 struct struct_field_searcher
1863 /* A found field. */
1866 /* Path to the structure where the field was found. */
1867 std::vector
<struct type
*> path
;
1869 /* The field found. */
1870 struct value
*field_value
;
1873 /* See corresponding fields for description of parameters. */
1874 struct_field_searcher (const char *name
,
1875 struct type
*outermost_type
,
1876 bool looking_for_baseclass
)
1878 m_looking_for_baseclass (looking_for_baseclass
),
1879 m_outermost_type (outermost_type
)
1883 /* The search entry point. If LOOKING_FOR_BASECLASS is true and the
1884 base class search yields ambiguous results, this throws an
1885 exception. If LOOKING_FOR_BASECLASS is false, the found fields
1886 are accumulated and the caller (search_struct_field) takes care
1887 of throwing an error if the field search yields ambiguous
1888 results. The latter is done that way so that the error message
1889 can include a list of all the found candidates. */
1890 void search (struct value
*arg
, LONGEST offset
, struct type
*type
);
1892 const std::vector
<found_field
> &fields ()
1897 struct value
*baseclass ()
1903 /* Update results to include V, a found field/baseclass. */
1904 void update_result (struct value
*v
, LONGEST boffset
);
1906 /* The name of the field/baseclass we're searching for. */
1909 /* Whether we're looking for a baseclass, or a field. */
1910 const bool m_looking_for_baseclass
;
1912 /* The offset of the baseclass containing the field/baseclass we
1914 LONGEST m_last_boffset
= 0;
1916 /* If looking for a baseclass, then the result is stored here. */
1917 struct value
*m_baseclass
= nullptr;
1919 /* When looking for fields, the found candidates are stored
1921 std::vector
<found_field
> m_fields
;
1923 /* The type of the initial type passed to search_struct_field; this
1924 is used for error reporting when the lookup is ambiguous. */
1925 struct type
*m_outermost_type
;
1927 /* The full path to the struct being inspected. E.g. for field 'x'
1928 defined in class B inherited by class A, we have A and B pushed
1930 std::vector
<struct type
*> m_struct_path
;
1934 struct_field_searcher::update_result (struct value
*v
, LONGEST boffset
)
1938 if (m_looking_for_baseclass
)
1940 if (m_baseclass
!= nullptr
1941 /* The result is not ambiguous if all the classes that are
1942 found occupy the same space. */
1943 && m_last_boffset
!= boffset
)
1944 error (_("base class '%s' is ambiguous in type '%s'"),
1945 m_name
, TYPE_SAFE_NAME (m_outermost_type
));
1948 m_last_boffset
= boffset
;
1952 /* The field is not ambiguous if it occupies the same
1954 if (m_fields
.empty () || m_last_boffset
!= boffset
)
1955 m_fields
.push_back ({m_struct_path
, v
});
1958 /*Fields can occupy the same space and have the same name (be
1959 ambiguous). This can happen when fields in two different base
1960 classes are marked [[no_unique_address]] and have the same name.
1961 The C++ standard says that such fields can only occupy the same
1962 space if they are of different type, but we don't rely on that in
1963 the following code. */
1964 bool ambiguous
= false, insert
= true;
1965 for (const found_field
&field
: m_fields
)
1967 if(field
.path
.back () != m_struct_path
.back ())
1969 /* Same boffset points to members of different classes.
1970 We have found an ambiguity and should record it. */
1975 /* We don't need to insert this value again, because a
1976 non-ambiguous path already leads to it. */
1981 if (ambiguous
&& insert
)
1982 m_fields
.push_back ({m_struct_path
, v
});
1988 /* A helper for search_struct_field. This does all the work; most
1989 arguments are as passed to search_struct_field. */
1992 struct_field_searcher::search (struct value
*arg1
, LONGEST offset
,
1998 m_struct_path
.push_back (type
);
1999 SCOPE_EXIT
{ m_struct_path
.pop_back (); };
2001 type
= check_typedef (type
);
2002 nbases
= TYPE_N_BASECLASSES (type
);
2004 if (!m_looking_for_baseclass
)
2005 for (i
= type
->num_fields () - 1; i
>= nbases
; i
--)
2007 const char *t_field_name
= type
->field (i
).name ();
2009 if (t_field_name
&& (strcmp_iw (t_field_name
, m_name
) == 0))
2013 if (field_is_static (&type
->field (i
)))
2014 v
= value_static_field (type
, i
);
2016 v
= value_primitive_field (arg1
, offset
, i
, type
);
2018 update_result (v
, offset
);
2023 && t_field_name
[0] == '\0')
2025 struct type
*field_type
= type
->field (i
).type ();
2027 if (field_type
->code () == TYPE_CODE_UNION
2028 || field_type
->code () == TYPE_CODE_STRUCT
)
2030 /* Look for a match through the fields of an anonymous
2031 union, or anonymous struct. C++ provides anonymous
2034 In the GNU Chill (now deleted from GDB)
2035 implementation of variant record types, each
2036 <alternative field> has an (anonymous) union type,
2037 each member of the union represents a <variant
2038 alternative>. Each <variant alternative> is
2039 represented as a struct, with a member for each
2042 LONGEST new_offset
= offset
;
2044 /* This is pretty gross. In G++, the offset in an
2045 anonymous union is relative to the beginning of the
2046 enclosing struct. In the GNU Chill (now deleted
2047 from GDB) implementation of variant records, the
2048 bitpos is zero in an anonymous union field, so we
2049 have to add the offset of the union here. */
2050 if (field_type
->code () == TYPE_CODE_STRUCT
2051 || (field_type
->num_fields () > 0
2052 && field_type
->field (0).loc_bitpos () == 0))
2053 new_offset
+= type
->field (i
).loc_bitpos () / 8;
2055 search (arg1
, new_offset
, field_type
);
2060 for (i
= 0; i
< nbases
; i
++)
2062 struct value
*v
= NULL
;
2063 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2064 /* If we are looking for baseclasses, this is what we get when
2065 we hit them. But it could happen that the base part's member
2066 name is not yet filled in. */
2067 int found_baseclass
= (m_looking_for_baseclass
2068 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2069 && (strcmp_iw (m_name
, basetype
->name ()) == 0));
2070 LONGEST boffset
= value_embedded_offset (arg1
) + offset
;
2072 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2076 boffset
= baseclass_offset (type
, i
,
2077 value_contents_for_printing (arg1
).data (),
2078 value_embedded_offset (arg1
) + offset
,
2079 value_address (arg1
),
2082 /* The virtual base class pointer might have been clobbered
2083 by the user program. Make sure that it still points to a
2084 valid memory location. */
2086 boffset
+= value_embedded_offset (arg1
) + offset
;
2088 || boffset
>= value_enclosing_type (arg1
)->length ())
2090 CORE_ADDR base_addr
;
2092 base_addr
= value_address (arg1
) + boffset
;
2093 v2
= value_at_lazy (basetype
, base_addr
);
2094 if (target_read_memory (base_addr
,
2095 value_contents_raw (v2
).data (),
2096 value_type (v2
)->length ()) != 0)
2097 error (_("virtual baseclass botch"));
2101 v2
= value_copy (arg1
);
2102 deprecated_set_value_type (v2
, basetype
);
2103 set_value_embedded_offset (v2
, boffset
);
2106 if (found_baseclass
)
2109 search (v2
, 0, TYPE_BASECLASS (type
, i
));
2111 else if (found_baseclass
)
2112 v
= value_primitive_field (arg1
, offset
, i
, type
);
2115 search (arg1
, offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2119 update_result (v
, boffset
);
2123 /* Helper function used by value_struct_elt to recurse through
2124 baseclasses. Look for a field NAME in ARG1. Search in it assuming
2125 it has (class) type TYPE. If found, return value, else return NULL.
2127 If LOOKING_FOR_BASECLASS, then instead of looking for struct
2128 fields, look for a baseclass named NAME. */
2130 static struct value
*
2131 search_struct_field (const char *name
, struct value
*arg1
,
2132 struct type
*type
, int looking_for_baseclass
)
2134 struct_field_searcher
searcher (name
, type
, looking_for_baseclass
);
2136 searcher
.search (arg1
, 0, type
);
2138 if (!looking_for_baseclass
)
2140 const auto &fields
= searcher
.fields ();
2142 if (fields
.empty ())
2144 else if (fields
.size () == 1)
2145 return fields
[0].field_value
;
2148 std::string candidates
;
2150 for (auto &&candidate
: fields
)
2152 gdb_assert (!candidate
.path
.empty ());
2154 struct type
*field_type
= value_type (candidate
.field_value
);
2155 struct type
*struct_type
= candidate
.path
.back ();
2159 for (struct type
*t
: candidate
.path
)
2168 candidates
+= string_printf ("\n '%s %s::%s' (%s)",
2169 TYPE_SAFE_NAME (field_type
),
2170 TYPE_SAFE_NAME (struct_type
),
2175 error (_("Request for member '%s' is ambiguous in type '%s'."
2176 " Candidates are:%s"),
2177 name
, TYPE_SAFE_NAME (type
),
2178 candidates
.c_str ());
2182 return searcher
.baseclass ();
2185 /* Helper function used by value_struct_elt to recurse through
2186 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2187 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2190 ARGS is an optional array of argument values used to help finding NAME.
2191 The contents of ARGS can be adjusted if type coercion is required in
2192 order to find a matching NAME.
2194 If found, return value, else if name matched and args not return
2195 (value) -1, else return NULL. */
2197 static struct value
*
2198 search_struct_method (const char *name
, struct value
**arg1p
,
2199 gdb::optional
<gdb::array_view
<value
*>> args
,
2200 LONGEST offset
, int *static_memfuncp
,
2205 int name_matched
= 0;
2207 type
= check_typedef (type
);
2208 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2210 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2212 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2214 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2215 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2218 check_stub_method_group (type
, i
);
2219 if (j
> 0 && !args
.has_value ())
2220 error (_("cannot resolve overloaded method "
2221 "`%s': no arguments supplied"), name
);
2222 else if (j
== 0 && !args
.has_value ())
2224 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2231 gdb_assert (args
.has_value ());
2232 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2233 TYPE_FN_FIELD_TYPE (f
, j
)->has_varargs (),
2234 TYPE_FN_FIELD_TYPE (f
, j
)->num_fields (),
2235 TYPE_FN_FIELD_ARGS (f
, j
), *args
))
2237 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2238 return value_virtual_fn_field (arg1p
, f
, j
,
2240 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2242 *static_memfuncp
= 1;
2243 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2252 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2254 LONGEST base_offset
;
2255 LONGEST this_offset
;
2257 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2259 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2260 struct value
*base_val
;
2261 const gdb_byte
*base_valaddr
;
2263 /* The virtual base class pointer might have been
2264 clobbered by the user program. Make sure that it
2265 still points to a valid memory location. */
2267 if (offset
< 0 || offset
>= type
->length ())
2271 gdb::byte_vector
tmp (baseclass
->length ());
2272 address
= value_address (*arg1p
);
2274 if (target_read_memory (address
+ offset
,
2275 tmp
.data (), baseclass
->length ()) != 0)
2276 error (_("virtual baseclass botch"));
2278 base_val
= value_from_contents_and_address (baseclass
,
2281 base_valaddr
= value_contents_for_printing (base_val
).data ();
2287 base_valaddr
= value_contents_for_printing (*arg1p
).data ();
2288 this_offset
= offset
;
2291 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2292 this_offset
, value_address (base_val
),
2297 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2299 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2300 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2301 if (v
== (struct value
*) - 1)
2307 /* FIXME-bothner: Why is this commented out? Why is it here? */
2308 /* *arg1p = arg1_tmp; */
2313 return (struct value
*) - 1;
2318 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2319 extract the component named NAME from the ultimate target
2320 structure/union and return it as a value with its appropriate type.
2321 ERR is used in the error message if *ARGP's type is wrong.
2323 C++: ARGS is a list of argument types to aid in the selection of
2324 an appropriate method. Also, handle derived types.
2326 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2327 where the truthvalue of whether the function that was resolved was
2328 a static member function or not is stored.
2330 ERR is an error message to be printed in case the field is not
2334 value_struct_elt (struct value
**argp
,
2335 gdb::optional
<gdb::array_view
<value
*>> args
,
2336 const char *name
, int *static_memfuncp
, const char *err
)
2341 *argp
= coerce_array (*argp
);
2343 t
= check_typedef (value_type (*argp
));
2345 /* Follow pointers until we get to a non-pointer. */
2347 while (t
->is_pointer_or_reference ())
2349 *argp
= value_ind (*argp
);
2350 /* Don't coerce fn pointer to fn and then back again! */
2351 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2352 *argp
= coerce_array (*argp
);
2353 t
= check_typedef (value_type (*argp
));
2356 if (t
->code () != TYPE_CODE_STRUCT
2357 && t
->code () != TYPE_CODE_UNION
)
2358 error (_("Attempt to extract a component of a value that is not a %s."),
2361 /* Assume it's not, unless we see that it is. */
2362 if (static_memfuncp
)
2363 *static_memfuncp
= 0;
2365 if (!args
.has_value ())
2367 /* if there are no arguments ...do this... */
2369 /* Try as a field first, because if we succeed, there is less
2371 v
= search_struct_field (name
, *argp
, t
, 0);
2375 if (current_language
->la_language
== language_fortran
)
2377 /* If it is not a field it is the type name of an inherited
2379 v
= search_struct_field (name
, *argp
, t
, 1);
2384 /* C++: If it was not found as a data field, then try to
2385 return it as a pointer to a method. */
2386 v
= search_struct_method (name
, argp
, args
, 0,
2387 static_memfuncp
, t
);
2389 if (v
== (struct value
*) - 1)
2390 error (_("Cannot take address of method %s."), name
);
2393 if (TYPE_NFN_FIELDS (t
))
2394 error (_("There is no member or method named %s."), name
);
2396 error (_("There is no member named %s."), name
);
2401 v
= search_struct_method (name
, argp
, args
, 0,
2402 static_memfuncp
, t
);
2404 if (v
== (struct value
*) - 1)
2406 error (_("One of the arguments you tried to pass to %s could not "
2407 "be converted to what the function wants."), name
);
2411 /* See if user tried to invoke data as function. If so, hand it
2412 back. If it's not callable (i.e., a pointer to function),
2413 gdb should give an error. */
2414 v
= search_struct_field (name
, *argp
, t
, 0);
2415 /* If we found an ordinary field, then it is not a method call.
2416 So, treat it as if it were a static member function. */
2417 if (v
&& static_memfuncp
)
2418 *static_memfuncp
= 1;
2422 throw_error (NOT_FOUND_ERROR
,
2423 _("Structure has no component named %s."), name
);
2427 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2428 to a structure or union, extract and return its component (field) of
2429 type FTYPE at the specified BITPOS.
2430 Throw an exception on error. */
2433 value_struct_elt_bitpos (struct value
**argp
, int bitpos
, struct type
*ftype
,
2439 *argp
= coerce_array (*argp
);
2441 t
= check_typedef (value_type (*argp
));
2443 while (t
->is_pointer_or_reference ())
2445 *argp
= value_ind (*argp
);
2446 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2447 *argp
= coerce_array (*argp
);
2448 t
= check_typedef (value_type (*argp
));
2451 if (t
->code () != TYPE_CODE_STRUCT
2452 && t
->code () != TYPE_CODE_UNION
)
2453 error (_("Attempt to extract a component of a value that is not a %s."),
2456 for (i
= TYPE_N_BASECLASSES (t
); i
< t
->num_fields (); i
++)
2458 if (!field_is_static (&t
->field (i
))
2459 && bitpos
== t
->field (i
).loc_bitpos ()
2460 && types_equal (ftype
, t
->field (i
).type ()))
2461 return value_primitive_field (*argp
, 0, i
, t
);
2464 error (_("No field with matching bitpos and type."));
2470 /* Search through the methods of an object (and its bases) to find a
2471 specified method. Return a reference to the fn_field list METHODS of
2472 overloaded instances defined in the source language. If available
2473 and matching, a vector of matching xmethods defined in extension
2474 languages are also returned in XMETHODS.
2476 Helper function for value_find_oload_list.
2477 ARGP is a pointer to a pointer to a value (the object).
2478 METHOD is a string containing the method name.
2479 OFFSET is the offset within the value.
2480 TYPE is the assumed type of the object.
2481 METHODS is a pointer to the matching overloaded instances defined
2482 in the source language. Since this is a recursive function,
2483 *METHODS should be set to NULL when calling this function.
2484 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2485 0 when calling this function.
2486 XMETHODS is the vector of matching xmethod workers. *XMETHODS
2487 should also be set to NULL when calling this function.
2488 BASETYPE is set to the actual type of the subobject where the
2490 BOFFSET is the offset of the base subobject where the method is found. */
2493 find_method_list (struct value
**argp
, const char *method
,
2494 LONGEST offset
, struct type
*type
,
2495 gdb::array_view
<fn_field
> *methods
,
2496 std::vector
<xmethod_worker_up
> *xmethods
,
2497 struct type
**basetype
, LONGEST
*boffset
)
2500 struct fn_field
*f
= NULL
;
2502 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2503 type
= check_typedef (type
);
2505 /* First check in object itself.
2506 This function is called recursively to search through base classes.
2507 If there is a source method match found at some stage, then we need not
2508 look for source methods in consequent recursive calls. */
2509 if (methods
->empty ())
2511 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2513 /* pai: FIXME What about operators and type conversions? */
2514 const char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2516 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2518 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2519 f
= TYPE_FN_FIELDLIST1 (type
, i
);
2520 *methods
= gdb::make_array_view (f
, len
);
2525 /* Resolve any stub methods. */
2526 check_stub_method_group (type
, i
);
2533 /* Unlike source methods, xmethods can be accumulated over successive
2534 recursive calls. In other words, an xmethod named 'm' in a class
2535 will not hide an xmethod named 'm' in its base class(es). We want
2536 it to be this way because xmethods are after all convenience functions
2537 and hence there is no point restricting them with something like method
2538 hiding. Moreover, if hiding is done for xmethods as well, then we will
2539 have to provide a mechanism to un-hide (like the 'using' construct). */
2540 get_matching_xmethod_workers (type
, method
, xmethods
);
2542 /* If source methods are not found in current class, look for them in the
2543 base classes. We also have to go through the base classes to gather
2544 extension methods. */
2545 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2547 LONGEST base_offset
;
2549 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2551 base_offset
= baseclass_offset (type
, i
,
2552 value_contents_for_printing (*argp
).data (),
2553 value_offset (*argp
) + offset
,
2554 value_address (*argp
), *argp
);
2556 else /* Non-virtual base, simply use bit position from debug
2559 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2562 find_method_list (argp
, method
, base_offset
+ offset
,
2563 TYPE_BASECLASS (type
, i
), methods
,
2564 xmethods
, basetype
, boffset
);
2568 /* Return the list of overloaded methods of a specified name. The methods
2569 could be those GDB finds in the binary, or xmethod. Methods found in
2570 the binary are returned in METHODS, and xmethods are returned in
2573 ARGP is a pointer to a pointer to a value (the object).
2574 METHOD is the method name.
2575 OFFSET is the offset within the value contents.
2576 METHODS is the list of matching overloaded instances defined in
2577 the source language.
2578 XMETHODS is the vector of matching xmethod workers defined in
2579 extension languages.
2580 BASETYPE is set to the type of the base subobject that defines the
2582 BOFFSET is the offset of the base subobject which defines the method. */
2585 value_find_oload_method_list (struct value
**argp
, const char *method
,
2587 gdb::array_view
<fn_field
> *methods
,
2588 std::vector
<xmethod_worker_up
> *xmethods
,
2589 struct type
**basetype
, LONGEST
*boffset
)
2593 t
= check_typedef (value_type (*argp
));
2595 /* Code snarfed from value_struct_elt. */
2596 while (t
->is_pointer_or_reference ())
2598 *argp
= value_ind (*argp
);
2599 /* Don't coerce fn pointer to fn and then back again! */
2600 if (check_typedef (value_type (*argp
))->code () != TYPE_CODE_FUNC
)
2601 *argp
= coerce_array (*argp
);
2602 t
= check_typedef (value_type (*argp
));
2605 if (t
->code () != TYPE_CODE_STRUCT
2606 && t
->code () != TYPE_CODE_UNION
)
2607 error (_("Attempt to extract a component of a "
2608 "value that is not a struct or union"));
2610 gdb_assert (methods
!= NULL
&& xmethods
!= NULL
);
2612 /* Clear the lists. */
2616 find_method_list (argp
, method
, 0, t
, methods
, xmethods
,
2620 /* Given an array of arguments (ARGS) (which includes an entry for
2621 "this" in the case of C++ methods), the NAME of a function, and
2622 whether it's a method or not (METHOD), find the best function that
2623 matches on the argument types according to the overload resolution
2626 METHOD can be one of three values:
2627 NON_METHOD for non-member functions.
2628 METHOD: for member functions.
2629 BOTH: used for overload resolution of operators where the
2630 candidates are expected to be either member or non member
2631 functions. In this case the first argument ARGTYPES
2632 (representing 'this') is expected to be a reference to the
2633 target object, and will be dereferenced when attempting the
2636 In the case of class methods, the parameter OBJ is an object value
2637 in which to search for overloaded methods.
2639 In the case of non-method functions, the parameter FSYM is a symbol
2640 corresponding to one of the overloaded functions.
2642 Return value is an integer: 0 -> good match, 10 -> debugger applied
2643 non-standard coercions, 100 -> incompatible.
2645 If a method is being searched for, VALP will hold the value.
2646 If a non-method is being searched for, SYMP will hold the symbol
2649 If a method is being searched for, and it is a static method,
2650 then STATICP will point to a non-zero value.
2652 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2653 ADL overload candidates when performing overload resolution for a fully
2656 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2657 read while picking the best overload match (it may be all zeroes and thus
2658 not have a vtable pointer), in which case skip virtual function lookup.
2659 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2662 Note: This function does *not* check the value of
2663 overload_resolution. Caller must check it to see whether overload
2664 resolution is permitted. */
2667 find_overload_match (gdb::array_view
<value
*> args
,
2668 const char *name
, enum oload_search_type method
,
2669 struct value
**objp
, struct symbol
*fsym
,
2670 struct value
**valp
, struct symbol
**symp
,
2671 int *staticp
, const int no_adl
,
2672 const enum noside noside
)
2674 struct value
*obj
= (objp
? *objp
: NULL
);
2675 struct type
*obj_type
= obj
? value_type (obj
) : NULL
;
2676 /* Index of best overloaded function. */
2677 int func_oload_champ
= -1;
2678 int method_oload_champ
= -1;
2679 int src_method_oload_champ
= -1;
2680 int ext_method_oload_champ
= -1;
2682 /* The measure for the current best match. */
2683 badness_vector method_badness
;
2684 badness_vector func_badness
;
2685 badness_vector ext_method_badness
;
2686 badness_vector src_method_badness
;
2688 struct value
*temp
= obj
;
2689 /* For methods, the list of overloaded methods. */
2690 gdb::array_view
<fn_field
> methods
;
2691 /* For non-methods, the list of overloaded function symbols. */
2692 std::vector
<symbol
*> functions
;
2693 /* For xmethods, the vector of xmethod workers. */
2694 std::vector
<xmethod_worker_up
> xmethods
;
2695 struct type
*basetype
= NULL
;
2698 const char *obj_type_name
= NULL
;
2699 const char *func_name
= NULL
;
2700 gdb::unique_xmalloc_ptr
<char> temp_func
;
2701 enum oload_classification match_quality
;
2702 enum oload_classification method_match_quality
= INCOMPATIBLE
;
2703 enum oload_classification src_method_match_quality
= INCOMPATIBLE
;
2704 enum oload_classification ext_method_match_quality
= INCOMPATIBLE
;
2705 enum oload_classification func_match_quality
= INCOMPATIBLE
;
2707 /* Get the list of overloaded methods or functions. */
2708 if (method
== METHOD
|| method
== BOTH
)
2712 /* OBJ may be a pointer value rather than the object itself. */
2713 obj
= coerce_ref (obj
);
2714 while (check_typedef (value_type (obj
))->code () == TYPE_CODE_PTR
)
2715 obj
= coerce_ref (value_ind (obj
));
2716 obj_type_name
= value_type (obj
)->name ();
2718 /* First check whether this is a data member, e.g. a pointer to
2720 if (check_typedef (value_type (obj
))->code () == TYPE_CODE_STRUCT
)
2722 *valp
= search_struct_field (name
, obj
,
2723 check_typedef (value_type (obj
)), 0);
2731 /* Retrieve the list of methods with the name NAME. */
2732 value_find_oload_method_list (&temp
, name
, 0, &methods
,
2733 &xmethods
, &basetype
, &boffset
);
2734 /* If this is a method only search, and no methods were found
2735 the search has failed. */
2736 if (method
== METHOD
&& methods
.empty () && xmethods
.empty ())
2737 error (_("Couldn't find method %s%s%s"),
2739 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2741 /* If we are dealing with stub method types, they should have
2742 been resolved by find_method_list via
2743 value_find_oload_method_list above. */
2744 if (!methods
.empty ())
2746 gdb_assert (TYPE_SELF_TYPE (methods
[0].type
) != NULL
);
2748 src_method_oload_champ
2749 = find_oload_champ (args
,
2751 methods
.data (), NULL
, NULL
,
2752 &src_method_badness
);
2754 src_method_match_quality
= classify_oload_match
2755 (src_method_badness
, args
.size (),
2756 oload_method_static_p (methods
.data (), src_method_oload_champ
));
2759 if (!xmethods
.empty ())
2761 ext_method_oload_champ
2762 = find_oload_champ (args
,
2764 NULL
, xmethods
.data (), NULL
,
2765 &ext_method_badness
);
2766 ext_method_match_quality
= classify_oload_match (ext_method_badness
,
2770 if (src_method_oload_champ
>= 0 && ext_method_oload_champ
>= 0)
2772 switch (compare_badness (ext_method_badness
, src_method_badness
))
2774 case 0: /* Src method and xmethod are equally good. */
2775 /* If src method and xmethod are equally good, then
2776 xmethod should be the winner. Hence, fall through to the
2777 case where a xmethod is better than the source
2778 method, except when the xmethod match quality is
2781 case 1: /* Src method and ext method are incompatible. */
2782 /* If ext method match is not standard, then let source method
2783 win. Otherwise, fallthrough to let xmethod win. */
2784 if (ext_method_match_quality
!= STANDARD
)
2786 method_oload_champ
= src_method_oload_champ
;
2787 method_badness
= src_method_badness
;
2788 ext_method_oload_champ
= -1;
2789 method_match_quality
= src_method_match_quality
;
2793 case 2: /* Ext method is champion. */
2794 method_oload_champ
= ext_method_oload_champ
;
2795 method_badness
= ext_method_badness
;
2796 src_method_oload_champ
= -1;
2797 method_match_quality
= ext_method_match_quality
;
2799 case 3: /* Src method is champion. */
2800 method_oload_champ
= src_method_oload_champ
;
2801 method_badness
= src_method_badness
;
2802 ext_method_oload_champ
= -1;
2803 method_match_quality
= src_method_match_quality
;
2806 gdb_assert_not_reached ("Unexpected overload comparison "
2811 else if (src_method_oload_champ
>= 0)
2813 method_oload_champ
= src_method_oload_champ
;
2814 method_badness
= src_method_badness
;
2815 method_match_quality
= src_method_match_quality
;
2817 else if (ext_method_oload_champ
>= 0)
2819 method_oload_champ
= ext_method_oload_champ
;
2820 method_badness
= ext_method_badness
;
2821 method_match_quality
= ext_method_match_quality
;
2825 if (method
== NON_METHOD
|| method
== BOTH
)
2827 const char *qualified_name
= NULL
;
2829 /* If the overload match is being search for both as a method
2830 and non member function, the first argument must now be
2833 args
[0] = value_ind (args
[0]);
2837 qualified_name
= fsym
->natural_name ();
2839 /* If we have a function with a C++ name, try to extract just
2840 the function part. Do not try this for non-functions (e.g.
2841 function pointers). */
2843 && (check_typedef (fsym
->type ())->code ()
2846 temp_func
= cp_func_name (qualified_name
);
2848 /* If cp_func_name did not remove anything, the name of the
2849 symbol did not include scope or argument types - it was
2850 probably a C-style function. */
2851 if (temp_func
!= nullptr)
2853 if (strcmp (temp_func
.get (), qualified_name
) == 0)
2856 func_name
= temp_func
.get ();
2863 qualified_name
= name
;
2866 /* If there was no C++ name, this must be a C-style function or
2867 not a function at all. Just return the same symbol. Do the
2868 same if cp_func_name fails for some reason. */
2869 if (func_name
== NULL
)
2875 func_oload_champ
= find_oload_champ_namespace (args
,
2882 if (func_oload_champ
>= 0)
2883 func_match_quality
= classify_oload_match (func_badness
,
2887 /* Did we find a match ? */
2888 if (method_oload_champ
== -1 && func_oload_champ
== -1)
2889 throw_error (NOT_FOUND_ERROR
,
2890 _("No symbol \"%s\" in current context."),
2893 /* If we have found both a method match and a function
2894 match, find out which one is better, and calculate match
2896 if (method_oload_champ
>= 0 && func_oload_champ
>= 0)
2898 switch (compare_badness (func_badness
, method_badness
))
2900 case 0: /* Top two contenders are equally good. */
2901 /* FIXME: GDB does not support the general ambiguous case.
2902 All candidates should be collected and presented the
2904 error (_("Ambiguous overload resolution"));
2906 case 1: /* Incomparable top contenders. */
2907 /* This is an error incompatible candidates
2908 should not have been proposed. */
2909 error (_("Internal error: incompatible "
2910 "overload candidates proposed"));
2912 case 2: /* Function champion. */
2913 method_oload_champ
= -1;
2914 match_quality
= func_match_quality
;
2916 case 3: /* Method champion. */
2917 func_oload_champ
= -1;
2918 match_quality
= method_match_quality
;
2921 error (_("Internal error: unexpected overload comparison result"));
2927 /* We have either a method match or a function match. */
2928 if (method_oload_champ
>= 0)
2929 match_quality
= method_match_quality
;
2931 match_quality
= func_match_quality
;
2934 if (match_quality
== INCOMPATIBLE
)
2936 if (method
== METHOD
)
2937 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2939 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2942 error (_("Cannot resolve function %s to any overloaded instance"),
2945 else if (match_quality
== NON_STANDARD
)
2947 if (method
== METHOD
)
2948 warning (_("Using non-standard conversion to match "
2949 "method %s%s%s to supplied arguments"),
2951 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2954 warning (_("Using non-standard conversion to match "
2955 "function %s to supplied arguments"),
2959 if (staticp
!= NULL
)
2960 *staticp
= oload_method_static_p (methods
.data (), method_oload_champ
);
2962 if (method_oload_champ
>= 0)
2964 if (src_method_oload_champ
>= 0)
2966 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, method_oload_champ
)
2967 && noside
!= EVAL_AVOID_SIDE_EFFECTS
)
2969 *valp
= value_virtual_fn_field (&temp
, methods
.data (),
2970 method_oload_champ
, basetype
,
2974 *valp
= value_fn_field (&temp
, methods
.data (),
2975 method_oload_champ
, basetype
, boffset
);
2978 *valp
= value_from_xmethod
2979 (std::move (xmethods
[ext_method_oload_champ
]));
2982 *symp
= functions
[func_oload_champ
];
2986 struct type
*temp_type
= check_typedef (value_type (temp
));
2987 struct type
*objtype
= check_typedef (obj_type
);
2989 if (temp_type
->code () != TYPE_CODE_PTR
2990 && objtype
->is_pointer_or_reference ())
2992 temp
= value_addr (temp
);
2997 switch (match_quality
)
3003 default: /* STANDARD */
3008 /* Find the best overload match, searching for FUNC_NAME in namespaces
3009 contained in QUALIFIED_NAME until it either finds a good match or
3010 runs out of namespaces. It stores the overloaded functions in
3011 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
3012 argument dependent lookup is not performed. */
3015 find_oload_champ_namespace (gdb::array_view
<value
*> args
,
3016 const char *func_name
,
3017 const char *qualified_name
,
3018 std::vector
<symbol
*> *oload_syms
,
3019 badness_vector
*oload_champ_bv
,
3024 find_oload_champ_namespace_loop (args
,
3027 oload_syms
, oload_champ_bv
,
3034 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
3035 how deep we've looked for namespaces, and the champ is stored in
3036 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
3037 if it isn't. Other arguments are the same as in
3038 find_oload_champ_namespace. */
3041 find_oload_champ_namespace_loop (gdb::array_view
<value
*> args
,
3042 const char *func_name
,
3043 const char *qualified_name
,
3045 std::vector
<symbol
*> *oload_syms
,
3046 badness_vector
*oload_champ_bv
,
3050 int next_namespace_len
= namespace_len
;
3051 int searched_deeper
= 0;
3052 int new_oload_champ
;
3053 char *new_namespace
;
3055 if (next_namespace_len
!= 0)
3057 gdb_assert (qualified_name
[next_namespace_len
] == ':');
3058 next_namespace_len
+= 2;
3060 next_namespace_len
+=
3061 cp_find_first_component (qualified_name
+ next_namespace_len
);
3063 /* First, see if we have a deeper namespace we can search in.
3064 If we get a good match there, use it. */
3066 if (qualified_name
[next_namespace_len
] == ':')
3068 searched_deeper
= 1;
3070 if (find_oload_champ_namespace_loop (args
,
3071 func_name
, qualified_name
,
3073 oload_syms
, oload_champ_bv
,
3074 oload_champ
, no_adl
))
3080 /* If we reach here, either we're in the deepest namespace or we
3081 didn't find a good match in a deeper namespace. But, in the
3082 latter case, we still have a bad match in a deeper namespace;
3083 note that we might not find any match at all in the current
3084 namespace. (There's always a match in the deepest namespace,
3085 because this overload mechanism only gets called if there's a
3086 function symbol to start off with.) */
3088 new_namespace
= (char *) alloca (namespace_len
+ 1);
3089 strncpy (new_namespace
, qualified_name
, namespace_len
);
3090 new_namespace
[namespace_len
] = '\0';
3092 std::vector
<symbol
*> new_oload_syms
3093 = make_symbol_overload_list (func_name
, new_namespace
);
3095 /* If we have reached the deepest level perform argument
3096 determined lookup. */
3097 if (!searched_deeper
&& !no_adl
)
3100 struct type
**arg_types
;
3102 /* Prepare list of argument types for overload resolution. */
3103 arg_types
= (struct type
**)
3104 alloca (args
.size () * (sizeof (struct type
*)));
3105 for (ix
= 0; ix
< args
.size (); ix
++)
3106 arg_types
[ix
] = value_type (args
[ix
]);
3107 add_symbol_overload_list_adl ({arg_types
, args
.size ()}, func_name
,
3111 badness_vector new_oload_champ_bv
;
3112 new_oload_champ
= find_oload_champ (args
,
3113 new_oload_syms
.size (),
3114 NULL
, NULL
, new_oload_syms
.data (),
3115 &new_oload_champ_bv
);
3117 /* Case 1: We found a good match. Free earlier matches (if any),
3118 and return it. Case 2: We didn't find a good match, but we're
3119 not the deepest function. Then go with the bad match that the
3120 deeper function found. Case 3: We found a bad match, and we're
3121 the deepest function. Then return what we found, even though
3122 it's a bad match. */
3124 if (new_oload_champ
!= -1
3125 && classify_oload_match (new_oload_champ_bv
, args
.size (), 0) == STANDARD
)
3127 *oload_syms
= std::move (new_oload_syms
);
3128 *oload_champ
= new_oload_champ
;
3129 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3132 else if (searched_deeper
)
3138 *oload_syms
= std::move (new_oload_syms
);
3139 *oload_champ
= new_oload_champ
;
3140 *oload_champ_bv
= std::move (new_oload_champ_bv
);
3145 /* Look for a function to take ARGS. Find the best match from among
3146 the overloaded methods or functions given by METHODS or FUNCTIONS
3147 or XMETHODS, respectively. One, and only one of METHODS, FUNCTIONS
3148 and XMETHODS can be non-NULL.
3150 NUM_FNS is the length of the array pointed at by METHODS, FUNCTIONS
3151 or XMETHODS, whichever is non-NULL.
3153 Return the index of the best match; store an indication of the
3154 quality of the match in OLOAD_CHAMP_BV. */
3157 find_oload_champ (gdb::array_view
<value
*> args
,
3160 xmethod_worker_up
*xmethods
,
3162 badness_vector
*oload_champ_bv
)
3164 /* A measure of how good an overloaded instance is. */
3166 /* Index of best overloaded function. */
3167 int oload_champ
= -1;
3168 /* Current ambiguity state for overload resolution. */
3169 int oload_ambiguous
= 0;
3170 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3172 /* A champion can be found among methods alone, or among functions
3173 alone, or in xmethods alone, but not in more than one of these
3175 gdb_assert ((methods
!= NULL
) + (functions
!= NULL
) + (xmethods
!= NULL
)
3178 /* Consider each candidate in turn. */
3179 for (size_t ix
= 0; ix
< num_fns
; ix
++)
3182 int static_offset
= 0;
3183 std::vector
<type
*> parm_types
;
3185 if (xmethods
!= NULL
)
3186 parm_types
= xmethods
[ix
]->get_arg_types ();
3191 if (methods
!= NULL
)
3193 nparms
= TYPE_FN_FIELD_TYPE (methods
, ix
)->num_fields ();
3194 static_offset
= oload_method_static_p (methods
, ix
);
3197 nparms
= functions
[ix
]->type ()->num_fields ();
3199 parm_types
.reserve (nparms
);
3200 for (jj
= 0; jj
< nparms
; jj
++)
3202 type
*t
= (methods
!= NULL
3203 ? (TYPE_FN_FIELD_ARGS (methods
, ix
)[jj
].type ())
3204 : functions
[ix
]->type ()->field (jj
).type ());
3205 parm_types
.push_back (t
);
3209 /* Compare parameter types to supplied argument types. Skip
3210 THIS for static methods. */
3211 bv
= rank_function (parm_types
,
3212 args
.slice (static_offset
));
3216 if (methods
!= NULL
)
3217 gdb_printf (gdb_stderr
,
3218 "Overloaded method instance %s, # of parms %d\n",
3219 methods
[ix
].physname
, (int) parm_types
.size ());
3220 else if (xmethods
!= NULL
)
3221 gdb_printf (gdb_stderr
,
3222 "Xmethod worker, # of parms %d\n",
3223 (int) parm_types
.size ());
3225 gdb_printf (gdb_stderr
,
3226 "Overloaded function instance "
3227 "%s # of parms %d\n",
3228 functions
[ix
]->demangled_name (),
3229 (int) parm_types
.size ());
3231 gdb_printf (gdb_stderr
,
3232 "...Badness of length : {%d, %d}\n",
3233 bv
[0].rank
, bv
[0].subrank
);
3235 for (jj
= 1; jj
< bv
.size (); jj
++)
3236 gdb_printf (gdb_stderr
,
3237 "...Badness of arg %d : {%d, %d}\n",
3238 jj
, bv
[jj
].rank
, bv
[jj
].subrank
);
3241 if (oload_champ_bv
->empty ())
3243 *oload_champ_bv
= std::move (bv
);
3246 else /* See whether current candidate is better or worse than
3248 switch (compare_badness (bv
, *oload_champ_bv
))
3250 case 0: /* Top two contenders are equally good. */
3251 oload_ambiguous
= 1;
3253 case 1: /* Incomparable top contenders. */
3254 oload_ambiguous
= 2;
3256 case 2: /* New champion, record details. */
3257 *oload_champ_bv
= std::move (bv
);
3258 oload_ambiguous
= 0;
3266 gdb_printf (gdb_stderr
, "Overload resolution "
3267 "champion is %d, ambiguous? %d\n",
3268 oload_champ
, oload_ambiguous
);
3274 /* Return 1 if we're looking at a static method, 0 if we're looking at
3275 a non-static method or a function that isn't a method. */
3278 oload_method_static_p (struct fn_field
*fns_ptr
, int index
)
3280 if (fns_ptr
&& index
>= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
3286 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3288 static enum oload_classification
3289 classify_oload_match (const badness_vector
&oload_champ_bv
,
3294 enum oload_classification worst
= STANDARD
;
3296 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
3298 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3299 or worse return INCOMPATIBLE. */
3300 if (compare_ranks (oload_champ_bv
[ix
],
3301 INCOMPATIBLE_TYPE_BADNESS
) <= 0)
3302 return INCOMPATIBLE
; /* Truly mismatched types. */
3303 /* Otherwise If this conversion is as bad as
3304 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3305 else if (compare_ranks (oload_champ_bv
[ix
],
3306 NS_POINTER_CONVERSION_BADNESS
) <= 0)
3307 worst
= NON_STANDARD
; /* Non-standard type conversions
3311 /* If no INCOMPATIBLE classification was found, return the worst one
3312 that was found (if any). */
3316 /* C++: return 1 is NAME is a legitimate name for the destructor of
3317 type TYPE. If TYPE does not have a destructor, or if NAME is
3318 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3319 have CHECK_TYPEDEF applied, this function will apply it itself. */
3322 destructor_name_p (const char *name
, struct type
*type
)
3326 const char *dname
= type_name_or_error (type
);
3327 const char *cp
= strchr (dname
, '<');
3330 /* Do not compare the template part for template classes. */
3332 len
= strlen (dname
);
3335 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
3336 error (_("name of destructor must equal name of class"));
3343 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3344 class". If the name is found, return a value representing it;
3345 otherwise throw an exception. */
3347 static struct value
*
3348 enum_constant_from_type (struct type
*type
, const char *name
)
3351 int name_len
= strlen (name
);
3353 gdb_assert (type
->code () == TYPE_CODE_ENUM
3354 && type
->is_declared_class ());
3356 for (i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); ++i
)
3358 const char *fname
= type
->field (i
).name ();
3361 if (type
->field (i
).loc_kind () != FIELD_LOC_KIND_ENUMVAL
3365 /* Look for the trailing "::NAME", since enum class constant
3366 names are qualified here. */
3367 len
= strlen (fname
);
3368 if (len
+ 2 >= name_len
3369 && fname
[len
- name_len
- 2] == ':'
3370 && fname
[len
- name_len
- 1] == ':'
3371 && strcmp (&fname
[len
- name_len
], name
) == 0)
3372 return value_from_longest (type
, type
->field (i
).loc_enumval ());
3375 error (_("no constant named \"%s\" in enum \"%s\""),
3376 name
, type
->name ());
3379 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3380 return the appropriate member (or the address of the member, if
3381 WANT_ADDRESS). This function is used to resolve user expressions
3382 of the form "DOMAIN::NAME". For more details on what happens, see
3383 the comment before value_struct_elt_for_reference. */
3386 value_aggregate_elt (struct type
*curtype
, const char *name
,
3387 struct type
*expect_type
, int want_address
,
3390 switch (curtype
->code ())
3392 case TYPE_CODE_STRUCT
:
3393 case TYPE_CODE_UNION
:
3394 return value_struct_elt_for_reference (curtype
, 0, curtype
,
3396 want_address
, noside
);
3397 case TYPE_CODE_NAMESPACE
:
3398 return value_namespace_elt (curtype
, name
,
3399 want_address
, noside
);
3401 case TYPE_CODE_ENUM
:
3402 return enum_constant_from_type (curtype
, name
);
3405 internal_error (_("non-aggregate type in value_aggregate_elt"));
3409 /* Compares the two method/function types T1 and T2 for "equality"
3410 with respect to the methods' parameters. If the types of the
3411 two parameter lists are the same, returns 1; 0 otherwise. This
3412 comparison may ignore any artificial parameters in T1 if
3413 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3414 the first artificial parameter in T1, assumed to be a 'this' pointer.
3416 The type T2 is expected to have come from make_params (in eval.c). */
3419 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
3423 if (t1
->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1
, 0))
3426 /* If skipping artificial fields, find the first real field
3428 if (skip_artificial
)
3430 while (start
< t1
->num_fields ()
3431 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
3435 /* Now compare parameters. */
3437 /* Special case: a method taking void. T1 will contain no
3438 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3439 if ((t1
->num_fields () - start
) == 0 && t2
->num_fields () == 1
3440 && t2
->field (0).type ()->code () == TYPE_CODE_VOID
)
3443 if ((t1
->num_fields () - start
) == t2
->num_fields ())
3447 for (i
= 0; i
< t2
->num_fields (); ++i
)
3449 if (compare_ranks (rank_one_type (t1
->field (start
+ i
).type (),
3450 t2
->field (i
).type (), NULL
),
3451 EXACT_MATCH_BADNESS
) != 0)
3461 /* C++: Given an aggregate type VT, and a class type CLS, search
3462 recursively for CLS using value V; If found, store the offset
3463 which is either fetched from the virtual base pointer if CLS
3464 is virtual or accumulated offset of its parent classes if
3465 CLS is non-virtual in *BOFFS, set ISVIRT to indicate if CLS
3466 is virtual, and return true. If not found, return false. */
3469 get_baseclass_offset (struct type
*vt
, struct type
*cls
,
3470 struct value
*v
, int *boffs
, bool *isvirt
)
3472 for (int i
= 0; i
< TYPE_N_BASECLASSES (vt
); i
++)
3474 struct type
*t
= vt
->field (i
).type ();
3475 if (types_equal (t
, cls
))
3477 if (BASETYPE_VIA_VIRTUAL (vt
, i
))
3479 const gdb_byte
*adr
= value_contents_for_printing (v
).data ();
3480 *boffs
= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3481 value_as_long (v
), v
);
3489 if (get_baseclass_offset (check_typedef (t
), cls
, v
, boffs
, isvirt
))
3491 if (*isvirt
== false) /* Add non-virtual base offset. */
3493 const gdb_byte
*adr
= value_contents_for_printing (v
).data ();
3494 *boffs
+= baseclass_offset (vt
, i
, adr
, value_offset (v
),
3495 value_as_long (v
), v
);
3504 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3505 return the address of this member as a "pointer to member" type.
3506 If INTYPE is non-null, then it will be the type of the member we
3507 are looking for. This will help us resolve "pointers to member
3508 functions". This function is used to resolve user expressions of
3509 the form "DOMAIN::NAME". */
3511 static struct value
*
3512 value_struct_elt_for_reference (struct type
*domain
, int offset
,
3513 struct type
*curtype
, const char *name
,
3514 struct type
*intype
,
3518 struct type
*t
= check_typedef (curtype
);
3520 struct value
*result
;
3522 if (t
->code () != TYPE_CODE_STRUCT
3523 && t
->code () != TYPE_CODE_UNION
)
3524 error (_("Internal error: non-aggregate type "
3525 "to value_struct_elt_for_reference"));
3527 for (i
= t
->num_fields () - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3529 const char *t_field_name
= t
->field (i
).name ();
3531 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3533 if (field_is_static (&t
->field (i
)))
3535 struct value
*v
= value_static_field (t
, i
);
3540 if (TYPE_FIELD_PACKED (t
, i
))
3541 error (_("pointers to bitfield members not allowed"));
3544 return value_from_longest
3545 (lookup_memberptr_type (t
->field (i
).type (), domain
),
3546 offset
+ (LONGEST
) (t
->field (i
).loc_bitpos () >> 3));
3547 else if (noside
!= EVAL_NORMAL
)
3548 return allocate_value (t
->field (i
).type ());
3551 /* Try to evaluate NAME as a qualified name with implicit
3552 this pointer. In this case, attempt to return the
3553 equivalent to `this->*(&TYPE::NAME)'. */
3554 struct value
*v
= value_of_this_silent (current_language
);
3557 struct value
*ptr
, *this_v
= v
;
3559 struct type
*type
, *tmp
;
3561 ptr
= value_aggregate_elt (domain
, name
, NULL
, 1, noside
);
3562 type
= check_typedef (value_type (ptr
));
3563 gdb_assert (type
!= NULL
3564 && type
->code () == TYPE_CODE_MEMBERPTR
);
3565 tmp
= lookup_pointer_type (TYPE_SELF_TYPE (type
));
3566 v
= value_cast_pointers (tmp
, v
, 1);
3567 mem_offset
= value_as_long (ptr
);
3568 if (domain
!= curtype
)
3570 /* Find class offset of type CURTYPE from either its
3571 parent type DOMAIN or the type of implied this. */
3573 bool isvirt
= false;
3574 if (get_baseclass_offset (domain
, curtype
, v
, &boff
,
3579 struct type
*p
= check_typedef (value_type (this_v
));
3580 p
= check_typedef (p
->target_type ());
3581 if (get_baseclass_offset (p
, curtype
, this_v
,
3586 tmp
= lookup_pointer_type (type
->target_type ());
3587 result
= value_from_pointer (tmp
,
3588 value_as_long (v
) + mem_offset
);
3589 return value_ind (result
);
3592 error (_("Cannot reference non-static field \"%s\""), name
);
3597 /* C++: If it was not found as a data field, then try to return it
3598 as a pointer to a method. */
3600 /* Perform all necessary dereferencing. */
3601 while (intype
&& intype
->code () == TYPE_CODE_PTR
)
3602 intype
= intype
->target_type ();
3604 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3606 const char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3608 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3611 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3612 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3614 check_stub_method_group (t
, i
);
3618 for (j
= 0; j
< len
; ++j
)
3620 if (TYPE_CONST (intype
) != TYPE_FN_FIELD_CONST (f
, j
))
3622 if (TYPE_VOLATILE (intype
) != TYPE_FN_FIELD_VOLATILE (f
, j
))
3625 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3626 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
),
3632 error (_("no member function matches "
3633 "that type instantiation"));
3640 for (ii
= 0; ii
< len
; ++ii
)
3642 /* Skip artificial methods. This is necessary if,
3643 for example, the user wants to "print
3644 subclass::subclass" with only one user-defined
3645 constructor. There is no ambiguity in this case.
3646 We are careful here to allow artificial methods
3647 if they are the unique result. */
3648 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3655 /* Desired method is ambiguous if more than one
3656 method is defined. */
3657 if (j
!= -1 && !TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
3658 error (_("non-unique member `%s' requires "
3659 "type instantiation"), name
);
3665 error (_("no matching member function"));
3668 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3671 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3672 0, VAR_DOMAIN
, 0).symbol
;
3678 return value_addr (read_var_value (s
, 0, 0));
3680 return read_var_value (s
, 0, 0);
3683 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3687 result
= allocate_value
3688 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3689 cplus_make_method_ptr (value_type (result
),
3690 value_contents_writeable (result
).data (),
3691 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3693 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3694 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3696 error (_("Cannot reference virtual member function \"%s\""),
3702 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3703 0, VAR_DOMAIN
, 0).symbol
;
3708 struct value
*v
= read_var_value (s
, 0, 0);
3713 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3714 cplus_make_method_ptr (value_type (result
),
3715 value_contents_writeable (result
).data (),
3716 value_address (v
), 0);
3722 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3727 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3730 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3731 v
= value_struct_elt_for_reference (domain
,
3732 offset
+ base_offset
,
3733 TYPE_BASECLASS (t
, i
),
3735 want_address
, noside
);
3740 /* As a last chance, pretend that CURTYPE is a namespace, and look
3741 it up that way; this (frequently) works for types nested inside
3744 return value_maybe_namespace_elt (curtype
, name
,
3745 want_address
, noside
);
3748 /* C++: Return the member NAME of the namespace given by the type
3751 static struct value
*
3752 value_namespace_elt (const struct type
*curtype
,
3753 const char *name
, int want_address
,
3756 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3761 error (_("No symbol \"%s\" in namespace \"%s\"."),
3762 name
, curtype
->name ());
3767 /* A helper function used by value_namespace_elt and
3768 value_struct_elt_for_reference. It looks up NAME inside the
3769 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3770 is a class and NAME refers to a type in CURTYPE itself (as opposed
3771 to, say, some base class of CURTYPE). */
3773 static struct value
*
3774 value_maybe_namespace_elt (const struct type
*curtype
,
3775 const char *name
, int want_address
,
3778 const char *namespace_name
= curtype
->name ();
3779 struct block_symbol sym
;
3780 struct value
*result
;
3782 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3783 get_selected_block (0), VAR_DOMAIN
);
3785 if (sym
.symbol
== NULL
)
3787 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3788 && (sym
.symbol
->aclass () == LOC_TYPEDEF
))
3789 result
= allocate_value (sym
.symbol
->type ());
3791 result
= value_of_variable (sym
.symbol
, sym
.block
);
3794 result
= value_addr (result
);
3799 /* Given a pointer or a reference value V, find its real (RTTI) type.
3801 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3802 and refer to the values computed for the object pointed to. */
3805 value_rtti_indirect_type (struct value
*v
, int *full
,
3806 LONGEST
*top
, int *using_enc
)
3808 struct value
*target
= NULL
;
3809 struct type
*type
, *real_type
, *target_type
;
3811 type
= value_type (v
);
3812 type
= check_typedef (type
);
3813 if (TYPE_IS_REFERENCE (type
))
3814 target
= coerce_ref (v
);
3815 else if (type
->code () == TYPE_CODE_PTR
)
3820 target
= value_ind (v
);
3822 catch (const gdb_exception_error
&except
)
3824 if (except
.error
== MEMORY_ERROR
)
3826 /* value_ind threw a memory error. The pointer is NULL or
3827 contains an uninitialized value: we can't determine any
3837 real_type
= value_rtti_type (target
, full
, top
, using_enc
);
3841 /* Copy qualifiers to the referenced object. */
3842 target_type
= value_type (target
);
3843 real_type
= make_cv_type (TYPE_CONST (target_type
),
3844 TYPE_VOLATILE (target_type
), real_type
, NULL
);
3845 if (TYPE_IS_REFERENCE (type
))
3846 real_type
= lookup_reference_type (real_type
, type
->code ());
3847 else if (type
->code () == TYPE_CODE_PTR
)
3848 real_type
= lookup_pointer_type (real_type
);
3850 internal_error (_("Unexpected value type."));
3852 /* Copy qualifiers to the pointer/reference. */
3853 real_type
= make_cv_type (TYPE_CONST (type
), TYPE_VOLATILE (type
),
3860 /* Given a value pointed to by ARGP, check its real run-time type, and
3861 if that is different from the enclosing type, create a new value
3862 using the real run-time type as the enclosing type (and of the same
3863 type as ARGP) and return it, with the embedded offset adjusted to
3864 be the correct offset to the enclosed object. RTYPE is the type,
3865 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3866 by value_rtti_type(). If these are available, they can be supplied
3867 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3868 NULL if they're not available. */
3871 value_full_object (struct value
*argp
,
3873 int xfull
, int xtop
,
3876 struct type
*real_type
;
3880 struct value
*new_val
;
3887 using_enc
= xusing_enc
;
3890 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3892 /* If no RTTI data, or if object is already complete, do nothing. */
3893 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3896 /* In a destructor we might see a real type that is a superclass of
3897 the object's type. In this case it is better to leave the object
3900 && real_type
->length () < value_enclosing_type (argp
)->length ())
3903 /* If we have the full object, but for some reason the enclosing
3904 type is wrong, set it. */
3905 /* pai: FIXME -- sounds iffy */
3908 argp
= value_copy (argp
);
3909 set_value_enclosing_type (argp
, real_type
);
3913 /* Check if object is in memory. */
3914 if (VALUE_LVAL (argp
) != lval_memory
)
3916 warning (_("Couldn't retrieve complete object of RTTI "
3917 "type %s; object may be in register(s)."),
3918 real_type
->name ());
3923 /* All other cases -- retrieve the complete object. */
3924 /* Go back by the computed top_offset from the beginning of the
3925 object, adjusting for the embedded offset of argp if that's what
3926 value_rtti_type used for its computation. */
3927 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3928 (using_enc
? 0 : value_embedded_offset (argp
)));
3929 deprecated_set_value_type (new_val
, value_type (argp
));
3930 set_value_embedded_offset (new_val
, (using_enc
3931 ? top
+ value_embedded_offset (argp
)
3937 /* Return the value of the local variable, if one exists. Throw error
3938 otherwise, such as if the request is made in an inappropriate context. */
3941 value_of_this (const struct language_defn
*lang
)
3943 struct block_symbol sym
;
3944 const struct block
*b
;
3945 frame_info_ptr frame
;
3947 if (lang
->name_of_this () == NULL
)
3948 error (_("no `this' in current language"));
3950 frame
= get_selected_frame (_("no frame selected"));
3952 b
= get_frame_block (frame
, NULL
);
3954 sym
= lookup_language_this (lang
, b
);
3955 if (sym
.symbol
== NULL
)
3956 error (_("current stack frame does not contain a variable named `%s'"),
3957 lang
->name_of_this ());
3959 return read_var_value (sym
.symbol
, sym
.block
, frame
);
3962 /* Return the value of the local variable, if one exists. Return NULL
3963 otherwise. Never throw error. */
3966 value_of_this_silent (const struct language_defn
*lang
)
3968 struct value
*ret
= NULL
;
3972 ret
= value_of_this (lang
);
3974 catch (const gdb_exception_error
&except
)
3981 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3982 elements long, starting at LOWBOUND. The result has the same lower
3983 bound as the original ARRAY. */
3986 value_slice (struct value
*array
, int lowbound
, int length
)
3988 struct type
*slice_range_type
, *slice_type
, *range_type
;
3989 LONGEST lowerbound
, upperbound
;
3990 struct value
*slice
;
3991 struct type
*array_type
;
3993 array_type
= check_typedef (value_type (array
));
3994 if (array_type
->code () != TYPE_CODE_ARRAY
3995 && array_type
->code () != TYPE_CODE_STRING
)
3996 error (_("cannot take slice of non-array"));
3998 if (type_not_allocated (array_type
))
3999 error (_("array not allocated"));
4000 if (type_not_associated (array_type
))
4001 error (_("array not associated"));
4003 range_type
= array_type
->index_type ();
4004 if (!get_discrete_bounds (range_type
, &lowerbound
, &upperbound
))
4005 error (_("slice from bad array or bitstring"));
4007 if (lowbound
< lowerbound
|| length
< 0
4008 || lowbound
+ length
- 1 > upperbound
)
4009 error (_("slice out of range"));
4011 /* FIXME-type-allocation: need a way to free this type when we are
4013 slice_range_type
= create_static_range_type (NULL
,
4014 range_type
->target_type (),
4016 lowbound
+ length
- 1);
4019 struct type
*element_type
= array_type
->target_type ();
4021 = (lowbound
- lowerbound
) * check_typedef (element_type
)->length ();
4023 slice_type
= create_array_type (NULL
,
4026 slice_type
->set_code (array_type
->code ());
4028 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
4029 slice
= allocate_value_lazy (slice_type
);
4032 slice
= allocate_value (slice_type
);
4033 value_contents_copy (slice
, 0, array
, offset
,
4034 type_length_units (slice_type
));
4037 set_value_component_location (slice
, array
);
4038 set_value_offset (slice
, value_offset (array
) + offset
);
4047 value_literal_complex (struct value
*arg1
,
4052 struct type
*real_type
= type
->target_type ();
4054 val
= allocate_value (type
);
4055 arg1
= value_cast (real_type
, arg1
);
4056 arg2
= value_cast (real_type
, arg2
);
4058 int len
= real_type
->length ();
4060 copy (value_contents (arg1
),
4061 value_contents_raw (val
).slice (0, len
));
4062 copy (value_contents (arg2
),
4063 value_contents_raw (val
).slice (len
, len
));
4071 value_real_part (struct value
*value
)
4073 struct type
*type
= check_typedef (value_type (value
));
4074 struct type
*ttype
= type
->target_type ();
4076 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4077 return value_from_component (value
, ttype
, 0);
4083 value_imaginary_part (struct value
*value
)
4085 struct type
*type
= check_typedef (value_type (value
));
4086 struct type
*ttype
= type
->target_type ();
4088 gdb_assert (type
->code () == TYPE_CODE_COMPLEX
);
4089 return value_from_component (value
, ttype
,
4090 check_typedef (ttype
)->length ());
4093 /* Cast a value into the appropriate complex data type. */
4095 static struct value
*
4096 cast_into_complex (struct type
*type
, struct value
*val
)
4098 struct type
*real_type
= type
->target_type ();
4100 if (value_type (val
)->code () == TYPE_CODE_COMPLEX
)
4102 struct type
*val_real_type
= value_type (val
)->target_type ();
4103 struct value
*re_val
= allocate_value (val_real_type
);
4104 struct value
*im_val
= allocate_value (val_real_type
);
4105 int len
= val_real_type
->length ();
4107 copy (value_contents (val
).slice (0, len
),
4108 value_contents_raw (re_val
));
4109 copy (value_contents (val
).slice (len
, len
),
4110 value_contents_raw (im_val
));
4112 return value_literal_complex (re_val
, im_val
, type
);
4114 else if (value_type (val
)->code () == TYPE_CODE_FLT
4115 || value_type (val
)->code () == TYPE_CODE_INT
)
4116 return value_literal_complex (val
,
4117 value_zero (real_type
, not_lval
),
4120 error (_("cannot cast non-number to complex"));
4123 void _initialize_valops ();
4125 _initialize_valops ()
4127 add_setshow_boolean_cmd ("overload-resolution", class_support
,
4128 &overload_resolution
, _("\
4129 Set overload resolution in evaluating C++ functions."), _("\
4130 Show overload resolution in evaluating C++ functions."),
4132 show_overload_resolution
,
4133 &setlist
, &showlist
);
4134 overload_resolution
= 1;