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 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"
42 #include "gdb_string.h"
43 #include "gdb_assert.h"
44 #include "cp-support.h"
47 extern int overload_debug;
48 /* Local functions. */
50 static int typecmp (int staticp, int varargs, int nargs,
51 struct field t1[], struct value *t2[]);
53 static struct value *search_struct_field (char *, struct value *,
54 int, struct type *, int);
56 static struct value *search_struct_method (char *, struct value **,
58 int, int *, struct type *);
60 static int find_oload_champ_namespace (struct type **, int,
61 const char *, const char *,
63 struct badness_vector **);
66 int find_oload_champ_namespace_loop (struct type **, int,
67 const char *, const char *,
68 int, struct symbol ***,
69 struct badness_vector **, int *);
71 static int find_oload_champ (struct type **, int, int, int,
72 struct fn_field *, struct symbol **,
73 struct badness_vector **);
75 static int oload_method_static (int, struct fn_field *, int);
77 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
80 oload_classification classify_oload_match (struct badness_vector *,
83 static int check_field_in (struct type *, const char *);
85 static struct value *value_struct_elt_for_reference (struct type *,
91 static struct value *value_namespace_elt (const struct type *,
92 char *, int , enum noside);
94 static struct value *value_maybe_namespace_elt (const struct type *,
98 static CORE_ADDR allocate_space_in_inferior (int);
100 static struct value *cast_into_complex (struct type *, struct value *);
102 static struct fn_field *find_method_list (struct value **, char *,
103 int, struct type *, int *,
104 struct type **, int *);
106 void _initialize_valops (void);
109 /* Flag for whether we want to abandon failed expression evals by
112 static int auto_abandon = 0;
115 int overload_resolution = 0;
117 show_overload_resolution (struct ui_file *file, int from_tty,
118 struct cmd_list_element *c,
121 fprintf_filtered (file, _("\
122 Overload resolution in evaluating C++ functions is %s.\n"),
126 /* Find the address of function name NAME in the inferior. */
129 find_function_in_inferior (const char *name)
132 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL);
135 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
137 error (_("\"%s\" exists in this program but is not a function."),
140 return value_of_variable (sym, NULL);
144 struct minimal_symbol *msymbol =
145 lookup_minimal_symbol (name, NULL, NULL);
150 type = lookup_pointer_type (builtin_type_char);
151 type = lookup_function_type (type);
152 type = lookup_pointer_type (type);
153 maddr = SYMBOL_VALUE_ADDRESS (msymbol);
154 return value_from_pointer (type, maddr);
158 if (!target_has_execution)
159 error (_("evaluation of this expression requires the target program to be active"));
161 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
166 /* Allocate NBYTES of space in the inferior using the inferior's
167 malloc and return a value that is a pointer to the allocated
171 value_allocate_space_in_inferior (int len)
173 struct value *blocklen;
175 find_function_in_inferior (gdbarch_name_of_malloc (current_gdbarch));
177 blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
178 val = call_function_by_hand (val, 1, &blocklen);
179 if (value_logical_not (val))
181 if (!target_has_execution)
182 error (_("No memory available to program now: you need to start the target first"));
184 error (_("No memory available to program: call to malloc failed"));
190 allocate_space_in_inferior (int len)
192 return value_as_long (value_allocate_space_in_inferior (len));
195 /* Cast one pointer or reference type to another. Both TYPE and
196 the type of ARG2 should be pointer types, or else both should be
197 reference types. Returns the new pointer or reference. */
200 value_cast_pointers (struct type *type, struct value *arg2)
202 struct type *type2 = check_typedef (value_type (arg2));
203 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
204 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
206 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
207 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
208 && !value_logical_not (arg2))
212 /* Look in the type of the source to see if it contains the
213 type of the target as a superclass. If so, we'll need to
214 offset the pointer rather than just change its type. */
215 if (TYPE_NAME (t1) != NULL)
219 if (TYPE_CODE (type2) == TYPE_CODE_REF)
220 v2 = coerce_ref (arg2);
222 v2 = value_ind (arg2);
223 v = search_struct_field (type_name_no_tag (t1),
228 deprecated_set_value_type (v, type);
233 /* Look in the type of the target to see if it contains the
234 type of the source as a superclass. If so, we'll need to
235 offset the pointer rather than just change its type.
236 FIXME: This fails silently with virtual inheritance. */
237 if (TYPE_NAME (t2) != NULL)
239 v = search_struct_field (type_name_no_tag (t2),
240 value_zero (t1, not_lval), 0, t1, 1);
243 CORE_ADDR addr2 = value_as_address (arg2);
244 addr2 -= (VALUE_ADDRESS (v)
246 + value_embedded_offset (v));
247 return value_from_pointer (type, addr2);
252 /* No superclass found, just change the pointer type. */
253 arg2 = value_copy (arg2);
254 deprecated_set_value_type (arg2, type);
255 arg2 = value_change_enclosing_type (arg2, type);
256 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
260 /* Cast value ARG2 to type TYPE and return as a value.
261 More general than a C cast: accepts any two types of the same length,
262 and if ARG2 is an lvalue it can be cast into anything at all. */
263 /* In C++, casts may change pointer or object representations. */
266 value_cast (struct type *type, struct value *arg2)
268 enum type_code code1;
269 enum type_code code2;
273 int convert_to_boolean = 0;
275 if (value_type (arg2) == type)
278 CHECK_TYPEDEF (type);
279 code1 = TYPE_CODE (type);
280 arg2 = coerce_ref (arg2);
281 type2 = check_typedef (value_type (arg2));
283 /* You can't cast to a reference type. See value_cast_pointers
285 gdb_assert (code1 != TYPE_CODE_REF);
287 /* A cast to an undetermined-length array_type, such as
288 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
289 where N is sizeof(OBJECT)/sizeof(TYPE). */
290 if (code1 == TYPE_CODE_ARRAY)
292 struct type *element_type = TYPE_TARGET_TYPE (type);
293 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
294 if (element_length > 0
295 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
297 struct type *range_type = TYPE_INDEX_TYPE (type);
298 int val_length = TYPE_LENGTH (type2);
299 LONGEST low_bound, high_bound, new_length;
300 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
301 low_bound = 0, high_bound = 0;
302 new_length = val_length / element_length;
303 if (val_length % element_length != 0)
304 warning (_("array element type size does not divide object size in cast"));
305 /* FIXME-type-allocation: need a way to free this type when
306 we are done with it. */
307 range_type = create_range_type ((struct type *) NULL,
308 TYPE_TARGET_TYPE (range_type),
310 new_length + low_bound - 1);
311 deprecated_set_value_type (arg2,
312 create_array_type ((struct type *) NULL,
319 if (current_language->c_style_arrays
320 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
321 arg2 = value_coerce_array (arg2);
323 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
324 arg2 = value_coerce_function (arg2);
326 type2 = check_typedef (value_type (arg2));
327 code2 = TYPE_CODE (type2);
329 if (code1 == TYPE_CODE_COMPLEX)
330 return cast_into_complex (type, arg2);
331 if (code1 == TYPE_CODE_BOOL)
333 code1 = TYPE_CODE_INT;
334 convert_to_boolean = 1;
336 if (code1 == TYPE_CODE_CHAR)
337 code1 = TYPE_CODE_INT;
338 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
339 code2 = TYPE_CODE_INT;
341 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
342 || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
343 || code2 == TYPE_CODE_RANGE);
345 if (code1 == TYPE_CODE_STRUCT
346 && code2 == TYPE_CODE_STRUCT
347 && TYPE_NAME (type) != 0)
349 /* Look in the type of the source to see if it contains the
350 type of the target as a superclass. If so, we'll need to
351 offset the object in addition to changing its type. */
352 struct value *v = search_struct_field (type_name_no_tag (type),
356 deprecated_set_value_type (v, type);
360 if (code1 == TYPE_CODE_FLT && scalar)
361 return value_from_double (type, value_as_double (arg2));
362 else if (code1 == TYPE_CODE_DECFLOAT && scalar)
364 int dec_len = TYPE_LENGTH (type);
367 if (code2 == TYPE_CODE_FLT)
368 decimal_from_floating (arg2, dec, dec_len);
369 else if (code2 == TYPE_CODE_DECFLOAT)
370 decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
373 /* The only option left is an integral type. */
374 decimal_from_integral (arg2, dec, dec_len);
376 return value_from_decfloat (type, dec);
378 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
379 || code1 == TYPE_CODE_RANGE)
380 && (scalar || code2 == TYPE_CODE_PTR
381 || code2 == TYPE_CODE_MEMBERPTR))
385 /* When we cast pointers to integers, we mustn't use
386 gdbarch_pointer_to_address to find the address the pointer
387 represents, as value_as_long would. GDB should evaluate
388 expressions just as the compiler would --- and the compiler
389 sees a cast as a simple reinterpretation of the pointer's
391 if (code2 == TYPE_CODE_PTR)
392 longest = extract_unsigned_integer (value_contents (arg2),
393 TYPE_LENGTH (type2));
395 longest = value_as_long (arg2);
396 return value_from_longest (type, convert_to_boolean ?
397 (LONGEST) (longest ? 1 : 0) : longest);
399 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
400 || code2 == TYPE_CODE_ENUM
401 || code2 == TYPE_CODE_RANGE))
403 /* TYPE_LENGTH (type) is the length of a pointer, but we really
404 want the length of an address! -- we are really dealing with
405 addresses (i.e., gdb representations) not pointers (i.e.,
406 target representations) here.
408 This allows things like "print *(int *)0x01000234" to work
409 without printing a misleading message -- which would
410 otherwise occur when dealing with a target having two byte
411 pointers and four byte addresses. */
413 int addr_bit = gdbarch_addr_bit (current_gdbarch);
415 LONGEST longest = value_as_long (arg2);
416 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
418 if (longest >= ((LONGEST) 1 << addr_bit)
419 || longest <= -((LONGEST) 1 << addr_bit))
420 warning (_("value truncated"));
422 return value_from_longest (type, longest);
424 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
425 && value_as_long (arg2) == 0)
427 struct value *result = allocate_value (type);
428 cplus_make_method_ptr (value_contents_writeable (result), 0, 0);
431 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
432 && value_as_long (arg2) == 0)
434 /* The Itanium C++ ABI represents NULL pointers to members as
435 minus one, instead of biasing the normal case. */
436 return value_from_longest (type, -1);
438 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
440 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
441 return value_cast_pointers (type, arg2);
443 arg2 = value_copy (arg2);
444 deprecated_set_value_type (arg2, type);
445 arg2 = value_change_enclosing_type (arg2, type);
446 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
449 else if (VALUE_LVAL (arg2) == lval_memory)
450 return value_at_lazy (type,
451 VALUE_ADDRESS (arg2) + value_offset (arg2));
452 else if (code1 == TYPE_CODE_VOID)
454 return value_zero (builtin_type_void, not_lval);
458 error (_("Invalid cast."));
463 /* Create a value of type TYPE that is zero, and return it. */
466 value_zero (struct type *type, enum lval_type lv)
468 struct value *val = allocate_value (type);
469 VALUE_LVAL (val) = lv;
474 /* Return a value with type TYPE located at ADDR.
476 Call value_at only if the data needs to be fetched immediately;
477 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
478 value_at_lazy instead. value_at_lazy simply records the address of
479 the data and sets the lazy-evaluation-required flag. The lazy flag
480 is tested in the value_contents macro, which is used if and when
481 the contents are actually required.
483 Note: value_at does *NOT* handle embedded offsets; perform such
484 adjustments before or after calling it. */
487 value_at (struct type *type, CORE_ADDR addr)
491 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
492 error (_("Attempt to dereference a generic pointer."));
494 val = allocate_value (type);
496 read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
498 VALUE_LVAL (val) = lval_memory;
499 VALUE_ADDRESS (val) = addr;
504 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
507 value_at_lazy (struct type *type, CORE_ADDR addr)
511 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
512 error (_("Attempt to dereference a generic pointer."));
514 val = allocate_value (type);
516 VALUE_LVAL (val) = lval_memory;
517 VALUE_ADDRESS (val) = addr;
518 set_value_lazy (val, 1);
523 /* Called only from the value_contents and value_contents_all()
524 macros, if the current data for a variable needs to be loaded into
525 value_contents(VAL). Fetches the data from the user's process, and
526 clears the lazy flag to indicate that the data in the buffer is
529 If the value is zero-length, we avoid calling read_memory, which
530 would abort. We mark the value as fetched anyway -- all 0 bytes of
533 This function returns a value because it is used in the
534 value_contents macro as part of an expression, where a void would
535 not work. The value is ignored. */
538 value_fetch_lazy (struct value *val)
540 CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
541 int length = TYPE_LENGTH (value_enclosing_type (val));
543 struct type *type = value_type (val);
545 read_memory (addr, value_contents_all_raw (val), length);
547 set_value_lazy (val, 0);
552 /* Store the contents of FROMVAL into the location of TOVAL.
553 Return a new value with the location of TOVAL and contents of FROMVAL. */
556 value_assign (struct value *toval, struct value *fromval)
560 struct frame_id old_frame;
562 if (!deprecated_value_modifiable (toval))
563 error (_("Left operand of assignment is not a modifiable lvalue."));
565 toval = coerce_ref (toval);
567 type = value_type (toval);
568 if (VALUE_LVAL (toval) != lval_internalvar)
569 fromval = value_cast (type, fromval);
571 fromval = coerce_array (fromval);
572 CHECK_TYPEDEF (type);
574 /* Since modifying a register can trash the frame chain, and
575 modifying memory can trash the frame cache, we save the old frame
576 and then restore the new frame afterwards. */
577 old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
579 switch (VALUE_LVAL (toval))
581 case lval_internalvar:
582 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
583 val = value_copy (VALUE_INTERNALVAR (toval)->value);
584 val = value_change_enclosing_type (val,
585 value_enclosing_type (fromval));
586 set_value_embedded_offset (val, value_embedded_offset (fromval));
587 set_value_pointed_to_offset (val,
588 value_pointed_to_offset (fromval));
591 case lval_internalvar_component:
592 set_internalvar_component (VALUE_INTERNALVAR (toval),
593 value_offset (toval),
594 value_bitpos (toval),
595 value_bitsize (toval),
601 const gdb_byte *dest_buffer;
602 CORE_ADDR changed_addr;
604 gdb_byte buffer[sizeof (LONGEST)];
606 if (value_bitsize (toval))
608 /* We assume that the argument to read_memory is in units
609 of host chars. FIXME: Is that correct? */
610 changed_len = (value_bitpos (toval)
611 + value_bitsize (toval)
615 if (changed_len > (int) sizeof (LONGEST))
616 error (_("Can't handle bitfields which don't fit in a %d bit word."),
617 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
619 read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
620 buffer, changed_len);
621 modify_field (buffer, value_as_long (fromval),
622 value_bitpos (toval), value_bitsize (toval));
623 changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
624 dest_buffer = buffer;
628 changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
629 changed_len = TYPE_LENGTH (type);
630 dest_buffer = value_contents (fromval);
633 write_memory (changed_addr, dest_buffer, changed_len);
634 if (deprecated_memory_changed_hook)
635 deprecated_memory_changed_hook (changed_addr, changed_len);
641 struct frame_info *frame;
644 /* Figure out which frame this is in currently. */
645 frame = frame_find_by_id (VALUE_FRAME_ID (toval));
646 value_reg = VALUE_REGNUM (toval);
649 error (_("Value being assigned to is no longer active."));
651 if (gdbarch_convert_register_p
652 (current_gdbarch, VALUE_REGNUM (toval), type))
654 /* If TOVAL is a special machine register requiring
655 conversion of program values to a special raw
657 gdbarch_value_to_register (current_gdbarch, frame,
658 VALUE_REGNUM (toval), type,
659 value_contents (fromval));
663 if (value_bitsize (toval))
666 gdb_byte buffer[sizeof (LONGEST)];
668 changed_len = (value_bitpos (toval)
669 + value_bitsize (toval)
673 if (changed_len > (int) sizeof (LONGEST))
674 error (_("Can't handle bitfields which don't fit in a %d bit word."),
675 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
677 get_frame_register_bytes (frame, value_reg,
678 value_offset (toval),
679 changed_len, buffer);
681 modify_field (buffer, value_as_long (fromval),
682 value_bitpos (toval),
683 value_bitsize (toval));
685 put_frame_register_bytes (frame, value_reg,
686 value_offset (toval),
687 changed_len, buffer);
691 put_frame_register_bytes (frame, value_reg,
692 value_offset (toval),
694 value_contents (fromval));
698 if (deprecated_register_changed_hook)
699 deprecated_register_changed_hook (-1);
700 observer_notify_target_changed (¤t_target);
705 error (_("Left operand of assignment is not an lvalue."));
708 /* Assigning to the stack pointer, frame pointer, and other
709 (architecture and calling convention specific) registers may
710 cause the frame cache to be out of date. Assigning to memory
711 also can. We just do this on all assignments to registers or
712 memory, for simplicity's sake; I doubt the slowdown matters. */
713 switch (VALUE_LVAL (toval))
718 reinit_frame_cache ();
720 /* Having destroyed the frame cache, restore the selected
723 /* FIXME: cagney/2002-11-02: There has to be a better way of
724 doing this. Instead of constantly saving/restoring the
725 frame. Why not create a get_selected_frame() function that,
726 having saved the selected frame's ID can automatically
727 re-find the previously selected frame automatically. */
730 struct frame_info *fi = frame_find_by_id (old_frame);
740 /* If the field does not entirely fill a LONGEST, then zero the sign
741 bits. If the field is signed, and is negative, then sign
743 if ((value_bitsize (toval) > 0)
744 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
746 LONGEST fieldval = value_as_long (fromval);
747 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
750 if (!TYPE_UNSIGNED (type)
751 && (fieldval & (valmask ^ (valmask >> 1))))
752 fieldval |= ~valmask;
754 fromval = value_from_longest (type, fieldval);
757 val = value_copy (toval);
758 memcpy (value_contents_raw (val), value_contents (fromval),
760 deprecated_set_value_type (val, type);
761 val = value_change_enclosing_type (val,
762 value_enclosing_type (fromval));
763 set_value_embedded_offset (val, value_embedded_offset (fromval));
764 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
769 /* Extend a value VAL to COUNT repetitions of its type. */
772 value_repeat (struct value *arg1, int count)
776 if (VALUE_LVAL (arg1) != lval_memory)
777 error (_("Only values in memory can be extended with '@'."));
779 error (_("Invalid number %d of repetitions."), count);
781 val = allocate_repeat_value (value_enclosing_type (arg1), count);
783 read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1),
784 value_contents_all_raw (val),
785 TYPE_LENGTH (value_enclosing_type (val)));
786 VALUE_LVAL (val) = lval_memory;
787 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
793 value_of_variable (struct symbol *var, struct block *b)
796 struct frame_info *frame = NULL;
799 frame = NULL; /* Use selected frame. */
800 else if (symbol_read_needs_frame (var))
802 frame = block_innermost_frame (b);
805 if (BLOCK_FUNCTION (b)
806 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
807 error (_("No frame is currently executing in block %s."),
808 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
810 error (_("No frame is currently executing in specified block"));
814 val = read_var_value (var, frame);
816 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
821 /* Given a value which is an array, return a value which is a pointer
822 to its first element, regardless of whether or not the array has a
825 FIXME: A previous comment here indicated that this routine should
826 be substracting the array's lower bound. It's not clear to me that
827 this is correct. Given an array subscripting operation, it would
828 certainly work to do the adjustment here, essentially computing:
830 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
832 However I believe a more appropriate and logical place to account
833 for the lower bound is to do so in value_subscript, essentially
836 (&array[0] + ((index - lowerbound) * sizeof array[0]))
838 As further evidence consider what would happen with operations
839 other than array subscripting, where the caller would get back a
840 value that had an address somewhere before the actual first element
841 of the array, and the information about the lower bound would be
842 lost because of the coercion to pointer type.
846 value_coerce_array (struct value *arg1)
848 struct type *type = check_typedef (value_type (arg1));
850 if (VALUE_LVAL (arg1) != lval_memory)
851 error (_("Attempt to take address of value not located in memory."));
853 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
854 (VALUE_ADDRESS (arg1) + value_offset (arg1)));
857 /* Given a value which is a function, return a value which is a pointer
861 value_coerce_function (struct value *arg1)
863 struct value *retval;
865 if (VALUE_LVAL (arg1) != lval_memory)
866 error (_("Attempt to take address of value not located in memory."));
868 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
869 (VALUE_ADDRESS (arg1) + value_offset (arg1)));
873 /* Return a pointer value for the object for which ARG1 is the
877 value_addr (struct value *arg1)
881 struct type *type = check_typedef (value_type (arg1));
882 if (TYPE_CODE (type) == TYPE_CODE_REF)
884 /* Copy the value, but change the type from (T&) to (T*). We
885 keep the same location information, which is efficient, and
886 allows &(&X) to get the location containing the reference. */
887 arg2 = value_copy (arg1);
888 deprecated_set_value_type (arg2,
889 lookup_pointer_type (TYPE_TARGET_TYPE (type)));
892 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
893 return value_coerce_function (arg1);
895 if (VALUE_LVAL (arg1) != lval_memory)
896 error (_("Attempt to take address of value not located in memory."));
898 /* Get target memory address */
899 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
900 (VALUE_ADDRESS (arg1)
901 + value_offset (arg1)
902 + value_embedded_offset (arg1)));
904 /* This may be a pointer to a base subobject; so remember the
905 full derived object's type ... */
906 arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
907 /* ... and also the relative position of the subobject in the full
909 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
913 /* Return a reference value for the object for which ARG1 is the
917 value_ref (struct value *arg1)
921 struct type *type = check_typedef (value_type (arg1));
922 if (TYPE_CODE (type) == TYPE_CODE_REF)
925 arg2 = value_addr (arg1);
926 deprecated_set_value_type (arg2, lookup_reference_type (type));
930 /* Given a value of a pointer type, apply the C unary * operator to
934 value_ind (struct value *arg1)
936 struct type *base_type;
939 arg1 = coerce_array (arg1);
941 base_type = check_typedef (value_type (arg1));
943 /* Allow * on an integer so we can cast it to whatever we want.
944 This returns an int, which seems like the most C-like thing to
945 do. "long long" variables are rare enough that
946 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
947 if (TYPE_CODE (base_type) == TYPE_CODE_INT)
948 return value_at_lazy (builtin_type_int,
949 (CORE_ADDR) value_as_address (arg1));
950 else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
952 struct type *enc_type;
953 /* We may be pointing to something embedded in a larger object.
954 Get the real type of the enclosing object. */
955 enc_type = check_typedef (value_enclosing_type (arg1));
956 enc_type = TYPE_TARGET_TYPE (enc_type);
958 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
959 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
960 /* For functions, go through find_function_addr, which knows
961 how to handle function descriptors. */
962 arg2 = value_at_lazy (enc_type,
963 find_function_addr (arg1, NULL));
965 /* Retrieve the enclosing object pointed to */
966 arg2 = value_at_lazy (enc_type,
967 (value_as_address (arg1)
968 - value_pointed_to_offset (arg1)));
970 /* Re-adjust type. */
971 deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
972 /* Add embedding info. */
973 arg2 = value_change_enclosing_type (arg2, enc_type);
974 set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
976 /* We may be pointing to an object of some derived type. */
977 arg2 = value_full_object (arg2, NULL, 0, 0, 0);
981 error (_("Attempt to take contents of a non-pointer value."));
982 return 0; /* For lint -- never reached. */
985 /* Create a value for an array by allocating space in the inferior,
986 copying the data into that space, and then setting up an array
989 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
990 is populated from the values passed in ELEMVEC.
992 The element type of the array is inherited from the type of the
993 first element, and all elements must have the same size (though we
994 don't currently enforce any restriction on their types). */
997 value_array (int lowbound, int highbound, struct value **elemvec)
1001 unsigned int typelength;
1003 struct type *rangetype;
1004 struct type *arraytype;
1007 /* Validate that the bounds are reasonable and that each of the
1008 elements have the same size. */
1010 nelem = highbound - lowbound + 1;
1013 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1015 typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1016 for (idx = 1; idx < nelem; idx++)
1018 if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1020 error (_("array elements must all be the same size"));
1024 rangetype = create_range_type ((struct type *) NULL,
1026 lowbound, highbound);
1027 arraytype = create_array_type ((struct type *) NULL,
1028 value_enclosing_type (elemvec[0]),
1031 if (!current_language->c_style_arrays)
1033 val = allocate_value (arraytype);
1034 for (idx = 0; idx < nelem; idx++)
1036 memcpy (value_contents_all_raw (val) + (idx * typelength),
1037 value_contents_all (elemvec[idx]),
1043 /* Allocate space to store the array in the inferior, and then
1044 initialize it by copying in each element. FIXME: Is it worth it
1045 to create a local buffer in which to collect each value and then
1046 write all the bytes in one operation? */
1048 addr = allocate_space_in_inferior (nelem * typelength);
1049 for (idx = 0; idx < nelem; idx++)
1051 write_memory (addr + (idx * typelength),
1052 value_contents_all (elemvec[idx]),
1056 /* Create the array type and set up an array value to be evaluated
1059 val = value_at_lazy (arraytype, addr);
1063 /* Create a value for a string constant by allocating space in the
1064 inferior, copying the data into that space, and returning the
1065 address with type TYPE_CODE_STRING. PTR points to the string
1066 constant data; LEN is number of characters.
1068 Note that string types are like array of char types with a lower
1069 bound of zero and an upper bound of LEN - 1. Also note that the
1070 string may contain embedded null bytes. */
1073 value_string (char *ptr, int len)
1076 int lowbound = current_language->string_lower_bound;
1077 struct type *rangetype = create_range_type ((struct type *) NULL,
1080 len + lowbound - 1);
1081 struct type *stringtype
1082 = create_string_type ((struct type *) NULL, rangetype);
1085 if (current_language->c_style_arrays == 0)
1087 val = allocate_value (stringtype);
1088 memcpy (value_contents_raw (val), ptr, len);
1093 /* Allocate space to store the string in the inferior, and then copy
1094 LEN bytes from PTR in gdb to that address in the inferior. */
1096 addr = allocate_space_in_inferior (len);
1097 write_memory (addr, (gdb_byte *) ptr, len);
1099 val = value_at_lazy (stringtype, addr);
1104 value_bitstring (char *ptr, int len)
1107 struct type *domain_type = create_range_type (NULL,
1110 struct type *type = create_set_type ((struct type *) NULL,
1112 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1113 val = allocate_value (type);
1114 memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
1118 /* See if we can pass arguments in T2 to a function which takes
1119 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1120 a NULL-terminated vector. If some arguments need coercion of some
1121 sort, then the coerced values are written into T2. Return value is
1122 0 if the arguments could be matched, or the position at which they
1125 STATICP is nonzero if the T1 argument list came from a static
1126 member function. T2 will still include the ``this'' pointer, but
1129 For non-static member functions, we ignore the first argument,
1130 which is the type of the instance variable. This is because we
1131 want to handle calls with objects from derived classes. This is
1132 not entirely correct: we should actually check to make sure that a
1133 requested operation is type secure, shouldn't we? FIXME. */
1136 typecmp (int staticp, int varargs, int nargs,
1137 struct field t1[], struct value *t2[])
1142 internal_error (__FILE__, __LINE__,
1143 _("typecmp: no argument list"));
1145 /* Skip ``this'' argument if applicable. T2 will always include
1151 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1154 struct type *tt1, *tt2;
1159 tt1 = check_typedef (t1[i].type);
1160 tt2 = check_typedef (value_type (t2[i]));
1162 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1163 /* We should be doing hairy argument matching, as below. */
1164 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1166 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1167 t2[i] = value_coerce_array (t2[i]);
1169 t2[i] = value_ref (t2[i]);
1173 /* djb - 20000715 - Until the new type structure is in the
1174 place, and we can attempt things like implicit conversions,
1175 we need to do this so you can take something like a map<const
1176 char *>, and properly access map["hello"], because the
1177 argument to [] will be a reference to a pointer to a char,
1178 and the argument will be a pointer to a char. */
1179 while (TYPE_CODE(tt1) == TYPE_CODE_REF
1180 || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1182 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1184 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1185 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1186 || TYPE_CODE(tt2) == TYPE_CODE_REF)
1188 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1190 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1192 /* Array to pointer is a `trivial conversion' according to the
1195 /* We should be doing much hairier argument matching (see
1196 section 13.2 of the ARM), but as a quick kludge, just check
1197 for the same type code. */
1198 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1201 if (varargs || t2[i] == NULL)
1206 /* Helper function used by value_struct_elt to recurse through
1207 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1208 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1209 TYPE. If found, return value, else return NULL.
1211 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1212 fields, look for a baseclass named NAME. */
1214 static struct value *
1215 search_struct_field (char *name, struct value *arg1, int offset,
1216 struct type *type, int looking_for_baseclass)
1219 int nbases = TYPE_N_BASECLASSES (type);
1221 CHECK_TYPEDEF (type);
1223 if (!looking_for_baseclass)
1224 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1226 char *t_field_name = TYPE_FIELD_NAME (type, i);
1228 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1231 if (TYPE_FIELD_STATIC (type, i))
1233 v = value_static_field (type, i);
1235 error (_("field %s is nonexistent or has been optimised out"),
1240 v = value_primitive_field (arg1, offset, i, type);
1242 error (_("there is no field named %s"), name);
1248 && (t_field_name[0] == '\0'
1249 || (TYPE_CODE (type) == TYPE_CODE_UNION
1250 && (strcmp_iw (t_field_name, "else") == 0))))
1252 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1253 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1254 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1256 /* Look for a match through the fields of an anonymous
1257 union, or anonymous struct. C++ provides anonymous
1260 In the GNU Chill (now deleted from GDB)
1261 implementation of variant record types, each
1262 <alternative field> has an (anonymous) union type,
1263 each member of the union represents a <variant
1264 alternative>. Each <variant alternative> is
1265 represented as a struct, with a member for each
1269 int new_offset = offset;
1271 /* This is pretty gross. In G++, the offset in an
1272 anonymous union is relative to the beginning of the
1273 enclosing struct. In the GNU Chill (now deleted
1274 from GDB) implementation of variant records, the
1275 bitpos is zero in an anonymous union field, so we
1276 have to add the offset of the union here. */
1277 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1278 || (TYPE_NFIELDS (field_type) > 0
1279 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1280 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1282 v = search_struct_field (name, arg1, new_offset,
1284 looking_for_baseclass);
1291 for (i = 0; i < nbases; i++)
1294 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1295 /* If we are looking for baseclasses, this is what we get when
1296 we hit them. But it could happen that the base part's member
1297 name is not yet filled in. */
1298 int found_baseclass = (looking_for_baseclass
1299 && TYPE_BASECLASS_NAME (type, i) != NULL
1300 && (strcmp_iw (name,
1301 TYPE_BASECLASS_NAME (type,
1304 if (BASETYPE_VIA_VIRTUAL (type, i))
1307 struct value *v2 = allocate_value (basetype);
1309 boffset = baseclass_offset (type, i,
1310 value_contents (arg1) + offset,
1311 VALUE_ADDRESS (arg1)
1312 + value_offset (arg1) + offset);
1314 error (_("virtual baseclass botch"));
1316 /* The virtual base class pointer might have been clobbered
1317 by the user program. Make sure that it still points to a
1318 valid memory location. */
1321 if (boffset < 0 || boffset >= TYPE_LENGTH (type))
1323 CORE_ADDR base_addr;
1326 VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
1327 if (target_read_memory (base_addr,
1328 value_contents_raw (v2),
1329 TYPE_LENGTH (basetype)) != 0)
1330 error (_("virtual baseclass botch"));
1331 VALUE_LVAL (v2) = lval_memory;
1332 VALUE_ADDRESS (v2) = base_addr;
1336 VALUE_LVAL (v2) = VALUE_LVAL (arg1);
1337 VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
1338 VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
1339 set_value_offset (v2, value_offset (arg1) + boffset);
1340 if (value_lazy (arg1))
1341 set_value_lazy (v2, 1);
1343 memcpy (value_contents_raw (v2),
1344 value_contents_raw (arg1) + boffset,
1345 TYPE_LENGTH (basetype));
1348 if (found_baseclass)
1350 v = search_struct_field (name, v2, 0,
1351 TYPE_BASECLASS (type, i),
1352 looking_for_baseclass);
1354 else if (found_baseclass)
1355 v = value_primitive_field (arg1, offset, i, type);
1357 v = search_struct_field (name, arg1,
1358 offset + TYPE_BASECLASS_BITPOS (type,
1360 basetype, looking_for_baseclass);
1367 /* Helper function used by value_struct_elt to recurse through
1368 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1369 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1372 If found, return value, else if name matched and args not return
1373 (value) -1, else return NULL. */
1375 static struct value *
1376 search_struct_method (char *name, struct value **arg1p,
1377 struct value **args, int offset,
1378 int *static_memfuncp, struct type *type)
1382 int name_matched = 0;
1383 char dem_opname[64];
1385 CHECK_TYPEDEF (type);
1386 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1388 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1389 /* FIXME! May need to check for ARM demangling here */
1390 if (strncmp (t_field_name, "__", 2) == 0 ||
1391 strncmp (t_field_name, "op", 2) == 0 ||
1392 strncmp (t_field_name, "type", 4) == 0)
1394 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
1395 t_field_name = dem_opname;
1396 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
1397 t_field_name = dem_opname;
1399 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1401 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1402 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1405 check_stub_method_group (type, i);
1406 if (j > 0 && args == 0)
1407 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
1408 else if (j == 0 && args == 0)
1410 v = value_fn_field (arg1p, f, j, type, offset);
1417 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1418 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
1419 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
1420 TYPE_FN_FIELD_ARGS (f, j), args))
1422 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1423 return value_virtual_fn_field (arg1p, f, j,
1425 if (TYPE_FN_FIELD_STATIC_P (f, j)
1427 *static_memfuncp = 1;
1428 v = value_fn_field (arg1p, f, j, type, offset);
1437 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1441 if (BASETYPE_VIA_VIRTUAL (type, i))
1443 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1444 const gdb_byte *base_valaddr;
1446 /* The virtual base class pointer might have been
1447 clobbered by the user program. Make sure that it
1448 still points to a valid memory location. */
1450 if (offset < 0 || offset >= TYPE_LENGTH (type))
1452 gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
1453 if (target_read_memory (VALUE_ADDRESS (*arg1p)
1454 + value_offset (*arg1p) + offset,
1455 tmp, TYPE_LENGTH (baseclass)) != 0)
1456 error (_("virtual baseclass botch"));
1460 base_valaddr = value_contents (*arg1p) + offset;
1462 base_offset = baseclass_offset (type, i, base_valaddr,
1463 VALUE_ADDRESS (*arg1p)
1464 + value_offset (*arg1p) + offset);
1465 if (base_offset == -1)
1466 error (_("virtual baseclass botch"));
1470 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1472 v = search_struct_method (name, arg1p, args, base_offset + offset,
1473 static_memfuncp, TYPE_BASECLASS (type, i));
1474 if (v == (struct value *) - 1)
1480 /* FIXME-bothner: Why is this commented out? Why is it here? */
1481 /* *arg1p = arg1_tmp; */
1486 return (struct value *) - 1;
1491 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1492 extract the component named NAME from the ultimate target
1493 structure/union and return it as a value with its appropriate type.
1494 ERR is used in the error message if *ARGP's type is wrong.
1496 C++: ARGS is a list of argument types to aid in the selection of
1497 an appropriate method. Also, handle derived types.
1499 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1500 where the truthvalue of whether the function that was resolved was
1501 a static member function or not is stored.
1503 ERR is an error message to be printed in case the field is not
1507 value_struct_elt (struct value **argp, struct value **args,
1508 char *name, int *static_memfuncp, char *err)
1513 *argp = coerce_array (*argp);
1515 t = check_typedef (value_type (*argp));
1517 /* Follow pointers until we get to a non-pointer. */
1519 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1521 *argp = value_ind (*argp);
1522 /* Don't coerce fn pointer to fn and then back again! */
1523 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
1524 *argp = coerce_array (*argp);
1525 t = check_typedef (value_type (*argp));
1528 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1529 && TYPE_CODE (t) != TYPE_CODE_UNION)
1530 error (_("Attempt to extract a component of a value that is not a %s."), err);
1532 /* Assume it's not, unless we see that it is. */
1533 if (static_memfuncp)
1534 *static_memfuncp = 0;
1538 /* if there are no arguments ...do this... */
1540 /* Try as a field first, because if we succeed, there is less
1542 v = search_struct_field (name, *argp, 0, t, 0);
1546 /* C++: If it was not found as a data field, then try to
1547 return it as a pointer to a method. */
1549 if (destructor_name_p (name, t))
1550 error (_("Cannot get value of destructor"));
1552 v = search_struct_method (name, argp, args, 0,
1553 static_memfuncp, t);
1555 if (v == (struct value *) - 1)
1556 error (_("Cannot take address of method %s."), name);
1559 if (TYPE_NFN_FIELDS (t))
1560 error (_("There is no member or method named %s."), name);
1562 error (_("There is no member named %s."), name);
1567 if (destructor_name_p (name, t))
1571 /* Destructors are a special case. */
1572 int m_index, f_index;
1575 if (get_destructor_fn_field (t, &m_index, &f_index))
1577 v = value_fn_field (NULL,
1578 TYPE_FN_FIELDLIST1 (t, m_index),
1582 error (_("could not find destructor function named %s."),
1589 error (_("destructor should not have any argument"));
1593 v = search_struct_method (name, argp, args, 0,
1594 static_memfuncp, t);
1596 if (v == (struct value *) - 1)
1598 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
1602 /* See if user tried to invoke data as function. If so, hand it
1603 back. If it's not callable (i.e., a pointer to function),
1604 gdb should give an error. */
1605 v = search_struct_field (name, *argp, 0, t, 0);
1609 error (_("Structure has no component named %s."), name);
1613 /* Search through the methods of an object (and its bases) to find a
1614 specified method. Return the pointer to the fn_field list of
1615 overloaded instances.
1617 Helper function for value_find_oload_list.
1618 ARGP is a pointer to a pointer to a value (the object).
1619 METHOD is a string containing the method name.
1620 OFFSET is the offset within the value.
1621 TYPE is the assumed type of the object.
1622 NUM_FNS is the number of overloaded instances.
1623 BASETYPE is set to the actual type of the subobject where the
1625 BOFFSET is the offset of the base subobject where the method is found.
1628 static struct fn_field *
1629 find_method_list (struct value **argp, char *method,
1630 int offset, struct type *type, int *num_fns,
1631 struct type **basetype, int *boffset)
1635 CHECK_TYPEDEF (type);
1639 /* First check in object itself. */
1640 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1642 /* pai: FIXME What about operators and type conversions? */
1643 char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1644 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
1646 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
1647 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1653 /* Resolve any stub methods. */
1654 check_stub_method_group (type, i);
1660 /* Not found in object, check in base subobjects. */
1661 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1664 if (BASETYPE_VIA_VIRTUAL (type, i))
1666 base_offset = value_offset (*argp) + offset;
1667 base_offset = baseclass_offset (type, i,
1668 value_contents (*argp) + base_offset,
1669 VALUE_ADDRESS (*argp) + base_offset);
1670 if (base_offset == -1)
1671 error (_("virtual baseclass botch"));
1673 else /* Non-virtual base, simply use bit position from debug
1676 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1678 f = find_method_list (argp, method, base_offset + offset,
1679 TYPE_BASECLASS (type, i), num_fns,
1687 /* Return the list of overloaded methods of a specified name.
1689 ARGP is a pointer to a pointer to a value (the object).
1690 METHOD is the method name.
1691 OFFSET is the offset within the value contents.
1692 NUM_FNS is the number of overloaded instances.
1693 BASETYPE is set to the type of the base subobject that defines the
1695 BOFFSET is the offset of the base subobject which defines the method.
1699 value_find_oload_method_list (struct value **argp, char *method,
1700 int offset, int *num_fns,
1701 struct type **basetype, int *boffset)
1705 t = check_typedef (value_type (*argp));
1707 /* Code snarfed from value_struct_elt. */
1708 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1710 *argp = value_ind (*argp);
1711 /* Don't coerce fn pointer to fn and then back again! */
1712 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
1713 *argp = coerce_array (*argp);
1714 t = check_typedef (value_type (*argp));
1717 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1718 && TYPE_CODE (t) != TYPE_CODE_UNION)
1719 error (_("Attempt to extract a component of a value that is not a struct or union"));
1721 return find_method_list (argp, method, 0, t, num_fns,
1725 /* Given an array of argument types (ARGTYPES) (which includes an
1726 entry for "this" in the case of C++ methods), the number of
1727 arguments NARGS, the NAME of a function whether it's a method or
1728 not (METHOD), and the degree of laxness (LAX) in conforming to
1729 overload resolution rules in ANSI C++, find the best function that
1730 matches on the argument types according to the overload resolution
1733 In the case of class methods, the parameter OBJ is an object value
1734 in which to search for overloaded methods.
1736 In the case of non-method functions, the parameter FSYM is a symbol
1737 corresponding to one of the overloaded functions.
1739 Return value is an integer: 0 -> good match, 10 -> debugger applied
1740 non-standard coercions, 100 -> incompatible.
1742 If a method is being searched for, VALP will hold the value.
1743 If a non-method is being searched for, SYMP will hold the symbol
1746 If a method is being searched for, and it is a static method,
1747 then STATICP will point to a non-zero value.
1749 Note: This function does *not* check the value of
1750 overload_resolution. Caller must check it to see whether overload
1751 resolution is permitted.
1755 find_overload_match (struct type **arg_types, int nargs,
1756 char *name, int method, int lax,
1757 struct value **objp, struct symbol *fsym,
1758 struct value **valp, struct symbol **symp,
1761 struct value *obj = (objp ? *objp : NULL);
1762 /* Index of best overloaded function. */
1764 /* The measure for the current best match. */
1765 struct badness_vector *oload_champ_bv = NULL;
1766 struct value *temp = obj;
1767 /* For methods, the list of overloaded methods. */
1768 struct fn_field *fns_ptr = NULL;
1769 /* For non-methods, the list of overloaded function symbols. */
1770 struct symbol **oload_syms = NULL;
1771 /* Number of overloaded instances being considered. */
1773 struct type *basetype = NULL;
1777 struct cleanup *old_cleanups = NULL;
1779 const char *obj_type_name = NULL;
1780 char *func_name = NULL;
1781 enum oload_classification match_quality;
1783 /* Get the list of overloaded methods or functions. */
1787 obj_type_name = TYPE_NAME (value_type (obj));
1788 /* Hack: evaluate_subexp_standard often passes in a pointer
1789 value rather than the object itself, so try again. */
1790 if ((!obj_type_name || !*obj_type_name)
1791 && (TYPE_CODE (value_type (obj)) == TYPE_CODE_PTR))
1792 obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj)));
1794 fns_ptr = value_find_oload_method_list (&temp, name,
1796 &basetype, &boffset);
1797 if (!fns_ptr || !num_fns)
1798 error (_("Couldn't find method %s%s%s"),
1800 (obj_type_name && *obj_type_name) ? "::" : "",
1802 /* If we are dealing with stub method types, they should have
1803 been resolved by find_method_list via
1804 value_find_oload_method_list above. */
1805 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
1806 oload_champ = find_oload_champ (arg_types, nargs, method,
1808 oload_syms, &oload_champ_bv);
1812 const char *qualified_name = SYMBOL_CPLUS_DEMANGLED_NAME (fsym);
1814 /* If we have a C++ name, try to extract just the function
1817 func_name = cp_func_name (qualified_name);
1819 /* If there was no C++ name, this must be a C-style function.
1820 Just return the same symbol. Do the same if cp_func_name
1821 fails for some reason. */
1822 if (func_name == NULL)
1828 old_cleanups = make_cleanup (xfree, func_name);
1829 make_cleanup (xfree, oload_syms);
1830 make_cleanup (xfree, oload_champ_bv);
1832 oload_champ = find_oload_champ_namespace (arg_types, nargs,
1839 /* Check how bad the best match is. */
1842 classify_oload_match (oload_champ_bv, nargs,
1843 oload_method_static (method, fns_ptr,
1846 if (match_quality == INCOMPATIBLE)
1849 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
1851 (obj_type_name && *obj_type_name) ? "::" : "",
1854 error (_("Cannot resolve function %s to any overloaded instance"),
1857 else if (match_quality == NON_STANDARD)
1860 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
1862 (obj_type_name && *obj_type_name) ? "::" : "",
1865 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
1871 if (staticp != NULL)
1872 *staticp = oload_method_static (method, fns_ptr, oload_champ);
1873 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
1874 *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ,
1877 *valp = value_fn_field (&temp, fns_ptr, oload_champ,
1882 *symp = oload_syms[oload_champ];
1887 if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
1888 && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR)
1890 temp = value_addr (temp);
1894 if (old_cleanups != NULL)
1895 do_cleanups (old_cleanups);
1897 switch (match_quality)
1903 default: /* STANDARD */
1908 /* Find the best overload match, searching for FUNC_NAME in namespaces
1909 contained in QUALIFIED_NAME until it either finds a good match or
1910 runs out of namespaces. It stores the overloaded functions in
1911 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
1912 calling function is responsible for freeing *OLOAD_SYMS and
1916 find_oload_champ_namespace (struct type **arg_types, int nargs,
1917 const char *func_name,
1918 const char *qualified_name,
1919 struct symbol ***oload_syms,
1920 struct badness_vector **oload_champ_bv)
1924 find_oload_champ_namespace_loop (arg_types, nargs,
1927 oload_syms, oload_champ_bv,
1933 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
1934 how deep we've looked for namespaces, and the champ is stored in
1935 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
1938 It is the caller's responsibility to free *OLOAD_SYMS and
1942 find_oload_champ_namespace_loop (struct type **arg_types, int nargs,
1943 const char *func_name,
1944 const char *qualified_name,
1946 struct symbol ***oload_syms,
1947 struct badness_vector **oload_champ_bv,
1950 int next_namespace_len = namespace_len;
1951 int searched_deeper = 0;
1953 struct cleanup *old_cleanups;
1954 int new_oload_champ;
1955 struct symbol **new_oload_syms;
1956 struct badness_vector *new_oload_champ_bv;
1957 char *new_namespace;
1959 if (next_namespace_len != 0)
1961 gdb_assert (qualified_name[next_namespace_len] == ':');
1962 next_namespace_len += 2;
1964 next_namespace_len +=
1965 cp_find_first_component (qualified_name + next_namespace_len);
1967 /* Initialize these to values that can safely be xfree'd. */
1969 *oload_champ_bv = NULL;
1971 /* First, see if we have a deeper namespace we can search in.
1972 If we get a good match there, use it. */
1974 if (qualified_name[next_namespace_len] == ':')
1976 searched_deeper = 1;
1978 if (find_oload_champ_namespace_loop (arg_types, nargs,
1979 func_name, qualified_name,
1981 oload_syms, oload_champ_bv,
1988 /* If we reach here, either we're in the deepest namespace or we
1989 didn't find a good match in a deeper namespace. But, in the
1990 latter case, we still have a bad match in a deeper namespace;
1991 note that we might not find any match at all in the current
1992 namespace. (There's always a match in the deepest namespace,
1993 because this overload mechanism only gets called if there's a
1994 function symbol to start off with.) */
1996 old_cleanups = make_cleanup (xfree, *oload_syms);
1997 old_cleanups = make_cleanup (xfree, *oload_champ_bv);
1998 new_namespace = alloca (namespace_len + 1);
1999 strncpy (new_namespace, qualified_name, namespace_len);
2000 new_namespace[namespace_len] = '\0';
2001 new_oload_syms = make_symbol_overload_list (func_name,
2003 while (new_oload_syms[num_fns])
2006 new_oload_champ = find_oload_champ (arg_types, nargs, 0, num_fns,
2007 NULL, new_oload_syms,
2008 &new_oload_champ_bv);
2010 /* Case 1: We found a good match. Free earlier matches (if any),
2011 and return it. Case 2: We didn't find a good match, but we're
2012 not the deepest function. Then go with the bad match that the
2013 deeper function found. Case 3: We found a bad match, and we're
2014 the deepest function. Then return what we found, even though
2015 it's a bad match. */
2017 if (new_oload_champ != -1
2018 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2020 *oload_syms = new_oload_syms;
2021 *oload_champ = new_oload_champ;
2022 *oload_champ_bv = new_oload_champ_bv;
2023 do_cleanups (old_cleanups);
2026 else if (searched_deeper)
2028 xfree (new_oload_syms);
2029 xfree (new_oload_champ_bv);
2030 discard_cleanups (old_cleanups);
2035 gdb_assert (new_oload_champ != -1);
2036 *oload_syms = new_oload_syms;
2037 *oload_champ = new_oload_champ;
2038 *oload_champ_bv = new_oload_champ_bv;
2039 discard_cleanups (old_cleanups);
2044 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2045 the best match from among the overloaded methods or functions
2046 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2047 The number of methods/functions in the list is given by NUM_FNS.
2048 Return the index of the best match; store an indication of the
2049 quality of the match in OLOAD_CHAMP_BV.
2051 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2054 find_oload_champ (struct type **arg_types, int nargs, int method,
2055 int num_fns, struct fn_field *fns_ptr,
2056 struct symbol **oload_syms,
2057 struct badness_vector **oload_champ_bv)
2060 /* A measure of how good an overloaded instance is. */
2061 struct badness_vector *bv;
2062 /* Index of best overloaded function. */
2063 int oload_champ = -1;
2064 /* Current ambiguity state for overload resolution. */
2065 int oload_ambiguous = 0;
2066 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2068 *oload_champ_bv = NULL;
2070 /* Consider each candidate in turn. */
2071 for (ix = 0; ix < num_fns; ix++)
2074 int static_offset = oload_method_static (method, fns_ptr, ix);
2076 struct type **parm_types;
2080 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2084 /* If it's not a method, this is the proper place. */
2085 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2088 /* Prepare array of parameter types. */
2089 parm_types = (struct type **)
2090 xmalloc (nparms * (sizeof (struct type *)));
2091 for (jj = 0; jj < nparms; jj++)
2092 parm_types[jj] = (method
2093 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2094 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
2097 /* Compare parameter types to supplied argument types. Skip
2098 THIS for static methods. */
2099 bv = rank_function (parm_types, nparms,
2100 arg_types + static_offset,
2101 nargs - static_offset);
2103 if (!*oload_champ_bv)
2105 *oload_champ_bv = bv;
2108 else /* See whether current candidate is better or worse than
2110 switch (compare_badness (bv, *oload_champ_bv))
2112 case 0: /* Top two contenders are equally good. */
2113 oload_ambiguous = 1;
2115 case 1: /* Incomparable top contenders. */
2116 oload_ambiguous = 2;
2118 case 2: /* New champion, record details. */
2119 *oload_champ_bv = bv;
2120 oload_ambiguous = 0;
2131 fprintf_filtered (gdb_stderr,
2132 "Overloaded method instance %s, # of parms %d\n",
2133 fns_ptr[ix].physname, nparms);
2135 fprintf_filtered (gdb_stderr,
2136 "Overloaded function instance %s # of parms %d\n",
2137 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
2139 for (jj = 0; jj < nargs - static_offset; jj++)
2140 fprintf_filtered (gdb_stderr,
2141 "...Badness @ %d : %d\n",
2143 fprintf_filtered (gdb_stderr,
2144 "Overload resolution champion is %d, ambiguous? %d\n",
2145 oload_champ, oload_ambiguous);
2152 /* Return 1 if we're looking at a static method, 0 if we're looking at
2153 a non-static method or a function that isn't a method. */
2156 oload_method_static (int method, struct fn_field *fns_ptr, int index)
2158 if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
2164 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2166 static enum oload_classification
2167 classify_oload_match (struct badness_vector *oload_champ_bv,
2173 for (ix = 1; ix <= nargs - static_offset; ix++)
2175 if (oload_champ_bv->rank[ix] >= 100)
2176 return INCOMPATIBLE; /* Truly mismatched types. */
2177 else if (oload_champ_bv->rank[ix] >= 10)
2178 return NON_STANDARD; /* Non-standard type conversions
2182 return STANDARD; /* Only standard conversions needed. */
2185 /* C++: return 1 is NAME is a legitimate name for the destructor of
2186 type TYPE. If TYPE does not have a destructor, or if NAME is
2187 inappropriate for TYPE, an error is signaled. */
2189 destructor_name_p (const char *name, const struct type *type)
2191 /* Destructors are a special case. */
2195 char *dname = type_name_no_tag (type);
2196 char *cp = strchr (dname, '<');
2199 /* Do not compare the template part for template classes. */
2201 len = strlen (dname);
2204 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
2205 error (_("name of destructor must equal name of class"));
2212 /* Helper function for check_field: Given TYPE, a structure/union,
2213 return 1 if the component named NAME from the ultimate target
2214 structure/union is defined, otherwise, return 0. */
2217 check_field_in (struct type *type, const char *name)
2221 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2223 char *t_field_name = TYPE_FIELD_NAME (type, i);
2224 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2228 /* C++: If it was not found as a data field, then try to return it
2229 as a pointer to a method. */
2231 /* Destructors are a special case. */
2232 if (destructor_name_p (name, type))
2234 int m_index, f_index;
2236 return get_destructor_fn_field (type, &m_index, &f_index);
2239 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2241 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2245 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2246 if (check_field_in (TYPE_BASECLASS (type, i), name))
2253 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2254 return 1 if the component named NAME from the ultimate target
2255 structure/union is defined, otherwise, return 0. */
2258 check_field (struct value *arg1, const char *name)
2262 arg1 = coerce_array (arg1);
2264 t = value_type (arg1);
2266 /* Follow pointers until we get to a non-pointer. */
2271 if (TYPE_CODE (t) != TYPE_CODE_PTR
2272 && TYPE_CODE (t) != TYPE_CODE_REF)
2274 t = TYPE_TARGET_TYPE (t);
2277 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2278 && TYPE_CODE (t) != TYPE_CODE_UNION)
2279 error (_("Internal error: `this' is not an aggregate"));
2281 return check_field_in (t, name);
2284 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2285 return the appropriate member (or the address of the member, if
2286 WANT_ADDRESS). This function is used to resolve user expressions
2287 of the form "DOMAIN::NAME". For more details on what happens, see
2288 the comment before value_struct_elt_for_reference. */
2291 value_aggregate_elt (struct type *curtype,
2292 char *name, int want_address,
2295 switch (TYPE_CODE (curtype))
2297 case TYPE_CODE_STRUCT:
2298 case TYPE_CODE_UNION:
2299 return value_struct_elt_for_reference (curtype, 0, curtype,
2301 want_address, noside);
2302 case TYPE_CODE_NAMESPACE:
2303 return value_namespace_elt (curtype, name,
2304 want_address, noside);
2306 internal_error (__FILE__, __LINE__,
2307 _("non-aggregate type in value_aggregate_elt"));
2311 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2312 return the address of this member as a "pointer to member" type.
2313 If INTYPE is non-null, then it will be the type of the member we
2314 are looking for. This will help us resolve "pointers to member
2315 functions". This function is used to resolve user expressions of
2316 the form "DOMAIN::NAME". */
2318 static struct value *
2319 value_struct_elt_for_reference (struct type *domain, int offset,
2320 struct type *curtype, char *name,
2321 struct type *intype,
2325 struct type *t = curtype;
2327 struct value *v, *result;
2329 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2330 && TYPE_CODE (t) != TYPE_CODE_UNION)
2331 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2333 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2335 char *t_field_name = TYPE_FIELD_NAME (t, i);
2337 if (t_field_name && strcmp (t_field_name, name) == 0)
2339 if (TYPE_FIELD_STATIC (t, i))
2341 v = value_static_field (t, i);
2343 error (_("static field %s has been optimized out"),
2349 if (TYPE_FIELD_PACKED (t, i))
2350 error (_("pointers to bitfield members not allowed"));
2353 return value_from_longest
2354 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
2355 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2356 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2357 return allocate_value (TYPE_FIELD_TYPE (t, i));
2359 error (_("Cannot reference non-static field \"%s\""), name);
2363 /* C++: If it was not found as a data field, then try to return it
2364 as a pointer to a method. */
2366 /* Destructors are a special case. */
2367 if (destructor_name_p (name, t))
2369 error (_("member pointers to destructors not implemented yet"));
2372 /* Perform all necessary dereferencing. */
2373 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2374 intype = TYPE_TARGET_TYPE (intype);
2376 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2378 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2379 char dem_opname[64];
2381 if (strncmp (t_field_name, "__", 2) == 0
2382 || strncmp (t_field_name, "op", 2) == 0
2383 || strncmp (t_field_name, "type", 4) == 0)
2385 if (cplus_demangle_opname (t_field_name,
2386 dem_opname, DMGL_ANSI))
2387 t_field_name = dem_opname;
2388 else if (cplus_demangle_opname (t_field_name,
2390 t_field_name = dem_opname;
2392 if (t_field_name && strcmp (t_field_name, name) == 0)
2394 int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2395 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2397 check_stub_method_group (t, i);
2399 if (intype == 0 && j > 1)
2400 error (_("non-unique member `%s' requires type instantiation"), name);
2404 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2407 error (_("no member function matches that type instantiation"));
2412 if (TYPE_FN_FIELD_STATIC_P (f, j))
2415 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2416 0, VAR_DOMAIN, 0, NULL);
2421 return value_addr (read_var_value (s, 0));
2423 return read_var_value (s, 0);
2426 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2430 result = allocate_value
2431 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
2432 cplus_make_method_ptr (value_contents_writeable (result),
2433 TYPE_FN_FIELD_VOFFSET (f, j), 1);
2435 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2436 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
2438 error (_("Cannot reference virtual member function \"%s\""),
2444 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2445 0, VAR_DOMAIN, 0, NULL);
2449 v = read_var_value (s, 0);
2454 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
2455 cplus_make_method_ptr (value_contents_writeable (result),
2456 VALUE_ADDRESS (v), 0);
2462 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2467 if (BASETYPE_VIA_VIRTUAL (t, i))
2470 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2471 v = value_struct_elt_for_reference (domain,
2472 offset + base_offset,
2473 TYPE_BASECLASS (t, i),
2475 want_address, noside);
2480 /* As a last chance, pretend that CURTYPE is a namespace, and look
2481 it up that way; this (frequently) works for types nested inside
2484 return value_maybe_namespace_elt (curtype, name,
2485 want_address, noside);
2488 /* C++: Return the member NAME of the namespace given by the type
2491 static struct value *
2492 value_namespace_elt (const struct type *curtype,
2493 char *name, int want_address,
2496 struct value *retval = value_maybe_namespace_elt (curtype, name,
2501 error (_("No symbol \"%s\" in namespace \"%s\"."),
2502 name, TYPE_TAG_NAME (curtype));
2507 /* A helper function used by value_namespace_elt and
2508 value_struct_elt_for_reference. It looks up NAME inside the
2509 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
2510 is a class and NAME refers to a type in CURTYPE itself (as opposed
2511 to, say, some base class of CURTYPE). */
2513 static struct value *
2514 value_maybe_namespace_elt (const struct type *curtype,
2515 char *name, int want_address,
2518 const char *namespace_name = TYPE_TAG_NAME (curtype);
2520 struct value *result;
2522 sym = cp_lookup_symbol_namespace (namespace_name, name, NULL,
2523 get_selected_block (0),
2528 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
2529 && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
2530 result = allocate_value (SYMBOL_TYPE (sym));
2532 result = value_of_variable (sym, get_selected_block (0));
2534 if (result && want_address)
2535 result = value_addr (result);
2540 /* Given a pointer value V, find the real (RTTI) type of the object it
2543 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2544 and refer to the values computed for the object pointed to. */
2547 value_rtti_target_type (struct value *v, int *full,
2548 int *top, int *using_enc)
2550 struct value *target;
2552 target = value_ind (v);
2554 return value_rtti_type (target, full, top, using_enc);
2557 /* Given a value pointed to by ARGP, check its real run-time type, and
2558 if that is different from the enclosing type, create a new value
2559 using the real run-time type as the enclosing type (and of the same
2560 type as ARGP) and return it, with the embedded offset adjusted to
2561 be the correct offset to the enclosed object. RTYPE is the type,
2562 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
2563 by value_rtti_type(). If these are available, they can be supplied
2564 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
2565 NULL if they're not available. */
2568 value_full_object (struct value *argp,
2570 int xfull, int xtop,
2573 struct type *real_type;
2577 struct value *new_val;
2584 using_enc = xusing_enc;
2587 real_type = value_rtti_type (argp, &full, &top, &using_enc);
2589 /* If no RTTI data, or if object is already complete, do nothing. */
2590 if (!real_type || real_type == value_enclosing_type (argp))
2593 /* If we have the full object, but for some reason the enclosing
2594 type is wrong, set it. */
2595 /* pai: FIXME -- sounds iffy */
2598 argp = value_change_enclosing_type (argp, real_type);
2602 /* Check if object is in memory */
2603 if (VALUE_LVAL (argp) != lval_memory)
2605 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
2606 TYPE_NAME (real_type));
2611 /* All other cases -- retrieve the complete object. */
2612 /* Go back by the computed top_offset from the beginning of the
2613 object, adjusting for the embedded offset of argp if that's what
2614 value_rtti_type used for its computation. */
2615 new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
2616 (using_enc ? 0 : value_embedded_offset (argp)));
2617 deprecated_set_value_type (new_val, value_type (argp));
2618 set_value_embedded_offset (new_val, (using_enc
2619 ? top + value_embedded_offset (argp)
2625 /* Return the value of the local variable, if one exists.
2626 Flag COMPLAIN signals an error if the request is made in an
2627 inappropriate context. */
2630 value_of_local (const char *name, int complain)
2632 struct symbol *func, *sym;
2635 struct frame_info *frame;
2638 frame = get_selected_frame (_("no frame selected"));
2641 frame = deprecated_safe_get_selected_frame ();
2646 func = get_frame_function (frame);
2650 error (_("no `%s' in nameless context"), name);
2655 b = SYMBOL_BLOCK_VALUE (func);
2656 if (dict_empty (BLOCK_DICT (b)))
2659 error (_("no args, no `%s'"), name);
2664 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2665 symbol instead of the LOC_ARG one (if both exist). */
2666 sym = lookup_block_symbol (b, name, NULL, VAR_DOMAIN);
2670 error (_("current stack frame does not contain a variable named `%s'"),
2676 ret = read_var_value (sym, frame);
2677 if (ret == 0 && complain)
2678 error (_("`%s' argument unreadable"), name);
2682 /* C++/Objective-C: return the value of the class instance variable,
2683 if one exists. Flag COMPLAIN signals an error if the request is
2684 made in an inappropriate context. */
2687 value_of_this (int complain)
2689 if (current_language->la_language == language_objc)
2690 return value_of_local ("self", complain);
2692 return value_of_local ("this", complain);
2695 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
2696 elements long, starting at LOWBOUND. The result has the same lower
2697 bound as the original ARRAY. */
2700 value_slice (struct value *array, int lowbound, int length)
2702 struct type *slice_range_type, *slice_type, *range_type;
2703 LONGEST lowerbound, upperbound;
2704 struct value *slice;
2705 struct type *array_type;
2707 array_type = check_typedef (value_type (array));
2708 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
2709 && TYPE_CODE (array_type) != TYPE_CODE_STRING
2710 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
2711 error (_("cannot take slice of non-array"));
2713 range_type = TYPE_INDEX_TYPE (array_type);
2714 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
2715 error (_("slice from bad array or bitstring"));
2717 if (lowbound < lowerbound || length < 0
2718 || lowbound + length - 1 > upperbound)
2719 error (_("slice out of range"));
2721 /* FIXME-type-allocation: need a way to free this type when we are
2723 slice_range_type = create_range_type ((struct type *) NULL,
2724 TYPE_TARGET_TYPE (range_type),
2726 lowbound + length - 1);
2727 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
2731 slice_type = create_set_type ((struct type *) NULL,
2733 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
2734 slice = value_zero (slice_type, not_lval);
2736 for (i = 0; i < length; i++)
2738 int element = value_bit_index (array_type,
2739 value_contents (array),
2742 error (_("internal error accessing bitstring"));
2743 else if (element > 0)
2745 int j = i % TARGET_CHAR_BIT;
2746 if (BITS_BIG_ENDIAN)
2747 j = TARGET_CHAR_BIT - 1 - j;
2748 value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
2751 /* We should set the address, bitssize, and bitspos, so the
2752 slice can be used on the LHS, but that may require extensions
2753 to value_assign. For now, just leave as a non_lval.
2758 struct type *element_type = TYPE_TARGET_TYPE (array_type);
2760 (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
2762 slice_type = create_array_type ((struct type *) NULL,
2765 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
2767 slice = allocate_value (slice_type);
2768 if (value_lazy (array))
2769 set_value_lazy (slice, 1);
2771 memcpy (value_contents_writeable (slice),
2772 value_contents (array) + offset,
2773 TYPE_LENGTH (slice_type));
2775 if (VALUE_LVAL (array) == lval_internalvar)
2776 VALUE_LVAL (slice) = lval_internalvar_component;
2778 VALUE_LVAL (slice) = VALUE_LVAL (array);
2780 VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2781 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
2782 set_value_offset (slice, value_offset (array) + offset);
2787 /* Create a value for a FORTRAN complex number. Currently most of the
2788 time values are coerced to COMPLEX*16 (i.e. a complex number
2789 composed of 2 doubles. This really should be a smarter routine
2790 that figures out precision inteligently as opposed to assuming
2791 doubles. FIXME: fmb */
2794 value_literal_complex (struct value *arg1,
2799 struct type *real_type = TYPE_TARGET_TYPE (type);
2801 val = allocate_value (type);
2802 arg1 = value_cast (real_type, arg1);
2803 arg2 = value_cast (real_type, arg2);
2805 memcpy (value_contents_raw (val),
2806 value_contents (arg1), TYPE_LENGTH (real_type));
2807 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
2808 value_contents (arg2), TYPE_LENGTH (real_type));
2812 /* Cast a value into the appropriate complex data type. */
2814 static struct value *
2815 cast_into_complex (struct type *type, struct value *val)
2817 struct type *real_type = TYPE_TARGET_TYPE (type);
2819 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
2821 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
2822 struct value *re_val = allocate_value (val_real_type);
2823 struct value *im_val = allocate_value (val_real_type);
2825 memcpy (value_contents_raw (re_val),
2826 value_contents (val), TYPE_LENGTH (val_real_type));
2827 memcpy (value_contents_raw (im_val),
2828 value_contents (val) + TYPE_LENGTH (val_real_type),
2829 TYPE_LENGTH (val_real_type));
2831 return value_literal_complex (re_val, im_val, type);
2833 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
2834 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
2835 return value_literal_complex (val,
2836 value_zero (real_type, not_lval),
2839 error (_("cannot cast non-number to complex"));
2843 _initialize_valops (void)
2845 add_setshow_boolean_cmd ("overload-resolution", class_support,
2846 &overload_resolution, _("\
2847 Set overload resolution in evaluating C++ functions."), _("\
2848 Show overload resolution in evaluating C++ functions."),
2850 show_overload_resolution,
2851 &setlist, &showlist);
2852 overload_resolution = 1;