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 /* Flag indicating HP compilers were used; needed to correctly handle some
38 value operations with HP aCC code/runtime. */
39 extern int hp_som_som_object_present
;
41 extern int overload_debug
;
42 /* Local functions. */
44 static int typecmp (int staticp
, struct type
*t1
[], value_ptr t2
[]);
46 static CORE_ADDR
find_function_addr (value_ptr
, struct type
**);
47 static value_ptr
value_arg_coerce (value_ptr
, struct type
*, int);
50 static CORE_ADDR
value_push (CORE_ADDR
, value_ptr
);
52 static value_ptr
search_struct_field (char *, value_ptr
, int,
55 static value_ptr
search_struct_method (char *, value_ptr
*,
57 int, int *, struct type
*);
59 static int check_field_in (struct type
*, const char *);
61 static CORE_ADDR
allocate_space_in_inferior (int);
63 static value_ptr
cast_into_complex (struct type
*, value_ptr
);
65 static struct fn_field
*find_method_list (value_ptr
* argp
, char *method
,
66 int offset
, int *static_memfuncp
,
67 struct type
*type
, int *num_fns
,
68 struct type
**basetype
,
71 void _initialize_valops (void);
73 /* Flag for whether we want to abandon failed expression evals by default. */
76 static int auto_abandon
= 0;
79 int overload_resolution
= 0;
81 /* This boolean tells what gdb should do if a signal is received while in
82 a function called from gdb (call dummy). If set, gdb unwinds the stack
83 and restore the context to what as it was before the call.
84 The default is to stop in the frame where the signal was received. */
86 int unwind_on_signal_p
= 0;
90 /* Find the address of function name NAME in the inferior. */
93 find_function_in_inferior (char *name
)
95 register struct symbol
*sym
;
96 sym
= lookup_symbol (name
, 0, VAR_NAMESPACE
, 0, NULL
);
99 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
101 error ("\"%s\" exists in this program but is not a function.",
104 return value_of_variable (sym
, NULL
);
108 struct minimal_symbol
*msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
113 type
= lookup_pointer_type (builtin_type_char
);
114 type
= lookup_function_type (type
);
115 type
= lookup_pointer_type (type
);
116 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
117 return value_from_pointer (type
, maddr
);
121 if (!target_has_execution
)
122 error ("evaluation of this expression requires the target program to be active");
124 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
129 /* Allocate NBYTES of space in the inferior using the inferior's malloc
130 and return a value that is a pointer to the allocated space. */
133 value_allocate_space_in_inferior (int len
)
136 register value_ptr val
= find_function_in_inferior ("malloc");
138 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
139 val
= call_function_by_hand (val
, 1, &blocklen
);
140 if (value_logical_not (val
))
142 if (!target_has_execution
)
143 error ("No memory available to program now: you need to start the target first");
145 error ("No memory available to program: call to malloc failed");
151 allocate_space_in_inferior (int len
)
153 return value_as_long (value_allocate_space_in_inferior (len
));
156 /* Cast value ARG2 to type TYPE and return as a value.
157 More general than a C cast: accepts any two types of the same length,
158 and if ARG2 is an lvalue it can be cast into anything at all. */
159 /* In C++, casts may change pointer or object representations. */
162 value_cast (struct type
*type
, register value_ptr arg2
)
164 register enum type_code code1
;
165 register enum type_code code2
;
169 int convert_to_boolean
= 0;
171 if (VALUE_TYPE (arg2
) == type
)
174 CHECK_TYPEDEF (type
);
175 code1
= TYPE_CODE (type
);
177 type2
= check_typedef (VALUE_TYPE (arg2
));
179 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
180 is treated like a cast to (TYPE [N])OBJECT,
181 where N is sizeof(OBJECT)/sizeof(TYPE). */
182 if (code1
== TYPE_CODE_ARRAY
)
184 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
185 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
186 if (element_length
> 0
187 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
189 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
190 int val_length
= TYPE_LENGTH (type2
);
191 LONGEST low_bound
, high_bound
, new_length
;
192 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
193 low_bound
= 0, high_bound
= 0;
194 new_length
= val_length
/ element_length
;
195 if (val_length
% element_length
!= 0)
196 warning ("array element type size does not divide object size in cast");
197 /* FIXME-type-allocation: need a way to free this type when we are
199 range_type
= create_range_type ((struct type
*) NULL
,
200 TYPE_TARGET_TYPE (range_type
),
202 new_length
+ low_bound
- 1);
203 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
204 element_type
, range_type
);
209 if (current_language
->c_style_arrays
210 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
211 arg2
= value_coerce_array (arg2
);
213 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
214 arg2
= value_coerce_function (arg2
);
216 type2
= check_typedef (VALUE_TYPE (arg2
));
217 COERCE_VARYING_ARRAY (arg2
, type2
);
218 code2
= TYPE_CODE (type2
);
220 if (code1
== TYPE_CODE_COMPLEX
)
221 return cast_into_complex (type
, arg2
);
222 if (code1
== TYPE_CODE_BOOL
)
224 code1
= TYPE_CODE_INT
;
225 convert_to_boolean
= 1;
227 if (code1
== TYPE_CODE_CHAR
)
228 code1
= TYPE_CODE_INT
;
229 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
230 code2
= TYPE_CODE_INT
;
232 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
233 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
235 if (code1
== TYPE_CODE_STRUCT
236 && code2
== TYPE_CODE_STRUCT
237 && TYPE_NAME (type
) != 0)
239 /* Look in the type of the source to see if it contains the
240 type of the target as a superclass. If so, we'll need to
241 offset the object in addition to changing its type. */
242 value_ptr v
= search_struct_field (type_name_no_tag (type
),
246 VALUE_TYPE (v
) = type
;
250 if (code1
== TYPE_CODE_FLT
&& scalar
)
251 return value_from_double (type
, value_as_double (arg2
));
252 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
253 || code1
== TYPE_CODE_RANGE
)
254 && (scalar
|| code2
== TYPE_CODE_PTR
))
258 if (hp_som_som_object_present
&& /* if target compiled by HP aCC */
259 (code2
== TYPE_CODE_PTR
))
264 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2
)))
266 /* With HP aCC, pointers to data members have a bias */
267 case TYPE_CODE_MEMBER
:
268 retvalp
= value_from_longest (type
, value_as_long (arg2
));
269 /* force evaluation */
270 ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
);
271 *ptr
&= ~0x20000000; /* zap 29th bit to remove bias */
274 /* While pointers to methods don't really point to a function */
275 case TYPE_CODE_METHOD
:
276 error ("Pointers to methods not supported with HP aCC");
279 break; /* fall out and go to normal handling */
282 longest
= value_as_long (arg2
);
283 return value_from_longest (type
, convert_to_boolean
?
284 (LONGEST
) (longest
? 1 : 0) : longest
);
286 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
||
287 code2
== TYPE_CODE_ENUM
||
288 code2
== TYPE_CODE_RANGE
))
290 /* TYPE_LENGTH (type) is the length of a pointer, but we really
291 want the length of an address! -- we are really dealing with
292 addresses (i.e., gdb representations) not pointers (i.e.,
293 target representations) here.
295 This allows things like "print *(int *)0x01000234" to work
296 without printing a misleading message -- which would
297 otherwise occur when dealing with a target having two byte
298 pointers and four byte addresses. */
300 int addr_bit
= TARGET_ADDR_BIT
;
302 LONGEST longest
= value_as_long (arg2
);
303 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
305 if (longest
>= ((LONGEST
) 1 << addr_bit
)
306 || longest
<= -((LONGEST
) 1 << addr_bit
))
307 warning ("value truncated");
309 return value_from_longest (type
, longest
);
311 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
313 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
315 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
316 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
317 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
318 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
319 && !value_logical_not (arg2
))
323 /* Look in the type of the source to see if it contains the
324 type of the target as a superclass. If so, we'll need to
325 offset the pointer rather than just change its type. */
326 if (TYPE_NAME (t1
) != NULL
)
328 v
= search_struct_field (type_name_no_tag (t1
),
329 value_ind (arg2
), 0, t2
, 1);
333 VALUE_TYPE (v
) = type
;
338 /* Look in the type of the target to see if it contains the
339 type of the source as a superclass. If so, we'll need to
340 offset the pointer rather than just change its type.
341 FIXME: This fails silently with virtual inheritance. */
342 if (TYPE_NAME (t2
) != NULL
)
344 v
= search_struct_field (type_name_no_tag (t2
),
345 value_zero (t1
, not_lval
), 0, t1
, 1);
348 value_ptr v2
= value_ind (arg2
);
349 VALUE_ADDRESS (v2
) -= VALUE_ADDRESS (v
)
352 /* JYG: adjust the new pointer value and
354 v2
->aligner
.contents
[0] -= VALUE_EMBEDDED_OFFSET (v
);
355 VALUE_EMBEDDED_OFFSET (v2
) = 0;
357 v2
= value_addr (v2
);
358 VALUE_TYPE (v2
) = type
;
363 /* No superclass found, just fall through to change ptr type. */
365 VALUE_TYPE (arg2
) = type
;
366 VALUE_ENCLOSING_TYPE (arg2
) = type
; /* pai: chk_val */
367 VALUE_POINTED_TO_OFFSET (arg2
) = 0; /* pai: chk_val */
370 else if (chill_varying_type (type
))
372 struct type
*range1
, *range2
, *eltype1
, *eltype2
;
375 LONGEST low_bound
, high_bound
;
376 char *valaddr
, *valaddr_data
;
377 /* For lint warning about eltype2 possibly uninitialized: */
379 if (code2
== TYPE_CODE_BITSTRING
)
380 error ("not implemented: converting bitstring to varying type");
381 if ((code2
!= TYPE_CODE_ARRAY
&& code2
!= TYPE_CODE_STRING
)
382 || (eltype1
= check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 1))),
383 eltype2
= check_typedef (TYPE_TARGET_TYPE (type2
)),
384 (TYPE_LENGTH (eltype1
) != TYPE_LENGTH (eltype2
)
385 /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
386 error ("Invalid conversion to varying type");
387 range1
= TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type
, 1), 0);
388 range2
= TYPE_FIELD_TYPE (type2
, 0);
389 if (get_discrete_bounds (range1
, &low_bound
, &high_bound
) < 0)
392 count1
= high_bound
- low_bound
+ 1;
393 if (get_discrete_bounds (range2
, &low_bound
, &high_bound
) < 0)
394 count1
= -1, count2
= 0; /* To force error before */
396 count2
= high_bound
- low_bound
+ 1;
398 error ("target varying type is too small");
399 val
= allocate_value (type
);
400 valaddr
= VALUE_CONTENTS_RAW (val
);
401 valaddr_data
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
402 /* Set val's __var_length field to count2. */
403 store_signed_integer (valaddr
, TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)),
405 /* Set the __var_data field to count2 elements copied from arg2. */
406 memcpy (valaddr_data
, VALUE_CONTENTS (arg2
),
407 count2
* TYPE_LENGTH (eltype2
));
408 /* Zero the rest of the __var_data field of val. */
409 memset (valaddr_data
+ count2
* TYPE_LENGTH (eltype2
), '\0',
410 (count1
- count2
) * TYPE_LENGTH (eltype2
));
413 else if (VALUE_LVAL (arg2
) == lval_memory
)
415 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
),
416 VALUE_BFD_SECTION (arg2
));
418 else if (code1
== TYPE_CODE_VOID
)
420 return value_zero (builtin_type_void
, not_lval
);
424 error ("Invalid cast.");
429 /* Create a value of type TYPE that is zero, and return it. */
432 value_zero (struct type
*type
, enum lval_type lv
)
434 register value_ptr val
= allocate_value (type
);
436 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (check_typedef (type
)));
437 VALUE_LVAL (val
) = lv
;
442 /* Return a value with type TYPE located at ADDR.
444 Call value_at only if the data needs to be fetched immediately;
445 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
446 value_at_lazy instead. value_at_lazy simply records the address of
447 the data and sets the lazy-evaluation-required flag. The lazy flag
448 is tested in the VALUE_CONTENTS macro, which is used if and when
449 the contents are actually required.
451 Note: value_at does *NOT* handle embedded offsets; perform such
452 adjustments before or after calling it. */
455 value_at (struct type
*type
, CORE_ADDR addr
, asection
*sect
)
457 register value_ptr val
;
459 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
460 error ("Attempt to dereference a generic pointer.");
462 val
= allocate_value (type
);
464 if (GDB_TARGET_IS_D10V
465 && TYPE_CODE (type
) == TYPE_CODE_PTR
466 && TYPE_TARGET_TYPE (type
)
467 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
469 /* pointer to function */
472 snum
= read_memory_unsigned_integer (addr
, 2);
473 num
= D10V_MAKE_IADDR (snum
);
474 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
476 else if (GDB_TARGET_IS_D10V
477 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
479 /* pointer to data */
482 snum
= read_memory_unsigned_integer (addr
, 2);
483 num
= D10V_MAKE_DADDR (snum
);
484 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
487 read_memory (addr
, VALUE_CONTENTS_ALL_RAW (val
), TYPE_LENGTH (type
));
489 VALUE_LVAL (val
) = lval_memory
;
490 VALUE_ADDRESS (val
) = addr
;
491 VALUE_BFD_SECTION (val
) = sect
;
496 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
499 value_at_lazy (struct type
*type
, CORE_ADDR addr
, asection
*sect
)
501 register value_ptr val
;
503 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
504 error ("Attempt to dereference a generic pointer.");
506 val
= allocate_value (type
);
508 VALUE_LVAL (val
) = lval_memory
;
509 VALUE_ADDRESS (val
) = addr
;
510 VALUE_LAZY (val
) = 1;
511 VALUE_BFD_SECTION (val
) = sect
;
516 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
517 if the current data for a variable needs to be loaded into
518 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
519 clears the lazy flag to indicate that the data in the buffer is valid.
521 If the value is zero-length, we avoid calling read_memory, which would
522 abort. We mark the value as fetched anyway -- all 0 bytes of it.
524 This function returns a value because it is used in the VALUE_CONTENTS
525 macro as part of an expression, where a void would not work. The
529 value_fetch_lazy (register value_ptr val
)
531 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
532 int length
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
));
534 struct type
*type
= VALUE_TYPE (val
);
535 if (GDB_TARGET_IS_D10V
536 && TYPE_CODE (type
) == TYPE_CODE_PTR
537 && TYPE_TARGET_TYPE (type
)
538 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
540 /* pointer to function */
543 snum
= read_memory_unsigned_integer (addr
, 2);
544 num
= D10V_MAKE_IADDR (snum
);
545 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
547 else if (GDB_TARGET_IS_D10V
548 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
550 /* pointer to data */
553 snum
= read_memory_unsigned_integer (addr
, 2);
554 num
= D10V_MAKE_DADDR (snum
);
555 store_address (VALUE_CONTENTS_RAW (val
), 4, num
);
558 read_memory (addr
, VALUE_CONTENTS_ALL_RAW (val
), length
);
560 VALUE_LAZY (val
) = 0;
565 /* Store the contents of FROMVAL into the location of TOVAL.
566 Return a new value with the location of TOVAL and contents of FROMVAL. */
569 value_assign (register value_ptr toval
, register value_ptr fromval
)
571 register struct type
*type
;
572 register value_ptr val
;
573 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
576 if (!toval
->modifiable
)
577 error ("Left operand of assignment is not a modifiable lvalue.");
581 type
= VALUE_TYPE (toval
);
582 if (VALUE_LVAL (toval
) != lval_internalvar
)
583 fromval
= value_cast (type
, fromval
);
585 COERCE_ARRAY (fromval
);
586 CHECK_TYPEDEF (type
);
588 /* If TOVAL is a special machine register requiring conversion
589 of program values to a special raw format,
590 convert FROMVAL's contents now, with result in `raw_buffer',
591 and set USE_BUFFER to the number of bytes to write. */
593 if (VALUE_REGNO (toval
) >= 0)
595 int regno
= VALUE_REGNO (toval
);
596 if (REGISTER_CONVERTIBLE (regno
))
598 struct type
*fromtype
= check_typedef (VALUE_TYPE (fromval
));
599 REGISTER_CONVERT_TO_RAW (fromtype
, regno
,
600 VALUE_CONTENTS (fromval
), raw_buffer
);
601 use_buffer
= REGISTER_RAW_SIZE (regno
);
605 switch (VALUE_LVAL (toval
))
607 case lval_internalvar
:
608 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
609 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
610 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
611 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
612 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
615 case lval_internalvar_component
:
616 set_internalvar_component (VALUE_INTERNALVAR (toval
),
617 VALUE_OFFSET (toval
),
618 VALUE_BITPOS (toval
),
619 VALUE_BITSIZE (toval
),
626 CORE_ADDR changed_addr
;
629 if (VALUE_BITSIZE (toval
))
631 char buffer
[sizeof (LONGEST
)];
632 /* We assume that the argument to read_memory is in units of
633 host chars. FIXME: Is that correct? */
634 changed_len
= (VALUE_BITPOS (toval
)
635 + VALUE_BITSIZE (toval
)
639 if (changed_len
> (int) sizeof (LONGEST
))
640 error ("Can't handle bitfields which don't fit in a %d bit word.",
641 sizeof (LONGEST
) * HOST_CHAR_BIT
);
643 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
644 buffer
, changed_len
);
645 modify_field (buffer
, value_as_long (fromval
),
646 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
647 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
648 dest_buffer
= buffer
;
652 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
653 changed_len
= use_buffer
;
654 dest_buffer
= raw_buffer
;
658 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
659 changed_len
= TYPE_LENGTH (type
);
660 dest_buffer
= VALUE_CONTENTS (fromval
);
663 write_memory (changed_addr
, dest_buffer
, changed_len
);
664 if (memory_changed_hook
)
665 memory_changed_hook (changed_addr
, changed_len
);
670 if (VALUE_BITSIZE (toval
))
672 char buffer
[sizeof (LONGEST
)];
674 REGISTER_RAW_SIZE (VALUE_REGNO (toval
)) - VALUE_OFFSET (toval
);
676 if (len
> (int) sizeof (LONGEST
))
677 error ("Can't handle bitfields in registers larger than %d bits.",
678 sizeof (LONGEST
) * HOST_CHAR_BIT
);
680 if (VALUE_BITPOS (toval
) + VALUE_BITSIZE (toval
)
681 > len
* HOST_CHAR_BIT
)
682 /* Getting this right would involve being very careful about
684 error ("Can't assign to bitfields that cross register "
687 read_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
689 modify_field (buffer
, value_as_long (fromval
),
690 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
691 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
695 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
696 raw_buffer
, use_buffer
);
699 /* Do any conversion necessary when storing this type to more
700 than one register. */
701 #ifdef REGISTER_CONVERT_FROM_TYPE
702 memcpy (raw_buffer
, VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
703 REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval
), type
, raw_buffer
);
704 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
705 raw_buffer
, TYPE_LENGTH (type
));
707 write_register_bytes (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
708 VALUE_CONTENTS (fromval
), TYPE_LENGTH (type
));
711 /* Assigning to the stack pointer, frame pointer, and other
712 (architecture and calling convention specific) registers may
713 cause the frame cache to be out of date. We just do this
714 on all assignments to registers for simplicity; I doubt the slowdown
716 reinit_frame_cache ();
719 case lval_reg_frame_relative
:
721 /* value is stored in a series of registers in the frame
722 specified by the structure. Copy that value out, modify
723 it, and copy it back in. */
724 int amount_to_copy
= (VALUE_BITSIZE (toval
) ? 1 : TYPE_LENGTH (type
));
725 int reg_size
= REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval
));
726 int byte_offset
= VALUE_OFFSET (toval
) % reg_size
;
727 int reg_offset
= VALUE_OFFSET (toval
) / reg_size
;
730 /* Make the buffer large enough in all cases. */
731 char *buffer
= (char *) alloca (amount_to_copy
733 + MAX_REGISTER_RAW_SIZE
);
736 struct frame_info
*frame
;
738 /* Figure out which frame this is in currently. */
739 for (frame
= get_current_frame ();
740 frame
&& FRAME_FP (frame
) != VALUE_FRAME (toval
);
741 frame
= get_prev_frame (frame
))
745 error ("Value being assigned to is no longer active.");
747 amount_to_copy
+= (reg_size
- amount_to_copy
% reg_size
);
750 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
752 amount_copied
< amount_to_copy
;
753 amount_copied
+= reg_size
, regno
++)
755 get_saved_register (buffer
+ amount_copied
,
756 (int *) NULL
, (CORE_ADDR
*) NULL
,
757 frame
, regno
, (enum lval_type
*) NULL
);
760 /* Modify what needs to be modified. */
761 if (VALUE_BITSIZE (toval
))
762 modify_field (buffer
+ byte_offset
,
763 value_as_long (fromval
),
764 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
766 memcpy (buffer
+ byte_offset
, raw_buffer
, use_buffer
);
768 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
772 for ((regno
= VALUE_FRAME_REGNUM (toval
) + reg_offset
,
774 amount_copied
< amount_to_copy
;
775 amount_copied
+= reg_size
, regno
++)
781 /* Just find out where to put it. */
782 get_saved_register ((char *) NULL
,
783 &optim
, &addr
, frame
, regno
, &lval
);
786 error ("Attempt to assign to a value that was optimized out.");
787 if (lval
== lval_memory
)
788 write_memory (addr
, buffer
+ amount_copied
, reg_size
);
789 else if (lval
== lval_register
)
790 write_register_bytes (addr
, buffer
+ amount_copied
, reg_size
);
792 error ("Attempt to assign to an unmodifiable value.");
795 if (register_changed_hook
)
796 register_changed_hook (-1);
802 error ("Left operand of assignment is not an lvalue.");
805 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
806 If the field is signed, and is negative, then sign extend. */
807 if ((VALUE_BITSIZE (toval
) > 0)
808 && (VALUE_BITSIZE (toval
) < 8 * (int) sizeof (LONGEST
)))
810 LONGEST fieldval
= value_as_long (fromval
);
811 LONGEST valmask
= (((ULONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
814 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
815 fieldval
|= ~valmask
;
817 fromval
= value_from_longest (type
, fieldval
);
820 val
= value_copy (toval
);
821 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
823 VALUE_TYPE (val
) = type
;
824 VALUE_ENCLOSING_TYPE (val
) = VALUE_ENCLOSING_TYPE (fromval
);
825 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
826 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
831 /* Extend a value VAL to COUNT repetitions of its type. */
834 value_repeat (value_ptr arg1
, int count
)
836 register value_ptr val
;
838 if (VALUE_LVAL (arg1
) != lval_memory
)
839 error ("Only values in memory can be extended with '@'.");
841 error ("Invalid number %d of repetitions.", count
);
843 val
= allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1
), count
);
845 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
846 VALUE_CONTENTS_ALL_RAW (val
),
847 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)));
848 VALUE_LVAL (val
) = lval_memory
;
849 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
855 value_of_variable (struct symbol
*var
, struct block
*b
)
858 struct frame_info
*frame
= NULL
;
861 frame
= NULL
; /* Use selected frame. */
862 else if (symbol_read_needs_frame (var
))
864 frame
= block_innermost_frame (b
);
867 if (BLOCK_FUNCTION (b
)
868 && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)))
869 error ("No frame is currently executing in block %s.",
870 SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)));
872 error ("No frame is currently executing in specified block");
876 val
= read_var_value (var
, frame
);
878 error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
883 /* Given a value which is an array, return a value which is a pointer to its
884 first element, regardless of whether or not the array has a nonzero lower
887 FIXME: A previous comment here indicated that this routine should be
888 substracting the array's lower bound. It's not clear to me that this
889 is correct. Given an array subscripting operation, it would certainly
890 work to do the adjustment here, essentially computing:
892 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
894 However I believe a more appropriate and logical place to account for
895 the lower bound is to do so in value_subscript, essentially computing:
897 (&array[0] + ((index - lowerbound) * sizeof array[0]))
899 As further evidence consider what would happen with operations other
900 than array subscripting, where the caller would get back a value that
901 had an address somewhere before the actual first element of the array,
902 and the information about the lower bound would be lost because of
903 the coercion to pointer type.
907 value_coerce_array (value_ptr arg1
)
909 register struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
911 if (VALUE_LVAL (arg1
) != lval_memory
)
912 error ("Attempt to take address of value not located in memory.");
914 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
915 (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
918 /* Given a value which is a function, return a value which is a pointer
922 value_coerce_function (value_ptr arg1
)
926 if (VALUE_LVAL (arg1
) != lval_memory
)
927 error ("Attempt to take address of value not located in memory.");
929 retval
= value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1
)),
930 (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
931 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (arg1
);
935 /* Return a pointer value for the object for which ARG1 is the contents. */
938 value_addr (value_ptr arg1
)
942 struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
943 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
945 /* Copy the value, but change the type from (T&) to (T*).
946 We keep the same location information, which is efficient,
947 and allows &(&X) to get the location containing the reference. */
948 arg2
= value_copy (arg1
);
949 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
952 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
953 return value_coerce_function (arg1
);
955 if (VALUE_LVAL (arg1
) != lval_memory
)
956 error ("Attempt to take address of value not located in memory.");
958 /* Get target memory address */
959 arg2
= value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1
)),
960 (VALUE_ADDRESS (arg1
)
961 + VALUE_OFFSET (arg1
)
962 + VALUE_EMBEDDED_OFFSET (arg1
)));
964 /* This may be a pointer to a base subobject; so remember the
965 full derived object's type ... */
966 VALUE_ENCLOSING_TYPE (arg2
) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1
));
967 /* ... and also the relative position of the subobject in the full object */
968 VALUE_POINTED_TO_OFFSET (arg2
) = VALUE_EMBEDDED_OFFSET (arg1
);
969 VALUE_BFD_SECTION (arg2
) = VALUE_BFD_SECTION (arg1
);
973 /* Given a value of a pointer type, apply the C unary * operator to it. */
976 value_ind (value_ptr arg1
)
978 struct type
*base_type
;
983 base_type
= check_typedef (VALUE_TYPE (arg1
));
985 if (TYPE_CODE (base_type
) == TYPE_CODE_MEMBER
)
986 error ("not implemented: member types in value_ind");
988 /* Allow * on an integer so we can cast it to whatever we want.
989 This returns an int, which seems like the most C-like thing
990 to do. "long long" variables are rare enough that
991 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
992 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
993 return value_at (builtin_type_int
,
994 (CORE_ADDR
) value_as_long (arg1
),
995 VALUE_BFD_SECTION (arg1
));
996 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
998 struct type
*enc_type
;
999 /* We may be pointing to something embedded in a larger object */
1000 /* Get the real type of the enclosing object */
1001 enc_type
= check_typedef (VALUE_ENCLOSING_TYPE (arg1
));
1002 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1003 /* Retrieve the enclosing object pointed to */
1004 arg2
= value_at_lazy (enc_type
,
1005 value_as_pointer (arg1
) - VALUE_POINTED_TO_OFFSET (arg1
),
1006 VALUE_BFD_SECTION (arg1
));
1007 /* Re-adjust type */
1008 VALUE_TYPE (arg2
) = TYPE_TARGET_TYPE (base_type
);
1009 /* Add embedding info */
1010 VALUE_ENCLOSING_TYPE (arg2
) = enc_type
;
1011 VALUE_EMBEDDED_OFFSET (arg2
) = VALUE_POINTED_TO_OFFSET (arg1
);
1013 /* We may be pointing to an object of some derived type */
1014 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1018 error ("Attempt to take contents of a non-pointer value.");
1019 return 0; /* For lint -- never reached */
1022 /* Pushing small parts of stack frames. */
1024 /* Push one word (the size of object that a register holds). */
1027 push_word (CORE_ADDR sp
, ULONGEST word
)
1029 register int len
= REGISTER_SIZE
;
1030 char *buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1032 store_unsigned_integer (buffer
, len
, word
);
1033 if (INNER_THAN (1, 2))
1035 /* stack grows downward */
1037 write_memory (sp
, buffer
, len
);
1041 /* stack grows upward */
1042 write_memory (sp
, buffer
, len
);
1049 /* Push LEN bytes with data at BUFFER. */
1052 push_bytes (CORE_ADDR sp
, char *buffer
, int len
)
1054 if (INNER_THAN (1, 2))
1056 /* stack grows downward */
1058 write_memory (sp
, buffer
, len
);
1062 /* stack grows upward */
1063 write_memory (sp
, buffer
, len
);
1070 #ifndef PARM_BOUNDARY
1071 #define PARM_BOUNDARY (0)
1074 /* Push onto the stack the specified value VALUE. Pad it correctly for
1075 it to be an argument to a function. */
1078 value_push (register CORE_ADDR sp
, value_ptr arg
)
1080 register int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
1081 register int container_len
= len
;
1082 register int offset
;
1084 /* How big is the container we're going to put this value in? */
1086 container_len
= ((len
+ PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1)
1087 & ~(PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1));
1089 /* Are we going to put it at the high or low end of the container? */
1090 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1091 offset
= container_len
- len
;
1095 if (INNER_THAN (1, 2))
1097 /* stack grows downward */
1098 sp
-= container_len
;
1099 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1103 /* stack grows upward */
1104 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1105 sp
+= container_len
;
1111 #ifndef PUSH_ARGUMENTS
1112 #define PUSH_ARGUMENTS default_push_arguments
1116 default_push_arguments (int nargs
, value_ptr
*args
, CORE_ADDR sp
,
1117 int struct_return
, CORE_ADDR struct_addr
)
1119 /* ASSERT ( !struct_return); */
1121 for (i
= nargs
- 1; i
>= 0; i
--)
1122 sp
= value_push (sp
, args
[i
]);
1127 /* A default function for COERCE_FLOAT_TO_DOUBLE: do the coercion only
1128 when we don't have any type for the argument at hand. This occurs
1129 when we have no debug info, or when passing varargs.
1131 This is an annoying default: the rule the compiler follows is to do
1132 the standard promotions whenever there is no prototype in scope,
1133 and almost all targets want this behavior. But there are some old
1134 architectures which want this odd behavior. If you want to go
1135 through them all and fix them, please do. Modern gdbarch-style
1136 targets may find it convenient to use standard_coerce_float_to_double. */
1138 default_coerce_float_to_double (struct type
*formal
, struct type
*actual
)
1140 return formal
== NULL
;
1144 /* Always coerce floats to doubles when there is no prototype in scope.
1145 If your architecture follows the standard type promotion rules for
1146 calling unprototyped functions, your gdbarch init function can pass
1147 this function to set_gdbarch_coerce_float_to_double to use its logic. */
1149 standard_coerce_float_to_double (struct type
*formal
, struct type
*actual
)
1155 /* Perform the standard coercions that are specified
1156 for arguments to be passed to C functions.
1158 If PARAM_TYPE is non-NULL, it is the expected parameter type.
1159 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
1162 value_arg_coerce (value_ptr arg
, struct type
*param_type
, int is_prototyped
)
1164 register struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
1165 register struct type
*type
1166 = param_type
? check_typedef (param_type
) : arg_type
;
1168 switch (TYPE_CODE (type
))
1171 if (TYPE_CODE (arg_type
) != TYPE_CODE_REF
)
1173 arg
= value_addr (arg
);
1174 VALUE_TYPE (arg
) = param_type
;
1179 case TYPE_CODE_CHAR
:
1180 case TYPE_CODE_BOOL
:
1181 case TYPE_CODE_ENUM
:
1182 /* If we don't have a prototype, coerce to integer type if necessary. */
1185 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1186 type
= builtin_type_int
;
1188 /* Currently all target ABIs require at least the width of an integer
1189 type for an argument. We may have to conditionalize the following
1190 type coercion for future targets. */
1191 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_int
))
1192 type
= builtin_type_int
;
1195 /* FIXME: We should always convert floats to doubles in the
1196 non-prototyped case. As many debugging formats include
1197 no information about prototyping, we have to live with
1198 COERCE_FLOAT_TO_DOUBLE for now. */
1199 if (!is_prototyped
&& COERCE_FLOAT_TO_DOUBLE (param_type
, arg_type
))
1201 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin_type_double
))
1202 type
= builtin_type_double
;
1203 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin_type_double
))
1204 type
= builtin_type_long_double
;
1207 case TYPE_CODE_FUNC
:
1208 type
= lookup_pointer_type (type
);
1210 case TYPE_CODE_ARRAY
:
1211 if (current_language
->c_style_arrays
)
1212 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1214 case TYPE_CODE_UNDEF
:
1216 case TYPE_CODE_STRUCT
:
1217 case TYPE_CODE_UNION
:
1218 case TYPE_CODE_VOID
:
1220 case TYPE_CODE_RANGE
:
1221 case TYPE_CODE_STRING
:
1222 case TYPE_CODE_BITSTRING
:
1223 case TYPE_CODE_ERROR
:
1224 case TYPE_CODE_MEMBER
:
1225 case TYPE_CODE_METHOD
:
1226 case TYPE_CODE_COMPLEX
:
1231 return value_cast (type
, arg
);
1234 /* Determine a function's address and its return type from its value.
1235 Calls error() if the function is not valid for calling. */
1238 find_function_addr (value_ptr function
, struct type
**retval_type
)
1240 register struct type
*ftype
= check_typedef (VALUE_TYPE (function
));
1241 register enum type_code code
= TYPE_CODE (ftype
);
1242 struct type
*value_type
;
1245 /* If it's a member function, just look at the function
1248 /* Determine address to call. */
1249 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
1251 funaddr
= VALUE_ADDRESS (function
);
1252 value_type
= TYPE_TARGET_TYPE (ftype
);
1254 else if (code
== TYPE_CODE_PTR
)
1256 funaddr
= value_as_pointer (function
);
1257 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
1258 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1259 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1261 funaddr
= CONVERT_FROM_FUNC_PTR_ADDR (funaddr
);
1262 value_type
= TYPE_TARGET_TYPE (ftype
);
1265 value_type
= builtin_type_int
;
1267 else if (code
== TYPE_CODE_INT
)
1269 /* Handle the case of functions lacking debugging info.
1270 Their values are characters since their addresses are char */
1271 if (TYPE_LENGTH (ftype
) == 1)
1272 funaddr
= value_as_pointer (value_addr (function
));
1274 /* Handle integer used as address of a function. */
1275 funaddr
= (CORE_ADDR
) value_as_long (function
);
1277 value_type
= builtin_type_int
;
1280 error ("Invalid data type for function to be called.");
1282 *retval_type
= value_type
;
1286 /* All this stuff with a dummy frame may seem unnecessarily complicated
1287 (why not just save registers in GDB?). The purpose of pushing a dummy
1288 frame which looks just like a real frame is so that if you call a
1289 function and then hit a breakpoint (get a signal, etc), "backtrace"
1290 will look right. Whether the backtrace needs to actually show the
1291 stack at the time the inferior function was called is debatable, but
1292 it certainly needs to not display garbage. So if you are contemplating
1293 making dummy frames be different from normal frames, consider that. */
1295 /* Perform a function call in the inferior.
1296 ARGS is a vector of values of arguments (NARGS of them).
1297 FUNCTION is a value, the function to be called.
1298 Returns a value representing what the function returned.
1299 May fail to return, if a breakpoint or signal is hit
1300 during the execution of the function.
1302 ARGS is modified to contain coerced values. */
1304 static value_ptr
hand_function_call (value_ptr function
, int nargs
,
1307 hand_function_call (value_ptr function
, int nargs
, value_ptr
*args
)
1309 register CORE_ADDR sp
;
1313 /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1314 is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
1315 and remove any extra bytes which might exist because ULONGEST is
1316 bigger than REGISTER_SIZE.
1318 NOTE: This is pretty wierd, as the call dummy is actually a
1319 sequence of instructions. But CISC machines will have
1320 to pack the instructions into REGISTER_SIZE units (and
1321 so will RISC machines for which INSTRUCTION_SIZE is not
1324 NOTE: This is pretty stupid. CALL_DUMMY should be in strict
1325 target byte order. */
1327 static ULONGEST
*dummy
;
1331 struct type
*value_type
;
1332 unsigned char struct_return
;
1333 CORE_ADDR struct_addr
= 0;
1334 struct inferior_status
*inf_status
;
1335 struct cleanup
*old_chain
;
1337 int using_gcc
; /* Set to version of gcc in use, or zero if not gcc */
1339 struct type
*param_type
= NULL
;
1340 struct type
*ftype
= check_typedef (SYMBOL_TYPE (function
));
1342 dummy
= alloca (SIZEOF_CALL_DUMMY_WORDS
);
1343 sizeof_dummy1
= REGISTER_SIZE
* SIZEOF_CALL_DUMMY_WORDS
/ sizeof (ULONGEST
);
1344 dummy1
= alloca (sizeof_dummy1
);
1345 memcpy (dummy
, CALL_DUMMY_WORDS
, SIZEOF_CALL_DUMMY_WORDS
);
1347 if (!target_has_execution
)
1350 inf_status
= save_inferior_status (1);
1351 old_chain
= make_cleanup_restore_inferior_status (inf_status
);
1353 /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1354 (and POP_FRAME for restoring them). (At least on most machines)
1355 they are saved on the stack in the inferior. */
1358 old_sp
= sp
= read_sp ();
1360 if (INNER_THAN (1, 2))
1362 /* Stack grows down */
1363 sp
-= sizeof_dummy1
;
1368 /* Stack grows up */
1370 sp
+= sizeof_dummy1
;
1373 funaddr
= find_function_addr (function
, &value_type
);
1374 CHECK_TYPEDEF (value_type
);
1377 struct block
*b
= block_for_pc (funaddr
);
1378 /* If compiled without -g, assume GCC 2. */
1379 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
1382 /* Are we returning a value using a structure return or a normal
1385 struct_return
= using_struct_return (function
, funaddr
, value_type
,
1388 /* Create a call sequence customized for this function
1389 and the number of arguments for it. */
1390 for (i
= 0; i
< (int) (SIZEOF_CALL_DUMMY_WORDS
/ sizeof (dummy
[0])); i
++)
1391 store_unsigned_integer (&dummy1
[i
* REGISTER_SIZE
],
1393 (ULONGEST
) dummy
[i
]);
1395 #ifdef GDB_TARGET_IS_HPPA
1396 real_pc
= FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1397 value_type
, using_gcc
);
1399 FIX_CALL_DUMMY (dummy1
, start_sp
, funaddr
, nargs
, args
,
1400 value_type
, using_gcc
);
1404 if (CALL_DUMMY_LOCATION
== ON_STACK
)
1406 write_memory (start_sp
, (char *) dummy1
, sizeof_dummy1
);
1409 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
)
1411 /* Convex Unix prohibits executing in the stack segment. */
1412 /* Hope there is empty room at the top of the text segment. */
1413 extern CORE_ADDR text_end
;
1414 static int checked
= 0;
1416 for (start_sp
= text_end
- sizeof_dummy1
; start_sp
< text_end
; ++start_sp
)
1417 if (read_memory_integer (start_sp
, 1) != 0)
1418 error ("text segment full -- no place to put call");
1421 real_pc
= text_end
- sizeof_dummy1
;
1422 write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1425 if (CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
1427 extern CORE_ADDR text_end
;
1431 errcode
= target_write_memory (real_pc
, (char *) dummy1
, sizeof_dummy1
);
1433 error ("Cannot write text segment -- call_function failed");
1436 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
1442 sp
= old_sp
; /* It really is used, for some ifdef's... */
1445 if (nargs
< TYPE_NFIELDS (ftype
))
1446 error ("too few arguments in function call");
1448 for (i
= nargs
- 1; i
>= 0; i
--)
1450 /* If we're off the end of the known arguments, do the standard
1451 promotions. FIXME: if we had a prototype, this should only
1452 be allowed if ... were present. */
1453 if (i
>= TYPE_NFIELDS (ftype
))
1454 args
[i
] = value_arg_coerce (args
[i
], NULL
, 0);
1458 int is_prototyped
= TYPE_FLAGS (ftype
) & TYPE_FLAG_PROTOTYPED
;
1459 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1461 args
[i
] = value_arg_coerce (args
[i
], param_type
, is_prototyped
);
1464 /*elz: this code is to handle the case in which the function to be called
1465 has a pointer to function as parameter and the corresponding actual argument
1466 is the address of a function and not a pointer to function variable.
1467 In aCC compiled code, the calls through pointers to functions (in the body
1468 of the function called by hand) are made via $$dyncall_external which
1469 requires some registers setting, this is taken care of if we call
1470 via a function pointer variable, but not via a function address.
1471 In cc this is not a problem. */
1475 /* if this parameter is a pointer to function */
1476 if (TYPE_CODE (param_type
) == TYPE_CODE_PTR
)
1477 if (TYPE_CODE (param_type
->target_type
) == TYPE_CODE_FUNC
)
1478 /* elz: FIXME here should go the test about the compiler used
1479 to compile the target. We want to issue the error
1480 message only if the compiler used was HP's aCC.
1481 If we used HP's cc, then there is no problem and no need
1482 to return at this point */
1483 if (using_gcc
== 0) /* && compiler == aCC */
1484 /* go see if the actual parameter is a variable of type
1485 pointer to function or just a function */
1486 if (args
[i
]->lval
== not_lval
)
1489 if (find_pc_partial_function ((CORE_ADDR
) args
[i
]->aligner
.contents
[0], &arg_name
, NULL
, NULL
))
1491 You cannot use function <%s> as argument. \n\
1492 You must use a pointer to function type variable. Command ignored.", arg_name
);
1496 if (REG_STRUCT_HAS_ADDR_P ())
1498 /* This is a machine like the sparc, where we may need to pass a
1499 pointer to the structure, not the structure itself. */
1500 for (i
= nargs
- 1; i
>= 0; i
--)
1502 struct type
*arg_type
= check_typedef (VALUE_TYPE (args
[i
]));
1503 if ((TYPE_CODE (arg_type
) == TYPE_CODE_STRUCT
1504 || TYPE_CODE (arg_type
) == TYPE_CODE_UNION
1505 || TYPE_CODE (arg_type
) == TYPE_CODE_ARRAY
1506 || TYPE_CODE (arg_type
) == TYPE_CODE_STRING
1507 || TYPE_CODE (arg_type
) == TYPE_CODE_BITSTRING
1508 || TYPE_CODE (arg_type
) == TYPE_CODE_SET
1509 || (TYPE_CODE (arg_type
) == TYPE_CODE_FLT
1510 && TYPE_LENGTH (arg_type
) > 8)
1512 && REG_STRUCT_HAS_ADDR (using_gcc
, arg_type
))
1515 int len
; /* = TYPE_LENGTH (arg_type); */
1517 arg_type
= check_typedef (VALUE_ENCLOSING_TYPE (args
[i
]));
1518 len
= TYPE_LENGTH (arg_type
);
1520 if (STACK_ALIGN_P ())
1521 /* MVS 11/22/96: I think at least some of this
1522 stack_align code is really broken. Better to let
1523 PUSH_ARGUMENTS adjust the stack in a target-defined
1525 aligned_len
= STACK_ALIGN (len
);
1528 if (INNER_THAN (1, 2))
1530 /* stack grows downward */
1535 /* The stack grows up, so the address of the thing
1536 we push is the stack pointer before we push it. */
1539 /* Push the structure. */
1540 write_memory (sp
, VALUE_CONTENTS_ALL (args
[i
]), len
);
1541 if (INNER_THAN (1, 2))
1543 /* The stack grows down, so the address of the thing
1544 we push is the stack pointer after we push it. */
1549 /* stack grows upward */
1552 /* The value we're going to pass is the address of the
1553 thing we just pushed. */
1554 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1556 args
[i
] = value_from_pointer (lookup_pointer_type (arg_type
),
1563 /* Reserve space for the return structure to be written on the
1564 stack, if necessary */
1568 int len
= TYPE_LENGTH (value_type
);
1569 if (STACK_ALIGN_P ())
1570 /* MVS 11/22/96: I think at least some of this stack_align
1571 code is really broken. Better to let PUSH_ARGUMENTS adjust
1572 the stack in a target-defined manner. */
1573 len
= STACK_ALIGN (len
);
1574 if (INNER_THAN (1, 2))
1576 /* stack grows downward */
1582 /* stack grows upward */
1588 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1589 on other architectures. This is because all the alignment is
1590 taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
1591 in hppa_push_arguments */
1592 if (EXTRA_STACK_ALIGNMENT_NEEDED
)
1594 /* MVS 11/22/96: I think at least some of this stack_align code
1595 is really broken. Better to let PUSH_ARGUMENTS adjust the
1596 stack in a target-defined manner. */
1597 if (STACK_ALIGN_P () && INNER_THAN (1, 2))
1599 /* If stack grows down, we must leave a hole at the top. */
1602 for (i
= nargs
- 1; i
>= 0; i
--)
1603 len
+= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
1604 if (CALL_DUMMY_STACK_ADJUST_P
)
1605 len
+= CALL_DUMMY_STACK_ADJUST
;
1606 sp
-= STACK_ALIGN (len
) - len
;
1610 sp
= PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
);
1612 #ifdef PUSH_RETURN_ADDRESS /* for targets that use no CALL_DUMMY */
1613 /* There are a number of targets now which actually don't write any
1614 CALL_DUMMY instructions into the target, but instead just save the
1615 machine state, push the arguments, and jump directly to the callee
1616 function. Since this doesn't actually involve executing a JSR/BSR
1617 instruction, the return address must be set up by hand, either by
1618 pushing onto the stack or copying into a return-address register
1619 as appropriate. Formerly this has been done in PUSH_ARGUMENTS,
1620 but that's overloading its functionality a bit, so I'm making it
1621 explicit to do it here. */
1622 sp
= PUSH_RETURN_ADDRESS (real_pc
, sp
);
1623 #endif /* PUSH_RETURN_ADDRESS */
1625 if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
1627 /* If stack grows up, we must leave a hole at the bottom, note
1628 that sp already has been advanced for the arguments! */
1629 if (CALL_DUMMY_STACK_ADJUST_P
)
1630 sp
+= CALL_DUMMY_STACK_ADJUST
;
1631 sp
= STACK_ALIGN (sp
);
1634 /* XXX This seems wrong. For stacks that grow down we shouldn't do
1636 /* MVS 11/22/96: I think at least some of this stack_align code is
1637 really broken. Better to let PUSH_ARGUMENTS adjust the stack in
1638 a target-defined manner. */
1639 if (CALL_DUMMY_STACK_ADJUST_P
)
1640 if (INNER_THAN (1, 2))
1642 /* stack grows downward */
1643 sp
-= CALL_DUMMY_STACK_ADJUST
;
1646 /* Store the address at which the structure is supposed to be
1647 written. Note that this (and the code which reserved the space
1648 above) assumes that gcc was used to compile this function. Since
1649 it doesn't cost us anything but space and if the function is pcc
1650 it will ignore this value, we will make that assumption.
1652 Also note that on some machines (like the sparc) pcc uses a
1653 convention like gcc's. */
1656 STORE_STRUCT_RETURN (struct_addr
, sp
);
1658 /* Write the stack pointer. This is here because the statements above
1659 might fool with it. On SPARC, this write also stores the register
1660 window into the right place in the new stack frame, which otherwise
1661 wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */
1664 if (SAVE_DUMMY_FRAME_TOS_P ())
1665 SAVE_DUMMY_FRAME_TOS (sp
);
1668 char *retbuf
= (char*) alloca (REGISTER_BYTES
);
1670 struct symbol
*symbol
;
1673 symbol
= find_pc_function (funaddr
);
1676 name
= SYMBOL_SOURCE_NAME (symbol
);
1680 /* Try the minimal symbols. */
1681 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
1685 name
= SYMBOL_SOURCE_NAME (msymbol
);
1691 sprintf (format
, "at %s", local_hex_format ());
1693 /* FIXME-32x64: assumes funaddr fits in a long. */
1694 sprintf (name
, format
, (unsigned long) funaddr
);
1697 /* Execute the stack dummy routine, calling FUNCTION.
1698 When it is done, discard the empty frame
1699 after storing the contents of all regs into retbuf. */
1700 rc
= run_stack_dummy (real_pc
+ CALL_DUMMY_START_OFFSET
, retbuf
);
1704 /* We stopped inside the FUNCTION because of a random signal.
1705 Further execution of the FUNCTION is not allowed. */
1707 if (unwind_on_signal_p
)
1709 /* The user wants the context restored. */
1711 /* We must get back to the frame we were before the dummy call. */
1714 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1715 a C++ name with arguments and stuff. */
1717 The program being debugged was signaled while in a function called from GDB.\n\
1718 GDB has restored the context to what it was before the call.\n\
1719 To change this behavior use \"set unwindonsignal off\"\n\
1720 Evaluation of the expression containing the function (%s) will be abandoned.",
1725 /* The user wants to stay in the frame where we stopped (default).*/
1727 /* If we did the cleanups, we would print a spurious error
1728 message (Unable to restore previously selected frame),
1729 would write the registers from the inf_status (which is
1730 wrong), and would do other wrong things. */
1731 discard_cleanups (old_chain
);
1732 discard_inferior_status (inf_status
);
1734 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1735 a C++ name with arguments and stuff. */
1737 The program being debugged was signaled while in a function called from GDB.\n\
1738 GDB remains in the frame where the signal was received.\n\
1739 To change this behavior use \"set unwindonsignal on\"\n\
1740 Evaluation of the expression containing the function (%s) will be abandoned.",
1747 /* We hit a breakpoint inside the FUNCTION. */
1749 /* If we did the cleanups, we would print a spurious error
1750 message (Unable to restore previously selected frame),
1751 would write the registers from the inf_status (which is
1752 wrong), and would do other wrong things. */
1753 discard_cleanups (old_chain
);
1754 discard_inferior_status (inf_status
);
1756 /* The following error message used to say "The expression
1757 which contained the function call has been discarded." It
1758 is a hard concept to explain in a few words. Ideally, GDB
1759 would be able to resume evaluation of the expression when
1760 the function finally is done executing. Perhaps someday
1761 this will be implemented (it would not be easy). */
1763 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1764 a C++ name with arguments and stuff. */
1766 The program being debugged stopped while in a function called from GDB.\n\
1767 When the function (%s) is done executing, GDB will silently\n\
1768 stop (instead of continuing to evaluate the expression containing\n\
1769 the function call).", name
);
1772 /* If we get here the called FUNCTION run to completion. */
1773 do_cleanups (old_chain
);
1775 /* Figure out the value returned by the function. */
1776 /* elz: I defined this new macro for the hppa architecture only.
1777 this gives us a way to get the value returned by the function from the stack,
1778 at the same address we told the function to put it.
1779 We cannot assume on the pa that r28 still contains the address of the returned
1780 structure. Usually this will be overwritten by the callee.
1781 I don't know about other architectures, so I defined this macro
1784 #ifdef VALUE_RETURNED_FROM_STACK
1786 return (value_ptr
) VALUE_RETURNED_FROM_STACK (value_type
, struct_addr
);
1789 return value_being_returned (value_type
, retbuf
, struct_return
);
1794 call_function_by_hand (value_ptr function
, int nargs
, value_ptr
*args
)
1798 return hand_function_call (function
, nargs
, args
);
1802 error ("Cannot invoke functions on this machine.");
1808 /* Create a value for an array by allocating space in the inferior, copying
1809 the data into that space, and then setting up an array value.
1811 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1812 populated from the values passed in ELEMVEC.
1814 The element type of the array is inherited from the type of the
1815 first element, and all elements must have the same size (though we
1816 don't currently enforce any restriction on their types). */
1819 value_array (int lowbound
, int highbound
, value_ptr
*elemvec
)
1823 unsigned int typelength
;
1825 struct type
*rangetype
;
1826 struct type
*arraytype
;
1829 /* Validate that the bounds are reasonable and that each of the elements
1830 have the same size. */
1832 nelem
= highbound
- lowbound
+ 1;
1835 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1837 typelength
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[0]));
1838 for (idx
= 1; idx
< nelem
; idx
++)
1840 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[idx
])) != typelength
)
1842 error ("array elements must all be the same size");
1846 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1847 lowbound
, highbound
);
1848 arraytype
= create_array_type ((struct type
*) NULL
,
1849 VALUE_ENCLOSING_TYPE (elemvec
[0]), rangetype
);
1851 if (!current_language
->c_style_arrays
)
1853 val
= allocate_value (arraytype
);
1854 for (idx
= 0; idx
< nelem
; idx
++)
1856 memcpy (VALUE_CONTENTS_ALL_RAW (val
) + (idx
* typelength
),
1857 VALUE_CONTENTS_ALL (elemvec
[idx
]),
1860 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (elemvec
[0]);
1864 /* Allocate space to store the array in the inferior, and then initialize
1865 it by copying in each element. FIXME: Is it worth it to create a
1866 local buffer in which to collect each value and then write all the
1867 bytes in one operation? */
1869 addr
= allocate_space_in_inferior (nelem
* typelength
);
1870 for (idx
= 0; idx
< nelem
; idx
++)
1872 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS_ALL (elemvec
[idx
]),
1876 /* Create the array type and set up an array value to be evaluated lazily. */
1878 val
= value_at_lazy (arraytype
, addr
, VALUE_BFD_SECTION (elemvec
[0]));
1882 /* Create a value for a string constant by allocating space in the inferior,
1883 copying the data into that space, and returning the address with type
1884 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1886 Note that string types are like array of char types with a lower bound of
1887 zero and an upper bound of LEN - 1. Also note that the string may contain
1888 embedded null bytes. */
1891 value_string (char *ptr
, int len
)
1894 int lowbound
= current_language
->string_lower_bound
;
1895 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1897 lowbound
, len
+ lowbound
- 1);
1898 struct type
*stringtype
1899 = create_string_type ((struct type
*) NULL
, rangetype
);
1902 if (current_language
->c_style_arrays
== 0)
1904 val
= allocate_value (stringtype
);
1905 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1910 /* Allocate space to store the string in the inferior, and then
1911 copy LEN bytes from PTR in gdb to that address in the inferior. */
1913 addr
= allocate_space_in_inferior (len
);
1914 write_memory (addr
, ptr
, len
);
1916 val
= value_at_lazy (stringtype
, addr
, NULL
);
1921 value_bitstring (char *ptr
, int len
)
1924 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1926 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1927 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1928 val
= allocate_value (type
);
1929 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1933 /* See if we can pass arguments in T2 to a function which takes arguments
1934 of types T1. Both t1 and t2 are NULL-terminated vectors. If some
1935 arguments need coercion of some sort, then the coerced values are written
1936 into T2. Return value is 0 if the arguments could be matched, or the
1937 position at which they differ if not.
1939 STATICP is nonzero if the T1 argument list came from a
1940 static member function.
1942 For non-static member functions, we ignore the first argument,
1943 which is the type of the instance variable. This is because we want
1944 to handle calls with objects from derived classes. This is not
1945 entirely correct: we should actually check to make sure that a
1946 requested operation is type secure, shouldn't we? FIXME. */
1949 typecmp (int staticp
, struct type
*t1
[], value_ptr t2
[])
1955 if (staticp
&& t1
== 0)
1959 if (TYPE_CODE (t1
[0]) == TYPE_CODE_VOID
)
1961 if (t1
[!staticp
] == 0)
1963 for (i
= !staticp
; t1
[i
] && TYPE_CODE (t1
[i
]) != TYPE_CODE_VOID
; i
++)
1965 struct type
*tt1
, *tt2
;
1968 tt1
= check_typedef (t1
[i
]);
1969 tt2
= check_typedef (VALUE_TYPE (t2
[i
]));
1970 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1971 /* We should be doing hairy argument matching, as below. */
1972 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1974 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1975 t2
[i
] = value_coerce_array (t2
[i
]);
1977 t2
[i
] = value_addr (t2
[i
]);
1981 /* djb - 20000715 - Until the new type structure is in the
1982 place, and we can attempt things like implicit conversions,
1983 we need to do this so you can take something like a map<const
1984 char *>, and properly access map["hello"], because the
1985 argument to [] will be a reference to a pointer to a char,
1986 and the argument will be a pointer to a char. */
1987 while ( TYPE_CODE(tt1
) == TYPE_CODE_REF
||
1988 TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1990 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1992 while ( TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
||
1993 TYPE_CODE(tt2
) == TYPE_CODE_PTR
||
1994 TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1996 tt2
= check_typedef( TYPE_TARGET_TYPE(tt2
) );
1998 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
2000 /* Array to pointer is a `trivial conversion' according to the ARM. */
2002 /* We should be doing much hairier argument matching (see section 13.2
2003 of the ARM), but as a quick kludge, just check for the same type
2005 if (TYPE_CODE (t1
[i
]) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
2010 return t2
[i
] ? i
+ 1 : 0;
2013 /* Helper function used by value_struct_elt to recurse through baseclasses.
2014 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2015 and search in it assuming it has (class) type TYPE.
2016 If found, return value, else return NULL.
2018 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
2019 look for a baseclass named NAME. */
2022 search_struct_field (char *name
, register value_ptr arg1
, int offset
,
2023 register struct type
*type
, int looking_for_baseclass
)
2026 int nbases
= TYPE_N_BASECLASSES (type
);
2028 CHECK_TYPEDEF (type
);
2030 if (!looking_for_baseclass
)
2031 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
2033 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2035 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2038 if (TYPE_FIELD_STATIC (type
, i
))
2039 v
= value_static_field (type
, i
);
2041 v
= value_primitive_field (arg1
, offset
, i
, type
);
2043 error ("there is no field named %s", name
);
2048 && (t_field_name
[0] == '\0'
2049 || (TYPE_CODE (type
) == TYPE_CODE_UNION
2050 && (strcmp_iw (t_field_name
, "else") == 0))))
2052 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
2053 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
2054 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
2056 /* Look for a match through the fields of an anonymous union,
2057 or anonymous struct. C++ provides anonymous unions.
2059 In the GNU Chill implementation of variant record types,
2060 each <alternative field> has an (anonymous) union type,
2061 each member of the union represents a <variant alternative>.
2062 Each <variant alternative> is represented as a struct,
2063 with a member for each <variant field>. */
2066 int new_offset
= offset
;
2068 /* This is pretty gross. In G++, the offset in an anonymous
2069 union is relative to the beginning of the enclosing struct.
2070 In the GNU Chill implementation of variant records,
2071 the bitpos is zero in an anonymous union field, so we
2072 have to add the offset of the union here. */
2073 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
2074 || (TYPE_NFIELDS (field_type
) > 0
2075 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2076 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2078 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
2079 looking_for_baseclass
);
2086 for (i
= 0; i
< nbases
; i
++)
2089 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2090 /* If we are looking for baseclasses, this is what we get when we
2091 hit them. But it could happen that the base part's member name
2092 is not yet filled in. */
2093 int found_baseclass
= (looking_for_baseclass
2094 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2095 && (strcmp_iw (name
, TYPE_BASECLASS_NAME (type
, i
)) == 0));
2097 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2100 value_ptr v2
= allocate_value (basetype
);
2102 boffset
= baseclass_offset (type
, i
,
2103 VALUE_CONTENTS (arg1
) + offset
,
2104 VALUE_ADDRESS (arg1
)
2105 + VALUE_OFFSET (arg1
) + offset
);
2107 error ("virtual baseclass botch");
2109 /* The virtual base class pointer might have been clobbered by the
2110 user program. Make sure that it still points to a valid memory
2114 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
2116 CORE_ADDR base_addr
;
2118 base_addr
= VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
) + boffset
;
2119 if (target_read_memory (base_addr
, VALUE_CONTENTS_RAW (v2
),
2120 TYPE_LENGTH (basetype
)) != 0)
2121 error ("virtual baseclass botch");
2122 VALUE_LVAL (v2
) = lval_memory
;
2123 VALUE_ADDRESS (v2
) = base_addr
;
2127 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
2128 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
2129 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + boffset
;
2130 if (VALUE_LAZY (arg1
))
2131 VALUE_LAZY (v2
) = 1;
2133 memcpy (VALUE_CONTENTS_RAW (v2
),
2134 VALUE_CONTENTS_RAW (arg1
) + boffset
,
2135 TYPE_LENGTH (basetype
));
2138 if (found_baseclass
)
2140 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
2141 looking_for_baseclass
);
2143 else if (found_baseclass
)
2144 v
= value_primitive_field (arg1
, offset
, i
, type
);
2146 v
= search_struct_field (name
, arg1
,
2147 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
2148 basetype
, looking_for_baseclass
);
2156 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2157 * in an object pointed to by VALADDR (on the host), assumed to be of
2158 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
2159 * looking (in case VALADDR is the contents of an enclosing object).
2161 * This routine recurses on the primary base of the derived class because
2162 * the virtual base entries of the primary base appear before the other
2163 * virtual base entries.
2165 * If the virtual base is not found, a negative integer is returned.
2166 * The magnitude of the negative integer is the number of entries in
2167 * the virtual table to skip over (entries corresponding to various
2168 * ancestral classes in the chain of primary bases).
2170 * Important: This assumes the HP / Taligent C++ runtime
2171 * conventions. Use baseclass_offset() instead to deal with g++
2175 find_rt_vbase_offset (struct type
*type
, struct type
*basetype
, char *valaddr
,
2176 int offset
, int *boffset_p
, int *skip_p
)
2178 int boffset
; /* offset of virtual base */
2179 int index
; /* displacement to use in virtual table */
2183 CORE_ADDR vtbl
; /* the virtual table pointer */
2184 struct type
*pbc
; /* the primary base class */
2186 /* Look for the virtual base recursively in the primary base, first.
2187 * This is because the derived class object and its primary base
2188 * subobject share the primary virtual table. */
2191 pbc
= TYPE_PRIMARY_BASE (type
);
2194 find_rt_vbase_offset (pbc
, basetype
, valaddr
, offset
, &boffset
, &skip
);
2197 *boffset_p
= boffset
;
2206 /* Find the index of the virtual base according to HP/Taligent
2207 runtime spec. (Depth-first, left-to-right.) */
2208 index
= virtual_base_index_skip_primaries (basetype
, type
);
2212 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
2217 /* pai: FIXME -- 32x64 possible problem */
2218 /* First word (4 bytes) in object layout is the vtable pointer */
2219 vtbl
= *(CORE_ADDR
*) (valaddr
+ offset
);
2221 /* Before the constructor is invoked, things are usually zero'd out. */
2223 error ("Couldn't find virtual table -- object may not be constructed yet.");
2226 /* Find virtual base's offset -- jump over entries for primary base
2227 * ancestors, then use the index computed above. But also adjust by
2228 * HP_ACC_VBASE_START for the vtable slots before the start of the
2229 * virtual base entries. Offset is negative -- virtual base entries
2230 * appear _before_ the address point of the virtual table. */
2232 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2235 /* epstein : FIXME -- added param for overlay section. May not be correct */
2236 vp
= value_at (builtin_type_int
, vtbl
+ 4 * (-skip
- index
- HP_ACC_VBASE_START
), NULL
);
2237 boffset
= value_as_long (vp
);
2239 *boffset_p
= boffset
;
2244 /* Helper function used by value_struct_elt to recurse through baseclasses.
2245 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2246 and search in it assuming it has (class) type TYPE.
2247 If found, return value, else if name matched and args not return (value)-1,
2248 else return NULL. */
2251 search_struct_method (char *name
, register value_ptr
*arg1p
,
2252 register value_ptr
*args
, int offset
,
2253 int *static_memfuncp
, register struct type
*type
)
2257 int name_matched
= 0;
2258 char dem_opname
[64];
2260 CHECK_TYPEDEF (type
);
2261 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2263 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2264 /* FIXME! May need to check for ARM demangling here */
2265 if (strncmp (t_field_name
, "__", 2) == 0 ||
2266 strncmp (t_field_name
, "op", 2) == 0 ||
2267 strncmp (t_field_name
, "type", 4) == 0)
2269 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2270 t_field_name
= dem_opname
;
2271 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2272 t_field_name
= dem_opname
;
2274 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2276 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2277 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2280 if (j
> 0 && args
== 0)
2281 error ("cannot resolve overloaded method `%s': no arguments supplied", name
);
2284 if (TYPE_FN_FIELD_STUB (f
, j
))
2285 check_stub_method (type
, i
, j
);
2286 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2287 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2289 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2290 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
2291 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
2292 *static_memfuncp
= 1;
2293 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2302 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2306 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2308 if (TYPE_HAS_VTABLE (type
))
2310 /* HP aCC compiled type, search for virtual base offset
2311 according to HP/Taligent runtime spec. */
2313 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2314 VALUE_CONTENTS_ALL (*arg1p
),
2315 offset
+ VALUE_EMBEDDED_OFFSET (*arg1p
),
2316 &base_offset
, &skip
);
2318 error ("Virtual base class offset not found in vtable");
2322 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2325 /* The virtual base class pointer might have been clobbered by the
2326 user program. Make sure that it still points to a valid memory
2329 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2331 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
2332 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
2333 + VALUE_OFFSET (*arg1p
) + offset
,
2335 TYPE_LENGTH (baseclass
)) != 0)
2336 error ("virtual baseclass botch");
2339 base_valaddr
= VALUE_CONTENTS (*arg1p
) + offset
;
2342 baseclass_offset (type
, i
, base_valaddr
,
2343 VALUE_ADDRESS (*arg1p
)
2344 + VALUE_OFFSET (*arg1p
) + offset
);
2345 if (base_offset
== -1)
2346 error ("virtual baseclass botch");
2351 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2353 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2354 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2355 if (v
== (value_ptr
) - 1)
2361 /* FIXME-bothner: Why is this commented out? Why is it here? */
2362 /* *arg1p = arg1_tmp; */
2367 return (value_ptr
) - 1;
2372 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2373 extract the component named NAME from the ultimate target structure/union
2374 and return it as a value with its appropriate type.
2375 ERR is used in the error message if *ARGP's type is wrong.
2377 C++: ARGS is a list of argument types to aid in the selection of
2378 an appropriate method. Also, handle derived types.
2380 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2381 where the truthvalue of whether the function that was resolved was
2382 a static member function or not is stored.
2384 ERR is an error message to be printed in case the field is not found. */
2387 value_struct_elt (register value_ptr
*argp
, register value_ptr
*args
,
2388 char *name
, int *static_memfuncp
, char *err
)
2390 register struct type
*t
;
2393 COERCE_ARRAY (*argp
);
2395 t
= check_typedef (VALUE_TYPE (*argp
));
2397 /* Follow pointers until we get to a non-pointer. */
2399 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2401 *argp
= value_ind (*argp
);
2402 /* Don't coerce fn pointer to fn and then back again! */
2403 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2404 COERCE_ARRAY (*argp
);
2405 t
= check_typedef (VALUE_TYPE (*argp
));
2408 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2409 error ("not implemented: member type in value_struct_elt");
2411 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2412 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2413 error ("Attempt to extract a component of a value that is not a %s.", err
);
2415 /* Assume it's not, unless we see that it is. */
2416 if (static_memfuncp
)
2417 *static_memfuncp
= 0;
2421 /* if there are no arguments ...do this... */
2423 /* Try as a field first, because if we succeed, there
2424 is less work to be done. */
2425 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2429 /* C++: If it was not found as a data field, then try to
2430 return it as a pointer to a method. */
2432 if (destructor_name_p (name
, t
))
2433 error ("Cannot get value of destructor");
2435 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2437 if (v
== (value_ptr
) - 1)
2438 error ("Cannot take address of a method");
2441 if (TYPE_NFN_FIELDS (t
))
2442 error ("There is no member or method named %s.", name
);
2444 error ("There is no member named %s.", name
);
2449 if (destructor_name_p (name
, t
))
2453 /* Destructors are a special case. */
2454 int m_index
, f_index
;
2457 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
2459 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, m_index
),
2463 error ("could not find destructor function named %s.", name
);
2469 error ("destructor should not have any argument");
2473 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
2475 if (v
== (value_ptr
) - 1)
2477 error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name
);
2481 /* See if user tried to invoke data as function. If so,
2482 hand it back. If it's not callable (i.e., a pointer to function),
2483 gdb should give an error. */
2484 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2488 error ("Structure has no component named %s.", name
);
2492 /* Search through the methods of an object (and its bases)
2493 * to find a specified method. Return the pointer to the
2494 * fn_field list of overloaded instances.
2495 * Helper function for value_find_oload_list.
2496 * ARGP is a pointer to a pointer to a value (the object)
2497 * METHOD is a string containing the method name
2498 * OFFSET is the offset within the value
2499 * STATIC_MEMFUNCP is set if the method is static
2500 * TYPE is the assumed type of the object
2501 * NUM_FNS is the number of overloaded instances
2502 * BASETYPE is set to the actual type of the subobject where the method is found
2503 * BOFFSET is the offset of the base subobject where the method is found */
2505 static struct fn_field
*
2506 find_method_list (value_ptr
*argp
, char *method
, int offset
,
2507 int *static_memfuncp
, struct type
*type
, int *num_fns
,
2508 struct type
**basetype
, int *boffset
)
2512 CHECK_TYPEDEF (type
);
2516 /* First check in object itself */
2517 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2519 /* pai: FIXME What about operators and type conversions? */
2520 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2521 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2523 *num_fns
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2526 return TYPE_FN_FIELDLIST1 (type
, i
);
2530 /* Not found in object, check in base subobjects */
2531 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2534 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2536 if (TYPE_HAS_VTABLE (type
))
2538 /* HP aCC compiled type, search for virtual base offset
2539 * according to HP/Taligent runtime spec. */
2541 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
2542 VALUE_CONTENTS_ALL (*argp
),
2543 offset
+ VALUE_EMBEDDED_OFFSET (*argp
),
2544 &base_offset
, &skip
);
2546 error ("Virtual base class offset not found in vtable");
2550 /* probably g++ runtime model */
2551 base_offset
= VALUE_OFFSET (*argp
) + offset
;
2553 baseclass_offset (type
, i
,
2554 VALUE_CONTENTS (*argp
) + base_offset
,
2555 VALUE_ADDRESS (*argp
) + base_offset
);
2556 if (base_offset
== -1)
2557 error ("virtual baseclass botch");
2561 /* non-virtual base, simply use bit position from debug info */
2563 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2565 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2566 static_memfuncp
, TYPE_BASECLASS (type
, i
), num_fns
, basetype
, boffset
);
2573 /* Return the list of overloaded methods of a specified name.
2574 * ARGP is a pointer to a pointer to a value (the object)
2575 * METHOD is the method name
2576 * OFFSET is the offset within the value contents
2577 * STATIC_MEMFUNCP is set if the method is static
2578 * NUM_FNS is the number of overloaded instances
2579 * BASETYPE is set to the type of the base subobject that defines the method
2580 * BOFFSET is the offset of the base subobject which defines the method */
2583 value_find_oload_method_list (value_ptr
*argp
, char *method
, int offset
,
2584 int *static_memfuncp
, int *num_fns
,
2585 struct type
**basetype
, int *boffset
)
2589 t
= check_typedef (VALUE_TYPE (*argp
));
2591 /* code snarfed from value_struct_elt */
2592 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2594 *argp
= value_ind (*argp
);
2595 /* Don't coerce fn pointer to fn and then back again! */
2596 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
2597 COERCE_ARRAY (*argp
);
2598 t
= check_typedef (VALUE_TYPE (*argp
));
2601 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2602 error ("Not implemented: member type in value_find_oload_lis");
2604 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2605 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2606 error ("Attempt to extract a component of a value that is not a struct or union");
2608 /* Assume it's not static, unless we see that it is. */
2609 if (static_memfuncp
)
2610 *static_memfuncp
= 0;
2612 return find_method_list (argp
, method
, 0, static_memfuncp
, t
, num_fns
, basetype
, boffset
);
2616 /* Given an array of argument types (ARGTYPES) (which includes an
2617 entry for "this" in the case of C++ methods), the number of
2618 arguments NARGS, the NAME of a function whether it's a method or
2619 not (METHOD), and the degree of laxness (LAX) in conforming to
2620 overload resolution rules in ANSI C++, find the best function that
2621 matches on the argument types according to the overload resolution
2624 In the case of class methods, the parameter OBJ is an object value
2625 in which to search for overloaded methods.
2627 In the case of non-method functions, the parameter FSYM is a symbol
2628 corresponding to one of the overloaded functions.
2630 Return value is an integer: 0 -> good match, 10 -> debugger applied
2631 non-standard coercions, 100 -> incompatible.
2633 If a method is being searched for, VALP will hold the value.
2634 If a non-method is being searched for, SYMP will hold the symbol for it.
2636 If a method is being searched for, and it is a static method,
2637 then STATICP will point to a non-zero value.
2639 Note: This function does *not* check the value of
2640 overload_resolution. Caller must check it to see whether overload
2641 resolution is permitted.
2645 find_overload_match (struct type
**arg_types
, int nargs
, char *name
, int method
,
2646 int lax
, value_ptr obj
, struct symbol
*fsym
,
2647 value_ptr
*valp
, struct symbol
**symp
, int *staticp
)
2650 struct type
**parm_types
;
2651 int champ_nparms
= 0;
2653 short oload_champ
= -1; /* Index of best overloaded function */
2654 short oload_ambiguous
= 0; /* Current ambiguity state for overload resolution */
2655 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2656 short oload_ambig_champ
= -1; /* 2nd contender for best match */
2657 short oload_non_standard
= 0; /* did we have to use non-standard conversions? */
2658 short oload_incompatible
= 0; /* are args supplied incompatible with any function? */
2660 struct badness_vector
*bv
; /* A measure of how good an overloaded instance is */
2661 struct badness_vector
*oload_champ_bv
= NULL
; /* The measure for the current best match */
2663 value_ptr temp
= obj
;
2664 struct fn_field
*fns_ptr
= NULL
; /* For methods, the list of overloaded methods */
2665 struct symbol
**oload_syms
= NULL
; /* For non-methods, the list of overloaded function symbols */
2666 int num_fns
= 0; /* Number of overloaded instances being considered */
2667 struct type
*basetype
= NULL
;
2672 char *obj_type_name
= NULL
;
2673 char *func_name
= NULL
;
2675 /* Get the list of overloaded methods or functions */
2680 struct type
*domain
;
2681 obj_type_name
= TYPE_NAME (VALUE_TYPE (obj
));
2682 /* Hack: evaluate_subexp_standard often passes in a pointer
2683 value rather than the object itself, so try again */
2684 if ((!obj_type_name
|| !*obj_type_name
) &&
2685 (TYPE_CODE (VALUE_TYPE (obj
)) == TYPE_CODE_PTR
))
2686 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj
)));
2688 fns_ptr
= value_find_oload_method_list (&temp
, name
, 0,
2691 &basetype
, &boffset
);
2692 if (!fns_ptr
|| !num_fns
)
2693 error ("Couldn't find method %s%s%s",
2695 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2697 domain
= TYPE_DOMAIN_TYPE (fns_ptr
[0].type
);
2698 len
= TYPE_NFN_FIELDS (domain
);
2699 /* NOTE: dan/2000-03-10: This stuff is for STABS, which won't
2700 give us the info we need directly in the types. We have to
2701 use the method stub conversion to get it. Be aware that this
2702 is by no means perfect, and if you use STABS, please move to
2703 DWARF-2, or something like it, because trying to improve
2704 overloading using STABS is really a waste of time. */
2705 for (i
= 0; i
< len
; i
++)
2708 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (domain
, i
);
2709 int len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
2711 for (j
= 0; j
< len2
; j
++)
2713 if (TYPE_FN_FIELD_STUB (f
, j
) && (!strcmp_iw (TYPE_FN_FIELDLIST_NAME (domain
,i
),name
)))
2714 check_stub_method (domain
, i
, j
);
2721 func_name
= cplus_demangle (SYMBOL_NAME (fsym
), DMGL_NO_OPTS
);
2723 /* If the name is NULL this must be a C-style function.
2724 Just return the same symbol. */
2731 oload_syms
= make_symbol_overload_list (fsym
);
2732 while (oload_syms
[++i
])
2735 error ("Couldn't find function %s", func_name
);
2738 oload_champ_bv
= NULL
;
2740 /* Consider each candidate in turn */
2741 for (ix
= 0; ix
< num_fns
; ix
++)
2745 /* For static member functions, we won't have a this pointer, but nothing
2746 else seems to handle them right now, so we just pretend ourselves */
2749 if (TYPE_FN_FIELD_ARGS(fns_ptr
,ix
))
2751 while (TYPE_CODE(TYPE_FN_FIELD_ARGS(fns_ptr
,ix
)[nparms
]) != TYPE_CODE_VOID
)
2757 /* If it's not a method, this is the proper place */
2758 nparms
=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms
[ix
]));
2761 /* Prepare array of parameter types */
2762 parm_types
= (struct type
**) xmalloc (nparms
* (sizeof (struct type
*)));
2763 for (jj
= 0; jj
< nparms
; jj
++)
2764 parm_types
[jj
] = (method
2765 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
])
2766 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]), jj
));
2768 /* Compare parameter types to supplied argument types */
2769 bv
= rank_function (parm_types
, nparms
, arg_types
, nargs
);
2771 if (!oload_champ_bv
)
2773 oload_champ_bv
= bv
;
2775 champ_nparms
= nparms
;
2778 /* See whether current candidate is better or worse than previous best */
2779 switch (compare_badness (bv
, oload_champ_bv
))
2782 oload_ambiguous
= 1; /* top two contenders are equally good */
2783 oload_ambig_champ
= ix
;
2786 oload_ambiguous
= 2; /* incomparable top contenders */
2787 oload_ambig_champ
= ix
;
2790 oload_champ_bv
= bv
; /* new champion, record details */
2791 oload_ambiguous
= 0;
2793 oload_ambig_champ
= -1;
2794 champ_nparms
= nparms
;
2804 fprintf_filtered (gdb_stderr
,"Overloaded method instance %s, # of parms %d\n", fns_ptr
[ix
].physname
, nparms
);
2806 fprintf_filtered (gdb_stderr
,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]), nparms
);
2807 for (jj
= 0; jj
< nargs
; jj
++)
2808 fprintf_filtered (gdb_stderr
,"...Badness @ %d : %d\n", jj
, bv
->rank
[jj
]);
2809 fprintf_filtered (gdb_stderr
,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ
, oload_ambiguous
);
2811 } /* end loop over all candidates */
2812 /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2813 if they have the exact same goodness. This is because there is no
2814 way to differentiate based on return type, which we need to in
2815 cases like overloads of .begin() <It's both const and non-const> */
2817 if (oload_ambiguous
)
2820 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2822 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2825 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2830 /* Check how bad the best match is */
2831 for (ix
= 1; ix
<= nargs
; ix
++)
2833 if (oload_champ_bv
->rank
[ix
] >= 100)
2834 oload_incompatible
= 1; /* truly mismatched types */
2836 else if (oload_champ_bv
->rank
[ix
] >= 10)
2837 oload_non_standard
= 1; /* non-standard type conversions needed */
2839 if (oload_incompatible
)
2842 error ("Cannot resolve method %s%s%s to any overloaded instance",
2844 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2847 error ("Cannot resolve function %s to any overloaded instance",
2850 else if (oload_non_standard
)
2853 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2855 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2858 warning ("Using non-standard conversion to match function %s to supplied arguments",
2864 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2865 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2867 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2871 *symp
= oload_syms
[oload_champ
];
2875 return oload_incompatible
? 100 : (oload_non_standard
? 10 : 0);
2878 /* C++: return 1 is NAME is a legitimate name for the destructor
2879 of type TYPE. If TYPE does not have a destructor, or
2880 if NAME is inappropriate for TYPE, an error is signaled. */
2882 destructor_name_p (const char *name
, const struct type
*type
)
2884 /* destructors are a special case. */
2888 char *dname
= type_name_no_tag (type
);
2889 char *cp
= strchr (dname
, '<');
2892 /* Do not compare the template part for template classes. */
2894 len
= strlen (dname
);
2897 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
2898 error ("name of destructor must equal name of class");
2905 /* Helper function for check_field: Given TYPE, a structure/union,
2906 return 1 if the component named NAME from the ultimate
2907 target structure/union is defined, otherwise, return 0. */
2910 check_field_in (register struct type
*type
, const char *name
)
2914 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2916 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2917 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2921 /* C++: If it was not found as a data field, then try to
2922 return it as a pointer to a method. */
2924 /* Destructors are a special case. */
2925 if (destructor_name_p (name
, type
))
2927 int m_index
, f_index
;
2929 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2932 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2934 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2938 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2939 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2946 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2947 return 1 if the component named NAME from the ultimate
2948 target structure/union is defined, otherwise, return 0. */
2951 check_field (register value_ptr arg1
, const char *name
)
2953 register struct type
*t
;
2955 COERCE_ARRAY (arg1
);
2957 t
= VALUE_TYPE (arg1
);
2959 /* Follow pointers until we get to a non-pointer. */
2964 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
2966 t
= TYPE_TARGET_TYPE (t
);
2969 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2970 error ("not implemented: member type in check_field");
2972 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2973 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2974 error ("Internal error: `this' is not an aggregate");
2976 return check_field_in (t
, name
);
2979 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2980 return the address of this member as a "pointer to member"
2981 type. If INTYPE is non-null, then it will be the type
2982 of the member we are looking for. This will help us resolve
2983 "pointers to member functions". This function is used
2984 to resolve user expressions of the form "DOMAIN::NAME". */
2987 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2988 struct type
*curtype
, char *name
,
2989 struct type
*intype
)
2991 register struct type
*t
= curtype
;
2995 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2996 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2997 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2999 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3001 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
3003 if (t_field_name
&& STREQ (t_field_name
, name
))
3005 if (TYPE_FIELD_STATIC (t
, i
))
3007 v
= value_static_field (t
, i
);
3009 error ("Internal error: could not find static variable %s",
3013 if (TYPE_FIELD_PACKED (t
, i
))
3014 error ("pointers to bitfield members not allowed");
3016 return value_from_longest
3017 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
3019 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
3023 /* C++: If it was not found as a data field, then try to
3024 return it as a pointer to a method. */
3026 /* Destructors are a special case. */
3027 if (destructor_name_p (name
, t
))
3029 error ("member pointers to destructors not implemented yet");
3032 /* Perform all necessary dereferencing. */
3033 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
3034 intype
= TYPE_TARGET_TYPE (intype
);
3036 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3038 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3039 char dem_opname
[64];
3041 if (strncmp (t_field_name
, "__", 2) == 0 ||
3042 strncmp (t_field_name
, "op", 2) == 0 ||
3043 strncmp (t_field_name
, "type", 4) == 0)
3045 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
3046 t_field_name
= dem_opname
;
3047 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
3048 t_field_name
= dem_opname
;
3050 if (t_field_name
&& STREQ (t_field_name
, name
))
3052 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3053 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3055 if (intype
== 0 && j
> 1)
3056 error ("non-unique member `%s' requires type instantiation", name
);
3060 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
3063 error ("no member function matches that type instantiation");
3068 if (TYPE_FN_FIELD_STUB (f
, j
))
3069 check_stub_method (t
, i
, j
);
3070 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3072 return value_from_longest
3073 (lookup_reference_type
3074 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
3076 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
3080 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3081 0, VAR_NAMESPACE
, 0, NULL
);
3088 v
= read_var_value (s
, 0);
3090 VALUE_TYPE (v
) = lookup_reference_type
3091 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
3099 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3104 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3107 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3108 v
= value_struct_elt_for_reference (domain
,
3109 offset
+ base_offset
,
3110 TYPE_BASECLASS (t
, i
),
3120 /* Find the real run-time type of a value using RTTI.
3121 * V is a pointer to the value.
3122 * A pointer to the struct type entry of the run-time type
3124 * FULL is a flag that is set only if the value V includes
3125 * the entire contents of an object of the RTTI type.
3126 * TOP is the offset to the top of the enclosing object of
3127 * the real run-time type. This offset may be for the embedded
3128 * object, or for the enclosing object of V.
3129 * USING_ENC is the flag that distinguishes the two cases.
3130 * If it is 1, then the offset is for the enclosing object,
3131 * otherwise for the embedded object.
3136 value_rtti_type (value_ptr v
, int *full
, int *top
, int *using_enc
)
3138 struct type
*known_type
;
3139 struct type
*rtti_type
;
3142 int using_enclosing
= 0;
3143 long top_offset
= 0;
3144 char rtti_type_name
[256];
3153 /* Get declared type */
3154 known_type
= VALUE_TYPE (v
);
3155 CHECK_TYPEDEF (known_type
);
3156 /* RTTI works only or class objects */
3157 if (TYPE_CODE (known_type
) != TYPE_CODE_CLASS
)
3159 if (TYPE_HAS_VTABLE(known_type
))
3161 /* If neither the declared type nor the enclosing type of the
3162 * value structure has a HP ANSI C++ style virtual table,
3163 * we can't do anything. */
3164 if (!TYPE_HAS_VTABLE (known_type
))
3166 known_type
= VALUE_ENCLOSING_TYPE (v
);
3167 CHECK_TYPEDEF (known_type
);
3168 if ((TYPE_CODE (known_type
) != TYPE_CODE_CLASS
) ||
3169 !TYPE_HAS_VTABLE (known_type
))
3170 return NULL
; /* No RTTI, or not HP-compiled types */
3171 CHECK_TYPEDEF (known_type
);
3172 using_enclosing
= 1;
3175 if (using_enclosing
&& using_enc
)
3178 /* First get the virtual table address */
3179 coreptr
= *(CORE_ADDR
*) ((VALUE_CONTENTS_ALL (v
))
3181 + (using_enclosing
? 0 : VALUE_EMBEDDED_OFFSET (v
)));
3183 return NULL
; /* return silently -- maybe called on gdb-generated value */
3185 /* Fetch the top offset of the object */
3186 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3187 vp
= value_at (builtin_type_int
,
3188 coreptr
+ 4 * HP_ACC_TOP_OFFSET_OFFSET
,
3189 VALUE_BFD_SECTION (v
));
3190 top_offset
= value_as_long (vp
);
3194 /* Fetch the typeinfo pointer */
3195 /* FIXME possible 32x64 problem with pointer size & arithmetic */
3196 vp
= value_at (builtin_type_int
, coreptr
+ 4 * HP_ACC_TYPEINFO_OFFSET
, VALUE_BFD_SECTION (v
));
3197 /* Indirect through the typeinfo pointer and retrieve the pointer
3198 * to the string name */
3199 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3201 error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3202 vp
= value_at (builtin_type_int
, coreptr
+ 4, VALUE_BFD_SECTION (v
)); /* 4 -> offset of name field */
3203 /* FIXME possible 32x64 problem */
3205 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
3207 read_memory_string (coreptr
, rtti_type_name
, 256);
3209 if (strlen (rtti_type_name
) == 0)
3210 error ("Retrieved null type name from typeinfo");
3212 /* search for type */
3213 rtti_type
= lookup_typename (rtti_type_name
, (struct block
*) 0, 1);
3216 error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name
);
3217 CHECK_TYPEDEF (rtti_type
);
3219 printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type
), TYPE_TAG_NAME (rtti_type
), full
? *full
: -1);
3221 /* Check whether we have the entire object */
3222 if (full
/* Non-null pointer passed */
3224 /* Either we checked on the whole object in hand and found the
3225 top offset to be zero */
3226 (((top_offset
== 0) &&
3228 TYPE_LENGTH (known_type
) == TYPE_LENGTH (rtti_type
))
3230 /* Or we checked on the embedded object and top offset was the
3231 same as the embedded offset */
3232 ((top_offset
== VALUE_EMBEDDED_OFFSET (v
)) &&
3234 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v
)) == TYPE_LENGTH (rtti_type
))))
3240 Right now this is G++ RTTI. Plan on this changing in the
3241 future as i get around to setting the vtables properly for G++
3242 compiled stuff. Also, i'll be using the type info functions,
3243 which are always right. Deal with it until then.
3247 struct minimal_symbol
*minsym
;
3249 char *demangled_name
;
3251 /* If the type has no vptr fieldno, try to get it filled in */
3252 if (TYPE_VPTR_FIELDNO(known_type
) < 0)
3253 fill_in_vptr_fieldno(known_type
);
3255 /* If we still can't find one, give up */
3256 if (TYPE_VPTR_FIELDNO(known_type
) < 0)
3259 /* Make sure our basetype and known type match, otherwise, cast
3260 so we can get at the vtable properly.
3262 btype
= TYPE_VPTR_BASETYPE (known_type
);
3263 CHECK_TYPEDEF (btype
);
3264 if (btype
!= known_type
)
3266 v
= value_cast (btype
, v
);
3271 We can't use value_ind here, because it would want to use RTTI, and
3272 we'd waste a bunch of time figuring out we already know the type.
3273 Besides, we don't care about the type, just the actual pointer
3275 if (VALUE_ADDRESS (value_field (v
, TYPE_VPTR_FIELDNO (known_type
))) == 0)
3279 If we are enclosed by something that isn't us, adjust the
3280 address properly and set using_enclosing.
3282 if (VALUE_ENCLOSING_TYPE(v
) != VALUE_TYPE(v
))
3285 tempval
=value_field(v
,TYPE_VPTR_FIELDNO(known_type
));
3286 VALUE_ADDRESS(tempval
)+=(TYPE_BASECLASS_BITPOS(known_type
,TYPE_VPTR_FIELDNO(known_type
))/8);
3287 vtbl
=value_as_pointer(tempval
);
3292 vtbl
=value_as_pointer(value_field(v
,TYPE_VPTR_FIELDNO(known_type
)));
3296 /* Try to find a symbol that is the vtable */
3297 minsym
=lookup_minimal_symbol_by_pc(vtbl
);
3298 if (minsym
==NULL
|| (demangled_name
=SYMBOL_NAME(minsym
))==NULL
|| !VTBL_PREFIX_P(demangled_name
))
3301 /* If we just skip the prefix, we get screwed by namespaces */
3302 demangled_name
=cplus_demangle(demangled_name
,DMGL_PARAMS
|DMGL_ANSI
);
3303 *(strchr(demangled_name
,' '))=0;
3305 /* Lookup the type for the name */
3306 rtti_type
=lookup_typename(demangled_name
, (struct block
*)0,1);
3308 if (rtti_type
==NULL
)
3311 if (TYPE_N_BASECLASSES(rtti_type
) > 1 && full
&& (*full
) != 1)
3314 *top
=TYPE_BASECLASS_BITPOS(rtti_type
,TYPE_VPTR_FIELDNO(rtti_type
))/8;
3315 if (top
&& ((*top
) >0))
3317 if (TYPE_LENGTH(rtti_type
) > TYPE_LENGTH(known_type
))
3335 *using_enc
=using_enclosing
;
3340 /* Given a pointer value V, find the real (RTTI) type
3341 of the object it points to.
3342 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3343 and refer to the values computed for the object pointed to. */
3346 value_rtti_target_type (value_ptr v
, int *full
, int *top
, int *using_enc
)
3350 target
= value_ind (v
);
3352 return value_rtti_type (target
, full
, top
, using_enc
);
3355 /* Given a value pointed to by ARGP, check its real run-time type, and
3356 if that is different from the enclosing type, create a new value
3357 using the real run-time type as the enclosing type (and of the same
3358 type as ARGP) and return it, with the embedded offset adjusted to
3359 be the correct offset to the enclosed object
3360 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3361 parameters, computed by value_rtti_type(). If these are available,
3362 they can be supplied and a second call to value_rtti_type() is avoided.
3363 (Pass RTYPE == NULL if they're not available */
3366 value_full_object (value_ptr argp
, struct type
*rtype
, int xfull
, int xtop
,
3369 struct type
*real_type
;
3380 using_enc
= xusing_enc
;
3383 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3385 /* If no RTTI data, or if object is already complete, do nothing */
3386 if (!real_type
|| real_type
== VALUE_ENCLOSING_TYPE (argp
))
3389 /* If we have the full object, but for some reason the enclosing
3390 type is wrong, set it *//* pai: FIXME -- sounds iffy */
3393 VALUE_ENCLOSING_TYPE (argp
) = real_type
;
3397 /* Check if object is in memory */
3398 if (VALUE_LVAL (argp
) != lval_memory
)
3400 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type
));
3405 /* All other cases -- retrieve the complete object */
3406 /* Go back by the computed top_offset from the beginning of the object,
3407 adjusting for the embedded offset of argp if that's what value_rtti_type
3408 used for its computation. */
3409 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
3410 (using_enc
? 0 : VALUE_EMBEDDED_OFFSET (argp
)),
3411 VALUE_BFD_SECTION (argp
));
3412 VALUE_TYPE (new_val
) = VALUE_TYPE (argp
);
3413 VALUE_EMBEDDED_OFFSET (new_val
) = using_enc
? top
+ VALUE_EMBEDDED_OFFSET (argp
) : top
;
3420 /* C++: return the value of the class instance variable, if one exists.
3421 Flag COMPLAIN signals an error if the request is made in an
3422 inappropriate context. */
3425 value_of_this (int complain
)
3427 struct symbol
*func
, *sym
;
3430 static const char funny_this
[] = "this";
3433 if (selected_frame
== 0)
3436 error ("no frame selected");
3441 func
= get_frame_function (selected_frame
);
3445 error ("no `this' in nameless context");
3450 b
= SYMBOL_BLOCK_VALUE (func
);
3451 i
= BLOCK_NSYMS (b
);
3455 error ("no args, no `this'");
3460 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3461 symbol instead of the LOC_ARG one (if both exist). */
3462 sym
= lookup_block_symbol (b
, funny_this
, VAR_NAMESPACE
);
3466 error ("current stack frame not in method");
3471 this = read_var_value (sym
, selected_frame
);
3472 if (this == 0 && complain
)
3473 error ("`this' argument at unknown address");
3477 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3478 long, starting at LOWBOUND. The result has the same lower bound as
3479 the original ARRAY. */
3482 value_slice (value_ptr array
, int lowbound
, int length
)
3484 struct type
*slice_range_type
, *slice_type
, *range_type
;
3485 LONGEST lowerbound
, upperbound
, offset
;
3487 struct type
*array_type
;
3488 array_type
= check_typedef (VALUE_TYPE (array
));
3489 COERCE_VARYING_ARRAY (array
, array_type
);
3490 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3491 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3492 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3493 error ("cannot take slice of non-array");
3494 range_type
= TYPE_INDEX_TYPE (array_type
);
3495 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3496 error ("slice from bad array or bitstring");
3497 if (lowbound
< lowerbound
|| length
< 0
3498 || lowbound
+ length
- 1 > upperbound
3499 /* Chill allows zero-length strings but not arrays. */
3500 || (current_language
->la_language
== language_chill
3501 && length
== 0 && TYPE_CODE (array_type
) == TYPE_CODE_ARRAY
))
3502 error ("slice out of range");
3503 /* FIXME-type-allocation: need a way to free this type when we are
3505 slice_range_type
= create_range_type ((struct type
*) NULL
,
3506 TYPE_TARGET_TYPE (range_type
),
3507 lowbound
, lowbound
+ length
- 1);
3508 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3511 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
3512 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3513 slice
= value_zero (slice_type
, not_lval
);
3514 for (i
= 0; i
< length
; i
++)
3516 int element
= value_bit_index (array_type
,
3517 VALUE_CONTENTS (array
),
3520 error ("internal error accessing bitstring");
3521 else if (element
> 0)
3523 int j
= i
% TARGET_CHAR_BIT
;
3524 if (BITS_BIG_ENDIAN
)
3525 j
= TARGET_CHAR_BIT
- 1 - j
;
3526 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3529 /* We should set the address, bitssize, and bitspos, so the clice
3530 can be used on the LHS, but that may require extensions to
3531 value_assign. For now, just leave as a non_lval. FIXME. */
3535 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3537 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3538 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
3540 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3541 slice
= allocate_value (slice_type
);
3542 if (VALUE_LAZY (array
))
3543 VALUE_LAZY (slice
) = 1;
3545 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
3546 TYPE_LENGTH (slice_type
));
3547 if (VALUE_LVAL (array
) == lval_internalvar
)
3548 VALUE_LVAL (slice
) = lval_internalvar_component
;
3550 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
3551 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
3552 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
3557 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3558 value as a fixed-length array. */
3561 varying_to_slice (value_ptr varray
)
3563 struct type
*vtype
= check_typedef (VALUE_TYPE (varray
));
3564 LONGEST length
= unpack_long (TYPE_FIELD_TYPE (vtype
, 0),
3565 VALUE_CONTENTS (varray
)
3566 + TYPE_FIELD_BITPOS (vtype
, 0) / 8);
3567 return value_slice (value_primitive_field (varray
, 0, 1, vtype
), 0, length
);
3570 /* Create a value for a FORTRAN complex number. Currently most of
3571 the time values are coerced to COMPLEX*16 (i.e. a complex number
3572 composed of 2 doubles. This really should be a smarter routine
3573 that figures out precision inteligently as opposed to assuming
3574 doubles. FIXME: fmb */
3577 value_literal_complex (value_ptr arg1
, value_ptr arg2
, struct type
*type
)
3579 register value_ptr val
;
3580 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3582 val
= allocate_value (type
);
3583 arg1
= value_cast (real_type
, arg1
);
3584 arg2
= value_cast (real_type
, arg2
);
3586 memcpy (VALUE_CONTENTS_RAW (val
),
3587 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
3588 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
3589 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
3593 /* Cast a value into the appropriate complex data type. */
3596 cast_into_complex (struct type
*type
, register value_ptr val
)
3598 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3599 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
3601 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
3602 value_ptr re_val
= allocate_value (val_real_type
);
3603 value_ptr im_val
= allocate_value (val_real_type
);
3605 memcpy (VALUE_CONTENTS_RAW (re_val
),
3606 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
3607 memcpy (VALUE_CONTENTS_RAW (im_val
),
3608 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
3609 TYPE_LENGTH (val_real_type
));
3611 return value_literal_complex (re_val
, im_val
, type
);
3613 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
3614 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
3615 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
3617 error ("cannot cast non-number to complex");
3621 _initialize_valops (void)
3625 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *) &auto_abandon
,
3626 "Set automatic abandonment of expressions upon failure.",
3632 (add_set_cmd ("overload-resolution", class_support
, var_boolean
, (char *) &overload_resolution
,
3633 "Set overload resolution in evaluating C++ functions.",
3636 overload_resolution
= 1;
3639 add_set_cmd ("unwindonsignal", no_class
, var_boolean
,
3640 (char *) &unwind_on_signal_p
,
3641 "Set unwinding of stack if a signal is received while in a call dummy.\n\
3642 The unwindonsignal lets the user determine what gdb should do if a signal\n\
3643 is received while in a function called from gdb (call dummy). If set, gdb\n\
3644 unwinds the stack and restore the context to what as it was before the call.\n\
3645 The default is to stop in the frame where the signal was received.", &setlist
),