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
];
289 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
292 COERCE_ARRAY (fromval
);
295 if (VALUE_LVAL (toval
) != lval_internalvar
)
296 fromval
= value_cast (type
, fromval
);
298 /* If TOVAL is a special machine register requiring conversion
299 of program values to a special raw format,
300 convert FROMVAL's contents now, with result in `raw_buffer',
301 and set USE_BUFFER to the number of bytes to write. */
303 if (VALUE_REGNO (toval
) >= 0
304 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
306 int regno
= VALUE_REGNO (toval
);
307 if (VALUE_TYPE (fromval
) != REGISTER_VIRTUAL_TYPE (regno
))
308 fromval
= value_cast (REGISTER_VIRTUAL_TYPE (regno
), fromval
);
309 memcpy (virtual_buffer
, VALUE_CONTENTS (fromval
),
310 REGISTER_VIRTUAL_SIZE (regno
));
311 REGISTER_CONVERT_TO_RAW (regno
, virtual_buffer
, raw_buffer
);
312 use_buffer
= REGISTER_RAW_SIZE (regno
);
315 switch (VALUE_LVAL (toval
))
317 case lval_internalvar
:
318 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
321 case lval_internalvar_component
:
322 set_internalvar_component (VALUE_INTERNALVAR (toval
),
323 VALUE_OFFSET (toval
),
324 VALUE_BITPOS (toval
),
325 VALUE_BITSIZE (toval
),
330 if (VALUE_BITSIZE (toval
))
332 char buffer
[sizeof (LONGEST
)];
333 /* We assume that the argument to read_memory is in units of
334 host chars. FIXME: Is that correct? */
335 int len
= (VALUE_BITPOS (toval
)
336 + VALUE_BITSIZE (toval
)
339 /* If bigger than a LONGEST, we don't handle it correctly,
340 but at least avoid corrupting memory. */
341 if (len
> sizeof (LONGEST
))
342 len
= sizeof (LONGEST
);
344 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
346 modify_field (buffer
, value_as_long (fromval
),
347 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
348 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
352 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
353 raw_buffer
, use_buffer
);
355 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
356 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
360 if (VALUE_BITSIZE (toval
))
362 char buffer
[MAX_REGISTER_RAW_SIZE
];
363 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
364 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
366 modify_field (buffer
, value_as_long (fromval
),
367 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
368 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
372 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
373 raw_buffer
, use_buffer
);
376 /* Do any conversion necessary when storing this type to more
377 than one register. */
378 #ifdef REGISTER_CONVERT_FROM_TYPE
379 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
380 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
381 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
382 raw_buffer
, TYPE_LENGTH (type
));
384 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
385 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
388 /* Assigning to the stack pointer, frame pointer, and other
389 (architecture and calling convention specific) registers may
390 cause the frame cache to be out of date. We just do this
391 on all assignments to registers for simplicity; I doubt the slowdown
393 reinit_frame_cache ();
396 case lval_reg_frame_relative
:
398 /* value is stored in a series of registers in the frame
399 specified by the structure. Copy that value out, modify
400 it, and copy it back in. */
401 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
402 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
403 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
404 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
407 /* Make the buffer large enough in all cases. */
408 char *buffer
= (char *) alloca (amount_to_copy
410 + MAX_REGISTER_RAW_SIZE
);
415 /* Figure out which frame this is in currently. */
416 for (frame
= get_current_frame ();
417 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
418 frame
= get_prev_frame (frame
))
422 error ("Value being assigned to is no longer active.");
424 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
427 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
429 amount_copied
< amount_to_copy
;
430 amount_copied
+= reg_size
, regno
++)
432 get_saved_register (buffer
+ amount_copied
,
433 (int *)NULL
, (CORE_ADDR
*)NULL
,
434 frame
, regno
, (enum lval_type
*)NULL
);
437 /* Modify what needs to be modified. */
438 if (VALUE_BITSIZE (toval
))
439 modify_field (buffer
+ byte_offset
,
440 value_as_long (fromval
),
441 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
443 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
445 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
449 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
451 amount_copied
< amount_to_copy
;
452 amount_copied
+= reg_size
, regno
++)
458 /* Just find out where to put it. */
459 get_saved_register ((char *)NULL
,
460 &optim
, &addr
, frame
, regno
, &lval
);
463 error ("Attempt to assign to a value that was optimized out.");
464 if (lval
== lval_memory
)
465 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
466 else if (lval
== lval_register
)
467 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
469 error ("Attempt to assign to an unmodifiable value.");
476 error ("Left side of = operation is not an lvalue.");
479 /* Return a value just like TOVAL except with the contents of FROMVAL
480 (except in the case of the type if TOVAL is an internalvar). */
482 if (VALUE_LVAL (toval
) == lval_internalvar
483 || VALUE_LVAL (toval
) == lval_internalvar_component
)
485 type
= VALUE_TYPE (fromval
);
488 /* FIXME: This loses if fromval is a different size than toval, for
489 example because fromval got cast in the REGISTER_CONVERTIBLE case
491 val
= allocate_value (type
);
492 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
493 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
495 VALUE_TYPE (val
) = type
;
500 /* Extend a value VAL to COUNT repetitions of its type. */
503 value_repeat (arg1
, count
)
509 if (VALUE_LVAL (arg1
) != lval_memory
)
510 error ("Only values in memory can be extended with '@'.");
512 error ("Invalid number %d of repetitions.", count
);
514 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
516 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
517 VALUE_CONTENTS_RAW (val
),
518 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
519 VALUE_LVAL (val
) = lval_memory
;
520 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
526 value_of_variable (var
, b
)
534 /* Use selected frame. */
538 fr
= block_innermost_frame (b
);
539 if (fr
== NULL
&& symbol_read_needs_frame (var
))
541 if (BLOCK_FUNCTION (b
) != NULL
542 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
543 error ("No frame is currently executing in block %s.",
544 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
546 error ("No frame is currently executing in specified block");
549 val
= read_var_value (var
, fr
);
551 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
555 /* Given a value which is an array, return a value which is a pointer to its
556 first element, regardless of whether or not the array has a nonzero lower
559 FIXME: A previous comment here indicated that this routine should be
560 substracting the array's lower bound. It's not clear to me that this
561 is correct. Given an array subscripting operation, it would certainly
562 work to do the adjustment here, essentially computing:
564 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
566 However I believe a more appropriate and logical place to account for
567 the lower bound is to do so in value_subscript, essentially computing:
569 (&array[0] + ((index - lowerbound) * sizeof array[0]))
571 As further evidence consider what would happen with operations other
572 than array subscripting, where the caller would get back a value that
573 had an address somewhere before the actual first element of the array,
574 and the information about the lower bound would be lost because of
575 the coercion to pointer type.
579 value_coerce_array (arg1
)
582 register struct type
*type
;
584 if (VALUE_LVAL (arg1
) != lval_memory
)
585 error ("Attempt to take address of value not located in memory.");
587 /* Get type of elements. */
588 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
589 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
591 /* A phony array made by value_repeat.
592 Its type is the type of the elements, not an array type. */
593 type
= VALUE_TYPE (arg1
);
595 return value_from_longest (lookup_pointer_type (type
),
596 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
599 /* Given a value which is a function, return a value which is a pointer
603 value_coerce_function (arg1
)
607 if (VALUE_LVAL (arg1
) != lval_memory
)
608 error ("Attempt to take address of value not located in memory.");
610 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
611 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
614 /* Return a pointer value for the object for which ARG1 is the contents. */
620 struct type
*type
= VALUE_TYPE (arg1
);
621 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
623 /* Copy the value, but change the type from (T&) to (T*).
624 We keep the same location information, which is efficient,
625 and allows &(&X) to get the location containing the reference. */
626 value arg2
= value_copy (arg1
);
627 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
630 if (VALUE_REPEATED (arg1
)
631 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
632 return value_coerce_array (arg1
);
633 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
634 return value_coerce_function (arg1
);
636 if (VALUE_LVAL (arg1
) != lval_memory
)
637 error ("Attempt to take address of value not located in memory.");
639 return value_from_longest (lookup_pointer_type (type
),
640 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
643 /* Given a value of a pointer type, apply the C unary * operator to it. */
651 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
652 error ("not implemented: member types in value_ind");
654 /* Allow * on an integer so we can cast it to whatever we want.
655 This returns an int, which seems like the most C-like thing
656 to do. "long long" variables are rare enough that
657 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
658 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
659 return value_at (builtin_type_int
,
660 (CORE_ADDR
) value_as_long (arg1
));
661 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
662 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
663 value_as_pointer (arg1
));
664 error ("Attempt to take contents of a non-pointer value.");
665 return 0; /* For lint -- never reached */
668 /* Pushing small parts of stack frames. */
670 /* Push one word (the size of object that a register holds). */
677 register int len
= sizeof (REGISTER_TYPE
);
678 char buffer
[MAX_REGISTER_RAW_SIZE
];
680 store_unsigned_integer (buffer
, len
, word
);
683 write_memory (sp
, buffer
, len
);
684 #else /* stack grows upward */
685 write_memory (sp
, buffer
, len
);
687 #endif /* stack grows upward */
692 /* Push LEN bytes with data at BUFFER. */
695 push_bytes (sp
, buffer
, len
)
702 write_memory (sp
, buffer
, len
);
703 #else /* stack grows upward */
704 write_memory (sp
, buffer
, len
);
706 #endif /* stack grows upward */
711 /* Push onto the stack the specified value VALUE. */
715 register CORE_ADDR sp
;
718 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
722 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
723 #else /* stack grows upward */
724 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
726 #endif /* stack grows upward */
731 /* Perform the standard coercions that are specified
732 for arguments to be passed to C functions. */
735 value_arg_coerce (arg
)
738 register struct type
*type
;
740 /* FIXME: We should coerce this according to the prototype (if we have
741 one). Right now we do a little bit of this in typecmp(), but that
742 doesn't always get called. For example, if passing a ref to a function
743 without a prototype, we probably should de-reference it. Currently
746 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ENUM
)
747 arg
= value_cast (builtin_type_unsigned_int
, arg
);
749 #if 1 /* FIXME: This is only a temporary patch. -fnf */
750 if (VALUE_REPEATED (arg
)
751 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
752 arg
= value_coerce_array (arg
);
753 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FUNC
)
754 arg
= value_coerce_function (arg
);
757 type
= VALUE_TYPE (arg
);
759 if (TYPE_CODE (type
) == TYPE_CODE_INT
760 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
761 return value_cast (builtin_type_int
, arg
);
763 if (TYPE_CODE (type
) == TYPE_CODE_FLT
764 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
765 return value_cast (builtin_type_double
, arg
);
770 /* Push the value ARG, first coercing it as an argument
774 value_arg_push (sp
, arg
)
775 register CORE_ADDR sp
;
778 return value_push (sp
, value_arg_coerce (arg
));
781 /* Determine a function's address and its return type from its value.
782 Calls error() if the function is not valid for calling. */
785 find_function_addr (function
, retval_type
)
787 struct type
**retval_type
;
789 register struct type
*ftype
= VALUE_TYPE (function
);
790 register enum type_code code
= TYPE_CODE (ftype
);
791 struct type
*value_type
;
794 /* If it's a member function, just look at the function
797 /* Determine address to call. */
798 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
800 funaddr
= VALUE_ADDRESS (function
);
801 value_type
= TYPE_TARGET_TYPE (ftype
);
803 else if (code
== TYPE_CODE_PTR
)
805 funaddr
= value_as_pointer (function
);
806 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
807 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
808 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
810 value_type
= builtin_type_int
;
812 else if (code
== TYPE_CODE_INT
)
814 /* Handle the case of functions lacking debugging info.
815 Their values are characters since their addresses are char */
816 if (TYPE_LENGTH (ftype
) == 1)
817 funaddr
= value_as_pointer (value_addr (function
));
819 /* Handle integer used as address of a function. */
820 funaddr
= (CORE_ADDR
) value_as_long (function
);
822 value_type
= builtin_type_int
;
825 error ("Invalid data type for function to be called.");
827 *retval_type
= value_type
;
831 #if defined (CALL_DUMMY)
832 /* All this stuff with a dummy frame may seem unnecessarily complicated
833 (why not just save registers in GDB?). The purpose of pushing a dummy
834 frame which looks just like a real frame is so that if you call a
835 function and then hit a breakpoint (get a signal, etc), "backtrace"
836 will look right. Whether the backtrace needs to actually show the
837 stack at the time the inferior function was called is debatable, but
838 it certainly needs to not display garbage. So if you are contemplating
839 making dummy frames be different from normal frames, consider that. */
841 /* Perform a function call in the inferior.
842 ARGS is a vector of values of arguments (NARGS of them).
843 FUNCTION is a value, the function to be called.
844 Returns a value representing what the function returned.
845 May fail to return, if a breakpoint or signal is hit
846 during the execution of the function. */
849 call_function_by_hand (function
, nargs
, args
)
854 register CORE_ADDR sp
;
857 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
858 is in host byte order. It is switched to target byte order before calling
860 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
861 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
863 struct type
*value_type
;
864 unsigned char struct_return
;
865 CORE_ADDR struct_addr
;
866 struct inferior_status inf_status
;
867 struct cleanup
*old_chain
;
872 if (!target_has_execution
)
875 save_inferior_status (&inf_status
, 1);
876 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
878 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
879 (and POP_FRAME for restoring them). (At least on most machines)
880 they are saved on the stack in the inferior. */
883 old_sp
= sp
= read_sp ();
885 #if 1 INNER_THAN 2 /* Stack grows down */
888 #else /* Stack grows up */
893 funaddr
= find_function_addr (function
, &value_type
);
896 struct block
*b
= block_for_pc (funaddr
);
897 /* If compiled without -g, assume GCC. */
898 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
901 /* Are we returning a value using a structure return or a normal
904 struct_return
= using_struct_return (function
, funaddr
, value_type
,
907 /* Create a call sequence customized for this function
908 and the number of arguments for it. */
909 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
910 store_unsigned_integer (&dummy1
[i
], sizeof (REGISTER_TYPE
),
911 (unsigned LONGEST
)dummy
[i
]);
913 #ifdef GDB_TARGET_IS_HPPA
914 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
915 value_type
, using_gcc
);
917 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
918 value_type
, using_gcc
);
922 #if CALL_DUMMY_LOCATION == ON_STACK
923 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
924 #endif /* On stack. */
926 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
927 /* Convex Unix prohibits executing in the stack segment. */
928 /* Hope there is empty room at the top of the text segment. */
930 extern CORE_ADDR text_end
;
933 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
934 if (read_memory_integer (start_sp
, 1) != 0)
935 error ("text segment full -- no place to put call");
938 real_pc
= text_end
- sizeof dummy
;
939 write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
941 #endif /* Before text_end. */
943 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
945 extern CORE_ADDR text_end
;
949 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
951 error ("Cannot write text segment -- call_function failed");
953 #endif /* After text_end. */
955 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
957 #endif /* At entry point. */
960 sp
= old_sp
; /* It really is used, for some ifdef's... */
964 /* If stack grows down, we must leave a hole at the top. */
968 /* Reserve space for the return structure to be written on the
969 stack, if necessary */
972 len
+= TYPE_LENGTH (value_type
);
974 for (i
= nargs
- 1; i
>= 0; i
--)
975 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
976 #ifdef CALL_DUMMY_STACK_ADJUST
977 len
+= CALL_DUMMY_STACK_ADJUST
;
980 sp
-= STACK_ALIGN (len
) - len
;
982 sp
+= STACK_ALIGN (len
) - len
;
985 #endif /* STACK_ALIGN */
987 /* Reserve space for the return structure to be written on the
988 stack, if necessary */
993 sp
-= TYPE_LENGTH (value_type
);
997 sp
+= TYPE_LENGTH (value_type
);
1001 #if defined (REG_STRUCT_HAS_ADDR)
1003 /* This is a machine like the sparc, where we need to pass a pointer
1004 to the structure, not the structure itself. */
1005 if (REG_STRUCT_HAS_ADDR (using_gcc
))
1006 for (i
= nargs
- 1; i
>= 0; i
--)
1007 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
1010 #if !(1 INNER_THAN 2)
1011 /* The stack grows up, so the address of the thing we push
1012 is the stack pointer before we push it. */
1015 /* Push the structure. */
1016 sp
= value_push (sp
, args
[i
]);
1018 /* The stack grows down, so the address of the thing we push
1019 is the stack pointer after we push it. */
1022 /* The value we're going to pass is the address of the thing
1024 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1028 #endif /* REG_STRUCT_HAS_ADDR. */
1030 #ifdef PUSH_ARGUMENTS
1031 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1032 #else /* !PUSH_ARGUMENTS */
1033 for (i
= nargs
- 1; i
>= 0; i
--)
1034 sp
= value_arg_push (sp
, args
[i
]);
1035 #endif /* !PUSH_ARGUMENTS */
1037 #ifdef CALL_DUMMY_STACK_ADJUST
1039 sp
-= CALL_DUMMY_STACK_ADJUST
;
1041 sp
+= CALL_DUMMY_STACK_ADJUST
;
1043 #endif /* CALL_DUMMY_STACK_ADJUST */
1045 /* Store the address at which the structure is supposed to be
1046 written. Note that this (and the code which reserved the space
1047 above) assumes that gcc was used to compile this function. Since
1048 it doesn't cost us anything but space and if the function is pcc
1049 it will ignore this value, we will make that assumption.
1051 Also note that on some machines (like the sparc) pcc uses a
1052 convention like gcc's. */
1055 STORE_STRUCT_RETURN (struct_addr
, sp
);
1057 /* Write the stack pointer. This is here because the statements above
1058 might fool with it. On SPARC, this write also stores the register
1059 window into the right place in the new stack frame, which otherwise
1060 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1064 char retbuf
[REGISTER_BYTES
];
1066 struct symbol
*symbol
;
1069 symbol
= find_pc_function (funaddr
);
1072 name
= SYMBOL_SOURCE_NAME (symbol
);
1076 /* Try the minimal symbols. */
1077 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1081 name
= SYMBOL_SOURCE_NAME (msymbol
);
1087 sprintf (format
, "at %s", local_hex_format ());
1089 sprintf (name
, format
, (unsigned long) funaddr
);
1092 /* Execute the stack dummy routine, calling FUNCTION.
1093 When it is done, discard the empty frame
1094 after storing the contents of all regs into retbuf. */
1095 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1097 /* We stopped somewhere besides the call dummy. */
1099 /* If we did the cleanups, we would print a spurious error message
1100 (Unable to restore previously selected frame), would write the
1101 registers from the inf_status (which is wrong), and would do other
1102 wrong things (like set stop_bpstat to the wrong thing). */
1103 discard_cleanups (old_chain
);
1104 /* Prevent memory leak. */
1105 bpstat_clear (&inf_status
.stop_bpstat
);
1107 /* The following error message used to say "The expression
1108 which contained the function call has been discarded." It
1109 is a hard concept to explain in a few words. Ideally, GDB
1110 would be able to resume evaluation of the expression when
1111 the function finally is done executing. Perhaps someday
1112 this will be implemented (it would not be easy). */
1114 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1115 a C++ name with arguments and stuff. */
1117 The program being debugged stopped while in a function called from GDB.\n\
1118 When the function (%s) is done executing, GDB will silently\n\
1119 stop (instead of continuing to evaluate the expression containing\n\
1120 the function call).", name
);
1123 do_cleanups (old_chain
);
1125 /* Figure out the value returned by the function. */
1126 return value_being_returned (value_type
, retbuf
, struct_return
);
1129 #else /* no CALL_DUMMY. */
1131 call_function_by_hand (function
, nargs
, args
)
1136 error ("Cannot invoke functions on this machine.");
1138 #endif /* no CALL_DUMMY. */
1141 /* Create a value for an array by allocating space in the inferior, copying
1142 the data into that space, and then setting up an array value.
1144 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1145 populated from the values passed in ELEMVEC.
1147 The element type of the array is inherited from the type of the
1148 first element, and all elements must have the same size (though we
1149 don't currently enforce any restriction on their types). */
1152 value_array (lowbound
, highbound
, elemvec
)
1161 struct type
*rangetype
;
1162 struct type
*arraytype
;
1165 /* Validate that the bounds are reasonable and that each of the elements
1166 have the same size. */
1168 nelem
= highbound
- lowbound
+ 1;
1171 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1173 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1174 for (idx
= 0; idx
< nelem
; idx
++)
1176 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1178 error ("array elements must all be the same size");
1182 /* Allocate space to store the array in the inferior, and then initialize
1183 it by copying in each element. FIXME: Is it worth it to create a
1184 local buffer in which to collect each value and then write all the
1185 bytes in one operation? */
1187 addr
= allocate_space_in_inferior (nelem
* typelength
);
1188 for (idx
= 0; idx
< nelem
; idx
++)
1190 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1194 /* Create the array type and set up an array value to be evaluated lazily. */
1196 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1197 lowbound
, highbound
);
1198 arraytype
= create_array_type ((struct type
*) NULL
,
1199 VALUE_TYPE (elemvec
[0]), rangetype
);
1200 val
= value_at_lazy (arraytype
, addr
);
1204 /* Create a value for a string constant by allocating space in the inferior,
1205 copying the data into that space, and returning the address with type
1206 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1208 Note that string types are like array of char types with a lower bound of
1209 zero and an upper bound of LEN - 1. Also note that the string may contain
1210 embedded null bytes. */
1213 value_string (ptr
, len
)
1218 struct type
*rangetype
;
1219 struct type
*stringtype
;
1222 /* Allocate space to store the string in the inferior, and then
1223 copy LEN bytes from PTR in gdb to that address in the inferior. */
1225 addr
= allocate_space_in_inferior (len
);
1226 write_memory (addr
, ptr
, len
);
1228 /* Create the string type and set up a string value to be evaluated
1231 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1233 stringtype
= create_string_type ((struct type
*) NULL
, rangetype
);
1234 val
= value_at_lazy (stringtype
, addr
);
1238 /* See if we can pass arguments in T2 to a function which takes arguments
1239 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1240 arguments need coercion of some sort, then the coerced values are written
1241 into T2. Return value is 0 if the arguments could be matched, or the
1242 position at which they differ if not.
1244 STATICP is nonzero if the T1 argument list came from a
1245 static member function.
1247 For non-static member functions, we ignore the first argument,
1248 which is the type of the instance variable. This is because we want
1249 to handle calls with objects from derived classes. This is not
1250 entirely correct: we should actually check to make sure that a
1251 requested operation is type secure, shouldn't we? FIXME. */
1254 typecmp (staticp
, t1
, t2
)
1263 if (staticp
&& t1
== 0)
1267 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1268 if (t1
[!staticp
] == 0) return 0;
1269 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1273 if (TYPE_CODE (t1
[i
]) == TYPE_CODE_REF
1274 /* We should be doing hairy argument matching, as below. */
1275 && (TYPE_CODE (TYPE_TARGET_TYPE (t1
[i
]))
1276 == TYPE_CODE (VALUE_TYPE (t2
[i
]))))
1278 t2
[i
] = value_addr (t2
[i
]);
1282 if (TYPE_CODE (t1
[i
]) == TYPE_CODE_PTR
1283 && TYPE_CODE (VALUE_TYPE (t2
[i
])) == TYPE_CODE_ARRAY
)
1284 /* Array to pointer is a `trivial conversion' according to the ARM. */
1287 /* We should be doing much hairier argument matching (see section 13.2
1288 of the ARM), but as a quick kludge, just check for the same type
1290 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1293 if (!t1
[i
]) return 0;
1294 return t2
[i
] ? i
+1 : 0;
1297 /* Helper function used by value_struct_elt to recurse through baseclasses.
1298 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1299 and search in it assuming it has (class) type TYPE.
1300 If found, return value, else return NULL.
1302 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1303 look for a baseclass named NAME. */
1306 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1308 register value arg1
;
1310 register struct type
*type
;
1311 int looking_for_baseclass
;
1315 check_stub_type (type
);
1317 if (! looking_for_baseclass
)
1318 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1320 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1322 if (t_field_name
&& STREQ (t_field_name
, name
))
1325 if (TYPE_FIELD_STATIC (type
, i
))
1327 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1328 struct symbol
*sym
=
1329 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1331 error ("Internal error: could not find physical static variable named %s",
1333 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1334 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1337 v
= value_primitive_field (arg1
, offset
, i
, type
);
1339 error("there is no field named %s", name
);
1344 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1347 /* If we are looking for baseclasses, this is what we get when we
1348 hit them. But it could happen that the base part's member name
1349 is not yet filled in. */
1350 int found_baseclass
= (looking_for_baseclass
1351 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1352 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1354 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1357 /* Fix to use baseclass_offset instead. FIXME */
1358 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1361 error ("virtual baseclass botch");
1362 if (found_baseclass
)
1364 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1365 looking_for_baseclass
);
1367 else if (found_baseclass
)
1368 v
= value_primitive_field (arg1
, offset
, i
, type
);
1370 v
= search_struct_field (name
, arg1
,
1371 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1372 TYPE_BASECLASS (type
, i
),
1373 looking_for_baseclass
);
1379 /* Helper function used by value_struct_elt to recurse through baseclasses.
1380 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1381 and search in it assuming it has (class) type TYPE.
1382 If found, return value, else if name matched and args not return (value)-1,
1383 else return NULL. */
1386 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1388 register value
*arg1p
, *args
;
1389 int offset
, *static_memfuncp
;
1390 register struct type
*type
;
1393 static int name_matched
= 0;
1395 check_stub_type (type
);
1396 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1398 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1399 if (t_field_name
&& STREQ (t_field_name
, name
))
1401 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1402 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1405 if (j
> 0 && args
== 0)
1406 error ("cannot resolve overloaded method `%s'", name
);
1409 if (TYPE_FN_FIELD_STUB (f
, j
))
1410 check_stub_method (type
, i
, j
);
1411 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1412 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1414 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1415 return (value
)value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1416 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1417 *static_memfuncp
= 1;
1418 return (value
)value_fn_field (arg1p
, f
, j
, type
, offset
);
1425 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1430 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1432 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1433 if (base_offset
== -1)
1434 error ("virtual baseclass botch");
1438 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1440 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1441 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1442 if (v
== (value
) -1)
1448 /* FIXME-bothner: Why is this commented out? Why is it here? */
1449 /* *arg1p = arg1_tmp;*/
1453 if (name_matched
) return (value
) -1;
1457 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1458 extract the component named NAME from the ultimate target structure/union
1459 and return it as a value with its appropriate type.
1460 ERR is used in the error message if *ARGP's type is wrong.
1462 C++: ARGS is a list of argument types to aid in the selection of
1463 an appropriate method. Also, handle derived types.
1465 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1466 where the truthvalue of whether the function that was resolved was
1467 a static member function or not is stored.
1469 ERR is an error message to be printed in case the field is not found. */
1472 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1473 register value
*argp
, *args
;
1475 int *static_memfuncp
;
1478 register struct type
*t
;
1481 COERCE_ARRAY (*argp
);
1483 t
= VALUE_TYPE (*argp
);
1485 /* Follow pointers until we get to a non-pointer. */
1487 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1489 *argp
= value_ind (*argp
);
1490 /* Don't coerce fn pointer to fn and then back again! */
1491 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1492 COERCE_ARRAY (*argp
);
1493 t
= VALUE_TYPE (*argp
);
1496 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1497 error ("not implemented: member type in value_struct_elt");
1499 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1500 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1501 error ("Attempt to extract a component of a value that is not a %s.", err
);
1503 /* Assume it's not, unless we see that it is. */
1504 if (static_memfuncp
)
1505 *static_memfuncp
=0;
1509 /* if there are no arguments ...do this... */
1511 /* Try as a field first, because if we succeed, there
1512 is less work to be done. */
1513 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1517 /* C++: If it was not found as a data field, then try to
1518 return it as a pointer to a method. */
1520 if (destructor_name_p (name
, t
))
1521 error ("Cannot get value of destructor");
1523 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1527 if (TYPE_NFN_FIELDS (t
))
1528 error ("There is no member or method named %s.", name
);
1530 error ("There is no member named %s.", name
);
1535 if (destructor_name_p (name
, t
))
1539 /* destructors are a special case. */
1540 return (value
)value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1541 TYPE_FN_FIELDLIST_LENGTH (t
, 0),
1546 error ("destructor should not have any argument");
1550 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1552 if (v
== (value
) -1)
1554 error("Argument list of %s mismatch with component in the structure.", name
);
1558 /* See if user tried to invoke data as function. If so,
1559 hand it back. If it's not callable (i.e., a pointer to function),
1560 gdb should give an error. */
1561 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1565 error ("Structure has no component named %s.", name
);
1569 /* C++: return 1 is NAME is a legitimate name for the destructor
1570 of type TYPE. If TYPE does not have a destructor, or
1571 if NAME is inappropriate for TYPE, an error is signaled. */
1573 destructor_name_p (name
, type
)
1575 const struct type
*type
;
1577 /* destructors are a special case. */
1581 char *dname
= type_name_no_tag (type
);
1582 if (!STREQ (dname
, name
+1))
1583 error ("name of destructor must equal name of class");
1590 /* Helper function for check_field: Given TYPE, a structure/union,
1591 return 1 if the component named NAME from the ultimate
1592 target structure/union is defined, otherwise, return 0. */
1595 check_field_in (type
, name
)
1596 register struct type
*type
;
1601 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1603 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1604 if (t_field_name
&& STREQ (t_field_name
, name
))
1608 /* C++: If it was not found as a data field, then try to
1609 return it as a pointer to a method. */
1611 /* Destructors are a special case. */
1612 if (destructor_name_p (name
, type
))
1615 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1617 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1621 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1622 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1629 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1630 return 1 if the component named NAME from the ultimate
1631 target structure/union is defined, otherwise, return 0. */
1634 check_field (arg1
, name
)
1635 register value arg1
;
1638 register struct type
*t
;
1640 COERCE_ARRAY (arg1
);
1642 t
= VALUE_TYPE (arg1
);
1644 /* Follow pointers until we get to a non-pointer. */
1646 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1647 t
= TYPE_TARGET_TYPE (t
);
1649 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1650 error ("not implemented: member type in check_field");
1652 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1653 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1654 error ("Internal error: `this' is not an aggregate");
1656 return check_field_in (t
, name
);
1659 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1660 return the address of this member as a "pointer to member"
1661 type. If INTYPE is non-null, then it will be the type
1662 of the member we are looking for. This will help us resolve
1663 "pointers to member functions". This function is used
1664 to resolve user expressions of the form "DOMAIN::NAME". */
1667 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1668 struct type
*domain
, *curtype
, *intype
;
1672 register struct type
*t
= curtype
;
1676 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1677 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1678 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1680 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1682 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1684 if (t_field_name
&& STREQ (t_field_name
, name
))
1686 if (TYPE_FIELD_STATIC (t
, i
))
1688 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1689 struct symbol
*sym
=
1690 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1692 error ("Internal error: could not find physical static variable named %s",
1694 return value_at (SYMBOL_TYPE (sym
),
1695 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1697 if (TYPE_FIELD_PACKED (t
, i
))
1698 error ("pointers to bitfield members not allowed");
1700 return value_from_longest
1701 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1703 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1707 /* C++: If it was not found as a data field, then try to
1708 return it as a pointer to a method. */
1710 /* Destructors are a special case. */
1711 if (destructor_name_p (name
, t
))
1713 error ("member pointers to destructors not implemented yet");
1716 /* Perform all necessary dereferencing. */
1717 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1718 intype
= TYPE_TARGET_TYPE (intype
);
1720 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1722 if (STREQ (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1724 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1725 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1727 if (intype
== 0 && j
> 1)
1728 error ("non-unique member `%s' requires type instantiation", name
);
1732 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1735 error ("no member function matches that type instantiation");
1740 if (TYPE_FN_FIELD_STUB (f
, j
))
1741 check_stub_method (t
, i
, j
);
1742 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1744 return value_from_longest
1745 (lookup_reference_type
1746 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1748 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1749 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1753 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1754 0, VAR_NAMESPACE
, 0, NULL
);
1761 v
= read_var_value (s
, 0);
1763 VALUE_TYPE (v
) = lookup_reference_type
1764 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1772 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1777 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1780 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1781 v
= value_struct_elt_for_reference (domain
,
1782 offset
+ base_offset
,
1783 TYPE_BASECLASS (t
, i
),
1792 /* C++: return the value of the class instance variable, if one exists.
1793 Flag COMPLAIN signals an error if the request is made in an
1794 inappropriate context. */
1796 value_of_this (complain
)
1799 extern FRAME selected_frame
;
1800 struct symbol
*func
, *sym
;
1803 static const char funny_this
[] = "this";
1806 if (selected_frame
== 0)
1808 error ("no frame selected");
1811 func
= get_frame_function (selected_frame
);
1815 error ("no `this' in nameless context");
1819 b
= SYMBOL_BLOCK_VALUE (func
);
1820 i
= BLOCK_NSYMS (b
);
1823 error ("no args, no `this'");
1826 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1827 symbol instead of the LOC_ARG one (if both exist). */
1828 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1832 error ("current stack frame not in method");
1837 this = read_var_value (sym
, selected_frame
);
1838 if (this == 0 && complain
)
1839 error ("`this' argument at unknown address");