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
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. */
38 #include "gdb_string.h"
39 #include "gdb_assert.h"
41 /* Flag indicating HP compilers were used; needed to correctly handle some
42 value operations with HP aCC code/runtime. */
43 extern int hp_som_som_object_present;
45 extern int overload_debug;
46 /* Local functions. */
48 static int typecmp (int staticp, int varargs, int nargs,
49 struct field t1[], struct value *t2[]);
51 static CORE_ADDR find_function_addr (struct value *, struct type **);
52 static struct value *value_arg_coerce (struct value *, struct type *, int);
55 static CORE_ADDR value_push (CORE_ADDR, struct value *);
57 static struct value *search_struct_field (char *, struct value *, int,
60 static struct value *search_struct_method (char *, struct value **,
62 int, int *, struct type *);
64 static int check_field_in (struct type *, const char *);
66 static CORE_ADDR allocate_space_in_inferior (int);
68 static struct value *cast_into_complex (struct type *, struct value *);
70 static struct fn_field *find_method_list (struct value ** argp, char *method,
72 struct type *type, int *num_fns,
73 struct type **basetype,
76 void _initialize_valops (void);
78 /* Flag for whether we want to abandon failed expression evals by default. */
81 static int auto_abandon = 0;
84 int overload_resolution = 0;
86 /* This boolean tells what gdb should do if a signal is received while in
87 a function called from gdb (call dummy). If set, gdb unwinds the stack
88 and restore the context to what as it was before the call.
89 The default is to stop in the frame where the signal was received. */
91 int unwind_on_signal_p = 0;
95 /* Find the address of function name NAME in the inferior. */
98 find_function_in_inferior (const char *name)
100 register struct symbol *sym;
101 sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
104 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
106 error ("\"%s\" exists in this program but is not a function.",
109 return value_of_variable (sym, NULL);
113 struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL);
118 type = lookup_pointer_type (builtin_type_char);
119 type = lookup_function_type (type);
120 type = lookup_pointer_type (type);
121 maddr = SYMBOL_VALUE_ADDRESS (msymbol);
122 return value_from_pointer (type, maddr);
126 if (!target_has_execution)
127 error ("evaluation of this expression requires the target program to be active");
129 error ("evaluation of this expression requires the program to have a function \"%s\".", name);
134 /* Allocate NBYTES of space in the inferior using the inferior's malloc
135 and return a value that is a pointer to the allocated space. */
138 value_allocate_space_in_inferior (int len)
140 struct value *blocklen;
141 struct value *val = find_function_in_inferior (NAME_OF_MALLOC);
143 blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
144 val = call_function_by_hand (val, 1, &blocklen);
145 if (value_logical_not (val))
147 if (!target_has_execution)
148 error ("No memory available to program now: you need to start the target first");
150 error ("No memory available to program: call to malloc failed");
156 allocate_space_in_inferior (int len)
158 return value_as_long (value_allocate_space_in_inferior (len));
161 /* Cast value ARG2 to type TYPE and return as a value.
162 More general than a C cast: accepts any two types of the same length,
163 and if ARG2 is an lvalue it can be cast into anything at all. */
164 /* In C++, casts may change pointer or object representations. */
167 value_cast (struct type *type, struct value *arg2)
169 register enum type_code code1;
170 register enum type_code code2;
174 int convert_to_boolean = 0;
176 if (VALUE_TYPE (arg2) == type)
179 CHECK_TYPEDEF (type);
180 code1 = TYPE_CODE (type);
182 type2 = check_typedef (VALUE_TYPE (arg2));
184 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
185 is treated like a cast to (TYPE [N])OBJECT,
186 where N is sizeof(OBJECT)/sizeof(TYPE). */
187 if (code1 == TYPE_CODE_ARRAY)
189 struct type *element_type = TYPE_TARGET_TYPE (type);
190 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
191 if (element_length > 0
192 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
194 struct type *range_type = TYPE_INDEX_TYPE (type);
195 int val_length = TYPE_LENGTH (type2);
196 LONGEST low_bound, high_bound, new_length;
197 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
198 low_bound = 0, high_bound = 0;
199 new_length = val_length / element_length;
200 if (val_length % element_length != 0)
201 warning ("array element type size does not divide object size in cast");
202 /* FIXME-type-allocation: need a way to free this type when we are
204 range_type = create_range_type ((struct type *) NULL,
205 TYPE_TARGET_TYPE (range_type),
207 new_length + low_bound - 1);
208 VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
209 element_type, range_type);
214 if (current_language->c_style_arrays
215 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
216 arg2 = value_coerce_array (arg2);
218 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
219 arg2 = value_coerce_function (arg2);
221 type2 = check_typedef (VALUE_TYPE (arg2));
222 COERCE_VARYING_ARRAY (arg2, type2);
223 code2 = TYPE_CODE (type2);
225 if (code1 == TYPE_CODE_COMPLEX)
226 return cast_into_complex (type, arg2);
227 if (code1 == TYPE_CODE_BOOL)
229 code1 = TYPE_CODE_INT;
230 convert_to_boolean = 1;
232 if (code1 == TYPE_CODE_CHAR)
233 code1 = TYPE_CODE_INT;
234 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
235 code2 = TYPE_CODE_INT;
237 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
238 || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
240 if (code1 == TYPE_CODE_STRUCT
241 && code2 == TYPE_CODE_STRUCT
242 && TYPE_NAME (type) != 0)
244 /* Look in the type of the source to see if it contains the
245 type of the target as a superclass. If so, we'll need to
246 offset the object in addition to changing its type. */
247 struct value *v = search_struct_field (type_name_no_tag (type),
251 VALUE_TYPE (v) = type;
255 if (code1 == TYPE_CODE_FLT && scalar)
256 return value_from_double (type, value_as_double (arg2));
257 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
258 || code1 == TYPE_CODE_RANGE)
259 && (scalar || code2 == TYPE_CODE_PTR))
263 if (hp_som_som_object_present && /* if target compiled by HP aCC */
264 (code2 == TYPE_CODE_PTR))
267 struct value *retvalp;
269 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
271 /* With HP aCC, pointers to data members have a bias */
272 case TYPE_CODE_MEMBER:
273 retvalp = value_from_longest (type, value_as_long (arg2));
274 /* force evaluation */
275 ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
276 *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
279 /* While pointers to methods don't really point to a function */
280 case TYPE_CODE_METHOD:
281 error ("Pointers to methods not supported with HP aCC");
284 break; /* fall out and go to normal handling */
288 /* When we cast pointers to integers, we mustn't use
289 POINTER_TO_ADDRESS to find the address the pointer
290 represents, as value_as_long would. GDB should evaluate
291 expressions just as the compiler would --- and the compiler
292 sees a cast as a simple reinterpretation of the pointer's
294 if (code2 == TYPE_CODE_PTR)
295 longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
296 TYPE_LENGTH (type2));
298 longest = value_as_long (arg2);
299 return value_from_longest (type, convert_to_boolean ?
300 (LONGEST) (longest ? 1 : 0) : longest);
302 else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT ||
303 code2 == TYPE_CODE_ENUM ||
304 code2 == TYPE_CODE_RANGE))
306 /* TYPE_LENGTH (type) is the length of a pointer, but we really
307 want the length of an address! -- we are really dealing with
308 addresses (i.e., gdb representations) not pointers (i.e.,
309 target representations) here.
311 This allows things like "print *(int *)0x01000234" to work
312 without printing a misleading message -- which would
313 otherwise occur when dealing with a target having two byte
314 pointers and four byte addresses. */
316 int addr_bit = TARGET_ADDR_BIT;
318 LONGEST longest = value_as_long (arg2);
319 if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
321 if (longest >= ((LONGEST) 1 << addr_bit)
322 || longest <= -((LONGEST) 1 << addr_bit))
323 warning ("value truncated");
325 return value_from_longest (type, longest);
327 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
329 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
331 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
332 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
333 if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
334 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
335 && !value_logical_not (arg2))
339 /* Look in the type of the source to see if it contains the
340 type of the target as a superclass. If so, we'll need to
341 offset the pointer rather than just change its type. */
342 if (TYPE_NAME (t1) != NULL)
344 v = search_struct_field (type_name_no_tag (t1),
345 value_ind (arg2), 0, t2, 1);
349 VALUE_TYPE (v) = type;
354 /* Look in the type of the target to see if it contains the
355 type of the source as a superclass. If so, we'll need to
356 offset the pointer rather than just change its type.
357 FIXME: This fails silently with virtual inheritance. */
358 if (TYPE_NAME (t2) != NULL)
360 v = search_struct_field (type_name_no_tag (t2),
361 value_zero (t1, not_lval), 0, t1, 1);
364 CORE_ADDR addr2 = value_as_address (arg2);
365 addr2 -= (VALUE_ADDRESS (v)
367 + VALUE_EMBEDDED_OFFSET (v));
368 return value_from_pointer (type, addr2);
372 /* No superclass found, just fall through to change ptr type. */
374 VALUE_TYPE (arg2) = type;
375 arg2 = value_change_enclosing_type (arg2, type);
376 VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */
379 else if (VALUE_LVAL (arg2) == lval_memory)
381 return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
382 VALUE_BFD_SECTION (arg2));
384 else if (code1 == TYPE_CODE_VOID)
386 return value_zero (builtin_type_void, not_lval);
390 error ("Invalid cast.");
395 /* Create a value of type TYPE that is zero, and return it. */
398 value_zero (struct type *type, enum lval_type lv)
400 struct value *val = allocate_value (type);
402 memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
403 VALUE_LVAL (val) = lv;
408 /* Return a value with type TYPE located at ADDR.
410 Call value_at only if the data needs to be fetched immediately;
411 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
412 value_at_lazy instead. value_at_lazy simply records the address of
413 the data and sets the lazy-evaluation-required flag. The lazy flag
414 is tested in the VALUE_CONTENTS macro, which is used if and when
415 the contents are actually required.
417 Note: value_at does *NOT* handle embedded offsets; perform such
418 adjustments before or after calling it. */
421 value_at (struct type *type, CORE_ADDR addr, asection *sect)
425 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
426 error ("Attempt to dereference a generic pointer.");
428 val = allocate_value (type);
430 read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
432 VALUE_LVAL (val) = lval_memory;
433 VALUE_ADDRESS (val) = addr;
434 VALUE_BFD_SECTION (val) = sect;
439 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
442 value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
446 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
447 error ("Attempt to dereference a generic pointer.");
449 val = allocate_value (type);
451 VALUE_LVAL (val) = lval_memory;
452 VALUE_ADDRESS (val) = addr;
453 VALUE_LAZY (val) = 1;
454 VALUE_BFD_SECTION (val) = sect;
459 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
460 if the current data for a variable needs to be loaded into
461 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
462 clears the lazy flag to indicate that the data in the buffer is valid.
464 If the value is zero-length, we avoid calling read_memory, which would
465 abort. We mark the value as fetched anyway -- all 0 bytes of it.
467 This function returns a value because it is used in the VALUE_CONTENTS
468 macro as part of an expression, where a void would not work. The
472 value_fetch_lazy (struct value *val)
474 CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
475 int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
477 struct type *type = VALUE_TYPE (val);
479 read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
481 VALUE_LAZY (val) = 0;
486 /* Store the contents of FROMVAL into the location of TOVAL.
487 Return a new value with the location of TOVAL and contents of FROMVAL. */
490 value_assign (struct value *toval, struct value *fromval)
492 register struct type *type;
494 char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
497 if (!toval->modifiable)
498 error ("Left operand of assignment is not a modifiable lvalue.");
502 type = VALUE_TYPE (toval);
503 if (VALUE_LVAL (toval) != lval_internalvar)
504 fromval = value_cast (type, fromval);
506 COERCE_ARRAY (fromval);
507 CHECK_TYPEDEF (type);
509 /* If TOVAL is a special machine register requiring conversion
510 of program values to a special raw format,
511 convert FROMVAL's contents now, with result in `raw_buffer',
512 and set USE_BUFFER to the number of bytes to write. */
514 if (VALUE_REGNO (toval) >= 0)
516 int regno = VALUE_REGNO (toval);
517 if (CONVERT_REGISTER_P (regno))
519 struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
520 VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer);
521 use_buffer = REGISTER_RAW_SIZE (regno);
525 switch (VALUE_LVAL (toval))
527 case lval_internalvar:
528 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
529 val = value_copy (VALUE_INTERNALVAR (toval)->value);
530 val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
531 VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
532 VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
535 case lval_internalvar_component:
536 set_internalvar_component (VALUE_INTERNALVAR (toval),
537 VALUE_OFFSET (toval),
538 VALUE_BITPOS (toval),
539 VALUE_BITSIZE (toval),
546 CORE_ADDR changed_addr;
549 if (VALUE_BITSIZE (toval))
551 char buffer[sizeof (LONGEST)];
552 /* We assume that the argument to read_memory is in units of
553 host chars. FIXME: Is that correct? */
554 changed_len = (VALUE_BITPOS (toval)
555 + VALUE_BITSIZE (toval)
559 if (changed_len > (int) sizeof (LONGEST))
560 error ("Can't handle bitfields which don't fit in a %d bit word.",
561 (int) sizeof (LONGEST) * HOST_CHAR_BIT);
563 read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
564 buffer, changed_len);
565 modify_field (buffer, value_as_long (fromval),
566 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
567 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
568 dest_buffer = buffer;
572 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
573 changed_len = use_buffer;
574 dest_buffer = raw_buffer;
578 changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
579 changed_len = TYPE_LENGTH (type);
580 dest_buffer = VALUE_CONTENTS (fromval);
583 write_memory (changed_addr, dest_buffer, changed_len);
584 if (memory_changed_hook)
585 memory_changed_hook (changed_addr, changed_len);
586 target_changed_event ();
590 case lval_reg_frame_relative:
593 struct frame_id old_frame;
594 /* value is stored in a series of registers in the frame
595 specified by the structure. Copy that value out, modify
596 it, and copy it back in. */
604 struct frame_info *frame;
606 /* Since modifying a register can trash the frame chain, we
607 save the old frame and then restore the new frame
609 old_frame = get_frame_id (deprecated_selected_frame);
611 /* Figure out which frame this is in currently. */
612 if (VALUE_LVAL (toval) == lval_register)
614 frame = get_current_frame ();
615 value_reg = VALUE_REGNO (toval);
619 for (frame = get_current_frame ();
620 frame && get_frame_base (frame) != VALUE_FRAME (toval);
621 frame = get_prev_frame (frame))
623 value_reg = VALUE_FRAME_REGNUM (toval);
627 error ("Value being assigned to is no longer active.");
629 /* Locate the first register that falls in the value that
630 needs to be transfered. Compute the offset of the value in
634 for (reg_offset = value_reg, offset = 0;
635 offset + REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval);
637 byte_offset = VALUE_OFFSET (toval) - offset;
640 /* Compute the number of register aligned values that need to
642 if (VALUE_BITSIZE (toval))
643 amount_to_copy = byte_offset + 1;
645 amount_to_copy = byte_offset + TYPE_LENGTH (type);
647 /* And a bounce buffer. Be slightly over generous. */
648 buffer = (char *) alloca (amount_to_copy
649 + MAX_REGISTER_RAW_SIZE);
652 for (regno = reg_offset, amount_copied = 0;
653 amount_copied < amount_to_copy;
654 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
656 frame_register_read (frame, regno, buffer + amount_copied);
659 /* Modify what needs to be modified. */
660 if (VALUE_BITSIZE (toval))
662 modify_field (buffer + byte_offset,
663 value_as_long (fromval),
664 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
668 memcpy (buffer + VALUE_OFFSET (toval), raw_buffer, use_buffer);
672 memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
674 /* Do any conversion necessary when storing this type to
675 more than one register. */
676 #ifdef REGISTER_CONVERT_FROM_TYPE
677 REGISTER_CONVERT_FROM_TYPE (value_reg, type,
678 (buffer + byte_offset));
683 for (regno = reg_offset, amount_copied = 0;
684 amount_copied < amount_to_copy;
685 amount_copied += REGISTER_RAW_SIZE (regno), regno++)
692 /* Just find out where to put it. */
693 frame_register (frame, regno, &optim, &lval, &addr, &realnum,
697 error ("Attempt to assign to a value that was optimized out.");
698 if (lval == lval_memory)
699 write_memory (addr, buffer + amount_copied,
700 REGISTER_RAW_SIZE (regno));
701 else if (lval == lval_register)
702 regcache_cooked_write (current_regcache, realnum,
703 (buffer + amount_copied));
705 error ("Attempt to assign to an unmodifiable value.");
708 if (register_changed_hook)
709 register_changed_hook (-1);
710 target_changed_event ();
712 /* Assigning to the stack pointer, frame pointer, and other
713 (architecture and calling convention specific) registers
714 may cause the frame cache to be out of date. We just do
715 this on all assignments to registers for simplicity; I
716 doubt the slowdown matters. */
717 reinit_frame_cache ();
719 /* Having destoroyed the frame cache, restore the selected
721 /* FIXME: cagney/2002-11-02: There has to be a better way of
722 doing this. Instead of constantly saving/restoring the
723 frame. Why not create a get_selected_frame() function
724 that, having saved the selected frame's ID can
725 automatically re-find the previously selected frame
728 struct frame_info *fi = frame_find_by_id (old_frame);
737 error ("Left operand of assignment is not an lvalue.");
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_SOURCE_NAME (BLOCK_FUNCTION (b)))
804 error ("No frame is currently executing in block %s.",
805 SYMBOL_SOURCE_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_SOURCE_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 = REGISTER_SIZE;
965 char *buffer = alloca (MAX_REGISTER_RAW_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 default_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]);
1058 /* Functions to use for the COERCE_FLOAT_TO_DOUBLE gdbarch method.
1060 How you should pass arguments to a function depends on whether it
1061 was defined in K&R style or prototype style. If you define a
1062 function using the K&R syntax that takes a `float' argument, then
1063 callers must pass that argument as a `double'. If you define the
1064 function using the prototype syntax, then you must pass the
1065 argument as a `float', with no promotion.
1067 Unfortunately, on certain older platforms, the debug info doesn't
1068 indicate reliably how each function was defined. A function type's
1069 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
1070 defined in prototype style. When calling a function whose
1071 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults the
1072 COERCE_FLOAT_TO_DOUBLE gdbarch method to decide what to do.
1074 For modern targets, it is proper to assume that, if the prototype
1075 flag is clear, that can be trusted: `float' arguments should be
1076 promoted to `double'. You should register the function
1077 `standard_coerce_float_to_double' to get this behavior.
1079 For some older targets, if the prototype flag is clear, that
1080 doesn't tell us anything. So we guess that, if we don't have a
1081 type for the formal parameter (i.e., the first argument to
1082 COERCE_FLOAT_TO_DOUBLE is null), then we should promote it;
1083 otherwise, we should leave it alone. The function
1084 `default_coerce_float_to_double' provides this behavior; it is the
1085 default value, for compatibility with older configurations. */
1087 default_coerce_float_to_double (struct type *formal, struct type *actual)
1089 return formal == NULL;
1094 standard_coerce_float_to_double (struct type *formal, struct type *actual)
1100 /* Perform the standard coercions that are specified
1101 for arguments to be passed to C functions.
1103 If PARAM_TYPE is non-NULL, it is the expected parameter type.
1104 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
1106 static struct value *
1107 value_arg_coerce (struct value *arg, struct type *param_type,
1110 register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
1111 register struct type *type
1112 = param_type ? check_typedef (param_type) : arg_type;
1114 switch (TYPE_CODE (type))
1117 if (TYPE_CODE (arg_type) != TYPE_CODE_REF
1118 && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
1120 arg = value_addr (arg);
1121 VALUE_TYPE (arg) = param_type;
1126 case TYPE_CODE_CHAR:
1127 case TYPE_CODE_BOOL:
1128 case TYPE_CODE_ENUM:
1129 /* If we don't have a prototype, coerce to integer type if necessary. */
1132 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1133 type = builtin_type_int;
1135 /* Currently all target ABIs require at least the width of an integer
1136 type for an argument. We may have to conditionalize the following
1137 type coercion for future targets. */
1138 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1139 type = builtin_type_int;
1142 /* FIXME: We should always convert floats to doubles in the
1143 non-prototyped case. As many debugging formats include
1144 no information about prototyping, we have to live with
1145 COERCE_FLOAT_TO_DOUBLE for now. */
1146 if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE (param_type, arg_type))
1148 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
1149 type = builtin_type_double;
1150 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
1151 type = builtin_type_long_double;
1154 case TYPE_CODE_FUNC:
1155 type = lookup_pointer_type (type);
1157 case TYPE_CODE_ARRAY:
1158 /* Arrays are coerced to pointers to their first element, unless
1159 they are vectors, in which case we want to leave them alone,
1160 because they are passed by value. */
1161 if (current_language->c_style_arrays)
1162 if (!TYPE_VECTOR (type))
1163 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1165 case TYPE_CODE_UNDEF:
1167 case TYPE_CODE_STRUCT:
1168 case TYPE_CODE_UNION:
1169 case TYPE_CODE_VOID:
1171 case TYPE_CODE_RANGE:
1172 case TYPE_CODE_STRING:
1173 case TYPE_CODE_BITSTRING:
1174 case TYPE_CODE_ERROR:
1175 case TYPE_CODE_MEMBER:
1176 case TYPE_CODE_METHOD:
1177 case TYPE_CODE_COMPLEX:
1182 return value_cast (type, arg);
1185 /* Determine a function's address and its return type from its value.
1186 Calls error() if the function is not valid for calling. */
1189 find_function_addr (struct value *function, struct type **retval_type)
1191 register struct type *ftype = check_typedef (VALUE_TYPE (function));
1192 register enum type_code code = TYPE_CODE (ftype);
1193 struct type *value_type;
1196 /* If it's a member function, just look at the function
1199 /* Determine address to call. */
1200 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
1202 funaddr = VALUE_ADDRESS (function);
1203 value_type = TYPE_TARGET_TYPE (ftype);
1205 else if (code == TYPE_CODE_PTR)
1207 funaddr = value_as_address (function);
1208 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1209 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1210 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1212 funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
1213 value_type = TYPE_TARGET_TYPE (ftype);
1216 value_type = builtin_type_int;
1218 else if (code == TYPE_CODE_INT)
1220 /* Handle the case of functions lacking debugging info.
1221 Their values are characters since their addresses are char */
1222 if (TYPE_LENGTH (ftype) == 1)
1223 funaddr = value_as_address (value_addr (function));
1225 /* Handle integer used as address of a function. */
1226 funaddr = (CORE_ADDR) value_as_long (function);
1228 value_type = builtin_type_int;
1231 error ("Invalid data type for function to be called.");
1233 *retval_type = value_type;
1237 /* All this stuff with a dummy frame may seem unnecessarily complicated
1238 (why not just save registers in GDB?). The purpose of pushing a dummy
1239 frame which looks just like a real frame is so that if you call a
1240 function and then hit a breakpoint (get a signal, etc), "backtrace"
1241 will look right. Whether the backtrace needs to actually show the
1242 stack at the time the inferior function was called is debatable, but
1243 it certainly needs to not display garbage. So if you are contemplating
1244 making dummy frames be different from normal frames, consider that. */
1246 /* Perform a function call in the inferior.
1247 ARGS is a vector of values of arguments (NARGS of them).
1248 FUNCTION is a value, the function to be called.
1249 Returns a value representing what the function returned.
1250 May fail to return, if a breakpoint or signal is hit
1251 during the execution of the function.
1253 ARGS is modified to contain coerced values. */
1255 static struct value *
1256 hand_function_call (struct value *function, int nargs, struct value **args)
1258 register CORE_ADDR sp;
1262 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1263 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1264 and remove any extra bytes which might exist because ULONGEST is
1265 bigger than REGISTER_SIZE.
1267 NOTE: This is pretty wierd, as the call dummy is actually a
1268 sequence of instructions. But CISC machines will have
1269 to pack the instructions into REGISTER_SIZE units (and
1270 so will RISC machines for which INSTRUCTION_SIZE is not
1273 NOTE: This is pretty stupid. CALL_DUMMY should be in strict
1274 target byte order. */
1276 static ULONGEST *dummy;
1280 struct type *value_type;
1281 unsigned char struct_return;
1282 CORE_ADDR struct_addr = 0;
1283 struct regcache *retbuf;
1284 struct cleanup *retbuf_cleanup;
1285 struct inferior_status *inf_status;
1286 struct cleanup *inf_status_cleanup;
1288 int using_gcc; /* Set to version of gcc in use, or zero if not gcc */
1290 struct type *param_type = NULL;
1291 struct type *ftype = check_typedef (SYMBOL_TYPE (function));
1292 int n_method_args = 0;
1294 dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
1295 sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
1296 dummy1 = alloca (sizeof_dummy1);
1297 memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
1299 if (!target_has_execution)
1302 /* Create a cleanup chain that contains the retbuf (buffer
1303 containing the register values). This chain is create BEFORE the
1304 inf_status chain so that the inferior status can cleaned up
1305 (restored or discarded) without having the retbuf freed. */
1306 retbuf = regcache_xmalloc (current_gdbarch);
1307 retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1309 /* A cleanup for the inferior status. Create this AFTER the retbuf
1310 so that this can be discarded or applied without interfering with
1312 inf_status = save_inferior_status (1);
1313 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
1315 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1316 (and POP_FRAME for restoring them). (At least on most machines)
1317 they are saved on the stack in the inferior. */
1320 old_sp = read_sp ();
1322 /* Ensure that the initial SP is correctly aligned. */
1323 if (gdbarch_frame_align_p (current_gdbarch))
1325 /* NOTE: cagney/2002-09-18:
1327 On a RISC architecture, a void parameterless generic dummy
1328 frame (i.e., no parameters, no result) typically does not
1329 need to push anything the stack and hence can leave SP and
1330 FP. Similarly, a framelss (possibly leaf) function does not
1331 push anything on the stack and, hence, that too can leave FP
1332 and SP unchanged. As a consequence, a sequence of void
1333 parameterless generic dummy frame calls to frameless
1334 functions will create a sequence of effectively identical
1335 frames (SP, FP and TOS and PC the same). This, not
1336 suprisingly, results in what appears to be a stack in an
1337 infinite loop --- when GDB tries to find a generic dummy
1338 frame on the internal dummy frame stack, it will always find
1341 To avoid this problem, the code below always grows the stack.
1342 That way, two dummy frames can never be identical. It does
1343 burn a few bytes of stack but that is a small price to pay
1345 sp = gdbarch_frame_align (current_gdbarch, old_sp);
1348 if (INNER_THAN (1, 2))
1349 /* Stack grows down. */
1350 sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
1352 /* Stack grows up. */
1353 sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
1355 gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp)
1356 || (INNER_THAN (2, 1) && sp >= old_sp));
1359 /* FIXME: cagney/2002-09-18: Hey, you loose! Who knows how badly
1360 aligned the SP is! Further, per comment above, if the generic
1361 dummy frame ends up empty (because nothing is pushed) GDB won't
1362 be able to correctly perform back traces. If a target is
1363 having trouble with backtraces, first thing to do is add
1364 FRAME_ALIGN() to its architecture vector. After that, try
1365 adding SAVE_DUMMY_FRAME_TOS() and modifying FRAME_CHAIN so that
1366 when the next outer frame is a generic dummy, it returns the
1367 current frame's base. */
1370 if (INNER_THAN (1, 2))
1372 /* Stack grows down */
1373 sp -= sizeof_dummy1;
1378 /* Stack grows up */
1380 sp += sizeof_dummy1;
1383 /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
1384 after allocating space for the call dummy. A target can specify
1385 a SIZEOF_DUMMY1 (via SIZEOF_CALL_DUMMY_WORDS) such that all local
1386 alignment requirements are met. */
1388 funaddr = find_function_addr (function, &value_type);
1389 CHECK_TYPEDEF (value_type);
1392 struct block *b = block_for_pc (funaddr);
1393 /* If compiled without -g, assume GCC 2. */
1394 using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
1397 /* Are we returning a value using a structure return or a normal
1400 struct_return = using_struct_return (function, funaddr, value_type,
1403 /* Create a call sequence customized for this function
1404 and the number of arguments for it. */
1405 for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
1406 store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1408 (ULONGEST) dummy[i]);
1410 #ifdef GDB_TARGET_IS_HPPA
1411 real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1412 value_type, using_gcc);
1414 FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1415 value_type, using_gcc);
1419 if (CALL_DUMMY_LOCATION == ON_STACK)
1421 write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
1422 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1423 generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
1426 if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
1428 /* Convex Unix prohibits executing in the stack segment. */
1429 /* Hope there is empty room at the top of the text segment. */
1430 extern CORE_ADDR text_end;
1431 static int checked = 0;
1433 for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
1434 if (read_memory_integer (start_sp, 1) != 0)
1435 error ("text segment full -- no place to put call");
1438 real_pc = text_end - sizeof_dummy1;
1439 write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1440 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1441 generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
1444 if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
1446 extern CORE_ADDR text_end;
1450 errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1452 error ("Cannot write text segment -- call_function failed");
1453 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1454 generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
1457 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
1460 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
1461 /* NOTE: cagney/2002-04-13: The entry point is going to be
1462 modified with a single breakpoint. */
1463 generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (),
1464 CALL_DUMMY_ADDRESS () + 1);
1468 sp = old_sp; /* It really is used, for some ifdef's... */
1471 if (nargs < TYPE_NFIELDS (ftype))
1472 error ("too few arguments in function call");
1474 for (i = nargs - 1; i >= 0; i--)
1478 /* FIXME drow/2002-05-31: Should just always mark methods as
1479 prototyped. Can we respect TYPE_VARARGS? Probably not. */
1480 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1483 prototyped = TYPE_PROTOTYPED (ftype);
1485 if (i < TYPE_NFIELDS (ftype))
1486 args[i] = value_arg_coerce (args[i], TYPE_FIELD_TYPE (ftype, i),
1489 args[i] = value_arg_coerce (args[i], NULL, 0);
1491 /*elz: this code is to handle the case in which the function to be called
1492 has a pointer to function as parameter and the corresponding actual argument
1493 is the address of a function and not a pointer to function variable.
1494 In aCC compiled code, the calls through pointers to functions (in the body
1495 of the function called by hand) are made via $$dyncall_external which
1496 requires some registers setting, this is taken care of if we call
1497 via a function pointer variable, but not via a function address.
1498 In cc this is not a problem. */
1501 if (param_type && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
1502 /* if this parameter is a pointer to function */
1503 if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
1504 if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
1505 /* elz: FIXME here should go the test about the compiler used
1506 to compile the target. We want to issue the error
1507 message only if the compiler used was HP's aCC.
1508 If we used HP's cc, then there is no problem and no need
1509 to return at this point */
1510 if (using_gcc == 0) /* && compiler == aCC */
1511 /* go see if the actual parameter is a variable of type
1512 pointer to function or just a function */
1513 if (args[i]->lval == not_lval)
1516 if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
1518 You cannot use function <%s> as argument. \n\
1519 You must use a pointer to function type variable. Command ignored.", arg_name);
1523 if (REG_STRUCT_HAS_ADDR_P ())
1525 /* This is a machine like the sparc, where we may need to pass a
1526 pointer to the structure, not the structure itself. */
1527 for (i = nargs - 1; i >= 0; i--)
1529 struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
1530 if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
1531 || TYPE_CODE (arg_type) == TYPE_CODE_UNION
1532 || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1533 || TYPE_CODE (arg_type) == TYPE_CODE_STRING
1534 || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
1535 || TYPE_CODE (arg_type) == TYPE_CODE_SET
1536 || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
1537 && TYPE_LENGTH (arg_type) > 8)
1539 && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
1542 int len; /* = TYPE_LENGTH (arg_type); */
1544 arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
1545 len = TYPE_LENGTH (arg_type);
1547 if (STACK_ALIGN_P ())
1548 /* MVS 11/22/96: I think at least some of this
1549 stack_align code is really broken. Better to let
1550 PUSH_ARGUMENTS adjust the stack in a target-defined
1552 aligned_len = STACK_ALIGN (len);
1555 if (INNER_THAN (1, 2))
1557 /* stack grows downward */
1559 /* ... so the address of the thing we push is the
1560 stack pointer after we push it. */
1565 /* The stack grows up, so the address of the thing
1566 we push is the stack pointer before we push it. */
1570 /* Push the structure. */
1571 write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
1572 /* The value we're going to pass is the address of the
1573 thing we just pushed. */
1574 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1576 args[i] = value_from_pointer (lookup_pointer_type (arg_type),
1583 /* Reserve space for the return structure to be written on the
1584 stack, if necessary. Make certain that the value is correctly
1589 int len = TYPE_LENGTH (value_type);
1590 if (STACK_ALIGN_P ())
1591 /* MVS 11/22/96: I think at least some of this stack_align
1592 code is really broken. Better to let PUSH_ARGUMENTS adjust
1593 the stack in a target-defined manner. */
1594 len = STACK_ALIGN (len);
1595 if (INNER_THAN (1, 2))
1597 /* Stack grows downward. Align STRUCT_ADDR and SP after
1598 making space for the return value. */
1600 if (gdbarch_frame_align_p (current_gdbarch))
1601 sp = gdbarch_frame_align (current_gdbarch, sp);
1606 /* Stack grows upward. Align the frame, allocate space, and
1607 then again, re-align the frame??? */
1608 if (gdbarch_frame_align_p (current_gdbarch))
1609 sp = gdbarch_frame_align (current_gdbarch, sp);
1612 if (gdbarch_frame_align_p (current_gdbarch))
1613 sp = gdbarch_frame_align (current_gdbarch, sp);
1617 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1618 on other architectures. This is because all the alignment is
1619 taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
1620 in hppa_push_arguments */
1621 if (EXTRA_STACK_ALIGNMENT_NEEDED)
1623 /* MVS 11/22/96: I think at least some of this stack_align code
1624 is really broken. Better to let PUSH_ARGUMENTS adjust the
1625 stack in a target-defined manner. */
1626 if (STACK_ALIGN_P () && INNER_THAN (1, 2))
1628 /* If stack grows down, we must leave a hole at the top. */
1631 for (i = nargs - 1; i >= 0; i--)
1632 len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
1633 if (CALL_DUMMY_STACK_ADJUST_P)
1634 len += CALL_DUMMY_STACK_ADJUST;
1635 sp -= STACK_ALIGN (len) - len;
1639 sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
1641 if (PUSH_RETURN_ADDRESS_P ())
1642 /* for targets that use no CALL_DUMMY */
1643 /* There are a number of targets now which actually don't write
1644 any CALL_DUMMY instructions into the target, but instead just
1645 save the machine state, push the arguments, and jump directly
1646 to the callee function. Since this doesn't actually involve
1647 executing a JSR/BSR instruction, the return address must be set
1648 up by hand, either by pushing onto the stack or copying into a
1649 return-address register as appropriate. Formerly this has been
1650 done in PUSH_ARGUMENTS, but that's overloading its
1651 functionality a bit, so I'm making it explicit to do it here. */
1652 sp = PUSH_RETURN_ADDRESS (real_pc, sp);
1654 if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
1656 /* If stack grows up, we must leave a hole at the bottom, note
1657 that sp already has been advanced for the arguments! */
1658 if (CALL_DUMMY_STACK_ADJUST_P)
1659 sp += CALL_DUMMY_STACK_ADJUST;
1660 sp = STACK_ALIGN (sp);
1663 /* XXX This seems wrong. For stacks that grow down we shouldn't do
1665 /* MVS 11/22/96: I think at least some of this stack_align code is
1666 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1667 a target-defined manner. */
1668 if (CALL_DUMMY_STACK_ADJUST_P)
1669 if (INNER_THAN (1, 2))
1671 /* stack grows downward */
1672 sp -= CALL_DUMMY_STACK_ADJUST;
1675 /* Store the address at which the structure is supposed to be
1676 written. Note that this (and the code which reserved the space
1677 above) assumes that gcc was used to compile this function. Since
1678 it doesn't cost us anything but space and if the function is pcc
1679 it will ignore this value, we will make that assumption.
1681 Also note that on some machines (like the sparc) pcc uses a
1682 convention like gcc's. */
1685 STORE_STRUCT_RETURN (struct_addr, sp);
1687 /* Write the stack pointer. This is here because the statements above
1688 might fool with it. On SPARC, this write also stores the register
1689 window into the right place in the new stack frame, which otherwise
1690 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1693 if (SAVE_DUMMY_FRAME_TOS_P ())
1694 SAVE_DUMMY_FRAME_TOS (sp);
1698 struct symbol *symbol;
1701 symbol = find_pc_function (funaddr);
1704 name = SYMBOL_SOURCE_NAME (symbol);
1708 /* Try the minimal symbols. */
1709 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1713 name = SYMBOL_SOURCE_NAME (msymbol);
1719 sprintf (format, "at %s", local_hex_format ());
1721 /* FIXME-32x64: assumes funaddr fits in a long. */
1722 sprintf (name, format, (unsigned long) funaddr);
1725 /* Execute the stack dummy routine, calling FUNCTION.
1726 When it is done, discard the empty frame
1727 after storing the contents of all regs into retbuf. */
1728 rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
1732 /* We stopped inside the FUNCTION because of a random signal.
1733 Further execution of the FUNCTION is not allowed. */
1735 if (unwind_on_signal_p)
1737 /* The user wants the context restored. */
1739 /* We must get back to the frame we were before the dummy call. */
1742 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1743 a C++ name with arguments and stuff. */
1745 The program being debugged was signaled while in a function called from GDB.\n\
1746 GDB has restored the context to what it was before the call.\n\
1747 To change this behavior use \"set unwindonsignal off\"\n\
1748 Evaluation of the expression containing the function (%s) will be abandoned.",
1753 /* The user wants to stay in the frame where we stopped (default).*/
1755 /* If we restored the inferior status (via the cleanup),
1756 we would print a spurious error message (Unable to
1757 restore previously selected frame), would write the
1758 registers from the inf_status (which is wrong), and
1759 would do other wrong things. */
1760 discard_cleanups (inf_status_cleanup);
1761 discard_inferior_status (inf_status);
1763 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1764 a C++ name with arguments and stuff. */
1766 The program being debugged was signaled while in a function called from GDB.\n\
1767 GDB remains in the frame where the signal was received.\n\
1768 To change this behavior use \"set unwindonsignal on\"\n\
1769 Evaluation of the expression containing the function (%s) will be abandoned.",
1776 /* We hit a breakpoint inside the FUNCTION. */
1778 /* If we restored the inferior status (via the cleanup), we
1779 would print a spurious error message (Unable to restore
1780 previously selected frame), would write the registers from
1781 the inf_status (which is wrong), and would do other wrong
1783 discard_cleanups (inf_status_cleanup);
1784 discard_inferior_status (inf_status);
1786 /* The following error message used to say "The expression
1787 which contained the function call has been discarded." It
1788 is a hard concept to explain in a few words. Ideally, GDB
1789 would be able to resume evaluation of the expression when
1790 the function finally is done executing. Perhaps someday
1791 this will be implemented (it would not be easy). */
1793 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1794 a C++ name with arguments and stuff. */
1796 The program being debugged stopped while in a function called from GDB.\n\
1797 When the function (%s) is done executing, GDB will silently\n\
1798 stop (instead of continuing to evaluate the expression containing\n\
1799 the function call).", name);
1802 /* If we get here the called FUNCTION run to completion. */
1804 /* Restore the inferior status, via its cleanup. At this stage,
1805 leave the RETBUF alone. */
1806 do_cleanups (inf_status_cleanup);
1808 /* Figure out the value returned by the function. */
1809 /* elz: I defined this new macro for the hppa architecture only.
1810 this gives us a way to get the value returned by the function
1811 from the stack, at the same address we told the function to put
1812 it. We cannot assume on the pa that r28 still contains the
1813 address of the returned structure. Usually this will be
1814 overwritten by the callee. I don't know about other
1815 architectures, so I defined this macro */
1816 #ifdef VALUE_RETURNED_FROM_STACK
1819 do_cleanups (retbuf_cleanup);
1820 return VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
1823 /* NOTE: cagney/2002-09-10: Only when the stack has been correctly
1824 aligned (using frame_align()) do we can trust STRUCT_ADDR and
1825 fetch the return value direct from the stack. This lack of
1826 trust comes about because legacy targets have a nasty habit of
1827 silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR.
1828 For such targets, just hope that value_being_returned() can
1829 find the adjusted value. */
1830 if (struct_return && gdbarch_frame_align_p (current_gdbarch))
1832 struct value *retval = value_at (value_type, struct_addr, NULL);
1833 do_cleanups (retbuf_cleanup);
1838 struct value *retval = value_being_returned (value_type, retbuf,
1840 do_cleanups (retbuf_cleanup);
1847 call_function_by_hand (struct value *function, int nargs, struct value **args)
1851 return hand_function_call (function, nargs, args);
1855 error ("Cannot invoke functions on this machine.");
1861 /* Create a value for an array by allocating space in the inferior, copying
1862 the data into that space, and then setting up an array value.
1864 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1865 populated from the values passed in ELEMVEC.
1867 The element type of the array is inherited from the type of the
1868 first element, and all elements must have the same size (though we
1869 don't currently enforce any restriction on their types). */
1872 value_array (int lowbound, int highbound, struct value **elemvec)
1876 unsigned int typelength;
1878 struct type *rangetype;
1879 struct type *arraytype;
1882 /* Validate that the bounds are reasonable and that each of the elements
1883 have the same size. */
1885 nelem = highbound - lowbound + 1;
1888 error ("bad array bounds (%d, %d)", lowbound, highbound);
1890 typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1891 for (idx = 1; idx < nelem; idx++)
1893 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1895 error ("array elements must all be the same size");
1899 rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1900 lowbound, highbound);
1901 arraytype = create_array_type ((struct type *) NULL,
1902 VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1904 if (!current_language->c_style_arrays)
1906 val = allocate_value (arraytype);
1907 for (idx = 0; idx < nelem; idx++)
1909 memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1910 VALUE_CONTENTS_ALL (elemvec[idx]),
1913 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1917 /* Allocate space to store the array in the inferior, and then initialize
1918 it by copying in each element. FIXME: Is it worth it to create a
1919 local buffer in which to collect each value and then write all the
1920 bytes in one operation? */
1922 addr = allocate_space_in_inferior (nelem * typelength);
1923 for (idx = 0; idx < nelem; idx++)
1925 write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1929 /* Create the array type and set up an array value to be evaluated lazily. */
1931 val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1935 /* Create a value for a string constant by allocating space in the inferior,
1936 copying the data into that space, and returning the address with type
1937 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1939 Note that string types are like array of char types with a lower bound of
1940 zero and an upper bound of LEN - 1. Also note that the string may contain
1941 embedded null bytes. */
1944 value_string (char *ptr, int len)
1947 int lowbound = current_language->string_lower_bound;
1948 struct type *rangetype = create_range_type ((struct type *) NULL,
1950 lowbound, len + lowbound - 1);
1951 struct type *stringtype
1952 = create_string_type ((struct type *) NULL, rangetype);
1955 if (current_language->c_style_arrays == 0)
1957 val = allocate_value (stringtype);
1958 memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1963 /* Allocate space to store the string in the inferior, and then
1964 copy LEN bytes from PTR in gdb to that address in the inferior. */
1966 addr = allocate_space_in_inferior (len);
1967 write_memory (addr, ptr, len);
1969 val = value_at_lazy (stringtype, addr, NULL);
1974 value_bitstring (char *ptr, int len)
1977 struct type *domain_type = create_range_type (NULL, builtin_type_int,
1979 struct type *type = create_set_type ((struct type *) NULL, domain_type);
1980 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1981 val = allocate_value (type);
1982 memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1986 /* See if we can pass arguments in T2 to a function which takes arguments
1987 of types T1. T1 is a list of NARGS arguments, and T2 is a NULL-terminated
1988 vector. If some arguments need coercion of some sort, then the coerced
1989 values are written into T2. Return value is 0 if the arguments could be
1990 matched, or the position at which they differ if not.
1992 STATICP is nonzero if the T1 argument list came from a
1993 static member function. T2 will still include the ``this'' pointer,
1994 but it will be skipped.
1996 For non-static member functions, we ignore the first argument,
1997 which is the type of the instance variable. This is because we want
1998 to handle calls with objects from derived classes. This is not
1999 entirely correct: we should actually check to make sure that a
2000 requested operation is type secure, shouldn't we? FIXME. */
2003 typecmp (int staticp, int varargs, int nargs,
2004 struct field t1[], struct value *t2[])
2009 internal_error (__FILE__, __LINE__, "typecmp: no argument list");
2011 /* Skip ``this'' argument if applicable. T2 will always include THIS. */
2016 (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
2019 struct type *tt1, *tt2;
2024 tt1 = check_typedef (t1[i].type);
2025 tt2 = check_typedef (VALUE_TYPE (t2[i]));
2027 if (TYPE_CODE (tt1) == TYPE_CODE_REF
2028 /* We should be doing hairy argument matching, as below. */
2029 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
2031 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
2032 t2[i] = value_coerce_array (t2[i]);
2034 t2[i] = value_addr (t2[i]);
2038 /* djb - 20000715 - Until the new type structure is in the
2039 place, and we can attempt things like implicit conversions,
2040 we need to do this so you can take something like a map<const
2041 char *>, and properly access map["hello"], because the
2042 argument to [] will be a reference to a pointer to a char,
2043 and the argument will be a pointer to a char. */
2044 while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
2045 TYPE_CODE (tt1) == TYPE_CODE_PTR)
2047 tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
2049 while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
2050 TYPE_CODE(tt2) == TYPE_CODE_PTR ||
2051 TYPE_CODE(tt2) == TYPE_CODE_REF)
2053 tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
2055 if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
2057 /* Array to pointer is a `trivial conversion' according to the ARM. */
2059 /* We should be doing much hairier argument matching (see section 13.2
2060 of the ARM), but as a quick kludge, just check for the same type
2062 if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i])))
2065 if (varargs || t2[i] == NULL)
2070 /* Helper function used by value_struct_elt to recurse through baseclasses.
2071 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2072 and search in it assuming it has (class) type TYPE.
2073 If found, return value, else return NULL.
2075 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
2076 look for a baseclass named NAME. */
2078 static struct value *
2079 search_struct_field (char *name, struct value *arg1, int offset,
2080 register struct type *type, int looking_for_baseclass)
2083 int nbases = TYPE_N_BASECLASSES (type);
2085 CHECK_TYPEDEF (type);
2087 if (!looking_for_baseclass)
2088 for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
2090 char *t_field_name = TYPE_FIELD_NAME (type, i);
2092 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2095 if (TYPE_FIELD_STATIC (type, i))
2097 v = value_static_field (type, i);
2099 error ("field %s is nonexistent or has been optimised out",
2104 v = value_primitive_field (arg1, offset, i, type);
2106 error ("there is no field named %s", name);
2112 && (t_field_name[0] == '\0'
2113 || (TYPE_CODE (type) == TYPE_CODE_UNION
2114 && (strcmp_iw (t_field_name, "else") == 0))))
2116 struct type *field_type = TYPE_FIELD_TYPE (type, i);
2117 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
2118 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
2120 /* Look for a match through the fields of an anonymous union,
2121 or anonymous struct. C++ provides anonymous unions.
2123 In the GNU Chill (now deleted from GDB)
2124 implementation of variant record types, each
2125 <alternative field> has an (anonymous) union type,
2126 each member of the union represents a <variant
2127 alternative>. Each <variant alternative> is
2128 represented as a struct, with a member for each
2132 int new_offset = offset;
2134 /* This is pretty gross. In G++, the offset in an
2135 anonymous union is relative to the beginning of the
2136 enclosing struct. In the GNU Chill (now deleted
2137 from GDB) implementation of variant records, the
2138 bitpos is zero in an anonymous union field, so we
2139 have to add the offset of the union here. */
2140 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
2141 || (TYPE_NFIELDS (field_type) > 0
2142 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
2143 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
2145 v = search_struct_field (name, arg1, new_offset, field_type,
2146 looking_for_baseclass);
2153 for (i = 0; i < nbases; i++)
2156 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2157 /* If we are looking for baseclasses, this is what we get when we
2158 hit them. But it could happen that the base part's member name
2159 is not yet filled in. */
2160 int found_baseclass = (looking_for_baseclass
2161 && TYPE_BASECLASS_NAME (type, i) != NULL
2162 && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0));
2164 if (BASETYPE_VIA_VIRTUAL (type, i))
2167 struct value *v2 = allocate_value (basetype);
2169 boffset = baseclass_offset (type, i,
2170 VALUE_CONTENTS (arg1) + offset,
2171 VALUE_ADDRESS (arg1)
2172 + VALUE_OFFSET (arg1) + offset);
2174 error ("virtual baseclass botch");
2176 /* The virtual base class pointer might have been clobbered by the
2177 user program. Make sure that it still points to a valid memory
2181 if (boffset < 0 || boffset >= TYPE_LENGTH (type))
2183 CORE_ADDR base_addr;
2185 base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
2186 if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
2187 TYPE_LENGTH (basetype)) != 0)
2188 error ("virtual baseclass botch");
2189 VALUE_LVAL (v2) = lval_memory;
2190 VALUE_ADDRESS (v2) = base_addr;
2194 VALUE_LVAL (v2) = VALUE_LVAL (arg1);
2195 VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
2196 VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
2197 if (VALUE_LAZY (arg1))
2198 VALUE_LAZY (v2) = 1;
2200 memcpy (VALUE_CONTENTS_RAW (v2),
2201 VALUE_CONTENTS_RAW (arg1) + boffset,
2202 TYPE_LENGTH (basetype));
2205 if (found_baseclass)
2207 v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
2208 looking_for_baseclass);
2210 else if (found_baseclass)
2211 v = value_primitive_field (arg1, offset, i, type);
2213 v = search_struct_field (name, arg1,
2214 offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2215 basetype, looking_for_baseclass);
2223 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2224 * in an object pointed to by VALADDR (on the host), assumed to be of
2225 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
2226 * looking (in case VALADDR is the contents of an enclosing object).
2228 * This routine recurses on the primary base of the derived class because
2229 * the virtual base entries of the primary base appear before the other
2230 * virtual base entries.
2232 * If the virtual base is not found, a negative integer is returned.
2233 * The magnitude of the negative integer is the number of entries in
2234 * the virtual table to skip over (entries corresponding to various
2235 * ancestral classes in the chain of primary bases).
2237 * Important: This assumes the HP / Taligent C++ runtime
2238 * conventions. Use baseclass_offset() instead to deal with g++
2242 find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
2243 int offset, int *boffset_p, int *skip_p)
2245 int boffset; /* offset of virtual base */
2246 int index; /* displacement to use in virtual table */
2250 CORE_ADDR vtbl; /* the virtual table pointer */
2251 struct type *pbc; /* the primary base class */
2253 /* Look for the virtual base recursively in the primary base, first.
2254 * This is because the derived class object and its primary base
2255 * subobject share the primary virtual table. */
2258 pbc = TYPE_PRIMARY_BASE (type);
2261 find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
2264 *boffset_p = boffset;
2273 /* Find the index of the virtual base according to HP/Taligent
2274 runtime spec. (Depth-first, left-to-right.) */
2275 index = virtual_base_index_skip_primaries (basetype, type);
2279 *skip_p = skip + virtual_base_list_length_skip_primaries (type);
2284 /* pai: FIXME -- 32x64 possible problem */
2285 /* First word (4 bytes) in object layout is the vtable pointer */
2286 vtbl = *(CORE_ADDR *) (valaddr + offset);
2288 /* Before the constructor is invoked, things are usually zero'd out. */
2290 error ("Couldn't find virtual table -- object may not be constructed yet.");
2293 /* Find virtual base's offset -- jump over entries for primary base
2294 * ancestors, then use the index computed above. But also adjust by
2295 * HP_ACC_VBASE_START for the vtable slots before the start of the
2296 * virtual base entries. Offset is negative -- virtual base entries
2297 * appear _before_ the address point of the virtual table. */
2299 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2302 /* epstein : FIXME -- added param for overlay section. May not be correct */
2303 vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
2304 boffset = value_as_long (vp);
2306 *boffset_p = boffset;
2311 /* Helper function used by value_struct_elt to recurse through baseclasses.
2312 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2313 and search in it assuming it has (class) type TYPE.
2314 If found, return value, else if name matched and args not return (value)-1,
2315 else return NULL. */
2317 static struct value *
2318 search_struct_method (char *name, struct value **arg1p,
2319 struct value **args, int offset,
2320 int *static_memfuncp, register struct type *type)
2324 int name_matched = 0;
2325 char dem_opname[64];
2327 CHECK_TYPEDEF (type);
2328 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2330 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2331 /* FIXME! May need to check for ARM demangling here */
2332 if (strncmp (t_field_name, "__", 2) == 0 ||
2333 strncmp (t_field_name, "op", 2) == 0 ||
2334 strncmp (t_field_name, "type", 4) == 0)
2336 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2337 t_field_name = dem_opname;
2338 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2339 t_field_name = dem_opname;
2341 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2343 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2344 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2347 check_stub_method_group (type, i);
2348 if (j > 0 && args == 0)
2349 error ("cannot resolve overloaded method `%s': no arguments supplied", name);
2350 else if (j == 0 && args == 0)
2352 v = value_fn_field (arg1p, f, j, type, offset);
2359 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2360 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2361 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2362 TYPE_FN_FIELD_ARGS (f, j), args))
2364 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2365 return value_virtual_fn_field (arg1p, f, j, type, offset);
2366 if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
2367 *static_memfuncp = 1;
2368 v = value_fn_field (arg1p, f, j, type, offset);
2377 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2381 if (BASETYPE_VIA_VIRTUAL (type, i))
2383 if (TYPE_HAS_VTABLE (type))
2385 /* HP aCC compiled type, search for virtual base offset
2386 according to HP/Taligent runtime spec. */
2388 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2389 VALUE_CONTENTS_ALL (*arg1p),
2390 offset + VALUE_EMBEDDED_OFFSET (*arg1p),
2391 &base_offset, &skip);
2393 error ("Virtual base class offset not found in vtable");
2397 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2400 /* The virtual base class pointer might have been clobbered by the
2401 user program. Make sure that it still points to a valid memory
2404 if (offset < 0 || offset >= TYPE_LENGTH (type))
2406 base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
2407 if (target_read_memory (VALUE_ADDRESS (*arg1p)
2408 + VALUE_OFFSET (*arg1p) + offset,
2410 TYPE_LENGTH (baseclass)) != 0)
2411 error ("virtual baseclass botch");
2414 base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
2417 baseclass_offset (type, i, base_valaddr,
2418 VALUE_ADDRESS (*arg1p)
2419 + VALUE_OFFSET (*arg1p) + offset);
2420 if (base_offset == -1)
2421 error ("virtual baseclass botch");
2426 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2428 v = search_struct_method (name, arg1p, args, base_offset + offset,
2429 static_memfuncp, TYPE_BASECLASS (type, i));
2430 if (v == (struct value *) - 1)
2436 /* FIXME-bothner: Why is this commented out? Why is it here? */
2437 /* *arg1p = arg1_tmp; */
2442 return (struct value *) - 1;
2447 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2448 extract the component named NAME from the ultimate target structure/union
2449 and return it as a value with its appropriate type.
2450 ERR is used in the error message if *ARGP's type is wrong.
2452 C++: ARGS is a list of argument types to aid in the selection of
2453 an appropriate method. Also, handle derived types.
2455 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2456 where the truthvalue of whether the function that was resolved was
2457 a static member function or not is stored.
2459 ERR is an error message to be printed in case the field is not found. */
2462 value_struct_elt (struct value **argp, struct value **args,
2463 char *name, int *static_memfuncp, char *err)
2465 register struct type *t;
2468 COERCE_ARRAY (*argp);
2470 t = check_typedef (VALUE_TYPE (*argp));
2472 /* Follow pointers until we get to a non-pointer. */
2474 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2476 *argp = value_ind (*argp);
2477 /* Don't coerce fn pointer to fn and then back again! */
2478 if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2479 COERCE_ARRAY (*argp);
2480 t = check_typedef (VALUE_TYPE (*argp));
2483 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2484 error ("not implemented: member type in value_struct_elt");
2486 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2487 && TYPE_CODE (t) != TYPE_CODE_UNION)
2488 error ("Attempt to extract a component of a value that is not a %s.", err);
2490 /* Assume it's not, unless we see that it is. */
2491 if (static_memfuncp)
2492 *static_memfuncp = 0;
2496 /* if there are no arguments ...do this... */
2498 /* Try as a field first, because if we succeed, there
2499 is less work to be done. */
2500 v = search_struct_field (name, *argp, 0, t, 0);
2504 /* C++: If it was not found as a data field, then try to
2505 return it as a pointer to a method. */
2507 if (destructor_name_p (name, t))
2508 error ("Cannot get value of destructor");
2510 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2512 if (v == (struct value *) - 1)
2513 error ("Cannot take address of a method");
2516 if (TYPE_NFN_FIELDS (t))
2517 error ("There is no member or method named %s.", name);
2519 error ("There is no member named %s.", name);
2524 if (destructor_name_p (name, t))
2528 /* Destructors are a special case. */
2529 int m_index, f_index;
2532 if (get_destructor_fn_field (t, &m_index, &f_index))
2534 v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
2538 error ("could not find destructor function named %s.", name);
2544 error ("destructor should not have any argument");
2548 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2550 if (v == (struct value *) - 1)
2552 error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
2556 /* See if user tried to invoke data as function. If so,
2557 hand it back. If it's not callable (i.e., a pointer to function),
2558 gdb should give an error. */
2559 v = search_struct_field (name, *argp, 0, t, 0);
2563 error ("Structure has no component named %s.", name);
2567 /* Search through the methods of an object (and its bases)
2568 * to find a specified method. Return the pointer to the
2569 * fn_field list of overloaded instances.
2570 * Helper function for value_find_oload_list.
2571 * ARGP is a pointer to a pointer to a value (the object)
2572 * METHOD is a string containing the method name
2573 * OFFSET is the offset within the value
2574 * TYPE is the assumed type of the object
2575 * NUM_FNS is the number of overloaded instances
2576 * BASETYPE is set to the actual type of the subobject where the method is found
2577 * BOFFSET is the offset of the base subobject where the method is found */
2579 static struct fn_field *
2580 find_method_list (struct value **argp, char *method, int offset,
2581 struct type *type, int *num_fns,
2582 struct type **basetype, int *boffset)
2586 CHECK_TYPEDEF (type);
2590 /* First check in object itself */
2591 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2593 /* pai: FIXME What about operators and type conversions? */
2594 char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2595 if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2597 int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2598 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2604 /* Resolve any stub methods. */
2605 check_stub_method_group (type, i);
2611 /* Not found in object, check in base subobjects */
2612 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2615 if (BASETYPE_VIA_VIRTUAL (type, i))
2617 if (TYPE_HAS_VTABLE (type))
2619 /* HP aCC compiled type, search for virtual base offset
2620 * according to HP/Taligent runtime spec. */
2622 find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2623 VALUE_CONTENTS_ALL (*argp),
2624 offset + VALUE_EMBEDDED_OFFSET (*argp),
2625 &base_offset, &skip);
2627 error ("Virtual base class offset not found in vtable");
2631 /* probably g++ runtime model */
2632 base_offset = VALUE_OFFSET (*argp) + offset;
2634 baseclass_offset (type, i,
2635 VALUE_CONTENTS (*argp) + base_offset,
2636 VALUE_ADDRESS (*argp) + base_offset);
2637 if (base_offset == -1)
2638 error ("virtual baseclass botch");
2642 /* non-virtual base, simply use bit position from debug info */
2644 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2646 f = find_method_list (argp, method, base_offset + offset,
2647 TYPE_BASECLASS (type, i), num_fns, basetype,
2655 /* Return the list of overloaded methods of a specified name.
2656 * ARGP is a pointer to a pointer to a value (the object)
2657 * METHOD is the method name
2658 * OFFSET is the offset within the value contents
2659 * NUM_FNS is the number of overloaded instances
2660 * BASETYPE is set to the type of the base subobject that defines the method
2661 * BOFFSET is the offset of the base subobject which defines the method */
2664 value_find_oload_method_list (struct value **argp, char *method, int offset,
2665 int *num_fns, struct type **basetype,
2670 t = check_typedef (VALUE_TYPE (*argp));
2672 /* code snarfed from value_struct_elt */
2673 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2675 *argp = value_ind (*argp);
2676 /* Don't coerce fn pointer to fn and then back again! */
2677 if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2678 COERCE_ARRAY (*argp);
2679 t = check_typedef (VALUE_TYPE (*argp));
2682 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2683 error ("Not implemented: member type in value_find_oload_lis");
2685 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2686 && TYPE_CODE (t) != TYPE_CODE_UNION)
2687 error ("Attempt to extract a component of a value that is not a struct or union");
2689 return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
2692 /* Given an array of argument types (ARGTYPES) (which includes an
2693 entry for "this" in the case of C++ methods), the number of
2694 arguments NARGS, the NAME of a function whether it's a method or
2695 not (METHOD), and the degree of laxness (LAX) in conforming to
2696 overload resolution rules in ANSI C++, find the best function that
2697 matches on the argument types according to the overload resolution
2700 In the case of class methods, the parameter OBJ is an object value
2701 in which to search for overloaded methods.
2703 In the case of non-method functions, the parameter FSYM is a symbol
2704 corresponding to one of the overloaded functions.
2706 Return value is an integer: 0 -> good match, 10 -> debugger applied
2707 non-standard coercions, 100 -> incompatible.
2709 If a method is being searched for, VALP will hold the value.
2710 If a non-method is being searched for, SYMP will hold the symbol for it.
2712 If a method is being searched for, and it is a static method,
2713 then STATICP will point to a non-zero value.
2715 Note: This function does *not* check the value of
2716 overload_resolution. Caller must check it to see whether overload
2717 resolution is permitted.
2721 find_overload_match (struct type **arg_types, int nargs, char *name, int method,
2722 int lax, struct value **objp, struct symbol *fsym,
2723 struct value **valp, struct symbol **symp, int *staticp)
2726 struct type **parm_types;
2727 int champ_nparms = 0;
2728 struct value *obj = (objp ? *objp : NULL);
2730 short oload_champ = -1; /* Index of best overloaded function */
2731 short oload_ambiguous = 0; /* Current ambiguity state for overload resolution */
2732 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2733 short oload_ambig_champ = -1; /* 2nd contender for best match */
2734 short oload_non_standard = 0; /* did we have to use non-standard conversions? */
2735 short oload_incompatible = 0; /* are args supplied incompatible with any function? */
2737 struct badness_vector *bv; /* A measure of how good an overloaded instance is */
2738 struct badness_vector *oload_champ_bv = NULL; /* The measure for the current best match */
2740 struct value *temp = obj;
2741 struct fn_field *fns_ptr = NULL; /* For methods, the list of overloaded methods */
2742 struct symbol **oload_syms = NULL; /* For non-methods, the list of overloaded function symbols */
2743 int num_fns = 0; /* Number of overloaded instances being considered */
2744 struct type *basetype = NULL;
2749 struct cleanup *cleanups = NULL;
2751 char *obj_type_name = NULL;
2752 char *func_name = NULL;
2754 /* Get the list of overloaded methods or functions */
2757 obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
2758 /* Hack: evaluate_subexp_standard often passes in a pointer
2759 value rather than the object itself, so try again */
2760 if ((!obj_type_name || !*obj_type_name) &&
2761 (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
2762 obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
2764 fns_ptr = value_find_oload_method_list (&temp, name, 0,
2766 &basetype, &boffset);
2767 if (!fns_ptr || !num_fns)
2768 error ("Couldn't find method %s%s%s",
2770 (obj_type_name && *obj_type_name) ? "::" : "",
2772 /* If we are dealing with stub method types, they should have
2773 been resolved by find_method_list via value_find_oload_method_list
2775 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2780 func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
2782 /* If the name is NULL this must be a C-style function.
2783 Just return the same symbol. */
2790 oload_syms = make_symbol_overload_list (fsym);
2791 cleanups = make_cleanup (xfree, oload_syms);
2792 while (oload_syms[++i])
2795 error ("Couldn't find function %s", func_name);
2798 oload_champ_bv = NULL;
2800 /* Consider each candidate in turn */
2801 for (ix = 0; ix < num_fns; ix++)
2806 if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix))
2808 nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2812 /* If it's not a method, this is the proper place */
2813 nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix]));
2816 /* Prepare array of parameter types */
2817 parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2818 for (jj = 0; jj < nparms; jj++)
2819 parm_types[jj] = (method
2820 ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2821 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj));
2823 /* Compare parameter types to supplied argument types. Skip THIS for
2825 bv = rank_function (parm_types, nparms, arg_types + static_offset,
2826 nargs - static_offset);
2828 if (!oload_champ_bv)
2830 oload_champ_bv = bv;
2832 champ_nparms = nparms;
2835 /* See whether current candidate is better or worse than previous best */
2836 switch (compare_badness (bv, oload_champ_bv))
2839 oload_ambiguous = 1; /* top two contenders are equally good */
2840 oload_ambig_champ = ix;
2843 oload_ambiguous = 2; /* incomparable top contenders */
2844 oload_ambig_champ = ix;
2847 oload_champ_bv = bv; /* new champion, record details */
2848 oload_ambiguous = 0;
2850 oload_ambig_champ = -1;
2851 champ_nparms = nparms;
2861 fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2863 fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
2864 for (jj = 0; jj < nargs - static_offset; jj++)
2865 fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
2866 fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2868 } /* end loop over all candidates */
2869 /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2870 if they have the exact same goodness. This is because there is no
2871 way to differentiate based on return type, which we need to in
2872 cases like overloads of .begin() <It's both const and non-const> */
2874 if (oload_ambiguous)
2877 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2879 (obj_type_name && *obj_type_name) ? "::" : "",
2882 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2887 /* Check how bad the best match is. */
2889 if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2891 for (ix = 1; ix <= nargs - static_offset; ix++)
2893 if (oload_champ_bv->rank[ix] >= 100)
2894 oload_incompatible = 1; /* truly mismatched types */
2896 else if (oload_champ_bv->rank[ix] >= 10)
2897 oload_non_standard = 1; /* non-standard type conversions needed */
2899 if (oload_incompatible)
2902 error ("Cannot resolve method %s%s%s to any overloaded instance",
2904 (obj_type_name && *obj_type_name) ? "::" : "",
2907 error ("Cannot resolve function %s to any overloaded instance",
2910 else if (oload_non_standard)
2913 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2915 (obj_type_name && *obj_type_name) ? "::" : "",
2918 warning ("Using non-standard conversion to match function %s to supplied arguments",
2924 if (staticp && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2928 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2929 *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2931 *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2935 *symp = oload_syms[oload_champ];
2941 if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
2942 && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
2944 temp = value_addr (temp);
2948 if (cleanups != NULL)
2949 do_cleanups (cleanups);
2951 return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2954 /* C++: return 1 is NAME is a legitimate name for the destructor
2955 of type TYPE. If TYPE does not have a destructor, or
2956 if NAME is inappropriate for TYPE, an error is signaled. */
2958 destructor_name_p (const char *name, const struct type *type)
2960 /* destructors are a special case. */
2964 char *dname = type_name_no_tag (type);
2965 char *cp = strchr (dname, '<');
2968 /* Do not compare the template part for template classes. */
2970 len = strlen (dname);
2973 if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2974 error ("name of destructor must equal name of class");
2981 /* Helper function for check_field: Given TYPE, a structure/union,
2982 return 1 if the component named NAME from the ultimate
2983 target structure/union is defined, otherwise, return 0. */
2986 check_field_in (register struct type *type, const char *name)
2990 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2992 char *t_field_name = TYPE_FIELD_NAME (type, i);
2993 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2997 /* C++: If it was not found as a data field, then try to
2998 return it as a pointer to a method. */
3000 /* Destructors are a special case. */
3001 if (destructor_name_p (name, type))
3003 int m_index, f_index;
3005 return get_destructor_fn_field (type, &m_index, &f_index);
3008 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
3010 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
3014 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
3015 if (check_field_in (TYPE_BASECLASS (type, i), name))
3022 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
3023 return 1 if the component named NAME from the ultimate
3024 target structure/union is defined, otherwise, return 0. */
3027 check_field (struct value *arg1, const char *name)
3029 register struct type *t;
3031 COERCE_ARRAY (arg1);
3033 t = VALUE_TYPE (arg1);
3035 /* Follow pointers until we get to a non-pointer. */
3040 if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
3042 t = TYPE_TARGET_TYPE (t);
3045 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
3046 error ("not implemented: member type in check_field");
3048 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3049 && TYPE_CODE (t) != TYPE_CODE_UNION)
3050 error ("Internal error: `this' is not an aggregate");
3052 return check_field_in (t, name);
3055 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3056 return the address of this member as a "pointer to member"
3057 type. If INTYPE is non-null, then it will be the type
3058 of the member we are looking for. This will help us resolve
3059 "pointers to member functions". This function is used
3060 to resolve user expressions of the form "DOMAIN::NAME". */
3063 value_struct_elt_for_reference (struct type *domain, int offset,
3064 struct type *curtype, char *name,
3065 struct type *intype)
3067 register struct type *t = curtype;
3071 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3072 && TYPE_CODE (t) != TYPE_CODE_UNION)
3073 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
3075 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3077 char *t_field_name = TYPE_FIELD_NAME (t, i);
3079 if (t_field_name && STREQ (t_field_name, name))
3081 if (TYPE_FIELD_STATIC (t, i))
3083 v = value_static_field (t, i);
3085 error ("static field %s has been optimized out",
3089 if (TYPE_FIELD_PACKED (t, i))
3090 error ("pointers to bitfield members not allowed");
3092 return value_from_longest
3093 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
3095 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3099 /* C++: If it was not found as a data field, then try to
3100 return it as a pointer to a method. */
3102 /* Destructors are a special case. */
3103 if (destructor_name_p (name, t))
3105 error ("member pointers to destructors not implemented yet");
3108 /* Perform all necessary dereferencing. */
3109 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3110 intype = TYPE_TARGET_TYPE (intype);
3112 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3114 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3115 char dem_opname[64];
3117 if (strncmp (t_field_name, "__", 2) == 0 ||
3118 strncmp (t_field_name, "op", 2) == 0 ||
3119 strncmp (t_field_name, "type", 4) == 0)
3121 if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
3122 t_field_name = dem_opname;
3123 else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
3124 t_field_name = dem_opname;
3126 if (t_field_name && STREQ (t_field_name, name))
3128 int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
3129 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3131 check_stub_method_group (t, i);
3133 if (intype == 0 && j > 1)
3134 error ("non-unique member `%s' requires type instantiation", name);
3138 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
3141 error ("no member function matches that type instantiation");
3146 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3148 return value_from_longest
3149 (lookup_reference_type
3150 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3152 (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
3156 struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3157 0, VAR_NAMESPACE, 0, NULL);
3164 v = read_var_value (s, 0);
3166 VALUE_TYPE (v) = lookup_reference_type
3167 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3175 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3180 if (BASETYPE_VIA_VIRTUAL (t, i))
3183 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3184 v = value_struct_elt_for_reference (domain,
3185 offset + base_offset,
3186 TYPE_BASECLASS (t, i),
3196 /* Given a pointer value V, find the real (RTTI) type
3197 of the object it points to.
3198 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3199 and refer to the values computed for the object pointed to. */
3202 value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc)
3204 struct value *target;
3206 target = value_ind (v);
3208 return value_rtti_type (target, full, top, using_enc);
3211 /* Given a value pointed to by ARGP, check its real run-time type, and
3212 if that is different from the enclosing type, create a new value
3213 using the real run-time type as the enclosing type (and of the same
3214 type as ARGP) and return it, with the embedded offset adjusted to
3215 be the correct offset to the enclosed object
3216 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3217 parameters, computed by value_rtti_type(). If these are available,
3218 they can be supplied and a second call to value_rtti_type() is avoided.
3219 (Pass RTYPE == NULL if they're not available */
3222 value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
3225 struct type *real_type;
3229 struct value *new_val;
3236 using_enc = xusing_enc;
3239 real_type = value_rtti_type (argp, &full, &top, &using_enc);
3241 /* If no RTTI data, or if object is already complete, do nothing */
3242 if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
3245 /* If we have the full object, but for some reason the enclosing
3246 type is wrong, set it *//* pai: FIXME -- sounds iffy */
3249 argp = value_change_enclosing_type (argp, real_type);
3253 /* Check if object is in memory */
3254 if (VALUE_LVAL (argp) != lval_memory)
3256 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
3261 /* All other cases -- retrieve the complete object */
3262 /* Go back by the computed top_offset from the beginning of the object,
3263 adjusting for the embedded offset of argp if that's what value_rtti_type
3264 used for its computation. */
3265 new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
3266 (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
3267 VALUE_BFD_SECTION (argp));
3268 VALUE_TYPE (new_val) = VALUE_TYPE (argp);
3269 VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
3276 /* Return the value of the local variable, if one exists.
3277 Flag COMPLAIN signals an error if the request is made in an
3278 inappropriate context. */
3281 value_of_local (const char *name, int complain)
3283 struct symbol *func, *sym;
3288 if (deprecated_selected_frame == 0)
3291 error ("no frame selected");
3296 func = get_frame_function (deprecated_selected_frame);
3300 error ("no `%s' in nameless context", name);
3305 b = SYMBOL_BLOCK_VALUE (func);
3306 i = BLOCK_NSYMS (b);
3310 error ("no args, no `%s'", name);
3315 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3316 symbol instead of the LOC_ARG one (if both exist). */
3317 sym = lookup_block_symbol (b, name, NULL, VAR_NAMESPACE);
3321 error ("current stack frame does not contain a variable named `%s'", name);
3326 ret = read_var_value (sym, deprecated_selected_frame);
3327 if (ret == 0 && complain)
3328 error ("`%s' argument unreadable", name);
3332 /* C++/Objective-C: return the value of the class instance variable,
3333 if one exists. Flag COMPLAIN signals an error if the request is
3334 made in an inappropriate context. */
3337 value_of_this (int complain)
3339 if (current_language->la_language == language_objc)
3340 return value_of_local ("self", complain);
3342 return value_of_local ("this", complain);
3345 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3346 long, starting at LOWBOUND. The result has the same lower bound as
3347 the original ARRAY. */
3350 value_slice (struct value *array, int lowbound, int length)
3352 struct type *slice_range_type, *slice_type, *range_type;
3353 LONGEST lowerbound, upperbound;
3354 struct value *slice;
3355 struct type *array_type;
3356 array_type = check_typedef (VALUE_TYPE (array));
3357 COERCE_VARYING_ARRAY (array, array_type);
3358 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3359 && TYPE_CODE (array_type) != TYPE_CODE_STRING
3360 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3361 error ("cannot take slice of non-array");
3362 range_type = TYPE_INDEX_TYPE (array_type);
3363 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3364 error ("slice from bad array or bitstring");
3365 if (lowbound < lowerbound || length < 0
3366 || lowbound + length - 1 > upperbound)
3367 error ("slice out of range");
3368 /* FIXME-type-allocation: need a way to free this type when we are
3370 slice_range_type = create_range_type ((struct type *) NULL,
3371 TYPE_TARGET_TYPE (range_type),
3372 lowbound, lowbound + length - 1);
3373 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3376 slice_type = create_set_type ((struct type *) NULL, slice_range_type);
3377 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3378 slice = value_zero (slice_type, not_lval);
3379 for (i = 0; i < length; i++)
3381 int element = value_bit_index (array_type,
3382 VALUE_CONTENTS (array),
3385 error ("internal error accessing bitstring");
3386 else if (element > 0)
3388 int j = i % TARGET_CHAR_BIT;
3389 if (BITS_BIG_ENDIAN)
3390 j = TARGET_CHAR_BIT - 1 - j;
3391 VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3394 /* We should set the address, bitssize, and bitspos, so the clice
3395 can be used on the LHS, but that may require extensions to
3396 value_assign. For now, just leave as a non_lval. FIXME. */
3400 struct type *element_type = TYPE_TARGET_TYPE (array_type);
3402 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3403 slice_type = create_array_type ((struct type *) NULL, element_type,
3405 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3406 slice = allocate_value (slice_type);
3407 if (VALUE_LAZY (array))
3408 VALUE_LAZY (slice) = 1;
3410 memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
3411 TYPE_LENGTH (slice_type));
3412 if (VALUE_LVAL (array) == lval_internalvar)
3413 VALUE_LVAL (slice) = lval_internalvar_component;
3415 VALUE_LVAL (slice) = VALUE_LVAL (array);
3416 VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
3417 VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
3422 /* Create a value for a FORTRAN complex number. Currently most of
3423 the time values are coerced to COMPLEX*16 (i.e. a complex number
3424 composed of 2 doubles. This really should be a smarter routine
3425 that figures out precision inteligently as opposed to assuming
3426 doubles. FIXME: fmb */
3429 value_literal_complex (struct value *arg1, struct value *arg2, struct type *type)
3432 struct type *real_type = TYPE_TARGET_TYPE (type);
3434 val = allocate_value (type);
3435 arg1 = value_cast (real_type, arg1);
3436 arg2 = value_cast (real_type, arg2);
3438 memcpy (VALUE_CONTENTS_RAW (val),
3439 VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
3440 memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
3441 VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
3445 /* Cast a value into the appropriate complex data type. */
3447 static struct value *
3448 cast_into_complex (struct type *type, struct value *val)
3450 struct type *real_type = TYPE_TARGET_TYPE (type);
3451 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
3453 struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
3454 struct value *re_val = allocate_value (val_real_type);
3455 struct value *im_val = allocate_value (val_real_type);
3457 memcpy (VALUE_CONTENTS_RAW (re_val),
3458 VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
3459 memcpy (VALUE_CONTENTS_RAW (im_val),
3460 VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
3461 TYPE_LENGTH (val_real_type));
3463 return value_literal_complex (re_val, im_val, type);
3465 else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
3466 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
3467 return value_literal_complex (val, value_zero (real_type, not_lval), type);
3469 error ("cannot cast non-number to complex");
3473 _initialize_valops (void)
3477 (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
3478 "Set automatic abandonment of expressions upon failure.",
3484 (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
3485 "Set overload resolution in evaluating C++ functions.",
3488 overload_resolution = 1;
3491 add_set_cmd ("unwindonsignal", no_class, var_boolean,
3492 (char *) &unwind_on_signal_p,
3493 "Set unwinding of stack if a signal is received while in a call dummy.\n\
3494 The unwindonsignal lets the user determine what gdb should do if a signal\n\
3495 is received while in a function called from gdb (call dummy). If set, gdb\n\
3496 unwinds the stack and restore the context to what as it was before the call.\n\
3497 The default is to stop in the frame where the signal was received.", &setlist),