1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
34 /* Local functions. */
37 typecmp
PARAMS ((int staticp
, struct type
*t1
[], value t2
[]));
40 find_function_addr
PARAMS ((value
, struct type
**));
43 value_push
PARAMS ((CORE_ADDR
, value
));
46 value_arg_push
PARAMS ((CORE_ADDR
, value
));
49 search_struct_field
PARAMS ((char *, value
, int, struct type
*, int));
52 search_struct_method
PARAMS ((char *, value
*, value
*, int, int *,
56 check_field_in
PARAMS ((struct type
*, const char *));
59 allocate_space_in_inferior
PARAMS ((int));
62 /* Allocate NBYTES of space in the inferior using the inferior's malloc
63 and return a value that is a pointer to the allocated space. */
66 allocate_space_in_inferior (len
)
70 register struct symbol
*sym
;
71 struct minimal_symbol
*msymbol
;
76 /* Find the address of malloc in the inferior. */
78 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
81 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
83 error ("\"malloc\" exists in this program but is not a function.");
85 val
= value_of_variable (sym
, NULL
);
89 msymbol
= lookup_minimal_symbol ("malloc", (struct objfile
*) NULL
);
92 type
= lookup_pointer_type (builtin_type_char
);
93 type
= lookup_function_type (type
);
94 type
= lookup_pointer_type (type
);
95 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
96 val
= value_from_longest (type
, maddr
);
100 error ("evaluation of this expression requires the program to have a function \"malloc\".");
104 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
105 val
= call_function_by_hand (val
, 1, &blocklen
);
106 if (value_logical_not (val
))
108 error ("No memory available to program.");
110 return (value_as_long (val
));
113 /* Cast value ARG2 to type TYPE and return as a value.
114 More general than a C cast: accepts any two types of the same length,
115 and if ARG2 is an lvalue it can be cast into anything at all. */
116 /* In C++, casts may change pointer or object representations. */
119 value_cast (type
, arg2
)
123 register enum type_code code1
;
124 register enum type_code code2
;
127 /* Coerce arrays but not enums. Enums will work as-is
128 and coercing them would cause an infinite recursion. */
129 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
132 code1
= TYPE_CODE (type
);
133 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
134 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
135 || code2
== TYPE_CODE_ENUM
);
137 if ( code1
== TYPE_CODE_STRUCT
138 && code2
== TYPE_CODE_STRUCT
139 && TYPE_NAME (type
) != 0)
141 /* Look in the type of the source to see if it contains the
142 type of the target as a superclass. If so, we'll need to
143 offset the object in addition to changing its type. */
144 value v
= search_struct_field (type_name_no_tag (type
),
145 arg2
, 0, VALUE_TYPE (arg2
), 1);
148 VALUE_TYPE (v
) = type
;
152 if (code1
== TYPE_CODE_FLT
&& scalar
)
153 return value_from_double (type
, value_as_double (arg2
));
154 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
)
155 && (scalar
|| code2
== TYPE_CODE_PTR
))
156 return value_from_longest (type
, value_as_long (arg2
));
157 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
159 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
161 /* Look in the type of the source to see if it contains the
162 type of the target as a superclass. If so, we'll need to
163 offset the pointer rather than just change its type. */
164 struct type
*t1
= TYPE_TARGET_TYPE (type
);
165 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
166 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
167 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
168 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
170 value v
= search_struct_field (type_name_no_tag (t1
),
171 value_ind (arg2
), 0, t2
, 1);
175 VALUE_TYPE (v
) = type
;
179 /* No superclass found, just fall through to change ptr type. */
181 VALUE_TYPE (arg2
) = type
;
184 else if (VALUE_LVAL (arg2
) == lval_memory
)
186 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
188 else if (code1
== TYPE_CODE_VOID
)
190 return value_zero (builtin_type_void
, not_lval
);
194 error ("Invalid cast.");
199 /* Create a value of type TYPE that is zero, and return it. */
202 value_zero (type
, lv
)
206 register value val
= allocate_value (type
);
208 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
209 VALUE_LVAL (val
) = lv
;
214 /* Return a value with type TYPE located at ADDR.
216 Call value_at only if the data needs to be fetched immediately;
217 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
218 value_at_lazy instead. value_at_lazy simply records the address of
219 the data and sets the lazy-evaluation-required flag. The lazy flag
220 is tested in the VALUE_CONTENTS macro, which is used if and when
221 the contents are actually required. */
224 value_at (type
, addr
)
228 register value val
= allocate_value (type
);
230 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
232 VALUE_LVAL (val
) = lval_memory
;
233 VALUE_ADDRESS (val
) = addr
;
238 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
241 value_at_lazy (type
, addr
)
245 register value val
= allocate_value (type
);
247 VALUE_LVAL (val
) = lval_memory
;
248 VALUE_ADDRESS (val
) = addr
;
249 VALUE_LAZY (val
) = 1;
254 /* Called only from the VALUE_CONTENTS macro, if the current data for
255 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
256 data from the user's process, and clears the lazy flag to indicate
257 that the data in the buffer is valid.
259 If the value is zero-length, we avoid calling read_memory, which would
260 abort. We mark the value as fetched anyway -- all 0 bytes of it.
262 This function returns a value because it is used in the VALUE_CONTENTS
263 macro as part of an expression, where a void would not work. The
267 value_fetch_lazy (val
)
270 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
272 if (TYPE_LENGTH (VALUE_TYPE (val
)))
273 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
274 TYPE_LENGTH (VALUE_TYPE (val
)));
275 VALUE_LAZY (val
) = 0;
280 /* Store the contents of FROMVAL into the location of TOVAL.
281 Return a new value with the location of TOVAL and contents of FROMVAL. */
284 value_assign (toval
, fromval
)
285 register value toval
, fromval
;
287 register struct type
*type
;
289 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
292 COERCE_ARRAY (fromval
);
295 type
= VALUE_TYPE (toval
);
296 if (VALUE_LVAL (toval
) != lval_internalvar
)
297 fromval
= value_cast (type
, fromval
);
299 /* If TOVAL is a special machine register requiring conversion
300 of program values to a special raw format,
301 convert FROMVAL's contents now, with result in `raw_buffer',
302 and set USE_BUFFER to the number of bytes to write. */
304 #ifdef REGISTER_CONVERTIBLE
305 if (VALUE_REGNO (toval
) >= 0
306 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
308 int regno
= VALUE_REGNO (toval
);
309 if (REGISTER_CONVERTIBLE (regno
))
311 REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval
), regno
,
312 VALUE_CONTENTS (fromval
), raw_buffer
);
313 use_buffer
= REGISTER_RAW_SIZE (regno
);
318 switch (VALUE_LVAL (toval
))
320 case lval_internalvar
:
321 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
324 case lval_internalvar_component
:
325 set_internalvar_component (VALUE_INTERNALVAR (toval
),
326 VALUE_OFFSET (toval
),
327 VALUE_BITPOS (toval
),
328 VALUE_BITSIZE (toval
),
333 if (VALUE_BITSIZE (toval
))
335 char buffer
[sizeof (LONGEST
)];
336 /* We assume that the argument to read_memory is in units of
337 host chars. FIXME: Is that correct? */
338 int len
= (VALUE_BITPOS (toval
)
339 + VALUE_BITSIZE (toval
)
343 if (len
> sizeof (LONGEST
))
344 error ("Can't handle bitfields which don't fit in a %d bit word.",
345 sizeof (LONGEST
) * HOST_CHAR_BIT
);
347 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
349 modify_field (buffer
, value_as_long (fromval
),
350 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
351 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
355 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
356 raw_buffer
, use_buffer
);
358 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
359 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
363 if (VALUE_BITSIZE (toval
))
365 char buffer
[sizeof (LONGEST
)];
366 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
368 if (len
> sizeof (LONGEST
))
369 error ("Can't handle bitfields in registers larger than %d bits.",
370 sizeof (LONGEST
) * HOST_CHAR_BIT
);
372 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
373 > len
* HOST_CHAR_BIT
)
374 /* Getting this right would involve being very careful about
377 Can't handle bitfield which doesn't fit in a single register.");
379 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
381 modify_field (buffer
, value_as_long (fromval
),
382 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
383 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
387 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
388 raw_buffer
, use_buffer
);
391 /* Do any conversion necessary when storing this type to more
392 than one register. */
393 #ifdef REGISTER_CONVERT_FROM_TYPE
394 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
395 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
396 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
397 raw_buffer
, TYPE_LENGTH (type
));
399 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
400 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
403 /* Assigning to the stack pointer, frame pointer, and other
404 (architecture and calling convention specific) registers may
405 cause the frame cache to be out of date. We just do this
406 on all assignments to registers for simplicity; I doubt the slowdown
408 reinit_frame_cache ();
411 case lval_reg_frame_relative
:
413 /* value is stored in a series of registers in the frame
414 specified by the structure. Copy that value out, modify
415 it, and copy it back in. */
416 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
417 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
418 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
419 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
422 /* Make the buffer large enough in all cases. */
423 char *buffer
= (char *) alloca (amount_to_copy
425 + MAX_REGISTER_RAW_SIZE
);
430 /* Figure out which frame this is in currently. */
431 for (frame
= get_current_frame ();
432 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
433 frame
= get_prev_frame (frame
))
437 error ("Value being assigned to is no longer active.");
439 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
442 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
444 amount_copied
< amount_to_copy
;
445 amount_copied
+= reg_size
, regno
++)
447 get_saved_register (buffer
+ amount_copied
,
448 (int *)NULL
, (CORE_ADDR
*)NULL
,
449 frame
, regno
, (enum lval_type
*)NULL
);
452 /* Modify what needs to be modified. */
453 if (VALUE_BITSIZE (toval
))
454 modify_field (buffer
+ byte_offset
,
455 value_as_long (fromval
),
456 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
458 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
460 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
464 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
466 amount_copied
< amount_to_copy
;
467 amount_copied
+= reg_size
, regno
++)
473 /* Just find out where to put it. */
474 get_saved_register ((char *)NULL
,
475 &optim
, &addr
, frame
, regno
, &lval
);
478 error ("Attempt to assign to a value that was optimized out.");
479 if (lval
== lval_memory
)
480 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
481 else if (lval
== lval_register
)
482 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
484 error ("Attempt to assign to an unmodifiable value.");
491 error ("Left side of = operation is not an lvalue.");
494 /* Return a value just like TOVAL except with the contents of FROMVAL
495 (except in the case of the type if TOVAL is an internalvar). */
497 if (VALUE_LVAL (toval
) == lval_internalvar
498 || VALUE_LVAL (toval
) == lval_internalvar_component
)
500 type
= VALUE_TYPE (fromval
);
503 val
= allocate_value (type
);
504 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
505 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
507 VALUE_TYPE (val
) = type
;
512 /* Extend a value VAL to COUNT repetitions of its type. */
515 value_repeat (arg1
, count
)
521 if (VALUE_LVAL (arg1
) != lval_memory
)
522 error ("Only values in memory can be extended with '@'.");
524 error ("Invalid number %d of repetitions.", count
);
526 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
528 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
529 VALUE_CONTENTS_RAW (val
),
530 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
531 VALUE_LVAL (val
) = lval_memory
;
532 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
538 value_of_variable (var
, b
)
546 /* Use selected frame. */
550 fr
= block_innermost_frame (b
);
551 if (fr
== NULL
&& symbol_read_needs_frame (var
))
553 if (BLOCK_FUNCTION (b
) != NULL
554 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
555 error ("No frame is currently executing in block %s.",
556 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
558 error ("No frame is currently executing in specified block");
561 val
= read_var_value (var
, fr
);
563 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
567 /* Given a value which is an array, return a value which is a pointer to its
568 first element, regardless of whether or not the array has a nonzero lower
571 FIXME: A previous comment here indicated that this routine should be
572 substracting the array's lower bound. It's not clear to me that this
573 is correct. Given an array subscripting operation, it would certainly
574 work to do the adjustment here, essentially computing:
576 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
578 However I believe a more appropriate and logical place to account for
579 the lower bound is to do so in value_subscript, essentially computing:
581 (&array[0] + ((index - lowerbound) * sizeof array[0]))
583 As further evidence consider what would happen with operations other
584 than array subscripting, where the caller would get back a value that
585 had an address somewhere before the actual first element of the array,
586 and the information about the lower bound would be lost because of
587 the coercion to pointer type.
591 value_coerce_array (arg1
)
594 register struct type
*type
;
596 if (VALUE_LVAL (arg1
) != lval_memory
)
597 error ("Attempt to take address of value not located in memory.");
599 /* Get type of elements. */
600 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
601 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRING
)
602 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
604 /* A phony array made by value_repeat.
605 Its type is the type of the elements, not an array type. */
606 type
= VALUE_TYPE (arg1
);
608 return value_from_longest (lookup_pointer_type (type
),
609 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
612 /* Given a value which is a function, return a value which is a pointer
616 value_coerce_function (arg1
)
620 if (VALUE_LVAL (arg1
) != lval_memory
)
621 error ("Attempt to take address of value not located in memory.");
623 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
624 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
627 /* Return a pointer value for the object for which ARG1 is the contents. */
633 struct type
*type
= VALUE_TYPE (arg1
);
634 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
636 /* Copy the value, but change the type from (T&) to (T*).
637 We keep the same location information, which is efficient,
638 and allows &(&X) to get the location containing the reference. */
639 value arg2
= value_copy (arg1
);
640 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
643 if (VALUE_REPEATED (arg1
)
644 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
645 return value_coerce_array (arg1
);
646 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
647 return value_coerce_function (arg1
);
649 if (VALUE_LVAL (arg1
) != lval_memory
)
650 error ("Attempt to take address of value not located in memory.");
652 return value_from_longest (lookup_pointer_type (type
),
653 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
656 /* Given a value of a pointer type, apply the C unary * operator to it. */
664 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
665 error ("not implemented: member types in value_ind");
667 /* Allow * on an integer so we can cast it to whatever we want.
668 This returns an int, which seems like the most C-like thing
669 to do. "long long" variables are rare enough that
670 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
671 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
672 return value_at (builtin_type_int
,
673 (CORE_ADDR
) value_as_long (arg1
));
674 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
675 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
676 value_as_pointer (arg1
));
677 error ("Attempt to take contents of a non-pointer value.");
678 return 0; /* For lint -- never reached */
681 /* Pushing small parts of stack frames. */
683 /* Push one word (the size of object that a register holds). */
688 unsigned LONGEST word
;
690 register int len
= REGISTER_SIZE
;
691 char buffer
[MAX_REGISTER_RAW_SIZE
];
693 store_unsigned_integer (buffer
, len
, word
);
696 write_memory (sp
, buffer
, len
);
697 #else /* stack grows upward */
698 write_memory (sp
, buffer
, len
);
700 #endif /* stack grows upward */
705 /* Push LEN bytes with data at BUFFER. */
708 push_bytes (sp
, buffer
, len
)
715 write_memory (sp
, buffer
, len
);
716 #else /* stack grows upward */
717 write_memory (sp
, buffer
, len
);
719 #endif /* stack grows upward */
724 /* Push onto the stack the specified value VALUE. */
728 register CORE_ADDR sp
;
731 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
735 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
736 #else /* stack grows upward */
737 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
739 #endif /* stack grows upward */
744 /* Perform the standard coercions that are specified
745 for arguments to be passed to C functions. */
748 value_arg_coerce (arg
)
751 register struct type
*type
;
753 /* FIXME: We should coerce this according to the prototype (if we have
754 one). Right now we do a little bit of this in typecmp(), but that
755 doesn't always get called. For example, if passing a ref to a function
756 without a prototype, we probably should de-reference it. Currently
759 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ENUM
)
760 arg
= value_cast (builtin_type_unsigned_int
, arg
);
762 #if 1 /* FIXME: This is only a temporary patch. -fnf */
763 if (VALUE_REPEATED (arg
)
764 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
765 arg
= value_coerce_array (arg
);
766 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FUNC
)
767 arg
= value_coerce_function (arg
);
770 type
= VALUE_TYPE (arg
);
772 if (TYPE_CODE (type
) == TYPE_CODE_INT
773 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
774 return value_cast (builtin_type_int
, arg
);
776 if (TYPE_CODE (type
) == TYPE_CODE_FLT
777 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
778 return value_cast (builtin_type_double
, arg
);
783 /* Push the value ARG, first coercing it as an argument
787 value_arg_push (sp
, arg
)
788 register CORE_ADDR sp
;
791 return value_push (sp
, value_arg_coerce (arg
));
794 /* Determine a function's address and its return type from its value.
795 Calls error() if the function is not valid for calling. */
798 find_function_addr (function
, retval_type
)
800 struct type
**retval_type
;
802 register struct type
*ftype
= VALUE_TYPE (function
);
803 register enum type_code code
= TYPE_CODE (ftype
);
804 struct type
*value_type
;
807 /* If it's a member function, just look at the function
810 /* Determine address to call. */
811 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
813 funaddr
= VALUE_ADDRESS (function
);
814 value_type
= TYPE_TARGET_TYPE (ftype
);
816 else if (code
== TYPE_CODE_PTR
)
818 funaddr
= value_as_pointer (function
);
819 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
820 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
821 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
823 value_type
= builtin_type_int
;
825 else if (code
== TYPE_CODE_INT
)
827 /* Handle the case of functions lacking debugging info.
828 Their values are characters since their addresses are char */
829 if (TYPE_LENGTH (ftype
) == 1)
830 funaddr
= value_as_pointer (value_addr (function
));
832 /* Handle integer used as address of a function. */
833 funaddr
= (CORE_ADDR
) value_as_long (function
);
835 value_type
= builtin_type_int
;
838 error ("Invalid data type for function to be called.");
840 *retval_type
= value_type
;
844 #if defined (CALL_DUMMY)
845 /* All this stuff with a dummy frame may seem unnecessarily complicated
846 (why not just save registers in GDB?). The purpose of pushing a dummy
847 frame which looks just like a real frame is so that if you call a
848 function and then hit a breakpoint (get a signal, etc), "backtrace"
849 will look right. Whether the backtrace needs to actually show the
850 stack at the time the inferior function was called is debatable, but
851 it certainly needs to not display garbage. So if you are contemplating
852 making dummy frames be different from normal frames, consider that. */
854 /* Perform a function call in the inferior.
855 ARGS is a vector of values of arguments (NARGS of them).
856 FUNCTION is a value, the function to be called.
857 Returns a value representing what the function returned.
858 May fail to return, if a breakpoint or signal is hit
859 during the execution of the function. */
862 call_function_by_hand (function
, nargs
, args
)
867 register CORE_ADDR sp
;
870 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
871 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
872 and remove any extra bytes which might exist because unsigned LONGEST is
873 bigger than REGISTER_SIZE. */
874 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
875 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
877 struct type
*value_type
;
878 unsigned char struct_return
;
879 CORE_ADDR struct_addr
;
880 struct inferior_status inf_status
;
881 struct cleanup
*old_chain
;
886 if (!target_has_execution
)
889 save_inferior_status (&inf_status
, 1);
890 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
892 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
893 (and POP_FRAME for restoring them). (At least on most machines)
894 they are saved on the stack in the inferior. */
897 old_sp
= sp
= read_sp ();
899 #if 1 INNER_THAN 2 /* Stack grows down */
902 #else /* Stack grows up */
907 funaddr
= find_function_addr (function
, &value_type
);
910 struct block
*b
= block_for_pc (funaddr
);
911 /* If compiled without -g, assume GCC. */
912 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
915 /* Are we returning a value using a structure return or a normal
918 struct_return
= using_struct_return (function
, funaddr
, value_type
,
921 /* Create a call sequence customized for this function
922 and the number of arguments for it. */
923 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
924 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
926 (unsigned LONGEST
)dummy
[i
]);
928 #ifdef GDB_TARGET_IS_HPPA
929 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
930 value_type
, using_gcc
);
932 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
933 value_type
, using_gcc
);
937 #if CALL_DUMMY_LOCATION == ON_STACK
938 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
939 #endif /* On stack. */
941 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
942 /* Convex Unix prohibits executing in the stack segment. */
943 /* Hope there is empty room at the top of the text segment. */
945 extern CORE_ADDR text_end
;
948 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
949 if (read_memory_integer (start_sp
, 1) != 0)
950 error ("text segment full -- no place to put call");
953 real_pc
= text_end
- sizeof dummy
;
954 write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
956 #endif /* Before text_end. */
958 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
960 extern CORE_ADDR text_end
;
964 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
966 error ("Cannot write text segment -- call_function failed");
968 #endif /* After text_end. */
970 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
972 #endif /* At entry point. */
975 sp
= old_sp
; /* It really is used, for some ifdef's... */
979 /* If stack grows down, we must leave a hole at the top. */
983 /* Reserve space for the return structure to be written on the
984 stack, if necessary */
987 len
+= TYPE_LENGTH (value_type
);
989 for (i
= nargs
- 1; i
>= 0; i
--)
990 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
991 #ifdef CALL_DUMMY_STACK_ADJUST
992 len
+= CALL_DUMMY_STACK_ADJUST
;
995 sp
-= STACK_ALIGN (len
) - len
;
997 sp
+= STACK_ALIGN (len
) - len
;
1000 #endif /* STACK_ALIGN */
1002 /* Reserve space for the return structure to be written on the
1003 stack, if necessary */
1008 sp
-= TYPE_LENGTH (value_type
);
1012 sp
+= TYPE_LENGTH (value_type
);
1016 #if defined (REG_STRUCT_HAS_ADDR)
1018 /* This is a machine like the sparc, where we need to pass a pointer
1019 to the structure, not the structure itself. */
1020 if (REG_STRUCT_HAS_ADDR (using_gcc
))
1021 for (i
= nargs
- 1; i
>= 0; i
--)
1022 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
1025 #if !(1 INNER_THAN 2)
1026 /* The stack grows up, so the address of the thing we push
1027 is the stack pointer before we push it. */
1030 /* Push the structure. */
1031 sp
= value_push (sp
, args
[i
]);
1033 /* The stack grows down, so the address of the thing we push
1034 is the stack pointer after we push it. */
1037 /* The value we're going to pass is the address of the thing
1039 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1043 #endif /* REG_STRUCT_HAS_ADDR. */
1045 #ifdef PUSH_ARGUMENTS
1046 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1047 #else /* !PUSH_ARGUMENTS */
1048 for (i
= nargs
- 1; i
>= 0; i
--)
1049 sp
= value_arg_push (sp
, args
[i
]);
1050 #endif /* !PUSH_ARGUMENTS */
1052 #ifdef CALL_DUMMY_STACK_ADJUST
1054 sp
-= CALL_DUMMY_STACK_ADJUST
;
1056 sp
+= CALL_DUMMY_STACK_ADJUST
;
1058 #endif /* CALL_DUMMY_STACK_ADJUST */
1060 /* Store the address at which the structure is supposed to be
1061 written. Note that this (and the code which reserved the space
1062 above) assumes that gcc was used to compile this function. Since
1063 it doesn't cost us anything but space and if the function is pcc
1064 it will ignore this value, we will make that assumption.
1066 Also note that on some machines (like the sparc) pcc uses a
1067 convention like gcc's. */
1070 STORE_STRUCT_RETURN (struct_addr
, sp
);
1072 /* Write the stack pointer. This is here because the statements above
1073 might fool with it. On SPARC, this write also stores the register
1074 window into the right place in the new stack frame, which otherwise
1075 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1079 char retbuf
[REGISTER_BYTES
];
1081 struct symbol
*symbol
;
1084 symbol
= find_pc_function (funaddr
);
1087 name
= SYMBOL_SOURCE_NAME (symbol
);
1091 /* Try the minimal symbols. */
1092 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1096 name
= SYMBOL_SOURCE_NAME (msymbol
);
1102 sprintf (format
, "at %s", local_hex_format ());
1104 sprintf (name
, format
, (unsigned long) funaddr
);
1107 /* Execute the stack dummy routine, calling FUNCTION.
1108 When it is done, discard the empty frame
1109 after storing the contents of all regs into retbuf. */
1110 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1112 /* We stopped somewhere besides the call dummy. */
1114 /* If we did the cleanups, we would print a spurious error message
1115 (Unable to restore previously selected frame), would write the
1116 registers from the inf_status (which is wrong), and would do other
1117 wrong things (like set stop_bpstat to the wrong thing). */
1118 discard_cleanups (old_chain
);
1119 /* Prevent memory leak. */
1120 bpstat_clear (&inf_status
.stop_bpstat
);
1122 /* The following error message used to say "The expression
1123 which contained the function call has been discarded." It
1124 is a hard concept to explain in a few words. Ideally, GDB
1125 would be able to resume evaluation of the expression when
1126 the function finally is done executing. Perhaps someday
1127 this will be implemented (it would not be easy). */
1129 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1130 a C++ name with arguments and stuff. */
1132 The program being debugged stopped while in a function called from GDB.\n\
1133 When the function (%s) is done executing, GDB will silently\n\
1134 stop (instead of continuing to evaluate the expression containing\n\
1135 the function call).", name
);
1138 do_cleanups (old_chain
);
1140 /* Figure out the value returned by the function. */
1141 return value_being_returned (value_type
, retbuf
, struct_return
);
1144 #else /* no CALL_DUMMY. */
1146 call_function_by_hand (function
, nargs
, args
)
1151 error ("Cannot invoke functions on this machine.");
1153 #endif /* no CALL_DUMMY. */
1156 /* Create a value for an array by allocating space in the inferior, copying
1157 the data into that space, and then setting up an array value.
1159 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1160 populated from the values passed in ELEMVEC.
1162 The element type of the array is inherited from the type of the
1163 first element, and all elements must have the same size (though we
1164 don't currently enforce any restriction on their types). */
1167 value_array (lowbound
, highbound
, elemvec
)
1176 struct type
*rangetype
;
1177 struct type
*arraytype
;
1180 /* Validate that the bounds are reasonable and that each of the elements
1181 have the same size. */
1183 nelem
= highbound
- lowbound
+ 1;
1186 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1188 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1189 for (idx
= 0; idx
< nelem
; idx
++)
1191 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1193 error ("array elements must all be the same size");
1197 /* Allocate space to store the array in the inferior, and then initialize
1198 it by copying in each element. FIXME: Is it worth it to create a
1199 local buffer in which to collect each value and then write all the
1200 bytes in one operation? */
1202 addr
= allocate_space_in_inferior (nelem
* typelength
);
1203 for (idx
= 0; idx
< nelem
; idx
++)
1205 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1209 /* Create the array type and set up an array value to be evaluated lazily. */
1211 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1212 lowbound
, highbound
);
1213 arraytype
= create_array_type ((struct type
*) NULL
,
1214 VALUE_TYPE (elemvec
[0]), rangetype
);
1215 val
= value_at_lazy (arraytype
, addr
);
1219 /* Create a value for a string constant by allocating space in the inferior,
1220 copying the data into that space, and returning the address with type
1221 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1223 Note that string types are like array of char types with a lower bound of
1224 zero and an upper bound of LEN - 1. Also note that the string may contain
1225 embedded null bytes. */
1228 value_string (ptr
, len
)
1233 struct type
*rangetype
;
1234 struct type
*stringtype
;
1237 /* Allocate space to store the string in the inferior, and then
1238 copy LEN bytes from PTR in gdb to that address in the inferior. */
1240 addr
= allocate_space_in_inferior (len
);
1241 write_memory (addr
, ptr
, len
);
1243 /* Create the string type and set up a string value to be evaluated
1246 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1248 stringtype
= create_string_type ((struct type
*) NULL
, rangetype
);
1249 val
= value_at_lazy (stringtype
, addr
);
1253 /* See if we can pass arguments in T2 to a function which takes arguments
1254 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1255 arguments need coercion of some sort, then the coerced values are written
1256 into T2. Return value is 0 if the arguments could be matched, or the
1257 position at which they differ if not.
1259 STATICP is nonzero if the T1 argument list came from a
1260 static member function.
1262 For non-static member functions, we ignore the first argument,
1263 which is the type of the instance variable. This is because we want
1264 to handle calls with objects from derived classes. This is not
1265 entirely correct: we should actually check to make sure that a
1266 requested operation is type secure, shouldn't we? FIXME. */
1269 typecmp (staticp
, t1
, t2
)
1278 if (staticp
&& t1
== 0)
1282 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1283 if (t1
[!staticp
] == 0) return 0;
1284 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1286 struct type
*tt1
, *tt2
;
1290 tt2
= VALUE_TYPE(t2
[i
]);
1291 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1292 /* We should be doing hairy argument matching, as below. */
1293 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1295 t2
[i
] = value_addr (t2
[i
]);
1299 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1300 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1302 tt1
= TYPE_TARGET_TYPE(tt1
);
1303 tt2
= TYPE_TARGET_TYPE(tt2
);
1305 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1306 /* Array to pointer is a `trivial conversion' according to the ARM. */
1308 /* We should be doing much hairier argument matching (see section 13.2
1309 of the ARM), but as a quick kludge, just check for the same type
1311 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1314 if (!t1
[i
]) return 0;
1315 return t2
[i
] ? i
+1 : 0;
1318 /* Helper function used by value_struct_elt to recurse through baseclasses.
1319 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1320 and search in it assuming it has (class) type TYPE.
1321 If found, return value, else return NULL.
1323 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1324 look for a baseclass named NAME. */
1327 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1329 register value arg1
;
1331 register struct type
*type
;
1332 int looking_for_baseclass
;
1336 check_stub_type (type
);
1338 if (! looking_for_baseclass
)
1339 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1341 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1343 if (t_field_name
&& STREQ (t_field_name
, name
))
1346 if (TYPE_FIELD_STATIC (type
, i
))
1348 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1349 struct symbol
*sym
=
1350 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1352 error ("Internal error: could not find physical static variable named %s",
1354 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1355 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1358 v
= value_primitive_field (arg1
, offset
, i
, type
);
1360 error("there is no field named %s", name
);
1365 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1368 /* If we are looking for baseclasses, this is what we get when we
1369 hit them. But it could happen that the base part's member name
1370 is not yet filled in. */
1371 int found_baseclass
= (looking_for_baseclass
1372 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1373 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1375 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1378 /* Fix to use baseclass_offset instead. FIXME */
1379 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1382 error ("virtual baseclass botch");
1383 if (found_baseclass
)
1385 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1386 looking_for_baseclass
);
1388 else if (found_baseclass
)
1389 v
= value_primitive_field (arg1
, offset
, i
, type
);
1391 v
= search_struct_field (name
, arg1
,
1392 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1393 TYPE_BASECLASS (type
, i
),
1394 looking_for_baseclass
);
1400 /* Helper function used by value_struct_elt to recurse through baseclasses.
1401 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1402 and search in it assuming it has (class) type TYPE.
1403 If found, return value, else if name matched and args not return (value)-1,
1404 else return NULL. */
1407 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1409 register value
*arg1p
, *args
;
1410 int offset
, *static_memfuncp
;
1411 register struct type
*type
;
1415 int name_matched
= 0;
1416 char dem_opname
[64];
1418 check_stub_type (type
);
1419 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1421 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1422 if (strncmp(t_field_name
, "__", 2)==0 ||
1423 strncmp(t_field_name
, "op", 2)==0 ||
1424 strncmp(t_field_name
, "type", 4)==0 )
1426 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1427 t_field_name
= dem_opname
;
1428 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1429 t_field_name
= dem_opname
;
1431 if (t_field_name
&& STREQ (t_field_name
, name
))
1433 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1434 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1437 if (j
> 0 && args
== 0)
1438 error ("cannot resolve overloaded method `%s'", name
);
1441 if (TYPE_FN_FIELD_STUB (f
, j
))
1442 check_stub_method (type
, i
, j
);
1443 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1444 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1446 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1447 return (value
)value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1448 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1449 *static_memfuncp
= 1;
1450 v
= (value
)value_fn_field (arg1p
, f
, j
, type
, offset
);
1451 if (v
!= (value
)NULL
) return v
;
1458 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1462 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1464 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1465 if (base_offset
== -1)
1466 error ("virtual baseclass botch");
1470 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1472 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1473 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1474 if (v
== (value
) -1)
1480 /* FIXME-bothner: Why is this commented out? Why is it here? */
1481 /* *arg1p = arg1_tmp;*/
1485 if (name_matched
) return (value
) -1;
1489 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1490 extract the component named NAME from the ultimate target structure/union
1491 and return it as a value with its appropriate type.
1492 ERR is used in the error message if *ARGP's type is wrong.
1494 C++: ARGS is a list of argument types to aid in the selection of
1495 an appropriate method. Also, handle derived types.
1497 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1498 where the truthvalue of whether the function that was resolved was
1499 a static member function or not is stored.
1501 ERR is an error message to be printed in case the field is not found. */
1504 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1505 register value
*argp
, *args
;
1507 int *static_memfuncp
;
1510 register struct type
*t
;
1513 COERCE_ARRAY (*argp
);
1515 t
= VALUE_TYPE (*argp
);
1517 /* Follow pointers until we get to a non-pointer. */
1519 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1521 *argp
= value_ind (*argp
);
1522 /* Don't coerce fn pointer to fn and then back again! */
1523 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1524 COERCE_ARRAY (*argp
);
1525 t
= VALUE_TYPE (*argp
);
1528 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1529 error ("not implemented: member type in value_struct_elt");
1531 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1532 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1533 error ("Attempt to extract a component of a value that is not a %s.", err
);
1535 /* Assume it's not, unless we see that it is. */
1536 if (static_memfuncp
)
1537 *static_memfuncp
=0;
1541 /* if there are no arguments ...do this... */
1543 /* Try as a field first, because if we succeed, there
1544 is less work to be done. */
1545 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1549 /* C++: If it was not found as a data field, then try to
1550 return it as a pointer to a method. */
1552 if (destructor_name_p (name
, t
))
1553 error ("Cannot get value of destructor");
1555 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1557 if (v
== (value
) -1)
1558 error ("Cannot take address of a method");
1561 if (TYPE_NFN_FIELDS (t
))
1562 error ("There is no member or method named %s.", name
);
1564 error ("There is no member named %s.", name
);
1569 if (destructor_name_p (name
, t
))
1573 /* destructors are a special case. */
1574 v
= (value
)value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1575 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1576 if (!v
) error("could not find destructor function named %s.", name
);
1581 error ("destructor should not have any argument");
1585 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1587 if (v
== (value
) -1)
1589 error("Argument list of %s mismatch with component in the structure.", name
);
1593 /* See if user tried to invoke data as function. If so,
1594 hand it back. If it's not callable (i.e., a pointer to function),
1595 gdb should give an error. */
1596 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1600 error ("Structure has no component named %s.", name
);
1604 /* C++: return 1 is NAME is a legitimate name for the destructor
1605 of type TYPE. If TYPE does not have a destructor, or
1606 if NAME is inappropriate for TYPE, an error is signaled. */
1608 destructor_name_p (name
, type
)
1610 const struct type
*type
;
1612 /* destructors are a special case. */
1616 char *dname
= type_name_no_tag (type
);
1617 if (!STREQ (dname
, name
+1))
1618 error ("name of destructor must equal name of class");
1625 /* Helper function for check_field: Given TYPE, a structure/union,
1626 return 1 if the component named NAME from the ultimate
1627 target structure/union is defined, otherwise, return 0. */
1630 check_field_in (type
, name
)
1631 register struct type
*type
;
1636 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1638 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1639 if (t_field_name
&& STREQ (t_field_name
, name
))
1643 /* C++: If it was not found as a data field, then try to
1644 return it as a pointer to a method. */
1646 /* Destructors are a special case. */
1647 if (destructor_name_p (name
, type
))
1650 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1652 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1656 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1657 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1664 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1665 return 1 if the component named NAME from the ultimate
1666 target structure/union is defined, otherwise, return 0. */
1669 check_field (arg1
, name
)
1670 register value arg1
;
1673 register struct type
*t
;
1675 COERCE_ARRAY (arg1
);
1677 t
= VALUE_TYPE (arg1
);
1679 /* Follow pointers until we get to a non-pointer. */
1681 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1682 t
= TYPE_TARGET_TYPE (t
);
1684 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1685 error ("not implemented: member type in check_field");
1687 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1688 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1689 error ("Internal error: `this' is not an aggregate");
1691 return check_field_in (t
, name
);
1694 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1695 return the address of this member as a "pointer to member"
1696 type. If INTYPE is non-null, then it will be the type
1697 of the member we are looking for. This will help us resolve
1698 "pointers to member functions". This function is used
1699 to resolve user expressions of the form "DOMAIN::NAME". */
1702 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1703 struct type
*domain
, *curtype
, *intype
;
1707 register struct type
*t
= curtype
;
1711 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1712 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1713 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1715 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1717 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1719 if (t_field_name
&& STREQ (t_field_name
, name
))
1721 if (TYPE_FIELD_STATIC (t
, i
))
1723 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1724 struct symbol
*sym
=
1725 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1727 error ("Internal error: could not find physical static variable named %s",
1729 return value_at (SYMBOL_TYPE (sym
),
1730 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1732 if (TYPE_FIELD_PACKED (t
, i
))
1733 error ("pointers to bitfield members not allowed");
1735 return value_from_longest
1736 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1738 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1742 /* C++: If it was not found as a data field, then try to
1743 return it as a pointer to a method. */
1745 /* Destructors are a special case. */
1746 if (destructor_name_p (name
, t
))
1748 error ("member pointers to destructors not implemented yet");
1751 /* Perform all necessary dereferencing. */
1752 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1753 intype
= TYPE_TARGET_TYPE (intype
);
1755 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1757 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
1758 char dem_opname
[64];
1760 if (strncmp(t_field_name
, "__", 2)==0 ||
1761 strncmp(t_field_name
, "op", 2)==0 ||
1762 strncmp(t_field_name
, "type", 4)==0 )
1764 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1765 t_field_name
= dem_opname
;
1766 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1767 t_field_name
= dem_opname
;
1769 if (t_field_name
&& STREQ (t_field_name
, name
))
1771 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1772 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1774 if (intype
== 0 && j
> 1)
1775 error ("non-unique member `%s' requires type instantiation", name
);
1779 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1782 error ("no member function matches that type instantiation");
1787 if (TYPE_FN_FIELD_STUB (f
, j
))
1788 check_stub_method (t
, i
, j
);
1789 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1791 return value_from_longest
1792 (lookup_reference_type
1793 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1795 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1796 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1800 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1801 0, VAR_NAMESPACE
, 0, NULL
);
1808 v
= read_var_value (s
, 0);
1810 VALUE_TYPE (v
) = lookup_reference_type
1811 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1819 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1824 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1827 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1828 v
= value_struct_elt_for_reference (domain
,
1829 offset
+ base_offset
,
1830 TYPE_BASECLASS (t
, i
),
1839 /* C++: return the value of the class instance variable, if one exists.
1840 Flag COMPLAIN signals an error if the request is made in an
1841 inappropriate context. */
1843 value_of_this (complain
)
1846 extern FRAME selected_frame
;
1847 struct symbol
*func
, *sym
;
1850 static const char funny_this
[] = "this";
1853 if (selected_frame
== 0)
1855 error ("no frame selected");
1858 func
= get_frame_function (selected_frame
);
1862 error ("no `this' in nameless context");
1866 b
= SYMBOL_BLOCK_VALUE (func
);
1867 i
= BLOCK_NSYMS (b
);
1870 error ("no args, no `this'");
1873 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1874 symbol instead of the LOC_ARG one (if both exist). */
1875 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1879 error ("current stack frame not in method");
1884 this = read_var_value (sym
, selected_frame
);
1885 if (this == 0 && complain
)
1886 error ("`this' argument at unknown address");