1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
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. */
34 #include "gdb_string.h"
36 /* Default to coercing float to double in function calls only when there is
37 no prototype. Otherwise on targets where the debug information is incorrect
38 for either the prototype or non-prototype case, we can force it by defining
39 COERCE_FLOAT_TO_DOUBLE in the target configuration file. */
41 #ifndef COERCE_FLOAT_TO_DOUBLE
42 #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL)
45 /* Flag indicating HP compilers were used; needed to correctly handle some
46 value operations with HP aCC code/runtime. */
47 extern int hp_som_som_object_present
;
50 /* Local functions. */
52 static int typecmp
PARAMS ((int staticp
, struct type
*t1
[], value_ptr t2
[]));
55 static CORE_ADDR find_function_addr
PARAMS ((value_ptr
, struct type
**));
56 static value_ptr value_arg_coerce
PARAMS ((value_ptr
, struct type
*, int));
60 #ifndef PUSH_ARGUMENTS
61 static CORE_ADDR value_push
PARAMS ((CORE_ADDR
, value_ptr
));
64 static value_ptr search_struct_field
PARAMS ((char *, value_ptr
, int,
67 static value_ptr search_struct_field_aux
PARAMS ((char *, value_ptr
, int,
68 struct type
*, int, int *, char *,
71 static value_ptr search_struct_method
PARAMS ((char *, value_ptr
*,
73 int, int *, struct type
*));
75 static int check_field_in
PARAMS ((struct type
*, const char *));
77 static CORE_ADDR allocate_space_in_inferior
PARAMS ((int));
79 static value_ptr cast_into_complex
PARAMS ((struct type
*, value_ptr
));
81 void _initialize_valops
PARAMS ((void));
83 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
85 /* Flag for whether we want to abandon failed expression evals by default. */
88 static int auto_abandon
= 0;
91 int overload_resolution
= 0;
95 /* Find the address of function name NAME in the inferior. */
98 find_function_in_inferior (name
)
101 register struct symbol
*sym
;
102 sym
= lookup_symbol (name
, 0, VAR_NAMESPACE
, 0, NULL
);
105 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
107 error ("\"%s\" exists in this program but is not a function.",
110 return value_of_variable (sym
, NULL
);
114 struct minimal_symbol
*msymbol
= lookup_minimal_symbol(name
, NULL
, NULL
);
119 type
= lookup_pointer_type (builtin_type_char
);
120 type
= lookup_function_type (type
);
121 type
= lookup_pointer_type (type
);
122 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
123 return value_from_longest (type
, maddr
);
127 if (!target_has_execution
)
128 error ("evaluation of this expression requires the target program to be active");
130 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
135 /* Allocate NBYTES of space in the inferior using the inferior's malloc
136 and return a value that is a pointer to the allocated space. */
139 value_allocate_space_in_inferior (len
)
143 register value_ptr val
= find_function_in_inferior ("malloc");
145 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
146 val
= call_function_by_hand (val
, 1, &blocklen
);
147 if (value_logical_not (val
))
149 if (!target_has_execution
)
150 error ("No memory available to program now: you need to start the target first");
152 error ("No memory available to program: call to malloc failed");
158 allocate_space_in_inferior (len
)
161 return value_as_long (value_allocate_space_in_inferior (len
));
164 /* Cast value ARG2 to type TYPE and return as a value.
165 More general than a C cast: accepts any two types of the same length,
166 and if ARG2 is an lvalue it can be cast into anything at all. */
167 /* In C++, casts may change pointer or object representations. */
170 value_cast (type
, arg2
)
172 register value_ptr arg2
;
174 register enum type_code code1
;
175 register enum type_code code2
;
179 int convert_to_boolean
= 0;
181 if (VALUE_TYPE (arg2
) == type
)
184 CHECK_TYPEDEF (type
);
185 code1
= TYPE_CODE (type
);
187 type2
= check_typedef (VALUE_TYPE (arg2
));
189 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
190 is treated like a cast to (TYPE [N])OBJECT,
191 where N is sizeof(OBJECT)/sizeof(TYPE). */
192 if (code1
== TYPE_CODE_ARRAY
)
194 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
195 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
196 if (element_length
> 0
197 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
199 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
200 int val_length
= TYPE_LENGTH (type2
);
201 LONGEST low_bound
, high_bound
, new_length
;
202 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
203 low_bound
= 0, high_bound
= 0;
204 new_length
= val_length
/ element_length
;
205 if (val_length
% element_length
!= 0)
206 warning("array element type size does not divide object size in cast");
207 /* FIXME-type-allocation: need a way to free this type when we are
209 range_type
= create_range_type ((struct type
*) NULL
,
210 TYPE_TARGET_TYPE (range_type
),
212 new_length
+ low_bound
- 1);
213 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
214 element_type
, range_type
);
219 if (current_language
->c_style_arrays
220 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
221 arg2
= value_coerce_array (arg2
);
223 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
224 arg2
= value_coerce_function (arg2
);
226 type2
= check_typedef (VALUE_TYPE (arg2
));
227 COERCE_VARYING_ARRAY (arg2
, type2
);
228 code2
= TYPE_CODE (type2
);
230 if (code1
== TYPE_CODE_COMPLEX
)
231 return cast_into_complex (type
, arg2
);
232 if (code1
== TYPE_CODE_BOOL
)
234 code1
= TYPE_CODE_INT
;
235 convert_to_boolean
= 1;
237 if (code1
== TYPE_CODE_CHAR
)
238 code1
= TYPE_CODE_INT
;
239 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
240 code2
= TYPE_CODE_INT
;
242 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
243 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
245 if ( code1
== TYPE_CODE_STRUCT
246 && code2
== TYPE_CODE_STRUCT
247 && TYPE_NAME (type
) != 0)
249 /* Look in the type of the source to see if it contains the
250 type of the target as a superclass. If so, we'll need to
251 offset the object in addition to changing its type. */
252 value_ptr v
= search_struct_field (type_name_no_tag (type
),
256 VALUE_TYPE (v
) = type
;
260 if (code1
== TYPE_CODE_FLT
&& scalar
)
261 return value_from_double (type
, value_as_double (arg2
));
262 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
263 || code1
== TYPE_CODE_RANGE
)
264 && (scalar
|| code2
== TYPE_CODE_PTR
))
268 if (hp_som_som_object_present
&& /* if target compiled by HP aCC */
269 (code2
== TYPE_CODE_PTR
))
274 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2
)))
276 /* With HP aCC, pointers to data members have a bias */
277 case TYPE_CODE_MEMBER
:
278 retvalp
= value_from_longest (type
, value_as_long (arg2
));
279 ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
); /* force evaluation */
280 *ptr
&= ~0x20000000; /* zap 29th bit to remove bias */
283 /* While pointers to methods don't really point to a function */
284 case TYPE_CODE_METHOD
:
285 error ("Pointers to methods not supported with HP aCC");
288 break; /* fall out and go to normal handling */
291 longest
= value_as_long (arg2
);
292 return value_from_longest (type
, convert_to_boolean
? (LONGEST
) (longest
? 1 : 0) : longest
);
294 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
296 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
298 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
299 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
300 if ( TYPE_CODE (t1
) == TYPE_CODE_STRUCT
301 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
302 && !value_logical_not (arg2
))
306 /* Look in the type of the source to see if it contains the
307 type of the target as a superclass. If so, we'll need to
308 offset the pointer rather than just change its type. */
309 if (TYPE_NAME (t1
) != NULL
)
311 v
= search_struct_field (type_name_no_tag (t1
),
312 value_ind (arg2
), 0, t2
, 1);
316 VALUE_TYPE (v
) = type
;
321 /* Look in the type of the target to see if it contains the
322 type of the source as a superclass. If so, we'll need to
323 offset the pointer rather than just change its type.
324 FIXME: This fails silently with virtual inheritance. */
325 if (TYPE_NAME (t2
) != NULL
)
327 v
= search_struct_field (type_name_no_tag (t2
),
328 value_zero (t1
, not_lval
), 0, t1
, 1);
331 value_ptr v2
= value_ind (arg2
);
332 VALUE_ADDRESS (v2
) -= VALUE_ADDRESS (v
)
334 v2
= value_addr (v2
);
335 VALUE_TYPE (v2
) = type
;
340 /* No superclass found, just fall through to change ptr type. */
342 VALUE_TYPE (arg2
) = type
;
343 VALUE_ENCLOSING_TYPE (arg2
) = type
; /* pai: chk_val */
344 VALUE_POINTED_TO_OFFSET (arg2
) = 0; /* pai: chk_val */
347 else if (chill_varying_type (type
))
349 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
352 LONGEST low_bound
, high_bound
;
353 char *valaddr
, *valaddr_data
;
354 /* For lint warning about eltype2 possibly uninitialized: */
356 if (code2
== TYPE_CODE_BITSTRING
)
357 error ("not implemented: converting bitstring to varying type");
358 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
359 || (eltype1
= check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1))),
360 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
)),
361 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
362 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
363 error ("Invalid conversion to varying type");
364 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
365 range2
= TYPE_FIELD_TYPE (type2
, 0);
366 if (get_discrete_bounds (range1
, &low_bound
, &high_bound
) < 0)
369 count1
= high_bound
- low_bound
+ 1;
370 if (get_discrete_bounds (range2
, &low_bound
, &high_bound
) < 0)
371 count1
= -1, count2
= 0; /* To force error before */
373 count2
= high_bound
- low_bound
+ 1;
375 error ("target varying type is too small");
376 val
= allocate_value (type
);
377 valaddr
= VALUE_CONTENTS_RAW (val
);
378 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
379 /* Set val's __var_length field to count2. */
380 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
382 /* Set the __var_data field to count2 elements copied from arg2. */
383 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
384 count2
* TYPE_LENGTH (eltype2
));
385 /* Zero the rest of the __var_data field of val. */
386 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
387 (count1
- count2
) * TYPE_LENGTH (eltype2
));
390 else if (VALUE_LVAL (arg2
) == lval_memory
)
392 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
),
393 VALUE_BFD_SECTION (arg2
));
395 else if (code1
== TYPE_CODE_VOID
)
397 return value_zero (builtin_type_void
, not_lval
);
401 error ("Invalid cast.");
406 /* Create a value of type TYPE that is zero, and return it. */
409 value_zero (type
, lv
)
413 register value_ptr val
= allocate_value (type
);
415 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (check_typedef (type
)));
416 VALUE_LVAL (val
) = lv
;
421 /* Return a value with type TYPE located at ADDR.
423 Call value_at only if the data needs to be fetched immediately;
424 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
425 value_at_lazy instead. value_at_lazy simply records the address of
426 the data and sets the lazy-evaluation-required flag. The lazy flag
427 is tested in the VALUE_CONTENTS macro, which is used if and when
428 the contents are actually required.
430 Note: value_at does *NOT* handle embedded offsets; perform such
431 adjustments before or after calling it. */
434 value_at (type
, addr
, sect
)
439 register value_ptr val
;
441 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
442 error ("Attempt to dereference a generic pointer.");
444 val
= allocate_value (type
);
446 #ifdef GDB_TARGET_IS_D10V
447 if (TYPE_CODE (type
) == TYPE_CODE_PTR
448 && TYPE_TARGET_TYPE (type
)
449 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
451 /* pointer to function */
454 snum
= read_memory_unsigned_integer (addr
, 2);
455 num
= D10V_MAKE_IADDR(snum
);
456 store_address ( VALUE_CONTENTS_RAW (val
), 4, num
);
458 else if (TYPE_CODE(type
) == TYPE_CODE_PTR
)
460 /* pointer to data */
463 snum
= read_memory_unsigned_integer (addr
, 2);
464 num
= D10V_MAKE_DADDR(snum
);
465 store_address ( VALUE_CONTENTS_RAW (val
), 4, num
);
469 read_memory_section (addr
, VALUE_CONTENTS_ALL_RAW (val
), TYPE_LENGTH (type
), sect
);
471 VALUE_LVAL (val
) = lval_memory
;
472 VALUE_ADDRESS (val
) = addr
;
473 VALUE_BFD_SECTION (val
) = sect
;
478 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
481 value_at_lazy (type
, addr
, sect
)
486 register value_ptr val
;
488 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
489 error ("Attempt to dereference a generic pointer.");
491 val
= allocate_value (type
);
493 VALUE_LVAL (val
) = lval_memory
;
494 VALUE_ADDRESS (val
) = addr
;
495 VALUE_LAZY (val
) = 1;
496 VALUE_BFD_SECTION (val
) = sect
;
501 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
502 if the current data for a variable needs to be loaded into
503 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
504 clears the lazy flag to indicate that the data in the buffer is valid.
506 If the value is zero-length, we avoid calling read_memory, which would
507 abort. We mark the value as fetched anyway -- all 0 bytes of it.
509 This function returns a value because it is used in the VALUE_CONTENTS
510 macro as part of an expression, where a void would not work. The
514 value_fetch_lazy (val
)
515 register value_ptr val
;
517 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
518 int length
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
));
520 #ifdef GDB_TARGET_IS_D10V
521 struct type
*type
= VALUE_TYPE(val
);
522 if (TYPE_CODE (type
) == TYPE_CODE_PTR
523 && TYPE_TARGET_TYPE (type
)
524 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
526 /* pointer to function */
529 snum
= read_memory_unsigned_integer (addr
, 2);
530 num
= D10V_MAKE_IADDR(snum
);
531 store_address ( VALUE_CONTENTS_RAW (val
), 4, num
);
533 else if (TYPE_CODE(type
) == TYPE_CODE_PTR
)
535 /* pointer to data */
538 snum
= read_memory_unsigned_integer (addr
, 2);
539 num
= D10V_MAKE_DADDR(snum
);
540 store_address ( VALUE_CONTENTS_RAW (val
), 4, num
);
546 read_memory_section (addr
, VALUE_CONTENTS_ALL_RAW (val
), length
,
547 VALUE_BFD_SECTION (val
));
548 VALUE_LAZY (val
) = 0;
553 /* Store the contents of FROMVAL into the location of TOVAL.
554 Return a new value with the location of TOVAL and contents of FROMVAL. */
557 value_assign (toval
, fromval
)
558 register value_ptr toval
, fromval
;
560 register struct type
*type
;
561 register value_ptr val
;
562 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
565 if (!toval
->modifiable
)
566 error ("Left operand of assignment is not a modifiable lvalue.");
570 type
= VALUE_TYPE (toval
);
571 if (VALUE_LVAL (toval
) != lval_internalvar
)
572 fromval
= value_cast (type
, fromval
);
574 COERCE_ARRAY (fromval
);
575 CHECK_TYPEDEF (type
);
577 /* If TOVAL is a special machine register requiring conversion
578 of program values to a special raw format,
579 convert FROMVAL's contents now, with result in `raw_buffer',
580 and set USE_BUFFER to the number of bytes to write. */
582 #ifdef REGISTER_CONVERTIBLE
583 if (VALUE_REGNO (toval
) >= 0
584 && REGISTER_CONVERTIBLE (VALUE_REGNO (toval
)))
586 int regno
= VALUE_REGNO (toval
);
587 if (REGISTER_CONVERTIBLE (regno
))
589 struct type
*fromtype
= check_typedef (VALUE_TYPE (fromval
));
590 REGISTER_CONVERT_TO_RAW (fromtype
, regno
,
591 VALUE_CONTENTS (fromval
), raw_buffer
);
592 use_buffer
= REGISTER_RAW_SIZE (regno
);
597 switch (VALUE_LVAL (toval
))
599 case lval_internalvar
:
600 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
601 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
602 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
603 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
604 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
607 case lval_internalvar_component
:
608 set_internalvar_component (VALUE_INTERNALVAR (toval
),
609 VALUE_OFFSET (toval
),
610 VALUE_BITPOS (toval
),
611 VALUE_BITSIZE (toval
),
618 CORE_ADDR changed_addr
;
621 if (VALUE_BITSIZE (toval
))
623 char buffer
[sizeof (LONGEST
)];
624 /* We assume that the argument to read_memory is in units of
625 host chars. FIXME: Is that correct? */
626 changed_len
= (VALUE_BITPOS (toval
)
627 + VALUE_BITSIZE (toval
)
631 if (changed_len
> (int) sizeof (LONGEST
))
632 error ("Can't handle bitfields which don't fit in a %d bit word.",
633 sizeof (LONGEST
) * HOST_CHAR_BIT
);
635 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
636 buffer
, changed_len
);
637 modify_field (buffer
, value_as_long (fromval
),
638 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
639 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
640 dest_buffer
= buffer
;
644 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
645 changed_len
= use_buffer
;
646 dest_buffer
= raw_buffer
;
650 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
651 changed_len
= TYPE_LENGTH (type
);
652 dest_buffer
= VALUE_CONTENTS (fromval
);
655 write_memory (changed_addr
, dest_buffer
, changed_len
);
656 if (memory_changed_hook
)
657 memory_changed_hook (changed_addr
, changed_len
);
662 if (VALUE_BITSIZE (toval
))
664 char buffer
[sizeof (LONGEST
)];
665 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
667 if (len
> (int) sizeof (LONGEST
))
668 error ("Can't handle bitfields in registers larger than %d bits.",
669 sizeof (LONGEST
) * HOST_CHAR_BIT
);
671 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
672 > len
* HOST_CHAR_BIT
)
673 /* Getting this right would involve being very careful about
676 Can't handle bitfield which doesn't fit in a single register.");
678 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
680 modify_field (buffer
, value_as_long (fromval
),
681 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
682 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
686 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
687 raw_buffer
, use_buffer
);
690 /* Do any conversion necessary when storing this type to more
691 than one register. */
692 #ifdef REGISTER_CONVERT_FROM_TYPE
693 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
694 REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval
), type
, raw_buffer
);
695 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
696 raw_buffer
, TYPE_LENGTH (type
));
698 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
699 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
702 /* Assigning to the stack pointer, frame pointer, and other
703 (architecture and calling convention specific) registers may
704 cause the frame cache to be out of date. We just do this
705 on all assignments to registers for simplicity; I doubt the slowdown
707 reinit_frame_cache ();
710 case lval_reg_frame_relative
:
712 /* value is stored in a series of registers in the frame
713 specified by the structure. Copy that value out, modify
714 it, and copy it back in. */
715 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
716 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
717 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
718 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
721 /* Make the buffer large enough in all cases. */
722 char *buffer
= (char *) alloca (amount_to_copy
724 + MAX_REGISTER_RAW_SIZE
);
727 struct frame_info
*frame
;
729 /* Figure out which frame this is in currently. */
730 for (frame
= get_current_frame ();
731 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
732 frame
= get_prev_frame (frame
))
736 error ("Value being assigned to is no longer active.");
738 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
741 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
743 amount_copied
< amount_to_copy
;
744 amount_copied
+= reg_size
, regno
++)
746 get_saved_register (buffer
+ amount_copied
,
747 (int *)NULL
, (CORE_ADDR
*)NULL
,
748 frame
, regno
, (enum lval_type
*)NULL
);
751 /* Modify what needs to be modified. */
752 if (VALUE_BITSIZE (toval
))
753 modify_field (buffer
+ byte_offset
,
754 value_as_long (fromval
),
755 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
757 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
759 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
763 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
765 amount_copied
< amount_to_copy
;
766 amount_copied
+= reg_size
, regno
++)
772 /* Just find out where to put it. */
773 get_saved_register ((char *)NULL
,
774 &optim
, &addr
, frame
, regno
, &lval
);
777 error ("Attempt to assign to a value that was optimized out.");
778 if (lval
== lval_memory
)
779 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
780 else if (lval
== lval_register
)
781 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
783 error ("Attempt to assign to an unmodifiable value.");
786 if (register_changed_hook
)
787 register_changed_hook (-1);
793 error ("Left operand of assignment is not an lvalue.");
796 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
797 If the field is signed, and is negative, then sign extend. */
798 if ((VALUE_BITSIZE (toval
) > 0)
799 && (VALUE_BITSIZE (toval
) < 8 * (int) sizeof (LONGEST
)))
801 LONGEST fieldval
= value_as_long (fromval
);
802 LONGEST valmask
= (((ULONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
805 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
806 fieldval
|= ~valmask
;
808 fromval
= value_from_longest (type
, fieldval
);
811 val
= value_copy (toval
);
812 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
814 VALUE_TYPE (val
) = type
;
815 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
816 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
817 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
822 /* Extend a value VAL to COUNT repetitions of its type. */
825 value_repeat (arg1
, count
)
829 register value_ptr val
;
831 if (VALUE_LVAL (arg1
) != lval_memory
)
832 error ("Only values in memory can be extended with '@'.");
834 error ("Invalid number %d of repetitions.", count
);
836 val
= allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1
), count
);
838 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
839 VALUE_CONTENTS_ALL_RAW (val
),
840 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)));
841 VALUE_LVAL (val
) = lval_memory
;
842 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
848 value_of_variable (var
, b
)
853 struct frame_info
*frame
= NULL
;
856 frame
= NULL
; /* Use selected frame. */
857 else if (symbol_read_needs_frame (var
))
859 frame
= block_innermost_frame (b
);
862 if (BLOCK_FUNCTION (b
)
863 && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)))
864 error ("No frame is currently executing in block %s.",
865 SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)));
867 error ("No frame is currently executing in specified block");
871 val
= read_var_value (var
, frame
);
873 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
878 /* Given a value which is an array, return a value which is a pointer to its
879 first element, regardless of whether or not the array has a nonzero lower
882 FIXME: A previous comment here indicated that this routine should be
883 substracting the array's lower bound. It's not clear to me that this
884 is correct. Given an array subscripting operation, it would certainly
885 work to do the adjustment here, essentially computing:
887 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
889 However I believe a more appropriate and logical place to account for
890 the lower bound is to do so in value_subscript, essentially computing:
892 (&array[0] + ((index - lowerbound) * sizeof array[0]))
894 As further evidence consider what would happen with operations other
895 than array subscripting, where the caller would get back a value that
896 had an address somewhere before the actual first element of the array,
897 and the information about the lower bound would be lost because of
898 the coercion to pointer type.
902 value_coerce_array (arg1
)
905 register struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
907 if (VALUE_LVAL (arg1
) != lval_memory
)
908 error ("Attempt to take address of value not located in memory.");
910 return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
911 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
914 /* Given a value which is a function, return a value which is a pointer
918 value_coerce_function (arg1
)
923 if (VALUE_LVAL (arg1
) != lval_memory
)
924 error ("Attempt to take address of value not located in memory.");
926 retval
= value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
927 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
928 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (arg1
);
932 /* Return a pointer value for the object for which ARG1 is the contents. */
940 struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
941 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
943 /* Copy the value, but change the type from (T&) to (T*).
944 We keep the same location information, which is efficient,
945 and allows &(&X) to get the location containing the reference. */
946 arg2
= value_copy (arg1
);
947 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
950 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
951 return value_coerce_function (arg1
);
953 if (VALUE_LVAL (arg1
) != lval_memory
)
954 error ("Attempt to take address of value not located in memory.");
956 /* Get target memory address */
957 arg2
= value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
958 (LONGEST
) (VALUE_ADDRESS (arg1
)
959 + VALUE_OFFSET (arg1
)
960 + VALUE_EMBEDDED_OFFSET (arg1
)));
962 /* This may be a pointer to a base subobject; so remember the
963 full derived object's type ... */
964 VALUE_ENCLOSING_TYPE (arg2
) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1
));
965 /* ... and also the relative position of the subobject in the full object */
966 VALUE_POINTED_TO_OFFSET (arg2
) = VALUE_EMBEDDED_OFFSET (arg1
);
967 VALUE_BFD_SECTION (arg2
) = VALUE_BFD_SECTION (arg1
);
971 /* Given a value of a pointer type, apply the C unary * operator to it. */
977 struct type
*base_type
;
983 base_type
= check_typedef (VALUE_TYPE (arg1
));
985 if (TYPE_CODE (base_type
) == TYPE_CODE_MEMBER
)
986 error ("not implemented: member types in value_ind");
988 /* Allow * on an integer so we can cast it to whatever we want.
989 This returns an int, which seems like the most C-like thing
990 to do. "long long" variables are rare enough that
991 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
992 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
993 return value_at (builtin_type_int
,
994 (CORE_ADDR
) value_as_long (arg1
),
995 VALUE_BFD_SECTION (arg1
));
996 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
998 struct type
*enc_type
;
999 /* We may be pointing to something embedded in a larger object */
1000 /* Get the real type of the enclosing object */
1001 enc_type
= check_typedef (VALUE_ENCLOSING_TYPE (arg1
));
1002 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1003 /* Retrieve the enclosing object pointed to */
1004 arg2
= value_at_lazy (enc_type
,
1005 value_as_pointer (arg1
) - VALUE_POINTED_TO_OFFSET (arg1
),
1006 VALUE_BFD_SECTION (arg1
));
1007 /* Re-adjust type */
1008 VALUE_TYPE (arg2
) = TYPE_TARGET_TYPE (base_type
);
1009 /* Add embedding info */
1010 VALUE_ENCLOSING_TYPE (arg2
) = enc_type
;
1011 VALUE_EMBEDDED_OFFSET (arg2
) = VALUE_POINTED_TO_OFFSET (arg1
);
1013 /* We may be pointing to an object of some derived type */
1014 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1018 error ("Attempt to take contents of a non-pointer value.");
1019 return 0; /* For lint -- never reached */
1022 /* Pushing small parts of stack frames. */
1024 /* Push one word (the size of object that a register holds). */
1027 push_word (sp
, word
)
1031 register int len
= REGISTER_SIZE
;
1032 char buffer
[MAX_REGISTER_RAW_SIZE
];
1034 store_unsigned_integer (buffer
, len
, word
);
1035 if (INNER_THAN (1, 2))
1037 /* stack grows downward */
1039 write_memory (sp
, buffer
, len
);
1043 /* stack grows upward */
1044 write_memory (sp
, buffer
, len
);
1051 /* Push LEN bytes with data at BUFFER. */
1054 push_bytes (sp
, buffer
, len
)
1059 if (INNER_THAN (1, 2))
1061 /* stack grows downward */
1063 write_memory (sp
, buffer
, len
);
1067 /* stack grows upward */
1068 write_memory (sp
, buffer
, len
);
1075 /* Push onto the stack the specified value VALUE. */
1077 #ifndef PUSH_ARGUMENTS
1080 value_push (sp
, arg
)
1081 register CORE_ADDR sp
;
1084 register int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
1086 if (INNER_THAN (1, 2))
1088 /* stack grows downward */
1090 write_memory (sp
, VALUE_CONTENTS_ALL (arg
), len
);
1094 /* stack grows upward */
1095 write_memory (sp
, VALUE_CONTENTS_ALL (arg
), len
);
1102 #endif /* !PUSH_ARGUMENTS */
1105 /* Perform the standard coercions that are specified
1106 for arguments to be passed to C functions.
1108 If PARAM_TYPE is non-NULL, it is the expected parameter type.
1109 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
1112 value_arg_coerce (arg
, param_type
, is_prototyped
)
1114 struct type
*param_type
;
1117 register struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1118 register struct type
*type
1119 = param_type
? check_typedef (param_type
) : arg_type
;
1121 switch (TYPE_CODE (type
))
1124 if (TYPE_CODE (arg_type
) != TYPE_CODE_REF
)
1126 arg
= value_addr (arg
);
1127 VALUE_TYPE (arg
) = param_type
;
1132 case TYPE_CODE_CHAR
:
1133 case TYPE_CODE_BOOL
:
1134 case TYPE_CODE_ENUM
:
1135 /* If we don't have a prototype, coerce to integer type if necessary. */
1138 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1139 type
= builtin_type_int
;
1141 /* Currently all target ABIs require at least the width of an integer
1142 type for an argument. We may have to conditionalize the following
1143 type coercion for future targets. */
1144 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1145 type
= builtin_type_int
;
1148 /* FIXME: We should always convert floats to doubles in the
1149 non-prototyped case. As many debugging formats include
1150 no information about prototyping, we have to live with
1151 COERCE_FLOAT_TO_DOUBLE for now. */
1152 if (!is_prototyped
&& COERCE_FLOAT_TO_DOUBLE
)
1154 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
1155 type
= builtin_type_double
;
1156 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin_type_double
))
1157 type
= builtin_type_long_double
;
1160 case TYPE_CODE_FUNC
:
1161 type
= lookup_pointer_type (type
);
1163 case TYPE_CODE_ARRAY
:
1164 if (current_language
->c_style_arrays
)
1165 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1167 case TYPE_CODE_UNDEF
:
1169 case TYPE_CODE_STRUCT
:
1170 case TYPE_CODE_UNION
:
1171 case TYPE_CODE_VOID
:
1173 case TYPE_CODE_RANGE
:
1174 case TYPE_CODE_STRING
:
1175 case TYPE_CODE_BITSTRING
:
1176 case TYPE_CODE_ERROR
:
1177 case TYPE_CODE_MEMBER
:
1178 case TYPE_CODE_METHOD
:
1179 case TYPE_CODE_COMPLEX
:
1184 return value_cast (type
, arg
);
1187 /* Determine a function's address and its return type from its value.
1188 Calls error() if the function is not valid for calling. */
1191 find_function_addr (function
, retval_type
)
1193 struct type
**retval_type
;
1195 register struct type
*ftype
= check_typedef (VALUE_TYPE (function
));
1196 register enum type_code code
= TYPE_CODE (ftype
);
1197 struct type
*value_type
;
1200 /* If it's a member function, just look at the function
1203 /* Determine address to call. */
1204 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
1206 funaddr
= VALUE_ADDRESS (function
);
1207 value_type
= TYPE_TARGET_TYPE (ftype
);
1209 else if (code
== TYPE_CODE_PTR
)
1211 funaddr
= value_as_pointer (function
);
1212 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1213 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1214 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1216 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1217 /* FIXME: This is a workaround for the unusual function
1218 pointer representation on the RS/6000, see comment
1219 in config/rs6000/tm-rs6000.h */
1220 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
1222 value_type
= TYPE_TARGET_TYPE (ftype
);
1225 value_type
= builtin_type_int
;
1227 else if (code
== TYPE_CODE_INT
)
1229 /* Handle the case of functions lacking debugging info.
1230 Their values are characters since their addresses are char */
1231 if (TYPE_LENGTH (ftype
) == 1)
1232 funaddr
= value_as_pointer (value_addr (function
));
1234 /* Handle integer used as address of a function. */
1235 funaddr
= (CORE_ADDR
) value_as_long (function
);
1237 value_type
= builtin_type_int
;
1240 error ("Invalid data type for function to be called.");
1242 *retval_type
= value_type
;
1246 /* All this stuff with a dummy frame may seem unnecessarily complicated
1247 (why not just save registers in GDB?). The purpose of pushing a dummy
1248 frame which looks just like a real frame is so that if you call a
1249 function and then hit a breakpoint (get a signal, etc), "backtrace"
1250 will look right. Whether the backtrace needs to actually show the
1251 stack at the time the inferior function was called is debatable, but
1252 it certainly needs to not display garbage. So if you are contemplating
1253 making dummy frames be different from normal frames, consider that. */
1255 /* Perform a function call in the inferior.
1256 ARGS is a vector of values of arguments (NARGS of them).
1257 FUNCTION is a value, the function to be called.
1258 Returns a value representing what the function returned.
1259 May fail to return, if a breakpoint or signal is hit
1260 during the execution of the function.
1262 ARGS is modified to contain coerced values. */
1265 call_function_by_hand (function
, nargs
, args
)
1270 register CORE_ADDR sp
;
1273 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1274 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1275 and remove any extra bytes which might exist because ULONGEST is
1276 bigger than REGISTER_SIZE.
1278 NOTE: This is pretty wierd, as the call dummy is actually a
1279 sequence of instructions. But CISC machines will have
1280 to pack the instructions into REGISTER_SIZE units (and
1281 so will RISC machines for which INSTRUCTION_SIZE is not
1284 static ULONGEST dummy
[] = CALL_DUMMY
;
1285 char dummy1
[REGISTER_SIZE
* sizeof dummy
/ sizeof (ULONGEST
)];
1287 struct type
*value_type
;
1288 unsigned char struct_return
;
1289 CORE_ADDR struct_addr
= 0;
1290 struct inferior_status inf_status
;
1291 struct cleanup
*old_chain
;
1293 int using_gcc
; /* Set to version of gcc in use, or zero if not gcc */
1295 struct type
*param_type
= NULL
;
1296 struct type
*ftype
= check_typedef (SYMBOL_TYPE (function
));
1298 if (!target_has_execution
)
1301 save_inferior_status (&inf_status
, 1);
1302 old_chain
= make_cleanup ((make_cleanup_func
) restore_inferior_status
,
1305 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1306 (and POP_FRAME for restoring them). (At least on most machines)
1307 they are saved on the stack in the inferior. */
1310 old_sp
= sp
= read_sp ();
1312 if (INNER_THAN (1, 2))
1314 /* Stack grows down */
1315 sp
-= sizeof dummy1
;
1320 /* Stack grows up */
1322 sp
+= sizeof dummy1
;
1325 funaddr
= find_function_addr (function
, &value_type
);
1326 CHECK_TYPEDEF (value_type
);
1329 struct block
*b
= block_for_pc (funaddr
);
1330 /* If compiled without -g, assume GCC 2. */
1331 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
1334 /* Are we returning a value using a structure return or a normal
1337 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1340 /* Create a call sequence customized for this function
1341 and the number of arguments for it. */
1342 for (i
= 0; i
< (int) (sizeof (dummy
) / sizeof (dummy
[0])); i
++)
1343 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1345 (ULONGEST
)dummy
[i
]);
1347 #ifdef GDB_TARGET_IS_HPPA
1348 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1349 value_type
, using_gcc
);
1351 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1352 value_type
, using_gcc
);
1356 #if CALL_DUMMY_LOCATION == ON_STACK
1357 write_memory (start_sp
, (char *)dummy1
, sizeof dummy1
);
1358 #endif /* On stack. */
1360 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1361 /* Convex Unix prohibits executing in the stack segment. */
1362 /* Hope there is empty room at the top of the text segment. */
1364 extern CORE_ADDR text_end
;
1367 for (start_sp
= text_end
- sizeof dummy1
; start_sp
< text_end
; ++start_sp
)
1368 if (read_memory_integer (start_sp
, 1) != 0)
1369 error ("text segment full -- no place to put call");
1372 real_pc
= text_end
- sizeof dummy1
;
1373 write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1375 #endif /* Before text_end. */
1377 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1379 extern CORE_ADDR text_end
;
1383 errcode
= target_write_memory (real_pc
, (char *)dummy1
, sizeof dummy1
);
1385 error ("Cannot write text segment -- call_function failed");
1387 #endif /* After text_end. */
1389 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1391 #endif /* At entry point. */
1394 sp
= old_sp
; /* It really is used, for some ifdef's... */
1397 if (nargs
< TYPE_NFIELDS (ftype
))
1398 error ("too few arguments in function call");
1400 for (i
= nargs
- 1; i
>= 0; i
--)
1402 /* If we're off the end of the known arguments, do the standard
1403 promotions. FIXME: if we had a prototype, this should only
1404 be allowed if ... were present. */
1405 if (i
>= TYPE_NFIELDS (ftype
))
1406 args
[i
] = value_arg_coerce (args
[i
], NULL
, 0);
1410 int is_prototyped
= TYPE_FLAGS (ftype
) & TYPE_FLAG_PROTOTYPED
;
1411 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1413 args
[i
] = value_arg_coerce (args
[i
], param_type
, is_prototyped
);
1416 /*elz: this code is to handle the case in which the function to be called
1417 has a pointer to function as parameter and the corresponding actual argument
1418 is the address of a function and not a pointer to function variable.
1419 In aCC compiled code, the calls through pointers to functions (in the body
1420 of the function called by hand) are made via $$dyncall_external which
1421 requires some registers setting, this is taken care of if we call
1422 via a function pointer variable, but not via a function address.
1423 In cc this is not a problem. */
1427 /* if this parameter is a pointer to function*/
1428 if (TYPE_CODE (param_type
) == TYPE_CODE_PTR
)
1429 if (TYPE_CODE (param_type
->target_type
) == TYPE_CODE_FUNC
)
1430 /* elz: FIXME here should go the test about the compiler used
1431 to compile the target. We want to issue the error
1432 message only if the compiler used was HP's aCC.
1433 If we used HP's cc, then there is no problem and no need
1434 to return at this point */
1435 if (using_gcc
== 0) /* && compiler == aCC*/
1436 /* go see if the actual parameter is a variable of type
1437 pointer to function or just a function */
1438 if (args
[i
]->lval
== not_lval
)
1441 if (find_pc_partial_function((CORE_ADDR
)args
[i
]->aligner
.contents
[0], &arg_name
, NULL
, NULL
))
1443 You cannot use function <%s> as argument. \n\
1444 You must use a pointer to function type variable. Command ignored.", arg_name
);
1448 #if defined (REG_STRUCT_HAS_ADDR)
1450 /* This is a machine like the sparc, where we may need to pass a pointer
1451 to the structure, not the structure itself. */
1452 for (i
= nargs
- 1; i
>= 0; i
--)
1454 struct type
*arg_type
= check_typedef (VALUE_TYPE (args
[i
]));
1455 if ((TYPE_CODE (arg_type
) == TYPE_CODE_STRUCT
1456 || TYPE_CODE (arg_type
) == TYPE_CODE_UNION
1457 || TYPE_CODE (arg_type
) == TYPE_CODE_ARRAY
1458 || TYPE_CODE (arg_type
) == TYPE_CODE_STRING
1459 || TYPE_CODE (arg_type
) == TYPE_CODE_BITSTRING
1460 || TYPE_CODE (arg_type
) == TYPE_CODE_SET
1461 || (TYPE_CODE (arg_type
) == TYPE_CODE_FLT
1462 && TYPE_LENGTH (arg_type
) > 8)
1464 && REG_STRUCT_HAS_ADDR (using_gcc
, arg_type
))
1467 int len
; /* = TYPE_LENGTH (arg_type); */
1469 arg_type
= check_typedef (VALUE_ENCLOSING_TYPE (args
[i
]));
1470 len
= TYPE_LENGTH (arg_type
);
1473 /* MVS 11/22/96: I think at least some of this stack_align code is
1474 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1475 a target-defined manner. */
1476 aligned_len
= STACK_ALIGN (len
);
1480 if (INNER_THAN (1, 2))
1482 /* stack grows downward */
1487 /* The stack grows up, so the address of the thing we push
1488 is the stack pointer before we push it. */
1491 /* Push the structure. */
1492 write_memory (sp
, VALUE_CONTENTS_ALL (args
[i
]), len
);
1493 if (INNER_THAN (1, 2))
1495 /* The stack grows down, so the address of the thing we push
1496 is the stack pointer after we push it. */
1501 /* stack grows upward */
1504 /* The value we're going to pass is the address of the thing
1506 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1508 args
[i
] = value_from_longest (lookup_pointer_type (arg_type
),
1513 #endif /* REG_STRUCT_HAS_ADDR. */
1515 /* Reserve space for the return structure to be written on the
1516 stack, if necessary */
1520 int len
= TYPE_LENGTH (value_type
);
1522 /* MVS 11/22/96: I think at least some of this stack_align code is
1523 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1524 a target-defined manner. */
1525 len
= STACK_ALIGN (len
);
1527 if (INNER_THAN (1, 2))
1529 /* stack grows downward */
1535 /* stack grows upward */
1541 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1542 on other architectures. This is because all the alignment is taken care
1543 of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
1544 hppa_push_arguments*/
1545 #ifndef NO_EXTRA_ALIGNMENT_NEEDED
1547 #if defined(STACK_ALIGN)
1548 /* MVS 11/22/96: I think at least some of this stack_align code is
1549 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1550 a target-defined manner. */
1551 if (INNER_THAN (1, 2))
1553 /* If stack grows down, we must leave a hole at the top. */
1556 for (i
= nargs
- 1; i
>= 0; i
--)
1557 len
+= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
1558 #ifdef CALL_DUMMY_STACK_ADJUST
1559 len
+= CALL_DUMMY_STACK_ADJUST
;
1561 sp
-= STACK_ALIGN (len
) - len
;
1563 #endif /* STACK_ALIGN */
1564 #endif /* NO_EXTRA_ALIGNMENT_NEEDED */
1566 #ifdef PUSH_ARGUMENTS
1567 PUSH_ARGUMENTS(nargs
, args
, sp
, struct_return
, struct_addr
);
1568 #else /* !PUSH_ARGUMENTS */
1569 for (i
= nargs
- 1; i
>= 0; i
--)
1570 sp
= value_push (sp
, args
[i
]);
1571 #endif /* !PUSH_ARGUMENTS */
1573 #ifdef PUSH_RETURN_ADDRESS /* for targets that use no CALL_DUMMY */
1574 /* There are a number of targets now which actually don't write any
1575 CALL_DUMMY instructions into the target, but instead just save the
1576 machine state, push the arguments, and jump directly to the callee
1577 function. Since this doesn't actually involve executing a JSR/BSR
1578 instruction, the return address must be set up by hand, either by
1579 pushing onto the stack or copying into a return-address register
1580 as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
1581 but that's overloading its functionality a bit, so I'm making it
1582 explicit to do it here. */
1583 sp
= PUSH_RETURN_ADDRESS(real_pc
, sp
);
1584 #endif /* PUSH_RETURN_ADDRESS */
1586 #if defined(STACK_ALIGN)
1587 if (! INNER_THAN (1, 2))
1589 /* If stack grows up, we must leave a hole at the bottom, note
1590 that sp already has been advanced for the arguments! */
1591 #ifdef CALL_DUMMY_STACK_ADJUST
1592 sp
+= CALL_DUMMY_STACK_ADJUST
;
1594 sp
= STACK_ALIGN (sp
);
1596 #endif /* STACK_ALIGN */
1598 /* XXX This seems wrong. For stacks that grow down we shouldn't do
1600 /* MVS 11/22/96: I think at least some of this stack_align code is
1601 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1602 a target-defined manner. */
1603 #ifdef CALL_DUMMY_STACK_ADJUST
1604 if (INNER_THAN (1, 2))
1606 /* stack grows downward */
1607 sp
-= CALL_DUMMY_STACK_ADJUST
;
1609 #endif /* CALL_DUMMY_STACK_ADJUST */
1611 /* Store the address at which the structure is supposed to be
1612 written. Note that this (and the code which reserved the space
1613 above) assumes that gcc was used to compile this function. Since
1614 it doesn't cost us anything but space and if the function is pcc
1615 it will ignore this value, we will make that assumption.
1617 Also note that on some machines (like the sparc) pcc uses a
1618 convention like gcc's. */
1621 STORE_STRUCT_RETURN (struct_addr
, sp
);
1623 /* Write the stack pointer. This is here because the statements above
1624 might fool with it. On SPARC, this write also stores the register
1625 window into the right place in the new stack frame, which otherwise
1626 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1630 char retbuf
[REGISTER_BYTES
];
1632 struct symbol
*symbol
;
1635 symbol
= find_pc_function (funaddr
);
1638 name
= SYMBOL_SOURCE_NAME (symbol
);
1642 /* Try the minimal symbols. */
1643 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1647 name
= SYMBOL_SOURCE_NAME (msymbol
);
1653 sprintf (format
, "at %s", local_hex_format ());
1655 /* FIXME-32x64: assumes funaddr fits in a long. */
1656 sprintf (name
, format
, (unsigned long) funaddr
);
1659 /* Execute the stack dummy routine, calling FUNCTION.
1660 When it is done, discard the empty frame
1661 after storing the contents of all regs into retbuf. */
1662 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1664 /* We stopped somewhere besides the call dummy. */
1666 /* If we did the cleanups, we would print a spurious error message
1667 (Unable to restore previously selected frame), would write the
1668 registers from the inf_status (which is wrong), and would do other
1669 wrong things (like set stop_bpstat to the wrong thing). */
1670 discard_cleanups (old_chain
);
1671 /* Prevent memory leak. */
1672 bpstat_clear (&inf_status
.stop_bpstat
);
1674 /* The following error message used to say "The expression
1675 which contained the function call has been discarded." It
1676 is a hard concept to explain in a few words. Ideally, GDB
1677 would be able to resume evaluation of the expression when
1678 the function finally is done executing. Perhaps someday
1679 this will be implemented (it would not be easy). */
1681 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1682 a C++ name with arguments and stuff. */
1684 The program being debugged stopped while in a function called from GDB.\n\
1685 When the function (%s) is done executing, GDB will silently\n\
1686 stop (instead of continuing to evaluate the expression containing\n\
1687 the function call).", name
);
1690 do_cleanups (old_chain
);
1692 /* Figure out the value returned by the function. */
1693 /* elz: I defined this new macro for the hppa architecture only.
1694 this gives us a way to get the value returned by the function from the stack,
1695 at the same address we told the function to put it.
1696 We cannot assume on the pa that r28 still contains the address of the returned
1697 structure. Usually this will be overwritten by the callee.
1698 I don't know about other architectures, so I defined this macro
1701 #ifdef VALUE_RETURNED_FROM_STACK
1703 return (value_ptr
) VALUE_RETURNED_FROM_STACK (value_type
, struct_addr
);
1706 return value_being_returned (value_type
, retbuf
, struct_return
);
1709 #else /* no CALL_DUMMY. */
1711 call_function_by_hand (function
, nargs
, args
)
1716 error ("Cannot invoke functions on this machine.");
1718 #endif /* no CALL_DUMMY. */
1721 /* Create a value for an array by allocating space in the inferior, copying
1722 the data into that space, and then setting up an array value.
1724 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1725 populated from the values passed in ELEMVEC.
1727 The element type of the array is inherited from the type of the
1728 first element, and all elements must have the same size (though we
1729 don't currently enforce any restriction on their types). */
1732 value_array (lowbound
, highbound
, elemvec
)
1739 unsigned int typelength
;
1741 struct type
*rangetype
;
1742 struct type
*arraytype
;
1745 /* Validate that the bounds are reasonable and that each of the elements
1746 have the same size. */
1748 nelem
= highbound
- lowbound
+ 1;
1751 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1753 typelength
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[0]));
1754 for (idx
= 1; idx
< nelem
; idx
++)
1756 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[idx
])) != typelength
)
1758 error ("array elements must all be the same size");
1762 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1763 lowbound
, highbound
);
1764 arraytype
= create_array_type ((struct type
*) NULL
,
1765 VALUE_ENCLOSING_TYPE (elemvec
[0]), rangetype
);
1767 if (!current_language
->c_style_arrays
)
1769 val
= allocate_value (arraytype
);
1770 for (idx
= 0; idx
< nelem
; idx
++)
1772 memcpy (VALUE_CONTENTS_ALL_RAW (val
) + (idx
* typelength
),
1773 VALUE_CONTENTS_ALL (elemvec
[idx
]),
1776 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (elemvec
[0]);
1780 /* Allocate space to store the array in the inferior, and then initialize
1781 it by copying in each element. FIXME: Is it worth it to create a
1782 local buffer in which to collect each value and then write all the
1783 bytes in one operation? */
1785 addr
= allocate_space_in_inferior (nelem
* typelength
);
1786 for (idx
= 0; idx
< nelem
; idx
++)
1788 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS_ALL (elemvec
[idx
]),
1792 /* Create the array type and set up an array value to be evaluated lazily. */
1794 val
= value_at_lazy (arraytype
, addr
, VALUE_BFD_SECTION (elemvec
[0]));
1798 /* Create a value for a string constant by allocating space in the inferior,
1799 copying the data into that space, and returning the address with type
1800 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1802 Note that string types are like array of char types with a lower bound of
1803 zero and an upper bound of LEN - 1. Also note that the string may contain
1804 embedded null bytes. */
1807 value_string (ptr
, len
)
1812 int lowbound
= current_language
->string_lower_bound
;
1813 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1815 lowbound
, len
+ lowbound
- 1);
1816 struct type
*stringtype
1817 = create_string_type ((struct type
*) NULL
, rangetype
);
1820 if (current_language
->c_style_arrays
== 0)
1822 val
= allocate_value (stringtype
);
1823 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1828 /* Allocate space to store the string in the inferior, and then
1829 copy LEN bytes from PTR in gdb to that address in the inferior. */
1831 addr
= allocate_space_in_inferior (len
);
1832 write_memory (addr
, ptr
, len
);
1834 val
= value_at_lazy (stringtype
, addr
, NULL
);
1839 value_bitstring (ptr
, len
)
1844 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1846 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1847 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1848 val
= allocate_value (type
);
1849 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1853 /* See if we can pass arguments in T2 to a function which takes arguments
1854 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1855 arguments need coercion of some sort, then the coerced values are written
1856 into T2. Return value is 0 if the arguments could be matched, or the
1857 position at which they differ if not.
1859 STATICP is nonzero if the T1 argument list came from a
1860 static member function.
1862 For non-static member functions, we ignore the first argument,
1863 which is the type of the instance variable. This is because we want
1864 to handle calls with objects from derived classes. This is not
1865 entirely correct: we should actually check to make sure that a
1866 requested operation is type secure, shouldn't we? FIXME. */
1869 typecmp (staticp
, t1
, t2
)
1878 if (staticp
&& t1
== 0)
1882 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
) return 0;
1883 if (t1
[!staticp
] == 0) return 0;
1884 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1886 struct type
*tt1
, *tt2
;
1889 tt1
= check_typedef (t1
[i
]);
1890 tt2
= check_typedef (VALUE_TYPE(t2
[i
]));
1891 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1892 /* We should be doing hairy argument matching, as below. */
1893 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1895 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1896 t2
[i
] = value_coerce_array (t2
[i
]);
1898 t2
[i
] = value_addr (t2
[i
]);
1902 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1903 && ( TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
1904 || TYPE_CODE (tt2
) == TYPE_CODE_PTR
))
1906 tt1
= check_typedef (TYPE_TARGET_TYPE(tt1
));
1907 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1909 if (TYPE_CODE(tt1
) == TYPE_CODE(tt2
)) continue;
1910 /* Array to pointer is a `trivial conversion' according to the ARM. */
1912 /* We should be doing much hairier argument matching (see section 13.2
1913 of the ARM), but as a quick kludge, just check for the same type
1915 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1918 if (!t1
[i
]) return 0;
1919 return t2
[i
] ? i
+1 : 0;
1922 /* Helper function used by value_struct_elt to recurse through baseclasses.
1923 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1924 and search in it assuming it has (class) type TYPE.
1925 If found, return value, else return NULL.
1927 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1928 look for a baseclass named NAME. */
1931 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1933 register value_ptr arg1
;
1935 register struct type
*type
;
1936 int looking_for_baseclass
;
1939 int nbases
= TYPE_N_BASECLASSES (type
);
1941 CHECK_TYPEDEF (type
);
1943 if (! looking_for_baseclass
)
1944 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1946 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1948 if (t_field_name
&& STREQ (t_field_name
, name
))
1951 if (TYPE_FIELD_STATIC (type
, i
))
1952 v
= value_static_field (type
, i
);
1954 v
= value_primitive_field (arg1
, offset
, i
, type
);
1956 error("there is no field named %s", name
);
1961 && (t_field_name
[0] == '\0'
1962 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1963 && STREQ (t_field_name
, "else"))))
1965 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1966 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1967 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1969 /* Look for a match through the fields of an anonymous union,
1970 or anonymous struct. C++ provides anonymous unions.
1972 In the GNU Chill implementation of variant record types,
1973 each <alternative field> has an (anonymous) union type,
1974 each member of the union represents a <variant alternative>.
1975 Each <variant alternative> is represented as a struct,
1976 with a member for each <variant field>. */
1979 int new_offset
= offset
;
1981 /* This is pretty gross. In G++, the offset in an anonymous
1982 union is relative to the beginning of the enclosing struct.
1983 In the GNU Chill implementation of variant records,
1984 the bitpos is zero in an anonymous union field, so we
1985 have to add the offset of the union here. */
1986 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1987 || (TYPE_NFIELDS (field_type
) > 0
1988 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1989 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1991 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
1992 looking_for_baseclass
);
1999 for (i
= 0; i
< nbases
; i
++)
2002 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2003 /* If we are looking for baseclasses, this is what we get when we
2004 hit them. But it could happen that the base part's member name
2005 is not yet filled in. */
2006 int found_baseclass
= (looking_for_baseclass
2007 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2008 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
2010 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2013 value_ptr v2
= allocate_value (basetype
);
2015 boffset
= baseclass_offset (type
, i
,
2016 VALUE_CONTENTS (arg1
) + offset
,
2017 VALUE_ADDRESS (arg1
)
2018 + VALUE_OFFSET (arg1
) + offset
);
2020 error ("virtual baseclass botch");
2022 /* The virtual base class pointer might have been clobbered by the
2023 user program. Make sure that it still points to a valid memory
2027 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
2029 CORE_ADDR base_addr
;
2031 base_addr
= VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
) + boffset
;
2032 if (target_read_memory (base_addr
, VALUE_CONTENTS_RAW (v2
),
2033 TYPE_LENGTH (basetype
)) != 0)
2034 error ("virtual baseclass botch");
2035 VALUE_LVAL (v2
) = lval_memory
;
2036 VALUE_ADDRESS (v2
) = base_addr
;
2040 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
2041 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
2042 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + boffset
;
2043 if (VALUE_LAZY (arg1
))
2044 VALUE_LAZY (v2
) = 1;
2046 memcpy (VALUE_CONTENTS_RAW (v2
),
2047 VALUE_CONTENTS_RAW (arg1
) + boffset
,
2048 TYPE_LENGTH (basetype
));
2051 if (found_baseclass
)
2053 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
2054 looking_for_baseclass
);
2056 else if (found_baseclass
)
2057 v
= value_primitive_field (arg1
, offset
, i
, type
);
2059 v
= search_struct_field (name
, arg1
,
2060 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2061 basetype
, looking_for_baseclass
);
2068 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2069 * in an object pointed to by VALADDR (on the host), assumed to be of
2070 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
2071 * looking (in case VALADDR is the contents of an enclosing object).
2073 * This routine recurses on the primary base of the derived class because
2074 * the virtual base entries of the primary base appear before the other
2075 * virtual base entries.
2077 * If the virtual base is not found, a negative integer is returned.
2078 * The magnitude of the negative integer is the number of entries in
2079 * the virtual table to skip over (entries corresponding to various
2080 * ancestral classes in the chain of primary bases).
2082 * Important: This assumes the HP / Taligent C++ runtime
2083 * conventions. Use baseclass_offset() instead to deal with g++
2087 find_rt_vbase_offset(type
, basetype
, valaddr
, offset
, boffset_p
, skip_p
)
2089 struct type
* basetype
;
2095 int boffset
; /* offset of virtual base */
2096 int index
; /* displacement to use in virtual table */
2100 CORE_ADDR vtbl
; /* the virtual table pointer */
2101 struct type
* pbc
; /* the primary base class */
2103 /* Look for the virtual base recursively in the primary base, first.
2104 * This is because the derived class object and its primary base
2105 * subobject share the primary virtual table. */
2108 pbc
= TYPE_PRIMARY_BASE(type
);
2111 find_rt_vbase_offset (pbc
, basetype
, valaddr
, offset
, &boffset
, &skip
);
2114 *boffset_p
= boffset
;
2123 /* Find the index of the virtual base according to HP/Taligent
2124 runtime spec. (Depth-first, left-to-right.) */
2125 index
= virtual_base_index_skip_primaries (basetype
, type
);
2128 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
2133 /* pai: FIXME -- 32x64 possible problem */
2134 /* First word (4 bytes) in object layout is the vtable pointer */
2135 vtbl
= * (CORE_ADDR
*) (valaddr
+ offset
);
2137 /* Before the constructor is invoked, things are usually zero'd out. */
2139 error ("Couldn't find virtual table -- object may not be constructed yet.");
2142 /* Find virtual base's offset -- jump over entries for primary base
2143 * ancestors, then use the index computed above. But also adjust by
2144 * HP_ACC_VBASE_START for the vtable slots before the start of the
2145 * virtual base entries. Offset is negative -- virtual base entries
2146 * appear _before_ the address point of the virtual table. */
2148 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2151 /* epstein : FIXME -- added param for overlay section. May not be correct */
2152 vp
= value_at (builtin_type_int
, vtbl
+ 4 * (- skip
- index
- HP_ACC_VBASE_START
), NULL
);
2153 boffset
= value_as_long (vp
);
2155 *boffset_p
= boffset
;
2160 /* Helper function used by value_struct_elt to recurse through baseclasses.
2161 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2162 and search in it assuming it has (class) type TYPE.
2163 If found, return value, else if name matched and args not return (value)-1,
2164 else return NULL. */
2167 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
2169 register value_ptr
*arg1p
, *args
;
2170 int offset
, *static_memfuncp
;
2171 register struct type
*type
;
2175 int name_matched
= 0;
2176 char dem_opname
[64];
2178 CHECK_TYPEDEF (type
);
2179 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2181 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2182 /* FIXME! May need to check for ARM demangling here */
2183 if (strncmp(t_field_name
, "__", 2)==0 ||
2184 strncmp(t_field_name
, "op", 2)==0 ||
2185 strncmp(t_field_name
, "type", 4)==0 )
2187 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
2188 t_field_name
= dem_opname
;
2189 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
2190 t_field_name
= dem_opname
;
2192 if (t_field_name
&& STREQ (t_field_name
, name
))
2194 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2195 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2198 if (j
> 0 && args
== 0)
2199 error ("cannot resolve overloaded method `%s': no arguments supplied", name
);
2202 if (TYPE_FN_FIELD_STUB (f
, j
))
2203 check_stub_method (type
, i
, j
);
2204 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2205 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2207 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2208 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
2209 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
2210 *static_memfuncp
= 1;
2211 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2212 if (v
!= NULL
) return v
;
2219 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2223 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2225 if (TYPE_HAS_VTABLE (type
))
2227 /* HP aCC compiled type, search for virtual base offset
2228 according to HP/Taligent runtime spec. */
2230 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2231 VALUE_CONTENTS_ALL (*arg1p
),
2232 offset
+ VALUE_EMBEDDED_OFFSET (*arg1p
),
2233 &base_offset
, &skip
);
2235 error ("Virtual base class offset not found in vtable");
2239 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2242 /* The virtual base class pointer might have been clobbered by the
2243 user program. Make sure that it still points to a valid memory
2246 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2248 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
2249 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
2250 + VALUE_OFFSET (*arg1p
) + offset
,
2252 TYPE_LENGTH (baseclass
)) != 0)
2253 error ("virtual baseclass botch");
2256 base_valaddr
= VALUE_CONTENTS (*arg1p
) + offset
;
2259 baseclass_offset (type
, i
, base_valaddr
,
2260 VALUE_ADDRESS (*arg1p
)
2261 + VALUE_OFFSET (*arg1p
) + offset
);
2262 if (base_offset
== -1)
2263 error ("virtual baseclass botch");
2268 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2270 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2271 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2272 if (v
== (value_ptr
) -1)
2278 /* FIXME-bothner: Why is this commented out? Why is it here? */
2279 /* *arg1p = arg1_tmp;*/
2283 if (name_matched
) return (value_ptr
) -1;
2287 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2288 extract the component named NAME from the ultimate target structure/union
2289 and return it as a value with its appropriate type.
2290 ERR is used in the error message if *ARGP's type is wrong.
2292 C++: ARGS is a list of argument types to aid in the selection of
2293 an appropriate method. Also, handle derived types.
2295 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2296 where the truthvalue of whether the function that was resolved was
2297 a static member function or not is stored.
2299 ERR is an error message to be printed in case the field is not found. */
2302 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
2303 register value_ptr
*argp
, *args
;
2305 int *static_memfuncp
;
2308 register struct type
*t
;
2311 COERCE_ARRAY (*argp
);
2313 t
= check_typedef (VALUE_TYPE (*argp
));
2315 /* Follow pointers until we get to a non-pointer. */
2317 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2319 *argp
= value_ind (*argp
);
2320 /* Don't coerce fn pointer to fn and then back again! */
2321 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2322 COERCE_ARRAY (*argp
);
2323 t
= check_typedef (VALUE_TYPE (*argp
));
2326 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2327 error ("not implemented: member type in value_struct_elt");
2329 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
2330 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2331 error ("Attempt to extract a component of a value that is not a %s.", err
);
2333 /* Assume it's not, unless we see that it is. */
2334 if (static_memfuncp
)
2335 *static_memfuncp
=0;
2339 /* if there are no arguments ...do this... */
2341 /* Try as a field first, because if we succeed, there
2342 is less work to be done. */
2343 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2347 /* C++: If it was not found as a data field, then try to
2348 return it as a pointer to a method. */
2350 if (destructor_name_p (name
, t
))
2351 error ("Cannot get value of destructor");
2353 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2355 if (v
== (value_ptr
) -1)
2356 error ("Cannot take address of a method");
2359 if (TYPE_NFN_FIELDS (t
))
2360 error ("There is no member or method named %s.", name
);
2362 error ("There is no member named %s.", name
);
2367 if (destructor_name_p (name
, t
))
2371 /* Destructors are a special case. */
2372 int m_index
, f_index
;
2375 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2377 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, m_index
),
2381 error ("could not find destructor function named %s.", name
);
2387 error ("destructor should not have any argument");
2391 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2393 if (v
== (value_ptr
) -1)
2395 error("Argument list of %s mismatch with component in the structure.", name
);
2399 /* See if user tried to invoke data as function. If so,
2400 hand it back. If it's not callable (i.e., a pointer to function),
2401 gdb should give an error. */
2402 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2406 error ("Structure has no component named %s.", name
);
2410 /* Search through the methods of an object (and its bases)
2411 * to find a specified method. Return the pointer to the
2412 * fn_field list of overloaded instances.
2413 * Helper function for value_find_oload_list.
2414 * ARGP is a pointer to a pointer to a value (the object)
2415 * METHOD is a string containing the method name
2416 * OFFSET is the offset within the value
2417 * STATIC_MEMFUNCP is set if the method is static
2418 * TYPE is the assumed type of the object
2419 * NUM_FNS is the number of overloaded instances
2420 * BASETYPE is set to the actual type of the subobject where the method is found
2421 * BOFFSET is the offset of the base subobject where the method is found */
2424 find_method_list (argp
, method
, offset
, static_memfuncp
, type
, num_fns
, basetype
, boffset
)
2428 int * static_memfuncp
;
2431 struct type
** basetype
;
2435 struct fn_field
* f
;
2436 CHECK_TYPEDEF (type
);
2440 /* First check in object itself */
2441 for (i
= TYPE_NFN_FIELDS (type
) -1; i
>= 0; i
--)
2443 /* pai: FIXME What about operators and type conversions? */
2444 char * fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2445 if (fn_field_name
&& STREQ (fn_field_name
, method
))
2447 *num_fns
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2450 return TYPE_FN_FIELDLIST1 (type
, i
);
2454 /* Not found in object, check in base subobjects */
2455 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2458 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2460 if (TYPE_HAS_VTABLE (type
))
2462 /* HP aCC compiled type, search for virtual base offset
2463 * according to HP/Taligent runtime spec. */
2465 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2466 VALUE_CONTENTS_ALL (*argp
),
2467 offset
+ VALUE_EMBEDDED_OFFSET (*argp
),
2468 &base_offset
, &skip
);
2470 error ("Virtual base class offset not found in vtable");
2474 /* probably g++ runtime model */
2475 base_offset
= VALUE_OFFSET (*argp
) + offset
;
2477 baseclass_offset (type
, i
,
2478 VALUE_CONTENTS (*argp
) + base_offset
,
2479 VALUE_ADDRESS (*argp
) + base_offset
);
2480 if (base_offset
== -1)
2481 error ("virtual baseclass botch");
2484 else /* non-virtual base, simply use bit position from debug info */
2486 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2488 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2489 static_memfuncp
, TYPE_BASECLASS (type
, i
), num_fns
, basetype
, boffset
);
2496 /* Return the list of overloaded methods of a specified name.
2497 * ARGP is a pointer to a pointer to a value (the object)
2498 * METHOD is the method name
2499 * OFFSET is the offset within the value contents
2500 * STATIC_MEMFUNCP is set if the method is static
2501 * NUM_FNS is the number of overloaded instances
2502 * BASETYPE is set to the type of the base subobject that defines the method
2503 * BOFFSET is the offset of the base subobject which defines the method */
2506 value_find_oload_method_list (argp
, method
, offset
, static_memfuncp
, num_fns
, basetype
, boffset
)
2510 int * static_memfuncp
;
2512 struct type
** basetype
;
2518 t
= check_typedef (VALUE_TYPE (*argp
));
2520 /* code snarfed from value_struct_elt */
2521 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2523 *argp
= value_ind (*argp
);
2524 /* Don't coerce fn pointer to fn and then back again! */
2525 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2526 COERCE_ARRAY (*argp
);
2527 t
= check_typedef (VALUE_TYPE (*argp
));
2530 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2531 error ("Not implemented: member type in value_find_oload_lis");
2533 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
2534 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2535 error ("Attempt to extract a component of a value that is not a struct or union");
2537 /* Assume it's not static, unless we see that it is. */
2538 if (static_memfuncp
)
2539 *static_memfuncp
=0;
2541 return find_method_list (argp
, method
, 0, static_memfuncp
, t
, num_fns
, basetype
, boffset
);
2545 /* Given an array of argument types (ARGTYPES) (which includes an
2546 entry for "this" in the case of C++ methods), the number of
2547 arguments NARGS, the NAME of a function whether it's a method or
2548 not (METHOD), and the degree of laxness (LAX) in conforming to
2549 overload resolution rules in ANSI C++, find the best function that
2550 matches on the argument types according to the overload resolution
2553 In the case of class methods, the parameter OBJ is an object value
2554 in which to search for overloaded methods.
2556 In the case of non-method functions, the parameter FSYM is a symbol
2557 corresponding to one of the overloaded functions.
2559 Return value is an integer: 0 -> good match, 10 -> debugger applied
2560 non-standard coercions, 100 -> incompatible.
2562 If a method is being searched for, VALP will hold the value.
2563 If a non-method is being searched for, SYMP will hold the symbol for it.
2565 If a method is being searched for, and it is a static method,
2566 then STATICP will point to a non-zero value.
2568 Note: This function does *not* check the value of
2569 overload_resolution. Caller must check it to see whether overload
2570 resolution is permitted.
2574 find_overload_match (arg_types
, nargs
, name
, method
, lax
, obj
, fsym
, valp
, symp
, staticp
)
2575 struct type
** arg_types
;
2581 struct symbol
* fsym
;
2583 struct symbol
** symp
;
2587 struct type
** parm_types
;
2588 int champ_nparms
= 0;
2590 short oload_champ
= -1; /* Index of best overloaded function */
2591 short oload_ambiguous
= 0; /* Current ambiguity state for overload resolution */
2592 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2593 short oload_ambig_champ
= -1; /* 2nd contender for best match */
2594 short oload_non_standard
= 0; /* did we have to use non-standard conversions? */
2595 short oload_incompatible
= 0; /* are args supplied incompatible with any function? */
2597 struct badness_vector
* bv
; /* A measure of how good an overloaded instance is */
2598 struct badness_vector
* oload_champ_bv
= NULL
; /* The measure for the current best match */
2600 value_ptr temp
= obj
;
2601 struct fn_field
* fns_ptr
= NULL
; /* For methods, the list of overloaded methods */
2602 struct symbol
** oload_syms
= NULL
; /* For non-methods, the list of overloaded function symbols */
2603 int num_fns
= 0; /* Number of overloaded instances being considered */
2604 struct type
* basetype
= NULL
;
2609 char * obj_type_name
= NULL
;
2610 char * func_name
= NULL
;
2612 /* Get the list of overloaded methods or functions */
2615 obj_type_name
= TYPE_NAME (VALUE_TYPE (obj
));
2616 /* Hack: evaluate_subexp_standard often passes in a pointer
2617 value rather than the object itself, so try again */
2618 if ((!obj_type_name
|| !*obj_type_name
) &&
2619 (TYPE_CODE (VALUE_TYPE (obj
)) == TYPE_CODE_PTR
))
2620 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj
)));
2622 fns_ptr
= value_find_oload_method_list (&temp
, name
, 0,
2625 &basetype
, &boffset
);
2626 if (!fns_ptr
|| !num_fns
)
2627 error ("Couldn't find method %s%s%s",
2629 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2635 func_name
= cplus_demangle (SYMBOL_NAME (fsym
), DMGL_NO_OPTS
);
2637 oload_syms
= make_symbol_overload_list (fsym
);
2638 while (oload_syms
[++i
])
2641 error ("Couldn't find function %s", func_name
);
2644 oload_champ_bv
= NULL
;
2646 /* Consider each candidate in turn */
2647 for (ix
= 0; ix
< num_fns
; ix
++)
2651 /* Number of parameters for current candidate */
2652 nparms
= method
? TYPE_NFIELDS (fns_ptr
[ix
].type
)
2653 : TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2655 /* Prepare array of parameter types */
2656 parm_types
= (struct type
**) xmalloc (nparms
* (sizeof (struct type
*)));
2657 for (jj
= 0; jj
< nparms
; jj
++)
2658 parm_types
[jj
] = method
? TYPE_FIELD_TYPE (fns_ptr
[ix
].type
, jj
)
2659 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]), jj
);
2661 /* Compare parameter types to supplied argument types */
2662 bv
= rank_function (parm_types
, nparms
, arg_types
, nargs
);
2664 if (!oload_champ_bv
)
2666 oload_champ_bv
= bv
;
2668 champ_nparms
= nparms
;
2671 /* See whether current candidate is better or worse than previous best */
2672 switch (compare_badness (bv
, oload_champ_bv
))
2675 oload_ambiguous
= 1; /* top two contenders are equally good */
2676 oload_ambig_champ
= ix
;
2679 oload_ambiguous
= 2; /* incomparable top contenders */
2680 oload_ambig_champ
= ix
;
2683 oload_champ_bv
= bv
; /* new champion, record details */
2684 oload_ambiguous
= 0;
2686 oload_ambig_champ
= -1;
2687 champ_nparms
= nparms
;
2696 printf("Overloaded method instance %s, # of parms %d\n", fns_ptr
[ix
].physname
, nparms
);
2698 printf("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME(oload_syms
[ix
]),nparms
);
2699 for (jj
= 0; jj
<= nargs
; jj
++)
2700 printf("...Badness @ %d : %d\n", jj
, bv
->rank
[jj
]);
2701 printf("Overload resolution champion is %d, ambiguous? %d\n", oload_champ
, oload_ambiguous
);
2703 } /* end loop over all candidates */
2705 if (oload_ambiguous
)
2708 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2710 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2713 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2717 /* Check how bad the best match is */
2718 for (ix
= 1; ix
<= nargs
; ix
++)
2720 switch (oload_champ_bv
->rank
[ix
])
2723 oload_non_standard
= 1; /* non-standard type conversions needed */
2726 oload_incompatible
= 1; /* truly mismatched types */
2730 if (oload_incompatible
)
2733 error ("Cannot resolve method %s%s%s to any overloaded instance",
2735 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2738 error ("Cannot resolve function %s to any overloaded instance",
2741 else if (oload_non_standard
)
2744 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2746 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2749 warning ("Using non-standard conversion to match function %s to supplied arguments",
2755 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2756 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2758 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2762 *symp
= oload_syms
[oload_champ
];
2766 return oload_incompatible
? 100 : (oload_non_standard
? 10 : 0);
2769 /* C++: return 1 is NAME is a legitimate name for the destructor
2770 of type TYPE. If TYPE does not have a destructor, or
2771 if NAME is inappropriate for TYPE, an error is signaled. */
2773 destructor_name_p (name
, type
)
2775 const struct type
*type
;
2777 /* destructors are a special case. */
2781 char *dname
= type_name_no_tag (type
);
2782 char *cp
= strchr (dname
, '<');
2785 /* Do not compare the template part for template classes. */
2787 len
= strlen (dname
);
2790 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
2791 error ("name of destructor must equal name of class");
2798 /* Helper function for check_field: Given TYPE, a structure/union,
2799 return 1 if the component named NAME from the ultimate
2800 target structure/union is defined, otherwise, return 0. */
2803 check_field_in (type
, name
)
2804 register struct type
*type
;
2809 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2811 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2812 if (t_field_name
&& STREQ (t_field_name
, name
))
2816 /* C++: If it was not found as a data field, then try to
2817 return it as a pointer to a method. */
2819 /* Destructors are a special case. */
2820 if (destructor_name_p (name
, type
))
2822 int m_index
, f_index
;
2824 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2827 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2829 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
2833 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2834 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2841 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2842 return 1 if the component named NAME from the ultimate
2843 target structure/union is defined, otherwise, return 0. */
2846 check_field (arg1
, name
)
2847 register value_ptr arg1
;
2850 register struct type
*t
;
2852 COERCE_ARRAY (arg1
);
2854 t
= VALUE_TYPE (arg1
);
2856 /* Follow pointers until we get to a non-pointer. */
2861 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
2863 t
= TYPE_TARGET_TYPE (t
);
2866 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2867 error ("not implemented: member type in check_field");
2869 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
2870 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2871 error ("Internal error: `this' is not an aggregate");
2873 return check_field_in (t
, name
);
2876 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2877 return the address of this member as a "pointer to member"
2878 type. If INTYPE is non-null, then it will be the type
2879 of the member we are looking for. This will help us resolve
2880 "pointers to member functions". This function is used
2881 to resolve user expressions of the form "DOMAIN::NAME". */
2884 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
2885 struct type
*domain
, *curtype
, *intype
;
2889 register struct type
*t
= curtype
;
2893 if ( TYPE_CODE (t
) != TYPE_CODE_STRUCT
2894 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2895 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2897 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2899 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2901 if (t_field_name
&& STREQ (t_field_name
, name
))
2903 if (TYPE_FIELD_STATIC (t
, i
))
2905 v
= value_static_field (t
, i
);
2907 error ("Internal error: could not find static variable %s",
2911 if (TYPE_FIELD_PACKED (t
, i
))
2912 error ("pointers to bitfield members not allowed");
2914 return value_from_longest
2915 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
2917 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2921 /* C++: If it was not found as a data field, then try to
2922 return it as a pointer to a method. */
2924 /* Destructors are a special case. */
2925 if (destructor_name_p (name
, t
))
2927 error ("member pointers to destructors not implemented yet");
2930 /* Perform all necessary dereferencing. */
2931 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2932 intype
= TYPE_TARGET_TYPE (intype
);
2934 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2936 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2937 char dem_opname
[64];
2939 if (strncmp(t_field_name
, "__", 2)==0 ||
2940 strncmp(t_field_name
, "op", 2)==0 ||
2941 strncmp(t_field_name
, "type", 4)==0 )
2943 if (cplus_demangle_opname(t_field_name
, dem_opname
, DMGL_ANSI
))
2944 t_field_name
= dem_opname
;
2945 else if (cplus_demangle_opname(t_field_name
, dem_opname
, 0))
2946 t_field_name
= dem_opname
;
2948 if (t_field_name
&& STREQ (t_field_name
, name
))
2950 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2951 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2953 if (intype
== 0 && j
> 1)
2954 error ("non-unique member `%s' requires type instantiation", name
);
2958 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2961 error ("no member function matches that type instantiation");
2966 if (TYPE_FN_FIELD_STUB (f
, j
))
2967 check_stub_method (t
, i
, j
);
2968 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2970 return value_from_longest
2971 (lookup_reference_type
2972 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2974 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
2978 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2979 0, VAR_NAMESPACE
, 0, NULL
);
2986 v
= read_var_value (s
, 0);
2988 VALUE_TYPE (v
) = lookup_reference_type
2989 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2997 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3002 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3005 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3006 v
= value_struct_elt_for_reference (domain
,
3007 offset
+ base_offset
,
3008 TYPE_BASECLASS (t
, i
),
3018 /* Find the real run-time type of a value using RTTI.
3019 * V is a pointer to the value.
3020 * A pointer to the struct type entry of the run-time type
3022 * FULL is a flag that is set only if the value V includes
3023 * the entire contents of an object of the RTTI type.
3024 * TOP is the offset to the top of the enclosing object of
3025 * the real run-time type. This offset may be for the embedded
3026 * object, or for the enclosing object of V.
3027 * USING_ENC is the flag that distinguishes the two cases.
3028 * If it is 1, then the offset is for the enclosing object,
3029 * otherwise for the embedded object.
3031 * This currently works only for RTTI information generated
3032 * by the HP ANSI C++ compiler (aCC). g++ today (1997-06-10)
3033 * does not appear to support RTTI. This function returns a
3034 * NULL value for objects in the g++ runtime model. */
3037 value_rtti_type (v
, full
, top
, using_enc
)
3043 struct type
* known_type
;
3044 struct type
* rtti_type
;
3047 int using_enclosing
= 0;
3048 long top_offset
= 0;
3049 char rtti_type_name
[256];
3058 /* Get declared type */
3059 known_type
= VALUE_TYPE (v
);
3060 CHECK_TYPEDEF (known_type
);
3061 /* RTTI works only or class objects */
3062 if (TYPE_CODE (known_type
) != TYPE_CODE_CLASS
)
3065 /* If neither the declared type nor the enclosing type of the
3066 * value structure has a HP ANSI C++ style virtual table,
3067 * we can't do anything. */
3068 if (!TYPE_HAS_VTABLE (known_type
))
3070 known_type
= VALUE_ENCLOSING_TYPE (v
);
3071 CHECK_TYPEDEF (known_type
);
3072 if ((TYPE_CODE (known_type
) != TYPE_CODE_CLASS
) ||
3073 !TYPE_HAS_VTABLE (known_type
))
3074 return NULL
; /* No RTTI, or not HP-compiled types */
3075 CHECK_TYPEDEF (known_type
);
3076 using_enclosing
= 1;
3079 if (using_enclosing
&& using_enc
)
3082 /* First get the virtual table address */
3083 coreptr
= * (CORE_ADDR
*) ((VALUE_CONTENTS_ALL (v
))
3085 + (using_enclosing
? 0 : VALUE_EMBEDDED_OFFSET (v
)));
3087 return NULL
; /* return silently -- maybe called on gdb-generated value */
3089 /* Fetch the top offset of the object */
3090 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3091 vp
= value_at (builtin_type_int
,
3092 coreptr
+ 4 * HP_ACC_TOP_OFFSET_OFFSET
,
3093 VALUE_BFD_SECTION (v
));
3094 top_offset
= value_as_long (vp
);
3098 /* Fetch the typeinfo pointer */
3099 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3100 vp
= value_at (builtin_type_int
, coreptr
+ 4 * HP_ACC_TYPEINFO_OFFSET
, VALUE_BFD_SECTION (v
));
3101 /* Indirect through the typeinfo pointer and retrieve the pointer
3102 * to the string name */
3103 coreptr
= * (CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3105 error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3106 vp
= value_at (builtin_type_int
, coreptr
+ 4, VALUE_BFD_SECTION (v
)); /* 4 -> offset of name field */
3107 /* FIXME possible 32x64 problem */
3109 coreptr
= * (CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3111 read_memory_string (coreptr
, rtti_type_name
, 256);
3113 if (strlen (rtti_type_name
) == 0)
3114 error ("Retrieved null type name from typeinfo");
3116 /* search for type */
3117 rtti_type
= lookup_typename (rtti_type_name
, (struct block
*) 0, 1);
3120 error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name
);
3121 CHECK_TYPEDEF (rtti_type
);
3123 #if 0 /* debugging*/
3124 printf("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type
), TYPE_TAG_NAME (rtti_type
), full
? *full
: -1);
3127 /* Check whether we have the entire object */
3128 if (full
/* Non-null pointer passed */
3131 /* Either we checked on the whole object in hand and found the
3132 top offset to be zero */
3133 (((top_offset
== 0) &&
3135 TYPE_LENGTH (known_type
) == TYPE_LENGTH (rtti_type
))
3137 /* Or we checked on the embedded object and top offset was the
3138 same as the embedded offset */
3139 ((top_offset
== VALUE_EMBEDDED_OFFSET (v
)) &&
3141 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v
)) == TYPE_LENGTH (rtti_type
))))
3148 /* Given a pointer value V, find the real (RTTI) type
3149 of the object it points to.
3150 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3151 and refer to the values computed for the object pointed to. */
3154 value_rtti_target_type (v
, full
, top
, using_enc
)
3162 target
= value_ind (v
);
3164 return value_rtti_type (target
, full
, top
, using_enc
);
3167 /* Given a value pointed to by ARGP, check its real run-time type, and
3168 if that is different from the enclosing type, create a new value
3169 using the real run-time type as the enclosing type (and of the same
3170 type as ARGP) and return it, with the embedded offset adjusted to
3171 be the correct offset to the enclosed object
3172 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3173 parameters, computed by value_rtti_type(). If these are available,
3174 they can be supplied and a second call to value_rtti_type() is avoided.
3175 (Pass RTYPE == NULL if they're not available */
3178 value_full_object (argp
, rtype
, xfull
, xtop
, xusing_enc
)
3180 struct type
* rtype
;
3186 struct type
* real_type
;
3197 using_enc
= xusing_enc
;
3200 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3202 /* If no RTTI data, or if object is already complete, do nothing */
3203 if (!real_type
|| real_type
== VALUE_ENCLOSING_TYPE (argp
))
3206 /* If we have the full object, but for some reason the enclosing
3207 type is wrong, set it */ /* pai: FIXME -- sounds iffy */
3210 VALUE_ENCLOSING_TYPE (argp
) = real_type
;
3214 /* Check if object is in memory */
3215 if (VALUE_LVAL (argp
) != lval_memory
)
3217 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type
));
3222 /* All other cases -- retrieve the complete object */
3223 /* Go back by the computed top_offset from the beginning of the object,
3224 adjusting for the embedded offset of argp if that's what value_rtti_type
3225 used for its computation. */
3226 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
3227 (using_enc
? 0 : VALUE_EMBEDDED_OFFSET (argp
)),
3228 VALUE_BFD_SECTION (argp
));
3229 VALUE_TYPE (new_val
) = VALUE_TYPE (argp
);
3230 VALUE_EMBEDDED_OFFSET (new_val
) = using_enc
? top
+ VALUE_EMBEDDED_OFFSET (argp
) : top
;
3237 /* C++: return the value of the class instance variable, if one exists.
3238 Flag COMPLAIN signals an error if the request is made in an
3239 inappropriate context. */
3242 value_of_this (complain
)
3245 struct symbol
*func
, *sym
;
3248 static const char funny_this
[] = "this";
3251 if (selected_frame
== 0)
3254 error ("no frame selected");
3258 func
= get_frame_function (selected_frame
);
3262 error ("no `this' in nameless context");
3266 b
= SYMBOL_BLOCK_VALUE (func
);
3267 i
= BLOCK_NSYMS (b
);
3271 error ("no args, no `this'");
3275 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3276 symbol instead of the LOC_ARG one (if both exist). */
3277 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
3281 error ("current stack frame not in method");
3286 this = read_var_value (sym
, selected_frame
);
3287 if (this == 0 && complain
)
3288 error ("`this' argument at unknown address");
3292 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3293 long, starting at LOWBOUND. The result has the same lower bound as
3294 the original ARRAY. */
3297 value_slice (array
, lowbound
, length
)
3299 int lowbound
, length
;
3301 struct type
*slice_range_type
, *slice_type
, *range_type
;
3302 LONGEST lowerbound
, upperbound
, offset
;
3304 struct type
*array_type
;
3305 array_type
= check_typedef (VALUE_TYPE (array
));
3306 COERCE_VARYING_ARRAY (array
, array_type
);
3307 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3308 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3309 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3310 error ("cannot take slice of non-array");
3311 range_type
= TYPE_INDEX_TYPE (array_type
);
3312 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3313 error ("slice from bad array or bitstring");
3314 if (lowbound
< lowerbound
|| length
< 0
3315 || lowbound
+ length
- 1 > upperbound
3316 /* Chill allows zero-length strings but not arrays. */
3317 || (current_language
->la_language
== language_chill
3318 && length
== 0 && TYPE_CODE (array_type
) == TYPE_CODE_ARRAY
))
3319 error ("slice out of range");
3320 /* FIXME-type-allocation: need a way to free this type when we are
3322 slice_range_type
= create_range_type ((struct type
*) NULL
,
3323 TYPE_TARGET_TYPE (range_type
),
3324 lowbound
, lowbound
+ length
- 1);
3325 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3328 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
3329 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3330 slice
= value_zero (slice_type
, not_lval
);
3331 for (i
= 0; i
< length
; i
++)
3333 int element
= value_bit_index (array_type
,
3334 VALUE_CONTENTS (array
),
3337 error ("internal error accessing bitstring");
3338 else if (element
> 0)
3340 int j
= i
% TARGET_CHAR_BIT
;
3341 if (BITS_BIG_ENDIAN
)
3342 j
= TARGET_CHAR_BIT
- 1 - j
;
3343 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3346 /* We should set the address, bitssize, and bitspos, so the clice
3347 can be used on the LHS, but that may require extensions to
3348 value_assign. For now, just leave as a non_lval. FIXME. */
3352 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3354 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3355 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
3357 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3358 slice
= allocate_value (slice_type
);
3359 if (VALUE_LAZY (array
))
3360 VALUE_LAZY (slice
) = 1;
3362 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
3363 TYPE_LENGTH (slice_type
));
3364 if (VALUE_LVAL (array
) == lval_internalvar
)
3365 VALUE_LVAL (slice
) = lval_internalvar_component
;
3367 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
3368 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
3369 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
3374 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3375 value as a fixed-length array. */
3378 varying_to_slice (varray
)
3381 struct type
*vtype
= check_typedef (VALUE_TYPE (varray
));
3382 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
3383 VALUE_CONTENTS (varray
)
3384 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
3385 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
3388 /* Create a value for a FORTRAN complex number. Currently most of
3389 the time values are coerced to COMPLEX*16 (i.e. a complex number
3390 composed of 2 doubles. This really should be a smarter routine
3391 that figures out precision inteligently as opposed to assuming
3392 doubles. FIXME: fmb */
3395 value_literal_complex (arg1
, arg2
, type
)
3400 register value_ptr val
;
3401 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3403 val
= allocate_value (type
);
3404 arg1
= value_cast (real_type
, arg1
);
3405 arg2
= value_cast (real_type
, arg2
);
3407 memcpy (VALUE_CONTENTS_RAW (val
),
3408 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
3409 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
3410 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
3414 /* Cast a value into the appropriate complex data type. */
3417 cast_into_complex (type
, val
)
3419 register value_ptr val
;
3421 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3422 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
3424 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
3425 value_ptr re_val
= allocate_value (val_real_type
);
3426 value_ptr im_val
= allocate_value (val_real_type
);
3428 memcpy (VALUE_CONTENTS_RAW (re_val
),
3429 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
3430 memcpy (VALUE_CONTENTS_RAW (im_val
),
3431 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
3432 TYPE_LENGTH (val_real_type
));
3434 return value_literal_complex (re_val
, im_val
, type
);
3436 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
3437 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
3438 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
3440 error ("cannot cast non-number to complex");
3444 _initialize_valops ()
3448 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *)&auto_abandon
,
3449 "Set automatic abandonment of expressions upon failure.",
3455 (add_set_cmd ("overload-resolution", class_support
, var_boolean
, (char *)&overload_resolution
,
3456 "Set overload resolution in evaluating C++ functions.",
3459 overload_resolution
= 1;