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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 /* Find the address of function name NAME in the inferior. */
62 find_function_in_inferior (name
)
65 register struct symbol
*sym
;
66 sym
= lookup_symbol (name
, 0, VAR_NAMESPACE
, 0, NULL
);
69 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
71 error ("\"%s\" exists in this program but is not a function.",
74 return value_of_variable (sym
, NULL
);
78 struct minimal_symbol
*msymbol
= lookup_minimal_symbol(name
, NULL
, NULL
);
83 type
= lookup_pointer_type (builtin_type_char
);
84 type
= lookup_function_type (type
);
85 type
= lookup_pointer_type (type
);
86 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
87 return value_from_longest (type
, maddr
);
91 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
96 /* Allocate NBYTES of space in the inferior using the inferior's malloc
97 and return a value that is a pointer to the allocated space. */
100 value_allocate_space_in_inferior (len
)
104 register value_ptr val
= find_function_in_inferior ("malloc");
106 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
107 val
= call_function_by_hand (val
, 1, &blocklen
);
108 if (value_logical_not (val
))
110 error ("No memory available to program.");
116 allocate_space_in_inferior (len
)
119 return value_as_long (value_allocate_space_in_inferior (len
));
122 /* Cast value ARG2 to type TYPE and return as a value.
123 More general than a C cast: accepts any two types of the same length,
124 and if ARG2 is an lvalue it can be cast into anything at all. */
125 /* In C++, casts may change pointer or object representations. */
128 value_cast (type
, arg2
)
130 register value_ptr arg2
;
132 register enum type_code code1
= TYPE_CODE (type
);
133 register enum type_code code2
;
136 if (VALUE_TYPE (arg2
) == type
)
141 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
142 is treated like a cast to (TYPE [N])OBJECT,
143 where N is sizeof(OBJECT)/sizeof(TYPE). */
144 if (code1
== TYPE_CODE_ARRAY
145 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
146 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
148 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
149 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
150 int low_bound
= TYPE_LOW_BOUND (range_type
);
151 int val_length
= TYPE_LENGTH (VALUE_TYPE (arg2
));
152 int new_length
= val_length
/ TYPE_LENGTH (element_type
);
153 if (val_length
% TYPE_LENGTH (element_type
) != 0)
154 warning("array element type size does not divide object size in cast");
155 /* FIXME-type-allocation: need a way to free this type when we are
157 range_type
= create_range_type ((struct type
*) NULL
,
158 TYPE_TARGET_TYPE (range_type
),
159 low_bound
, new_length
+ low_bound
- 1);
160 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
161 element_type
, range_type
);
165 if (current_language
->c_style_arrays
166 && TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_ARRAY
)
167 arg2
= value_coerce_array (arg2
);
169 if (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_FUNC
)
170 arg2
= value_coerce_function (arg2
);
172 COERCE_VARYING_ARRAY (arg2
);
174 code2
= TYPE_CODE (VALUE_TYPE (arg2
));
176 if (code1
== TYPE_CODE_COMPLEX
)
177 return cast_into_complex (type
, arg2
);
178 if (code1
== TYPE_CODE_BOOL
)
179 code1
= TYPE_CODE_INT
;
180 if (code2
== TYPE_CODE_BOOL
)
181 code2
= TYPE_CODE_INT
;
183 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
184 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
186 if ( code1
== TYPE_CODE_STRUCT
187 && code2
== TYPE_CODE_STRUCT
188 && TYPE_NAME (type
) != 0)
190 /* Look in the type of the source to see if it contains the
191 type of the target as a superclass. If so, we'll need to
192 offset the object in addition to changing its type. */
193 value_ptr v
= search_struct_field (type_name_no_tag (type
),
194 arg2
, 0, VALUE_TYPE (arg2
), 1);
197 VALUE_TYPE (v
) = type
;
201 if (code1
== TYPE_CODE_FLT
&& scalar
)
202 return value_from_double (type
, value_as_double (arg2
));
203 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
204 || code1
== TYPE_CODE_RANGE
)
205 && (scalar
|| code2
== TYPE_CODE_PTR
))
206 return value_from_longest (type
, value_as_long (arg2
));
207 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (VALUE_TYPE (arg2
)))
209 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
211 /* Look in the type of the source to see if it contains the
212 type of the target as a superclass. If so, we'll need to
213 offset the pointer rather than just change its type. */
214 struct type
*t1
= TYPE_TARGET_TYPE (type
);
215 struct type
*t2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
216 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
217 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
218 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
220 value_ptr v
= search_struct_field (type_name_no_tag (t1
),
221 value_ind (arg2
), 0, t2
, 1);
225 VALUE_TYPE (v
) = type
;
229 /* No superclass found, just fall through to change ptr type. */
231 VALUE_TYPE (arg2
) = type
;
234 else if (chill_varying_type (type
))
236 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
239 char *valaddr
, *valaddr_data
;
240 if (code2
== TYPE_CODE_BITSTRING
)
241 error ("not implemented: converting bitstring to varying type");
242 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
243 || (eltype1
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1)),
244 eltype2
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
)),
245 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
246 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
247 error ("Invalid conversion to varying type");
248 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
249 range2
= TYPE_FIELD_TYPE (VALUE_TYPE (arg2
), 0);
250 count1
= TYPE_HIGH_BOUND (range1
) - TYPE_LOW_BOUND (range1
) + 1;
251 count2
= TYPE_HIGH_BOUND (range2
) - TYPE_LOW_BOUND (range2
) + 1;
253 error ("target varying type is too small");
254 val
= allocate_value (type
);
255 valaddr
= VALUE_CONTENTS_RAW (val
);
256 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
257 /* Set val's __var_length field to count2. */
258 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
260 /* Set the __var_data field to count2 elements copied from arg2. */
261 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
262 count2
* TYPE_LENGTH (eltype2
));
263 /* Zero the rest of the __var_data field of val. */
264 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
265 (count1
- count2
) * TYPE_LENGTH (eltype2
));
268 else if (VALUE_LVAL (arg2
) == lval_memory
)
270 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
272 else if (code1
== TYPE_CODE_VOID
)
274 return value_zero (builtin_type_void
, not_lval
);
278 error ("Invalid cast.");
283 /* Create a value of type TYPE that is zero, and return it. */
286 value_zero (type
, lv
)
290 register value_ptr val
= allocate_value (type
);
292 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (type
));
293 VALUE_LVAL (val
) = lv
;
298 /* Return a value with type TYPE located at ADDR.
300 Call value_at only if the data needs to be fetched immediately;
301 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
302 value_at_lazy instead. value_at_lazy simply records the address of
303 the data and sets the lazy-evaluation-required flag. The lazy flag
304 is tested in the VALUE_CONTENTS macro, which is used if and when
305 the contents are actually required. */
308 value_at (type
, addr
)
312 register value_ptr val
;
314 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
315 error ("Attempt to dereference a generic pointer.");
317 val
= allocate_value (type
);
319 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
321 VALUE_LVAL (val
) = lval_memory
;
322 VALUE_ADDRESS (val
) = addr
;
327 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
330 value_at_lazy (type
, addr
)
334 register value_ptr val
;
336 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
337 error ("Attempt to dereference a generic pointer.");
339 val
= allocate_value (type
);
341 VALUE_LVAL (val
) = lval_memory
;
342 VALUE_ADDRESS (val
) = addr
;
343 VALUE_LAZY (val
) = 1;
348 /* Called only from the VALUE_CONTENTS macro, if the current data for
349 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
350 data from the user's process, and clears the lazy flag to indicate
351 that the data in the buffer is valid.
353 If the value is zero-length, we avoid calling read_memory, which would
354 abort. We mark the value as fetched anyway -- all 0 bytes of it.
356 This function returns a value because it is used in the VALUE_CONTENTS
357 macro as part of an expression, where a void would not work. The
361 value_fetch_lazy (val
)
362 register value_ptr val
;
364 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
366 if (TYPE_LENGTH (VALUE_TYPE (val
)))
367 read_memory (addr
, VALUE_CONTENTS_RAW (val
),
368 TYPE_LENGTH (VALUE_TYPE (val
)));
369 VALUE_LAZY (val
) = 0;
374 /* Store the contents of FROMVAL into the location of TOVAL.
375 Return a new value with the location of TOVAL and contents of FROMVAL. */
378 value_assign (toval
, fromval
)
379 register value_ptr toval
, fromval
;
381 register struct type
*type
;
382 register value_ptr val
;
383 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
386 if (!toval
->modifiable
)
387 error ("Left operand of assignment is not a modifiable lvalue.");
389 COERCE_ARRAY (fromval
);
392 type
= VALUE_TYPE (toval
);
393 if (VALUE_LVAL (toval
) != lval_internalvar
)
394 fromval
= value_cast (type
, fromval
);
396 /* If TOVAL is a special machine register requiring conversion
397 of program values to a special raw format,
398 convert FROMVAL's contents now, with result in `raw_buffer',
399 and set USE_BUFFER to the number of bytes to write. */
401 #ifdef REGISTER_CONVERTIBLE
402 if (VALUE_REGNO (toval
) >= 0
403 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
405 int regno
= VALUE_REGNO (toval
);
406 if (REGISTER_CONVERTIBLE (regno
))
408 REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval
), regno
,
409 VALUE_CONTENTS (fromval
), raw_buffer
);
410 use_buffer
= REGISTER_RAW_SIZE (regno
);
415 switch (VALUE_LVAL (toval
))
417 case lval_internalvar
:
418 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
421 case lval_internalvar_component
:
422 set_internalvar_component (VALUE_INTERNALVAR (toval
),
423 VALUE_OFFSET (toval
),
424 VALUE_BITPOS (toval
),
425 VALUE_BITSIZE (toval
),
430 if (VALUE_BITSIZE (toval
))
432 char buffer
[sizeof (LONGEST
)];
433 /* We assume that the argument to read_memory is in units of
434 host chars. FIXME: Is that correct? */
435 int len
= (VALUE_BITPOS (toval
)
436 + VALUE_BITSIZE (toval
)
440 if (len
> sizeof (LONGEST
))
441 error ("Can't handle bitfields which don't fit in a %d bit word.",
442 sizeof (LONGEST
) * HOST_CHAR_BIT
);
444 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
446 modify_field (buffer
, value_as_long (fromval
),
447 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
448 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
452 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
453 raw_buffer
, use_buffer
);
455 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
456 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
460 if (VALUE_BITSIZE (toval
))
462 char buffer
[sizeof (LONGEST
)];
463 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
465 if (len
> sizeof (LONGEST
))
466 error ("Can't handle bitfields in registers larger than %d bits.",
467 sizeof (LONGEST
) * HOST_CHAR_BIT
);
469 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
470 > len
* HOST_CHAR_BIT
)
471 /* Getting this right would involve being very careful about
474 Can't handle bitfield which doesn't fit in a single register.");
476 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
478 modify_field (buffer
, value_as_long (fromval
),
479 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
480 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
484 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
485 raw_buffer
, use_buffer
);
488 /* Do any conversion necessary when storing this type to more
489 than one register. */
490 #ifdef REGISTER_CONVERT_FROM_TYPE
491 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
492 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
493 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
494 raw_buffer
, TYPE_LENGTH (type
));
496 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
497 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
500 /* Assigning to the stack pointer, frame pointer, and other
501 (architecture and calling convention specific) registers may
502 cause the frame cache to be out of date. We just do this
503 on all assignments to registers for simplicity; I doubt the slowdown
505 reinit_frame_cache ();
508 case lval_reg_frame_relative
:
510 /* value is stored in a series of registers in the frame
511 specified by the structure. Copy that value out, modify
512 it, and copy it back in. */
513 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
514 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
515 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
516 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
519 /* Make the buffer large enough in all cases. */
520 char *buffer
= (char *) alloca (amount_to_copy
522 + MAX_REGISTER_RAW_SIZE
);
525 struct frame_info
*frame
;
527 /* Figure out which frame this is in currently. */
528 for (frame
= get_current_frame ();
529 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
530 frame
= get_prev_frame (frame
))
534 error ("Value being assigned to is no longer active.");
536 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
539 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
541 amount_copied
< amount_to_copy
;
542 amount_copied
+= reg_size
, regno
++)
544 get_saved_register (buffer
+ amount_copied
,
545 (int *)NULL
, (CORE_ADDR
*)NULL
,
546 frame
, regno
, (enum lval_type
*)NULL
);
549 /* Modify what needs to be modified. */
550 if (VALUE_BITSIZE (toval
))
551 modify_field (buffer
+ byte_offset
,
552 value_as_long (fromval
),
553 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
555 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
557 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
561 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
563 amount_copied
< amount_to_copy
;
564 amount_copied
+= reg_size
, regno
++)
570 /* Just find out where to put it. */
571 get_saved_register ((char *)NULL
,
572 &optim
, &addr
, frame
, regno
, &lval
);
575 error ("Attempt to assign to a value that was optimized out.");
576 if (lval
== lval_memory
)
577 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
578 else if (lval
== lval_register
)
579 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
581 error ("Attempt to assign to an unmodifiable value.");
588 error ("Left operand of assignment is not an lvalue.");
591 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
592 If the field is signed, and is negative, then sign extend. */
593 if ((VALUE_BITSIZE (toval
) > 0)
594 && (VALUE_BITSIZE (toval
) < 8 * sizeof (LONGEST
)))
596 LONGEST fieldval
= value_as_long (fromval
);
597 LONGEST valmask
= (((unsigned LONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
600 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
601 fieldval
|= ~valmask
;
603 fromval
= value_from_longest (type
, fieldval
);
606 /* Return a value just like TOVAL except with the contents of FROMVAL
607 (except in the case of the type if TOVAL is an internalvar). */
609 if (VALUE_LVAL (toval
) == lval_internalvar
610 || VALUE_LVAL (toval
) == lval_internalvar_component
)
612 type
= VALUE_TYPE (fromval
);
615 val
= value_copy (toval
);
616 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
618 VALUE_TYPE (val
) = type
;
623 /* Extend a value VAL to COUNT repetitions of its type. */
626 value_repeat (arg1
, count
)
630 register value_ptr val
;
632 if (VALUE_LVAL (arg1
) != lval_memory
)
633 error ("Only values in memory can be extended with '@'.");
635 error ("Invalid number %d of repetitions.", count
);
637 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
639 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
640 VALUE_CONTENTS_RAW (val
),
641 TYPE_LENGTH (VALUE_TYPE (val
)));
642 VALUE_LVAL (val
) = lval_memory
;
643 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
649 value_of_variable (var
, b
)
654 struct frame_info
*frame
;
657 /* Use selected frame. */
661 frame
= block_innermost_frame (b
);
662 if (frame
== NULL
&& symbol_read_needs_frame (var
))
664 if (BLOCK_FUNCTION (b
) != NULL
665 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
666 error ("No frame is currently executing in block %s.",
667 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
669 error ("No frame is currently executing in specified block");
672 val
= read_var_value (var
, frame
);
674 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
678 /* Given a value which is an array, return a value which is a pointer to its
679 first element, regardless of whether or not the array has a nonzero lower
682 FIXME: A previous comment here indicated that this routine should be
683 substracting the array's lower bound. It's not clear to me that this
684 is correct. Given an array subscripting operation, it would certainly
685 work to do the adjustment here, essentially computing:
687 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
689 However I believe a more appropriate and logical place to account for
690 the lower bound is to do so in value_subscript, essentially computing:
692 (&array[0] + ((index - lowerbound) * sizeof array[0]))
694 As further evidence consider what would happen with operations other
695 than array subscripting, where the caller would get back a value that
696 had an address somewhere before the actual first element of the array,
697 and the information about the lower bound would be lost because of
698 the coercion to pointer type.
702 value_coerce_array (arg1
)
705 register struct type
*type
;
707 if (VALUE_LVAL (arg1
) != lval_memory
)
708 error ("Attempt to take address of value not located in memory.");
710 /* Get type of elements. */
711 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_ARRAY
712 || TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_STRING
)
713 type
= TYPE_TARGET_TYPE (VALUE_TYPE (arg1
));
715 /* A phony array made by value_repeat.
716 Its type is the type of the elements, not an array type. */
717 type
= VALUE_TYPE (arg1
);
719 return value_from_longest (lookup_pointer_type (type
),
720 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
723 /* Given a value which is a function, return a value which is a pointer
727 value_coerce_function (arg1
)
731 if (VALUE_LVAL (arg1
) != lval_memory
)
732 error ("Attempt to take address of value not located in memory.");
734 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
735 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
738 /* Return a pointer value for the object for which ARG1 is the contents. */
744 struct type
*type
= VALUE_TYPE (arg1
);
745 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
747 /* Copy the value, but change the type from (T&) to (T*).
748 We keep the same location information, which is efficient,
749 and allows &(&X) to get the location containing the reference. */
750 value_ptr arg2
= value_copy (arg1
);
751 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
754 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
755 return value_coerce_function (arg1
);
757 if (VALUE_LVAL (arg1
) != lval_memory
)
758 error ("Attempt to take address of value not located in memory.");
760 return value_from_longest (lookup_pointer_type (type
),
761 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
764 /* Given a value of a pointer type, apply the C unary * operator to it. */
772 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_MEMBER
)
773 error ("not implemented: member types in value_ind");
775 /* Allow * on an integer so we can cast it to whatever we want.
776 This returns an int, which seems like the most C-like thing
777 to do. "long long" variables are rare enough that
778 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
779 if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_INT
)
780 return value_at (builtin_type_int
,
781 (CORE_ADDR
) value_as_long (arg1
));
782 else if (TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
)
783 return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)),
784 value_as_pointer (arg1
));
785 error ("Attempt to take contents of a non-pointer value.");
786 return 0; /* For lint -- never reached */
789 /* Pushing small parts of stack frames. */
791 /* Push one word (the size of object that a register holds). */
796 unsigned LONGEST word
;
798 register int len
= REGISTER_SIZE
;
799 char buffer
[MAX_REGISTER_RAW_SIZE
];
801 store_unsigned_integer (buffer
, len
, word
);
804 write_memory (sp
, buffer
, len
);
805 #else /* stack grows upward */
806 write_memory (sp
, buffer
, len
);
808 #endif /* stack grows upward */
813 /* Push LEN bytes with data at BUFFER. */
816 push_bytes (sp
, buffer
, len
)
823 write_memory (sp
, buffer
, len
);
824 #else /* stack grows upward */
825 write_memory (sp
, buffer
, len
);
827 #endif /* stack grows upward */
832 /* Push onto the stack the specified value VALUE. */
836 register CORE_ADDR sp
;
839 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
843 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
844 #else /* stack grows upward */
845 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
847 #endif /* stack grows upward */
852 /* Perform the standard coercions that are specified
853 for arguments to be passed to C functions.
855 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
858 value_arg_coerce (arg
, param_type
)
860 struct type
*param_type
;
862 register struct type
*type
;
864 #if 1 /* FIXME: This is only a temporary patch. -fnf */
865 if (current_language
->c_style_arrays
866 && TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_ARRAY
)
867 arg
= value_coerce_array (arg
);
870 type
= param_type
? param_type
: VALUE_TYPE (arg
);
872 switch (TYPE_CODE (type
))
875 if (TYPE_CODE (VALUE_TYPE (arg
)) != TYPE_CODE_REF
)
877 arg
= value_addr (arg
);
878 VALUE_TYPE (arg
) = param_type
;
886 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
887 type
= builtin_type_int
;
890 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
891 type
= builtin_type_double
;
894 type
= lookup_pointer_type (type
);
896 case TYPE_CODE_UNDEF
:
898 case TYPE_CODE_ARRAY
:
899 case TYPE_CODE_STRUCT
:
900 case TYPE_CODE_UNION
:
903 case TYPE_CODE_RANGE
:
904 case TYPE_CODE_STRING
:
905 case TYPE_CODE_BITSTRING
:
906 case TYPE_CODE_ERROR
:
907 case TYPE_CODE_MEMBER
:
908 case TYPE_CODE_METHOD
:
909 case TYPE_CODE_COMPLEX
:
914 return value_cast (type
, arg
);
917 /* Determine a function's address and its return type from its value.
918 Calls error() if the function is not valid for calling. */
921 find_function_addr (function
, retval_type
)
923 struct type
**retval_type
;
925 register struct type
*ftype
= VALUE_TYPE (function
);
926 register enum type_code code
= TYPE_CODE (ftype
);
927 struct type
*value_type
;
930 /* If it's a member function, just look at the function
933 /* Determine address to call. */
934 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
936 funaddr
= VALUE_ADDRESS (function
);
937 value_type
= TYPE_TARGET_TYPE (ftype
);
939 else if (code
== TYPE_CODE_PTR
)
941 funaddr
= value_as_pointer (function
);
942 if (TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_FUNC
943 || TYPE_CODE (TYPE_TARGET_TYPE (ftype
)) == TYPE_CODE_METHOD
)
945 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
946 /* FIXME: This is a workaround for the unusual function
947 pointer representation on the RS/6000, see comment
948 in config/rs6000/tm-rs6000.h */
949 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
951 value_type
= TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
));
954 value_type
= builtin_type_int
;
956 else if (code
== TYPE_CODE_INT
)
958 /* Handle the case of functions lacking debugging info.
959 Their values are characters since their addresses are char */
960 if (TYPE_LENGTH (ftype
) == 1)
961 funaddr
= value_as_pointer (value_addr (function
));
963 /* Handle integer used as address of a function. */
964 funaddr
= (CORE_ADDR
) value_as_long (function
);
966 value_type
= builtin_type_int
;
969 error ("Invalid data type for function to be called.");
971 *retval_type
= value_type
;
975 #if defined (CALL_DUMMY)
976 /* All this stuff with a dummy frame may seem unnecessarily complicated
977 (why not just save registers in GDB?). The purpose of pushing a dummy
978 frame which looks just like a real frame is so that if you call a
979 function and then hit a breakpoint (get a signal, etc), "backtrace"
980 will look right. Whether the backtrace needs to actually show the
981 stack at the time the inferior function was called is debatable, but
982 it certainly needs to not display garbage. So if you are contemplating
983 making dummy frames be different from normal frames, consider that. */
985 /* Perform a function call in the inferior.
986 ARGS is a vector of values of arguments (NARGS of them).
987 FUNCTION is a value, the function to be called.
988 Returns a value representing what the function returned.
989 May fail to return, if a breakpoint or signal is hit
990 during the execution of the function.
992 ARGS is modified to contain coerced values. */
995 call_function_by_hand (function
, nargs
, args
)
1000 register CORE_ADDR sp
;
1003 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1004 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1005 and remove any extra bytes which might exist because unsigned LONGEST is
1006 bigger than REGISTER_SIZE. */
1007 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
1008 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
1010 struct type
*value_type
;
1011 unsigned char struct_return
;
1012 CORE_ADDR struct_addr
;
1013 struct inferior_status inf_status
;
1014 struct cleanup
*old_chain
;
1018 struct type
*ftype
= SYMBOL_TYPE (function
);
1020 if (!target_has_execution
)
1023 save_inferior_status (&inf_status
, 1);
1024 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
1026 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1027 (and POP_FRAME for restoring them). (At least on most machines)
1028 they are saved on the stack in the inferior. */
1031 old_sp
= sp
= read_sp ();
1033 #if 1 INNER_THAN 2 /* Stack grows down */
1034 sp
-= sizeof dummy1
;
1036 #else /* Stack grows up */
1038 sp
+= sizeof dummy1
;
1041 funaddr
= find_function_addr (function
, &value_type
);
1044 struct block
*b
= block_for_pc (funaddr
);
1045 /* If compiled without -g, assume GCC. */
1046 using_gcc
= b
== NULL
? 0 : BLOCK_GCC_COMPILED (b
);
1049 /* Are we returning a value using a structure return or a normal
1052 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1055 /* Create a call sequence customized for this function
1056 and the number of arguments for it. */
1057 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
1058 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1060 (unsigned LONGEST
)dummy
[i
]);
1062 #ifdef GDB_TARGET_IS_HPPA
1063 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1064 value_type
, using_gcc
);
1066 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1067 value_type
, using_gcc
);
1071 #if CALL_DUMMY_LOCATION == ON_STACK
1072 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1073 #endif /* On stack. */
1075 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1076 /* Convex Unix prohibits executing in the stack segment. */
1077 /* Hope there is empty room at the top of the text segment. */
1079 extern CORE_ADDR text_end
;
1082 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1083 if (read_memory_integer (start_sp
, 1) != 0)
1084 error ("text segment full -- no place to put call");
1087 real_pc
= text_end
- sizeof dummy1
;
1088 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1090 #endif /* Before text_end. */
1092 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1094 extern CORE_ADDR text_end
;
1098 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1100 error ("Cannot write text segment -- call_function failed");
1102 #endif /* After text_end. */
1104 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1106 #endif /* At entry point. */
1109 sp
= old_sp
; /* It really is used, for some ifdef's... */
1112 if (nargs
< TYPE_NFIELDS (ftype
))
1113 error ("too few arguments in function call");
1115 for (i
= nargs
- 1; i
>= 0; i
--)
1117 struct type
*param_type
;
1118 if (TYPE_NFIELDS (ftype
) > i
)
1119 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1122 args
[i
] = value_arg_coerce (args
[i
], param_type
);
1125 #if defined (REG_STRUCT_HAS_ADDR)
1127 /* This is a machine like the sparc, where we may need to pass a pointer
1128 to the structure, not the structure itself. */
1129 for (i
= nargs
- 1; i
>= 0; i
--)
1130 if ((TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRUCT
1131 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_UNION
1132 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_ARRAY
1133 || TYPE_CODE (VALUE_TYPE (args
[i
])) == TYPE_CODE_STRING
)
1134 && REG_STRUCT_HAS_ADDR (using_gcc
, VALUE_TYPE (args
[i
])))
1137 int len
= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1139 int aligned_len
= STACK_ALIGN (len
);
1141 int aligned_len
= len
;
1143 #if !(1 INNER_THAN 2)
1144 /* The stack grows up, so the address of the thing we push
1145 is the stack pointer before we push it. */
1150 /* Push the structure. */
1151 write_memory (sp
, VALUE_CONTENTS (args
[i
]), len
);
1153 /* The stack grows down, so the address of the thing we push
1154 is the stack pointer after we push it. */
1159 /* The value we're going to pass is the address of the thing
1161 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1165 #endif /* REG_STRUCT_HAS_ADDR. */
1167 /* Reserve space for the return structure to be written on the
1168 stack, if necessary */
1172 int len
= TYPE_LENGTH (value_type
);
1174 len
= STACK_ALIGN (len
);
1186 /* If stack grows down, we must leave a hole at the top. */
1190 for (i
= nargs
- 1; i
>= 0; i
--)
1191 len
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1192 #ifdef CALL_DUMMY_STACK_ADJUST
1193 len
+= CALL_DUMMY_STACK_ADJUST
;
1196 sp
-= STACK_ALIGN (len
) - len
;
1198 sp
+= STACK_ALIGN (len
) - len
;
1201 #endif /* STACK_ALIGN */
1203 #ifdef PUSH_ARGUMENTS
1204 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1205 #else /* !PUSH_ARGUMENTS */
1206 for (i
= nargs
- 1; i
>= 0; i
--)
1207 sp
= value_push (sp
, args
[i
]);
1208 #endif /* !PUSH_ARGUMENTS */
1210 #ifdef CALL_DUMMY_STACK_ADJUST
1212 sp
-= CALL_DUMMY_STACK_ADJUST
;
1214 sp
+= CALL_DUMMY_STACK_ADJUST
;
1216 #endif /* CALL_DUMMY_STACK_ADJUST */
1218 /* Store the address at which the structure is supposed to be
1219 written. Note that this (and the code which reserved the space
1220 above) assumes that gcc was used to compile this function. Since
1221 it doesn't cost us anything but space and if the function is pcc
1222 it will ignore this value, we will make that assumption.
1224 Also note that on some machines (like the sparc) pcc uses a
1225 convention like gcc's. */
1228 STORE_STRUCT_RETURN (struct_addr
, sp
);
1230 /* Write the stack pointer. This is here because the statements above
1231 might fool with it. On SPARC, this write also stores the register
1232 window into the right place in the new stack frame, which otherwise
1233 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1237 char retbuf
[REGISTER_BYTES
];
1239 struct symbol
*symbol
;
1242 symbol
= find_pc_function (funaddr
);
1245 name
= SYMBOL_SOURCE_NAME (symbol
);
1249 /* Try the minimal symbols. */
1250 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1254 name
= SYMBOL_SOURCE_NAME (msymbol
);
1260 sprintf (format
, "at %s", local_hex_format ());
1262 /* FIXME-32x64: assumes funaddr fits in a long. */
1263 sprintf (name
, format
, (unsigned long) funaddr
);
1266 /* Execute the stack dummy routine, calling FUNCTION.
1267 When it is done, discard the empty frame
1268 after storing the contents of all regs into retbuf. */
1269 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1271 /* We stopped somewhere besides the call dummy. */
1273 /* If we did the cleanups, we would print a spurious error message
1274 (Unable to restore previously selected frame), would write the
1275 registers from the inf_status (which is wrong), and would do other
1276 wrong things (like set stop_bpstat to the wrong thing). */
1277 discard_cleanups (old_chain
);
1278 /* Prevent memory leak. */
1279 bpstat_clear (&inf_status
.stop_bpstat
);
1281 /* The following error message used to say "The expression
1282 which contained the function call has been discarded." It
1283 is a hard concept to explain in a few words. Ideally, GDB
1284 would be able to resume evaluation of the expression when
1285 the function finally is done executing. Perhaps someday
1286 this will be implemented (it would not be easy). */
1288 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1289 a C++ name with arguments and stuff. */
1291 The program being debugged stopped while in a function called from GDB.\n\
1292 When the function (%s) is done executing, GDB will silently\n\
1293 stop (instead of continuing to evaluate the expression containing\n\
1294 the function call).", name
);
1297 do_cleanups (old_chain
);
1299 /* Figure out the value returned by the function. */
1300 return value_being_returned (value_type
, retbuf
, struct_return
);
1303 #else /* no CALL_DUMMY. */
1305 call_function_by_hand (function
, nargs
, args
)
1310 error ("Cannot invoke functions on this machine.");
1312 #endif /* no CALL_DUMMY. */
1315 /* Create a value for an array by allocating space in the inferior, copying
1316 the data into that space, and then setting up an array value.
1318 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1319 populated from the values passed in ELEMVEC.
1321 The element type of the array is inherited from the type of the
1322 first element, and all elements must have the same size (though we
1323 don't currently enforce any restriction on their types). */
1326 value_array (lowbound
, highbound
, elemvec
)
1335 struct type
*rangetype
;
1336 struct type
*arraytype
;
1339 /* Validate that the bounds are reasonable and that each of the elements
1340 have the same size. */
1342 nelem
= highbound
- lowbound
+ 1;
1345 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1347 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1348 for (idx
= 0; idx
< nelem
; idx
++)
1350 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1352 error ("array elements must all be the same size");
1356 /* Allocate space to store the array in the inferior, and then initialize
1357 it by copying in each element. FIXME: Is it worth it to create a
1358 local buffer in which to collect each value and then write all the
1359 bytes in one operation? */
1361 addr
= allocate_space_in_inferior (nelem
* typelength
);
1362 for (idx
= 0; idx
< nelem
; idx
++)
1364 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1368 /* Create the array type and set up an array value to be evaluated lazily. */
1370 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1371 lowbound
, highbound
);
1372 arraytype
= create_array_type ((struct type
*) NULL
,
1373 VALUE_TYPE (elemvec
[0]), rangetype
);
1374 val
= value_at_lazy (arraytype
, addr
);
1378 /* Create a value for a string constant by allocating space in the inferior,
1379 copying the data into that space, and returning the address with type
1380 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1382 Note that string types are like array of char types with a lower bound of
1383 zero and an upper bound of LEN - 1. Also note that the string may contain
1384 embedded null bytes. */
1387 value_string (ptr
, len
)
1392 int lowbound
= current_language
->string_lower_bound
;
1393 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1395 lowbound
, len
+ lowbound
- 1);
1396 struct type
*stringtype
1397 = create_string_type ((struct type
*) NULL
, rangetype
);
1400 if (current_language
->c_style_arrays
== 0)
1402 val
= allocate_value (stringtype
);
1403 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1408 /* Allocate space to store the string in the inferior, and then
1409 copy LEN bytes from PTR in gdb to that address in the inferior. */
1411 addr
= allocate_space_in_inferior (len
);
1412 write_memory (addr
, ptr
, len
);
1414 val
= value_at_lazy (stringtype
, addr
);
1419 value_bitstring (ptr
, len
)
1424 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1426 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1427 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1428 val
= allocate_value (type
);
1429 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1433 /* See if we can pass arguments in T2 to a function which takes arguments
1434 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1435 arguments need coercion of some sort, then the coerced values are written
1436 into T2. Return value is 0 if the arguments could be matched, or the
1437 position at which they differ if not.
1439 STATICP is nonzero if the T1 argument list came from a
1440 static member function.
1442 For non-static member functions, we ignore the first argument,
1443 which is the type of the instance variable. This is because we want
1444 to handle calls with objects from derived classes. This is not
1445 entirely correct: we should actually check to make sure that a
1446 requested operation is type secure, shouldn't we? FIXME. */
1449 typecmp (staticp
, t1
, t2
)
1458 if (staticp
&& t1
== 0)
1462 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1463 if (t1
[!staticp
] == 0) return 0;
1464 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1466 struct type
*tt1
, *tt2
;
1470 tt2
= VALUE_TYPE(t2
[i
]);
1471 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1472 /* We should be doing hairy argument matching, as below. */
1473 && (TYPE_CODE (TYPE_TARGET_TYPE (tt1
)) == TYPE_CODE (tt2
)))
1475 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1476 t2
[i
] = value_coerce_array (t2
[i
]);
1478 t2
[i
] = value_addr (t2
[i
]);
1482 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1483 && (TYPE_CODE(tt2
)==TYPE_CODE_ARRAY
|| TYPE_CODE(tt2
)==TYPE_CODE_PTR
))
1485 tt1
= TYPE_TARGET_TYPE(tt1
);
1486 tt2
= TYPE_TARGET_TYPE(tt2
);
1488 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1489 /* Array to pointer is a `trivial conversion' according to the ARM. */
1491 /* We should be doing much hairier argument matching (see section 13.2
1492 of the ARM), but as a quick kludge, just check for the same type
1494 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1497 if (!t1
[i
]) return 0;
1498 return t2
[i
] ? i
+1 : 0;
1501 /* Helper function used by value_struct_elt to recurse through baseclasses.
1502 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1503 and search in it assuming it has (class) type TYPE.
1504 If found, return value, else return NULL.
1506 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1507 look for a baseclass named NAME. */
1510 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1512 register value_ptr arg1
;
1514 register struct type
*type
;
1515 int looking_for_baseclass
;
1519 check_stub_type (type
);
1521 if (! looking_for_baseclass
)
1522 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1524 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1526 if (t_field_name
&& STREQ (t_field_name
, name
))
1529 if (TYPE_FIELD_STATIC (type
, i
))
1531 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1532 struct symbol
*sym
=
1533 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1535 error ("Internal error: could not find physical static variable named %s",
1537 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1538 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1541 v
= value_primitive_field (arg1
, offset
, i
, type
);
1543 error("there is no field named %s", name
);
1548 && (t_field_name
[0] == '\0'
1549 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1550 && STREQ (t_field_name
, "else"))))
1552 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1553 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1554 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1556 /* Look for a match through the fields of an anonymous union,
1557 or anonymous struct. C++ provides anonymous unions.
1559 In the GNU Chill implementation of variant record types,
1560 each <alternative field> has an (anonymous) union type,
1561 each member of the union represents a <variant alternative>.
1562 Each <variant alternative> is represented as a struct,
1563 with a member for each <variant field>. */
1566 int new_offset
= offset
;
1568 /* This is pretty gross. In G++, the offset in an anonymous
1569 union is relative to the beginning of the enclosing struct.
1570 In the GNU Chill implementation of variant records,
1571 the bitpos is zero in an anonymous union field, so we
1572 have to add the offset of the union here. */
1573 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1574 || (TYPE_NFIELDS (field_type
) > 0
1575 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1576 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1578 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
1579 looking_for_baseclass
);
1586 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1589 /* If we are looking for baseclasses, this is what we get when we
1590 hit them. But it could happen that the base part's member name
1591 is not yet filled in. */
1592 int found_baseclass
= (looking_for_baseclass
1593 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1594 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1596 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1599 /* Fix to use baseclass_offset instead. FIXME */
1600 baseclass_addr (type
, i
, VALUE_CONTENTS (arg1
) + offset
,
1603 error ("virtual baseclass botch");
1604 if (found_baseclass
)
1606 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1607 looking_for_baseclass
);
1609 else if (found_baseclass
)
1610 v
= value_primitive_field (arg1
, offset
, i
, type
);
1612 v
= search_struct_field (name
, arg1
,
1613 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1614 TYPE_BASECLASS (type
, i
),
1615 looking_for_baseclass
);
1621 /* Helper function used by value_struct_elt to recurse through baseclasses.
1622 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1623 and search in it assuming it has (class) type TYPE.
1624 If found, return value, else if name matched and args not return (value)-1,
1625 else return NULL. */
1628 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1630 register value_ptr
*arg1p
, *args
;
1631 int offset
, *static_memfuncp
;
1632 register struct type
*type
;
1636 int name_matched
= 0;
1637 char dem_opname
[64];
1639 check_stub_type (type
);
1640 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1642 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1643 if (strncmp(t_field_name
, "__", 2)==0 ||
1644 strncmp(t_field_name
, "op", 2)==0 ||
1645 strncmp(t_field_name
, "type", 4)==0 )
1647 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1648 t_field_name
= dem_opname
;
1649 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1650 t_field_name
= dem_opname
;
1652 if (t_field_name
&& STREQ (t_field_name
, name
))
1654 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1655 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1658 if (j
> 0 && args
== 0)
1659 error ("cannot resolve overloaded method `%s'", name
);
1662 if (TYPE_FN_FIELD_STUB (f
, j
))
1663 check_stub_method (type
, i
, j
);
1664 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1665 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1667 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1668 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1669 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1670 *static_memfuncp
= 1;
1671 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1672 if (v
!= NULL
) return v
;
1679 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1683 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1685 base_offset
= baseclass_offset (type
, i
, *arg1p
, offset
);
1686 if (base_offset
== -1)
1687 error ("virtual baseclass botch");
1691 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1693 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1694 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1695 if (v
== (value_ptr
) -1)
1701 /* FIXME-bothner: Why is this commented out? Why is it here? */
1702 /* *arg1p = arg1_tmp;*/
1706 if (name_matched
) return (value_ptr
) -1;
1710 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1711 extract the component named NAME from the ultimate target structure/union
1712 and return it as a value with its appropriate type.
1713 ERR is used in the error message if *ARGP's type is wrong.
1715 C++: ARGS is a list of argument types to aid in the selection of
1716 an appropriate method. Also, handle derived types.
1718 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1719 where the truthvalue of whether the function that was resolved was
1720 a static member function or not is stored.
1722 ERR is an error message to be printed in case the field is not found. */
1725 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1726 register value_ptr
*argp
, *args
;
1728 int *static_memfuncp
;
1731 register struct type
*t
;
1734 COERCE_ARRAY (*argp
);
1736 t
= VALUE_TYPE (*argp
);
1738 /* Follow pointers until we get to a non-pointer. */
1740 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1742 *argp
= value_ind (*argp
);
1743 /* Don't coerce fn pointer to fn and then back again! */
1744 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1745 COERCE_ARRAY (*argp
);
1746 t
= VALUE_TYPE (*argp
);
1749 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1750 error ("not implemented: member type in value_struct_elt");
1752 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1753 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1754 error ("Attempt to extract a component of a value that is not a %s.", err
);
1756 /* Assume it's not, unless we see that it is. */
1757 if (static_memfuncp
)
1758 *static_memfuncp
=0;
1762 /* if there are no arguments ...do this... */
1764 /* Try as a field first, because if we succeed, there
1765 is less work to be done. */
1766 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1770 /* C++: If it was not found as a data field, then try to
1771 return it as a pointer to a method. */
1773 if (destructor_name_p (name
, t
))
1774 error ("Cannot get value of destructor");
1776 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1778 if (v
== (value_ptr
) -1)
1779 error ("Cannot take address of a method");
1782 if (TYPE_NFN_FIELDS (t
))
1783 error ("There is no member or method named %s.", name
);
1785 error ("There is no member named %s.", name
);
1790 if (destructor_name_p (name
, t
))
1794 /* destructors are a special case. */
1795 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1796 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1797 if (!v
) error("could not find destructor function named %s.", name
);
1802 error ("destructor should not have any argument");
1806 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1808 if (v
== (value_ptr
) -1)
1810 error("Argument list of %s mismatch with component in the structure.", name
);
1814 /* See if user tried to invoke data as function. If so,
1815 hand it back. If it's not callable (i.e., a pointer to function),
1816 gdb should give an error. */
1817 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1821 error ("Structure has no component named %s.", name
);
1825 /* C++: return 1 is NAME is a legitimate name for the destructor
1826 of type TYPE. If TYPE does not have a destructor, or
1827 if NAME is inappropriate for TYPE, an error is signaled. */
1829 destructor_name_p (name
, type
)
1831 const struct type
*type
;
1833 /* destructors are a special case. */
1837 char *dname
= type_name_no_tag (type
);
1838 char *cp
= strchr (dname
, '<');
1841 /* Do not compare the template part for template classes. */
1843 len
= strlen (dname
);
1846 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
1847 error ("name of destructor must equal name of class");
1854 /* Helper function for check_field: Given TYPE, a structure/union,
1855 return 1 if the component named NAME from the ultimate
1856 target structure/union is defined, otherwise, return 0. */
1859 check_field_in (type
, name
)
1860 register struct type
*type
;
1865 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1867 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1868 if (t_field_name
&& STREQ (t_field_name
, name
))
1872 /* C++: If it was not found as a data field, then try to
1873 return it as a pointer to a method. */
1875 /* Destructors are a special case. */
1876 if (destructor_name_p (name
, type
))
1879 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1881 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1885 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1886 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1893 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1894 return 1 if the component named NAME from the ultimate
1895 target structure/union is defined, otherwise, return 0. */
1898 check_field (arg1
, name
)
1899 register value_ptr arg1
;
1902 register struct type
*t
;
1904 COERCE_ARRAY (arg1
);
1906 t
= VALUE_TYPE (arg1
);
1908 /* Follow pointers until we get to a non-pointer. */
1910 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1911 t
= TYPE_TARGET_TYPE (t
);
1913 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1914 error ("not implemented: member type in check_field");
1916 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1917 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1918 error ("Internal error: `this' is not an aggregate");
1920 return check_field_in (t
, name
);
1923 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1924 return the address of this member as a "pointer to member"
1925 type. If INTYPE is non-null, then it will be the type
1926 of the member we are looking for. This will help us resolve
1927 "pointers to member functions". This function is used
1928 to resolve user expressions of the form "DOMAIN::NAME". */
1931 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1932 struct type
*domain
, *curtype
, *intype
;
1936 register struct type
*t
= curtype
;
1940 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1941 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1942 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1944 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
1946 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
1948 if (t_field_name
&& STREQ (t_field_name
, name
))
1950 if (TYPE_FIELD_STATIC (t
, i
))
1952 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
1953 struct symbol
*sym
=
1954 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1956 error ("Internal error: could not find physical static variable named %s",
1958 return value_at (SYMBOL_TYPE (sym
),
1959 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1961 if (TYPE_FIELD_PACKED (t
, i
))
1962 error ("pointers to bitfield members not allowed");
1964 return value_from_longest
1965 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
1967 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
1971 /* C++: If it was not found as a data field, then try to
1972 return it as a pointer to a method. */
1974 /* Destructors are a special case. */
1975 if (destructor_name_p (name
, t
))
1977 error ("member pointers to destructors not implemented yet");
1980 /* Perform all necessary dereferencing. */
1981 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
1982 intype
= TYPE_TARGET_TYPE (intype
);
1984 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
1986 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
1987 char dem_opname
[64];
1989 if (strncmp(t_field_name
, "__", 2)==0 ||
1990 strncmp(t_field_name
, "op", 2)==0 ||
1991 strncmp(t_field_name
, "type", 4)==0 )
1993 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1994 t_field_name
= dem_opname
;
1995 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1996 t_field_name
= dem_opname
;
1998 if (t_field_name
&& STREQ (t_field_name
, name
))
2000 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2001 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2003 if (intype
== 0 && j
> 1)
2004 error ("non-unique member `%s' requires type instantiation", name
);
2008 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2011 error ("no member function matches that type instantiation");
2016 if (TYPE_FN_FIELD_STUB (f
, j
))
2017 check_stub_method (t
, i
, j
);
2018 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2020 return value_from_longest
2021 (lookup_reference_type
2022 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2024 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
2028 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2029 0, VAR_NAMESPACE
, 0, NULL
);
2036 v
= read_var_value (s
, 0);
2038 VALUE_TYPE (v
) = lookup_reference_type
2039 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2047 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2052 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2055 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2056 v
= value_struct_elt_for_reference (domain
,
2057 offset
+ base_offset
,
2058 TYPE_BASECLASS (t
, i
),
2067 /* C++: return the value of the class instance variable, if one exists.
2068 Flag COMPLAIN signals an error if the request is made in an
2069 inappropriate context. */
2072 value_of_this (complain
)
2075 struct symbol
*func
, *sym
;
2078 static const char funny_this
[] = "this";
2081 if (selected_frame
== 0)
2083 error ("no frame selected");
2086 func
= get_frame_function (selected_frame
);
2090 error ("no `this' in nameless context");
2094 b
= SYMBOL_BLOCK_VALUE (func
);
2095 i
= BLOCK_NSYMS (b
);
2098 error ("no args, no `this'");
2101 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2102 symbol instead of the LOC_ARG one (if both exist). */
2103 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
2107 error ("current stack frame not in method");
2112 this = read_var_value (sym
, selected_frame
);
2113 if (this == 0 && complain
)
2114 error ("`this' argument at unknown address");
2118 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2119 long, starting at LOWBOUND. The result has the same lower bound as
2120 the original ARRAY. */
2123 value_slice (array
, lowbound
, length
)
2125 int lowbound
, length
;
2127 COERCE_VARYING_ARRAY (array
);
2128 if (TYPE_CODE (VALUE_TYPE (array
)) == TYPE_CODE_BITSTRING
)
2129 error ("not implemented - bitstring slice");
2130 if (TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_ARRAY
2131 && TYPE_CODE (VALUE_TYPE (array
)) != TYPE_CODE_STRING
)
2132 error ("cannot take slice of non-array");
2135 struct type
*slice_range_type
, *slice_type
;
2137 struct type
*range_type
= TYPE_FIELD_TYPE (VALUE_TYPE (array
), 0);
2138 struct type
*element_type
= TYPE_TARGET_TYPE (VALUE_TYPE (array
));
2139 int lowerbound
= TYPE_LOW_BOUND (range_type
);
2140 int upperbound
= TYPE_HIGH_BOUND (range_type
);
2141 int offset
= (lowbound
- lowerbound
) * TYPE_LENGTH (element_type
);
2142 if (lowbound
< lowerbound
|| length
< 0
2143 || lowbound
+ length
- 1 > upperbound
)
2144 error ("slice out of range");
2145 /* FIXME-type-allocation: need a way to free this type when we are
2147 slice_range_type
= create_range_type ((struct type
*) NULL
,
2148 TYPE_TARGET_TYPE (range_type
),
2150 lowerbound
+ length
- 1);
2151 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2153 TYPE_CODE (slice_type
) = TYPE_CODE (VALUE_TYPE (array
));
2154 slice
= allocate_value (slice_type
);
2155 if (VALUE_LAZY (array
))
2156 VALUE_LAZY (slice
) = 1;
2158 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2159 TYPE_LENGTH (slice_type
));
2160 if (VALUE_LVAL (array
) == lval_internalvar
)
2161 VALUE_LVAL (slice
) = lval_internalvar_component
;
2163 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2164 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2165 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2170 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2171 value as a fixed-length array. */
2174 varying_to_slice (varray
)
2177 struct type
*vtype
= VALUE_TYPE (varray
);
2178 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
2179 VALUE_CONTENTS (varray
)
2180 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
2181 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
2184 /* Create a value for a FORTRAN complex number. Currently most of
2185 the time values are coerced to COMPLEX*16 (i.e. a complex number
2186 composed of 2 doubles. This really should be a smarter routine
2187 that figures out precision inteligently as opposed to assuming
2188 doubles. FIXME: fmb */
2191 value_literal_complex (arg1
, arg2
, type
)
2196 register value_ptr val
;
2197 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2199 val
= allocate_value (type
);
2200 arg1
= value_cast (real_type
, arg1
);
2201 arg2
= value_cast (real_type
, arg2
);
2203 memcpy (VALUE_CONTENTS_RAW (val
),
2204 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2205 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2206 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2210 /* Cast a value into the appropriate complex data type. */
2213 cast_into_complex (type
, val
)
2215 register value_ptr val
;
2217 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2218 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2220 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2221 value_ptr re_val
= allocate_value (val_real_type
);
2222 value_ptr im_val
= allocate_value (val_real_type
);
2224 memcpy (VALUE_CONTENTS_RAW (re_val
),
2225 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2226 memcpy (VALUE_CONTENTS_RAW (im_val
),
2227 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2228 TYPE_LENGTH (val_real_type
));
2230 return value_literal_complex (re_val
, im_val
, type
);
2232 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2233 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2234 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2236 error ("cannot cast non-number to complex");