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 /* Push onto the stack the specified value VALUE. */
1067 value_push (sp
, arg
)
1068 register CORE_ADDR sp
;
1071 register int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
1073 if (INNER_THAN (1, 2))
1075 /* stack grows downward */
1077 write_memory (sp
, VALUE_CONTENTS_ALL (arg
), len
);
1081 /* stack grows upward */
1082 write_memory (sp
, VALUE_CONTENTS_ALL (arg
), len
);
1089 #ifndef PUSH_ARGUMENTS
1090 #define PUSH_ARGUMENTS default_push_arguments
1094 default_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
1099 CORE_ADDR struct_addr
;
1101 /* ASSERT ( !struct_return); */
1103 for (i
= nargs
- 1; i
>= 0; i
--)
1104 sp
= value_push (sp
, args
[i
]);
1109 /* Perform the standard coercions that are specified
1110 for arguments to be passed to C functions.
1112 If PARAM_TYPE is non-NULL, it is the expected parameter type.
1113 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
1116 value_arg_coerce (arg
, param_type
, is_prototyped
)
1118 struct type
*param_type
;
1121 register struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1122 register struct type
*type
1123 = param_type
? check_typedef (param_type
) : arg_type
;
1125 switch (TYPE_CODE (type
))
1128 if (TYPE_CODE (arg_type
) != TYPE_CODE_REF
)
1130 arg
= value_addr (arg
);
1131 VALUE_TYPE (arg
) = param_type
;
1136 case TYPE_CODE_CHAR
:
1137 case TYPE_CODE_BOOL
:
1138 case TYPE_CODE_ENUM
:
1139 /* If we don't have a prototype, coerce to integer type if necessary. */
1142 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1143 type
= builtin_type_int
;
1145 /* Currently all target ABIs require at least the width of an integer
1146 type for an argument. We may have to conditionalize the following
1147 type coercion for future targets. */
1148 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1149 type
= builtin_type_int
;
1152 /* FIXME: We should always convert floats to doubles in the
1153 non-prototyped case. As many debugging formats include
1154 no information about prototyping, we have to live with
1155 COERCE_FLOAT_TO_DOUBLE for now. */
1156 if (!is_prototyped
&& COERCE_FLOAT_TO_DOUBLE
)
1158 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
1159 type
= builtin_type_double
;
1160 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin_type_double
))
1161 type
= builtin_type_long_double
;
1164 case TYPE_CODE_FUNC
:
1165 type
= lookup_pointer_type (type
);
1167 case TYPE_CODE_ARRAY
:
1168 if (current_language
->c_style_arrays
)
1169 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1171 case TYPE_CODE_UNDEF
:
1173 case TYPE_CODE_STRUCT
:
1174 case TYPE_CODE_UNION
:
1175 case TYPE_CODE_VOID
:
1177 case TYPE_CODE_RANGE
:
1178 case TYPE_CODE_STRING
:
1179 case TYPE_CODE_BITSTRING
:
1180 case TYPE_CODE_ERROR
:
1181 case TYPE_CODE_MEMBER
:
1182 case TYPE_CODE_METHOD
:
1183 case TYPE_CODE_COMPLEX
:
1188 return value_cast (type
, arg
);
1191 /* Determine a function's address and its return type from its value.
1192 Calls error() if the function is not valid for calling. */
1195 find_function_addr (function
, retval_type
)
1197 struct type
**retval_type
;
1199 register struct type
*ftype
= check_typedef (VALUE_TYPE (function
));
1200 register enum type_code code
= TYPE_CODE (ftype
);
1201 struct type
*value_type
;
1204 /* If it's a member function, just look at the function
1207 /* Determine address to call. */
1208 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
1210 funaddr
= VALUE_ADDRESS (function
);
1211 value_type
= TYPE_TARGET_TYPE (ftype
);
1213 else if (code
== TYPE_CODE_PTR
)
1215 funaddr
= value_as_pointer (function
);
1216 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1217 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1218 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1220 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1221 /* FIXME: This is a workaround for the unusual function
1222 pointer representation on the RS/6000, see comment
1223 in config/rs6000/tm-rs6000.h */
1224 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
1226 value_type
= TYPE_TARGET_TYPE (ftype
);
1229 value_type
= builtin_type_int
;
1231 else if (code
== TYPE_CODE_INT
)
1233 /* Handle the case of functions lacking debugging info.
1234 Their values are characters since their addresses are char */
1235 if (TYPE_LENGTH (ftype
) == 1)
1236 funaddr
= value_as_pointer (value_addr (function
));
1238 /* Handle integer used as address of a function. */
1239 funaddr
= (CORE_ADDR
) value_as_long (function
);
1241 value_type
= builtin_type_int
;
1244 error ("Invalid data type for function to be called.");
1246 *retval_type
= value_type
;
1250 /* All this stuff with a dummy frame may seem unnecessarily complicated
1251 (why not just save registers in GDB?). The purpose of pushing a dummy
1252 frame which looks just like a real frame is so that if you call a
1253 function and then hit a breakpoint (get a signal, etc), "backtrace"
1254 will look right. Whether the backtrace needs to actually show the
1255 stack at the time the inferior function was called is debatable, but
1256 it certainly needs to not display garbage. So if you are contemplating
1257 making dummy frames be different from normal frames, consider that. */
1259 /* Perform a function call in the inferior.
1260 ARGS is a vector of values of arguments (NARGS of them).
1261 FUNCTION is a value, the function to be called.
1262 Returns a value representing what the function returned.
1263 May fail to return, if a breakpoint or signal is hit
1264 during the execution of the function.
1266 ARGS is modified to contain coerced values. */
1268 static value_ptr hand_function_call
PARAMS ((value_ptr function
, int nargs
, value_ptr
* args
));
1270 hand_function_call (function
, nargs
, args
)
1275 register CORE_ADDR sp
;
1278 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1279 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1280 and remove any extra bytes which might exist because ULONGEST is
1281 bigger than REGISTER_SIZE.
1283 NOTE: This is pretty wierd, as the call dummy is actually a
1284 sequence of instructions. But CISC machines will have
1285 to pack the instructions into REGISTER_SIZE units (and
1286 so will RISC machines for which INSTRUCTION_SIZE is not
1289 NOTE: This is pretty stupid. CALL_DUMMY should be in strict
1290 target byte order. */
1292 static ULONGEST
*dummy
;
1296 struct type
*value_type
;
1297 unsigned char struct_return
;
1298 CORE_ADDR struct_addr
= 0;
1299 struct inferior_status
*inf_status
;
1300 struct cleanup
*old_chain
;
1302 int using_gcc
; /* Set to version of gcc in use, or zero if not gcc */
1304 struct type
*param_type
= NULL
;
1305 struct type
*ftype
= check_typedef (SYMBOL_TYPE (function
));
1307 dummy
= alloca (SIZEOF_CALL_DUMMY_WORDS
);
1308 sizeof_dummy1
= REGISTER_SIZE
* SIZEOF_CALL_DUMMY_WORDS
/ sizeof (ULONGEST
);
1309 dummy1
= alloca (sizeof_dummy1
);
1310 memcpy (dummy
, CALL_DUMMY_WORDS
, SIZEOF_CALL_DUMMY_WORDS
);
1312 if (!target_has_execution
)
1315 inf_status
= save_inferior_status (1);
1316 old_chain
= make_cleanup ((make_cleanup_func
) restore_inferior_status
,
1319 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1320 (and POP_FRAME for restoring them). (At least on most machines)
1321 they are saved on the stack in the inferior. */
1324 old_sp
= sp
= read_sp ();
1326 if (INNER_THAN (1, 2))
1328 /* Stack grows down */
1329 sp
-= sizeof_dummy1
;
1334 /* Stack grows up */
1336 sp
+= sizeof_dummy1
;
1339 funaddr
= find_function_addr (function
, &value_type
);
1340 CHECK_TYPEDEF (value_type
);
1343 struct block
*b
= block_for_pc (funaddr
);
1344 /* If compiled without -g, assume GCC 2. */
1345 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
1348 /* Are we returning a value using a structure return or a normal
1351 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1354 /* Create a call sequence customized for this function
1355 and the number of arguments for it. */
1356 for (i
= 0; i
< (int) (SIZEOF_CALL_DUMMY_WORDS
/ sizeof (dummy
[0])); i
++)
1357 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1359 (ULONGEST
) dummy
[i
]);
1361 #ifdef GDB_TARGET_IS_HPPA
1362 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1363 value_type
, using_gcc
);
1365 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1366 value_type
, using_gcc
);
1370 if (CALL_DUMMY_LOCATION
== ON_STACK
)
1372 write_memory (start_sp
, (char *) dummy1
, sizeof_dummy1
);
1375 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
)
1377 /* Convex Unix prohibits executing in the stack segment. */
1378 /* Hope there is empty room at the top of the text segment. */
1379 extern CORE_ADDR text_end
;
1380 static int checked
= 0;
1382 for (start_sp
= text_end
- sizeof_dummy1
; start_sp
< text_end
; ++start_sp
)
1383 if (read_memory_integer (start_sp
, 1) != 0)
1384 error ("text segment full -- no place to put call");
1387 real_pc
= text_end
- sizeof_dummy1
;
1388 write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1391 if (CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
1393 extern CORE_ADDR text_end
;
1397 errcode
= target_write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1399 error ("Cannot write text segment -- call_function failed");
1402 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
1408 sp
= old_sp
; /* It really is used, for some ifdef's... */
1411 if (nargs
< TYPE_NFIELDS (ftype
))
1412 error ("too few arguments in function call");
1414 for (i
= nargs
- 1; i
>= 0; i
--)
1416 /* If we're off the end of the known arguments, do the standard
1417 promotions. FIXME: if we had a prototype, this should only
1418 be allowed if ... were present. */
1419 if (i
>= TYPE_NFIELDS (ftype
))
1420 args
[i
] = value_arg_coerce (args
[i
], NULL
, 0);
1424 int is_prototyped
= TYPE_FLAGS (ftype
) & TYPE_FLAG_PROTOTYPED
;
1425 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1427 args
[i
] = value_arg_coerce (args
[i
], param_type
, is_prototyped
);
1430 /*elz: this code is to handle the case in which the function to be called
1431 has a pointer to function as parameter and the corresponding actual argument
1432 is the address of a function and not a pointer to function variable.
1433 In aCC compiled code, the calls through pointers to functions (in the body
1434 of the function called by hand) are made via $$dyncall_external which
1435 requires some registers setting, this is taken care of if we call
1436 via a function pointer variable, but not via a function address.
1437 In cc this is not a problem. */
1441 /* if this parameter is a pointer to function */
1442 if (TYPE_CODE (param_type
) == TYPE_CODE_PTR
)
1443 if (TYPE_CODE (param_type
->target_type
) == TYPE_CODE_FUNC
)
1444 /* elz: FIXME here should go the test about the compiler used
1445 to compile the target. We want to issue the error
1446 message only if the compiler used was HP's aCC.
1447 If we used HP's cc, then there is no problem and no need
1448 to return at this point */
1449 if (using_gcc
== 0) /* && compiler == aCC */
1450 /* go see if the actual parameter is a variable of type
1451 pointer to function or just a function */
1452 if (args
[i
]->lval
== not_lval
)
1455 if (find_pc_partial_function ((CORE_ADDR
) args
[i
]->aligner
.contents
[0], &arg_name
, NULL
, NULL
))
1457 You cannot use function <%s> as argument. \n\
1458 You must use a pointer to function type variable. Command ignored.", arg_name
);
1462 #if defined (REG_STRUCT_HAS_ADDR)
1464 /* This is a machine like the sparc, where we may need to pass a pointer
1465 to the structure, not the structure itself. */
1466 for (i
= nargs
- 1; i
>= 0; i
--)
1468 struct type
*arg_type
= check_typedef (VALUE_TYPE (args
[i
]));
1469 if ((TYPE_CODE (arg_type
) == TYPE_CODE_STRUCT
1470 || TYPE_CODE (arg_type
) == TYPE_CODE_UNION
1471 || TYPE_CODE (arg_type
) == TYPE_CODE_ARRAY
1472 || TYPE_CODE (arg_type
) == TYPE_CODE_STRING
1473 || TYPE_CODE (arg_type
) == TYPE_CODE_BITSTRING
1474 || TYPE_CODE (arg_type
) == TYPE_CODE_SET
1475 || (TYPE_CODE (arg_type
) == TYPE_CODE_FLT
1476 && TYPE_LENGTH (arg_type
) > 8)
1478 && REG_STRUCT_HAS_ADDR (using_gcc
, arg_type
))
1481 int len
; /* = TYPE_LENGTH (arg_type); */
1483 arg_type
= check_typedef (VALUE_ENCLOSING_TYPE (args
[i
]));
1484 len
= TYPE_LENGTH (arg_type
);
1487 /* MVS 11/22/96: I think at least some of this stack_align code is
1488 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1489 a target-defined manner. */
1490 aligned_len
= STACK_ALIGN (len
);
1494 if (INNER_THAN (1, 2))
1496 /* stack grows downward */
1501 /* The stack grows up, so the address of the thing we push
1502 is the stack pointer before we push it. */
1505 /* Push the structure. */
1506 write_memory (sp
, VALUE_CONTENTS_ALL (args
[i
]), len
);
1507 if (INNER_THAN (1, 2))
1509 /* The stack grows down, so the address of the thing we push
1510 is the stack pointer after we push it. */
1515 /* stack grows upward */
1518 /* The value we're going to pass is the address of the thing
1520 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1522 args
[i
] = value_from_longest (lookup_pointer_type (arg_type
),
1527 #endif /* REG_STRUCT_HAS_ADDR. */
1529 /* Reserve space for the return structure to be written on the
1530 stack, if necessary */
1534 int len
= TYPE_LENGTH (value_type
);
1536 /* MVS 11/22/96: I think at least some of this stack_align code is
1537 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1538 a target-defined manner. */
1539 len
= STACK_ALIGN (len
);
1541 if (INNER_THAN (1, 2))
1543 /* stack grows downward */
1549 /* stack grows upward */
1555 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1556 on other architectures. This is because all the alignment is taken care
1557 of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
1558 hppa_push_arguments */
1559 #ifndef NO_EXTRA_ALIGNMENT_NEEDED
1561 #if defined(STACK_ALIGN)
1562 /* MVS 11/22/96: I think at least some of this stack_align code is
1563 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1564 a target-defined manner. */
1565 if (INNER_THAN (1, 2))
1567 /* If stack grows down, we must leave a hole at the top. */
1570 for (i
= nargs
- 1; i
>= 0; i
--)
1571 len
+= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
1572 if (CALL_DUMMY_STACK_ADJUST_P
)
1573 len
+= CALL_DUMMY_STACK_ADJUST
;
1574 sp
-= STACK_ALIGN (len
) - len
;
1576 #endif /* STACK_ALIGN */
1577 #endif /* NO_EXTRA_ALIGNMENT_NEEDED */
1579 sp
= PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
);
1581 #ifdef PUSH_RETURN_ADDRESS /* for targets that use no CALL_DUMMY */
1582 /* There are a number of targets now which actually don't write any
1583 CALL_DUMMY instructions into the target, but instead just save the
1584 machine state, push the arguments, and jump directly to the callee
1585 function. Since this doesn't actually involve executing a JSR/BSR
1586 instruction, the return address must be set up by hand, either by
1587 pushing onto the stack or copying into a return-address register
1588 as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
1589 but that's overloading its functionality a bit, so I'm making it
1590 explicit to do it here. */
1591 sp
= PUSH_RETURN_ADDRESS (real_pc
, sp
);
1592 #endif /* PUSH_RETURN_ADDRESS */
1594 #if defined(STACK_ALIGN)
1595 if (!INNER_THAN (1, 2))
1597 /* If stack grows up, we must leave a hole at the bottom, note
1598 that sp already has been advanced for the arguments! */
1599 if (CALL_DUMMY_STACK_ADJUST_P
)
1600 sp
+= CALL_DUMMY_STACK_ADJUST
;
1601 sp
= STACK_ALIGN (sp
);
1603 #endif /* STACK_ALIGN */
1605 /* XXX This seems wrong. For stacks that grow down we shouldn't do
1607 /* MVS 11/22/96: I think at least some of this stack_align code is
1608 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1609 a target-defined manner. */
1610 if (CALL_DUMMY_STACK_ADJUST_P
)
1611 if (INNER_THAN (1, 2))
1613 /* stack grows downward */
1614 sp
-= CALL_DUMMY_STACK_ADJUST
;
1617 /* Store the address at which the structure is supposed to be
1618 written. Note that this (and the code which reserved the space
1619 above) assumes that gcc was used to compile this function. Since
1620 it doesn't cost us anything but space and if the function is pcc
1621 it will ignore this value, we will make that assumption.
1623 Also note that on some machines (like the sparc) pcc uses a
1624 convention like gcc's. */
1627 STORE_STRUCT_RETURN (struct_addr
, sp
);
1629 /* Write the stack pointer. This is here because the statements above
1630 might fool with it. On SPARC, this write also stores the register
1631 window into the right place in the new stack frame, which otherwise
1632 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1635 #ifdef SAVE_DUMMY_FRAME_TOS
1636 SAVE_DUMMY_FRAME_TOS (sp
);
1640 char retbuf
[REGISTER_BYTES
];
1642 struct symbol
*symbol
;
1645 symbol
= find_pc_function (funaddr
);
1648 name
= SYMBOL_SOURCE_NAME (symbol
);
1652 /* Try the minimal symbols. */
1653 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1657 name
= SYMBOL_SOURCE_NAME (msymbol
);
1663 sprintf (format
, "at %s", local_hex_format ());
1665 /* FIXME-32x64: assumes funaddr fits in a long. */
1666 sprintf (name
, format
, (unsigned long) funaddr
);
1669 /* Execute the stack dummy routine, calling FUNCTION.
1670 When it is done, discard the empty frame
1671 after storing the contents of all regs into retbuf. */
1672 if (run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
))
1674 /* We stopped somewhere besides the call dummy. */
1676 /* If we did the cleanups, we would print a spurious error
1677 message (Unable to restore previously selected frame),
1678 would write the registers from the inf_status (which is
1679 wrong), and would do other wrong things. */
1680 discard_cleanups (old_chain
);
1681 discard_inferior_status (inf_status
);
1683 /* The following error message used to say "The expression
1684 which contained the function call has been discarded." It
1685 is a hard concept to explain in a few words. Ideally, GDB
1686 would be able to resume evaluation of the expression when
1687 the function finally is done executing. Perhaps someday
1688 this will be implemented (it would not be easy). */
1690 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1691 a C++ name with arguments and stuff. */
1693 The program being debugged stopped while in a function called from GDB.\n\
1694 When the function (%s) is done executing, GDB will silently\n\
1695 stop (instead of continuing to evaluate the expression containing\n\
1696 the function call).", name
);
1699 do_cleanups (old_chain
);
1701 /* Figure out the value returned by the function. */
1702 /* elz: I defined this new macro for the hppa architecture only.
1703 this gives us a way to get the value returned by the function from the stack,
1704 at the same address we told the function to put it.
1705 We cannot assume on the pa that r28 still contains the address of the returned
1706 structure. Usually this will be overwritten by the callee.
1707 I don't know about other architectures, so I defined this macro
1710 #ifdef VALUE_RETURNED_FROM_STACK
1712 return (value_ptr
) VALUE_RETURNED_FROM_STACK (value_type
, struct_addr
);
1715 return value_being_returned (value_type
, retbuf
, struct_return
);
1720 call_function_by_hand (function
, nargs
, args
)
1727 return hand_function_call (function
, nargs
, args
);
1731 error ("Cannot invoke functions on this machine.");
1737 /* Create a value for an array by allocating space in the inferior, copying
1738 the data into that space, and then setting up an array value.
1740 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1741 populated from the values passed in ELEMVEC.
1743 The element type of the array is inherited from the type of the
1744 first element, and all elements must have the same size (though we
1745 don't currently enforce any restriction on their types). */
1748 value_array (lowbound
, highbound
, elemvec
)
1755 unsigned int typelength
;
1757 struct type
*rangetype
;
1758 struct type
*arraytype
;
1761 /* Validate that the bounds are reasonable and that each of the elements
1762 have the same size. */
1764 nelem
= highbound
- lowbound
+ 1;
1767 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1769 typelength
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[0]));
1770 for (idx
= 1; idx
< nelem
; idx
++)
1772 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[idx
])) != typelength
)
1774 error ("array elements must all be the same size");
1778 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1779 lowbound
, highbound
);
1780 arraytype
= create_array_type ((struct type
*) NULL
,
1781 VALUE_ENCLOSING_TYPE (elemvec
[0]), rangetype
);
1783 if (!current_language
->c_style_arrays
)
1785 val
= allocate_value (arraytype
);
1786 for (idx
= 0; idx
< nelem
; idx
++)
1788 memcpy (VALUE_CONTENTS_ALL_RAW (val
) + (idx
* typelength
),
1789 VALUE_CONTENTS_ALL (elemvec
[idx
]),
1792 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (elemvec
[0]);
1796 /* Allocate space to store the array in the inferior, and then initialize
1797 it by copying in each element. FIXME: Is it worth it to create a
1798 local buffer in which to collect each value and then write all the
1799 bytes in one operation? */
1801 addr
= allocate_space_in_inferior (nelem
* typelength
);
1802 for (idx
= 0; idx
< nelem
; idx
++)
1804 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS_ALL (elemvec
[idx
]),
1808 /* Create the array type and set up an array value to be evaluated lazily. */
1810 val
= value_at_lazy (arraytype
, addr
, VALUE_BFD_SECTION (elemvec
[0]));
1814 /* Create a value for a string constant by allocating space in the inferior,
1815 copying the data into that space, and returning the address with type
1816 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1818 Note that string types are like array of char types with a lower bound of
1819 zero and an upper bound of LEN - 1. Also note that the string may contain
1820 embedded null bytes. */
1823 value_string (ptr
, len
)
1828 int lowbound
= current_language
->string_lower_bound
;
1829 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1831 lowbound
, len
+ lowbound
- 1);
1832 struct type
*stringtype
1833 = create_string_type ((struct type
*) NULL
, rangetype
);
1836 if (current_language
->c_style_arrays
== 0)
1838 val
= allocate_value (stringtype
);
1839 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1844 /* Allocate space to store the string in the inferior, and then
1845 copy LEN bytes from PTR in gdb to that address in the inferior. */
1847 addr
= allocate_space_in_inferior (len
);
1848 write_memory (addr
, ptr
, len
);
1850 val
= value_at_lazy (stringtype
, addr
, NULL
);
1855 value_bitstring (ptr
, len
)
1860 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1862 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1863 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1864 val
= allocate_value (type
);
1865 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1869 /* See if we can pass arguments in T2 to a function which takes arguments
1870 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1871 arguments need coercion of some sort, then the coerced values are written
1872 into T2. Return value is 0 if the arguments could be matched, or the
1873 position at which they differ if not.
1875 STATICP is nonzero if the T1 argument list came from a
1876 static member function.
1878 For non-static member functions, we ignore the first argument,
1879 which is the type of the instance variable. This is because we want
1880 to handle calls with objects from derived classes. This is not
1881 entirely correct: we should actually check to make sure that a
1882 requested operation is type secure, shouldn't we? FIXME. */
1885 typecmp (staticp
, t1
, t2
)
1894 if (staticp
&& t1
== 0)
1898 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
)
1900 if (t1
[!staticp
] == 0)
1902 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1904 struct type
*tt1
, *tt2
;
1907 tt1
= check_typedef (t1
[i
]);
1908 tt2
= check_typedef (VALUE_TYPE (t2
[i
]));
1909 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1910 /* We should be doing hairy argument matching, as below. */
1911 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1913 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1914 t2
[i
] = value_coerce_array (t2
[i
]);
1916 t2
[i
] = value_addr (t2
[i
]);
1920 while (TYPE_CODE (tt1
) == TYPE_CODE_PTR
1921 && (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
1922 || TYPE_CODE (tt2
) == TYPE_CODE_PTR
))
1924 tt1
= check_typedef (TYPE_TARGET_TYPE (tt1
));
1925 tt2
= check_typedef (TYPE_TARGET_TYPE (tt2
));
1927 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1929 /* Array to pointer is a `trivial conversion' according to the ARM. */
1931 /* We should be doing much hairier argument matching (see section 13.2
1932 of the ARM), but as a quick kludge, just check for the same type
1934 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1939 return t2
[i
] ? i
+ 1 : 0;
1942 /* Helper function used by value_struct_elt to recurse through baseclasses.
1943 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1944 and search in it assuming it has (class) type TYPE.
1945 If found, return value, else return NULL.
1947 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1948 look for a baseclass named NAME. */
1951 search_struct_field (name
, arg1
, offset
, type
, looking_for_baseclass
)
1953 register value_ptr arg1
;
1955 register struct type
*type
;
1956 int looking_for_baseclass
;
1959 int nbases
= TYPE_N_BASECLASSES (type
);
1961 CHECK_TYPEDEF (type
);
1963 if (!looking_for_baseclass
)
1964 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1966 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1968 if (t_field_name
&& STREQ (t_field_name
, name
))
1971 if (TYPE_FIELD_STATIC (type
, i
))
1972 v
= value_static_field (type
, i
);
1974 v
= value_primitive_field (arg1
, offset
, i
, type
);
1976 error ("there is no field named %s", name
);
1981 && (t_field_name
[0] == '\0'
1982 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1983 && STREQ (t_field_name
, "else"))))
1985 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1986 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1987 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1989 /* Look for a match through the fields of an anonymous union,
1990 or anonymous struct. C++ provides anonymous unions.
1992 In the GNU Chill implementation of variant record types,
1993 each <alternative field> has an (anonymous) union type,
1994 each member of the union represents a <variant alternative>.
1995 Each <variant alternative> is represented as a struct,
1996 with a member for each <variant field>. */
1999 int new_offset
= offset
;
2001 /* This is pretty gross. In G++, the offset in an anonymous
2002 union is relative to the beginning of the enclosing struct.
2003 In the GNU Chill implementation of variant records,
2004 the bitpos is zero in an anonymous union field, so we
2005 have to add the offset of the union here. */
2006 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
2007 || (TYPE_NFIELDS (field_type
) > 0
2008 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2009 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2011 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
2012 looking_for_baseclass
);
2019 for (i
= 0; i
< nbases
; i
++)
2022 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2023 /* If we are looking for baseclasses, this is what we get when we
2024 hit them. But it could happen that the base part's member name
2025 is not yet filled in. */
2026 int found_baseclass
= (looking_for_baseclass
2027 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2028 && STREQ (name
, TYPE_BASECLASS_NAME (type
, i
)));
2030 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2033 value_ptr v2
= allocate_value (basetype
);
2035 boffset
= baseclass_offset (type
, i
,
2036 VALUE_CONTENTS (arg1
) + offset
,
2037 VALUE_ADDRESS (arg1
)
2038 + VALUE_OFFSET (arg1
) + offset
);
2040 error ("virtual baseclass botch");
2042 /* The virtual base class pointer might have been clobbered by the
2043 user program. Make sure that it still points to a valid memory
2047 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
2049 CORE_ADDR base_addr
;
2051 base_addr
= VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
) + boffset
;
2052 if (target_read_memory (base_addr
, VALUE_CONTENTS_RAW (v2
),
2053 TYPE_LENGTH (basetype
)) != 0)
2054 error ("virtual baseclass botch");
2055 VALUE_LVAL (v2
) = lval_memory
;
2056 VALUE_ADDRESS (v2
) = base_addr
;
2060 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
2061 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
2062 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + boffset
;
2063 if (VALUE_LAZY (arg1
))
2064 VALUE_LAZY (v2
) = 1;
2066 memcpy (VALUE_CONTENTS_RAW (v2
),
2067 VALUE_CONTENTS_RAW (arg1
) + boffset
,
2068 TYPE_LENGTH (basetype
));
2071 if (found_baseclass
)
2073 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
2074 looking_for_baseclass
);
2076 else if (found_baseclass
)
2077 v
= value_primitive_field (arg1
, offset
, i
, type
);
2079 v
= search_struct_field (name
, arg1
,
2080 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2081 basetype
, looking_for_baseclass
);
2089 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2090 * in an object pointed to by VALADDR (on the host), assumed to be of
2091 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
2092 * looking (in case VALADDR is the contents of an enclosing object).
2094 * This routine recurses on the primary base of the derived class because
2095 * the virtual base entries of the primary base appear before the other
2096 * virtual base entries.
2098 * If the virtual base is not found, a negative integer is returned.
2099 * The magnitude of the negative integer is the number of entries in
2100 * the virtual table to skip over (entries corresponding to various
2101 * ancestral classes in the chain of primary bases).
2103 * Important: This assumes the HP / Taligent C++ runtime
2104 * conventions. Use baseclass_offset() instead to deal with g++
2108 find_rt_vbase_offset (type
, basetype
, valaddr
, offset
, boffset_p
, skip_p
)
2110 struct type
*basetype
;
2116 int boffset
; /* offset of virtual base */
2117 int index
; /* displacement to use in virtual table */
2121 CORE_ADDR vtbl
; /* the virtual table pointer */
2122 struct type
*pbc
; /* the primary base class */
2124 /* Look for the virtual base recursively in the primary base, first.
2125 * This is because the derived class object and its primary base
2126 * subobject share the primary virtual table. */
2129 pbc
= TYPE_PRIMARY_BASE (type
);
2132 find_rt_vbase_offset (pbc
, basetype
, valaddr
, offset
, &boffset
, &skip
);
2135 *boffset_p
= boffset
;
2144 /* Find the index of the virtual base according to HP/Taligent
2145 runtime spec. (Depth-first, left-to-right.) */
2146 index
= virtual_base_index_skip_primaries (basetype
, type
);
2150 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
2155 /* pai: FIXME -- 32x64 possible problem */
2156 /* First word (4 bytes) in object layout is the vtable pointer */
2157 vtbl
= *(CORE_ADDR
*) (valaddr
+ offset
);
2159 /* Before the constructor is invoked, things are usually zero'd out. */
2161 error ("Couldn't find virtual table -- object may not be constructed yet.");
2164 /* Find virtual base's offset -- jump over entries for primary base
2165 * ancestors, then use the index computed above. But also adjust by
2166 * HP_ACC_VBASE_START for the vtable slots before the start of the
2167 * virtual base entries. Offset is negative -- virtual base entries
2168 * appear _before_ the address point of the virtual table. */
2170 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2173 /* epstein : FIXME -- added param for overlay section. May not be correct */
2174 vp
= value_at (builtin_type_int
, vtbl
+ 4 * (-skip
- index
- HP_ACC_VBASE_START
), NULL
);
2175 boffset
= value_as_long (vp
);
2177 *boffset_p
= boffset
;
2182 /* Helper function used by value_struct_elt to recurse through baseclasses.
2183 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2184 and search in it assuming it has (class) type TYPE.
2185 If found, return value, else if name matched and args not return (value)-1,
2186 else return NULL. */
2189 search_struct_method (name
, arg1p
, args
, offset
, static_memfuncp
, type
)
2191 register value_ptr
*arg1p
, *args
;
2192 int offset
, *static_memfuncp
;
2193 register struct type
*type
;
2197 int name_matched
= 0;
2198 char dem_opname
[64];
2200 CHECK_TYPEDEF (type
);
2201 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2203 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2204 /* FIXME! May need to check for ARM demangling here */
2205 if (strncmp (t_field_name
, "__", 2) == 0 ||
2206 strncmp (t_field_name
, "op", 2) == 0 ||
2207 strncmp (t_field_name
, "type", 4) == 0)
2209 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2210 t_field_name
= dem_opname
;
2211 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2212 t_field_name
= dem_opname
;
2214 if (t_field_name
&& STREQ (t_field_name
, name
))
2216 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2217 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2220 if (j
> 0 && args
== 0)
2221 error ("cannot resolve overloaded method `%s': no arguments supplied", name
);
2224 if (TYPE_FN_FIELD_STUB (f
, j
))
2225 check_stub_method (type
, i
, j
);
2226 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2227 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2229 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2230 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
2231 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
2232 *static_memfuncp
= 1;
2233 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2242 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2246 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2248 if (TYPE_HAS_VTABLE (type
))
2250 /* HP aCC compiled type, search for virtual base offset
2251 according to HP/Taligent runtime spec. */
2253 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2254 VALUE_CONTENTS_ALL (*arg1p
),
2255 offset
+ VALUE_EMBEDDED_OFFSET (*arg1p
),
2256 &base_offset
, &skip
);
2258 error ("Virtual base class offset not found in vtable");
2262 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2265 /* The virtual base class pointer might have been clobbered by the
2266 user program. Make sure that it still points to a valid memory
2269 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2271 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
2272 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
2273 + VALUE_OFFSET (*arg1p
) + offset
,
2275 TYPE_LENGTH (baseclass
)) != 0)
2276 error ("virtual baseclass botch");
2279 base_valaddr
= VALUE_CONTENTS (*arg1p
) + offset
;
2282 baseclass_offset (type
, i
, base_valaddr
,
2283 VALUE_ADDRESS (*arg1p
)
2284 + VALUE_OFFSET (*arg1p
) + offset
);
2285 if (base_offset
== -1)
2286 error ("virtual baseclass botch");
2291 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2293 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2294 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2295 if (v
== (value_ptr
) - 1)
2301 /* FIXME-bothner: Why is this commented out? Why is it here? */
2302 /* *arg1p = arg1_tmp; */
2307 return (value_ptr
) - 1;
2312 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2313 extract the component named NAME from the ultimate target structure/union
2314 and return it as a value with its appropriate type.
2315 ERR is used in the error message if *ARGP's type is wrong.
2317 C++: ARGS is a list of argument types to aid in the selection of
2318 an appropriate method. Also, handle derived types.
2320 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2321 where the truthvalue of whether the function that was resolved was
2322 a static member function or not is stored.
2324 ERR is an error message to be printed in case the field is not found. */
2327 value_struct_elt (argp
, args
, name
, static_memfuncp
, err
)
2328 register value_ptr
*argp
, *args
;
2330 int *static_memfuncp
;
2333 register struct type
*t
;
2336 COERCE_ARRAY (*argp
);
2338 t
= check_typedef (VALUE_TYPE (*argp
));
2340 /* Follow pointers until we get to a non-pointer. */
2342 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2344 *argp
= value_ind (*argp
);
2345 /* Don't coerce fn pointer to fn and then back again! */
2346 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2347 COERCE_ARRAY (*argp
);
2348 t
= check_typedef (VALUE_TYPE (*argp
));
2351 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2352 error ("not implemented: member type in value_struct_elt");
2354 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2355 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2356 error ("Attempt to extract a component of a value that is not a %s.", err
);
2358 /* Assume it's not, unless we see that it is. */
2359 if (static_memfuncp
)
2360 *static_memfuncp
= 0;
2364 /* if there are no arguments ...do this... */
2366 /* Try as a field first, because if we succeed, there
2367 is less work to be done. */
2368 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2372 /* C++: If it was not found as a data field, then try to
2373 return it as a pointer to a method. */
2375 if (destructor_name_p (name
, t
))
2376 error ("Cannot get value of destructor");
2378 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2380 if (v
== (value_ptr
) - 1)
2381 error ("Cannot take address of a method");
2384 if (TYPE_NFN_FIELDS (t
))
2385 error ("There is no member or method named %s.", name
);
2387 error ("There is no member named %s.", name
);
2392 if (destructor_name_p (name
, t
))
2396 /* Destructors are a special case. */
2397 int m_index
, f_index
;
2400 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2402 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, m_index
),
2406 error ("could not find destructor function named %s.", name
);
2412 error ("destructor should not have any argument");
2416 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2418 if (v
== (value_ptr
) - 1)
2420 error ("Argument list of %s mismatch with component in the structure.", name
);
2424 /* See if user tried to invoke data as function. If so,
2425 hand it back. If it's not callable (i.e., a pointer to function),
2426 gdb should give an error. */
2427 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2431 error ("Structure has no component named %s.", name
);
2435 /* Search through the methods of an object (and its bases)
2436 * to find a specified method. Return the pointer to the
2437 * fn_field list of overloaded instances.
2438 * Helper function for value_find_oload_list.
2439 * ARGP is a pointer to a pointer to a value (the object)
2440 * METHOD is a string containing the method name
2441 * OFFSET is the offset within the value
2442 * STATIC_MEMFUNCP is set if the method is static
2443 * TYPE is the assumed type of the object
2444 * NUM_FNS is the number of overloaded instances
2445 * BASETYPE is set to the actual type of the subobject where the method is found
2446 * BOFFSET is the offset of the base subobject where the method is found */
2448 static struct fn_field
*
2449 find_method_list (argp
, method
, offset
, static_memfuncp
, type
, num_fns
, basetype
, boffset
)
2453 int *static_memfuncp
;
2456 struct type
**basetype
;
2461 CHECK_TYPEDEF (type
);
2465 /* First check in object itself */
2466 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2468 /* pai: FIXME What about operators and type conversions? */
2469 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2470 if (fn_field_name
&& STREQ (fn_field_name
, method
))
2472 *num_fns
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2475 return TYPE_FN_FIELDLIST1 (type
, i
);
2479 /* Not found in object, check in base subobjects */
2480 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2483 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2485 if (TYPE_HAS_VTABLE (type
))
2487 /* HP aCC compiled type, search for virtual base offset
2488 * according to HP/Taligent runtime spec. */
2490 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2491 VALUE_CONTENTS_ALL (*argp
),
2492 offset
+ VALUE_EMBEDDED_OFFSET (*argp
),
2493 &base_offset
, &skip
);
2495 error ("Virtual base class offset not found in vtable");
2499 /* probably g++ runtime model */
2500 base_offset
= VALUE_OFFSET (*argp
) + offset
;
2502 baseclass_offset (type
, i
,
2503 VALUE_CONTENTS (*argp
) + base_offset
,
2504 VALUE_ADDRESS (*argp
) + base_offset
);
2505 if (base_offset
== -1)
2506 error ("virtual baseclass botch");
2510 /* non-virtual base, simply use bit position from debug info */
2512 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2514 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2515 static_memfuncp
, TYPE_BASECLASS (type
, i
), num_fns
, basetype
, boffset
);
2522 /* Return the list of overloaded methods of a specified name.
2523 * ARGP is a pointer to a pointer to a value (the object)
2524 * METHOD is the method name
2525 * OFFSET is the offset within the value contents
2526 * STATIC_MEMFUNCP is set if the method is static
2527 * NUM_FNS is the number of overloaded instances
2528 * BASETYPE is set to the type of the base subobject that defines the method
2529 * BOFFSET is the offset of the base subobject which defines the method */
2532 value_find_oload_method_list (argp
, method
, offset
, static_memfuncp
, num_fns
, basetype
, boffset
)
2536 int *static_memfuncp
;
2538 struct type
**basetype
;
2543 t
= check_typedef (VALUE_TYPE (*argp
));
2545 /* code snarfed from value_struct_elt */
2546 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2548 *argp
= value_ind (*argp
);
2549 /* Don't coerce fn pointer to fn and then back again! */
2550 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2551 COERCE_ARRAY (*argp
);
2552 t
= check_typedef (VALUE_TYPE (*argp
));
2555 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2556 error ("Not implemented: member type in value_find_oload_lis");
2558 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2559 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2560 error ("Attempt to extract a component of a value that is not a struct or union");
2562 /* Assume it's not static, unless we see that it is. */
2563 if (static_memfuncp
)
2564 *static_memfuncp
= 0;
2566 return find_method_list (argp
, method
, 0, static_memfuncp
, t
, num_fns
, basetype
, boffset
);
2570 /* Given an array of argument types (ARGTYPES) (which includes an
2571 entry for "this" in the case of C++ methods), the number of
2572 arguments NARGS, the NAME of a function whether it's a method or
2573 not (METHOD), and the degree of laxness (LAX) in conforming to
2574 overload resolution rules in ANSI C++, find the best function that
2575 matches on the argument types according to the overload resolution
2578 In the case of class methods, the parameter OBJ is an object value
2579 in which to search for overloaded methods.
2581 In the case of non-method functions, the parameter FSYM is a symbol
2582 corresponding to one of the overloaded functions.
2584 Return value is an integer: 0 -> good match, 10 -> debugger applied
2585 non-standard coercions, 100 -> incompatible.
2587 If a method is being searched for, VALP will hold the value.
2588 If a non-method is being searched for, SYMP will hold the symbol for it.
2590 If a method is being searched for, and it is a static method,
2591 then STATICP will point to a non-zero value.
2593 Note: This function does *not* check the value of
2594 overload_resolution. Caller must check it to see whether overload
2595 resolution is permitted.
2599 find_overload_match (arg_types
, nargs
, name
, method
, lax
, obj
, fsym
, valp
, symp
, staticp
)
2600 struct type
**arg_types
;
2606 struct symbol
*fsym
;
2608 struct symbol
**symp
;
2612 struct type
**parm_types
;
2613 int champ_nparms
= 0;
2615 short oload_champ
= -1; /* Index of best overloaded function */
2616 short oload_ambiguous
= 0; /* Current ambiguity state for overload resolution */
2617 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2618 short oload_ambig_champ
= -1; /* 2nd contender for best match */
2619 short oload_non_standard
= 0; /* did we have to use non-standard conversions? */
2620 short oload_incompatible
= 0; /* are args supplied incompatible with any function? */
2622 struct badness_vector
*bv
; /* A measure of how good an overloaded instance is */
2623 struct badness_vector
*oload_champ_bv
= NULL
; /* The measure for the current best match */
2625 value_ptr temp
= obj
;
2626 struct fn_field
*fns_ptr
= NULL
; /* For methods, the list of overloaded methods */
2627 struct symbol
**oload_syms
= NULL
; /* For non-methods, the list of overloaded function symbols */
2628 int num_fns
= 0; /* Number of overloaded instances being considered */
2629 struct type
*basetype
= NULL
;
2634 char *obj_type_name
= NULL
;
2635 char *func_name
= NULL
;
2637 /* Get the list of overloaded methods or functions */
2640 obj_type_name
= TYPE_NAME (VALUE_TYPE (obj
));
2641 /* Hack: evaluate_subexp_standard often passes in a pointer
2642 value rather than the object itself, so try again */
2643 if ((!obj_type_name
|| !*obj_type_name
) &&
2644 (TYPE_CODE (VALUE_TYPE (obj
)) == TYPE_CODE_PTR
))
2645 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj
)));
2647 fns_ptr
= value_find_oload_method_list (&temp
, name
, 0,
2650 &basetype
, &boffset
);
2651 if (!fns_ptr
|| !num_fns
)
2652 error ("Couldn't find method %s%s%s",
2654 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2660 func_name
= cplus_demangle (SYMBOL_NAME (fsym
), DMGL_NO_OPTS
);
2662 oload_syms
= make_symbol_overload_list (fsym
);
2663 while (oload_syms
[++i
])
2666 error ("Couldn't find function %s", func_name
);
2669 oload_champ_bv
= NULL
;
2671 /* Consider each candidate in turn */
2672 for (ix
= 0; ix
< num_fns
; ix
++)
2674 /* Number of parameters for current candidate */
2675 nparms
= method
? TYPE_NFIELDS (fns_ptr
[ix
].type
)
2676 : TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2678 /* Prepare array of parameter types */
2679 parm_types
= (struct type
**) xmalloc (nparms
* (sizeof (struct type
*)));
2680 for (jj
= 0; jj
< nparms
; jj
++)
2681 parm_types
[jj
] = method
? TYPE_FIELD_TYPE (fns_ptr
[ix
].type
, jj
)
2682 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]), jj
);
2684 /* Compare parameter types to supplied argument types */
2685 bv
= rank_function (parm_types
, nparms
, arg_types
, nargs
);
2687 if (!oload_champ_bv
)
2689 oload_champ_bv
= bv
;
2691 champ_nparms
= nparms
;
2694 /* See whether current candidate is better or worse than previous best */
2695 switch (compare_badness (bv
, oload_champ_bv
))
2698 oload_ambiguous
= 1; /* top two contenders are equally good */
2699 oload_ambig_champ
= ix
;
2702 oload_ambiguous
= 2; /* incomparable top contenders */
2703 oload_ambig_champ
= ix
;
2706 oload_champ_bv
= bv
; /* new champion, record details */
2707 oload_ambiguous
= 0;
2709 oload_ambig_champ
= -1;
2710 champ_nparms
= nparms
;
2719 printf ("Overloaded method instance %s, # of parms %d\n", fns_ptr
[ix
].physname
, nparms
);
2721 printf ("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]), nparms
);
2722 for (jj
= 0; jj
<= nargs
; jj
++)
2723 printf ("...Badness @ %d : %d\n", jj
, bv
->rank
[jj
]);
2724 printf ("Overload resolution champion is %d, ambiguous? %d\n", oload_champ
, oload_ambiguous
);
2726 } /* end loop over all candidates */
2728 if (oload_ambiguous
)
2731 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2733 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2736 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2740 /* Check how bad the best match is */
2741 for (ix
= 1; ix
<= nargs
; ix
++)
2743 switch (oload_champ_bv
->rank
[ix
])
2746 oload_non_standard
= 1; /* non-standard type conversions needed */
2749 oload_incompatible
= 1; /* truly mismatched types */
2753 if (oload_incompatible
)
2756 error ("Cannot resolve method %s%s%s to any overloaded instance",
2758 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2761 error ("Cannot resolve function %s to any overloaded instance",
2764 else if (oload_non_standard
)
2767 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2769 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2772 warning ("Using non-standard conversion to match function %s to supplied arguments",
2778 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2779 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2781 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2785 *symp
= oload_syms
[oload_champ
];
2789 return oload_incompatible
? 100 : (oload_non_standard
? 10 : 0);
2792 /* C++: return 1 is NAME is a legitimate name for the destructor
2793 of type TYPE. If TYPE does not have a destructor, or
2794 if NAME is inappropriate for TYPE, an error is signaled. */
2796 destructor_name_p (name
, type
)
2798 const struct type
*type
;
2800 /* destructors are a special case. */
2804 char *dname
= type_name_no_tag (type
);
2805 char *cp
= strchr (dname
, '<');
2808 /* Do not compare the template part for template classes. */
2810 len
= strlen (dname
);
2813 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
2814 error ("name of destructor must equal name of class");
2821 /* Helper function for check_field: Given TYPE, a structure/union,
2822 return 1 if the component named NAME from the ultimate
2823 target structure/union is defined, otherwise, return 0. */
2826 check_field_in (type
, name
)
2827 register struct type
*type
;
2832 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2834 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2835 if (t_field_name
&& STREQ (t_field_name
, name
))
2839 /* C++: If it was not found as a data field, then try to
2840 return it as a pointer to a method. */
2842 /* Destructors are a special case. */
2843 if (destructor_name_p (name
, type
))
2845 int m_index
, f_index
;
2847 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2850 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2852 if (STREQ (TYPE_FN_FIELDLIST_NAME (type
, i
), name
))
2856 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2857 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2864 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2865 return 1 if the component named NAME from the ultimate
2866 target structure/union is defined, otherwise, return 0. */
2869 check_field (arg1
, name
)
2870 register value_ptr arg1
;
2873 register struct type
*t
;
2875 COERCE_ARRAY (arg1
);
2877 t
= VALUE_TYPE (arg1
);
2879 /* Follow pointers until we get to a non-pointer. */
2884 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
2886 t
= TYPE_TARGET_TYPE (t
);
2889 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2890 error ("not implemented: member type in check_field");
2892 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2893 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2894 error ("Internal error: `this' is not an aggregate");
2896 return check_field_in (t
, name
);
2899 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2900 return the address of this member as a "pointer to member"
2901 type. If INTYPE is non-null, then it will be the type
2902 of the member we are looking for. This will help us resolve
2903 "pointers to member functions". This function is used
2904 to resolve user expressions of the form "DOMAIN::NAME". */
2907 value_struct_elt_for_reference (domain
, offset
, curtype
, name
, intype
)
2908 struct type
*domain
, *curtype
, *intype
;
2912 register struct type
*t
= curtype
;
2916 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2917 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2918 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2920 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2922 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2924 if (t_field_name
&& STREQ (t_field_name
, name
))
2926 if (TYPE_FIELD_STATIC (t
, i
))
2928 v
= value_static_field (t
, i
);
2930 error ("Internal error: could not find static variable %s",
2934 if (TYPE_FIELD_PACKED (t
, i
))
2935 error ("pointers to bitfield members not allowed");
2937 return value_from_longest
2938 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
2940 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2944 /* C++: If it was not found as a data field, then try to
2945 return it as a pointer to a method. */
2947 /* Destructors are a special case. */
2948 if (destructor_name_p (name
, t
))
2950 error ("member pointers to destructors not implemented yet");
2953 /* Perform all necessary dereferencing. */
2954 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2955 intype
= TYPE_TARGET_TYPE (intype
);
2957 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2959 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2960 char dem_opname
[64];
2962 if (strncmp (t_field_name
, "__", 2) == 0 ||
2963 strncmp (t_field_name
, "op", 2) == 0 ||
2964 strncmp (t_field_name
, "type", 4) == 0)
2966 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2967 t_field_name
= dem_opname
;
2968 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2969 t_field_name
= dem_opname
;
2971 if (t_field_name
&& STREQ (t_field_name
, name
))
2973 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2974 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2976 if (intype
== 0 && j
> 1)
2977 error ("non-unique member `%s' requires type instantiation", name
);
2981 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2984 error ("no member function matches that type instantiation");
2989 if (TYPE_FN_FIELD_STUB (f
, j
))
2990 check_stub_method (t
, i
, j
);
2991 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2993 return value_from_longest
2994 (lookup_reference_type
2995 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2997 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
3001 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3002 0, VAR_NAMESPACE
, 0, NULL
);
3009 v
= read_var_value (s
, 0);
3011 VALUE_TYPE (v
) = lookup_reference_type
3012 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
3020 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3025 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3028 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3029 v
= value_struct_elt_for_reference (domain
,
3030 offset
+ base_offset
,
3031 TYPE_BASECLASS (t
, i
),
3041 /* Find the real run-time type of a value using RTTI.
3042 * V is a pointer to the value.
3043 * A pointer to the struct type entry of the run-time type
3045 * FULL is a flag that is set only if the value V includes
3046 * the entire contents of an object of the RTTI type.
3047 * TOP is the offset to the top of the enclosing object of
3048 * the real run-time type. This offset may be for the embedded
3049 * object, or for the enclosing object of V.
3050 * USING_ENC is the flag that distinguishes the two cases.
3051 * If it is 1, then the offset is for the enclosing object,
3052 * otherwise for the embedded object.
3054 * This currently works only for RTTI information generated
3055 * by the HP ANSI C++ compiler (aCC). g++ today (1997-06-10)
3056 * does not appear to support RTTI. This function returns a
3057 * NULL value for objects in the g++ runtime model. */
3060 value_rtti_type (v
, full
, top
, using_enc
)
3066 struct type
*known_type
;
3067 struct type
*rtti_type
;
3070 int using_enclosing
= 0;
3071 long top_offset
= 0;
3072 char rtti_type_name
[256];
3081 /* Get declared type */
3082 known_type
= VALUE_TYPE (v
);
3083 CHECK_TYPEDEF (known_type
);
3084 /* RTTI works only or class objects */
3085 if (TYPE_CODE (known_type
) != TYPE_CODE_CLASS
)
3088 /* If neither the declared type nor the enclosing type of the
3089 * value structure has a HP ANSI C++ style virtual table,
3090 * we can't do anything. */
3091 if (!TYPE_HAS_VTABLE (known_type
))
3093 known_type
= VALUE_ENCLOSING_TYPE (v
);
3094 CHECK_TYPEDEF (known_type
);
3095 if ((TYPE_CODE (known_type
) != TYPE_CODE_CLASS
) ||
3096 !TYPE_HAS_VTABLE (known_type
))
3097 return NULL
; /* No RTTI, or not HP-compiled types */
3098 CHECK_TYPEDEF (known_type
);
3099 using_enclosing
= 1;
3102 if (using_enclosing
&& using_enc
)
3105 /* First get the virtual table address */
3106 coreptr
= *(CORE_ADDR
*) ((VALUE_CONTENTS_ALL (v
))
3108 + (using_enclosing
? 0 : VALUE_EMBEDDED_OFFSET (v
)));
3110 return NULL
; /* return silently -- maybe called on gdb-generated value */
3112 /* Fetch the top offset of the object */
3113 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3114 vp
= value_at (builtin_type_int
,
3115 coreptr
+ 4 * HP_ACC_TOP_OFFSET_OFFSET
,
3116 VALUE_BFD_SECTION (v
));
3117 top_offset
= value_as_long (vp
);
3121 /* Fetch the typeinfo pointer */
3122 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3123 vp
= value_at (builtin_type_int
, coreptr
+ 4 * HP_ACC_TYPEINFO_OFFSET
, VALUE_BFD_SECTION (v
));
3124 /* Indirect through the typeinfo pointer and retrieve the pointer
3125 * to the string name */
3126 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3128 error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3129 vp
= value_at (builtin_type_int
, coreptr
+ 4, VALUE_BFD_SECTION (v
)); /* 4 -> offset of name field */
3130 /* FIXME possible 32x64 problem */
3132 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3134 read_memory_string (coreptr
, rtti_type_name
, 256);
3136 if (strlen (rtti_type_name
) == 0)
3137 error ("Retrieved null type name from typeinfo");
3139 /* search for type */
3140 rtti_type
= lookup_typename (rtti_type_name
, (struct block
*) 0, 1);
3143 error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name
);
3144 CHECK_TYPEDEF (rtti_type
);
3146 #if 0 /* debugging */
3147 printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type
), TYPE_TAG_NAME (rtti_type
), full
? *full
: -1);
3150 /* Check whether we have the entire object */
3151 if (full
/* Non-null pointer passed */
3154 /* Either we checked on the whole object in hand and found the
3155 top offset to be zero */
3156 (((top_offset
== 0) &&
3158 TYPE_LENGTH (known_type
) == TYPE_LENGTH (rtti_type
))
3160 /* Or we checked on the embedded object and top offset was the
3161 same as the embedded offset */
3162 ((top_offset
== VALUE_EMBEDDED_OFFSET (v
)) &&
3164 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v
)) == TYPE_LENGTH (rtti_type
))))
3171 /* Given a pointer value V, find the real (RTTI) type
3172 of the object it points to.
3173 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3174 and refer to the values computed for the object pointed to. */
3177 value_rtti_target_type (v
, full
, top
, using_enc
)
3185 target
= value_ind (v
);
3187 return value_rtti_type (target
, full
, top
, using_enc
);
3190 /* Given a value pointed to by ARGP, check its real run-time type, and
3191 if that is different from the enclosing type, create a new value
3192 using the real run-time type as the enclosing type (and of the same
3193 type as ARGP) and return it, with the embedded offset adjusted to
3194 be the correct offset to the enclosed object
3195 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3196 parameters, computed by value_rtti_type(). If these are available,
3197 they can be supplied and a second call to value_rtti_type() is avoided.
3198 (Pass RTYPE == NULL if they're not available */
3201 value_full_object (argp
, rtype
, xfull
, xtop
, xusing_enc
)
3209 struct type
*real_type
;
3220 using_enc
= xusing_enc
;
3223 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3225 /* If no RTTI data, or if object is already complete, do nothing */
3226 if (!real_type
|| real_type
== VALUE_ENCLOSING_TYPE (argp
))
3229 /* If we have the full object, but for some reason the enclosing
3230 type is wrong, set it *//* pai: FIXME -- sounds iffy */
3233 VALUE_ENCLOSING_TYPE (argp
) = real_type
;
3237 /* Check if object is in memory */
3238 if (VALUE_LVAL (argp
) != lval_memory
)
3240 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type
));
3245 /* All other cases -- retrieve the complete object */
3246 /* Go back by the computed top_offset from the beginning of the object,
3247 adjusting for the embedded offset of argp if that's what value_rtti_type
3248 used for its computation. */
3249 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
3250 (using_enc
? 0 : VALUE_EMBEDDED_OFFSET (argp
)),
3251 VALUE_BFD_SECTION (argp
));
3252 VALUE_TYPE (new_val
) = VALUE_TYPE (argp
);
3253 VALUE_EMBEDDED_OFFSET (new_val
) = using_enc
? top
+ VALUE_EMBEDDED_OFFSET (argp
) : top
;
3260 /* C++: return the value of the class instance variable, if one exists.
3261 Flag COMPLAIN signals an error if the request is made in an
3262 inappropriate context. */
3265 value_of_this (complain
)
3268 struct symbol
*func
, *sym
;
3271 static const char funny_this
[] = "this";
3274 if (selected_frame
== 0)
3277 error ("no frame selected");
3282 func
= get_frame_function (selected_frame
);
3286 error ("no `this' in nameless context");
3291 b
= SYMBOL_BLOCK_VALUE (func
);
3292 i
= BLOCK_NSYMS (b
);
3296 error ("no args, no `this'");
3301 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3302 symbol instead of the LOC_ARG one (if both exist). */
3303 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
3307 error ("current stack frame not in method");
3312 this = read_var_value (sym
, selected_frame
);
3313 if (this == 0 && complain
)
3314 error ("`this' argument at unknown address");
3318 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3319 long, starting at LOWBOUND. The result has the same lower bound as
3320 the original ARRAY. */
3323 value_slice (array
, lowbound
, length
)
3325 int lowbound
, length
;
3327 struct type
*slice_range_type
, *slice_type
, *range_type
;
3328 LONGEST lowerbound
, upperbound
, offset
;
3330 struct type
*array_type
;
3331 array_type
= check_typedef (VALUE_TYPE (array
));
3332 COERCE_VARYING_ARRAY (array
, array_type
);
3333 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3334 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3335 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3336 error ("cannot take slice of non-array");
3337 range_type
= TYPE_INDEX_TYPE (array_type
);
3338 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3339 error ("slice from bad array or bitstring");
3340 if (lowbound
< lowerbound
|| length
< 0
3341 || lowbound
+ length
- 1 > upperbound
3342 /* Chill allows zero-length strings but not arrays. */
3343 || (current_language
->la_language
== language_chill
3344 && length
== 0 && TYPE_CODE (array_type
) == TYPE_CODE_ARRAY
))
3345 error ("slice out of range");
3346 /* FIXME-type-allocation: need a way to free this type when we are
3348 slice_range_type
= create_range_type ((struct type
*) NULL
,
3349 TYPE_TARGET_TYPE (range_type
),
3350 lowbound
, lowbound
+ length
- 1);
3351 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3354 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
3355 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3356 slice
= value_zero (slice_type
, not_lval
);
3357 for (i
= 0; i
< length
; i
++)
3359 int element
= value_bit_index (array_type
,
3360 VALUE_CONTENTS (array
),
3363 error ("internal error accessing bitstring");
3364 else if (element
> 0)
3366 int j
= i
% TARGET_CHAR_BIT
;
3367 if (BITS_BIG_ENDIAN
)
3368 j
= TARGET_CHAR_BIT
- 1 - j
;
3369 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3372 /* We should set the address, bitssize, and bitspos, so the clice
3373 can be used on the LHS, but that may require extensions to
3374 value_assign. For now, just leave as a non_lval. FIXME. */
3378 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3380 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3381 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
3383 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3384 slice
= allocate_value (slice_type
);
3385 if (VALUE_LAZY (array
))
3386 VALUE_LAZY (slice
) = 1;
3388 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
3389 TYPE_LENGTH (slice_type
));
3390 if (VALUE_LVAL (array
) == lval_internalvar
)
3391 VALUE_LVAL (slice
) = lval_internalvar_component
;
3393 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
3394 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
3395 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
3400 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3401 value as a fixed-length array. */
3404 varying_to_slice (varray
)
3407 struct type
*vtype
= check_typedef (VALUE_TYPE (varray
));
3408 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
3409 VALUE_CONTENTS (varray
)
3410 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
3411 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
3414 /* Create a value for a FORTRAN complex number. Currently most of
3415 the time values are coerced to COMPLEX*16 (i.e. a complex number
3416 composed of 2 doubles. This really should be a smarter routine
3417 that figures out precision inteligently as opposed to assuming
3418 doubles. FIXME: fmb */
3421 value_literal_complex (arg1
, arg2
, type
)
3426 register value_ptr val
;
3427 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3429 val
= allocate_value (type
);
3430 arg1
= value_cast (real_type
, arg1
);
3431 arg2
= value_cast (real_type
, arg2
);
3433 memcpy (VALUE_CONTENTS_RAW (val
),
3434 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
3435 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
3436 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
3440 /* Cast a value into the appropriate complex data type. */
3443 cast_into_complex (type
, val
)
3445 register value_ptr val
;
3447 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3448 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
3450 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
3451 value_ptr re_val
= allocate_value (val_real_type
);
3452 value_ptr im_val
= allocate_value (val_real_type
);
3454 memcpy (VALUE_CONTENTS_RAW (re_val
),
3455 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
3456 memcpy (VALUE_CONTENTS_RAW (im_val
),
3457 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
3458 TYPE_LENGTH (val_real_type
));
3460 return value_literal_complex (re_val
, im_val
, type
);
3462 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
3463 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
3464 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
3466 error ("cannot cast non-number to complex");
3470 _initialize_valops ()
3474 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *) &auto_abandon
,
3475 "Set automatic abandonment of expressions upon failure.",
3481 (add_set_cmd ("overload-resolution", class_support
, var_boolean
, (char *) &overload_resolution
,
3482 "Set overload resolution in evaluating C++ functions.",
3485 overload_resolution
= 1;