1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
35 /* Local functions. */
37 static int typecmp
PARAMS ((int staticp
, struct type
*t1
[], value_ptr t2
[]));
39 static CORE_ADDR find_function_addr
PARAMS ((value_ptr
, struct type
**));
41 static CORE_ADDR value_push
PARAMS ((CORE_ADDR
, value_ptr
));
43 static value_ptr search_struct_field
PARAMS ((char *, value_ptr
, int,
46 static value_ptr search_struct_method
PARAMS ((char *, value_ptr
*,
48 int, int *, struct type
*));
50 static int check_field_in
PARAMS ((struct type
*, const char *));
52 static CORE_ADDR allocate_space_in_inferior
PARAMS ((int));
54 static value_ptr cast_into_complex
PARAMS ((struct type
*, value_ptr
));
56 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
59 /* Allocate NBYTES of space in the inferior using the inferior's malloc
60 and return a value that is a pointer to the allocated space. */
63 allocate_space_in_inferior (len
)
66 register value_ptr val
;
67 register struct symbol
*sym
;
68 struct minimal_symbol
*msymbol
;
73 /* Find the address of malloc in the inferior. */
75 sym
= lookup_symbol ("malloc", 0, VAR_NAMESPACE
, 0, NULL
);
78 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
80 error ("\"malloc\" exists in this program but is not a function.");
82 val
= value_of_variable (sym
, NULL
);
86 msymbol
= lookup_minimal_symbol ("malloc", NULL
, NULL
);
89 type
= lookup_pointer_type (builtin_type_char
);
90 type
= lookup_function_type (type
);
91 type
= lookup_pointer_type (type
);
92 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
93 val
= value_from_longest (type
, maddr
);
97 error ("evaluation of this expression requires the program to have a function \"malloc\".");
101 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
102 val
= call_function_by_hand (val
, 1, &blocklen
);
103 if (value_logical_not (val
))
105 error ("No memory available to program.");
107 return (value_as_long (val
));
110 /* Cast value ARG2 to type TYPE and return as a value.
111 More general than a C cast: accepts any two types of the same length,
112 and if ARG2 is an lvalue it can be cast into anything at all. */
113 /* In C++, casts may change pointer or object representations. */
116 value_cast (type
, arg2
)
118 register value_ptr arg2
;
120 register enum type_code code1
;
121 register enum type_code code2
;
124 if (VALUE_TYPE (arg2
) == type
)
127 /* Coerce arrays but not enums. Enums will work as-is
128 and coercing them would cause an infinite recursion. */
129 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_ENUM
)
132 COERCE_VARYING_ARRAY (arg2
);
134 code1
= TYPE_CODE (type
);
135 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
137 if (code1
== TYPE_CODE_COMPLEX
)
138 return cast_into_complex (type
, arg2
);
139 if (code1
== TYPE_CODE_BOOL
)
140 code1
= TYPE_CODE_INT
;
141 if (code2
== TYPE_CODE_BOOL
)
142 code2
= TYPE_CODE_INT
;
144 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
145 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
147 if ( code1
== TYPE_CODE_STRUCT
148 && code2
== TYPE_CODE_STRUCT
149 && TYPE_NAME (type
) != 0)
151 /* Look in the type of the source to see if it contains the
152 type of the target as a superclass. If so, we'll need to
153 offset the object in addition to changing its type. */
154 value_ptr v
= search_struct_field (type_name_no_tag (type
),
155 arg2
, 0, VALUE_TYPE (arg2
), 1);
158 VALUE_TYPE (v
) = type
;
162 if (code1
== TYPE_CODE_FLT
&& scalar
)
163 return value_from_double (type
, value_as_double (arg2
));
164 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
165 || code1
== TYPE_CODE_RANGE
)
166 && (scalar
|| code2
== TYPE_CODE_PTR
))
167 return value_from_longest (type
, value_as_long (arg2
));
168 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
170 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
172 /* Look in the type of the source to see if it contains the
173 type of the target as a superclass. If so, we'll need to
174 offset the pointer rather than just change its type. */
175 struct type
*t1
= TYPE_TARGET_TYPE (type
);
176 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
177 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
178 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
179 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
181 value_ptr v
= search_struct_field (type_name_no_tag (t1
),
182 value_ind (arg2
), 0, t2
, 1);
186 VALUE_TYPE (v
) = type
;
190 /* No superclass found, just fall through to change ptr type. */
192 VALUE_TYPE (arg2
) = type
;
195 else if (chill_varying_type (type
))
197 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
200 char *valaddr
, *valaddr_data
;
201 if (code2
== TYPE_CODE_BITSTRING
)
202 error ("not implemented: converting bitstring to varying type");
203 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
204 || (eltype1
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1)),
205 eltype2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
)),
206 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
207 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
208 error ("Invalid conversion to varying type");
209 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
210 range2
= TYPE_FIELD_TYPE (VALUE_TYPE (arg2
), 0);
211 count1
= TYPE_HIGH_BOUND (range1
) - TYPE_LOW_BOUND (range1
) + 1;
212 count2
= TYPE_HIGH_BOUND (range2
) - TYPE_LOW_BOUND (range2
) + 1;
214 error ("target varying type is too small");
215 val
= allocate_value (type
);
216 valaddr
= VALUE_CONTENTS_RAW (val
);
217 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
218 /* Set val's __var_length field to count2. */
219 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
221 /* Set the __var_data field to count2 elements copied from arg2. */
222 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
223 count2
* TYPE_LENGTH (eltype2
));
224 /* Zero the rest of the __var_data field of val. */
225 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
226 (count1
- count2
) * TYPE_LENGTH (eltype2
));
229 else if (VALUE_LVAL (arg2
) == lval_memory
)
231 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
233 else if (code1
== TYPE_CODE_VOID
)
235 return value_zero (builtin_type_void
, not_lval
);
239 error ("Invalid cast.");
244 /* Create a value of type TYPE that is zero, and return it. */
247 value_zero (type
, lv
)
251 register value_ptr val
= allocate_value (type
);
253 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
254 VALUE_LVAL (val
) = lv
;
259 /* Return a value with type TYPE located at ADDR.
261 Call value_at only if the data needs to be fetched immediately;
262 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
263 value_at_lazy instead. value_at_lazy simply records the address of
264 the data and sets the lazy-evaluation-required flag. The lazy flag
265 is tested in the VALUE_CONTENTS macro, which is used if and when
266 the contents are actually required. */
269 value_at (type
, addr
)
273 register value_ptr val
;
275 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
276 error ("Attempt to dereference a generic pointer.");
278 val
= allocate_value (type
);
280 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
282 VALUE_LVAL (val
) = lval_memory
;
283 VALUE_ADDRESS (val
) = addr
;
288 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
291 value_at_lazy (type
, addr
)
295 register value_ptr val
;
297 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
298 error ("Attempt to dereference a generic pointer.");
300 val
= allocate_value (type
);
302 VALUE_LVAL (val
) = lval_memory
;
303 VALUE_ADDRESS (val
) = addr
;
304 VALUE_LAZY (val
) = 1;
309 /* Called only from the VALUE_CONTENTS macro, if the current data for
310 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
311 data from the user's process, and clears the lazy flag to indicate
312 that the data in the buffer is valid.
314 If the value is zero-length, we avoid calling read_memory, which would
315 abort. We mark the value as fetched anyway -- all 0 bytes of it.
317 This function returns a value because it is used in the VALUE_CONTENTS
318 macro as part of an expression, where a void would not work. The
322 value_fetch_lazy (val
)
323 register value_ptr val
;
325 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
327 if (TYPE_LENGTH (VALUE_TYPE (val
)))
328 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
329 TYPE_LENGTH (VALUE_TYPE (val
)));
330 VALUE_LAZY (val
) = 0;
335 /* Store the contents of FROMVAL into the location of TOVAL.
336 Return a new value with the location of TOVAL and contents of FROMVAL. */
339 value_assign (toval
, fromval
)
340 register value_ptr toval
, fromval
;
342 register struct type
*type
;
343 register value_ptr val
;
344 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
347 if (!toval
->modifiable
)
348 error ("Left operand of assignment is not a modifiable lvalue.");
350 COERCE_ARRAY (fromval
);
353 type
= VALUE_TYPE (toval
);
354 if (VALUE_LVAL (toval
) != lval_internalvar
)
355 fromval
= value_cast (type
, fromval
);
357 /* If TOVAL is a special machine register requiring conversion
358 of program values to a special raw format,
359 convert FROMVAL's contents now, with result in `raw_buffer',
360 and set USE_BUFFER to the number of bytes to write. */
362 #ifdef REGISTER_CONVERTIBLE
363 if (VALUE_REGNO (toval
) >= 0
364 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
366 int regno
= VALUE_REGNO (toval
);
367 if (REGISTER_CONVERTIBLE (regno
))
369 REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval
), regno
,
370 VALUE_CONTENTS (fromval
), raw_buffer
);
371 use_buffer
= REGISTER_RAW_SIZE (regno
);
376 switch (VALUE_LVAL (toval
))
378 case lval_internalvar
:
379 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
382 case lval_internalvar_component
:
383 set_internalvar_component (VALUE_INTERNALVAR (toval
),
384 VALUE_OFFSET (toval
),
385 VALUE_BITPOS (toval
),
386 VALUE_BITSIZE (toval
),
391 if (VALUE_BITSIZE (toval
))
393 char buffer
[sizeof (LONGEST
)];
394 /* We assume that the argument to read_memory is in units of
395 host chars. FIXME: Is that correct? */
396 int len
= (VALUE_BITPOS (toval
)
397 + VALUE_BITSIZE (toval
)
401 if (len
> sizeof (LONGEST
))
402 error ("Can't handle bitfields which don't fit in a %d bit word.",
403 sizeof (LONGEST
) * HOST_CHAR_BIT
);
405 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
407 modify_field (buffer
, value_as_long (fromval
),
408 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
409 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
413 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
414 raw_buffer
, use_buffer
);
416 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
417 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
421 if (VALUE_BITSIZE (toval
))
423 char buffer
[sizeof (LONGEST
)];
424 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
426 if (len
> sizeof (LONGEST
))
427 error ("Can't handle bitfields in registers larger than %d bits.",
428 sizeof (LONGEST
) * HOST_CHAR_BIT
);
430 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
431 > len
* HOST_CHAR_BIT
)
432 /* Getting this right would involve being very careful about
435 Can't handle bitfield which doesn't fit in a single register.");
437 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
439 modify_field (buffer
, value_as_long (fromval
),
440 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
441 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
445 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
446 raw_buffer
, use_buffer
);
449 /* Do any conversion necessary when storing this type to more
450 than one register. */
451 #ifdef REGISTER_CONVERT_FROM_TYPE
452 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
453 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
454 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
455 raw_buffer
, TYPE_LENGTH (type
));
457 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
458 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
461 /* Assigning to the stack pointer, frame pointer, and other
462 (architecture and calling convention specific) registers may
463 cause the frame cache to be out of date. We just do this
464 on all assignments to registers for simplicity; I doubt the slowdown
466 reinit_frame_cache ();
469 case lval_reg_frame_relative
:
471 /* value is stored in a series of registers in the frame
472 specified by the structure. Copy that value out, modify
473 it, and copy it back in. */
474 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
475 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
476 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
477 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
480 /* Make the buffer large enough in all cases. */
481 char *buffer
= (char *) alloca (amount_to_copy
483 + MAX_REGISTER_RAW_SIZE
);
486 struct frame_info
*frame
;
488 /* Figure out which frame this is in currently. */
489 for (frame
= get_current_frame ();
490 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
491 frame
= get_prev_frame (frame
))
495 error ("Value being assigned to is no longer active.");
497 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
500 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
502 amount_copied
< amount_to_copy
;
503 amount_copied
+= reg_size
, regno
++)
505 get_saved_register (buffer
+ amount_copied
,
506 (int *)NULL
, (CORE_ADDR
*)NULL
,
507 frame
, regno
, (enum lval_type
*)NULL
);
510 /* Modify what needs to be modified. */
511 if (VALUE_BITSIZE (toval
))
512 modify_field (buffer
+ byte_offset
,
513 value_as_long (fromval
),
514 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
516 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
518 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
522 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
524 amount_copied
< amount_to_copy
;
525 amount_copied
+= reg_size
, regno
++)
531 /* Just find out where to put it. */
532 get_saved_register ((char *)NULL
,
533 &optim
, &addr
, frame
, regno
, &lval
);
536 error ("Attempt to assign to a value that was optimized out.");
537 if (lval
== lval_memory
)
538 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
539 else if (lval
== lval_register
)
540 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
542 error ("Attempt to assign to an unmodifiable value.");
549 error ("Left operand of assignment is not an lvalue.");
552 /* Return a value just like TOVAL except with the contents of FROMVAL
553 (except in the case of the type if TOVAL is an internalvar). */
555 if (VALUE_LVAL (toval
) == lval_internalvar
556 || VALUE_LVAL (toval
) == lval_internalvar_component
)
558 type
= VALUE_TYPE (fromval
);
561 val
= allocate_value (type
);
562 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
563 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
565 VALUE_TYPE (val
) = type
;
570 /* Extend a value VAL to COUNT repetitions of its type. */
573 value_repeat (arg1
, count
)
577 register value_ptr val
;
579 if (VALUE_LVAL (arg1
) != lval_memory
)
580 error ("Only values in memory can be extended with '@'.");
582 error ("Invalid number %d of repetitions.", count
);
584 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
586 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
587 VALUE_CONTENTS_RAW (val
),
588 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
589 VALUE_LVAL (val
) = lval_memory
;
590 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
596 value_of_variable (var
, b
)
601 struct frame_info
*frame
;
604 /* Use selected frame. */
608 frame
= block_innermost_frame (b
);
609 if (frame
== NULL
&& symbol_read_needs_frame (var
))
611 if (BLOCK_FUNCTION (b
) != NULL
612 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
613 error ("No frame is currently executing in block %s.",
614 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
616 error ("No frame is currently executing in specified block");
619 val
= read_var_value (var
, frame
);
621 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
625 /* Given a value which is an array, return a value which is a pointer to its
626 first element, regardless of whether or not the array has a nonzero lower
629 FIXME: A previous comment here indicated that this routine should be
630 substracting the array's lower bound. It's not clear to me that this
631 is correct. Given an array subscripting operation, it would certainly
632 work to do the adjustment here, essentially computing:
634 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
636 However I believe a more appropriate and logical place to account for
637 the lower bound is to do so in value_subscript, essentially computing:
639 (&array[0] + ((index - lowerbound) * sizeof array[0]))
641 As further evidence consider what would happen with operations other
642 than array subscripting, where the caller would get back a value that
643 had an address somewhere before the actual first element of the array,
644 and the information about the lower bound would be lost because of
645 the coercion to pointer type.
649 value_coerce_array (arg1
)
652 register struct type
*type
;
654 if (VALUE_LVAL (arg1
) != lval_memory
)
655 error ("Attempt to take address of value not located in memory.");
657 /* Get type of elements. */
658 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
659 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRING
)
660 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
662 /* A phony array made by value_repeat.
663 Its type is the type of the elements, not an array type. */
664 type
= VALUE_TYPE (arg1
);
666 return value_from_longest (lookup_pointer_type (type
),
667 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
670 /* Given a value which is a function, return a value which is a pointer
674 value_coerce_function (arg1
)
678 if (VALUE_LVAL (arg1
) != lval_memory
)
679 error ("Attempt to take address of value not located in memory.");
681 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
682 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
685 /* Return a pointer value for the object for which ARG1 is the contents. */
691 struct type
*type
= VALUE_TYPE (arg1
);
692 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
694 /* Copy the value, but change the type from (T&) to (T*).
695 We keep the same location information, which is efficient,
696 and allows &(&X) to get the location containing the reference. */
697 value_ptr arg2
= value_copy (arg1
);
698 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
701 if (current_language
->c_style_arrays
702 && (VALUE_REPEATED (arg1
)
703 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
))
704 return value_coerce_array (arg1
);
705 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
706 return value_coerce_function (arg1
);
708 if (VALUE_LVAL (arg1
) != lval_memory
)
709 error ("Attempt to take address of value not located in memory.");
711 return value_from_longest (lookup_pointer_type (type
),
712 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
715 /* Given a value of a pointer type, apply the C unary * operator to it. */
723 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
724 error ("not implemented: member types in value_ind");
726 /* Allow * on an integer so we can cast it to whatever we want.
727 This returns an int, which seems like the most C-like thing
728 to do. "long long" variables are rare enough that
729 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
730 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
731 return value_at (builtin_type_int
,
732 (CORE_ADDR
) value_as_long (arg1
));
733 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
734 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
735 value_as_pointer (arg1
));
736 error ("Attempt to take contents of a non-pointer value.");
737 return 0; /* For lint -- never reached */
740 /* Pushing small parts of stack frames. */
742 /* Push one word (the size of object that a register holds). */
747 unsigned LONGEST word
;
749 register int len
= REGISTER_SIZE
;
750 char buffer
[MAX_REGISTER_RAW_SIZE
];
752 store_unsigned_integer (buffer
, len
, word
);
755 write_memory (sp
, buffer
, len
);
756 #else /* stack grows upward */
757 write_memory (sp
, buffer
, len
);
759 #endif /* stack grows upward */
764 /* Push LEN bytes with data at BUFFER. */
767 push_bytes (sp
, buffer
, len
)
774 write_memory (sp
, buffer
, len
);
775 #else /* stack grows upward */
776 write_memory (sp
, buffer
, len
);
778 #endif /* stack grows upward */
783 /* Push onto the stack the specified value VALUE. */
787 register CORE_ADDR sp
;
790 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
794 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
795 #else /* stack grows upward */
796 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
798 #endif /* stack grows upward */
803 /* Perform the standard coercions that are specified
804 for arguments to be passed to C functions.
806 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
809 value_arg_coerce (arg
, param_type
)
811 struct type
*param_type
;
813 register struct type
*type
= param_type
? param_type
: VALUE_TYPE (arg
);
815 switch (TYPE_CODE (type
))
818 if (TYPE_CODE (SYMBOL_TYPE (arg
)) != TYPE_CODE_REF
)
820 arg
= value_addr (arg
);
821 VALUE_TYPE (arg
) = param_type
;
829 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
830 type
= builtin_type_int
;
833 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
834 type
= builtin_type_double
;
837 type
= lookup_pointer_type (type
);
841 #if 1 /* FIXME: This is only a temporary patch. -fnf */
842 if (current_language
->c_style_arrays
843 && (VALUE_REPEATED (arg
)
844 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
))
845 arg
= value_coerce_array (arg
);
848 return value_cast (type
, arg
);
851 /* Determine a function's address and its return type from its value.
852 Calls error() if the function is not valid for calling. */
855 find_function_addr (function
, retval_type
)
857 struct type
**retval_type
;
859 register struct type
*ftype
= VALUE_TYPE (function
);
860 register enum type_code code
= TYPE_CODE (ftype
);
861 struct type
*value_type
;
864 /* If it's a member function, just look at the function
867 /* Determine address to call. */
868 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
870 funaddr
= VALUE_ADDRESS (function
);
871 value_type
= TYPE_TARGET_TYPE (ftype
);
873 else if (code
== TYPE_CODE_PTR
)
875 funaddr
= value_as_pointer (function
);
876 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
877 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
879 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
880 /* FIXME: This is a workaround for the unusual function
881 pointer representation on the RS/6000, see comment
882 in config/rs6000/tm-rs6000.h */
883 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
885 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
888 value_type
= builtin_type_int
;
890 else if (code
== TYPE_CODE_INT
)
892 /* Handle the case of functions lacking debugging info.
893 Their values are characters since their addresses are char */
894 if (TYPE_LENGTH (ftype
) == 1)
895 funaddr
= value_as_pointer (value_addr (function
));
897 /* Handle integer used as address of a function. */
898 funaddr
= (CORE_ADDR
) value_as_long (function
);
900 value_type
= builtin_type_int
;
903 error ("Invalid data type for function to be called.");
905 *retval_type
= value_type
;
909 #if defined (CALL_DUMMY)
910 /* All this stuff with a dummy frame may seem unnecessarily complicated
911 (why not just save registers in GDB?). The purpose of pushing a dummy
912 frame which looks just like a real frame is so that if you call a
913 function and then hit a breakpoint (get a signal, etc), "backtrace"
914 will look right. Whether the backtrace needs to actually show the
915 stack at the time the inferior function was called is debatable, but
916 it certainly needs to not display garbage. So if you are contemplating
917 making dummy frames be different from normal frames, consider that. */
919 /* Perform a function call in the inferior.
920 ARGS is a vector of values of arguments (NARGS of them).
921 FUNCTION is a value, the function to be called.
922 Returns a value representing what the function returned.
923 May fail to return, if a breakpoint or signal is hit
924 during the execution of the function.
926 ARGS is modified to contain coerced values. */
929 call_function_by_hand (function
, nargs
, args
)
934 register CORE_ADDR sp
;
937 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
938 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
939 and remove any extra bytes which might exist because unsigned LONGEST is
940 bigger than REGISTER_SIZE. */
941 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
942 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
944 struct type
*value_type
;
945 unsigned char struct_return
;
946 CORE_ADDR struct_addr
;
947 struct inferior_status inf_status
;
948 struct cleanup
*old_chain
;
952 struct type
*ftype
= SYMBOL_TYPE (function
);
954 if (!target_has_execution
)
957 save_inferior_status (&inf_status
, 1);
958 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
960 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
961 (and POP_FRAME for restoring them). (At least on most machines)
962 they are saved on the stack in the inferior. */
965 old_sp
= sp
= read_sp ();
967 #if 1 INNER_THAN 2 /* Stack grows down */
970 #else /* Stack grows up */
975 funaddr
= find_function_addr (function
, &value_type
);
978 struct block
*b
= block_for_pc (funaddr
);
979 /* If compiled without -g, assume GCC. */
980 using_gcc
= b
== NULL
|| BLOCK_GCC_COMPILED (b
);
983 /* Are we returning a value using a structure return or a normal
986 struct_return
= using_struct_return (function
, funaddr
, value_type
,
989 /* Create a call sequence customized for this function
990 and the number of arguments for it. */
991 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
992 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
994 (unsigned LONGEST
)dummy
[i
]);
996 #ifdef GDB_TARGET_IS_HPPA
997 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
998 value_type
, using_gcc
);
1000 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1001 value_type
, using_gcc
);
1005 #if CALL_DUMMY_LOCATION == ON_STACK
1006 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1007 #endif /* On stack. */
1009 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1010 /* Convex Unix prohibits executing in the stack segment. */
1011 /* Hope there is empty room at the top of the text segment. */
1013 extern CORE_ADDR text_end
;
1016 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1017 if (read_memory_integer (start_sp
, 1) != 0)
1018 error ("text segment full -- no place to put call");
1021 real_pc
= text_end
- sizeof dummy1
;
1022 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1024 #endif /* Before text_end. */
1026 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1028 extern CORE_ADDR text_end
;
1032 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1034 error ("Cannot write text segment -- call_function failed");
1036 #endif /* After text_end. */
1038 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1040 #endif /* At entry point. */
1043 sp
= old_sp
; /* It really is used, for some ifdef's... */
1046 for (i
= nargs
- 1; i
>= 0; i
--)
1048 struct type
*param_type
;
1049 if (TYPE_NFIELDS (ftype
) > i
)
1050 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1053 args
[i
] = value_arg_coerce (args
[i
], param_type
);
1057 /* If stack grows down, we must leave a hole at the top. */
1061 /* Reserve space for the return structure to be written on the
1062 stack, if necessary */
1065 len
+= TYPE_LENGTH (value_type
);
1067 for (i
= nargs
- 1; i
>= 0; i
--)
1068 len
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1069 #ifdef CALL_DUMMY_STACK_ADJUST
1070 len
+= CALL_DUMMY_STACK_ADJUST
;
1073 sp
-= STACK_ALIGN (len
) - len
;
1075 sp
+= STACK_ALIGN (len
) - len
;
1078 #endif /* STACK_ALIGN */
1080 /* Reserve space for the return structure to be written on the
1081 stack, if necessary */
1086 sp
-= TYPE_LENGTH (value_type
);
1090 sp
+= TYPE_LENGTH (value_type
);
1094 #if defined (REG_STRUCT_HAS_ADDR)
1096 /* This is a machine like the sparc, where we may need to pass a pointer
1097 to the structure, not the structure itself. */
1098 for (i
= nargs
- 1; i
>= 0; i
--)
1099 if (TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
1100 && REG_STRUCT_HAS_ADDR (using_gcc
, VALUE_TYPE (args
[i
])))
1103 #if !(1 INNER_THAN 2)
1104 /* The stack grows up, so the address of the thing we push
1105 is the stack pointer before we push it. */
1108 /* Push the structure. */
1109 sp
= value_push (sp
, args
[i
]);
1111 /* The stack grows down, so the address of the thing we push
1112 is the stack pointer after we push it. */
1115 /* The value we're going to pass is the address of the thing
1117 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1121 #endif /* REG_STRUCT_HAS_ADDR. */
1123 #ifdef PUSH_ARGUMENTS
1124 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1125 #else /* !PUSH_ARGUMENTS */
1126 for (i
= nargs
- 1; i
>= 0; i
--)
1127 sp
= value_push (sp
, args
[i
]);
1128 #endif /* !PUSH_ARGUMENTS */
1130 #ifdef CALL_DUMMY_STACK_ADJUST
1132 sp
-= CALL_DUMMY_STACK_ADJUST
;
1134 sp
+= CALL_DUMMY_STACK_ADJUST
;
1136 #endif /* CALL_DUMMY_STACK_ADJUST */
1138 /* Store the address at which the structure is supposed to be
1139 written. Note that this (and the code which reserved the space
1140 above) assumes that gcc was used to compile this function. Since
1141 it doesn't cost us anything but space and if the function is pcc
1142 it will ignore this value, we will make that assumption.
1144 Also note that on some machines (like the sparc) pcc uses a
1145 convention like gcc's. */
1148 STORE_STRUCT_RETURN (struct_addr
, sp
);
1150 /* Write the stack pointer. This is here because the statements above
1151 might fool with it. On SPARC, this write also stores the register
1152 window into the right place in the new stack frame, which otherwise
1153 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1157 char retbuf
[REGISTER_BYTES
];
1159 struct symbol
*symbol
;
1162 symbol
= find_pc_function (funaddr
);
1165 name
= SYMBOL_SOURCE_NAME (symbol
);
1169 /* Try the minimal symbols. */
1170 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1174 name
= SYMBOL_SOURCE_NAME (msymbol
);
1180 sprintf (format
, "at %s", local_hex_format ());
1182 /* FIXME-32x64: assumes funaddr fits in a long. */
1183 sprintf (name
, format
, (unsigned long) funaddr
);
1186 /* Execute the stack dummy routine, calling FUNCTION.
1187 When it is done, discard the empty frame
1188 after storing the contents of all regs into retbuf. */
1189 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1191 /* We stopped somewhere besides the call dummy. */
1193 /* If we did the cleanups, we would print a spurious error message
1194 (Unable to restore previously selected frame), would write the
1195 registers from the inf_status (which is wrong), and would do other
1196 wrong things (like set stop_bpstat to the wrong thing). */
1197 discard_cleanups (old_chain
);
1198 /* Prevent memory leak. */
1199 bpstat_clear (&inf_status
.stop_bpstat
);
1201 /* The following error message used to say "The expression
1202 which contained the function call has been discarded." It
1203 is a hard concept to explain in a few words. Ideally, GDB
1204 would be able to resume evaluation of the expression when
1205 the function finally is done executing. Perhaps someday
1206 this will be implemented (it would not be easy). */
1208 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1209 a C++ name with arguments and stuff. */
1211 The program being debugged stopped while in a function called from GDB.\n\
1212 When the function (%s) is done executing, GDB will silently\n\
1213 stop (instead of continuing to evaluate the expression containing\n\
1214 the function call).", name
);
1217 do_cleanups (old_chain
);
1219 /* Figure out the value returned by the function. */
1220 return value_being_returned (value_type
, retbuf
, struct_return
);
1223 #else /* no CALL_DUMMY. */
1225 call_function_by_hand (function
, nargs
, args
)
1230 error ("Cannot invoke functions on this machine.");
1232 #endif /* no CALL_DUMMY. */
1235 /* Create a value for an array by allocating space in the inferior, copying
1236 the data into that space, and then setting up an array value.
1238 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1239 populated from the values passed in ELEMVEC.
1241 The element type of the array is inherited from the type of the
1242 first element, and all elements must have the same size (though we
1243 don't currently enforce any restriction on their types). */
1246 value_array (lowbound
, highbound
, elemvec
)
1255 struct type
*rangetype
;
1256 struct type
*arraytype
;
1259 /* Validate that the bounds are reasonable and that each of the elements
1260 have the same size. */
1262 nelem
= highbound
- lowbound
+ 1;
1265 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1267 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1268 for (idx
= 0; idx
< nelem
; idx
++)
1270 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1272 error ("array elements must all be the same size");
1276 /* Allocate space to store the array in the inferior, and then initialize
1277 it by copying in each element. FIXME: Is it worth it to create a
1278 local buffer in which to collect each value and then write all the
1279 bytes in one operation? */
1281 addr
= allocate_space_in_inferior (nelem
* typelength
);
1282 for (idx
= 0; idx
< nelem
; idx
++)
1284 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1288 /* Create the array type and set up an array value to be evaluated lazily. */
1290 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1291 lowbound
, highbound
);
1292 arraytype
= create_array_type ((struct type
*) NULL
,
1293 VALUE_TYPE (elemvec
[0]), rangetype
);
1294 val
= value_at_lazy (arraytype
, addr
);
1298 /* Create a value for a string constant by allocating space in the inferior,
1299 copying the data into that space, and returning the address with type
1300 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1302 Note that string types are like array of char types with a lower bound of
1303 zero and an upper bound of LEN - 1. Also note that the string may contain
1304 embedded null bytes. */
1307 value_string (ptr
, len
)
1312 int lowbound
= current_language
->string_lower_bound
;
1313 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1315 lowbound
, len
+ lowbound
- 1);
1316 struct type
*stringtype
1317 = create_string_type ((struct type
*) NULL
, rangetype
);
1320 if (current_language
->c_style_arrays
== 0)
1322 val
= allocate_value (stringtype
);
1323 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1328 /* Allocate space to store the string in the inferior, and then
1329 copy LEN bytes from PTR in gdb to that address in the inferior. */
1331 addr
= allocate_space_in_inferior (len
);
1332 write_memory (addr
, ptr
, len
);
1334 val
= value_at_lazy (stringtype
, addr
);
1339 value_bitstring (ptr
, len
)
1344 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1346 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1347 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1348 val
= allocate_value (type
);
1349 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
) / TARGET_CHAR_BIT
);
1353 /* See if we can pass arguments in T2 to a function which takes arguments
1354 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1355 arguments need coercion of some sort, then the coerced values are written
1356 into T2. Return value is 0 if the arguments could be matched, or the
1357 position at which they differ if not.
1359 STATICP is nonzero if the T1 argument list came from a
1360 static member function.
1362 For non-static member functions, we ignore the first argument,
1363 which is the type of the instance variable. This is because we want
1364 to handle calls with objects from derived classes. This is not
1365 entirely correct: we should actually check to make sure that a
1366 requested operation is type secure, shouldn't we? FIXME. */
1369 typecmp (staticp
, t1
, t2
)
1378 if (staticp
&& t1
== 0)
1382 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1383 if (t1
[!staticp
] == 0) return 0;
1384 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1386 struct type
*tt1
, *tt2
;
1390 tt2
= VALUE_TYPE(t2
[i
]);
1391 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1392 /* We should be doing hairy argument matching, as below. */
1393 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1395 t2
[i
] = value_addr (t2
[i
]);
1399 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1400 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1402 tt1
= TYPE_TARGET_TYPE(tt1
);
1403 tt2
= TYPE_TARGET_TYPE(tt2
);
1405 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1406 /* Array to pointer is a `trivial conversion' according to the ARM. */
1408 /* We should be doing much hairier argument matching (see section 13.2
1409 of the ARM), but as a quick kludge, just check for the same type
1411 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1414 if (!t1
[i
]) return 0;
1415 return t2
[i
] ? i
+1 : 0;
1418 /* Helper function used by value_struct_elt to recurse through baseclasses.
1419 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1420 and search in it assuming it has (class) type TYPE.
1421 If found, return value, else return NULL.
1423 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1424 look for a baseclass named NAME. */
1427 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1429 register value_ptr arg1
;
1431 register struct type
*type
;
1432 int looking_for_baseclass
;
1436 check_stub_type (type
);
1438 if (! looking_for_baseclass
)
1439 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1441 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1443 if (t_field_name
&& STREQ (t_field_name
, name
))
1446 if (TYPE_FIELD_STATIC (type
, i
))
1448 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1449 struct symbol
*sym
=
1450 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1452 error ("Internal error: could not find physical static variable named %s",
1454 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1455 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1458 v
= value_primitive_field (arg1
, offset
, i
, type
);
1460 error("there is no field named %s", name
);
1463 if (t_field_name
&& t_field_name
[0] == '\0'
1464 && TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
1466 /* Look for a match through the fields of an anonymous union. */
1468 v
= search_struct_field (name
, arg1
, offset
,
1469 TYPE_FIELD_TYPE (type
, i
),
1470 looking_for_baseclass
);
1476 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1479 /* If we are looking for baseclasses, this is what we get when we
1480 hit them. But it could happen that the base part's member name
1481 is not yet filled in. */
1482 int found_baseclass
= (looking_for_baseclass
1483 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1484 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1486 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1489 /* Fix to use baseclass_offset instead. FIXME */
1490 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1493 error ("virtual baseclass botch");
1494 if (found_baseclass
)
1496 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1497 looking_for_baseclass
);
1499 else if (found_baseclass
)
1500 v
= value_primitive_field (arg1
, offset
, i
, type
);
1502 v
= search_struct_field (name
, arg1
,
1503 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1504 TYPE_BASECLASS (type
, i
),
1505 looking_for_baseclass
);
1511 /* Helper function used by value_struct_elt to recurse through baseclasses.
1512 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1513 and search in it assuming it has (class) type TYPE.
1514 If found, return value, else if name matched and args not return (value)-1,
1515 else return NULL. */
1518 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1520 register value_ptr
*arg1p
, *args
;
1521 int offset
, *static_memfuncp
;
1522 register struct type
*type
;
1526 int name_matched
= 0;
1527 char dem_opname
[64];
1529 check_stub_type (type
);
1530 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1532 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1533 if (strncmp(t_field_name
, "__", 2)==0 ||
1534 strncmp(t_field_name
, "op", 2)==0 ||
1535 strncmp(t_field_name
, "type", 4)==0 )
1537 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1538 t_field_name
= dem_opname
;
1539 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1540 t_field_name
= dem_opname
;
1542 if (t_field_name
&& STREQ (t_field_name
, name
))
1544 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1545 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1548 if (j
> 0 && args
== 0)
1549 error ("cannot resolve overloaded method `%s'", name
);
1552 if (TYPE_FN_FIELD_STUB (f
, j
))
1553 check_stub_method (type
, i
, j
);
1554 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1555 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1557 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1558 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1559 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1560 *static_memfuncp
= 1;
1561 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1562 if (v
!= NULL
) return v
;
1569 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1573 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1575 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1576 if (base_offset
== -1)
1577 error ("virtual baseclass botch");
1581 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1583 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1584 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1585 if (v
== (value_ptr
) -1)
1591 /* FIXME-bothner: Why is this commented out? Why is it here? */
1592 /* *arg1p = arg1_tmp;*/
1596 if (name_matched
) return (value_ptr
) -1;
1600 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1601 extract the component named NAME from the ultimate target structure/union
1602 and return it as a value with its appropriate type.
1603 ERR is used in the error message if *ARGP's type is wrong.
1605 C++: ARGS is a list of argument types to aid in the selection of
1606 an appropriate method. Also, handle derived types.
1608 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1609 where the truthvalue of whether the function that was resolved was
1610 a static member function or not is stored.
1612 ERR is an error message to be printed in case the field is not found. */
1615 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1616 register value_ptr
*argp
, *args
;
1618 int *static_memfuncp
;
1621 register struct type
*t
;
1624 COERCE_ARRAY (*argp
);
1626 t
= VALUE_TYPE (*argp
);
1628 /* Follow pointers until we get to a non-pointer. */
1630 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1632 *argp
= value_ind (*argp
);
1633 /* Don't coerce fn pointer to fn and then back again! */
1634 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1635 COERCE_ARRAY (*argp
);
1636 t
= VALUE_TYPE (*argp
);
1639 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1640 error ("not implemented: member type in value_struct_elt");
1642 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1643 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1644 error ("Attempt to extract a component of a value that is not a %s.", err
);
1646 /* Assume it's not, unless we see that it is. */
1647 if (static_memfuncp
)
1648 *static_memfuncp
=0;
1652 /* if there are no arguments ...do this... */
1654 /* Try as a field first, because if we succeed, there
1655 is less work to be done. */
1656 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1660 /* C++: If it was not found as a data field, then try to
1661 return it as a pointer to a method. */
1663 if (destructor_name_p (name
, t
))
1664 error ("Cannot get value of destructor");
1666 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1668 if (v
== (value_ptr
) -1)
1669 error ("Cannot take address of a method");
1672 if (TYPE_NFN_FIELDS (t
))
1673 error ("There is no member or method named %s.", name
);
1675 error ("There is no member named %s.", name
);
1680 if (destructor_name_p (name
, t
))
1684 /* destructors are a special case. */
1685 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1686 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1687 if (!v
) error("could not find destructor function named %s.", name
);
1692 error ("destructor should not have any argument");
1696 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1698 if (v
== (value_ptr
) -1)
1700 error("Argument list of %s mismatch with component in the structure.", name
);
1704 /* See if user tried to invoke data as function. If so,
1705 hand it back. If it's not callable (i.e., a pointer to function),
1706 gdb should give an error. */
1707 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1711 error ("Structure has no component named %s.", name
);
1715 /* C++: return 1 is NAME is a legitimate name for the destructor
1716 of type TYPE. If TYPE does not have a destructor, or
1717 if NAME is inappropriate for TYPE, an error is signaled. */
1719 destructor_name_p (name
, type
)
1721 const struct type
*type
;
1723 /* destructors are a special case. */
1727 char *dname
= type_name_no_tag (type
);
1728 char *cp
= strchr (dname
, '<');
1731 /* Do not compare the template part for template classes. */
1733 len
= strlen (dname
);
1736 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
1737 error ("name of destructor must equal name of class");
1744 /* Helper function for check_field: Given TYPE, a structure/union,
1745 return 1 if the component named NAME from the ultimate
1746 target structure/union is defined, otherwise, return 0. */
1749 check_field_in (type
, name
)
1750 register struct type
*type
;
1755 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1757 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1758 if (t_field_name
&& STREQ (t_field_name
, name
))
1762 /* C++: If it was not found as a data field, then try to
1763 return it as a pointer to a method. */
1765 /* Destructors are a special case. */
1766 if (destructor_name_p (name
, type
))
1769 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1771 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1775 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1776 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1783 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1784 return 1 if the component named NAME from the ultimate
1785 target structure/union is defined, otherwise, return 0. */
1788 check_field (arg1
, name
)
1789 register value_ptr arg1
;
1792 register struct type
*t
;
1794 COERCE_ARRAY (arg1
);
1796 t
= VALUE_TYPE (arg1
);
1798 /* Follow pointers until we get to a non-pointer. */
1800 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1801 t
= TYPE_TARGET_TYPE (t
);
1803 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1804 error ("not implemented: member type in check_field");
1806 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1807 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1808 error ("Internal error: `this' is not an aggregate");
1810 return check_field_in (t
, name
);
1813 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1814 return the address of this member as a "pointer to member"
1815 type. If INTYPE is non-null, then it will be the type
1816 of the member we are looking for. This will help us resolve
1817 "pointers to member functions". This function is used
1818 to resolve user expressions of the form "DOMAIN::NAME". */
1821 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1822 struct type
*domain
, *curtype
, *intype
;
1826 register struct type
*t
= curtype
;
1830 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1831 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1832 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1834 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1836 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1838 if (t_field_name
&& STREQ (t_field_name
, name
))
1840 if (TYPE_FIELD_STATIC (t
, i
))
1842 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1843 struct symbol
*sym
=
1844 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1846 error ("Internal error: could not find physical static variable named %s",
1848 return value_at (SYMBOL_TYPE (sym
),
1849 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1851 if (TYPE_FIELD_PACKED (t
, i
))
1852 error ("pointers to bitfield members not allowed");
1854 return value_from_longest
1855 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1857 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1861 /* C++: If it was not found as a data field, then try to
1862 return it as a pointer to a method. */
1864 /* Destructors are a special case. */
1865 if (destructor_name_p (name
, t
))
1867 error ("member pointers to destructors not implemented yet");
1870 /* Perform all necessary dereferencing. */
1871 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1872 intype
= TYPE_TARGET_TYPE (intype
);
1874 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1876 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
1877 char dem_opname
[64];
1879 if (strncmp(t_field_name
, "__", 2)==0 ||
1880 strncmp(t_field_name
, "op", 2)==0 ||
1881 strncmp(t_field_name
, "type", 4)==0 )
1883 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1884 t_field_name
= dem_opname
;
1885 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1886 t_field_name
= dem_opname
;
1888 if (t_field_name
&& STREQ (t_field_name
, name
))
1890 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1891 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1893 if (intype
== 0 && j
> 1)
1894 error ("non-unique member `%s' requires type instantiation", name
);
1898 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1901 error ("no member function matches that type instantiation");
1906 if (TYPE_FN_FIELD_STUB (f
, j
))
1907 check_stub_method (t
, i
, j
);
1908 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1910 return value_from_longest
1911 (lookup_reference_type
1912 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1914 (LONGEST
) METHOD_PTR_FROM_VOFFSET
1915 (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1919 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1920 0, VAR_NAMESPACE
, 0, NULL
);
1927 v
= read_var_value (s
, 0);
1929 VALUE_TYPE (v
) = lookup_reference_type
1930 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1938 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1943 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1946 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1947 v
= value_struct_elt_for_reference (domain
,
1948 offset
+ base_offset
,
1949 TYPE_BASECLASS (t
, i
),
1958 /* C++: return the value of the class instance variable, if one exists.
1959 Flag COMPLAIN signals an error if the request is made in an
1960 inappropriate context. */
1963 value_of_this (complain
)
1966 struct symbol
*func
, *sym
;
1969 static const char funny_this
[] = "this";
1972 if (selected_frame
== 0)
1974 error ("no frame selected");
1977 func
= get_frame_function (selected_frame
);
1981 error ("no `this' in nameless context");
1985 b
= SYMBOL_BLOCK_VALUE (func
);
1986 i
= BLOCK_NSYMS (b
);
1989 error ("no args, no `this'");
1992 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
1993 symbol instead of the LOC_ARG one (if both exist). */
1994 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
1998 error ("current stack frame not in method");
2003 this = read_var_value (sym
, selected_frame
);
2004 if (this == 0 && complain
)
2005 error ("`this' argument at unknown address");
2009 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2010 long, starting at LOWBOUND. The result has the same lower bound as
2011 the original ARRAY. */
2014 value_slice (array
, lowbound
, length
)
2016 int lowbound
, length
;
2018 if (TYPE_CODE (VALUE_TYPE (array
)) == TYPE_CODE_BITSTRING
)
2019 error ("not implemented - bitstring slice");
2020 if (TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_ARRAY
2021 && TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_STRING
)
2022 error ("cannot take slice of non-array");
2025 struct type
*slice_range_type
, *slice_type
;
2027 struct type
*range_type
= TYPE_FIELD_TYPE (VALUE_TYPE (array
), 0);
2028 struct type
*element_type
= TYPE_TARGET_TYPE (VALUE_TYPE (array
));
2029 int lowerbound
= TYPE_LOW_BOUND (range_type
);
2030 int upperbound
= TYPE_HIGH_BOUND (range_type
);
2031 int offset
= (lowbound
- lowerbound
) * TYPE_LENGTH (element_type
);
2032 if (lowbound
< lowerbound
|| length
< 0
2033 || lowbound
+ length
- 1 > upperbound
)
2034 error ("slice out of range");
2035 slice_range_type
= create_range_type ((struct type
*) NULL
,
2036 TYPE_TARGET_TYPE (range_type
),
2038 lowerbound
+ length
- 1);
2039 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2041 TYPE_CODE (slice_type
) = TYPE_CODE (VALUE_TYPE (array
));
2042 slice
= allocate_value (slice_type
);
2043 if (VALUE_LAZY (array
))
2044 VALUE_LAZY (slice
) = 1;
2046 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2047 TYPE_LENGTH (slice_type
));
2048 if (VALUE_LVAL (array
) == lval_internalvar
)
2049 VALUE_LVAL (slice
) = lval_internalvar_component
;
2051 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2052 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2053 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2058 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2059 value as a fixed-length array. */
2062 varying_to_slice (varray
)
2065 struct type
*vtype
= VALUE_TYPE (varray
);
2066 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
2067 VALUE_CONTENTS (varray
)
2068 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
2069 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
2072 /* Create a value for a FORTRAN complex number. Currently most of
2073 the time values are coerced to COMPLEX*16 (i.e. a complex number
2074 composed of 2 doubles. This really should be a smarter routine
2075 that figures out precision inteligently as opposed to assuming
2076 doubles. FIXME: fmb */
2079 value_literal_complex (arg1
, arg2
, type
)
2084 register value_ptr val
;
2085 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2087 val
= allocate_value (type
);
2088 arg1
= value_cast (real_type
, arg1
);
2089 arg2
= value_cast (real_type
, arg2
);
2091 memcpy (VALUE_CONTENTS_RAW (val
),
2092 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2093 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2094 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2098 /* Cast a value into the appropriate complex data type. */
2101 cast_into_complex (type
, val
)
2103 register value_ptr val
;
2105 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2106 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2108 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2109 value_ptr re_val
= allocate_value (val_real_type
);
2110 value_ptr im_val
= allocate_value (val_real_type
);
2112 memcpy (VALUE_CONTENTS_RAW (re_val
),
2113 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2114 memcpy (VALUE_CONTENTS_RAW (im_val
),
2115 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2116 TYPE_LENGTH (val_real_type
));
2118 return value_literal_complex (re_val
, im_val
, type
);
2120 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2121 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2122 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2124 error ("cannot cast non-number to complex");