1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "dictionary.h"
38 #include "cp-support.h"
40 #include "user-regs.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
50 extern int overload_debug;
51 /* Local functions. */
53 static int typecmp (int staticp, int varargs, int nargs,
54 struct field t1[], struct value *t2[]);
56 static struct value *search_struct_field (const char *, struct value *,
57 int, struct type *, int);
59 static struct value *search_struct_method (const char *, struct value **,
61 int, int *, struct type *);
63 static int find_oload_champ_namespace (struct type **, int,
64 const char *, const char *,
66 struct badness_vector **,
70 int find_oload_champ_namespace_loop (struct type **, int,
71 const char *, const char *,
72 int, struct symbol ***,
73 struct badness_vector **, int *,
76 static int find_oload_champ (struct type **, int, int, int,
77 struct fn_field *, struct symbol **,
78 struct badness_vector **);
80 static int oload_method_static (int, struct fn_field *, int);
82 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
85 oload_classification classify_oload_match (struct badness_vector *,
88 static struct value *value_struct_elt_for_reference (struct type *,
94 static struct value *value_namespace_elt (const struct type *,
95 char *, int , enum noside);
97 static struct value *value_maybe_namespace_elt (const struct type *,
101 static CORE_ADDR allocate_space_in_inferior (int);
103 static struct value *cast_into_complex (struct type *, struct value *);
105 static struct fn_field *find_method_list (struct value **, const char *,
106 int, struct type *, int *,
107 struct type **, int *);
109 void _initialize_valops (void);
112 /* Flag for whether we want to abandon failed expression evals by
115 static int auto_abandon = 0;
118 int overload_resolution = 0;
120 show_overload_resolution (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c,
124 fprintf_filtered (file, _("\
125 Overload resolution in evaluating C++ functions is %s.\n"),
129 /* Find the address of function name NAME in the inferior. If OBJF_P
130 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
134 find_function_in_inferior (const char *name, struct objfile **objf_p)
137 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
140 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
142 error (_("\"%s\" exists in this program but is not a function."),
147 *objf_p = SYMBOL_SYMTAB (sym)->objfile;
149 return value_of_variable (sym, NULL);
153 struct minimal_symbol *msymbol =
154 lookup_minimal_symbol (name, NULL, NULL);
157 struct objfile *objfile = msymbol_objfile (msymbol);
158 struct gdbarch *gdbarch = get_objfile_arch (objfile);
162 type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
163 type = lookup_function_type (type);
164 type = lookup_pointer_type (type);
165 maddr = SYMBOL_VALUE_ADDRESS (msymbol);
170 return value_from_pointer (type, maddr);
174 if (!target_has_execution)
175 error (_("evaluation of this expression requires the target program to be active"));
177 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
182 /* Allocate NBYTES of space in the inferior using the inferior's
183 malloc and return a value that is a pointer to the allocated
187 value_allocate_space_in_inferior (int len)
189 struct objfile *objf;
190 struct value *val = find_function_in_inferior ("malloc", &objf);
191 struct gdbarch *gdbarch = get_objfile_arch (objf);
192 struct value *blocklen;
194 blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
195 val = call_function_by_hand (val, 1, &blocklen);
196 if (value_logical_not (val))
198 if (!target_has_execution)
199 error (_("No memory available to program now: you need to start the target first"));
201 error (_("No memory available to program: call to malloc failed"));
207 allocate_space_in_inferior (int len)
209 return value_as_long (value_allocate_space_in_inferior (len));
212 /* Cast struct value VAL to type TYPE and return as a value.
213 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
214 for this to work. Typedef to one of the codes is permitted.
215 Returns NULL if the cast is neither an upcast nor a downcast. */
217 static struct value *
218 value_cast_structs (struct type *type, struct value *v2)
224 gdb_assert (type != NULL && v2 != NULL);
226 t1 = check_typedef (type);
227 t2 = check_typedef (value_type (v2));
229 /* Check preconditions. */
230 gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
231 || TYPE_CODE (t1) == TYPE_CODE_UNION)
232 && !!"Precondition is that type is of STRUCT or UNION kind.");
233 gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
234 || TYPE_CODE (t2) == TYPE_CODE_UNION)
235 && !!"Precondition is that value is of STRUCT or UNION kind");
237 if (TYPE_NAME (t1) != NULL
238 && TYPE_NAME (t2) != NULL
239 && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
242 /* Upcasting: look in the type of the source to see if it contains the
243 type of the target as a superclass. If so, we'll need to
244 offset the pointer rather than just change its type. */
245 if (TYPE_NAME (t1) != NULL)
247 v = search_struct_field (type_name_no_tag (t1),
253 /* Downcasting: look in the type of the target to see if it contains the
254 type of the source as a superclass. If so, we'll need to
255 offset the pointer rather than just change its type. */
256 if (TYPE_NAME (t2) != NULL)
258 /* Try downcasting using the run-time type of the value. */
259 int full, top, using_enc;
260 struct type *real_type;
262 real_type = value_rtti_type (v2, &full, &top, &using_enc);
265 v = value_full_object (v2, real_type, full, top, using_enc);
266 v = value_at_lazy (real_type, value_address (v));
268 /* We might be trying to cast to the outermost enclosing
269 type, in which case search_struct_field won't work. */
270 if (TYPE_NAME (real_type) != NULL
271 && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
274 v = search_struct_field (type_name_no_tag (t2), v, 0, real_type, 1);
279 /* Try downcasting using information from the destination type
280 T2. This wouldn't work properly for classes with virtual
281 bases, but those were handled above. */
282 v = search_struct_field (type_name_no_tag (t2),
283 value_zero (t1, not_lval), 0, t1, 1);
286 /* Downcasting is possible (t1 is superclass of v2). */
287 CORE_ADDR addr2 = value_address (v2);
288 addr2 -= value_address (v) + value_embedded_offset (v);
289 return value_at (type, addr2);
296 /* Cast one pointer or reference type to another. Both TYPE and
297 the type of ARG2 should be pointer types, or else both should be
298 reference types. Returns the new pointer or reference. */
301 value_cast_pointers (struct type *type, struct value *arg2)
303 struct type *type2 = check_typedef (value_type (arg2));
304 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
305 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
307 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
308 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
309 && !value_logical_not (arg2))
313 if (TYPE_CODE (type2) == TYPE_CODE_REF)
314 v2 = coerce_ref (arg2);
316 v2 = value_ind (arg2);
317 gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) == TYPE_CODE_STRUCT
318 && !!"Why did coercion fail?");
319 v2 = value_cast_structs (t1, v2);
320 /* At this point we have what we can have, un-dereference if needed. */
323 struct value *v = value_addr (v2);
324 deprecated_set_value_type (v, type);
329 /* No superclass found, just change the pointer type. */
330 arg2 = value_copy (arg2);
331 deprecated_set_value_type (arg2, type);
332 arg2 = value_change_enclosing_type (arg2, type);
333 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
337 /* Cast value ARG2 to type TYPE and return as a value.
338 More general than a C cast: accepts any two types of the same length,
339 and if ARG2 is an lvalue it can be cast into anything at all. */
340 /* In C++, casts may change pointer or object representations. */
343 value_cast (struct type *type, struct value *arg2)
345 enum type_code code1;
346 enum type_code code2;
350 int convert_to_boolean = 0;
352 if (value_type (arg2) == type)
355 code1 = TYPE_CODE (check_typedef (type));
357 /* Check if we are casting struct reference to struct reference. */
358 if (code1 == TYPE_CODE_REF)
360 /* We dereference type; then we recurse and finally
361 we generate value of the given reference. Nothing wrong with
363 struct type *t1 = check_typedef (type);
364 struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
365 struct value *val = value_cast (dereftype, arg2);
366 return value_ref (val);
369 code2 = TYPE_CODE (check_typedef (value_type (arg2)));
371 if (code2 == TYPE_CODE_REF)
372 /* We deref the value and then do the cast. */
373 return value_cast (type, coerce_ref (arg2));
375 CHECK_TYPEDEF (type);
376 code1 = TYPE_CODE (type);
377 arg2 = coerce_ref (arg2);
378 type2 = check_typedef (value_type (arg2));
380 /* You can't cast to a reference type. See value_cast_pointers
382 gdb_assert (code1 != TYPE_CODE_REF);
384 /* A cast to an undetermined-length array_type, such as
385 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
386 where N is sizeof(OBJECT)/sizeof(TYPE). */
387 if (code1 == TYPE_CODE_ARRAY)
389 struct type *element_type = TYPE_TARGET_TYPE (type);
390 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
391 if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
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 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
397 low_bound = 0, high_bound = 0;
398 new_length = val_length / element_length;
399 if (val_length % element_length != 0)
400 warning (_("array element type size does not divide object size in cast"));
401 /* FIXME-type-allocation: need a way to free this type when
402 we are done with it. */
403 range_type = create_range_type ((struct type *) NULL,
404 TYPE_TARGET_TYPE (range_type),
406 new_length + low_bound - 1);
407 deprecated_set_value_type (arg2,
408 create_array_type ((struct type *) NULL,
415 if (current_language->c_style_arrays
416 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
417 arg2 = value_coerce_array (arg2);
419 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
420 arg2 = value_coerce_function (arg2);
422 type2 = check_typedef (value_type (arg2));
423 code2 = TYPE_CODE (type2);
425 if (code1 == TYPE_CODE_COMPLEX)
426 return cast_into_complex (type, arg2);
427 if (code1 == TYPE_CODE_BOOL)
429 code1 = TYPE_CODE_INT;
430 convert_to_boolean = 1;
432 if (code1 == TYPE_CODE_CHAR)
433 code1 = TYPE_CODE_INT;
434 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
435 code2 = TYPE_CODE_INT;
437 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
438 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
439 || code2 == TYPE_CODE_RANGE);
441 if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
442 && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
443 && TYPE_NAME (type) != 0)
445 struct value *v = value_cast_structs (type, arg2);
450 if (code1 == TYPE_CODE_FLT && scalar)
451 return value_from_double (type, value_as_double (arg2));
452 else if (code1 == TYPE_CODE_DECFLOAT && scalar)
454 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
455 int dec_len = TYPE_LENGTH (type);
458 if (code2 == TYPE_CODE_FLT)
459 decimal_from_floating (arg2, dec, dec_len, byte_order);
460 else if (code2 == TYPE_CODE_DECFLOAT)
461 decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
462 byte_order, dec, dec_len, byte_order);
464 /* The only option left is an integral type. */
465 decimal_from_integral (arg2, dec, dec_len, byte_order);
467 return value_from_decfloat (type, dec);
469 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
470 || code1 == TYPE_CODE_RANGE)
471 && (scalar || code2 == TYPE_CODE_PTR
472 || code2 == TYPE_CODE_MEMBERPTR))
476 /* When we cast pointers to integers, we mustn't use
477 gdbarch_pointer_to_address to find the address the pointer
478 represents, as value_as_long would. GDB should evaluate
479 expressions just as the compiler would --- and the compiler
480 sees a cast as a simple reinterpretation of the pointer's
482 if (code2 == TYPE_CODE_PTR)
483 longest = extract_unsigned_integer
484 (value_contents (arg2), TYPE_LENGTH (type2),
485 gdbarch_byte_order (get_type_arch (type2)));
487 longest = value_as_long (arg2);
488 return value_from_longest (type, convert_to_boolean ?
489 (LONGEST) (longest ? 1 : 0) : longest);
491 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
492 || code2 == TYPE_CODE_ENUM
493 || code2 == TYPE_CODE_RANGE))
495 /* TYPE_LENGTH (type) is the length of a pointer, but we really
496 want the length of an address! -- we are really dealing with
497 addresses (i.e., gdb representations) not pointers (i.e.,
498 target representations) here.
500 This allows things like "print *(int *)0x01000234" to work
501 without printing a misleading message -- which would
502 otherwise occur when dealing with a target having two byte
503 pointers and four byte addresses. */
505 int addr_bit = gdbarch_addr_bit (get_type_arch (type2));
507 LONGEST longest = value_as_long (arg2);
508 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
510 if (longest >= ((LONGEST) 1 << addr_bit)
511 || longest <= -((LONGEST) 1 << addr_bit))
512 warning (_("value truncated"));
514 return value_from_longest (type, longest);
516 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
517 && value_as_long (arg2) == 0)
519 struct value *result = allocate_value (type);
520 cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0);
523 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
524 && value_as_long (arg2) == 0)
526 /* The Itanium C++ ABI represents NULL pointers to members as
527 minus one, instead of biasing the normal case. */
528 return value_from_longest (type, -1);
530 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
532 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
533 return value_cast_pointers (type, arg2);
535 arg2 = value_copy (arg2);
536 deprecated_set_value_type (arg2, type);
537 arg2 = value_change_enclosing_type (arg2, type);
538 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
541 else if (VALUE_LVAL (arg2) == lval_memory)
542 return value_at_lazy (type, value_address (arg2));
543 else if (code1 == TYPE_CODE_VOID)
545 return value_zero (type, not_lval);
549 error (_("Invalid cast."));
554 /* The C++ reinterpret_cast operator. */
557 value_reinterpret_cast (struct type *type, struct value *arg)
559 struct value *result;
560 struct type *real_type = check_typedef (type);
561 struct type *arg_type, *dest_type;
563 enum type_code dest_code, arg_code;
565 /* Do reference, function, and array conversion. */
566 arg = coerce_array (arg);
568 /* Attempt to preserve the type the user asked for. */
571 /* If we are casting to a reference type, transform
572 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
573 if (TYPE_CODE (real_type) == TYPE_CODE_REF)
576 arg = value_addr (arg);
577 dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
578 real_type = lookup_pointer_type (real_type);
581 arg_type = value_type (arg);
583 dest_code = TYPE_CODE (real_type);
584 arg_code = TYPE_CODE (arg_type);
586 /* We can convert pointer types, or any pointer type to int, or int
588 if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
589 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
590 || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
591 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
592 || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
593 || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
594 || (dest_code == arg_code
595 && (dest_code == TYPE_CODE_PTR
596 || dest_code == TYPE_CODE_METHODPTR
597 || dest_code == TYPE_CODE_MEMBERPTR)))
598 result = value_cast (dest_type, arg);
600 error (_("Invalid reinterpret_cast"));
603 result = value_cast (type, value_ref (value_ind (result)));
608 /* A helper for value_dynamic_cast. This implements the first of two
609 runtime checks: we iterate over all the base classes of the value's
610 class which are equal to the desired class; if only one of these
611 holds the value, then it is the answer. */
614 dynamic_cast_check_1 (struct type *desired_type,
615 const bfd_byte *contents,
617 struct type *search_type,
619 struct type *arg_type,
620 struct value **result)
622 int i, result_count = 0;
624 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
626 int offset = baseclass_offset (search_type, i, contents, address);
628 error (_("virtual baseclass botch"));
629 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
631 if (address + offset >= arg_addr
632 && address + offset < arg_addr + TYPE_LENGTH (arg_type))
636 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
641 result_count += dynamic_cast_check_1 (desired_type,
644 TYPE_BASECLASS (search_type, i),
653 /* A helper for value_dynamic_cast. This implements the second of two
654 runtime checks: we look for a unique public sibling class of the
655 argument's declared class. */
658 dynamic_cast_check_2 (struct type *desired_type,
659 const bfd_byte *contents,
661 struct type *search_type,
662 struct value **result)
664 int i, result_count = 0;
666 for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
670 if (! BASETYPE_VIA_PUBLIC (search_type, i))
673 offset = baseclass_offset (search_type, i, contents, address);
675 error (_("virtual baseclass botch"));
676 if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
680 *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
684 result_count += dynamic_cast_check_2 (desired_type,
687 TYPE_BASECLASS (search_type, i),
694 /* The C++ dynamic_cast operator. */
697 value_dynamic_cast (struct type *type, struct value *arg)
699 int full, top, using_enc;
700 struct type *resolved_type = check_typedef (type);
701 struct type *arg_type = check_typedef (value_type (arg));
702 struct type *class_type, *rtti_type;
703 struct value *result, *tem, *original_arg = arg;
705 int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF;
707 if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
708 && TYPE_CODE (resolved_type) != TYPE_CODE_REF)
709 error (_("Argument to dynamic_cast must be a pointer or reference type"));
710 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
711 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_CLASS)
712 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
714 class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
715 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
717 if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
718 && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
719 && value_as_long (arg) == 0))
720 error (_("Argument to dynamic_cast does not have pointer type"));
721 if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
723 arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
724 if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
725 error (_("Argument to dynamic_cast does not have pointer to class type"));
728 /* Handle NULL pointers. */
729 if (value_as_long (arg) == 0)
730 return value_zero (type, not_lval);
732 arg = value_ind (arg);
736 if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
737 error (_("Argument to dynamic_cast does not have class type"));
740 /* If the classes are the same, just return the argument. */
741 if (class_types_same_p (class_type, arg_type))
742 return value_cast (type, arg);
744 /* If the target type is a unique base class of the argument's
745 declared type, just cast it. */
746 if (is_ancestor (class_type, arg_type))
748 if (is_unique_ancestor (class_type, arg))
749 return value_cast (type, original_arg);
750 error (_("Ambiguous dynamic_cast"));
753 rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
755 error (_("Couldn't determine value's most derived type for dynamic_cast"));
757 /* Compute the most derived object's address. */
758 addr = value_address (arg);
766 addr += top + value_embedded_offset (arg);
768 /* dynamic_cast<void *> means to return a pointer to the
769 most-derived object. */
770 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
771 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
772 return value_at_lazy (type, addr);
774 tem = value_at (type, addr);
776 /* The first dynamic check specified in 5.2.7. */
777 if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
779 if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
782 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
783 value_contents (tem), value_address (tem),
787 return value_cast (type,
788 is_ref ? value_ref (result) : value_addr (result));
791 /* The second dynamic check specified in 5.2.7. */
793 if (is_public_ancestor (arg_type, rtti_type)
794 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
795 value_contents (tem), value_address (tem),
796 rtti_type, &result) == 1)
797 return value_cast (type,
798 is_ref ? value_ref (result) : value_addr (result));
800 if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
801 return value_zero (type, not_lval);
803 error (_("dynamic_cast failed"));
806 /* Create a value of type TYPE that is zero, and return it. */
809 value_zero (struct type *type, enum lval_type lv)
811 struct value *val = allocate_value (type);
812 VALUE_LVAL (val) = lv;
817 /* Create a value of numeric type TYPE that is one, and return it. */
820 value_one (struct type *type, enum lval_type lv)
822 struct type *type1 = check_typedef (type);
825 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
827 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
829 decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
830 val = value_from_decfloat (type, v);
832 else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
834 val = value_from_double (type, (DOUBLEST) 1);
836 else if (is_integral_type (type1))
838 val = value_from_longest (type, (LONGEST) 1);
842 error (_("Not a numeric type."));
845 VALUE_LVAL (val) = lv;
849 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
851 static struct value *
852 get_value_at (struct type *type, CORE_ADDR addr, int lazy)
856 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
857 error (_("Attempt to dereference a generic pointer."));
861 val = allocate_value_lazy (type);
865 val = allocate_value (type);
866 read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
869 VALUE_LVAL (val) = lval_memory;
870 set_value_address (val, addr);
875 /* Return a value with type TYPE located at ADDR.
877 Call value_at only if the data needs to be fetched immediately;
878 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
879 value_at_lazy instead. value_at_lazy simply records the address of
880 the data and sets the lazy-evaluation-required flag. The lazy flag
881 is tested in the value_contents macro, which is used if and when
882 the contents are actually required.
884 Note: value_at does *NOT* handle embedded offsets; perform such
885 adjustments before or after calling it. */
888 value_at (struct type *type, CORE_ADDR addr)
890 return get_value_at (type, addr, 0);
893 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
896 value_at_lazy (struct type *type, CORE_ADDR addr)
898 return get_value_at (type, addr, 1);
901 /* Called only from the value_contents and value_contents_all()
902 macros, if the current data for a variable needs to be loaded into
903 value_contents(VAL). Fetches the data from the user's process, and
904 clears the lazy flag to indicate that the data in the buffer is
907 If the value is zero-length, we avoid calling read_memory, which
908 would abort. We mark the value as fetched anyway -- all 0 bytes of
911 This function returns a value because it is used in the
912 value_contents macro as part of an expression, where a void would
913 not work. The value is ignored. */
916 value_fetch_lazy (struct value *val)
918 gdb_assert (value_lazy (val));
919 allocate_value_contents (val);
920 if (value_bitsize (val))
922 /* To read a lazy bitfield, read the entire enclosing value. This
923 prevents reading the same block of (possibly volatile) memory once
924 per bitfield. It would be even better to read only the containing
925 word, but we have no way to record that just specific bits of a
926 value have been fetched. */
927 struct type *type = check_typedef (value_type (val));
928 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
929 struct value *parent = value_parent (val);
930 LONGEST offset = value_offset (val);
931 LONGEST num = unpack_bits_as_long (value_type (val),
932 value_contents (parent) + offset,
934 value_bitsize (val));
935 int length = TYPE_LENGTH (type);
936 store_signed_integer (value_contents_raw (val), length, byte_order, num);
938 else if (VALUE_LVAL (val) == lval_memory)
940 CORE_ADDR addr = value_address (val);
941 int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
945 if (value_stack (val))
946 read_stack (addr, value_contents_all_raw (val), length);
948 read_memory (addr, value_contents_all_raw (val), length);
951 else if (VALUE_LVAL (val) == lval_register)
953 struct frame_info *frame;
955 struct type *type = check_typedef (value_type (val));
956 struct value *new_val = val, *mark = value_mark ();
958 /* Offsets are not supported here; lazy register values must
959 refer to the entire register. */
960 gdb_assert (value_offset (val) == 0);
962 while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
964 frame = frame_find_by_id (VALUE_FRAME_ID (new_val));
965 regnum = VALUE_REGNUM (new_val);
967 gdb_assert (frame != NULL);
969 /* Convertible register routines are used for multi-register
970 values and for interpretation in different types
971 (e.g. float or int from a double register). Lazy
972 register values should have the register's natural type,
973 so they do not apply. */
974 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame),
977 new_val = get_frame_register_value (frame, regnum);
980 /* If it's still lazy (for instance, a saved register on the
982 if (value_lazy (new_val))
983 value_fetch_lazy (new_val);
985 /* If the register was not saved, mark it unavailable. */
986 if (value_optimized_out (new_val))
987 set_value_optimized_out (val, 1);
989 memcpy (value_contents_raw (val), value_contents (new_val),
994 struct gdbarch *gdbarch;
995 frame = frame_find_by_id (VALUE_FRAME_ID (val));
996 regnum = VALUE_REGNUM (val);
997 gdbarch = get_frame_arch (frame);
999 fprintf_unfiltered (gdb_stdlog, "\
1000 { value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
1001 frame_relative_level (frame), regnum,
1002 user_reg_map_regnum_to_name (gdbarch, regnum));
1004 fprintf_unfiltered (gdb_stdlog, "->");
1005 if (value_optimized_out (new_val))
1006 fprintf_unfiltered (gdb_stdlog, " optimized out");
1010 const gdb_byte *buf = value_contents (new_val);
1012 if (VALUE_LVAL (new_val) == lval_register)
1013 fprintf_unfiltered (gdb_stdlog, " register=%d",
1014 VALUE_REGNUM (new_val));
1015 else if (VALUE_LVAL (new_val) == lval_memory)
1016 fprintf_unfiltered (gdb_stdlog, " address=%s",
1018 value_address (new_val)));
1020 fprintf_unfiltered (gdb_stdlog, " computed");
1022 fprintf_unfiltered (gdb_stdlog, " bytes=");
1023 fprintf_unfiltered (gdb_stdlog, "[");
1024 for (i = 0; i < register_size (gdbarch, regnum); i++)
1025 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1026 fprintf_unfiltered (gdb_stdlog, "]");
1029 fprintf_unfiltered (gdb_stdlog, " }\n");
1032 /* Dispose of the intermediate values. This prevents
1033 watchpoints from trying to watch the saved frame pointer. */
1034 value_free_to_mark (mark);
1036 else if (VALUE_LVAL (val) == lval_computed)
1037 value_computed_funcs (val)->read (val);
1039 internal_error (__FILE__, __LINE__, "Unexpected lazy value type.");
1041 set_value_lazy (val, 0);
1046 /* Store the contents of FROMVAL into the location of TOVAL.
1047 Return a new value with the location of TOVAL and contents of FROMVAL. */
1050 value_assign (struct value *toval, struct value *fromval)
1054 struct frame_id old_frame;
1056 if (!deprecated_value_modifiable (toval))
1057 error (_("Left operand of assignment is not a modifiable lvalue."));
1059 toval = coerce_ref (toval);
1061 type = value_type (toval);
1062 if (VALUE_LVAL (toval) != lval_internalvar)
1064 toval = value_coerce_to_target (toval);
1065 fromval = value_cast (type, fromval);
1069 /* Coerce arrays and functions to pointers, except for arrays
1070 which only live in GDB's storage. */
1071 if (!value_must_coerce_to_target (fromval))
1072 fromval = coerce_array (fromval);
1075 CHECK_TYPEDEF (type);
1077 /* Since modifying a register can trash the frame chain, and
1078 modifying memory can trash the frame cache, we save the old frame
1079 and then restore the new frame afterwards. */
1080 old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
1082 switch (VALUE_LVAL (toval))
1084 case lval_internalvar:
1085 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1086 val = value_copy (fromval);
1087 val = value_change_enclosing_type (val,
1088 value_enclosing_type (fromval));
1089 set_value_embedded_offset (val, value_embedded_offset (fromval));
1090 set_value_pointed_to_offset (val,
1091 value_pointed_to_offset (fromval));
1094 case lval_internalvar_component:
1095 set_internalvar_component (VALUE_INTERNALVAR (toval),
1096 value_offset (toval),
1097 value_bitpos (toval),
1098 value_bitsize (toval),
1104 const gdb_byte *dest_buffer;
1105 CORE_ADDR changed_addr;
1107 gdb_byte buffer[sizeof (LONGEST)];
1109 if (value_bitsize (toval))
1111 struct value *parent = value_parent (toval);
1112 changed_addr = value_address (parent) + value_offset (toval);
1114 changed_len = (value_bitpos (toval)
1115 + value_bitsize (toval)
1116 + HOST_CHAR_BIT - 1)
1119 /* If we can read-modify-write exactly the size of the
1120 containing type (e.g. short or int) then do so. This
1121 is safer for volatile bitfields mapped to hardware
1123 if (changed_len < TYPE_LENGTH (type)
1124 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
1125 && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0)
1126 changed_len = TYPE_LENGTH (type);
1128 if (changed_len > (int) sizeof (LONGEST))
1129 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1130 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1132 read_memory (changed_addr, buffer, changed_len);
1133 modify_field (type, buffer, value_as_long (fromval),
1134 value_bitpos (toval), value_bitsize (toval));
1135 dest_buffer = buffer;
1139 changed_addr = value_address (toval);
1140 changed_len = TYPE_LENGTH (type);
1141 dest_buffer = value_contents (fromval);
1144 write_memory (changed_addr, dest_buffer, changed_len);
1145 observer_notify_memory_changed (changed_addr, changed_len,
1152 struct frame_info *frame;
1153 struct gdbarch *gdbarch;
1156 /* Figure out which frame this is in currently. */
1157 frame = frame_find_by_id (VALUE_FRAME_ID (toval));
1158 value_reg = VALUE_REGNUM (toval);
1161 error (_("Value being assigned to is no longer active."));
1163 gdbarch = get_frame_arch (frame);
1164 if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), type))
1166 /* If TOVAL is a special machine register requiring
1167 conversion of program values to a special raw
1169 gdbarch_value_to_register (gdbarch, frame,
1170 VALUE_REGNUM (toval), type,
1171 value_contents (fromval));
1175 if (value_bitsize (toval))
1177 struct value *parent = value_parent (toval);
1178 int offset = value_offset (parent) + value_offset (toval);
1180 gdb_byte buffer[sizeof (LONGEST)];
1182 changed_len = (value_bitpos (toval)
1183 + value_bitsize (toval)
1184 + HOST_CHAR_BIT - 1)
1187 if (changed_len > (int) sizeof (LONGEST))
1188 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1189 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1191 get_frame_register_bytes (frame, value_reg, offset,
1192 changed_len, buffer);
1194 modify_field (type, buffer, value_as_long (fromval),
1195 value_bitpos (toval), value_bitsize (toval));
1197 put_frame_register_bytes (frame, value_reg, offset,
1198 changed_len, buffer);
1202 put_frame_register_bytes (frame, value_reg,
1203 value_offset (toval),
1205 value_contents (fromval));
1209 if (deprecated_register_changed_hook)
1210 deprecated_register_changed_hook (-1);
1211 observer_notify_target_changed (¤t_target);
1217 struct lval_funcs *funcs = value_computed_funcs (toval);
1219 funcs->write (toval, fromval);
1224 error (_("Left operand of assignment is not an lvalue."));
1227 /* Assigning to the stack pointer, frame pointer, and other
1228 (architecture and calling convention specific) registers may
1229 cause the frame cache to be out of date. Assigning to memory
1230 also can. We just do this on all assignments to registers or
1231 memory, for simplicity's sake; I doubt the slowdown matters. */
1232 switch (VALUE_LVAL (toval))
1237 reinit_frame_cache ();
1239 /* Having destroyed the frame cache, restore the selected
1242 /* FIXME: cagney/2002-11-02: There has to be a better way of
1243 doing this. Instead of constantly saving/restoring the
1244 frame. Why not create a get_selected_frame() function that,
1245 having saved the selected frame's ID can automatically
1246 re-find the previously selected frame automatically. */
1249 struct frame_info *fi = frame_find_by_id (old_frame);
1259 /* If the field does not entirely fill a LONGEST, then zero the sign
1260 bits. If the field is signed, and is negative, then sign
1262 if ((value_bitsize (toval) > 0)
1263 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1265 LONGEST fieldval = value_as_long (fromval);
1266 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1268 fieldval &= valmask;
1269 if (!TYPE_UNSIGNED (type)
1270 && (fieldval & (valmask ^ (valmask >> 1))))
1271 fieldval |= ~valmask;
1273 fromval = value_from_longest (type, fieldval);
1276 val = value_copy (toval);
1277 memcpy (value_contents_raw (val), value_contents (fromval),
1278 TYPE_LENGTH (type));
1279 deprecated_set_value_type (val, type);
1280 val = value_change_enclosing_type (val,
1281 value_enclosing_type (fromval));
1282 set_value_embedded_offset (val, value_embedded_offset (fromval));
1283 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
1288 /* Extend a value VAL to COUNT repetitions of its type. */
1291 value_repeat (struct value *arg1, int count)
1295 if (VALUE_LVAL (arg1) != lval_memory)
1296 error (_("Only values in memory can be extended with '@'."));
1298 error (_("Invalid number %d of repetitions."), count);
1300 val = allocate_repeat_value (value_enclosing_type (arg1), count);
1302 read_memory (value_address (arg1),
1303 value_contents_all_raw (val),
1304 TYPE_LENGTH (value_enclosing_type (val)));
1305 VALUE_LVAL (val) = lval_memory;
1306 set_value_address (val, value_address (arg1));
1312 value_of_variable (struct symbol *var, struct block *b)
1315 struct frame_info *frame;
1317 if (!symbol_read_needs_frame (var))
1320 frame = get_selected_frame (_("No frame selected."));
1323 frame = block_innermost_frame (b);
1326 if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
1327 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
1328 error (_("No frame is currently executing in block %s."),
1329 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
1331 error (_("No frame is currently executing in specified block"));
1335 val = read_var_value (var, frame);
1337 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
1343 address_of_variable (struct symbol *var, struct block *b)
1345 struct type *type = SYMBOL_TYPE (var);
1348 /* Evaluate it first; if the result is a memory address, we're fine.
1349 Lazy evaluation pays off here. */
1351 val = value_of_variable (var, b);
1353 if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1354 || TYPE_CODE (type) == TYPE_CODE_FUNC)
1356 CORE_ADDR addr = value_address (val);
1357 return value_from_pointer (lookup_pointer_type (type), addr);
1360 /* Not a memory address; check what the problem was. */
1361 switch (VALUE_LVAL (val))
1365 struct frame_info *frame;
1366 const char *regname;
1368 frame = frame_find_by_id (VALUE_FRAME_ID (val));
1371 regname = gdbarch_register_name (get_frame_arch (frame),
1372 VALUE_REGNUM (val));
1373 gdb_assert (regname && *regname);
1375 error (_("Address requested for identifier "
1376 "\"%s\" which is in register $%s"),
1377 SYMBOL_PRINT_NAME (var), regname);
1382 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1383 SYMBOL_PRINT_NAME (var));
1390 /* Return one if VAL does not live in target memory, but should in order
1391 to operate on it. Otherwise return zero. */
1394 value_must_coerce_to_target (struct value *val)
1396 struct type *valtype;
1398 /* The only lval kinds which do not live in target memory. */
1399 if (VALUE_LVAL (val) != not_lval
1400 && VALUE_LVAL (val) != lval_internalvar)
1403 valtype = check_typedef (value_type (val));
1405 switch (TYPE_CODE (valtype))
1407 case TYPE_CODE_ARRAY:
1408 case TYPE_CODE_STRING:
1415 /* Make sure that VAL lives in target memory if it's supposed to. For instance,
1416 strings are constructed as character arrays in GDB's storage, and this
1417 function copies them to the target. */
1420 value_coerce_to_target (struct value *val)
1425 if (!value_must_coerce_to_target (val))
1428 length = TYPE_LENGTH (check_typedef (value_type (val)));
1429 addr = allocate_space_in_inferior (length);
1430 write_memory (addr, value_contents (val), length);
1431 return value_at_lazy (value_type (val), addr);
1434 /* Given a value which is an array, return a value which is a pointer
1435 to its first element, regardless of whether or not the array has a
1436 nonzero lower bound.
1438 FIXME: A previous comment here indicated that this routine should
1439 be substracting the array's lower bound. It's not clear to me that
1440 this is correct. Given an array subscripting operation, it would
1441 certainly work to do the adjustment here, essentially computing:
1443 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1445 However I believe a more appropriate and logical place to account
1446 for the lower bound is to do so in value_subscript, essentially
1449 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1451 As further evidence consider what would happen with operations
1452 other than array subscripting, where the caller would get back a
1453 value that had an address somewhere before the actual first element
1454 of the array, and the information about the lower bound would be
1455 lost because of the coercion to pointer type.
1459 value_coerce_array (struct value *arg1)
1461 struct type *type = check_typedef (value_type (arg1));
1463 /* If the user tries to do something requiring a pointer with an
1464 array that has not yet been pushed to the target, then this would
1465 be a good time to do so. */
1466 arg1 = value_coerce_to_target (arg1);
1468 if (VALUE_LVAL (arg1) != lval_memory)
1469 error (_("Attempt to take address of value not located in memory."));
1471 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1472 value_address (arg1));
1475 /* Given a value which is a function, return a value which is a pointer
1479 value_coerce_function (struct value *arg1)
1481 struct value *retval;
1483 if (VALUE_LVAL (arg1) != lval_memory)
1484 error (_("Attempt to take address of value not located in memory."));
1486 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1487 value_address (arg1));
1491 /* Return a pointer value for the object for which ARG1 is the
1495 value_addr (struct value *arg1)
1499 struct type *type = check_typedef (value_type (arg1));
1500 if (TYPE_CODE (type) == TYPE_CODE_REF)
1502 /* Copy the value, but change the type from (T&) to (T*). We
1503 keep the same location information, which is efficient, and
1504 allows &(&X) to get the location containing the reference. */
1505 arg2 = value_copy (arg1);
1506 deprecated_set_value_type (arg2,
1507 lookup_pointer_type (TYPE_TARGET_TYPE (type)));
1510 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1511 return value_coerce_function (arg1);
1513 /* If this is an array that has not yet been pushed to the target,
1514 then this would be a good time to force it to memory. */
1515 arg1 = value_coerce_to_target (arg1);
1517 if (VALUE_LVAL (arg1) != lval_memory)
1518 error (_("Attempt to take address of value not located in memory."));
1520 /* Get target memory address */
1521 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1522 (value_address (arg1)
1523 + value_embedded_offset (arg1)));
1525 /* This may be a pointer to a base subobject; so remember the
1526 full derived object's type ... */
1527 arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
1528 /* ... and also the relative position of the subobject in the full
1530 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
1534 /* Return a reference value for the object for which ARG1 is the
1538 value_ref (struct value *arg1)
1542 struct type *type = check_typedef (value_type (arg1));
1543 if (TYPE_CODE (type) == TYPE_CODE_REF)
1546 arg2 = value_addr (arg1);
1547 deprecated_set_value_type (arg2, lookup_reference_type (type));
1551 /* Given a value of a pointer type, apply the C unary * operator to
1555 value_ind (struct value *arg1)
1557 struct type *base_type;
1560 arg1 = coerce_array (arg1);
1562 base_type = check_typedef (value_type (arg1));
1564 if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
1566 struct type *enc_type;
1567 /* We may be pointing to something embedded in a larger object.
1568 Get the real type of the enclosing object. */
1569 enc_type = check_typedef (value_enclosing_type (arg1));
1570 enc_type = TYPE_TARGET_TYPE (enc_type);
1572 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
1573 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
1574 /* For functions, go through find_function_addr, which knows
1575 how to handle function descriptors. */
1576 arg2 = value_at_lazy (enc_type,
1577 find_function_addr (arg1, NULL));
1579 /* Retrieve the enclosing object pointed to */
1580 arg2 = value_at_lazy (enc_type,
1581 (value_as_address (arg1)
1582 - value_pointed_to_offset (arg1)));
1584 /* Re-adjust type. */
1585 deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
1586 /* Add embedding info. */
1587 arg2 = value_change_enclosing_type (arg2, enc_type);
1588 set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
1590 /* We may be pointing to an object of some derived type. */
1591 arg2 = value_full_object (arg2, NULL, 0, 0, 0);
1595 error (_("Attempt to take contents of a non-pointer value."));
1596 return 0; /* For lint -- never reached. */
1599 /* Create a value for an array by allocating space in GDB, copying
1600 copying the data into that space, and then setting up an array
1603 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1604 is populated from the values passed in ELEMVEC.
1606 The element type of the array is inherited from the type of the
1607 first element, and all elements must have the same size (though we
1608 don't currently enforce any restriction on their types). */
1611 value_array (int lowbound, int highbound, struct value **elemvec)
1615 unsigned int typelength;
1617 struct type *arraytype;
1619 /* Validate that the bounds are reasonable and that each of the
1620 elements have the same size. */
1622 nelem = highbound - lowbound + 1;
1625 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1627 typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1628 for (idx = 1; idx < nelem; idx++)
1630 if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1632 error (_("array elements must all be the same size"));
1636 arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1637 lowbound, highbound);
1639 if (!current_language->c_style_arrays)
1641 val = allocate_value (arraytype);
1642 for (idx = 0; idx < nelem; idx++)
1644 memcpy (value_contents_all_raw (val) + (idx * typelength),
1645 value_contents_all (elemvec[idx]),
1651 /* Allocate space to store the array, and then initialize it by
1652 copying in each element. */
1654 val = allocate_value (arraytype);
1655 for (idx = 0; idx < nelem; idx++)
1656 memcpy (value_contents_writeable (val) + (idx * typelength),
1657 value_contents_all (elemvec[idx]),
1663 value_cstring (char *ptr, int len, struct type *char_type)
1666 int lowbound = current_language->string_lower_bound;
1667 int highbound = len / TYPE_LENGTH (char_type);
1668 struct type *stringtype
1669 = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1671 val = allocate_value (stringtype);
1672 memcpy (value_contents_raw (val), ptr, len);
1676 /* Create a value for a string constant by allocating space in the
1677 inferior, copying the data into that space, and returning the
1678 address with type TYPE_CODE_STRING. PTR points to the string
1679 constant data; LEN is number of characters.
1681 Note that string types are like array of char types with a lower
1682 bound of zero and an upper bound of LEN - 1. Also note that the
1683 string may contain embedded null bytes. */
1686 value_string (char *ptr, int len, struct type *char_type)
1689 int lowbound = current_language->string_lower_bound;
1690 int highbound = len / TYPE_LENGTH (char_type);
1691 struct type *stringtype
1692 = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1694 val = allocate_value (stringtype);
1695 memcpy (value_contents_raw (val), ptr, len);
1700 value_bitstring (char *ptr, int len, struct type *index_type)
1703 struct type *domain_type
1704 = create_range_type (NULL, index_type, 0, len - 1);
1705 struct type *type = create_set_type (NULL, domain_type);
1706 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1707 val = allocate_value (type);
1708 memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
1712 /* See if we can pass arguments in T2 to a function which takes
1713 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1714 a NULL-terminated vector. If some arguments need coercion of some
1715 sort, then the coerced values are written into T2. Return value is
1716 0 if the arguments could be matched, or the position at which they
1719 STATICP is nonzero if the T1 argument list came from a static
1720 member function. T2 will still include the ``this'' pointer, but
1723 For non-static member functions, we ignore the first argument,
1724 which is the type of the instance variable. This is because we
1725 want to handle calls with objects from derived classes. This is
1726 not entirely correct: we should actually check to make sure that a
1727 requested operation is type secure, shouldn't we? FIXME. */
1730 typecmp (int staticp, int varargs, int nargs,
1731 struct field t1[], struct value *t2[])
1736 internal_error (__FILE__, __LINE__,
1737 _("typecmp: no argument list"));
1739 /* Skip ``this'' argument if applicable. T2 will always include
1745 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1748 struct type *tt1, *tt2;
1753 tt1 = check_typedef (t1[i].type);
1754 tt2 = check_typedef (value_type (t2[i]));
1756 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1757 /* We should be doing hairy argument matching, as below. */
1758 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1760 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1761 t2[i] = value_coerce_array (t2[i]);
1763 t2[i] = value_ref (t2[i]);
1767 /* djb - 20000715 - Until the new type structure is in the
1768 place, and we can attempt things like implicit conversions,
1769 we need to do this so you can take something like a map<const
1770 char *>, and properly access map["hello"], because the
1771 argument to [] will be a reference to a pointer to a char,
1772 and the argument will be a pointer to a char. */
1773 while (TYPE_CODE(tt1) == TYPE_CODE_REF
1774 || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1776 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1778 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1779 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1780 || TYPE_CODE(tt2) == TYPE_CODE_REF)
1782 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1784 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1786 /* Array to pointer is a `trivial conversion' according to the
1789 /* We should be doing much hairier argument matching (see
1790 section 13.2 of the ARM), but as a quick kludge, just check
1791 for the same type code. */
1792 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1795 if (varargs || t2[i] == NULL)
1800 /* Helper function used by value_struct_elt to recurse through
1801 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1802 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1803 TYPE. If found, return value, else return NULL.
1805 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1806 fields, look for a baseclass named NAME. */
1808 static struct value *
1809 search_struct_field (const char *name, struct value *arg1, int offset,
1810 struct type *type, int looking_for_baseclass)
1815 CHECK_TYPEDEF (type);
1816 nbases = TYPE_N_BASECLASSES (type);
1818 if (!looking_for_baseclass)
1819 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1821 char *t_field_name = TYPE_FIELD_NAME (type, i);
1823 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1826 if (field_is_static (&TYPE_FIELD (type, i)))
1828 v = value_static_field (type, i);
1830 error (_("field %s is nonexistent or has been optimised out"),
1835 v = value_primitive_field (arg1, offset, i, type);
1837 error (_("there is no field named %s"), name);
1843 && (t_field_name[0] == '\0'
1844 || (TYPE_CODE (type) == TYPE_CODE_UNION
1845 && (strcmp_iw (t_field_name, "else") == 0))))
1847 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1848 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1849 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1851 /* Look for a match through the fields of an anonymous
1852 union, or anonymous struct. C++ provides anonymous
1855 In the GNU Chill (now deleted from GDB)
1856 implementation of variant record types, each
1857 <alternative field> has an (anonymous) union type,
1858 each member of the union represents a <variant
1859 alternative>. Each <variant alternative> is
1860 represented as a struct, with a member for each
1864 int new_offset = offset;
1866 /* This is pretty gross. In G++, the offset in an
1867 anonymous union is relative to the beginning of the
1868 enclosing struct. In the GNU Chill (now deleted
1869 from GDB) implementation of variant records, the
1870 bitpos is zero in an anonymous union field, so we
1871 have to add the offset of the union here. */
1872 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1873 || (TYPE_NFIELDS (field_type) > 0
1874 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1875 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1877 v = search_struct_field (name, arg1, new_offset,
1879 looking_for_baseclass);
1886 for (i = 0; i < nbases; i++)
1889 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1890 /* If we are looking for baseclasses, this is what we get when
1891 we hit them. But it could happen that the base part's member
1892 name is not yet filled in. */
1893 int found_baseclass = (looking_for_baseclass
1894 && TYPE_BASECLASS_NAME (type, i) != NULL
1895 && (strcmp_iw (name,
1896 TYPE_BASECLASS_NAME (type,
1899 if (BASETYPE_VIA_VIRTUAL (type, i))
1904 boffset = baseclass_offset (type, i,
1905 value_contents (arg1) + offset,
1906 value_address (arg1)
1907 + value_embedded_offset (arg1)
1910 error (_("virtual baseclass botch"));
1912 /* The virtual base class pointer might have been clobbered
1913 by the user program. Make sure that it still points to a
1914 valid memory location. */
1916 boffset += value_embedded_offset (arg1) + offset;
1918 || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
1920 CORE_ADDR base_addr;
1922 v2 = allocate_value (basetype);
1923 base_addr = value_address (arg1) + boffset;
1924 if (target_read_memory (base_addr,
1925 value_contents_raw (v2),
1926 TYPE_LENGTH (basetype)) != 0)
1927 error (_("virtual baseclass botch"));
1928 VALUE_LVAL (v2) = lval_memory;
1929 set_value_address (v2, base_addr);
1933 v2 = value_copy (arg1);
1934 deprecated_set_value_type (v2, basetype);
1935 set_value_embedded_offset (v2, boffset);
1938 if (found_baseclass)
1940 v = search_struct_field (name, v2, 0,
1941 TYPE_BASECLASS (type, i),
1942 looking_for_baseclass);
1944 else if (found_baseclass)
1945 v = value_primitive_field (arg1, offset, i, type);
1947 v = search_struct_field (name, arg1,
1948 offset + TYPE_BASECLASS_BITPOS (type,
1950 basetype, looking_for_baseclass);
1957 /* Helper function used by value_struct_elt to recurse through
1958 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1959 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1962 If found, return value, else if name matched and args not return
1963 (value) -1, else return NULL. */
1965 static struct value *
1966 search_struct_method (const char *name, struct value **arg1p,
1967 struct value **args, int offset,
1968 int *static_memfuncp, struct type *type)
1972 int name_matched = 0;
1973 char dem_opname[64];
1975 CHECK_TYPEDEF (type);
1976 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1978 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1979 /* FIXME! May need to check for ARM demangling here */
1980 if (strncmp (t_field_name, "__", 2) == 0 ||
1981 strncmp (t_field_name, "op", 2) == 0 ||
1982 strncmp (t_field_name, "type", 4) == 0)
1984 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
1985 t_field_name = dem_opname;
1986 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
1987 t_field_name = dem_opname;
1989 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1991 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1992 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1995 check_stub_method_group (type, i);
1996 if (j > 0 && args == 0)
1997 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
1998 else if (j == 0 && args == 0)
2000 v = value_fn_field (arg1p, f, j, type, offset);
2007 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2008 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2009 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2010 TYPE_FN_FIELD_ARGS (f, j), args))
2012 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2013 return value_virtual_fn_field (arg1p, f, j,
2015 if (TYPE_FN_FIELD_STATIC_P (f, j)
2017 *static_memfuncp = 1;
2018 v = value_fn_field (arg1p, f, j, type, offset);
2027 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2031 if (BASETYPE_VIA_VIRTUAL (type, i))
2033 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2034 const gdb_byte *base_valaddr;
2036 /* The virtual base class pointer might have been
2037 clobbered by the user program. Make sure that it
2038 still points to a valid memory location. */
2040 if (offset < 0 || offset >= TYPE_LENGTH (type))
2042 gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
2043 if (target_read_memory (value_address (*arg1p) + offset,
2044 tmp, TYPE_LENGTH (baseclass)) != 0)
2045 error (_("virtual baseclass botch"));
2049 base_valaddr = value_contents (*arg1p) + offset;
2051 base_offset = baseclass_offset (type, i, base_valaddr,
2052 value_address (*arg1p) + offset);
2053 if (base_offset == -1)
2054 error (_("virtual baseclass botch"));
2058 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2060 v = search_struct_method (name, arg1p, args, base_offset + offset,
2061 static_memfuncp, TYPE_BASECLASS (type, i));
2062 if (v == (struct value *) - 1)
2068 /* FIXME-bothner: Why is this commented out? Why is it here? */
2069 /* *arg1p = arg1_tmp; */
2074 return (struct value *) - 1;
2079 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2080 extract the component named NAME from the ultimate target
2081 structure/union and return it as a value with its appropriate type.
2082 ERR is used in the error message if *ARGP's type is wrong.
2084 C++: ARGS is a list of argument types to aid in the selection of
2085 an appropriate method. Also, handle derived types.
2087 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2088 where the truthvalue of whether the function that was resolved was
2089 a static member function or not is stored.
2091 ERR is an error message to be printed in case the field is not
2095 value_struct_elt (struct value **argp, struct value **args,
2096 const char *name, int *static_memfuncp, const char *err)
2101 *argp = coerce_array (*argp);
2103 t = check_typedef (value_type (*argp));
2105 /* Follow pointers until we get to a non-pointer. */
2107 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2109 *argp = value_ind (*argp);
2110 /* Don't coerce fn pointer to fn and then back again! */
2111 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2112 *argp = coerce_array (*argp);
2113 t = check_typedef (value_type (*argp));
2116 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2117 && TYPE_CODE (t) != TYPE_CODE_UNION)
2118 error (_("Attempt to extract a component of a value that is not a %s."), err);
2120 /* Assume it's not, unless we see that it is. */
2121 if (static_memfuncp)
2122 *static_memfuncp = 0;
2126 /* if there are no arguments ...do this... */
2128 /* Try as a field first, because if we succeed, there is less
2130 v = search_struct_field (name, *argp, 0, t, 0);
2134 /* C++: If it was not found as a data field, then try to
2135 return it as a pointer to a method. */
2136 v = search_struct_method (name, argp, args, 0,
2137 static_memfuncp, t);
2139 if (v == (struct value *) - 1)
2140 error (_("Cannot take address of method %s."), name);
2143 if (TYPE_NFN_FIELDS (t))
2144 error (_("There is no member or method named %s."), name);
2146 error (_("There is no member named %s."), name);
2151 v = search_struct_method (name, argp, args, 0,
2152 static_memfuncp, t);
2154 if (v == (struct value *) - 1)
2156 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
2160 /* See if user tried to invoke data as function. If so, hand it
2161 back. If it's not callable (i.e., a pointer to function),
2162 gdb should give an error. */
2163 v = search_struct_field (name, *argp, 0, t, 0);
2164 /* If we found an ordinary field, then it is not a method call.
2165 So, treat it as if it were a static member function. */
2166 if (v && static_memfuncp)
2167 *static_memfuncp = 1;
2171 error (_("Structure has no component named %s."), name);
2175 /* Search through the methods of an object (and its bases) to find a
2176 specified method. Return the pointer to the fn_field list of
2177 overloaded instances.
2179 Helper function for value_find_oload_list.
2180 ARGP is a pointer to a pointer to a value (the object).
2181 METHOD is a string containing the method name.
2182 OFFSET is the offset within the value.
2183 TYPE is the assumed type of the object.
2184 NUM_FNS is the number of overloaded instances.
2185 BASETYPE is set to the actual type of the subobject where the
2187 BOFFSET is the offset of the base subobject where the method is found.
2190 static struct fn_field *
2191 find_method_list (struct value **argp, const char *method,
2192 int offset, struct type *type, int *num_fns,
2193 struct type **basetype, int *boffset)
2197 CHECK_TYPEDEF (type);
2201 /* First check in object itself. */
2202 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2204 /* pai: FIXME What about operators and type conversions? */
2205 char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2206 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2208 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2209 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2215 /* Resolve any stub methods. */
2216 check_stub_method_group (type, i);
2222 /* Not found in object, check in base subobjects. */
2223 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2226 if (BASETYPE_VIA_VIRTUAL (type, i))
2228 base_offset = value_offset (*argp) + offset;
2229 base_offset = baseclass_offset (type, i,
2230 value_contents (*argp) + base_offset,
2231 value_address (*argp) + base_offset);
2232 if (base_offset == -1)
2233 error (_("virtual baseclass botch"));
2235 else /* Non-virtual base, simply use bit position from debug
2238 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2240 f = find_method_list (argp, method, base_offset + offset,
2241 TYPE_BASECLASS (type, i), num_fns,
2249 /* Return the list of overloaded methods of a specified name.
2251 ARGP is a pointer to a pointer to a value (the object).
2252 METHOD is the method name.
2253 OFFSET is the offset within the value contents.
2254 NUM_FNS is the number of overloaded instances.
2255 BASETYPE is set to the type of the base subobject that defines the
2257 BOFFSET is the offset of the base subobject which defines the method.
2261 value_find_oload_method_list (struct value **argp, const char *method,
2262 int offset, int *num_fns,
2263 struct type **basetype, int *boffset)
2267 t = check_typedef (value_type (*argp));
2269 /* Code snarfed from value_struct_elt. */
2270 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2272 *argp = value_ind (*argp);
2273 /* Don't coerce fn pointer to fn and then back again! */
2274 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2275 *argp = coerce_array (*argp);
2276 t = check_typedef (value_type (*argp));
2279 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2280 && TYPE_CODE (t) != TYPE_CODE_UNION)
2281 error (_("Attempt to extract a component of a value that is not a struct or union"));
2283 return find_method_list (argp, method, 0, t, num_fns,
2287 /* Given an array of argument types (ARGTYPES) (which includes an
2288 entry for "this" in the case of C++ methods), the number of
2289 arguments NARGS, the NAME of a function whether it's a method or
2290 not (METHOD), and the degree of laxness (LAX) in conforming to
2291 overload resolution rules in ANSI C++, find the best function that
2292 matches on the argument types according to the overload resolution
2295 In the case of class methods, the parameter OBJ is an object value
2296 in which to search for overloaded methods.
2298 In the case of non-method functions, the parameter FSYM is a symbol
2299 corresponding to one of the overloaded functions.
2301 Return value is an integer: 0 -> good match, 10 -> debugger applied
2302 non-standard coercions, 100 -> incompatible.
2304 If a method is being searched for, VALP will hold the value.
2305 If a non-method is being searched for, SYMP will hold the symbol
2308 If a method is being searched for, and it is a static method,
2309 then STATICP will point to a non-zero value.
2311 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2312 ADL overload candidates when performing overload resolution for a fully
2315 Note: This function does *not* check the value of
2316 overload_resolution. Caller must check it to see whether overload
2317 resolution is permitted.
2321 find_overload_match (struct type **arg_types, int nargs,
2322 const char *name, int method, int lax,
2323 struct value **objp, struct symbol *fsym,
2324 struct value **valp, struct symbol **symp,
2325 int *staticp, const int no_adl)
2327 struct value *obj = (objp ? *objp : NULL);
2328 /* Index of best overloaded function. */
2330 /* The measure for the current best match. */
2331 struct badness_vector *oload_champ_bv = NULL;
2332 struct value *temp = obj;
2333 /* For methods, the list of overloaded methods. */
2334 struct fn_field *fns_ptr = NULL;
2335 /* For non-methods, the list of overloaded function symbols. */
2336 struct symbol **oload_syms = NULL;
2337 /* Number of overloaded instances being considered. */
2339 struct type *basetype = NULL;
2342 struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2344 const char *obj_type_name = NULL;
2345 const char *func_name = NULL;
2346 enum oload_classification match_quality;
2348 /* Get the list of overloaded methods or functions. */
2353 /* OBJ may be a pointer value rather than the object itself. */
2354 obj = coerce_ref (obj);
2355 while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2356 obj = coerce_ref (value_ind (obj));
2357 obj_type_name = TYPE_NAME (value_type (obj));
2359 /* First check whether this is a data member, e.g. a pointer to
2361 if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2363 *valp = search_struct_field (name, obj, 0,
2364 check_typedef (value_type (obj)), 0);
2372 fns_ptr = value_find_oload_method_list (&temp, name,
2374 &basetype, &boffset);
2375 if (!fns_ptr || !num_fns)
2376 error (_("Couldn't find method %s%s%s"),
2378 (obj_type_name && *obj_type_name) ? "::" : "",
2380 /* If we are dealing with stub method types, they should have
2381 been resolved by find_method_list via
2382 value_find_oload_method_list above. */
2383 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2384 oload_champ = find_oload_champ (arg_types, nargs, method,
2386 oload_syms, &oload_champ_bv);
2390 const char *qualified_name = NULL;
2394 qualified_name = SYMBOL_NATURAL_NAME (fsym);
2396 /* If we have a function with a C++ name, try to extract just
2397 the function part. Do not try this for non-functions (e.g.
2398 function pointers). */
2400 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC)
2404 temp = cp_func_name (qualified_name);
2406 /* If cp_func_name did not remove anything, the name of the
2407 symbol did not include scope or argument types - it was
2408 probably a C-style function. */
2411 make_cleanup (xfree, temp);
2412 if (strcmp (temp, qualified_name) == 0)
2422 qualified_name = name;
2425 /* If there was no C++ name, this must be a C-style function or
2426 not a function at all. Just return the same symbol. Do the
2427 same if cp_func_name fails for some reason. */
2428 if (func_name == NULL)
2434 make_cleanup (xfree, oload_syms);
2435 make_cleanup (xfree, oload_champ_bv);
2437 oload_champ = find_oload_champ_namespace (arg_types, nargs,
2445 /* Did we find a match ? */
2446 if (oload_champ == -1)
2447 error ("No symbol \"%s\" in current context.", name);
2449 /* Check how bad the best match is. */
2451 classify_oload_match (oload_champ_bv, nargs,
2452 oload_method_static (method, fns_ptr,
2455 if (match_quality == INCOMPATIBLE)
2458 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2460 (obj_type_name && *obj_type_name) ? "::" : "",
2463 error (_("Cannot resolve function %s to any overloaded instance"),
2466 else if (match_quality == NON_STANDARD)
2469 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2471 (obj_type_name && *obj_type_name) ? "::" : "",
2474 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2480 if (staticp != NULL)
2481 *staticp = oload_method_static (method, fns_ptr, oload_champ);
2482 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2483 *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ,
2486 *valp = value_fn_field (&temp, fns_ptr, oload_champ,
2491 *symp = oload_syms[oload_champ];
2496 struct type *temp_type = check_typedef (value_type (temp));
2497 struct type *obj_type = check_typedef (value_type (*objp));
2498 if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2499 && (TYPE_CODE (obj_type) == TYPE_CODE_PTR
2500 || TYPE_CODE (obj_type) == TYPE_CODE_REF))
2502 temp = value_addr (temp);
2507 do_cleanups (all_cleanups);
2509 switch (match_quality)
2515 default: /* STANDARD */
2520 /* Find the best overload match, searching for FUNC_NAME in namespaces
2521 contained in QUALIFIED_NAME until it either finds a good match or
2522 runs out of namespaces. It stores the overloaded functions in
2523 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2524 calling function is responsible for freeing *OLOAD_SYMS and
2525 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2529 find_oload_champ_namespace (struct type **arg_types, int nargs,
2530 const char *func_name,
2531 const char *qualified_name,
2532 struct symbol ***oload_syms,
2533 struct badness_vector **oload_champ_bv,
2538 find_oload_champ_namespace_loop (arg_types, nargs,
2541 oload_syms, oload_champ_bv,
2548 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2549 how deep we've looked for namespaces, and the champ is stored in
2550 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2551 if it isn't. Other arguments are the same as in
2552 find_oload_champ_namespace
2554 It is the caller's responsibility to free *OLOAD_SYMS and
2558 find_oload_champ_namespace_loop (struct type **arg_types, int nargs,
2559 const char *func_name,
2560 const char *qualified_name,
2562 struct symbol ***oload_syms,
2563 struct badness_vector **oload_champ_bv,
2567 int next_namespace_len = namespace_len;
2568 int searched_deeper = 0;
2570 struct cleanup *old_cleanups;
2571 int new_oload_champ;
2572 struct symbol **new_oload_syms;
2573 struct badness_vector *new_oload_champ_bv;
2574 char *new_namespace;
2576 if (next_namespace_len != 0)
2578 gdb_assert (qualified_name[next_namespace_len] == ':');
2579 next_namespace_len += 2;
2581 next_namespace_len +=
2582 cp_find_first_component (qualified_name + next_namespace_len);
2584 /* Initialize these to values that can safely be xfree'd. */
2586 *oload_champ_bv = NULL;
2588 /* First, see if we have a deeper namespace we can search in.
2589 If we get a good match there, use it. */
2591 if (qualified_name[next_namespace_len] == ':')
2593 searched_deeper = 1;
2595 if (find_oload_champ_namespace_loop (arg_types, nargs,
2596 func_name, qualified_name,
2598 oload_syms, oload_champ_bv,
2599 oload_champ, no_adl))
2605 /* If we reach here, either we're in the deepest namespace or we
2606 didn't find a good match in a deeper namespace. But, in the
2607 latter case, we still have a bad match in a deeper namespace;
2608 note that we might not find any match at all in the current
2609 namespace. (There's always a match in the deepest namespace,
2610 because this overload mechanism only gets called if there's a
2611 function symbol to start off with.) */
2613 old_cleanups = make_cleanup (xfree, *oload_syms);
2614 old_cleanups = make_cleanup (xfree, *oload_champ_bv);
2615 new_namespace = alloca (namespace_len + 1);
2616 strncpy (new_namespace, qualified_name, namespace_len);
2617 new_namespace[namespace_len] = '\0';
2618 new_oload_syms = make_symbol_overload_list (func_name,
2621 /* If we have reached the deepest level perform argument
2622 determined lookup. */
2623 if (!searched_deeper && !no_adl)
2624 make_symbol_overload_list_adl (arg_types, nargs, func_name);
2626 while (new_oload_syms[num_fns])
2629 new_oload_champ = find_oload_champ (arg_types, nargs, 0, num_fns,
2630 NULL, new_oload_syms,
2631 &new_oload_champ_bv);
2633 /* Case 1: We found a good match. Free earlier matches (if any),
2634 and return it. Case 2: We didn't find a good match, but we're
2635 not the deepest function. Then go with the bad match that the
2636 deeper function found. Case 3: We found a bad match, and we're
2637 the deepest function. Then return what we found, even though
2638 it's a bad match. */
2640 if (new_oload_champ != -1
2641 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2643 *oload_syms = new_oload_syms;
2644 *oload_champ = new_oload_champ;
2645 *oload_champ_bv = new_oload_champ_bv;
2646 do_cleanups (old_cleanups);
2649 else if (searched_deeper)
2651 xfree (new_oload_syms);
2652 xfree (new_oload_champ_bv);
2653 discard_cleanups (old_cleanups);
2658 *oload_syms = new_oload_syms;
2659 *oload_champ = new_oload_champ;
2660 *oload_champ_bv = new_oload_champ_bv;
2661 discard_cleanups (old_cleanups);
2666 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2667 the best match from among the overloaded methods or functions
2668 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2669 The number of methods/functions in the list is given by NUM_FNS.
2670 Return the index of the best match; store an indication of the
2671 quality of the match in OLOAD_CHAMP_BV.
2673 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2676 find_oload_champ (struct type **arg_types, int nargs, int method,
2677 int num_fns, struct fn_field *fns_ptr,
2678 struct symbol **oload_syms,
2679 struct badness_vector **oload_champ_bv)
2682 /* A measure of how good an overloaded instance is. */
2683 struct badness_vector *bv;
2684 /* Index of best overloaded function. */
2685 int oload_champ = -1;
2686 /* Current ambiguity state for overload resolution. */
2687 int oload_ambiguous = 0;
2688 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2690 *oload_champ_bv = NULL;
2692 /* Consider each candidate in turn. */
2693 for (ix = 0; ix < num_fns; ix++)
2696 int static_offset = oload_method_static (method, fns_ptr, ix);
2698 struct type **parm_types;
2702 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2706 /* If it's not a method, this is the proper place. */
2707 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2710 /* Prepare array of parameter types. */
2711 parm_types = (struct type **)
2712 xmalloc (nparms * (sizeof (struct type *)));
2713 for (jj = 0; jj < nparms; jj++)
2714 parm_types[jj] = (method
2715 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2716 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
2719 /* Compare parameter types to supplied argument types. Skip
2720 THIS for static methods. */
2721 bv = rank_function (parm_types, nparms,
2722 arg_types + static_offset,
2723 nargs - static_offset);
2725 if (!*oload_champ_bv)
2727 *oload_champ_bv = bv;
2730 else /* See whether current candidate is better or worse than
2732 switch (compare_badness (bv, *oload_champ_bv))
2734 case 0: /* Top two contenders are equally good. */
2735 oload_ambiguous = 1;
2737 case 1: /* Incomparable top contenders. */
2738 oload_ambiguous = 2;
2740 case 2: /* New champion, record details. */
2741 *oload_champ_bv = bv;
2742 oload_ambiguous = 0;
2753 fprintf_filtered (gdb_stderr,
2754 "Overloaded method instance %s, # of parms %d\n",
2755 fns_ptr[ix].physname, nparms);
2757 fprintf_filtered (gdb_stderr,
2758 "Overloaded function instance %s # of parms %d\n",
2759 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
2761 for (jj = 0; jj < nargs - static_offset; jj++)
2762 fprintf_filtered (gdb_stderr,
2763 "...Badness @ %d : %d\n",
2765 fprintf_filtered (gdb_stderr,
2766 "Overload resolution champion is %d, ambiguous? %d\n",
2767 oload_champ, oload_ambiguous);
2774 /* Return 1 if we're looking at a static method, 0 if we're looking at
2775 a non-static method or a function that isn't a method. */
2778 oload_method_static (int method, struct fn_field *fns_ptr, int index)
2780 if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
2786 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2788 static enum oload_classification
2789 classify_oload_match (struct badness_vector *oload_champ_bv,
2795 for (ix = 1; ix <= nargs - static_offset; ix++)
2797 if (oload_champ_bv->rank[ix] >= 100)
2798 return INCOMPATIBLE; /* Truly mismatched types. */
2799 else if (oload_champ_bv->rank[ix] >= 10)
2800 return NON_STANDARD; /* Non-standard type conversions
2804 return STANDARD; /* Only standard conversions needed. */
2807 /* C++: return 1 is NAME is a legitimate name for the destructor of
2808 type TYPE. If TYPE does not have a destructor, or if NAME is
2809 inappropriate for TYPE, an error is signaled. */
2811 destructor_name_p (const char *name, const struct type *type)
2815 char *dname = type_name_no_tag (type);
2816 char *cp = strchr (dname, '<');
2819 /* Do not compare the template part for template classes. */
2821 len = strlen (dname);
2824 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
2825 error (_("name of destructor must equal name of class"));
2832 /* Given TYPE, a structure/union,
2833 return 1 if the component named NAME from the ultimate target
2834 structure/union is defined, otherwise, return 0. */
2837 check_field (struct type *type, const char *name)
2841 /* The type may be a stub. */
2842 CHECK_TYPEDEF (type);
2844 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2846 char *t_field_name = TYPE_FIELD_NAME (type, i);
2847 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2851 /* C++: If it was not found as a data field, then try to return it
2852 as a pointer to a method. */
2854 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2856 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2860 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2861 if (check_field (TYPE_BASECLASS (type, i), name))
2867 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2868 return the appropriate member (or the address of the member, if
2869 WANT_ADDRESS). This function is used to resolve user expressions
2870 of the form "DOMAIN::NAME". For more details on what happens, see
2871 the comment before value_struct_elt_for_reference. */
2874 value_aggregate_elt (struct type *curtype, char *name,
2875 struct type *expect_type, int want_address,
2878 switch (TYPE_CODE (curtype))
2880 case TYPE_CODE_STRUCT:
2881 case TYPE_CODE_UNION:
2882 return value_struct_elt_for_reference (curtype, 0, curtype,
2884 want_address, noside);
2885 case TYPE_CODE_NAMESPACE:
2886 return value_namespace_elt (curtype, name,
2887 want_address, noside);
2889 internal_error (__FILE__, __LINE__,
2890 _("non-aggregate type in value_aggregate_elt"));
2894 /* Compares the two method/function types T1 and T2 for "equality"
2895 with respect to the the methods' parameters. If the types of the
2896 two parameter lists are the same, returns 1; 0 otherwise. This
2897 comparison may ignore any artificial parameters in T1 if
2898 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
2899 the first artificial parameter in T1, assumed to be a 'this' pointer.
2901 The type T2 is expected to have come from make_params (in eval.c). */
2904 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
2908 if (TYPE_FIELD_ARTIFICIAL (t1, 0))
2911 /* If skipping artificial fields, find the first real field
2913 if (skip_artificial)
2915 while (start < TYPE_NFIELDS (t1)
2916 && TYPE_FIELD_ARTIFICIAL (t1, start))
2920 /* Now compare parameters */
2922 /* Special case: a method taking void. T1 will contain no
2923 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
2924 if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
2925 && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
2928 if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
2931 for (i = 0; i < TYPE_NFIELDS (t2); ++i)
2933 if (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
2934 TYPE_FIELD_TYPE (t2, i))
2945 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2946 return the address of this member as a "pointer to member" type.
2947 If INTYPE is non-null, then it will be the type of the member we
2948 are looking for. This will help us resolve "pointers to member
2949 functions". This function is used to resolve user expressions of
2950 the form "DOMAIN::NAME". */
2952 static struct value *
2953 value_struct_elt_for_reference (struct type *domain, int offset,
2954 struct type *curtype, char *name,
2955 struct type *intype,
2959 struct type *t = curtype;
2961 struct value *v, *result;
2963 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2964 && TYPE_CODE (t) != TYPE_CODE_UNION)
2965 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2967 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2969 char *t_field_name = TYPE_FIELD_NAME (t, i);
2971 if (t_field_name && strcmp (t_field_name, name) == 0)
2973 if (field_is_static (&TYPE_FIELD (t, i)))
2975 v = value_static_field (t, i);
2977 error (_("static field %s has been optimized out"),
2983 if (TYPE_FIELD_PACKED (t, i))
2984 error (_("pointers to bitfield members not allowed"));
2987 return value_from_longest
2988 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
2989 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2990 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2991 return allocate_value (TYPE_FIELD_TYPE (t, i));
2993 error (_("Cannot reference non-static field \"%s\""), name);
2997 /* C++: If it was not found as a data field, then try to return it
2998 as a pointer to a method. */
3000 /* Perform all necessary dereferencing. */
3001 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3002 intype = TYPE_TARGET_TYPE (intype);
3004 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3006 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3007 char dem_opname[64];
3009 if (strncmp (t_field_name, "__", 2) == 0
3010 || strncmp (t_field_name, "op", 2) == 0
3011 || strncmp (t_field_name, "type", 4) == 0)
3013 if (cplus_demangle_opname (t_field_name,
3014 dem_opname, DMGL_ANSI))
3015 t_field_name = dem_opname;
3016 else if (cplus_demangle_opname (t_field_name,
3018 t_field_name = dem_opname;
3020 if (t_field_name && strcmp (t_field_name, name) == 0)
3023 int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3024 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3026 check_stub_method_group (t, i);
3030 for (j = 0; j < len; ++j)
3032 if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3033 || compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 1))
3038 error (_("no member function matches that type instantiation"));
3045 for (ii = 0; ii < TYPE_FN_FIELDLIST_LENGTH (t, i);
3048 /* Skip artificial methods. This is necessary if,
3049 for example, the user wants to "print
3050 subclass::subclass" with only one user-defined
3051 constructor. There is no ambiguity in this
3053 if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3056 /* Desired method is ambiguous if more than one
3057 method is defined. */
3059 error (_("non-unique member `%s' requires type instantiation"), name);
3065 if (TYPE_FN_FIELD_STATIC_P (f, j))
3068 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3074 return value_addr (read_var_value (s, 0));
3076 return read_var_value (s, 0);
3079 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3083 result = allocate_value
3084 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3085 cplus_make_method_ptr (value_type (result),
3086 value_contents_writeable (result),
3087 TYPE_FN_FIELD_VOFFSET (f, j), 1);
3089 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3090 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3092 error (_("Cannot reference virtual member function \"%s\""),
3098 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3103 v = read_var_value (s, 0);
3108 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3109 cplus_make_method_ptr (value_type (result),
3110 value_contents_writeable (result),
3111 value_address (v), 0);
3117 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3122 if (BASETYPE_VIA_VIRTUAL (t, i))
3125 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3126 v = value_struct_elt_for_reference (domain,
3127 offset + base_offset,
3128 TYPE_BASECLASS (t, i),
3130 want_address, noside);
3135 /* As a last chance, pretend that CURTYPE is a namespace, and look
3136 it up that way; this (frequently) works for types nested inside
3139 return value_maybe_namespace_elt (curtype, name,
3140 want_address, noside);
3143 /* C++: Return the member NAME of the namespace given by the type
3146 static struct value *
3147 value_namespace_elt (const struct type *curtype,
3148 char *name, int want_address,
3151 struct value *retval = value_maybe_namespace_elt (curtype, name,
3156 error (_("No symbol \"%s\" in namespace \"%s\"."),
3157 name, TYPE_TAG_NAME (curtype));
3162 /* A helper function used by value_namespace_elt and
3163 value_struct_elt_for_reference. It looks up NAME inside the
3164 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3165 is a class and NAME refers to a type in CURTYPE itself (as opposed
3166 to, say, some base class of CURTYPE). */
3168 static struct value *
3169 value_maybe_namespace_elt (const struct type *curtype,
3170 char *name, int want_address,
3173 const char *namespace_name = TYPE_TAG_NAME (curtype);
3175 struct value *result;
3177 sym = cp_lookup_symbol_namespace (namespace_name, name,
3178 get_selected_block (0),
3183 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3184 && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3185 result = allocate_value (SYMBOL_TYPE (sym));
3187 result = value_of_variable (sym, get_selected_block (0));
3189 if (result && want_address)
3190 result = value_addr (result);
3195 /* Given a pointer value V, find the real (RTTI) type of the object it
3198 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3199 and refer to the values computed for the object pointed to. */
3202 value_rtti_target_type (struct value *v, int *full,
3203 int *top, int *using_enc)
3205 struct value *target;
3207 target = value_ind (v);
3209 return value_rtti_type (target, full, top, using_enc);
3212 /* Given a value pointed to by ARGP, check its real run-time type, and
3213 if that is different from the enclosing type, create a new value
3214 using the real run-time type as the enclosing type (and of the same
3215 type as ARGP) and return it, with the embedded offset adjusted to
3216 be the correct offset to the enclosed object. RTYPE is the type,
3217 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3218 by value_rtti_type(). If these are available, they can be supplied
3219 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3220 NULL if they're not available. */
3223 value_full_object (struct value *argp,
3225 int xfull, int xtop,
3228 struct type *real_type;
3232 struct value *new_val;
3239 using_enc = xusing_enc;
3242 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3244 /* If no RTTI data, or if object is already complete, do nothing. */
3245 if (!real_type || real_type == value_enclosing_type (argp))
3248 /* If we have the full object, but for some reason the enclosing
3249 type is wrong, set it. */
3250 /* pai: FIXME -- sounds iffy */
3253 argp = value_change_enclosing_type (argp, real_type);
3257 /* Check if object is in memory */
3258 if (VALUE_LVAL (argp) != lval_memory)
3260 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
3261 TYPE_NAME (real_type));
3266 /* All other cases -- retrieve the complete object. */
3267 /* Go back by the computed top_offset from the beginning of the
3268 object, adjusting for the embedded offset of argp if that's what
3269 value_rtti_type used for its computation. */
3270 new_val = value_at_lazy (real_type, value_address (argp) - top +
3271 (using_enc ? 0 : value_embedded_offset (argp)));
3272 deprecated_set_value_type (new_val, value_type (argp));
3273 set_value_embedded_offset (new_val, (using_enc
3274 ? top + value_embedded_offset (argp)
3280 /* Return the value of the local variable, if one exists.
3281 Flag COMPLAIN signals an error if the request is made in an
3282 inappropriate context. */
3285 value_of_local (const char *name, int complain)
3287 struct symbol *func, *sym;
3290 struct frame_info *frame;
3293 frame = get_selected_frame (_("no frame selected"));
3296 frame = deprecated_safe_get_selected_frame ();
3301 func = get_frame_function (frame);
3305 error (_("no `%s' in nameless context"), name);
3310 b = SYMBOL_BLOCK_VALUE (func);
3311 if (dict_empty (BLOCK_DICT (b)))
3314 error (_("no args, no `%s'"), name);
3319 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3320 symbol instead of the LOC_ARG one (if both exist). */
3321 sym = lookup_block_symbol (b, name, VAR_DOMAIN);
3325 error (_("current stack frame does not contain a variable named `%s'"),
3331 ret = read_var_value (sym, frame);
3332 if (ret == 0 && complain)
3333 error (_("`%s' argument unreadable"), name);
3337 /* C++/Objective-C: return the value of the class instance variable,
3338 if one exists. Flag COMPLAIN signals an error if the request is
3339 made in an inappropriate context. */
3342 value_of_this (int complain)
3344 if (!current_language->la_name_of_this)
3346 return value_of_local (current_language->la_name_of_this, complain);
3349 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3350 elements long, starting at LOWBOUND. The result has the same lower
3351 bound as the original ARRAY. */
3354 value_slice (struct value *array, int lowbound, int length)
3356 struct type *slice_range_type, *slice_type, *range_type;
3357 LONGEST lowerbound, upperbound;
3358 struct value *slice;
3359 struct type *array_type;
3361 array_type = check_typedef (value_type (array));
3362 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3363 && TYPE_CODE (array_type) != TYPE_CODE_STRING
3364 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3365 error (_("cannot take slice of non-array"));
3367 range_type = TYPE_INDEX_TYPE (array_type);
3368 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3369 error (_("slice from bad array or bitstring"));
3371 if (lowbound < lowerbound || length < 0
3372 || lowbound + length - 1 > upperbound)
3373 error (_("slice out of range"));
3375 /* FIXME-type-allocation: need a way to free this type when we are
3377 slice_range_type = create_range_type ((struct type *) NULL,
3378 TYPE_TARGET_TYPE (range_type),
3380 lowbound + length - 1);
3381 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3385 slice_type = create_set_type ((struct type *) NULL,
3387 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3388 slice = value_zero (slice_type, not_lval);
3390 for (i = 0; i < length; i++)
3392 int element = value_bit_index (array_type,
3393 value_contents (array),
3396 error (_("internal error accessing bitstring"));
3397 else if (element > 0)
3399 int j = i % TARGET_CHAR_BIT;
3400 if (gdbarch_bits_big_endian (get_type_arch (array_type)))
3401 j = TARGET_CHAR_BIT - 1 - j;
3402 value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3405 /* We should set the address, bitssize, and bitspos, so the
3406 slice can be used on the LHS, but that may require extensions
3407 to value_assign. For now, just leave as a non_lval.
3412 struct type *element_type = TYPE_TARGET_TYPE (array_type);
3414 (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3416 slice_type = create_array_type ((struct type *) NULL,
3419 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3421 if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3422 slice = allocate_value_lazy (slice_type);
3425 slice = allocate_value (slice_type);
3426 memcpy (value_contents_writeable (slice),
3427 value_contents (array) + offset,
3428 TYPE_LENGTH (slice_type));
3431 set_value_component_location (slice, array);
3432 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3433 set_value_offset (slice, value_offset (array) + offset);
3438 /* Create a value for a FORTRAN complex number. Currently most of the
3439 time values are coerced to COMPLEX*16 (i.e. a complex number
3440 composed of 2 doubles. This really should be a smarter routine
3441 that figures out precision inteligently as opposed to assuming
3442 doubles. FIXME: fmb */
3445 value_literal_complex (struct value *arg1,
3450 struct type *real_type = TYPE_TARGET_TYPE (type);
3452 val = allocate_value (type);
3453 arg1 = value_cast (real_type, arg1);
3454 arg2 = value_cast (real_type, arg2);
3456 memcpy (value_contents_raw (val),
3457 value_contents (arg1), TYPE_LENGTH (real_type));
3458 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3459 value_contents (arg2), TYPE_LENGTH (real_type));
3463 /* Cast a value into the appropriate complex data type. */
3465 static struct value *
3466 cast_into_complex (struct type *type, struct value *val)
3468 struct type *real_type = TYPE_TARGET_TYPE (type);
3470 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3472 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3473 struct value *re_val = allocate_value (val_real_type);
3474 struct value *im_val = allocate_value (val_real_type);
3476 memcpy (value_contents_raw (re_val),
3477 value_contents (val), TYPE_LENGTH (val_real_type));
3478 memcpy (value_contents_raw (im_val),
3479 value_contents (val) + TYPE_LENGTH (val_real_type),
3480 TYPE_LENGTH (val_real_type));
3482 return value_literal_complex (re_val, im_val, type);
3484 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3485 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3486 return value_literal_complex (val,
3487 value_zero (real_type, not_lval),
3490 error (_("cannot cast non-number to complex"));
3494 _initialize_valops (void)
3496 add_setshow_boolean_cmd ("overload-resolution", class_support,
3497 &overload_resolution, _("\
3498 Set overload resolution in evaluating C++ functions."), _("\
3499 Show overload resolution in evaluating C++ functions."),
3501 show_overload_resolution,
3502 &setlist, &showlist);
3503 overload_resolution = 1;