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 bzero (VALUE_CONTENTS (val
), 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
);
201 if (VALUE_LVAL (toval
) != lval_internalvar
)
202 fromval
= value_cast (type
, fromval
);
204 /* If TOVAL is a special machine register requiring conversion
205 of program values to a special raw format,
206 convert FROMVAL's contents now, with result in `raw_buffer',
207 and set USE_BUFFER to the number of bytes to write. */
209 if (VALUE_REGNO (toval
) >= 0
210 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
212 int regno
= VALUE_REGNO (toval
);
213 if (VALUE_TYPE (fromval
) != REGISTER_VIRTUAL_TYPE (regno
))
214 fromval
= value_cast (REGISTER_VIRTUAL_TYPE (regno
), fromval
);
215 bcopy (VALUE_CONTENTS (fromval
), virtual_buffer
,
216 REGISTER_VIRTUAL_SIZE (regno
));
217 target_convert_from_virtual (regno
, virtual_buffer
, raw_buffer
);
218 use_buffer
= REGISTER_RAW_SIZE (regno
);
221 switch (VALUE_LVAL (toval
))
223 case lval_internalvar
:
224 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
227 case lval_internalvar_component
:
228 set_internalvar_component (VALUE_INTERNALVAR (toval
),
229 VALUE_OFFSET (toval
),
230 VALUE_BITPOS (toval
),
231 VALUE_BITSIZE (toval
),
236 if (VALUE_BITSIZE (toval
))
238 int v
; /* FIXME, this won't work for large bitfields */
239 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
241 modify_field (&v
, (int) value_as_long (fromval
),
242 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
243 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
244 (char *)&v
, sizeof v
);
247 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
248 raw_buffer
, use_buffer
);
250 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
251 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
255 if (VALUE_BITSIZE (toval
))
259 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
261 modify_field (&v
, (int) value_as_long (fromval
),
262 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
263 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
267 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
268 raw_buffer
, use_buffer
);
270 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
271 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
274 case lval_reg_frame_relative
:
276 /* value is stored in a series of registers in the frame
277 specified by the structure. Copy that value out, modify
278 it, and copy it back in. */
279 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
280 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
281 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
282 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
284 char *buffer
= (char *) alloca (amount_to_copy
);
288 /* Figure out which frame this is in currently. */
289 for (frame
= get_current_frame ();
290 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
291 frame
= get_prev_frame (frame
))
295 error ("Value being assigned to is no longer active.");
297 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
300 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
302 amount_copied
< amount_to_copy
;
303 amount_copied
+= reg_size
, regno
++)
305 get_saved_register (buffer
+ amount_copied
,
306 (int *)NULL
, (CORE_ADDR
)NULL
,
307 frame
, regno
, (enum lval_type
*)NULL
);
310 /* Modify what needs to be modified. */
311 if (VALUE_BITSIZE (toval
))
312 modify_field (buffer
+ byte_offset
,
313 (int) value_as_long (fromval
),
314 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
316 bcopy (raw_buffer
, buffer
+ byte_offset
, use_buffer
);
318 bcopy (VALUE_CONTENTS (fromval
), buffer
+ byte_offset
,
322 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
324 amount_copied
< amount_to_copy
;
325 amount_copied
+= reg_size
, regno
++)
331 /* Just find out where to put it. */
332 get_saved_register ((char *)NULL
,
333 &optim
, &addr
, frame
, regno
, &lval
);
336 error ("Attempt to assign to a value that was optimized out.");
337 if (lval
== lval_memory
)
338 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
339 else if (lval
== lval_register
)
340 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
342 error ("Attempt to assign to an unmodifiable value.");
349 error ("Left side of = operation is not an lvalue.");
352 /* Return a value just like TOVAL except with the contents of FROMVAL
353 (except in the case of the type if TOVAL is an internalvar). */
355 if (VALUE_LVAL (toval
) == lval_internalvar
356 || VALUE_LVAL (toval
) == lval_internalvar_component
)
358 type
= VALUE_TYPE (fromval
);
361 val
= allocate_value (type
);
362 bcopy (toval
, val
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
363 bcopy (VALUE_CONTENTS (fromval
), VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
364 VALUE_TYPE (val
) = type
;
369 /* Extend a value VAL to COUNT repetitions of its type. */
372 value_repeat (arg1
, count
)
378 if (VALUE_LVAL (arg1
) != lval_memory
)
379 error ("Only values in memory can be extended with '@'.");
381 error ("Invalid number %d of repetitions.", count
);
383 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
385 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
386 VALUE_CONTENTS_RAW (val
),
387 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
388 VALUE_LVAL (val
) = lval_memory
;
389 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
395 value_of_variable (var
)
400 val
= read_var_value (var
, (FRAME
) 0);
402 error ("Address of symbol \"%s\" is unknown.", SYMBOL_NAME (var
));
406 /* Given a value which is an array, return a value which is
407 a pointer to its first (actually, zeroth) element.
408 FIXME, this should be subtracting the array's lower bound. */
411 value_coerce_array (arg1
)
414 register struct type
*type
;
416 if (VALUE_LVAL (arg1
) != lval_memory
)
417 error ("Attempt to take address of value not located in memory.");
419 /* Get type of elements. */
420 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
421 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
423 /* A phony array made by value_repeat.
424 Its type is the type of the elements, not an array type. */
425 type
= VALUE_TYPE (arg1
);
427 return value_from_longest (lookup_pointer_type (type
),
428 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
431 /* Given a value which is a function, return a value which is a pointer
435 value_coerce_function (arg1
)
439 if (VALUE_LVAL (arg1
) != lval_memory
)
440 error ("Attempt to take address of value not located in memory.");
442 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
443 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
446 /* Return a pointer value for the object for which ARG1 is the contents. */
454 if (VALUE_REPEATED (arg1
)
455 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
)
456 return value_coerce_array (arg1
);
457 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_FUNC
)
458 return value_coerce_function (arg1
);
460 if (VALUE_LVAL (arg1
) != lval_memory
)
461 error ("Attempt to take address of value not located in memory.");
463 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
464 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
467 /* Given a value of a pointer type, apply the C unary * operator to it. */
475 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
476 error ("not implemented: member types in value_ind");
478 /* Allow * on an integer so we can cast it to whatever we want.
479 This returns an int, which seems like the most C-like thing
480 to do. "long long" variables are rare enough that
481 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
482 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
483 return value_at (builtin_type_int
,
484 (CORE_ADDR
) value_as_long (arg1
));
485 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
486 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
487 value_as_pointer (arg1
));
488 error ("Attempt to take contents of a non-pointer value.");
489 return 0; /* For lint -- never reached */
492 /* Pushing small parts of stack frames. */
494 /* Push one word (the size of object that a register holds). */
497 push_word (sp
, buffer
)
499 REGISTER_TYPE buffer
;
501 register int len
= sizeof (REGISTER_TYPE
);
503 SWAP_TARGET_AND_HOST (&buffer
, len
);
506 write_memory (sp
, (char *)&buffer
, len
);
507 #else /* stack grows upward */
508 write_memory (sp
, (char *)&buffer
, len
);
510 #endif /* stack grows upward */
515 /* Push LEN bytes with data at BUFFER. */
518 push_bytes (sp
, buffer
, len
)
525 write_memory (sp
, buffer
, len
);
526 #else /* stack grows upward */
527 write_memory (sp
, buffer
, len
);
529 #endif /* stack grows upward */
534 /* Push onto the stack the specified value VALUE. */
538 register CORE_ADDR sp
;
541 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
545 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
546 #else /* stack grows upward */
547 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
549 #endif /* stack grows upward */
554 /* Perform the standard coercions that are specified
555 for arguments to be passed to C functions. */
558 value_arg_coerce (arg
)
561 register struct type
*type
;
565 type
= VALUE_TYPE (arg
);
567 if (TYPE_CODE (type
) == TYPE_CODE_INT
568 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
569 return value_cast (builtin_type_int
, arg
);
571 if (TYPE_CODE (type
) == TYPE_CODE_FLT
572 && TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
573 return value_cast (builtin_type_double
, arg
);
578 /* Push the value ARG, first coercing it as an argument
582 value_arg_push (sp
, arg
)
583 register CORE_ADDR sp
;
586 return value_push (sp
, value_arg_coerce (arg
));
589 /* Determine a function's address and its return type from its value.
590 Calls error() if the function is not valid for calling. */
593 find_function_addr (function
, retval_type
)
595 struct type
**retval_type
;
597 register struct type
*ftype
= VALUE_TYPE (function
);
598 register enum type_code code
= TYPE_CODE (ftype
);
599 struct type
*value_type
;
602 /* If it's a member function, just look at the function
605 /* Determine address to call. */
606 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
608 funaddr
= VALUE_ADDRESS (function
);
609 value_type
= TYPE_TARGET_TYPE (ftype
);
611 else if (code
== TYPE_CODE_PTR
)
613 funaddr
= value_as_pointer (function
);
614 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
615 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
616 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
618 value_type
= builtin_type_int
;
620 else if (code
== TYPE_CODE_INT
)
622 /* Handle the case of functions lacking debugging info.
623 Their values are characters since their addresses are char */
624 if (TYPE_LENGTH (ftype
) == 1)
625 funaddr
= value_as_pointer (value_addr (function
));
627 /* Handle integer used as address of a function. */
628 funaddr
= (CORE_ADDR
) value_as_long (function
);
630 value_type
= builtin_type_int
;
633 error ("Invalid data type for function to be called.");
635 *retval_type
= value_type
;
639 #if defined (CALL_DUMMY)
640 /* All this stuff with a dummy frame may seem unnecessarily complicated
641 (why not just save registers in GDB?). The purpose of pushing a dummy
642 frame which looks just like a real frame is so that if you call a
643 function and then hit a breakpoint (get a signal, etc), "backtrace"
644 will look right. Whether the backtrace needs to actually show the
645 stack at the time the inferior function was called is debatable, but
646 it certainly needs to not display garbage. So if you are contemplating
647 making dummy frames be different from normal frames, consider that. */
649 /* Perform a function call in the inferior.
650 ARGS is a vector of values of arguments (NARGS of them).
651 FUNCTION is a value, the function to be called.
652 Returns a value representing what the function returned.
653 May fail to return, if a breakpoint or signal is hit
654 during the execution of the function. */
657 call_function_by_hand (function
, nargs
, args
)
662 register CORE_ADDR sp
;
665 /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
666 is in host byte order. It is switched to target byte order before calling
668 static REGISTER_TYPE dummy
[] = CALL_DUMMY
;
669 REGISTER_TYPE dummy1
[sizeof dummy
/ sizeof (REGISTER_TYPE
)];
671 struct type
*value_type
;
672 unsigned char struct_return
;
673 CORE_ADDR struct_addr
;
674 struct inferior_status inf_status
;
675 struct cleanup
*old_chain
;
679 save_inferior_status (&inf_status
, 1);
680 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
682 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
683 (and POP_FRAME for restoring them). (At least on most machines)
684 they are saved on the stack in the inferior. */
687 old_sp
= sp
= read_register (SP_REGNUM
);
689 #if 1 INNER_THAN 2 /* Stack grows down */
692 #else /* Stack grows up */
697 funaddr
= find_function_addr (function
, &value_type
);
700 struct block
*b
= block_for_pc (funaddr
);
701 /* If compiled without -g, assume GCC. */
702 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
705 /* Are we returning a value using a structure return or a normal
708 struct_return
= using_struct_return (function
, funaddr
, value_type
,
711 /* Create a call sequence customized for this function
712 and the number of arguments for it. */
713 bcopy (dummy
, dummy1
, sizeof dummy
);
714 for (i
= 0; i
< sizeof dummy
/ sizeof (REGISTER_TYPE
); i
++)
715 SWAP_TARGET_AND_HOST (&dummy1
[i
], sizeof (REGISTER_TYPE
));
716 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
717 value_type
, using_gcc
);
719 #if CALL_DUMMY_LOCATION == ON_STACK
720 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
722 #else /* Not on stack. */
723 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
724 /* Convex Unix prohibits executing in the stack segment. */
725 /* Hope there is empty room at the top of the text segment. */
727 extern CORE_ADDR text_end
;
730 for (start_sp
= text_end
- sizeof dummy
; start_sp
< text_end
; ++start_sp
)
731 if (read_memory_integer (start_sp
, 1) != 0)
732 error ("text segment full -- no place to put call");
735 start_sp
= text_end
- sizeof dummy
;
736 write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
738 #else /* After text_end. */
740 extern CORE_ADDR text_end
;
744 errcode
= target_write_memory (start_sp
, (char *)dummy1
, sizeof dummy
);
746 error ("Cannot write text segment -- call_function failed");
748 #endif /* After text_end. */
749 #endif /* Not on stack. */
752 sp
= old_sp
; /* It really is used, for some ifdef's... */
756 /* If stack grows down, we must leave a hole at the top. */
760 /* Reserve space for the return structure to be written on the
761 stack, if necessary */
764 len
+= TYPE_LENGTH (value_type
);
766 for (i
= nargs
- 1; i
>= 0; i
--)
767 len
+= TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args
[i
])));
768 #ifdef CALL_DUMMY_STACK_ADJUST
769 len
+= CALL_DUMMY_STACK_ADJUST
;
772 sp
-= STACK_ALIGN (len
) - len
;
774 sp
+= STACK_ALIGN (len
) - len
;
777 #endif /* STACK_ALIGN */
779 /* Reserve space for the return structure to be written on the
780 stack, if necessary */
785 sp
-= TYPE_LENGTH (value_type
);
789 sp
+= TYPE_LENGTH (value_type
);
793 #if defined (REG_STRUCT_HAS_ADDR)
795 /* This is a machine like the sparc, where we need to pass a pointer
796 to the structure, not the structure itself. */
797 if (REG_STRUCT_HAS_ADDR (using_gcc
))
798 for (i
= nargs
- 1; i
>= 0; i
--)
799 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
)
802 #if !(1 INNER_THAN 2)
803 /* The stack grows up, so the address of the thing we push
804 is the stack pointer before we push it. */
807 /* Push the structure. */
808 sp
= value_push (sp
, args
[i
]);
810 /* The stack grows down, so the address of the thing we push
811 is the stack pointer after we push it. */
814 /* The value we're going to pass is the address of the thing
816 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
820 #endif /* REG_STRUCT_HAS_ADDR. */
822 #ifdef PUSH_ARGUMENTS
823 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
824 #else /* !PUSH_ARGUMENTS */
825 for (i
= nargs
- 1; i
>= 0; i
--)
826 sp
= value_arg_push (sp
, args
[i
]);
827 #endif /* !PUSH_ARGUMENTS */
829 #ifdef CALL_DUMMY_STACK_ADJUST
831 sp
-= CALL_DUMMY_STACK_ADJUST
;
833 sp
+= CALL_DUMMY_STACK_ADJUST
;
835 #endif /* CALL_DUMMY_STACK_ADJUST */
837 /* Store the address at which the structure is supposed to be
838 written. Note that this (and the code which reserved the space
839 above) assumes that gcc was used to compile this function. Since
840 it doesn't cost us anything but space and if the function is pcc
841 it will ignore this value, we will make that assumption.
843 Also note that on some machines (like the sparc) pcc uses a
844 convention like gcc's. */
847 STORE_STRUCT_RETURN (struct_addr
, sp
);
849 /* Write the stack pointer. This is here because the statements above
850 might fool with it. On SPARC, this write also stores the register
851 window into the right place in the new stack frame, which otherwise
852 wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */
853 write_register (SP_REGNUM
, sp
);
855 /* Figure out the value returned by the function. */
857 char retbuf
[REGISTER_BYTES
];
859 /* Execute the stack dummy routine, calling FUNCTION.
860 When it is done, discard the empty frame
861 after storing the contents of all regs into retbuf. */
862 run_stack_dummy (start_sp
+ CALL_DUMMY_START_OFFSET
, retbuf
);
864 do_cleanups (old_chain
);
866 return value_being_returned (value_type
, retbuf
, struct_return
);
869 #else /* no CALL_DUMMY. */
871 call_function_by_hand (function
, nargs
, args
)
876 error ("Cannot invoke functions on this machine.");
878 #endif /* no CALL_DUMMY. */
880 /* Create a value for a string constant:
881 Call the function malloc in the inferior to get space for it,
882 then copy the data into that space
883 and then return the address with type char *.
884 PTR points to the string constant data; LEN is number of characters. */
887 value_string (ptr
, len
)
892 register struct symbol
*sym
;
894 register char *copy
= (char *) alloca (len
+ 1);
896 register char *o
= copy
, *ibeg
= ptr
;
899 /* Copy the string into COPY, processing escapes.
900 We could not conveniently process them in the parser
901 because the string there wants to be a substring of the input. */
903 while (i
- ibeg
< len
)
908 c
= parse_escape (&i
);
916 /* Get the length of the string after escapes are processed. */
920 /* Find the address of malloc in the inferior. */
922 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
925 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
926 error ("\"malloc\" exists in this program but is not a function.");
927 val
= value_of_variable (sym
);
932 j
= lookup_misc_func ("malloc");
934 val
= value_from_longest (
935 lookup_pointer_type (lookup_function_type (
936 lookup_pointer_type (builtin_type_char
))),
937 (LONGEST
) misc_function_vector
[j
].address
);
939 error ("String constants require the program to have a function \"malloc\".");
942 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) (len
+ 1));
943 val
= target_call_function (val
, 1, &blocklen
);
944 if (value_zerop (val
))
945 error ("No memory available for string constant.");
946 write_memory (value_as_pointer (val
), copy
, len
+ 1);
947 VALUE_TYPE (val
) = lookup_pointer_type (builtin_type_char
);
951 /* Helper function used by value_struct_elt to recurse through baseclasses.
952 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
953 and search in it assuming it has (class) type TYPE.
954 If found, return value, else return NULL.
956 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
957 look for a baseclass named NAME. */
960 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
964 register struct type
*type
;
965 int looking_for_baseclass
;
969 check_stub_type (type
);
971 if (! looking_for_baseclass
)
972 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
974 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
976 if (t_field_name
&& !strcmp (t_field_name
, name
))
978 value v
= (TYPE_FIELD_STATIC (type
, i
)
979 ? value_static_field (type
, name
, i
)
980 : value_primitive_field (arg1
, offset
, i
, type
));
982 error("there is no field named %s", name
);
987 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
990 /* If we are looking for baseclasses, this is what we get when we
992 int found_baseclass
= (looking_for_baseclass
993 && !strcmp (name
, TYPE_BASECLASS_NAME (type
, i
)));
995 if (BASETYPE_VIA_VIRTUAL (type
, i
))
998 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1001 error ("virtual baseclass botch");
1002 if (found_baseclass
)
1004 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1005 looking_for_baseclass
);
1009 if (found_baseclass
)
1010 v
= value_primitive_field (arg1
, offset
, i
, type
);
1012 v
= search_struct_field (name
, arg1
,
1013 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1014 TYPE_BASECLASS (type
, i
),
1015 looking_for_baseclass
);
1021 /* Helper function used by value_struct_elt to recurse through baseclasses.
1022 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1023 and search in it assuming it has (class) type TYPE.
1024 If found, return value, else return NULL. */
1027 search_struct_method (name
, arg1
, args
, offset
, static_memfuncp
, type
)
1029 register value arg1
, *args
;
1030 int offset
, *static_memfuncp
;
1031 register struct type
*type
;
1035 check_stub_type (type
);
1036 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1038 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1039 if (t_field_name
&& !strcmp (t_field_name
, name
))
1041 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1042 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1044 if (j
> 0 && args
== 0)
1045 error ("cannot resolve overloaded method `%s'", name
);
1048 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, j
)) & TYPE_FLAG_STUB
)
1049 check_stub_method (type
, i
, j
);
1050 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1051 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1053 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1054 return (value
)value_virtual_fn_field (arg1
, f
, j
, type
);
1055 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1056 *static_memfuncp
= 1;
1057 return (value
)value_fn_field (f
, j
);
1064 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1068 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1071 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1074 error ("virtual baseclass botch");
1075 v
= search_struct_method (name
, v2
, args
, 0,
1076 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1081 v
= search_struct_method (name
, arg1
, args
,
1082 TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1083 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1089 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1090 extract the component named NAME from the ultimate target structure/union
1091 and return it as a value with its appropriate type.
1092 ERR is used in the error message if *ARGP's type is wrong.
1094 C++: ARGS is a list of argument types to aid in the selection of
1095 an appropriate method. Also, handle derived types.
1097 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1098 where the truthvalue of whether the function that was resolved was
1099 a static member function or not is stored.
1101 ERR is an error message to be printed in case the field is not found. */
1104 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1105 register value
*argp
, *args
;
1107 int *static_memfuncp
;
1110 register struct type
*t
;
1113 COERCE_ARRAY (*argp
);
1115 t
= VALUE_TYPE (*argp
);
1117 /* Follow pointers until we get to a non-pointer. */
1119 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1121 *argp
= value_ind (*argp
);
1122 /* Don't coerce fn pointer to fn and then back again! */
1123 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1124 COERCE_ARRAY (*argp
);
1125 t
= VALUE_TYPE (*argp
);
1128 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1129 error ("not implemented: member type in value_struct_elt");
1131 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1132 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1133 error ("Attempt to extract a component of a value that is not a %s.", err
);
1135 /* Assume it's not, unless we see that it is. */
1136 if (static_memfuncp
)
1137 *static_memfuncp
=0;
1141 /* if there are no arguments ...do this... */
1143 /* Try as a field first, because if we succeed, there
1144 is less work to be done. */
1145 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1149 /* C++: If it was not found as a data field, then try to
1150 return it as a pointer to a method. */
1152 if (destructor_name_p (name
, t
))
1153 error ("Cannot get value of destructor");
1155 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1159 if (TYPE_NFN_FIELDS (t
))
1160 error ("There is no member or method named %s.", name
);
1162 error ("There is no member named %s.", name
);
1167 if (destructor_name_p (name
, t
))
1171 /* destructors are a special case. */
1172 return (value
)value_fn_field (TYPE_FN_FIELDLIST1 (t
, 0),
1173 TYPE_FN_FIELDLIST_LENGTH (t
, 0));
1177 error ("destructor should not have any argument");
1181 v
= search_struct_method (name
, *argp
, args
, 0, static_memfuncp
, t
);
1185 /* See if user tried to invoke data as function. If so,
1186 hand it back. If it's not callable (i.e., a pointer to function),
1187 gdb should give an error. */
1188 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1192 error ("Structure has no component named %s.", name
);
1196 /* C++: return 1 is NAME is a legitimate name for the destructor
1197 of type TYPE. If TYPE does not have a destructor, or
1198 if NAME is inappropriate for TYPE, an error is signaled. */
1200 destructor_name_p (name
, type
)
1204 /* destructors are a special case. */
1208 char *dname
= type_name_no_tag (type
);
1209 if (strcmp (dname
, name
+1))
1210 error ("name of destructor must equal name of class");
1217 /* Helper function for check_field: Given TYPE, a structure/union,
1218 return 1 if the component named NAME from the ultimate
1219 target structure/union is defined, otherwise, return 0. */
1222 check_field_in (type
, name
)
1223 register struct type
*type
;
1228 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1230 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1231 if (t_field_name
&& !strcmp (t_field_name
, name
))
1235 /* C++: If it was not found as a data field, then try to
1236 return it as a pointer to a method. */
1238 /* Destructors are a special case. */
1239 if (destructor_name_p (name
, type
))
1242 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1244 if (!strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1248 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1249 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1256 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1257 return 1 if the component named NAME from the ultimate
1258 target structure/union is defined, otherwise, return 0. */
1261 check_field (arg1
, name
)
1262 register value arg1
;
1265 register struct type
*t
;
1267 COERCE_ARRAY (arg1
);
1269 t
= VALUE_TYPE (arg1
);
1271 /* Follow pointers until we get to a non-pointer. */
1273 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1274 t
= TYPE_TARGET_TYPE (t
);
1276 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1277 error ("not implemented: member type in check_field");
1279 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1280 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1281 error ("Internal error: `this' is not an aggregate");
1283 return check_field_in (t
, name
);
1286 /* C++: Given an aggregate type DOMAIN, and a member name NAME,
1287 return the address of this member as a "pointer to member"
1288 type. If INTYPE is non-null, then it will be the type
1289 of the member we are looking for. This will help us resolve
1290 "pointers to member functions". This function is only used
1291 to resolve user expressions of the form "&class::member". */
1294 value_struct_elt_for_address (domain
, intype
, name
)
1295 struct type
*domain
, *intype
;
1298 register struct type
*t
= domain
;
1302 struct type
*baseclass
;
1304 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1305 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1306 error ("Internal error: non-aggregate type to value_struct_elt_for_address");
1312 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1314 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1316 if (t_field_name
&& !strcmp (t_field_name
, name
))
1318 if (TYPE_FIELD_STATIC (t
, i
))
1320 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1321 struct symbol
*sym
=
1322 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1325 "Internal error: could not find physical static variable named %s",
1327 return value_from_longest (
1328 lookup_pointer_type (TYPE_FIELD_TYPE (t
, i
)),
1329 (LONGEST
)SYMBOL_BLOCK_VALUE (sym
));
1331 if (TYPE_FIELD_PACKED (t
, i
))
1332 error ("pointers to bitfield members not allowed");
1334 return value_from_longest (
1335 lookup_pointer_type (
1336 lookup_member_type (TYPE_FIELD_TYPE (t
, i
), baseclass
)),
1337 (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1341 if (TYPE_N_BASECLASSES (t
) == 0)
1344 t
= TYPE_BASECLASS (t
, 0);
1347 /* C++: If it was not found as a data field, then try to
1348 return it as a pointer to a method. */
1351 /* Destructors are a special case. */
1352 if (destructor_name_p (name
, t
))
1354 error ("member pointers to destructors not implemented yet");
1357 /* Perform all necessary dereferencing. */
1358 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1359 intype
= TYPE_TARGET_TYPE (intype
);
1363 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1365 if (!strcmp (TYPE_FN_FIELDLIST_NAME (t
, i
), name
))
1367 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1368 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1370 if (intype
== 0 && j
> 1)
1371 error ("non-unique member `%s' requires type instantiation", name
);
1375 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1378 error ("no member function matches that type instantiation");
1383 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, j
)) & TYPE_FLAG_STUB
)
1384 check_stub_method (t
, i
, j
);
1385 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1387 return value_from_longest (
1388 lookup_pointer_type (
1389 lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1391 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
1395 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1396 0, VAR_NAMESPACE
, 0, NULL
);
1397 v
= locate_var_value (s
, 0);
1398 VALUE_TYPE (v
) = lookup_pointer_type (
1399 lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1406 if (TYPE_N_BASECLASSES (t
) == 0)
1409 t
= TYPE_BASECLASS (t
, 0);
1414 /* Compare two argument lists and return the position in which they differ,
1417 STATICP is nonzero if the T1 argument list came from a
1418 static member function.
1420 For non-static member functions, we ignore the first argument,
1421 which is the type of the instance variable. This is because we want
1422 to handle calls with objects from derived classes. This is not
1423 entirely correct: we should actually check to make sure that a
1424 requested operation is type secure, shouldn't we? FIXME. */
1427 typecmp (staticp
, t1
, t2
)
1436 if (staticp
&& t1
== 0)
1440 if (t1
[0]->code
== TYPE_CODE_VOID
) return 0;
1441 if (t1
[!staticp
] == 0) return 0;
1442 for (i
= !staticp
; t1
[i
] && t1
[i
]->code
!= TYPE_CODE_VOID
; i
++)
1445 || t1
[i
]->code
!= t2
[i
]->type
->code
1446 /* Too pessimistic: || t1[i]->target_type != t2[i]->type->target_type */
1450 if (!t1
[i
]) return 0;
1451 return t2
[i
] ? i
+1 : 0;
1454 /* C++: return the value of the class instance variable, if one exists.
1455 Flag COMPLAIN signals an error if the request is made in an
1456 inappropriate context. */
1458 value_of_this (complain
)
1461 extern FRAME selected_frame
;
1462 struct symbol
*func
, *sym
;
1465 static const char funny_this
[] = "this";
1468 if (selected_frame
== 0)
1470 error ("no frame selected");
1473 func
= get_frame_function (selected_frame
);
1477 error ("no `this' in nameless context");
1481 b
= SYMBOL_BLOCK_VALUE (func
);
1482 i
= BLOCK_NSYMS (b
);
1485 error ("no args, no `this'");
1488 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1489 symbol instead of the LOC_ARG one (if both exist). */
1490 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1494 error ("current stack frame not in method");
1499 this = read_var_value (sym
, selected_frame
);
1500 if (this == 0 && complain
)
1501 error ("`this' argument at unknown address");