1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
3 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
40 #include "gdb_string.h"
41 #include "gdb_assert.h"
43 /* Flag indicating HP compilers were used; needed to correctly handle some
44 value operations with HP aCC code/runtime. */
45 extern int hp_som_som_object_present;
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 CORE_ADDR value_push (CORE_ADDR, struct value *);
55 static struct value *search_struct_field (char *, struct value *, int,
58 static struct value *search_struct_method (char *, struct value **,
60 int, int *, struct type *);
62 static int check_field_in (struct type *, const char *);
64 static CORE_ADDR allocate_space_in_inferior (int);
66 static struct value *cast_into_complex (struct type *, struct value *);
68 static struct fn_field *find_method_list (struct value ** argp, char *method,
70 struct type *type, int *num_fns,
71 struct type **basetype,
74 void _initialize_valops (void);
76 /* Flag for whether we want to abandon failed expression evals by default. */
79 static int auto_abandon = 0;
82 int overload_resolution = 0;
84 /* Find the address of function name NAME in the inferior. */
87 find_function_in_inferior (const char *name)
89 register struct symbol *sym;
90 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL);
93 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
95 error ("\"%s\" exists in this program but is not a function.",
98 return value_of_variable (sym, NULL);
102 struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL);
107 type = lookup_pointer_type (builtin_type_char);
108 type = lookup_function_type (type);
109 type = lookup_pointer_type (type);
110 maddr = SYMBOL_VALUE_ADDRESS (msymbol);
111 return value_from_pointer (type, maddr);
115 if (!target_has_execution)
116 error ("evaluation of this expression requires the target program to be active");
118 error ("evaluation of this expression requires the program to have a function \"%s\".", name);
123 /* Allocate NBYTES of space in the inferior using the inferior's malloc
124 and return a value that is a pointer to the allocated space. */
127 value_allocate_space_in_inferior (int len)
129 struct value *blocklen;
130 struct value *val = find_function_in_inferior (NAME_OF_MALLOC);
132 blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
133 val = call_function_by_hand (val, 1, &blocklen);
134 if (value_logical_not (val))
136 if (!target_has_execution)
137 error ("No memory available to program now: you need to start the target first");
139 error ("No memory available to program: call to malloc failed");
145 allocate_space_in_inferior (int len)
147 return value_as_long (value_allocate_space_in_inferior (len));
150 /* Cast value ARG2 to type TYPE and return as a value.
151 More general than a C cast: accepts any two types of the same length,
152 and if ARG2 is an lvalue it can be cast into anything at all. */
153 /* In C++, casts may change pointer or object representations. */
156 value_cast (struct type *type, struct value *arg2)
158 register enum type_code code1;
159 register enum type_code code2;
163 int convert_to_boolean = 0;
165 if (VALUE_TYPE (arg2) == type)
168 CHECK_TYPEDEF (type);
169 code1 = TYPE_CODE (type);
171 type2 = check_typedef (VALUE_TYPE (arg2));
173 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
174 is treated like a cast to (TYPE [N])OBJECT,
175 where N is sizeof(OBJECT)/sizeof(TYPE). */
176 if (code1 == TYPE_CODE_ARRAY)
178 struct type *element_type = TYPE_TARGET_TYPE (type);
179 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
180 if (element_length > 0
181 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
183 struct type *range_type = TYPE_INDEX_TYPE (type);
184 int val_length = TYPE_LENGTH (type2);
185 LONGEST low_bound, high_bound, new_length;
186 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
187 low_bound = 0, high_bound = 0;
188 new_length = val_length / element_length;
189 if (val_length % element_length != 0)
190 warning ("array element type size does not divide object size in cast");
191 /* FIXME-type-allocation: need a way to free this type when we are
193 range_type = create_range_type ((struct type *) NULL,
194 TYPE_TARGET_TYPE (range_type),
196 new_length + low_bound - 1);
197 VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
198 element_type, range_type);
203 if (current_language->c_style_arrays
204 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
205 arg2 = value_coerce_array (arg2);
207 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
208 arg2 = value_coerce_function (arg2);
210 type2 = check_typedef (VALUE_TYPE (arg2));
211 COERCE_VARYING_ARRAY (arg2, type2);
212 code2 = TYPE_CODE (type2);
214 if (code1 == TYPE_CODE_COMPLEX)
215 return cast_into_complex (type, arg2);
216 if (code1 == TYPE_CODE_BOOL)
218 code1 = TYPE_CODE_INT;
219 convert_to_boolean = 1;
221 if (code1 == TYPE_CODE_CHAR)
222 code1 = TYPE_CODE_INT;
223 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
224 code2 = TYPE_CODE_INT;
226 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
227 || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
229 if (code1 == TYPE_CODE_STRUCT
230 && code2 == TYPE_CODE_STRUCT
231 && TYPE_NAME (type) != 0)
233 /* Look in the type of the source to see if it contains the
234 type of the target as a superclass. If so, we'll need to
235 offset the object in addition to changing its type. */
236 struct value *v = search_struct_field (type_name_no_tag (type),
240 VALUE_TYPE (v) = type;
244 if (code1 == TYPE_CODE_FLT && scalar)
245 return value_from_double (type, value_as_double (arg2));
246 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
247 || code1 == TYPE_CODE_RANGE)
248 && (scalar || code2 == TYPE_CODE_PTR))
252 if (hp_som_som_object_present && /* if target compiled by HP aCC */
253 (code2 == TYPE_CODE_PTR))
256 struct value *retvalp;
258 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
260 /* With HP aCC, pointers to data members have a bias */
261 case TYPE_CODE_MEMBER:
262 retvalp = value_from_longest (type, value_as_long (arg2));
263 /* force evaluation */
264 ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
265 *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
268 /* While pointers to methods don't really point to a function */
269 case TYPE_CODE_METHOD:
270 error ("Pointers to methods not supported with HP aCC");
273 break; /* fall out and go to normal handling */
277 /* When we cast pointers to integers, we mustn't use
278 POINTER_TO_ADDRESS to find the address the pointer
279 represents, as value_as_long would. GDB should evaluate
280 expressions just as the compiler would --- and the compiler
281 sees a cast as a simple reinterpretation of the pointer's
283 if (code2 == TYPE_CODE_PTR)
284 longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
285 TYPE_LENGTH (type2));
287 longest = value_as_long (arg2);
288 return value_from_longest (type, convert_to_boolean ?
289 (LONGEST) (longest ? 1 : 0) : longest);
291 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT ||
292 code2 == TYPE_CODE_ENUM ||
293 code2 == TYPE_CODE_RANGE))
295 /* TYPE_LENGTH (type) is the length of a pointer, but we really
296 want the length of an address! -- we are really dealing with
297 addresses (i.e., gdb representations) not pointers (i.e.,
298 target representations) here.
300 This allows things like "print *(int *)0x01000234" to work
301 without printing a misleading message -- which would
302 otherwise occur when dealing with a target having two byte
303 pointers and four byte addresses. */
305 int addr_bit = TARGET_ADDR_BIT;
307 LONGEST longest = value_as_long (arg2);
308 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
310 if (longest >= ((LONGEST) 1 << addr_bit)
311 || longest <= -((LONGEST) 1 << addr_bit))
312 warning ("value truncated");
314 return value_from_longest (type, longest);
316 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
318 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
320 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
321 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
322 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
323 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
324 && !value_logical_not (arg2))
328 /* Look in the type of the source to see if it contains the
329 type of the target as a superclass. If so, we'll need to
330 offset the pointer rather than just change its type. */
331 if (TYPE_NAME (t1) != NULL)
333 v = search_struct_field (type_name_no_tag (t1),
334 value_ind (arg2), 0, t2, 1);
338 VALUE_TYPE (v) = type;
343 /* Look in the type of the target to see if it contains the
344 type of the source as a superclass. If so, we'll need to
345 offset the pointer rather than just change its type.
346 FIXME: This fails silently with virtual inheritance. */
347 if (TYPE_NAME (t2) != NULL)
349 v = search_struct_field (type_name_no_tag (t2),
350 value_zero (t1, not_lval), 0, t1, 1);
353 CORE_ADDR addr2 = value_as_address (arg2);
354 addr2 -= (VALUE_ADDRESS (v)
356 + VALUE_EMBEDDED_OFFSET (v));
357 return value_from_pointer (type, addr2);
361 /* No superclass found, just fall through to change ptr type. */
363 VALUE_TYPE (arg2) = type;
364 arg2 = value_change_enclosing_type (arg2, type);
365 VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */
368 else if (VALUE_LVAL (arg2) == lval_memory)
370 return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
371 VALUE_BFD_SECTION (arg2));
373 else if (code1 == TYPE_CODE_VOID)
375 return value_zero (builtin_type_void, not_lval);
379 error ("Invalid cast.");
384 /* Create a value of type TYPE that is zero, and return it. */
387 value_zero (struct type *type, enum lval_type lv)
389 struct value *val = allocate_value (type);
391 memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
392 VALUE_LVAL (val) = lv;
397 /* Return a value with type TYPE located at ADDR.
399 Call value_at only if the data needs to be fetched immediately;
400 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
401 value_at_lazy instead. value_at_lazy simply records the address of
402 the data and sets the lazy-evaluation-required flag. The lazy flag
403 is tested in the VALUE_CONTENTS macro, which is used if and when
404 the contents are actually required.
406 Note: value_at does *NOT* handle embedded offsets; perform such
407 adjustments before or after calling it. */
410 value_at (struct type *type, CORE_ADDR addr, asection *sect)
414 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
415 error ("Attempt to dereference a generic pointer.");
417 val = allocate_value (type);
419 read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
421 VALUE_LVAL (val) = lval_memory;
422 VALUE_ADDRESS (val) = addr;
423 VALUE_BFD_SECTION (val) = sect;
428 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
431 value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
435 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
436 error ("Attempt to dereference a generic pointer.");
438 val = allocate_value (type);
440 VALUE_LVAL (val) = lval_memory;
441 VALUE_ADDRESS (val) = addr;
442 VALUE_LAZY (val) = 1;
443 VALUE_BFD_SECTION (val) = sect;
448 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
449 if the current data for a variable needs to be loaded into
450 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
451 clears the lazy flag to indicate that the data in the buffer is valid.
453 If the value is zero-length, we avoid calling read_memory, which would
454 abort. We mark the value as fetched anyway -- all 0 bytes of it.
456 This function returns a value because it is used in the VALUE_CONTENTS
457 macro as part of an expression, where a void would not work. The
461 value_fetch_lazy (struct value *val)
463 CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
464 int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
466 struct type *type = VALUE_TYPE (val);
468 read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
470 VALUE_LAZY (val) = 0;
475 /* Store the contents of FROMVAL into the location of TOVAL.
476 Return a new value with the location of TOVAL and contents of FROMVAL. */
479 value_assign (struct value *toval, struct value *fromval)
481 register struct type *type;
483 char raw_buffer[MAX_REGISTER_SIZE];
485 struct frame_id old_frame;
487 if (!toval->modifiable)
488 error ("Left operand of assignment is not a modifiable lvalue.");
492 type = VALUE_TYPE (toval);
493 if (VALUE_LVAL (toval) != lval_internalvar)
494 fromval = value_cast (type, fromval);
496 COERCE_ARRAY (fromval);
497 CHECK_TYPEDEF (type);
499 /* If TOVAL is a special machine register requiring conversion
500 of program values to a special raw format,
501 convert FROMVAL's contents now, with result in `raw_buffer',
502 and set USE_BUFFER to the number of bytes to write. */
504 if (VALUE_REGNO (toval) >= 0)
506 int regno = VALUE_REGNO (toval);
507 if (CONVERT_REGISTER_P (regno))
509 struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
510 VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer);
511 use_buffer = REGISTER_RAW_SIZE (regno);
515 /* Since modifying a register can trash the frame chain, and modifying memory
516 can trash the frame cache, we save the old frame and then restore the new
518 old_frame = get_frame_id (deprecated_selected_frame);
520 switch (VALUE_LVAL (toval))
522 case lval_internalvar:
523 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
524 val = value_copy (VALUE_INTERNALVAR (toval)->value);
525 val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
526 VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
527 VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
530 case lval_internalvar_component:
531 set_internalvar_component (VALUE_INTERNALVAR (toval),
532 VALUE_OFFSET (toval),
533 VALUE_BITPOS (toval),
534 VALUE_BITSIZE (toval),
541 CORE_ADDR changed_addr;
544 if (VALUE_BITSIZE (toval))
546 char buffer[sizeof (LONGEST)];
547 /* We assume that the argument to read_memory is in units of
548 host chars. FIXME: Is that correct? */
549 changed_len = (VALUE_BITPOS (toval)
550 + VALUE_BITSIZE (toval)
554 if (changed_len > (int) sizeof (LONGEST))
555 error ("Can't handle bitfields which don't fit in a %d bit word.",
556 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
558 read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
559 buffer, changed_len);
560 modify_field (buffer, value_as_long (fromval),
561 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
562 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
563 dest_buffer = buffer;
567 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
568 changed_len = use_buffer;
569 dest_buffer = raw_buffer;
573 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
574 changed_len = TYPE_LENGTH (type);
575 dest_buffer = VALUE_CONTENTS (fromval);
578 write_memory (changed_addr, dest_buffer, changed_len);
579 if (memory_changed_hook)
580 memory_changed_hook (changed_addr, changed_len);
581 target_changed_event ();
585 case lval_reg_frame_relative:
588 /* value is stored in a series of registers in the frame
589 specified by the structure. Copy that value out, modify
590 it, and copy it back in. */
598 struct frame_info *frame;
600 /* Figure out which frame this is in currently. */
601 if (VALUE_LVAL (toval) == lval_register)
603 frame = get_current_frame ();
604 value_reg = VALUE_REGNO (toval);
608 for (frame = get_current_frame ();
609 frame && get_frame_base (frame) != VALUE_FRAME (toval);
610 frame = get_prev_frame (frame))
612 value_reg = VALUE_FRAME_REGNUM (toval);
616 error ("Value being assigned to is no longer active.");
618 /* Locate the first register that falls in the value that
619 needs to be transfered. Compute the offset of the value in
623 for (reg_offset = value_reg, offset = 0;
624 offset + REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval);
626 byte_offset = VALUE_OFFSET (toval) - offset;
629 /* Compute the number of register aligned values that need to
631 if (VALUE_BITSIZE (toval))
632 amount_to_copy = byte_offset + 1;
634 amount_to_copy = byte_offset + TYPE_LENGTH (type);
636 /* And a bounce buffer. Be slightly over generous. */
637 buffer = (char *) alloca (amount_to_copy + MAX_REGISTER_SIZE);
640 for (regno = reg_offset, amount_copied = 0;
641 amount_copied < amount_to_copy;
642 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
644 frame_register_read (frame, regno, buffer + amount_copied);
647 /* Modify what needs to be modified. */
648 if (VALUE_BITSIZE (toval))
650 modify_field (buffer + byte_offset,
651 value_as_long (fromval),
652 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
656 memcpy (buffer + VALUE_OFFSET (toval), raw_buffer, use_buffer);
660 memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
662 /* Do any conversion necessary when storing this type to
663 more than one register. */
664 #ifdef REGISTER_CONVERT_FROM_TYPE
665 REGISTER_CONVERT_FROM_TYPE (value_reg, type,
666 (buffer + byte_offset));
671 for (regno = reg_offset, amount_copied = 0;
672 amount_copied < amount_to_copy;
673 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
680 /* Just find out where to put it. */
681 frame_register (frame, regno, &optim, &lval, &addr, &realnum,
685 error ("Attempt to assign to a value that was optimized out.");
686 if (lval == lval_memory)
687 write_memory (addr, buffer + amount_copied,
688 REGISTER_RAW_SIZE (regno));
689 else if (lval == lval_register)
690 regcache_cooked_write (current_regcache, realnum,
691 (buffer + amount_copied));
693 error ("Attempt to assign to an unmodifiable value.");
696 if (register_changed_hook)
697 register_changed_hook (-1);
698 target_changed_event ();
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))
717 case lval_reg_frame_relative:
719 reinit_frame_cache ();
721 /* Having destoroyed the frame cache, restore the selected frame. */
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 bits.
741 If the field is signed, and is negative, then sign extend. */
742 if ((VALUE_BITSIZE (toval) > 0)
743 && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
745 LONGEST fieldval = value_as_long (fromval);
746 LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
749 if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
750 fieldval |= ~valmask;
752 fromval = value_from_longest (type, fieldval);
755 val = value_copy (toval);
756 memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
758 VALUE_TYPE (val) = type;
759 val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
760 VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
761 VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
766 /* Extend a value VAL to COUNT repetitions of its type. */
769 value_repeat (struct value *arg1, int count)
773 if (VALUE_LVAL (arg1) != lval_memory)
774 error ("Only values in memory can be extended with '@'.");
776 error ("Invalid number %d of repetitions.", count);
778 val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
780 read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
781 VALUE_CONTENTS_ALL_RAW (val),
782 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
783 VALUE_LVAL (val) = lval_memory;
784 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
790 value_of_variable (struct symbol *var, struct block *b)
793 struct frame_info *frame = NULL;
796 frame = NULL; /* Use selected frame. */
797 else if (symbol_read_needs_frame (var))
799 frame = block_innermost_frame (b);
802 if (BLOCK_FUNCTION (b)
803 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
804 error ("No frame is currently executing in block %s.",
805 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
807 error ("No frame is currently executing in specified block");
811 val = read_var_value (var, frame);
813 error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
818 /* Given a value which is an array, return a value which is a pointer to its
819 first element, regardless of whether or not the array has a nonzero lower
822 FIXME: A previous comment here indicated that this routine should be
823 substracting the array's lower bound. It's not clear to me that this
824 is correct. Given an array subscripting operation, it would certainly
825 work to do the adjustment here, essentially computing:
827 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
829 However I believe a more appropriate and logical place to account for
830 the lower bound is to do so in value_subscript, essentially computing:
832 (&array[0] + ((index - lowerbound) * sizeof array[0]))
834 As further evidence consider what would happen with operations other
835 than array subscripting, where the caller would get back a value that
836 had an address somewhere before the actual first element of the array,
837 and the information about the lower bound would be lost because of
838 the coercion to pointer type.
842 value_coerce_array (struct value *arg1)
844 register struct type *type = check_typedef (VALUE_TYPE (arg1));
846 if (VALUE_LVAL (arg1) != lval_memory)
847 error ("Attempt to take address of value not located in memory.");
849 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
850 (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
853 /* Given a value which is a function, return a value which is a pointer
857 value_coerce_function (struct value *arg1)
859 struct value *retval;
861 if (VALUE_LVAL (arg1) != lval_memory)
862 error ("Attempt to take address of value not located in memory.");
864 retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
865 (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
866 VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
870 /* Return a pointer value for the object for which ARG1 is the contents. */
873 value_addr (struct value *arg1)
877 struct type *type = check_typedef (VALUE_TYPE (arg1));
878 if (TYPE_CODE (type) == TYPE_CODE_REF)
880 /* Copy the value, but change the type from (T&) to (T*).
881 We keep the same location information, which is efficient,
882 and allows &(&X) to get the location containing the reference. */
883 arg2 = value_copy (arg1);
884 VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
887 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
888 return value_coerce_function (arg1);
890 if (VALUE_LVAL (arg1) != lval_memory)
891 error ("Attempt to take address of value not located in memory.");
893 /* Get target memory address */
894 arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
895 (VALUE_ADDRESS (arg1)
896 + VALUE_OFFSET (arg1)
897 + VALUE_EMBEDDED_OFFSET (arg1)));
899 /* This may be a pointer to a base subobject; so remember the
900 full derived object's type ... */
901 arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
902 /* ... and also the relative position of the subobject in the full object */
903 VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
904 VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
908 /* Given a value of a pointer type, apply the C unary * operator to it. */
911 value_ind (struct value *arg1)
913 struct type *base_type;
918 base_type = check_typedef (VALUE_TYPE (arg1));
920 if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
921 error ("not implemented: member types in value_ind");
923 /* Allow * on an integer so we can cast it to whatever we want.
924 This returns an int, which seems like the most C-like thing
925 to do. "long long" variables are rare enough that
926 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
927 if (TYPE_CODE (base_type) == TYPE_CODE_INT)
928 return value_at_lazy (builtin_type_int,
929 (CORE_ADDR) value_as_long (arg1),
930 VALUE_BFD_SECTION (arg1));
931 else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
933 struct type *enc_type;
934 /* We may be pointing to something embedded in a larger object */
935 /* Get the real type of the enclosing object */
936 enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
937 enc_type = TYPE_TARGET_TYPE (enc_type);
938 /* Retrieve the enclosing object pointed to */
939 arg2 = value_at_lazy (enc_type,
940 value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
941 VALUE_BFD_SECTION (arg1));
943 VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
944 /* Add embedding info */
945 arg2 = value_change_enclosing_type (arg2, enc_type);
946 VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
948 /* We may be pointing to an object of some derived type */
949 arg2 = value_full_object (arg2, NULL, 0, 0, 0);
953 error ("Attempt to take contents of a non-pointer value.");
954 return 0; /* For lint -- never reached */
957 /* Pushing small parts of stack frames. */
959 /* Push one word (the size of object that a register holds). */
962 push_word (CORE_ADDR sp, ULONGEST word)
964 register int len = DEPRECATED_REGISTER_SIZE;
965 char buffer[MAX_REGISTER_SIZE];
967 store_unsigned_integer (buffer, len, word);
968 if (INNER_THAN (1, 2))
970 /* stack grows downward */
972 write_memory (sp, buffer, len);
976 /* stack grows upward */
977 write_memory (sp, buffer, len);
984 /* Push LEN bytes with data at BUFFER. */
987 push_bytes (CORE_ADDR sp, char *buffer, int len)
989 if (INNER_THAN (1, 2))
991 /* stack grows downward */
993 write_memory (sp, buffer, len);
997 /* stack grows upward */
998 write_memory (sp, buffer, len);
1005 #ifndef PARM_BOUNDARY
1006 #define PARM_BOUNDARY (0)
1009 /* Push onto the stack the specified value VALUE. Pad it correctly for
1010 it to be an argument to a function. */
1013 value_push (register CORE_ADDR sp, struct value *arg)
1015 register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
1016 register int container_len = len;
1017 register int offset;
1019 /* How big is the container we're going to put this value in? */
1021 container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1)
1022 & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
1024 /* Are we going to put it at the high or low end of the container? */
1025 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1026 offset = container_len - len;
1030 if (INNER_THAN (1, 2))
1032 /* stack grows downward */
1033 sp -= container_len;
1034 write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1038 /* stack grows upward */
1039 write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1040 sp += container_len;
1047 legacy_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1048 int struct_return, CORE_ADDR struct_addr)
1050 /* ASSERT ( !struct_return); */
1052 for (i = nargs - 1; i >= 0; i--)
1053 sp = value_push (sp, args[i]);
1057 /* Create a value for an array by allocating space in the inferior, copying
1058 the data into that space, and then setting up an array value.
1060 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1061 populated from the values passed in ELEMVEC.
1063 The element type of the array is inherited from the type of the
1064 first element, and all elements must have the same size (though we
1065 don't currently enforce any restriction on their types). */
1068 value_array (int lowbound, int highbound, struct value **elemvec)
1072 unsigned int typelength;
1074 struct type *rangetype;
1075 struct type *arraytype;
1078 /* Validate that the bounds are reasonable and that each of the elements
1079 have the same size. */
1081 nelem = highbound - lowbound + 1;
1084 error ("bad array bounds (%d, %d)", lowbound, highbound);
1086 typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1087 for (idx = 1; idx < nelem; idx++)
1089 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1091 error ("array elements must all be the same size");
1095 rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1096 lowbound, highbound);
1097 arraytype = create_array_type ((struct type *) NULL,
1098 VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1100 if (!current_language->c_style_arrays)
1102 val = allocate_value (arraytype);
1103 for (idx = 0; idx < nelem; idx++)
1105 memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1106 VALUE_CONTENTS_ALL (elemvec[idx]),
1109 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1113 /* Allocate space to store the array in the inferior, and then initialize
1114 it by copying in each element. FIXME: Is it worth it to create a
1115 local buffer in which to collect each value and then write all the
1116 bytes in one operation? */
1118 addr = allocate_space_in_inferior (nelem * typelength);
1119 for (idx = 0; idx < nelem; idx++)
1121 write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1125 /* Create the array type and set up an array value to be evaluated lazily. */
1127 val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1131 /* Create a value for a string constant by allocating space in the inferior,
1132 copying the data into that space, and returning the address with type
1133 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1135 Note that string types are like array of char types with a lower bound of
1136 zero and an upper bound of LEN - 1. Also note that the string may contain
1137 embedded null bytes. */
1140 value_string (char *ptr, int len)
1143 int lowbound = current_language->string_lower_bound;
1144 struct type *rangetype = create_range_type ((struct type *) NULL,
1146 lowbound, len + lowbound - 1);
1147 struct type *stringtype
1148 = create_string_type ((struct type *) NULL, rangetype);
1151 if (current_language->c_style_arrays == 0)
1153 val = allocate_value (stringtype);
1154 memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1159 /* Allocate space to store the string in the inferior, and then
1160 copy LEN bytes from PTR in gdb to that address in the inferior. */
1162 addr = allocate_space_in_inferior (len);
1163 write_memory (addr, ptr, len);
1165 val = value_at_lazy (stringtype, addr, NULL);
1170 value_bitstring (char *ptr, int len)
1173 struct type *domain_type = create_range_type (NULL, builtin_type_int,
1175 struct type *type = create_set_type ((struct type *) NULL, domain_type);
1176 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1177 val = allocate_value (type);
1178 memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1182 /* See if we can pass arguments in T2 to a function which takes arguments
1183 of types T1. T1 is a list of NARGS arguments, and T2 is a NULL-terminated
1184 vector. If some arguments need coercion of some sort, then the coerced
1185 values are written into T2. Return value is 0 if the arguments could be
1186 matched, or the position at which they differ if not.
1188 STATICP is nonzero if the T1 argument list came from a
1189 static member function. T2 will still include the ``this'' pointer,
1190 but it will be skipped.
1192 For non-static member functions, we ignore the first argument,
1193 which is the type of the instance variable. This is because we want
1194 to handle calls with objects from derived classes. This is not
1195 entirely correct: we should actually check to make sure that a
1196 requested operation is type secure, shouldn't we? FIXME. */
1199 typecmp (int staticp, int varargs, int nargs,
1200 struct field t1[], struct value *t2[])
1205 internal_error (__FILE__, __LINE__, "typecmp: no argument list");
1207 /* Skip ``this'' argument if applicable. T2 will always include THIS. */
1212 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1215 struct type *tt1, *tt2;
1220 tt1 = check_typedef (t1[i].type);
1221 tt2 = check_typedef (VALUE_TYPE (t2[i]));
1223 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1224 /* We should be doing hairy argument matching, as below. */
1225 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1227 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1228 t2[i] = value_coerce_array (t2[i]);
1230 t2[i] = value_addr (t2[i]);
1234 /* djb - 20000715 - Until the new type structure is in the
1235 place, and we can attempt things like implicit conversions,
1236 we need to do this so you can take something like a map<const
1237 char *>, and properly access map["hello"], because the
1238 argument to [] will be a reference to a pointer to a char,
1239 and the argument will be a pointer to a char. */
1240 while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
1241 TYPE_CODE (tt1) == TYPE_CODE_PTR)
1243 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1245 while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
1246 TYPE_CODE(tt2) == TYPE_CODE_PTR ||
1247 TYPE_CODE(tt2) == TYPE_CODE_REF)
1249 tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
1251 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1253 /* Array to pointer is a `trivial conversion' according to the ARM. */
1255 /* We should be doing much hairier argument matching (see section 13.2
1256 of the ARM), but as a quick kludge, just check for the same type
1258 if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i])))
1261 if (varargs || t2[i] == NULL)
1266 /* Helper function used by value_struct_elt to recurse through baseclasses.
1267 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1268 and search in it assuming it has (class) type TYPE.
1269 If found, return value, else return NULL.
1271 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1272 look for a baseclass named NAME. */
1274 static struct value *
1275 search_struct_field (char *name, struct value *arg1, int offset,
1276 register struct type *type, int looking_for_baseclass)
1279 int nbases = TYPE_N_BASECLASSES (type);
1281 CHECK_TYPEDEF (type);
1283 if (!looking_for_baseclass)
1284 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1286 char *t_field_name = TYPE_FIELD_NAME (type, i);
1288 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1291 if (TYPE_FIELD_STATIC (type, i))
1293 v = value_static_field (type, i);
1295 error ("field %s is nonexistent or has been optimised out",
1300 v = value_primitive_field (arg1, offset, i, type);
1302 error ("there is no field named %s", name);
1308 && (t_field_name[0] == '\0'
1309 || (TYPE_CODE (type) == TYPE_CODE_UNION
1310 && (strcmp_iw (t_field_name, "else") == 0))))
1312 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1313 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1314 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1316 /* Look for a match through the fields of an anonymous union,
1317 or anonymous struct. C++ provides anonymous unions.
1319 In the GNU Chill (now deleted from GDB)
1320 implementation of variant record types, each
1321 <alternative field> has an (anonymous) union type,
1322 each member of the union represents a <variant
1323 alternative>. Each <variant alternative> is
1324 represented as a struct, with a member for each
1328 int new_offset = offset;
1330 /* This is pretty gross. In G++, the offset in an
1331 anonymous union is relative to the beginning of the
1332 enclosing struct. In the GNU Chill (now deleted
1333 from GDB) implementation of variant records, the
1334 bitpos is zero in an anonymous union field, so we
1335 have to add the offset of the union here. */
1336 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1337 || (TYPE_NFIELDS (field_type) > 0
1338 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1339 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1341 v = search_struct_field (name, arg1, new_offset, field_type,
1342 looking_for_baseclass);
1349 for (i = 0; i < nbases; i++)
1352 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1353 /* If we are looking for baseclasses, this is what we get when we
1354 hit them. But it could happen that the base part's member name
1355 is not yet filled in. */
1356 int found_baseclass = (looking_for_baseclass
1357 && TYPE_BASECLASS_NAME (type, i) != NULL
1358 && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0));
1360 if (BASETYPE_VIA_VIRTUAL (type, i))
1363 struct value *v2 = allocate_value (basetype);
1365 boffset = baseclass_offset (type, i,
1366 VALUE_CONTENTS (arg1) + offset,
1367 VALUE_ADDRESS (arg1)
1368 + VALUE_OFFSET (arg1) + offset);
1370 error ("virtual baseclass botch");
1372 /* The virtual base class pointer might have been clobbered by the
1373 user program. Make sure that it still points to a valid memory
1377 if (boffset < 0 || boffset >= TYPE_LENGTH (type))
1379 CORE_ADDR base_addr;
1381 base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
1382 if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
1383 TYPE_LENGTH (basetype)) != 0)
1384 error ("virtual baseclass botch");
1385 VALUE_LVAL (v2) = lval_memory;
1386 VALUE_ADDRESS (v2) = base_addr;
1390 VALUE_LVAL (v2) = VALUE_LVAL (arg1);
1391 VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
1392 VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
1393 if (VALUE_LAZY (arg1))
1394 VALUE_LAZY (v2) = 1;
1396 memcpy (VALUE_CONTENTS_RAW (v2),
1397 VALUE_CONTENTS_RAW (arg1) + boffset,
1398 TYPE_LENGTH (basetype));
1401 if (found_baseclass)
1403 v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
1404 looking_for_baseclass);
1406 else if (found_baseclass)
1407 v = value_primitive_field (arg1, offset, i, type);
1409 v = search_struct_field (name, arg1,
1410 offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
1411 basetype, looking_for_baseclass);
1419 /* Return the offset (in bytes) of the virtual base of type BASETYPE
1420 * in an object pointed to by VALADDR (on the host), assumed to be of
1421 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
1422 * looking (in case VALADDR is the contents of an enclosing object).
1424 * This routine recurses on the primary base of the derived class because
1425 * the virtual base entries of the primary base appear before the other
1426 * virtual base entries.
1428 * If the virtual base is not found, a negative integer is returned.
1429 * The magnitude of the negative integer is the number of entries in
1430 * the virtual table to skip over (entries corresponding to various
1431 * ancestral classes in the chain of primary bases).
1433 * Important: This assumes the HP / Taligent C++ runtime
1434 * conventions. Use baseclass_offset() instead to deal with g++
1438 find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
1439 int offset, int *boffset_p, int *skip_p)
1441 int boffset; /* offset of virtual base */
1442 int index; /* displacement to use in virtual table */
1446 CORE_ADDR vtbl; /* the virtual table pointer */
1447 struct type *pbc; /* the primary base class */
1449 /* Look for the virtual base recursively in the primary base, first.
1450 * This is because the derived class object and its primary base
1451 * subobject share the primary virtual table. */
1454 pbc = TYPE_PRIMARY_BASE (type);
1457 find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
1460 *boffset_p = boffset;
1469 /* Find the index of the virtual base according to HP/Taligent
1470 runtime spec. (Depth-first, left-to-right.) */
1471 index = virtual_base_index_skip_primaries (basetype, type);
1475 *skip_p = skip + virtual_base_list_length_skip_primaries (type);
1480 /* pai: FIXME -- 32x64 possible problem */
1481 /* First word (4 bytes) in object layout is the vtable pointer */
1482 vtbl = *(CORE_ADDR *) (valaddr + offset);
1484 /* Before the constructor is invoked, things are usually zero'd out. */
1486 error ("Couldn't find virtual table -- object may not be constructed yet.");
1489 /* Find virtual base's offset -- jump over entries for primary base
1490 * ancestors, then use the index computed above. But also adjust by
1491 * HP_ACC_VBASE_START for the vtable slots before the start of the
1492 * virtual base entries. Offset is negative -- virtual base entries
1493 * appear _before_ the address point of the virtual table. */
1495 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
1498 /* epstein : FIXME -- added param for overlay section. May not be correct */
1499 vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
1500 boffset = value_as_long (vp);
1502 *boffset_p = boffset;
1507 /* Helper function used by value_struct_elt to recurse through baseclasses.
1508 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1509 and search in it assuming it has (class) type TYPE.
1510 If found, return value, else if name matched and args not return (value)-1,
1511 else return NULL. */
1513 static struct value *
1514 search_struct_method (char *name, struct value **arg1p,
1515 struct value **args, int offset,
1516 int *static_memfuncp, register struct type *type)
1520 int name_matched = 0;
1521 char dem_opname[64];
1523 CHECK_TYPEDEF (type);
1524 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1526 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1527 /* FIXME! May need to check for ARM demangling here */
1528 if (strncmp (t_field_name, "__", 2) == 0 ||
1529 strncmp (t_field_name, "op", 2) == 0 ||
1530 strncmp (t_field_name, "type", 4) == 0)
1532 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
1533 t_field_name = dem_opname;
1534 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
1535 t_field_name = dem_opname;
1537 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1539 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1540 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1543 check_stub_method_group (type, i);
1544 if (j > 0 && args == 0)
1545 error ("cannot resolve overloaded method `%s': no arguments supplied", name);
1546 else if (j == 0 && args == 0)
1548 v = value_fn_field (arg1p, f, j, type, offset);
1555 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1556 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
1557 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
1558 TYPE_FN_FIELD_ARGS (f, j), args))
1560 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1561 return value_virtual_fn_field (arg1p, f, j, type, offset);
1562 if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
1563 *static_memfuncp = 1;
1564 v = value_fn_field (arg1p, f, j, type, offset);
1573 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1577 if (BASETYPE_VIA_VIRTUAL (type, i))
1579 if (TYPE_HAS_VTABLE (type))
1581 /* HP aCC compiled type, search for virtual base offset
1582 according to HP/Taligent runtime spec. */
1584 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
1585 VALUE_CONTENTS_ALL (*arg1p),
1586 offset + VALUE_EMBEDDED_OFFSET (*arg1p),
1587 &base_offset, &skip);
1589 error ("Virtual base class offset not found in vtable");
1593 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1596 /* The virtual base class pointer might have been clobbered by the
1597 user program. Make sure that it still points to a valid memory
1600 if (offset < 0 || offset >= TYPE_LENGTH (type))
1602 base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
1603 if (target_read_memory (VALUE_ADDRESS (*arg1p)
1604 + VALUE_OFFSET (*arg1p) + offset,
1606 TYPE_LENGTH (baseclass)) != 0)
1607 error ("virtual baseclass botch");
1610 base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
1613 baseclass_offset (type, i, base_valaddr,
1614 VALUE_ADDRESS (*arg1p)
1615 + VALUE_OFFSET (*arg1p) + offset);
1616 if (base_offset == -1)
1617 error ("virtual baseclass botch");
1622 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1624 v = search_struct_method (name, arg1p, args, base_offset + offset,
1625 static_memfuncp, TYPE_BASECLASS (type, i));
1626 if (v == (struct value *) - 1)
1632 /* FIXME-bothner: Why is this commented out? Why is it here? */
1633 /* *arg1p = arg1_tmp; */
1638 return (struct value *) - 1;
1643 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1644 extract the component named NAME from the ultimate target structure/union
1645 and return it as a value with its appropriate type.
1646 ERR is used in the error message if *ARGP's type is wrong.
1648 C++: ARGS is a list of argument types to aid in the selection of
1649 an appropriate method. Also, handle derived types.
1651 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1652 where the truthvalue of whether the function that was resolved was
1653 a static member function or not is stored.
1655 ERR is an error message to be printed in case the field is not found. */
1658 value_struct_elt (struct value **argp, struct value **args,
1659 char *name, int *static_memfuncp, char *err)
1661 register struct type *t;
1664 COERCE_ARRAY (*argp);
1666 t = check_typedef (VALUE_TYPE (*argp));
1668 /* Follow pointers until we get to a non-pointer. */
1670 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1672 *argp = value_ind (*argp);
1673 /* Don't coerce fn pointer to fn and then back again! */
1674 if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
1675 COERCE_ARRAY (*argp);
1676 t = check_typedef (VALUE_TYPE (*argp));
1679 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1680 error ("not implemented: member type in value_struct_elt");
1682 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1683 && TYPE_CODE (t) != TYPE_CODE_UNION)
1684 error ("Attempt to extract a component of a value that is not a %s.", err);
1686 /* Assume it's not, unless we see that it is. */
1687 if (static_memfuncp)
1688 *static_memfuncp = 0;
1692 /* if there are no arguments ...do this... */
1694 /* Try as a field first, because if we succeed, there
1695 is less work to be done. */
1696 v = search_struct_field (name, *argp, 0, t, 0);
1700 /* C++: If it was not found as a data field, then try to
1701 return it as a pointer to a method. */
1703 if (destructor_name_p (name, t))
1704 error ("Cannot get value of destructor");
1706 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1708 if (v == (struct value *) - 1)
1709 error ("Cannot take address of a method");
1712 if (TYPE_NFN_FIELDS (t))
1713 error ("There is no member or method named %s.", name);
1715 error ("There is no member named %s.", name);
1720 if (destructor_name_p (name, t))
1724 /* Destructors are a special case. */
1725 int m_index, f_index;
1728 if (get_destructor_fn_field (t, &m_index, &f_index))
1730 v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
1734 error ("could not find destructor function named %s.", name);
1740 error ("destructor should not have any argument");
1744 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1746 if (v == (struct value *) - 1)
1748 error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
1752 /* See if user tried to invoke data as function. If so,
1753 hand it back. If it's not callable (i.e., a pointer to function),
1754 gdb should give an error. */
1755 v = search_struct_field (name, *argp, 0, t, 0);
1759 error ("Structure has no component named %s.", name);
1763 /* Search through the methods of an object (and its bases)
1764 * to find a specified method. Return the pointer to the
1765 * fn_field list of overloaded instances.
1766 * Helper function for value_find_oload_list.
1767 * ARGP is a pointer to a pointer to a value (the object)
1768 * METHOD is a string containing the method name
1769 * OFFSET is the offset within the value
1770 * TYPE is the assumed type of the object
1771 * NUM_FNS is the number of overloaded instances
1772 * BASETYPE is set to the actual type of the subobject where the method is found
1773 * BOFFSET is the offset of the base subobject where the method is found */
1775 static struct fn_field *
1776 find_method_list (struct value **argp, char *method, int offset,
1777 struct type *type, int *num_fns,
1778 struct type **basetype, int *boffset)
1782 CHECK_TYPEDEF (type);
1786 /* First check in object itself */
1787 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1789 /* pai: FIXME What about operators and type conversions? */
1790 char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1791 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
1793 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
1794 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1800 /* Resolve any stub methods. */
1801 check_stub_method_group (type, i);
1807 /* Not found in object, check in base subobjects */
1808 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1811 if (BASETYPE_VIA_VIRTUAL (type, i))
1813 if (TYPE_HAS_VTABLE (type))
1815 /* HP aCC compiled type, search for virtual base offset
1816 * according to HP/Taligent runtime spec. */
1818 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
1819 VALUE_CONTENTS_ALL (*argp),
1820 offset + VALUE_EMBEDDED_OFFSET (*argp),
1821 &base_offset, &skip);
1823 error ("Virtual base class offset not found in vtable");
1827 /* probably g++ runtime model */
1828 base_offset = VALUE_OFFSET (*argp) + offset;
1830 baseclass_offset (type, i,
1831 VALUE_CONTENTS (*argp) + base_offset,
1832 VALUE_ADDRESS (*argp) + base_offset);
1833 if (base_offset == -1)
1834 error ("virtual baseclass botch");
1838 /* non-virtual base, simply use bit position from debug info */
1840 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1842 f = find_method_list (argp, method, base_offset + offset,
1843 TYPE_BASECLASS (type, i), num_fns, basetype,
1851 /* Return the list of overloaded methods of a specified name.
1852 * ARGP is a pointer to a pointer to a value (the object)
1853 * METHOD is the method name
1854 * OFFSET is the offset within the value contents
1855 * NUM_FNS is the number of overloaded instances
1856 * BASETYPE is set to the type of the base subobject that defines the method
1857 * BOFFSET is the offset of the base subobject which defines the method */
1860 value_find_oload_method_list (struct value **argp, char *method, int offset,
1861 int *num_fns, struct type **basetype,
1866 t = check_typedef (VALUE_TYPE (*argp));
1868 /* code snarfed from value_struct_elt */
1869 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1871 *argp = value_ind (*argp);
1872 /* Don't coerce fn pointer to fn and then back again! */
1873 if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
1874 COERCE_ARRAY (*argp);
1875 t = check_typedef (VALUE_TYPE (*argp));
1878 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1879 error ("Not implemented: member type in value_find_oload_lis");
1881 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1882 && TYPE_CODE (t) != TYPE_CODE_UNION)
1883 error ("Attempt to extract a component of a value that is not a struct or union");
1885 return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
1888 /* Given an array of argument types (ARGTYPES) (which includes an
1889 entry for "this" in the case of C++ methods), the number of
1890 arguments NARGS, the NAME of a function whether it's a method or
1891 not (METHOD), and the degree of laxness (LAX) in conforming to
1892 overload resolution rules in ANSI C++, find the best function that
1893 matches on the argument types according to the overload resolution
1896 In the case of class methods, the parameter OBJ is an object value
1897 in which to search for overloaded methods.
1899 In the case of non-method functions, the parameter FSYM is a symbol
1900 corresponding to one of the overloaded functions.
1902 Return value is an integer: 0 -> good match, 10 -> debugger applied
1903 non-standard coercions, 100 -> incompatible.
1905 If a method is being searched for, VALP will hold the value.
1906 If a non-method is being searched for, SYMP will hold the symbol for it.
1908 If a method is being searched for, and it is a static method,
1909 then STATICP will point to a non-zero value.
1911 Note: This function does *not* check the value of
1912 overload_resolution. Caller must check it to see whether overload
1913 resolution is permitted.
1917 find_overload_match (struct type **arg_types, int nargs, char *name, int method,
1918 int lax, struct value **objp, struct symbol *fsym,
1919 struct value **valp, struct symbol **symp, int *staticp)
1922 struct type **parm_types;
1923 int champ_nparms = 0;
1924 struct value *obj = (objp ? *objp : NULL);
1926 short oload_champ = -1; /* Index of best overloaded function */
1927 short oload_ambiguous = 0; /* Current ambiguity state for overload resolution */
1928 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
1929 short oload_ambig_champ = -1; /* 2nd contender for best match */
1930 short oload_non_standard = 0; /* did we have to use non-standard conversions? */
1931 short oload_incompatible = 0; /* are args supplied incompatible with any function? */
1933 struct badness_vector *bv; /* A measure of how good an overloaded instance is */
1934 struct badness_vector *oload_champ_bv = NULL; /* The measure for the current best match */
1936 struct value *temp = obj;
1937 struct fn_field *fns_ptr = NULL; /* For methods, the list of overloaded methods */
1938 struct symbol **oload_syms = NULL; /* For non-methods, the list of overloaded function symbols */
1939 int num_fns = 0; /* Number of overloaded instances being considered */
1940 struct type *basetype = NULL;
1945 struct cleanup *cleanups = NULL;
1947 char *obj_type_name = NULL;
1948 char *func_name = NULL;
1950 /* Get the list of overloaded methods or functions */
1953 obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
1954 /* Hack: evaluate_subexp_standard often passes in a pointer
1955 value rather than the object itself, so try again */
1956 if ((!obj_type_name || !*obj_type_name) &&
1957 (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
1958 obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
1960 fns_ptr = value_find_oload_method_list (&temp, name, 0,
1962 &basetype, &boffset);
1963 if (!fns_ptr || !num_fns)
1964 error ("Couldn't find method %s%s%s",
1966 (obj_type_name && *obj_type_name) ? "::" : "",
1968 /* If we are dealing with stub method types, they should have
1969 been resolved by find_method_list via value_find_oload_method_list
1971 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
1976 func_name = cplus_demangle (DEPRECATED_SYMBOL_NAME (fsym), DMGL_NO_OPTS);
1978 /* If the name is NULL this must be a C-style function.
1979 Just return the same symbol. */
1986 oload_syms = make_symbol_overload_list (fsym);
1987 cleanups = make_cleanup (xfree, oload_syms);
1988 while (oload_syms[++i])
1991 error ("Couldn't find function %s", func_name);
1994 oload_champ_bv = NULL;
1996 /* Consider each candidate in turn */
1997 for (ix = 0; ix < num_fns; ix++)
2002 if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix))
2004 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2008 /* If it's not a method, this is the proper place */
2009 nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix]));
2012 /* Prepare array of parameter types */
2013 parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2014 for (jj = 0; jj < nparms; jj++)
2015 parm_types[jj] = (method
2016 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2017 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj));
2019 /* Compare parameter types to supplied argument types. Skip THIS for
2021 bv = rank_function (parm_types, nparms, arg_types + static_offset,
2022 nargs - static_offset);
2024 if (!oload_champ_bv)
2026 oload_champ_bv = bv;
2028 champ_nparms = nparms;
2031 /* See whether current candidate is better or worse than previous best */
2032 switch (compare_badness (bv, oload_champ_bv))
2035 oload_ambiguous = 1; /* top two contenders are equally good */
2036 oload_ambig_champ = ix;
2039 oload_ambiguous = 2; /* incomparable top contenders */
2040 oload_ambig_champ = ix;
2043 oload_champ_bv = bv; /* new champion, record details */
2044 oload_ambiguous = 0;
2046 oload_ambig_champ = -1;
2047 champ_nparms = nparms;
2057 fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2059 fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
2060 for (jj = 0; jj < nargs - static_offset; jj++)
2061 fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
2062 fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2064 } /* end loop over all candidates */
2065 /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2066 if they have the exact same goodness. This is because there is no
2067 way to differentiate based on return type, which we need to in
2068 cases like overloads of .begin() <It's both const and non-const> */
2070 if (oload_ambiguous)
2073 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2075 (obj_type_name && *obj_type_name) ? "::" : "",
2078 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2083 /* Check how bad the best match is. */
2085 if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2087 for (ix = 1; ix <= nargs - static_offset; ix++)
2089 if (oload_champ_bv->rank[ix] >= 100)
2090 oload_incompatible = 1; /* truly mismatched types */
2092 else if (oload_champ_bv->rank[ix] >= 10)
2093 oload_non_standard = 1; /* non-standard type conversions needed */
2095 if (oload_incompatible)
2098 error ("Cannot resolve method %s%s%s to any overloaded instance",
2100 (obj_type_name && *obj_type_name) ? "::" : "",
2103 error ("Cannot resolve function %s to any overloaded instance",
2106 else if (oload_non_standard)
2109 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2111 (obj_type_name && *obj_type_name) ? "::" : "",
2114 warning ("Using non-standard conversion to match function %s to supplied arguments",
2120 if (staticp && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2124 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2125 *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2127 *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2131 *symp = oload_syms[oload_champ];
2137 if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
2138 && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
2140 temp = value_addr (temp);
2144 if (cleanups != NULL)
2145 do_cleanups (cleanups);
2147 return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2150 /* C++: return 1 is NAME is a legitimate name for the destructor
2151 of type TYPE. If TYPE does not have a destructor, or
2152 if NAME is inappropriate for TYPE, an error is signaled. */
2154 destructor_name_p (const char *name, const struct type *type)
2156 /* destructors are a special case. */
2160 char *dname = type_name_no_tag (type);
2161 char *cp = strchr (dname, '<');
2164 /* Do not compare the template part for template classes. */
2166 len = strlen (dname);
2169 if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2170 error ("name of destructor must equal name of class");
2177 /* Helper function for check_field: Given TYPE, a structure/union,
2178 return 1 if the component named NAME from the ultimate
2179 target structure/union is defined, otherwise, return 0. */
2182 check_field_in (register struct type *type, const char *name)
2186 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2188 char *t_field_name = TYPE_FIELD_NAME (type, i);
2189 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2193 /* C++: If it was not found as a data field, then try to
2194 return it as a pointer to a method. */
2196 /* Destructors are a special case. */
2197 if (destructor_name_p (name, type))
2199 int m_index, f_index;
2201 return get_destructor_fn_field (type, &m_index, &f_index);
2204 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2206 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2210 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2211 if (check_field_in (TYPE_BASECLASS (type, i), name))
2218 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2219 return 1 if the component named NAME from the ultimate
2220 target structure/union is defined, otherwise, return 0. */
2223 check_field (struct value *arg1, const char *name)
2225 register struct type *t;
2227 COERCE_ARRAY (arg1);
2229 t = VALUE_TYPE (arg1);
2231 /* Follow pointers until we get to a non-pointer. */
2236 if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
2238 t = TYPE_TARGET_TYPE (t);
2241 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2242 error ("not implemented: member type in check_field");
2244 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2245 && TYPE_CODE (t) != TYPE_CODE_UNION)
2246 error ("Internal error: `this' is not an aggregate");
2248 return check_field_in (t, name);
2251 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2252 return the address of this member as a "pointer to member"
2253 type. If INTYPE is non-null, then it will be the type
2254 of the member we are looking for. This will help us resolve
2255 "pointers to member functions". This function is used
2256 to resolve user expressions of the form "DOMAIN::NAME". */
2259 value_struct_elt_for_reference (struct type *domain, int offset,
2260 struct type *curtype, char *name,
2261 struct type *intype)
2263 register struct type *t = curtype;
2267 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2268 && TYPE_CODE (t) != TYPE_CODE_UNION)
2269 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2271 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2273 char *t_field_name = TYPE_FIELD_NAME (t, i);
2275 if (t_field_name && STREQ (t_field_name, name))
2277 if (TYPE_FIELD_STATIC (t, i))
2279 v = value_static_field (t, i);
2281 error ("static field %s has been optimized out",
2285 if (TYPE_FIELD_PACKED (t, i))
2286 error ("pointers to bitfield members not allowed");
2288 return value_from_longest
2289 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
2291 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2295 /* C++: If it was not found as a data field, then try to
2296 return it as a pointer to a method. */
2298 /* Destructors are a special case. */
2299 if (destructor_name_p (name, t))
2301 error ("member pointers to destructors not implemented yet");
2304 /* Perform all necessary dereferencing. */
2305 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2306 intype = TYPE_TARGET_TYPE (intype);
2308 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2310 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2311 char dem_opname[64];
2313 if (strncmp (t_field_name, "__", 2) == 0 ||
2314 strncmp (t_field_name, "op", 2) == 0 ||
2315 strncmp (t_field_name, "type", 4) == 0)
2317 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2318 t_field_name = dem_opname;
2319 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2320 t_field_name = dem_opname;
2322 if (t_field_name && STREQ (t_field_name, name))
2324 int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2325 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2327 check_stub_method_group (t, i);
2329 if (intype == 0 && j > 1)
2330 error ("non-unique member `%s' requires type instantiation", name);
2334 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2337 error ("no member function matches that type instantiation");
2342 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2344 return value_from_longest
2345 (lookup_reference_type
2346 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2348 (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
2352 struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2353 0, VAR_DOMAIN, 0, NULL);
2360 v = read_var_value (s, 0);
2362 VALUE_TYPE (v) = lookup_reference_type
2363 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2371 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2376 if (BASETYPE_VIA_VIRTUAL (t, i))
2379 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2380 v = value_struct_elt_for_reference (domain,
2381 offset + base_offset,
2382 TYPE_BASECLASS (t, i),
2392 /* Given a pointer value V, find the real (RTTI) type
2393 of the object it points to.
2394 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2395 and refer to the values computed for the object pointed to. */
2398 value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc)
2400 struct value *target;
2402 target = value_ind (v);
2404 return value_rtti_type (target, full, top, using_enc);
2407 /* Given a value pointed to by ARGP, check its real run-time type, and
2408 if that is different from the enclosing type, create a new value
2409 using the real run-time type as the enclosing type (and of the same
2410 type as ARGP) and return it, with the embedded offset adjusted to
2411 be the correct offset to the enclosed object
2412 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
2413 parameters, computed by value_rtti_type(). If these are available,
2414 they can be supplied and a second call to value_rtti_type() is avoided.
2415 (Pass RTYPE == NULL if they're not available */
2418 value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
2421 struct type *real_type;
2425 struct value *new_val;
2432 using_enc = xusing_enc;
2435 real_type = value_rtti_type (argp, &full, &top, &using_enc);
2437 /* If no RTTI data, or if object is already complete, do nothing */
2438 if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
2441 /* If we have the full object, but for some reason the enclosing
2442 type is wrong, set it *//* pai: FIXME -- sounds iffy */
2445 argp = value_change_enclosing_type (argp, real_type);
2449 /* Check if object is in memory */
2450 if (VALUE_LVAL (argp) != lval_memory)
2452 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
2457 /* All other cases -- retrieve the complete object */
2458 /* Go back by the computed top_offset from the beginning of the object,
2459 adjusting for the embedded offset of argp if that's what value_rtti_type
2460 used for its computation. */
2461 new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
2462 (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
2463 VALUE_BFD_SECTION (argp));
2464 VALUE_TYPE (new_val) = VALUE_TYPE (argp);
2465 VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
2472 /* Return the value of the local variable, if one exists.
2473 Flag COMPLAIN signals an error if the request is made in an
2474 inappropriate context. */
2477 value_of_local (const char *name, int complain)
2479 struct symbol *func, *sym;
2484 if (deprecated_selected_frame == 0)
2487 error ("no frame selected");
2492 func = get_frame_function (deprecated_selected_frame);
2496 error ("no `%s' in nameless context", name);
2501 b = SYMBOL_BLOCK_VALUE (func);
2502 i = BLOCK_NSYMS (b);
2506 error ("no args, no `%s'", name);
2511 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2512 symbol instead of the LOC_ARG one (if both exist). */
2513 sym = lookup_block_symbol (b, name, NULL, VAR_DOMAIN);
2517 error ("current stack frame does not contain a variable named `%s'", name);
2522 ret = read_var_value (sym, deprecated_selected_frame);
2523 if (ret == 0 && complain)
2524 error ("`%s' argument unreadable", name);
2528 /* C++/Objective-C: return the value of the class instance variable,
2529 if one exists. Flag COMPLAIN signals an error if the request is
2530 made in an inappropriate context. */
2533 value_of_this (int complain)
2535 if (current_language->la_language == language_objc)
2536 return value_of_local ("self", complain);
2538 return value_of_local ("this", complain);
2541 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2542 long, starting at LOWBOUND. The result has the same lower bound as
2543 the original ARRAY. */
2546 value_slice (struct value *array, int lowbound, int length)
2548 struct type *slice_range_type, *slice_type, *range_type;
2549 LONGEST lowerbound, upperbound;
2550 struct value *slice;
2551 struct type *array_type;
2552 array_type = check_typedef (VALUE_TYPE (array));
2553 COERCE_VARYING_ARRAY (array, array_type);
2554 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
2555 && TYPE_CODE (array_type) != TYPE_CODE_STRING
2556 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
2557 error ("cannot take slice of non-array");
2558 range_type = TYPE_INDEX_TYPE (array_type);
2559 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
2560 error ("slice from bad array or bitstring");
2561 if (lowbound < lowerbound || length < 0
2562 || lowbound + length - 1 > upperbound)
2563 error ("slice out of range");
2564 /* FIXME-type-allocation: need a way to free this type when we are
2566 slice_range_type = create_range_type ((struct type *) NULL,
2567 TYPE_TARGET_TYPE (range_type),
2568 lowbound, lowbound + length - 1);
2569 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
2572 slice_type = create_set_type ((struct type *) NULL, slice_range_type);
2573 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
2574 slice = value_zero (slice_type, not_lval);
2575 for (i = 0; i < length; i++)
2577 int element = value_bit_index (array_type,
2578 VALUE_CONTENTS (array),
2581 error ("internal error accessing bitstring");
2582 else if (element > 0)
2584 int j = i % TARGET_CHAR_BIT;
2585 if (BITS_BIG_ENDIAN)
2586 j = TARGET_CHAR_BIT - 1 - j;
2587 VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
2590 /* We should set the address, bitssize, and bitspos, so the clice
2591 can be used on the LHS, but that may require extensions to
2592 value_assign. For now, just leave as a non_lval. FIXME. */
2596 struct type *element_type = TYPE_TARGET_TYPE (array_type);
2598 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
2599 slice_type = create_array_type ((struct type *) NULL, element_type,
2601 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
2602 slice = allocate_value (slice_type);
2603 if (VALUE_LAZY (array))
2604 VALUE_LAZY (slice) = 1;
2606 memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
2607 TYPE_LENGTH (slice_type));
2608 if (VALUE_LVAL (array) == lval_internalvar)
2609 VALUE_LVAL (slice) = lval_internalvar_component;
2611 VALUE_LVAL (slice) = VALUE_LVAL (array);
2612 VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2613 VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
2618 /* Create a value for a FORTRAN complex number. Currently most of
2619 the time values are coerced to COMPLEX*16 (i.e. a complex number
2620 composed of 2 doubles. This really should be a smarter routine
2621 that figures out precision inteligently as opposed to assuming
2622 doubles. FIXME: fmb */
2625 value_literal_complex (struct value *arg1, struct value *arg2, struct type *type)
2628 struct type *real_type = TYPE_TARGET_TYPE (type);
2630 val = allocate_value (type);
2631 arg1 = value_cast (real_type, arg1);
2632 arg2 = value_cast (real_type, arg2);
2634 memcpy (VALUE_CONTENTS_RAW (val),
2635 VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
2636 memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
2637 VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
2641 /* Cast a value into the appropriate complex data type. */
2643 static struct value *
2644 cast_into_complex (struct type *type, struct value *val)
2646 struct type *real_type = TYPE_TARGET_TYPE (type);
2647 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
2649 struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
2650 struct value *re_val = allocate_value (val_real_type);
2651 struct value *im_val = allocate_value (val_real_type);
2653 memcpy (VALUE_CONTENTS_RAW (re_val),
2654 VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
2655 memcpy (VALUE_CONTENTS_RAW (im_val),
2656 VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
2657 TYPE_LENGTH (val_real_type));
2659 return value_literal_complex (re_val, im_val, type);
2661 else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
2662 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
2663 return value_literal_complex (val, value_zero (real_type, not_lval), type);
2665 error ("cannot cast non-number to complex");
2669 _initialize_valops (void)
2673 (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
2674 "Set automatic abandonment of expressions upon failure.",
2680 (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
2681 "Set overload resolution in evaluating C++ functions.",
2684 overload_resolution = 1;