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)
58 /* Flag for whether we want to abandon failed expression evals by default. */
60 static int auto_abandon
= 0;
63 /* Find the address of function name NAME in the inferior. */
66 find_function_in_inferior (name
)
69 register struct symbol
*sym
;
70 sym
= lookup_symbol (name
, 0, VAR_NAMESPACE
, 0, NULL
);
73 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
75 error ("\"%s\" exists in this program but is not a function.",
78 return value_of_variable (sym
, NULL
);
82 struct minimal_symbol
*msymbol
= lookup_minimal_symbol(name
, NULL
, NULL
);
87 type
= lookup_pointer_type (builtin_type_char
);
88 type
= lookup_function_type (type
);
89 type
= lookup_pointer_type (type
);
90 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
91 return value_from_longest (type
, maddr
);
95 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
100 /* Allocate NBYTES of space in the inferior using the inferior's malloc
101 and return a value that is a pointer to the allocated space. */
104 value_allocate_space_in_inferior (len
)
108 register value_ptr val
= find_function_in_inferior ("malloc");
110 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
111 val
= call_function_by_hand (val
, 1, &blocklen
);
112 if (value_logical_not (val
))
114 error ("No memory available to program.");
120 allocate_space_in_inferior (len
)
123 return value_as_long (value_allocate_space_in_inferior (len
));
126 /* Cast value ARG2 to type TYPE and return as a value.
127 More general than a C cast: accepts any two types of the same length,
128 and if ARG2 is an lvalue it can be cast into anything at all. */
129 /* In C++, casts may change pointer or object representations. */
132 value_cast (type
, arg2
)
134 register value_ptr arg2
;
136 register enum type_code code1
;
137 register enum type_code code2
;
141 if (VALUE_TYPE (arg2
) == type
)
144 CHECK_TYPEDEF (type
);
145 code1
= TYPE_CODE (type
);
147 type2
= check_typedef (VALUE_TYPE (arg2
));
149 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
150 is treated like a cast to (TYPE [N])OBJECT,
151 where N is sizeof(OBJECT)/sizeof(TYPE). */
152 if (code1
== TYPE_CODE_ARRAY
)
154 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
155 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
156 if (element_length
> 0
157 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
159 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
160 int val_length
= TYPE_LENGTH (type2
);
161 LONGEST low_bound
, high_bound
, new_length
;
162 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
163 low_bound
= 0, high_bound
= 0;
164 new_length
= val_length
/ element_length
;
165 if (val_length
% element_length
!= 0)
166 warning("array element type size does not divide object size in cast");
167 /* FIXME-type-allocation: need a way to free this type when we are
169 range_type
= create_range_type ((struct type
*) NULL
,
170 TYPE_TARGET_TYPE (range_type
),
172 new_length
+ low_bound
- 1);
173 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
174 element_type
, range_type
);
179 if (current_language
->c_style_arrays
180 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
181 arg2
= value_coerce_array (arg2
);
183 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
184 arg2
= value_coerce_function (arg2
);
186 type2
= check_typedef (VALUE_TYPE (arg2
));
187 COERCE_VARYING_ARRAY (arg2
, type2
);
188 code2
= TYPE_CODE (type2
);
190 if (code1
== TYPE_CODE_COMPLEX
)
191 return cast_into_complex (type
, arg2
);
192 if (code1
== TYPE_CODE_BOOL
|| code1
== TYPE_CODE_CHAR
)
193 code1
= TYPE_CODE_INT
;
194 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
195 code2
= TYPE_CODE_INT
;
197 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
198 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
200 if ( code1
== TYPE_CODE_STRUCT
201 && code2
== TYPE_CODE_STRUCT
202 && TYPE_NAME (type
) != 0)
204 /* Look in the type of the source to see if it contains the
205 type of the target as a superclass. If so, we'll need to
206 offset the object in addition to changing its type. */
207 value_ptr v
= search_struct_field (type_name_no_tag (type
),
211 VALUE_TYPE (v
) = type
;
215 if (code1
== TYPE_CODE_FLT
&& scalar
)
216 return value_from_double (type
, value_as_double (arg2
));
217 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
218 || code1
== TYPE_CODE_RANGE
)
219 && (scalar
|| code2
== TYPE_CODE_PTR
))
220 return value_from_longest (type
, value_as_long (arg2
));
221 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
223 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
225 /* Look in the type of the source to see if it contains the
226 type of the target as a superclass. If so, we'll need to
227 offset the pointer rather than just change its type. */
228 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
229 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
230 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
231 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
232 && TYPE_NAME (t1
) != 0) /* if name unknown, can't have supercl */
234 value_ptr v
= search_struct_field (type_name_no_tag (t1
),
235 value_ind (arg2
), 0, t2
, 1);
239 VALUE_TYPE (v
) = type
;
243 /* No superclass found, just fall through to change ptr type. */
245 VALUE_TYPE (arg2
) = type
;
248 else if (chill_varying_type (type
))
250 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
253 LONGEST low_bound
, high_bound
;
254 char *valaddr
, *valaddr_data
;
255 if (code2
== TYPE_CODE_BITSTRING
)
256 error ("not implemented: converting bitstring to varying type");
257 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
258 || (eltype1
= check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1))),
259 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
)),
260 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
261 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
262 error ("Invalid conversion to varying type");
263 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
264 range2
= TYPE_FIELD_TYPE (type2
, 0);
265 if (get_discrete_bounds (range1
, &low_bound
, &high_bound
) < 0)
268 count1
= high_bound
- low_bound
+ 1;
269 if (get_discrete_bounds (range2
, &low_bound
, &high_bound
) < 0)
270 count1
= -1, count2
= 0; /* To force error before */
272 count2
= high_bound
- low_bound
+ 1;
274 error ("target varying type is too small");
275 val
= allocate_value (type
);
276 valaddr
= VALUE_CONTENTS_RAW (val
);
277 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
278 /* Set val's __var_length field to count2. */
279 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
281 /* Set the __var_data field to count2 elements copied from arg2. */
282 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
283 count2
* TYPE_LENGTH (eltype2
));
284 /* Zero the rest of the __var_data field of val. */
285 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
286 (count1
- count2
) * TYPE_LENGTH (eltype2
));
289 else if (VALUE_LVAL (arg2
) == lval_memory
)
291 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
));
293 else if (code1
== TYPE_CODE_VOID
)
295 return value_zero (builtin_type_void
, not_lval
);
299 error ("Invalid cast.");
304 /* Create a value of type TYPE that is zero, and return it. */
307 value_zero (type
, lv
)
311 register value_ptr val
= allocate_value (type
);
313 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (check_typedef (type
)));
314 VALUE_LVAL (val
) = lv
;
319 /* Return a value with type TYPE located at ADDR.
321 Call value_at only if the data needs to be fetched immediately;
322 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
323 value_at_lazy instead. value_at_lazy simply records the address of
324 the data and sets the lazy-evaluation-required flag. The lazy flag
325 is tested in the VALUE_CONTENTS macro, which is used if and when
326 the contents are actually required. */
329 value_at (type
, addr
)
333 register value_ptr val
;
335 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
336 error ("Attempt to dereference a generic pointer.");
338 val
= allocate_value (type
);
340 read_memory (addr
, VALUE_CONTENTS_RAW (val
), TYPE_LENGTH (type
));
342 VALUE_LVAL (val
) = lval_memory
;
343 VALUE_ADDRESS (val
) = addr
;
348 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
351 value_at_lazy (type
, addr
)
355 register value_ptr val
;
357 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
358 error ("Attempt to dereference a generic pointer.");
360 val
= allocate_value (type
);
362 VALUE_LVAL (val
) = lval_memory
;
363 VALUE_ADDRESS (val
) = addr
;
364 VALUE_LAZY (val
) = 1;
369 /* Called only from the VALUE_CONTENTS macro, if the current data for
370 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
371 data from the user's process, and clears the lazy flag to indicate
372 that the data in the buffer is valid.
374 If the value is zero-length, we avoid calling read_memory, which would
375 abort. We mark the value as fetched anyway -- all 0 bytes of it.
377 This function returns a value because it is used in the VALUE_CONTENTS
378 macro as part of an expression, where a void would not work. The
382 value_fetch_lazy (val
)
383 register value_ptr val
;
385 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
386 int length
= TYPE_LENGTH (VALUE_TYPE (val
));
389 read_memory (addr
, VALUE_CONTENTS_RAW (val
), length
);
390 VALUE_LAZY (val
) = 0;
395 /* Store the contents of FROMVAL into the location of TOVAL.
396 Return a new value with the location of TOVAL and contents of FROMVAL. */
399 value_assign (toval
, fromval
)
400 register value_ptr toval
, fromval
;
402 register struct type
*type
;
403 register value_ptr val
;
404 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
407 if (!toval
->modifiable
)
408 error ("Left operand of assignment is not a modifiable lvalue.");
412 type
= VALUE_TYPE (toval
);
413 if (VALUE_LVAL (toval
) != lval_internalvar
)
414 fromval
= value_cast (type
, fromval
);
416 COERCE_ARRAY (fromval
);
417 CHECK_TYPEDEF (type
);
419 /* If TOVAL is a special machine register requiring conversion
420 of program values to a special raw format,
421 convert FROMVAL's contents now, with result in `raw_buffer',
422 and set USE_BUFFER to the number of bytes to write. */
424 #ifdef REGISTER_CONVERTIBLE
425 if (VALUE_REGNO (toval
) >= 0
426 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
428 int regno
= VALUE_REGNO (toval
);
429 if (REGISTER_CONVERTIBLE (regno
))
431 struct type
*fromtype
= check_typedef (VALUE_TYPE (fromval
));
432 REGISTER_CONVERT_TO_RAW (fromtype
, regno
,
433 VALUE_CONTENTS (fromval
), raw_buffer
);
434 use_buffer
= REGISTER_RAW_SIZE (regno
);
439 switch (VALUE_LVAL (toval
))
441 case lval_internalvar
:
442 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
443 return VALUE_INTERNALVAR (toval
)->value
;
445 case lval_internalvar_component
:
446 set_internalvar_component (VALUE_INTERNALVAR (toval
),
447 VALUE_OFFSET (toval
),
448 VALUE_BITPOS (toval
),
449 VALUE_BITSIZE (toval
),
454 if (VALUE_BITSIZE (toval
))
456 char buffer
[sizeof (LONGEST
)];
457 /* We assume that the argument to read_memory is in units of
458 host chars. FIXME: Is that correct? */
459 int len
= (VALUE_BITPOS (toval
)
460 + VALUE_BITSIZE (toval
)
464 if (len
> sizeof (LONGEST
))
465 error ("Can't handle bitfields which don't fit in a %d bit word.",
466 sizeof (LONGEST
) * HOST_CHAR_BIT
);
468 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
470 modify_field (buffer
, value_as_long (fromval
),
471 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
472 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
476 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
477 raw_buffer
, use_buffer
);
479 write_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
480 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
484 if (VALUE_BITSIZE (toval
))
486 char buffer
[sizeof (LONGEST
)];
487 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
489 if (len
> sizeof (LONGEST
))
490 error ("Can't handle bitfields in registers larger than %d bits.",
491 sizeof (LONGEST
) * HOST_CHAR_BIT
);
493 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
494 > len
* HOST_CHAR_BIT
)
495 /* Getting this right would involve being very careful about
498 Can't handle bitfield which doesn't fit in a single register.");
500 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
502 modify_field (buffer
, value_as_long (fromval
),
503 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
504 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
508 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
509 raw_buffer
, use_buffer
);
512 /* Do any conversion necessary when storing this type to more
513 than one register. */
514 #ifdef REGISTER_CONVERT_FROM_TYPE
515 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
516 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
517 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
518 raw_buffer
, TYPE_LENGTH (type
));
520 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
521 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
524 /* Assigning to the stack pointer, frame pointer, and other
525 (architecture and calling convention specific) registers may
526 cause the frame cache to be out of date. We just do this
527 on all assignments to registers for simplicity; I doubt the slowdown
529 reinit_frame_cache ();
532 case lval_reg_frame_relative
:
534 /* value is stored in a series of registers in the frame
535 specified by the structure. Copy that value out, modify
536 it, and copy it back in. */
537 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
538 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
539 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
540 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
543 /* Make the buffer large enough in all cases. */
544 char *buffer
= (char *) alloca (amount_to_copy
546 + MAX_REGISTER_RAW_SIZE
);
549 struct frame_info
*frame
;
551 /* Figure out which frame this is in currently. */
552 for (frame
= get_current_frame ();
553 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
554 frame
= get_prev_frame (frame
))
558 error ("Value being assigned to is no longer active.");
560 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
563 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
565 amount_copied
< amount_to_copy
;
566 amount_copied
+= reg_size
, regno
++)
568 get_saved_register (buffer
+ amount_copied
,
569 (int *)NULL
, (CORE_ADDR
*)NULL
,
570 frame
, regno
, (enum lval_type
*)NULL
);
573 /* Modify what needs to be modified. */
574 if (VALUE_BITSIZE (toval
))
575 modify_field (buffer
+ byte_offset
,
576 value_as_long (fromval
),
577 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
579 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
581 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
585 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
587 amount_copied
< amount_to_copy
;
588 amount_copied
+= reg_size
, regno
++)
594 /* Just find out where to put it. */
595 get_saved_register ((char *)NULL
,
596 &optim
, &addr
, frame
, regno
, &lval
);
599 error ("Attempt to assign to a value that was optimized out.");
600 if (lval
== lval_memory
)
601 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
602 else if (lval
== lval_register
)
603 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
605 error ("Attempt to assign to an unmodifiable value.");
612 error ("Left operand of assignment is not an lvalue.");
615 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
616 If the field is signed, and is negative, then sign extend. */
617 if ((VALUE_BITSIZE (toval
) > 0)
618 && (VALUE_BITSIZE (toval
) < 8 * sizeof (LONGEST
)))
620 LONGEST fieldval
= value_as_long (fromval
);
621 LONGEST valmask
= (((unsigned LONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
624 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
625 fieldval
|= ~valmask
;
627 fromval
= value_from_longest (type
, fieldval
);
630 val
= value_copy (toval
);
631 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
633 VALUE_TYPE (val
) = type
;
638 /* Extend a value VAL to COUNT repetitions of its type. */
641 value_repeat (arg1
, count
)
645 register value_ptr val
;
647 if (VALUE_LVAL (arg1
) != lval_memory
)
648 error ("Only values in memory can be extended with '@'.");
650 error ("Invalid number %d of repetitions.", count
);
652 val
= allocate_repeat_value (VALUE_TYPE (arg1
), count
);
654 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
655 VALUE_CONTENTS_RAW (val
),
656 TYPE_LENGTH (VALUE_TYPE (val
)));
657 VALUE_LVAL (val
) = lval_memory
;
658 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
664 value_of_variable (var
, b
)
669 struct frame_info
*frame
;
672 /* Use selected frame. */
676 frame
= block_innermost_frame (b
);
677 if (frame
== NULL
&& symbol_read_needs_frame (var
))
679 if (BLOCK_FUNCTION (b
) != NULL
680 && SYMBOL_NAME (BLOCK_FUNCTION (b
)) != NULL
)
681 error ("No frame is currently executing in block %s.",
682 SYMBOL_NAME (BLOCK_FUNCTION (b
)));
684 error ("No frame is currently executing in specified block");
687 val
= read_var_value (var
, frame
);
689 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
693 /* Given a value which is an array, return a value which is a pointer to its
694 first element, regardless of whether or not the array has a nonzero lower
697 FIXME: A previous comment here indicated that this routine should be
698 substracting the array's lower bound. It's not clear to me that this
699 is correct. Given an array subscripting operation, it would certainly
700 work to do the adjustment here, essentially computing:
702 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
704 However I believe a more appropriate and logical place to account for
705 the lower bound is to do so in value_subscript, essentially computing:
707 (&array[0] + ((index - lowerbound) * sizeof array[0]))
709 As further evidence consider what would happen with operations other
710 than array subscripting, where the caller would get back a value that
711 had an address somewhere before the actual first element of the array,
712 and the information about the lower bound would be lost because of
713 the coercion to pointer type.
717 value_coerce_array (arg1
)
720 register struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
722 if (VALUE_LVAL (arg1
) != lval_memory
)
723 error ("Attempt to take address of value not located in memory.");
725 return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
726 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
729 /* Given a value which is a function, return a value which is a pointer
733 value_coerce_function (arg1
)
737 if (VALUE_LVAL (arg1
) != lval_memory
)
738 error ("Attempt to take address of value not located in memory.");
740 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
741 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
744 /* Return a pointer value for the object for which ARG1 is the contents. */
750 struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
751 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
753 /* Copy the value, but change the type from (T&) to (T*).
754 We keep the same location information, which is efficient,
755 and allows &(&X) to get the location containing the reference. */
756 value_ptr arg2
= value_copy (arg1
);
757 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
760 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
761 return value_coerce_function (arg1
);
763 if (VALUE_LVAL (arg1
) != lval_memory
)
764 error ("Attempt to take address of value not located in memory.");
766 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
767 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
770 /* Given a value of a pointer type, apply the C unary * operator to it. */
778 type1
= check_typedef (VALUE_TYPE (arg1
));
780 if (TYPE_CODE (type1
) == TYPE_CODE_MEMBER
)
781 error ("not implemented: member types in value_ind");
783 /* Allow * on an integer so we can cast it to whatever we want.
784 This returns an int, which seems like the most C-like thing
785 to do. "long long" variables are rare enough that
786 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
787 if (TYPE_CODE (type1
) == TYPE_CODE_INT
)
788 return value_at (builtin_type_int
,
789 (CORE_ADDR
) value_as_long (arg1
));
790 else if (TYPE_CODE (type1
) == TYPE_CODE_PTR
)
791 return value_at_lazy (TYPE_TARGET_TYPE (type1
), value_as_pointer (arg1
));
792 error ("Attempt to take contents of a non-pointer value.");
793 return 0; /* For lint -- never reached */
796 /* Pushing small parts of stack frames. */
798 /* Push one word (the size of object that a register holds). */
803 unsigned LONGEST word
;
805 register int len
= REGISTER_SIZE
;
806 char buffer
[MAX_REGISTER_RAW_SIZE
];
808 store_unsigned_integer (buffer
, len
, word
);
811 write_memory (sp
, buffer
, len
);
812 #else /* stack grows upward */
813 write_memory (sp
, buffer
, len
);
815 #endif /* stack grows upward */
820 /* Push LEN bytes with data at BUFFER. */
823 push_bytes (sp
, buffer
, len
)
830 write_memory (sp
, buffer
, len
);
831 #else /* stack grows upward */
832 write_memory (sp
, buffer
, len
);
834 #endif /* stack grows upward */
839 /* Push onto the stack the specified value VALUE. */
843 register CORE_ADDR sp
;
846 register int len
= TYPE_LENGTH (VALUE_TYPE (arg
));
850 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
851 #else /* stack grows upward */
852 write_memory (sp
, VALUE_CONTENTS (arg
), len
);
854 #endif /* stack grows upward */
859 /* Perform the standard coercions that are specified
860 for arguments to be passed to C functions.
862 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
865 value_arg_coerce (arg
, param_type
)
867 struct type
*param_type
;
869 register struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
870 register struct type
*type
871 = param_type
? check_typedef (param_type
) : arg_type
;
873 switch (TYPE_CODE (type
))
876 if (TYPE_CODE (arg_type
) != TYPE_CODE_REF
)
878 arg
= value_addr (arg
);
879 VALUE_TYPE (arg
) = param_type
;
887 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
888 type
= builtin_type_int
;
891 /* coerce float to double, unless the function prototype specifies float */
896 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
897 type
= builtin_type_double
;
898 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin_type_double
))
899 type
= builtin_type_long_double
;
903 type
= lookup_pointer_type (type
);
905 case TYPE_CODE_ARRAY
:
906 if (current_language
->c_style_arrays
)
907 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
909 case TYPE_CODE_UNDEF
:
911 case TYPE_CODE_STRUCT
:
912 case TYPE_CODE_UNION
:
915 case TYPE_CODE_RANGE
:
916 case TYPE_CODE_STRING
:
917 case TYPE_CODE_BITSTRING
:
918 case TYPE_CODE_ERROR
:
919 case TYPE_CODE_MEMBER
:
920 case TYPE_CODE_METHOD
:
921 case TYPE_CODE_COMPLEX
:
926 return value_cast (type
, arg
);
929 /* Determine a function's address and its return type from its value.
930 Calls error() if the function is not valid for calling. */
933 find_function_addr (function
, retval_type
)
935 struct type
**retval_type
;
937 register struct type
*ftype
= check_typedef (VALUE_TYPE (function
));
938 register enum type_code code
= TYPE_CODE (ftype
);
939 struct type
*value_type
;
942 /* If it's a member function, just look at the function
945 /* Determine address to call. */
946 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
948 funaddr
= VALUE_ADDRESS (function
);
949 value_type
= TYPE_TARGET_TYPE (ftype
);
951 else if (code
== TYPE_CODE_PTR
)
953 funaddr
= value_as_pointer (function
);
954 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
955 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
956 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
958 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
959 /* FIXME: This is a workaround for the unusual function
960 pointer representation on the RS/6000, see comment
961 in config/rs6000/tm-rs6000.h */
962 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
964 value_type
= TYPE_TARGET_TYPE (ftype
);
967 value_type
= builtin_type_int
;
969 else if (code
== TYPE_CODE_INT
)
971 /* Handle the case of functions lacking debugging info.
972 Their values are characters since their addresses are char */
973 if (TYPE_LENGTH (ftype
) == 1)
974 funaddr
= value_as_pointer (value_addr (function
));
976 /* Handle integer used as address of a function. */
977 funaddr
= (CORE_ADDR
) value_as_long (function
);
979 value_type
= builtin_type_int
;
982 error ("Invalid data type for function to be called.");
984 *retval_type
= value_type
;
988 #if defined (CALL_DUMMY)
989 /* All this stuff with a dummy frame may seem unnecessarily complicated
990 (why not just save registers in GDB?). The purpose of pushing a dummy
991 frame which looks just like a real frame is so that if you call a
992 function and then hit a breakpoint (get a signal, etc), "backtrace"
993 will look right. Whether the backtrace needs to actually show the
994 stack at the time the inferior function was called is debatable, but
995 it certainly needs to not display garbage. So if you are contemplating
996 making dummy frames be different from normal frames, consider that. */
998 /* Perform a function call in the inferior.
999 ARGS is a vector of values of arguments (NARGS of them).
1000 FUNCTION is a value, the function to be called.
1001 Returns a value representing what the function returned.
1002 May fail to return, if a breakpoint or signal is hit
1003 during the execution of the function.
1005 ARGS is modified to contain coerced values. */
1008 call_function_by_hand (function
, nargs
, args
)
1013 register CORE_ADDR sp
;
1016 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1017 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1018 and remove any extra bytes which might exist because unsigned LONGEST is
1019 bigger than REGISTER_SIZE. */
1020 static unsigned LONGEST dummy
[] = CALL_DUMMY
;
1021 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (unsigned LONGEST
)];
1023 struct type
*value_type
;
1024 unsigned char struct_return
;
1025 CORE_ADDR struct_addr
;
1026 struct inferior_status inf_status
;
1027 struct cleanup
*old_chain
;
1031 struct type
*ftype
= check_typedef (SYMBOL_TYPE (function
));
1033 if (!target_has_execution
)
1036 save_inferior_status (&inf_status
, 1);
1037 old_chain
= make_cleanup (restore_inferior_status
, &inf_status
);
1039 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1040 (and POP_FRAME for restoring them). (At least on most machines)
1041 they are saved on the stack in the inferior. */
1044 old_sp
= sp
= read_sp ();
1046 #if 1 INNER_THAN 2 /* Stack grows down */
1047 sp
-= sizeof dummy1
;
1049 #else /* Stack grows up */
1051 sp
+= sizeof dummy1
;
1054 funaddr
= find_function_addr (function
, &value_type
);
1055 CHECK_TYPEDEF (value_type
);
1058 struct block
*b
= block_for_pc (funaddr
);
1059 /* If compiled without -g, assume GCC. */
1060 using_gcc
= b
== NULL
? 0 : BLOCK_GCC_COMPILED (b
);
1063 /* Are we returning a value using a structure return or a normal
1066 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1069 /* Create a call sequence customized for this function
1070 and the number of arguments for it. */
1071 for (i
= 0; i
< sizeof dummy
/ sizeof (dummy
[0]); i
++)
1072 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1074 (unsigned LONGEST
)dummy
[i
]);
1076 #ifdef GDB_TARGET_IS_HPPA
1077 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1078 value_type
, using_gcc
);
1080 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1081 value_type
, using_gcc
);
1085 #if CALL_DUMMY_LOCATION == ON_STACK
1086 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1087 #endif /* On stack. */
1089 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1090 /* Convex Unix prohibits executing in the stack segment. */
1091 /* Hope there is empty room at the top of the text segment. */
1093 extern CORE_ADDR text_end
;
1096 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1097 if (read_memory_integer (start_sp
, 1) != 0)
1098 error ("text segment full -- no place to put call");
1101 real_pc
= text_end
- sizeof dummy1
;
1102 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1104 #endif /* Before text_end. */
1106 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1108 extern CORE_ADDR text_end
;
1112 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1114 error ("Cannot write text segment -- call_function failed");
1116 #endif /* After text_end. */
1118 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1120 #endif /* At entry point. */
1123 sp
= old_sp
; /* It really is used, for some ifdef's... */
1126 if (nargs
< TYPE_NFIELDS (ftype
))
1127 error ("too few arguments in function call");
1129 for (i
= nargs
- 1; i
>= 0; i
--)
1131 struct type
*param_type
;
1132 if (TYPE_NFIELDS (ftype
) > i
)
1133 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1136 args
[i
] = value_arg_coerce (args
[i
], param_type
);
1139 #if defined (REG_STRUCT_HAS_ADDR)
1141 /* This is a machine like the sparc, where we may need to pass a pointer
1142 to the structure, not the structure itself. */
1143 for (i
= nargs
- 1; i
>= 0; i
--)
1145 struct type
*arg_type
= check_typedef (VALUE_TYPE (args
[i
]));
1146 if ((TYPE_CODE (arg_type
) == TYPE_CODE_STRUCT
1147 || TYPE_CODE (arg_type
) == TYPE_CODE_UNION
1148 || TYPE_CODE (arg_type
) == TYPE_CODE_ARRAY
1149 || TYPE_CODE (arg_type
) == TYPE_CODE_STRING
1150 || TYPE_CODE (arg_type
) == TYPE_CODE_BITSTRING
1151 || TYPE_CODE (arg_type
) == TYPE_CODE_SET
1152 || (TYPE_CODE (arg_type
) == TYPE_CODE_FLT
1153 && TYPE_LENGTH (arg_type
) > 8)
1155 && REG_STRUCT_HAS_ADDR (using_gcc
, arg_type
))
1158 int len
= TYPE_LENGTH (arg_type
);
1160 int aligned_len
= STACK_ALIGN (len
);
1162 int aligned_len
= len
;
1164 #if !(1 INNER_THAN 2)
1165 /* The stack grows up, so the address of the thing we push
1166 is the stack pointer before we push it. */
1171 /* Push the structure. */
1172 write_memory (sp
, VALUE_CONTENTS (args
[i
]), len
);
1174 /* The stack grows down, so the address of the thing we push
1175 is the stack pointer after we push it. */
1180 /* The value we're going to pass is the address of the thing
1182 args
[i
] = value_from_longest (lookup_pointer_type (value_type
),
1187 #endif /* REG_STRUCT_HAS_ADDR. */
1189 /* Reserve space for the return structure to be written on the
1190 stack, if necessary */
1194 int len
= TYPE_LENGTH (value_type
);
1196 len
= STACK_ALIGN (len
);
1208 /* If stack grows down, we must leave a hole at the top. */
1212 for (i
= nargs
- 1; i
>= 0; i
--)
1213 len
+= TYPE_LENGTH (VALUE_TYPE (args
[i
]));
1214 #ifdef CALL_DUMMY_STACK_ADJUST
1215 len
+= CALL_DUMMY_STACK_ADJUST
;
1218 sp
-= STACK_ALIGN (len
) - len
;
1220 sp
+= STACK_ALIGN (len
) - len
;
1223 #endif /* STACK_ALIGN */
1225 #ifdef PUSH_ARGUMENTS
1226 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1227 #else /* !PUSH_ARGUMENTS */
1228 for (i
= nargs
- 1; i
>= 0; i
--)
1229 sp
= value_push (sp
, args
[i
]);
1230 #endif /* !PUSH_ARGUMENTS */
1232 #ifdef CALL_DUMMY_STACK_ADJUST
1234 sp
-= CALL_DUMMY_STACK_ADJUST
;
1236 sp
+= CALL_DUMMY_STACK_ADJUST
;
1238 #endif /* CALL_DUMMY_STACK_ADJUST */
1240 /* Store the address at which the structure is supposed to be
1241 written. Note that this (and the code which reserved the space
1242 above) assumes that gcc was used to compile this function. Since
1243 it doesn't cost us anything but space and if the function is pcc
1244 it will ignore this value, we will make that assumption.
1246 Also note that on some machines (like the sparc) pcc uses a
1247 convention like gcc's. */
1250 STORE_STRUCT_RETURN (struct_addr
, sp
);
1252 /* Write the stack pointer. This is here because the statements above
1253 might fool with it. On SPARC, this write also stores the register
1254 window into the right place in the new stack frame, which otherwise
1255 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1259 char retbuf
[REGISTER_BYTES
];
1261 struct symbol
*symbol
;
1264 symbol
= find_pc_function (funaddr
);
1267 name
= SYMBOL_SOURCE_NAME (symbol
);
1271 /* Try the minimal symbols. */
1272 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1276 name
= SYMBOL_SOURCE_NAME (msymbol
);
1282 sprintf (format
, "at %s", local_hex_format ());
1284 /* FIXME-32x64: assumes funaddr fits in a long. */
1285 sprintf (name
, format
, (unsigned long) funaddr
);
1288 /* Execute the stack dummy routine, calling FUNCTION.
1289 When it is done, discard the empty frame
1290 after storing the contents of all regs into retbuf. */
1291 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1293 /* We stopped somewhere besides the call dummy. */
1295 /* If we did the cleanups, we would print a spurious error message
1296 (Unable to restore previously selected frame), would write the
1297 registers from the inf_status (which is wrong), and would do other
1298 wrong things (like set stop_bpstat to the wrong thing). */
1299 discard_cleanups (old_chain
);
1300 /* Prevent memory leak. */
1301 bpstat_clear (&inf_status
.stop_bpstat
);
1303 /* The following error message used to say "The expression
1304 which contained the function call has been discarded." It
1305 is a hard concept to explain in a few words. Ideally, GDB
1306 would be able to resume evaluation of the expression when
1307 the function finally is done executing. Perhaps someday
1308 this will be implemented (it would not be easy). */
1310 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1311 a C++ name with arguments and stuff. */
1313 The program being debugged stopped while in a function called from GDB.\n\
1314 When the function (%s) is done executing, GDB will silently\n\
1315 stop (instead of continuing to evaluate the expression containing\n\
1316 the function call).", name
);
1319 do_cleanups (old_chain
);
1321 /* Figure out the value returned by the function. */
1322 return value_being_returned (value_type
, retbuf
, struct_return
);
1325 #else /* no CALL_DUMMY. */
1327 call_function_by_hand (function
, nargs
, args
)
1332 error ("Cannot invoke functions on this machine.");
1334 #endif /* no CALL_DUMMY. */
1337 /* Create a value for an array by allocating space in the inferior, copying
1338 the data into that space, and then setting up an array value.
1340 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1341 populated from the values passed in ELEMVEC.
1343 The element type of the array is inherited from the type of the
1344 first element, and all elements must have the same size (though we
1345 don't currently enforce any restriction on their types). */
1348 value_array (lowbound
, highbound
, elemvec
)
1357 struct type
*rangetype
;
1358 struct type
*arraytype
;
1361 /* Validate that the bounds are reasonable and that each of the elements
1362 have the same size. */
1364 nelem
= highbound
- lowbound
+ 1;
1367 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1369 typelength
= TYPE_LENGTH (VALUE_TYPE (elemvec
[0]));
1370 for (idx
= 1; idx
< nelem
; idx
++)
1372 if (TYPE_LENGTH (VALUE_TYPE (elemvec
[idx
])) != typelength
)
1374 error ("array elements must all be the same size");
1378 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1379 lowbound
, highbound
);
1380 arraytype
= create_array_type ((struct type
*) NULL
,
1381 VALUE_TYPE (elemvec
[0]), rangetype
);
1383 if (!current_language
->c_style_arrays
)
1385 val
= allocate_value (arraytype
);
1386 for (idx
= 0; idx
< nelem
; idx
++)
1388 memcpy (VALUE_CONTENTS_RAW (val
) + (idx
* typelength
),
1389 VALUE_CONTENTS (elemvec
[idx
]),
1395 /* Allocate space to store the array in the inferior, and then initialize
1396 it by copying in each element. FIXME: Is it worth it to create a
1397 local buffer in which to collect each value and then write all the
1398 bytes in one operation? */
1400 addr
= allocate_space_in_inferior (nelem
* typelength
);
1401 for (idx
= 0; idx
< nelem
; idx
++)
1403 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS (elemvec
[idx
]),
1407 /* Create the array type and set up an array value to be evaluated lazily. */
1409 val
= value_at_lazy (arraytype
, addr
);
1413 /* Create a value for a string constant by allocating space in the inferior,
1414 copying the data into that space, and returning the address with type
1415 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1417 Note that string types are like array of char types with a lower bound of
1418 zero and an upper bound of LEN - 1. Also note that the string may contain
1419 embedded null bytes. */
1422 value_string (ptr
, len
)
1427 int lowbound
= current_language
->string_lower_bound
;
1428 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1430 lowbound
, len
+ lowbound
- 1);
1431 struct type
*stringtype
1432 = create_string_type ((struct type
*) NULL
, rangetype
);
1435 if (current_language
->c_style_arrays
== 0)
1437 val
= allocate_value (stringtype
);
1438 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1443 /* Allocate space to store the string in the inferior, and then
1444 copy LEN bytes from PTR in gdb to that address in the inferior. */
1446 addr
= allocate_space_in_inferior (len
);
1447 write_memory (addr
, ptr
, len
);
1449 val
= value_at_lazy (stringtype
, addr
);
1454 value_bitstring (ptr
, len
)
1459 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1461 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1462 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1463 val
= allocate_value (type
);
1464 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1468 /* See if we can pass arguments in T2 to a function which takes arguments
1469 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1470 arguments need coercion of some sort, then the coerced values are written
1471 into T2. Return value is 0 if the arguments could be matched, or the
1472 position at which they differ if not.
1474 STATICP is nonzero if the T1 argument list came from a
1475 static member function.
1477 For non-static member functions, we ignore the first argument,
1478 which is the type of the instance variable. This is because we want
1479 to handle calls with objects from derived classes. This is not
1480 entirely correct: we should actually check to make sure that a
1481 requested operation is type secure, shouldn't we? FIXME. */
1484 typecmp (staticp
, t1
, t2
)
1493 if (staticp
&& t1
== 0)
1497 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1498 if (t1
[!staticp
] == 0) return 0;
1499 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1501 struct type
*tt1
, *tt2
;
1504 tt1
= check_typedef (t1
[i
]);
1505 tt2
= check_typedef (VALUE_TYPE(t2
[i
]));
1506 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1507 /* We should be doing hairy argument matching, as below. */
1508 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1510 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1511 t2
[i
] = value_coerce_array (t2
[i
]);
1513 t2
[i
] = value_addr (t2
[i
]);
1517 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1518 && ( TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
1519 || TYPE_CODE (tt2
) == TYPE_CODE_PTR
))
1521 tt1
= check_typedef (TYPE_TARGET_TYPE(tt1
));
1522 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1524 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1525 /* Array to pointer is a `trivial conversion' according to the ARM. */
1527 /* We should be doing much hairier argument matching (see section 13.2
1528 of the ARM), but as a quick kludge, just check for the same type
1530 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1533 if (!t1
[i
]) return 0;
1534 return t2
[i
] ? i
+1 : 0;
1537 /* Helper function used by value_struct_elt to recurse through baseclasses.
1538 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1539 and search in it assuming it has (class) type TYPE.
1540 If found, return value, else return NULL.
1542 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1543 look for a baseclass named NAME. */
1546 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1548 register value_ptr arg1
;
1550 register struct type
*type
;
1551 int looking_for_baseclass
;
1555 CHECK_TYPEDEF (type
);
1557 if (! looking_for_baseclass
)
1558 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1560 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1562 if (t_field_name
&& STREQ (t_field_name
, name
))
1565 if (TYPE_FIELD_STATIC (type
, i
))
1567 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
1568 struct symbol
*sym
=
1569 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1571 error ("Internal error: could not find physical static variable named %s",
1573 v
= value_at (TYPE_FIELD_TYPE (type
, i
),
1574 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1577 v
= value_primitive_field (arg1
, offset
, i
, type
);
1579 error("there is no field named %s", name
);
1584 && (t_field_name
[0] == '\0'
1585 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1586 && STREQ (t_field_name
, "else"))))
1588 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1589 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1590 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1592 /* Look for a match through the fields of an anonymous union,
1593 or anonymous struct. C++ provides anonymous unions.
1595 In the GNU Chill implementation of variant record types,
1596 each <alternative field> has an (anonymous) union type,
1597 each member of the union represents a <variant alternative>.
1598 Each <variant alternative> is represented as a struct,
1599 with a member for each <variant field>. */
1602 int new_offset
= offset
;
1604 /* This is pretty gross. In G++, the offset in an anonymous
1605 union is relative to the beginning of the enclosing struct.
1606 In the GNU Chill implementation of variant records,
1607 the bitpos is zero in an anonymous union field, so we
1608 have to add the offset of the union here. */
1609 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1610 || (TYPE_NFIELDS (field_type
) > 0
1611 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1612 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1614 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
1615 looking_for_baseclass
);
1622 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1625 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1626 /* If we are looking for baseclasses, this is what we get when we
1627 hit them. But it could happen that the base part's member name
1628 is not yet filled in. */
1629 int found_baseclass
= (looking_for_baseclass
1630 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1631 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
1633 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1635 int boffset
= VALUE_OFFSET (arg1
) + offset
;
1636 boffset
= baseclass_offset (type
, i
,
1637 VALUE_CONTENTS (arg1
) + boffset
,
1638 VALUE_ADDRESS (arg1
) + boffset
);
1640 error ("virtual baseclass botch");
1641 if (found_baseclass
)
1643 value_ptr v2
= allocate_value (basetype
);
1644 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
1645 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
1646 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + offset
+ boffset
;
1647 if (VALUE_LAZY (arg1
))
1648 VALUE_LAZY (v2
) = 1;
1650 memcpy (VALUE_CONTENTS_RAW (v2
),
1651 VALUE_CONTENTS_RAW (arg1
) + offset
+ boffset
,
1652 TYPE_LENGTH (basetype
));
1655 v
= search_struct_field (name
, arg1
, offset
+ boffset
,
1656 TYPE_BASECLASS (type
, i
),
1657 looking_for_baseclass
);
1659 else if (found_baseclass
)
1660 v
= value_primitive_field (arg1
, offset
, i
, type
);
1662 v
= search_struct_field (name
, arg1
,
1663 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1664 basetype
, looking_for_baseclass
);
1670 /* Helper function used by value_struct_elt to recurse through baseclasses.
1671 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1672 and search in it assuming it has (class) type TYPE.
1673 If found, return value, else if name matched and args not return (value)-1,
1674 else return NULL. */
1677 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
1679 register value_ptr
*arg1p
, *args
;
1680 int offset
, *static_memfuncp
;
1681 register struct type
*type
;
1685 int name_matched
= 0;
1686 char dem_opname
[64];
1688 CHECK_TYPEDEF (type
);
1689 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1691 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1692 if (strncmp(t_field_name
, "__", 2)==0 ||
1693 strncmp(t_field_name
, "op", 2)==0 ||
1694 strncmp(t_field_name
, "type", 4)==0 )
1696 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
1697 t_field_name
= dem_opname
;
1698 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
1699 t_field_name
= dem_opname
;
1701 if (t_field_name
&& STREQ (t_field_name
, name
))
1703 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1704 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1707 if (j
> 0 && args
== 0)
1708 error ("cannot resolve overloaded method `%s'", name
);
1711 if (TYPE_FN_FIELD_STUB (f
, j
))
1712 check_stub_method (type
, i
, j
);
1713 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1714 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1716 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1717 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1718 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1719 *static_memfuncp
= 1;
1720 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1721 if (v
!= NULL
) return v
;
1728 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1732 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1734 base_offset
= VALUE_OFFSET (*arg1p
) + offset
;
1736 baseclass_offset (type
, i
,
1737 VALUE_CONTENTS (*arg1p
) + base_offset
,
1738 VALUE_ADDRESS (*arg1p
) + base_offset
);
1739 if (base_offset
== -1)
1740 error ("virtual baseclass botch");
1744 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1746 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1747 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1748 if (v
== (value_ptr
) -1)
1754 /* FIXME-bothner: Why is this commented out? Why is it here? */
1755 /* *arg1p = arg1_tmp;*/
1759 if (name_matched
) return (value_ptr
) -1;
1763 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1764 extract the component named NAME from the ultimate target structure/union
1765 and return it as a value with its appropriate type.
1766 ERR is used in the error message if *ARGP's type is wrong.
1768 C++: ARGS is a list of argument types to aid in the selection of
1769 an appropriate method. Also, handle derived types.
1771 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1772 where the truthvalue of whether the function that was resolved was
1773 a static member function or not is stored.
1775 ERR is an error message to be printed in case the field is not found. */
1778 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
1779 register value_ptr
*argp
, *args
;
1781 int *static_memfuncp
;
1784 register struct type
*t
;
1787 COERCE_ARRAY (*argp
);
1789 t
= check_typedef (VALUE_TYPE (*argp
));
1791 /* Follow pointers until we get to a non-pointer. */
1793 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1795 *argp
= value_ind (*argp
);
1796 /* Don't coerce fn pointer to fn and then back again! */
1797 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1798 COERCE_ARRAY (*argp
);
1799 t
= check_typedef (VALUE_TYPE (*argp
));
1802 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1803 error ("not implemented: member type in value_struct_elt");
1805 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1806 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1807 error ("Attempt to extract a component of a value that is not a %s.", err
);
1809 /* Assume it's not, unless we see that it is. */
1810 if (static_memfuncp
)
1811 *static_memfuncp
=0;
1815 /* if there are no arguments ...do this... */
1817 /* Try as a field first, because if we succeed, there
1818 is less work to be done. */
1819 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1823 /* C++: If it was not found as a data field, then try to
1824 return it as a pointer to a method. */
1826 if (destructor_name_p (name
, t
))
1827 error ("Cannot get value of destructor");
1829 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1831 if (v
== (value_ptr
) -1)
1832 error ("Cannot take address of a method");
1835 if (TYPE_NFN_FIELDS (t
))
1836 error ("There is no member or method named %s.", name
);
1838 error ("There is no member named %s.", name
);
1843 if (destructor_name_p (name
, t
))
1847 /* destructors are a special case. */
1848 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, 0),
1849 TYPE_FN_FIELDLIST_LENGTH (t
, 0), 0, 0);
1850 if (!v
) error("could not find destructor function named %s.", name
);
1855 error ("destructor should not have any argument");
1859 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1861 if (v
== (value_ptr
) -1)
1863 error("Argument list of %s mismatch with component in the structure.", name
);
1867 /* See if user tried to invoke data as function. If so,
1868 hand it back. If it's not callable (i.e., a pointer to function),
1869 gdb should give an error. */
1870 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1874 error ("Structure has no component named %s.", name
);
1878 /* C++: return 1 is NAME is a legitimate name for the destructor
1879 of type TYPE. If TYPE does not have a destructor, or
1880 if NAME is inappropriate for TYPE, an error is signaled. */
1882 destructor_name_p (name
, type
)
1884 const struct type
*type
;
1886 /* destructors are a special case. */
1890 char *dname
= type_name_no_tag (type
);
1891 char *cp
= strchr (dname
, '<');
1894 /* Do not compare the template part for template classes. */
1896 len
= strlen (dname
);
1899 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
1900 error ("name of destructor must equal name of class");
1907 /* Helper function for check_field: Given TYPE, a structure/union,
1908 return 1 if the component named NAME from the ultimate
1909 target structure/union is defined, otherwise, return 0. */
1912 check_field_in (type
, name
)
1913 register struct type
*type
;
1918 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1920 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1921 if (t_field_name
&& STREQ (t_field_name
, name
))
1925 /* C++: If it was not found as a data field, then try to
1926 return it as a pointer to a method. */
1928 /* Destructors are a special case. */
1929 if (destructor_name_p (name
, type
))
1932 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1934 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
1938 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1939 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
1946 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1947 return 1 if the component named NAME from the ultimate
1948 target structure/union is defined, otherwise, return 0. */
1951 check_field (arg1
, name
)
1952 register value_ptr arg1
;
1955 register struct type
*t
;
1957 COERCE_ARRAY (arg1
);
1959 t
= VALUE_TYPE (arg1
);
1961 /* Follow pointers until we get to a non-pointer. */
1966 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
1968 t
= TYPE_TARGET_TYPE (t
);
1971 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1972 error ("not implemented: member type in check_field");
1974 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1975 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1976 error ("Internal error: `this' is not an aggregate");
1978 return check_field_in (t
, name
);
1981 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1982 return the address of this member as a "pointer to member"
1983 type. If INTYPE is non-null, then it will be the type
1984 of the member we are looking for. This will help us resolve
1985 "pointers to member functions". This function is used
1986 to resolve user expressions of the form "DOMAIN::NAME". */
1989 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
1990 struct type
*domain
, *curtype
, *intype
;
1994 register struct type
*t
= curtype
;
1998 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
1999 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2000 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2002 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2004 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2006 if (t_field_name
&& STREQ (t_field_name
, name
))
2008 if (TYPE_FIELD_STATIC (t
, i
))
2010 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (t
, i
);
2011 struct symbol
*sym
=
2012 lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
2014 error ("Internal error: could not find physical static variable named %s",
2016 return value_at (SYMBOL_TYPE (sym
),
2017 (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
2019 if (TYPE_FIELD_PACKED (t
, i
))
2020 error ("pointers to bitfield members not allowed");
2022 return value_from_longest
2023 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
2025 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2029 /* C++: If it was not found as a data field, then try to
2030 return it as a pointer to a method. */
2032 /* Destructors are a special case. */
2033 if (destructor_name_p (name
, t
))
2035 error ("member pointers to destructors not implemented yet");
2038 /* Perform all necessary dereferencing. */
2039 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2040 intype
= TYPE_TARGET_TYPE (intype
);
2042 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2044 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2045 char dem_opname
[64];
2047 if (strncmp(t_field_name
, "__", 2)==0 ||
2048 strncmp(t_field_name
, "op", 2)==0 ||
2049 strncmp(t_field_name
, "type", 4)==0 )
2051 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
2052 t_field_name
= dem_opname
;
2053 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
2054 t_field_name
= dem_opname
;
2056 if (t_field_name
&& STREQ (t_field_name
, name
))
2058 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2059 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2061 if (intype
== 0 && j
> 1)
2062 error ("non-unique member `%s' requires type instantiation", name
);
2066 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2069 error ("no member function matches that type instantiation");
2074 if (TYPE_FN_FIELD_STUB (f
, j
))
2075 check_stub_method (t
, i
, j
);
2076 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2078 return value_from_longest
2079 (lookup_reference_type
2080 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2082 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
2086 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2087 0, VAR_NAMESPACE
, 0, NULL
);
2094 v
= read_var_value (s
, 0);
2096 VALUE_TYPE (v
) = lookup_reference_type
2097 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2105 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2110 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2113 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2114 v
= value_struct_elt_for_reference (domain
,
2115 offset
+ base_offset
,
2116 TYPE_BASECLASS (t
, i
),
2125 /* C++: return the value of the class instance variable, if one exists.
2126 Flag COMPLAIN signals an error if the request is made in an
2127 inappropriate context. */
2130 value_of_this (complain
)
2133 struct symbol
*func
, *sym
;
2136 static const char funny_this
[] = "this";
2139 if (selected_frame
== 0)
2141 error ("no frame selected");
2144 func
= get_frame_function (selected_frame
);
2148 error ("no `this' in nameless context");
2152 b
= SYMBOL_BLOCK_VALUE (func
);
2153 i
= BLOCK_NSYMS (b
);
2156 error ("no args, no `this'");
2159 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2160 symbol instead of the LOC_ARG one (if both exist). */
2161 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
2165 error ("current stack frame not in method");
2170 this = read_var_value (sym
, selected_frame
);
2171 if (this == 0 && complain
)
2172 error ("`this' argument at unknown address");
2176 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2177 long, starting at LOWBOUND. The result has the same lower bound as
2178 the original ARRAY. */
2181 value_slice (array
, lowbound
, length
)
2183 int lowbound
, length
;
2185 struct type
*slice_range_type
, *slice_type
, *range_type
;
2186 LONGEST lowerbound
, upperbound
, offset
;
2188 struct type
*array_type
;
2189 array_type
= check_typedef (VALUE_TYPE (array
));
2190 COERCE_VARYING_ARRAY (array
, array_type
);
2191 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
2192 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
2193 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
2194 error ("cannot take slice of non-array");
2195 range_type
= TYPE_INDEX_TYPE (array_type
);
2196 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
2197 error ("slice from bad array or bitstring");
2198 if (lowbound
< lowerbound
|| length
< 0
2199 || lowbound
+ length
- 1 > upperbound
2200 /* Chill allows zero-length strings but not arrays. */
2201 || (current_language
->la_language
== language_chill
2202 && length
== 0 && TYPE_CODE (array_type
) == TYPE_CODE_ARRAY
))
2203 error ("slice out of range");
2204 /* FIXME-type-allocation: need a way to free this type when we are
2206 slice_range_type
= create_range_type ((struct type
*) NULL
,
2207 TYPE_TARGET_TYPE (range_type
),
2208 lowerbound
, lowerbound
+ length
- 1);
2209 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
2212 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
2213 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
2214 slice
= value_zero (slice_type
, not_lval
);
2215 for (i
= 0; i
< length
; i
++)
2217 int element
= value_bit_index (array_type
,
2218 VALUE_CONTENTS (array
),
2221 error ("internal error accessing bitstring");
2222 else if (element
> 0)
2224 int j
= i
% TARGET_CHAR_BIT
;
2225 if (BITS_BIG_ENDIAN
)
2226 j
= TARGET_CHAR_BIT
- 1 - j
;
2227 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
2230 /* We should set the address, bitssize, and bitspos, so the clice
2231 can be used on the LHS, but that may require extensions to
2232 value_assign. For now, just leave as a non_lval. FIXME. */
2236 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
2238 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
2239 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2241 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
2242 slice
= allocate_value (slice_type
);
2243 if (VALUE_LAZY (array
))
2244 VALUE_LAZY (slice
) = 1;
2246 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2247 TYPE_LENGTH (slice_type
));
2248 if (VALUE_LVAL (array
) == lval_internalvar
)
2249 VALUE_LVAL (slice
) = lval_internalvar_component
;
2251 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2252 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2253 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2258 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2259 value as a fixed-length array. */
2262 varying_to_slice (varray
)
2265 struct type
*vtype
= check_typedef (VALUE_TYPE (varray
));
2266 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
2267 VALUE_CONTENTS (varray
)
2268 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
2269 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
2272 /* Create a value for a FORTRAN complex number. Currently most of
2273 the time values are coerced to COMPLEX*16 (i.e. a complex number
2274 composed of 2 doubles. This really should be a smarter routine
2275 that figures out precision inteligently as opposed to assuming
2276 doubles. FIXME: fmb */
2279 value_literal_complex (arg1
, arg2
, type
)
2284 register value_ptr val
;
2285 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2287 val
= allocate_value (type
);
2288 arg1
= value_cast (real_type
, arg1
);
2289 arg2
= value_cast (real_type
, arg2
);
2291 memcpy (VALUE_CONTENTS_RAW (val
),
2292 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2293 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2294 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2298 /* Cast a value into the appropriate complex data type. */
2301 cast_into_complex (type
, val
)
2303 register value_ptr val
;
2305 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2306 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2308 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2309 value_ptr re_val
= allocate_value (val_real_type
);
2310 value_ptr im_val
= allocate_value (val_real_type
);
2312 memcpy (VALUE_CONTENTS_RAW (re_val
),
2313 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2314 memcpy (VALUE_CONTENTS_RAW (im_val
),
2315 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2316 TYPE_LENGTH (val_real_type
));
2318 return value_literal_complex (re_val
, im_val
, type
);
2320 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2321 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2322 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2324 error ("cannot cast non-number to complex");
2328 _initialize_valops ()
2332 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *)&auto_abandon
,
2333 "Set automatic abandonment of expressions upon failure.",