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