1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1989, 1991 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. */
32 static value
search_struct_field ();
34 /* Cast value ARG2 to type TYPE and return as a value.
35 More general than a C cast: accepts any two types of the same length,
36 and if ARG2 is an lvalue it can be cast into anything at all. */
37 /* In C++, casts may change pointer representations. */
40 value_cast (type
, arg2
)
44 register enum type_code code1
;
45 register enum type_code code2
;
48 /* Coerce arrays but not enums. Enums will work as-is
49 and coercing them would cause an infinite recursion. */
50 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
53 code1
= TYPE_CODE (type
);
54 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
55 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
56 || code2
== TYPE_CODE_ENUM
);
58 if (code1
== TYPE_CODE_FLT
&& scalar
)
59 return value_from_double (type
, value_as_double (arg2
));
60 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
)
61 && (scalar
|| code2
== TYPE_CODE_PTR
))
62 return value_from_longest (type
, value_as_long (arg2
));
63 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
65 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
67 /* Look in the type of the source to see if it contains the
68 type of the target as a superclass. If so, we'll need to
69 offset the pointer rather than just change its type. */
70 struct type
*t1
= TYPE_TARGET_TYPE (type
);
71 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
72 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
73 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
74 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
76 value v
= search_struct_field (type_name_no_tag (t1
),
77 value_ind (arg2
), 0, t2
, 1);
81 VALUE_TYPE (v
) = type
;
85 /* No superclass found, just fall through to change ptr type. */
87 VALUE_TYPE (arg2
) = type
;
90 else if (VALUE_LVAL (arg2
) == lval_memory
)
92 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
94 else if (code1
== TYPE_CODE_VOID
)
96 return value_zero (builtin_type_void
, not_lval
);
100 error ("Invalid cast.");
105 /* Create a value of type TYPE that is zero, and return it. */
108 value_zero (type
, lv
)
112 register value val
= allocate_value (type
);
114 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
115 VALUE_LVAL (val
) = lv
;
120 /* Return a value with type TYPE located at ADDR.
122 Call value_at only if the data needs to be fetched immediately;
123 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
124 value_at_lazy instead. value_at_lazy simply records the address of
125 the data and sets the lazy-evaluation-required flag. The lazy flag
126 is tested in the VALUE_CONTENTS macro, which is used if and when
127 the contents are actually required. */
130 value_at (type
, addr
)
134 register value val
= allocate_value (type
);
136 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
138 VALUE_LVAL (val
) = lval_memory
;
139 VALUE_ADDRESS (val
) = addr
;
144 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
147 value_at_lazy (type
, addr
)
151 register value val
= allocate_value (type
);
153 VALUE_LVAL (val
) = lval_memory
;
154 VALUE_ADDRESS (val
) = addr
;
155 VALUE_LAZY (val
) = 1;
160 /* Called only from the VALUE_CONTENTS macro, if the current data for
161 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
162 data from the user's process, and clears the lazy flag to indicate
163 that the data in the buffer is valid.
165 If the value is zero-length, we avoid calling read_memory, which would
166 abort. We mark the value as fetched anyway -- all 0 bytes of it.
168 This function returns a value because it is used in the VALUE_CONTENTS
169 macro as part of an expression, where a void would not work. The
173 value_fetch_lazy (val
)
176 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
178 if (TYPE_LENGTH (VALUE_TYPE (val
)))
179 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
180 TYPE_LENGTH (VALUE_TYPE (val
)));
181 VALUE_LAZY (val
) = 0;
186 /* Store the contents of FROMVAL into the location of TOVAL.
187 Return a new value with the location of TOVAL and contents of FROMVAL. */
190 value_assign (toval
, fromval
)
191 register value toval
, fromval
;
193 register struct type
*type
= VALUE_TYPE (toval
);
195 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
196 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
199 COERCE_ARRAY (fromval
);
202 if (VALUE_LVAL (toval
) != lval_internalvar
)
203 fromval
= value_cast (type
, fromval
);
205 /* If TOVAL is a special machine register requiring conversion
206 of program values to a special raw format,
207 convert FROMVAL's contents now, with result in `raw_buffer',
208 and set USE_BUFFER to the number of bytes to write. */
210 if (VALUE_REGNO (toval
) >= 0
211 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
213 int regno
= VALUE_REGNO (toval
);
214 if (VALUE_TYPE (fromval
) != REGISTER_VIRTUAL_TYPE (regno
))
215 fromval
= value_cast (REGISTER_VIRTUAL_TYPE (regno
), fromval
);
216 memcpy (virtual_buffer
, VALUE_CONTENTS (fromval
),
217 REGISTER_VIRTUAL_SIZE (regno
));
218 target_convert_from_virtual (regno
, virtual_buffer
, raw_buffer
);
219 use_buffer
= REGISTER_RAW_SIZE (regno
);
222 switch (VALUE_LVAL (toval
))
224 case lval_internalvar
:
225 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
228 case lval_internalvar_component
:
229 set_internalvar_component (VALUE_INTERNALVAR (toval
),
230 VALUE_OFFSET (toval
),
231 VALUE_BITPOS (toval
),
232 VALUE_BITSIZE (toval
),
237 if (VALUE_BITSIZE (toval
))
239 int v
; /* FIXME, this won't work for large bitfields */
240 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
242 modify_field (&v
, (int) value_as_long (fromval
),
243 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
244 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
245 (char *)&v
, sizeof v
);
248 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
249 raw_buffer
, use_buffer
);
251 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
252 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
256 if (VALUE_BITSIZE (toval
))
260 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
262 modify_field (&v
, (int) value_as_long (fromval
),
263 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
264 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
268 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
269 raw_buffer
, use_buffer
);
271 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
272 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
275 case lval_reg_frame_relative
:
277 /* value is stored in a series of registers in the frame
278 specified by the structure. Copy that value out, modify
279 it, and copy it back in. */
280 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
281 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
282 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
283 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
285 char *buffer
= (char *) alloca (amount_to_copy
);
289 /* Figure out which frame this is in currently. */
290 for (frame
= get_current_frame ();
291 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
292 frame
= get_prev_frame (frame
))
296 error ("Value being assigned to is no longer active.");
298 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
301 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
303 amount_copied
< amount_to_copy
;
304 amount_copied
+= reg_size
, regno
++)
306 get_saved_register (buffer
+ amount_copied
,
307 (int *)NULL
, (CORE_ADDR
)NULL
,
308 frame
, regno
, (enum lval_type
*)NULL
);
311 /* Modify what needs to be modified. */
312 if (VALUE_BITSIZE (toval
))
313 modify_field (buffer
+ byte_offset
,
314 (int) value_as_long (fromval
),
315 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
317 bcopy (raw_buffer
, buffer
+ byte_offset
, use_buffer
);
319 bcopy (VALUE_CONTENTS (fromval
), buffer
+ byte_offset
,
323 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
325 amount_copied
< amount_to_copy
;
326 amount_copied
+= reg_size
, regno
++)
332 /* Just find out where to put it. */
333 get_saved_register ((char *)NULL
,
334 &optim
, &addr
, frame
, regno
, &lval
);
337 error ("Attempt to assign to a value that was optimized out.");
338 if (lval
== lval_memory
)
339 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
340 else if (lval
== lval_register
)
341 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
343 error ("Attempt to assign to an unmodifiable value.");
350 error ("Left side of = operation is not an lvalue.");
353 /* Return a value just like TOVAL except with the contents of FROMVAL
354 (except in the case of the type if TOVAL is an internalvar). */
356 if (VALUE_LVAL (toval
) == lval_internalvar
357 || VALUE_LVAL (toval
) == lval_internalvar_component
)
359 type
= VALUE_TYPE (fromval
);
362 val
= allocate_value (type
);
363 bcopy (toval
, val
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
364 bcopy (VALUE_CONTENTS (fromval
), VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
365 VALUE_TYPE (val
) = type
;
370 /* Extend a value VAL to COUNT repetitions of its type. */
373 value_repeat (arg1
, count
)
379 if (VALUE_LVAL (arg1
) != lval_memory
)
380 error ("Only values in memory can be extended with '@'.");
382 error ("Invalid number %d of repetitions.", count
);
384 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
386 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
387 VALUE_CONTENTS_RAW (val
),
388 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
389 VALUE_LVAL (val
) = lval_memory
;
390 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
396 value_of_variable (var
)
401 val
= read_var_value (var
, (FRAME
) 0);
403 error ("Address of symbol \"%s\" is unknown.", SYMBOL_NAME (var
));
407 /* Given a value which is an array, return a value which is
408 a pointer to its first (actually, zeroth) element.
409 FIXME, this should be subtracting the array's lower bound. */
412 value_coerce_array (arg1
)
415 register struct type
*type
;
417 if (VALUE_LVAL (arg1
) != lval_memory
)
418 error ("Attempt to take address of value not located in memory.");
420 /* Get type of elements. */
421 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
422 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
424 /* A phony array made by value_repeat.
425 Its type is the type of the elements, not an array type. */
426 type
= VALUE_TYPE (arg1
);
428 return value_from_longest (lookup_pointer_type (type
),
429 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
432 /* Given a value which is a function, return a value which is a pointer
436 value_coerce_function (arg1
)
440 if (VALUE_LVAL (arg1
) != lval_memory
)
441 error ("Attempt to take address of value not located in memory.");
443 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
444 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
447 /* Return a pointer value for the object for which ARG1 is the contents. */
453 struct type
*type
= VALUE_TYPE (arg1
);
454 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
456 /* Copy the value, but change the type from (T&) to (T*).
457 We keep the same location information, which is efficient,
458 and allows &(&X) to get the location containing the reference. */
459 value arg2
= value_copy (arg1
);
460 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
463 if (VALUE_REPEATED (arg1
)
464 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
465 return value_coerce_array (arg1
);
466 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
467 return value_coerce_function (arg1
);
469 if (VALUE_LVAL (arg1
) != lval_memory
)
470 error ("Attempt to take address of value not located in memory.");
472 return value_from_longest (lookup_pointer_type (type
),
473 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
476 /* Given a value of a pointer type, apply the C unary * operator to it. */
484 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
485 error ("not implemented: member types in value_ind");
487 /* Allow * on an integer so we can cast it to whatever we want.
488 This returns an int, which seems like the most C-like thing
489 to do. "long long" variables are rare enough that
490 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
491 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
492 return value_at (builtin_type_int
,
493 (CORE_ADDR
) value_as_long (arg1
));
494 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
495 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
496 value_as_pointer (arg1
));
497 error ("Attempt to take contents of a non-pointer value.");
498 return 0; /* For lint -- never reached */
501 /* Pushing small parts of stack frames. */
503 /* Push one word (the size of object that a register holds). */
506 push_word (sp
, buffer
)
508 REGISTER_TYPE buffer
;
510 register int len
= sizeof (REGISTER_TYPE
);
512 SWAP_TARGET_AND_HOST (&buffer
, len
);
515 write_memory (sp
, (char *)&buffer
, len
);
516 #else /* stack grows upward */
517 write_memory (sp
, (char *)&buffer
, len
);
519 #endif /* stack grows upward */
524 /* Push LEN bytes with data at BUFFER. */
527 push_bytes (sp
, buffer
, len
)
534 write_memory (sp
, buffer
, len
);
535 #else /* stack grows upward */
536 write_memory (sp
, buffer
, len
);
538 #endif /* stack grows upward */
543 /* Push onto the stack the specified value VALUE. */
547 register CORE_ADDR sp
;
550 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
554 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
555 #else /* stack grows upward */
556 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
558 #endif /* stack grows upward */
563 /* Perform the standard coercions that are specified
564 for arguments to be passed to C functions. */
567 value_arg_coerce (arg
)
570 register struct type
*type
;
574 type
= VALUE_TYPE (arg
);
576 if (TYPE_CODE (type
) == TYPE_CODE_INT
577 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
578 return value_cast (builtin_type_int
, arg
);
580 if (TYPE_CODE (type
) == TYPE_CODE_FLT
581 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
582 return value_cast (builtin_type_double
, arg
);
587 /* Push the value ARG, first coercing it as an argument
591 value_arg_push (sp
, arg
)
592 register CORE_ADDR sp
;
595 return value_push (sp
, value_arg_coerce (arg
));
598 /* Determine a function's address and its return type from its value.
599 Calls error() if the function is not valid for calling. */
602 find_function_addr (function
, retval_type
)
604 struct type
**retval_type
;
606 register struct type
*ftype
= VALUE_TYPE (function
);
607 register enum type_code code
= TYPE_CODE (ftype
);
608 struct type
*value_type
;
611 /* If it's a member function, just look at the function
614 /* Determine address to call. */
615 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
617 funaddr
= VALUE_ADDRESS (function
);
618 value_type
= TYPE_TARGET_TYPE (ftype
);
620 else if (code
== TYPE_CODE_PTR
)
622 funaddr
= value_as_pointer (function
);
623 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
624 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
625 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
627 value_type
= builtin_type_int
;
629 else if (code
== TYPE_CODE_INT
)
631 /* Handle the case of functions lacking debugging info.
632 Their values are characters since their addresses are char */
633 if (TYPE_LENGTH (ftype
) == 1)
634 funaddr
= value_as_pointer (value_addr (function
));
636 /* Handle integer used as address of a function. */
637 funaddr
= (CORE_ADDR
) value_as_long (function
);
639 value_type
= builtin_type_int
;
642 error ("Invalid data type for function to be called.");
644 *retval_type
= value_type
;
648 #if defined (CALL_DUMMY)
649 /* All this stuff with a dummy frame may seem unnecessarily complicated
650 (why not just save registers in GDB?). The purpose of pushing a dummy
651 frame which looks just like a real frame is so that if you call a
652 function and then hit a breakpoint (get a signal, etc), "backtrace"
653 will look right. Whether the backtrace needs to actually show the
654 stack at the time the inferior function was called is debatable, but
655 it certainly needs to not display garbage. So if you are contemplating
656 making dummy frames be different from normal frames, consider that. */
658 /* Perform a function call in the inferior.
659 ARGS is a vector of values of arguments (NARGS of them).
660 FUNCTION is a value, the function to be called.
661 Returns a value representing what the function returned.
662 May fail to return, if a breakpoint or signal is hit
663 during the execution of the function. */
666 call_function_by_hand (function
, nargs
, args
)
671 register CORE_ADDR sp
;
674 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
675 is in host byte order. It is switched to target byte order before calling
677 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
678 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
680 struct type
*value_type
;
681 unsigned char struct_return
;
682 CORE_ADDR struct_addr
;
683 struct inferior_status inf_status
;
684 struct cleanup
*old_chain
;
688 save_inferior_status (&inf_status
, 1);
689 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
691 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
692 (and POP_FRAME for restoring them). (At least on most machines)
693 they are saved on the stack in the inferior. */
696 old_sp
= sp
= read_register (SP_REGNUM
);
698 #if 1 INNER_THAN 2 /* Stack grows down */
701 #else /* Stack grows up */
706 funaddr
= find_function_addr (function
, &value_type
);
709 struct block
*b
= block_for_pc (funaddr
);
710 /* If compiled without -g, assume GCC. */
711 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
714 /* Are we returning a value using a structure return or a normal
717 struct_return
= using_struct_return (function
, funaddr
, value_type
,
720 /* Create a call sequence customized for this function
721 and the number of arguments for it. */
722 bcopy (dummy
, dummy1
, sizeof dummy
);
723 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
724 SWAP_TARGET_AND_HOST (&dummy1
[i
], sizeof (REGISTER_TYPE
));
725 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
726 value_type
, using_gcc
);
728 #if CALL_DUMMY_LOCATION == ON_STACK
729 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
731 #else /* Not on stack. */
732 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
733 /* Convex Unix prohibits executing in the stack segment. */
734 /* Hope there is empty room at the top of the text segment. */
736 extern CORE_ADDR text_end
;
739 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
740 if (read_memory_integer (start_sp
, 1) != 0)
741 error ("text segment full -- no place to put call");
744 start_sp
= text_end
- sizeof dummy
;
745 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
747 #else /* After text_end. */
749 extern CORE_ADDR text_end
;
753 errcode
= target_write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
755 error ("Cannot write text segment -- call_function failed");
757 #endif /* After text_end. */
758 #endif /* Not on stack. */
761 sp
= old_sp
; /* It really is used, for some ifdef's... */
765 /* If stack grows down, we must leave a hole at the top. */
769 /* Reserve space for the return structure to be written on the
770 stack, if necessary */
773 len
+= TYPE_LENGTH (value_type
);
775 for (i
= nargs
- 1; i
>= 0; i
--)
776 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
777 #ifdef CALL_DUMMY_STACK_ADJUST
778 len
+= CALL_DUMMY_STACK_ADJUST
;
781 sp
-= STACK_ALIGN (len
) - len
;
783 sp
+= STACK_ALIGN (len
) - len
;
786 #endif /* STACK_ALIGN */
788 /* Reserve space for the return structure to be written on the
789 stack, if necessary */
794 sp
-= TYPE_LENGTH (value_type
);
798 sp
+= TYPE_LENGTH (value_type
);
802 #if defined (REG_STRUCT_HAS_ADDR)
804 /* This is a machine like the sparc, where we need to pass a pointer
805 to the structure, not the structure itself. */
806 if (REG_STRUCT_HAS_ADDR (using_gcc
))
807 for (i
= nargs
- 1; i
>= 0; i
--)
808 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
811 #if !(1 INNER_THAN 2)
812 /* The stack grows up, so the address of the thing we push
813 is the stack pointer before we push it. */
816 /* Push the structure. */
817 sp
= value_push (sp
, args
[i
]);
819 /* The stack grows down, so the address of the thing we push
820 is the stack pointer after we push it. */
823 /* The value we're going to pass is the address of the thing
825 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
829 #endif /* REG_STRUCT_HAS_ADDR. */
831 #ifdef PUSH_ARGUMENTS
832 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
833 #else /* !PUSH_ARGUMENTS */
834 for (i
= nargs
- 1; i
>= 0; i
--)
835 sp
= value_arg_push (sp
, args
[i
]);
836 #endif /* !PUSH_ARGUMENTS */
838 #ifdef CALL_DUMMY_STACK_ADJUST
840 sp
-= CALL_DUMMY_STACK_ADJUST
;
842 sp
+= CALL_DUMMY_STACK_ADJUST
;
844 #endif /* CALL_DUMMY_STACK_ADJUST */
846 /* Store the address at which the structure is supposed to be
847 written. Note that this (and the code which reserved the space
848 above) assumes that gcc was used to compile this function. Since
849 it doesn't cost us anything but space and if the function is pcc
850 it will ignore this value, we will make that assumption.
852 Also note that on some machines (like the sparc) pcc uses a
853 convention like gcc's. */
856 STORE_STRUCT_RETURN (struct_addr
, sp
);
858 /* Write the stack pointer. This is here because the statements above
859 might fool with it. On SPARC, this write also stores the register
860 window into the right place in the new stack frame, which otherwise
861 wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */
862 write_register (SP_REGNUM
, sp
);
864 /* Figure out the value returned by the function. */
866 char retbuf
[REGISTER_BYTES
];
868 /* Execute the stack dummy routine, calling FUNCTION.
869 When it is done, discard the empty frame
870 after storing the contents of all regs into retbuf. */
871 run_stack_dummy (start_sp
+ CALL_DUMMY_START_OFFSET
, retbuf
);
873 do_cleanups (old_chain
);
875 return value_being_returned (value_type
, retbuf
, struct_return
);
878 #else /* no CALL_DUMMY. */
880 call_function_by_hand (function
, nargs
, args
)
885 error ("Cannot invoke functions on this machine.");
887 #endif /* no CALL_DUMMY. */
889 /* Create a value for a string constant:
890 Call the function malloc in the inferior to get space for it,
891 then copy the data into that space
892 and then return the address with type char *.
893 PTR points to the string constant data; LEN is number of characters. */
896 value_string (ptr
, len
)
901 register struct symbol
*sym
;
903 register char *copy
= (char *) alloca (len
+ 1);
905 register char *o
= copy
, *ibeg
= ptr
;
908 /* Copy the string into COPY, processing escapes.
909 We could not conveniently process them in the parser
910 because the string there wants to be a substring of the input. */
912 while (i
- ibeg
< len
)
917 c
= parse_escape (&i
);
925 /* Get the length of the string after escapes are processed. */
929 /* Find the address of malloc in the inferior. */
931 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
934 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
935 error ("\"malloc\" exists in this program but is not a function.");
936 val
= value_of_variable (sym
);
941 j
= lookup_misc_func ("malloc");
943 val
= value_from_longest (
944 lookup_pointer_type (lookup_function_type (
945 lookup_pointer_type (builtin_type_char
))),
946 (LONGEST
) misc_function_vector
[j
].address
);
948 error ("String constants require the program to have a function \"malloc\".");
951 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) (len
+ 1));
952 val
= target_call_function (val
, 1, &blocklen
);
953 if (value_zerop (val
))
954 error ("No memory available for string constant.");
955 write_memory (value_as_pointer (val
), copy
, len
+ 1);
956 VALUE_TYPE (val
) = lookup_pointer_type (builtin_type_char
);
960 /* Helper function used by value_struct_elt to recurse through baseclasses.
961 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
962 and search in it assuming it has (class) type TYPE.
963 If found, return value, else return NULL.
965 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
966 look for a baseclass named NAME. */
969 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
973 register struct type
*type
;
974 int looking_for_baseclass
;
978 check_stub_type (type
);
980 if (! looking_for_baseclass
)
981 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
983 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
985 if (t_field_name
&& !strcmp (t_field_name
, name
))
987 value v
= (TYPE_FIELD_STATIC (type
, i
)
988 ? value_static_field (type
, name
, i
)
989 : value_primitive_field (arg1
, offset
, i
, type
));
991 error("there is no field named %s", name
);
996 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
999 /* If we are looking for baseclasses, this is what we get when we
1001 int found_baseclass
= (looking_for_baseclass
1002 && !strcmp (name
, TYPE_BASECLASS_NAME (type
, i
)));
1004 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1007 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1010 error ("virtual baseclass botch");
1011 if (found_baseclass
)
1013 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1014 looking_for_baseclass
);
1018 if (found_baseclass
)
1019 v
= value_primitive_field (arg1
, offset
, i
, type
);
1021 v
= search_struct_field (name
, arg1
,
1022 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1023 TYPE_BASECLASS (type
, i
),
1024 looking_for_baseclass
);
1030 /* Helper function used by value_struct_elt to recurse through baseclasses.
1031 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1032 and search in it assuming it has (class) type TYPE.
1033 If found, return value, else return NULL. */
1036 search_struct_method (name
, arg1
, args
, offset
, static_memfuncp
, type
)
1038 register value arg1
, *args
;
1039 int offset
, *static_memfuncp
;
1040 register struct type
*type
;
1044 check_stub_type (type
);
1045 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1047 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1048 if (t_field_name
&& !strcmp (t_field_name
, name
))
1050 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1051 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1053 if (j
> 0 && args
== 0)
1054 error ("cannot resolve overloaded method `%s'", name
);
1057 if (TYPE_FN_FIELD_STUB (f
, j
))
1058 check_stub_method (type
, i
, j
);
1059 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1060 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1062 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1063 return (value
)value_virtual_fn_field (arg1
, f
, j
, type
);
1064 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1065 *static_memfuncp
= 1;
1066 return (value
)value_fn_field (f
, j
);
1073 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1077 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1080 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1083 error ("virtual baseclass botch");
1084 v
= search_struct_method (name
, v2
, args
, 0,
1085 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1090 v
= search_struct_method (name
, arg1
, args
,
1091 TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1092 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1098 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1099 extract the component named NAME from the ultimate target structure/union
1100 and return it as a value with its appropriate type.
1101 ERR is used in the error message if *ARGP's type is wrong.
1103 C++: ARGS is a list of argument types to aid in the selection of
1104 an appropriate method. Also, handle derived types.
1106 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1107 where the truthvalue of whether the function that was resolved was
1108 a static member function or not is stored.
1110 ERR is an error message to be printed in case the field is not found. */
1113 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1114 register value
*argp
, *args
;
1116 int *static_memfuncp
;
1119 register struct type
*t
;
1122 COERCE_ARRAY (*argp
);
1124 t
= VALUE_TYPE (*argp
);
1126 /* Follow pointers until we get to a non-pointer. */
1128 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1130 *argp
= value_ind (*argp
);
1131 /* Don't coerce fn pointer to fn and then back again! */
1132 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1133 COERCE_ARRAY (*argp
);
1134 t
= VALUE_TYPE (*argp
);
1137 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1138 error ("not implemented: member type in value_struct_elt");
1140 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1141 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1142 error ("Attempt to extract a component of a value that is not a %s.", err
);
1144 /* Assume it's not, unless we see that it is. */
1145 if (static_memfuncp
)
1146 *static_memfuncp
=0;
1150 /* if there are no arguments ...do this... */
1152 /* Try as a field first, because if we succeed, there
1153 is less work to be done. */
1154 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1158 /* C++: If it was not found as a data field, then try to
1159 return it as a pointer to a method. */
1161 if (destructor_name_p (name
, t
))
1162 error ("Cannot get value of destructor");
1164 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1168 if (TYPE_NFN_FIELDS (t
))
1169 error ("There is no member or method named %s.", name
);
1171 error ("There is no member named %s.", name
);
1176 if (destructor_name_p (name
, t
))
1180 /* destructors are a special case. */
1181 return (value
)value_fn_field (TYPE_FN_FIELDLIST1 (t
, 0),
1182 TYPE_FN_FIELDLIST_LENGTH (t
, 0));
1186 error ("destructor should not have any argument");
1190 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1194 /* See if user tried to invoke data as function. If so,
1195 hand it back. If it's not callable (i.e., a pointer to function),
1196 gdb should give an error. */
1197 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1201 error ("Structure has no component named %s.", name
);
1205 /* C++: return 1 is NAME is a legitimate name for the destructor
1206 of type TYPE. If TYPE does not have a destructor, or
1207 if NAME is inappropriate for TYPE, an error is signaled. */
1209 destructor_name_p (name
, type
)
1213 /* destructors are a special case. */
1217 char *dname
= type_name_no_tag (type
);
1218 if (strcmp (dname
, name
+1))
1219 error ("name of destructor must equal name of class");
1226 /* Helper function for check_field: Given TYPE, a structure/union,
1227 return 1 if the component named NAME from the ultimate
1228 target structure/union is defined, otherwise, return 0. */
1231 check_field_in (type
, name
)
1232 register struct type
*type
;
1237 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1239 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1240 if (t_field_name
&& !strcmp (t_field_name
, name
))
1244 /* C++: If it was not found as a data field, then try to
1245 return it as a pointer to a method. */
1247 /* Destructors are a special case. */
1248 if (destructor_name_p (name
, type
))
1251 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1253 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1257 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1258 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1265 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1266 return 1 if the component named NAME from the ultimate
1267 target structure/union is defined, otherwise, return 0. */
1270 check_field (arg1
, name
)
1271 register value arg1
;
1274 register struct type
*t
;
1276 COERCE_ARRAY (arg1
);
1278 t
= VALUE_TYPE (arg1
);
1280 /* Follow pointers until we get to a non-pointer. */
1282 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1283 t
= TYPE_TARGET_TYPE (t
);
1285 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1286 error ("not implemented: member type in check_field");
1288 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1289 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1290 error ("Internal error: `this' is not an aggregate");
1292 return check_field_in (t
, name
);
1295 /* C++: Given an aggregate type DOMAIN, and a member name NAME,
1296 return the address of this member as a "pointer to member"
1297 type. If INTYPE is non-null, then it will be the type
1298 of the member we are looking for. This will help us resolve
1299 "pointers to member functions". This function is only used
1300 to resolve user expressions of the form "&class::member". */
1303 value_struct_elt_for_address (domain
, intype
, name
)
1304 struct type
*domain
, *intype
;
1307 register struct type
*t
= domain
;
1311 struct type
*baseclass
;
1313 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1314 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1315 error ("Internal error: non-aggregate type to value_struct_elt_for_address");
1321 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1323 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1325 if (t_field_name
&& !strcmp (t_field_name
, name
))
1327 if (TYPE_FIELD_STATIC (t
, i
))
1329 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1330 struct symbol
*sym
=
1331 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1334 "Internal error: could not find physical static variable named %s",
1336 return value_from_longest (
1337 lookup_pointer_type (TYPE_FIELD_TYPE (t
, i
)),
1338 (LONGEST
)SYMBOL_BLOCK_VALUE (sym
));
1340 if (TYPE_FIELD_PACKED (t
, i
))
1341 error ("pointers to bitfield members not allowed");
1343 return value_from_longest (
1344 lookup_pointer_type (
1345 lookup_member_type (TYPE_FIELD_TYPE (t
, i
), baseclass
)),
1346 (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1350 if (TYPE_N_BASECLASSES (t
) == 0)
1353 t
= TYPE_BASECLASS (t
, 0);
1356 /* C++: If it was not found as a data field, then try to
1357 return it as a pointer to a method. */
1360 /* Destructors are a special case. */
1361 if (destructor_name_p (name
, t
))
1363 error ("member pointers to destructors not implemented yet");
1366 /* Perform all necessary dereferencing. */
1367 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1368 intype
= TYPE_TARGET_TYPE (intype
);
1372 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1374 if (!strcmp (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1376 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1377 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1379 if (intype
== 0 && j
> 1)
1380 error ("non-unique member `%s' requires type instantiation", name
);
1384 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1387 error ("no member function matches that type instantiation");
1392 if (TYPE_FN_FIELD_STUB (f
, j
))
1393 check_stub_method (t
, i
, j
);
1394 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1396 return value_from_longest (
1397 lookup_pointer_type (
1398 lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1400 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
1404 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1405 0, VAR_NAMESPACE
, 0, NULL
);
1406 v
= locate_var_value (s
, 0);
1407 VALUE_TYPE (v
) = lookup_pointer_type (
1408 lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1415 if (TYPE_N_BASECLASSES (t
) == 0)
1418 t
= TYPE_BASECLASS (t
, 0);
1423 /* Compare two argument lists and return the position in which they differ,
1426 STATICP is nonzero if the T1 argument list came from a
1427 static member function.
1429 For non-static member functions, we ignore the first argument,
1430 which is the type of the instance variable. This is because we want
1431 to handle calls with objects from derived classes. This is not
1432 entirely correct: we should actually check to make sure that a
1433 requested operation is type secure, shouldn't we? FIXME. */
1436 typecmp (staticp
, t1
, t2
)
1445 if (staticp
&& t1
== 0)
1449 if (t1
[0]->code
== TYPE_CODE_VOID
) return 0;
1450 if (t1
[!staticp
] == 0) return 0;
1451 for (i
= !staticp
; t1
[i
] && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
1454 || t1
[i
]->code
!= t2
[i
]->type
->code
1455 /* Too pessimistic: || t1[i]->target_type != t2[i]->type->target_type */
1459 if (!t1
[i
]) return 0;
1460 return t2
[i
] ? i
+1 : 0;
1463 /* C++: return the value of the class instance variable, if one exists.
1464 Flag COMPLAIN signals an error if the request is made in an
1465 inappropriate context. */
1467 value_of_this (complain
)
1470 extern FRAME selected_frame
;
1471 struct symbol
*func
, *sym
;
1474 static const char funny_this
[] = "this";
1477 if (selected_frame
== 0)
1479 error ("no frame selected");
1482 func
= get_frame_function (selected_frame
);
1486 error ("no `this' in nameless context");
1490 b
= SYMBOL_BLOCK_VALUE (func
);
1491 i
= BLOCK_NSYMS (b
);
1494 error ("no args, no `this'");
1497 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1498 symbol instead of the LOC_ARG one (if both exist). */
1499 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1503 error ("current stack frame not in method");
1508 this = read_var_value (sym
, selected_frame
);
1509 if (this == 0 && complain
)
1510 error ("`this' argument at unknown address");