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 /* Default to coercing float to double in function calls only when there is
36 no prototype. Otherwise on targets where the debug information is incorrect
37 for either the prototype or non-prototype case, we can force it by defining
38 COERCE_FLOAT_TO_DOUBLE in the target configuration file. */
40 #ifndef COERCE_FLOAT_TO_DOUBLE
41 #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL)
44 /* Local functions. */
46 static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
48 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
50 static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
52 static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
55 static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
57 int, int *, struct type *));
59 static int check_field_in PARAMS ((struct type *, const char *));
61 static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
63 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
65 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
67 /* Flag for whether we want to abandon failed expression evals by default. */
69 static int auto_abandon = 0;
72 /* Find the address of function name NAME in the inferior. */
75 find_function_in_inferior (name)
78 register struct symbol *sym;
79 sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
82 if (SYMBOL_CLASS (sym) != LOC_BLOCK)
84 error ("\"%s\" exists in this program but is not a function.",
87 return value_of_variable (sym, NULL);
91 struct minimal_symbol *msymbol = lookup_minimal_symbol(name, NULL, NULL);
96 type = lookup_pointer_type (builtin_type_char);
97 type = lookup_function_type (type);
98 type = lookup_pointer_type (type);
99 maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
100 return value_from_longest (type, maddr);
104 error ("evaluation of this expression requires the program to have a function \"%s\".", name);
109 /* Allocate NBYTES of space in the inferior using the inferior's malloc
110 and return a value that is a pointer to the allocated space. */
113 value_allocate_space_in_inferior (len)
117 register value_ptr val = find_function_in_inferior ("malloc");
119 blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
120 val = call_function_by_hand (val, 1, &blocklen);
121 if (value_logical_not (val))
123 error ("No memory available to program.");
129 allocate_space_in_inferior (len)
132 return value_as_long (value_allocate_space_in_inferior (len));
135 /* Cast value ARG2 to type TYPE and return as a value.
136 More general than a C cast: accepts any two types of the same length,
137 and if ARG2 is an lvalue it can be cast into anything at all. */
138 /* In C++, casts may change pointer or object representations. */
141 value_cast (type, arg2)
143 register value_ptr arg2;
145 register enum type_code code1;
146 register enum type_code code2;
150 if (VALUE_TYPE (arg2) == type)
153 CHECK_TYPEDEF (type);
154 code1 = TYPE_CODE (type);
156 type2 = check_typedef (VALUE_TYPE (arg2));
158 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
159 is treated like a cast to (TYPE [N])OBJECT,
160 where N is sizeof(OBJECT)/sizeof(TYPE). */
161 if (code1 == TYPE_CODE_ARRAY)
163 struct type *element_type = TYPE_TARGET_TYPE (type);
164 unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
165 if (element_length > 0
166 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
168 struct type *range_type = TYPE_INDEX_TYPE (type);
169 int val_length = TYPE_LENGTH (type2);
170 LONGEST low_bound, high_bound, new_length;
171 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
172 low_bound = 0, high_bound = 0;
173 new_length = val_length / element_length;
174 if (val_length % element_length != 0)
175 warning("array element type size does not divide object size in cast");
176 /* FIXME-type-allocation: need a way to free this type when we are
178 range_type = create_range_type ((struct type *) NULL,
179 TYPE_TARGET_TYPE (range_type),
181 new_length + low_bound - 1);
182 VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
183 element_type, range_type);
188 if (current_language->c_style_arrays
189 && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
190 arg2 = value_coerce_array (arg2);
192 if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
193 arg2 = value_coerce_function (arg2);
195 type2 = check_typedef (VALUE_TYPE (arg2));
196 COERCE_VARYING_ARRAY (arg2, type2);
197 code2 = TYPE_CODE (type2);
199 if (code1 == TYPE_CODE_COMPLEX)
200 return cast_into_complex (type, arg2);
201 if (code1 == TYPE_CODE_BOOL || code1 == TYPE_CODE_CHAR)
202 code1 = TYPE_CODE_INT;
203 if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
204 code2 = TYPE_CODE_INT;
206 scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
207 || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
209 if ( code1 == TYPE_CODE_STRUCT
210 && code2 == TYPE_CODE_STRUCT
211 && TYPE_NAME (type) != 0)
213 /* Look in the type of the source to see if it contains the
214 type of the target as a superclass. If so, we'll need to
215 offset the object in addition to changing its type. */
216 value_ptr v = search_struct_field (type_name_no_tag (type),
220 VALUE_TYPE (v) = type;
224 if (code1 == TYPE_CODE_FLT && scalar)
225 return value_from_double (type, value_as_double (arg2));
226 else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
227 || code1 == TYPE_CODE_RANGE)
228 && (scalar || code2 == TYPE_CODE_PTR))
229 return value_from_longest (type, value_as_long (arg2));
230 else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
232 if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
234 /* Look in the type of the source to see if it contains the
235 type of the target as a superclass. If so, we'll need to
236 offset the pointer rather than just change its type. */
237 struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
238 struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
239 if ( TYPE_CODE (t1) == TYPE_CODE_STRUCT
240 && TYPE_CODE (t2) == TYPE_CODE_STRUCT
241 && TYPE_NAME (t1) != 0) /* if name unknown, can't have supercl */
243 value_ptr v = search_struct_field (type_name_no_tag (t1),
244 value_ind (arg2), 0, t2, 1);
248 VALUE_TYPE (v) = type;
252 /* No superclass found, just fall through to change ptr type. */
254 VALUE_TYPE (arg2) = type;
257 else if (chill_varying_type (type))
259 struct type *range1, *range2, *eltype1, *eltype2;
262 LONGEST low_bound, high_bound;
263 char *valaddr, *valaddr_data;
264 if (code2 == TYPE_CODE_BITSTRING)
265 error ("not implemented: converting bitstring to varying type");
266 if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING)
267 || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))),
268 eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)),
269 (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
270 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
271 error ("Invalid conversion to varying type");
272 range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0);
273 range2 = TYPE_FIELD_TYPE (type2, 0);
274 if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0)
277 count1 = high_bound - low_bound + 1;
278 if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0)
279 count1 = -1, count2 = 0; /* To force error before */
281 count2 = high_bound - low_bound + 1;
283 error ("target varying type is too small");
284 val = allocate_value (type);
285 valaddr = VALUE_CONTENTS_RAW (val);
286 valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
287 /* Set val's __var_length field to count2. */
288 store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)),
290 /* Set the __var_data field to count2 elements copied from arg2. */
291 memcpy (valaddr_data, VALUE_CONTENTS (arg2),
292 count2 * TYPE_LENGTH (eltype2));
293 /* Zero the rest of the __var_data field of val. */
294 memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0',
295 (count1 - count2) * TYPE_LENGTH (eltype2));
298 else if (VALUE_LVAL (arg2) == lval_memory)
300 return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
302 else if (code1 == TYPE_CODE_VOID)
304 return value_zero (builtin_type_void, not_lval);
308 error ("Invalid cast.");
313 /* Create a value of type TYPE that is zero, and return it. */
316 value_zero (type, lv)
320 register value_ptr val = allocate_value (type);
322 memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
323 VALUE_LVAL (val) = lv;
328 /* Return a value with type TYPE located at ADDR.
330 Call value_at only if the data needs to be fetched immediately;
331 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
332 value_at_lazy instead. value_at_lazy simply records the address of
333 the data and sets the lazy-evaluation-required flag. The lazy flag
334 is tested in the VALUE_CONTENTS macro, which is used if and when
335 the contents are actually required. */
338 value_at (type, addr)
342 register value_ptr val;
344 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
345 error ("Attempt to dereference a generic pointer.");
347 val = allocate_value (type);
349 read_memory (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (type));
351 VALUE_LVAL (val) = lval_memory;
352 VALUE_ADDRESS (val) = addr;
357 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
360 value_at_lazy (type, addr)
364 register value_ptr val;
366 if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
367 error ("Attempt to dereference a generic pointer.");
369 val = allocate_value (type);
371 VALUE_LVAL (val) = lval_memory;
372 VALUE_ADDRESS (val) = addr;
373 VALUE_LAZY (val) = 1;
378 /* Called only from the VALUE_CONTENTS macro, if the current data for
379 a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the
380 data from the user's process, and clears the lazy flag to indicate
381 that the data in the buffer is valid.
383 If the value is zero-length, we avoid calling read_memory, which would
384 abort. We mark the value as fetched anyway -- all 0 bytes of it.
386 This function returns a value because it is used in the VALUE_CONTENTS
387 macro as part of an expression, where a void would not work. The
391 value_fetch_lazy (val)
392 register value_ptr val;
394 CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
395 int length = TYPE_LENGTH (VALUE_TYPE (val));
398 read_memory (addr, VALUE_CONTENTS_RAW (val), length);
399 VALUE_LAZY (val) = 0;
404 /* Store the contents of FROMVAL into the location of TOVAL.
405 Return a new value with the location of TOVAL and contents of FROMVAL. */
408 value_assign (toval, fromval)
409 register value_ptr toval, fromval;
411 register struct type *type;
412 register value_ptr val;
413 char raw_buffer[MAX_REGISTER_RAW_SIZE];
416 if (!toval->modifiable)
417 error ("Left operand of assignment is not a modifiable lvalue.");
421 type = VALUE_TYPE (toval);
422 if (VALUE_LVAL (toval) != lval_internalvar)
423 fromval = value_cast (type, fromval);
425 COERCE_ARRAY (fromval);
426 CHECK_TYPEDEF (type);
428 /* If TOVAL is a special machine register requiring conversion
429 of program values to a special raw format,
430 convert FROMVAL's contents now, with result in `raw_buffer',
431 and set USE_BUFFER to the number of bytes to write. */
433 #ifdef REGISTER_CONVERTIBLE
434 if (VALUE_REGNO (toval) >= 0
435 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
437 int regno = VALUE_REGNO (toval);
438 if (REGISTER_CONVERTIBLE (regno))
440 struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
441 REGISTER_CONVERT_TO_RAW (fromtype, regno,
442 VALUE_CONTENTS (fromval), raw_buffer);
443 use_buffer = REGISTER_RAW_SIZE (regno);
448 switch (VALUE_LVAL (toval))
450 case lval_internalvar:
451 set_internalvar (VALUE_INTERNALVAR (toval), fromval);
452 return value_copy (VALUE_INTERNALVAR (toval)->value);
454 case lval_internalvar_component:
455 set_internalvar_component (VALUE_INTERNALVAR (toval),
456 VALUE_OFFSET (toval),
457 VALUE_BITPOS (toval),
458 VALUE_BITSIZE (toval),
463 if (VALUE_BITSIZE (toval))
465 char buffer[sizeof (LONGEST)];
466 /* We assume that the argument to read_memory is in units of
467 host chars. FIXME: Is that correct? */
468 int len = (VALUE_BITPOS (toval)
469 + VALUE_BITSIZE (toval)
473 if (len > sizeof (LONGEST))
474 error ("Can't handle bitfields which don't fit in a %d bit word.",
475 sizeof (LONGEST) * HOST_CHAR_BIT);
477 read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
479 modify_field (buffer, value_as_long (fromval),
480 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
481 write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
485 write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
486 raw_buffer, use_buffer);
488 write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
489 VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
493 if (VALUE_BITSIZE (toval))
495 char buffer[sizeof (LONGEST)];
496 int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
498 if (len > sizeof (LONGEST))
499 error ("Can't handle bitfields in registers larger than %d bits.",
500 sizeof (LONGEST) * HOST_CHAR_BIT);
502 if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
503 > len * HOST_CHAR_BIT)
504 /* Getting this right would involve being very careful about
507 Can't handle bitfield which doesn't fit in a single register.");
509 read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
511 modify_field (buffer, value_as_long (fromval),
512 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
513 write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
517 write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
518 raw_buffer, use_buffer);
521 /* Do any conversion necessary when storing this type to more
522 than one register. */
523 #ifdef REGISTER_CONVERT_FROM_TYPE
524 memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
525 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval), type, raw_buffer);
526 write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
527 raw_buffer, TYPE_LENGTH (type));
529 write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
530 VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
533 /* Assigning to the stack pointer, frame pointer, and other
534 (architecture and calling convention specific) registers may
535 cause the frame cache to be out of date. We just do this
536 on all assignments to registers for simplicity; I doubt the slowdown
538 reinit_frame_cache ();
541 case lval_reg_frame_relative:
543 /* value is stored in a series of registers in the frame
544 specified by the structure. Copy that value out, modify
545 it, and copy it back in. */
546 int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
547 int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
548 int byte_offset = VALUE_OFFSET (toval) % reg_size;
549 int reg_offset = VALUE_OFFSET (toval) / reg_size;
552 /* Make the buffer large enough in all cases. */
553 char *buffer = (char *) alloca (amount_to_copy
555 + MAX_REGISTER_RAW_SIZE);
558 struct frame_info *frame;
560 /* Figure out which frame this is in currently. */
561 for (frame = get_current_frame ();
562 frame && FRAME_FP (frame) != VALUE_FRAME (toval);
563 frame = get_prev_frame (frame))
567 error ("Value being assigned to is no longer active.");
569 amount_to_copy += (reg_size - amount_to_copy % reg_size);
572 for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
574 amount_copied < amount_to_copy;
575 amount_copied += reg_size, regno++)
577 get_saved_register (buffer + amount_copied,
578 (int *)NULL, (CORE_ADDR *)NULL,
579 frame, regno, (enum lval_type *)NULL);
582 /* Modify what needs to be modified. */
583 if (VALUE_BITSIZE (toval))
584 modify_field (buffer + byte_offset,
585 value_as_long (fromval),
586 VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
588 memcpy (buffer + byte_offset, raw_buffer, use_buffer);
590 memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
594 for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
596 amount_copied < amount_to_copy;
597 amount_copied += reg_size, regno++)
603 /* Just find out where to put it. */
604 get_saved_register ((char *)NULL,
605 &optim, &addr, frame, regno, &lval);
608 error ("Attempt to assign to a value that was optimized out.");
609 if (lval == lval_memory)
610 write_memory (addr, buffer + amount_copied, reg_size);
611 else if (lval == lval_register)
612 write_register_bytes (addr, buffer + amount_copied, reg_size);
614 error ("Attempt to assign to an unmodifiable value.");
621 error ("Left operand of assignment is not an lvalue.");
624 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
625 If the field is signed, and is negative, then sign extend. */
626 if ((VALUE_BITSIZE (toval) > 0)
627 && (VALUE_BITSIZE (toval) < 8 * sizeof (LONGEST)))
629 LONGEST fieldval = value_as_long (fromval);
630 LONGEST valmask = (((unsigned LONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
633 if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
634 fieldval |= ~valmask;
636 fromval = value_from_longest (type, fieldval);
639 val = value_copy (toval);
640 memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
642 VALUE_TYPE (val) = type;
647 /* Extend a value VAL to COUNT repetitions of its type. */
650 value_repeat (arg1, count)
654 register value_ptr val;
656 if (VALUE_LVAL (arg1) != lval_memory)
657 error ("Only values in memory can be extended with '@'.");
659 error ("Invalid number %d of repetitions.", count);
661 val = allocate_repeat_value (VALUE_TYPE (arg1), count);
663 read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
664 VALUE_CONTENTS_RAW (val),
665 TYPE_LENGTH (VALUE_TYPE (val)));
666 VALUE_LVAL (val) = lval_memory;
667 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
673 value_of_variable (var, b)
678 struct frame_info *frame;
681 /* Use selected frame. */
685 frame = block_innermost_frame (b);
686 if (frame == NULL && symbol_read_needs_frame (var))
688 if (BLOCK_FUNCTION (b) != NULL
689 && SYMBOL_NAME (BLOCK_FUNCTION (b)) != NULL)
690 error ("No frame is currently executing in block %s.",
691 SYMBOL_NAME (BLOCK_FUNCTION (b)));
693 error ("No frame is currently executing in specified block");
696 val = read_var_value (var, frame);
698 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
702 /* Given a value which is an array, return a value which is a pointer to its
703 first element, regardless of whether or not the array has a nonzero lower
706 FIXME: A previous comment here indicated that this routine should be
707 substracting the array's lower bound. It's not clear to me that this
708 is correct. Given an array subscripting operation, it would certainly
709 work to do the adjustment here, essentially computing:
711 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
713 However I believe a more appropriate and logical place to account for
714 the lower bound is to do so in value_subscript, essentially computing:
716 (&array[0] + ((index - lowerbound) * sizeof array[0]))
718 As further evidence consider what would happen with operations other
719 than array subscripting, where the caller would get back a value that
720 had an address somewhere before the actual first element of the array,
721 and the information about the lower bound would be lost because of
722 the coercion to pointer type.
726 value_coerce_array (arg1)
729 register struct type *type = check_typedef (VALUE_TYPE (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 (TYPE_TARGET_TYPE (type)),
735 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
738 /* Given a value which is a function, return a value which is a pointer
742 value_coerce_function (arg1)
746 if (VALUE_LVAL (arg1) != lval_memory)
747 error ("Attempt to take address of value not located in memory.");
749 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
750 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
753 /* Return a pointer value for the object for which ARG1 is the contents. */
759 struct type *type = check_typedef (VALUE_TYPE (arg1));
760 if (TYPE_CODE (type) == TYPE_CODE_REF)
762 /* Copy the value, but change the type from (T&) to (T*).
763 We keep the same location information, which is efficient,
764 and allows &(&X) to get the location containing the reference. */
765 value_ptr arg2 = value_copy (arg1);
766 VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
769 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
770 return value_coerce_function (arg1);
772 if (VALUE_LVAL (arg1) != lval_memory)
773 error ("Attempt to take address of value not located in memory.");
775 return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
776 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
779 /* Given a value of a pointer type, apply the C unary * operator to it. */
787 type1 = check_typedef (VALUE_TYPE (arg1));
789 if (TYPE_CODE (type1) == TYPE_CODE_MEMBER)
790 error ("not implemented: member types in value_ind");
792 /* Allow * on an integer so we can cast it to whatever we want.
793 This returns an int, which seems like the most C-like thing
794 to do. "long long" variables are rare enough that
795 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
796 if (TYPE_CODE (type1) == TYPE_CODE_INT)
797 return value_at (builtin_type_int,
798 (CORE_ADDR) value_as_long (arg1));
799 else if (TYPE_CODE (type1) == TYPE_CODE_PTR)
800 return value_at_lazy (TYPE_TARGET_TYPE (type1), value_as_pointer (arg1));
801 error ("Attempt to take contents of a non-pointer value.");
802 return 0; /* For lint -- never reached */
805 /* Pushing small parts of stack frames. */
807 /* Push one word (the size of object that a register holds). */
812 unsigned LONGEST word;
814 register int len = REGISTER_SIZE;
815 char buffer[MAX_REGISTER_RAW_SIZE];
817 store_unsigned_integer (buffer, len, word);
820 write_memory (sp, buffer, len);
821 #else /* stack grows upward */
822 write_memory (sp, buffer, len);
824 #endif /* stack grows upward */
829 /* Push LEN bytes with data at BUFFER. */
832 push_bytes (sp, buffer, len)
839 write_memory (sp, buffer, len);
840 #else /* stack grows upward */
841 write_memory (sp, buffer, len);
843 #endif /* stack grows upward */
848 /* Push onto the stack the specified value VALUE. */
852 register CORE_ADDR sp;
855 register int len = TYPE_LENGTH (VALUE_TYPE (arg));
859 write_memory (sp, VALUE_CONTENTS (arg), len);
860 #else /* stack grows upward */
861 write_memory (sp, VALUE_CONTENTS (arg), len);
863 #endif /* stack grows upward */
868 /* Perform the standard coercions that are specified
869 for arguments to be passed to C functions.
871 If PARAM_TYPE is non-NULL, it is the expected parameter type. */
874 value_arg_coerce (arg, param_type)
876 struct type *param_type;
878 register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
879 register struct type *type
880 = param_type ? check_typedef (param_type) : arg_type;
882 switch (TYPE_CODE (type))
885 if (TYPE_CODE (arg_type) != TYPE_CODE_REF)
887 arg = value_addr (arg);
888 VALUE_TYPE (arg) = param_type;
896 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
897 type = builtin_type_int;
900 /* coerce float to double, unless the function prototype specifies float */
901 if (COERCE_FLOAT_TO_DOUBLE)
903 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
904 type = builtin_type_double;
905 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
906 type = builtin_type_long_double;
910 type = lookup_pointer_type (type);
912 case TYPE_CODE_ARRAY:
913 if (current_language->c_style_arrays)
914 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
916 case TYPE_CODE_UNDEF:
918 case TYPE_CODE_STRUCT:
919 case TYPE_CODE_UNION:
922 case TYPE_CODE_RANGE:
923 case TYPE_CODE_STRING:
924 case TYPE_CODE_BITSTRING:
925 case TYPE_CODE_ERROR:
926 case TYPE_CODE_MEMBER:
927 case TYPE_CODE_METHOD:
928 case TYPE_CODE_COMPLEX:
933 return value_cast (type, arg);
936 /* Determine a function's address and its return type from its value.
937 Calls error() if the function is not valid for calling. */
940 find_function_addr (function, retval_type)
942 struct type **retval_type;
944 register struct type *ftype = check_typedef (VALUE_TYPE (function));
945 register enum type_code code = TYPE_CODE (ftype);
946 struct type *value_type;
949 /* If it's a member function, just look at the function
952 /* Determine address to call. */
953 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
955 funaddr = VALUE_ADDRESS (function);
956 value_type = TYPE_TARGET_TYPE (ftype);
958 else if (code == TYPE_CODE_PTR)
960 funaddr = value_as_pointer (function);
961 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
962 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
963 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
965 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
966 /* FIXME: This is a workaround for the unusual function
967 pointer representation on the RS/6000, see comment
968 in config/rs6000/tm-rs6000.h */
969 funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
971 value_type = TYPE_TARGET_TYPE (ftype);
974 value_type = builtin_type_int;
976 else if (code == TYPE_CODE_INT)
978 /* Handle the case of functions lacking debugging info.
979 Their values are characters since their addresses are char */
980 if (TYPE_LENGTH (ftype) == 1)
981 funaddr = value_as_pointer (value_addr (function));
983 /* Handle integer used as address of a function. */
984 funaddr = (CORE_ADDR) value_as_long (function);
986 value_type = builtin_type_int;
989 error ("Invalid data type for function to be called.");
991 *retval_type = value_type;
995 #if defined (CALL_DUMMY)
996 /* All this stuff with a dummy frame may seem unnecessarily complicated
997 (why not just save registers in GDB?). The purpose of pushing a dummy
998 frame which looks just like a real frame is so that if you call a
999 function and then hit a breakpoint (get a signal, etc), "backtrace"
1000 will look right. Whether the backtrace needs to actually show the
1001 stack at the time the inferior function was called is debatable, but
1002 it certainly needs to not display garbage. So if you are contemplating
1003 making dummy frames be different from normal frames, consider that. */
1005 /* Perform a function call in the inferior.
1006 ARGS is a vector of values of arguments (NARGS of them).
1007 FUNCTION is a value, the function to be called.
1008 Returns a value representing what the function returned.
1009 May fail to return, if a breakpoint or signal is hit
1010 during the execution of the function.
1012 ARGS is modified to contain coerced values. */
1015 call_function_by_hand (function, nargs, args)
1020 register CORE_ADDR sp;
1023 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1024 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1025 and remove any extra bytes which might exist because unsigned LONGEST is
1026 bigger than REGISTER_SIZE. */
1027 static unsigned LONGEST dummy[] = CALL_DUMMY;
1028 char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (unsigned LONGEST)];
1030 struct type *value_type;
1031 unsigned char struct_return;
1032 CORE_ADDR struct_addr;
1033 struct inferior_status inf_status;
1034 struct cleanup *old_chain;
1038 struct type *ftype = check_typedef (SYMBOL_TYPE (function));
1040 if (!target_has_execution)
1043 save_inferior_status (&inf_status, 1);
1044 old_chain = make_cleanup (restore_inferior_status, &inf_status);
1046 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1047 (and POP_FRAME for restoring them). (At least on most machines)
1048 they are saved on the stack in the inferior. */
1051 old_sp = sp = read_sp ();
1053 #if 1 INNER_THAN 2 /* Stack grows down */
1054 sp -= sizeof dummy1;
1056 #else /* Stack grows up */
1058 sp += sizeof dummy1;
1061 funaddr = find_function_addr (function, &value_type);
1062 CHECK_TYPEDEF (value_type);
1065 struct block *b = block_for_pc (funaddr);
1066 /* If compiled without -g, assume GCC. */
1067 using_gcc = b == NULL ? 0 : BLOCK_GCC_COMPILED (b);
1070 /* Are we returning a value using a structure return or a normal
1073 struct_return = using_struct_return (function, funaddr, value_type,
1076 /* Create a call sequence customized for this function
1077 and the number of arguments for it. */
1078 for (i = 0; i < sizeof dummy / sizeof (dummy[0]); i++)
1079 store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1081 (unsigned LONGEST)dummy[i]);
1083 #ifdef GDB_TARGET_IS_HPPA
1084 real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1085 value_type, using_gcc);
1087 FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1088 value_type, using_gcc);
1092 #if CALL_DUMMY_LOCATION == ON_STACK
1093 write_memory (start_sp, (char *)dummy1, sizeof dummy1);
1094 #endif /* On stack. */
1096 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1097 /* Convex Unix prohibits executing in the stack segment. */
1098 /* Hope there is empty room at the top of the text segment. */
1100 extern CORE_ADDR text_end;
1103 for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
1104 if (read_memory_integer (start_sp, 1) != 0)
1105 error ("text segment full -- no place to put call");
1108 real_pc = text_end - sizeof dummy1;
1109 write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1111 #endif /* Before text_end. */
1113 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1115 extern CORE_ADDR text_end;
1119 errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1121 error ("Cannot write text segment -- call_function failed");
1123 #endif /* After text_end. */
1125 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1127 #endif /* At entry point. */
1130 sp = old_sp; /* It really is used, for some ifdef's... */
1133 if (nargs < TYPE_NFIELDS (ftype))
1134 error ("too few arguments in function call");
1136 for (i = nargs - 1; i >= 0; i--)
1138 struct type *param_type;
1139 if (TYPE_NFIELDS (ftype) > i)
1140 param_type = TYPE_FIELD_TYPE (ftype, i);
1143 args[i] = value_arg_coerce (args[i], param_type);
1146 #if defined (REG_STRUCT_HAS_ADDR)
1148 /* This is a machine like the sparc, where we may need to pass a pointer
1149 to the structure, not the structure itself. */
1150 for (i = nargs - 1; i >= 0; i--)
1152 struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
1153 if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
1154 || TYPE_CODE (arg_type) == TYPE_CODE_UNION
1155 || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1156 || TYPE_CODE (arg_type) == TYPE_CODE_STRING
1157 || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
1158 || TYPE_CODE (arg_type) == TYPE_CODE_SET
1159 || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
1160 && TYPE_LENGTH (arg_type) > 8)
1162 && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
1165 int len = TYPE_LENGTH (arg_type);
1167 int aligned_len = STACK_ALIGN (len);
1169 int aligned_len = len;
1171 #if !(1 INNER_THAN 2)
1172 /* The stack grows up, so the address of the thing we push
1173 is the stack pointer before we push it. */
1178 /* Push the structure. */
1179 write_memory (sp, VALUE_CONTENTS (args[i]), len);
1181 /* The stack grows down, so the address of the thing we push
1182 is the stack pointer after we push it. */
1187 /* The value we're going to pass is the address of the thing
1189 args[i] = value_from_longest (lookup_pointer_type (value_type),
1194 #endif /* REG_STRUCT_HAS_ADDR. */
1196 /* Reserve space for the return structure to be written on the
1197 stack, if necessary */
1201 int len = TYPE_LENGTH (value_type);
1203 len = STACK_ALIGN (len);
1215 /* If stack grows down, we must leave a hole at the top. */
1219 for (i = nargs - 1; i >= 0; i--)
1220 len += TYPE_LENGTH (VALUE_TYPE (args[i]));
1221 #ifdef CALL_DUMMY_STACK_ADJUST
1222 len += CALL_DUMMY_STACK_ADJUST;
1225 sp -= STACK_ALIGN (len) - len;
1227 sp += STACK_ALIGN (len) - len;
1230 #endif /* STACK_ALIGN */
1232 #ifdef PUSH_ARGUMENTS
1233 PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr);
1234 #else /* !PUSH_ARGUMENTS */
1235 for (i = nargs - 1; i >= 0; i--)
1236 sp = value_push (sp, args[i]);
1237 #endif /* !PUSH_ARGUMENTS */
1239 #ifdef CALL_DUMMY_STACK_ADJUST
1241 sp -= CALL_DUMMY_STACK_ADJUST;
1243 sp += CALL_DUMMY_STACK_ADJUST;
1245 #endif /* CALL_DUMMY_STACK_ADJUST */
1247 /* Store the address at which the structure is supposed to be
1248 written. Note that this (and the code which reserved the space
1249 above) assumes that gcc was used to compile this function. Since
1250 it doesn't cost us anything but space and if the function is pcc
1251 it will ignore this value, we will make that assumption.
1253 Also note that on some machines (like the sparc) pcc uses a
1254 convention like gcc's. */
1257 STORE_STRUCT_RETURN (struct_addr, sp);
1259 /* Write the stack pointer. This is here because the statements above
1260 might fool with it. On SPARC, this write also stores the register
1261 window into the right place in the new stack frame, which otherwise
1262 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1266 char retbuf[REGISTER_BYTES];
1268 struct symbol *symbol;
1271 symbol = find_pc_function (funaddr);
1274 name = SYMBOL_SOURCE_NAME (symbol);
1278 /* Try the minimal symbols. */
1279 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1283 name = SYMBOL_SOURCE_NAME (msymbol);
1289 sprintf (format, "at %s", local_hex_format ());
1291 /* FIXME-32x64: assumes funaddr fits in a long. */
1292 sprintf (name, format, (unsigned long) funaddr);
1295 /* Execute the stack dummy routine, calling FUNCTION.
1296 When it is done, discard the empty frame
1297 after storing the contents of all regs into retbuf. */
1298 if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
1300 /* We stopped somewhere besides the call dummy. */
1302 /* If we did the cleanups, we would print a spurious error message
1303 (Unable to restore previously selected frame), would write the
1304 registers from the inf_status (which is wrong), and would do other
1305 wrong things (like set stop_bpstat to the wrong thing). */
1306 discard_cleanups (old_chain);
1307 /* Prevent memory leak. */
1308 bpstat_clear (&inf_status.stop_bpstat);
1310 /* The following error message used to say "The expression
1311 which contained the function call has been discarded." It
1312 is a hard concept to explain in a few words. Ideally, GDB
1313 would be able to resume evaluation of the expression when
1314 the function finally is done executing. Perhaps someday
1315 this will be implemented (it would not be easy). */
1317 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1318 a C++ name with arguments and stuff. */
1320 The program being debugged stopped while in a function called from GDB.\n\
1321 When the function (%s) is done executing, GDB will silently\n\
1322 stop (instead of continuing to evaluate the expression containing\n\
1323 the function call).", name);
1326 do_cleanups (old_chain);
1328 /* Figure out the value returned by the function. */
1329 return value_being_returned (value_type, retbuf, struct_return);
1332 #else /* no CALL_DUMMY. */
1334 call_function_by_hand (function, nargs, args)
1339 error ("Cannot invoke functions on this machine.");
1341 #endif /* no CALL_DUMMY. */
1344 /* Create a value for an array by allocating space in the inferior, copying
1345 the data into that space, and then setting up an array value.
1347 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1348 populated from the values passed in ELEMVEC.
1350 The element type of the array is inherited from the type of the
1351 first element, and all elements must have the same size (though we
1352 don't currently enforce any restriction on their types). */
1355 value_array (lowbound, highbound, elemvec)
1364 struct type *rangetype;
1365 struct type *arraytype;
1368 /* Validate that the bounds are reasonable and that each of the elements
1369 have the same size. */
1371 nelem = highbound - lowbound + 1;
1374 error ("bad array bounds (%d, %d)", lowbound, highbound);
1376 typelength = TYPE_LENGTH (VALUE_TYPE (elemvec[0]));
1377 for (idx = 1; idx < nelem; idx++)
1379 if (TYPE_LENGTH (VALUE_TYPE (elemvec[idx])) != typelength)
1381 error ("array elements must all be the same size");
1385 rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1386 lowbound, highbound);
1387 arraytype = create_array_type ((struct type *) NULL,
1388 VALUE_TYPE (elemvec[0]), rangetype);
1390 if (!current_language->c_style_arrays)
1392 val = allocate_value (arraytype);
1393 for (idx = 0; idx < nelem; idx++)
1395 memcpy (VALUE_CONTENTS_RAW (val) + (idx * typelength),
1396 VALUE_CONTENTS (elemvec[idx]),
1402 /* Allocate space to store the array in the inferior, and then initialize
1403 it by copying in each element. FIXME: Is it worth it to create a
1404 local buffer in which to collect each value and then write all the
1405 bytes in one operation? */
1407 addr = allocate_space_in_inferior (nelem * typelength);
1408 for (idx = 0; idx < nelem; idx++)
1410 write_memory (addr + (idx * typelength), VALUE_CONTENTS (elemvec[idx]),
1414 /* Create the array type and set up an array value to be evaluated lazily. */
1416 val = value_at_lazy (arraytype, addr);
1420 /* Create a value for a string constant by allocating space in the inferior,
1421 copying the data into that space, and returning the address with type
1422 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1424 Note that string types are like array of char types with a lower bound of
1425 zero and an upper bound of LEN - 1. Also note that the string may contain
1426 embedded null bytes. */
1429 value_string (ptr, len)
1434 int lowbound = current_language->string_lower_bound;
1435 struct type *rangetype = create_range_type ((struct type *) NULL,
1437 lowbound, len + lowbound - 1);
1438 struct type *stringtype
1439 = create_string_type ((struct type *) NULL, rangetype);
1442 if (current_language->c_style_arrays == 0)
1444 val = allocate_value (stringtype);
1445 memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1450 /* Allocate space to store the string in the inferior, and then
1451 copy LEN bytes from PTR in gdb to that address in the inferior. */
1453 addr = allocate_space_in_inferior (len);
1454 write_memory (addr, ptr, len);
1456 val = value_at_lazy (stringtype, addr);
1461 value_bitstring (ptr, len)
1466 struct type *domain_type = create_range_type (NULL, builtin_type_int,
1468 struct type *type = create_set_type ((struct type*) NULL, domain_type);
1469 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1470 val = allocate_value (type);
1471 memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1475 /* See if we can pass arguments in T2 to a function which takes arguments
1476 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1477 arguments need coercion of some sort, then the coerced values are written
1478 into T2. Return value is 0 if the arguments could be matched, or the
1479 position at which they differ if not.
1481 STATICP is nonzero if the T1 argument list came from a
1482 static member function.
1484 For non-static member functions, we ignore the first argument,
1485 which is the type of the instance variable. This is because we want
1486 to handle calls with objects from derived classes. This is not
1487 entirely correct: we should actually check to make sure that a
1488 requested operation is type secure, shouldn't we? FIXME. */
1491 typecmp (staticp, t1, t2)
1500 if (staticp && t1 == 0)
1504 if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) return 0;
1505 if (t1[!staticp] == 0) return 0;
1506 for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
1508 struct type *tt1, *tt2;
1511 tt1 = check_typedef (t1[i]);
1512 tt2 = check_typedef (VALUE_TYPE(t2[i]));
1513 if (TYPE_CODE (tt1) == TYPE_CODE_REF
1514 /* We should be doing hairy argument matching, as below. */
1515 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1517 if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1518 t2[i] = value_coerce_array (t2[i]);
1520 t2[i] = value_addr (t2[i]);
1524 while (TYPE_CODE (tt1) == TYPE_CODE_PTR
1525 && ( TYPE_CODE (tt2) == TYPE_CODE_ARRAY
1526 || TYPE_CODE (tt2) == TYPE_CODE_PTR))
1528 tt1 = check_typedef (TYPE_TARGET_TYPE(tt1));
1529 tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1531 if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
1532 /* Array to pointer is a `trivial conversion' according to the ARM. */
1534 /* We should be doing much hairier argument matching (see section 13.2
1535 of the ARM), but as a quick kludge, just check for the same type
1537 if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
1540 if (!t1[i]) return 0;
1541 return t2[i] ? i+1 : 0;
1544 /* Helper function used by value_struct_elt to recurse through baseclasses.
1545 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1546 and search in it assuming it has (class) type TYPE.
1547 If found, return value, else return NULL.
1549 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1550 look for a baseclass named NAME. */
1553 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
1555 register value_ptr arg1;
1557 register struct type *type;
1558 int looking_for_baseclass;
1562 CHECK_TYPEDEF (type);
1564 if (! looking_for_baseclass)
1565 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1567 char *t_field_name = TYPE_FIELD_NAME (type, i);
1569 if (t_field_name && STREQ (t_field_name, name))
1572 if (TYPE_FIELD_STATIC (type, i))
1574 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, i);
1575 struct symbol *sym =
1576 lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1578 error ("Internal error: could not find physical static variable named %s",
1580 v = value_at (TYPE_FIELD_TYPE (type, i),
1581 (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1584 v = value_primitive_field (arg1, offset, i, type);
1586 error("there is no field named %s", name);
1591 && (t_field_name[0] == '\0'
1592 || (TYPE_CODE (type) == TYPE_CODE_UNION
1593 && STREQ (t_field_name, "else"))))
1595 struct type *field_type = TYPE_FIELD_TYPE (type, i);
1596 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1597 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1599 /* Look for a match through the fields of an anonymous union,
1600 or anonymous struct. C++ provides anonymous unions.
1602 In the GNU Chill implementation of variant record types,
1603 each <alternative field> has an (anonymous) union type,
1604 each member of the union represents a <variant alternative>.
1605 Each <variant alternative> is represented as a struct,
1606 with a member for each <variant field>. */
1609 int new_offset = offset;
1611 /* This is pretty gross. In G++, the offset in an anonymous
1612 union is relative to the beginning of the enclosing struct.
1613 In the GNU Chill implementation of variant records,
1614 the bitpos is zero in an anonymous union field, so we
1615 have to add the offset of the union here. */
1616 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1617 || (TYPE_NFIELDS (field_type) > 0
1618 && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1619 new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1621 v = search_struct_field (name, arg1, new_offset, field_type,
1622 looking_for_baseclass);
1629 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1632 struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1633 /* If we are looking for baseclasses, this is what we get when we
1634 hit them. But it could happen that the base part's member name
1635 is not yet filled in. */
1636 int found_baseclass = (looking_for_baseclass
1637 && TYPE_BASECLASS_NAME (type, i) != NULL
1638 && STREQ (name, TYPE_BASECLASS_NAME (type, i)));
1640 if (BASETYPE_VIA_VIRTUAL (type, i))
1642 int boffset = VALUE_OFFSET (arg1) + offset;
1643 boffset = baseclass_offset (type, i,
1644 VALUE_CONTENTS (arg1) + boffset,
1645 VALUE_ADDRESS (arg1) + boffset);
1647 error ("virtual baseclass botch");
1648 if (found_baseclass)
1650 value_ptr v2 = allocate_value (basetype);
1651 VALUE_LVAL (v2) = VALUE_LVAL (arg1);
1652 VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
1653 VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + offset + boffset;
1654 if (VALUE_LAZY (arg1))
1655 VALUE_LAZY (v2) = 1;
1657 memcpy (VALUE_CONTENTS_RAW (v2),
1658 VALUE_CONTENTS_RAW (arg1) + offset + boffset,
1659 TYPE_LENGTH (basetype));
1662 v = search_struct_field (name, arg1, offset + boffset,
1663 TYPE_BASECLASS (type, i),
1664 looking_for_baseclass);
1666 else if (found_baseclass)
1667 v = value_primitive_field (arg1, offset, i, type);
1669 v = search_struct_field (name, arg1,
1670 offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
1671 basetype, looking_for_baseclass);
1677 /* Helper function used by value_struct_elt to recurse through baseclasses.
1678 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1679 and search in it assuming it has (class) type TYPE.
1680 If found, return value, else if name matched and args not return (value)-1,
1681 else return NULL. */
1684 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
1686 register value_ptr *arg1p, *args;
1687 int offset, *static_memfuncp;
1688 register struct type *type;
1692 int name_matched = 0;
1693 char dem_opname[64];
1695 CHECK_TYPEDEF (type);
1696 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1698 char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1699 if (strncmp(t_field_name, "__", 2)==0 ||
1700 strncmp(t_field_name, "op", 2)==0 ||
1701 strncmp(t_field_name, "type", 4)==0 )
1703 if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
1704 t_field_name = dem_opname;
1705 else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
1706 t_field_name = dem_opname;
1708 if (t_field_name && STREQ (t_field_name, name))
1710 int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1711 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1714 if (j > 0 && args == 0)
1715 error ("cannot resolve overloaded method `%s'", name);
1718 if (TYPE_FN_FIELD_STUB (f, j))
1719 check_stub_method (type, i, j);
1720 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1721 TYPE_FN_FIELD_ARGS (f, j), args))
1723 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1724 return value_virtual_fn_field (arg1p, f, j, type, offset);
1725 if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
1726 *static_memfuncp = 1;
1727 v = value_fn_field (arg1p, f, j, type, offset);
1728 if (v != NULL) return v;
1735 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1739 if (BASETYPE_VIA_VIRTUAL (type, i))
1741 base_offset = VALUE_OFFSET (*arg1p) + offset;
1743 baseclass_offset (type, i,
1744 VALUE_CONTENTS (*arg1p) + base_offset,
1745 VALUE_ADDRESS (*arg1p) + base_offset);
1746 if (base_offset == -1)
1747 error ("virtual baseclass botch");
1751 base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1753 v = search_struct_method (name, arg1p, args, base_offset + offset,
1754 static_memfuncp, TYPE_BASECLASS (type, i));
1755 if (v == (value_ptr) -1)
1761 /* FIXME-bothner: Why is this commented out? Why is it here? */
1762 /* *arg1p = arg1_tmp;*/
1766 if (name_matched) return (value_ptr) -1;
1770 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1771 extract the component named NAME from the ultimate target structure/union
1772 and return it as a value with its appropriate type.
1773 ERR is used in the error message if *ARGP's type is wrong.
1775 C++: ARGS is a list of argument types to aid in the selection of
1776 an appropriate method. Also, handle derived types.
1778 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1779 where the truthvalue of whether the function that was resolved was
1780 a static member function or not is stored.
1782 ERR is an error message to be printed in case the field is not found. */
1785 value_struct_elt (argp, args, name, static_memfuncp, err)
1786 register value_ptr *argp, *args;
1788 int *static_memfuncp;
1791 register struct type *t;
1794 COERCE_ARRAY (*argp);
1796 t = check_typedef (VALUE_TYPE (*argp));
1798 /* Follow pointers until we get to a non-pointer. */
1800 while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1802 *argp = value_ind (*argp);
1803 /* Don't coerce fn pointer to fn and then back again! */
1804 if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
1805 COERCE_ARRAY (*argp);
1806 t = check_typedef (VALUE_TYPE (*argp));
1809 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1810 error ("not implemented: member type in value_struct_elt");
1812 if ( TYPE_CODE (t) != TYPE_CODE_STRUCT
1813 && TYPE_CODE (t) != TYPE_CODE_UNION)
1814 error ("Attempt to extract a component of a value that is not a %s.", err);
1816 /* Assume it's not, unless we see that it is. */
1817 if (static_memfuncp)
1818 *static_memfuncp =0;
1822 /* if there are no arguments ...do this... */
1824 /* Try as a field first, because if we succeed, there
1825 is less work to be done. */
1826 v = search_struct_field (name, *argp, 0, t, 0);
1830 /* C++: If it was not found as a data field, then try to
1831 return it as a pointer to a method. */
1833 if (destructor_name_p (name, t))
1834 error ("Cannot get value of destructor");
1836 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1838 if (v == (value_ptr) -1)
1839 error ("Cannot take address of a method");
1842 if (TYPE_NFN_FIELDS (t))
1843 error ("There is no member or method named %s.", name);
1845 error ("There is no member named %s.", name);
1850 if (destructor_name_p (name, t))
1854 /* destructors are a special case. */
1855 v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, 0),
1856 TYPE_FN_FIELDLIST_LENGTH (t, 0), 0, 0);
1857 if (!v) error("could not find destructor function named %s.", name);
1862 error ("destructor should not have any argument");
1866 v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1868 if (v == (value_ptr) -1)
1870 error("Argument list of %s mismatch with component in the structure.", name);
1874 /* See if user tried to invoke data as function. If so,
1875 hand it back. If it's not callable (i.e., a pointer to function),
1876 gdb should give an error. */
1877 v = search_struct_field (name, *argp, 0, t, 0);
1881 error ("Structure has no component named %s.", name);
1885 /* C++: return 1 is NAME is a legitimate name for the destructor
1886 of type TYPE. If TYPE does not have a destructor, or
1887 if NAME is inappropriate for TYPE, an error is signaled. */
1889 destructor_name_p (name, type)
1891 const struct type *type;
1893 /* destructors are a special case. */
1897 char *dname = type_name_no_tag (type);
1898 char *cp = strchr (dname, '<');
1901 /* Do not compare the template part for template classes. */
1903 len = strlen (dname);
1906 if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
1907 error ("name of destructor must equal name of class");
1914 /* Helper function for check_field: Given TYPE, a structure/union,
1915 return 1 if the component named NAME from the ultimate
1916 target structure/union is defined, otherwise, return 0. */
1919 check_field_in (type, name)
1920 register struct type *type;
1925 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1927 char *t_field_name = TYPE_FIELD_NAME (type, i);
1928 if (t_field_name && STREQ (t_field_name, name))
1932 /* C++: If it was not found as a data field, then try to
1933 return it as a pointer to a method. */
1935 /* Destructors are a special case. */
1936 if (destructor_name_p (name, type))
1939 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1941 if (STREQ (TYPE_FN_FIELDLIST_NAME (type, i), name))
1945 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1946 if (check_field_in (TYPE_BASECLASS (type, i), name))
1953 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1954 return 1 if the component named NAME from the ultimate
1955 target structure/union is defined, otherwise, return 0. */
1958 check_field (arg1, name)
1959 register value_ptr arg1;
1962 register struct type *t;
1964 COERCE_ARRAY (arg1);
1966 t = VALUE_TYPE (arg1);
1968 /* Follow pointers until we get to a non-pointer. */
1973 if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
1975 t = TYPE_TARGET_TYPE (t);
1978 if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1979 error ("not implemented: member type in check_field");
1981 if ( TYPE_CODE (t) != TYPE_CODE_STRUCT
1982 && TYPE_CODE (t) != TYPE_CODE_UNION)
1983 error ("Internal error: `this' is not an aggregate");
1985 return check_field_in (t, name);
1988 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1989 return the address of this member as a "pointer to member"
1990 type. If INTYPE is non-null, then it will be the type
1991 of the member we are looking for. This will help us resolve
1992 "pointers to member functions". This function is used
1993 to resolve user expressions of the form "DOMAIN::NAME". */
1996 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
1997 struct type *domain, *curtype, *intype;
2001 register struct type *t = curtype;
2005 if ( TYPE_CODE (t) != TYPE_CODE_STRUCT
2006 && TYPE_CODE (t) != TYPE_CODE_UNION)
2007 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2009 for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2011 char *t_field_name = TYPE_FIELD_NAME (t, i);
2013 if (t_field_name && STREQ (t_field_name, name))
2015 if (TYPE_FIELD_STATIC (t, i))
2017 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (t, i);
2018 struct symbol *sym =
2019 lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
2021 error ("Internal error: could not find physical static variable named %s",
2023 return value_at (SYMBOL_TYPE (sym),
2024 (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
2026 if (TYPE_FIELD_PACKED (t, i))
2027 error ("pointers to bitfield members not allowed");
2029 return value_from_longest
2030 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
2032 offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2036 /* C++: If it was not found as a data field, then try to
2037 return it as a pointer to a method. */
2039 /* Destructors are a special case. */
2040 if (destructor_name_p (name, t))
2042 error ("member pointers to destructors not implemented yet");
2045 /* Perform all necessary dereferencing. */
2046 while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2047 intype = TYPE_TARGET_TYPE (intype);
2049 for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2051 char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2052 char dem_opname[64];
2054 if (strncmp(t_field_name, "__", 2)==0 ||
2055 strncmp(t_field_name, "op", 2)==0 ||
2056 strncmp(t_field_name, "type", 4)==0 )
2058 if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
2059 t_field_name = dem_opname;
2060 else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
2061 t_field_name = dem_opname;
2063 if (t_field_name && STREQ (t_field_name, name))
2065 int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2066 struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2068 if (intype == 0 && j > 1)
2069 error ("non-unique member `%s' requires type instantiation", name);
2073 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2076 error ("no member function matches that type instantiation");
2081 if (TYPE_FN_FIELD_STUB (f, j))
2082 check_stub_method (t, i, j);
2083 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2085 return value_from_longest
2086 (lookup_reference_type
2087 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2089 (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
2093 struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2094 0, VAR_NAMESPACE, 0, NULL);
2101 v = read_var_value (s, 0);
2103 VALUE_TYPE (v) = lookup_reference_type
2104 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2112 for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2117 if (BASETYPE_VIA_VIRTUAL (t, i))
2120 base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2121 v = value_struct_elt_for_reference (domain,
2122 offset + base_offset,
2123 TYPE_BASECLASS (t, i),
2132 /* C++: return the value of the class instance variable, if one exists.
2133 Flag COMPLAIN signals an error if the request is made in an
2134 inappropriate context. */
2137 value_of_this (complain)
2140 struct symbol *func, *sym;
2143 static const char funny_this[] = "this";
2146 if (selected_frame == 0)
2148 error ("no frame selected");
2151 func = get_frame_function (selected_frame);
2155 error ("no `this' in nameless context");
2159 b = SYMBOL_BLOCK_VALUE (func);
2160 i = BLOCK_NSYMS (b);
2163 error ("no args, no `this'");
2166 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2167 symbol instead of the LOC_ARG one (if both exist). */
2168 sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
2172 error ("current stack frame not in method");
2177 this = read_var_value (sym, selected_frame);
2178 if (this == 0 && complain)
2179 error ("`this' argument at unknown address");
2183 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2184 long, starting at LOWBOUND. The result has the same lower bound as
2185 the original ARRAY. */
2188 value_slice (array, lowbound, length)
2190 int lowbound, length;
2192 struct type *slice_range_type, *slice_type, *range_type;
2193 LONGEST lowerbound, upperbound, offset;
2195 struct type *array_type;
2196 array_type = check_typedef (VALUE_TYPE (array));
2197 COERCE_VARYING_ARRAY (array, array_type);
2198 if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
2199 && TYPE_CODE (array_type) != TYPE_CODE_STRING
2200 && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
2201 error ("cannot take slice of non-array");
2202 range_type = TYPE_INDEX_TYPE (array_type);
2203 if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
2204 error ("slice from bad array or bitstring");
2205 if (lowbound < lowerbound || length < 0
2206 || lowbound + length - 1 > upperbound
2207 /* Chill allows zero-length strings but not arrays. */
2208 || (current_language->la_language == language_chill
2209 && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY))
2210 error ("slice out of range");
2211 /* FIXME-type-allocation: need a way to free this type when we are
2213 slice_range_type = create_range_type ((struct type*) NULL,
2214 TYPE_TARGET_TYPE (range_type),
2215 lowerbound, lowerbound + length - 1);
2216 if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
2219 slice_type = create_set_type ((struct type*) NULL, slice_range_type);
2220 TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
2221 slice = value_zero (slice_type, not_lval);
2222 for (i = 0; i < length; i++)
2224 int element = value_bit_index (array_type,
2225 VALUE_CONTENTS (array),
2228 error ("internal error accessing bitstring");
2229 else if (element > 0)
2231 int j = i % TARGET_CHAR_BIT;
2232 if (BITS_BIG_ENDIAN)
2233 j = TARGET_CHAR_BIT - 1 - j;
2234 VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
2237 /* We should set the address, bitssize, and bitspos, so the clice
2238 can be used on the LHS, but that may require extensions to
2239 value_assign. For now, just leave as a non_lval. FIXME. */
2243 struct type *element_type = TYPE_TARGET_TYPE (array_type);
2245 = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
2246 slice_type = create_array_type ((struct type*) NULL, element_type,
2248 TYPE_CODE (slice_type) = TYPE_CODE (array_type);
2249 slice = allocate_value (slice_type);
2250 if (VALUE_LAZY (array))
2251 VALUE_LAZY (slice) = 1;
2253 memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
2254 TYPE_LENGTH (slice_type));
2255 if (VALUE_LVAL (array) == lval_internalvar)
2256 VALUE_LVAL (slice) = lval_internalvar_component;
2258 VALUE_LVAL (slice) = VALUE_LVAL (array);
2259 VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2260 VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
2265 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2266 value as a fixed-length array. */
2269 varying_to_slice (varray)
2272 struct type *vtype = check_typedef (VALUE_TYPE (varray));
2273 LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
2274 VALUE_CONTENTS (varray)
2275 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
2276 return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
2279 /* Create a value for a FORTRAN complex number. Currently most of
2280 the time values are coerced to COMPLEX*16 (i.e. a complex number
2281 composed of 2 doubles. This really should be a smarter routine
2282 that figures out precision inteligently as opposed to assuming
2283 doubles. FIXME: fmb */
2286 value_literal_complex (arg1, arg2, type)
2291 register value_ptr val;
2292 struct type *real_type = TYPE_TARGET_TYPE (type);
2294 val = allocate_value (type);
2295 arg1 = value_cast (real_type, arg1);
2296 arg2 = value_cast (real_type, arg2);
2298 memcpy (VALUE_CONTENTS_RAW (val),
2299 VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
2300 memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
2301 VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
2305 /* Cast a value into the appropriate complex data type. */
2308 cast_into_complex (type, val)
2310 register value_ptr val;
2312 struct type *real_type = TYPE_TARGET_TYPE (type);
2313 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
2315 struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
2316 value_ptr re_val = allocate_value (val_real_type);
2317 value_ptr im_val = allocate_value (val_real_type);
2319 memcpy (VALUE_CONTENTS_RAW (re_val),
2320 VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
2321 memcpy (VALUE_CONTENTS_RAW (im_val),
2322 VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
2323 TYPE_LENGTH (val_real_type));
2325 return value_literal_complex (re_val, im_val, type);
2327 else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
2328 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
2329 return value_literal_complex (val, value_zero (real_type, not_lval), type);
2331 error ("cannot cast non-number to complex");
2335 _initialize_valops ()
2339 (add_set_cmd ("abandon", class_support, var_boolean, (char *)&auto_abandon,
2340 "Set automatic abandonment of expressions upon failure.",