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. */
32 /* Local functions. */
35 typecmp
PARAMS ((int staticp
, struct type
*t1
[], value t2
[]));
38 find_function_addr
PARAMS ((value
, struct type
**));
41 value_push
PARAMS ((CORE_ADDR
, value
));
44 value_arg_push
PARAMS ((CORE_ADDR
, value
));
47 search_struct_field
PARAMS ((char *, value
, int, struct type
*, int));
50 search_struct_method
PARAMS ((char *, value
*, value
*, int, int *,
54 check_field_in
PARAMS ((struct type
*, const char *));
57 allocate_space_in_inferior
PARAMS ((int));
60 /* Allocate NBYTES of space in the inferior using the inferior's malloc
61 and return a value that is a pointer to the allocated space. */
64 allocate_space_in_inferior (len
)
68 register struct symbol
*sym
;
69 struct minimal_symbol
*msymbol
;
74 /* Find the address of malloc in the inferior. */
76 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
79 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
81 error ("\"malloc\" exists in this program but is not a function.");
83 val
= value_of_variable (sym
);
87 msymbol
= lookup_minimal_symbol ("malloc", (struct objfile
*) NULL
);
90 type
= lookup_pointer_type (builtin_type_char
);
91 type
= lookup_function_type (type
);
92 type
= lookup_pointer_type (type
);
93 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
94 val
= value_from_longest (type
, maddr
);
98 error ("evaluation of this expression requires the program to have a function \"malloc\".");
102 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
103 val
= call_function_by_hand (val
, 1, &blocklen
);
104 if (value_logical_not (val
))
106 error ("No memory available to program.");
108 return (value_as_long (val
));
111 /* Cast value ARG2 to type TYPE and return as a value.
112 More general than a C cast: accepts any two types of the same length,
113 and if ARG2 is an lvalue it can be cast into anything at all. */
114 /* In C++, casts may change pointer representations. */
117 value_cast (type
, arg2
)
121 register enum type_code code1
;
122 register enum type_code code2
;
125 /* Coerce arrays but not enums. Enums will work as-is
126 and coercing them would cause an infinite recursion. */
127 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
130 code1
= TYPE_CODE (type
);
131 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
132 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
133 || code2
== TYPE_CODE_ENUM
);
135 if (code1
== TYPE_CODE_FLT
&& scalar
)
136 return value_from_double (type
, value_as_double (arg2
));
137 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
)
138 && (scalar
|| code2
== TYPE_CODE_PTR
))
139 return value_from_longest (type
, value_as_long (arg2
));
140 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
142 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
144 /* Look in the type of the source to see if it contains the
145 type of the target as a superclass. If so, we'll need to
146 offset the pointer rather than just change its type. */
147 struct type
*t1
= TYPE_TARGET_TYPE (type
);
148 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
149 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
150 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
151 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
153 value v
= search_struct_field (type_name_no_tag (t1
),
154 value_ind (arg2
), 0, t2
, 1);
158 VALUE_TYPE (v
) = type
;
162 /* No superclass found, just fall through to change ptr type. */
164 VALUE_TYPE (arg2
) = type
;
167 else if (VALUE_LVAL (arg2
) == lval_memory
)
169 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
171 else if (code1
== TYPE_CODE_VOID
)
173 return value_zero (builtin_type_void
, not_lval
);
177 error ("Invalid cast.");
182 /* Create a value of type TYPE that is zero, and return it. */
185 value_zero (type
, lv
)
189 register value val
= allocate_value (type
);
191 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
192 VALUE_LVAL (val
) = lv
;
197 /* Return a value with type TYPE located at ADDR.
199 Call value_at only if the data needs to be fetched immediately;
200 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
201 value_at_lazy instead. value_at_lazy simply records the address of
202 the data and sets the lazy-evaluation-required flag. The lazy flag
203 is tested in the VALUE_CONTENTS macro, which is used if and when
204 the contents are actually required. */
207 value_at (type
, addr
)
211 register value val
= allocate_value (type
);
213 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
215 VALUE_LVAL (val
) = lval_memory
;
216 VALUE_ADDRESS (val
) = addr
;
221 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
224 value_at_lazy (type
, addr
)
228 register value val
= allocate_value (type
);
230 VALUE_LVAL (val
) = lval_memory
;
231 VALUE_ADDRESS (val
) = addr
;
232 VALUE_LAZY (val
) = 1;
237 /* Called only from the VALUE_CONTENTS macro, if the current data for
238 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
239 data from the user's process, and clears the lazy flag to indicate
240 that the data in the buffer is valid.
242 If the value is zero-length, we avoid calling read_memory, which would
243 abort. We mark the value as fetched anyway -- all 0 bytes of it.
245 This function returns a value because it is used in the VALUE_CONTENTS
246 macro as part of an expression, where a void would not work. The
250 value_fetch_lazy (val
)
253 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
255 if (TYPE_LENGTH (VALUE_TYPE (val
)))
256 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
257 TYPE_LENGTH (VALUE_TYPE (val
)));
258 VALUE_LAZY (val
) = 0;
263 /* Store the contents of FROMVAL into the location of TOVAL.
264 Return a new value with the location of TOVAL and contents of FROMVAL. */
267 value_assign (toval
, fromval
)
268 register value toval
, fromval
;
270 register struct type
*type
= VALUE_TYPE (toval
);
272 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
273 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
276 COERCE_ARRAY (fromval
);
279 if (VALUE_LVAL (toval
) != lval_internalvar
)
280 fromval
= value_cast (type
, fromval
);
282 /* If TOVAL is a special machine register requiring conversion
283 of program values to a special raw format,
284 convert FROMVAL's contents now, with result in `raw_buffer',
285 and set USE_BUFFER to the number of bytes to write. */
287 if (VALUE_REGNO (toval
) >= 0
288 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
290 int regno
= VALUE_REGNO (toval
);
291 if (VALUE_TYPE (fromval
) != REGISTER_VIRTUAL_TYPE (regno
))
292 fromval
= value_cast (REGISTER_VIRTUAL_TYPE (regno
), fromval
);
293 memcpy (virtual_buffer
, VALUE_CONTENTS (fromval
),
294 REGISTER_VIRTUAL_SIZE (regno
));
295 REGISTER_CONVERT_TO_RAW (regno
, virtual_buffer
, raw_buffer
);
296 use_buffer
= REGISTER_RAW_SIZE (regno
);
299 switch (VALUE_LVAL (toval
))
301 case lval_internalvar
:
302 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
305 case lval_internalvar_component
:
306 set_internalvar_component (VALUE_INTERNALVAR (toval
),
307 VALUE_OFFSET (toval
),
308 VALUE_BITPOS (toval
),
309 VALUE_BITSIZE (toval
),
314 if (VALUE_BITSIZE (toval
))
316 int v
; /* FIXME, this won't work for large bitfields */
317 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
318 (char *) &v
, sizeof v
);
319 modify_field ((char *) &v
, (int) value_as_long (fromval
),
320 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
321 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
322 (char *)&v
, sizeof v
);
325 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
326 raw_buffer
, use_buffer
);
328 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
329 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
333 if (VALUE_BITSIZE (toval
))
337 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
338 (char *) &v
, sizeof v
);
339 modify_field ((char *) &v
, (int) value_as_long (fromval
),
340 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
341 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
342 (char *) &v
, sizeof v
);
345 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
346 raw_buffer
, use_buffer
);
348 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
349 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
352 case lval_reg_frame_relative
:
354 /* value is stored in a series of registers in the frame
355 specified by the structure. Copy that value out, modify
356 it, and copy it back in. */
357 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
358 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
359 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
360 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
362 char *buffer
= (char *) alloca (amount_to_copy
);
366 /* Figure out which frame this is in currently. */
367 for (frame
= get_current_frame ();
368 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
369 frame
= get_prev_frame (frame
))
373 error ("Value being assigned to is no longer active.");
375 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
378 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
380 amount_copied
< amount_to_copy
;
381 amount_copied
+= reg_size
, regno
++)
383 get_saved_register (buffer
+ amount_copied
,
384 (int *)NULL
, (CORE_ADDR
*)NULL
,
385 frame
, regno
, (enum lval_type
*)NULL
);
388 /* Modify what needs to be modified. */
389 if (VALUE_BITSIZE (toval
))
390 modify_field (buffer
+ byte_offset
,
391 (int) value_as_long (fromval
),
392 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
394 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
396 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
400 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
402 amount_copied
< amount_to_copy
;
403 amount_copied
+= reg_size
, regno
++)
409 /* Just find out where to put it. */
410 get_saved_register ((char *)NULL
,
411 &optim
, &addr
, frame
, regno
, &lval
);
414 error ("Attempt to assign to a value that was optimized out.");
415 if (lval
== lval_memory
)
416 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
417 else if (lval
== lval_register
)
418 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
420 error ("Attempt to assign to an unmodifiable value.");
427 error ("Left side of = operation is not an lvalue.");
430 /* Return a value just like TOVAL except with the contents of FROMVAL
431 (except in the case of the type if TOVAL is an internalvar). */
433 if (VALUE_LVAL (toval
) == lval_internalvar
434 || VALUE_LVAL (toval
) == lval_internalvar_component
)
436 type
= VALUE_TYPE (fromval
);
439 val
= allocate_value (type
);
440 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
441 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
443 VALUE_TYPE (val
) = type
;
448 /* Extend a value VAL to COUNT repetitions of its type. */
451 value_repeat (arg1
, count
)
457 if (VALUE_LVAL (arg1
) != lval_memory
)
458 error ("Only values in memory can be extended with '@'.");
460 error ("Invalid number %d of repetitions.", count
);
462 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
464 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
465 VALUE_CONTENTS_RAW (val
),
466 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
467 VALUE_LVAL (val
) = lval_memory
;
468 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
474 value_of_variable (var
)
479 val
= read_var_value (var
, (FRAME
) 0);
481 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
485 /* Given a value which is an array, return a value which is a pointer to its
486 first element, regardless of whether or not the array has a nonzero lower
489 FIXME: A previous comment here indicated that this routine should be
490 substracting the array's lower bound. It's not clear to me that this
491 is correct. Given an array subscripting operation, it would certainly
492 work to do the adjustment here, essentially computing:
494 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
496 However I believe a more appropriate and logical place to account for
497 the lower bound is to do so in value_subscript, essentially computing:
499 (&array[0] + ((index - lowerbound) * sizeof array[0]))
501 As further evidence consider what would happen with operations other
502 than array subscripting, where the caller would get back a value that
503 had an address somewhere before the actual first element of the array,
504 and the information about the lower bound would be lost because of
505 the coercion to pointer type.
509 value_coerce_array (arg1
)
512 register struct type
*type
;
514 if (VALUE_LVAL (arg1
) != lval_memory
)
515 error ("Attempt to take address of value not located in memory.");
517 /* Get type of elements. */
518 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
519 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
521 /* A phony array made by value_repeat.
522 Its type is the type of the elements, not an array type. */
523 type
= VALUE_TYPE (arg1
);
525 return value_from_longest (lookup_pointer_type (type
),
526 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
529 /* Given a value which is a function, return a value which is a pointer
533 value_coerce_function (arg1
)
537 if (VALUE_LVAL (arg1
) != lval_memory
)
538 error ("Attempt to take address of value not located in memory.");
540 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
541 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
544 /* Return a pointer value for the object for which ARG1 is the contents. */
550 struct type
*type
= VALUE_TYPE (arg1
);
551 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
553 /* Copy the value, but change the type from (T&) to (T*).
554 We keep the same location information, which is efficient,
555 and allows &(&X) to get the location containing the reference. */
556 value arg2
= value_copy (arg1
);
557 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
560 if (VALUE_REPEATED (arg1
)
561 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
562 return value_coerce_array (arg1
);
563 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
564 return value_coerce_function (arg1
);
566 if (VALUE_LVAL (arg1
) != lval_memory
)
567 error ("Attempt to take address of value not located in memory.");
569 return value_from_longest (lookup_pointer_type (type
),
570 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
573 /* Given a value of a pointer type, apply the C unary * operator to it. */
581 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
582 error ("not implemented: member types in value_ind");
584 /* Allow * on an integer so we can cast it to whatever we want.
585 This returns an int, which seems like the most C-like thing
586 to do. "long long" variables are rare enough that
587 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
588 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
589 return value_at (builtin_type_int
,
590 (CORE_ADDR
) value_as_long (arg1
));
591 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
592 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
593 value_as_pointer (arg1
));
594 error ("Attempt to take contents of a non-pointer value.");
595 return 0; /* For lint -- never reached */
598 /* Pushing small parts of stack frames. */
600 /* Push one word (the size of object that a register holds). */
603 push_word (sp
, buffer
)
605 REGISTER_TYPE buffer
;
607 register int len
= sizeof (REGISTER_TYPE
);
609 SWAP_TARGET_AND_HOST (&buffer
, len
);
612 write_memory (sp
, (char *)&buffer
, len
);
613 #else /* stack grows upward */
614 write_memory (sp
, (char *)&buffer
, len
);
616 #endif /* stack grows upward */
621 /* Push LEN bytes with data at BUFFER. */
624 push_bytes (sp
, buffer
, len
)
631 write_memory (sp
, buffer
, len
);
632 #else /* stack grows upward */
633 write_memory (sp
, buffer
, len
);
635 #endif /* stack grows upward */
640 /* Push onto the stack the specified value VALUE. */
644 register CORE_ADDR sp
;
647 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
651 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
652 #else /* stack grows upward */
653 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
655 #endif /* stack grows upward */
660 /* Perform the standard coercions that are specified
661 for arguments to be passed to C functions. */
664 value_arg_coerce (arg
)
667 register struct type
*type
;
670 #if 1 /* FIXME: This is only a temporary patch. -fnf */
671 if (VALUE_REPEATED (arg
)
672 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
673 arg
= value_coerce_array (arg
);
674 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_FUNC
)
675 arg
= value_coerce_function (arg
);
678 type
= VALUE_TYPE (arg
);
680 if (TYPE_CODE (type
) == TYPE_CODE_INT
681 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
682 return value_cast (builtin_type_int
, arg
);
684 if (TYPE_CODE (type
) == TYPE_CODE_FLT
685 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
686 return value_cast (builtin_type_double
, arg
);
691 /* Push the value ARG, first coercing it as an argument
695 value_arg_push (sp
, arg
)
696 register CORE_ADDR sp
;
699 return value_push (sp
, value_arg_coerce (arg
));
702 /* Determine a function's address and its return type from its value.
703 Calls error() if the function is not valid for calling. */
706 find_function_addr (function
, retval_type
)
708 struct type
**retval_type
;
710 register struct type
*ftype
= VALUE_TYPE (function
);
711 register enum type_code code
= TYPE_CODE (ftype
);
712 struct type
*value_type
;
715 /* If it's a member function, just look at the function
718 /* Determine address to call. */
719 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
721 funaddr
= VALUE_ADDRESS (function
);
722 value_type
= TYPE_TARGET_TYPE (ftype
);
724 else if (code
== TYPE_CODE_PTR
)
726 funaddr
= value_as_pointer (function
);
727 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
728 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
729 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
731 value_type
= builtin_type_int
;
733 else if (code
== TYPE_CODE_INT
)
735 /* Handle the case of functions lacking debugging info.
736 Their values are characters since their addresses are char */
737 if (TYPE_LENGTH (ftype
) == 1)
738 funaddr
= value_as_pointer (value_addr (function
));
740 /* Handle integer used as address of a function. */
741 funaddr
= (CORE_ADDR
) value_as_long (function
);
743 value_type
= builtin_type_int
;
746 error ("Invalid data type for function to be called.");
748 *retval_type
= value_type
;
752 #if defined (CALL_DUMMY)
753 /* All this stuff with a dummy frame may seem unnecessarily complicated
754 (why not just save registers in GDB?). The purpose of pushing a dummy
755 frame which looks just like a real frame is so that if you call a
756 function and then hit a breakpoint (get a signal, etc), "backtrace"
757 will look right. Whether the backtrace needs to actually show the
758 stack at the time the inferior function was called is debatable, but
759 it certainly needs to not display garbage. So if you are contemplating
760 making dummy frames be different from normal frames, consider that. */
762 /* Perform a function call in the inferior.
763 ARGS is a vector of values of arguments (NARGS of them).
764 FUNCTION is a value, the function to be called.
765 Returns a value representing what the function returned.
766 May fail to return, if a breakpoint or signal is hit
767 during the execution of the function. */
770 call_function_by_hand (function
, nargs
, args
)
775 register CORE_ADDR sp
;
778 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
779 is in host byte order. It is switched to target byte order before calling
781 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
782 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
784 struct type
*value_type
;
785 unsigned char struct_return
;
786 CORE_ADDR struct_addr
;
787 struct inferior_status inf_status
;
788 struct cleanup
*old_chain
;
793 if (!target_has_execution
)
796 save_inferior_status (&inf_status
, 1);
797 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
799 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
800 (and POP_FRAME for restoring them). (At least on most machines)
801 they are saved on the stack in the inferior. */
804 old_sp
= sp
= read_register (SP_REGNUM
);
806 #if 1 INNER_THAN 2 /* Stack grows down */
809 #else /* Stack grows up */
814 funaddr
= find_function_addr (function
, &value_type
);
817 struct block
*b
= block_for_pc (funaddr
);
818 /* If compiled without -g, assume GCC. */
819 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
822 /* Are we returning a value using a structure return or a normal
825 struct_return
= using_struct_return (function
, funaddr
, value_type
,
828 /* Create a call sequence customized for this function
829 and the number of arguments for it. */
830 memcpy (dummy1
, dummy
, sizeof dummy
);
831 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
832 SWAP_TARGET_AND_HOST (&dummy1
[i
], sizeof (REGISTER_TYPE
));
834 #ifdef GDB_TARGET_IS_HPPA
835 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
836 value_type
, using_gcc
);
838 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
839 value_type
, using_gcc
);
843 #if CALL_DUMMY_LOCATION == ON_STACK
844 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
846 #else /* Not on stack. */
847 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
848 /* Convex Unix prohibits executing in the stack segment. */
849 /* Hope there is empty room at the top of the text segment. */
851 extern CORE_ADDR text_end
;
854 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
855 if (read_memory_integer (start_sp
, 1) != 0)
856 error ("text segment full -- no place to put call");
859 start_sp
= text_end
- sizeof dummy
;
860 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
862 #else /* After text_end. */
864 extern CORE_ADDR text_end
;
868 errcode
= target_write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
870 error ("Cannot write text segment -- call_function failed");
872 #endif /* After text_end. */
873 #endif /* Not on stack. */
876 sp
= old_sp
; /* It really is used, for some ifdef's... */
880 /* If stack grows down, we must leave a hole at the top. */
884 /* Reserve space for the return structure to be written on the
885 stack, if necessary */
888 len
+= TYPE_LENGTH (value_type
);
890 for (i
= nargs
- 1; i
>= 0; i
--)
891 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
892 #ifdef CALL_DUMMY_STACK_ADJUST
893 len
+= CALL_DUMMY_STACK_ADJUST
;
896 sp
-= STACK_ALIGN (len
) - len
;
898 sp
+= STACK_ALIGN (len
) - len
;
901 #endif /* STACK_ALIGN */
903 /* Reserve space for the return structure to be written on the
904 stack, if necessary */
909 sp
-= TYPE_LENGTH (value_type
);
913 sp
+= TYPE_LENGTH (value_type
);
917 #if defined (REG_STRUCT_HAS_ADDR)
919 /* This is a machine like the sparc, where we need to pass a pointer
920 to the structure, not the structure itself. */
921 if (REG_STRUCT_HAS_ADDR (using_gcc
))
922 for (i
= nargs
- 1; i
>= 0; i
--)
923 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
926 #if !(1 INNER_THAN 2)
927 /* The stack grows up, so the address of the thing we push
928 is the stack pointer before we push it. */
931 /* Push the structure. */
932 sp
= value_push (sp
, args
[i
]);
934 /* The stack grows down, so the address of the thing we push
935 is the stack pointer after we push it. */
938 /* The value we're going to pass is the address of the thing
940 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
944 #endif /* REG_STRUCT_HAS_ADDR. */
946 #ifdef PUSH_ARGUMENTS
947 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
948 #else /* !PUSH_ARGUMENTS */
949 for (i
= nargs
- 1; i
>= 0; i
--)
950 sp
= value_arg_push (sp
, args
[i
]);
951 #endif /* !PUSH_ARGUMENTS */
953 #ifdef CALL_DUMMY_STACK_ADJUST
955 sp
-= CALL_DUMMY_STACK_ADJUST
;
957 sp
+= CALL_DUMMY_STACK_ADJUST
;
959 #endif /* CALL_DUMMY_STACK_ADJUST */
961 /* Store the address at which the structure is supposed to be
962 written. Note that this (and the code which reserved the space
963 above) assumes that gcc was used to compile this function. Since
964 it doesn't cost us anything but space and if the function is pcc
965 it will ignore this value, we will make that assumption.
967 Also note that on some machines (like the sparc) pcc uses a
968 convention like gcc's. */
971 STORE_STRUCT_RETURN (struct_addr
, sp
);
973 /* Write the stack pointer. This is here because the statements above
974 might fool with it. On SPARC, this write also stores the register
975 window into the right place in the new stack frame, which otherwise
976 wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */
977 write_register (SP_REGNUM
, sp
);
979 /* Figure out the value returned by the function. */
981 char retbuf
[REGISTER_BYTES
];
983 /* Execute the stack dummy routine, calling FUNCTION.
984 When it is done, discard the empty frame
985 after storing the contents of all regs into retbuf. */
986 run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
);
988 do_cleanups (old_chain
);
990 return value_being_returned (value_type
, retbuf
, struct_return
);
993 #else /* no CALL_DUMMY. */
995 call_function_by_hand (function
, nargs
, args
)
1000 error ("Cannot invoke functions on this machine.");
1002 #endif /* no CALL_DUMMY. */
1005 /* Create a value for an array by allocating space in the inferior, copying
1006 the data into that space, and then setting up an array value.
1008 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1009 populated from the values passed in ELEMVEC.
1011 The element type of the array is inherited from the type of the
1012 first element, and all elements must have the same size (though we
1013 don't currently enforce any restriction on their types). */
1016 value_array (lowbound
, highbound
, elemvec
)
1025 struct type
*rangetype
;
1026 struct type
*arraytype
;
1029 /* Validate that the bounds are reasonable and that each of the elements
1030 have the same size. */
1032 nelem
= highbound
- lowbound
+ 1;
1035 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1037 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1038 for (idx
= 0; idx
< nelem
; idx
++)
1040 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1042 error ("array elements must all be the same size");
1046 /* Allocate space to store the array in the inferior, and then initialize
1047 it by copying in each element. FIXME: Is it worth it to create a
1048 local buffer in which to collect each value and then write all the
1049 bytes in one operation? */
1051 addr
= allocate_space_in_inferior (nelem
* typelength
);
1052 for (idx
= 0; idx
< nelem
; idx
++)
1054 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1058 /* Create the array type and set up an array value to be evaluated lazily. */
1060 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1061 lowbound
, highbound
);
1062 arraytype
= create_array_type ((struct type
*) NULL
,
1063 VALUE_TYPE (elemvec
[0]), rangetype
);
1064 val
= value_at_lazy (arraytype
, addr
);
1068 /* Create a value for a string constant by allocating space in the inferior,
1069 copying the data into that space, and returning the address with type
1070 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1072 Note that string types are like array of char types with a lower bound of
1073 zero and an upper bound of LEN - 1. Also note that the string may contain
1074 embedded null bytes. */
1077 value_string (ptr
, len
)
1082 struct type
*rangetype
;
1083 struct type
*stringtype
;
1086 /* Allocate space to store the string in the inferior, and then
1087 copy LEN bytes from PTR in gdb to that address in the inferior. */
1089 addr
= allocate_space_in_inferior (len
);
1090 write_memory (addr
, ptr
, len
);
1092 /* Create the string type and set up a string value to be evaluated
1095 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1097 stringtype
= create_string_type ((struct type
*) NULL
, rangetype
);
1098 val
= value_at_lazy (stringtype
, addr
);
1102 /* Compare two argument lists and return the position in which they differ,
1105 STATICP is nonzero if the T1 argument list came from a
1106 static member function.
1108 For non-static member functions, we ignore the first argument,
1109 which is the type of the instance variable. This is because we want
1110 to handle calls with objects from derived classes. This is not
1111 entirely correct: we should actually check to make sure that a
1112 requested operation is type secure, shouldn't we? FIXME. */
1115 typecmp (staticp
, t1
, t2
)
1124 if (staticp
&& t1
== 0)
1128 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1129 if (t1
[!staticp
] == 0) return 0;
1130 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1134 if (TYPE_CODE (t1
[i
]) == TYPE_CODE_REF
1135 && TYPE_TARGET_TYPE (t1
[i
]) == VALUE_TYPE (t2
[i
]))
1137 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1140 if (!t1
[i
]) return 0;
1141 return t2
[i
] ? i
+1 : 0;
1144 /* Helper function used by value_struct_elt to recurse through baseclasses.
1145 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1146 and search in it assuming it has (class) type TYPE.
1147 If found, return value, else return NULL.
1149 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1150 look for a baseclass named NAME. */
1153 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1155 register value arg1
;
1157 register struct type
*type
;
1158 int looking_for_baseclass
;
1162 check_stub_type (type
);
1164 if (! looking_for_baseclass
)
1165 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1167 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1169 if (t_field_name
&& STREQ (t_field_name
, name
))
1172 if (TYPE_FIELD_STATIC (type
, i
))
1174 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1175 struct symbol
*sym
=
1176 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1178 error ("Internal error: could not find physical static variable named %s",
1180 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1181 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1184 v
= value_primitive_field (arg1
, offset
, i
, type
);
1186 error("there is no field named %s", name
);
1191 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1194 /* If we are looking for baseclasses, this is what we get when we
1196 int found_baseclass
= (looking_for_baseclass
1197 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1199 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1202 /* Fix to use baseclass_offset instead. FIXME */
1203 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1206 error ("virtual baseclass botch");
1207 if (found_baseclass
)
1209 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1210 looking_for_baseclass
);
1212 else if (found_baseclass
)
1213 v
= value_primitive_field (arg1
, offset
, i
, type
);
1215 v
= search_struct_field (name
, arg1
,
1216 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1217 TYPE_BASECLASS (type
, i
),
1218 looking_for_baseclass
);
1224 /* Helper function used by value_struct_elt to recurse through baseclasses.
1225 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1226 and search in it assuming it has (class) type TYPE.
1227 If found, return value, else return NULL. */
1230 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1232 register value
*arg1p
, *args
;
1233 int offset
, *static_memfuncp
;
1234 register struct type
*type
;
1238 check_stub_type (type
);
1239 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1241 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1242 if (t_field_name
&& STREQ (t_field_name
, name
))
1244 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1245 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1247 if (j
> 0 && args
== 0)
1248 error ("cannot resolve overloaded method `%s'", name
);
1251 if (TYPE_FN_FIELD_STUB (f
, j
))
1252 check_stub_method (type
, i
, j
);
1253 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1254 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1256 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1257 return (value
)value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1258 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1259 *static_memfuncp
= 1;
1260 return (value
)value_fn_field (arg1p
, f
, j
, type
, offset
);
1267 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1272 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1274 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1275 if (base_offset
== -1)
1276 error ("virtual baseclass botch");
1280 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1282 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1283 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1286 /* FIXME-bothner: Why is this commented out? Why is it here? */
1287 /* *arg1p = arg1_tmp;*/
1294 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1295 extract the component named NAME from the ultimate target structure/union
1296 and return it as a value with its appropriate type.
1297 ERR is used in the error message if *ARGP's type is wrong.
1299 C++: ARGS is a list of argument types to aid in the selection of
1300 an appropriate method. Also, handle derived types.
1302 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1303 where the truthvalue of whether the function that was resolved was
1304 a static member function or not is stored.
1306 ERR is an error message to be printed in case the field is not found. */
1309 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1310 register value
*argp
, *args
;
1312 int *static_memfuncp
;
1315 register struct type
*t
;
1318 COERCE_ARRAY (*argp
);
1320 t
= VALUE_TYPE (*argp
);
1322 /* Follow pointers until we get to a non-pointer. */
1324 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1326 *argp
= value_ind (*argp
);
1327 /* Don't coerce fn pointer to fn and then back again! */
1328 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1329 COERCE_ARRAY (*argp
);
1330 t
= VALUE_TYPE (*argp
);
1333 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1334 error ("not implemented: member type in value_struct_elt");
1336 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1337 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1338 error ("Attempt to extract a component of a value that is not a %s.", err
);
1340 /* Assume it's not, unless we see that it is. */
1341 if (static_memfuncp
)
1342 *static_memfuncp
=0;
1346 /* if there are no arguments ...do this... */
1348 /* Try as a field first, because if we succeed, there
1349 is less work to be done. */
1350 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1354 /* C++: If it was not found as a data field, then try to
1355 return it as a pointer to a method. */
1357 if (destructor_name_p (name
, t
))
1358 error ("Cannot get value of destructor");
1360 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1364 if (TYPE_NFN_FIELDS (t
))
1365 error ("There is no member or method named %s.", name
);
1367 error ("There is no member named %s.", name
);
1372 if (destructor_name_p (name
, t
))
1376 /* destructors are a special case. */
1377 return (value
)value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1378 TYPE_FN_FIELDLIST_LENGTH (t
, 0),
1383 error ("destructor should not have any argument");
1387 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1391 /* See if user tried to invoke data as function. If so,
1392 hand it back. If it's not callable (i.e., a pointer to function),
1393 gdb should give an error. */
1394 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1398 error ("Structure has no component named %s.", name
);
1402 /* C++: return 1 is NAME is a legitimate name for the destructor
1403 of type TYPE. If TYPE does not have a destructor, or
1404 if NAME is inappropriate for TYPE, an error is signaled. */
1406 destructor_name_p (name
, type
)
1408 const struct type
*type
;
1410 /* destructors are a special case. */
1414 char *dname
= type_name_no_tag (type
);
1415 if (!STREQ (dname
, name
+1))
1416 error ("name of destructor must equal name of class");
1423 /* Helper function for check_field: Given TYPE, a structure/union,
1424 return 1 if the component named NAME from the ultimate
1425 target structure/union is defined, otherwise, return 0. */
1428 check_field_in (type
, name
)
1429 register struct type
*type
;
1434 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1436 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1437 if (t_field_name
&& STREQ (t_field_name
, name
))
1441 /* C++: If it was not found as a data field, then try to
1442 return it as a pointer to a method. */
1444 /* Destructors are a special case. */
1445 if (destructor_name_p (name
, type
))
1448 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1450 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1454 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1455 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1462 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1463 return 1 if the component named NAME from the ultimate
1464 target structure/union is defined, otherwise, return 0. */
1467 check_field (arg1
, name
)
1468 register value arg1
;
1471 register struct type
*t
;
1473 COERCE_ARRAY (arg1
);
1475 t
= VALUE_TYPE (arg1
);
1477 /* Follow pointers until we get to a non-pointer. */
1479 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1480 t
= TYPE_TARGET_TYPE (t
);
1482 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1483 error ("not implemented: member type in check_field");
1485 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1486 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1487 error ("Internal error: `this' is not an aggregate");
1489 return check_field_in (t
, name
);
1492 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1493 return the address of this member as a "pointer to member"
1494 type. If INTYPE is non-null, then it will be the type
1495 of the member we are looking for. This will help us resolve
1496 "pointers to member functions". This function is used
1497 to resolve user expressions of the form "DOMAIN::NAME". */
1500 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1501 struct type
*domain
, *curtype
, *intype
;
1505 register struct type
*t
= curtype
;
1509 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1510 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1511 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1513 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1515 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1517 if (t_field_name
&& STREQ (t_field_name
, name
))
1519 if (TYPE_FIELD_STATIC (t
, i
))
1521 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1522 struct symbol
*sym
=
1523 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1525 error ("Internal error: could not find physical static variable named %s",
1527 return value_at (SYMBOL_TYPE (sym
),
1528 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1530 if (TYPE_FIELD_PACKED (t
, i
))
1531 error ("pointers to bitfield members not allowed");
1533 return value_from_longest
1534 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1536 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1540 /* C++: If it was not found as a data field, then try to
1541 return it as a pointer to a method. */
1543 /* Destructors are a special case. */
1544 if (destructor_name_p (name
, t
))
1546 error ("member pointers to destructors not implemented yet");
1549 /* Perform all necessary dereferencing. */
1550 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1551 intype
= TYPE_TARGET_TYPE (intype
);
1553 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1555 if (STREQ (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1557 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1558 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1560 if (intype
== 0 && j
> 1)
1561 error ("non-unique member `%s' requires type instantiation", name
);
1565 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1568 error ("no member function matches that type instantiation");
1573 if (TYPE_FN_FIELD_STUB (f
, j
))
1574 check_stub_method (t
, i
, j
);
1575 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1577 return value_from_longest
1578 (lookup_reference_type
1579 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1581 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1582 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1586 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1587 0, VAR_NAMESPACE
, 0, NULL
);
1594 v
= read_var_value (s
, 0);
1596 VALUE_TYPE (v
) = lookup_reference_type
1597 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1605 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1610 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1613 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1614 v
= value_struct_elt_for_reference (domain
,
1615 offset
+ base_offset
,
1616 TYPE_BASECLASS (t
, i
),
1625 /* C++: return the value of the class instance variable, if one exists.
1626 Flag COMPLAIN signals an error if the request is made in an
1627 inappropriate context. */
1629 value_of_this (complain
)
1632 extern FRAME selected_frame
;
1633 struct symbol
*func
, *sym
;
1636 static const char funny_this
[] = "this";
1639 if (selected_frame
== 0)
1641 error ("no frame selected");
1644 func
= get_frame_function (selected_frame
);
1648 error ("no `this' in nameless context");
1652 b
= SYMBOL_BLOCK_VALUE (func
);
1653 i
= BLOCK_NSYMS (b
);
1656 error ("no args, no `this'");
1659 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1660 symbol instead of the LOC_ARG one (if both exist). */
1661 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1665 error ("current stack frame not in method");
1670 this = read_var_value (sym
, selected_frame
);
1671 if (this == 0 && complain
)
1672 error ("`this' argument at unknown address");