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
= TYPE_CODE (type
);
121 register enum type_code code2
;
124 if (VALUE_TYPE (arg2
) == type
)
129 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
130 is treated like a cast to (TYPE [N])OBJECT,
131 where N is sizeof(OBJECT)/sizeof(TYPE). */
132 if (code1
== TYPE_CODE_ARRAY
133 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
134 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
136 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
137 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
138 int low_bound
= TYPE_LOW_BOUND (range_type
);
139 int val_length
= TYPE_LENGTH (VALUE_TYPE (arg2
));
140 int new_length
= val_length
/ TYPE_LENGTH (element_type
);
141 if (val_length
% TYPE_LENGTH (element_type
) != 0)
142 warning("array element type size does not divide object size in cast");
143 /* FIXME-type-allocation: need a way to free this type when we are
145 range_type
= create_range_type ((struct type
*) NULL
,
146 TYPE_TARGET_TYPE (range_type
),
147 low_bound
, new_length
+ low_bound
- 1);
148 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
149 element_type
, range_type
);
153 if (current_language
->c_style_arrays
154 && (VALUE_REPEATED (arg2
)
155 || TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_ARRAY
))
156 arg2
= value_coerce_array (arg2
);
158 if (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_FUNC
)
159 arg2
= value_coerce_function (arg2
);
161 COERCE_VARYING_ARRAY (arg2
);
163 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
165 if (code1
== TYPE_CODE_COMPLEX
)
166 return cast_into_complex (type
, arg2
);
167 if (code1
== TYPE_CODE_BOOL
)
168 code1
= TYPE_CODE_INT
;
169 if (code2
== TYPE_CODE_BOOL
)
170 code2
= TYPE_CODE_INT
;
172 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
173 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
175 if ( code1
== TYPE_CODE_STRUCT
176 && code2
== TYPE_CODE_STRUCT
177 && TYPE_NAME (type
) != 0)
179 /* Look in the type of the source to see if it contains the
180 type of the target as a superclass. If so, we'll need to
181 offset the object in addition to changing its type. */
182 value_ptr v
= search_struct_field (type_name_no_tag (type
),
183 arg2
, 0, VALUE_TYPE (arg2
), 1);
186 VALUE_TYPE (v
) = type
;
190 if (code1
== TYPE_CODE_FLT
&& scalar
)
191 return value_from_double (type
, value_as_double (arg2
));
192 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
193 || code1
== TYPE_CODE_RANGE
)
194 && (scalar
|| code2
== TYPE_CODE_PTR
))
195 return value_from_longest (type
, value_as_long (arg2
));
196 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
198 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
200 /* Look in the type of the source to see if it contains the
201 type of the target as a superclass. If so, we'll need to
202 offset the pointer rather than just change its type. */
203 struct type
*t1
= TYPE_TARGET_TYPE (type
);
204 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
205 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
206 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
207 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
209 value_ptr v
= search_struct_field (type_name_no_tag (t1
),
210 value_ind (arg2
), 0, t2
, 1);
214 VALUE_TYPE (v
) = type
;
218 /* No superclass found, just fall through to change ptr type. */
220 VALUE_TYPE (arg2
) = type
;
223 else if (chill_varying_type (type
))
225 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
228 char *valaddr
, *valaddr_data
;
229 if (code2
== TYPE_CODE_BITSTRING
)
230 error ("not implemented: converting bitstring to varying type");
231 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
232 || (eltype1
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1)),
233 eltype2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
)),
234 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
235 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
236 error ("Invalid conversion to varying type");
237 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
238 range2
= TYPE_FIELD_TYPE (VALUE_TYPE (arg2
), 0);
239 count1
= TYPE_HIGH_BOUND (range1
) - TYPE_LOW_BOUND (range1
) + 1;
240 count2
= TYPE_HIGH_BOUND (range2
) - TYPE_LOW_BOUND (range2
) + 1;
242 error ("target varying type is too small");
243 val
= allocate_value (type
);
244 valaddr
= VALUE_CONTENTS_RAW (val
);
245 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
246 /* Set val's __var_length field to count2. */
247 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
249 /* Set the __var_data field to count2 elements copied from arg2. */
250 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
251 count2
* TYPE_LENGTH (eltype2
));
252 /* Zero the rest of the __var_data field of val. */
253 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
254 (count1
- count2
) * TYPE_LENGTH (eltype2
));
257 else if (VALUE_LVAL (arg2
) == lval_memory
)
259 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
261 else if (code1
== TYPE_CODE_VOID
)
263 return value_zero (builtin_type_void
, not_lval
);
267 error ("Invalid cast.");
272 /* Create a value of type TYPE that is zero, and return it. */
275 value_zero (type
, lv
)
279 register value_ptr val
= allocate_value (type
);
281 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
282 VALUE_LVAL (val
) = lv
;
287 /* Return a value with type TYPE located at ADDR.
289 Call value_at only if the data needs to be fetched immediately;
290 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
291 value_at_lazy instead. value_at_lazy simply records the address of
292 the data and sets the lazy-evaluation-required flag. The lazy flag
293 is tested in the VALUE_CONTENTS macro, which is used if and when
294 the contents are actually required. */
297 value_at (type
, addr
)
301 register value_ptr val
;
303 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
304 error ("Attempt to dereference a generic pointer.");
306 val
= allocate_value (type
);
308 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
310 VALUE_LVAL (val
) = lval_memory
;
311 VALUE_ADDRESS (val
) = addr
;
316 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
319 value_at_lazy (type
, addr
)
323 register value_ptr val
;
325 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
326 error ("Attempt to dereference a generic pointer.");
328 val
= allocate_value (type
);
330 VALUE_LVAL (val
) = lval_memory
;
331 VALUE_ADDRESS (val
) = addr
;
332 VALUE_LAZY (val
) = 1;
337 /* Called only from the VALUE_CONTENTS macro, if the current data for
338 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
339 data from the user's process, and clears the lazy flag to indicate
340 that the data in the buffer is valid.
342 If the value is zero-length, we avoid calling read_memory, which would
343 abort. We mark the value as fetched anyway -- all 0 bytes of it.
345 This function returns a value because it is used in the VALUE_CONTENTS
346 macro as part of an expression, where a void would not work. The
350 value_fetch_lazy (val
)
351 register value_ptr val
;
353 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
355 if (TYPE_LENGTH (VALUE_TYPE (val
)))
356 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
357 TYPE_LENGTH (VALUE_TYPE (val
)));
358 VALUE_LAZY (val
) = 0;
363 /* Store the contents of FROMVAL into the location of TOVAL.
364 Return a new value with the location of TOVAL and contents of FROMVAL. */
367 value_assign (toval
, fromval
)
368 register value_ptr toval
, fromval
;
370 register struct type
*type
;
371 register value_ptr val
;
372 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
375 if (!toval
->modifiable
)
376 error ("Left operand of assignment is not a modifiable lvalue.");
378 COERCE_ARRAY (fromval
);
381 type
= VALUE_TYPE (toval
);
382 if (VALUE_LVAL (toval
) != lval_internalvar
)
383 fromval
= value_cast (type
, fromval
);
385 /* If TOVAL is a special machine register requiring conversion
386 of program values to a special raw format,
387 convert FROMVAL's contents now, with result in `raw_buffer',
388 and set USE_BUFFER to the number of bytes to write. */
390 #ifdef REGISTER_CONVERTIBLE
391 if (VALUE_REGNO (toval
) >= 0
392 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
394 int regno
= VALUE_REGNO (toval
);
395 if (REGISTER_CONVERTIBLE (regno
))
397 REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval
), regno
,
398 VALUE_CONTENTS (fromval
), raw_buffer
);
399 use_buffer
= REGISTER_RAW_SIZE (regno
);
404 switch (VALUE_LVAL (toval
))
406 case lval_internalvar
:
407 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
410 case lval_internalvar_component
:
411 set_internalvar_component (VALUE_INTERNALVAR (toval
),
412 VALUE_OFFSET (toval
),
413 VALUE_BITPOS (toval
),
414 VALUE_BITSIZE (toval
),
419 if (VALUE_BITSIZE (toval
))
421 char buffer
[sizeof (LONGEST
)];
422 /* We assume that the argument to read_memory is in units of
423 host chars. FIXME: Is that correct? */
424 int len
= (VALUE_BITPOS (toval
)
425 + VALUE_BITSIZE (toval
)
429 if (len
> sizeof (LONGEST
))
430 error ("Can't handle bitfields which don't fit in a %d bit word.",
431 sizeof (LONGEST
) * HOST_CHAR_BIT
);
433 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
435 modify_field (buffer
, value_as_long (fromval
),
436 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
437 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
441 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
442 raw_buffer
, use_buffer
);
444 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
445 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
449 if (VALUE_BITSIZE (toval
))
451 char buffer
[sizeof (LONGEST
)];
452 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
454 if (len
> sizeof (LONGEST
))
455 error ("Can't handle bitfields in registers larger than %d bits.",
456 sizeof (LONGEST
) * HOST_CHAR_BIT
);
458 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
459 > len
* HOST_CHAR_BIT
)
460 /* Getting this right would involve being very careful about
463 Can't handle bitfield which doesn't fit in a single register.");
465 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
467 modify_field (buffer
, value_as_long (fromval
),
468 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
469 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
473 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
474 raw_buffer
, use_buffer
);
477 /* Do any conversion necessary when storing this type to more
478 than one register. */
479 #ifdef REGISTER_CONVERT_FROM_TYPE
480 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
481 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
482 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
483 raw_buffer
, TYPE_LENGTH (type
));
485 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
486 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
489 /* Assigning to the stack pointer, frame pointer, and other
490 (architecture and calling convention specific) registers may
491 cause the frame cache to be out of date. We just do this
492 on all assignments to registers for simplicity; I doubt the slowdown
494 reinit_frame_cache ();
497 case lval_reg_frame_relative
:
499 /* value is stored in a series of registers in the frame
500 specified by the structure. Copy that value out, modify
501 it, and copy it back in. */
502 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
503 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
504 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
505 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
508 /* Make the buffer large enough in all cases. */
509 char *buffer
= (char *) alloca (amount_to_copy
511 + MAX_REGISTER_RAW_SIZE
);
514 struct frame_info
*frame
;
516 /* Figure out which frame this is in currently. */
517 for (frame
= get_current_frame ();
518 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
519 frame
= get_prev_frame (frame
))
523 error ("Value being assigned to is no longer active.");
525 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
528 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
530 amount_copied
< amount_to_copy
;
531 amount_copied
+= reg_size
, regno
++)
533 get_saved_register (buffer
+ amount_copied
,
534 (int *)NULL
, (CORE_ADDR
*)NULL
,
535 frame
, regno
, (enum lval_type
*)NULL
);
538 /* Modify what needs to be modified. */
539 if (VALUE_BITSIZE (toval
))
540 modify_field (buffer
+ byte_offset
,
541 value_as_long (fromval
),
542 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
544 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
546 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
550 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
552 amount_copied
< amount_to_copy
;
553 amount_copied
+= reg_size
, regno
++)
559 /* Just find out where to put it. */
560 get_saved_register ((char *)NULL
,
561 &optim
, &addr
, frame
, regno
, &lval
);
564 error ("Attempt to assign to a value that was optimized out.");
565 if (lval
== lval_memory
)
566 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
567 else if (lval
== lval_register
)
568 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
570 error ("Attempt to assign to an unmodifiable value.");
577 error ("Left operand of assignment is not an lvalue.");
580 /* Return a value just like TOVAL except with the contents of FROMVAL
581 (except in the case of the type if TOVAL is an internalvar). */
583 if (VALUE_LVAL (toval
) == lval_internalvar
584 || VALUE_LVAL (toval
) == lval_internalvar_component
)
586 type
= VALUE_TYPE (fromval
);
589 val
= allocate_value (type
);
590 memcpy (val
, toval
, VALUE_CONTENTS_RAW (val
) - (char *) val
);
591 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
593 VALUE_TYPE (val
) = type
;
598 /* Extend a value VAL to COUNT repetitions of its type. */
601 value_repeat (arg1
, count
)
605 register value_ptr val
;
607 if (VALUE_LVAL (arg1
) != lval_memory
)
608 error ("Only values in memory can be extended with '@'.");
610 error ("Invalid number %d of repetitions.", count
);
612 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
614 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
615 VALUE_CONTENTS_RAW (val
),
616 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
617 VALUE_LVAL (val
) = lval_memory
;
618 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
624 value_of_variable (var
, b
)
629 struct frame_info
*frame
;
632 /* Use selected frame. */
636 frame
= block_innermost_frame (b
);
637 if (frame
== NULL
&& symbol_read_needs_frame (var
))
639 if (BLOCK_FUNCTION (b
) != NULL
640 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
641 error ("No frame is currently executing in block %s.",
642 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
644 error ("No frame is currently executing in specified block");
647 val
= read_var_value (var
, frame
);
649 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
653 /* Given a value which is an array, return a value which is a pointer to its
654 first element, regardless of whether or not the array has a nonzero lower
657 FIXME: A previous comment here indicated that this routine should be
658 substracting the array's lower bound. It's not clear to me that this
659 is correct. Given an array subscripting operation, it would certainly
660 work to do the adjustment here, essentially computing:
662 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
664 However I believe a more appropriate and logical place to account for
665 the lower bound is to do so in value_subscript, essentially computing:
667 (&array[0] + ((index - lowerbound) * sizeof array[0]))
669 As further evidence consider what would happen with operations other
670 than array subscripting, where the caller would get back a value that
671 had an address somewhere before the actual first element of the array,
672 and the information about the lower bound would be lost because of
673 the coercion to pointer type.
677 value_coerce_array (arg1
)
680 register struct type
*type
;
682 if (VALUE_LVAL (arg1
) != lval_memory
)
683 error ("Attempt to take address of value not located in memory.");
685 /* Get type of elements. */
686 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
687 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRING
)
688 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
690 /* A phony array made by value_repeat.
691 Its type is the type of the elements, not an array type. */
692 type
= VALUE_TYPE (arg1
);
694 return value_from_longest (lookup_pointer_type (type
),
695 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
698 /* Given a value which is a function, return a value which is a pointer
702 value_coerce_function (arg1
)
706 if (VALUE_LVAL (arg1
) != lval_memory
)
707 error ("Attempt to take address of value not located in memory.");
709 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
710 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
713 /* Return a pointer value for the object for which ARG1 is the contents. */
719 struct type
*type
= VALUE_TYPE (arg1
);
720 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
722 /* Copy the value, but change the type from (T&) to (T*).
723 We keep the same location information, which is efficient,
724 and allows &(&X) to get the location containing the reference. */
725 value_ptr arg2
= value_copy (arg1
);
726 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
729 if (current_language
->c_style_arrays
730 && (VALUE_REPEATED (arg1
)
731 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
))
732 return value_coerce_array (arg1
);
733 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
734 return value_coerce_function (arg1
);
736 if (VALUE_LVAL (arg1
) != lval_memory
)
737 error ("Attempt to take address of value not located in memory.");
739 return value_from_longest (lookup_pointer_type (type
),
740 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
743 /* Given a value of a pointer type, apply the C unary * operator to it. */
751 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
752 error ("not implemented: member types in value_ind");
754 /* Allow * on an integer so we can cast it to whatever we want.
755 This returns an int, which seems like the most C-like thing
756 to do. "long long" variables are rare enough that
757 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
758 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
759 return value_at (builtin_type_int
,
760 (CORE_ADDR
) value_as_long (arg1
));
761 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
762 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
763 value_as_pointer (arg1
));
764 error ("Attempt to take contents of a non-pointer value.");
765 return 0; /* For lint -- never reached */
768 /* Pushing small parts of stack frames. */
770 /* Push one word (the size of object that a register holds). */
775 unsigned LONGEST word
;
777 register int len
= REGISTER_SIZE
;
778 char buffer
[MAX_REGISTER_RAW_SIZE
];
780 store_unsigned_integer (buffer
, len
, word
);
783 write_memory (sp
, buffer
, len
);
784 #else /* stack grows upward */
785 write_memory (sp
, buffer
, len
);
787 #endif /* stack grows upward */
792 /* Push LEN bytes with data at BUFFER. */
795 push_bytes (sp
, buffer
, len
)
802 write_memory (sp
, buffer
, len
);
803 #else /* stack grows upward */
804 write_memory (sp
, buffer
, len
);
806 #endif /* stack grows upward */
811 /* Push onto the stack the specified value VALUE. */
815 register CORE_ADDR sp
;
818 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
822 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
823 #else /* stack grows upward */
824 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
826 #endif /* stack grows upward */
831 /* Perform the standard coercions that are specified
832 for arguments to be passed to C functions.
834 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
837 value_arg_coerce (arg
, param_type
)
839 struct type
*param_type
;
841 register struct type
*type
= param_type
? param_type
: VALUE_TYPE (arg
);
843 switch (TYPE_CODE (type
))
846 if (TYPE_CODE (VALUE_TYPE (arg
)) != TYPE_CODE_REF
)
848 arg
= value_addr (arg
);
849 VALUE_TYPE (arg
) = param_type
;
857 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
858 type
= builtin_type_int
;
861 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
862 type
= builtin_type_double
;
865 type
= lookup_pointer_type (type
);
869 #if 1 /* FIXME: This is only a temporary patch. -fnf */
870 if (current_language
->c_style_arrays
871 && (VALUE_REPEATED (arg
)
872 || TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
))
873 arg
= value_coerce_array (arg
);
876 return value_cast (type
, arg
);
879 /* Determine a function's address and its return type from its value.
880 Calls error() if the function is not valid for calling. */
883 find_function_addr (function
, retval_type
)
885 struct type
**retval_type
;
887 register struct type
*ftype
= VALUE_TYPE (function
);
888 register enum type_code code
= TYPE_CODE (ftype
);
889 struct type
*value_type
;
892 /* If it's a member function, just look at the function
895 /* Determine address to call. */
896 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
898 funaddr
= VALUE_ADDRESS (function
);
899 value_type
= TYPE_TARGET_TYPE (ftype
);
901 else if (code
== TYPE_CODE_PTR
)
903 funaddr
= value_as_pointer (function
);
904 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
905 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
907 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
908 /* FIXME: This is a workaround for the unusual function
909 pointer representation on the RS/6000, see comment
910 in config/rs6000/tm-rs6000.h */
911 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
913 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
916 value_type
= builtin_type_int
;
918 else if (code
== TYPE_CODE_INT
)
920 /* Handle the case of functions lacking debugging info.
921 Their values are characters since their addresses are char */
922 if (TYPE_LENGTH (ftype
) == 1)
923 funaddr
= value_as_pointer (value_addr (function
));
925 /* Handle integer used as address of a function. */
926 funaddr
= (CORE_ADDR
) value_as_long (function
);
928 value_type
= builtin_type_int
;
931 error ("Invalid data type for function to be called.");
933 *retval_type
= value_type
;
937 #if defined (CALL_DUMMY)
938 /* All this stuff with a dummy frame may seem unnecessarily complicated
939 (why not just save registers in GDB?). The purpose of pushing a dummy
940 frame which looks just like a real frame is so that if you call a
941 function and then hit a breakpoint (get a signal, etc), "backtrace"
942 will look right. Whether the backtrace needs to actually show the
943 stack at the time the inferior function was called is debatable, but
944 it certainly needs to not display garbage. So if you are contemplating
945 making dummy frames be different from normal frames, consider that. */
947 /* Perform a function call in the inferior.
948 ARGS is a vector of values of arguments (NARGS of them).
949 FUNCTION is a value, the function to be called.
950 Returns a value representing what the function returned.
951 May fail to return, if a breakpoint or signal is hit
952 during the execution of the function.
954 ARGS is modified to contain coerced values. */
957 call_function_by_hand (function
, nargs
, args
)
962 register CORE_ADDR sp
;
965 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
966 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
967 and remove any extra bytes which might exist because unsigned LONGEST is
968 bigger than REGISTER_SIZE. */
969 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
970 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
972 struct type
*value_type
;
973 unsigned char struct_return
;
974 CORE_ADDR struct_addr
;
975 struct inferior_status inf_status
;
976 struct cleanup
*old_chain
;
980 struct type
*ftype
= SYMBOL_TYPE (function
);
982 if (!target_has_execution
)
985 save_inferior_status (&inf_status
, 1);
986 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
988 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
989 (and POP_FRAME for restoring them). (At least on most machines)
990 they are saved on the stack in the inferior. */
993 old_sp
= sp
= read_sp ();
995 #if 1 INNER_THAN 2 /* Stack grows down */
998 #else /* Stack grows up */
1000 sp
+= sizeof dummy1
;
1003 funaddr
= find_function_addr (function
, &value_type
);
1006 struct block
*b
= block_for_pc (funaddr
);
1007 /* If compiled without -g, assume GCC. */
1008 using_gcc
= b
== NULL
? 0 : BLOCK_GCC_COMPILED (b
);
1011 /* Are we returning a value using a structure return or a normal
1014 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1017 /* Create a call sequence customized for this function
1018 and the number of arguments for it. */
1019 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
1020 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1022 (unsigned LONGEST
)dummy
[i
]);
1024 #ifdef GDB_TARGET_IS_HPPA
1025 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1026 value_type
, using_gcc
);
1028 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1029 value_type
, using_gcc
);
1033 #if CALL_DUMMY_LOCATION == ON_STACK
1034 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1035 #endif /* On stack. */
1037 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1038 /* Convex Unix prohibits executing in the stack segment. */
1039 /* Hope there is empty room at the top of the text segment. */
1041 extern CORE_ADDR text_end
;
1044 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1045 if (read_memory_integer (start_sp
, 1) != 0)
1046 error ("text segment full -- no place to put call");
1049 real_pc
= text_end
- sizeof dummy1
;
1050 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1052 #endif /* Before text_end. */
1054 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1056 extern CORE_ADDR text_end
;
1060 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1062 error ("Cannot write text segment -- call_function failed");
1064 #endif /* After text_end. */
1066 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1068 #endif /* At entry point. */
1071 sp
= old_sp
; /* It really is used, for some ifdef's... */
1074 if (nargs
< TYPE_NFIELDS (ftype
))
1075 error ("too few arguments in function call");
1077 for (i
= nargs
- 1; i
>= 0; i
--)
1079 struct type
*param_type
;
1080 if (TYPE_NFIELDS (ftype
) > i
)
1081 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1084 args
[i
] = value_arg_coerce (args
[i
], param_type
);
1087 #if defined (REG_STRUCT_HAS_ADDR)
1089 /* This is a machine like the sparc, where we may need to pass a pointer
1090 to the structure, not the structure itself. */
1091 for (i
= nargs
- 1; i
>= 0; i
--)
1092 if ((TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
1093 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_UNION
1094 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_ARRAY
1095 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRING
)
1096 && REG_STRUCT_HAS_ADDR (using_gcc
, VALUE_TYPE (args
[i
])))
1099 int len
= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1101 int aligned_len
= STACK_ALIGN (len
);
1103 int aligned_len
= len
;
1105 #if !(1 INNER_THAN 2)
1106 /* The stack grows up, so the address of the thing we push
1107 is the stack pointer before we push it. */
1112 /* Push the structure. */
1113 write_memory (sp
, VALUE_CONTENTS (args
[i
]), len
);
1115 /* The stack grows down, so the address of the thing we push
1116 is the stack pointer after we push it. */
1121 /* The value we're going to pass is the address of the thing
1123 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1127 #endif /* REG_STRUCT_HAS_ADDR. */
1129 /* Reserve space for the return structure to be written on the
1130 stack, if necessary */
1134 int len
= TYPE_LENGTH (value_type
);
1136 len
= STACK_ALIGN (len
);
1148 /* If stack grows down, we must leave a hole at the top. */
1152 for (i
= nargs
- 1; i
>= 0; i
--)
1153 len
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1154 #ifdef CALL_DUMMY_STACK_ADJUST
1155 len
+= CALL_DUMMY_STACK_ADJUST
;
1158 sp
-= STACK_ALIGN (len
) - len
;
1160 sp
+= STACK_ALIGN (len
) - len
;
1163 #endif /* STACK_ALIGN */
1165 #ifdef PUSH_ARGUMENTS
1166 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1167 #else /* !PUSH_ARGUMENTS */
1168 for (i
= nargs
- 1; i
>= 0; i
--)
1169 sp
= value_push (sp
, args
[i
]);
1170 #endif /* !PUSH_ARGUMENTS */
1172 #ifdef CALL_DUMMY_STACK_ADJUST
1174 sp
-= CALL_DUMMY_STACK_ADJUST
;
1176 sp
+= CALL_DUMMY_STACK_ADJUST
;
1178 #endif /* CALL_DUMMY_STACK_ADJUST */
1180 /* Store the address at which the structure is supposed to be
1181 written. Note that this (and the code which reserved the space
1182 above) assumes that gcc was used to compile this function. Since
1183 it doesn't cost us anything but space and if the function is pcc
1184 it will ignore this value, we will make that assumption.
1186 Also note that on some machines (like the sparc) pcc uses a
1187 convention like gcc's. */
1190 STORE_STRUCT_RETURN (struct_addr
, sp
);
1192 /* Write the stack pointer. This is here because the statements above
1193 might fool with it. On SPARC, this write also stores the register
1194 window into the right place in the new stack frame, which otherwise
1195 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1199 char retbuf
[REGISTER_BYTES
];
1201 struct symbol
*symbol
;
1204 symbol
= find_pc_function (funaddr
);
1207 name
= SYMBOL_SOURCE_NAME (symbol
);
1211 /* Try the minimal symbols. */
1212 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1216 name
= SYMBOL_SOURCE_NAME (msymbol
);
1222 sprintf (format
, "at %s", local_hex_format ());
1224 /* FIXME-32x64: assumes funaddr fits in a long. */
1225 sprintf (name
, format
, (unsigned long) funaddr
);
1228 /* Execute the stack dummy routine, calling FUNCTION.
1229 When it is done, discard the empty frame
1230 after storing the contents of all regs into retbuf. */
1231 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1233 /* We stopped somewhere besides the call dummy. */
1235 /* If we did the cleanups, we would print a spurious error message
1236 (Unable to restore previously selected frame), would write the
1237 registers from the inf_status (which is wrong), and would do other
1238 wrong things (like set stop_bpstat to the wrong thing). */
1239 discard_cleanups (old_chain
);
1240 /* Prevent memory leak. */
1241 bpstat_clear (&inf_status
.stop_bpstat
);
1243 /* The following error message used to say "The expression
1244 which contained the function call has been discarded." It
1245 is a hard concept to explain in a few words. Ideally, GDB
1246 would be able to resume evaluation of the expression when
1247 the function finally is done executing. Perhaps someday
1248 this will be implemented (it would not be easy). */
1250 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1251 a C++ name with arguments and stuff. */
1253 The program being debugged stopped while in a function called from GDB.\n\
1254 When the function (%s) is done executing, GDB will silently\n\
1255 stop (instead of continuing to evaluate the expression containing\n\
1256 the function call).", name
);
1259 do_cleanups (old_chain
);
1261 /* Figure out the value returned by the function. */
1262 return value_being_returned (value_type
, retbuf
, struct_return
);
1265 #else /* no CALL_DUMMY. */
1267 call_function_by_hand (function
, nargs
, args
)
1272 error ("Cannot invoke functions on this machine.");
1274 #endif /* no CALL_DUMMY. */
1277 /* Create a value for an array by allocating space in the inferior, copying
1278 the data into that space, and then setting up an array value.
1280 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1281 populated from the values passed in ELEMVEC.
1283 The element type of the array is inherited from the type of the
1284 first element, and all elements must have the same size (though we
1285 don't currently enforce any restriction on their types). */
1288 value_array (lowbound
, highbound
, elemvec
)
1297 struct type
*rangetype
;
1298 struct type
*arraytype
;
1301 /* Validate that the bounds are reasonable and that each of the elements
1302 have the same size. */
1304 nelem
= highbound
- lowbound
+ 1;
1307 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1309 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1310 for (idx
= 0; idx
< nelem
; idx
++)
1312 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1314 error ("array elements must all be the same size");
1318 /* Allocate space to store the array in the inferior, and then initialize
1319 it by copying in each element. FIXME: Is it worth it to create a
1320 local buffer in which to collect each value and then write all the
1321 bytes in one operation? */
1323 addr
= allocate_space_in_inferior (nelem
* typelength
);
1324 for (idx
= 0; idx
< nelem
; idx
++)
1326 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1330 /* Create the array type and set up an array value to be evaluated lazily. */
1332 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1333 lowbound
, highbound
);
1334 arraytype
= create_array_type ((struct type
*) NULL
,
1335 VALUE_TYPE (elemvec
[0]), rangetype
);
1336 val
= value_at_lazy (arraytype
, addr
);
1340 /* Create a value for a string constant by allocating space in the inferior,
1341 copying the data into that space, and returning the address with type
1342 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1344 Note that string types are like array of char types with a lower bound of
1345 zero and an upper bound of LEN - 1. Also note that the string may contain
1346 embedded null bytes. */
1349 value_string (ptr
, len
)
1354 int lowbound
= current_language
->string_lower_bound
;
1355 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1357 lowbound
, len
+ lowbound
- 1);
1358 struct type
*stringtype
1359 = create_string_type ((struct type
*) NULL
, rangetype
);
1362 if (current_language
->c_style_arrays
== 0)
1364 val
= allocate_value (stringtype
);
1365 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1370 /* Allocate space to store the string in the inferior, and then
1371 copy LEN bytes from PTR in gdb to that address in the inferior. */
1373 addr
= allocate_space_in_inferior (len
);
1374 write_memory (addr
, ptr
, len
);
1376 val
= value_at_lazy (stringtype
, addr
);
1381 value_bitstring (ptr
, len
)
1386 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1388 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1389 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1390 val
= allocate_value (type
);
1391 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
) / TARGET_CHAR_BIT
);
1395 /* See if we can pass arguments in T2 to a function which takes arguments
1396 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1397 arguments need coercion of some sort, then the coerced values are written
1398 into T2. Return value is 0 if the arguments could be matched, or the
1399 position at which they differ if not.
1401 STATICP is nonzero if the T1 argument list came from a
1402 static member function.
1404 For non-static member functions, we ignore the first argument,
1405 which is the type of the instance variable. This is because we want
1406 to handle calls with objects from derived classes. This is not
1407 entirely correct: we should actually check to make sure that a
1408 requested operation is type secure, shouldn't we? FIXME. */
1411 typecmp (staticp
, t1
, t2
)
1420 if (staticp
&& t1
== 0)
1424 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1425 if (t1
[!staticp
] == 0) return 0;
1426 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1428 struct type
*tt1
, *tt2
;
1432 tt2
= VALUE_TYPE(t2
[i
]);
1433 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1434 /* We should be doing hairy argument matching, as below. */
1435 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1437 t2
[i
] = value_addr (t2
[i
]);
1441 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1442 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1444 tt1
= TYPE_TARGET_TYPE(tt1
);
1445 tt2
= TYPE_TARGET_TYPE(tt2
);
1447 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1448 /* Array to pointer is a `trivial conversion' according to the ARM. */
1450 /* We should be doing much hairier argument matching (see section 13.2
1451 of the ARM), but as a quick kludge, just check for the same type
1453 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1456 if (!t1
[i
]) return 0;
1457 return t2
[i
] ? i
+1 : 0;
1460 /* Helper function used by value_struct_elt to recurse through baseclasses.
1461 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1462 and search in it assuming it has (class) type TYPE.
1463 If found, return value, else return NULL.
1465 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1466 look for a baseclass named NAME. */
1469 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1471 register value_ptr arg1
;
1473 register struct type
*type
;
1474 int looking_for_baseclass
;
1478 check_stub_type (type
);
1480 if (! looking_for_baseclass
)
1481 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1483 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1485 if (t_field_name
&& STREQ (t_field_name
, name
))
1488 if (TYPE_FIELD_STATIC (type
, i
))
1490 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1491 struct symbol
*sym
=
1492 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1494 error ("Internal error: could not find physical static variable named %s",
1496 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1497 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1500 v
= value_primitive_field (arg1
, offset
, i
, type
);
1502 error("there is no field named %s", name
);
1505 if (t_field_name
&& t_field_name
[0] == '\0'
1506 && TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
1508 /* Look for a match through the fields of an anonymous union. */
1510 v
= search_struct_field (name
, arg1
, offset
,
1511 TYPE_FIELD_TYPE (type
, i
),
1512 looking_for_baseclass
);
1518 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1521 /* If we are looking for baseclasses, this is what we get when we
1522 hit them. But it could happen that the base part's member name
1523 is not yet filled in. */
1524 int found_baseclass
= (looking_for_baseclass
1525 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1526 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1528 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1531 /* Fix to use baseclass_offset instead. FIXME */
1532 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1535 error ("virtual baseclass botch");
1536 if (found_baseclass
)
1538 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1539 looking_for_baseclass
);
1541 else if (found_baseclass
)
1542 v
= value_primitive_field (arg1
, offset
, i
, type
);
1544 v
= search_struct_field (name
, arg1
,
1545 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1546 TYPE_BASECLASS (type
, i
),
1547 looking_for_baseclass
);
1553 /* Helper function used by value_struct_elt to recurse through baseclasses.
1554 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1555 and search in it assuming it has (class) type TYPE.
1556 If found, return value, else if name matched and args not return (value)-1,
1557 else return NULL. */
1560 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1562 register value_ptr
*arg1p
, *args
;
1563 int offset
, *static_memfuncp
;
1564 register struct type
*type
;
1568 int name_matched
= 0;
1569 char dem_opname
[64];
1571 check_stub_type (type
);
1572 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1574 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1575 if (strncmp(t_field_name
, "__", 2)==0 ||
1576 strncmp(t_field_name
, "op", 2)==0 ||
1577 strncmp(t_field_name
, "type", 4)==0 )
1579 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1580 t_field_name
= dem_opname
;
1581 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1582 t_field_name
= dem_opname
;
1584 if (t_field_name
&& STREQ (t_field_name
, name
))
1586 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1587 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1590 if (j
> 0 && args
== 0)
1591 error ("cannot resolve overloaded method `%s'", name
);
1594 if (TYPE_FN_FIELD_STUB (f
, j
))
1595 check_stub_method (type
, i
, j
);
1596 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1597 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1599 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1600 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1601 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1602 *static_memfuncp
= 1;
1603 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1604 if (v
!= NULL
) return v
;
1611 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1615 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1617 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1618 if (base_offset
== -1)
1619 error ("virtual baseclass botch");
1623 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1625 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1626 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1627 if (v
== (value_ptr
) -1)
1633 /* FIXME-bothner: Why is this commented out? Why is it here? */
1634 /* *arg1p = arg1_tmp;*/
1638 if (name_matched
) return (value_ptr
) -1;
1642 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1643 extract the component named NAME from the ultimate target structure/union
1644 and return it as a value with its appropriate type.
1645 ERR is used in the error message if *ARGP's type is wrong.
1647 C++: ARGS is a list of argument types to aid in the selection of
1648 an appropriate method. Also, handle derived types.
1650 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1651 where the truthvalue of whether the function that was resolved was
1652 a static member function or not is stored.
1654 ERR is an error message to be printed in case the field is not found. */
1657 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1658 register value_ptr
*argp
, *args
;
1660 int *static_memfuncp
;
1663 register struct type
*t
;
1666 COERCE_ARRAY (*argp
);
1668 t
= VALUE_TYPE (*argp
);
1670 /* Follow pointers until we get to a non-pointer. */
1672 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1674 *argp
= value_ind (*argp
);
1675 /* Don't coerce fn pointer to fn and then back again! */
1676 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1677 COERCE_ARRAY (*argp
);
1678 t
= VALUE_TYPE (*argp
);
1681 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1682 error ("not implemented: member type in value_struct_elt");
1684 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1685 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1686 error ("Attempt to extract a component of a value that is not a %s.", err
);
1688 /* Assume it's not, unless we see that it is. */
1689 if (static_memfuncp
)
1690 *static_memfuncp
=0;
1694 /* if there are no arguments ...do this... */
1696 /* Try as a field first, because if we succeed, there
1697 is less work to be done. */
1698 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1702 /* C++: If it was not found as a data field, then try to
1703 return it as a pointer to a method. */
1705 if (destructor_name_p (name
, t
))
1706 error ("Cannot get value of destructor");
1708 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1710 if (v
== (value_ptr
) -1)
1711 error ("Cannot take address of a method");
1714 if (TYPE_NFN_FIELDS (t
))
1715 error ("There is no member or method named %s.", name
);
1717 error ("There is no member named %s.", name
);
1722 if (destructor_name_p (name
, t
))
1726 /* destructors are a special case. */
1727 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1728 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1729 if (!v
) error("could not find destructor function named %s.", name
);
1734 error ("destructor should not have any argument");
1738 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1740 if (v
== (value_ptr
) -1)
1742 error("Argument list of %s mismatch with component in the structure.", name
);
1746 /* See if user tried to invoke data as function. If so,
1747 hand it back. If it's not callable (i.e., a pointer to function),
1748 gdb should give an error. */
1749 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1753 error ("Structure has no component named %s.", name
);
1757 /* C++: return 1 is NAME is a legitimate name for the destructor
1758 of type TYPE. If TYPE does not have a destructor, or
1759 if NAME is inappropriate for TYPE, an error is signaled. */
1761 destructor_name_p (name
, type
)
1763 const struct type
*type
;
1765 /* destructors are a special case. */
1769 char *dname
= type_name_no_tag (type
);
1770 char *cp
= strchr (dname
, '<');
1773 /* Do not compare the template part for template classes. */
1775 len
= strlen (dname
);
1778 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
1779 error ("name of destructor must equal name of class");
1786 /* Helper function for check_field: Given TYPE, a structure/union,
1787 return 1 if the component named NAME from the ultimate
1788 target structure/union is defined, otherwise, return 0. */
1791 check_field_in (type
, name
)
1792 register struct type
*type
;
1797 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1799 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1800 if (t_field_name
&& STREQ (t_field_name
, name
))
1804 /* C++: If it was not found as a data field, then try to
1805 return it as a pointer to a method. */
1807 /* Destructors are a special case. */
1808 if (destructor_name_p (name
, type
))
1811 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1813 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1817 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1818 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1825 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1826 return 1 if the component named NAME from the ultimate
1827 target structure/union is defined, otherwise, return 0. */
1830 check_field (arg1
, name
)
1831 register value_ptr arg1
;
1834 register struct type
*t
;
1836 COERCE_ARRAY (arg1
);
1838 t
= VALUE_TYPE (arg1
);
1840 /* Follow pointers until we get to a non-pointer. */
1842 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1843 t
= TYPE_TARGET_TYPE (t
);
1845 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1846 error ("not implemented: member type in check_field");
1848 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1849 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1850 error ("Internal error: `this' is not an aggregate");
1852 return check_field_in (t
, name
);
1855 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1856 return the address of this member as a "pointer to member"
1857 type. If INTYPE is non-null, then it will be the type
1858 of the member we are looking for. This will help us resolve
1859 "pointers to member functions". This function is used
1860 to resolve user expressions of the form "DOMAIN::NAME". */
1863 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1864 struct type
*domain
, *curtype
, *intype
;
1868 register struct type
*t
= curtype
;
1872 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1873 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1874 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1876 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1878 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1880 if (t_field_name
&& STREQ (t_field_name
, name
))
1882 if (TYPE_FIELD_STATIC (t
, i
))
1884 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1885 struct symbol
*sym
=
1886 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1888 error ("Internal error: could not find physical static variable named %s",
1890 return value_at (SYMBOL_TYPE (sym
),
1891 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1893 if (TYPE_FIELD_PACKED (t
, i
))
1894 error ("pointers to bitfield members not allowed");
1896 return value_from_longest
1897 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1899 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1903 /* C++: If it was not found as a data field, then try to
1904 return it as a pointer to a method. */
1906 /* Destructors are a special case. */
1907 if (destructor_name_p (name
, t
))
1909 error ("member pointers to destructors not implemented yet");
1912 /* Perform all necessary dereferencing. */
1913 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1914 intype
= TYPE_TARGET_TYPE (intype
);
1916 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1918 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
1919 char dem_opname
[64];
1921 if (strncmp(t_field_name
, "__", 2)==0 ||
1922 strncmp(t_field_name
, "op", 2)==0 ||
1923 strncmp(t_field_name
, "type", 4)==0 )
1925 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1926 t_field_name
= dem_opname
;
1927 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1928 t_field_name
= dem_opname
;
1930 if (t_field_name
&& STREQ (t_field_name
, name
))
1932 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1933 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1935 if (intype
== 0 && j
> 1)
1936 error ("non-unique member `%s' requires type instantiation", name
);
1940 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1943 error ("no member function matches that type instantiation");
1948 if (TYPE_FN_FIELD_STUB (f
, j
))
1949 check_stub_method (t
, i
, j
);
1950 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1952 return value_from_longest
1953 (lookup_reference_type
1954 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1956 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1960 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1961 0, VAR_NAMESPACE
, 0, NULL
);
1968 v
= read_var_value (s
, 0);
1970 VALUE_TYPE (v
) = lookup_reference_type
1971 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1979 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
1984 if (BASETYPE_VIA_VIRTUAL (t
, i
))
1987 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
1988 v
= value_struct_elt_for_reference (domain
,
1989 offset
+ base_offset
,
1990 TYPE_BASECLASS (t
, i
),
1999 /* C++: return the value of the class instance variable, if one exists.
2000 Flag COMPLAIN signals an error if the request is made in an
2001 inappropriate context. */
2004 value_of_this (complain
)
2007 struct symbol
*func
, *sym
;
2010 static const char funny_this
[] = "this";
2013 if (selected_frame
== 0)
2015 error ("no frame selected");
2018 func
= get_frame_function (selected_frame
);
2022 error ("no `this' in nameless context");
2026 b
= SYMBOL_BLOCK_VALUE (func
);
2027 i
= BLOCK_NSYMS (b
);
2030 error ("no args, no `this'");
2033 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2034 symbol instead of the LOC_ARG one (if both exist). */
2035 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
2039 error ("current stack frame not in method");
2044 this = read_var_value (sym
, selected_frame
);
2045 if (this == 0 && complain
)
2046 error ("`this' argument at unknown address");
2050 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2051 long, starting at LOWBOUND. The result has the same lower bound as
2052 the original ARRAY. */
2055 value_slice (array
, lowbound
, length
)
2057 int lowbound
, length
;
2059 COERCE_VARYING_ARRAY (array
);
2060 if (TYPE_CODE (VALUE_TYPE (array
)) == TYPE_CODE_BITSTRING
)
2061 error ("not implemented - bitstring slice");
2062 if (TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_ARRAY
2063 && TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_STRING
)
2064 error ("cannot take slice of non-array");
2067 struct type
*slice_range_type
, *slice_type
;
2069 struct type
*range_type
= TYPE_FIELD_TYPE (VALUE_TYPE (array
), 0);
2070 struct type
*element_type
= TYPE_TARGET_TYPE (VALUE_TYPE (array
));
2071 int lowerbound
= TYPE_LOW_BOUND (range_type
);
2072 int upperbound
= TYPE_HIGH_BOUND (range_type
);
2073 int offset
= (lowbound
- lowerbound
) * TYPE_LENGTH (element_type
);
2074 if (lowbound
< lowerbound
|| length
< 0
2075 || lowbound
+ length
- 1 > upperbound
)
2076 error ("slice out of range");
2077 /* FIXME-type-allocation: need a way to free this type when we are
2079 slice_range_type
= create_range_type ((struct type
*) NULL
,
2080 TYPE_TARGET_TYPE (range_type
),
2082 lowerbound
+ length
- 1);
2083 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2085 TYPE_CODE (slice_type
) = TYPE_CODE (VALUE_TYPE (array
));
2086 slice
= allocate_value (slice_type
);
2087 if (VALUE_LAZY (array
))
2088 VALUE_LAZY (slice
) = 1;
2090 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2091 TYPE_LENGTH (slice_type
));
2092 if (VALUE_LVAL (array
) == lval_internalvar
)
2093 VALUE_LVAL (slice
) = lval_internalvar_component
;
2095 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2096 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2097 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2102 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2103 value as a fixed-length array. */
2106 varying_to_slice (varray
)
2109 struct type
*vtype
= VALUE_TYPE (varray
);
2110 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
2111 VALUE_CONTENTS (varray
)
2112 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
2113 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
2116 /* Create a value for a FORTRAN complex number. Currently most of
2117 the time values are coerced to COMPLEX*16 (i.e. a complex number
2118 composed of 2 doubles. This really should be a smarter routine
2119 that figures out precision inteligently as opposed to assuming
2120 doubles. FIXME: fmb */
2123 value_literal_complex (arg1
, arg2
, type
)
2128 register value_ptr val
;
2129 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2131 val
= allocate_value (type
);
2132 arg1
= value_cast (real_type
, arg1
);
2133 arg2
= value_cast (real_type
, arg2
);
2135 memcpy (VALUE_CONTENTS_RAW (val
),
2136 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2137 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2138 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2142 /* Cast a value into the appropriate complex data type. */
2145 cast_into_complex (type
, val
)
2147 register value_ptr val
;
2149 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2150 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2152 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2153 value_ptr re_val
= allocate_value (val_real_type
);
2154 value_ptr im_val
= allocate_value (val_real_type
);
2156 memcpy (VALUE_CONTENTS_RAW (re_val
),
2157 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2158 memcpy (VALUE_CONTENTS_RAW (im_val
),
2159 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2160 TYPE_LENGTH (val_real_type
));
2162 return value_literal_complex (re_val
, im_val
, type
);
2164 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2165 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2166 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2168 error ("cannot cast non-number to complex");