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,
20 Boston, MA 02111-1307, USA. */
35 #include "gdb_string.h"
37 /* Default to coercing float to double in function calls only when there is
38 no prototype. Otherwise on targets where the debug information is incorrect
39 for either the prototype or non-prototype case, we can force it by defining
40 COERCE_FLOAT_TO_DOUBLE in the target configuration file. */
42 #ifndef COERCE_FLOAT_TO_DOUBLE
43 #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL)
46 /* Flag indicating HP compilers were used; needed to correctly handle some
47 value operations with HP aCC code/runtime. */
48 extern int hp_som_som_object_present
;
51 /* Local functions. */
53 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));
59 static CORE_ADDR value_push
PARAMS ((CORE_ADDR
, value_ptr
));
61 static value_ptr search_struct_field
PARAMS ((char *, value_ptr
, int,
64 static value_ptr search_struct_method
PARAMS ((char *, value_ptr
*,
66 int, int *, struct type
*));
68 static int check_field_in
PARAMS ((struct type
*, const char *));
70 static CORE_ADDR allocate_space_in_inferior
PARAMS ((int));
72 static value_ptr cast_into_complex
PARAMS ((struct type
*, value_ptr
));
74 static struct fn_field
*find_method_list
PARAMS ((value_ptr
* argp
, char *method
, int offset
, int *static_memfuncp
, struct type
* type
, int *num_fns
, struct type
** basetype
, int *boffset
));
76 void _initialize_valops
PARAMS ((void));
78 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
80 /* Flag for whether we want to abandon failed expression evals by default. */
83 static int auto_abandon
= 0;
86 int overload_resolution
= 0;
90 /* Find the address of function name NAME in the inferior. */
93 find_function_in_inferior (name
)
96 register struct symbol
*sym
;
97 sym
= lookup_symbol (name
, 0, VAR_NAMESPACE
, 0, NULL
);
100 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
102 error ("\"%s\" exists in this program but is not a function.",
105 return value_of_variable (sym
, NULL
);
109 struct minimal_symbol
*msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
114 type
= lookup_pointer_type (builtin_type_char
);
115 type
= lookup_function_type (type
);
116 type
= lookup_pointer_type (type
);
117 maddr
= (LONGEST
) SYMBOL_VALUE_ADDRESS (msymbol
);
118 return value_from_longest (type
, maddr
);
122 if (!target_has_execution
)
123 error ("evaluation of this expression requires the target program to be active");
125 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
130 /* Allocate NBYTES of space in the inferior using the inferior's malloc
131 and return a value that is a pointer to the allocated space. */
134 value_allocate_space_in_inferior (len
)
138 register value_ptr val
= find_function_in_inferior ("malloc");
140 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
141 val
= call_function_by_hand (val
, 1, &blocklen
);
142 if (value_logical_not (val
))
144 if (!target_has_execution
)
145 error ("No memory available to program now: you need to start the target first");
147 error ("No memory available to program: call to malloc failed");
153 allocate_space_in_inferior (len
)
156 return value_as_long (value_allocate_space_in_inferior (len
));
159 /* Cast value ARG2 to type TYPE and return as a value.
160 More general than a C cast: accepts any two types of the same length,
161 and if ARG2 is an lvalue it can be cast into anything at all. */
162 /* In C++, casts may change pointer or object representations. */
165 value_cast (type
, arg2
)
167 register value_ptr arg2
;
169 register enum type_code code1
;
170 register enum type_code code2
;
174 int convert_to_boolean
= 0;
176 if (VALUE_TYPE (arg2
) == type
)
179 CHECK_TYPEDEF (type
);
180 code1
= TYPE_CODE (type
);
182 type2
= check_typedef (VALUE_TYPE (arg2
));
184 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
185 is treated like a cast to (TYPE [N])OBJECT,
186 where N is sizeof(OBJECT)/sizeof(TYPE). */
187 if (code1
== TYPE_CODE_ARRAY
)
189 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
190 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
191 if (element_length
> 0
192 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
194 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
195 int val_length
= TYPE_LENGTH (type2
);
196 LONGEST low_bound
, high_bound
, new_length
;
197 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
198 low_bound
= 0, high_bound
= 0;
199 new_length
= val_length
/ element_length
;
200 if (val_length
% element_length
!= 0)
201 warning ("array element type size does not divide object size in cast");
202 /* FIXME-type-allocation: need a way to free this type when we are
204 range_type
= create_range_type ((struct type
*) NULL
,
205 TYPE_TARGET_TYPE (range_type
),
207 new_length
+ low_bound
- 1);
208 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
209 element_type
, range_type
);
214 if (current_language
->c_style_arrays
215 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
216 arg2
= value_coerce_array (arg2
);
218 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
219 arg2
= value_coerce_function (arg2
);
221 type2
= check_typedef (VALUE_TYPE (arg2
));
222 COERCE_VARYING_ARRAY (arg2
, type2
);
223 code2
= TYPE_CODE (type2
);
225 if (code1
== TYPE_CODE_COMPLEX
)
226 return cast_into_complex (type
, arg2
);
227 if (code1
== TYPE_CODE_BOOL
)
229 code1
= TYPE_CODE_INT
;
230 convert_to_boolean
= 1;
232 if (code1
== TYPE_CODE_CHAR
)
233 code1
= TYPE_CODE_INT
;
234 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
235 code2
= TYPE_CODE_INT
;
237 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
238 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
240 if (code1
== TYPE_CODE_STRUCT
241 && code2
== TYPE_CODE_STRUCT
242 && TYPE_NAME (type
) != 0)
244 /* Look in the type of the source to see if it contains the
245 type of the target as a superclass. If so, we'll need to
246 offset the object in addition to changing its type. */
247 value_ptr v
= search_struct_field (type_name_no_tag (type
),
251 VALUE_TYPE (v
) = type
;
255 if (code1
== TYPE_CODE_FLT
&& scalar
)
256 return value_from_double (type
, value_as_double (arg2
));
257 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
258 || code1
== TYPE_CODE_RANGE
)
259 && (scalar
|| code2
== TYPE_CODE_PTR
))
263 if (hp_som_som_object_present
&& /* if target compiled by HP aCC */
264 (code2
== TYPE_CODE_PTR
))
269 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2
)))
271 /* With HP aCC, pointers to data members have a bias */
272 case TYPE_CODE_MEMBER
:
273 retvalp
= value_from_longest (type
, value_as_long (arg2
));
274 ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
); /* force evaluation */
275 *ptr
&= ~0x20000000; /* zap 29th bit to remove bias */
278 /* While pointers to methods don't really point to a function */
279 case TYPE_CODE_METHOD
:
280 error ("Pointers to methods not supported with HP aCC");
283 break; /* fall out and go to normal handling */
286 longest
= value_as_long (arg2
);
287 return value_from_longest (type
, convert_to_boolean
? (LONGEST
) (longest
? 1 : 0) : longest
);
289 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
291 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
293 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
294 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
295 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
296 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
297 && !value_logical_not (arg2
))
301 /* Look in the type of the source to see if it contains the
302 type of the target as a superclass. If so, we'll need to
303 offset the pointer rather than just change its type. */
304 if (TYPE_NAME (t1
) != NULL
)
306 v
= search_struct_field (type_name_no_tag (t1
),
307 value_ind (arg2
), 0, t2
, 1);
311 VALUE_TYPE (v
) = type
;
316 /* Look in the type of the target to see if it contains the
317 type of the source as a superclass. If so, we'll need to
318 offset the pointer rather than just change its type.
319 FIXME: This fails silently with virtual inheritance. */
320 if (TYPE_NAME (t2
) != NULL
)
322 v
= search_struct_field (type_name_no_tag (t2
),
323 value_zero (t1
, not_lval
), 0, t1
, 1);
326 value_ptr v2
= value_ind (arg2
);
327 VALUE_ADDRESS (v2
) -= VALUE_ADDRESS (v
)
329 v2
= value_addr (v2
);
330 VALUE_TYPE (v2
) = type
;
335 /* No superclass found, just fall through to change ptr type. */
337 VALUE_TYPE (arg2
) = type
;
338 VALUE_ENCLOSING_TYPE (arg2
) = type
; /* pai: chk_val */
339 VALUE_POINTED_TO_OFFSET (arg2
) = 0; /* pai: chk_val */
342 else if (chill_varying_type (type
))
344 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
347 LONGEST low_bound
, high_bound
;
348 char *valaddr
, *valaddr_data
;
349 /* For lint warning about eltype2 possibly uninitialized: */
351 if (code2
== TYPE_CODE_BITSTRING
)
352 error ("not implemented: converting bitstring to varying type");
353 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
354 || (eltype1
= check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1))),
355 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
)),
356 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
357 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
358 error ("Invalid conversion to varying type");
359 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
360 range2
= TYPE_FIELD_TYPE (type2
, 0);
361 if (get_discrete_bounds (range1
, &low_bound
, &high_bound
) < 0)
364 count1
= high_bound
- low_bound
+ 1;
365 if (get_discrete_bounds (range2
, &low_bound
, &high_bound
) < 0)
366 count1
= -1, count2
= 0; /* To force error before */
368 count2
= high_bound
- low_bound
+ 1;
370 error ("target varying type is too small");
371 val
= allocate_value (type
);
372 valaddr
= VALUE_CONTENTS_RAW (val
);
373 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
374 /* Set val's __var_length field to count2. */
375 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
377 /* Set the __var_data field to count2 elements copied from arg2. */
378 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
379 count2
* TYPE_LENGTH (eltype2
));
380 /* Zero the rest of the __var_data field of val. */
381 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
382 (count1
- count2
) * TYPE_LENGTH (eltype2
));
385 else if (VALUE_LVAL (arg2
) == lval_memory
)
387 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
),
388 VALUE_BFD_SECTION (arg2
));
390 else if (code1
== TYPE_CODE_VOID
)
392 return value_zero (builtin_type_void
, not_lval
);
396 error ("Invalid cast.");
401 /* Create a value of type TYPE that is zero, and return it. */
404 value_zero (type
, lv
)
408 register value_ptr val
= allocate_value (type
);
410 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (check_typedef (type
)));
411 VALUE_LVAL (val
) = lv
;
416 /* Return a value with type TYPE located at ADDR.
418 Call value_at only if the data needs to be fetched immediately;
419 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
420 value_at_lazy instead. value_at_lazy simply records the address of
421 the data and sets the lazy-evaluation-required flag. The lazy flag
422 is tested in the VALUE_CONTENTS macro, which is used if and when
423 the contents are actually required.
425 Note: value_at does *NOT* handle embedded offsets; perform such
426 adjustments before or after calling it. */
429 value_at (type
, addr
, sect
)
434 register value_ptr val
;
436 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
437 error ("Attempt to dereference a generic pointer.");
439 val
= allocate_value (type
);
441 if (GDB_TARGET_IS_D10V
442 && TYPE_CODE (type
) == TYPE_CODE_PTR
443 && TYPE_TARGET_TYPE (type
)
444 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
446 /* pointer to function */
449 snum
= read_memory_unsigned_integer (addr
, 2);
450 num
= D10V_MAKE_IADDR (snum
);
451 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
453 else if (GDB_TARGET_IS_D10V
454 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
456 /* pointer to data */
459 snum
= read_memory_unsigned_integer (addr
, 2);
460 num
= D10V_MAKE_DADDR (snum
);
461 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
464 read_memory_section (addr
, VALUE_CONTENTS_ALL_RAW (val
), TYPE_LENGTH (type
), sect
);
466 VALUE_LVAL (val
) = lval_memory
;
467 VALUE_ADDRESS (val
) = addr
;
468 VALUE_BFD_SECTION (val
) = sect
;
473 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
476 value_at_lazy (type
, addr
, sect
)
481 register value_ptr val
;
483 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
484 error ("Attempt to dereference a generic pointer.");
486 val
= allocate_value (type
);
488 VALUE_LVAL (val
) = lval_memory
;
489 VALUE_ADDRESS (val
) = addr
;
490 VALUE_LAZY (val
) = 1;
491 VALUE_BFD_SECTION (val
) = sect
;
496 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
497 if the current data for a variable needs to be loaded into
498 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
499 clears the lazy flag to indicate that the data in the buffer is valid.
501 If the value is zero-length, we avoid calling read_memory, which would
502 abort. We mark the value as fetched anyway -- all 0 bytes of it.
504 This function returns a value because it is used in the VALUE_CONTENTS
505 macro as part of an expression, where a void would not work. The
509 value_fetch_lazy (val
)
510 register value_ptr val
;
512 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
513 int length
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
));
515 struct type
*type
= VALUE_TYPE (val
);
516 if (GDB_TARGET_IS_D10V
517 && TYPE_CODE (type
) == TYPE_CODE_PTR
518 && TYPE_TARGET_TYPE (type
)
519 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
521 /* pointer to function */
524 snum
= read_memory_unsigned_integer (addr
, 2);
525 num
= D10V_MAKE_IADDR (snum
);
526 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
528 else if (GDB_TARGET_IS_D10V
529 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
531 /* pointer to data */
534 snum
= read_memory_unsigned_integer (addr
, 2);
535 num
= D10V_MAKE_DADDR (snum
);
536 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
539 read_memory_section (addr
, VALUE_CONTENTS_ALL_RAW (val
), length
,
540 VALUE_BFD_SECTION (val
));
541 VALUE_LAZY (val
) = 0;
546 /* Store the contents of FROMVAL into the location of TOVAL.
547 Return a new value with the location of TOVAL and contents of FROMVAL. */
550 value_assign (toval
, fromval
)
551 register value_ptr toval
, fromval
;
553 register struct type
*type
;
554 register value_ptr val
;
555 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
558 if (!toval
->modifiable
)
559 error ("Left operand of assignment is not a modifiable lvalue.");
563 type
= VALUE_TYPE (toval
);
564 if (VALUE_LVAL (toval
) != lval_internalvar
)
565 fromval
= value_cast (type
, fromval
);
567 COERCE_ARRAY (fromval
);
568 CHECK_TYPEDEF (type
);
570 /* If TOVAL is a special machine register requiring conversion
571 of program values to a special raw format,
572 convert FROMVAL's contents now, with result in `raw_buffer',
573 and set USE_BUFFER to the number of bytes to write. */
575 if (VALUE_REGNO (toval
) >= 0)
577 int regno
= VALUE_REGNO (toval
);
578 if (REGISTER_CONVERTIBLE (regno
))
580 struct type
*fromtype
= check_typedef (VALUE_TYPE (fromval
));
581 REGISTER_CONVERT_TO_RAW (fromtype
, regno
,
582 VALUE_CONTENTS (fromval
), raw_buffer
);
583 use_buffer
= REGISTER_RAW_SIZE (regno
);
587 switch (VALUE_LVAL (toval
))
589 case lval_internalvar
:
590 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
591 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
592 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
593 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
594 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
597 case lval_internalvar_component
:
598 set_internalvar_component (VALUE_INTERNALVAR (toval
),
599 VALUE_OFFSET (toval
),
600 VALUE_BITPOS (toval
),
601 VALUE_BITSIZE (toval
),
608 CORE_ADDR changed_addr
;
611 if (VALUE_BITSIZE (toval
))
613 char buffer
[sizeof (LONGEST
)];
614 /* We assume that the argument to read_memory is in units of
615 host chars. FIXME: Is that correct? */
616 changed_len
= (VALUE_BITPOS (toval
)
617 + VALUE_BITSIZE (toval
)
621 if (changed_len
> (int) sizeof (LONGEST
))
622 error ("Can't handle bitfields which don't fit in a %d bit word.",
623 sizeof (LONGEST
) * HOST_CHAR_BIT
);
625 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
626 buffer
, changed_len
);
627 modify_field (buffer
, value_as_long (fromval
),
628 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
629 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
630 dest_buffer
= buffer
;
634 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
635 changed_len
= use_buffer
;
636 dest_buffer
= raw_buffer
;
640 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
641 changed_len
= TYPE_LENGTH (type
);
642 dest_buffer
= VALUE_CONTENTS (fromval
);
645 write_memory (changed_addr
, dest_buffer
, changed_len
);
646 if (memory_changed_hook
)
647 memory_changed_hook (changed_addr
, changed_len
);
652 if (VALUE_BITSIZE (toval
))
654 char buffer
[sizeof (LONGEST
)];
655 int len
= REGISTER_RAW_SIZE (VALUE_REGNO (toval
));
657 if (len
> (int) sizeof (LONGEST
))
658 error ("Can't handle bitfields in registers larger than %d bits.",
659 sizeof (LONGEST
) * HOST_CHAR_BIT
);
661 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
662 > len
* HOST_CHAR_BIT
)
663 /* Getting this right would involve being very careful about
666 Can't handle bitfield which doesn't fit in a single register.");
668 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
670 modify_field (buffer
, value_as_long (fromval
),
671 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
672 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
676 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
677 raw_buffer
, use_buffer
);
680 /* Do any conversion necessary when storing this type to more
681 than one register. */
682 #ifdef REGISTER_CONVERT_FROM_TYPE
683 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
684 REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval
), type
, raw_buffer
);
685 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
686 raw_buffer
, TYPE_LENGTH (type
));
688 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
689 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
692 /* Assigning to the stack pointer, frame pointer, and other
693 (architecture and calling convention specific) registers may
694 cause the frame cache to be out of date. We just do this
695 on all assignments to registers for simplicity; I doubt the slowdown
697 reinit_frame_cache ();
700 case lval_reg_frame_relative
:
702 /* value is stored in a series of registers in the frame
703 specified by the structure. Copy that value out, modify
704 it, and copy it back in. */
705 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
706 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
707 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
708 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
711 /* Make the buffer large enough in all cases. */
712 char *buffer
= (char *) alloca (amount_to_copy
714 + MAX_REGISTER_RAW_SIZE
);
717 struct frame_info
*frame
;
719 /* Figure out which frame this is in currently. */
720 for (frame
= get_current_frame ();
721 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
722 frame
= get_prev_frame (frame
))
726 error ("Value being assigned to is no longer active.");
728 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
731 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
733 amount_copied
< amount_to_copy
;
734 amount_copied
+= reg_size
, regno
++)
736 get_saved_register (buffer
+ amount_copied
,
737 (int *) NULL
, (CORE_ADDR
*) NULL
,
738 frame
, regno
, (enum lval_type
*) NULL
);
741 /* Modify what needs to be modified. */
742 if (VALUE_BITSIZE (toval
))
743 modify_field (buffer
+ byte_offset
,
744 value_as_long (fromval
),
745 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
747 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
749 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
753 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
755 amount_copied
< amount_to_copy
;
756 amount_copied
+= reg_size
, regno
++)
762 /* Just find out where to put it. */
763 get_saved_register ((char *) NULL
,
764 &optim
, &addr
, frame
, regno
, &lval
);
767 error ("Attempt to assign to a value that was optimized out.");
768 if (lval
== lval_memory
)
769 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
770 else if (lval
== lval_register
)
771 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
773 error ("Attempt to assign to an unmodifiable value.");
776 if (register_changed_hook
)
777 register_changed_hook (-1);
783 error ("Left operand of assignment is not an lvalue.");
786 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
787 If the field is signed, and is negative, then sign extend. */
788 if ((VALUE_BITSIZE (toval
) > 0)
789 && (VALUE_BITSIZE (toval
) < 8 * (int) sizeof (LONGEST
)))
791 LONGEST fieldval
= value_as_long (fromval
);
792 LONGEST valmask
= (((ULONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
795 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
796 fieldval
|= ~valmask
;
798 fromval
= value_from_longest (type
, fieldval
);
801 val
= value_copy (toval
);
802 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
804 VALUE_TYPE (val
) = type
;
805 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
806 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
807 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
812 /* Extend a value VAL to COUNT repetitions of its type. */
815 value_repeat (arg1
, count
)
819 register value_ptr val
;
821 if (VALUE_LVAL (arg1
) != lval_memory
)
822 error ("Only values in memory can be extended with '@'.");
824 error ("Invalid number %d of repetitions.", count
);
826 val
= allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1
), count
);
828 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
829 VALUE_CONTENTS_ALL_RAW (val
),
830 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)));
831 VALUE_LVAL (val
) = lval_memory
;
832 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
838 value_of_variable (var
, b
)
843 struct frame_info
*frame
= NULL
;
846 frame
= NULL
; /* Use selected frame. */
847 else if (symbol_read_needs_frame (var
))
849 frame
= block_innermost_frame (b
);
852 if (BLOCK_FUNCTION (b
)
853 && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)))
854 error ("No frame is currently executing in block %s.",
855 SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)));
857 error ("No frame is currently executing in specified block");
861 val
= read_var_value (var
, frame
);
863 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
868 /* Given a value which is an array, return a value which is a pointer to its
869 first element, regardless of whether or not the array has a nonzero lower
872 FIXME: A previous comment here indicated that this routine should be
873 substracting the array's lower bound. It's not clear to me that this
874 is correct. Given an array subscripting operation, it would certainly
875 work to do the adjustment here, essentially computing:
877 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
879 However I believe a more appropriate and logical place to account for
880 the lower bound is to do so in value_subscript, essentially computing:
882 (&array[0] + ((index - lowerbound) * sizeof array[0]))
884 As further evidence consider what would happen with operations other
885 than array subscripting, where the caller would get back a value that
886 had an address somewhere before the actual first element of the array,
887 and the information about the lower bound would be lost because of
888 the coercion to pointer type.
892 value_coerce_array (arg1
)
895 register struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
897 if (VALUE_LVAL (arg1
) != lval_memory
)
898 error ("Attempt to take address of value not located in memory.");
900 return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
901 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
904 /* Given a value which is a function, return a value which is a pointer
908 value_coerce_function (arg1
)
913 if (VALUE_LVAL (arg1
) != lval_memory
)
914 error ("Attempt to take address of value not located in memory.");
916 retval
= value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
917 (LONGEST
) (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
918 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (arg1
);
922 /* Return a pointer value for the object for which ARG1 is the contents. */
930 struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
931 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
933 /* Copy the value, but change the type from (T&) to (T*).
934 We keep the same location information, which is efficient,
935 and allows &(&X) to get the location containing the reference. */
936 arg2
= value_copy (arg1
);
937 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
940 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
941 return value_coerce_function (arg1
);
943 if (VALUE_LVAL (arg1
) != lval_memory
)
944 error ("Attempt to take address of value not located in memory.");
946 /* Get target memory address */
947 arg2
= value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1
)),
948 (LONGEST
) (VALUE_ADDRESS (arg1
)
949 + VALUE_OFFSET (arg1
)
950 + VALUE_EMBEDDED_OFFSET (arg1
)));
952 /* This may be a pointer to a base subobject; so remember the
953 full derived object's type ... */
954 VALUE_ENCLOSING_TYPE (arg2
) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1
));
955 /* ... and also the relative position of the subobject in the full object */
956 VALUE_POINTED_TO_OFFSET (arg2
) = VALUE_EMBEDDED_OFFSET (arg1
);
957 VALUE_BFD_SECTION (arg2
) = VALUE_BFD_SECTION (arg1
);
961 /* Given a value of a pointer type, apply the C unary * operator to it. */
967 struct type
*base_type
;
972 base_type
= check_typedef (VALUE_TYPE (arg1
));
974 if (TYPE_CODE (base_type
) == TYPE_CODE_MEMBER
)
975 error ("not implemented: member types in value_ind");
977 /* Allow * on an integer so we can cast it to whatever we want.
978 This returns an int, which seems like the most C-like thing
979 to do. "long long" variables are rare enough that
980 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
981 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
982 return value_at (builtin_type_int
,
983 (CORE_ADDR
) value_as_long (arg1
),
984 VALUE_BFD_SECTION (arg1
));
985 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
987 struct type
*enc_type
;
988 /* We may be pointing to something embedded in a larger object */
989 /* Get the real type of the enclosing object */
990 enc_type
= check_typedef (VALUE_ENCLOSING_TYPE (arg1
));
991 enc_type
= TYPE_TARGET_TYPE (enc_type
);
992 /* Retrieve the enclosing object pointed to */
993 arg2
= value_at_lazy (enc_type
,
994 value_as_pointer (arg1
) - VALUE_POINTED_TO_OFFSET (arg1
),
995 VALUE_BFD_SECTION (arg1
));
997 VALUE_TYPE (arg2
) = TYPE_TARGET_TYPE (base_type
);
998 /* Add embedding info */
999 VALUE_ENCLOSING_TYPE (arg2
) = enc_type
;
1000 VALUE_EMBEDDED_OFFSET (arg2
) = VALUE_POINTED_TO_OFFSET (arg1
);
1002 /* We may be pointing to an object of some derived type */
1003 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1007 error ("Attempt to take contents of a non-pointer value.");
1008 return 0; /* For lint -- never reached */
1011 /* Pushing small parts of stack frames. */
1013 /* Push one word (the size of object that a register holds). */
1016 push_word (sp
, word
)
1020 register int len
= REGISTER_SIZE
;
1021 char buffer
[MAX_REGISTER_RAW_SIZE
];
1023 store_unsigned_integer (buffer
, len
, word
);
1024 if (INNER_THAN (1, 2))
1026 /* stack grows downward */
1028 write_memory (sp
, buffer
, len
);
1032 /* stack grows upward */
1033 write_memory (sp
, buffer
, len
);
1040 /* Push LEN bytes with data at BUFFER. */
1043 push_bytes (sp
, buffer
, len
)
1048 if (INNER_THAN (1, 2))
1050 /* stack grows downward */
1052 write_memory (sp
, buffer
, len
);
1056 /* stack grows upward */
1057 write_memory (sp
, buffer
, len
);
1064 #ifndef PARM_BOUNDARY
1065 #define PARM_BOUNDARY (0)
1068 /* Push onto the stack the specified value VALUE. Pad it correctly for
1069 it to be an argument to a function. */
1072 value_push (sp
, arg
)
1073 register CORE_ADDR sp
;
1076 register int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
1077 register int container_len
;
1078 register int offset
;
1080 /* How big is the container we're going to put this value in? */
1082 container_len
= ((len
+ PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1)
1083 & ~(PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1));
1085 /* Are we going to put it at the high or low end of the container? */
1086 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1087 offset
= container_len
- len
;
1091 if (INNER_THAN (1, 2))
1093 /* stack grows downward */
1094 sp
-= container_len
;
1095 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1099 /* stack grows upward */
1100 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1101 sp
+= container_len
;
1107 #ifndef PUSH_ARGUMENTS
1108 #define PUSH_ARGUMENTS default_push_arguments
1112 default_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
1117 CORE_ADDR struct_addr
;
1119 /* ASSERT ( !struct_return); */
1121 for (i
= nargs
- 1; i
>= 0; i
--)
1122 sp
= value_push (sp
, args
[i
]);
1127 /* Perform the standard coercions that are specified
1128 for arguments to be passed to C functions.
1130 If PARAM_TYPE is non-NULL, it is the expected parameter type.
1131 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
1134 value_arg_coerce (arg
, param_type
, is_prototyped
)
1136 struct type
*param_type
;
1139 register struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1140 register struct type
*type
1141 = param_type
? check_typedef (param_type
) : arg_type
;
1143 switch (TYPE_CODE (type
))
1146 if (TYPE_CODE (arg_type
) != TYPE_CODE_REF
)
1148 arg
= value_addr (arg
);
1149 VALUE_TYPE (arg
) = param_type
;
1154 case TYPE_CODE_CHAR
:
1155 case TYPE_CODE_BOOL
:
1156 case TYPE_CODE_ENUM
:
1157 /* If we don't have a prototype, coerce to integer type if necessary. */
1160 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1161 type
= builtin_type_int
;
1163 /* Currently all target ABIs require at least the width of an integer
1164 type for an argument. We may have to conditionalize the following
1165 type coercion for future targets. */
1166 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1167 type
= builtin_type_int
;
1170 /* FIXME: We should always convert floats to doubles in the
1171 non-prototyped case. As many debugging formats include
1172 no information about prototyping, we have to live with
1173 COERCE_FLOAT_TO_DOUBLE for now. */
1174 if (!is_prototyped
&& COERCE_FLOAT_TO_DOUBLE
)
1176 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
1177 type
= builtin_type_double
;
1178 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin_type_double
))
1179 type
= builtin_type_long_double
;
1182 case TYPE_CODE_FUNC
:
1183 type
= lookup_pointer_type (type
);
1185 case TYPE_CODE_ARRAY
:
1186 if (current_language
->c_style_arrays
)
1187 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1189 case TYPE_CODE_UNDEF
:
1191 case TYPE_CODE_STRUCT
:
1192 case TYPE_CODE_UNION
:
1193 case TYPE_CODE_VOID
:
1195 case TYPE_CODE_RANGE
:
1196 case TYPE_CODE_STRING
:
1197 case TYPE_CODE_BITSTRING
:
1198 case TYPE_CODE_ERROR
:
1199 case TYPE_CODE_MEMBER
:
1200 case TYPE_CODE_METHOD
:
1201 case TYPE_CODE_COMPLEX
:
1206 return value_cast (type
, arg
);
1209 /* Determine a function's address and its return type from its value.
1210 Calls error() if the function is not valid for calling. */
1213 find_function_addr (function
, retval_type
)
1215 struct type
**retval_type
;
1217 register struct type
*ftype
= check_typedef (VALUE_TYPE (function
));
1218 register enum type_code code
= TYPE_CODE (ftype
);
1219 struct type
*value_type
;
1222 /* If it's a member function, just look at the function
1225 /* Determine address to call. */
1226 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
1228 funaddr
= VALUE_ADDRESS (function
);
1229 value_type
= TYPE_TARGET_TYPE (ftype
);
1231 else if (code
== TYPE_CODE_PTR
)
1233 funaddr
= value_as_pointer (function
);
1234 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1235 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1236 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1238 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1239 /* FIXME: This is a workaround for the unusual function
1240 pointer representation on the RS/6000, see comment
1241 in config/rs6000/tm-rs6000.h */
1242 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
1244 value_type
= TYPE_TARGET_TYPE (ftype
);
1247 value_type
= builtin_type_int
;
1249 else if (code
== TYPE_CODE_INT
)
1251 /* Handle the case of functions lacking debugging info.
1252 Their values are characters since their addresses are char */
1253 if (TYPE_LENGTH (ftype
) == 1)
1254 funaddr
= value_as_pointer (value_addr (function
));
1256 /* Handle integer used as address of a function. */
1257 funaddr
= (CORE_ADDR
) value_as_long (function
);
1259 value_type
= builtin_type_int
;
1262 error ("Invalid data type for function to be called.");
1264 *retval_type
= value_type
;
1268 /* All this stuff with a dummy frame may seem unnecessarily complicated
1269 (why not just save registers in GDB?). The purpose of pushing a dummy
1270 frame which looks just like a real frame is so that if you call a
1271 function and then hit a breakpoint (get a signal, etc), "backtrace"
1272 will look right. Whether the backtrace needs to actually show the
1273 stack at the time the inferior function was called is debatable, but
1274 it certainly needs to not display garbage. So if you are contemplating
1275 making dummy frames be different from normal frames, consider that. */
1277 /* Perform a function call in the inferior.
1278 ARGS is a vector of values of arguments (NARGS of them).
1279 FUNCTION is a value, the function to be called.
1280 Returns a value representing what the function returned.
1281 May fail to return, if a breakpoint or signal is hit
1282 during the execution of the function.
1284 ARGS is modified to contain coerced values. */
1286 static value_ptr hand_function_call
PARAMS ((value_ptr function
, int nargs
, value_ptr
* args
));
1288 hand_function_call (function
, nargs
, args
)
1293 register CORE_ADDR sp
;
1296 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1297 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1298 and remove any extra bytes which might exist because ULONGEST is
1299 bigger than REGISTER_SIZE.
1301 NOTE: This is pretty wierd, as the call dummy is actually a
1302 sequence of instructions. But CISC machines will have
1303 to pack the instructions into REGISTER_SIZE units (and
1304 so will RISC machines for which INSTRUCTION_SIZE is not
1307 NOTE: This is pretty stupid. CALL_DUMMY should be in strict
1308 target byte order. */
1310 static ULONGEST
*dummy
;
1314 struct type
*value_type
;
1315 unsigned char struct_return
;
1316 CORE_ADDR struct_addr
= 0;
1317 struct inferior_status
*inf_status
;
1318 struct cleanup
*old_chain
;
1320 int using_gcc
; /* Set to version of gcc in use, or zero if not gcc */
1322 struct type
*param_type
= NULL
;
1323 struct type
*ftype
= check_typedef (SYMBOL_TYPE (function
));
1325 dummy
= alloca (SIZEOF_CALL_DUMMY_WORDS
);
1326 sizeof_dummy1
= REGISTER_SIZE
* SIZEOF_CALL_DUMMY_WORDS
/ sizeof (ULONGEST
);
1327 dummy1
= alloca (sizeof_dummy1
);
1328 memcpy (dummy
, CALL_DUMMY_WORDS
, SIZEOF_CALL_DUMMY_WORDS
);
1330 if (!target_has_execution
)
1333 inf_status
= save_inferior_status (1);
1334 old_chain
= make_cleanup ((make_cleanup_func
) restore_inferior_status
,
1337 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1338 (and POP_FRAME for restoring them). (At least on most machines)
1339 they are saved on the stack in the inferior. */
1342 old_sp
= sp
= read_sp ();
1344 if (INNER_THAN (1, 2))
1346 /* Stack grows down */
1347 sp
-= sizeof_dummy1
;
1352 /* Stack grows up */
1354 sp
+= sizeof_dummy1
;
1357 funaddr
= find_function_addr (function
, &value_type
);
1358 CHECK_TYPEDEF (value_type
);
1361 struct block
*b
= block_for_pc (funaddr
);
1362 /* If compiled without -g, assume GCC 2. */
1363 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
1366 /* Are we returning a value using a structure return or a normal
1369 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1372 /* Create a call sequence customized for this function
1373 and the number of arguments for it. */
1374 for (i
= 0; i
< (int) (SIZEOF_CALL_DUMMY_WORDS
/ sizeof (dummy
[0])); i
++)
1375 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1377 (ULONGEST
) dummy
[i
]);
1379 #ifdef GDB_TARGET_IS_HPPA
1380 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1381 value_type
, using_gcc
);
1383 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1384 value_type
, using_gcc
);
1388 if (CALL_DUMMY_LOCATION
== ON_STACK
)
1390 write_memory (start_sp
, (char *) dummy1
, sizeof_dummy1
);
1393 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
)
1395 /* Convex Unix prohibits executing in the stack segment. */
1396 /* Hope there is empty room at the top of the text segment. */
1397 extern CORE_ADDR text_end
;
1398 static int checked
= 0;
1400 for (start_sp
= text_end
- sizeof_dummy1
; start_sp
< text_end
; ++start_sp
)
1401 if (read_memory_integer (start_sp
, 1) != 0)
1402 error ("text segment full -- no place to put call");
1405 real_pc
= text_end
- sizeof_dummy1
;
1406 write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1409 if (CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
1411 extern CORE_ADDR text_end
;
1415 errcode
= target_write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1417 error ("Cannot write text segment -- call_function failed");
1420 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
1426 sp
= old_sp
; /* It really is used, for some ifdef's... */
1429 if (nargs
< TYPE_NFIELDS (ftype
))
1430 error ("too few arguments in function call");
1432 for (i
= nargs
- 1; i
>= 0; i
--)
1434 /* If we're off the end of the known arguments, do the standard
1435 promotions. FIXME: if we had a prototype, this should only
1436 be allowed if ... were present. */
1437 if (i
>= TYPE_NFIELDS (ftype
))
1438 args
[i
] = value_arg_coerce (args
[i
], NULL
, 0);
1442 int is_prototyped
= TYPE_FLAGS (ftype
) & TYPE_FLAG_PROTOTYPED
;
1443 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1445 args
[i
] = value_arg_coerce (args
[i
], param_type
, is_prototyped
);
1448 /*elz: this code is to handle the case in which the function to be called
1449 has a pointer to function as parameter and the corresponding actual argument
1450 is the address of a function and not a pointer to function variable.
1451 In aCC compiled code, the calls through pointers to functions (in the body
1452 of the function called by hand) are made via $$dyncall_external which
1453 requires some registers setting, this is taken care of if we call
1454 via a function pointer variable, but not via a function address.
1455 In cc this is not a problem. */
1459 /* if this parameter is a pointer to function */
1460 if (TYPE_CODE (param_type
) == TYPE_CODE_PTR
)
1461 if (TYPE_CODE (param_type
->target_type
) == TYPE_CODE_FUNC
)
1462 /* elz: FIXME here should go the test about the compiler used
1463 to compile the target. We want to issue the error
1464 message only if the compiler used was HP's aCC.
1465 If we used HP's cc, then there is no problem and no need
1466 to return at this point */
1467 if (using_gcc
== 0) /* && compiler == aCC */
1468 /* go see if the actual parameter is a variable of type
1469 pointer to function or just a function */
1470 if (args
[i
]->lval
== not_lval
)
1473 if (find_pc_partial_function ((CORE_ADDR
) args
[i
]->aligner
.contents
[0], &arg_name
, NULL
, NULL
))
1475 You cannot use function <%s> as argument. \n\
1476 You must use a pointer to function type variable. Command ignored.", arg_name
);
1480 #if defined (REG_STRUCT_HAS_ADDR)
1482 /* This is a machine like the sparc, where we may need to pass a pointer
1483 to the structure, not the structure itself. */
1484 for (i
= nargs
- 1; i
>= 0; i
--)
1486 struct type
*arg_type
= check_typedef (VALUE_TYPE (args
[i
]));
1487 if ((TYPE_CODE (arg_type
) == TYPE_CODE_STRUCT
1488 || TYPE_CODE (arg_type
) == TYPE_CODE_UNION
1489 || TYPE_CODE (arg_type
) == TYPE_CODE_ARRAY
1490 || TYPE_CODE (arg_type
) == TYPE_CODE_STRING
1491 || TYPE_CODE (arg_type
) == TYPE_CODE_BITSTRING
1492 || TYPE_CODE (arg_type
) == TYPE_CODE_SET
1493 || (TYPE_CODE (arg_type
) == TYPE_CODE_FLT
1494 && TYPE_LENGTH (arg_type
) > 8)
1496 && REG_STRUCT_HAS_ADDR (using_gcc
, arg_type
))
1499 int len
; /* = TYPE_LENGTH (arg_type); */
1501 arg_type
= check_typedef (VALUE_ENCLOSING_TYPE (args
[i
]));
1502 len
= TYPE_LENGTH (arg_type
);
1505 /* MVS 11/22/96: I think at least some of this stack_align code is
1506 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1507 a target-defined manner. */
1508 aligned_len
= STACK_ALIGN (len
);
1512 if (INNER_THAN (1, 2))
1514 /* stack grows downward */
1519 /* The stack grows up, so the address of the thing we push
1520 is the stack pointer before we push it. */
1523 /* Push the structure. */
1524 write_memory (sp
, VALUE_CONTENTS_ALL (args
[i
]), len
);
1525 if (INNER_THAN (1, 2))
1527 /* The stack grows down, so the address of the thing we push
1528 is the stack pointer after we push it. */
1533 /* stack grows upward */
1536 /* The value we're going to pass is the address of the thing
1538 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1540 args
[i
] = value_from_longest (lookup_pointer_type (arg_type
),
1545 #endif /* REG_STRUCT_HAS_ADDR. */
1547 /* Reserve space for the return structure to be written on the
1548 stack, if necessary */
1552 int len
= TYPE_LENGTH (value_type
);
1554 /* MVS 11/22/96: I think at least some of this stack_align code is
1555 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1556 a target-defined manner. */
1557 len
= STACK_ALIGN (len
);
1559 if (INNER_THAN (1, 2))
1561 /* stack grows downward */
1567 /* stack grows upward */
1573 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1574 on other architectures. This is because all the alignment is taken care
1575 of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
1576 hppa_push_arguments */
1577 #ifndef NO_EXTRA_ALIGNMENT_NEEDED
1579 #if defined(STACK_ALIGN)
1580 /* MVS 11/22/96: I think at least some of this stack_align code is
1581 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1582 a target-defined manner. */
1583 if (INNER_THAN (1, 2))
1585 /* If stack grows down, we must leave a hole at the top. */
1588 for (i
= nargs
- 1; i
>= 0; i
--)
1589 len
+= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
1590 if (CALL_DUMMY_STACK_ADJUST_P
)
1591 len
+= CALL_DUMMY_STACK_ADJUST
;
1592 sp
-= STACK_ALIGN (len
) - len
;
1594 #endif /* STACK_ALIGN */
1595 #endif /* NO_EXTRA_ALIGNMENT_NEEDED */
1597 sp
= PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
);
1599 #ifdef PUSH_RETURN_ADDRESS /* for targets that use no CALL_DUMMY */
1600 /* There are a number of targets now which actually don't write any
1601 CALL_DUMMY instructions into the target, but instead just save the
1602 machine state, push the arguments, and jump directly to the callee
1603 function. Since this doesn't actually involve executing a JSR/BSR
1604 instruction, the return address must be set up by hand, either by
1605 pushing onto the stack or copying into a return-address register
1606 as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
1607 but that's overloading its functionality a bit, so I'm making it
1608 explicit to do it here. */
1609 sp
= PUSH_RETURN_ADDRESS (real_pc
, sp
);
1610 #endif /* PUSH_RETURN_ADDRESS */
1612 #if defined(STACK_ALIGN)
1613 if (!INNER_THAN (1, 2))
1615 /* If stack grows up, we must leave a hole at the bottom, note
1616 that sp already has been advanced for the arguments! */
1617 if (CALL_DUMMY_STACK_ADJUST_P
)
1618 sp
+= CALL_DUMMY_STACK_ADJUST
;
1619 sp
= STACK_ALIGN (sp
);
1621 #endif /* STACK_ALIGN */
1623 /* XXX This seems wrong. For stacks that grow down we shouldn't do
1625 /* MVS 11/22/96: I think at least some of this stack_align code is
1626 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1627 a target-defined manner. */
1628 if (CALL_DUMMY_STACK_ADJUST_P
)
1629 if (INNER_THAN (1, 2))
1631 /* stack grows downward */
1632 sp
-= CALL_DUMMY_STACK_ADJUST
;
1635 /* Store the address at which the structure is supposed to be
1636 written. Note that this (and the code which reserved the space
1637 above) assumes that gcc was used to compile this function. Since
1638 it doesn't cost us anything but space and if the function is pcc
1639 it will ignore this value, we will make that assumption.
1641 Also note that on some machines (like the sparc) pcc uses a
1642 convention like gcc's. */
1645 STORE_STRUCT_RETURN (struct_addr
, sp
);
1647 /* Write the stack pointer. This is here because the statements above
1648 might fool with it. On SPARC, this write also stores the register
1649 window into the right place in the new stack frame, which otherwise
1650 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1653 #ifdef SAVE_DUMMY_FRAME_TOS
1654 SAVE_DUMMY_FRAME_TOS (sp
);
1658 char retbuf
[REGISTER_BYTES
];
1660 struct symbol
*symbol
;
1663 symbol
= find_pc_function (funaddr
);
1666 name
= SYMBOL_SOURCE_NAME (symbol
);
1670 /* Try the minimal symbols. */
1671 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1675 name
= SYMBOL_SOURCE_NAME (msymbol
);
1681 sprintf (format
, "at %s", local_hex_format ());
1683 /* FIXME-32x64: assumes funaddr fits in a long. */
1684 sprintf (name
, format
, (unsigned long) funaddr
);
1687 /* Execute the stack dummy routine, calling FUNCTION.
1688 When it is done, discard the empty frame
1689 after storing the contents of all regs into retbuf. */
1690 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1692 /* We stopped somewhere besides the call dummy. */
1694 /* If we did the cleanups, we would print a spurious error
1695 message (Unable to restore previously selected frame),
1696 would write the registers from the inf_status (which is
1697 wrong), and would do other wrong things. */
1698 discard_cleanups (old_chain
);
1699 discard_inferior_status (inf_status
);
1701 /* The following error message used to say "The expression
1702 which contained the function call has been discarded." It
1703 is a hard concept to explain in a few words. Ideally, GDB
1704 would be able to resume evaluation of the expression when
1705 the function finally is done executing. Perhaps someday
1706 this will be implemented (it would not be easy). */
1708 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1709 a C++ name with arguments and stuff. */
1711 The program being debugged stopped while in a function called from GDB.\n\
1712 When the function (%s) is done executing, GDB will silently\n\
1713 stop (instead of continuing to evaluate the expression containing\n\
1714 the function call).", name
);
1717 do_cleanups (old_chain
);
1719 /* Figure out the value returned by the function. */
1720 /* elz: I defined this new macro for the hppa architecture only.
1721 this gives us a way to get the value returned by the function from the stack,
1722 at the same address we told the function to put it.
1723 We cannot assume on the pa that r28 still contains the address of the returned
1724 structure. Usually this will be overwritten by the callee.
1725 I don't know about other architectures, so I defined this macro
1728 #ifdef VALUE_RETURNED_FROM_STACK
1730 return (value_ptr
) VALUE_RETURNED_FROM_STACK (value_type
, struct_addr
);
1733 return value_being_returned (value_type
, retbuf
, struct_return
);
1738 call_function_by_hand (function
, nargs
, args
)
1745 return hand_function_call (function
, nargs
, args
);
1749 error ("Cannot invoke functions on this machine.");
1755 /* Create a value for an array by allocating space in the inferior, copying
1756 the data into that space, and then setting up an array value.
1758 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1759 populated from the values passed in ELEMVEC.
1761 The element type of the array is inherited from the type of the
1762 first element, and all elements must have the same size (though we
1763 don't currently enforce any restriction on their types). */
1766 value_array (lowbound
, highbound
, elemvec
)
1773 unsigned int typelength
;
1775 struct type
*rangetype
;
1776 struct type
*arraytype
;
1779 /* Validate that the bounds are reasonable and that each of the elements
1780 have the same size. */
1782 nelem
= highbound
- lowbound
+ 1;
1785 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1787 typelength
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[0]));
1788 for (idx
= 1; idx
< nelem
; idx
++)
1790 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[idx
])) != typelength
)
1792 error ("array elements must all be the same size");
1796 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1797 lowbound
, highbound
);
1798 arraytype
= create_array_type ((struct type
*) NULL
,
1799 VALUE_ENCLOSING_TYPE (elemvec
[0]), rangetype
);
1801 if (!current_language
->c_style_arrays
)
1803 val
= allocate_value (arraytype
);
1804 for (idx
= 0; idx
< nelem
; idx
++)
1806 memcpy (VALUE_CONTENTS_ALL_RAW (val
) + (idx
* typelength
),
1807 VALUE_CONTENTS_ALL (elemvec
[idx
]),
1810 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (elemvec
[0]);
1814 /* Allocate space to store the array in the inferior, and then initialize
1815 it by copying in each element. FIXME: Is it worth it to create a
1816 local buffer in which to collect each value and then write all the
1817 bytes in one operation? */
1819 addr
= allocate_space_in_inferior (nelem
* typelength
);
1820 for (idx
= 0; idx
< nelem
; idx
++)
1822 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS_ALL (elemvec
[idx
]),
1826 /* Create the array type and set up an array value to be evaluated lazily. */
1828 val
= value_at_lazy (arraytype
, addr
, VALUE_BFD_SECTION (elemvec
[0]));
1832 /* Create a value for a string constant by allocating space in the inferior,
1833 copying the data into that space, and returning the address with type
1834 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1836 Note that string types are like array of char types with a lower bound of
1837 zero and an upper bound of LEN - 1. Also note that the string may contain
1838 embedded null bytes. */
1841 value_string (ptr
, len
)
1846 int lowbound
= current_language
->string_lower_bound
;
1847 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1849 lowbound
, len
+ lowbound
- 1);
1850 struct type
*stringtype
1851 = create_string_type ((struct type
*) NULL
, rangetype
);
1854 if (current_language
->c_style_arrays
== 0)
1856 val
= allocate_value (stringtype
);
1857 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1862 /* Allocate space to store the string in the inferior, and then
1863 copy LEN bytes from PTR in gdb to that address in the inferior. */
1865 addr
= allocate_space_in_inferior (len
);
1866 write_memory (addr
, ptr
, len
);
1868 val
= value_at_lazy (stringtype
, addr
, NULL
);
1873 value_bitstring (ptr
, len
)
1878 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1880 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1881 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1882 val
= allocate_value (type
);
1883 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1887 /* See if we can pass arguments in T2 to a function which takes arguments
1888 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1889 arguments need coercion of some sort, then the coerced values are written
1890 into T2. Return value is 0 if the arguments could be matched, or the
1891 position at which they differ if not.
1893 STATICP is nonzero if the T1 argument list came from a
1894 static member function.
1896 For non-static member functions, we ignore the first argument,
1897 which is the type of the instance variable. This is because we want
1898 to handle calls with objects from derived classes. This is not
1899 entirely correct: we should actually check to make sure that a
1900 requested operation is type secure, shouldn't we? FIXME. */
1903 typecmp (staticp
, t1
, t2
)
1912 if (staticp
&& t1
== 0)
1916 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
)
1918 if (t1
[!staticp
] == 0)
1920 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1922 struct type
*tt1
, *tt2
;
1925 tt1
= check_typedef (t1
[i
]);
1926 tt2
= check_typedef (VALUE_TYPE (t2
[i
]));
1927 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1928 /* We should be doing hairy argument matching, as below. */
1929 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1931 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1932 t2
[i
] = value_coerce_array (t2
[i
]);
1934 t2
[i
] = value_addr (t2
[i
]);
1938 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1939 && (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
1940 || TYPE_CODE (tt2
) == TYPE_CODE_PTR
))
1942 tt1
= check_typedef (TYPE_TARGET_TYPE (tt1
));
1943 tt2
= check_typedef (TYPE_TARGET_TYPE (tt2
));
1945 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1947 /* Array to pointer is a `trivial conversion' according to the ARM. */
1949 /* We should be doing much hairier argument matching (see section 13.2
1950 of the ARM), but as a quick kludge, just check for the same type
1952 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1957 return t2
[i
] ? i
+ 1 : 0;
1960 /* Helper function used by value_struct_elt to recurse through baseclasses.
1961 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1962 and search in it assuming it has (class) type TYPE.
1963 If found, return value, else return NULL.
1965 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1966 look for a baseclass named NAME. */
1969 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1971 register value_ptr arg1
;
1973 register struct type
*type
;
1974 int looking_for_baseclass
;
1977 int nbases
= TYPE_N_BASECLASSES (type
);
1979 CHECK_TYPEDEF (type
);
1981 if (!looking_for_baseclass
)
1982 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1984 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1986 if (t_field_name
&& STREQ (t_field_name
, name
))
1989 if (TYPE_FIELD_STATIC (type
, i
))
1990 v
= value_static_field (type
, i
);
1992 v
= value_primitive_field (arg1
, offset
, i
, type
);
1994 error ("there is no field named %s", name
);
1999 && (t_field_name
[0] == '\0'
2000 || (TYPE_CODE (type
) == TYPE_CODE_UNION
2001 && STREQ (t_field_name
, "else"))))
2003 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
2004 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
2005 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
2007 /* Look for a match through the fields of an anonymous union,
2008 or anonymous struct. C++ provides anonymous unions.
2010 In the GNU Chill implementation of variant record types,
2011 each <alternative field> has an (anonymous) union type,
2012 each member of the union represents a <variant alternative>.
2013 Each <variant alternative> is represented as a struct,
2014 with a member for each <variant field>. */
2017 int new_offset
= offset
;
2019 /* This is pretty gross. In G++, the offset in an anonymous
2020 union is relative to the beginning of the enclosing struct.
2021 In the GNU Chill implementation of variant records,
2022 the bitpos is zero in an anonymous union field, so we
2023 have to add the offset of the union here. */
2024 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
2025 || (TYPE_NFIELDS (field_type
) > 0
2026 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2027 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2029 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
2030 looking_for_baseclass
);
2037 for (i
= 0; i
< nbases
; i
++)
2040 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2041 /* If we are looking for baseclasses, this is what we get when we
2042 hit them. But it could happen that the base part's member name
2043 is not yet filled in. */
2044 int found_baseclass
= (looking_for_baseclass
2045 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2046 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
2048 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2051 value_ptr v2
= allocate_value (basetype
);
2053 boffset
= baseclass_offset (type
, i
,
2054 VALUE_CONTENTS (arg1
) + offset
,
2055 VALUE_ADDRESS (arg1
)
2056 + VALUE_OFFSET (arg1
) + offset
);
2058 error ("virtual baseclass botch");
2060 /* The virtual base class pointer might have been clobbered by the
2061 user program. Make sure that it still points to a valid memory
2065 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
2067 CORE_ADDR base_addr
;
2069 base_addr
= VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
) + boffset
;
2070 if (target_read_memory (base_addr
, VALUE_CONTENTS_RAW (v2
),
2071 TYPE_LENGTH (basetype
)) != 0)
2072 error ("virtual baseclass botch");
2073 VALUE_LVAL (v2
) = lval_memory
;
2074 VALUE_ADDRESS (v2
) = base_addr
;
2078 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
2079 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
2080 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + boffset
;
2081 if (VALUE_LAZY (arg1
))
2082 VALUE_LAZY (v2
) = 1;
2084 memcpy (VALUE_CONTENTS_RAW (v2
),
2085 VALUE_CONTENTS_RAW (arg1
) + boffset
,
2086 TYPE_LENGTH (basetype
));
2089 if (found_baseclass
)
2091 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
2092 looking_for_baseclass
);
2094 else if (found_baseclass
)
2095 v
= value_primitive_field (arg1
, offset
, i
, type
);
2097 v
= search_struct_field (name
, arg1
,
2098 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2099 basetype
, looking_for_baseclass
);
2107 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2108 * in an object pointed to by VALADDR (on the host), assumed to be of
2109 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
2110 * looking (in case VALADDR is the contents of an enclosing object).
2112 * This routine recurses on the primary base of the derived class because
2113 * the virtual base entries of the primary base appear before the other
2114 * virtual base entries.
2116 * If the virtual base is not found, a negative integer is returned.
2117 * The magnitude of the negative integer is the number of entries in
2118 * the virtual table to skip over (entries corresponding to various
2119 * ancestral classes in the chain of primary bases).
2121 * Important: This assumes the HP / Taligent C++ runtime
2122 * conventions. Use baseclass_offset() instead to deal with g++
2126 find_rt_vbase_offset (type
, basetype
, valaddr
, offset
, boffset_p
, skip_p
)
2128 struct type
*basetype
;
2134 int boffset
; /* offset of virtual base */
2135 int index
; /* displacement to use in virtual table */
2139 CORE_ADDR vtbl
; /* the virtual table pointer */
2140 struct type
*pbc
; /* the primary base class */
2142 /* Look for the virtual base recursively in the primary base, first.
2143 * This is because the derived class object and its primary base
2144 * subobject share the primary virtual table. */
2147 pbc
= TYPE_PRIMARY_BASE (type
);
2150 find_rt_vbase_offset (pbc
, basetype
, valaddr
, offset
, &boffset
, &skip
);
2153 *boffset_p
= boffset
;
2162 /* Find the index of the virtual base according to HP/Taligent
2163 runtime spec. (Depth-first, left-to-right.) */
2164 index
= virtual_base_index_skip_primaries (basetype
, type
);
2168 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
2173 /* pai: FIXME -- 32x64 possible problem */
2174 /* First word (4 bytes) in object layout is the vtable pointer */
2175 vtbl
= *(CORE_ADDR
*) (valaddr
+ offset
);
2177 /* Before the constructor is invoked, things are usually zero'd out. */
2179 error ("Couldn't find virtual table -- object may not be constructed yet.");
2182 /* Find virtual base's offset -- jump over entries for primary base
2183 * ancestors, then use the index computed above. But also adjust by
2184 * HP_ACC_VBASE_START for the vtable slots before the start of the
2185 * virtual base entries. Offset is negative -- virtual base entries
2186 * appear _before_ the address point of the virtual table. */
2188 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2191 /* epstein : FIXME -- added param for overlay section. May not be correct */
2192 vp
= value_at (builtin_type_int
, vtbl
+ 4 * (-skip
- index
- HP_ACC_VBASE_START
), NULL
);
2193 boffset
= value_as_long (vp
);
2195 *boffset_p
= boffset
;
2200 /* Helper function used by value_struct_elt to recurse through baseclasses.
2201 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2202 and search in it assuming it has (class) type TYPE.
2203 If found, return value, else if name matched and args not return (value)-1,
2204 else return NULL. */
2207 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
2209 register value_ptr
*arg1p
, *args
;
2210 int offset
, *static_memfuncp
;
2211 register struct type
*type
;
2215 int name_matched
= 0;
2216 char dem_opname
[64];
2218 CHECK_TYPEDEF (type
);
2219 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2221 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2222 /* FIXME! May need to check for ARM demangling here */
2223 if (strncmp (t_field_name
, "__", 2) == 0 ||
2224 strncmp (t_field_name
, "op", 2) == 0 ||
2225 strncmp (t_field_name
, "type", 4) == 0)
2227 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2228 t_field_name
= dem_opname
;
2229 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2230 t_field_name
= dem_opname
;
2232 if (t_field_name
&& STREQ (t_field_name
, name
))
2234 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2235 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2238 if (j
> 0 && args
== 0)
2239 error ("cannot resolve overloaded method `%s': no arguments supplied", name
);
2242 if (TYPE_FN_FIELD_STUB (f
, j
))
2243 check_stub_method (type
, i
, j
);
2244 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2245 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2247 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2248 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
2249 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
2250 *static_memfuncp
= 1;
2251 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2260 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2264 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2266 if (TYPE_HAS_VTABLE (type
))
2268 /* HP aCC compiled type, search for virtual base offset
2269 according to HP/Taligent runtime spec. */
2271 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2272 VALUE_CONTENTS_ALL (*arg1p
),
2273 offset
+ VALUE_EMBEDDED_OFFSET (*arg1p
),
2274 &base_offset
, &skip
);
2276 error ("Virtual base class offset not found in vtable");
2280 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2283 /* The virtual base class pointer might have been clobbered by the
2284 user program. Make sure that it still points to a valid memory
2287 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2289 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
2290 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
2291 + VALUE_OFFSET (*arg1p
) + offset
,
2293 TYPE_LENGTH (baseclass
)) != 0)
2294 error ("virtual baseclass botch");
2297 base_valaddr
= VALUE_CONTENTS (*arg1p
) + offset
;
2300 baseclass_offset (type
, i
, base_valaddr
,
2301 VALUE_ADDRESS (*arg1p
)
2302 + VALUE_OFFSET (*arg1p
) + offset
);
2303 if (base_offset
== -1)
2304 error ("virtual baseclass botch");
2309 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2311 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2312 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2313 if (v
== (value_ptr
) - 1)
2319 /* FIXME-bothner: Why is this commented out? Why is it here? */
2320 /* *arg1p = arg1_tmp; */
2325 return (value_ptr
) - 1;
2330 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2331 extract the component named NAME from the ultimate target structure/union
2332 and return it as a value with its appropriate type.
2333 ERR is used in the error message if *ARGP's type is wrong.
2335 C++: ARGS is a list of argument types to aid in the selection of
2336 an appropriate method. Also, handle derived types.
2338 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2339 where the truthvalue of whether the function that was resolved was
2340 a static member function or not is stored.
2342 ERR is an error message to be printed in case the field is not found. */
2345 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
2346 register value_ptr
*argp
, *args
;
2348 int *static_memfuncp
;
2351 register struct type
*t
;
2354 COERCE_ARRAY (*argp
);
2356 t
= check_typedef (VALUE_TYPE (*argp
));
2358 /* Follow pointers until we get to a non-pointer. */
2360 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2362 *argp
= value_ind (*argp
);
2363 /* Don't coerce fn pointer to fn and then back again! */
2364 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2365 COERCE_ARRAY (*argp
);
2366 t
= check_typedef (VALUE_TYPE (*argp
));
2369 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2370 error ("not implemented: member type in value_struct_elt");
2372 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2373 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2374 error ("Attempt to extract a component of a value that is not a %s.", err
);
2376 /* Assume it's not, unless we see that it is. */
2377 if (static_memfuncp
)
2378 *static_memfuncp
= 0;
2382 /* if there are no arguments ...do this... */
2384 /* Try as a field first, because if we succeed, there
2385 is less work to be done. */
2386 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2390 /* C++: If it was not found as a data field, then try to
2391 return it as a pointer to a method. */
2393 if (destructor_name_p (name
, t
))
2394 error ("Cannot get value of destructor");
2396 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2398 if (v
== (value_ptr
) - 1)
2399 error ("Cannot take address of a method");
2402 if (TYPE_NFN_FIELDS (t
))
2403 error ("There is no member or method named %s.", name
);
2405 error ("There is no member named %s.", name
);
2410 if (destructor_name_p (name
, t
))
2414 /* Destructors are a special case. */
2415 int m_index
, f_index
;
2418 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2420 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, m_index
),
2424 error ("could not find destructor function named %s.", name
);
2430 error ("destructor should not have any argument");
2434 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2436 if (v
== (value_ptr
) - 1)
2438 error ("Argument list of %s mismatch with component in the structure.", name
);
2442 /* See if user tried to invoke data as function. If so,
2443 hand it back. If it's not callable (i.e., a pointer to function),
2444 gdb should give an error. */
2445 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2449 error ("Structure has no component named %s.", name
);
2453 /* Search through the methods of an object (and its bases)
2454 * to find a specified method. Return the pointer to the
2455 * fn_field list of overloaded instances.
2456 * Helper function for value_find_oload_list.
2457 * ARGP is a pointer to a pointer to a value (the object)
2458 * METHOD is a string containing the method name
2459 * OFFSET is the offset within the value
2460 * STATIC_MEMFUNCP is set if the method is static
2461 * TYPE is the assumed type of the object
2462 * NUM_FNS is the number of overloaded instances
2463 * BASETYPE is set to the actual type of the subobject where the method is found
2464 * BOFFSET is the offset of the base subobject where the method is found */
2466 static struct fn_field
*
2467 find_method_list (argp
, method
, offset
, static_memfuncp
, type
, num_fns
, basetype
, boffset
)
2471 int *static_memfuncp
;
2474 struct type
**basetype
;
2479 CHECK_TYPEDEF (type
);
2483 /* First check in object itself */
2484 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2486 /* pai: FIXME What about operators and type conversions? */
2487 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2488 if (fn_field_name
&& STREQ (fn_field_name
, method
))
2490 *num_fns
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2493 return TYPE_FN_FIELDLIST1 (type
, i
);
2497 /* Not found in object, check in base subobjects */
2498 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2501 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2503 if (TYPE_HAS_VTABLE (type
))
2505 /* HP aCC compiled type, search for virtual base offset
2506 * according to HP/Taligent runtime spec. */
2508 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2509 VALUE_CONTENTS_ALL (*argp
),
2510 offset
+ VALUE_EMBEDDED_OFFSET (*argp
),
2511 &base_offset
, &skip
);
2513 error ("Virtual base class offset not found in vtable");
2517 /* probably g++ runtime model */
2518 base_offset
= VALUE_OFFSET (*argp
) + offset
;
2520 baseclass_offset (type
, i
,
2521 VALUE_CONTENTS (*argp
) + base_offset
,
2522 VALUE_ADDRESS (*argp
) + base_offset
);
2523 if (base_offset
== -1)
2524 error ("virtual baseclass botch");
2528 /* non-virtual base, simply use bit position from debug info */
2530 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2532 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2533 static_memfuncp
, TYPE_BASECLASS (type
, i
), num_fns
, basetype
, boffset
);
2540 /* Return the list of overloaded methods of a specified name.
2541 * ARGP is a pointer to a pointer to a value (the object)
2542 * METHOD is the method name
2543 * OFFSET is the offset within the value contents
2544 * STATIC_MEMFUNCP is set if the method is static
2545 * NUM_FNS is the number of overloaded instances
2546 * BASETYPE is set to the type of the base subobject that defines the method
2547 * BOFFSET is the offset of the base subobject which defines the method */
2550 value_find_oload_method_list (argp
, method
, offset
, static_memfuncp
, num_fns
, basetype
, boffset
)
2554 int *static_memfuncp
;
2556 struct type
**basetype
;
2561 t
= check_typedef (VALUE_TYPE (*argp
));
2563 /* code snarfed from value_struct_elt */
2564 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2566 *argp
= value_ind (*argp
);
2567 /* Don't coerce fn pointer to fn and then back again! */
2568 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2569 COERCE_ARRAY (*argp
);
2570 t
= check_typedef (VALUE_TYPE (*argp
));
2573 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2574 error ("Not implemented: member type in value_find_oload_lis");
2576 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2577 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2578 error ("Attempt to extract a component of a value that is not a struct or union");
2580 /* Assume it's not static, unless we see that it is. */
2581 if (static_memfuncp
)
2582 *static_memfuncp
= 0;
2584 return find_method_list (argp
, method
, 0, static_memfuncp
, t
, num_fns
, basetype
, boffset
);
2588 /* Given an array of argument types (ARGTYPES) (which includes an
2589 entry for "this" in the case of C++ methods), the number of
2590 arguments NARGS, the NAME of a function whether it's a method or
2591 not (METHOD), and the degree of laxness (LAX) in conforming to
2592 overload resolution rules in ANSI C++, find the best function that
2593 matches on the argument types according to the overload resolution
2596 In the case of class methods, the parameter OBJ is an object value
2597 in which to search for overloaded methods.
2599 In the case of non-method functions, the parameter FSYM is a symbol
2600 corresponding to one of the overloaded functions.
2602 Return value is an integer: 0 -> good match, 10 -> debugger applied
2603 non-standard coercions, 100 -> incompatible.
2605 If a method is being searched for, VALP will hold the value.
2606 If a non-method is being searched for, SYMP will hold the symbol for it.
2608 If a method is being searched for, and it is a static method,
2609 then STATICP will point to a non-zero value.
2611 Note: This function does *not* check the value of
2612 overload_resolution. Caller must check it to see whether overload
2613 resolution is permitted.
2617 find_overload_match (arg_types
, nargs
, name
, method
, lax
, obj
, fsym
, valp
, symp
, staticp
)
2618 struct type
**arg_types
;
2624 struct symbol
*fsym
;
2626 struct symbol
**symp
;
2630 struct type
**parm_types
;
2631 int champ_nparms
= 0;
2633 short oload_champ
= -1; /* Index of best overloaded function */
2634 short oload_ambiguous
= 0; /* Current ambiguity state for overload resolution */
2635 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2636 short oload_ambig_champ
= -1; /* 2nd contender for best match */
2637 short oload_non_standard
= 0; /* did we have to use non-standard conversions? */
2638 short oload_incompatible
= 0; /* are args supplied incompatible with any function? */
2640 struct badness_vector
*bv
; /* A measure of how good an overloaded instance is */
2641 struct badness_vector
*oload_champ_bv
= NULL
; /* The measure for the current best match */
2643 value_ptr temp
= obj
;
2644 struct fn_field
*fns_ptr
= NULL
; /* For methods, the list of overloaded methods */
2645 struct symbol
**oload_syms
= NULL
; /* For non-methods, the list of overloaded function symbols */
2646 int num_fns
= 0; /* Number of overloaded instances being considered */
2647 struct type
*basetype
= NULL
;
2652 char *obj_type_name
= NULL
;
2653 char *func_name
= NULL
;
2655 /* Get the list of overloaded methods or functions */
2658 obj_type_name
= TYPE_NAME (VALUE_TYPE (obj
));
2659 /* Hack: evaluate_subexp_standard often passes in a pointer
2660 value rather than the object itself, so try again */
2661 if ((!obj_type_name
|| !*obj_type_name
) &&
2662 (TYPE_CODE (VALUE_TYPE (obj
)) == TYPE_CODE_PTR
))
2663 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj
)));
2665 fns_ptr
= value_find_oload_method_list (&temp
, name
, 0,
2668 &basetype
, &boffset
);
2669 if (!fns_ptr
|| !num_fns
)
2670 error ("Couldn't find method %s%s%s",
2672 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2678 func_name
= cplus_demangle (SYMBOL_NAME (fsym
), DMGL_NO_OPTS
);
2680 oload_syms
= make_symbol_overload_list (fsym
);
2681 while (oload_syms
[++i
])
2684 error ("Couldn't find function %s", func_name
);
2687 oload_champ_bv
= NULL
;
2689 /* Consider each candidate in turn */
2690 for (ix
= 0; ix
< num_fns
; ix
++)
2692 /* Number of parameters for current candidate */
2693 nparms
= method
? TYPE_NFIELDS (fns_ptr
[ix
].type
)
2694 : TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2696 /* Prepare array of parameter types */
2697 parm_types
= (struct type
**) xmalloc (nparms
* (sizeof (struct type
*)));
2698 for (jj
= 0; jj
< nparms
; jj
++)
2699 parm_types
[jj
] = method
? TYPE_FIELD_TYPE (fns_ptr
[ix
].type
, jj
)
2700 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]), jj
);
2702 /* Compare parameter types to supplied argument types */
2703 bv
= rank_function (parm_types
, nparms
, arg_types
, nargs
);
2705 if (!oload_champ_bv
)
2707 oload_champ_bv
= bv
;
2709 champ_nparms
= nparms
;
2712 /* See whether current candidate is better or worse than previous best */
2713 switch (compare_badness (bv
, oload_champ_bv
))
2716 oload_ambiguous
= 1; /* top two contenders are equally good */
2717 oload_ambig_champ
= ix
;
2720 oload_ambiguous
= 2; /* incomparable top contenders */
2721 oload_ambig_champ
= ix
;
2724 oload_champ_bv
= bv
; /* new champion, record details */
2725 oload_ambiguous
= 0;
2727 oload_ambig_champ
= -1;
2728 champ_nparms
= nparms
;
2737 printf ("Overloaded method instance %s, # of parms %d\n", fns_ptr
[ix
].physname
, nparms
);
2739 printf ("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]), nparms
);
2740 for (jj
= 0; jj
<= nargs
; jj
++)
2741 printf ("...Badness @ %d : %d\n", jj
, bv
->rank
[jj
]);
2742 printf ("Overload resolution champion is %d, ambiguous? %d\n", oload_champ
, oload_ambiguous
);
2744 } /* end loop over all candidates */
2746 if (oload_ambiguous
)
2749 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2751 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2754 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2758 /* Check how bad the best match is */
2759 for (ix
= 1; ix
<= nargs
; ix
++)
2761 switch (oload_champ_bv
->rank
[ix
])
2764 oload_non_standard
= 1; /* non-standard type conversions needed */
2767 oload_incompatible
= 1; /* truly mismatched types */
2771 if (oload_incompatible
)
2774 error ("Cannot resolve method %s%s%s to any overloaded instance",
2776 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2779 error ("Cannot resolve function %s to any overloaded instance",
2782 else if (oload_non_standard
)
2785 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2787 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2790 warning ("Using non-standard conversion to match function %s to supplied arguments",
2796 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2797 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2799 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2803 *symp
= oload_syms
[oload_champ
];
2807 return oload_incompatible
? 100 : (oload_non_standard
? 10 : 0);
2810 /* C++: return 1 is NAME is a legitimate name for the destructor
2811 of type TYPE. If TYPE does not have a destructor, or
2812 if NAME is inappropriate for TYPE, an error is signaled. */
2814 destructor_name_p (name
, type
)
2816 const struct type
*type
;
2818 /* destructors are a special case. */
2822 char *dname
= type_name_no_tag (type
);
2823 char *cp
= strchr (dname
, '<');
2826 /* Do not compare the template part for template classes. */
2828 len
= strlen (dname
);
2831 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
2832 error ("name of destructor must equal name of class");
2839 /* Helper function for check_field: Given TYPE, a structure/union,
2840 return 1 if the component named NAME from the ultimate
2841 target structure/union is defined, otherwise, return 0. */
2844 check_field_in (type
, name
)
2845 register struct type
*type
;
2850 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2852 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2853 if (t_field_name
&& STREQ (t_field_name
, name
))
2857 /* C++: If it was not found as a data field, then try to
2858 return it as a pointer to a method. */
2860 /* Destructors are a special case. */
2861 if (destructor_name_p (name
, type
))
2863 int m_index
, f_index
;
2865 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2868 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2870 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
2874 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2875 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2882 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2883 return 1 if the component named NAME from the ultimate
2884 target structure/union is defined, otherwise, return 0. */
2887 check_field (arg1
, name
)
2888 register value_ptr arg1
;
2891 register struct type
*t
;
2893 COERCE_ARRAY (arg1
);
2895 t
= VALUE_TYPE (arg1
);
2897 /* Follow pointers until we get to a non-pointer. */
2902 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
2904 t
= TYPE_TARGET_TYPE (t
);
2907 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2908 error ("not implemented: member type in check_field");
2910 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2911 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2912 error ("Internal error: `this' is not an aggregate");
2914 return check_field_in (t
, name
);
2917 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2918 return the address of this member as a "pointer to member"
2919 type. If INTYPE is non-null, then it will be the type
2920 of the member we are looking for. This will help us resolve
2921 "pointers to member functions". This function is used
2922 to resolve user expressions of the form "DOMAIN::NAME". */
2925 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
2926 struct type
*domain
, *curtype
, *intype
;
2930 register struct type
*t
= curtype
;
2934 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2935 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2936 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2938 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2940 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2942 if (t_field_name
&& STREQ (t_field_name
, name
))
2944 if (TYPE_FIELD_STATIC (t
, i
))
2946 v
= value_static_field (t
, i
);
2948 error ("Internal error: could not find static variable %s",
2952 if (TYPE_FIELD_PACKED (t
, i
))
2953 error ("pointers to bitfield members not allowed");
2955 return value_from_longest
2956 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
2958 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2962 /* C++: If it was not found as a data field, then try to
2963 return it as a pointer to a method. */
2965 /* Destructors are a special case. */
2966 if (destructor_name_p (name
, t
))
2968 error ("member pointers to destructors not implemented yet");
2971 /* Perform all necessary dereferencing. */
2972 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2973 intype
= TYPE_TARGET_TYPE (intype
);
2975 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2977 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2978 char dem_opname
[64];
2980 if (strncmp (t_field_name
, "__", 2) == 0 ||
2981 strncmp (t_field_name
, "op", 2) == 0 ||
2982 strncmp (t_field_name
, "type", 4) == 0)
2984 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2985 t_field_name
= dem_opname
;
2986 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2987 t_field_name
= dem_opname
;
2989 if (t_field_name
&& STREQ (t_field_name
, name
))
2991 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2992 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2994 if (intype
== 0 && j
> 1)
2995 error ("non-unique member `%s' requires type instantiation", name
);
2999 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
3002 error ("no member function matches that type instantiation");
3007 if (TYPE_FN_FIELD_STUB (f
, j
))
3008 check_stub_method (t
, i
, j
);
3009 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3011 return value_from_longest
3012 (lookup_reference_type
3013 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
3015 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
3019 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3020 0, VAR_NAMESPACE
, 0, NULL
);
3027 v
= read_var_value (s
, 0);
3029 VALUE_TYPE (v
) = lookup_reference_type
3030 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
3038 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3043 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3046 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3047 v
= value_struct_elt_for_reference (domain
,
3048 offset
+ base_offset
,
3049 TYPE_BASECLASS (t
, i
),
3059 /* Find the real run-time type of a value using RTTI.
3060 * V is a pointer to the value.
3061 * A pointer to the struct type entry of the run-time type
3063 * FULL is a flag that is set only if the value V includes
3064 * the entire contents of an object of the RTTI type.
3065 * TOP is the offset to the top of the enclosing object of
3066 * the real run-time type. This offset may be for the embedded
3067 * object, or for the enclosing object of V.
3068 * USING_ENC is the flag that distinguishes the two cases.
3069 * If it is 1, then the offset is for the enclosing object,
3070 * otherwise for the embedded object.
3072 * This currently works only for RTTI information generated
3073 * by the HP ANSI C++ compiler (aCC). g++ today (1997-06-10)
3074 * does not appear to support RTTI. This function returns a
3075 * NULL value for objects in the g++ runtime model. */
3078 value_rtti_type (v
, full
, top
, using_enc
)
3084 struct type
*known_type
;
3085 struct type
*rtti_type
;
3088 int using_enclosing
= 0;
3089 long top_offset
= 0;
3090 char rtti_type_name
[256];
3099 /* Get declared type */
3100 known_type
= VALUE_TYPE (v
);
3101 CHECK_TYPEDEF (known_type
);
3102 /* RTTI works only or class objects */
3103 if (TYPE_CODE (known_type
) != TYPE_CODE_CLASS
)
3106 /* If neither the declared type nor the enclosing type of the
3107 * value structure has a HP ANSI C++ style virtual table,
3108 * we can't do anything. */
3109 if (!TYPE_HAS_VTABLE (known_type
))
3111 known_type
= VALUE_ENCLOSING_TYPE (v
);
3112 CHECK_TYPEDEF (known_type
);
3113 if ((TYPE_CODE (known_type
) != TYPE_CODE_CLASS
) ||
3114 !TYPE_HAS_VTABLE (known_type
))
3115 return NULL
; /* No RTTI, or not HP-compiled types */
3116 CHECK_TYPEDEF (known_type
);
3117 using_enclosing
= 1;
3120 if (using_enclosing
&& using_enc
)
3123 /* First get the virtual table address */
3124 coreptr
= *(CORE_ADDR
*) ((VALUE_CONTENTS_ALL (v
))
3126 + (using_enclosing
? 0 : VALUE_EMBEDDED_OFFSET (v
)));
3128 return NULL
; /* return silently -- maybe called on gdb-generated value */
3130 /* Fetch the top offset of the object */
3131 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3132 vp
= value_at (builtin_type_int
,
3133 coreptr
+ 4 * HP_ACC_TOP_OFFSET_OFFSET
,
3134 VALUE_BFD_SECTION (v
));
3135 top_offset
= value_as_long (vp
);
3139 /* Fetch the typeinfo pointer */
3140 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3141 vp
= value_at (builtin_type_int
, coreptr
+ 4 * HP_ACC_TYPEINFO_OFFSET
, VALUE_BFD_SECTION (v
));
3142 /* Indirect through the typeinfo pointer and retrieve the pointer
3143 * to the string name */
3144 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3146 error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3147 vp
= value_at (builtin_type_int
, coreptr
+ 4, VALUE_BFD_SECTION (v
)); /* 4 -> offset of name field */
3148 /* FIXME possible 32x64 problem */
3150 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3152 read_memory_string (coreptr
, rtti_type_name
, 256);
3154 if (strlen (rtti_type_name
) == 0)
3155 error ("Retrieved null type name from typeinfo");
3157 /* search for type */
3158 rtti_type
= lookup_typename (rtti_type_name
, (struct block
*) 0, 1);
3161 error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name
);
3162 CHECK_TYPEDEF (rtti_type
);
3164 #if 0 /* debugging */
3165 printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type
), TYPE_TAG_NAME (rtti_type
), full
? *full
: -1);
3168 /* Check whether we have the entire object */
3169 if (full
/* Non-null pointer passed */
3172 /* Either we checked on the whole object in hand and found the
3173 top offset to be zero */
3174 (((top_offset
== 0) &&
3176 TYPE_LENGTH (known_type
) == TYPE_LENGTH (rtti_type
))
3178 /* Or we checked on the embedded object and top offset was the
3179 same as the embedded offset */
3180 ((top_offset
== VALUE_EMBEDDED_OFFSET (v
)) &&
3182 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v
)) == TYPE_LENGTH (rtti_type
))))
3189 /* Given a pointer value V, find the real (RTTI) type
3190 of the object it points to.
3191 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3192 and refer to the values computed for the object pointed to. */
3195 value_rtti_target_type (v
, full
, top
, using_enc
)
3203 target
= value_ind (v
);
3205 return value_rtti_type (target
, full
, top
, using_enc
);
3208 /* Given a value pointed to by ARGP, check its real run-time type, and
3209 if that is different from the enclosing type, create a new value
3210 using the real run-time type as the enclosing type (and of the same
3211 type as ARGP) and return it, with the embedded offset adjusted to
3212 be the correct offset to the enclosed object
3213 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3214 parameters, computed by value_rtti_type(). If these are available,
3215 they can be supplied and a second call to value_rtti_type() is avoided.
3216 (Pass RTYPE == NULL if they're not available */
3219 value_full_object (argp
, rtype
, xfull
, xtop
, xusing_enc
)
3227 struct type
*real_type
;
3238 using_enc
= xusing_enc
;
3241 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3243 /* If no RTTI data, or if object is already complete, do nothing */
3244 if (!real_type
|| real_type
== VALUE_ENCLOSING_TYPE (argp
))
3247 /* If we have the full object, but for some reason the enclosing
3248 type is wrong, set it *//* pai: FIXME -- sounds iffy */
3251 VALUE_ENCLOSING_TYPE (argp
) = real_type
;
3255 /* Check if object is in memory */
3256 if (VALUE_LVAL (argp
) != lval_memory
)
3258 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type
));
3263 /* All other cases -- retrieve the complete object */
3264 /* Go back by the computed top_offset from the beginning of the object,
3265 adjusting for the embedded offset of argp if that's what value_rtti_type
3266 used for its computation. */
3267 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
3268 (using_enc
? 0 : VALUE_EMBEDDED_OFFSET (argp
)),
3269 VALUE_BFD_SECTION (argp
));
3270 VALUE_TYPE (new_val
) = VALUE_TYPE (argp
);
3271 VALUE_EMBEDDED_OFFSET (new_val
) = using_enc
? top
+ VALUE_EMBEDDED_OFFSET (argp
) : top
;
3278 /* C++: return the value of the class instance variable, if one exists.
3279 Flag COMPLAIN signals an error if the request is made in an
3280 inappropriate context. */
3283 value_of_this (complain
)
3286 struct symbol
*func
, *sym
;
3289 static const char funny_this
[] = "this";
3292 if (selected_frame
== 0)
3295 error ("no frame selected");
3300 func
= get_frame_function (selected_frame
);
3304 error ("no `this' in nameless context");
3309 b
= SYMBOL_BLOCK_VALUE (func
);
3310 i
= BLOCK_NSYMS (b
);
3314 error ("no args, no `this'");
3319 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3320 symbol instead of the LOC_ARG one (if both exist). */
3321 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
3325 error ("current stack frame not in method");
3330 this = read_var_value (sym
, selected_frame
);
3331 if (this == 0 && complain
)
3332 error ("`this' argument at unknown address");
3336 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3337 long, starting at LOWBOUND. The result has the same lower bound as
3338 the original ARRAY. */
3341 value_slice (array
, lowbound
, length
)
3343 int lowbound
, length
;
3345 struct type
*slice_range_type
, *slice_type
, *range_type
;
3346 LONGEST lowerbound
, upperbound
, offset
;
3348 struct type
*array_type
;
3349 array_type
= check_typedef (VALUE_TYPE (array
));
3350 COERCE_VARYING_ARRAY (array
, array_type
);
3351 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3352 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3353 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3354 error ("cannot take slice of non-array");
3355 range_type
= TYPE_INDEX_TYPE (array_type
);
3356 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3357 error ("slice from bad array or bitstring");
3358 if (lowbound
< lowerbound
|| length
< 0
3359 || lowbound
+ length
- 1 > upperbound
3360 /* Chill allows zero-length strings but not arrays. */
3361 || (current_language
->la_language
== language_chill
3362 && length
== 0 && TYPE_CODE (array_type
) == TYPE_CODE_ARRAY
))
3363 error ("slice out of range");
3364 /* FIXME-type-allocation: need a way to free this type when we are
3366 slice_range_type
= create_range_type ((struct type
*) NULL
,
3367 TYPE_TARGET_TYPE (range_type
),
3368 lowbound
, lowbound
+ length
- 1);
3369 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3372 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
3373 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3374 slice
= value_zero (slice_type
, not_lval
);
3375 for (i
= 0; i
< length
; i
++)
3377 int element
= value_bit_index (array_type
,
3378 VALUE_CONTENTS (array
),
3381 error ("internal error accessing bitstring");
3382 else if (element
> 0)
3384 int j
= i
% TARGET_CHAR_BIT
;
3385 if (BITS_BIG_ENDIAN
)
3386 j
= TARGET_CHAR_BIT
- 1 - j
;
3387 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3390 /* We should set the address, bitssize, and bitspos, so the clice
3391 can be used on the LHS, but that may require extensions to
3392 value_assign. For now, just leave as a non_lval. FIXME. */
3396 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3398 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3399 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
3401 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3402 slice
= allocate_value (slice_type
);
3403 if (VALUE_LAZY (array
))
3404 VALUE_LAZY (slice
) = 1;
3406 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
3407 TYPE_LENGTH (slice_type
));
3408 if (VALUE_LVAL (array
) == lval_internalvar
)
3409 VALUE_LVAL (slice
) = lval_internalvar_component
;
3411 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
3412 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
3413 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
3418 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3419 value as a fixed-length array. */
3422 varying_to_slice (varray
)
3425 struct type
*vtype
= check_typedef (VALUE_TYPE (varray
));
3426 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
3427 VALUE_CONTENTS (varray
)
3428 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
3429 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
3432 /* Create a value for a FORTRAN complex number. Currently most of
3433 the time values are coerced to COMPLEX*16 (i.e. a complex number
3434 composed of 2 doubles. This really should be a smarter routine
3435 that figures out precision inteligently as opposed to assuming
3436 doubles. FIXME: fmb */
3439 value_literal_complex (arg1
, arg2
, type
)
3444 register value_ptr val
;
3445 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3447 val
= allocate_value (type
);
3448 arg1
= value_cast (real_type
, arg1
);
3449 arg2
= value_cast (real_type
, arg2
);
3451 memcpy (VALUE_CONTENTS_RAW (val
),
3452 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
3453 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
3454 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
3458 /* Cast a value into the appropriate complex data type. */
3461 cast_into_complex (type
, val
)
3463 register value_ptr val
;
3465 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3466 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
3468 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
3469 value_ptr re_val
= allocate_value (val_real_type
);
3470 value_ptr im_val
= allocate_value (val_real_type
);
3472 memcpy (VALUE_CONTENTS_RAW (re_val
),
3473 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
3474 memcpy (VALUE_CONTENTS_RAW (im_val
),
3475 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
3476 TYPE_LENGTH (val_real_type
));
3478 return value_literal_complex (re_val
, im_val
, type
);
3480 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
3481 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
3482 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
3484 error ("cannot cast non-number to complex");
3488 _initialize_valops ()
3492 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *) &auto_abandon
,
3493 "Set automatic abandonment of expressions upon failure.",
3499 (add_set_cmd ("overload-resolution", class_support
, var_boolean
, (char *) &overload_resolution
,
3500 "Set overload resolution in evaluating C++ functions.",
3503 overload_resolution
= 1;