GDB (xrefs)
Loading...
Searching...
No Matches
valops.c
Go to the documentation of this file.
1/* Perform non-arithmetic operations on values, for GDB.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "gdbtypes.h"
23#include "value.h"
24#include "frame.h"
25#include "inferior.h"
26#include "gdbcore.h"
27#include "target.h"
28#include "demangle.h"
29#include "language.h"
30#include "gdbcmd.h"
31#include "regcache.h"
32#include "cp-abi.h"
33#include "block.h"
34#include "infcall.h"
35#include "dictionary.h"
36#include "cp-support.h"
37#include "target-float.h"
38#include "tracepoint.h"
39#include "observable.h"
40#include "objfiles.h"
41#include "extension.h"
42#include "gdbtypes.h"
43#include "gdbsupport/byte-vector.h"
44#include "typeprint.h"
45
46/* Local functions. */
47
48static int typecmp (bool staticp, bool varargs, int nargs,
49 struct field t1[], const gdb::array_view<value *> t2);
50
51static struct value *search_struct_field (const char *, struct value *,
52 struct type *, int);
53
54static struct value *search_struct_method (const char *, struct value **,
55 gdb::optional<gdb::array_view<value *>>,
56 LONGEST, int *, struct type *);
57
58static int find_oload_champ_namespace (gdb::array_view<value *> args,
59 const char *, const char *,
60 std::vector<symbol *> *oload_syms,
62 const int no_adl);
63
64static int find_oload_champ_namespace_loop (gdb::array_view<value *> args,
65 const char *, const char *,
66 int, std::vector<symbol *> *oload_syms,
67 badness_vector *, int *,
68 const int no_adl);
69
70static int find_oload_champ (gdb::array_view<value *> args,
71 size_t num_fns,
72 fn_field *methods,
73 xmethod_worker_up *xmethods,
74 symbol **functions,
75 badness_vector *oload_champ_bv);
76
77static int oload_method_static_p (struct fn_field *, int);
78
80
82 (const badness_vector &, int, int);
83
84static struct value *value_struct_elt_for_reference (struct type *,
85 int, struct type *,
86 const char *,
87 struct type *,
88 int, enum noside);
89
90static struct value *value_namespace_elt (const struct type *,
91 const char *, int , enum noside);
92
93static struct value *value_maybe_namespace_elt (const struct type *,
94 const char *, int,
95 enum noside);
96
97static CORE_ADDR allocate_space_in_inferior (int);
98
99static struct value *cast_into_complex (struct type *, struct value *);
100
102static void
103show_overload_resolution (struct ui_file *file, int from_tty,
104 struct cmd_list_element *c,
105 const char *value)
106{
107 gdb_printf (file, _("Overload resolution in evaluating "
108 "C++ functions is %s.\n"),
109 value);
110}
111
112/* Find the address of function name NAME in the inferior. If OBJF_P
113 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
114 is defined. */
115
116struct value *
117find_function_in_inferior (const char *name, struct objfile **objf_p)
118{
119 struct block_symbol sym;
120
121 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
122 if (sym.symbol != NULL)
123 {
124 if (sym.symbol->aclass () != LOC_BLOCK)
125 {
126 error (_("\"%s\" exists in this program but is not a function."),
127 name);
128 }
129
130 if (objf_p)
131 *objf_p = sym.symbol->objfile ();
132
133 return value_of_variable (sym.symbol, sym.block);
134 }
135 else
136 {
137 struct bound_minimal_symbol msymbol =
139
140 if (msymbol.minsym != NULL)
141 {
142 struct objfile *objfile = msymbol.objfile;
143 struct gdbarch *gdbarch = objfile->arch ();
144
145 struct type *type;
146 CORE_ADDR maddr;
147 type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
150 maddr = msymbol.value_address ();
151
152 if (objf_p)
153 *objf_p = objfile;
154
155 return value_from_pointer (type, maddr);
156 }
157 else
158 {
159 if (!target_has_execution ())
160 error (_("evaluation of this expression "
161 "requires the target program to be active"));
162 else
163 error (_("evaluation of this expression requires the "
164 "program to have a function \"%s\"."),
165 name);
166 }
167 }
168}
169
170/* Allocate NBYTES of space in the inferior using the inferior's
171 malloc and return a value that is a pointer to the allocated
172 space. */
173
174struct value *
176{
177 struct objfile *objf;
178 struct value *val = find_function_in_inferior ("malloc", &objf);
179 struct gdbarch *gdbarch = objf->arch ();
180 struct value *blocklen;
181
182 blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
183 val = call_function_by_hand (val, NULL, blocklen);
184 if (value_logical_not (val))
185 {
186 if (!target_has_execution ())
187 error (_("No memory available to program now: "
188 "you need to start the target first"));
189 else
190 error (_("No memory available to program: call to malloc failed"));
191 }
192 return val;
193}
194
195static CORE_ADDR
197{
199}
200
201/* Cast struct value VAL to type TYPE and return as a value.
202 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
203 for this to work. Typedef to one of the codes is permitted.
204 Returns NULL if the cast is neither an upcast nor a downcast. */
205
206static struct value *
207value_cast_structs (struct type *type, struct value *v2)
208{
209 struct type *t1;
210 struct type *t2;
211 struct value *v;
212
213 gdb_assert (type != NULL && v2 != NULL);
214
215 t1 = check_typedef (type);
216 t2 = check_typedef (value_type (v2));
217
218 /* Check preconditions. */
219 gdb_assert ((t1->code () == TYPE_CODE_STRUCT
220 || t1->code () == TYPE_CODE_UNION)
221 && !!"Precondition is that type is of STRUCT or UNION kind.");
222 gdb_assert ((t2->code () == TYPE_CODE_STRUCT
223 || t2->code () == TYPE_CODE_UNION)
224 && !!"Precondition is that value is of STRUCT or UNION kind");
225
226 if (t1->name () != NULL
227 && t2->name () != NULL
228 && !strcmp (t1->name (), t2->name ()))
229 return NULL;
230
231 /* Upcasting: look in the type of the source to see if it contains the
232 type of the target as a superclass. If so, we'll need to
233 offset the pointer rather than just change its type. */
234 if (t1->name () != NULL)
235 {
236 v = search_struct_field (t1->name (),
237 v2, t2, 1);
238 if (v)
239 return v;
240 }
241
242 /* Downcasting: look in the type of the target to see if it contains the
243 type of the source as a superclass. If so, we'll need to
244 offset the pointer rather than just change its type. */
245 if (t2->name () != NULL)
246 {
247 /* Try downcasting using the run-time type of the value. */
248 int full, using_enc;
249 LONGEST top;
250 struct type *real_type;
251
252 real_type = value_rtti_type (v2, &full, &top, &using_enc);
253 if (real_type)
254 {
255 v = value_full_object (v2, real_type, full, top, using_enc);
256 v = value_at_lazy (real_type, value_address (v));
257 real_type = value_type (v);
258
259 /* We might be trying to cast to the outermost enclosing
260 type, in which case search_struct_field won't work. */
261 if (real_type->name () != NULL
262 && !strcmp (real_type->name (), t1->name ()))
263 return v;
264
265 v = search_struct_field (t2->name (), v, real_type, 1);
266 if (v)
267 return v;
268 }
269
270 /* Try downcasting using information from the destination type
271 T2. This wouldn't work properly for classes with virtual
272 bases, but those were handled above. */
273 v = search_struct_field (t2->name (),
274 value_zero (t1, not_lval), t1, 1);
275 if (v)
276 {
277 /* Downcasting is possible (t1 is superclass of v2). */
278 CORE_ADDR addr2 = value_address (v2) + value_embedded_offset (v2);
279
280 addr2 -= value_address (v) + value_embedded_offset (v);
281 return value_at (type, addr2);
282 }
283 }
284
285 return NULL;
286}
287
288/* Cast one pointer or reference type to another. Both TYPE and
289 the type of ARG2 should be pointer types, or else both should be
290 reference types. If SUBCLASS_CHECK is non-zero, this will force a
291 check to see whether TYPE is a superclass of ARG2's type. If
292 SUBCLASS_CHECK is zero, then the subclass check is done only when
293 ARG2 is itself non-zero. Returns the new pointer or reference. */
294
295struct value *
296value_cast_pointers (struct type *type, struct value *arg2,
297 int subclass_check)
298{
299 struct type *type1 = check_typedef (type);
300 struct type *type2 = check_typedef (value_type (arg2));
301 struct type *t1 = check_typedef (type1->target_type ());
302 struct type *t2 = check_typedef (type2->target_type ());
303
304 if (t1->code () == TYPE_CODE_STRUCT
305 && t2->code () == TYPE_CODE_STRUCT
306 && (subclass_check || !value_logical_not (arg2)))
307 {
308 struct value *v2;
309
310 if (TYPE_IS_REFERENCE (type2))
311 v2 = coerce_ref (arg2);
312 else
313 v2 = value_ind (arg2);
314 gdb_assert (check_typedef (value_type (v2))->code ()
315 == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
316 v2 = value_cast_structs (t1, v2);
317 /* At this point we have what we can have, un-dereference if needed. */
318 if (v2)
319 {
320 struct value *v = value_addr (v2);
321
323 return v;
324 }
325 }
326
327 /* No superclass found, just change the pointer type. */
328 arg2 = value_copy (arg2);
331 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
332 return arg2;
333}
334
335/* See value.h. */
336
339{
340 struct type *type = check_typedef (value_type (value));
341
342 gdb_mpq result;
344 {
346 type);
347 mpq_set_d (result.val, d);
348 }
349 else
350 {
351 gdb_assert (is_integral_type (type)
353
354 gdb_mpz vz;
356 type->is_unsigned ());
357 mpq_set_z (result.val, vz.val);
358
360 mpq_mul (result.val, result.val,
362 }
363
364 return result;
365}
366
367/* Assuming that TO_TYPE is a fixed point type, return a value
368 corresponding to the cast of FROM_VAL to that type. */
369
370static struct value *
371value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
372{
373 struct type *from_type = value_type (from_val);
374
375 if (from_type == to_type)
376 return from_val;
377
378 if (!is_floating_type (from_type)
379 && !is_integral_type (from_type)
380 && !is_fixed_point_type (from_type))
381 error (_("Invalid conversion from type %s to fixed point type %s"),
382 from_type->name (), to_type->name ());
383
384 gdb_mpq vq = value_to_gdb_mpq (from_val);
385
386 /* Divide that value by the scaling factor to obtain the unscaled
387 value, first in rational form, and then in integer form. */
388
389 mpq_div (vq.val, vq.val, to_type->fixed_point_scaling_factor ().val);
390 gdb_mpz unscaled = vq.get_rounded ();
391
392 /* Finally, create the result value, and pack the unscaled value
393 in it. */
394 struct value *result = allocate_value (to_type);
395 unscaled.write (value_contents_raw (result),
396 type_byte_order (to_type),
397 to_type->is_unsigned ());
398
399 return result;
400}
401
402/* Cast value ARG2 to type TYPE and return as a value.
403 More general than a C cast: accepts any two types of the same length,
404 and if ARG2 is an lvalue it can be cast into anything at all. */
405/* In C++, casts may change pointer or object representations. */
406
407struct value *
408value_cast (struct type *type, struct value *arg2)
409{
410 enum type_code code1;
411 enum type_code code2;
412 int scalar;
413 struct type *type2;
414
415 int convert_to_boolean = 0;
416
417 /* TYPE might be equal in meaning to the existing type of ARG2, but for
418 many reasons, might be a different type object (e.g. TYPE might be a
419 gdbarch owned type, while VALUE_TYPE (ARG2) could be an objfile owned
420 type).
421
422 In this case we want to preserve the LVAL of ARG2 as this allows the
423 resulting value to be used in more places. We do this by calling
424 VALUE_COPY if appropriate. */
425 if (types_deeply_equal (value_type (arg2), type))
426 {
427 /* If the types are exactly equal then we can avoid creating a new
428 value completely. */
429 if (value_type (arg2) != type)
430 {
431 arg2 = value_copy (arg2);
433 }
434 return arg2;
435 }
436
438 return value_cast_to_fixed_point (type, arg2);
439
440 /* Check if we are casting struct reference to struct reference. */
442 {
443 /* We dereference type; then we recurse and finally
444 we generate value of the given reference. Nothing wrong with
445 that. */
446 struct type *t1 = check_typedef (type);
447 struct type *dereftype = check_typedef (t1->target_type ());
448 struct value *val = value_cast (dereftype, arg2);
449
450 return value_ref (val, t1->code ());
451 }
452
454 /* We deref the value and then do the cast. */
455 return value_cast (type, coerce_ref (arg2));
456
457 /* Strip typedefs / resolve stubs in order to get at the type's
458 code/length, but remember the original type, to use as the
459 resulting type of the cast, in case it was a typedef. */
460 struct type *to_type = type;
461
463 code1 = type->code ();
464 arg2 = coerce_ref (arg2);
465 type2 = check_typedef (value_type (arg2));
466
467 /* You can't cast to a reference type. See value_cast_pointers
468 instead. */
469 gdb_assert (!TYPE_IS_REFERENCE (type));
470
471 /* A cast to an undetermined-length array_type, such as
472 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
473 where N is sizeof(OBJECT)/sizeof(TYPE). */
474 if (code1 == TYPE_CODE_ARRAY)
475 {
476 struct type *element_type = type->target_type ();
477 unsigned element_length = check_typedef (element_type)->length ();
478
479 if (element_length > 0 && type->bounds ()->high.kind () == PROP_UNDEFINED)
480 {
481 struct type *range_type = type->index_type ();
482 int val_length = type2->length ();
483 LONGEST low_bound, high_bound, new_length;
484
485 if (!get_discrete_bounds (range_type, &low_bound, &high_bound))
486 low_bound = 0, high_bound = 0;
487 new_length = val_length / element_length;
488 if (val_length % element_length != 0)
489 warning (_("array element type size does not "
490 "divide object size in cast"));
491 /* FIXME-type-allocation: need a way to free this type when
492 we are done with it. */
493 range_type = create_static_range_type (NULL,
494 range_type->target_type (),
495 low_bound,
496 new_length + low_bound - 1);
498 create_array_type (NULL,
499 element_type,
500 range_type));
501 return arg2;
502 }
503 }
504
506 && type2->code () == TYPE_CODE_ARRAY
507 && !type2->is_vector ())
508 arg2 = value_coerce_array (arg2);
509
510 if (type2->code () == TYPE_CODE_FUNC)
511 arg2 = value_coerce_function (arg2);
512
513 type2 = check_typedef (value_type (arg2));
514 code2 = type2->code ();
515
516 if (code1 == TYPE_CODE_COMPLEX)
517 return cast_into_complex (to_type, arg2);
518 if (code1 == TYPE_CODE_BOOL)
519 {
520 code1 = TYPE_CODE_INT;
521 convert_to_boolean = 1;
522 }
523 if (code1 == TYPE_CODE_CHAR)
524 code1 = TYPE_CODE_INT;
525 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
526 code2 = TYPE_CODE_INT;
527
528 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
529 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
530 || code2 == TYPE_CODE_RANGE
531 || is_fixed_point_type (type2));
532
533 if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
534 && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
535 && type->name () != 0)
536 {
537 struct value *v = value_cast_structs (to_type, arg2);
538
539 if (v)
540 return v;
541 }
542
543 if (is_floating_type (type) && scalar)
544 {
545 if (is_floating_value (arg2))
546 {
547 struct value *v = allocate_value (to_type);
548 target_float_convert (value_contents (arg2).data (), type2,
549 value_contents_raw (v).data (), type);
550 return v;
551 }
552 else if (is_fixed_point_type (type2))
553 {
554 gdb_mpq fp_val;
555
556 fp_val.read_fixed_point (value_contents (arg2),
557 type_byte_order (type2),
558 type2->is_unsigned (),
560
561 struct value *v = allocate_value (to_type);
563 to_type, mpq_get_d (fp_val.val));
564 return v;
565 }
566
567 /* The only option left is an integral type. */
568 if (type2->is_unsigned ())
569 return value_from_ulongest (to_type, value_as_long (arg2));
570 else
571 return value_from_longest (to_type, value_as_long (arg2));
572 }
573 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
574 || code1 == TYPE_CODE_RANGE)
575 && (scalar || code2 == TYPE_CODE_PTR
576 || code2 == TYPE_CODE_MEMBERPTR))
577 {
578 LONGEST longest;
579
580 /* When we cast pointers to integers, we mustn't use
581 gdbarch_pointer_to_address to find the address the pointer
582 represents, as value_as_long would. GDB should evaluate
583 expressions just as the compiler would --- and the compiler
584 sees a cast as a simple reinterpretation of the pointer's
585 bits. */
586 if (code2 == TYPE_CODE_PTR)
588 (value_contents (arg2), type_byte_order (type2));
589 else
590 longest = value_as_long (arg2);
591 return value_from_longest (to_type, convert_to_boolean ?
592 (LONGEST) (longest ? 1 : 0) : longest);
593 }
594 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
595 || code2 == TYPE_CODE_ENUM
596 || code2 == TYPE_CODE_RANGE))
597 {
598 /* type->length () is the length of a pointer, but we really
599 want the length of an address! -- we are really dealing with
600 addresses (i.e., gdb representations) not pointers (i.e.,
601 target representations) here.
602
603 This allows things like "print *(int *)0x01000234" to work
604 without printing a misleading message -- which would
605 otherwise occur when dealing with a target having two byte
606 pointers and four byte addresses. */
607
608 int addr_bit = gdbarch_addr_bit (type2->arch ());
609 LONGEST longest = value_as_long (arg2);
610
611 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
612 {
613 if (longest >= ((LONGEST) 1 << addr_bit)
614 || longest <= -((LONGEST) 1 << addr_bit))
615 warning (_("value truncated"));
616 }
617 return value_from_longest (to_type, longest);
618 }
619 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
620 && value_as_long (arg2) == 0)
621 {
622 struct value *result = allocate_value (to_type);
623
624 cplus_make_method_ptr (to_type,
625 value_contents_writeable (result).data (), 0, 0);
626 return result;
627 }
628 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
629 && value_as_long (arg2) == 0)
630 {
631 /* The Itanium C++ ABI represents NULL pointers to members as
632 minus one, instead of biasing the normal case. */
633 return value_from_longest (to_type, -1);
634 }
635 else if (code1 == TYPE_CODE_ARRAY && type->is_vector ()
636 && code2 == TYPE_CODE_ARRAY && type2->is_vector ()
637 && type->length () != type2->length ())
638 error (_("Cannot convert between vector values of different sizes"));
639 else if (code1 == TYPE_CODE_ARRAY && type->is_vector () && scalar
640 && type->length () != type2->length ())
641 error (_("can only cast scalar to vector of same size"));
642 else if (code1 == TYPE_CODE_VOID)
643 {
644 return value_zero (to_type, not_lval);
645 }
646 else if (type->length () == type2->length ())
647 {
648 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
649 return value_cast_pointers (to_type, arg2, 0);
650
651 arg2 = value_copy (arg2);
652 deprecated_set_value_type (arg2, to_type);
653 set_value_enclosing_type (arg2, to_type);
654 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
655 return arg2;
656 }
657 else if (VALUE_LVAL (arg2) == lval_memory)
658 return value_at_lazy (to_type, value_address (arg2));
659 else
660 {
662 error (_("Invalid type conversion."));
663 error (_("Invalid cast."));
664 }
665}
666
667/* The C++ reinterpret_cast operator. */
668
669struct value *
670value_reinterpret_cast (struct type *type, struct value *arg)
671{
672 struct value *result;
673 struct type *real_type = check_typedef (type);
674 struct type *arg_type, *dest_type;
675 int is_ref = 0;
676 enum type_code dest_code, arg_code;
677
678 /* Do reference, function, and array conversion. */
679 arg = coerce_array (arg);
680
681 /* Attempt to preserve the type the user asked for. */
682 dest_type = type;
683
684 /* If we are casting to a reference type, transform
685 reinterpret_cast<T&[&]>(V) to *reinterpret_cast<T*>(&V). */
686 if (TYPE_IS_REFERENCE (real_type))
687 {
688 is_ref = 1;
689 arg = value_addr (arg);
690 dest_type = lookup_pointer_type (dest_type->target_type ());
691 real_type = lookup_pointer_type (real_type);
692 }
693
694 arg_type = value_type (arg);
695
696 dest_code = real_type->code ();
697 arg_code = arg_type->code ();
698
699 /* We can convert pointer types, or any pointer type to int, or int
700 type to pointer. */
701 if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
702 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
703 || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
704 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
705 || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
706 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
707 || (dest_code == arg_code
708 && (dest_code == TYPE_CODE_PTR
709 || dest_code == TYPE_CODE_METHODPTR
710 || dest_code == TYPE_CODE_MEMBERPTR)))
711 result = value_cast (dest_type, arg);
712 else
713 error (_("Invalid reinterpret_cast"));
714
715 if (is_ref)
716 result = value_cast (type, value_ref (value_ind (result),
717 type->code ()));
718
719 return result;
720}
721
722/* A helper for value_dynamic_cast. This implements the first of two
723 runtime checks: we iterate over all the base classes of the value's
724 class which are equal to the desired class; if only one of these
725 holds the value, then it is the answer. */
726
727static int
728dynamic_cast_check_1 (struct type *desired_type,
729 const gdb_byte *valaddr,
730 LONGEST embedded_offset,
731 CORE_ADDR address,
732 struct value *val,
733 struct type *search_type,
734 CORE_ADDR arg_addr,
735 struct type *arg_type,
736 struct value **result)
737{
738 int i, result_count = 0;
739
740 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
741 {
742 LONGEST offset = baseclass_offset (search_type, i, valaddr,
743 embedded_offset,
744 address, val);
745
746 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
747 {
748 if (address + embedded_offset + offset >= arg_addr
749 && address + embedded_offset + offset < arg_addr + arg_type->length ())
750 {
751 ++result_count;
752 if (!*result)
753 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
754 address + embedded_offset + offset);
755 }
756 }
757 else
758 result_count += dynamic_cast_check_1 (desired_type,
759 valaddr,
760 embedded_offset + offset,
761 address, val,
762 TYPE_BASECLASS (search_type, i),
763 arg_addr,
764 arg_type,
765 result);
766 }
767
768 return result_count;
769}
770
771/* A helper for value_dynamic_cast. This implements the second of two
772 runtime checks: we look for a unique public sibling class of the
773 argument's declared class. */
774
775static int
776dynamic_cast_check_2 (struct type *desired_type,
777 const gdb_byte *valaddr,
778 LONGEST embedded_offset,
779 CORE_ADDR address,
780 struct value *val,
781 struct type *search_type,
782 struct value **result)
783{
784 int i, result_count = 0;
785
786 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
787 {
788 LONGEST offset;
789
790 if (! BASETYPE_VIA_PUBLIC (search_type, i))
791 continue;
792
793 offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
794 address, val);
795 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
796 {
797 ++result_count;
798 if (*result == NULL)
799 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
800 address + embedded_offset + offset);
801 }
802 else
803 result_count += dynamic_cast_check_2 (desired_type,
804 valaddr,
805 embedded_offset + offset,
806 address, val,
807 TYPE_BASECLASS (search_type, i),
808 result);
809 }
810
811 return result_count;
812}
813
814/* The C++ dynamic_cast operator. */
815
816struct value *
817value_dynamic_cast (struct type *type, struct value *arg)
818{
819 int full, using_enc;
820 LONGEST top;
821 struct type *resolved_type = check_typedef (type);
822 struct type *arg_type = check_typedef (value_type (arg));
823 struct type *class_type, *rtti_type;
824 struct value *result, *tem, *original_arg = arg;
825 CORE_ADDR addr;
826 int is_ref = TYPE_IS_REFERENCE (resolved_type);
827
828 if (resolved_type->code () != TYPE_CODE_PTR
829 && !TYPE_IS_REFERENCE (resolved_type))
830 error (_("Argument to dynamic_cast must be a pointer or reference type"));
831 if (resolved_type->target_type ()->code () != TYPE_CODE_VOID
832 && resolved_type->target_type ()->code () != TYPE_CODE_STRUCT)
833 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
834
835 class_type = check_typedef (resolved_type->target_type ());
836 if (resolved_type->code () == TYPE_CODE_PTR)
837 {
838 if (arg_type->code () != TYPE_CODE_PTR
839 && ! (arg_type->code () == TYPE_CODE_INT
840 && value_as_long (arg) == 0))
841 error (_("Argument to dynamic_cast does not have pointer type"));
842 if (arg_type->code () == TYPE_CODE_PTR)
843 {
844 arg_type = check_typedef (arg_type->target_type ());
845 if (arg_type->code () != TYPE_CODE_STRUCT)
846 error (_("Argument to dynamic_cast does "
847 "not have pointer to class type"));
848 }
849
850 /* Handle NULL pointers. */
851 if (value_as_long (arg) == 0)
852 return value_zero (type, not_lval);
853
854 arg = value_ind (arg);
855 }
856 else
857 {
858 if (arg_type->code () != TYPE_CODE_STRUCT)
859 error (_("Argument to dynamic_cast does not have class type"));
860 }
861
862 /* If the classes are the same, just return the argument. */
863 if (class_types_same_p (class_type, arg_type))
864 return value_cast (type, arg);
865
866 /* If the target type is a unique base class of the argument's
867 declared type, just cast it. */
868 if (is_ancestor (class_type, arg_type))
869 {
870 if (is_unique_ancestor (class_type, arg))
871 return value_cast (type, original_arg);
872 error (_("Ambiguous dynamic_cast"));
873 }
874
875 rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
876 if (! rtti_type)
877 error (_("Couldn't determine value's most derived type for dynamic_cast"));
878
879 /* Compute the most derived object's address. */
880 addr = value_address (arg);
881 if (full)
882 {
883 /* Done. */
884 }
885 else if (using_enc)
886 addr += top;
887 else
888 addr += top + value_embedded_offset (arg);
889
890 /* dynamic_cast<void *> means to return a pointer to the
891 most-derived object. */
892 if (resolved_type->code () == TYPE_CODE_PTR
893 && resolved_type->target_type ()->code () == TYPE_CODE_VOID)
894 return value_at_lazy (type, addr);
895
896 tem = value_at (type, addr);
897 type = value_type (tem);
898
899 /* The first dynamic check specified in 5.2.7. */
900 if (is_public_ancestor (arg_type, resolved_type->target_type ()))
901 {
902 if (class_types_same_p (rtti_type, resolved_type->target_type ()))
903 return tem;
904 result = NULL;
905 if (dynamic_cast_check_1 (resolved_type->target_type (),
906 value_contents_for_printing (tem).data (),
908 value_address (tem), tem,
909 rtti_type, addr,
910 arg_type,
911 &result) == 1)
912 return value_cast (type,
913 is_ref
914 ? value_ref (result, resolved_type->code ())
915 : value_addr (result));
916 }
917
918 /* The second dynamic check specified in 5.2.7. */
919 result = NULL;
920 if (is_public_ancestor (arg_type, rtti_type)
921 && dynamic_cast_check_2 (resolved_type->target_type (),
922 value_contents_for_printing (tem).data (),
924 value_address (tem), tem,
925 rtti_type, &result) == 1)
926 return value_cast (type,
927 is_ref
928 ? value_ref (result, resolved_type->code ())
929 : value_addr (result));
930
931 if (resolved_type->code () == TYPE_CODE_PTR)
932 return value_zero (type, not_lval);
933
934 error (_("dynamic_cast failed"));
935}
936
937/* Create a not_lval value of numeric type TYPE that is one, and return it. */
938
939struct value *
941{
942 struct type *type1 = check_typedef (type);
943 struct value *val;
944
945 if (is_integral_type (type1) || is_floating_type (type1))
946 {
947 val = value_from_longest (type, (LONGEST) 1);
948 }
949 else if (type1->code () == TYPE_CODE_ARRAY && type1->is_vector ())
950 {
951 struct type *eltype = check_typedef (type1->target_type ());
952 int i;
953 LONGEST low_bound, high_bound;
954
955 if (!get_array_bounds (type1, &low_bound, &high_bound))
956 error (_("Could not determine the vector bounds"));
957
958 val = allocate_value (type);
959 gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val);
960 int elt_len = eltype->length ();
961
962 for (i = 0; i < high_bound - low_bound + 1; i++)
963 {
964 value *tmp = value_one (eltype);
965 copy (value_contents_all (tmp),
966 val_contents.slice (i * elt_len, elt_len));
967 }
968 }
969 else
970 {
971 error (_("Not a numeric type."));
972 }
973
974 /* value_one result is never used for assignments to. */
975 gdb_assert (VALUE_LVAL (val) == not_lval);
976
977 return val;
978}
979
980/* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
981 The type of the created value may differ from the passed type TYPE.
982 Make sure to retrieve the returned values's new type after this call
983 e.g. in case the type is a variable length array. */
984
985static struct value *
986get_value_at (struct type *type, CORE_ADDR addr, int lazy)
987{
988 struct value *val;
989
990 if (check_typedef (type)->code () == TYPE_CODE_VOID)
991 error (_("Attempt to dereference a generic pointer."));
992
993 val = value_from_contents_and_address (type, NULL, addr);
994
995 if (!lazy)
996 value_fetch_lazy (val);
997
998 return val;
999}
1000
1001/* Return a value with type TYPE located at ADDR.
1002
1003 Call value_at only if the data needs to be fetched immediately;
1004 if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
1005 value_at_lazy instead. value_at_lazy simply records the address of
1006 the data and sets the lazy-evaluation-required flag. The lazy flag
1007 is tested in the value_contents macro, which is used if and when
1008 the contents are actually required. The type of the created value
1009 may differ from the passed type TYPE. Make sure to retrieve the
1010 returned values's new type after this call e.g. in case the type
1011 is a variable length array.
1012
1013 Note: value_at does *NOT* handle embedded offsets; perform such
1014 adjustments before or after calling it. */
1015
1016struct value *
1017value_at (struct type *type, CORE_ADDR addr)
1018{
1019 return get_value_at (type, addr, 0);
1020}
1021
1022/* Return a lazy value with type TYPE located at ADDR (cf. value_at).
1023 The type of the created value may differ from the passed type TYPE.
1024 Make sure to retrieve the returned values's new type after this call
1025 e.g. in case the type is a variable length array. */
1026
1027struct value *
1028value_at_lazy (struct type *type, CORE_ADDR addr)
1029{
1030 return get_value_at (type, addr, 1);
1031}
1032
1033void
1034read_value_memory (struct value *val, LONGEST bit_offset,
1035 int stack, CORE_ADDR memaddr,
1036 gdb_byte *buffer, size_t length)
1037{
1038 ULONGEST xfered_total = 0;
1039 struct gdbarch *arch = get_value_arch (val);
1040 int unit_size = gdbarch_addressable_memory_unit_size (arch);
1041 enum target_object object;
1042
1044
1045 while (xfered_total < length)
1046 {
1048 ULONGEST xfered_partial;
1049
1050 status = target_xfer_partial (current_inferior ()->top_target (),
1051 object, NULL,
1052 buffer + xfered_total * unit_size, NULL,
1053 memaddr + xfered_total,
1054 length - xfered_total,
1055 &xfered_partial);
1056
1057 if (status == TARGET_XFER_OK)
1058 /* nothing */;
1059 else if (status == TARGET_XFER_UNAVAILABLE)
1060 mark_value_bits_unavailable (val, (xfered_total * HOST_CHAR_BIT
1061 + bit_offset),
1062 xfered_partial * HOST_CHAR_BIT);
1063 else if (status == TARGET_XFER_EOF)
1064 memory_error (TARGET_XFER_E_IO, memaddr + xfered_total);
1065 else
1066 memory_error (status, memaddr + xfered_total);
1067
1068 xfered_total += xfered_partial;
1069 QUIT;
1070 }
1071}
1072
1073/* Store the contents of FROMVAL into the location of TOVAL.
1074 Return a new value with the location of TOVAL and contents of FROMVAL. */
1075
1076struct value *
1077value_assign (struct value *toval, struct value *fromval)
1078{
1079 struct type *type;
1080 struct value *val;
1081 struct frame_id old_frame;
1082
1083 if (!deprecated_value_modifiable (toval))
1084 error (_("Left operand of assignment is not a modifiable lvalue."));
1085
1086 toval = coerce_ref (toval);
1087
1088 type = value_type (toval);
1089 if (VALUE_LVAL (toval) != lval_internalvar)
1090 fromval = value_cast (type, fromval);
1091 else
1092 {
1093 /* Coerce arrays and functions to pointers, except for arrays
1094 which only live in GDB's storage. */
1095 if (!value_must_coerce_to_target (fromval))
1096 fromval = coerce_array (fromval);
1097 }
1098
1100
1101 /* Since modifying a register can trash the frame chain, and
1102 modifying memory can trash the frame cache, we save the old frame
1103 and then restore the new frame afterwards. */
1105
1106 switch (VALUE_LVAL (toval))
1107 {
1108 case lval_internalvar:
1109 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1110 return value_of_internalvar (type->arch (),
1111 VALUE_INTERNALVAR (toval));
1112
1114 {
1115 LONGEST offset = value_offset (toval);
1116
1117 /* Are we dealing with a bitfield?
1118
1119 It is important to mention that `value_parent (toval)' is
1120 non-NULL iff `value_bitsize (toval)' is non-zero. */
1121 if (value_bitsize (toval))
1122 {
1123 /* VALUE_INTERNALVAR below refers to the parent value, while
1124 the offset is relative to this parent value. */
1125 gdb_assert (value_parent (value_parent (toval)) == NULL);
1126 offset += value_offset (value_parent (toval));
1127 }
1128
1130 offset,
1131 value_bitpos (toval),
1132 value_bitsize (toval),
1133 fromval);
1134 }
1135 break;
1136
1137 case lval_memory:
1138 {
1139 const gdb_byte *dest_buffer;
1140 CORE_ADDR changed_addr;
1141 int changed_len;
1142 gdb_byte buffer[sizeof (LONGEST)];
1143
1144 if (value_bitsize (toval))
1145 {
1146 struct value *parent = value_parent (toval);
1147
1148 changed_addr = value_address (parent) + value_offset (toval);
1149 changed_len = (value_bitpos (toval)
1150 + value_bitsize (toval)
1151 + HOST_CHAR_BIT - 1)
1152 / HOST_CHAR_BIT;
1153
1154 /* If we can read-modify-write exactly the size of the
1155 containing type (e.g. short or int) then do so. This
1156 is safer for volatile bitfields mapped to hardware
1157 registers. */
1158 if (changed_len < type->length ()
1159 && type->length () <= (int) sizeof (LONGEST)
1160 && ((LONGEST) changed_addr % type->length ()) == 0)
1161 changed_len = type->length ();
1162
1163 if (changed_len > (int) sizeof (LONGEST))
1164 error (_("Can't handle bitfields which "
1165 "don't fit in a %d bit word."),
1166 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1167
1168 read_memory (changed_addr, buffer, changed_len);
1169 modify_field (type, buffer, value_as_long (fromval),
1170 value_bitpos (toval), value_bitsize (toval));
1171 dest_buffer = buffer;
1172 }
1173 else
1174 {
1175 changed_addr = value_address (toval);
1176 changed_len = type_length_units (type);
1177 dest_buffer = value_contents (fromval).data ();
1178 }
1179
1180 write_memory_with_notification (changed_addr, dest_buffer, changed_len);
1181 }
1182 break;
1183
1184 case lval_register:
1185 {
1186 frame_info_ptr frame;
1187 struct gdbarch *gdbarch;
1188 int value_reg;
1189
1190 /* Figure out which frame this register value is in. The value
1191 holds the frame_id for the next frame, that is the frame this
1192 register value was unwound from.
1193
1194 Below we will call put_frame_register_bytes which requires that
1195 we pass it the actual frame in which the register value is
1196 valid, i.e. not the next frame. */
1197 frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (toval));
1198 frame = get_prev_frame_always (frame);
1199
1200 value_reg = VALUE_REGNUM (toval);
1201
1202 if (!frame)
1203 error (_("Value being assigned to is no longer active."));
1204
1205 gdbarch = get_frame_arch (frame);
1206
1207 if (value_bitsize (toval))
1208 {
1209 struct value *parent = value_parent (toval);
1210 LONGEST offset = value_offset (parent) + value_offset (toval);
1211 size_t changed_len;
1212 gdb_byte buffer[sizeof (LONGEST)];
1213 int optim, unavail;
1214
1215 changed_len = (value_bitpos (toval)
1216 + value_bitsize (toval)
1217 + HOST_CHAR_BIT - 1)
1218 / HOST_CHAR_BIT;
1219
1220 if (changed_len > sizeof (LONGEST))
1221 error (_("Can't handle bitfields which "
1222 "don't fit in a %d bit word."),
1223 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1224
1225 if (!get_frame_register_bytes (frame, value_reg, offset,
1226 {buffer, changed_len},
1227 &optim, &unavail))
1228 {
1229 if (optim)
1230 throw_error (OPTIMIZED_OUT_ERROR,
1231 _("value has been optimized out"));
1232 if (unavail)
1233 throw_error (NOT_AVAILABLE_ERROR,
1234 _("value is not available"));
1235 }
1236
1237 modify_field (type, buffer, value_as_long (fromval),
1238 value_bitpos (toval), value_bitsize (toval));
1239
1240 put_frame_register_bytes (frame, value_reg, offset,
1241 {buffer, changed_len});
1242 }
1243 else
1244 {
1246 type))
1247 {
1248 /* If TOVAL is a special machine register requiring
1249 conversion of program values to a special raw
1250 format. */
1252 VALUE_REGNUM (toval), type,
1253 value_contents (fromval).data ());
1254 }
1255 else
1256 put_frame_register_bytes (frame, value_reg,
1257 value_offset (toval),
1258 value_contents (fromval));
1259 }
1260
1261 gdb::observers::register_changed.notify (frame, value_reg);
1262 break;
1263 }
1264
1265 case lval_computed:
1266 {
1267 const struct lval_funcs *funcs = value_computed_funcs (toval);
1268
1269 if (funcs->write != NULL)
1270 {
1271 funcs->write (toval, fromval);
1272 break;
1273 }
1274 }
1275 /* Fall through. */
1276
1277 default:
1278 error (_("Left operand of assignment is not an lvalue."));
1279 }
1280
1281 /* Assigning to the stack pointer, frame pointer, and other
1282 (architecture and calling convention specific) registers may
1283 cause the frame cache and regcache to be out of date. Assigning to memory
1284 also can. We just do this on all assignments to registers or
1285 memory, for simplicity's sake; I doubt the slowdown matters. */
1286 switch (VALUE_LVAL (toval))
1287 {
1288 case lval_memory:
1289 case lval_register:
1290 case lval_computed:
1291
1293 (current_inferior ()->top_target ());
1294
1295 /* Having destroyed the frame cache, restore the selected
1296 frame. */
1297
1298 /* FIXME: cagney/2002-11-02: There has to be a better way of
1299 doing this. Instead of constantly saving/restoring the
1300 frame. Why not create a get_selected_frame() function that,
1301 having saved the selected frame's ID can automatically
1302 re-find the previously selected frame automatically. */
1303
1304 {
1305 frame_info_ptr fi = frame_find_by_id (old_frame);
1306
1307 if (fi != NULL)
1308 select_frame (fi);
1309 }
1310
1311 break;
1312 default:
1313 break;
1314 }
1315
1316 /* If the field does not entirely fill a LONGEST, then zero the sign
1317 bits. If the field is signed, and is negative, then sign
1318 extend. */
1319 if ((value_bitsize (toval) > 0)
1320 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1321 {
1322 LONGEST fieldval = value_as_long (fromval);
1323 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1324
1325 fieldval &= valmask;
1326 if (!type->is_unsigned ()
1327 && (fieldval & (valmask ^ (valmask >> 1))))
1328 fieldval |= ~valmask;
1329
1330 fromval = value_from_longest (type, fieldval);
1331 }
1332
1333 /* The return value is a copy of TOVAL so it shares its location
1334 information, but its contents are updated from FROMVAL. This
1335 implies the returned value is not lazy, even if TOVAL was. */
1336 val = value_copy (toval);
1337 set_value_lazy (val, 0);
1338 copy (value_contents (fromval), value_contents_raw (val));
1339
1340 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1341 in the case of pointer types. For object types, the enclosing type
1342 and embedded offset must *not* be copied: the target object refered
1343 to by TOVAL retains its original dynamic type after assignment. */
1344 if (type->code () == TYPE_CODE_PTR)
1345 {
1348 }
1349
1350 return val;
1351}
1352
1353/* Extend a value ARG1 to COUNT repetitions of its type. */
1354
1355struct value *
1356value_repeat (struct value *arg1, int count)
1357{
1358 struct value *val;
1359
1360 if (VALUE_LVAL (arg1) != lval_memory)
1361 error (_("Only values in memory can be extended with '@'."));
1362 if (count < 1)
1363 error (_("Invalid number %d of repetitions."), count);
1364
1365 val = allocate_repeat_value (value_enclosing_type (arg1), count);
1366
1367 VALUE_LVAL (val) = lval_memory;
1368 set_value_address (val, value_address (arg1));
1369
1370 read_value_memory (val, 0, value_stack (val), value_address (val),
1371 value_contents_all_raw (val).data (),
1373
1374 return val;
1375}
1376
1377struct value *
1378value_of_variable (struct symbol *var, const struct block *b)
1379{
1380 frame_info_ptr frame = NULL;
1381
1382 if (symbol_read_needs_frame (var))
1383 frame = get_selected_frame (_("No frame selected."));
1384
1385 return read_var_value (var, b, frame);
1386}
1387
1388struct value *
1389address_of_variable (struct symbol *var, const struct block *b)
1390{
1391 struct type *type = var->type ();
1392 struct value *val;
1393
1394 /* Evaluate it first; if the result is a memory address, we're fine.
1395 Lazy evaluation pays off here. */
1396
1397 val = value_of_variable (var, b);
1398 type = value_type (val);
1399
1400 if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1401 || type->code () == TYPE_CODE_FUNC)
1402 {
1403 CORE_ADDR addr = value_address (val);
1404
1406 }
1407
1408 /* Not a memory address; check what the problem was. */
1409 switch (VALUE_LVAL (val))
1410 {
1411 case lval_register:
1412 {
1413 frame_info_ptr frame;
1414 const char *regname;
1415
1416 frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val));
1417 gdb_assert (frame);
1418
1419 regname = gdbarch_register_name (get_frame_arch (frame),
1420 VALUE_REGNUM (val));
1421 gdb_assert (regname != nullptr && *regname != '\0');
1422
1423 error (_("Address requested for identifier "
1424 "\"%s\" which is in register $%s"),
1425 var->print_name (), regname);
1426 break;
1427 }
1428
1429 default:
1430 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1431 var->print_name ());
1432 break;
1433 }
1434
1435 return val;
1436}
1437
1438/* See value.h. */
1439
1440bool
1442{
1443 struct type *valtype;
1444
1445 /* The only lval kinds which do not live in target memory. */
1446 if (VALUE_LVAL (val) != not_lval
1447 && VALUE_LVAL (val) != lval_internalvar
1448 && VALUE_LVAL (val) != lval_xcallable)
1449 return false;
1450
1451 valtype = check_typedef (value_type (val));
1452
1453 switch (valtype->code ())
1454 {
1455 case TYPE_CODE_ARRAY:
1456 return valtype->is_vector () ? 0 : 1;
1457 case TYPE_CODE_STRING:
1458 return true;
1459 default:
1460 return false;
1461 }
1462}
1463
1464/* Make sure that VAL lives in target memory if it's supposed to. For
1465 instance, strings are constructed as character arrays in GDB's
1466 storage, and this function copies them to the target. */
1467
1468struct value *
1470{
1471 LONGEST length;
1472 CORE_ADDR addr;
1473
1474 if (!value_must_coerce_to_target (val))
1475 return val;
1476
1477 length = check_typedef (value_type (val))->length ();
1478 addr = allocate_space_in_inferior (length);
1479 write_memory (addr, value_contents (val).data (), length);
1480 return value_at_lazy (value_type (val), addr);
1481}
1482
1483/* Given a value which is an array, return a value which is a pointer
1484 to its first element, regardless of whether or not the array has a
1485 nonzero lower bound.
1486
1487 FIXME: A previous comment here indicated that this routine should
1488 be substracting the array's lower bound. It's not clear to me that
1489 this is correct. Given an array subscripting operation, it would
1490 certainly work to do the adjustment here, essentially computing:
1491
1492 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1493
1494 However I believe a more appropriate and logical place to account
1495 for the lower bound is to do so in value_subscript, essentially
1496 computing:
1497
1498 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1499
1500 As further evidence consider what would happen with operations
1501 other than array subscripting, where the caller would get back a
1502 value that had an address somewhere before the actual first element
1503 of the array, and the information about the lower bound would be
1504 lost because of the coercion to pointer type. */
1505
1506struct value *
1508{
1509 struct type *type = check_typedef (value_type (arg1));
1510
1511 /* If the user tries to do something requiring a pointer with an
1512 array that has not yet been pushed to the target, then this would
1513 be a good time to do so. */
1514 arg1 = value_coerce_to_target (arg1);
1515
1516 if (VALUE_LVAL (arg1) != lval_memory)
1517 error (_("Attempt to take address of value not located in memory."));
1518
1520 value_address (arg1));
1521}
1522
1523/* Given a value which is a function, return a value which is a pointer
1524 to it. */
1525
1526struct value *
1528{
1529 struct value *retval;
1530
1531 if (VALUE_LVAL (arg1) != lval_memory)
1532 error (_("Attempt to take address of value not located in memory."));
1533
1535 value_address (arg1));
1536 return retval;
1537}
1538
1539/* Return a pointer value for the object for which ARG1 is the
1540 contents. */
1541
1542struct value *
1543value_addr (struct value *arg1)
1544{
1545 struct value *arg2;
1546 struct type *type = check_typedef (value_type (arg1));
1547
1548 if (TYPE_IS_REFERENCE (type))
1549 {
1551 TARGET_CHAR_BIT * type->length ()))
1552 arg1 = coerce_ref (arg1);
1553 else
1554 {
1555 /* Copy the value, but change the type from (T&) to (T*). We
1556 keep the same location information, which is efficient, and
1557 allows &(&X) to get the location containing the reference.
1558 Do the same to its enclosing type for consistency. */
1559 struct type *type_ptr
1561 struct type *enclosing_type
1563 struct type *enclosing_type_ptr
1564 = lookup_pointer_type (enclosing_type->target_type ());
1565
1566 arg2 = value_copy (arg1);
1567 deprecated_set_value_type (arg2, type_ptr);
1568 set_value_enclosing_type (arg2, enclosing_type_ptr);
1569
1570 return arg2;
1571 }
1572 }
1573 if (type->code () == TYPE_CODE_FUNC)
1574 return value_coerce_function (arg1);
1575
1576 /* If this is an array that has not yet been pushed to the target,
1577 then this would be a good time to force it to memory. */
1578 arg1 = value_coerce_to_target (arg1);
1579
1580 if (VALUE_LVAL (arg1) != lval_memory)
1581 error (_("Attempt to take address of value not located in memory."));
1582
1583 /* Get target memory address. */
1585 (value_address (arg1)
1586 + value_embedded_offset (arg1)));
1587
1588 /* This may be a pointer to a base subobject; so remember the
1589 full derived object's type ... */
1592 /* ... and also the relative position of the subobject in the full
1593 object. */
1595 return arg2;
1596}
1597
1598/* Return a reference value for the object for which ARG1 is the
1599 contents. */
1600
1601struct value *
1602value_ref (struct value *arg1, enum type_code refcode)
1603{
1604 struct value *arg2;
1605 struct type *type = check_typedef (value_type (arg1));
1606
1607 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
1608
1609 if ((type->code () == TYPE_CODE_REF
1610 || type->code () == TYPE_CODE_RVALUE_REF)
1611 && type->code () == refcode)
1612 return arg1;
1613
1614 arg2 = value_addr (arg1);
1616 return arg2;
1617}
1618
1619/* Given a value of a pointer type, apply the C unary * operator to
1620 it. */
1621
1622struct value *
1623value_ind (struct value *arg1)
1624{
1625 struct type *base_type;
1626 struct value *arg2;
1627
1628 arg1 = coerce_array (arg1);
1629
1630 base_type = check_typedef (value_type (arg1));
1631
1632 if (VALUE_LVAL (arg1) == lval_computed)
1633 {
1634 const struct lval_funcs *funcs = value_computed_funcs (arg1);
1635
1636 if (funcs->indirect)
1637 {
1638 struct value *result = funcs->indirect (arg1);
1639
1640 if (result)
1641 return result;
1642 }
1643 }
1644
1645 if (base_type->code () == TYPE_CODE_PTR)
1646 {
1647 struct type *enc_type;
1648
1649 /* We may be pointing to something embedded in a larger object.
1650 Get the real type of the enclosing object. */
1651 enc_type = check_typedef (value_enclosing_type (arg1));
1652 enc_type = enc_type->target_type ();
1653
1654 CORE_ADDR base_addr;
1655 if (check_typedef (enc_type)->code () == TYPE_CODE_FUNC
1656 || check_typedef (enc_type)->code () == TYPE_CODE_METHOD)
1657 {
1658 /* For functions, go through find_function_addr, which knows
1659 how to handle function descriptors. */
1660 base_addr = find_function_addr (arg1, NULL);
1661 }
1662 else
1663 {
1664 /* Retrieve the enclosing object pointed to. */
1665 base_addr = (value_as_address (arg1)
1666 - value_pointed_to_offset (arg1));
1667 }
1668 arg2 = value_at_lazy (enc_type, base_addr);
1669 enc_type = value_type (arg2);
1670 return readjust_indirect_value_type (arg2, enc_type, base_type,
1671 arg1, base_addr);
1672 }
1673
1674 error (_("Attempt to take contents of a non-pointer value."));
1675}
1676
1677/* Create a value for an array by allocating space in GDB, copying the
1678 data into that space, and then setting up an array value.
1679
1680 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1681 is populated from the values passed in ELEMVEC.
1682
1683 The element type of the array is inherited from the type of the
1684 first element, and all elements must have the same size (though we
1685 don't currently enforce any restriction on their types). */
1686
1687struct value *
1688value_array (int lowbound, int highbound, struct value **elemvec)
1689{
1690 int nelem;
1691 int idx;
1692 ULONGEST typelength;
1693 struct value *val;
1694 struct type *arraytype;
1695
1696 /* Validate that the bounds are reasonable and that each of the
1697 elements have the same size. */
1698
1699 nelem = highbound - lowbound + 1;
1700 if (nelem <= 0)
1701 {
1702 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1703 }
1704 typelength = type_length_units (value_enclosing_type (elemvec[0]));
1705 for (idx = 1; idx < nelem; idx++)
1706 {
1707 if (type_length_units (value_enclosing_type (elemvec[idx]))
1708 != typelength)
1709 {
1710 error (_("array elements must all be the same size"));
1711 }
1712 }
1713
1714 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1715 lowbound, highbound);
1716
1718 {
1719 val = allocate_value (arraytype);
1720 for (idx = 0; idx < nelem; idx++)
1721 value_contents_copy (val, idx * typelength, elemvec[idx], 0,
1722 typelength);
1723 return val;
1724 }
1725
1726 /* Allocate space to store the array, and then initialize it by
1727 copying in each element. */
1728
1729 val = allocate_value (arraytype);
1730 for (idx = 0; idx < nelem; idx++)
1731 value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength);
1732 return val;
1733}
1734
1735struct value *
1736value_cstring (const char *ptr, ssize_t len, struct type *char_type)
1737{
1738 struct value *val;
1739 int lowbound = current_language->string_lower_bound ();
1740 ssize_t highbound = len / char_type->length ();
1741 struct type *stringtype
1742 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1743
1744 val = allocate_value (stringtype);
1745 memcpy (value_contents_raw (val).data (), ptr, len);
1746 return val;
1747}
1748
1749/* Create a value for a string constant by allocating space in the
1750 inferior, copying the data into that space, and returning the
1751 address with type TYPE_CODE_STRING. PTR points to the string
1752 constant data; LEN is number of characters.
1753
1754 Note that string types are like array of char types with a lower
1755 bound of zero and an upper bound of LEN - 1. Also note that the
1756 string may contain embedded null bytes. */
1757
1758struct value *
1759value_string (const char *ptr, ssize_t len, struct type *char_type)
1760{
1761 struct value *val;
1762 int lowbound = current_language->string_lower_bound ();
1763 ssize_t highbound = len / char_type->length ();
1764 struct type *stringtype
1765 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1766
1767 val = allocate_value (stringtype);
1768 memcpy (value_contents_raw (val).data (), ptr, len);
1769 return val;
1770}
1771
1772
1773/* See if we can pass arguments in T2 to a function which takes arguments
1774 of types T1. T1 is a list of NARGS arguments, and T2 is an array_view
1775 of the values we're trying to pass. If some arguments need coercion of
1776 some sort, then the coerced values are written into T2. Return value is
1777 0 if the arguments could be matched, or the position at which they
1778 differ if not.
1779
1780 STATICP is nonzero if the T1 argument list came from a static
1781 member function. T2 must still include the ``this'' pointer, but
1782 it will be skipped.
1783
1784 For non-static member functions, we ignore the first argument,
1785 which is the type of the instance variable. This is because we
1786 want to handle calls with objects from derived classes. This is
1787 not entirely correct: we should actually check to make sure that a
1788 requested operation is type secure, shouldn't we? FIXME. */
1789
1790static int
1791typecmp (bool staticp, bool varargs, int nargs,
1792 struct field t1[], gdb::array_view<value *> t2)
1793{
1794 int i;
1795
1796 /* Skip ``this'' argument if applicable. T2 will always include
1797 THIS. */
1798 if (staticp)
1799 t2 = t2.slice (1);
1800
1801 for (i = 0;
1802 (i < nargs) && t1[i].type ()->code () != TYPE_CODE_VOID;
1803 i++)
1804 {
1805 struct type *tt1, *tt2;
1806
1807 if (i == t2.size ())
1808 return i + 1;
1809
1810 tt1 = check_typedef (t1[i].type ());
1811 tt2 = check_typedef (value_type (t2[i]));
1812
1813 if (TYPE_IS_REFERENCE (tt1)
1814 /* We should be doing hairy argument matching, as below. */
1815 && (check_typedef (tt1->target_type ())->code ()
1816 == tt2->code ()))
1817 {
1818 if (tt2->code () == TYPE_CODE_ARRAY)
1819 t2[i] = value_coerce_array (t2[i]);
1820 else
1821 t2[i] = value_ref (t2[i], tt1->code ());
1822 continue;
1823 }
1824
1825 /* djb - 20000715 - Until the new type structure is in the
1826 place, and we can attempt things like implicit conversions,
1827 we need to do this so you can take something like a map<const
1828 char *>, and properly access map["hello"], because the
1829 argument to [] will be a reference to a pointer to a char,
1830 and the argument will be a pointer to a char. */
1831 while (TYPE_IS_REFERENCE (tt1) || tt1->code () == TYPE_CODE_PTR)
1832 {
1833 tt1 = check_typedef ( tt1->target_type () );
1834 }
1835 while (tt2->code () == TYPE_CODE_ARRAY
1836 || tt2->code () == TYPE_CODE_PTR
1837 || TYPE_IS_REFERENCE (tt2))
1838 {
1839 tt2 = check_typedef (tt2->target_type ());
1840 }
1841 if (tt1->code () == tt2->code ())
1842 continue;
1843 /* Array to pointer is a `trivial conversion' according to the
1844 ARM. */
1845
1846 /* We should be doing much hairier argument matching (see
1847 section 13.2 of the ARM), but as a quick kludge, just check
1848 for the same type code. */
1849 if (t1[i].type ()->code () != value_type (t2[i])->code ())
1850 return i + 1;
1851 }
1852 if (varargs || i == t2.size ())
1853 return 0;
1854 return i + 1;
1855}
1856
1857/* Helper class for search_struct_field that keeps track of found
1858 results and possibly throws an exception if the search yields
1859 ambiguous results. See search_struct_field for description of
1860 LOOKING_FOR_BASECLASS. */
1861
1863{
1864 /* A found field. */
1866 {
1867 /* Path to the structure where the field was found. */
1868 std::vector<struct type *> path;
1869
1870 /* The field found. */
1872 };
1873
1874 /* See corresponding fields for description of parameters. */
1876 struct type *outermost_type,
1877 bool looking_for_baseclass)
1878 : m_name (name),
1879 m_looking_for_baseclass (looking_for_baseclass),
1880 m_outermost_type (outermost_type)
1881 {
1882 }
1883
1884 /* The search entry point. If LOOKING_FOR_BASECLASS is true and the
1885 base class search yields ambiguous results, this throws an
1886 exception. If LOOKING_FOR_BASECLASS is false, the found fields
1887 are accumulated and the caller (search_struct_field) takes care
1888 of throwing an error if the field search yields ambiguous
1889 results. The latter is done that way so that the error message
1890 can include a list of all the found candidates. */
1891 void search (struct value *arg, LONGEST offset, struct type *type);
1892
1893 const std::vector<found_field> &fields ()
1894 {
1895 return m_fields;
1896 }
1897
1898 struct value *baseclass ()
1899 {
1900 return m_baseclass;
1901 }
1902
1903private:
1904 /* Update results to include V, a found field/baseclass. */
1905 void update_result (struct value *v, LONGEST boffset);
1906
1907 /* The name of the field/baseclass we're searching for. */
1908 const char *m_name;
1909
1910 /* Whether we're looking for a baseclass, or a field. */
1912
1913 /* The offset of the baseclass containing the field/baseclass we
1914 last recorded. */
1915 LONGEST m_last_boffset = 0;
1916
1917 /* If looking for a baseclass, then the result is stored here. */
1918 struct value *m_baseclass = nullptr;
1919
1920 /* When looking for fields, the found candidates are stored
1921 here. */
1922 std::vector<found_field> m_fields;
1923
1924 /* The type of the initial type passed to search_struct_field; this
1925 is used for error reporting when the lookup is ambiguous. */
1927
1928 /* The full path to the struct being inspected. E.g. for field 'x'
1929 defined in class B inherited by class A, we have A and B pushed
1930 on the path. */
1931 std::vector <struct type *> m_struct_path;
1932};
1933
1934void
1936{
1937 if (v != NULL)
1938 {
1940 {
1941 if (m_baseclass != nullptr
1942 /* The result is not ambiguous if all the classes that are
1943 found occupy the same space. */
1944 && m_last_boffset != boffset)
1945 error (_("base class '%s' is ambiguous in type '%s'"),
1947
1948 m_baseclass = v;
1949 m_last_boffset = boffset;
1950 }
1951 else
1952 {
1953 /* The field is not ambiguous if it occupies the same
1954 space. */
1955 if (m_fields.empty () || m_last_boffset != boffset)
1956 m_fields.push_back ({m_struct_path, v});
1957 else
1958 {
1959 /*Fields can occupy the same space and have the same name (be
1960 ambiguous). This can happen when fields in two different base
1961 classes are marked [[no_unique_address]] and have the same name.
1962 The C++ standard says that such fields can only occupy the same
1963 space if they are of different type, but we don't rely on that in
1964 the following code. */
1965 bool ambiguous = false, insert = true;
1966 for (const found_field &field: m_fields)
1967 {
1968 if(field.path.back () != m_struct_path.back ())
1969 {
1970 /* Same boffset points to members of different classes.
1971 We have found an ambiguity and should record it. */
1972 ambiguous = true;
1973 }
1974 else
1975 {
1976 /* We don't need to insert this value again, because a
1977 non-ambiguous path already leads to it. */
1978 insert = false;
1979 break;
1980 }
1981 }
1982 if (ambiguous && insert)
1983 m_fields.push_back ({m_struct_path, v});
1984 }
1985 }
1986 }
1987}
1988
1989/* A helper for search_struct_field. This does all the work; most
1990 arguments are as passed to search_struct_field. */
1991
1992void
1993struct_field_searcher::search (struct value *arg1, LONGEST offset,
1994 struct type *type)
1995{
1996 int i;
1997 int nbases;
1998
1999 m_struct_path.push_back (type);
2000 SCOPE_EXIT { m_struct_path.pop_back (); };
2001
2003 nbases = TYPE_N_BASECLASSES (type);
2004
2006 for (i = type->num_fields () - 1; i >= nbases; i--)
2007 {
2008 const char *t_field_name = type->field (i).name ();
2009
2010 if (t_field_name && (strcmp_iw (t_field_name, m_name) == 0))
2011 {
2012 struct value *v;
2013
2014 if (field_is_static (&type->field (i)))
2015 v = value_static_field (type, i);
2016 else
2017 v = value_primitive_field (arg1, offset, i, type);
2018
2019 update_result (v, offset);
2020 return;
2021 }
2022
2023 if (t_field_name
2024 && t_field_name[0] == '\0')
2025 {
2026 struct type *field_type = type->field (i).type ();
2027
2028 if (field_type->code () == TYPE_CODE_UNION
2029 || field_type->code () == TYPE_CODE_STRUCT)
2030 {
2031 /* Look for a match through the fields of an anonymous
2032 union, or anonymous struct. C++ provides anonymous
2033 unions.
2034
2035 In the GNU Chill (now deleted from GDB)
2036 implementation of variant record types, each
2037 <alternative field> has an (anonymous) union type,
2038 each member of the union represents a <variant
2039 alternative>. Each <variant alternative> is
2040 represented as a struct, with a member for each
2041 <variant field>. */
2042
2043 LONGEST new_offset = offset;
2044
2045 /* This is pretty gross. In G++, the offset in an
2046 anonymous union is relative to the beginning of the
2047 enclosing struct. In the GNU Chill (now deleted
2048 from GDB) implementation of variant records, the
2049 bitpos is zero in an anonymous union field, so we
2050 have to add the offset of the union here. */
2051 if (field_type->code () == TYPE_CODE_STRUCT
2052 || (field_type->num_fields () > 0
2053 && field_type->field (0).loc_bitpos () == 0))
2054 new_offset += type->field (i).loc_bitpos () / 8;
2055
2056 search (arg1, new_offset, field_type);
2057 }
2058 }
2059 }
2060
2061 for (i = 0; i < nbases; i++)
2062 {
2063 struct value *v = NULL;
2064 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2065 /* If we are looking for baseclasses, this is what we get when
2066 we hit them. But it could happen that the base part's member
2067 name is not yet filled in. */
2068 int found_baseclass = (m_looking_for_baseclass
2069 && TYPE_BASECLASS_NAME (type, i) != NULL
2070 && (strcmp_iw (m_name, basetype->name ()) == 0));
2071 LONGEST boffset = value_embedded_offset (arg1) + offset;
2072
2073 if (BASETYPE_VIA_VIRTUAL (type, i))
2074 {
2075 struct value *v2;
2076
2077 boffset = baseclass_offset (type, i,
2078 value_contents_for_printing (arg1).data (),
2079 value_embedded_offset (arg1) + offset,
2080 value_address (arg1),
2081 arg1);
2082
2083 /* The virtual base class pointer might have been clobbered
2084 by the user program. Make sure that it still points to a
2085 valid memory location. */
2086
2087 boffset += value_embedded_offset (arg1) + offset;
2088 if (boffset < 0
2089 || boffset >= value_enclosing_type (arg1)->length ())
2090 {
2091 CORE_ADDR base_addr;
2092
2093 base_addr = value_address (arg1) + boffset;
2094 v2 = value_at_lazy (basetype, base_addr);
2095 if (target_read_memory (base_addr,
2096 value_contents_raw (v2).data (),
2097 value_type (v2)->length ()) != 0)
2098 error (_("virtual baseclass botch"));
2099 }
2100 else
2101 {
2102 v2 = value_copy (arg1);
2103 deprecated_set_value_type (v2, basetype);
2104 set_value_embedded_offset (v2, boffset);
2105 }
2106
2107 if (found_baseclass)
2108 v = v2;
2109 else
2110 search (v2, 0, TYPE_BASECLASS (type, i));
2111 }
2112 else if (found_baseclass)
2113 v = value_primitive_field (arg1, offset, i, type);
2114 else
2115 {
2116 search (arg1, offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2117 basetype);
2118 }
2119
2120 update_result (v, boffset);
2121 }
2122}
2123
2124/* Helper function used by value_struct_elt to recurse through
2125 baseclasses. Look for a field NAME in ARG1. Search in it assuming
2126 it has (class) type TYPE. If found, return value, else return NULL.
2127
2128 If LOOKING_FOR_BASECLASS, then instead of looking for struct
2129 fields, look for a baseclass named NAME. */
2130
2131static struct value *
2132search_struct_field (const char *name, struct value *arg1,
2133 struct type *type, int looking_for_baseclass)
2134{
2135 struct_field_searcher searcher (name, type, looking_for_baseclass);
2136
2137 searcher.search (arg1, 0, type);
2138
2139 if (!looking_for_baseclass)
2140 {
2141 const auto &fields = searcher.fields ();
2142
2143 if (fields.empty ())
2144 return nullptr;
2145 else if (fields.size () == 1)
2146 return fields[0].field_value;
2147 else
2148 {
2149 std::string candidates;
2150
2151 for (auto &&candidate : fields)
2152 {
2153 gdb_assert (!candidate.path.empty ());
2154
2155 struct type *field_type = value_type (candidate.field_value);
2156 struct type *struct_type = candidate.path.back ();
2157
2158 std::string path;
2159 bool first = true;
2160 for (struct type *t : candidate.path)
2161 {
2162 if (first)
2163 first = false;
2164 else
2165 path += " -> ";
2166 path += t->name ();
2167 }
2168
2169 candidates += string_printf ("\n '%s %s::%s' (%s)",
2170 TYPE_SAFE_NAME (field_type),
2171 TYPE_SAFE_NAME (struct_type),
2172 name,
2173 path.c_str ());
2174 }
2175
2176 error (_("Request for member '%s' is ambiguous in type '%s'."
2177 " Candidates are:%s"),
2179 candidates.c_str ());
2180 }
2181 }
2182 else
2183 return searcher.baseclass ();
2184}
2185
2186/* Helper function used by value_struct_elt to recurse through
2187 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2188 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2189 TYPE.
2190
2191 ARGS is an optional array of argument values used to help finding NAME.
2192 The contents of ARGS can be adjusted if type coercion is required in
2193 order to find a matching NAME.
2194
2195 If found, return value, else if name matched and args not return
2196 (value) -1, else return NULL. */
2197
2198static struct value *
2199search_struct_method (const char *name, struct value **arg1p,
2200 gdb::optional<gdb::array_view<value *>> args,
2201 LONGEST offset, int *static_memfuncp,
2202 struct type *type)
2203{
2204 int i;
2205 struct value *v;
2206 int name_matched = 0;
2207
2209 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2210 {
2211 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2212
2213 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2214 {
2215 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2216 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2217
2218 name_matched = 1;
2220 if (j > 0 && !args.has_value ())
2221 error (_("cannot resolve overloaded method "
2222 "`%s': no arguments supplied"), name);
2223 else if (j == 0 && !args.has_value ())
2224 {
2225 v = value_fn_field (arg1p, f, j, type, offset);
2226 if (v != NULL)
2227 return v;
2228 }
2229 else
2230 while (j >= 0)
2231 {
2232 gdb_assert (args.has_value ());
2233 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2234 TYPE_FN_FIELD_TYPE (f, j)->has_varargs (),
2235 TYPE_FN_FIELD_TYPE (f, j)->num_fields (),
2236 TYPE_FN_FIELD_ARGS (f, j), *args))
2237 {
2238 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2239 return value_virtual_fn_field (arg1p, f, j,
2240 type, offset);
2241 if (TYPE_FN_FIELD_STATIC_P (f, j)
2242 && static_memfuncp)
2243 *static_memfuncp = 1;
2244 v = value_fn_field (arg1p, f, j, type, offset);
2245 if (v != NULL)
2246 return v;
2247 }
2248 j--;
2249 }
2250 }
2251 }
2252
2253 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2254 {
2255 LONGEST base_offset;
2256 LONGEST this_offset;
2257
2258 if (BASETYPE_VIA_VIRTUAL (type, i))
2259 {
2260 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2261 struct value *base_val;
2262 const gdb_byte *base_valaddr;
2263
2264 /* The virtual base class pointer might have been
2265 clobbered by the user program. Make sure that it
2266 still points to a valid memory location. */
2267
2268 if (offset < 0 || offset >= type->length ())
2269 {
2270 CORE_ADDR address;
2271
2272 gdb::byte_vector tmp (baseclass->length ());
2273 address = value_address (*arg1p);
2274
2276 tmp.data (), baseclass->length ()) != 0)
2277 error (_("virtual baseclass botch"));
2278
2279 base_val = value_from_contents_and_address (baseclass,
2280 tmp.data (),
2281 address + offset);
2282 base_valaddr = value_contents_for_printing (base_val).data ();
2283 this_offset = 0;
2284 }
2285 else
2286 {
2287 base_val = *arg1p;
2288 base_valaddr = value_contents_for_printing (*arg1p).data ();
2289 this_offset = offset;
2290 }
2291
2292 base_offset = baseclass_offset (type, i, base_valaddr,
2293 this_offset, value_address (base_val),
2294 base_val);
2295 }
2296 else
2297 {
2298 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2299 }
2300 v = search_struct_method (name, arg1p, args, base_offset + offset,
2301 static_memfuncp, TYPE_BASECLASS (type, i));
2302 if (v == (struct value *) - 1)
2303 {
2304 name_matched = 1;
2305 }
2306 else if (v)
2307 {
2308 /* FIXME-bothner: Why is this commented out? Why is it here? */
2309 /* *arg1p = arg1_tmp; */
2310 return v;
2311 }
2312 }
2313 if (name_matched)
2314 return (struct value *) - 1;
2315 else
2316 return NULL;
2317}
2318
2319/* Given *ARGP, a value of type (pointer to a)* structure/union,
2320 extract the component named NAME from the ultimate target
2321 structure/union and return it as a value with its appropriate type.
2322 ERR is used in the error message if *ARGP's type is wrong.
2323
2324 C++: ARGS is a list of argument types to aid in the selection of
2325 an appropriate method. Also, handle derived types.
2326
2327 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2328 where the truthvalue of whether the function that was resolved was
2329 a static member function or not is stored.
2330
2331 ERR is an error message to be printed in case the field is not
2332 found. */
2333
2334struct value *
2336 gdb::optional<gdb::array_view<value *>> args,
2337 const char *name, int *static_memfuncp, const char *err)
2338{
2339 struct type *t;
2340 struct value *v;
2341
2342 *argp = coerce_array (*argp);
2343
2344 t = check_typedef (value_type (*argp));
2345
2346 /* Follow pointers until we get to a non-pointer. */
2347
2348 while (t->is_pointer_or_reference ())
2349 {
2350 *argp = value_ind (*argp);
2351 /* Don't coerce fn pointer to fn and then back again! */
2352 if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
2353 *argp = coerce_array (*argp);
2354 t = check_typedef (value_type (*argp));
2355 }
2356
2357 if (t->code () != TYPE_CODE_STRUCT
2358 && t->code () != TYPE_CODE_UNION)
2359 error (_("Attempt to extract a component of a value that is not a %s."),
2360 err);
2361
2362 /* Assume it's not, unless we see that it is. */
2363 if (static_memfuncp)
2364 *static_memfuncp = 0;
2365
2366 if (!args.has_value ())
2367 {
2368 /* if there are no arguments ...do this... */
2369
2370 /* Try as a field first, because if we succeed, there is less
2371 work to be done. */
2372 v = search_struct_field (name, *argp, t, 0);
2373 if (v)
2374 return v;
2375
2377 {
2378 /* If it is not a field it is the type name of an inherited
2379 structure. */
2380 v = search_struct_field (name, *argp, t, 1);
2381 if (v)
2382 return v;
2383 }
2384
2385 /* C++: If it was not found as a data field, then try to
2386 return it as a pointer to a method. */
2387 v = search_struct_method (name, argp, args, 0,
2388 static_memfuncp, t);
2389
2390 if (v == (struct value *) - 1)
2391 error (_("Cannot take address of method %s."), name);
2392 else if (v == 0)
2393 {
2394 if (TYPE_NFN_FIELDS (t))
2395 error (_("There is no member or method named %s."), name);
2396 else
2397 error (_("There is no member named %s."), name);
2398 }
2399 return v;
2400 }
2401
2402 v = search_struct_method (name, argp, args, 0,
2403 static_memfuncp, t);
2404
2405 if (v == (struct value *) - 1)
2406 {
2407 error (_("One of the arguments you tried to pass to %s could not "
2408 "be converted to what the function wants."), name);
2409 }
2410 else if (v == 0)
2411 {
2412 /* See if user tried to invoke data as function. If so, hand it
2413 back. If it's not callable (i.e., a pointer to function),
2414 gdb should give an error. */
2415 v = search_struct_field (name, *argp, t, 0);
2416 /* If we found an ordinary field, then it is not a method call.
2417 So, treat it as if it were a static member function. */
2418 if (v && static_memfuncp)
2419 *static_memfuncp = 1;
2420 }
2421
2422 if (!v)
2423 throw_error (NOT_FOUND_ERROR,
2424 _("Structure has no component named %s."), name);
2425 return v;
2426}
2427
2428/* Given *ARGP, a value of type structure or union, or a pointer/reference
2429 to a structure or union, extract and return its component (field) of
2430 type FTYPE at the specified BITPOS.
2431 Throw an exception on error. */
2432
2433struct value *
2434value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
2435 const char *err)
2436{
2437 struct type *t;
2438 int i;
2439
2440 *argp = coerce_array (*argp);
2441
2442 t = check_typedef (value_type (*argp));
2443
2444 while (t->is_pointer_or_reference ())
2445 {
2446 *argp = value_ind (*argp);
2447 if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
2448 *argp = coerce_array (*argp);
2449 t = check_typedef (value_type (*argp));
2450 }
2451
2452 if (t->code () != TYPE_CODE_STRUCT
2453 && t->code () != TYPE_CODE_UNION)
2454 error (_("Attempt to extract a component of a value that is not a %s."),
2455 err);
2456
2457 for (i = TYPE_N_BASECLASSES (t); i < t->num_fields (); i++)
2458 {
2459 if (!field_is_static (&t->field (i))
2460 && bitpos == t->field (i).loc_bitpos ()
2461 && types_equal (ftype, t->field (i).type ()))
2462 return value_primitive_field (*argp, 0, i, t);
2463 }
2464
2465 error (_("No field with matching bitpos and type."));
2466
2467 /* Never hit. */
2468 return NULL;
2469}
2470
2471/* Search through the methods of an object (and its bases) to find a
2472 specified method. Return a reference to the fn_field list METHODS of
2473 overloaded instances defined in the source language. If available
2474 and matching, a vector of matching xmethods defined in extension
2475 languages are also returned in XMETHODS.
2476
2477 Helper function for value_find_oload_list.
2478 ARGP is a pointer to a pointer to a value (the object).
2479 METHOD is a string containing the method name.
2480 OFFSET is the offset within the value.
2481 TYPE is the assumed type of the object.
2482 METHODS is a pointer to the matching overloaded instances defined
2483 in the source language. Since this is a recursive function,
2484 *METHODS should be set to NULL when calling this function.
2485 NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2486 0 when calling this function.
2487 XMETHODS is the vector of matching xmethod workers. *XMETHODS
2488 should also be set to NULL when calling this function.
2489 BASETYPE is set to the actual type of the subobject where the
2490 method is found.
2491 BOFFSET is the offset of the base subobject where the method is found. */
2492
2493static void
2494find_method_list (struct value **argp, const char *method,
2495 LONGEST offset, struct type *type,
2496 gdb::array_view<fn_field> *methods,
2497 std::vector<xmethod_worker_up> *xmethods,
2498 struct type **basetype, LONGEST *boffset)
2499{
2500 int i;
2501 struct fn_field *f = NULL;
2502
2503 gdb_assert (methods != NULL && xmethods != NULL);
2505
2506 /* First check in object itself.
2507 This function is called recursively to search through base classes.
2508 If there is a source method match found at some stage, then we need not
2509 look for source methods in consequent recursive calls. */
2510 if (methods->empty ())
2511 {
2512 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2513 {
2514 /* pai: FIXME What about operators and type conversions? */
2515 const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2516
2517 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2518 {
2519 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2520 f = TYPE_FN_FIELDLIST1 (type, i);
2521 *methods = gdb::make_array_view (f, len);
2522
2523 *basetype = type;
2524 *boffset = offset;
2525
2526 /* Resolve any stub methods. */
2528
2529 break;
2530 }
2531 }
2532 }
2533
2534 /* Unlike source methods, xmethods can be accumulated over successive
2535 recursive calls. In other words, an xmethod named 'm' in a class
2536 will not hide an xmethod named 'm' in its base class(es). We want
2537 it to be this way because xmethods are after all convenience functions
2538 and hence there is no point restricting them with something like method
2539 hiding. Moreover, if hiding is done for xmethods as well, then we will
2540 have to provide a mechanism to un-hide (like the 'using' construct). */
2541 get_matching_xmethod_workers (type, method, xmethods);
2542
2543 /* If source methods are not found in current class, look for them in the
2544 base classes. We also have to go through the base classes to gather
2545 extension methods. */
2546 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2547 {
2548 LONGEST base_offset;
2549
2550 if (BASETYPE_VIA_VIRTUAL (type, i))
2551 {
2552 base_offset = baseclass_offset (type, i,
2553 value_contents_for_printing (*argp).data (),
2554 value_offset (*argp) + offset,
2555 value_address (*argp), *argp);
2556 }
2557 else /* Non-virtual base, simply use bit position from debug
2558 info. */
2559 {
2560 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2561 }
2562
2563 find_method_list (argp, method, base_offset + offset,
2564 TYPE_BASECLASS (type, i), methods,
2565 xmethods, basetype, boffset);
2566 }
2567}
2568
2569/* Return the list of overloaded methods of a specified name. The methods
2570 could be those GDB finds in the binary, or xmethod. Methods found in
2571 the binary are returned in METHODS, and xmethods are returned in
2572 XMETHODS.
2573
2574 ARGP is a pointer to a pointer to a value (the object).
2575 METHOD is the method name.
2576 OFFSET is the offset within the value contents.
2577 METHODS is the list of matching overloaded instances defined in
2578 the source language.
2579 XMETHODS is the vector of matching xmethod workers defined in
2580 extension languages.
2581 BASETYPE is set to the type of the base subobject that defines the
2582 method.
2583 BOFFSET is the offset of the base subobject which defines the method. */
2584
2585static void
2586value_find_oload_method_list (struct value **argp, const char *method,
2587 LONGEST offset,
2588 gdb::array_view<fn_field> *methods,
2589 std::vector<xmethod_worker_up> *xmethods,
2590 struct type **basetype, LONGEST *boffset)
2591{
2592 struct type *t;
2593
2594 t = check_typedef (value_type (*argp));
2595
2596 /* Code snarfed from value_struct_elt. */
2597 while (t->is_pointer_or_reference ())
2598 {
2599 *argp = value_ind (*argp);
2600 /* Don't coerce fn pointer to fn and then back again! */
2601 if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
2602 *argp = coerce_array (*argp);
2603 t = check_typedef (value_type (*argp));
2604 }
2605
2606 if (t->code () != TYPE_CODE_STRUCT
2607 && t->code () != TYPE_CODE_UNION)
2608 error (_("Attempt to extract a component of a "
2609 "value that is not a struct or union"));
2610
2611 gdb_assert (methods != NULL && xmethods != NULL);
2612
2613 /* Clear the lists. */
2614 *methods = {};
2615 xmethods->clear ();
2616
2617 find_method_list (argp, method, 0, t, methods, xmethods,
2618 basetype, boffset);
2619}
2620
2621/* Helper function for find_overload_match. If no matches were
2622 found, this function may generate a hint for the user that some
2623 of the relevant types are incomplete, so GDB can't evaluate
2624 type relationships to properly evaluate overloads.
2625
2626 If no incomplete types are present, an empty string is returned. */
2627static std::string
2628incomplete_type_hint (gdb::array_view<value *> args)
2629{
2630 int incomplete_types = 0;
2631 std::string incomplete_arg_names;
2632 for (const struct value *arg : args)
2633 {
2634 struct type *t = value_type (arg);
2635 while (t->code () == TYPE_CODE_PTR)
2636 t = t->target_type ();
2637 if (t->is_stub ())
2638 {
2639 string_file buffer;
2640 if (incomplete_types > 0)
2641 incomplete_arg_names += ", ";
2642
2643 current_language->print_type (value_type (arg), "", &buffer,
2644 -1, 0, &type_print_raw_options);
2645
2646 incomplete_types++;
2647 incomplete_arg_names += buffer.string ();
2648 }
2649 }
2650 std::string hint;
2651 if (incomplete_types > 1)
2652 hint = string_printf (_("\nThe types: '%s' aren't fully known to GDB."
2653 " Please cast them directly to the desired"
2654 " typed in the function call."),
2655 incomplete_arg_names.c_str ());
2656 else if (incomplete_types == 1)
2657 hint = string_printf (_("\nThe type: '%s' isn't fully known to GDB."
2658 " Please cast it directly to the desired"
2659 " typed in the function call."),
2660 incomplete_arg_names.c_str ());
2661 return hint;
2662}
2663
2664/* Given an array of arguments (ARGS) (which includes an entry for
2665 "this" in the case of C++ methods), the NAME of a function, and
2666 whether it's a method or not (METHOD), find the best function that
2667 matches on the argument types according to the overload resolution
2668 rules.
2669
2670 METHOD can be one of three values:
2671 NON_METHOD for non-member functions.
2672 METHOD: for member functions.
2673 BOTH: used for overload resolution of operators where the
2674 candidates are expected to be either member or non member
2675 functions. In this case the first argument ARGTYPES
2676 (representing 'this') is expected to be a reference to the
2677 target object, and will be dereferenced when attempting the
2678 non-member search.
2679
2680 In the case of class methods, the parameter OBJ is an object value
2681 in which to search for overloaded methods.
2682
2683 In the case of non-method functions, the parameter FSYM is a symbol
2684 corresponding to one of the overloaded functions.
2685
2686 Return value is an integer: 0 -> good match, 10 -> debugger applied
2687 non-standard coercions, 100 -> incompatible.
2688
2689 If a method is being searched for, VALP will hold the value.
2690 If a non-method is being searched for, SYMP will hold the symbol
2691 for it.
2692
2693 If a method is being searched for, and it is a static method,
2694 then STATICP will point to a non-zero value.
2695
2696 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2697 ADL overload candidates when performing overload resolution for a fully
2698 qualified name.
2699
2700 If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2701 read while picking the best overload match (it may be all zeroes and thus
2702 not have a vtable pointer), in which case skip virtual function lookup.
2703 This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2704 the result type.
2705
2706 Note: This function does *not* check the value of
2707 overload_resolution. Caller must check it to see whether overload
2708 resolution is permitted. */
2709
2710int
2711find_overload_match (gdb::array_view<value *> args,
2712 const char *name, enum oload_search_type method,
2713 struct value **objp, struct symbol *fsym,
2714 struct value **valp, struct symbol **symp,
2715 int *staticp, const int no_adl,
2716 const enum noside noside)
2717{
2718 struct value *obj = (objp ? *objp : NULL);
2719 struct type *obj_type = obj ? value_type (obj) : NULL;
2720 /* Index of best overloaded function. */
2721 int func_oload_champ = -1;
2722 int method_oload_champ = -1;
2723 int src_method_oload_champ = -1;
2724 int ext_method_oload_champ = -1;
2725
2726 /* The measure for the current best match. */
2727 badness_vector method_badness;
2728 badness_vector func_badness;
2729 badness_vector ext_method_badness;
2730 badness_vector src_method_badness;
2731
2732 struct value *temp = obj;
2733 /* For methods, the list of overloaded methods. */
2734 gdb::array_view<fn_field> methods;
2735 /* For non-methods, the list of overloaded function symbols. */
2736 std::vector<symbol *> functions;
2737 /* For xmethods, the vector of xmethod workers. */
2738 std::vector<xmethod_worker_up> xmethods;
2739 struct type *basetype = NULL;
2740 LONGEST boffset;
2741
2742 const char *obj_type_name = NULL;
2743 const char *func_name = NULL;
2744 gdb::unique_xmalloc_ptr<char> temp_func;
2745 enum oload_classification match_quality;
2746 enum oload_classification method_match_quality = INCOMPATIBLE;
2747 enum oload_classification src_method_match_quality = INCOMPATIBLE;
2748 enum oload_classification ext_method_match_quality = INCOMPATIBLE;
2749 enum oload_classification func_match_quality = INCOMPATIBLE;
2750
2751 /* Get the list of overloaded methods or functions. */
2752 if (method == METHOD || method == BOTH)
2753 {
2754 gdb_assert (obj);
2755
2756 /* OBJ may be a pointer value rather than the object itself. */
2757 obj = coerce_ref (obj);
2758 while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR)
2759 obj = coerce_ref (value_ind (obj));
2760 obj_type_name = value_type (obj)->name ();
2761
2762 /* First check whether this is a data member, e.g. a pointer to
2763 a function. */
2764 if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT)
2765 {
2766 *valp = search_struct_field (name, obj,
2767 check_typedef (value_type (obj)), 0);
2768 if (*valp)
2769 {
2770 *staticp = 1;
2771 return 0;
2772 }
2773 }
2774
2775 /* Retrieve the list of methods with the name NAME. */
2776 value_find_oload_method_list (&temp, name, 0, &methods,
2777 &xmethods, &basetype, &boffset);
2778 /* If this is a method only search, and no methods were found
2779 the search has failed. */
2780 if (method == METHOD && methods.empty () && xmethods.empty ())
2781 error (_("Couldn't find method %s%s%s"),
2782 obj_type_name,
2783 (obj_type_name && *obj_type_name) ? "::" : "",
2784 name);
2785 /* If we are dealing with stub method types, they should have
2786 been resolved by find_method_list via
2787 value_find_oload_method_list above. */
2788 if (!methods.empty ())
2789 {
2790 gdb_assert (TYPE_SELF_TYPE (methods[0].type) != NULL);
2791
2792 src_method_oload_champ
2793 = find_oload_champ (args,
2794 methods.size (),
2795 methods.data (), NULL, NULL,
2796 &src_method_badness);
2797
2798 src_method_match_quality = classify_oload_match
2799 (src_method_badness, args.size (),
2800 oload_method_static_p (methods.data (), src_method_oload_champ));
2801 }
2802
2803 if (!xmethods.empty ())
2804 {
2805 ext_method_oload_champ
2806 = find_oload_champ (args,
2807 xmethods.size (),
2808 NULL, xmethods.data (), NULL,
2809 &ext_method_badness);
2810 ext_method_match_quality = classify_oload_match (ext_method_badness,
2811 args.size (), 0);
2812 }
2813
2814 if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0)
2815 {
2816 switch (compare_badness (ext_method_badness, src_method_badness))
2817 {
2818 case 0: /* Src method and xmethod are equally good. */
2819 /* If src method and xmethod are equally good, then
2820 xmethod should be the winner. Hence, fall through to the
2821 case where a xmethod is better than the source
2822 method, except when the xmethod match quality is
2823 non-standard. */
2824 /* FALLTHROUGH */
2825 case 1: /* Src method and ext method are incompatible. */
2826 /* If ext method match is not standard, then let source method
2827 win. Otherwise, fallthrough to let xmethod win. */
2828 if (ext_method_match_quality != STANDARD)
2829 {
2830 method_oload_champ = src_method_oload_champ;
2831 method_badness = src_method_badness;
2832 ext_method_oload_champ = -1;
2833 method_match_quality = src_method_match_quality;
2834 break;
2835 }
2836 /* FALLTHROUGH */
2837 case 2: /* Ext method is champion. */
2838 method_oload_champ = ext_method_oload_champ;
2839 method_badness = ext_method_badness;
2840 src_method_oload_champ = -1;
2841 method_match_quality = ext_method_match_quality;
2842 break;
2843 case 3: /* Src method is champion. */
2844 method_oload_champ = src_method_oload_champ;
2845 method_badness = src_method_badness;
2846 ext_method_oload_champ = -1;
2847 method_match_quality = src_method_match_quality;
2848 break;
2849 default:
2850 gdb_assert_not_reached ("Unexpected overload comparison "
2851 "result");
2852 break;
2853 }
2854 }
2855 else if (src_method_oload_champ >= 0)
2856 {
2857 method_oload_champ = src_method_oload_champ;
2858 method_badness = src_method_badness;
2859 method_match_quality = src_method_match_quality;
2860 }
2861 else if (ext_method_oload_champ >= 0)
2862 {
2863 method_oload_champ = ext_method_oload_champ;
2864 method_badness = ext_method_badness;
2865 method_match_quality = ext_method_match_quality;
2866 }
2867 }
2868
2869 if (method == NON_METHOD || method == BOTH)
2870 {
2871 const char *qualified_name = NULL;
2872
2873 /* If the overload match is being search for both as a method
2874 and non member function, the first argument must now be
2875 dereferenced. */
2876 if (method == BOTH)
2877 args[0] = value_ind (args[0]);
2878
2879 if (fsym)
2880 {
2881 qualified_name = fsym->natural_name ();
2882
2883 /* If we have a function with a C++ name, try to extract just
2884 the function part. Do not try this for non-functions (e.g.
2885 function pointers). */
2886 if (qualified_name
2887 && (check_typedef (fsym->type ())->code ()
2888 == TYPE_CODE_FUNC))
2889 {
2890 temp_func = cp_func_name (qualified_name);
2891
2892 /* If cp_func_name did not remove anything, the name of the
2893 symbol did not include scope or argument types - it was
2894 probably a C-style function. */
2895 if (temp_func != nullptr)
2896 {
2897 if (strcmp (temp_func.get (), qualified_name) == 0)
2898 func_name = NULL;
2899 else
2900 func_name = temp_func.get ();
2901 }
2902 }
2903 }
2904 else
2905 {
2906 func_name = name;
2907 qualified_name = name;
2908 }
2909
2910 /* If there was no C++ name, this must be a C-style function or
2911 not a function at all. Just return the same symbol. Do the
2912 same if cp_func_name fails for some reason. */
2913 if (func_name == NULL)
2914 {
2915 *symp = fsym;
2916 return 0;
2917 }
2918
2919 func_oload_champ = find_oload_champ_namespace (args,
2920 func_name,
2921 qualified_name,
2922 &functions,
2923 &func_badness,
2924 no_adl);
2925
2926 if (func_oload_champ >= 0)
2927 func_match_quality = classify_oload_match (func_badness,
2928 args.size (), 0);
2929 }
2930
2931 /* Did we find a match ? */
2932 if (method_oload_champ == -1 && func_oload_champ == -1)
2933 throw_error (NOT_FOUND_ERROR,
2934 _("No symbol \"%s\" in current context."),
2935 name);
2936
2937 /* If we have found both a method match and a function
2938 match, find out which one is better, and calculate match
2939 quality. */
2940 if (method_oload_champ >= 0 && func_oload_champ >= 0)
2941 {
2942 switch (compare_badness (func_badness, method_badness))
2943 {
2944 case 0: /* Top two contenders are equally good. */
2945 /* FIXME: GDB does not support the general ambiguous case.
2946 All candidates should be collected and presented the
2947 user. */
2948 error (_("Ambiguous overload resolution"));
2949 break;
2950 case 1: /* Incomparable top contenders. */
2951 /* This is an error incompatible candidates
2952 should not have been proposed. */
2953 error (_("Internal error: incompatible "
2954 "overload candidates proposed"));
2955 break;
2956 case 2: /* Function champion. */
2957 method_oload_champ = -1;
2958 match_quality = func_match_quality;
2959 break;
2960 case 3: /* Method champion. */
2961 func_oload_champ = -1;
2962 match_quality = method_match_quality;
2963 break;
2964 default:
2965 error (_("Internal error: unexpected overload comparison result"));
2966 break;
2967 }
2968 }
2969 else
2970 {
2971 /* We have either a method match or a function match. */
2972 if (method_oload_champ >= 0)
2973 match_quality = method_match_quality;
2974 else
2975 match_quality = func_match_quality;
2976 }
2977
2978 if (match_quality == INCOMPATIBLE)
2979 {
2980 std::string hint = incomplete_type_hint (args);
2981 if (method == METHOD)
2982 error (_("Cannot resolve method %s%s%s to any overloaded instance%s"),
2983 obj_type_name,
2984 (obj_type_name && *obj_type_name) ? "::" : "",
2985 name, hint.c_str ());
2986 else
2987 error (_("Cannot resolve function %s to any overloaded instance%s"),
2988 func_name, hint.c_str ());
2989 }
2990 else if (match_quality == NON_STANDARD)
2991 {
2992 if (method == METHOD)
2993 warning (_("Using non-standard conversion to match "
2994 "method %s%s%s to supplied arguments"),
2995 obj_type_name,
2996 (obj_type_name && *obj_type_name) ? "::" : "",
2997 name);
2998 else
2999 warning (_("Using non-standard conversion to match "
3000 "function %s to supplied arguments"),
3001 func_name);
3002 }
3003
3004 if (staticp != NULL)
3005 *staticp = oload_method_static_p (methods.data (), method_oload_champ);
3006
3007 if (method_oload_champ >= 0)
3008 {
3009 if (src_method_oload_champ >= 0)
3010 {
3011 if (TYPE_FN_FIELD_VIRTUAL_P (methods, method_oload_champ)
3013 {
3014 *valp = value_virtual_fn_field (&temp, methods.data (),
3015 method_oload_champ, basetype,
3016 boffset);
3017 }
3018 else
3019 *valp = value_fn_field (&temp, methods.data (),
3020 method_oload_champ, basetype, boffset);
3021 }
3022 else
3023 *valp = value_from_xmethod
3024 (std::move (xmethods[ext_method_oload_champ]));
3025 }
3026 else
3027 *symp = functions[func_oload_champ];
3028
3029 if (objp)
3030 {
3031 struct type *temp_type = check_typedef (value_type (temp));
3032 struct type *objtype = check_typedef (obj_type);
3033
3034 if (temp_type->code () != TYPE_CODE_PTR
3035 && objtype->is_pointer_or_reference ())
3036 {
3037 temp = value_addr (temp);
3038 }
3039 *objp = temp;
3040 }
3041
3042 switch (match_quality)
3043 {
3044 case INCOMPATIBLE:
3045 return 100;
3046 case NON_STANDARD:
3047 return 10;
3048 default: /* STANDARD */
3049 return 0;
3050 }
3051}
3052
3053/* Find the best overload match, searching for FUNC_NAME in namespaces
3054 contained in QUALIFIED_NAME until it either finds a good match or
3055 runs out of namespaces. It stores the overloaded functions in
3056 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
3057 argument dependent lookup is not performed. */
3058
3059static int
3060find_oload_champ_namespace (gdb::array_view<value *> args,
3061 const char *func_name,
3062 const char *qualified_name,
3063 std::vector<symbol *> *oload_syms,
3064 badness_vector *oload_champ_bv,
3065 const int no_adl)
3066{
3067 int oload_champ;
3068
3070 func_name,
3071 qualified_name, 0,
3072 oload_syms, oload_champ_bv,
3073 &oload_champ,
3074 no_adl);
3075
3076 return oload_champ;
3077}
3078
3079/* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
3080 how deep we've looked for namespaces, and the champ is stored in
3081 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
3082 if it isn't. Other arguments are the same as in
3083 find_oload_champ_namespace. */
3084
3085static int
3086find_oload_champ_namespace_loop (gdb::array_view<value *> args,
3087 const char *func_name,
3088 const char *qualified_name,
3089 int namespace_len,
3090 std::vector<symbol *> *oload_syms,
3091 badness_vector *oload_champ_bv,
3092 int *oload_champ,
3093 const int no_adl)
3094{
3095 int next_namespace_len = namespace_len;
3096 int searched_deeper = 0;
3097 int new_oload_champ;
3098 char *new_namespace;
3099
3100 if (next_namespace_len != 0)
3101 {
3102 gdb_assert (qualified_name[next_namespace_len] == ':');
3103 next_namespace_len += 2;
3104 }
3105 next_namespace_len +=
3106 cp_find_first_component (qualified_name + next_namespace_len);
3107
3108 /* First, see if we have a deeper namespace we can search in.
3109 If we get a good match there, use it. */
3110
3111 if (qualified_name[next_namespace_len] == ':')
3112 {
3113 searched_deeper = 1;
3114
3116 func_name, qualified_name,
3117 next_namespace_len,
3118 oload_syms, oload_champ_bv,
3119 oload_champ, no_adl))
3120 {
3121 return 1;
3122 }
3123 };
3124
3125 /* If we reach here, either we're in the deepest namespace or we
3126 didn't find a good match in a deeper namespace. But, in the
3127 latter case, we still have a bad match in a deeper namespace;
3128 note that we might not find any match at all in the current
3129 namespace. (There's always a match in the deepest namespace,
3130 because this overload mechanism only gets called if there's a
3131 function symbol to start off with.) */
3132
3133 new_namespace = (char *) alloca (namespace_len + 1);
3134 strncpy (new_namespace, qualified_name, namespace_len);
3135 new_namespace[namespace_len] = '\0';
3136
3137 std::vector<symbol *> new_oload_syms
3138 = make_symbol_overload_list (func_name, new_namespace);
3139
3140 /* If we have reached the deepest level perform argument
3141 determined lookup. */
3142 if (!searched_deeper && !no_adl)
3143 {
3144 int ix;
3145 struct type **arg_types;
3146
3147 /* Prepare list of argument types for overload resolution. */
3148 arg_types = (struct type **)
3149 alloca (args.size () * (sizeof (struct type *)));
3150 for (ix = 0; ix < args.size (); ix++)
3151 arg_types[ix] = value_type (args[ix]);
3152 add_symbol_overload_list_adl ({arg_types, args.size ()}, func_name,
3153 &new_oload_syms);
3154 }
3155
3156 badness_vector new_oload_champ_bv;
3157 new_oload_champ = find_oload_champ (args,
3158 new_oload_syms.size (),
3159 NULL, NULL, new_oload_syms.data (),
3160 &new_oload_champ_bv);
3161
3162 /* Case 1: We found a good match. Free earlier matches (if any),
3163 and return it. Case 2: We didn't find a good match, but we're
3164 not the deepest function. Then go with the bad match that the
3165 deeper function found. Case 3: We found a bad match, and we're
3166 the deepest function. Then return what we found, even though
3167 it's a bad match. */
3168
3169 if (new_oload_champ != -1
3170 && classify_oload_match (new_oload_champ_bv, args.size (), 0) == STANDARD)
3171 {
3172 *oload_syms = std::move (new_oload_syms);
3173 *oload_champ = new_oload_champ;
3174 *oload_champ_bv = std::move (new_oload_champ_bv);
3175 return 1;
3176 }
3177 else if (searched_deeper)
3178 {
3179 return 0;
3180 }
3181 else
3182 {
3183 *oload_syms = std::move (new_oload_syms);
3184 *oload_champ = new_oload_champ;
3185 *oload_champ_bv = std::move (new_oload_champ_bv);
3186 return 0;
3187 }
3188}
3189
3190/* Look for a function to take ARGS. Find the best match from among
3191 the overloaded methods or functions given by METHODS or FUNCTIONS
3192 or XMETHODS, respectively. One, and only one of METHODS, FUNCTIONS
3193 and XMETHODS can be non-NULL.
3194
3195 NUM_FNS is the length of the array pointed at by METHODS, FUNCTIONS
3196 or XMETHODS, whichever is non-NULL.
3197
3198 Return the index of the best match; store an indication of the
3199 quality of the match in OLOAD_CHAMP_BV. */
3200
3201static int
3202find_oload_champ (gdb::array_view<value *> args,
3203 size_t num_fns,
3204 fn_field *methods,
3205 xmethod_worker_up *xmethods,
3206 symbol **functions,
3207 badness_vector *oload_champ_bv)
3208{
3209 /* A measure of how good an overloaded instance is. */
3210 badness_vector bv;
3211 /* Index of best overloaded function. */
3212 int oload_champ = -1;
3213 /* Current ambiguity state for overload resolution. */
3214 int oload_ambiguous = 0;
3215 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3216
3217 /* A champion can be found among methods alone, or among functions
3218 alone, or in xmethods alone, but not in more than one of these
3219 groups. */
3220 gdb_assert ((methods != NULL) + (functions != NULL) + (xmethods != NULL)
3221 == 1);
3222
3223 /* Consider each candidate in turn. */
3224 for (size_t ix = 0; ix < num_fns; ix++)
3225 {
3226 int jj;
3227 int static_offset = 0;
3228 std::vector<type *> parm_types;
3229
3230 if (xmethods != NULL)
3231 parm_types = xmethods[ix]->get_arg_types ();
3232 else
3233 {
3234 size_t nparms;
3235
3236 if (methods != NULL)
3237 {
3238 nparms = TYPE_FN_FIELD_TYPE (methods, ix)->num_fields ();
3239 static_offset = oload_method_static_p (methods, ix);
3240 }
3241 else
3242 nparms = functions[ix]->type ()->num_fields ();
3243
3244 parm_types.reserve (nparms);
3245 for (jj = 0; jj < nparms; jj++)
3246 {
3247 type *t = (methods != NULL
3248 ? (TYPE_FN_FIELD_ARGS (methods, ix)[jj].type ())
3249 : functions[ix]->type ()->field (jj).type ());
3250 parm_types.push_back (t);
3251 }
3252 }
3253
3254 /* Compare parameter types to supplied argument types. Skip
3255 THIS for static methods. */
3256 bv = rank_function (parm_types,
3257 args.slice (static_offset));
3258
3259 if (overload_debug)
3260 {
3261 if (methods != NULL)
3263 "Overloaded method instance %s, # of parms %d\n",
3264 methods[ix].physname, (int) parm_types.size ());
3265 else if (xmethods != NULL)
3267 "Xmethod worker, # of parms %d\n",
3268 (int) parm_types.size ());
3269 else
3271 "Overloaded function instance "
3272 "%s # of parms %d\n",
3273 functions[ix]->demangled_name (),
3274 (int) parm_types.size ());
3275
3277 "...Badness of length : {%d, %d}\n",
3278 bv[0].rank, bv[0].subrank);
3279
3280 for (jj = 1; jj < bv.size (); jj++)
3282 "...Badness of arg %d : {%d, %d}\n",
3283 jj, bv[jj].rank, bv[jj].subrank);
3284 }
3285
3286 if (oload_champ_bv->empty ())
3287 {
3288 *oload_champ_bv = std::move (bv);
3289 oload_champ = 0;
3290 }
3291 else /* See whether current candidate is better or worse than
3292 previous best. */
3293 switch (compare_badness (bv, *oload_champ_bv))
3294 {
3295 case 0: /* Top two contenders are equally good. */
3296 oload_ambiguous = 1;
3297 break;
3298 case 1: /* Incomparable top contenders. */
3299 oload_ambiguous = 2;
3300 break;
3301 case 2: /* New champion, record details. */
3302 *oload_champ_bv = std::move (bv);
3303 oload_ambiguous = 0;
3304 oload_champ = ix;
3305 break;
3306 case 3:
3307 default:
3308 break;
3309 }
3310 if (overload_debug)
3311 gdb_printf (gdb_stderr, "Overload resolution "
3312 "champion is %d, ambiguous? %d\n",
3313 oload_champ, oload_ambiguous);
3314 }
3315
3316 return oload_champ;
3317}
3318
3319/* Return 1 if we're looking at a static method, 0 if we're looking at
3320 a non-static method or a function that isn't a method. */
3321
3322static int
3323oload_method_static_p (struct fn_field *fns_ptr, int index)
3324{
3325 if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3326 return 1;
3327 else
3328 return 0;
3329}
3330
3331/* Check how good an overload match OLOAD_CHAMP_BV represents. */
3332
3333static enum oload_classification
3335 int nargs,
3336 int static_offset)
3337{
3338 int ix;
3339 enum oload_classification worst = STANDARD;
3340
3341 for (ix = 1; ix <= nargs - static_offset; ix++)
3342 {
3343 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3344 or worse return INCOMPATIBLE. */
3345 if (compare_ranks (oload_champ_bv[ix],
3347 return INCOMPATIBLE; /* Truly mismatched types. */
3348 /* Otherwise If this conversion is as bad as
3349 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3350 else if (compare_ranks (oload_champ_bv[ix],
3352 worst = NON_STANDARD; /* Non-standard type conversions
3353 needed. */
3354 }
3355
3356 /* If no INCOMPATIBLE classification was found, return the worst one
3357 that was found (if any). */
3358 return worst;
3359}
3360
3361/* C++: return 1 is NAME is a legitimate name for the destructor of
3362 type TYPE. If TYPE does not have a destructor, or if NAME is
3363 inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3364 have CHECK_TYPEDEF applied, this function will apply it itself. */
3365
3366int
3367destructor_name_p (const char *name, struct type *type)
3368{
3369 if (name[0] == '~')
3370 {
3371 const char *dname = type_name_or_error (type);
3372 const char *cp = strchr (dname, '<');
3373 unsigned int len;
3374
3375 /* Do not compare the template part for template classes. */
3376 if (cp == NULL)
3377 len = strlen (dname);
3378 else
3379 len = cp - dname;
3380 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3381 error (_("name of destructor must equal name of class"));
3382 else
3383 return 1;
3384 }
3385 return 0;
3386}
3387
3388/* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3389 class". If the name is found, return a value representing it;
3390 otherwise throw an exception. */
3391
3392static struct value *
3394{
3395 int i;
3396 int name_len = strlen (name);
3397
3398 gdb_assert (type->code () == TYPE_CODE_ENUM
3399 && type->is_declared_class ());
3400
3401 for (i = TYPE_N_BASECLASSES (type); i < type->num_fields (); ++i)
3402 {
3403 const char *fname = type->field (i).name ();
3404 int len;
3405
3407 || fname == NULL)
3408 continue;
3409
3410 /* Look for the trailing "::NAME", since enum class constant
3411 names are qualified here. */
3412 len = strlen (fname);
3413 if (len + 2 >= name_len
3414 && fname[len - name_len - 2] == ':'
3415 && fname[len - name_len - 1] == ':'
3416 && strcmp (&fname[len - name_len], name) == 0)
3417 return value_from_longest (type, type->field (i).loc_enumval ());
3418 }
3419
3420 error (_("no constant named \"%s\" in enum \"%s\""),
3421 name, type->name ());
3422}
3423
3424/* C++: Given an aggregate type CURTYPE, and a member name NAME,
3425 return the appropriate member (or the address of the member, if
3426 WANT_ADDRESS). This function is used to resolve user expressions
3427 of the form "DOMAIN::NAME". For more details on what happens, see
3428 the comment before value_struct_elt_for_reference. */
3429
3430struct value *
3431value_aggregate_elt (struct type *curtype, const char *name,
3432 struct type *expect_type, int want_address,
3433 enum noside noside)
3434{
3435 switch (curtype->code ())
3436 {
3437 case TYPE_CODE_STRUCT:
3438 case TYPE_CODE_UNION:
3439 return value_struct_elt_for_reference (curtype, 0, curtype,
3440 name, expect_type,
3441 want_address, noside);
3442 case TYPE_CODE_NAMESPACE:
3443 return value_namespace_elt (curtype, name,
3444 want_address, noside);
3445
3446 case TYPE_CODE_ENUM:
3447 return enum_constant_from_type (curtype, name);
3448
3449 default:
3450 internal_error (_("non-aggregate type in value_aggregate_elt"));
3451 }
3452}
3453
3454/* Compares the two method/function types T1 and T2 for "equality"
3455 with respect to the methods' parameters. If the types of the
3456 two parameter lists are the same, returns 1; 0 otherwise. This
3457 comparison may ignore any artificial parameters in T1 if
3458 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3459 the first artificial parameter in T1, assumed to be a 'this' pointer.
3460
3461 The type T2 is expected to have come from make_params (in eval.c). */
3462
3463static int
3464compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3465{
3466 int start = 0;
3467
3468 if (t1->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3469 ++start;
3470
3471 /* If skipping artificial fields, find the first real field
3472 in T1. */
3473 if (skip_artificial)
3474 {
3475 while (start < t1->num_fields ()
3476 && TYPE_FIELD_ARTIFICIAL (t1, start))
3477 ++start;
3478 }
3479
3480 /* Now compare parameters. */
3481
3482 /* Special case: a method taking void. T1 will contain no
3483 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3484 if ((t1->num_fields () - start) == 0 && t2->num_fields () == 1
3485 && t2->field (0).type ()->code () == TYPE_CODE_VOID)
3486 return 1;
3487
3488 if ((t1->num_fields () - start) == t2->num_fields ())
3489 {
3490 int i;
3491
3492 for (i = 0; i < t2->num_fields (); ++i)
3493 {
3494 if (compare_ranks (rank_one_type (t1->field (start + i).type (),
3495 t2->field (i).type (), NULL),
3496 EXACT_MATCH_BADNESS) != 0)
3497 return 0;
3498 }
3499
3500 return 1;
3501 }
3502
3503 return 0;
3504}
3505
3506/* C++: Given an aggregate type VT, and a class type CLS, search
3507 recursively for CLS using value V; If found, store the offset
3508 which is either fetched from the virtual base pointer if CLS
3509 is virtual or accumulated offset of its parent classes if
3510 CLS is non-virtual in *BOFFS, set ISVIRT to indicate if CLS
3511 is virtual, and return true. If not found, return false. */
3512
3513static bool
3514get_baseclass_offset (struct type *vt, struct type *cls,
3515 struct value *v, int *boffs, bool *isvirt)
3516{
3517 for (int i = 0; i < TYPE_N_BASECLASSES (vt); i++)
3518 {
3519 struct type *t = vt->field (i).type ();
3520 if (types_equal (t, cls))
3521 {
3522 if (BASETYPE_VIA_VIRTUAL (vt, i))
3523 {
3524 const gdb_byte *adr = value_contents_for_printing (v).data ();
3525 *boffs = baseclass_offset (vt, i, adr, value_offset (v),
3526 value_as_long (v), v);
3527 *isvirt = true;
3528 }
3529 else
3530 *isvirt = false;
3531 return true;
3532 }
3533
3534 if (get_baseclass_offset (check_typedef (t), cls, v, boffs, isvirt))
3535 {
3536 if (*isvirt == false) /* Add non-virtual base offset. */
3537 {
3538 const gdb_byte *adr = value_contents_for_printing (v).data ();
3539 *boffs += baseclass_offset (vt, i, adr, value_offset (v),
3540 value_as_long (v), v);
3541 }
3542 return true;
3543 }
3544 }
3545
3546 return false;
3547}
3548
3549/* C++: Given an aggregate type CURTYPE, and a member name NAME,
3550 return the address of this member as a "pointer to member" type.
3551 If INTYPE is non-null, then it will be the type of the member we
3552 are looking for. This will help us resolve "pointers to member
3553 functions". This function is used to resolve user expressions of
3554 the form "DOMAIN::NAME". */
3555
3556static struct value *
3558 struct type *curtype, const char *name,
3559 struct type *intype,
3560 int want_address,
3561 enum noside noside)
3562{
3563 struct type *t = check_typedef (curtype);
3564 int i;
3565 struct value *result;
3566
3567 if (t->code () != TYPE_CODE_STRUCT
3568 && t->code () != TYPE_CODE_UNION)
3569 error (_("Internal error: non-aggregate type "
3570 "to value_struct_elt_for_reference"));
3571
3572 for (i = t->num_fields () - 1; i >= TYPE_N_BASECLASSES (t); i--)
3573 {
3574 const char *t_field_name = t->field (i).name ();
3575
3576 if (t_field_name && strcmp (t_field_name, name) == 0)
3577 {
3578 if (field_is_static (&t->field (i)))
3579 {
3580 struct value *v = value_static_field (t, i);
3581 if (want_address)
3582 v = value_addr (v);
3583 return v;
3584 }
3585 if (TYPE_FIELD_PACKED (t, i))
3586 error (_("pointers to bitfield members not allowed"));
3587
3588 if (want_address)
3589 return value_from_longest
3590 (lookup_memberptr_type (t->field (i).type (), domain),
3591 offset + (LONGEST) (t->field (i).loc_bitpos () >> 3));
3592 else if (noside != EVAL_NORMAL)
3593 return allocate_value (t->field (i).type ());
3594 else
3595 {
3596 /* Try to evaluate NAME as a qualified name with implicit
3597 this pointer. In this case, attempt to return the
3598 equivalent to `this->*(&TYPE::NAME)'. */
3600 if (v != NULL)
3601 {
3602 struct value *ptr, *this_v = v;
3603 long mem_offset;
3604 struct type *type, *tmp;
3605
3606 ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
3607 type = check_typedef (value_type (ptr));
3608 gdb_assert (type != NULL
3609 && type->code () == TYPE_CODE_MEMBERPTR);
3611 v = value_cast_pointers (tmp, v, 1);
3612 mem_offset = value_as_long (ptr);
3613 if (domain != curtype)
3614 {
3615 /* Find class offset of type CURTYPE from either its
3616 parent type DOMAIN or the type of implied this. */
3617 int boff = 0;
3618 bool isvirt = false;
3619 if (get_baseclass_offset (domain, curtype, v, &boff,
3620 &isvirt))
3621 mem_offset += boff;
3622 else
3623 {
3624 struct type *p = check_typedef (value_type (this_v));
3625 p = check_typedef (p->target_type ());
3626 if (get_baseclass_offset (p, curtype, this_v,
3627 &boff, &isvirt))
3628 mem_offset += boff;
3629 }
3630 }
3632 result = value_from_pointer (tmp,
3633 value_as_long (v) + mem_offset);
3634 return value_ind (result);
3635 }
3636
3637 error (_("Cannot reference non-static field \"%s\""), name);
3638 }
3639 }
3640 }
3641
3642 /* C++: If it was not found as a data field, then try to return it
3643 as a pointer to a method. */
3644
3645 /* Perform all necessary dereferencing. */
3646 while (intype && intype->code () == TYPE_CODE_PTR)
3647 intype = intype->target_type ();
3648
3649 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3650 {
3651 const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3652
3653 if (t_field_name && strcmp (t_field_name, name) == 0)
3654 {
3655 int j;
3656 int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3657 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3658
3660
3661 if (intype)
3662 {
3663 for (j = 0; j < len; ++j)
3664 {
3665 if (TYPE_CONST (intype) != TYPE_FN_FIELD_CONST (f, j))
3666 continue;
3667 if (TYPE_VOLATILE (intype) != TYPE_FN_FIELD_VOLATILE (f, j))
3668 continue;
3669
3670 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3672 intype, 1))
3673 break;
3674 }
3675
3676 if (j == len)
3677 error (_("no member function matches "
3678 "that type instantiation"));
3679 }
3680 else
3681 {
3682 int ii;
3683
3684 j = -1;
3685 for (ii = 0; ii < len; ++ii)
3686 {
3687 /* Skip artificial methods. This is necessary if,
3688 for example, the user wants to "print
3689 subclass::subclass" with only one user-defined
3690 constructor. There is no ambiguity in this case.
3691 We are careful here to allow artificial methods
3692 if they are the unique result. */
3693 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3694 {
3695 if (j == -1)
3696 j = ii;
3697 continue;
3698 }
3699
3700 /* Desired method is ambiguous if more than one
3701 method is defined. */
3702 if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3703 error (_("non-unique member `%s' requires "
3704 "type instantiation"), name);
3705
3706 j = ii;
3707 }
3708
3709 if (j == -1)
3710 error (_("no matching member function"));
3711 }
3712
3713 if (TYPE_FN_FIELD_STATIC_P (f, j))
3714 {
3715 struct symbol *s =
3717 0, VAR_DOMAIN, 0).symbol;
3718
3719 if (s == NULL)
3720 return NULL;
3721
3722 if (want_address)
3723 return value_addr (read_var_value (s, 0, 0));
3724 else
3725 return read_var_value (s, 0, 0);
3726 }
3727
3728 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3729 {
3730 if (want_address)
3731 {
3732 result = allocate_value
3735 value_contents_writeable (result).data (),
3736 TYPE_FN_FIELD_VOFFSET (f, j), 1);
3737 }
3738 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3739 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3740 else
3741 error (_("Cannot reference virtual member function \"%s\""),
3742 name);
3743 }
3744 else
3745 {
3746 struct symbol *s =
3748 0, VAR_DOMAIN, 0).symbol;
3749
3750 if (s == NULL)
3751 return NULL;
3752
3753 struct value *v = read_var_value (s, 0, 0);
3754 if (!want_address)
3755 result = v;
3756 else
3757 {
3760 value_contents_writeable (result).data (),
3761 value_address (v), 0);
3762 }
3763 }
3764 return result;
3765 }
3766 }
3767 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3768 {
3769 struct value *v;
3770 int base_offset;
3771
3772 if (BASETYPE_VIA_VIRTUAL (t, i))
3773 base_offset = 0;
3774 else
3775 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3777 offset + base_offset,
3778 TYPE_BASECLASS (t, i),
3779 name, intype,
3780 want_address, noside);
3781 if (v)
3782 return v;
3783 }
3784
3785 /* As a last chance, pretend that CURTYPE is a namespace, and look
3786 it up that way; this (frequently) works for types nested inside
3787 classes. */
3788
3789 return value_maybe_namespace_elt (curtype, name,
3790 want_address, noside);
3791}
3792
3793/* C++: Return the member NAME of the namespace given by the type
3794 CURTYPE. */
3795
3796static struct value *
3797value_namespace_elt (const struct type *curtype,
3798 const char *name, int want_address,
3799 enum noside noside)
3800{
3801 struct value *retval = value_maybe_namespace_elt (curtype, name,
3802 want_address,
3803 noside);
3804
3805 if (retval == NULL)
3806 error (_("No symbol \"%s\" in namespace \"%s\"."),
3807 name, curtype->name ());
3808
3809 return retval;
3810}
3811
3812/* A helper function used by value_namespace_elt and
3813 value_struct_elt_for_reference. It looks up NAME inside the
3814 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3815 is a class and NAME refers to a type in CURTYPE itself (as opposed
3816 to, say, some base class of CURTYPE). */
3817
3818static struct value *
3819value_maybe_namespace_elt (const struct type *curtype,
3820 const char *name, int want_address,
3821 enum noside noside)
3822{
3823 const char *namespace_name = curtype->name ();
3824 struct block_symbol sym;
3825 struct value *result;
3826
3829
3830 if (sym.symbol == NULL)
3831 return NULL;
3832 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3833 && (sym.symbol->aclass () == LOC_TYPEDEF))
3834 result = allocate_value (sym.symbol->type ());
3835 else
3836 result = value_of_variable (sym.symbol, sym.block);
3837
3838 if (want_address)
3839 result = value_addr (result);
3840
3841 return result;
3842}
3843
3844/* Given a pointer or a reference value V, find its real (RTTI) type.
3845
3846 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3847 and refer to the values computed for the object pointed to. */
3848
3849struct type *
3850value_rtti_indirect_type (struct value *v, int *full,
3851 LONGEST *top, int *using_enc)
3852{
3853 struct value *target = NULL;
3854 struct type *type, *real_type, *target_type;
3855
3856 type = value_type (v);
3858 if (TYPE_IS_REFERENCE (type))
3859 target = coerce_ref (v);
3860 else if (type->code () == TYPE_CODE_PTR)
3861 {
3862
3863 try
3864 {
3865 target = value_ind (v);
3866 }
3867 catch (const gdb_exception_error &except)
3868 {
3869 if (except.error == MEMORY_ERROR)
3870 {
3871 /* value_ind threw a memory error. The pointer is NULL or
3872 contains an uninitialized value: we can't determine any
3873 type. */
3874 return NULL;
3875 }
3876 throw;
3877 }
3878 }
3879 else
3880 return NULL;
3881
3882 real_type = value_rtti_type (target, full, top, using_enc);
3883
3884 if (real_type)
3885 {
3886 /* Copy qualifiers to the referenced object. */
3887 target_type = value_type (target);
3888 real_type = make_cv_type (TYPE_CONST (target_type),
3889 TYPE_VOLATILE (target_type), real_type, NULL);
3890 if (TYPE_IS_REFERENCE (type))
3891 real_type = lookup_reference_type (real_type, type->code ());
3892 else if (type->code () == TYPE_CODE_PTR)
3893 real_type = lookup_pointer_type (real_type);
3894 else
3895 internal_error (_("Unexpected value type."));
3896
3897 /* Copy qualifiers to the pointer/reference. */
3898 real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3899 real_type, NULL);
3900 }
3901
3902 return real_type;
3903}
3904
3905/* Given a value pointed to by ARGP, check its real run-time type, and
3906 if that is different from the enclosing type, create a new value
3907 using the real run-time type as the enclosing type (and of the same
3908 type as ARGP) and return it, with the embedded offset adjusted to
3909 be the correct offset to the enclosed object. RTYPE is the type,
3910 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3911 by value_rtti_type(). If these are available, they can be supplied
3912 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3913 NULL if they're not available. */
3914
3915struct value *
3917 struct type *rtype,
3918 int xfull, int xtop,
3919 int xusing_enc)
3920{
3921 struct type *real_type;
3922 int full = 0;
3923 LONGEST top = -1;
3924 int using_enc = 0;
3925 struct value *new_val;
3926
3927 if (rtype)
3928 {
3929 real_type = rtype;
3930 full = xfull;
3931 top = xtop;
3932 using_enc = xusing_enc;
3933 }
3934 else
3935 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3936
3937 /* If no RTTI data, or if object is already complete, do nothing. */
3938 if (!real_type || real_type == value_enclosing_type (argp))
3939 return argp;
3940
3941 /* In a destructor we might see a real type that is a superclass of
3942 the object's type. In this case it is better to leave the object
3943 as-is. */
3944 if (full
3945 && real_type->length () < value_enclosing_type (argp)->length ())
3946 return argp;
3947
3948 /* If we have the full object, but for some reason the enclosing
3949 type is wrong, set it. */
3950 /* pai: FIXME -- sounds iffy */
3951 if (full)
3952 {
3953 argp = value_copy (argp);
3954 set_value_enclosing_type (argp, real_type);
3955 return argp;
3956 }
3957
3958 /* Check if object is in memory. */
3959 if (VALUE_LVAL (argp) != lval_memory)
3960 {
3961 warning (_("Couldn't retrieve complete object of RTTI "
3962 "type %s; object may be in register(s)."),
3963 real_type->name ());
3964
3965 return argp;
3966 }
3967
3968 /* All other cases -- retrieve the complete object. */
3969 /* Go back by the computed top_offset from the beginning of the
3970 object, adjusting for the embedded offset of argp if that's what
3971 value_rtti_type used for its computation. */
3972 new_val = value_at_lazy (real_type, value_address (argp) - top +
3973 (using_enc ? 0 : value_embedded_offset (argp)));
3974 deprecated_set_value_type (new_val, value_type (argp));
3975 set_value_embedded_offset (new_val, (using_enc
3976 ? top + value_embedded_offset (argp)
3977 : top));
3978 return new_val;
3979}
3980
3981
3982/* Return the value of the local variable, if one exists. Throw error
3983 otherwise, such as if the request is made in an inappropriate context. */
3984
3985struct value *
3986value_of_this (const struct language_defn *lang)
3987{
3988 struct block_symbol sym;
3989 const struct block *b;
3990 frame_info_ptr frame;
3991
3992 if (lang->name_of_this () == NULL)
3993 error (_("no `this' in current language"));
3994
3995 frame = get_selected_frame (_("no frame selected"));
3996
3997 b = get_frame_block (frame, NULL);
3998
3999 sym = lookup_language_this (lang, b);
4000 if (sym.symbol == NULL)
4001 error (_("current stack frame does not contain a variable named `%s'"),
4002 lang->name_of_this ());
4003
4004 return read_var_value (sym.symbol, sym.block, frame);
4005}
4006
4007/* Return the value of the local variable, if one exists. Return NULL
4008 otherwise. Never throw error. */
4009
4010struct value *
4012{
4013 struct value *ret = NULL;
4014
4015 try
4016 {
4017 ret = value_of_this (lang);
4018 }
4019 catch (const gdb_exception_error &except)
4020 {
4021 }
4022
4023 return ret;
4024}
4025
4026/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
4027 elements long, starting at LOWBOUND. The result has the same lower
4028 bound as the original ARRAY. */
4029
4030struct value *
4031value_slice (struct value *array, int lowbound, int length)
4032{
4033 struct type *slice_range_type, *slice_type, *range_type;
4034 LONGEST lowerbound, upperbound;
4035 struct value *slice;
4036 struct type *array_type;
4037
4038 array_type = check_typedef (value_type (array));
4039 if (array_type->code () != TYPE_CODE_ARRAY
4040 && array_type->code () != TYPE_CODE_STRING)
4041 error (_("cannot take slice of non-array"));
4042
4043 if (type_not_allocated (array_type))
4044 error (_("array not allocated"));
4045 if (type_not_associated (array_type))
4046 error (_("array not associated"));
4047
4048 range_type = array_type->index_type ();
4049 if (!get_discrete_bounds (range_type, &lowerbound, &upperbound))
4050 error (_("slice from bad array or bitstring"));
4051
4052 if (lowbound < lowerbound || length < 0
4053 || lowbound + length - 1 > upperbound)
4054 error (_("slice out of range"));
4055
4056 /* FIXME-type-allocation: need a way to free this type when we are
4057 done with it. */
4058 slice_range_type = create_static_range_type (NULL,
4059 range_type->target_type (),
4060 lowbound,
4061 lowbound + length - 1);
4062
4063 {
4064 struct type *element_type = array_type->target_type ();
4065 LONGEST offset
4066 = (lowbound - lowerbound) * check_typedef (element_type)->length ();
4067
4068 slice_type = create_array_type (NULL,
4069 element_type,
4070 slice_range_type);
4071 slice_type->set_code (array_type->code ());
4072
4073 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
4074 slice = allocate_value_lazy (slice_type);
4075 else
4076 {
4077 slice = allocate_value (slice_type);
4078 value_contents_copy (slice, 0, array, offset,
4079 type_length_units (slice_type));
4080 }
4081
4082 set_value_component_location (slice, array);
4083 set_value_offset (slice, value_offset (array) + offset);
4084 }
4085
4086 return slice;
4087}
4088
4089/* See value.h. */
4090
4091struct value *
4093 struct value *arg2,
4094 struct type *type)
4095{
4096 struct value *val;
4097 struct type *real_type = type->target_type ();
4098
4099 val = allocate_value (type);
4100 arg1 = value_cast (real_type, arg1);
4101 arg2 = value_cast (real_type, arg2);
4102
4103 int len = real_type->length ();
4104
4105 copy (value_contents (arg1),
4106 value_contents_raw (val).slice (0, len));
4107 copy (value_contents (arg2),
4108 value_contents_raw (val).slice (len, len));
4109
4110 return val;
4111}
4112
4113/* See value.h. */
4114
4115struct value *
4117{
4118 struct type *type = check_typedef (value_type (value));
4119 struct type *ttype = type->target_type ();
4120
4121 gdb_assert (type->code () == TYPE_CODE_COMPLEX);
4122 return value_from_component (value, ttype, 0);
4123}
4124
4125/* See value.h. */
4126
4127struct value *
4129{
4130 struct type *type = check_typedef (value_type (value));
4131 struct type *ttype = type->target_type ();
4132
4133 gdb_assert (type->code () == TYPE_CODE_COMPLEX);
4135 check_typedef (ttype)->length ());
4136}
4137
4138/* Cast a value into the appropriate complex data type. */
4139
4140static struct value *
4141cast_into_complex (struct type *type, struct value *val)
4142{
4143 struct type *real_type = type->target_type ();
4144
4145 if (value_type (val)->code () == TYPE_CODE_COMPLEX)
4146 {
4147 struct type *val_real_type = value_type (val)->target_type ();
4148 struct value *re_val = allocate_value (val_real_type);
4149 struct value *im_val = allocate_value (val_real_type);
4150 int len = val_real_type->length ();
4151
4152 copy (value_contents (val).slice (0, len),
4153 value_contents_raw (re_val));
4154 copy (value_contents (val).slice (len, len),
4155 value_contents_raw (im_val));
4156
4157 return value_literal_complex (re_val, im_val, type);
4158 }
4159 else if (value_type (val)->code () == TYPE_CODE_FLT
4160 || value_type (val)->code () == TYPE_CODE_INT)
4161 return value_literal_complex (val,
4162 value_zero (real_type, not_lval),
4163 type);
4164 else
4165 error (_("cannot cast non-number to complex"));
4166}
4167
4168void _initialize_valops ();
4169void
4171{
4172 add_setshow_boolean_cmd ("overload-resolution", class_support,
4173 &overload_resolution, _("\
4174Set overload resolution in evaluating C++ functions."), _("\
4175Show overload resolution in evaluating C++ functions."),
4176 NULL, NULL,
4178 &setlist, &showlist);
4180}
const char *const name
int code
Definition ada-lex.l:688
void f()
Definition 1.cc:36
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
Definition blockframe.c:55
const std::string & string()
Definition ui-file.h:194
struct cmd_list_element * showlist
Definition cli-cmds.c:125
struct cmd_list_element * setlist
Definition cli-cmds.c:117
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
@ class_support
Definition command.h:58
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:346
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:237
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:359
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition corefile.c:185
struct value * value_virtual_fn_field(struct value **arg1p, struct fn_field *f, int j, struct type *type, int offset)
Definition cp-abi.c:96
void cplus_make_method_ptr(struct type *type, gdb_byte *contents, CORE_ADDR value, int is_virtual)
Definition cp-abi.c:146
int baseclass_offset(struct type *type, int index, const gdb_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, const struct value *val)
Definition cp-abi.c:68
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition cp-abi.c:107
struct block_symbol cp_lookup_symbol_namespace(const char *scope, const char *name, const struct block *block, const domain_enum domain)
gdb::unique_xmalloc_ptr< char > cp_func_name(const char *full_name)
Definition cp-support.c:882
void add_symbol_overload_list_adl(gdb::array_view< type * > arg_types, const char *func_name, std::vector< symbol * > *overload_list)
unsigned int cp_find_first_component(const char *name)
struct std::vector< symbol * > make_symbol_overload_list(const char *func_name, const char *the_namespace)
@ language_ada
Definition defs.h:226
@ language_fortran
Definition defs.h:219
@ lval_memory
Definition defs.h:364
@ lval_internalvar_component
Definition defs.h:372
@ not_lval
Definition defs.h:362
@ lval_computed
Definition defs.h:375
@ lval_internalvar
Definition defs.h:368
@ lval_xcallable
Definition defs.h:370
@ lval_register
Definition defs.h:366
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:526
#define QUIT
Definition defs.h:186
noside
Definition expression.h:55
@ EVAL_NORMAL
Definition expression.h:56
@ EVAL_AVOID_SIDE_EFFECTS
Definition expression.h:57
void get_matching_xmethod_workers(struct type *type, const char *method_name, std::vector< xmethod_worker_up > *workers)
Definition extension.c:834
std::unique_ptr< xmethod_worker > xmethod_worker_up
Definition extension.h:229
int symbol_read_needs_frame(struct symbol *sym)
Definition findvar.c:389
struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
Definition findvar.c:787
frame_info_ptr deprecated_safe_get_selected_frame(void)
Definition frame.c:1832
void select_frame(frame_info_ptr fi)
Definition frame.c:1852
frame_info_ptr get_prev_frame_always(frame_info_ptr this_frame)
Definition frame.c:2329
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
void put_frame_register_bytes(frame_info_ptr frame, int regnum, CORE_ADDR offset, gdb::array_view< const gdb_byte > buffer)
Definition frame.c:1521
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1813
frame_info_ptr frame_find_by_id(struct frame_id id)
Definition frame.c:868
bool get_frame_register_bytes(frame_info_ptr frame, int regnum, CORE_ADDR offset, gdb::array_view< gdb_byte > buffer, int *optimizedp, int *unavailablep)
Definition frame.c:1432
struct frame_id get_frame_id(frame_info_ptr fi)
Definition frame.c:607
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition stack.c:2602
void gdbarch_value_to_register(struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, const gdb_byte *buf)
Definition gdbarch.c:2480
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition gdbarch.c:2142
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1708
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition gdbarch.c:5200
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition gdbarch.c:2446
enum bfd_endian type_byte_order(const struct type *type)
Definition gdbtypes.c:4018
void check_stub_method_group(struct type *type, int method_id)
Definition gdbtypes.c:3322
struct type * lookup_pointer_type(struct type *type)
Definition gdbtypes.c:402
struct type * lookup_methodptr_type(struct type *to_type)
Definition gdbtypes.c:855
int is_integral_type(struct type *t)
Definition gdbtypes.c:3772
int is_floating_type(struct type *t)
Definition gdbtypes.c:3787
const struct rank NS_POINTER_CONVERSION_BADNESS
Definition gdbtypes.c:75
int field_is_static(struct field *f)
Definition gdbtypes.c:5048
struct rank rank_one_type(struct type *parm, struct type *arg, struct value *value)
Definition gdbtypes.c:4899
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition gdbtypes.c:1431
const struct rank INCOMPATIBLE_TYPE_BADNESS
Definition gdbtypes.c:58
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition gdbtypes.c:714
bool get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition gdbtypes.c:1201
struct type * lookup_function_type(struct type *type)
Definition gdbtypes.c:539
badness_vector rank_function(gdb::array_view< type * > parms, gdb::array_view< value * > args)
Definition gdbtypes.c:4158
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition gdbtypes.c:1422
int compare_ranks(struct rank a, struct rank b)
Definition gdbtypes.c:4066
struct type * lookup_reference_type(struct type *type, enum type_code refcode)
Definition gdbtypes.c:482
int is_unique_ancestor(struct type *base, struct value *val)
Definition gdbtypes.c:4005
struct type * lookup_memberptr_type(struct type *type, struct type *domain)
Definition gdbtypes.c:843
struct type * lookup_string_range_type(struct type *string_char_type, LONGEST low_bound, LONGEST high_bound)
Definition gdbtypes.c:1473
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition gdbtypes.c:1220
unsigned int overload_debug
Definition gdbtypes.c:138
int compare_badness(const badness_vector &a, const badness_vector &b)
Definition gdbtypes.c:4094
int is_ancestor(struct type *base, struct type *dclass)
Definition gdbtypes.c:3936
int is_public_ancestor(struct type *base, struct type *dclass)
Definition gdbtypes.c:3945
int type_not_associated(const struct type *type)
Definition gdbtypes.c:4491
unsigned int type_length_units(struct type *type)
Definition gdbtypes.c:280
bool types_equal(struct type *a, struct type *b)
Definition gdbtypes.c:4232
bool types_deeply_equal(struct type *type1, struct type *type2)
Definition gdbtypes.c:4460
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition gdbtypes.c:1025
const struct rank EXACT_MATCH_BADNESS
Definition gdbtypes.c:60
int class_types_same_p(const struct type *a, const struct type *b)
Definition gdbtypes.c:3876
bool is_fixed_point_type(struct type *type)
Definition gdbtypes.c:6116
int type_not_allocated(const struct type *type)
Definition gdbtypes.c:4479
const char * type_name_or_error(struct type *type)
Definition gdbtypes.c:1678
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
#define TYPE_BASECLASS_NAME(thistype, index)
Definition gdbtypes.h:2109
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition gdbtypes.h:2169
#define TYPE_NFN_FIELDS(thistype)
Definition gdbtypes.h:2086
@ PROP_UNDEFINED
Definition gdbtypes.h:292
#define TYPE_FN_FIELD_ARGS(thisfn, n)
Definition gdbtypes.h:2171
#define TYPE_IS_REFERENCE(t)
Definition gdbtypes.h:156
#define TYPE_FN_FIELD_VOFFSET(thisfn, n)
Definition gdbtypes.h:2180
@ FIELD_LOC_KIND_ENUMVAL
Definition gdbtypes.h:494
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition gdbtypes.h:2157
#define TYPE_SAFE_NAME(type)
Definition gdbtypes.h:2228
#define TYPE_SELF_TYPE(thistype)
Definition gdbtypes.h:2074
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition gdbtypes.h:2170
#define TYPE_FN_FIELD_VOLATILE(thisfn, n)
Definition gdbtypes.h:2173
#define TYPE_BASECLASS(thistype, index)
Definition gdbtypes.h:2107
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n)
Definition gdbtypes.h:2181
#define TYPE_BASECLASS_BITPOS(thistype, index)
Definition gdbtypes.h:2110
#define TYPE_CONST(t)
Definition gdbtypes.h:134
#define TYPE_VOLATILE(t)
Definition gdbtypes.h:139
type_code
Definition gdbtypes.h:99
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition gdbtypes.h:2159
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition gdbtypes.h:2122
#define TYPE_FN_FIELD_STATIC_P(thisfn, n)
Definition gdbtypes.h:2182
#define TYPE_FIELD_PACKED(thistype, n)
Definition gdbtypes.h:2124
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition gdbtypes.h:2115
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition gdbtypes.h:2158
#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n)
Definition gdbtypes.h:2176
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition gdbtypes.h:2111
#define TYPE_N_BASECLASSES(thistype)
Definition gdbtypes.h:2108
std::vector< rank > badness_vector
Definition gdbtypes.h:1710
#define TYPE_FN_FIELD_CONST(thisfn, n)
Definition gdbtypes.h:2172
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1790
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1791
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type, struct type **function_type)
Definition infcall.c:277
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition infcall.c:781
struct inferior * current_inferior(void)
Definition inferior.c:54
const struct language_defn * current_language
Definition language.c:83
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition minsyms.c:481
observable< struct target_ops * > target_changed
observable< frame_info_ptr, int > register_changed
static const char * namespace_name(struct die_info *die, int *is_anonymous, struct dwarf2_cu *)
Definition read.c:16153
const struct block * block
Definition symtab.h:1498
struct symbol * symbol
Definition symtab.h:1494
Definition block.h:109
struct objfile * objfile
Definition minsyms.h:54
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
dynamic_prop_kind kind() const
Definition gdbtypes.h:337
LONGEST loc_bitpos() const
Definition gdbtypes.h:586
field_loc_kind loc_kind() const
Definition gdbtypes.h:581
LONGEST loc_enumval() const
Definition gdbtypes.h:598
const char * name() const
Definition gdbtypes.h:569
struct type * type() const
Definition gdbtypes.h:559
struct type * type
Definition gdbtypes.h:1506
void read_fixed_point(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p, const gdb_mpq &scaling_factor)
Definition gmp-utils.c:192
gdb_mpz get_rounded() const
Definition gmp-utils.c:159
mpq_t val
Definition gmp-utils.h:148
void read(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p)
Definition gmp-utils.c:45
void write(gdb::array_view< gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p) const
Definition gmp-utils.c:68
mpz_t val
Definition gmp-utils.h:40
const char * natural_name() const
Definition symtab.c:1027
const char * print_name() const
Definition symtab.h:474
enum language la_language
Definition language.h:275
virtual const char * name_of_this() const
Definition language.h:586
virtual void print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags) const =0
virtual char string_lower_bound() const
Definition language.h:602
virtual bool c_style_arrays_p() const
Definition language.h:594
void(* write)(struct value *toval, struct value *fromval)
Definition value.h:265
struct value *(* indirect)(struct value *value)
Definition value.h:276
struct gdbarch * arch() const
Definition objfiles.h:482
struct dynamic_prop high
Definition gdbtypes.h:696
std::vector< struct type * > path
Definition valops.c:1868
struct value * baseclass()
Definition valops.c:1898
void search(struct value *arg, LONGEST offset, struct type *type)
Definition valops.c:1993
const char * m_name
Definition valops.c:1908
void update_result(struct value *v, LONGEST boffset)
Definition valops.c:1935
struct type * m_outermost_type
Definition valops.c:1926
const std::vector< found_field > & fields()
Definition valops.c:1893
std::vector< struct type * > m_struct_path
Definition valops.c:1931
std::vector< found_field > m_fields
Definition valops.c:1922
const bool m_looking_for_baseclass
Definition valops.c:1911
struct value * m_baseclass
Definition valops.c:1918
struct_field_searcher(const char *name, struct type *outermost_type, bool looking_for_baseclass)
Definition valops.c:1875
address_class aclass() const
Definition symtab.h:1235
struct type * type() const
Definition symtab.h:1285
struct objfile * objfile() const
Definition symtab.c:6477
struct type * target_type() const
Definition gdbtypes.h:1000
type_code code() const
Definition gdbtypes.h:927
void set_code(type_code code)
Definition gdbtypes.h:933
ULONGEST length() const
Definition gdbtypes.h:954
struct field & field(int idx) const
Definition gdbtypes.h:983
bool is_unsigned() const
Definition gdbtypes.h:1063
bool is_vector() const
Definition gdbtypes.h:1149
bool is_declared_class() const
Definition gdbtypes.h:1230
int num_fields() const
Definition gdbtypes.h:965
bool is_stub() const
Definition gdbtypes.h:1091
gdbarch * arch() const
Definition gdbtypes.c:245
const gdb_mpq & fixed_point_scaling_factor()
Definition gdbtypes.c:6143
bool is_pointer_or_reference() const
Definition gdbtypes.h:1394
range_bounds * bounds() const
Definition gdbtypes.h:1028
const char * name() const
Definition gdbtypes.h:939
type * index_type() const
Definition gdbtypes.h:995
Definition value.c:181
const struct lval_funcs * funcs
Definition value.c:271
unsigned int stack
Definition value.c:236
value_ref_ptr parent
Definition value.c:301
unsigned int lazy
Definition value.c:229
LONGEST offset
Definition value.c:281
LONGEST bitpos
Definition value.c:289
CORE_ADDR address
Definition value.c:246
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1967
struct block_symbol lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition symtab.c:1989
@ LOC_BLOCK
Definition symtab.h:999
@ LOC_TYPEDEF
Definition symtab.h:989
@ VAR_DOMAIN
Definition symtab.h:881
void target_float_convert(const gdb_byte *from, const struct type *from_type, gdb_byte *to, const struct type *to_type)
double target_float_to_host_double(const gdb_byte *addr, const struct type *type)
void target_float_from_host_double(gdb_byte *addr, const struct type *type, double val)
bool target_has_execution(inferior *inf)
Definition target.c:202
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
target_xfer_partial_ftype target_xfer_partial
target_xfer_status
Definition target.h:214
@ TARGET_XFER_E_IO
Definition target.h:227
@ TARGET_XFER_EOF
Definition target.h:219
@ TARGET_XFER_OK
Definition target.h:216
@ TARGET_XFER_UNAVAILABLE
Definition target.h:222
target_object
Definition target.h:138
@ TARGET_OBJECT_STACK_MEMORY
Definition target.h:150
@ TARGET_OBJECT_MEMORY
Definition target.h:142
const struct type_print_options type_print_raw_options
Definition typeprint.c:41
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
int strcmp_iw(const char *string1, const char *string2)
Definition utils.c:2981
#define gdb_stderr
Definition utils.h:193
bool value_logical_not(struct value *arg1)
Definition valarith.c:1670
struct value * value_coerce_to_target(struct value *val)
Definition valops.c:1469
static struct value * value_namespace_elt(const struct type *, const char *, int, enum noside)
Definition valops.c:3797
struct value * value_cast_pointers(struct type *type, struct value *arg2, int subclass_check)
Definition valops.c:296
static int dynamic_cast_check_2(struct type *desired_type, const gdb_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, struct value **result)
Definition valops.c:776
static enum oload_classification classify_oload_match(const badness_vector &, int, int)
Definition valops.c:3334
static int compare_parameters(struct type *t1, struct type *t2, int skip_artificial)
Definition valops.c:3464
bool overload_resolution
Definition valops.c:101
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition valops.c:1017
static struct value * search_struct_method(const char *, struct value **, gdb::optional< gdb::array_view< value * > >, LONGEST, int *, struct type *)
Definition valops.c:2199
static struct value * value_maybe_namespace_elt(const struct type *, const char *, int, enum noside)
Definition valops.c:3819
struct value * value_string(const char *ptr, ssize_t len, struct type *char_type)
Definition valops.c:1759
struct value * value_array(int lowbound, int highbound, struct value **elemvec)
Definition valops.c:1688
struct value * value_slice(struct value *array, int lowbound, int length)
Definition valops.c:4031
static int typecmp(bool staticp, bool varargs, int nargs, struct field t1[], const gdb::array_view< value * > t2)
static struct value * value_cast_to_fixed_point(struct type *to_type, struct value *from_val)
Definition valops.c:371
struct value * value_cstring(const char *ptr, ssize_t len, struct type *char_type)
Definition valops.c:1736
static bool get_baseclass_offset(struct type *vt, struct type *cls, struct value *v, int *boffs, bool *isvirt)
Definition valops.c:3514
struct value * value_aggregate_elt(struct type *curtype, const char *name, struct type *expect_type, int want_address, enum noside noside)
Definition valops.c:3431
struct value * value_of_this_silent(const struct language_defn *lang)
Definition valops.c:4011
struct value * value_allocate_space_in_inferior(int len)
Definition valops.c:175
struct type * value_rtti_indirect_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition valops.c:3850
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition valops.c:1028
static int find_oload_champ(gdb::array_view< value * > args, size_t num_fns, fn_field *methods, xmethod_worker_up *xmethods, symbol **functions, badness_vector *oload_champ_bv)
Definition valops.c:3202
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition valops.c:3916
struct value * value_one(struct type *type)
Definition valops.c:940
static int dynamic_cast_check_1(struct type *desired_type, const gdb_byte *valaddr, LONGEST embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, CORE_ADDR arg_addr, struct type *arg_type, struct value **result)
Definition valops.c:728
oload_classification
Definition valops.c:79
@ INCOMPATIBLE
Definition valops.c:79
@ NON_STANDARD
Definition valops.c:79
@ STANDARD
Definition valops.c:79
static int oload_method_static_p(struct fn_field *, int)
Definition valops.c:3323
struct value * value_coerce_array(struct value *arg1)
Definition valops.c:1507
static void show_overload_resolution(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition valops.c:103
void _initialize_valops()
Definition valops.c:4170
struct value * value_struct_elt(struct value **argp, gdb::optional< gdb::array_view< value * > > args, const char *name, int *static_memfuncp, const char *err)
Definition valops.c:2335
struct value * value_of_variable(struct symbol *var, const struct block *b)
Definition valops.c:1378
struct value * value_addr(struct value *arg1)
Definition valops.c:1543
static struct value * value_struct_elt_for_reference(struct type *, int, struct type *, const char *, struct type *, int, enum noside)
Definition valops.c:3557
struct value * value_repeat(struct value *arg1, int count)
Definition valops.c:1356
static CORE_ADDR allocate_space_in_inferior(int)
Definition valops.c:196
static struct value * cast_into_complex(struct type *, struct value *)
Definition valops.c:4141
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition valops.c:117
struct value * value_cast(struct type *type, struct value *arg2)
Definition valops.c:408
static struct value * enum_constant_from_type(struct type *type, const char *name)
Definition valops.c:3393
static void value_find_oload_method_list(struct value **argp, const char *method, LONGEST offset, gdb::array_view< fn_field > *methods, std::vector< xmethod_worker_up > *xmethods, struct type **basetype, LONGEST *boffset)
Definition valops.c:2586
struct value * value_assign(struct value *toval, struct value *fromval)
Definition valops.c:1077
struct value * value_real_part(struct value *value)
Definition valops.c:4116
struct value * value_coerce_function(struct value *arg1)
Definition valops.c:1527
bool value_must_coerce_to_target(struct value *val)
Definition valops.c:1441
static struct value * get_value_at(struct type *type, CORE_ADDR addr, int lazy)
Definition valops.c:986
struct value * value_ind(struct value *arg1)
Definition valops.c:1623
struct value * value_literal_complex(struct value *arg1, struct value *arg2, struct type *type)
Definition valops.c:4092
static void find_method_list(struct value **argp, const char *method, LONGEST offset, struct type *type, gdb::array_view< fn_field > *methods, std::vector< xmethod_worker_up > *xmethods, struct type **basetype, LONGEST *boffset)
Definition valops.c:2494
struct value * value_struct_elt_bitpos(struct value **argp, int bitpos, struct type *ftype, const char *err)
Definition valops.c:2434
static struct value * search_struct_field(const char *, struct value *, struct type *, int)
Definition valops.c:2132
static struct value * value_cast_structs(struct type *type, struct value *v2)
Definition valops.c:207
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition valops.c:1602
struct value * value_dynamic_cast(struct type *type, struct value *arg)
Definition valops.c:817
static int find_oload_champ_namespace_loop(gdb::array_view< value * > args, const char *, const char *, int, std::vector< symbol * > *oload_syms, badness_vector *, int *, const int no_adl)
Definition valops.c:3086
struct value * address_of_variable(struct symbol *var, const struct block *b)
Definition valops.c:1389
gdb_mpq value_to_gdb_mpq(struct value *value)
Definition valops.c:338
void read_value_memory(struct value *val, LONGEST bit_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
Definition valops.c:1034
static int find_oload_champ_namespace(gdb::array_view< value * > args, const char *, const char *, std::vector< symbol * > *oload_syms, badness_vector *, const int no_adl)
Definition valops.c:3060
struct value * value_of_this(const struct language_defn *lang)
Definition valops.c:3986
struct value * value_imaginary_part(struct value *value)
Definition valops.c:4128
int destructor_name_p(const char *name, struct type *type)
Definition valops.c:3367
struct value * value_reinterpret_cast(struct type *type, struct value *arg)
Definition valops.c:670
int find_overload_match(gdb::array_view< value * > args, const char *name, enum oload_search_type method, struct value **objp, struct symbol *fsym, struct value **valp, struct symbol **symp, int *staticp, const int no_adl, const enum noside noside)
Definition valops.c:2711
static std::string incomplete_type_hint(gdb::array_view< value * > args)
Definition valops.c:2628
struct type * value_type(const struct value *value)
Definition value.c:1109
struct value * value_from_component(struct value *whole, struct type *type, LONGEST offset)
Definition value.c:3806
struct value * value_zero(struct type *type, enum lval_type lv)
Definition value.c:3613
LONGEST value_embedded_offset(const struct value *value)
Definition value.c:1555
struct value * value_of_internalvar(struct gdbarch *gdbarch, struct internalvar *var)
Definition value.c:2250
struct value * allocate_value_lazy(struct type *type)
Definition value.c:948
LONGEST value_offset(const struct value *value)
Definition value.c:1120
gdb::array_view< const gdb_byte > value_contents_all(struct value *value)
Definition value.c:1284
LONGEST value_bitsize(const struct value *value)
Definition value.c:1142
struct value * value_parent(const struct value *value)
Definition value.c:1153
const struct lval_funcs * value_computed_funcs(const struct value *v)
Definition value.c:1579
bool is_floating_value(struct value *val)
Definition value.c:3020
int value_lazy(const struct value *value)
Definition value.c:1440
void value_contents_copy(struct value *dst, LONGEST dst_offset, struct value *src, LONGEST src_offset, LONGEST length)
Definition value.c:1430
struct value * allocate_value(struct type *type)
Definition value.c:1053
CORE_ADDR value_as_address(struct value *val)
Definition value.c:2804
struct gdbarch * get_value_arch(const struct value *value)
Definition value.c:377
void set_value_embedded_offset(struct value *value, LONGEST val)
Definition value.c:1561
void set_value_address(struct value *value, CORE_ADDR addr)
Definition value.c:1631
void set_value_component_location(struct value *component, const struct value *whole)
Definition value.c:1858
void value_fetch_lazy(struct value *val)
Definition value.c:4162
struct value * value_primitive_field(struct value *arg1, LONGEST offset, int fieldno, struct type *arg_type)
Definition value.c:3105
void set_value_offset(struct value *value, LONGEST offset)
Definition value.c:1125
struct value * value_from_xmethod(xmethod_worker_up &&worker)
Definition value.c:2751
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition value.c:3637
struct value * value_static_field(struct type *type, int fieldno)
Definition value.c:3039
CORE_ADDR value_address(const struct value *value)
Definition value.c:1607
struct value * value_from_longest(struct type *type, LONGEST num)
Definition value.c:3625
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
Definition value.c:1167
struct value * coerce_ref(struct value *arg)
Definition value.c:3902
struct value * coerce_array(struct value *arg)
Definition value.c:3926
void mark_value_bits_unavailable(struct value *value, LONGEST offset, LONGEST length)
Definition value.c:628
void set_internalvar(struct internalvar *var, struct value *val)
Definition value.c:2404
void set_internalvar_component(struct internalvar *var, LONGEST offset, LONGEST bitpos, LONGEST bitsize, struct value *newval)
Definition value.c:2374
gdb::array_view< const gdb_byte > value_contents(struct value *value)
Definition value.c:1464
gdb::array_view< gdb_byte > value_contents_writeable(struct value *value)
Definition value.c:1473
gdb::array_view< gdb_byte > value_contents_all_raw(struct value *value)
Definition value.c:1180
struct value * value_fn_field(struct value **arg1p, struct fn_field *f, int j, struct type *type, LONGEST offset)
Definition value.c:3242
LONGEST value_as_long(struct value *val)
Definition value.c:2791
void modify_field(struct type *type, gdb_byte *addr, LONGEST fieldval, LONGEST bitpos, LONGEST bitsize)
Definition value.c:3466
struct value * value_copy(const value *arg)
Definition value.c:1760
void set_value_pointed_to_offset(struct value *value, LONGEST val)
Definition value.c:1573
LONGEST value_pointed_to_offset(const struct value *value)
Definition value.c:1567
int value_stack(const struct value *value)
Definition value.c:1452
gdb::array_view< const gdb_byte > value_contents_for_printing(struct value *value)
Definition value.c:1265
void set_value_enclosing_type(struct value *val, struct type *new_encl_type)
Definition value.c:3086
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition value.c:3651
struct type * value_enclosing_type(const struct value *value)
Definition value.c:1189
int deprecated_value_modifiable(const struct value *value)
Definition value.c:1658
struct value * readjust_indirect_value_type(struct value *value, struct type *enc_type, const struct type *original_type, struct value *original_value, CORE_ADDR original_value_address)
Definition value.c:3877
void deprecated_set_value_type(struct value *value, struct type *type)
Definition value.c:1114
int value_bits_synthetic_pointer(const struct value *value, LONGEST offset, LONGEST length)
Definition value.c:1543
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition value.c:3703
LONGEST value_bitpos(const struct value *value)
Definition value.c:1131
void set_value_lazy(struct value *value, int val)
Definition value.c:1446
struct value * allocate_repeat_value(struct type *type, int count)
Definition value.c:1066
#define VALUE_NEXT_FRAME_ID(val)
Definition value.h:465
#define VALUE_LVAL(val)
Definition value.h:438
#define VALUE_REGNUM(val)
Definition value.h:469
#define VALUE_INTERNALVAR(val)
Definition value.h:458
oload_search_type
Definition value.h:867
@ BOTH
Definition value.h:867
@ METHOD
Definition value.h:867
@ NON_METHOD
Definition value.h:867