1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
33 /* Local functions. */
36 typecmp
PARAMS ((int staticp
, struct type
*t1
[], value t2
[]));
39 find_function_addr
PARAMS ((value
, struct type
**));
42 value_push
PARAMS ((CORE_ADDR
, value
));
45 value_arg_push
PARAMS ((CORE_ADDR
, value
));
48 search_struct_field
PARAMS ((char *, value
, int, struct type
*, int));
51 search_struct_method
PARAMS ((char *, value
*, value
*, int, int *,
55 check_field_in
PARAMS ((struct type
*, const char *));
58 allocate_space_in_inferior
PARAMS ((int));
61 /* Allocate NBYTES of space in the inferior using the inferior's malloc
62 and return a value that is a pointer to the allocated space. */
65 allocate_space_in_inferior (len
)
69 register struct symbol
*sym
;
70 struct minimal_symbol
*msymbol
;
75 /* Find the address of malloc in the inferior. */
77 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
80 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
82 error ("\"malloc\" exists in this program but is not a function.");
84 val
= value_of_variable (sym
, NULL
);
88 msymbol
= lookup_minimal_symbol ("malloc", (struct objfile
*) NULL
);
91 type
= lookup_pointer_type (builtin_type_char
);
92 type
= lookup_function_type (type
);
93 type
= lookup_pointer_type (type
);
94 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
95 val
= value_from_longest (type
, maddr
);
99 error ("evaluation of this expression requires the program to have a function \"malloc\".");
103 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
104 val
= call_function_by_hand (val
, 1, &blocklen
);
105 if (value_logical_not (val
))
107 error ("No memory available to program.");
109 return (value_as_long (val
));
112 /* Cast value ARG2 to type TYPE and return as a value.
113 More general than a C cast: accepts any two types of the same length,
114 and if ARG2 is an lvalue it can be cast into anything at all. */
115 /* In C++, casts may change pointer or object representations. */
118 value_cast (type
, arg2
)
122 register enum type_code code1
;
123 register enum type_code code2
;
126 /* Coerce arrays but not enums. Enums will work as-is
127 and coercing them would cause an infinite recursion. */
128 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
131 code1
= TYPE_CODE (type
);
132 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
133 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
134 || code2
== TYPE_CODE_ENUM
);
136 if ( code1
== TYPE_CODE_STRUCT
137 && code2
== TYPE_CODE_STRUCT
138 && TYPE_NAME (type
) != 0)
140 /* Look in the type of the source to see if it contains the
141 type of the target as a superclass. If so, we'll need to
142 offset the object in addition to changing its type. */
143 value v
= search_struct_field (type_name_no_tag (type
),
144 arg2
, 0, VALUE_TYPE (arg2
), 1);
147 VALUE_TYPE (v
) = type
;
151 if (code1
== TYPE_CODE_FLT
&& scalar
)
152 return value_from_double (type
, value_as_double (arg2
));
153 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
)
154 && (scalar
|| code2
== TYPE_CODE_PTR
))
155 return value_from_longest (type
, value_as_long (arg2
));
156 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
158 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
160 /* Look in the type of the source to see if it contains the
161 type of the target as a superclass. If so, we'll need to
162 offset the pointer rather than just change its type. */
163 struct type
*t1
= TYPE_TARGET_TYPE (type
);
164 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
165 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
166 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
167 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
169 value v
= search_struct_field (type_name_no_tag (t1
),
170 value_ind (arg2
), 0, t2
, 1);
174 VALUE_TYPE (v
) = type
;
178 /* No superclass found, just fall through to change ptr type. */
180 VALUE_TYPE (arg2
) = type
;
183 else if (VALUE_LVAL (arg2
) == lval_memory
)
185 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
187 else if (code1
== TYPE_CODE_VOID
)
189 return value_zero (builtin_type_void
, not_lval
);
193 error ("Invalid cast.");
198 /* Create a value of type TYPE that is zero, and return it. */
201 value_zero (type
, lv
)
205 register value val
= allocate_value (type
);
207 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
208 VALUE_LVAL (val
) = lv
;
213 /* Return a value with type TYPE located at ADDR.
215 Call value_at only if the data needs to be fetched immediately;
216 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
217 value_at_lazy instead. value_at_lazy simply records the address of
218 the data and sets the lazy-evaluation-required flag. The lazy flag
219 is tested in the VALUE_CONTENTS macro, which is used if and when
220 the contents are actually required. */
223 value_at (type
, addr
)
227 register value val
= allocate_value (type
);
229 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
231 VALUE_LVAL (val
) = lval_memory
;
232 VALUE_ADDRESS (val
) = addr
;
237 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
240 value_at_lazy (type
, addr
)
244 register value val
= allocate_value (type
);
246 VALUE_LVAL (val
) = lval_memory
;
247 VALUE_ADDRESS (val
) = addr
;
248 VALUE_LAZY (val
) = 1;
253 /* Called only from the VALUE_CONTENTS macro, if the current data for
254 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
255 data from the user's process, and clears the lazy flag to indicate
256 that the data in the buffer is valid.
258 If the value is zero-length, we avoid calling read_memory, which would
259 abort. We mark the value as fetched anyway -- all 0 bytes of it.
261 This function returns a value because it is used in the VALUE_CONTENTS
262 macro as part of an expression, where a void would not work. The
266 value_fetch_lazy (val
)
269 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
271 if (TYPE_LENGTH (VALUE_TYPE (val
)))
272 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
273 TYPE_LENGTH (VALUE_TYPE (val
)));
274 VALUE_LAZY (val
) = 0;
279 /* Store the contents of FROMVAL into the location of TOVAL.
280 Return a new value with the location of TOVAL and contents of FROMVAL. */
283 value_assign (toval
, fromval
)
284 register value toval
, fromval
;
286 register struct type
*type
= VALUE_TYPE (toval
);
288 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
291 COERCE_ARRAY (fromval
);
294 if (VALUE_LVAL (toval
) != lval_internalvar
)
295 fromval
= value_cast (type
, fromval
);
297 /* If TOVAL is a special machine register requiring conversion
298 of program values to a special raw format,
299 convert FROMVAL's contents now, with result in `raw_buffer',
300 and set USE_BUFFER to the number of bytes to write. */
302 #ifdef REGISTER_CONVERTIBLE
303 if (VALUE_REGNO (toval
) >= 0
304 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
306 int regno
= VALUE_REGNO (toval
);
307 if (REGISTER_CONVERTIBLE (regno
))
309 REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval
), regno
,
310 VALUE_CONTENTS (fromval
), raw_buffer
);
311 use_buffer
= REGISTER_RAW_SIZE (regno
);
316 switch (VALUE_LVAL (toval
))
318 case lval_internalvar
:
319 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
322 case lval_internalvar_component
:
323 set_internalvar_component (VALUE_INTERNALVAR (toval
),
324 VALUE_OFFSET (toval
),
325 VALUE_BITPOS (toval
),
326 VALUE_BITSIZE (toval
),
331 if (VALUE_BITSIZE (toval
))
333 char buffer
[sizeof (LONGEST
)];
334 /* We assume that the argument to read_memory is in units of
335 host chars. FIXME: Is that correct? */
336 int len
= (VALUE_BITPOS (toval
)
337 + VALUE_BITSIZE (toval
)
341 if (len
> sizeof (LONGEST
))
342 error ("Can't handle bitfields which don't fit in a %d bit word.",
343 sizeof (LONGEST
) * HOST_CHAR_BIT
);
345 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
347 modify_field (buffer
, value_as_long (fromval
),
348 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
349 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
353 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
354 raw_buffer
, use_buffer
);
356 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
357 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
361 if (VALUE_BITSIZE (toval
))
363 char buffer
[sizeof (LONGEST
)];
364 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
366 if (len
> sizeof (LONGEST
))
367 error ("Can't handle bitfields in registers larger than %d bits.",
368 sizeof (LONGEST
) * HOST_CHAR_BIT
);
370 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
371 > len
* HOST_CHAR_BIT
)
372 /* Getting this right would involve being very careful about
375 Can't handle bitfield which doesn't fit in a single register.");
377 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
379 modify_field (buffer
, value_as_long (fromval
),
380 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
381 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
385 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
386 raw_buffer
, use_buffer
);
389 /* Do any conversion necessary when storing this type to more
390 than one register. */
391 #ifdef REGISTER_CONVERT_FROM_TYPE
392 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
393 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
394 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
395 raw_buffer
, TYPE_LENGTH (type
));
397 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
398 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
401 /* Assigning to the stack pointer, frame pointer, and other
402 (architecture and calling convention specific) registers may
403 cause the frame cache to be out of date. We just do this
404 on all assignments to registers for simplicity; I doubt the slowdown
406 reinit_frame_cache ();
409 case lval_reg_frame_relative
:
411 /* value is stored in a series of registers in the frame
412 specified by the structure. Copy that value out, modify
413 it, and copy it back in. */
414 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
415 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
416 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
417 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
420 /* Make the buffer large enough in all cases. */
421 char *buffer
= (char *) alloca (amount_to_copy
423 + MAX_REGISTER_RAW_SIZE
);
428 /* Figure out which frame this is in currently. */
429 for (frame
= get_current_frame ();
430 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
431 frame
= get_prev_frame (frame
))
435 error ("Value being assigned to is no longer active.");
437 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
440 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
442 amount_copied
< amount_to_copy
;
443 amount_copied
+= reg_size
, regno
++)
445 get_saved_register (buffer
+ amount_copied
,
446 (int *)NULL
, (CORE_ADDR
*)NULL
,
447 frame
, regno
, (enum lval_type
*)NULL
);
450 /* Modify what needs to be modified. */
451 if (VALUE_BITSIZE (toval
))
452 modify_field (buffer
+ byte_offset
,
453 value_as_long (fromval
),
454 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
456 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
458 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
462 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
464 amount_copied
< amount_to_copy
;
465 amount_copied
+= reg_size
, regno
++)
471 /* Just find out where to put it. */
472 get_saved_register ((char *)NULL
,
473 &optim
, &addr
, frame
, regno
, &lval
);
476 error ("Attempt to assign to a value that was optimized out.");
477 if (lval
== lval_memory
)
478 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
479 else if (lval
== lval_register
)
480 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
482 error ("Attempt to assign to an unmodifiable value.");
489 error ("Left side of = operation is not an lvalue.");
492 /* Return a value just like TOVAL except with the contents of FROMVAL
493 (except in the case of the type if TOVAL is an internalvar). */
495 if (VALUE_LVAL (toval
) == lval_internalvar
496 || VALUE_LVAL (toval
) == lval_internalvar_component
)
498 type
= VALUE_TYPE (fromval
);
501 val
= allocate_value (type
);
502 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
503 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
505 VALUE_TYPE (val
) = type
;
510 /* Extend a value VAL to COUNT repetitions of its type. */
513 value_repeat (arg1
, count
)
519 if (VALUE_LVAL (arg1
) != lval_memory
)
520 error ("Only values in memory can be extended with '@'.");
522 error ("Invalid number %d of repetitions.", count
);
524 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
526 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
527 VALUE_CONTENTS_RAW (val
),
528 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
529 VALUE_LVAL (val
) = lval_memory
;
530 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
536 value_of_variable (var
, b
)
544 /* Use selected frame. */
548 fr
= block_innermost_frame (b
);
549 if (fr
== NULL
&& symbol_read_needs_frame (var
))
551 if (BLOCK_FUNCTION (b
) != NULL
552 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
553 error ("No frame is currently executing in block %s.",
554 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
556 error ("No frame is currently executing in specified block");
559 val
= read_var_value (var
, fr
);
561 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
565 /* Given a value which is an array, return a value which is a pointer to its
566 first element, regardless of whether or not the array has a nonzero lower
569 FIXME: A previous comment here indicated that this routine should be
570 substracting the array's lower bound. It's not clear to me that this
571 is correct. Given an array subscripting operation, it would certainly
572 work to do the adjustment here, essentially computing:
574 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
576 However I believe a more appropriate and logical place to account for
577 the lower bound is to do so in value_subscript, essentially computing:
579 (&array[0] + ((index - lowerbound) * sizeof array[0]))
581 As further evidence consider what would happen with operations other
582 than array subscripting, where the caller would get back a value that
583 had an address somewhere before the actual first element of the array,
584 and the information about the lower bound would be lost because of
585 the coercion to pointer type.
589 value_coerce_array (arg1
)
592 register struct type
*type
;
594 if (VALUE_LVAL (arg1
) != lval_memory
)
595 error ("Attempt to take address of value not located in memory.");
597 /* Get type of elements. */
598 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
599 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
601 /* A phony array made by value_repeat.
602 Its type is the type of the elements, not an array type. */
603 type
= VALUE_TYPE (arg1
);
605 return value_from_longest (lookup_pointer_type (type
),
606 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
609 /* Given a value which is a function, return a value which is a pointer
613 value_coerce_function (arg1
)
617 if (VALUE_LVAL (arg1
) != lval_memory
)
618 error ("Attempt to take address of value not located in memory.");
620 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
621 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
624 /* Return a pointer value for the object for which ARG1 is the contents. */
630 struct type
*type
= VALUE_TYPE (arg1
);
631 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
633 /* Copy the value, but change the type from (T&) to (T*).
634 We keep the same location information, which is efficient,
635 and allows &(&X) to get the location containing the reference. */
636 value arg2
= value_copy (arg1
);
637 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
640 if (VALUE_REPEATED (arg1
)
641 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
642 return value_coerce_array (arg1
);
643 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
644 return value_coerce_function (arg1
);
646 if (VALUE_LVAL (arg1
) != lval_memory
)
647 error ("Attempt to take address of value not located in memory.");
649 return value_from_longest (lookup_pointer_type (type
),
650 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
653 /* Given a value of a pointer type, apply the C unary * operator to it. */
661 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
662 error ("not implemented: member types in value_ind");
664 /* Allow * on an integer so we can cast it to whatever we want.
665 This returns an int, which seems like the most C-like thing
666 to do. "long long" variables are rare enough that
667 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
668 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
669 return value_at (builtin_type_int
,
670 (CORE_ADDR
) value_as_long (arg1
));
671 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
672 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
673 value_as_pointer (arg1
));
674 error ("Attempt to take contents of a non-pointer value.");
675 return 0; /* For lint -- never reached */
678 /* Pushing small parts of stack frames. */
680 /* Push one word (the size of object that a register holds). */
687 register int len
= sizeof (REGISTER_TYPE
);
688 char buffer
[MAX_REGISTER_RAW_SIZE
];
690 store_unsigned_integer (buffer
, len
, word
);
693 write_memory (sp
, buffer
, len
);
694 #else /* stack grows upward */
695 write_memory (sp
, buffer
, len
);
697 #endif /* stack grows upward */
702 /* Push LEN bytes with data at BUFFER. */
705 push_bytes (sp
, buffer
, len
)
712 write_memory (sp
, buffer
, len
);
713 #else /* stack grows upward */
714 write_memory (sp
, buffer
, len
);
716 #endif /* stack grows upward */
721 /* Push onto the stack the specified value VALUE. */
725 register CORE_ADDR sp
;
728 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
732 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
733 #else /* stack grows upward */
734 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
736 #endif /* stack grows upward */
741 /* Perform the standard coercions that are specified
742 for arguments to be passed to C functions. */
745 value_arg_coerce (arg
)
748 register struct type
*type
;
750 /* FIXME: We should coerce this according to the prototype (if we have
751 one). Right now we do a little bit of this in typecmp(), but that
752 doesn't always get called. For example, if passing a ref to a function
753 without a prototype, we probably should de-reference it. Currently
756 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ENUM
)
757 arg
= value_cast (builtin_type_unsigned_int
, arg
);
759 #if 1 /* FIXME: This is only a temporary patch. -fnf */
760 if (VALUE_REPEATED (arg
)
761 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
762 arg
= value_coerce_array (arg
);
763 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FUNC
)
764 arg
= value_coerce_function (arg
);
767 type
= VALUE_TYPE (arg
);
769 if (TYPE_CODE (type
) == TYPE_CODE_INT
770 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
771 return value_cast (builtin_type_int
, arg
);
773 if (TYPE_CODE (type
) == TYPE_CODE_FLT
774 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
775 return value_cast (builtin_type_double
, arg
);
780 /* Push the value ARG, first coercing it as an argument
784 value_arg_push (sp
, arg
)
785 register CORE_ADDR sp
;
788 return value_push (sp
, value_arg_coerce (arg
));
791 /* Determine a function's address and its return type from its value.
792 Calls error() if the function is not valid for calling. */
795 find_function_addr (function
, retval_type
)
797 struct type
**retval_type
;
799 register struct type
*ftype
= VALUE_TYPE (function
);
800 register enum type_code code
= TYPE_CODE (ftype
);
801 struct type
*value_type
;
804 /* If it's a member function, just look at the function
807 /* Determine address to call. */
808 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
810 funaddr
= VALUE_ADDRESS (function
);
811 value_type
= TYPE_TARGET_TYPE (ftype
);
813 else if (code
== TYPE_CODE_PTR
)
815 funaddr
= value_as_pointer (function
);
816 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
817 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
818 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
820 value_type
= builtin_type_int
;
822 else if (code
== TYPE_CODE_INT
)
824 /* Handle the case of functions lacking debugging info.
825 Their values are characters since their addresses are char */
826 if (TYPE_LENGTH (ftype
) == 1)
827 funaddr
= value_as_pointer (value_addr (function
));
829 /* Handle integer used as address of a function. */
830 funaddr
= (CORE_ADDR
) value_as_long (function
);
832 value_type
= builtin_type_int
;
835 error ("Invalid data type for function to be called.");
837 *retval_type
= value_type
;
841 #if defined (CALL_DUMMY)
842 /* All this stuff with a dummy frame may seem unnecessarily complicated
843 (why not just save registers in GDB?). The purpose of pushing a dummy
844 frame which looks just like a real frame is so that if you call a
845 function and then hit a breakpoint (get a signal, etc), "backtrace"
846 will look right. Whether the backtrace needs to actually show the
847 stack at the time the inferior function was called is debatable, but
848 it certainly needs to not display garbage. So if you are contemplating
849 making dummy frames be different from normal frames, consider that. */
851 /* Perform a function call in the inferior.
852 ARGS is a vector of values of arguments (NARGS of them).
853 FUNCTION is a value, the function to be called.
854 Returns a value representing what the function returned.
855 May fail to return, if a breakpoint or signal is hit
856 during the execution of the function. */
859 call_function_by_hand (function
, nargs
, args
)
864 register CORE_ADDR sp
;
867 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
868 is in host byte order. It is switched to target byte order before calling
870 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
871 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
873 struct type
*value_type
;
874 unsigned char struct_return
;
875 CORE_ADDR struct_addr
;
876 struct inferior_status inf_status
;
877 struct cleanup
*old_chain
;
882 if (!target_has_execution
)
885 save_inferior_status (&inf_status
, 1);
886 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
888 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
889 (and POP_FRAME for restoring them). (At least on most machines)
890 they are saved on the stack in the inferior. */
893 old_sp
= sp
= read_sp ();
895 #if 1 INNER_THAN 2 /* Stack grows down */
898 #else /* Stack grows up */
903 funaddr
= find_function_addr (function
, &value_type
);
906 struct block
*b
= block_for_pc (funaddr
);
907 /* If compiled without -g, assume GCC. */
908 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
911 /* Are we returning a value using a structure return or a normal
914 struct_return
= using_struct_return (function
, funaddr
, value_type
,
917 /* Create a call sequence customized for this function
918 and the number of arguments for it. */
919 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
920 store_unsigned_integer (&dummy1
[i
], sizeof (REGISTER_TYPE
),
921 (unsigned LONGEST
)dummy
[i
]);
923 #ifdef GDB_TARGET_IS_HPPA
924 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
925 value_type
, using_gcc
);
927 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
928 value_type
, using_gcc
);
932 #if CALL_DUMMY_LOCATION == ON_STACK
933 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
934 #endif /* On stack. */
936 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
937 /* Convex Unix prohibits executing in the stack segment. */
938 /* Hope there is empty room at the top of the text segment. */
940 extern CORE_ADDR text_end
;
943 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
944 if (read_memory_integer (start_sp
, 1) != 0)
945 error ("text segment full -- no place to put call");
948 real_pc
= text_end
- sizeof dummy
;
949 write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
951 #endif /* Before text_end. */
953 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
955 extern CORE_ADDR text_end
;
959 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
961 error ("Cannot write text segment -- call_function failed");
963 #endif /* After text_end. */
965 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
967 #endif /* At entry point. */
970 sp
= old_sp
; /* It really is used, for some ifdef's... */
974 /* If stack grows down, we must leave a hole at the top. */
978 /* Reserve space for the return structure to be written on the
979 stack, if necessary */
982 len
+= TYPE_LENGTH (value_type
);
984 for (i
= nargs
- 1; i
>= 0; i
--)
985 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
986 #ifdef CALL_DUMMY_STACK_ADJUST
987 len
+= CALL_DUMMY_STACK_ADJUST
;
990 sp
-= STACK_ALIGN (len
) - len
;
992 sp
+= STACK_ALIGN (len
) - len
;
995 #endif /* STACK_ALIGN */
997 /* Reserve space for the return structure to be written on the
998 stack, if necessary */
1003 sp
-= TYPE_LENGTH (value_type
);
1007 sp
+= TYPE_LENGTH (value_type
);
1011 #if defined (REG_STRUCT_HAS_ADDR)
1013 /* This is a machine like the sparc, where we need to pass a pointer
1014 to the structure, not the structure itself. */
1015 if (REG_STRUCT_HAS_ADDR (using_gcc
))
1016 for (i
= nargs
- 1; i
>= 0; i
--)
1017 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
1020 #if !(1 INNER_THAN 2)
1021 /* The stack grows up, so the address of the thing we push
1022 is the stack pointer before we push it. */
1025 /* Push the structure. */
1026 sp
= value_push (sp
, args
[i
]);
1028 /* The stack grows down, so the address of the thing we push
1029 is the stack pointer after we push it. */
1032 /* The value we're going to pass is the address of the thing
1034 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1038 #endif /* REG_STRUCT_HAS_ADDR. */
1040 #ifdef PUSH_ARGUMENTS
1041 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1042 #else /* !PUSH_ARGUMENTS */
1043 for (i
= nargs
- 1; i
>= 0; i
--)
1044 sp
= value_arg_push (sp
, args
[i
]);
1045 #endif /* !PUSH_ARGUMENTS */
1047 #ifdef CALL_DUMMY_STACK_ADJUST
1049 sp
-= CALL_DUMMY_STACK_ADJUST
;
1051 sp
+= CALL_DUMMY_STACK_ADJUST
;
1053 #endif /* CALL_DUMMY_STACK_ADJUST */
1055 /* Store the address at which the structure is supposed to be
1056 written. Note that this (and the code which reserved the space
1057 above) assumes that gcc was used to compile this function. Since
1058 it doesn't cost us anything but space and if the function is pcc
1059 it will ignore this value, we will make that assumption.
1061 Also note that on some machines (like the sparc) pcc uses a
1062 convention like gcc's. */
1065 STORE_STRUCT_RETURN (struct_addr
, sp
);
1067 /* Write the stack pointer. This is here because the statements above
1068 might fool with it. On SPARC, this write also stores the register
1069 window into the right place in the new stack frame, which otherwise
1070 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1074 char retbuf
[REGISTER_BYTES
];
1076 struct symbol
*symbol
;
1079 symbol
= find_pc_function (funaddr
);
1082 name
= SYMBOL_SOURCE_NAME (symbol
);
1086 /* Try the minimal symbols. */
1087 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1091 name
= SYMBOL_SOURCE_NAME (msymbol
);
1097 sprintf (format
, "at %s", local_hex_format ());
1099 sprintf (name
, format
, (unsigned long) funaddr
);
1102 /* Execute the stack dummy routine, calling FUNCTION.
1103 When it is done, discard the empty frame
1104 after storing the contents of all regs into retbuf. */
1105 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1107 /* We stopped somewhere besides the call dummy. */
1109 /* If we did the cleanups, we would print a spurious error message
1110 (Unable to restore previously selected frame), would write the
1111 registers from the inf_status (which is wrong), and would do other
1112 wrong things (like set stop_bpstat to the wrong thing). */
1113 discard_cleanups (old_chain
);
1114 /* Prevent memory leak. */
1115 bpstat_clear (&inf_status
.stop_bpstat
);
1117 /* The following error message used to say "The expression
1118 which contained the function call has been discarded." It
1119 is a hard concept to explain in a few words. Ideally, GDB
1120 would be able to resume evaluation of the expression when
1121 the function finally is done executing. Perhaps someday
1122 this will be implemented (it would not be easy). */
1124 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1125 a C++ name with arguments and stuff. */
1127 The program being debugged stopped while in a function called from GDB.\n\
1128 When the function (%s) is done executing, GDB will silently\n\
1129 stop (instead of continuing to evaluate the expression containing\n\
1130 the function call).", name
);
1133 do_cleanups (old_chain
);
1135 /* Figure out the value returned by the function. */
1136 return value_being_returned (value_type
, retbuf
, struct_return
);
1139 #else /* no CALL_DUMMY. */
1141 call_function_by_hand (function
, nargs
, args
)
1146 error ("Cannot invoke functions on this machine.");
1148 #endif /* no CALL_DUMMY. */
1151 /* Create a value for an array by allocating space in the inferior, copying
1152 the data into that space, and then setting up an array value.
1154 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1155 populated from the values passed in ELEMVEC.
1157 The element type of the array is inherited from the type of the
1158 first element, and all elements must have the same size (though we
1159 don't currently enforce any restriction on their types). */
1162 value_array (lowbound
, highbound
, elemvec
)
1171 struct type
*rangetype
;
1172 struct type
*arraytype
;
1175 /* Validate that the bounds are reasonable and that each of the elements
1176 have the same size. */
1178 nelem
= highbound
- lowbound
+ 1;
1181 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1183 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1184 for (idx
= 0; idx
< nelem
; idx
++)
1186 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1188 error ("array elements must all be the same size");
1192 /* Allocate space to store the array in the inferior, and then initialize
1193 it by copying in each element. FIXME: Is it worth it to create a
1194 local buffer in which to collect each value and then write all the
1195 bytes in one operation? */
1197 addr
= allocate_space_in_inferior (nelem
* typelength
);
1198 for (idx
= 0; idx
< nelem
; idx
++)
1200 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1204 /* Create the array type and set up an array value to be evaluated lazily. */
1206 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1207 lowbound
, highbound
);
1208 arraytype
= create_array_type ((struct type
*) NULL
,
1209 VALUE_TYPE (elemvec
[0]), rangetype
);
1210 val
= value_at_lazy (arraytype
, addr
);
1214 /* Create a value for a string constant by allocating space in the inferior,
1215 copying the data into that space, and returning the address with type
1216 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1218 Note that string types are like array of char types with a lower bound of
1219 zero and an upper bound of LEN - 1. Also note that the string may contain
1220 embedded null bytes. */
1223 value_string (ptr
, len
)
1228 struct type
*rangetype
;
1229 struct type
*stringtype
;
1232 /* Allocate space to store the string in the inferior, and then
1233 copy LEN bytes from PTR in gdb to that address in the inferior. */
1235 addr
= allocate_space_in_inferior (len
);
1236 write_memory (addr
, ptr
, len
);
1238 /* Create the string type and set up a string value to be evaluated
1241 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1243 stringtype
= create_string_type ((struct type
*) NULL
, rangetype
);
1244 val
= value_at_lazy (stringtype
, addr
);
1248 /* See if we can pass arguments in T2 to a function which takes arguments
1249 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1250 arguments need coercion of some sort, then the coerced values are written
1251 into T2. Return value is 0 if the arguments could be matched, or the
1252 position at which they differ if not.
1254 STATICP is nonzero if the T1 argument list came from a
1255 static member function.
1257 For non-static member functions, we ignore the first argument,
1258 which is the type of the instance variable. This is because we want
1259 to handle calls with objects from derived classes. This is not
1260 entirely correct: we should actually check to make sure that a
1261 requested operation is type secure, shouldn't we? FIXME. */
1264 typecmp (staticp
, t1
, t2
)
1273 if (staticp
&& t1
== 0)
1277 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1278 if (t1
[!staticp
] == 0) return 0;
1279 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1281 struct type
*tt1
, *tt2
;
1285 tt2
= VALUE_TYPE(t2
[i
]);
1286 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1287 /* We should be doing hairy argument matching, as below. */
1288 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1290 t2
[i
] = value_addr (t2
[i
]);
1294 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1295 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1297 tt1
= TYPE_TARGET_TYPE(tt1
);
1298 tt2
= TYPE_TARGET_TYPE(tt2
);
1300 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1301 /* Array to pointer is a `trivial conversion' according to the ARM. */
1303 /* We should be doing much hairier argument matching (see section 13.2
1304 of the ARM), but as a quick kludge, just check for the same type
1306 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1309 if (!t1
[i
]) return 0;
1310 return t2
[i
] ? i
+1 : 0;
1313 /* Helper function used by value_struct_elt to recurse through baseclasses.
1314 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1315 and search in it assuming it has (class) type TYPE.
1316 If found, return value, else return NULL.
1318 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1319 look for a baseclass named NAME. */
1322 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1324 register value arg1
;
1326 register struct type
*type
;
1327 int looking_for_baseclass
;
1331 check_stub_type (type
);
1333 if (! looking_for_baseclass
)
1334 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1336 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1338 if (t_field_name
&& STREQ (t_field_name
, name
))
1341 if (TYPE_FIELD_STATIC (type
, i
))
1343 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1344 struct symbol
*sym
=
1345 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1347 error ("Internal error: could not find physical static variable named %s",
1349 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1350 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1353 v
= value_primitive_field (arg1
, offset
, i
, type
);
1355 error("there is no field named %s", name
);
1360 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1363 /* If we are looking for baseclasses, this is what we get when we
1364 hit them. But it could happen that the base part's member name
1365 is not yet filled in. */
1366 int found_baseclass
= (looking_for_baseclass
1367 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1368 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1370 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1373 /* Fix to use baseclass_offset instead. FIXME */
1374 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1377 error ("virtual baseclass botch");
1378 if (found_baseclass
)
1380 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1381 looking_for_baseclass
);
1383 else if (found_baseclass
)
1384 v
= value_primitive_field (arg1
, offset
, i
, type
);
1386 v
= search_struct_field (name
, arg1
,
1387 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1388 TYPE_BASECLASS (type
, i
),
1389 looking_for_baseclass
);
1395 /* Helper function used by value_struct_elt to recurse through baseclasses.
1396 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1397 and search in it assuming it has (class) type TYPE.
1398 If found, return value, else if name matched and args not return (value)-1,
1399 else return NULL. */
1402 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1404 register value
*arg1p
, *args
;
1405 int offset
, *static_memfuncp
;
1406 register struct type
*type
;
1410 static int name_matched
= 0;
1411 char dem_opname
[64];
1413 check_stub_type (type
);
1414 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1416 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1417 if (strncmp(t_field_name
, "__", 2)==0 ||
1418 strncmp(t_field_name
, "op", 2)==0 ||
1419 strncmp(t_field_name
, "type", 4)==0 )
1421 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1422 t_field_name
= dem_opname
;
1423 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1424 t_field_name
= dem_opname
;
1426 if (t_field_name
&& STREQ (t_field_name
, name
))
1428 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1429 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1432 if (j
> 0 && args
== 0)
1433 error ("cannot resolve overloaded method `%s'", name
);
1436 if (TYPE_FN_FIELD_STUB (f
, j
))
1437 check_stub_method (type
, i
, j
);
1438 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1439 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1441 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1442 return (value
)value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1443 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1444 *static_memfuncp
= 1;
1445 v
= (value
)value_fn_field (arg1p
, f
, j
, type
, offset
);
1446 if (v
!= (value
)NULL
) return v
;
1453 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1457 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1459 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1460 if (base_offset
== -1)
1461 error ("virtual baseclass botch");
1465 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1467 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1468 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1469 if (v
== (value
) -1)
1475 /* FIXME-bothner: Why is this commented out? Why is it here? */
1476 /* *arg1p = arg1_tmp;*/
1480 if (name_matched
) return (value
) -1;
1484 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1485 extract the component named NAME from the ultimate target structure/union
1486 and return it as a value with its appropriate type.
1487 ERR is used in the error message if *ARGP's type is wrong.
1489 C++: ARGS is a list of argument types to aid in the selection of
1490 an appropriate method. Also, handle derived types.
1492 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1493 where the truthvalue of whether the function that was resolved was
1494 a static member function or not is stored.
1496 ERR is an error message to be printed in case the field is not found. */
1499 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1500 register value
*argp
, *args
;
1502 int *static_memfuncp
;
1505 register struct type
*t
;
1508 COERCE_ARRAY (*argp
);
1510 t
= VALUE_TYPE (*argp
);
1512 /* Follow pointers until we get to a non-pointer. */
1514 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1516 *argp
= value_ind (*argp
);
1517 /* Don't coerce fn pointer to fn and then back again! */
1518 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1519 COERCE_ARRAY (*argp
);
1520 t
= VALUE_TYPE (*argp
);
1523 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1524 error ("not implemented: member type in value_struct_elt");
1526 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1527 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1528 error ("Attempt to extract a component of a value that is not a %s.", err
);
1530 /* Assume it's not, unless we see that it is. */
1531 if (static_memfuncp
)
1532 *static_memfuncp
=0;
1536 /* if there are no arguments ...do this... */
1538 /* Try as a field first, because if we succeed, there
1539 is less work to be done. */
1540 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1544 /* C++: If it was not found as a data field, then try to
1545 return it as a pointer to a method. */
1547 if (destructor_name_p (name
, t
))
1548 error ("Cannot get value of destructor");
1550 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1554 if (TYPE_NFN_FIELDS (t
))
1555 error ("There is no member or method named %s.", name
);
1557 error ("There is no member named %s.", name
);
1562 if (destructor_name_p (name
, t
))
1566 /* destructors are a special case. */
1567 v
= (value
)value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1568 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1569 if (!v
) error("could not find destructor function named %s.", name
);
1574 error ("destructor should not have any argument");
1578 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1580 if (v
== (value
) -1)
1582 error("Argument list of %s mismatch with component in the structure.", name
);
1586 /* See if user tried to invoke data as function. If so,
1587 hand it back. If it's not callable (i.e., a pointer to function),
1588 gdb should give an error. */
1589 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1593 error ("Structure has no component named %s.", name
);
1597 /* C++: return 1 is NAME is a legitimate name for the destructor
1598 of type TYPE. If TYPE does not have a destructor, or
1599 if NAME is inappropriate for TYPE, an error is signaled. */
1601 destructor_name_p (name
, type
)
1603 const struct type
*type
;
1605 /* destructors are a special case. */
1609 char *dname
= type_name_no_tag (type
);
1610 if (!STREQ (dname
, name
+1))
1611 error ("name of destructor must equal name of class");
1618 /* Helper function for check_field: Given TYPE, a structure/union,
1619 return 1 if the component named NAME from the ultimate
1620 target structure/union is defined, otherwise, return 0. */
1623 check_field_in (type
, name
)
1624 register struct type
*type
;
1629 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1631 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1632 if (t_field_name
&& STREQ (t_field_name
, name
))
1636 /* C++: If it was not found as a data field, then try to
1637 return it as a pointer to a method. */
1639 /* Destructors are a special case. */
1640 if (destructor_name_p (name
, type
))
1643 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1645 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1649 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1650 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1657 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1658 return 1 if the component named NAME from the ultimate
1659 target structure/union is defined, otherwise, return 0. */
1662 check_field (arg1
, name
)
1663 register value arg1
;
1666 register struct type
*t
;
1668 COERCE_ARRAY (arg1
);
1670 t
= VALUE_TYPE (arg1
);
1672 /* Follow pointers until we get to a non-pointer. */
1674 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1675 t
= TYPE_TARGET_TYPE (t
);
1677 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1678 error ("not implemented: member type in check_field");
1680 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1681 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1682 error ("Internal error: `this' is not an aggregate");
1684 return check_field_in (t
, name
);
1687 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1688 return the address of this member as a "pointer to member"
1689 type. If INTYPE is non-null, then it will be the type
1690 of the member we are looking for. This will help us resolve
1691 "pointers to member functions". This function is used
1692 to resolve user expressions of the form "DOMAIN::NAME". */
1695 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1696 struct type
*domain
, *curtype
, *intype
;
1700 register struct type
*t
= curtype
;
1704 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1705 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1706 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1708 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1710 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1712 if (t_field_name
&& STREQ (t_field_name
, name
))
1714 if (TYPE_FIELD_STATIC (t
, i
))
1716 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1717 struct symbol
*sym
=
1718 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1720 error ("Internal error: could not find physical static variable named %s",
1722 return value_at (SYMBOL_TYPE (sym
),
1723 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1725 if (TYPE_FIELD_PACKED (t
, i
))
1726 error ("pointers to bitfield members not allowed");
1728 return value_from_longest
1729 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1731 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1735 /* C++: If it was not found as a data field, then try to
1736 return it as a pointer to a method. */
1738 /* Destructors are a special case. */
1739 if (destructor_name_p (name
, t
))
1741 error ("member pointers to destructors not implemented yet");
1744 /* Perform all necessary dereferencing. */
1745 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1746 intype
= TYPE_TARGET_TYPE (intype
);
1748 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1750 if (STREQ (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1752 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1753 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1755 if (intype
== 0 && j
> 1)
1756 error ("non-unique member `%s' requires type instantiation", name
);
1760 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1763 error ("no member function matches that type instantiation");
1768 if (TYPE_FN_FIELD_STUB (f
, j
))
1769 check_stub_method (t
, i
, j
);
1770 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1772 return value_from_longest
1773 (lookup_reference_type
1774 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1776 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1777 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1781 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1782 0, VAR_NAMESPACE
, 0, NULL
);
1789 v
= read_var_value (s
, 0);
1791 VALUE_TYPE (v
) = lookup_reference_type
1792 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1800 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1805 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1808 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1809 v
= value_struct_elt_for_reference (domain
,
1810 offset
+ base_offset
,
1811 TYPE_BASECLASS (t
, i
),
1820 /* C++: return the value of the class instance variable, if one exists.
1821 Flag COMPLAIN signals an error if the request is made in an
1822 inappropriate context. */
1824 value_of_this (complain
)
1827 extern FRAME selected_frame
;
1828 struct symbol
*func
, *sym
;
1831 static const char funny_this
[] = "this";
1834 if (selected_frame
== 0)
1836 error ("no frame selected");
1839 func
= get_frame_function (selected_frame
);
1843 error ("no `this' in nameless context");
1847 b
= SYMBOL_BLOCK_VALUE (func
);
1848 i
= BLOCK_NSYMS (b
);
1851 error ("no args, no `this'");
1854 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1855 symbol instead of the LOC_ARG one (if both exist). */
1856 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1860 error ("current stack frame not in method");
1865 this = read_var_value (sym
, selected_frame
);
1866 if (this == 0 && complain
)
1867 error ("`this' argument at unknown address");