1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
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. */
33 #include "gdb_string.h"
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
);
611 if (VALUE_REPEATED (arg1
))
612 error ("Cannot create artificial arrays of artificial arrays.");
614 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
616 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
617 VALUE_CONTENTS_RAW (val
),
618 TYPE_LENGTH (VALUE_TYPE (val
)) * count
);
619 VALUE_LVAL (val
) = lval_memory
;
620 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
626 value_of_variable (var
, b
)
631 struct frame_info
*frame
;
634 /* Use selected frame. */
638 frame
= block_innermost_frame (b
);
639 if (frame
== NULL
&& symbol_read_needs_frame (var
))
641 if (BLOCK_FUNCTION (b
) != NULL
642 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
643 error ("No frame is currently executing in block %s.",
644 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
646 error ("No frame is currently executing in specified block");
649 val
= read_var_value (var
, frame
);
651 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
655 /* Given a value which is an array, return a value which is a pointer to its
656 first element, regardless of whether or not the array has a nonzero lower
659 FIXME: A previous comment here indicated that this routine should be
660 substracting the array's lower bound. It's not clear to me that this
661 is correct. Given an array subscripting operation, it would certainly
662 work to do the adjustment here, essentially computing:
664 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
666 However I believe a more appropriate and logical place to account for
667 the lower bound is to do so in value_subscript, essentially computing:
669 (&array[0] + ((index - lowerbound) * sizeof array[0]))
671 As further evidence consider what would happen with operations other
672 than array subscripting, where the caller would get back a value that
673 had an address somewhere before the actual first element of the array,
674 and the information about the lower bound would be lost because of
675 the coercion to pointer type.
679 value_coerce_array (arg1
)
682 register struct type
*type
;
684 if (VALUE_LVAL (arg1
) != lval_memory
)
685 error ("Attempt to take address of value not located in memory.");
687 /* Get type of elements. */
688 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
689 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRING
)
690 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
692 /* A phony array made by value_repeat.
693 Its type is the type of the elements, not an array type. */
694 type
= VALUE_TYPE (arg1
);
696 return value_from_longest (lookup_pointer_type (type
),
697 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
700 /* Given a value which is a function, return a value which is a pointer
704 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 (VALUE_TYPE (arg1
)),
712 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
715 /* Return a pointer value for the object for which ARG1 is the contents. */
721 struct type
*type
= VALUE_TYPE (arg1
);
722 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
724 /* Copy the value, but change the type from (T&) to (T*).
725 We keep the same location information, which is efficient,
726 and allows &(&X) to get the location containing the reference. */
727 value_ptr arg2
= value_copy (arg1
);
728 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
731 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
732 return value_coerce_function (arg1
);
734 if (VALUE_LVAL (arg1
) != lval_memory
)
735 error ("Attempt to take address of value not located in memory.");
737 return value_from_longest (lookup_pointer_type (type
),
738 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
741 /* Given a value of a pointer type, apply the C unary * operator to it. */
749 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
750 error ("not implemented: member types in value_ind");
752 /* Allow * on an integer so we can cast it to whatever we want.
753 This returns an int, which seems like the most C-like thing
754 to do. "long long" variables are rare enough that
755 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
756 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
757 return value_at (builtin_type_int
,
758 (CORE_ADDR
) value_as_long (arg1
));
759 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
760 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
761 value_as_pointer (arg1
));
762 error ("Attempt to take contents of a non-pointer value.");
763 return 0; /* For lint -- never reached */
766 /* Pushing small parts of stack frames. */
768 /* Push one word (the size of object that a register holds). */
773 unsigned LONGEST word
;
775 register int len
= REGISTER_SIZE
;
776 char buffer
[MAX_REGISTER_RAW_SIZE
];
778 store_unsigned_integer (buffer
, len
, word
);
781 write_memory (sp
, buffer
, len
);
782 #else /* stack grows upward */
783 write_memory (sp
, buffer
, len
);
785 #endif /* stack grows upward */
790 /* Push LEN bytes with data at BUFFER. */
793 push_bytes (sp
, buffer
, len
)
800 write_memory (sp
, buffer
, len
);
801 #else /* stack grows upward */
802 write_memory (sp
, buffer
, len
);
804 #endif /* stack grows upward */
809 /* Push onto the stack the specified value VALUE. */
813 register CORE_ADDR sp
;
816 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
820 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
821 #else /* stack grows upward */
822 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
824 #endif /* stack grows upward */
829 /* Perform the standard coercions that are specified
830 for arguments to be passed to C functions.
832 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
835 value_arg_coerce (arg
, param_type
)
837 struct type
*param_type
;
839 register struct 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 type
= param_type
? param_type
: VALUE_TYPE (arg
);
850 switch (TYPE_CODE (type
))
853 if (TYPE_CODE (VALUE_TYPE (arg
)) != TYPE_CODE_REF
)
855 arg
= value_addr (arg
);
856 VALUE_TYPE (arg
) = param_type
;
864 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
865 type
= builtin_type_int
;
868 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
869 type
= builtin_type_double
;
872 type
= lookup_pointer_type (type
);
874 case TYPE_CODE_UNDEF
:
876 case TYPE_CODE_ARRAY
:
877 case TYPE_CODE_STRUCT
:
878 case TYPE_CODE_UNION
:
881 case TYPE_CODE_RANGE
:
882 case TYPE_CODE_STRING
:
883 case TYPE_CODE_BITSTRING
:
884 case TYPE_CODE_ERROR
:
885 case TYPE_CODE_MEMBER
:
886 case TYPE_CODE_METHOD
:
887 case TYPE_CODE_COMPLEX
:
892 return value_cast (type
, arg
);
895 /* Determine a function's address and its return type from its value.
896 Calls error() if the function is not valid for calling. */
899 find_function_addr (function
, retval_type
)
901 struct type
**retval_type
;
903 register struct type
*ftype
= VALUE_TYPE (function
);
904 register enum type_code code
= TYPE_CODE (ftype
);
905 struct type
*value_type
;
908 /* If it's a member function, just look at the function
911 /* Determine address to call. */
912 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
914 funaddr
= VALUE_ADDRESS (function
);
915 value_type
= TYPE_TARGET_TYPE (ftype
);
917 else if (code
== TYPE_CODE_PTR
)
919 funaddr
= value_as_pointer (function
);
920 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
921 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
923 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
924 /* FIXME: This is a workaround for the unusual function
925 pointer representation on the RS/6000, see comment
926 in config/rs6000/tm-rs6000.h */
927 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
929 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
932 value_type
= builtin_type_int
;
934 else if (code
== TYPE_CODE_INT
)
936 /* Handle the case of functions lacking debugging info.
937 Their values are characters since their addresses are char */
938 if (TYPE_LENGTH (ftype
) == 1)
939 funaddr
= value_as_pointer (value_addr (function
));
941 /* Handle integer used as address of a function. */
942 funaddr
= (CORE_ADDR
) value_as_long (function
);
944 value_type
= builtin_type_int
;
947 error ("Invalid data type for function to be called.");
949 *retval_type
= value_type
;
953 #if defined (CALL_DUMMY)
954 /* All this stuff with a dummy frame may seem unnecessarily complicated
955 (why not just save registers in GDB?). The purpose of pushing a dummy
956 frame which looks just like a real frame is so that if you call a
957 function and then hit a breakpoint (get a signal, etc), "backtrace"
958 will look right. Whether the backtrace needs to actually show the
959 stack at the time the inferior function was called is debatable, but
960 it certainly needs to not display garbage. So if you are contemplating
961 making dummy frames be different from normal frames, consider that. */
963 /* Perform a function call in the inferior.
964 ARGS is a vector of values of arguments (NARGS of them).
965 FUNCTION is a value, the function to be called.
966 Returns a value representing what the function returned.
967 May fail to return, if a breakpoint or signal is hit
968 during the execution of the function.
970 ARGS is modified to contain coerced values. */
973 call_function_by_hand (function
, nargs
, args
)
978 register CORE_ADDR sp
;
981 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
982 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
983 and remove any extra bytes which might exist because unsigned LONGEST is
984 bigger than REGISTER_SIZE. */
985 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
986 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
988 struct type
*value_type
;
989 unsigned char struct_return
;
990 CORE_ADDR struct_addr
;
991 struct inferior_status inf_status
;
992 struct cleanup
*old_chain
;
996 struct type
*ftype
= SYMBOL_TYPE (function
);
998 if (!target_has_execution
)
1001 save_inferior_status (&inf_status
, 1);
1002 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
1004 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1005 (and POP_FRAME for restoring them). (At least on most machines)
1006 they are saved on the stack in the inferior. */
1009 old_sp
= sp
= read_sp ();
1011 #if 1 INNER_THAN 2 /* Stack grows down */
1012 sp
-= sizeof dummy1
;
1014 #else /* Stack grows up */
1016 sp
+= sizeof dummy1
;
1019 funaddr
= find_function_addr (function
, &value_type
);
1022 struct block
*b
= block_for_pc (funaddr
);
1023 /* If compiled without -g, assume GCC. */
1024 using_gcc
= b
== NULL
? 0 : BLOCK_GCC_COMPILED (b
);
1027 /* Are we returning a value using a structure return or a normal
1030 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1033 /* Create a call sequence customized for this function
1034 and the number of arguments for it. */
1035 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
1036 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1038 (unsigned LONGEST
)dummy
[i
]);
1040 #ifdef GDB_TARGET_IS_HPPA
1041 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1042 value_type
, using_gcc
);
1044 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1045 value_type
, using_gcc
);
1049 #if CALL_DUMMY_LOCATION == ON_STACK
1050 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1051 #endif /* On stack. */
1053 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1054 /* Convex Unix prohibits executing in the stack segment. */
1055 /* Hope there is empty room at the top of the text segment. */
1057 extern CORE_ADDR text_end
;
1060 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1061 if (read_memory_integer (start_sp
, 1) != 0)
1062 error ("text segment full -- no place to put call");
1065 real_pc
= text_end
- sizeof dummy1
;
1066 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1068 #endif /* Before text_end. */
1070 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1072 extern CORE_ADDR text_end
;
1076 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1078 error ("Cannot write text segment -- call_function failed");
1080 #endif /* After text_end. */
1082 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1084 #endif /* At entry point. */
1087 sp
= old_sp
; /* It really is used, for some ifdef's... */
1090 if (nargs
< TYPE_NFIELDS (ftype
))
1091 error ("too few arguments in function call");
1093 for (i
= nargs
- 1; i
>= 0; i
--)
1095 struct type
*param_type
;
1096 if (TYPE_NFIELDS (ftype
) > i
)
1097 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1100 args
[i
] = value_arg_coerce (args
[i
], param_type
);
1103 #if defined (REG_STRUCT_HAS_ADDR)
1105 /* This is a machine like the sparc, where we may need to pass a pointer
1106 to the structure, not the structure itself. */
1107 for (i
= nargs
- 1; i
>= 0; i
--)
1108 if ((TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
1109 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_UNION
1110 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_ARRAY
1111 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRING
)
1112 && REG_STRUCT_HAS_ADDR (using_gcc
, VALUE_TYPE (args
[i
])))
1115 int len
= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1117 int aligned_len
= STACK_ALIGN (len
);
1119 int aligned_len
= len
;
1121 #if !(1 INNER_THAN 2)
1122 /* The stack grows up, so the address of the thing we push
1123 is the stack pointer before we push it. */
1128 /* Push the structure. */
1129 write_memory (sp
, VALUE_CONTENTS (args
[i
]), len
);
1131 /* The stack grows down, so the address of the thing we push
1132 is the stack pointer after we push it. */
1137 /* The value we're going to pass is the address of the thing
1139 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1143 #endif /* REG_STRUCT_HAS_ADDR. */
1145 /* Reserve space for the return structure to be written on the
1146 stack, if necessary */
1150 int len
= TYPE_LENGTH (value_type
);
1152 len
= STACK_ALIGN (len
);
1164 /* If stack grows down, we must leave a hole at the top. */
1168 for (i
= nargs
- 1; i
>= 0; i
--)
1169 len
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1170 #ifdef CALL_DUMMY_STACK_ADJUST
1171 len
+= CALL_DUMMY_STACK_ADJUST
;
1174 sp
-= STACK_ALIGN (len
) - len
;
1176 sp
+= STACK_ALIGN (len
) - len
;
1179 #endif /* STACK_ALIGN */
1181 #ifdef PUSH_ARGUMENTS
1182 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1183 #else /* !PUSH_ARGUMENTS */
1184 for (i
= nargs
- 1; i
>= 0; i
--)
1185 sp
= value_push (sp
, args
[i
]);
1186 #endif /* !PUSH_ARGUMENTS */
1188 #ifdef CALL_DUMMY_STACK_ADJUST
1190 sp
-= CALL_DUMMY_STACK_ADJUST
;
1192 sp
+= CALL_DUMMY_STACK_ADJUST
;
1194 #endif /* CALL_DUMMY_STACK_ADJUST */
1196 /* Store the address at which the structure is supposed to be
1197 written. Note that this (and the code which reserved the space
1198 above) assumes that gcc was used to compile this function. Since
1199 it doesn't cost us anything but space and if the function is pcc
1200 it will ignore this value, we will make that assumption.
1202 Also note that on some machines (like the sparc) pcc uses a
1203 convention like gcc's. */
1206 STORE_STRUCT_RETURN (struct_addr
, sp
);
1208 /* Write the stack pointer. This is here because the statements above
1209 might fool with it. On SPARC, this write also stores the register
1210 window into the right place in the new stack frame, which otherwise
1211 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1215 char retbuf
[REGISTER_BYTES
];
1217 struct symbol
*symbol
;
1220 symbol
= find_pc_function (funaddr
);
1223 name
= SYMBOL_SOURCE_NAME (symbol
);
1227 /* Try the minimal symbols. */
1228 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1232 name
= SYMBOL_SOURCE_NAME (msymbol
);
1238 sprintf (format
, "at %s", local_hex_format ());
1240 /* FIXME-32x64: assumes funaddr fits in a long. */
1241 sprintf (name
, format
, (unsigned long) funaddr
);
1244 /* Execute the stack dummy routine, calling FUNCTION.
1245 When it is done, discard the empty frame
1246 after storing the contents of all regs into retbuf. */
1247 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1249 /* We stopped somewhere besides the call dummy. */
1251 /* If we did the cleanups, we would print a spurious error message
1252 (Unable to restore previously selected frame), would write the
1253 registers from the inf_status (which is wrong), and would do other
1254 wrong things (like set stop_bpstat to the wrong thing). */
1255 discard_cleanups (old_chain
);
1256 /* Prevent memory leak. */
1257 bpstat_clear (&inf_status
.stop_bpstat
);
1259 /* The following error message used to say "The expression
1260 which contained the function call has been discarded." It
1261 is a hard concept to explain in a few words. Ideally, GDB
1262 would be able to resume evaluation of the expression when
1263 the function finally is done executing. Perhaps someday
1264 this will be implemented (it would not be easy). */
1266 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1267 a C++ name with arguments and stuff. */
1269 The program being debugged stopped while in a function called from GDB.\n\
1270 When the function (%s) is done executing, GDB will silently\n\
1271 stop (instead of continuing to evaluate the expression containing\n\
1272 the function call).", name
);
1275 do_cleanups (old_chain
);
1277 /* Figure out the value returned by the function. */
1278 return value_being_returned (value_type
, retbuf
, struct_return
);
1281 #else /* no CALL_DUMMY. */
1283 call_function_by_hand (function
, nargs
, args
)
1288 error ("Cannot invoke functions on this machine.");
1290 #endif /* no CALL_DUMMY. */
1293 /* Create a value for an array by allocating space in the inferior, copying
1294 the data into that space, and then setting up an array value.
1296 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1297 populated from the values passed in ELEMVEC.
1299 The element type of the array is inherited from the type of the
1300 first element, and all elements must have the same size (though we
1301 don't currently enforce any restriction on their types). */
1304 value_array (lowbound
, highbound
, elemvec
)
1313 struct type
*rangetype
;
1314 struct type
*arraytype
;
1317 /* Validate that the bounds are reasonable and that each of the elements
1318 have the same size. */
1320 nelem
= highbound
- lowbound
+ 1;
1323 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1325 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1326 for (idx
= 0; idx
< nelem
; idx
++)
1328 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1330 error ("array elements must all be the same size");
1334 /* Allocate space to store the array in the inferior, and then initialize
1335 it by copying in each element. FIXME: Is it worth it to create a
1336 local buffer in which to collect each value and then write all the
1337 bytes in one operation? */
1339 addr
= allocate_space_in_inferior (nelem
* typelength
);
1340 for (idx
= 0; idx
< nelem
; idx
++)
1342 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1346 /* Create the array type and set up an array value to be evaluated lazily. */
1348 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1349 lowbound
, highbound
);
1350 arraytype
= create_array_type ((struct type
*) NULL
,
1351 VALUE_TYPE (elemvec
[0]), rangetype
);
1352 val
= value_at_lazy (arraytype
, addr
);
1356 /* Create a value for a string constant by allocating space in the inferior,
1357 copying the data into that space, and returning the address with type
1358 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1360 Note that string types are like array of char types with a lower bound of
1361 zero and an upper bound of LEN - 1. Also note that the string may contain
1362 embedded null bytes. */
1365 value_string (ptr
, len
)
1370 int lowbound
= current_language
->string_lower_bound
;
1371 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1373 lowbound
, len
+ lowbound
- 1);
1374 struct type
*stringtype
1375 = create_string_type ((struct type
*) NULL
, rangetype
);
1378 if (current_language
->c_style_arrays
== 0)
1380 val
= allocate_value (stringtype
);
1381 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1386 /* Allocate space to store the string in the inferior, and then
1387 copy LEN bytes from PTR in gdb to that address in the inferior. */
1389 addr
= allocate_space_in_inferior (len
);
1390 write_memory (addr
, ptr
, len
);
1392 val
= value_at_lazy (stringtype
, addr
);
1397 value_bitstring (ptr
, len
)
1402 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1404 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1405 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1406 val
= allocate_value (type
);
1407 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
) / TARGET_CHAR_BIT
);
1411 /* See if we can pass arguments in T2 to a function which takes arguments
1412 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1413 arguments need coercion of some sort, then the coerced values are written
1414 into T2. Return value is 0 if the arguments could be matched, or the
1415 position at which they differ if not.
1417 STATICP is nonzero if the T1 argument list came from a
1418 static member function.
1420 For non-static member functions, we ignore the first argument,
1421 which is the type of the instance variable. This is because we want
1422 to handle calls with objects from derived classes. This is not
1423 entirely correct: we should actually check to make sure that a
1424 requested operation is type secure, shouldn't we? FIXME. */
1427 typecmp (staticp
, t1
, t2
)
1436 if (staticp
&& t1
== 0)
1440 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1441 if (t1
[!staticp
] == 0) return 0;
1442 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1444 struct type
*tt1
, *tt2
;
1448 tt2
= VALUE_TYPE(t2
[i
]);
1449 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1450 /* We should be doing hairy argument matching, as below. */
1451 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1453 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
|| VALUE_REPEATED (t2
[i
]))
1454 t2
[i
] = value_coerce_array (t2
[i
]);
1456 t2
[i
] = value_addr (t2
[i
]);
1460 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1461 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1463 tt1
= TYPE_TARGET_TYPE(tt1
);
1464 tt2
= TYPE_TARGET_TYPE(tt2
);
1466 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1467 /* Array to pointer is a `trivial conversion' according to the ARM. */
1469 /* We should be doing much hairier argument matching (see section 13.2
1470 of the ARM), but as a quick kludge, just check for the same type
1472 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1475 if (!t1
[i
]) return 0;
1476 return t2
[i
] ? i
+1 : 0;
1479 /* Helper function used by value_struct_elt to recurse through baseclasses.
1480 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1481 and search in it assuming it has (class) type TYPE.
1482 If found, return value, else return NULL.
1484 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1485 look for a baseclass named NAME. */
1488 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1490 register value_ptr arg1
;
1492 register struct type
*type
;
1493 int looking_for_baseclass
;
1497 check_stub_type (type
);
1499 if (! looking_for_baseclass
)
1500 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1502 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1504 if (t_field_name
&& STREQ (t_field_name
, name
))
1507 if (TYPE_FIELD_STATIC (type
, i
))
1509 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1510 struct symbol
*sym
=
1511 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1513 error ("Internal error: could not find physical static variable named %s",
1515 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1516 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1519 v
= value_primitive_field (arg1
, offset
, i
, type
);
1521 error("there is no field named %s", name
);
1524 if (t_field_name
&& t_field_name
[0] == '\0'
1525 && TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
1527 /* Look for a match through the fields of an anonymous union. */
1529 v
= search_struct_field (name
, arg1
, offset
,
1530 TYPE_FIELD_TYPE (type
, i
),
1531 looking_for_baseclass
);
1537 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1540 /* If we are looking for baseclasses, this is what we get when we
1541 hit them. But it could happen that the base part's member name
1542 is not yet filled in. */
1543 int found_baseclass
= (looking_for_baseclass
1544 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1545 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1547 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1550 /* Fix to use baseclass_offset instead. FIXME */
1551 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1554 error ("virtual baseclass botch");
1555 if (found_baseclass
)
1557 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1558 looking_for_baseclass
);
1560 else if (found_baseclass
)
1561 v
= value_primitive_field (arg1
, offset
, i
, type
);
1563 v
= search_struct_field (name
, arg1
,
1564 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1565 TYPE_BASECLASS (type
, i
),
1566 looking_for_baseclass
);
1572 /* Helper function used by value_struct_elt to recurse through baseclasses.
1573 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1574 and search in it assuming it has (class) type TYPE.
1575 If found, return value, else if name matched and args not return (value)-1,
1576 else return NULL. */
1579 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1581 register value_ptr
*arg1p
, *args
;
1582 int offset
, *static_memfuncp
;
1583 register struct type
*type
;
1587 int name_matched
= 0;
1588 char dem_opname
[64];
1590 check_stub_type (type
);
1591 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1593 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1594 if (strncmp(t_field_name
, "__", 2)==0 ||
1595 strncmp(t_field_name
, "op", 2)==0 ||
1596 strncmp(t_field_name
, "type", 4)==0 )
1598 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1599 t_field_name
= dem_opname
;
1600 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1601 t_field_name
= dem_opname
;
1603 if (t_field_name
&& STREQ (t_field_name
, name
))
1605 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1606 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1609 if (j
> 0 && args
== 0)
1610 error ("cannot resolve overloaded method `%s'", name
);
1613 if (TYPE_FN_FIELD_STUB (f
, j
))
1614 check_stub_method (type
, i
, j
);
1615 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1616 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1618 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1619 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1620 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1621 *static_memfuncp
= 1;
1622 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1623 if (v
!= NULL
) return v
;
1630 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1634 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1636 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1637 if (base_offset
== -1)
1638 error ("virtual baseclass botch");
1642 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1644 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1645 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1646 if (v
== (value_ptr
) -1)
1652 /* FIXME-bothner: Why is this commented out? Why is it here? */
1653 /* *arg1p = arg1_tmp;*/
1657 if (name_matched
) return (value_ptr
) -1;
1661 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1662 extract the component named NAME from the ultimate target structure/union
1663 and return it as a value with its appropriate type.
1664 ERR is used in the error message if *ARGP's type is wrong.
1666 C++: ARGS is a list of argument types to aid in the selection of
1667 an appropriate method. Also, handle derived types.
1669 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1670 where the truthvalue of whether the function that was resolved was
1671 a static member function or not is stored.
1673 ERR is an error message to be printed in case the field is not found. */
1676 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1677 register value_ptr
*argp
, *args
;
1679 int *static_memfuncp
;
1682 register struct type
*t
;
1685 COERCE_ARRAY (*argp
);
1687 t
= VALUE_TYPE (*argp
);
1689 /* Follow pointers until we get to a non-pointer. */
1691 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1693 *argp
= value_ind (*argp
);
1694 /* Don't coerce fn pointer to fn and then back again! */
1695 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1696 COERCE_ARRAY (*argp
);
1697 t
= VALUE_TYPE (*argp
);
1700 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1701 error ("not implemented: member type in value_struct_elt");
1703 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1704 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1705 error ("Attempt to extract a component of a value that is not a %s.", err
);
1707 /* Assume it's not, unless we see that it is. */
1708 if (static_memfuncp
)
1709 *static_memfuncp
=0;
1713 /* if there are no arguments ...do this... */
1715 /* Try as a field first, because if we succeed, there
1716 is less work to be done. */
1717 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1721 /* C++: If it was not found as a data field, then try to
1722 return it as a pointer to a method. */
1724 if (destructor_name_p (name
, t
))
1725 error ("Cannot get value of destructor");
1727 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1729 if (v
== (value_ptr
) -1)
1730 error ("Cannot take address of a method");
1733 if (TYPE_NFN_FIELDS (t
))
1734 error ("There is no member or method named %s.", name
);
1736 error ("There is no member named %s.", name
);
1741 if (destructor_name_p (name
, t
))
1745 /* destructors are a special case. */
1746 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1747 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1748 if (!v
) error("could not find destructor function named %s.", name
);
1753 error ("destructor should not have any argument");
1757 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1759 if (v
== (value_ptr
) -1)
1761 error("Argument list of %s mismatch with component in the structure.", name
);
1765 /* See if user tried to invoke data as function. If so,
1766 hand it back. If it's not callable (i.e., a pointer to function),
1767 gdb should give an error. */
1768 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1772 error ("Structure has no component named %s.", name
);
1776 /* C++: return 1 is NAME is a legitimate name for the destructor
1777 of type TYPE. If TYPE does not have a destructor, or
1778 if NAME is inappropriate for TYPE, an error is signaled. */
1780 destructor_name_p (name
, type
)
1782 const struct type
*type
;
1784 /* destructors are a special case. */
1788 char *dname
= type_name_no_tag (type
);
1789 char *cp
= strchr (dname
, '<');
1792 /* Do not compare the template part for template classes. */
1794 len
= strlen (dname
);
1797 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
1798 error ("name of destructor must equal name of class");
1805 /* Helper function for check_field: Given TYPE, a structure/union,
1806 return 1 if the component named NAME from the ultimate
1807 target structure/union is defined, otherwise, return 0. */
1810 check_field_in (type
, name
)
1811 register struct type
*type
;
1816 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1818 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1819 if (t_field_name
&& STREQ (t_field_name
, name
))
1823 /* C++: If it was not found as a data field, then try to
1824 return it as a pointer to a method. */
1826 /* Destructors are a special case. */
1827 if (destructor_name_p (name
, type
))
1830 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1832 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1836 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1837 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1844 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1845 return 1 if the component named NAME from the ultimate
1846 target structure/union is defined, otherwise, return 0. */
1849 check_field (arg1
, name
)
1850 register value_ptr arg1
;
1853 register struct type
*t
;
1855 COERCE_ARRAY (arg1
);
1857 t
= VALUE_TYPE (arg1
);
1859 /* Follow pointers until we get to a non-pointer. */
1861 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1862 t
= TYPE_TARGET_TYPE (t
);
1864 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1865 error ("not implemented: member type in check_field");
1867 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1868 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1869 error ("Internal error: `this' is not an aggregate");
1871 return check_field_in (t
, name
);
1874 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1875 return the address of this member as a "pointer to member"
1876 type. If INTYPE is non-null, then it will be the type
1877 of the member we are looking for. This will help us resolve
1878 "pointers to member functions". This function is used
1879 to resolve user expressions of the form "DOMAIN::NAME". */
1882 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1883 struct type
*domain
, *curtype
, *intype
;
1887 register struct type
*t
= curtype
;
1891 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1892 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1893 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1895 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1897 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1899 if (t_field_name
&& STREQ (t_field_name
, name
))
1901 if (TYPE_FIELD_STATIC (t
, i
))
1903 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1904 struct symbol
*sym
=
1905 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1907 error ("Internal error: could not find physical static variable named %s",
1909 return value_at (SYMBOL_TYPE (sym
),
1910 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1912 if (TYPE_FIELD_PACKED (t
, i
))
1913 error ("pointers to bitfield members not allowed");
1915 return value_from_longest
1916 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1918 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1922 /* C++: If it was not found as a data field, then try to
1923 return it as a pointer to a method. */
1925 /* Destructors are a special case. */
1926 if (destructor_name_p (name
, t
))
1928 error ("member pointers to destructors not implemented yet");
1931 /* Perform all necessary dereferencing. */
1932 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1933 intype
= TYPE_TARGET_TYPE (intype
);
1935 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1937 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
1938 char dem_opname
[64];
1940 if (strncmp(t_field_name
, "__", 2)==0 ||
1941 strncmp(t_field_name
, "op", 2)==0 ||
1942 strncmp(t_field_name
, "type", 4)==0 )
1944 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1945 t_field_name
= dem_opname
;
1946 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1947 t_field_name
= dem_opname
;
1949 if (t_field_name
&& STREQ (t_field_name
, name
))
1951 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
1952 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
1954 if (intype
== 0 && j
> 1)
1955 error ("non-unique member `%s' requires type instantiation", name
);
1959 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
1962 error ("no member function matches that type instantiation");
1967 if (TYPE_FN_FIELD_STUB (f
, j
))
1968 check_stub_method (t
, i
, j
);
1969 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1971 return value_from_longest
1972 (lookup_reference_type
1973 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1975 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
1979 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
1980 0, VAR_NAMESPACE
, 0, NULL
);
1987 v
= read_var_value (s
, 0);
1989 VALUE_TYPE (v
) = lookup_reference_type
1990 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
1998 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2003 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2006 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2007 v
= value_struct_elt_for_reference (domain
,
2008 offset
+ base_offset
,
2009 TYPE_BASECLASS (t
, i
),
2018 /* C++: return the value of the class instance variable, if one exists.
2019 Flag COMPLAIN signals an error if the request is made in an
2020 inappropriate context. */
2023 value_of_this (complain
)
2026 struct symbol
*func
, *sym
;
2029 static const char funny_this
[] = "this";
2032 if (selected_frame
== 0)
2034 error ("no frame selected");
2037 func
= get_frame_function (selected_frame
);
2041 error ("no `this' in nameless context");
2045 b
= SYMBOL_BLOCK_VALUE (func
);
2046 i
= BLOCK_NSYMS (b
);
2049 error ("no args, no `this'");
2052 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2053 symbol instead of the LOC_ARG one (if both exist). */
2054 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
2058 error ("current stack frame not in method");
2063 this = read_var_value (sym
, selected_frame
);
2064 if (this == 0 && complain
)
2065 error ("`this' argument at unknown address");
2069 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2070 long, starting at LOWBOUND. The result has the same lower bound as
2071 the original ARRAY. */
2074 value_slice (array
, lowbound
, length
)
2076 int lowbound
, length
;
2078 COERCE_VARYING_ARRAY (array
);
2079 if (TYPE_CODE (VALUE_TYPE (array
)) == TYPE_CODE_BITSTRING
)
2080 error ("not implemented - bitstring slice");
2081 if (TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_ARRAY
2082 && TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_STRING
)
2083 error ("cannot take slice of non-array");
2086 struct type
*slice_range_type
, *slice_type
;
2088 struct type
*range_type
= TYPE_FIELD_TYPE (VALUE_TYPE (array
), 0);
2089 struct type
*element_type
= TYPE_TARGET_TYPE (VALUE_TYPE (array
));
2090 int lowerbound
= TYPE_LOW_BOUND (range_type
);
2091 int upperbound
= TYPE_HIGH_BOUND (range_type
);
2092 int offset
= (lowbound
- lowerbound
) * TYPE_LENGTH (element_type
);
2093 if (lowbound
< lowerbound
|| length
< 0
2094 || lowbound
+ length
- 1 > upperbound
)
2095 error ("slice out of range");
2096 /* FIXME-type-allocation: need a way to free this type when we are
2098 slice_range_type
= create_range_type ((struct type
*) NULL
,
2099 TYPE_TARGET_TYPE (range_type
),
2101 lowerbound
+ length
- 1);
2102 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2104 TYPE_CODE (slice_type
) = TYPE_CODE (VALUE_TYPE (array
));
2105 slice
= allocate_value (slice_type
);
2106 if (VALUE_LAZY (array
))
2107 VALUE_LAZY (slice
) = 1;
2109 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2110 TYPE_LENGTH (slice_type
));
2111 if (VALUE_LVAL (array
) == lval_internalvar
)
2112 VALUE_LVAL (slice
) = lval_internalvar_component
;
2114 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2115 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2116 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2121 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2122 value as a fixed-length array. */
2125 varying_to_slice (varray
)
2128 struct type
*vtype
= VALUE_TYPE (varray
);
2129 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
2130 VALUE_CONTENTS (varray
)
2131 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
2132 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
2135 /* Create a value for a FORTRAN complex number. Currently most of
2136 the time values are coerced to COMPLEX*16 (i.e. a complex number
2137 composed of 2 doubles. This really should be a smarter routine
2138 that figures out precision inteligently as opposed to assuming
2139 doubles. FIXME: fmb */
2142 value_literal_complex (arg1
, arg2
, type
)
2147 register value_ptr val
;
2148 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2150 val
= allocate_value (type
);
2151 arg1
= value_cast (real_type
, arg1
);
2152 arg2
= value_cast (real_type
, arg2
);
2154 memcpy (VALUE_CONTENTS_RAW (val
),
2155 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2156 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2157 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2161 /* Cast a value into the appropriate complex data type. */
2164 cast_into_complex (type
, val
)
2166 register value_ptr val
;
2168 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2169 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2171 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2172 value_ptr re_val
= allocate_value (val_real_type
);
2173 value_ptr im_val
= allocate_value (val_real_type
);
2175 memcpy (VALUE_CONTENTS_RAW (re_val
),
2176 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2177 memcpy (VALUE_CONTENTS_RAW (im_val
),
2178 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2179 TYPE_LENGTH (val_real_type
));
2181 return value_literal_complex (re_val
, im_val
, type
);
2183 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2184 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2185 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2187 error ("cannot cast non-number to complex");