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. */
31 /* Local functions. */
34 find_function_addr
PARAMS ((value
, struct type
**));
37 value_push
PARAMS ((CORE_ADDR
, value
));
40 value_arg_push
PARAMS ((CORE_ADDR
, value
));
43 search_struct_field
PARAMS ((char *, value
, int, struct type
*, int));
46 search_struct_method
PARAMS ((char *, value
, value
*, int, int *,
50 check_field_in
PARAMS ((struct type
*, const char *));
53 /* Cast value ARG2 to type TYPE and return as a value.
54 More general than a C cast: accepts any two types of the same length,
55 and if ARG2 is an lvalue it can be cast into anything at all. */
56 /* In C++, casts may change pointer representations. */
59 value_cast (type
, arg2
)
63 register enum type_code code1
;
64 register enum type_code code2
;
67 /* Coerce arrays but not enums. Enums will work as-is
68 and coercing them would cause an infinite recursion. */
69 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
72 code1
= TYPE_CODE (type
);
73 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
74 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
75 || code2
== TYPE_CODE_ENUM
);
77 if (code1
== TYPE_CODE_FLT
&& scalar
)
78 return value_from_double (type
, value_as_double (arg2
));
79 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
)
80 && (scalar
|| code2
== TYPE_CODE_PTR
))
81 return value_from_longest (type
, value_as_long (arg2
));
82 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
84 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
86 /* Look in the type of the source to see if it contains the
87 type of the target as a superclass. If so, we'll need to
88 offset the pointer rather than just change its type. */
89 struct type
*t1
= TYPE_TARGET_TYPE (type
);
90 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
91 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
92 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
93 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
95 value v
= search_struct_field (type_name_no_tag (t1
),
96 value_ind (arg2
), 0, t2
, 1);
100 VALUE_TYPE (v
) = type
;
104 /* No superclass found, just fall through to change ptr type. */
106 VALUE_TYPE (arg2
) = type
;
109 else if (VALUE_LVAL (arg2
) == lval_memory
)
111 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
113 else if (code1
== TYPE_CODE_VOID
)
115 return value_zero (builtin_type_void
, not_lval
);
119 error ("Invalid cast.");
124 /* Create a value of type TYPE that is zero, and return it. */
127 value_zero (type
, lv
)
131 register value val
= allocate_value (type
);
133 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
134 VALUE_LVAL (val
) = lv
;
139 /* Return a value with type TYPE located at ADDR.
141 Call value_at only if the data needs to be fetched immediately;
142 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
143 value_at_lazy instead. value_at_lazy simply records the address of
144 the data and sets the lazy-evaluation-required flag. The lazy flag
145 is tested in the VALUE_CONTENTS macro, which is used if and when
146 the contents are actually required. */
149 value_at (type
, addr
)
153 register value val
= allocate_value (type
);
155 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
157 VALUE_LVAL (val
) = lval_memory
;
158 VALUE_ADDRESS (val
) = addr
;
163 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
166 value_at_lazy (type
, addr
)
170 register value val
= allocate_value (type
);
172 VALUE_LVAL (val
) = lval_memory
;
173 VALUE_ADDRESS (val
) = addr
;
174 VALUE_LAZY (val
) = 1;
179 /* Called only from the VALUE_CONTENTS macro, if the current data for
180 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
181 data from the user's process, and clears the lazy flag to indicate
182 that the data in the buffer is valid.
184 If the value is zero-length, we avoid calling read_memory, which would
185 abort. We mark the value as fetched anyway -- all 0 bytes of it.
187 This function returns a value because it is used in the VALUE_CONTENTS
188 macro as part of an expression, where a void would not work. The
192 value_fetch_lazy (val
)
195 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
197 if (TYPE_LENGTH (VALUE_TYPE (val
)))
198 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
199 TYPE_LENGTH (VALUE_TYPE (val
)));
200 VALUE_LAZY (val
) = 0;
205 /* Store the contents of FROMVAL into the location of TOVAL.
206 Return a new value with the location of TOVAL and contents of FROMVAL. */
209 value_assign (toval
, fromval
)
210 register value toval
, fromval
;
212 register struct type
*type
= VALUE_TYPE (toval
);
214 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
215 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
218 COERCE_ARRAY (fromval
);
221 if (VALUE_LVAL (toval
) != lval_internalvar
)
222 fromval
= value_cast (type
, fromval
);
224 /* If TOVAL is a special machine register requiring conversion
225 of program values to a special raw format,
226 convert FROMVAL's contents now, with result in `raw_buffer',
227 and set USE_BUFFER to the number of bytes to write. */
229 if (VALUE_REGNO (toval
) >= 0
230 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
232 int regno
= VALUE_REGNO (toval
);
233 if (VALUE_TYPE (fromval
) != REGISTER_VIRTUAL_TYPE (regno
))
234 fromval
= value_cast (REGISTER_VIRTUAL_TYPE (regno
), fromval
);
235 memcpy (virtual_buffer
, VALUE_CONTENTS (fromval
),
236 REGISTER_VIRTUAL_SIZE (regno
));
237 target_convert_from_virtual (regno
, virtual_buffer
, raw_buffer
);
238 use_buffer
= REGISTER_RAW_SIZE (regno
);
241 switch (VALUE_LVAL (toval
))
243 case lval_internalvar
:
244 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
247 case lval_internalvar_component
:
248 set_internalvar_component (VALUE_INTERNALVAR (toval
),
249 VALUE_OFFSET (toval
),
250 VALUE_BITPOS (toval
),
251 VALUE_BITSIZE (toval
),
256 if (VALUE_BITSIZE (toval
))
258 int v
; /* FIXME, this won't work for large bitfields */
259 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
260 (char *) &v
, sizeof v
);
261 modify_field ((char *) &v
, (int) value_as_long (fromval
),
262 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
263 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
264 (char *)&v
, sizeof v
);
267 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
268 raw_buffer
, use_buffer
);
270 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
271 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
275 if (VALUE_BITSIZE (toval
))
279 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
280 (char *) &v
, sizeof v
);
281 modify_field ((char *) &v
, (int) value_as_long (fromval
),
282 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
283 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
284 (char *) &v
, sizeof v
);
287 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
288 raw_buffer
, use_buffer
);
290 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
291 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
294 case lval_reg_frame_relative
:
296 /* value is stored in a series of registers in the frame
297 specified by the structure. Copy that value out, modify
298 it, and copy it back in. */
299 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
300 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
301 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
302 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
304 char *buffer
= (char *) alloca (amount_to_copy
);
308 /* Figure out which frame this is in currently. */
309 for (frame
= get_current_frame ();
310 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
311 frame
= get_prev_frame (frame
))
315 error ("Value being assigned to is no longer active.");
317 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
320 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
322 amount_copied
< amount_to_copy
;
323 amount_copied
+= reg_size
, regno
++)
325 get_saved_register (buffer
+ amount_copied
,
326 (int *)NULL
, (CORE_ADDR
)NULL
,
327 frame
, regno
, (enum lval_type
*)NULL
);
330 /* Modify what needs to be modified. */
331 if (VALUE_BITSIZE (toval
))
332 modify_field (buffer
+ byte_offset
,
333 (int) value_as_long (fromval
),
334 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
336 bcopy (raw_buffer
, buffer
+ byte_offset
, use_buffer
);
338 bcopy (VALUE_CONTENTS (fromval
), buffer
+ byte_offset
,
342 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
344 amount_copied
< amount_to_copy
;
345 amount_copied
+= reg_size
, regno
++)
351 /* Just find out where to put it. */
352 get_saved_register ((char *)NULL
,
353 &optim
, &addr
, frame
, regno
, &lval
);
356 error ("Attempt to assign to a value that was optimized out.");
357 if (lval
== lval_memory
)
358 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
359 else if (lval
== lval_register
)
360 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
362 error ("Attempt to assign to an unmodifiable value.");
369 error ("Left side of = operation is not an lvalue.");
372 /* Return a value just like TOVAL except with the contents of FROMVAL
373 (except in the case of the type if TOVAL is an internalvar). */
375 if (VALUE_LVAL (toval
) == lval_internalvar
376 || VALUE_LVAL (toval
) == lval_internalvar_component
)
378 type
= VALUE_TYPE (fromval
);
381 val
= allocate_value (type
);
382 bcopy (toval
, val
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
383 bcopy (VALUE_CONTENTS (fromval
), VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
384 VALUE_TYPE (val
) = type
;
389 /* Extend a value VAL to COUNT repetitions of its type. */
392 value_repeat (arg1
, count
)
398 if (VALUE_LVAL (arg1
) != lval_memory
)
399 error ("Only values in memory can be extended with '@'.");
401 error ("Invalid number %d of repetitions.", count
);
403 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
405 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
406 VALUE_CONTENTS_RAW (val
),
407 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
408 VALUE_LVAL (val
) = lval_memory
;
409 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
415 value_of_variable (var
)
420 val
= read_var_value (var
, (FRAME
) 0);
422 error ("Address of symbol \"%s\" is unknown.", SYMBOL_NAME (var
));
426 /* Given a value which is an array, return a value which is
427 a pointer to its first (actually, zeroth) element.
428 FIXME, this should be subtracting the array's lower bound. */
431 value_coerce_array (arg1
)
434 register struct type
*type
;
436 if (VALUE_LVAL (arg1
) != lval_memory
)
437 error ("Attempt to take address of value not located in memory.");
439 /* Get type of elements. */
440 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
441 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
443 /* A phony array made by value_repeat.
444 Its type is the type of the elements, not an array type. */
445 type
= VALUE_TYPE (arg1
);
447 return value_from_longest (lookup_pointer_type (type
),
448 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
451 /* Given a value which is a function, return a value which is a pointer
455 value_coerce_function (arg1
)
459 if (VALUE_LVAL (arg1
) != lval_memory
)
460 error ("Attempt to take address of value not located in memory.");
462 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
463 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
466 /* Return a pointer value for the object for which ARG1 is the contents. */
472 struct type
*type
= VALUE_TYPE (arg1
);
473 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
475 /* Copy the value, but change the type from (T&) to (T*).
476 We keep the same location information, which is efficient,
477 and allows &(&X) to get the location containing the reference. */
478 value arg2
= value_copy (arg1
);
479 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
482 if (VALUE_REPEATED (arg1
)
483 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
484 return value_coerce_array (arg1
);
485 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
486 return value_coerce_function (arg1
);
488 if (VALUE_LVAL (arg1
) != lval_memory
)
489 error ("Attempt to take address of value not located in memory.");
491 return value_from_longest (lookup_pointer_type (type
),
492 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
495 /* Given a value of a pointer type, apply the C unary * operator to it. */
503 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
504 error ("not implemented: member types in value_ind");
506 /* Allow * on an integer so we can cast it to whatever we want.
507 This returns an int, which seems like the most C-like thing
508 to do. "long long" variables are rare enough that
509 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
510 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
511 return value_at (builtin_type_int
,
512 (CORE_ADDR
) value_as_long (arg1
));
513 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
514 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
515 value_as_pointer (arg1
));
516 error ("Attempt to take contents of a non-pointer value.");
517 return 0; /* For lint -- never reached */
520 /* Pushing small parts of stack frames. */
522 /* Push one word (the size of object that a register holds). */
525 push_word (sp
, buffer
)
527 REGISTER_TYPE buffer
;
529 register int len
= sizeof (REGISTER_TYPE
);
531 SWAP_TARGET_AND_HOST (&buffer
, len
);
534 write_memory (sp
, (char *)&buffer
, len
);
535 #else /* stack grows upward */
536 write_memory (sp
, (char *)&buffer
, len
);
538 #endif /* stack grows upward */
543 /* Push LEN bytes with data at BUFFER. */
546 push_bytes (sp
, buffer
, len
)
553 write_memory (sp
, buffer
, len
);
554 #else /* stack grows upward */
555 write_memory (sp
, buffer
, len
);
557 #endif /* stack grows upward */
562 /* Push onto the stack the specified value VALUE. */
566 register CORE_ADDR sp
;
569 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
573 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
574 #else /* stack grows upward */
575 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
577 #endif /* stack grows upward */
582 /* Perform the standard coercions that are specified
583 for arguments to be passed to C functions. */
586 value_arg_coerce (arg
)
589 register struct type
*type
;
593 type
= VALUE_TYPE (arg
);
595 if (TYPE_CODE (type
) == TYPE_CODE_INT
596 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
597 return value_cast (builtin_type_int
, arg
);
599 if (TYPE_CODE (type
) == TYPE_CODE_FLT
600 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
601 return value_cast (builtin_type_double
, arg
);
606 /* Push the value ARG, first coercing it as an argument
610 value_arg_push (sp
, arg
)
611 register CORE_ADDR sp
;
614 return value_push (sp
, value_arg_coerce (arg
));
617 /* Determine a function's address and its return type from its value.
618 Calls error() if the function is not valid for calling. */
621 find_function_addr (function
, retval_type
)
623 struct type
**retval_type
;
625 register struct type
*ftype
= VALUE_TYPE (function
);
626 register enum type_code code
= TYPE_CODE (ftype
);
627 struct type
*value_type
;
630 /* If it's a member function, just look at the function
633 /* Determine address to call. */
634 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
636 funaddr
= VALUE_ADDRESS (function
);
637 value_type
= TYPE_TARGET_TYPE (ftype
);
639 else if (code
== TYPE_CODE_PTR
)
641 funaddr
= value_as_pointer (function
);
642 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
643 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
644 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
646 value_type
= builtin_type_int
;
648 else if (code
== TYPE_CODE_INT
)
650 /* Handle the case of functions lacking debugging info.
651 Their values are characters since their addresses are char */
652 if (TYPE_LENGTH (ftype
) == 1)
653 funaddr
= value_as_pointer (value_addr (function
));
655 /* Handle integer used as address of a function. */
656 funaddr
= (CORE_ADDR
) value_as_long (function
);
658 value_type
= builtin_type_int
;
661 error ("Invalid data type for function to be called.");
663 *retval_type
= value_type
;
667 #if defined (CALL_DUMMY)
668 /* All this stuff with a dummy frame may seem unnecessarily complicated
669 (why not just save registers in GDB?). The purpose of pushing a dummy
670 frame which looks just like a real frame is so that if you call a
671 function and then hit a breakpoint (get a signal, etc), "backtrace"
672 will look right. Whether the backtrace needs to actually show the
673 stack at the time the inferior function was called is debatable, but
674 it certainly needs to not display garbage. So if you are contemplating
675 making dummy frames be different from normal frames, consider that. */
677 /* Perform a function call in the inferior.
678 ARGS is a vector of values of arguments (NARGS of them).
679 FUNCTION is a value, the function to be called.
680 Returns a value representing what the function returned.
681 May fail to return, if a breakpoint or signal is hit
682 during the execution of the function. */
685 call_function_by_hand (function
, nargs
, args
)
690 register CORE_ADDR sp
;
693 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
694 is in host byte order. It is switched to target byte order before calling
696 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
697 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
699 struct type
*value_type
;
700 unsigned char struct_return
;
701 CORE_ADDR struct_addr
;
702 struct inferior_status inf_status
;
703 struct cleanup
*old_chain
;
707 if (!target_has_execution
)
710 save_inferior_status (&inf_status
, 1);
711 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
713 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
714 (and POP_FRAME for restoring them). (At least on most machines)
715 they are saved on the stack in the inferior. */
718 old_sp
= sp
= read_register (SP_REGNUM
);
720 #if 1 INNER_THAN 2 /* Stack grows down */
723 #else /* Stack grows up */
728 funaddr
= find_function_addr (function
, &value_type
);
731 struct block
*b
= block_for_pc (funaddr
);
732 /* If compiled without -g, assume GCC. */
733 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
736 /* Are we returning a value using a structure return or a normal
739 struct_return
= using_struct_return (function
, funaddr
, value_type
,
742 /* Create a call sequence customized for this function
743 and the number of arguments for it. */
744 bcopy (dummy
, dummy1
, sizeof dummy
);
745 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
746 SWAP_TARGET_AND_HOST (&dummy1
[i
], sizeof (REGISTER_TYPE
));
747 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
748 value_type
, using_gcc
);
750 #if CALL_DUMMY_LOCATION == ON_STACK
751 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
753 #else /* Not on stack. */
754 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
755 /* Convex Unix prohibits executing in the stack segment. */
756 /* Hope there is empty room at the top of the text segment. */
758 extern CORE_ADDR text_end
;
761 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
762 if (read_memory_integer (start_sp
, 1) != 0)
763 error ("text segment full -- no place to put call");
766 start_sp
= text_end
- sizeof dummy
;
767 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
769 #else /* After text_end. */
771 extern CORE_ADDR text_end
;
775 errcode
= target_write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
777 error ("Cannot write text segment -- call_function failed");
779 #endif /* After text_end. */
780 #endif /* Not on stack. */
783 sp
= old_sp
; /* It really is used, for some ifdef's... */
787 /* If stack grows down, we must leave a hole at the top. */
791 /* Reserve space for the return structure to be written on the
792 stack, if necessary */
795 len
+= TYPE_LENGTH (value_type
);
797 for (i
= nargs
- 1; i
>= 0; i
--)
798 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
799 #ifdef CALL_DUMMY_STACK_ADJUST
800 len
+= CALL_DUMMY_STACK_ADJUST
;
803 sp
-= STACK_ALIGN (len
) - len
;
805 sp
+= STACK_ALIGN (len
) - len
;
808 #endif /* STACK_ALIGN */
810 /* Reserve space for the return structure to be written on the
811 stack, if necessary */
816 sp
-= TYPE_LENGTH (value_type
);
820 sp
+= TYPE_LENGTH (value_type
);
824 #if defined (REG_STRUCT_HAS_ADDR)
826 /* This is a machine like the sparc, where we need to pass a pointer
827 to the structure, not the structure itself. */
828 if (REG_STRUCT_HAS_ADDR (using_gcc
))
829 for (i
= nargs
- 1; i
>= 0; i
--)
830 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
833 #if !(1 INNER_THAN 2)
834 /* The stack grows up, so the address of the thing we push
835 is the stack pointer before we push it. */
838 /* Push the structure. */
839 sp
= value_push (sp
, args
[i
]);
841 /* The stack grows down, so the address of the thing we push
842 is the stack pointer after we push it. */
845 /* The value we're going to pass is the address of the thing
847 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
851 #endif /* REG_STRUCT_HAS_ADDR. */
853 #ifdef PUSH_ARGUMENTS
854 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
855 #else /* !PUSH_ARGUMENTS */
856 for (i
= nargs
- 1; i
>= 0; i
--)
857 sp
= value_arg_push (sp
, args
[i
]);
858 #endif /* !PUSH_ARGUMENTS */
860 #ifdef CALL_DUMMY_STACK_ADJUST
862 sp
-= CALL_DUMMY_STACK_ADJUST
;
864 sp
+= CALL_DUMMY_STACK_ADJUST
;
866 #endif /* CALL_DUMMY_STACK_ADJUST */
868 /* Store the address at which the structure is supposed to be
869 written. Note that this (and the code which reserved the space
870 above) assumes that gcc was used to compile this function. Since
871 it doesn't cost us anything but space and if the function is pcc
872 it will ignore this value, we will make that assumption.
874 Also note that on some machines (like the sparc) pcc uses a
875 convention like gcc's. */
878 STORE_STRUCT_RETURN (struct_addr
, sp
);
880 /* Write the stack pointer. This is here because the statements above
881 might fool with it. On SPARC, this write also stores the register
882 window into the right place in the new stack frame, which otherwise
883 wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */
884 write_register (SP_REGNUM
, sp
);
886 /* Figure out the value returned by the function. */
888 char retbuf
[REGISTER_BYTES
];
890 /* Execute the stack dummy routine, calling FUNCTION.
891 When it is done, discard the empty frame
892 after storing the contents of all regs into retbuf. */
893 run_stack_dummy (start_sp
+ CALL_DUMMY_START_OFFSET
, retbuf
);
895 do_cleanups (old_chain
);
897 return value_being_returned (value_type
, retbuf
, struct_return
);
900 #else /* no CALL_DUMMY. */
902 call_function_by_hand (function
, nargs
, args
)
907 error ("Cannot invoke functions on this machine.");
909 #endif /* no CALL_DUMMY. */
911 /* Create a value for a string constant:
912 Call the function malloc in the inferior to get space for it,
913 then copy the data into that space
914 and then return the address with type char *.
915 PTR points to the string constant data; LEN is number of characters. */
918 value_string (ptr
, len
)
923 register struct symbol
*sym
;
925 register char *copy
= (char *) alloca (len
+ 1);
927 register char *o
= copy
, *ibeg
= ptr
;
930 /* Copy the string into COPY, processing escapes.
931 We could not conveniently process them in the parser
932 because the string there wants to be a substring of the input. */
934 while (i
- ibeg
< len
)
939 c
= parse_escape (&i
);
947 /* Get the length of the string after escapes are processed. */
951 /* Find the address of malloc in the inferior. */
953 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
956 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
957 error ("\"malloc\" exists in this program but is not a function.");
958 val
= value_of_variable (sym
);
962 struct minimal_symbol
*msymbol
;
963 msymbol
= lookup_minimal_symbol ("malloc", (struct objfile
*) NULL
);
966 value_from_longest (lookup_pointer_type (lookup_function_type (
967 lookup_pointer_type (builtin_type_char
))),
968 (LONGEST
) msymbol
-> address
);
970 error ("String constants require the program to have a function \"malloc\".");
973 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) (len
+ 1));
974 val
= call_function_by_hand (val
, 1, &blocklen
);
975 if (value_zerop (val
))
976 error ("No memory available for string constant.");
977 write_memory (value_as_pointer (val
), copy
, len
+ 1);
978 VALUE_TYPE (val
) = lookup_pointer_type (builtin_type_char
);
982 /* Helper function used by value_struct_elt to recurse through baseclasses.
983 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
984 and search in it assuming it has (class) type TYPE.
985 If found, return value, else return NULL.
987 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
988 look for a baseclass named NAME. */
991 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
995 register struct type
*type
;
996 int looking_for_baseclass
;
1000 check_stub_type (type
);
1002 if (! looking_for_baseclass
)
1003 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1005 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1007 if (t_field_name
&& !strcmp (t_field_name
, name
))
1010 if (TYPE_FIELD_STATIC (type
, i
))
1012 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1013 struct symbol
*sym
=
1014 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1016 "Internal error: could not find physical static variable named %s",
1018 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1019 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1022 v
= value_primitive_field (arg1
, offset
, i
, type
);
1024 error("there is no field named %s", name
);
1029 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1032 /* If we are looking for baseclasses, this is what we get when we
1034 int found_baseclass
= (looking_for_baseclass
1035 && !strcmp (name
, TYPE_BASECLASS_NAME (type
, i
)));
1037 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1040 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1043 error ("virtual baseclass botch");
1044 if (found_baseclass
)
1046 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1047 looking_for_baseclass
);
1049 else if (found_baseclass
)
1050 v
= value_primitive_field (arg1
, offset
, i
, type
);
1052 v
= search_struct_field (name
, arg1
,
1053 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1054 TYPE_BASECLASS (type
, i
),
1055 looking_for_baseclass
);
1061 /* Helper function used by value_struct_elt to recurse through baseclasses.
1062 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1063 and search in it assuming it has (class) type TYPE.
1064 If found, return value, else return NULL. */
1067 search_struct_method (name
, arg1
, args
, offset
, static_memfuncp
, type
)
1069 register value arg1
, *args
;
1070 int offset
, *static_memfuncp
;
1071 register struct type
*type
;
1075 check_stub_type (type
);
1076 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1078 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1079 if (t_field_name
&& !strcmp (t_field_name
, name
))
1081 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1082 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1084 if (j
> 0 && args
== 0)
1085 error ("cannot resolve overloaded method `%s'", name
);
1088 if (TYPE_FN_FIELD_STUB (f
, j
))
1089 check_stub_method (type
, i
, j
);
1090 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1091 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1093 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1094 return (value
)value_virtual_fn_field (arg1
, f
, j
, type
);
1095 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1096 *static_memfuncp
= 1;
1097 return (value
)value_fn_field (f
, j
);
1104 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1109 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1111 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1114 error ("virtual baseclass botch");
1120 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1122 v
= search_struct_method (name
, v2
, args
, base_offset
,
1123 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1129 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1130 extract the component named NAME from the ultimate target structure/union
1131 and return it as a value with its appropriate type.
1132 ERR is used in the error message if *ARGP's type is wrong.
1134 C++: ARGS is a list of argument types to aid in the selection of
1135 an appropriate method. Also, handle derived types.
1137 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1138 where the truthvalue of whether the function that was resolved was
1139 a static member function or not is stored.
1141 ERR is an error message to be printed in case the field is not found. */
1144 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1145 register value
*argp
, *args
;
1147 int *static_memfuncp
;
1150 register struct type
*t
;
1153 COERCE_ARRAY (*argp
);
1155 t
= VALUE_TYPE (*argp
);
1157 /* Follow pointers until we get to a non-pointer. */
1159 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1161 *argp
= value_ind (*argp
);
1162 /* Don't coerce fn pointer to fn and then back again! */
1163 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1164 COERCE_ARRAY (*argp
);
1165 t
= VALUE_TYPE (*argp
);
1168 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1169 error ("not implemented: member type in value_struct_elt");
1171 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1172 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1173 error ("Attempt to extract a component of a value that is not a %s.", err
);
1175 /* Assume it's not, unless we see that it is. */
1176 if (static_memfuncp
)
1177 *static_memfuncp
=0;
1181 /* if there are no arguments ...do this... */
1183 /* Try as a field first, because if we succeed, there
1184 is less work to be done. */
1185 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1189 /* C++: If it was not found as a data field, then try to
1190 return it as a pointer to a method. */
1192 if (destructor_name_p (name
, t
))
1193 error ("Cannot get value of destructor");
1195 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1199 if (TYPE_NFN_FIELDS (t
))
1200 error ("There is no member or method named %s.", name
);
1202 error ("There is no member named %s.", name
);
1207 if (destructor_name_p (name
, t
))
1211 /* destructors are a special case. */
1212 return (value
)value_fn_field (TYPE_FN_FIELDLIST1 (t
, 0),
1213 TYPE_FN_FIELDLIST_LENGTH (t
, 0));
1217 error ("destructor should not have any argument");
1221 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1225 /* See if user tried to invoke data as function. If so,
1226 hand it back. If it's not callable (i.e., a pointer to function),
1227 gdb should give an error. */
1228 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1232 error ("Structure has no component named %s.", name
);
1236 /* C++: return 1 is NAME is a legitimate name for the destructor
1237 of type TYPE. If TYPE does not have a destructor, or
1238 if NAME is inappropriate for TYPE, an error is signaled. */
1240 destructor_name_p (name
, type
)
1242 const struct type
*type
;
1244 /* destructors are a special case. */
1248 char *dname
= type_name_no_tag (type
);
1249 if (strcmp (dname
, name
+1))
1250 error ("name of destructor must equal name of class");
1257 /* Helper function for check_field: Given TYPE, a structure/union,
1258 return 1 if the component named NAME from the ultimate
1259 target structure/union is defined, otherwise, return 0. */
1262 check_field_in (type
, name
)
1263 register struct type
*type
;
1268 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1270 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1271 if (t_field_name
&& !strcmp (t_field_name
, name
))
1275 /* C++: If it was not found as a data field, then try to
1276 return it as a pointer to a method. */
1278 /* Destructors are a special case. */
1279 if (destructor_name_p (name
, type
))
1282 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1284 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1288 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1289 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1296 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1297 return 1 if the component named NAME from the ultimate
1298 target structure/union is defined, otherwise, return 0. */
1301 check_field (arg1
, name
)
1302 register value arg1
;
1305 register struct type
*t
;
1307 COERCE_ARRAY (arg1
);
1309 t
= VALUE_TYPE (arg1
);
1311 /* Follow pointers until we get to a non-pointer. */
1313 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1314 t
= TYPE_TARGET_TYPE (t
);
1316 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1317 error ("not implemented: member type in check_field");
1319 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1320 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1321 error ("Internal error: `this' is not an aggregate");
1323 return check_field_in (t
, name
);
1326 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1327 return the address of this member as a "pointer to member"
1328 type. If INTYPE is non-null, then it will be the type
1329 of the member we are looking for. This will help us resolve
1330 "pointers to member functions". This function is used
1331 to resolve user expressions of the form "DOMAIN::NAME". */
1334 value_struct_elt_for_reference (domain
, curtype
, name
, intype
)
1335 struct type
*domain
, *curtype
, *intype
;
1338 register struct type
*t
= curtype
;
1342 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1343 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1344 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1346 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1348 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1350 if (t_field_name
&& !strcmp (t_field_name
, name
))
1352 if (TYPE_FIELD_STATIC (t
, i
))
1354 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1355 struct symbol
*sym
=
1356 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1359 "Internal error: could not find physical static variable named %s",
1361 return value_at (SYMBOL_TYPE (sym
),
1362 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1364 if (TYPE_FIELD_PACKED (t
, i
))
1365 error ("pointers to bitfield members not allowed");
1367 return value_from_longest
1368 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1370 (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1374 /* C++: If it was not found as a data field, then try to
1375 return it as a pointer to a method. */
1377 /* Destructors are a special case. */
1378 if (destructor_name_p (name
, t
))
1380 error ("member pointers to destructors not implemented yet");
1383 /* Perform all necessary dereferencing. */
1384 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1385 intype
= TYPE_TARGET_TYPE (intype
);
1387 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1389 if (!strcmp (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1391 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1392 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1394 if (intype
== 0 && j
> 1)
1395 error ("non-unique member `%s' requires type instantiation", name
);
1399 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1402 error ("no member function matches that type instantiation");
1407 if (TYPE_FN_FIELD_STUB (f
, j
))
1408 check_stub_method (t
, i
, j
);
1409 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1411 return value_from_longest
1412 (lookup_reference_type
1413 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1415 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
1419 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1420 0, VAR_NAMESPACE
, 0, NULL
);
1421 v
= read_var_value (s
, 0);
1423 VALUE_TYPE (v
) = lookup_reference_type
1424 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1432 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1434 v
= value_struct_elt_for_reference (domain
,
1435 TYPE_BASECLASS (t
, i
),
1444 /* Compare two argument lists and return the position in which they differ,
1447 STATICP is nonzero if the T1 argument list came from a
1448 static member function.
1450 For non-static member functions, we ignore the first argument,
1451 which is the type of the instance variable. This is because we want
1452 to handle calls with objects from derived classes. This is not
1453 entirely correct: we should actually check to make sure that a
1454 requested operation is type secure, shouldn't we? FIXME. */
1457 typecmp (staticp
, t1
, t2
)
1466 if (staticp
&& t1
== 0)
1470 if (t1
[0]->code
== TYPE_CODE_VOID
) return 0;
1471 if (t1
[!staticp
] == 0) return 0;
1472 for (i
= !staticp
; t1
[i
] && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
1475 || t1
[i
]->code
!= t2
[i
]->type
->code
1476 /* Too pessimistic: || t1[i]->target_type != t2[i]->type->target_type */
1480 if (!t1
[i
]) return 0;
1481 return t2
[i
] ? i
+1 : 0;
1484 /* C++: return the value of the class instance variable, if one exists.
1485 Flag COMPLAIN signals an error if the request is made in an
1486 inappropriate context. */
1488 value_of_this (complain
)
1491 extern FRAME selected_frame
;
1492 struct symbol
*func
, *sym
;
1495 static const char funny_this
[] = "this";
1498 if (selected_frame
== 0)
1500 error ("no frame selected");
1503 func
= get_frame_function (selected_frame
);
1507 error ("no `this' in nameless context");
1511 b
= SYMBOL_BLOCK_VALUE (func
);
1512 i
= BLOCK_NSYMS (b
);
1515 error ("no args, no `this'");
1518 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1519 symbol instead of the LOC_ARG one (if both exist). */
1520 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1524 error ("current stack frame not in method");
1529 this = read_var_value (sym
, selected_frame
);
1530 if (this == 0 && complain
)
1531 error ("`this' argument at unknown address");