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 int v
; /* FIXME, this won't work for large bitfields */
333 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
334 (char *) &v
, sizeof v
);
335 modify_field ((char *) &v
, value_as_long (fromval
),
336 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
337 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
338 (char *)&v
, sizeof v
);
341 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
342 raw_buffer
, use_buffer
);
344 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
345 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
349 if (VALUE_BITSIZE (toval
))
353 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
354 (char *) &v
, sizeof v
);
355 modify_field ((char *) &v
, value_as_long (fromval
),
356 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
357 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
358 (char *) &v
, sizeof v
);
361 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
362 raw_buffer
, use_buffer
);
365 /* Do any conversion necessary when storing this type to more
366 than one register. */
367 #ifdef REGISTER_CONVERT_FROM_TYPE
368 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
369 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
370 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
371 raw_buffer
, TYPE_LENGTH (type
));
373 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
374 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
379 case lval_reg_frame_relative
:
381 /* value is stored in a series of registers in the frame
382 specified by the structure. Copy that value out, modify
383 it, and copy it back in. */
384 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
385 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
386 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
387 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
389 char *buffer
= (char *) alloca (amount_to_copy
);
393 /* Figure out which frame this is in currently. */
394 for (frame
= get_current_frame ();
395 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
396 frame
= get_prev_frame (frame
))
400 error ("Value being assigned to is no longer active.");
402 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
405 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
407 amount_copied
< amount_to_copy
;
408 amount_copied
+= reg_size
, regno
++)
410 get_saved_register (buffer
+ amount_copied
,
411 (int *)NULL
, (CORE_ADDR
*)NULL
,
412 frame
, regno
, (enum lval_type
*)NULL
);
415 /* Modify what needs to be modified. */
416 if (VALUE_BITSIZE (toval
))
417 modify_field (buffer
+ byte_offset
,
418 value_as_long (fromval
),
419 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
421 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
423 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
427 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
429 amount_copied
< amount_to_copy
;
430 amount_copied
+= reg_size
, regno
++)
436 /* Just find out where to put it. */
437 get_saved_register ((char *)NULL
,
438 &optim
, &addr
, frame
, regno
, &lval
);
441 error ("Attempt to assign to a value that was optimized out.");
442 if (lval
== lval_memory
)
443 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
444 else if (lval
== lval_register
)
445 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
447 error ("Attempt to assign to an unmodifiable value.");
454 error ("Left side of = operation is not an lvalue.");
457 /* Return a value just like TOVAL except with the contents of FROMVAL
458 (except in the case of the type if TOVAL is an internalvar). */
460 if (VALUE_LVAL (toval
) == lval_internalvar
461 || VALUE_LVAL (toval
) == lval_internalvar_component
)
463 type
= VALUE_TYPE (fromval
);
466 val
= allocate_value (type
);
467 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
468 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
470 VALUE_TYPE (val
) = type
;
475 /* Extend a value VAL to COUNT repetitions of its type. */
478 value_repeat (arg1
, count
)
484 if (VALUE_LVAL (arg1
) != lval_memory
)
485 error ("Only values in memory can be extended with '@'.");
487 error ("Invalid number %d of repetitions.", count
);
489 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
491 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
492 VALUE_CONTENTS_RAW (val
),
493 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
494 VALUE_LVAL (val
) = lval_memory
;
495 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
501 value_of_variable (var
, b
)
509 /* Use selected frame. */
513 fr
= block_innermost_frame (b
);
516 if (BLOCK_FUNCTION (b
) != NULL
517 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
518 error ("No frame is currently executing in block %s.",
519 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
521 error ("No frame is currently executing in specified block");
524 val
= read_var_value (var
, fr
);
526 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
530 /* Given a value which is an array, return a value which is a pointer to its
531 first element, regardless of whether or not the array has a nonzero lower
534 FIXME: A previous comment here indicated that this routine should be
535 substracting the array's lower bound. It's not clear to me that this
536 is correct. Given an array subscripting operation, it would certainly
537 work to do the adjustment here, essentially computing:
539 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
541 However I believe a more appropriate and logical place to account for
542 the lower bound is to do so in value_subscript, essentially computing:
544 (&array[0] + ((index - lowerbound) * sizeof array[0]))
546 As further evidence consider what would happen with operations other
547 than array subscripting, where the caller would get back a value that
548 had an address somewhere before the actual first element of the array,
549 and the information about the lower bound would be lost because of
550 the coercion to pointer type.
554 value_coerce_array (arg1
)
557 register struct type
*type
;
559 if (VALUE_LVAL (arg1
) != lval_memory
)
560 error ("Attempt to take address of value not located in memory.");
562 /* Get type of elements. */
563 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
564 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
566 /* A phony array made by value_repeat.
567 Its type is the type of the elements, not an array type. */
568 type
= VALUE_TYPE (arg1
);
570 return value_from_longest (lookup_pointer_type (type
),
571 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
574 /* Given a value which is a function, return a value which is a pointer
578 value_coerce_function (arg1
)
582 if (VALUE_LVAL (arg1
) != lval_memory
)
583 error ("Attempt to take address of value not located in memory.");
585 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
586 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
589 /* Return a pointer value for the object for which ARG1 is the contents. */
595 struct type
*type
= VALUE_TYPE (arg1
);
596 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
598 /* Copy the value, but change the type from (T&) to (T*).
599 We keep the same location information, which is efficient,
600 and allows &(&X) to get the location containing the reference. */
601 value arg2
= value_copy (arg1
);
602 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
605 if (VALUE_REPEATED (arg1
)
606 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
607 return value_coerce_array (arg1
);
608 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
609 return value_coerce_function (arg1
);
611 if (VALUE_LVAL (arg1
) != lval_memory
)
612 error ("Attempt to take address of value not located in memory.");
614 return value_from_longest (lookup_pointer_type (type
),
615 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
618 /* Given a value of a pointer type, apply the C unary * operator to it. */
626 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
627 error ("not implemented: member types in value_ind");
629 /* Allow * on an integer so we can cast it to whatever we want.
630 This returns an int, which seems like the most C-like thing
631 to do. "long long" variables are rare enough that
632 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
633 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
634 return value_at (builtin_type_int
,
635 (CORE_ADDR
) value_as_long (arg1
));
636 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
637 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
638 value_as_pointer (arg1
));
639 error ("Attempt to take contents of a non-pointer value.");
640 return 0; /* For lint -- never reached */
643 /* Pushing small parts of stack frames. */
645 /* Push one word (the size of object that a register holds). */
652 register int len
= sizeof (REGISTER_TYPE
);
653 char buffer
[MAX_REGISTER_RAW_SIZE
];
655 store_unsigned_integer (buffer
, len
, word
);
658 write_memory (sp
, buffer
, len
);
659 #else /* stack grows upward */
660 write_memory (sp
, buffer
, len
);
662 #endif /* stack grows upward */
667 /* Push LEN bytes with data at BUFFER. */
670 push_bytes (sp
, buffer
, len
)
677 write_memory (sp
, buffer
, len
);
678 #else /* stack grows upward */
679 write_memory (sp
, buffer
, len
);
681 #endif /* stack grows upward */
686 /* Push onto the stack the specified value VALUE. */
690 register CORE_ADDR sp
;
693 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
697 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
698 #else /* stack grows upward */
699 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
701 #endif /* stack grows upward */
706 /* Perform the standard coercions that are specified
707 for arguments to be passed to C functions. */
710 value_arg_coerce (arg
)
713 register struct type
*type
;
715 /* FIXME: We should coerce this according to the prototype (if we have
716 one). Right now we do a little bit of this in typecmp(), but that
717 doesn't always get called. For example, if passing a ref to a function
718 without a prototype, we probably should de-reference it. Currently
721 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ENUM
)
722 arg
= value_cast (builtin_type_unsigned_int
, arg
);
724 #if 1 /* FIXME: This is only a temporary patch. -fnf */
725 if (VALUE_REPEATED (arg
)
726 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
727 arg
= value_coerce_array (arg
);
728 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FUNC
)
729 arg
= value_coerce_function (arg
);
732 type
= VALUE_TYPE (arg
);
734 if (TYPE_CODE (type
) == TYPE_CODE_INT
735 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
736 return value_cast (builtin_type_int
, arg
);
738 if (TYPE_CODE (type
) == TYPE_CODE_FLT
739 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
740 return value_cast (builtin_type_double
, arg
);
745 /* Push the value ARG, first coercing it as an argument
749 value_arg_push (sp
, arg
)
750 register CORE_ADDR sp
;
753 return value_push (sp
, value_arg_coerce (arg
));
756 /* Determine a function's address and its return type from its value.
757 Calls error() if the function is not valid for calling. */
760 find_function_addr (function
, retval_type
)
762 struct type
**retval_type
;
764 register struct type
*ftype
= VALUE_TYPE (function
);
765 register enum type_code code
= TYPE_CODE (ftype
);
766 struct type
*value_type
;
769 /* If it's a member function, just look at the function
772 /* Determine address to call. */
773 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
775 funaddr
= VALUE_ADDRESS (function
);
776 value_type
= TYPE_TARGET_TYPE (ftype
);
778 else if (code
== TYPE_CODE_PTR
)
780 funaddr
= value_as_pointer (function
);
781 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
782 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
783 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
785 value_type
= builtin_type_int
;
787 else if (code
== TYPE_CODE_INT
)
789 /* Handle the case of functions lacking debugging info.
790 Their values are characters since their addresses are char */
791 if (TYPE_LENGTH (ftype
) == 1)
792 funaddr
= value_as_pointer (value_addr (function
));
794 /* Handle integer used as address of a function. */
795 funaddr
= (CORE_ADDR
) value_as_long (function
);
797 value_type
= builtin_type_int
;
800 error ("Invalid data type for function to be called.");
802 *retval_type
= value_type
;
806 #if defined (CALL_DUMMY)
807 /* All this stuff with a dummy frame may seem unnecessarily complicated
808 (why not just save registers in GDB?). The purpose of pushing a dummy
809 frame which looks just like a real frame is so that if you call a
810 function and then hit a breakpoint (get a signal, etc), "backtrace"
811 will look right. Whether the backtrace needs to actually show the
812 stack at the time the inferior function was called is debatable, but
813 it certainly needs to not display garbage. So if you are contemplating
814 making dummy frames be different from normal frames, consider that. */
816 /* Perform a function call in the inferior.
817 ARGS is a vector of values of arguments (NARGS of them).
818 FUNCTION is a value, the function to be called.
819 Returns a value representing what the function returned.
820 May fail to return, if a breakpoint or signal is hit
821 during the execution of the function. */
824 call_function_by_hand (function
, nargs
, args
)
829 register CORE_ADDR sp
;
832 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
833 is in host byte order. It is switched to target byte order before calling
835 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
836 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
838 struct type
*value_type
;
839 unsigned char struct_return
;
840 CORE_ADDR struct_addr
;
841 struct inferior_status inf_status
;
842 struct cleanup
*old_chain
;
847 if (!target_has_execution
)
850 save_inferior_status (&inf_status
, 1);
851 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
853 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
854 (and POP_FRAME for restoring them). (At least on most machines)
855 they are saved on the stack in the inferior. */
858 old_sp
= sp
= read_sp ();
860 #if 1 INNER_THAN 2 /* Stack grows down */
863 #else /* Stack grows up */
868 funaddr
= find_function_addr (function
, &value_type
);
871 struct block
*b
= block_for_pc (funaddr
);
872 /* If compiled without -g, assume GCC. */
873 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
876 /* Are we returning a value using a structure return or a normal
879 struct_return
= using_struct_return (function
, funaddr
, value_type
,
882 /* Create a call sequence customized for this function
883 and the number of arguments for it. */
884 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
885 store_unsigned_integer (&dummy1
[i
], sizeof (REGISTER_TYPE
),
886 (unsigned LONGEST
)dummy
[i
]);
888 #ifdef GDB_TARGET_IS_HPPA
889 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
890 value_type
, using_gcc
);
892 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
893 value_type
, using_gcc
);
897 #if CALL_DUMMY_LOCATION == ON_STACK
898 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
899 #endif /* On stack. */
901 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
902 /* Convex Unix prohibits executing in the stack segment. */
903 /* Hope there is empty room at the top of the text segment. */
905 extern CORE_ADDR text_end
;
908 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
909 if (read_memory_integer (start_sp
, 1) != 0)
910 error ("text segment full -- no place to put call");
913 real_pc
= text_end
- sizeof dummy
;
914 write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
916 #endif /* Before text_end. */
918 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
920 extern CORE_ADDR text_end
;
924 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy
);
926 error ("Cannot write text segment -- call_function failed");
928 #endif /* After text_end. */
930 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
932 #endif /* At entry point. */
935 sp
= old_sp
; /* It really is used, for some ifdef's... */
939 /* If stack grows down, we must leave a hole at the top. */
943 /* Reserve space for the return structure to be written on the
944 stack, if necessary */
947 len
+= TYPE_LENGTH (value_type
);
949 for (i
= nargs
- 1; i
>= 0; i
--)
950 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
951 #ifdef CALL_DUMMY_STACK_ADJUST
952 len
+= CALL_DUMMY_STACK_ADJUST
;
955 sp
-= STACK_ALIGN (len
) - len
;
957 sp
+= STACK_ALIGN (len
) - len
;
960 #endif /* STACK_ALIGN */
962 /* Reserve space for the return structure to be written on the
963 stack, if necessary */
968 sp
-= TYPE_LENGTH (value_type
);
972 sp
+= TYPE_LENGTH (value_type
);
976 #if defined (REG_STRUCT_HAS_ADDR)
978 /* This is a machine like the sparc, where we need to pass a pointer
979 to the structure, not the structure itself. */
980 if (REG_STRUCT_HAS_ADDR (using_gcc
))
981 for (i
= nargs
- 1; i
>= 0; i
--)
982 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
985 #if !(1 INNER_THAN 2)
986 /* The stack grows up, so the address of the thing we push
987 is the stack pointer before we push it. */
990 /* Push the structure. */
991 sp
= value_push (sp
, args
[i
]);
993 /* The stack grows down, so the address of the thing we push
994 is the stack pointer after we push it. */
997 /* The value we're going to pass is the address of the thing
999 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1003 #endif /* REG_STRUCT_HAS_ADDR. */
1005 #ifdef PUSH_ARGUMENTS
1006 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1007 #else /* !PUSH_ARGUMENTS */
1008 for (i
= nargs
- 1; i
>= 0; i
--)
1009 sp
= value_arg_push (sp
, args
[i
]);
1010 #endif /* !PUSH_ARGUMENTS */
1012 #ifdef CALL_DUMMY_STACK_ADJUST
1014 sp
-= CALL_DUMMY_STACK_ADJUST
;
1016 sp
+= CALL_DUMMY_STACK_ADJUST
;
1018 #endif /* CALL_DUMMY_STACK_ADJUST */
1020 /* Store the address at which the structure is supposed to be
1021 written. Note that this (and the code which reserved the space
1022 above) assumes that gcc was used to compile this function. Since
1023 it doesn't cost us anything but space and if the function is pcc
1024 it will ignore this value, we will make that assumption.
1026 Also note that on some machines (like the sparc) pcc uses a
1027 convention like gcc's. */
1030 STORE_STRUCT_RETURN (struct_addr
, sp
);
1032 /* Write the stack pointer. This is here because the statements above
1033 might fool with it. On SPARC, this write also stores the register
1034 window into the right place in the new stack frame, which otherwise
1035 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1039 char retbuf
[REGISTER_BYTES
];
1041 struct symbol
*symbol
;
1044 symbol
= find_pc_function (funaddr
);
1047 name
= SYMBOL_SOURCE_NAME (symbol
);
1051 /* Try the minimal symbols. */
1052 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1056 name
= SYMBOL_SOURCE_NAME (msymbol
);
1062 sprintf (format
, "at %s", local_hex_format ());
1064 sprintf (name
, format
, (unsigned long) funaddr
);
1067 /* Execute the stack dummy routine, calling FUNCTION.
1068 When it is done, discard the empty frame
1069 after storing the contents of all regs into retbuf. */
1070 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1072 /* We stopped somewhere besides the call dummy. */
1074 /* If we did the cleanups, we would print a spurious error message
1075 (Unable to restore previously selected frame), would write the
1076 registers from the inf_status (which is wrong), and would do other
1077 wrong things (like set stop_bpstat to the wrong thing). */
1078 discard_cleanups (old_chain
);
1079 /* Prevent memory leak. */
1080 bpstat_clear (&inf_status
.stop_bpstat
);
1082 /* The following error message used to say "The expression
1083 which contained the function call has been discarded." It
1084 is a hard concept to explain in a few words. Ideally, GDB
1085 would be able to resume evaluation of the expression when
1086 the function finally is done executing. Perhaps someday
1087 this will be implemented (it would not be easy). */
1089 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1090 a C++ name with arguments and stuff. */
1092 The program being debugged stopped while in a function called from GDB.\n\
1093 When the function (%s) is done executing, GDB will silently\n\
1094 stop (instead of continuing to evaluate the expression containing\n\
1095 the function call).", name
);
1098 do_cleanups (old_chain
);
1100 /* Figure out the value returned by the function. */
1101 return value_being_returned (value_type
, retbuf
, struct_return
);
1104 #else /* no CALL_DUMMY. */
1106 call_function_by_hand (function
, nargs
, args
)
1111 error ("Cannot invoke functions on this machine.");
1113 #endif /* no CALL_DUMMY. */
1116 /* Create a value for an array by allocating space in the inferior, copying
1117 the data into that space, and then setting up an array value.
1119 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1120 populated from the values passed in ELEMVEC.
1122 The element type of the array is inherited from the type of the
1123 first element, and all elements must have the same size (though we
1124 don't currently enforce any restriction on their types). */
1127 value_array (lowbound
, highbound
, elemvec
)
1136 struct type
*rangetype
;
1137 struct type
*arraytype
;
1140 /* Validate that the bounds are reasonable and that each of the elements
1141 have the same size. */
1143 nelem
= highbound
- lowbound
+ 1;
1146 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1148 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1149 for (idx
= 0; idx
< nelem
; idx
++)
1151 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1153 error ("array elements must all be the same size");
1157 /* Allocate space to store the array in the inferior, and then initialize
1158 it by copying in each element. FIXME: Is it worth it to create a
1159 local buffer in which to collect each value and then write all the
1160 bytes in one operation? */
1162 addr
= allocate_space_in_inferior (nelem
* typelength
);
1163 for (idx
= 0; idx
< nelem
; idx
++)
1165 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1169 /* Create the array type and set up an array value to be evaluated lazily. */
1171 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1172 lowbound
, highbound
);
1173 arraytype
= create_array_type ((struct type
*) NULL
,
1174 VALUE_TYPE (elemvec
[0]), rangetype
);
1175 val
= value_at_lazy (arraytype
, addr
);
1179 /* Create a value for a string constant by allocating space in the inferior,
1180 copying the data into that space, and returning the address with type
1181 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1183 Note that string types are like array of char types with a lower bound of
1184 zero and an upper bound of LEN - 1. Also note that the string may contain
1185 embedded null bytes. */
1188 value_string (ptr
, len
)
1193 struct type
*rangetype
;
1194 struct type
*stringtype
;
1197 /* Allocate space to store the string in the inferior, and then
1198 copy LEN bytes from PTR in gdb to that address in the inferior. */
1200 addr
= allocate_space_in_inferior (len
);
1201 write_memory (addr
, ptr
, len
);
1203 /* Create the string type and set up a string value to be evaluated
1206 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1208 stringtype
= create_string_type ((struct type
*) NULL
, rangetype
);
1209 val
= value_at_lazy (stringtype
, addr
);
1213 /* See if we can pass arguments in T2 to a function which takes arguments
1214 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1215 arguments need coercion of some sort, then the coerced values are written
1216 into T2. Return value is 0 if the arguments could be matched, or the
1217 position at which they differ if not.
1219 STATICP is nonzero if the T1 argument list came from a
1220 static member function.
1222 For non-static member functions, we ignore the first argument,
1223 which is the type of the instance variable. This is because we want
1224 to handle calls with objects from derived classes. This is not
1225 entirely correct: we should actually check to make sure that a
1226 requested operation is type secure, shouldn't we? FIXME. */
1229 typecmp (staticp
, t1
, t2
)
1238 if (staticp
&& t1
== 0)
1242 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1243 if (t1
[!staticp
] == 0) return 0;
1244 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1248 if (TYPE_CODE (t1
[i
]) == TYPE_CODE_REF
1249 /* We should be doing hairy argument matching, as below. */
1250 && (TYPE_CODE (TYPE_TARGET_TYPE (t1
[i
]))
1251 == TYPE_CODE (VALUE_TYPE (t2
[i
]))))
1253 t2
[i
] = value_addr (t2
[i
]);
1257 if (TYPE_CODE (t1
[i
]) == TYPE_CODE_PTR
1258 && TYPE_CODE (VALUE_TYPE (t2
[i
])) == TYPE_CODE_ARRAY
)
1259 /* Array to pointer is a `trivial conversion' according to the ARM. */
1262 /* We should be doing much hairier argument matching (see section 13.2
1263 of the ARM), but as a quick kludge, just check for the same type
1265 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1268 if (!t1
[i
]) return 0;
1269 return t2
[i
] ? i
+1 : 0;
1272 /* Helper function used by value_struct_elt to recurse through baseclasses.
1273 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1274 and search in it assuming it has (class) type TYPE.
1275 If found, return value, else return NULL.
1277 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1278 look for a baseclass named NAME. */
1281 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1283 register value arg1
;
1285 register struct type
*type
;
1286 int looking_for_baseclass
;
1290 check_stub_type (type
);
1292 if (! looking_for_baseclass
)
1293 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1295 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1297 if (t_field_name
&& STREQ (t_field_name
, name
))
1300 if (TYPE_FIELD_STATIC (type
, i
))
1302 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1303 struct symbol
*sym
=
1304 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1306 error ("Internal error: could not find physical static variable named %s",
1308 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1309 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1312 v
= value_primitive_field (arg1
, offset
, i
, type
);
1314 error("there is no field named %s", name
);
1319 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1322 /* If we are looking for baseclasses, this is what we get when we
1323 hit them. But it could happen that the base part's member name
1324 is not yet filled in. */
1325 int found_baseclass
= (looking_for_baseclass
1326 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1327 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1329 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1332 /* Fix to use baseclass_offset instead. FIXME */
1333 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1336 error ("virtual baseclass botch");
1337 if (found_baseclass
)
1339 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1340 looking_for_baseclass
);
1342 else if (found_baseclass
)
1343 v
= value_primitive_field (arg1
, offset
, i
, type
);
1345 v
= search_struct_field (name
, arg1
,
1346 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1347 TYPE_BASECLASS (type
, i
),
1348 looking_for_baseclass
);
1354 /* Helper function used by value_struct_elt to recurse through baseclasses.
1355 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1356 and search in it assuming it has (class) type TYPE.
1357 If found, return value, else if name matched and args not return (value)-1,
1358 else return NULL. */
1361 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1363 register value
*arg1p
, *args
;
1364 int offset
, *static_memfuncp
;
1365 register struct type
*type
;
1368 static int name_matched
= 0;
1370 check_stub_type (type
);
1371 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1373 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1374 if (t_field_name
&& STREQ (t_field_name
, name
))
1376 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1377 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1380 if (j
> 0 && args
== 0)
1381 error ("cannot resolve overloaded method `%s'", name
);
1384 if (TYPE_FN_FIELD_STUB (f
, j
))
1385 check_stub_method (type
, i
, j
);
1386 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1387 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1389 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1390 return (value
)value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1391 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1392 *static_memfuncp
= 1;
1393 return (value
)value_fn_field (arg1p
, f
, j
, type
, offset
);
1400 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1405 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1407 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1408 if (base_offset
== -1)
1409 error ("virtual baseclass botch");
1413 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1415 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1416 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1417 if (v
== (value
) -1)
1423 /* FIXME-bothner: Why is this commented out? Why is it here? */
1424 /* *arg1p = arg1_tmp;*/
1428 if (name_matched
) return (value
) -1;
1432 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1433 extract the component named NAME from the ultimate target structure/union
1434 and return it as a value with its appropriate type.
1435 ERR is used in the error message if *ARGP's type is wrong.
1437 C++: ARGS is a list of argument types to aid in the selection of
1438 an appropriate method. Also, handle derived types.
1440 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1441 where the truthvalue of whether the function that was resolved was
1442 a static member function or not is stored.
1444 ERR is an error message to be printed in case the field is not found. */
1447 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1448 register value
*argp
, *args
;
1450 int *static_memfuncp
;
1453 register struct type
*t
;
1456 COERCE_ARRAY (*argp
);
1458 t
= VALUE_TYPE (*argp
);
1460 /* Follow pointers until we get to a non-pointer. */
1462 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1464 *argp
= value_ind (*argp
);
1465 /* Don't coerce fn pointer to fn and then back again! */
1466 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1467 COERCE_ARRAY (*argp
);
1468 t
= VALUE_TYPE (*argp
);
1471 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1472 error ("not implemented: member type in value_struct_elt");
1474 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1475 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1476 error ("Attempt to extract a component of a value that is not a %s.", err
);
1478 /* Assume it's not, unless we see that it is. */
1479 if (static_memfuncp
)
1480 *static_memfuncp
=0;
1484 /* if there are no arguments ...do this... */
1486 /* Try as a field first, because if we succeed, there
1487 is less work to be done. */
1488 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1492 /* C++: If it was not found as a data field, then try to
1493 return it as a pointer to a method. */
1495 if (destructor_name_p (name
, t
))
1496 error ("Cannot get value of destructor");
1498 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1502 if (TYPE_NFN_FIELDS (t
))
1503 error ("There is no member or method named %s.", name
);
1505 error ("There is no member named %s.", name
);
1510 if (destructor_name_p (name
, t
))
1514 /* destructors are a special case. */
1515 return (value
)value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1516 TYPE_FN_FIELDLIST_LENGTH (t
, 0),
1521 error ("destructor should not have any argument");
1525 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1527 if (v
== (value
) -1)
1529 error("Argument list of %s mismatch with component in the structure.", name
);
1533 /* See if user tried to invoke data as function. If so,
1534 hand it back. If it's not callable (i.e., a pointer to function),
1535 gdb should give an error. */
1536 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1540 error ("Structure has no component named %s.", name
);
1544 /* C++: return 1 is NAME is a legitimate name for the destructor
1545 of type TYPE. If TYPE does not have a destructor, or
1546 if NAME is inappropriate for TYPE, an error is signaled. */
1548 destructor_name_p (name
, type
)
1550 const struct type
*type
;
1552 /* destructors are a special case. */
1556 char *dname
= type_name_no_tag (type
);
1557 if (!STREQ (dname
, name
+1))
1558 error ("name of destructor must equal name of class");
1565 /* Helper function for check_field: Given TYPE, a structure/union,
1566 return 1 if the component named NAME from the ultimate
1567 target structure/union is defined, otherwise, return 0. */
1570 check_field_in (type
, name
)
1571 register struct type
*type
;
1576 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1578 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1579 if (t_field_name
&& STREQ (t_field_name
, name
))
1583 /* C++: If it was not found as a data field, then try to
1584 return it as a pointer to a method. */
1586 /* Destructors are a special case. */
1587 if (destructor_name_p (name
, type
))
1590 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1592 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1596 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1597 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1604 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1605 return 1 if the component named NAME from the ultimate
1606 target structure/union is defined, otherwise, return 0. */
1609 check_field (arg1
, name
)
1610 register value arg1
;
1613 register struct type
*t
;
1615 COERCE_ARRAY (arg1
);
1617 t
= VALUE_TYPE (arg1
);
1619 /* Follow pointers until we get to a non-pointer. */
1621 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1622 t
= TYPE_TARGET_TYPE (t
);
1624 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1625 error ("not implemented: member type in check_field");
1627 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1628 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1629 error ("Internal error: `this' is not an aggregate");
1631 return check_field_in (t
, name
);
1634 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1635 return the address of this member as a "pointer to member"
1636 type. If INTYPE is non-null, then it will be the type
1637 of the member we are looking for. This will help us resolve
1638 "pointers to member functions". This function is used
1639 to resolve user expressions of the form "DOMAIN::NAME". */
1642 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1643 struct type
*domain
, *curtype
, *intype
;
1647 register struct type
*t
= curtype
;
1651 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1652 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1653 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1655 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1657 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1659 if (t_field_name
&& STREQ (t_field_name
, name
))
1661 if (TYPE_FIELD_STATIC (t
, i
))
1663 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1664 struct symbol
*sym
=
1665 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1667 error ("Internal error: could not find physical static variable named %s",
1669 return value_at (SYMBOL_TYPE (sym
),
1670 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1672 if (TYPE_FIELD_PACKED (t
, i
))
1673 error ("pointers to bitfield members not allowed");
1675 return value_from_longest
1676 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1678 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1682 /* C++: If it was not found as a data field, then try to
1683 return it as a pointer to a method. */
1685 /* Destructors are a special case. */
1686 if (destructor_name_p (name
, t
))
1688 error ("member pointers to destructors not implemented yet");
1691 /* Perform all necessary dereferencing. */
1692 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1693 intype
= TYPE_TARGET_TYPE (intype
);
1695 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1697 if (STREQ (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1699 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1700 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1702 if (intype
== 0 && j
> 1)
1703 error ("non-unique member `%s' requires type instantiation", name
);
1707 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1710 error ("no member function matches that type instantiation");
1715 if (TYPE_FN_FIELD_STUB (f
, j
))
1716 check_stub_method (t
, i
, j
);
1717 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1719 return value_from_longest
1720 (lookup_reference_type
1721 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1723 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1724 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1728 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1729 0, VAR_NAMESPACE
, 0, NULL
);
1736 v
= read_var_value (s
, 0);
1738 VALUE_TYPE (v
) = lookup_reference_type
1739 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1747 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1752 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1755 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1756 v
= value_struct_elt_for_reference (domain
,
1757 offset
+ base_offset
,
1758 TYPE_BASECLASS (t
, i
),
1767 /* C++: return the value of the class instance variable, if one exists.
1768 Flag COMPLAIN signals an error if the request is made in an
1769 inappropriate context. */
1771 value_of_this (complain
)
1774 extern FRAME selected_frame
;
1775 struct symbol
*func
, *sym
;
1778 static const char funny_this
[] = "this";
1781 if (selected_frame
== 0)
1783 error ("no frame selected");
1786 func
= get_frame_function (selected_frame
);
1790 error ("no `this' in nameless context");
1794 b
= SYMBOL_BLOCK_VALUE (func
);
1795 i
= BLOCK_NSYMS (b
);
1798 error ("no args, no `this'");
1801 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1802 symbol instead of the LOC_ARG one (if both exist). */
1803 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1807 error ("current stack frame not in method");
1812 this = read_var_value (sym
, selected_frame
);
1813 if (this == 0 && complain
)
1814 error ("`this' argument at unknown address");