1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
5 2006, 2007 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 2 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, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
39 #include "dictionary.h"
40 #include "cp-support.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
48 extern int overload_debug;
49 /* Local functions. */
51 static int typecmp (int staticp, int varargs, int nargs,
52 struct field t1[], struct value *t2[]);
54 static struct value *search_struct_field (char *, struct value *,
55 int, struct type *, int);
57 static struct value *search_struct_method (char *, struct value **,
59 int, int *, struct type *);
61 static int find_oload_champ_namespace (struct type **, int,
62 const char *, const char *,
64 struct badness_vector **);
67 int find_oload_champ_namespace_loop (struct type **, int,
68 const char *, const char *,
69 int, struct symbol ***,
70 struct badness_vector **, int *);
72 static int find_oload_champ (struct type **, int, int, int,
73 struct fn_field *, struct symbol **,
74 struct badness_vector **);
76 static int oload_method_static (int, struct fn_field *, int);
78 enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
81 oload_classification classify_oload_match (struct badness_vector *,
84 static int check_field_in (struct type *, const char *);
86 static struct value *value_struct_elt_for_reference (struct type *,
92 static struct value *value_namespace_elt (const struct type *,
93 char *, int , enum noside);
95 static struct value *value_maybe_namespace_elt (const struct type *,
99 static CORE_ADDR allocate_space_in_inferior (int);
101 static struct value *cast_into_complex (struct type *, struct value *);
103 static struct fn_field *find_method_list (struct value **, char *,
104 int, struct type *, int *,
105 struct type **, int *);
107 void _initialize_valops (void);
110 /* Flag for whether we want to abandon failed expression evals by
113 static int auto_abandon = 0;
116 int overload_resolution = 0;
118 show_overload_resolution (struct ui_file *file, int from_tty,
119 struct cmd_list_element *c,
122 fprintf_filtered (file, _("\
123 Overload resolution in evaluating C++ functions is %s.\n"),
127 /* Find the address of function name NAME in the inferior. */
130 find_function_in_inferior (const char *name)
133 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL);
136 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
138 error (_("\"%s\" exists in this program but is not a function."),
141 return value_of_variable (sym, NULL);
145 struct minimal_symbol *msymbol =
146 lookup_minimal_symbol (name, NULL, NULL);
151 type = lookup_pointer_type (builtin_type_char);
152 type = lookup_function_type (type);
153 type = lookup_pointer_type (type);
154 maddr = SYMBOL_VALUE_ADDRESS (msymbol);
155 return value_from_pointer (type, maddr);
159 if (!target_has_execution)
160 error (_("evaluation of this expression requires the target program to be active"));
162 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
167 /* Allocate NBYTES of space in the inferior using the inferior's
168 malloc and return a value that is a pointer to the allocated
172 value_allocate_space_in_inferior (int len)
174 struct value *blocklen;
176 find_function_in_inferior (gdbarch_name_of_malloc (current_gdbarch));
178 blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
179 val = call_function_by_hand (val, 1, &blocklen);
180 if (value_logical_not (val))
182 if (!target_has_execution)
183 error (_("No memory available to program now: you need to start the target first"));
185 error (_("No memory available to program: call to malloc failed"));
191 allocate_space_in_inferior (int len)
193 return value_as_long (value_allocate_space_in_inferior (len));
196 /* Cast one pointer or reference type to another. Both TYPE and
197 the type of ARG2 should be pointer types, or else both should be
198 reference types. Returns the new pointer or reference. */
201 value_cast_pointers (struct type *type, struct value *arg2)
203 struct type *type2 = check_typedef (value_type (arg2));
204 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
205 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
207 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
208 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
209 && !value_logical_not (arg2))
213 /* Look in the type of the source to see if it contains the
214 type of the target as a superclass. If so, we'll need to
215 offset the pointer rather than just change its type. */
216 if (TYPE_NAME (t1) != NULL)
220 if (TYPE_CODE (type2) == TYPE_CODE_REF)
221 v2 = coerce_ref (arg2);
223 v2 = value_ind (arg2);
224 v = search_struct_field (type_name_no_tag (t1),
229 deprecated_set_value_type (v, type);
234 /* Look in the type of the target to see if it contains the
235 type of the source as a superclass. If so, we'll need to
236 offset the pointer rather than just change its type.
237 FIXME: This fails silently with virtual inheritance. */
238 if (TYPE_NAME (t2) != NULL)
240 v = search_struct_field (type_name_no_tag (t2),
241 value_zero (t1, not_lval), 0, t1, 1);
244 CORE_ADDR addr2 = value_as_address (arg2);
245 addr2 -= (VALUE_ADDRESS (v)
247 + value_embedded_offset (v));
248 return value_from_pointer (type, addr2);
253 /* No superclass found, just change the pointer type. */
254 arg2 = value_copy (arg2);
255 deprecated_set_value_type (arg2, type);
256 arg2 = value_change_enclosing_type (arg2, type);
257 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
261 /* Cast value ARG2 to type TYPE and return as a value.
262 More general than a C cast: accepts any two types of the same length,
263 and if ARG2 is an lvalue it can be cast into anything at all. */
264 /* In C++, casts may change pointer or object representations. */
267 value_cast (struct type *type, struct value *arg2)
269 enum type_code code1;
270 enum type_code code2;
274 int convert_to_boolean = 0;
276 if (value_type (arg2) == type)
279 CHECK_TYPEDEF (type);
280 code1 = TYPE_CODE (type);
281 arg2 = coerce_ref (arg2);
282 type2 = check_typedef (value_type (arg2));
284 /* You can't cast to a reference type. See value_cast_pointers
286 gdb_assert (code1 != TYPE_CODE_REF);
288 /* A cast to an undetermined-length array_type, such as
289 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
290 where N is sizeof(OBJECT)/sizeof(TYPE). */
291 if (code1 == TYPE_CODE_ARRAY)
293 struct type *element_type = TYPE_TARGET_TYPE (type);
294 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
295 if (element_length > 0
296 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
298 struct type *range_type = TYPE_INDEX_TYPE (type);
299 int val_length = TYPE_LENGTH (type2);
300 LONGEST low_bound, high_bound, new_length;
301 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
302 low_bound = 0, high_bound = 0;
303 new_length = val_length / element_length;
304 if (val_length % element_length != 0)
305 warning (_("array element type size does not divide object size in cast"));
306 /* FIXME-type-allocation: need a way to free this type when
307 we are done with it. */
308 range_type = create_range_type ((struct type *) NULL,
309 TYPE_TARGET_TYPE (range_type),
311 new_length + low_bound - 1);
312 deprecated_set_value_type (arg2,
313 create_array_type ((struct type *) NULL,
320 if (current_language->c_style_arrays
321 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
322 arg2 = value_coerce_array (arg2);
324 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
325 arg2 = value_coerce_function (arg2);
327 type2 = check_typedef (value_type (arg2));
328 code2 = TYPE_CODE (type2);
330 if (code1 == TYPE_CODE_COMPLEX)
331 return cast_into_complex (type, arg2);
332 if (code1 == TYPE_CODE_BOOL)
334 code1 = TYPE_CODE_INT;
335 convert_to_boolean = 1;
337 if (code1 == TYPE_CODE_CHAR)
338 code1 = TYPE_CODE_INT;
339 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
340 code2 = TYPE_CODE_INT;
342 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
343 || code2 == TYPE_CODE_ENUM || 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_INT || code1 == TYPE_CODE_ENUM
363 || code1 == TYPE_CODE_RANGE)
364 && (scalar || code2 == TYPE_CODE_PTR
365 || code2 == TYPE_CODE_MEMBERPTR))
369 /* When we cast pointers to integers, we mustn't use
370 gdbarch_pointer_to_address to find the address the pointer
371 represents, as value_as_long would. GDB should evaluate
372 expressions just as the compiler would --- and the compiler
373 sees a cast as a simple reinterpretation of the pointer's
375 if (code2 == TYPE_CODE_PTR)
376 longest = extract_unsigned_integer (value_contents (arg2),
377 TYPE_LENGTH (type2));
379 longest = value_as_long (arg2);
380 return value_from_longest (type, convert_to_boolean ?
381 (LONGEST) (longest ? 1 : 0) : longest);
383 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
384 || code2 == TYPE_CODE_ENUM
385 || code2 == TYPE_CODE_RANGE))
387 /* TYPE_LENGTH (type) is the length of a pointer, but we really
388 want the length of an address! -- we are really dealing with
389 addresses (i.e., gdb representations) not pointers (i.e.,
390 target representations) here.
392 This allows things like "print *(int *)0x01000234" to work
393 without printing a misleading message -- which would
394 otherwise occur when dealing with a target having two byte
395 pointers and four byte addresses. */
397 int addr_bit = gdbarch_addr_bit (current_gdbarch);
399 LONGEST longest = value_as_long (arg2);
400 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
402 if (longest >= ((LONGEST) 1 << addr_bit)
403 || longest <= -((LONGEST) 1 << addr_bit))
404 warning (_("value truncated"));
406 return value_from_longest (type, longest);
408 else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
409 && value_as_long (arg2) == 0)
411 struct value *result = allocate_value (type);
412 cplus_make_method_ptr (value_contents_writeable (result), 0, 0);
415 else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
416 && value_as_long (arg2) == 0)
418 /* The Itanium C++ ABI represents NULL pointers to members as
419 minus one, instead of biasing the normal case. */
420 return value_from_longest (type, -1);
422 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
424 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
425 return value_cast_pointers (type, arg2);
427 arg2 = value_copy (arg2);
428 deprecated_set_value_type (arg2, type);
429 arg2 = value_change_enclosing_type (arg2, type);
430 set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
433 else if (VALUE_LVAL (arg2) == lval_memory)
434 return value_at_lazy (type,
435 VALUE_ADDRESS (arg2) + value_offset (arg2));
436 else if (code1 == TYPE_CODE_VOID)
438 return value_zero (builtin_type_void, not_lval);
442 error (_("Invalid cast."));
447 /* Create a value of type TYPE that is zero, and return it. */
450 value_zero (struct type *type, enum lval_type lv)
452 struct value *val = allocate_value (type);
453 VALUE_LVAL (val) = lv;
458 /* Return a value with type TYPE located at ADDR.
460 Call value_at only if the data needs to be fetched immediately;
461 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
462 value_at_lazy instead. value_at_lazy simply records the address of
463 the data and sets the lazy-evaluation-required flag. The lazy flag
464 is tested in the value_contents macro, which is used if and when
465 the contents are actually required.
467 Note: value_at does *NOT* handle embedded offsets; perform such
468 adjustments before or after calling it. */
471 value_at (struct type *type, CORE_ADDR addr)
475 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
476 error (_("Attempt to dereference a generic pointer."));
478 val = allocate_value (type);
480 read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
482 VALUE_LVAL (val) = lval_memory;
483 VALUE_ADDRESS (val) = addr;
488 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
491 value_at_lazy (struct type *type, CORE_ADDR addr)
495 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
496 error (_("Attempt to dereference a generic pointer."));
498 val = allocate_value (type);
500 VALUE_LVAL (val) = lval_memory;
501 VALUE_ADDRESS (val) = addr;
502 set_value_lazy (val, 1);
507 /* Called only from the value_contents and value_contents_all()
508 macros, if the current data for a variable needs to be loaded into
509 value_contents(VAL). Fetches the data from the user's process, and
510 clears the lazy flag to indicate that the data in the buffer is
513 If the value is zero-length, we avoid calling read_memory, which
514 would abort. We mark the value as fetched anyway -- all 0 bytes of
517 This function returns a value because it is used in the
518 value_contents macro as part of an expression, where a void would
519 not work. The value is ignored. */
522 value_fetch_lazy (struct value *val)
524 CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
525 int length = TYPE_LENGTH (value_enclosing_type (val));
527 struct type *type = value_type (val);
529 read_memory (addr, value_contents_all_raw (val), length);
531 set_value_lazy (val, 0);
536 /* Store the contents of FROMVAL into the location of TOVAL.
537 Return a new value with the location of TOVAL and contents of FROMVAL. */
540 value_assign (struct value *toval, struct value *fromval)
544 struct frame_id old_frame;
546 if (!deprecated_value_modifiable (toval))
547 error (_("Left operand of assignment is not a modifiable lvalue."));
549 toval = coerce_ref (toval);
551 type = value_type (toval);
552 if (VALUE_LVAL (toval) != lval_internalvar)
553 fromval = value_cast (type, fromval);
555 fromval = coerce_array (fromval);
556 CHECK_TYPEDEF (type);
558 /* Since modifying a register can trash the frame chain, and
559 modifying memory can trash the frame cache, we save the old frame
560 and then restore the new frame afterwards. */
561 old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
563 switch (VALUE_LVAL (toval))
565 case lval_internalvar:
566 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
567 val = value_copy (VALUE_INTERNALVAR (toval)->value);
568 val = value_change_enclosing_type (val,
569 value_enclosing_type (fromval));
570 set_value_embedded_offset (val, value_embedded_offset (fromval));
571 set_value_pointed_to_offset (val,
572 value_pointed_to_offset (fromval));
575 case lval_internalvar_component:
576 set_internalvar_component (VALUE_INTERNALVAR (toval),
577 value_offset (toval),
578 value_bitpos (toval),
579 value_bitsize (toval),
585 const gdb_byte *dest_buffer;
586 CORE_ADDR changed_addr;
588 gdb_byte buffer[sizeof (LONGEST)];
590 if (value_bitsize (toval))
592 /* We assume that the argument to read_memory is in units
593 of host chars. FIXME: Is that correct? */
594 changed_len = (value_bitpos (toval)
595 + value_bitsize (toval)
599 if (changed_len > (int) sizeof (LONGEST))
600 error (_("Can't handle bitfields which don't fit in a %d bit word."),
601 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
603 read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
604 buffer, changed_len);
605 modify_field (buffer, value_as_long (fromval),
606 value_bitpos (toval), value_bitsize (toval));
607 changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
608 dest_buffer = buffer;
612 changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
613 changed_len = TYPE_LENGTH (type);
614 dest_buffer = value_contents (fromval);
617 write_memory (changed_addr, dest_buffer, changed_len);
618 if (deprecated_memory_changed_hook)
619 deprecated_memory_changed_hook (changed_addr, changed_len);
625 struct frame_info *frame;
628 /* Figure out which frame this is in currently. */
629 frame = frame_find_by_id (VALUE_FRAME_ID (toval));
630 value_reg = VALUE_REGNUM (toval);
633 error (_("Value being assigned to is no longer active."));
635 if (gdbarch_convert_register_p
636 (current_gdbarch, VALUE_REGNUM (toval), type))
638 /* If TOVAL is a special machine register requiring
639 conversion of program values to a special raw
641 gdbarch_value_to_register (current_gdbarch, frame,
642 VALUE_REGNUM (toval), type,
643 value_contents (fromval));
647 if (value_bitsize (toval))
650 gdb_byte buffer[sizeof (LONGEST)];
652 changed_len = (value_bitpos (toval)
653 + value_bitsize (toval)
657 if (changed_len > (int) sizeof (LONGEST))
658 error (_("Can't handle bitfields which don't fit in a %d bit word."),
659 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
661 get_frame_register_bytes (frame, value_reg,
662 value_offset (toval),
663 changed_len, buffer);
665 modify_field (buffer, value_as_long (fromval),
666 value_bitpos (toval),
667 value_bitsize (toval));
669 put_frame_register_bytes (frame, value_reg,
670 value_offset (toval),
671 changed_len, buffer);
675 put_frame_register_bytes (frame, value_reg,
676 value_offset (toval),
678 value_contents (fromval));
682 if (deprecated_register_changed_hook)
683 deprecated_register_changed_hook (-1);
684 observer_notify_target_changed (¤t_target);
689 error (_("Left operand of assignment is not an lvalue."));
692 /* Assigning to the stack pointer, frame pointer, and other
693 (architecture and calling convention specific) registers may
694 cause the frame cache to be out of date. Assigning to memory
695 also can. We just do this on all assignments to registers or
696 memory, for simplicity's sake; I doubt the slowdown matters. */
697 switch (VALUE_LVAL (toval))
702 reinit_frame_cache ();
704 /* Having destroyed the frame cache, restore the selected
707 /* FIXME: cagney/2002-11-02: There has to be a better way of
708 doing this. Instead of constantly saving/restoring the
709 frame. Why not create a get_selected_frame() function that,
710 having saved the selected frame's ID can automatically
711 re-find the previously selected frame automatically. */
714 struct frame_info *fi = frame_find_by_id (old_frame);
724 /* If the field does not entirely fill a LONGEST, then zero the sign
725 bits. If the field is signed, and is negative, then sign
727 if ((value_bitsize (toval) > 0)
728 && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
730 LONGEST fieldval = value_as_long (fromval);
731 LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
734 if (!TYPE_UNSIGNED (type)
735 && (fieldval & (valmask ^ (valmask >> 1))))
736 fieldval |= ~valmask;
738 fromval = value_from_longest (type, fieldval);
741 val = value_copy (toval);
742 memcpy (value_contents_raw (val), value_contents (fromval),
744 deprecated_set_value_type (val, type);
745 val = value_change_enclosing_type (val,
746 value_enclosing_type (fromval));
747 set_value_embedded_offset (val, value_embedded_offset (fromval));
748 set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
753 /* Extend a value VAL to COUNT repetitions of its type. */
756 value_repeat (struct value *arg1, int count)
760 if (VALUE_LVAL (arg1) != lval_memory)
761 error (_("Only values in memory can be extended with '@'."));
763 error (_("Invalid number %d of repetitions."), count);
765 val = allocate_repeat_value (value_enclosing_type (arg1), count);
767 read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1),
768 value_contents_all_raw (val),
769 TYPE_LENGTH (value_enclosing_type (val)));
770 VALUE_LVAL (val) = lval_memory;
771 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
777 value_of_variable (struct symbol *var, struct block *b)
780 struct frame_info *frame = NULL;
783 frame = NULL; /* Use selected frame. */
784 else if (symbol_read_needs_frame (var))
786 frame = block_innermost_frame (b);
789 if (BLOCK_FUNCTION (b)
790 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
791 error (_("No frame is currently executing in block %s."),
792 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
794 error (_("No frame is currently executing in specified block"));
798 val = read_var_value (var, frame);
800 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
805 /* Given a value which is an array, return a value which is a pointer
806 to its first element, regardless of whether or not the array has a
809 FIXME: A previous comment here indicated that this routine should
810 be substracting the array's lower bound. It's not clear to me that
811 this is correct. Given an array subscripting operation, it would
812 certainly work to do the adjustment here, essentially computing:
814 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
816 However I believe a more appropriate and logical place to account
817 for the lower bound is to do so in value_subscript, essentially
820 (&array[0] + ((index - lowerbound) * sizeof array[0]))
822 As further evidence consider what would happen with operations
823 other than array subscripting, where the caller would get back a
824 value that had an address somewhere before the actual first element
825 of the array, and the information about the lower bound would be
826 lost because of the coercion to pointer type.
830 value_coerce_array (struct value *arg1)
832 struct type *type = check_typedef (value_type (arg1));
834 if (VALUE_LVAL (arg1) != lval_memory)
835 error (_("Attempt to take address of value not located in memory."));
837 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
838 (VALUE_ADDRESS (arg1) + value_offset (arg1)));
841 /* Given a value which is a function, return a value which is a pointer
845 value_coerce_function (struct value *arg1)
847 struct value *retval;
849 if (VALUE_LVAL (arg1) != lval_memory)
850 error (_("Attempt to take address of value not located in memory."));
852 retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
853 (VALUE_ADDRESS (arg1) + value_offset (arg1)));
857 /* Return a pointer value for the object for which ARG1 is the
861 value_addr (struct value *arg1)
865 struct type *type = check_typedef (value_type (arg1));
866 if (TYPE_CODE (type) == TYPE_CODE_REF)
868 /* Copy the value, but change the type from (T&) to (T*). We
869 keep the same location information, which is efficient, and
870 allows &(&X) to get the location containing the reference. */
871 arg2 = value_copy (arg1);
872 deprecated_set_value_type (arg2,
873 lookup_pointer_type (TYPE_TARGET_TYPE (type)));
876 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
877 return value_coerce_function (arg1);
879 if (VALUE_LVAL (arg1) != lval_memory)
880 error (_("Attempt to take address of value not located in memory."));
882 /* Get target memory address */
883 arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
884 (VALUE_ADDRESS (arg1)
885 + value_offset (arg1)
886 + value_embedded_offset (arg1)));
888 /* This may be a pointer to a base subobject; so remember the
889 full derived object's type ... */
890 arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
891 /* ... and also the relative position of the subobject in the full
893 set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
897 /* Return a reference value for the object for which ARG1 is the
901 value_ref (struct value *arg1)
905 struct type *type = check_typedef (value_type (arg1));
906 if (TYPE_CODE (type) == TYPE_CODE_REF)
909 arg2 = value_addr (arg1);
910 deprecated_set_value_type (arg2, lookup_reference_type (type));
914 /* Given a value of a pointer type, apply the C unary * operator to
918 value_ind (struct value *arg1)
920 struct type *base_type;
923 arg1 = coerce_array (arg1);
925 base_type = check_typedef (value_type (arg1));
927 /* Allow * on an integer so we can cast it to whatever we want.
928 This returns an int, which seems like the most C-like thing to
929 do. "long long" variables are rare enough that
930 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
931 if (TYPE_CODE (base_type) == TYPE_CODE_INT)
932 return value_at_lazy (builtin_type_int,
933 (CORE_ADDR) value_as_address (arg1));
934 else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
936 struct type *enc_type;
937 /* We may be pointing to something embedded in a larger object.
938 Get the real type of the enclosing object. */
939 enc_type = check_typedef (value_enclosing_type (arg1));
940 enc_type = TYPE_TARGET_TYPE (enc_type);
942 if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
943 || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
944 /* For functions, go through find_function_addr, which knows
945 how to handle function descriptors. */
946 arg2 = value_at_lazy (enc_type,
947 find_function_addr (arg1, NULL));
949 /* Retrieve the enclosing object pointed to */
950 arg2 = value_at_lazy (enc_type,
951 (value_as_address (arg1)
952 - value_pointed_to_offset (arg1)));
954 /* Re-adjust type. */
955 deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
956 /* Add embedding info. */
957 arg2 = value_change_enclosing_type (arg2, enc_type);
958 set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
960 /* We may be pointing to an object of some derived type. */
961 arg2 = value_full_object (arg2, NULL, 0, 0, 0);
965 error (_("Attempt to take contents of a non-pointer value."));
966 return 0; /* For lint -- never reached. */
969 /* Create a value for an array by allocating space in the inferior,
970 copying the data into that space, and then setting up an array
973 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
974 is populated from the values passed in ELEMVEC.
976 The element type of the array is inherited from the type of the
977 first element, and all elements must have the same size (though we
978 don't currently enforce any restriction on their types). */
981 value_array (int lowbound, int highbound, struct value **elemvec)
985 unsigned int typelength;
987 struct type *rangetype;
988 struct type *arraytype;
991 /* Validate that the bounds are reasonable and that each of the
992 elements have the same size. */
994 nelem = highbound - lowbound + 1;
997 error (_("bad array bounds (%d, %d)"), lowbound, highbound);
999 typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1000 for (idx = 1; idx < nelem; idx++)
1002 if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1004 error (_("array elements must all be the same size"));
1008 rangetype = create_range_type ((struct type *) NULL,
1010 lowbound, highbound);
1011 arraytype = create_array_type ((struct type *) NULL,
1012 value_enclosing_type (elemvec[0]),
1015 if (!current_language->c_style_arrays)
1017 val = allocate_value (arraytype);
1018 for (idx = 0; idx < nelem; idx++)
1020 memcpy (value_contents_all_raw (val) + (idx * typelength),
1021 value_contents_all (elemvec[idx]),
1027 /* Allocate space to store the array in the inferior, and then
1028 initialize it by copying in each element. FIXME: Is it worth it
1029 to create a local buffer in which to collect each value and then
1030 write all the bytes in one operation? */
1032 addr = allocate_space_in_inferior (nelem * typelength);
1033 for (idx = 0; idx < nelem; idx++)
1035 write_memory (addr + (idx * typelength),
1036 value_contents_all (elemvec[idx]),
1040 /* Create the array type and set up an array value to be evaluated
1043 val = value_at_lazy (arraytype, addr);
1047 /* Create a value for a string constant by allocating space in the
1048 inferior, copying the data into that space, and returning the
1049 address with type TYPE_CODE_STRING. PTR points to the string
1050 constant data; LEN is number of characters.
1052 Note that string types are like array of char types with a lower
1053 bound of zero and an upper bound of LEN - 1. Also note that the
1054 string may contain embedded null bytes. */
1057 value_string (char *ptr, int len)
1060 int lowbound = current_language->string_lower_bound;
1061 struct type *rangetype = create_range_type ((struct type *) NULL,
1064 len + lowbound - 1);
1065 struct type *stringtype
1066 = create_string_type ((struct type *) NULL, rangetype);
1069 if (current_language->c_style_arrays == 0)
1071 val = allocate_value (stringtype);
1072 memcpy (value_contents_raw (val), ptr, len);
1077 /* Allocate space to store the string in the inferior, and then copy
1078 LEN bytes from PTR in gdb to that address in the inferior. */
1080 addr = allocate_space_in_inferior (len);
1081 write_memory (addr, (gdb_byte *) ptr, len);
1083 val = value_at_lazy (stringtype, addr);
1088 value_bitstring (char *ptr, int len)
1091 struct type *domain_type = create_range_type (NULL,
1094 struct type *type = create_set_type ((struct type *) NULL,
1096 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1097 val = allocate_value (type);
1098 memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
1102 /* See if we can pass arguments in T2 to a function which takes
1103 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1104 a NULL-terminated vector. If some arguments need coercion of some
1105 sort, then the coerced values are written into T2. Return value is
1106 0 if the arguments could be matched, or the position at which they
1109 STATICP is nonzero if the T1 argument list came from a static
1110 member function. T2 will still include the ``this'' pointer, but
1113 For non-static member functions, we ignore the first argument,
1114 which is the type of the instance variable. This is because we
1115 want to handle calls with objects from derived classes. This is
1116 not entirely correct: we should actually check to make sure that a
1117 requested operation is type secure, shouldn't we? FIXME. */
1120 typecmp (int staticp, int varargs, int nargs,
1121 struct field t1[], struct value *t2[])
1126 internal_error (__FILE__, __LINE__,
1127 _("typecmp: no argument list"));
1129 /* Skip ``this'' argument if applicable. T2 will always include
1135 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1138 struct type *tt1, *tt2;
1143 tt1 = check_typedef (t1[i].type);
1144 tt2 = check_typedef (value_type (t2[i]));
1146 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1147 /* We should be doing hairy argument matching, as below. */
1148 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1150 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1151 t2[i] = value_coerce_array (t2[i]);
1153 t2[i] = value_ref (t2[i]);
1157 /* djb - 20000715 - Until the new type structure is in the
1158 place, and we can attempt things like implicit conversions,
1159 we need to do this so you can take something like a map<const
1160 char *>, and properly access map["hello"], because the
1161 argument to [] will be a reference to a pointer to a char,
1162 and the argument will be a pointer to a char. */
1163 while (TYPE_CODE(tt1) == TYPE_CODE_REF
1164 || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1166 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1168 while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1169 || TYPE_CODE(tt2) == TYPE_CODE_PTR
1170 || TYPE_CODE(tt2) == TYPE_CODE_REF)
1172 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1174 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1176 /* Array to pointer is a `trivial conversion' according to the
1179 /* We should be doing much hairier argument matching (see
1180 section 13.2 of the ARM), but as a quick kludge, just check
1181 for the same type code. */
1182 if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1185 if (varargs || t2[i] == NULL)
1190 /* Helper function used by value_struct_elt to recurse through
1191 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1192 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1193 TYPE. If found, return value, else return NULL.
1195 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1196 fields, look for a baseclass named NAME. */
1198 static struct value *
1199 search_struct_field (char *name, struct value *arg1, int offset,
1200 struct type *type, int looking_for_baseclass)
1203 int nbases = TYPE_N_BASECLASSES (type);
1205 CHECK_TYPEDEF (type);
1207 if (!looking_for_baseclass)
1208 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1210 char *t_field_name = TYPE_FIELD_NAME (type, i);
1212 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1215 if (TYPE_FIELD_STATIC (type, i))
1217 v = value_static_field (type, i);
1219 error (_("field %s is nonexistent or has been optimised out"),
1224 v = value_primitive_field (arg1, offset, i, type);
1226 error (_("there is no field named %s"), name);
1232 && (t_field_name[0] == '\0'
1233 || (TYPE_CODE (type) == TYPE_CODE_UNION
1234 && (strcmp_iw (t_field_name, "else") == 0))))
1236 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1237 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1238 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1240 /* Look for a match through the fields of an anonymous
1241 union, or anonymous struct. C++ provides anonymous
1244 In the GNU Chill (now deleted from GDB)
1245 implementation of variant record types, each
1246 <alternative field> has an (anonymous) union type,
1247 each member of the union represents a <variant
1248 alternative>. Each <variant alternative> is
1249 represented as a struct, with a member for each
1253 int new_offset = offset;
1255 /* This is pretty gross. In G++, the offset in an
1256 anonymous union is relative to the beginning of the
1257 enclosing struct. In the GNU Chill (now deleted
1258 from GDB) implementation of variant records, the
1259 bitpos is zero in an anonymous union field, so we
1260 have to add the offset of the union here. */
1261 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1262 || (TYPE_NFIELDS (field_type) > 0
1263 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1264 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1266 v = search_struct_field (name, arg1, new_offset,
1268 looking_for_baseclass);
1275 for (i = 0; i < nbases; i++)
1278 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1279 /* If we are looking for baseclasses, this is what we get when
1280 we hit them. But it could happen that the base part's member
1281 name is not yet filled in. */
1282 int found_baseclass = (looking_for_baseclass
1283 && TYPE_BASECLASS_NAME (type, i) != NULL
1284 && (strcmp_iw (name,
1285 TYPE_BASECLASS_NAME (type,
1288 if (BASETYPE_VIA_VIRTUAL (type, i))
1291 struct value *v2 = allocate_value (basetype);
1293 boffset = baseclass_offset (type, i,
1294 value_contents (arg1) + offset,
1295 VALUE_ADDRESS (arg1)
1296 + value_offset (arg1) + offset);
1298 error (_("virtual baseclass botch"));
1300 /* The virtual base class pointer might have been clobbered
1301 by the user program. Make sure that it still points to a
1302 valid memory location. */
1305 if (boffset < 0 || boffset >= TYPE_LENGTH (type))
1307 CORE_ADDR base_addr;
1310 VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
1311 if (target_read_memory (base_addr,
1312 value_contents_raw (v2),
1313 TYPE_LENGTH (basetype)) != 0)
1314 error (_("virtual baseclass botch"));
1315 VALUE_LVAL (v2) = lval_memory;
1316 VALUE_ADDRESS (v2) = base_addr;
1320 VALUE_LVAL (v2) = VALUE_LVAL (arg1);
1321 VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
1322 VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
1323 set_value_offset (v2, value_offset (arg1) + boffset);
1324 if (value_lazy (arg1))
1325 set_value_lazy (v2, 1);
1327 memcpy (value_contents_raw (v2),
1328 value_contents_raw (arg1) + boffset,
1329 TYPE_LENGTH (basetype));
1332 if (found_baseclass)
1334 v = search_struct_field (name, v2, 0,
1335 TYPE_BASECLASS (type, i),
1336 looking_for_baseclass);
1338 else if (found_baseclass)
1339 v = value_primitive_field (arg1, offset, i, type);
1341 v = search_struct_field (name, arg1,
1342 offset + TYPE_BASECLASS_BITPOS (type,
1344 basetype, looking_for_baseclass);
1352 /* Return the offset (in bytes) of the virtual base of type BASETYPE
1353 * in an object pointed to by VALADDR (on the host), assumed to be of
1354 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
1355 * looking (in case VALADDR is the contents of an enclosing object).
1357 * This routine recurses on the primary base of the derived class
1358 * because the virtual base entries of the primary base appear before
1359 * the other virtual base entries.
1361 * If the virtual base is not found, a negative integer is returned.
1362 * The magnitude of the negative integer is the number of entries in
1363 * the virtual table to skip over (entries corresponding to various
1364 * ancestral classes in the chain of primary bases).
1366 * Important: This assumes the HP / Taligent C++ runtime conventions.
1367 * Use baseclass_offset() instead to deal with g++ conventions. */
1370 find_rt_vbase_offset (struct type *type, struct type *basetype,
1371 const gdb_byte *valaddr, int offset,
1372 int *boffset_p, int *skip_p)
1374 int boffset; /* Offset of virtual base. */
1375 int index; /* Displacement to use in virtual
1380 CORE_ADDR vtbl; /* The virtual table pointer. */
1381 struct type *pbc; /* The primary base class. */
1383 /* Look for the virtual base recursively in the primary base, first.
1384 * This is because the derived class object and its primary base
1385 * subobject share the primary virtual table. */
1388 pbc = TYPE_PRIMARY_BASE (type);
1391 find_rt_vbase_offset (pbc, basetype, valaddr,
1392 offset, &boffset, &skip);
1395 *boffset_p = boffset;
1404 /* Find the index of the virtual base according to HP/Taligent
1405 runtime spec. (Depth-first, left-to-right.) */
1406 index = virtual_base_index_skip_primaries (basetype, type);
1410 *skip_p = skip + virtual_base_list_length_skip_primaries (type);
1415 /* pai: FIXME -- 32x64 possible problem. */
1416 /* First word (4 bytes) in object layout is the vtable pointer. */
1417 vtbl = *(CORE_ADDR *) (valaddr + offset);
1419 /* Before the constructor is invoked, things are usually zero'd
1422 error (_("Couldn't find virtual table -- object may not be constructed yet."));
1425 /* Find virtual base's offset -- jump over entries for primary base
1426 * ancestors, then use the index computed above. But also adjust by
1427 * HP_ACC_VBASE_START for the vtable slots before the start of the
1428 * virtual base entries. Offset is negative -- virtual base entries
1429 * appear _before_ the address point of the virtual table. */
1431 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
1434 /* epstein : FIXME -- added param for overlay section. May not be
1436 vp = value_at (builtin_type_int,
1437 vtbl + 4 * (-skip - index - HP_ACC_VBASE_START));
1438 boffset = value_as_long (vp);
1440 *boffset_p = boffset;
1445 /* Helper function used by value_struct_elt to recurse through
1446 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1447 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1450 If found, return value, else if name matched and args not return
1451 (value) -1, else return NULL. */
1453 static struct value *
1454 search_struct_method (char *name, struct value **arg1p,
1455 struct value **args, int offset,
1456 int *static_memfuncp, struct type *type)
1460 int name_matched = 0;
1461 char dem_opname[64];
1463 CHECK_TYPEDEF (type);
1464 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1466 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1467 /* FIXME! May need to check for ARM demangling here */
1468 if (strncmp (t_field_name, "__", 2) == 0 ||
1469 strncmp (t_field_name, "op", 2) == 0 ||
1470 strncmp (t_field_name, "type", 4) == 0)
1472 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
1473 t_field_name = dem_opname;
1474 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
1475 t_field_name = dem_opname;
1477 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1479 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1480 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1483 check_stub_method_group (type, i);
1484 if (j > 0 && args == 0)
1485 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
1486 else if (j == 0 && args == 0)
1488 v = value_fn_field (arg1p, f, j, type, offset);
1495 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1496 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
1497 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
1498 TYPE_FN_FIELD_ARGS (f, j), args))
1500 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1501 return value_virtual_fn_field (arg1p, f, j,
1503 if (TYPE_FN_FIELD_STATIC_P (f, j)
1505 *static_memfuncp = 1;
1506 v = value_fn_field (arg1p, f, j, type, offset);
1515 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1519 if (BASETYPE_VIA_VIRTUAL (type, i))
1521 if (TYPE_HAS_VTABLE (type))
1523 /* HP aCC compiled type, search for virtual base offset
1524 according to HP/Taligent runtime spec. */
1526 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
1527 value_contents_all (*arg1p),
1528 offset + value_embedded_offset (*arg1p),
1529 &base_offset, &skip);
1531 error (_("Virtual base class offset not found in vtable"));
1535 struct type *baseclass =
1536 check_typedef (TYPE_BASECLASS (type, i));
1537 const gdb_byte *base_valaddr;
1539 /* The virtual base class pointer might have been
1540 clobbered by the user program. Make sure that it
1541 still points to a valid memory location. */
1543 if (offset < 0 || offset >= TYPE_LENGTH (type))
1545 gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
1546 if (target_read_memory (VALUE_ADDRESS (*arg1p)
1547 + value_offset (*arg1p) + offset,
1548 tmp, TYPE_LENGTH (baseclass)) != 0)
1549 error (_("virtual baseclass botch"));
1553 base_valaddr = value_contents (*arg1p) + offset;
1556 baseclass_offset (type, i, base_valaddr,
1557 VALUE_ADDRESS (*arg1p)
1558 + value_offset (*arg1p) + offset);
1559 if (base_offset == -1)
1560 error (_("virtual baseclass botch"));
1565 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1567 v = search_struct_method (name, arg1p, args, base_offset + offset,
1568 static_memfuncp, TYPE_BASECLASS (type, i));
1569 if (v == (struct value *) - 1)
1575 /* FIXME-bothner: Why is this commented out? Why is it here? */
1576 /* *arg1p = arg1_tmp; */
1581 return (struct value *) - 1;
1586 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1587 extract the component named NAME from the ultimate target
1588 structure/union and return it as a value with its appropriate type.
1589 ERR is used in the error message if *ARGP's type is wrong.
1591 C++: ARGS is a list of argument types to aid in the selection of
1592 an appropriate method. Also, handle derived types.
1594 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1595 where the truthvalue of whether the function that was resolved was
1596 a static member function or not is stored.
1598 ERR is an error message to be printed in case the field is not
1602 value_struct_elt (struct value **argp, struct value **args,
1603 char *name, int *static_memfuncp, char *err)
1608 *argp = coerce_array (*argp);
1610 t = check_typedef (value_type (*argp));
1612 /* Follow pointers until we get to a non-pointer. */
1614 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1616 *argp = value_ind (*argp);
1617 /* Don't coerce fn pointer to fn and then back again! */
1618 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
1619 *argp = coerce_array (*argp);
1620 t = check_typedef (value_type (*argp));
1623 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1624 && TYPE_CODE (t) != TYPE_CODE_UNION)
1625 error (_("Attempt to extract a component of a value that is not a %s."), err);
1627 /* Assume it's not, unless we see that it is. */
1628 if (static_memfuncp)
1629 *static_memfuncp = 0;
1633 /* if there are no arguments ...do this... */
1635 /* Try as a field first, because if we succeed, there is less
1637 v = search_struct_field (name, *argp, 0, t, 0);
1641 /* C++: If it was not found as a data field, then try to
1642 return it as a pointer to a method. */
1644 if (destructor_name_p (name, t))
1645 error (_("Cannot get value of destructor"));
1647 v = search_struct_method (name, argp, args, 0,
1648 static_memfuncp, t);
1650 if (v == (struct value *) - 1)
1651 error (_("Cannot take address of method %s."), name);
1654 if (TYPE_NFN_FIELDS (t))
1655 error (_("There is no member or method named %s."), name);
1657 error (_("There is no member named %s."), name);
1662 if (destructor_name_p (name, t))
1666 /* Destructors are a special case. */
1667 int m_index, f_index;
1670 if (get_destructor_fn_field (t, &m_index, &f_index))
1672 v = value_fn_field (NULL,
1673 TYPE_FN_FIELDLIST1 (t, m_index),
1677 error (_("could not find destructor function named %s."),
1684 error (_("destructor should not have any argument"));
1688 v = search_struct_method (name, argp, args, 0,
1689 static_memfuncp, t);
1691 if (v == (struct value *) - 1)
1693 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
1697 /* See if user tried to invoke data as function. If so, hand it
1698 back. If it's not callable (i.e., a pointer to function),
1699 gdb should give an error. */
1700 v = search_struct_field (name, *argp, 0, t, 0);
1704 error (_("Structure has no component named %s."), name);
1708 /* Search through the methods of an object (and its bases) to find a
1709 specified method. Return the pointer to the fn_field list of
1710 overloaded instances.
1712 Helper function for value_find_oload_list.
1713 ARGP is a pointer to a pointer to a value (the object).
1714 METHOD is a string containing the method name.
1715 OFFSET is the offset within the value.
1716 TYPE is the assumed type of the object.
1717 NUM_FNS is the number of overloaded instances.
1718 BASETYPE is set to the actual type of the subobject where the
1720 BOFFSET is the offset of the base subobject where the method is found.
1723 static struct fn_field *
1724 find_method_list (struct value **argp, char *method,
1725 int offset, struct type *type, int *num_fns,
1726 struct type **basetype, int *boffset)
1730 CHECK_TYPEDEF (type);
1734 /* First check in object itself. */
1735 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1737 /* pai: FIXME What about operators and type conversions? */
1738 char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1739 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
1741 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
1742 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1748 /* Resolve any stub methods. */
1749 check_stub_method_group (type, i);
1755 /* Not found in object, check in base subobjects. */
1756 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1759 if (BASETYPE_VIA_VIRTUAL (type, i))
1761 if (TYPE_HAS_VTABLE (type))
1763 /* HP aCC compiled type, search for virtual base offset
1764 * according to HP/Taligent runtime spec. */
1766 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
1767 value_contents_all (*argp),
1768 offset + value_embedded_offset (*argp),
1769 &base_offset, &skip);
1771 error (_("Virtual base class offset not found in vtable"));
1775 /* probably g++ runtime model */
1776 base_offset = value_offset (*argp) + offset;
1778 baseclass_offset (type, i,
1779 value_contents (*argp) + base_offset,
1780 VALUE_ADDRESS (*argp) + base_offset);
1781 if (base_offset == -1)
1782 error (_("virtual baseclass botch"));
1785 else /* Non-virtual base, simply use bit position from debug
1788 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1790 f = find_method_list (argp, method, base_offset + offset,
1791 TYPE_BASECLASS (type, i), num_fns,
1799 /* Return the list of overloaded methods of a specified name.
1801 ARGP is a pointer to a pointer to a value (the object).
1802 METHOD is the method name.
1803 OFFSET is the offset within the value contents.
1804 NUM_FNS is the number of overloaded instances.
1805 BASETYPE is set to the type of the base subobject that defines the
1807 BOFFSET is the offset of the base subobject which defines the method.
1811 value_find_oload_method_list (struct value **argp, char *method,
1812 int offset, int *num_fns,
1813 struct type **basetype, int *boffset)
1817 t = check_typedef (value_type (*argp));
1819 /* Code snarfed from value_struct_elt. */
1820 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1822 *argp = value_ind (*argp);
1823 /* Don't coerce fn pointer to fn and then back again! */
1824 if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
1825 *argp = coerce_array (*argp);
1826 t = check_typedef (value_type (*argp));
1829 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1830 && TYPE_CODE (t) != TYPE_CODE_UNION)
1831 error (_("Attempt to extract a component of a value that is not a struct or union"));
1833 return find_method_list (argp, method, 0, t, num_fns,
1837 /* Given an array of argument types (ARGTYPES) (which includes an
1838 entry for "this" in the case of C++ methods), the number of
1839 arguments NARGS, the NAME of a function whether it's a method or
1840 not (METHOD), and the degree of laxness (LAX) in conforming to
1841 overload resolution rules in ANSI C++, find the best function that
1842 matches on the argument types according to the overload resolution
1845 In the case of class methods, the parameter OBJ is an object value
1846 in which to search for overloaded methods.
1848 In the case of non-method functions, the parameter FSYM is a symbol
1849 corresponding to one of the overloaded functions.
1851 Return value is an integer: 0 -> good match, 10 -> debugger applied
1852 non-standard coercions, 100 -> incompatible.
1854 If a method is being searched for, VALP will hold the value.
1855 If a non-method is being searched for, SYMP will hold the symbol
1858 If a method is being searched for, and it is a static method,
1859 then STATICP will point to a non-zero value.
1861 Note: This function does *not* check the value of
1862 overload_resolution. Caller must check it to see whether overload
1863 resolution is permitted.
1867 find_overload_match (struct type **arg_types, int nargs,
1868 char *name, int method, int lax,
1869 struct value **objp, struct symbol *fsym,
1870 struct value **valp, struct symbol **symp,
1873 struct value *obj = (objp ? *objp : NULL);
1874 /* Index of best overloaded function. */
1876 /* The measure for the current best match. */
1877 struct badness_vector *oload_champ_bv = NULL;
1878 struct value *temp = obj;
1879 /* For methods, the list of overloaded methods. */
1880 struct fn_field *fns_ptr = NULL;
1881 /* For non-methods, the list of overloaded function symbols. */
1882 struct symbol **oload_syms = NULL;
1883 /* Number of overloaded instances being considered. */
1885 struct type *basetype = NULL;
1889 struct cleanup *old_cleanups = NULL;
1891 const char *obj_type_name = NULL;
1892 char *func_name = NULL;
1893 enum oload_classification match_quality;
1895 /* Get the list of overloaded methods or functions. */
1898 obj_type_name = TYPE_NAME (value_type (obj));
1899 /* Hack: evaluate_subexp_standard often passes in a pointer
1900 value rather than the object itself, so try again. */
1901 if ((!obj_type_name || !*obj_type_name)
1902 && (TYPE_CODE (value_type (obj)) == TYPE_CODE_PTR))
1903 obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj)));
1905 fns_ptr = value_find_oload_method_list (&temp, name,
1907 &basetype, &boffset);
1908 if (!fns_ptr || !num_fns)
1909 error (_("Couldn't find method %s%s%s"),
1911 (obj_type_name && *obj_type_name) ? "::" : "",
1913 /* If we are dealing with stub method types, they should have
1914 been resolved by find_method_list via
1915 value_find_oload_method_list above. */
1916 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
1917 oload_champ = find_oload_champ (arg_types, nargs, method,
1919 oload_syms, &oload_champ_bv);
1923 const char *qualified_name = SYMBOL_CPLUS_DEMANGLED_NAME (fsym);
1925 /* If we have a C++ name, try to extract just the function
1928 func_name = cp_func_name (qualified_name);
1930 /* If there was no C++ name, this must be a C-style function.
1931 Just return the same symbol. Do the same if cp_func_name
1932 fails for some reason. */
1933 if (func_name == NULL)
1939 old_cleanups = make_cleanup (xfree, func_name);
1940 make_cleanup (xfree, oload_syms);
1941 make_cleanup (xfree, oload_champ_bv);
1943 oload_champ = find_oload_champ_namespace (arg_types, nargs,
1950 /* Check how bad the best match is. */
1953 classify_oload_match (oload_champ_bv, nargs,
1954 oload_method_static (method, fns_ptr,
1957 if (match_quality == INCOMPATIBLE)
1960 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
1962 (obj_type_name && *obj_type_name) ? "::" : "",
1965 error (_("Cannot resolve function %s to any overloaded instance"),
1968 else if (match_quality == NON_STANDARD)
1971 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
1973 (obj_type_name && *obj_type_name) ? "::" : "",
1976 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
1982 if (staticp != NULL)
1983 *staticp = oload_method_static (method, fns_ptr, oload_champ);
1984 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
1985 *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ,
1988 *valp = value_fn_field (&temp, fns_ptr, oload_champ,
1993 *symp = oload_syms[oload_champ];
1998 if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
1999 && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR)
2001 temp = value_addr (temp);
2005 if (old_cleanups != NULL)
2006 do_cleanups (old_cleanups);
2008 switch (match_quality)
2014 default: /* STANDARD */
2019 /* Find the best overload match, searching for FUNC_NAME in namespaces
2020 contained in QUALIFIED_NAME until it either finds a good match or
2021 runs out of namespaces. It stores the overloaded functions in
2022 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2023 calling function is responsible for freeing *OLOAD_SYMS and
2027 find_oload_champ_namespace (struct type **arg_types, int nargs,
2028 const char *func_name,
2029 const char *qualified_name,
2030 struct symbol ***oload_syms,
2031 struct badness_vector **oload_champ_bv)
2035 find_oload_champ_namespace_loop (arg_types, nargs,
2038 oload_syms, oload_champ_bv,
2044 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2045 how deep we've looked for namespaces, and the champ is stored in
2046 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2049 It is the caller's responsibility to free *OLOAD_SYMS and
2053 find_oload_champ_namespace_loop (struct type **arg_types, int nargs,
2054 const char *func_name,
2055 const char *qualified_name,
2057 struct symbol ***oload_syms,
2058 struct badness_vector **oload_champ_bv,
2061 int next_namespace_len = namespace_len;
2062 int searched_deeper = 0;
2064 struct cleanup *old_cleanups;
2065 int new_oload_champ;
2066 struct symbol **new_oload_syms;
2067 struct badness_vector *new_oload_champ_bv;
2068 char *new_namespace;
2070 if (next_namespace_len != 0)
2072 gdb_assert (qualified_name[next_namespace_len] == ':');
2073 next_namespace_len += 2;
2075 next_namespace_len +=
2076 cp_find_first_component (qualified_name + next_namespace_len);
2078 /* Initialize these to values that can safely be xfree'd. */
2080 *oload_champ_bv = NULL;
2082 /* First, see if we have a deeper namespace we can search in.
2083 If we get a good match there, use it. */
2085 if (qualified_name[next_namespace_len] == ':')
2087 searched_deeper = 1;
2089 if (find_oload_champ_namespace_loop (arg_types, nargs,
2090 func_name, qualified_name,
2092 oload_syms, oload_champ_bv,
2099 /* If we reach here, either we're in the deepest namespace or we
2100 didn't find a good match in a deeper namespace. But, in the
2101 latter case, we still have a bad match in a deeper namespace;
2102 note that we might not find any match at all in the current
2103 namespace. (There's always a match in the deepest namespace,
2104 because this overload mechanism only gets called if there's a
2105 function symbol to start off with.) */
2107 old_cleanups = make_cleanup (xfree, *oload_syms);
2108 old_cleanups = make_cleanup (xfree, *oload_champ_bv);
2109 new_namespace = alloca (namespace_len + 1);
2110 strncpy (new_namespace, qualified_name, namespace_len);
2111 new_namespace[namespace_len] = '\0';
2112 new_oload_syms = make_symbol_overload_list (func_name,
2114 while (new_oload_syms[num_fns])
2117 new_oload_champ = find_oload_champ (arg_types, nargs, 0, num_fns,
2118 NULL, new_oload_syms,
2119 &new_oload_champ_bv);
2121 /* Case 1: We found a good match. Free earlier matches (if any),
2122 and return it. Case 2: We didn't find a good match, but we're
2123 not the deepest function. Then go with the bad match that the
2124 deeper function found. Case 3: We found a bad match, and we're
2125 the deepest function. Then return what we found, even though
2126 it's a bad match. */
2128 if (new_oload_champ != -1
2129 && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2131 *oload_syms = new_oload_syms;
2132 *oload_champ = new_oload_champ;
2133 *oload_champ_bv = new_oload_champ_bv;
2134 do_cleanups (old_cleanups);
2137 else if (searched_deeper)
2139 xfree (new_oload_syms);
2140 xfree (new_oload_champ_bv);
2141 discard_cleanups (old_cleanups);
2146 gdb_assert (new_oload_champ != -1);
2147 *oload_syms = new_oload_syms;
2148 *oload_champ = new_oload_champ;
2149 *oload_champ_bv = new_oload_champ_bv;
2150 discard_cleanups (old_cleanups);
2155 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2156 the best match from among the overloaded methods or functions
2157 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2158 The number of methods/functions in the list is given by NUM_FNS.
2159 Return the index of the best match; store an indication of the
2160 quality of the match in OLOAD_CHAMP_BV.
2162 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2165 find_oload_champ (struct type **arg_types, int nargs, int method,
2166 int num_fns, struct fn_field *fns_ptr,
2167 struct symbol **oload_syms,
2168 struct badness_vector **oload_champ_bv)
2171 /* A measure of how good an overloaded instance is. */
2172 struct badness_vector *bv;
2173 /* Index of best overloaded function. */
2174 int oload_champ = -1;
2175 /* Current ambiguity state for overload resolution. */
2176 int oload_ambiguous = 0;
2177 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2179 *oload_champ_bv = NULL;
2181 /* Consider each candidate in turn. */
2182 for (ix = 0; ix < num_fns; ix++)
2185 int static_offset = oload_method_static (method, fns_ptr, ix);
2187 struct type **parm_types;
2191 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2195 /* If it's not a method, this is the proper place. */
2196 nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2199 /* Prepare array of parameter types. */
2200 parm_types = (struct type **)
2201 xmalloc (nparms * (sizeof (struct type *)));
2202 for (jj = 0; jj < nparms; jj++)
2203 parm_types[jj] = (method
2204 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2205 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
2208 /* Compare parameter types to supplied argument types. Skip
2209 THIS for static methods. */
2210 bv = rank_function (parm_types, nparms,
2211 arg_types + static_offset,
2212 nargs - static_offset);
2214 if (!*oload_champ_bv)
2216 *oload_champ_bv = bv;
2219 else /* See whether current candidate is better or worse than
2221 switch (compare_badness (bv, *oload_champ_bv))
2223 case 0: /* Top two contenders are equally good. */
2224 oload_ambiguous = 1;
2226 case 1: /* Incomparable top contenders. */
2227 oload_ambiguous = 2;
2229 case 2: /* New champion, record details. */
2230 *oload_champ_bv = bv;
2231 oload_ambiguous = 0;
2242 fprintf_filtered (gdb_stderr,
2243 "Overloaded method instance %s, # of parms %d\n",
2244 fns_ptr[ix].physname, nparms);
2246 fprintf_filtered (gdb_stderr,
2247 "Overloaded function instance %s # of parms %d\n",
2248 SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
2250 for (jj = 0; jj < nargs - static_offset; jj++)
2251 fprintf_filtered (gdb_stderr,
2252 "...Badness @ %d : %d\n",
2254 fprintf_filtered (gdb_stderr,
2255 "Overload resolution champion is %d, ambiguous? %d\n",
2256 oload_champ, oload_ambiguous);
2263 /* Return 1 if we're looking at a static method, 0 if we're looking at
2264 a non-static method or a function that isn't a method. */
2267 oload_method_static (int method, struct fn_field *fns_ptr, int index)
2269 if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
2275 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2277 static enum oload_classification
2278 classify_oload_match (struct badness_vector *oload_champ_bv,
2284 for (ix = 1; ix <= nargs - static_offset; ix++)
2286 if (oload_champ_bv->rank[ix] >= 100)
2287 return INCOMPATIBLE; /* Truly mismatched types. */
2288 else if (oload_champ_bv->rank[ix] >= 10)
2289 return NON_STANDARD; /* Non-standard type conversions
2293 return STANDARD; /* Only standard conversions needed. */
2296 /* C++: return 1 is NAME is a legitimate name for the destructor of
2297 type TYPE. If TYPE does not have a destructor, or if NAME is
2298 inappropriate for TYPE, an error is signaled. */
2300 destructor_name_p (const char *name, const struct type *type)
2302 /* Destructors are a special case. */
2306 char *dname = type_name_no_tag (type);
2307 char *cp = strchr (dname, '<');
2310 /* Do not compare the template part for template classes. */
2312 len = strlen (dname);
2315 if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
2316 error (_("name of destructor must equal name of class"));
2323 /* Helper function for check_field: Given TYPE, a structure/union,
2324 return 1 if the component named NAME from the ultimate target
2325 structure/union is defined, otherwise, return 0. */
2328 check_field_in (struct type *type, const char *name)
2332 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2334 char *t_field_name = TYPE_FIELD_NAME (type, i);
2335 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2339 /* C++: If it was not found as a data field, then try to return it
2340 as a pointer to a method. */
2342 /* Destructors are a special case. */
2343 if (destructor_name_p (name, type))
2345 int m_index, f_index;
2347 return get_destructor_fn_field (type, &m_index, &f_index);
2350 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2352 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2356 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2357 if (check_field_in (TYPE_BASECLASS (type, i), name))
2364 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2365 return 1 if the component named NAME from the ultimate target
2366 structure/union is defined, otherwise, return 0. */
2369 check_field (struct value *arg1, const char *name)
2373 arg1 = coerce_array (arg1);
2375 t = value_type (arg1);
2377 /* Follow pointers until we get to a non-pointer. */
2382 if (TYPE_CODE (t) != TYPE_CODE_PTR
2383 && TYPE_CODE (t) != TYPE_CODE_REF)
2385 t = TYPE_TARGET_TYPE (t);
2388 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2389 && TYPE_CODE (t) != TYPE_CODE_UNION)
2390 error (_("Internal error: `this' is not an aggregate"));
2392 return check_field_in (t, name);
2395 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2396 return the appropriate member (or the address of the member, if
2397 WANT_ADDRESS). This function is used to resolve user expressions
2398 of the form "DOMAIN::NAME". For more details on what happens, see
2399 the comment before value_struct_elt_for_reference. */
2402 value_aggregate_elt (struct type *curtype,
2403 char *name, int want_address,
2406 switch (TYPE_CODE (curtype))
2408 case TYPE_CODE_STRUCT:
2409 case TYPE_CODE_UNION:
2410 return value_struct_elt_for_reference (curtype, 0, curtype,
2412 want_address, noside);
2413 case TYPE_CODE_NAMESPACE:
2414 return value_namespace_elt (curtype, name,
2415 want_address, noside);
2417 internal_error (__FILE__, __LINE__,
2418 _("non-aggregate type in value_aggregate_elt"));
2422 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2423 return the address of this member as a "pointer to member" type.
2424 If INTYPE is non-null, then it will be the type of the member we
2425 are looking for. This will help us resolve "pointers to member
2426 functions". This function is used to resolve user expressions of
2427 the form "DOMAIN::NAME". */
2429 static struct value *
2430 value_struct_elt_for_reference (struct type *domain, int offset,
2431 struct type *curtype, char *name,
2432 struct type *intype,
2436 struct type *t = curtype;
2438 struct value *v, *result;
2440 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2441 && TYPE_CODE (t) != TYPE_CODE_UNION)
2442 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2444 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2446 char *t_field_name = TYPE_FIELD_NAME (t, i);
2448 if (t_field_name && strcmp (t_field_name, name) == 0)
2450 if (TYPE_FIELD_STATIC (t, i))
2452 v = value_static_field (t, i);
2454 error (_("static field %s has been optimized out"),
2460 if (TYPE_FIELD_PACKED (t, i))
2461 error (_("pointers to bitfield members not allowed"));
2464 return value_from_longest
2465 (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
2466 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2467 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2468 return allocate_value (TYPE_FIELD_TYPE (t, i));
2470 error (_("Cannot reference non-static field \"%s\""), name);
2474 /* C++: If it was not found as a data field, then try to return it
2475 as a pointer to a method. */
2477 /* Destructors are a special case. */
2478 if (destructor_name_p (name, t))
2480 error (_("member pointers to destructors not implemented yet"));
2483 /* Perform all necessary dereferencing. */
2484 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2485 intype = TYPE_TARGET_TYPE (intype);
2487 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2489 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2490 char dem_opname[64];
2492 if (strncmp (t_field_name, "__", 2) == 0
2493 || strncmp (t_field_name, "op", 2) == 0
2494 || strncmp (t_field_name, "type", 4) == 0)
2496 if (cplus_demangle_opname (t_field_name,
2497 dem_opname, DMGL_ANSI))
2498 t_field_name = dem_opname;
2499 else if (cplus_demangle_opname (t_field_name,
2501 t_field_name = dem_opname;
2503 if (t_field_name && strcmp (t_field_name, name) == 0)
2505 int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2506 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2508 check_stub_method_group (t, i);
2510 if (intype == 0 && j > 1)
2511 error (_("non-unique member `%s' requires type instantiation"), name);
2515 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2518 error (_("no member function matches that type instantiation"));
2523 if (TYPE_FN_FIELD_STATIC_P (f, j))
2526 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2527 0, VAR_DOMAIN, 0, NULL);
2532 return value_addr (read_var_value (s, 0));
2534 return read_var_value (s, 0);
2537 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2541 result = allocate_value
2542 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
2543 cplus_make_method_ptr (value_contents_writeable (result),
2544 TYPE_FN_FIELD_VOFFSET (f, j), 1);
2546 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2547 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
2549 error (_("Cannot reference virtual member function \"%s\""),
2555 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2556 0, VAR_DOMAIN, 0, NULL);
2560 v = read_var_value (s, 0);
2565 result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
2566 cplus_make_method_ptr (value_contents_writeable (result),
2567 VALUE_ADDRESS (v), 0);
2573 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2578 if (BASETYPE_VIA_VIRTUAL (t, i))
2581 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2582 v = value_struct_elt_for_reference (domain,
2583 offset + base_offset,
2584 TYPE_BASECLASS (t, i),
2586 want_address, noside);
2591 /* As a last chance, pretend that CURTYPE is a namespace, and look
2592 it up that way; this (frequently) works for types nested inside
2595 return value_maybe_namespace_elt (curtype, name,
2596 want_address, noside);
2599 /* C++: Return the member NAME of the namespace given by the type
2602 static struct value *
2603 value_namespace_elt (const struct type *curtype,
2604 char *name, int want_address,
2607 struct value *retval = value_maybe_namespace_elt (curtype, name,
2612 error (_("No symbol \"%s\" in namespace \"%s\"."),
2613 name, TYPE_TAG_NAME (curtype));
2618 /* A helper function used by value_namespace_elt and
2619 value_struct_elt_for_reference. It looks up NAME inside the
2620 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
2621 is a class and NAME refers to a type in CURTYPE itself (as opposed
2622 to, say, some base class of CURTYPE). */
2624 static struct value *
2625 value_maybe_namespace_elt (const struct type *curtype,
2626 char *name, int want_address,
2629 const char *namespace_name = TYPE_TAG_NAME (curtype);
2631 struct value *result;
2633 sym = cp_lookup_symbol_namespace (namespace_name, name, NULL,
2634 get_selected_block (0),
2639 else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
2640 && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
2641 result = allocate_value (SYMBOL_TYPE (sym));
2643 result = value_of_variable (sym, get_selected_block (0));
2645 if (result && want_address)
2646 result = value_addr (result);
2651 /* Given a pointer value V, find the real (RTTI) type of the object it
2654 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2655 and refer to the values computed for the object pointed to. */
2658 value_rtti_target_type (struct value *v, int *full,
2659 int *top, int *using_enc)
2661 struct value *target;
2663 target = value_ind (v);
2665 return value_rtti_type (target, full, top, using_enc);
2668 /* Given a value pointed to by ARGP, check its real run-time type, and
2669 if that is different from the enclosing type, create a new value
2670 using the real run-time type as the enclosing type (and of the same
2671 type as ARGP) and return it, with the embedded offset adjusted to
2672 be the correct offset to the enclosed object. RTYPE is the type,
2673 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
2674 by value_rtti_type(). If these are available, they can be supplied
2675 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
2676 NULL if they're not available. */
2679 value_full_object (struct value *argp,
2681 int xfull, int xtop,
2684 struct type *real_type;
2688 struct value *new_val;
2695 using_enc = xusing_enc;
2698 real_type = value_rtti_type (argp, &full, &top, &using_enc);
2700 /* If no RTTI data, or if object is already complete, do nothing. */
2701 if (!real_type || real_type == value_enclosing_type (argp))
2704 /* If we have the full object, but for some reason the enclosing
2705 type is wrong, set it. */
2706 /* pai: FIXME -- sounds iffy */
2709 argp = value_change_enclosing_type (argp, real_type);
2713 /* Check if object is in memory */
2714 if (VALUE_LVAL (argp) != lval_memory)
2716 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
2717 TYPE_NAME (real_type));
2722 /* All other cases -- retrieve the complete object. */
2723 /* Go back by the computed top_offset from the beginning of the
2724 object, adjusting for the embedded offset of argp if that's what
2725 value_rtti_type used for its computation. */
2726 new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
2727 (using_enc ? 0 : value_embedded_offset (argp)));
2728 deprecated_set_value_type (new_val, value_type (argp));
2729 set_value_embedded_offset (new_val, (using_enc
2730 ? top + value_embedded_offset (argp)
2736 /* Return the value of the local variable, if one exists.
2737 Flag COMPLAIN signals an error if the request is made in an
2738 inappropriate context. */
2741 value_of_local (const char *name, int complain)
2743 struct symbol *func, *sym;
2746 struct frame_info *frame;
2749 frame = get_selected_frame (_("no frame selected"));
2752 frame = deprecated_safe_get_selected_frame ();
2757 func = get_frame_function (frame);
2761 error (_("no `%s' in nameless context"), name);
2766 b = SYMBOL_BLOCK_VALUE (func);
2767 if (dict_empty (BLOCK_DICT (b)))
2770 error (_("no args, no `%s'"), name);
2775 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2776 symbol instead of the LOC_ARG one (if both exist). */
2777 sym = lookup_block_symbol (b, name, NULL, VAR_DOMAIN);
2781 error (_("current stack frame does not contain a variable named `%s'"),
2787 ret = read_var_value (sym, frame);
2788 if (ret == 0 && complain)
2789 error (_("`%s' argument unreadable"), name);
2793 /* C++/Objective-C: return the value of the class instance variable,
2794 if one exists. Flag COMPLAIN signals an error if the request is
2795 made in an inappropriate context. */
2798 value_of_this (int complain)
2800 if (current_language->la_language == language_objc)
2801 return value_of_local ("self", complain);
2803 return value_of_local ("this", complain);
2806 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
2807 elements long, starting at LOWBOUND. The result has the same lower
2808 bound as the original ARRAY. */
2811 value_slice (struct value *array, int lowbound, int length)
2813 struct type *slice_range_type, *slice_type, *range_type;
2814 LONGEST lowerbound, upperbound;
2815 struct value *slice;
2816 struct type *array_type;
2818 array_type = check_typedef (value_type (array));
2819 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
2820 && TYPE_CODE (array_type) != TYPE_CODE_STRING
2821 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
2822 error (_("cannot take slice of non-array"));
2824 range_type = TYPE_INDEX_TYPE (array_type);
2825 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
2826 error (_("slice from bad array or bitstring"));
2828 if (lowbound < lowerbound || length < 0
2829 || lowbound + length - 1 > upperbound)
2830 error (_("slice out of range"));
2832 /* FIXME-type-allocation: need a way to free this type when we are
2834 slice_range_type = create_range_type ((struct type *) NULL,
2835 TYPE_TARGET_TYPE (range_type),
2837 lowbound + length - 1);
2838 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
2842 slice_type = create_set_type ((struct type *) NULL,
2844 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
2845 slice = value_zero (slice_type, not_lval);
2847 for (i = 0; i < length; i++)
2849 int element = value_bit_index (array_type,
2850 value_contents (array),
2853 error (_("internal error accessing bitstring"));
2854 else if (element > 0)
2856 int j = i % TARGET_CHAR_BIT;
2857 if (BITS_BIG_ENDIAN)
2858 j = TARGET_CHAR_BIT - 1 - j;
2859 value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
2862 /* We should set the address, bitssize, and bitspos, so the
2863 slice can be used on the LHS, but that may require extensions
2864 to value_assign. For now, just leave as a non_lval.
2869 struct type *element_type = TYPE_TARGET_TYPE (array_type);
2871 (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
2873 slice_type = create_array_type ((struct type *) NULL,
2876 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
2878 slice = allocate_value (slice_type);
2879 if (value_lazy (array))
2880 set_value_lazy (slice, 1);
2882 memcpy (value_contents_writeable (slice),
2883 value_contents (array) + offset,
2884 TYPE_LENGTH (slice_type));
2886 if (VALUE_LVAL (array) == lval_internalvar)
2887 VALUE_LVAL (slice) = lval_internalvar_component;
2889 VALUE_LVAL (slice) = VALUE_LVAL (array);
2891 VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2892 VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
2893 set_value_offset (slice, value_offset (array) + offset);
2898 /* Create a value for a FORTRAN complex number. Currently most of the
2899 time values are coerced to COMPLEX*16 (i.e. a complex number
2900 composed of 2 doubles. This really should be a smarter routine
2901 that figures out precision inteligently as opposed to assuming
2902 doubles. FIXME: fmb */
2905 value_literal_complex (struct value *arg1,
2910 struct type *real_type = TYPE_TARGET_TYPE (type);
2912 val = allocate_value (type);
2913 arg1 = value_cast (real_type, arg1);
2914 arg2 = value_cast (real_type, arg2);
2916 memcpy (value_contents_raw (val),
2917 value_contents (arg1), TYPE_LENGTH (real_type));
2918 memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
2919 value_contents (arg2), TYPE_LENGTH (real_type));
2923 /* Cast a value into the appropriate complex data type. */
2925 static struct value *
2926 cast_into_complex (struct type *type, struct value *val)
2928 struct type *real_type = TYPE_TARGET_TYPE (type);
2930 if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
2932 struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
2933 struct value *re_val = allocate_value (val_real_type);
2934 struct value *im_val = allocate_value (val_real_type);
2936 memcpy (value_contents_raw (re_val),
2937 value_contents (val), TYPE_LENGTH (val_real_type));
2938 memcpy (value_contents_raw (im_val),
2939 value_contents (val) + TYPE_LENGTH (val_real_type),
2940 TYPE_LENGTH (val_real_type));
2942 return value_literal_complex (re_val, im_val, type);
2944 else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
2945 || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
2946 return value_literal_complex (val,
2947 value_zero (real_type, not_lval),
2950 error (_("cannot cast non-number to complex"));
2954 _initialize_valops (void)
2956 add_setshow_boolean_cmd ("overload-resolution", class_support,
2957 &overload_resolution, _("\
2958 Set overload resolution in evaluating C++ functions."), _("\
2959 Show overload resolution in evaluating C++ functions."),
2961 show_overload_resolution,
2962 &setlist, &showlist);
2963 overload_resolution = 1;