1 /* Perform non-arithmetic operations on values, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
3 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
40 #include "gdb_string.h"
41 #include "gdb_assert.h"
43 /* Flag indicating HP compilers were used; needed to correctly handle some
44 value operations with HP aCC code/runtime. */
45 extern int hp_som_som_object_present
;
47 extern int overload_debug
;
48 /* Local functions. */
50 static int typecmp (int staticp
, int varargs
, int nargs
,
51 struct field t1
[], struct value
*t2
[]);
53 static CORE_ADDR
value_push (CORE_ADDR
, struct value
*);
55 static struct value
*search_struct_field (char *, struct value
*, int,
58 static struct value
*search_struct_method (char *, struct value
**,
60 int, int *, struct type
*);
62 static int check_field_in (struct type
*, const char *);
64 static CORE_ADDR
allocate_space_in_inferior (int);
66 static struct value
*cast_into_complex (struct type
*, struct value
*);
68 static struct fn_field
*find_method_list (struct value
** argp
, char *method
,
70 struct type
*type
, int *num_fns
,
71 struct type
**basetype
,
74 void _initialize_valops (void);
76 /* Flag for whether we want to abandon failed expression evals by default. */
79 static int auto_abandon
= 0;
82 int overload_resolution
= 0;
84 /* Find the address of function name NAME in the inferior. */
87 find_function_in_inferior (const char *name
)
89 register struct symbol
*sym
;
90 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0, NULL
);
93 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
95 error ("\"%s\" exists in this program but is not a function.",
98 return value_of_variable (sym
, NULL
);
102 struct minimal_symbol
*msymbol
= lookup_minimal_symbol (name
, NULL
, NULL
);
107 type
= lookup_pointer_type (builtin_type_char
);
108 type
= lookup_function_type (type
);
109 type
= lookup_pointer_type (type
);
110 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
111 return value_from_pointer (type
, maddr
);
115 if (!target_has_execution
)
116 error ("evaluation of this expression requires the target program to be active");
118 error ("evaluation of this expression requires the program to have a function \"%s\".", name
);
123 /* Allocate NBYTES of space in the inferior using the inferior's malloc
124 and return a value that is a pointer to the allocated space. */
127 value_allocate_space_in_inferior (int len
)
129 struct value
*blocklen
;
130 struct value
*val
= find_function_in_inferior (NAME_OF_MALLOC
);
132 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
133 val
= call_function_by_hand (val
, 1, &blocklen
);
134 if (value_logical_not (val
))
136 if (!target_has_execution
)
137 error ("No memory available to program now: you need to start the target first");
139 error ("No memory available to program: call to malloc failed");
145 allocate_space_in_inferior (int len
)
147 return value_as_long (value_allocate_space_in_inferior (len
));
150 /* Cast value ARG2 to type TYPE and return as a value.
151 More general than a C cast: accepts any two types of the same length,
152 and if ARG2 is an lvalue it can be cast into anything at all. */
153 /* In C++, casts may change pointer or object representations. */
156 value_cast (struct type
*type
, struct value
*arg2
)
158 register enum type_code code1
;
159 register enum type_code code2
;
163 int convert_to_boolean
= 0;
165 if (VALUE_TYPE (arg2
) == type
)
168 CHECK_TYPEDEF (type
);
169 code1
= TYPE_CODE (type
);
171 type2
= check_typedef (VALUE_TYPE (arg2
));
173 /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
174 is treated like a cast to (TYPE [N])OBJECT,
175 where N is sizeof(OBJECT)/sizeof(TYPE). */
176 if (code1
== TYPE_CODE_ARRAY
)
178 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
179 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
180 if (element_length
> 0
181 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
183 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
184 int val_length
= TYPE_LENGTH (type2
);
185 LONGEST low_bound
, high_bound
, new_length
;
186 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
187 low_bound
= 0, high_bound
= 0;
188 new_length
= val_length
/ element_length
;
189 if (val_length
% element_length
!= 0)
190 warning ("array element type size does not divide object size in cast");
191 /* FIXME-type-allocation: need a way to free this type when we are
193 range_type
= create_range_type ((struct type
*) NULL
,
194 TYPE_TARGET_TYPE (range_type
),
196 new_length
+ low_bound
- 1);
197 VALUE_TYPE (arg2
) = create_array_type ((struct type
*) NULL
,
198 element_type
, range_type
);
203 if (current_language
->c_style_arrays
204 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
205 arg2
= value_coerce_array (arg2
);
207 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
208 arg2
= value_coerce_function (arg2
);
210 type2
= check_typedef (VALUE_TYPE (arg2
));
211 COERCE_VARYING_ARRAY (arg2
, type2
);
212 code2
= TYPE_CODE (type2
);
214 if (code1
== TYPE_CODE_COMPLEX
)
215 return cast_into_complex (type
, arg2
);
216 if (code1
== TYPE_CODE_BOOL
)
218 code1
= TYPE_CODE_INT
;
219 convert_to_boolean
= 1;
221 if (code1
== TYPE_CODE_CHAR
)
222 code1
= TYPE_CODE_INT
;
223 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
224 code2
= TYPE_CODE_INT
;
226 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
227 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
229 if (code1
== TYPE_CODE_STRUCT
230 && code2
== TYPE_CODE_STRUCT
231 && TYPE_NAME (type
) != 0)
233 /* Look in the type of the source to see if it contains the
234 type of the target as a superclass. If so, we'll need to
235 offset the object in addition to changing its type. */
236 struct value
*v
= search_struct_field (type_name_no_tag (type
),
240 VALUE_TYPE (v
) = type
;
244 if (code1
== TYPE_CODE_FLT
&& scalar
)
245 return value_from_double (type
, value_as_double (arg2
));
246 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
247 || code1
== TYPE_CODE_RANGE
)
248 && (scalar
|| code2
== TYPE_CODE_PTR
))
252 if (hp_som_som_object_present
&& /* if target compiled by HP aCC */
253 (code2
== TYPE_CODE_PTR
))
256 struct value
*retvalp
;
258 switch (TYPE_CODE (TYPE_TARGET_TYPE (type2
)))
260 /* With HP aCC, pointers to data members have a bias */
261 case TYPE_CODE_MEMBER
:
262 retvalp
= value_from_longest (type
, value_as_long (arg2
));
263 /* force evaluation */
264 ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
);
265 *ptr
&= ~0x20000000; /* zap 29th bit to remove bias */
268 /* While pointers to methods don't really point to a function */
269 case TYPE_CODE_METHOD
:
270 error ("Pointers to methods not supported with HP aCC");
273 break; /* fall out and go to normal handling */
277 /* When we cast pointers to integers, we mustn't use
278 POINTER_TO_ADDRESS to find the address the pointer
279 represents, as value_as_long would. GDB should evaluate
280 expressions just as the compiler would --- and the compiler
281 sees a cast as a simple reinterpretation of the pointer's
283 if (code2
== TYPE_CODE_PTR
)
284 longest
= extract_unsigned_integer (VALUE_CONTENTS (arg2
),
285 TYPE_LENGTH (type2
));
287 longest
= value_as_long (arg2
);
288 return value_from_longest (type
, convert_to_boolean
?
289 (LONGEST
) (longest
? 1 : 0) : longest
);
291 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
||
292 code2
== TYPE_CODE_ENUM
||
293 code2
== TYPE_CODE_RANGE
))
295 /* TYPE_LENGTH (type) is the length of a pointer, but we really
296 want the length of an address! -- we are really dealing with
297 addresses (i.e., gdb representations) not pointers (i.e.,
298 target representations) here.
300 This allows things like "print *(int *)0x01000234" to work
301 without printing a misleading message -- which would
302 otherwise occur when dealing with a target having two byte
303 pointers and four byte addresses. */
305 int addr_bit
= TARGET_ADDR_BIT
;
307 LONGEST longest
= value_as_long (arg2
);
308 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
310 if (longest
>= ((LONGEST
) 1 << addr_bit
)
311 || longest
<= -((LONGEST
) 1 << addr_bit
))
312 warning ("value truncated");
314 return value_from_longest (type
, longest
);
316 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
318 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
320 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
321 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
322 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
323 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
324 && !value_logical_not (arg2
))
328 /* Look in the type of the source to see if it contains the
329 type of the target as a superclass. If so, we'll need to
330 offset the pointer rather than just change its type. */
331 if (TYPE_NAME (t1
) != NULL
)
333 v
= search_struct_field (type_name_no_tag (t1
),
334 value_ind (arg2
), 0, t2
, 1);
338 VALUE_TYPE (v
) = type
;
343 /* Look in the type of the target to see if it contains the
344 type of the source as a superclass. If so, we'll need to
345 offset the pointer rather than just change its type.
346 FIXME: This fails silently with virtual inheritance. */
347 if (TYPE_NAME (t2
) != NULL
)
349 v
= search_struct_field (type_name_no_tag (t2
),
350 value_zero (t1
, not_lval
), 0, t1
, 1);
353 CORE_ADDR addr2
= value_as_address (arg2
);
354 addr2
-= (VALUE_ADDRESS (v
)
356 + VALUE_EMBEDDED_OFFSET (v
));
357 return value_from_pointer (type
, addr2
);
361 /* No superclass found, just fall through to change ptr type. */
363 VALUE_TYPE (arg2
) = type
;
364 arg2
= value_change_enclosing_type (arg2
, type
);
365 VALUE_POINTED_TO_OFFSET (arg2
) = 0; /* pai: chk_val */
368 else if (VALUE_LVAL (arg2
) == lval_memory
)
370 return value_at_lazy (type
, VALUE_ADDRESS (arg2
) + VALUE_OFFSET (arg2
),
371 VALUE_BFD_SECTION (arg2
));
373 else if (code1
== TYPE_CODE_VOID
)
375 return value_zero (builtin_type_void
, not_lval
);
379 error ("Invalid cast.");
384 /* Create a value of type TYPE that is zero, and return it. */
387 value_zero (struct type
*type
, enum lval_type lv
)
389 struct value
*val
= allocate_value (type
);
391 memset (VALUE_CONTENTS (val
), 0, TYPE_LENGTH (check_typedef (type
)));
392 VALUE_LVAL (val
) = lv
;
397 /* Return a value with type TYPE located at ADDR.
399 Call value_at only if the data needs to be fetched immediately;
400 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
401 value_at_lazy instead. value_at_lazy simply records the address of
402 the data and sets the lazy-evaluation-required flag. The lazy flag
403 is tested in the VALUE_CONTENTS macro, which is used if and when
404 the contents are actually required.
406 Note: value_at does *NOT* handle embedded offsets; perform such
407 adjustments before or after calling it. */
410 value_at (struct type
*type
, CORE_ADDR addr
, asection
*sect
)
414 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
415 error ("Attempt to dereference a generic pointer.");
417 val
= allocate_value (type
);
419 read_memory (addr
, VALUE_CONTENTS_ALL_RAW (val
), TYPE_LENGTH (type
));
421 VALUE_LVAL (val
) = lval_memory
;
422 VALUE_ADDRESS (val
) = addr
;
423 VALUE_BFD_SECTION (val
) = sect
;
428 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
431 value_at_lazy (struct type
*type
, CORE_ADDR addr
, asection
*sect
)
435 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
436 error ("Attempt to dereference a generic pointer.");
438 val
= allocate_value (type
);
440 VALUE_LVAL (val
) = lval_memory
;
441 VALUE_ADDRESS (val
) = addr
;
442 VALUE_LAZY (val
) = 1;
443 VALUE_BFD_SECTION (val
) = sect
;
448 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
449 if the current data for a variable needs to be loaded into
450 VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
451 clears the lazy flag to indicate that the data in the buffer is valid.
453 If the value is zero-length, we avoid calling read_memory, which would
454 abort. We mark the value as fetched anyway -- all 0 bytes of it.
456 This function returns a value because it is used in the VALUE_CONTENTS
457 macro as part of an expression, where a void would not work. The
461 value_fetch_lazy (struct value
*val
)
463 CORE_ADDR addr
= VALUE_ADDRESS (val
) + VALUE_OFFSET (val
);
464 int length
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
));
466 struct type
*type
= VALUE_TYPE (val
);
468 read_memory (addr
, VALUE_CONTENTS_ALL_RAW (val
), length
);
470 VALUE_LAZY (val
) = 0;
475 /* Store the contents of FROMVAL into the location of TOVAL.
476 Return a new value with the location of TOVAL and contents of FROMVAL. */
479 value_assign (struct value
*toval
, struct value
*fromval
)
481 register struct type
*type
;
483 char raw_buffer
[MAX_REGISTER_SIZE
];
485 struct frame_id old_frame
;
487 if (!toval
->modifiable
)
488 error ("Left operand of assignment is not a modifiable lvalue.");
492 type
= VALUE_TYPE (toval
);
493 if (VALUE_LVAL (toval
) != lval_internalvar
)
494 fromval
= value_cast (type
, fromval
);
496 COERCE_ARRAY (fromval
);
497 CHECK_TYPEDEF (type
);
499 /* If TOVAL is a special machine register requiring conversion
500 of program values to a special raw format,
501 convert FROMVAL's contents now, with result in `raw_buffer',
502 and set USE_BUFFER to the number of bytes to write. */
504 if (VALUE_REGNO (toval
) >= 0)
506 int regno
= VALUE_REGNO (toval
);
507 if (CONVERT_REGISTER_P (regno
))
509 struct type
*fromtype
= check_typedef (VALUE_TYPE (fromval
));
510 VALUE_TO_REGISTER (fromtype
, regno
, VALUE_CONTENTS (fromval
), raw_buffer
);
511 use_buffer
= REGISTER_RAW_SIZE (regno
);
515 /* Since modifying a register can trash the frame chain, and modifying memory
516 can trash the frame cache, we save the old frame and then restore the new
518 old_frame
= get_frame_id (deprecated_selected_frame
);
520 switch (VALUE_LVAL (toval
))
522 case lval_internalvar
:
523 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
524 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
525 val
= value_change_enclosing_type (val
, VALUE_ENCLOSING_TYPE (fromval
));
526 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
527 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
530 case lval_internalvar_component
:
531 set_internalvar_component (VALUE_INTERNALVAR (toval
),
532 VALUE_OFFSET (toval
),
533 VALUE_BITPOS (toval
),
534 VALUE_BITSIZE (toval
),
541 CORE_ADDR changed_addr
;
544 if (VALUE_BITSIZE (toval
))
546 char buffer
[sizeof (LONGEST
)];
547 /* We assume that the argument to read_memory is in units of
548 host chars. FIXME: Is that correct? */
549 changed_len
= (VALUE_BITPOS (toval
)
550 + VALUE_BITSIZE (toval
)
554 if (changed_len
> (int) sizeof (LONGEST
))
555 error ("Can't handle bitfields which don't fit in a %d bit word.",
556 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
558 read_memory (VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
),
559 buffer
, changed_len
);
560 modify_field (buffer
, value_as_long (fromval
),
561 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
562 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
563 dest_buffer
= buffer
;
567 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
568 changed_len
= use_buffer
;
569 dest_buffer
= raw_buffer
;
573 changed_addr
= VALUE_ADDRESS (toval
) + VALUE_OFFSET (toval
);
574 changed_len
= TYPE_LENGTH (type
);
575 dest_buffer
= VALUE_CONTENTS (fromval
);
578 write_memory (changed_addr
, dest_buffer
, changed_len
);
579 if (memory_changed_hook
)
580 memory_changed_hook (changed_addr
, changed_len
);
581 target_changed_event ();
585 case lval_reg_frame_relative
:
588 /* value is stored in a series of registers in the frame
589 specified by the structure. Copy that value out, modify
590 it, and copy it back in. */
598 struct frame_info
*frame
;
600 /* Figure out which frame this is in currently. */
601 if (VALUE_LVAL (toval
) == lval_register
)
603 frame
= get_current_frame ();
604 value_reg
= VALUE_REGNO (toval
);
608 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
609 value_reg
= VALUE_FRAME_REGNUM (toval
);
613 error ("Value being assigned to is no longer active.");
615 /* Locate the first register that falls in the value that
616 needs to be transfered. Compute the offset of the value in
620 for (reg_offset
= value_reg
, offset
= 0;
621 offset
+ REGISTER_RAW_SIZE (reg_offset
) <= VALUE_OFFSET (toval
);
623 byte_offset
= VALUE_OFFSET (toval
) - offset
;
626 /* Compute the number of register aligned values that need to
628 if (VALUE_BITSIZE (toval
))
629 amount_to_copy
= byte_offset
+ 1;
631 amount_to_copy
= byte_offset
+ TYPE_LENGTH (type
);
633 /* And a bounce buffer. Be slightly over generous. */
634 buffer
= (char *) alloca (amount_to_copy
+ MAX_REGISTER_SIZE
);
637 for (regno
= reg_offset
, amount_copied
= 0;
638 amount_copied
< amount_to_copy
;
639 amount_copied
+= REGISTER_RAW_SIZE (regno
), regno
++)
641 frame_register_read (frame
, regno
, buffer
+ amount_copied
);
644 /* Modify what needs to be modified. */
645 if (VALUE_BITSIZE (toval
))
647 modify_field (buffer
+ byte_offset
,
648 value_as_long (fromval
),
649 VALUE_BITPOS (toval
), VALUE_BITSIZE (toval
));
653 memcpy (buffer
+ VALUE_OFFSET (toval
), raw_buffer
, use_buffer
);
657 memcpy (buffer
+ byte_offset
, VALUE_CONTENTS (fromval
),
659 /* Do any conversion necessary when storing this type to
660 more than one register. */
661 #ifdef REGISTER_CONVERT_FROM_TYPE
662 REGISTER_CONVERT_FROM_TYPE (value_reg
, type
,
663 (buffer
+ byte_offset
));
668 for (regno
= reg_offset
, amount_copied
= 0;
669 amount_copied
< amount_to_copy
;
670 amount_copied
+= REGISTER_RAW_SIZE (regno
), regno
++)
677 /* Just find out where to put it. */
678 frame_register (frame
, regno
, &optim
, &lval
, &addr
, &realnum
,
682 error ("Attempt to assign to a value that was optimized out.");
683 if (lval
== lval_memory
)
684 write_memory (addr
, buffer
+ amount_copied
,
685 REGISTER_RAW_SIZE (regno
));
686 else if (lval
== lval_register
)
687 regcache_cooked_write (current_regcache
, realnum
,
688 (buffer
+ amount_copied
));
690 error ("Attempt to assign to an unmodifiable value.");
693 if (register_changed_hook
)
694 register_changed_hook (-1);
695 target_changed_event ();
702 error ("Left operand of assignment is not an lvalue.");
705 /* Assigning to the stack pointer, frame pointer, and other
706 (architecture and calling convention specific) registers may
707 cause the frame cache to be out of date. Assigning to memory
708 also can. We just do this on all assignments to registers or
709 memory, for simplicity's sake; I doubt the slowdown matters. */
710 switch (VALUE_LVAL (toval
))
714 case lval_reg_frame_relative
:
716 reinit_frame_cache ();
718 /* Having destoroyed the frame cache, restore the selected frame. */
720 /* FIXME: cagney/2002-11-02: There has to be a better way of
721 doing this. Instead of constantly saving/restoring the
722 frame. Why not create a get_selected_frame() function that,
723 having saved the selected frame's ID can automatically
724 re-find the previously selected frame automatically. */
727 struct frame_info
*fi
= frame_find_by_id (old_frame
);
737 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
738 If the field is signed, and is negative, then sign extend. */
739 if ((VALUE_BITSIZE (toval
) > 0)
740 && (VALUE_BITSIZE (toval
) < 8 * (int) sizeof (LONGEST
)))
742 LONGEST fieldval
= value_as_long (fromval
);
743 LONGEST valmask
= (((ULONGEST
) 1) << VALUE_BITSIZE (toval
)) - 1;
746 if (!TYPE_UNSIGNED (type
) && (fieldval
& (valmask
^ (valmask
>> 1))))
747 fieldval
|= ~valmask
;
749 fromval
= value_from_longest (type
, fieldval
);
752 val
= value_copy (toval
);
753 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS (fromval
),
755 VALUE_TYPE (val
) = type
;
756 val
= value_change_enclosing_type (val
, VALUE_ENCLOSING_TYPE (fromval
));
757 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (fromval
);
758 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (fromval
);
763 /* Extend a value VAL to COUNT repetitions of its type. */
766 value_repeat (struct value
*arg1
, int count
)
770 if (VALUE_LVAL (arg1
) != lval_memory
)
771 error ("Only values in memory can be extended with '@'.");
773 error ("Invalid number %d of repetitions.", count
);
775 val
= allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1
), count
);
777 read_memory (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
),
778 VALUE_CONTENTS_ALL_RAW (val
),
779 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val
)));
780 VALUE_LVAL (val
) = lval_memory
;
781 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
);
787 value_of_variable (struct symbol
*var
, struct block
*b
)
790 struct frame_info
*frame
= NULL
;
793 frame
= NULL
; /* Use selected frame. */
794 else if (symbol_read_needs_frame (var
))
796 frame
= block_innermost_frame (b
);
799 if (BLOCK_FUNCTION (b
)
800 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
801 error ("No frame is currently executing in block %s.",
802 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
804 error ("No frame is currently executing in specified block");
808 val
= read_var_value (var
, frame
);
810 error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var
));
815 /* Given a value which is an array, return a value which is a pointer to its
816 first element, regardless of whether or not the array has a nonzero lower
819 FIXME: A previous comment here indicated that this routine should be
820 substracting the array's lower bound. It's not clear to me that this
821 is correct. Given an array subscripting operation, it would certainly
822 work to do the adjustment here, essentially computing:
824 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
826 However I believe a more appropriate and logical place to account for
827 the lower bound is to do so in value_subscript, essentially computing:
829 (&array[0] + ((index - lowerbound) * sizeof array[0]))
831 As further evidence consider what would happen with operations other
832 than array subscripting, where the caller would get back a value that
833 had an address somewhere before the actual first element of the array,
834 and the information about the lower bound would be lost because of
835 the coercion to pointer type.
839 value_coerce_array (struct value
*arg1
)
841 register struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
843 if (VALUE_LVAL (arg1
) != lval_memory
)
844 error ("Attempt to take address of value not located in memory.");
846 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
847 (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
850 /* Given a value which is a function, return a value which is a pointer
854 value_coerce_function (struct value
*arg1
)
856 struct value
*retval
;
858 if (VALUE_LVAL (arg1
) != lval_memory
)
859 error ("Attempt to take address of value not located in memory.");
861 retval
= value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1
)),
862 (VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
)));
863 VALUE_BFD_SECTION (retval
) = VALUE_BFD_SECTION (arg1
);
867 /* Return a pointer value for the object for which ARG1 is the contents. */
870 value_addr (struct value
*arg1
)
874 struct type
*type
= check_typedef (VALUE_TYPE (arg1
));
875 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
877 /* Copy the value, but change the type from (T&) to (T*).
878 We keep the same location information, which is efficient,
879 and allows &(&X) to get the location containing the reference. */
880 arg2
= value_copy (arg1
);
881 VALUE_TYPE (arg2
) = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
884 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
885 return value_coerce_function (arg1
);
887 if (VALUE_LVAL (arg1
) != lval_memory
)
888 error ("Attempt to take address of value not located in memory.");
890 /* Get target memory address */
891 arg2
= value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1
)),
892 (VALUE_ADDRESS (arg1
)
893 + VALUE_OFFSET (arg1
)
894 + VALUE_EMBEDDED_OFFSET (arg1
)));
896 /* This may be a pointer to a base subobject; so remember the
897 full derived object's type ... */
898 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1
)));
899 /* ... and also the relative position of the subobject in the full object */
900 VALUE_POINTED_TO_OFFSET (arg2
) = VALUE_EMBEDDED_OFFSET (arg1
);
901 VALUE_BFD_SECTION (arg2
) = VALUE_BFD_SECTION (arg1
);
905 /* Given a value of a pointer type, apply the C unary * operator to it. */
908 value_ind (struct value
*arg1
)
910 struct type
*base_type
;
915 base_type
= check_typedef (VALUE_TYPE (arg1
));
917 if (TYPE_CODE (base_type
) == TYPE_CODE_MEMBER
)
918 error ("not implemented: member types in value_ind");
920 /* Allow * on an integer so we can cast it to whatever we want.
921 This returns an int, which seems like the most C-like thing
922 to do. "long long" variables are rare enough that
923 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
924 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
925 return value_at_lazy (builtin_type_int
,
926 (CORE_ADDR
) value_as_long (arg1
),
927 VALUE_BFD_SECTION (arg1
));
928 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
930 struct type
*enc_type
;
931 /* We may be pointing to something embedded in a larger object */
932 /* Get the real type of the enclosing object */
933 enc_type
= check_typedef (VALUE_ENCLOSING_TYPE (arg1
));
934 enc_type
= TYPE_TARGET_TYPE (enc_type
);
935 /* Retrieve the enclosing object pointed to */
936 arg2
= value_at_lazy (enc_type
,
937 value_as_address (arg1
) - VALUE_POINTED_TO_OFFSET (arg1
),
938 VALUE_BFD_SECTION (arg1
));
940 VALUE_TYPE (arg2
) = TYPE_TARGET_TYPE (base_type
);
941 /* Add embedding info */
942 arg2
= value_change_enclosing_type (arg2
, enc_type
);
943 VALUE_EMBEDDED_OFFSET (arg2
) = VALUE_POINTED_TO_OFFSET (arg1
);
945 /* We may be pointing to an object of some derived type */
946 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
950 error ("Attempt to take contents of a non-pointer value.");
951 return 0; /* For lint -- never reached */
954 /* Pushing small parts of stack frames. */
956 /* Push one word (the size of object that a register holds). */
959 push_word (CORE_ADDR sp
, ULONGEST word
)
961 register int len
= DEPRECATED_REGISTER_SIZE
;
962 char buffer
[MAX_REGISTER_SIZE
];
964 store_unsigned_integer (buffer
, len
, word
);
965 if (INNER_THAN (1, 2))
967 /* stack grows downward */
969 write_memory (sp
, buffer
, len
);
973 /* stack grows upward */
974 write_memory (sp
, buffer
, len
);
981 /* Push LEN bytes with data at BUFFER. */
984 push_bytes (CORE_ADDR sp
, char *buffer
, int len
)
986 if (INNER_THAN (1, 2))
988 /* stack grows downward */
990 write_memory (sp
, buffer
, len
);
994 /* stack grows upward */
995 write_memory (sp
, buffer
, len
);
1002 #ifndef PARM_BOUNDARY
1003 #define PARM_BOUNDARY (0)
1006 /* Push onto the stack the specified value VALUE. Pad it correctly for
1007 it to be an argument to a function. */
1010 value_push (register CORE_ADDR sp
, struct value
*arg
)
1012 register int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
1013 register int container_len
= len
;
1014 register int offset
;
1016 /* How big is the container we're going to put this value in? */
1018 container_len
= ((len
+ PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1)
1019 & ~(PARM_BOUNDARY
/ TARGET_CHAR_BIT
- 1));
1021 /* Are we going to put it at the high or low end of the container? */
1022 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1023 offset
= container_len
- len
;
1027 if (INNER_THAN (1, 2))
1029 /* stack grows downward */
1030 sp
-= container_len
;
1031 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1035 /* stack grows upward */
1036 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (arg
), len
);
1037 sp
+= container_len
;
1044 legacy_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1045 int struct_return
, CORE_ADDR struct_addr
)
1047 /* ASSERT ( !struct_return); */
1049 for (i
= nargs
- 1; i
>= 0; i
--)
1050 sp
= value_push (sp
, args
[i
]);
1054 /* Create a value for an array by allocating space in the inferior, copying
1055 the data into that space, and then setting up an array value.
1057 The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1058 populated from the values passed in ELEMVEC.
1060 The element type of the array is inherited from the type of the
1061 first element, and all elements must have the same size (though we
1062 don't currently enforce any restriction on their types). */
1065 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1069 unsigned int typelength
;
1071 struct type
*rangetype
;
1072 struct type
*arraytype
;
1075 /* Validate that the bounds are reasonable and that each of the elements
1076 have the same size. */
1078 nelem
= highbound
- lowbound
+ 1;
1081 error ("bad array bounds (%d, %d)", lowbound
, highbound
);
1083 typelength
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[0]));
1084 for (idx
= 1; idx
< nelem
; idx
++)
1086 if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec
[idx
])) != typelength
)
1088 error ("array elements must all be the same size");
1092 rangetype
= create_range_type ((struct type
*) NULL
, builtin_type_int
,
1093 lowbound
, highbound
);
1094 arraytype
= create_array_type ((struct type
*) NULL
,
1095 VALUE_ENCLOSING_TYPE (elemvec
[0]), rangetype
);
1097 if (!current_language
->c_style_arrays
)
1099 val
= allocate_value (arraytype
);
1100 for (idx
= 0; idx
< nelem
; idx
++)
1102 memcpy (VALUE_CONTENTS_ALL_RAW (val
) + (idx
* typelength
),
1103 VALUE_CONTENTS_ALL (elemvec
[idx
]),
1106 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (elemvec
[0]);
1110 /* Allocate space to store the array in the inferior, and then initialize
1111 it by copying in each element. FIXME: Is it worth it to create a
1112 local buffer in which to collect each value and then write all the
1113 bytes in one operation? */
1115 addr
= allocate_space_in_inferior (nelem
* typelength
);
1116 for (idx
= 0; idx
< nelem
; idx
++)
1118 write_memory (addr
+ (idx
* typelength
), VALUE_CONTENTS_ALL (elemvec
[idx
]),
1122 /* Create the array type and set up an array value to be evaluated lazily. */
1124 val
= value_at_lazy (arraytype
, addr
, VALUE_BFD_SECTION (elemvec
[0]));
1128 /* Create a value for a string constant by allocating space in the inferior,
1129 copying the data into that space, and returning the address with type
1130 TYPE_CODE_STRING. PTR points to the string constant data; LEN is number
1132 Note that string types are like array of char types with a lower bound of
1133 zero and an upper bound of LEN - 1. Also note that the string may contain
1134 embedded null bytes. */
1137 value_string (char *ptr
, int len
)
1140 int lowbound
= current_language
->string_lower_bound
;
1141 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1143 lowbound
, len
+ lowbound
- 1);
1144 struct type
*stringtype
1145 = create_string_type ((struct type
*) NULL
, rangetype
);
1148 if (current_language
->c_style_arrays
== 0)
1150 val
= allocate_value (stringtype
);
1151 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1156 /* Allocate space to store the string in the inferior, and then
1157 copy LEN bytes from PTR in gdb to that address in the inferior. */
1159 addr
= allocate_space_in_inferior (len
);
1160 write_memory (addr
, ptr
, len
);
1162 val
= value_at_lazy (stringtype
, addr
, NULL
);
1167 value_bitstring (char *ptr
, int len
)
1170 struct type
*domain_type
= create_range_type (NULL
, builtin_type_int
,
1172 struct type
*type
= create_set_type ((struct type
*) NULL
, domain_type
);
1173 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1174 val
= allocate_value (type
);
1175 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, TYPE_LENGTH (type
));
1179 /* See if we can pass arguments in T2 to a function which takes arguments
1180 of types T1. T1 is a list of NARGS arguments, and T2 is a NULL-terminated
1181 vector. If some arguments need coercion of some sort, then the coerced
1182 values are written into T2. Return value is 0 if the arguments could be
1183 matched, or the position at which they differ if not.
1185 STATICP is nonzero if the T1 argument list came from a
1186 static member function. T2 will still include the ``this'' pointer,
1187 but it will be skipped.
1189 For non-static member functions, we ignore the first argument,
1190 which is the type of the instance variable. This is because we want
1191 to handle calls with objects from derived classes. This is not
1192 entirely correct: we should actually check to make sure that a
1193 requested operation is type secure, shouldn't we? FIXME. */
1196 typecmp (int staticp
, int varargs
, int nargs
,
1197 struct field t1
[], struct value
*t2
[])
1202 internal_error (__FILE__
, __LINE__
, "typecmp: no argument list");
1204 /* Skip ``this'' argument if applicable. T2 will always include THIS. */
1209 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1212 struct type
*tt1
, *tt2
;
1217 tt1
= check_typedef (t1
[i
].type
);
1218 tt2
= check_typedef (VALUE_TYPE (t2
[i
]));
1220 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1221 /* We should be doing hairy argument matching, as below. */
1222 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1224 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1225 t2
[i
] = value_coerce_array (t2
[i
]);
1227 t2
[i
] = value_addr (t2
[i
]);
1231 /* djb - 20000715 - Until the new type structure is in the
1232 place, and we can attempt things like implicit conversions,
1233 we need to do this so you can take something like a map<const
1234 char *>, and properly access map["hello"], because the
1235 argument to [] will be a reference to a pointer to a char,
1236 and the argument will be a pointer to a char. */
1237 while ( TYPE_CODE(tt1
) == TYPE_CODE_REF
||
1238 TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1240 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1242 while ( TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
||
1243 TYPE_CODE(tt2
) == TYPE_CODE_PTR
||
1244 TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1246 tt2
= check_typedef( TYPE_TARGET_TYPE(tt2
) );
1248 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1250 /* Array to pointer is a `trivial conversion' according to the ARM. */
1252 /* We should be doing much hairier argument matching (see section 13.2
1253 of the ARM), but as a quick kludge, just check for the same type
1255 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (VALUE_TYPE (t2
[i
])))
1258 if (varargs
|| t2
[i
] == NULL
)
1263 /* Helper function used by value_struct_elt to recurse through baseclasses.
1264 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1265 and search in it assuming it has (class) type TYPE.
1266 If found, return value, else return NULL.
1268 If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1269 look for a baseclass named NAME. */
1271 static struct value
*
1272 search_struct_field (char *name
, struct value
*arg1
, int offset
,
1273 register struct type
*type
, int looking_for_baseclass
)
1276 int nbases
= TYPE_N_BASECLASSES (type
);
1278 CHECK_TYPEDEF (type
);
1280 if (!looking_for_baseclass
)
1281 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1283 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1285 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1288 if (TYPE_FIELD_STATIC (type
, i
))
1290 v
= value_static_field (type
, i
);
1292 error ("field %s is nonexistent or has been optimised out",
1297 v
= value_primitive_field (arg1
, offset
, i
, type
);
1299 error ("there is no field named %s", name
);
1305 && (t_field_name
[0] == '\0'
1306 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1307 && (strcmp_iw (t_field_name
, "else") == 0))))
1309 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1310 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1311 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1313 /* Look for a match through the fields of an anonymous union,
1314 or anonymous struct. C++ provides anonymous unions.
1316 In the GNU Chill (now deleted from GDB)
1317 implementation of variant record types, each
1318 <alternative field> has an (anonymous) union type,
1319 each member of the union represents a <variant
1320 alternative>. Each <variant alternative> is
1321 represented as a struct, with a member for each
1325 int new_offset
= offset
;
1327 /* This is pretty gross. In G++, the offset in an
1328 anonymous union is relative to the beginning of the
1329 enclosing struct. In the GNU Chill (now deleted
1330 from GDB) implementation of variant records, the
1331 bitpos is zero in an anonymous union field, so we
1332 have to add the offset of the union here. */
1333 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1334 || (TYPE_NFIELDS (field_type
) > 0
1335 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1336 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1338 v
= search_struct_field (name
, arg1
, new_offset
, field_type
,
1339 looking_for_baseclass
);
1346 for (i
= 0; i
< nbases
; i
++)
1349 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1350 /* If we are looking for baseclasses, this is what we get when we
1351 hit them. But it could happen that the base part's member name
1352 is not yet filled in. */
1353 int found_baseclass
= (looking_for_baseclass
1354 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1355 && (strcmp_iw (name
, TYPE_BASECLASS_NAME (type
, i
)) == 0));
1357 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1360 struct value
*v2
= allocate_value (basetype
);
1362 boffset
= baseclass_offset (type
, i
,
1363 VALUE_CONTENTS (arg1
) + offset
,
1364 VALUE_ADDRESS (arg1
)
1365 + VALUE_OFFSET (arg1
) + offset
);
1367 error ("virtual baseclass botch");
1369 /* The virtual base class pointer might have been clobbered by the
1370 user program. Make sure that it still points to a valid memory
1374 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
1376 CORE_ADDR base_addr
;
1378 base_addr
= VALUE_ADDRESS (arg1
) + VALUE_OFFSET (arg1
) + boffset
;
1379 if (target_read_memory (base_addr
, VALUE_CONTENTS_RAW (v2
),
1380 TYPE_LENGTH (basetype
)) != 0)
1381 error ("virtual baseclass botch");
1382 VALUE_LVAL (v2
) = lval_memory
;
1383 VALUE_ADDRESS (v2
) = base_addr
;
1387 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
1388 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
1389 VALUE_OFFSET (v2
) = VALUE_OFFSET (arg1
) + boffset
;
1390 if (VALUE_LAZY (arg1
))
1391 VALUE_LAZY (v2
) = 1;
1393 memcpy (VALUE_CONTENTS_RAW (v2
),
1394 VALUE_CONTENTS_RAW (arg1
) + boffset
,
1395 TYPE_LENGTH (basetype
));
1398 if (found_baseclass
)
1400 v
= search_struct_field (name
, v2
, 0, TYPE_BASECLASS (type
, i
),
1401 looking_for_baseclass
);
1403 else if (found_baseclass
)
1404 v
= value_primitive_field (arg1
, offset
, i
, type
);
1406 v
= search_struct_field (name
, arg1
,
1407 offset
+ TYPE_BASECLASS_BITPOS (type
, i
) / 8,
1408 basetype
, looking_for_baseclass
);
1416 /* Return the offset (in bytes) of the virtual base of type BASETYPE
1417 * in an object pointed to by VALADDR (on the host), assumed to be of
1418 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
1419 * looking (in case VALADDR is the contents of an enclosing object).
1421 * This routine recurses on the primary base of the derived class because
1422 * the virtual base entries of the primary base appear before the other
1423 * virtual base entries.
1425 * If the virtual base is not found, a negative integer is returned.
1426 * The magnitude of the negative integer is the number of entries in
1427 * the virtual table to skip over (entries corresponding to various
1428 * ancestral classes in the chain of primary bases).
1430 * Important: This assumes the HP / Taligent C++ runtime
1431 * conventions. Use baseclass_offset() instead to deal with g++
1435 find_rt_vbase_offset (struct type
*type
, struct type
*basetype
, char *valaddr
,
1436 int offset
, int *boffset_p
, int *skip_p
)
1438 int boffset
; /* offset of virtual base */
1439 int index
; /* displacement to use in virtual table */
1443 CORE_ADDR vtbl
; /* the virtual table pointer */
1444 struct type
*pbc
; /* the primary base class */
1446 /* Look for the virtual base recursively in the primary base, first.
1447 * This is because the derived class object and its primary base
1448 * subobject share the primary virtual table. */
1451 pbc
= TYPE_PRIMARY_BASE (type
);
1454 find_rt_vbase_offset (pbc
, basetype
, valaddr
, offset
, &boffset
, &skip
);
1457 *boffset_p
= boffset
;
1466 /* Find the index of the virtual base according to HP/Taligent
1467 runtime spec. (Depth-first, left-to-right.) */
1468 index
= virtual_base_index_skip_primaries (basetype
, type
);
1472 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
1477 /* pai: FIXME -- 32x64 possible problem */
1478 /* First word (4 bytes) in object layout is the vtable pointer */
1479 vtbl
= *(CORE_ADDR
*) (valaddr
+ offset
);
1481 /* Before the constructor is invoked, things are usually zero'd out. */
1483 error ("Couldn't find virtual table -- object may not be constructed yet.");
1486 /* Find virtual base's offset -- jump over entries for primary base
1487 * ancestors, then use the index computed above. But also adjust by
1488 * HP_ACC_VBASE_START for the vtable slots before the start of the
1489 * virtual base entries. Offset is negative -- virtual base entries
1490 * appear _before_ the address point of the virtual table. */
1492 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
1495 /* epstein : FIXME -- added param for overlay section. May not be correct */
1496 vp
= value_at (builtin_type_int
, vtbl
+ 4 * (-skip
- index
- HP_ACC_VBASE_START
), NULL
);
1497 boffset
= value_as_long (vp
);
1499 *boffset_p
= boffset
;
1504 /* Helper function used by value_struct_elt to recurse through baseclasses.
1505 Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1506 and search in it assuming it has (class) type TYPE.
1507 If found, return value, else if name matched and args not return (value)-1,
1508 else return NULL. */
1510 static struct value
*
1511 search_struct_method (char *name
, struct value
**arg1p
,
1512 struct value
**args
, int offset
,
1513 int *static_memfuncp
, register struct type
*type
)
1517 int name_matched
= 0;
1518 char dem_opname
[64];
1520 CHECK_TYPEDEF (type
);
1521 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1523 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1524 /* FIXME! May need to check for ARM demangling here */
1525 if (strncmp (t_field_name
, "__", 2) == 0 ||
1526 strncmp (t_field_name
, "op", 2) == 0 ||
1527 strncmp (t_field_name
, "type", 4) == 0)
1529 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1530 t_field_name
= dem_opname
;
1531 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1532 t_field_name
= dem_opname
;
1534 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1536 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1537 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1540 check_stub_method_group (type
, i
);
1541 if (j
> 0 && args
== 0)
1542 error ("cannot resolve overloaded method `%s': no arguments supplied", name
);
1543 else if (j
== 0 && args
== 0)
1545 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1552 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1553 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
1554 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
1555 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1557 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1558 return value_virtual_fn_field (arg1p
, f
, j
, type
, offset
);
1559 if (TYPE_FN_FIELD_STATIC_P (f
, j
) && static_memfuncp
)
1560 *static_memfuncp
= 1;
1561 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1570 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1574 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1576 if (TYPE_HAS_VTABLE (type
))
1578 /* HP aCC compiled type, search for virtual base offset
1579 according to HP/Taligent runtime spec. */
1581 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
1582 VALUE_CONTENTS_ALL (*arg1p
),
1583 offset
+ VALUE_EMBEDDED_OFFSET (*arg1p
),
1584 &base_offset
, &skip
);
1586 error ("Virtual base class offset not found in vtable");
1590 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1593 /* The virtual base class pointer might have been clobbered by the
1594 user program. Make sure that it still points to a valid memory
1597 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
1599 base_valaddr
= (char *) alloca (TYPE_LENGTH (baseclass
));
1600 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
1601 + VALUE_OFFSET (*arg1p
) + offset
,
1603 TYPE_LENGTH (baseclass
)) != 0)
1604 error ("virtual baseclass botch");
1607 base_valaddr
= VALUE_CONTENTS (*arg1p
) + offset
;
1610 baseclass_offset (type
, i
, base_valaddr
,
1611 VALUE_ADDRESS (*arg1p
)
1612 + VALUE_OFFSET (*arg1p
) + offset
);
1613 if (base_offset
== -1)
1614 error ("virtual baseclass botch");
1619 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1621 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1622 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1623 if (v
== (struct value
*) - 1)
1629 /* FIXME-bothner: Why is this commented out? Why is it here? */
1630 /* *arg1p = arg1_tmp; */
1635 return (struct value
*) - 1;
1640 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1641 extract the component named NAME from the ultimate target structure/union
1642 and return it as a value with its appropriate type.
1643 ERR is used in the error message if *ARGP's type is wrong.
1645 C++: ARGS is a list of argument types to aid in the selection of
1646 an appropriate method. Also, handle derived types.
1648 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1649 where the truthvalue of whether the function that was resolved was
1650 a static member function or not is stored.
1652 ERR is an error message to be printed in case the field is not found. */
1655 value_struct_elt (struct value
**argp
, struct value
**args
,
1656 char *name
, int *static_memfuncp
, char *err
)
1658 register struct type
*t
;
1661 COERCE_ARRAY (*argp
);
1663 t
= check_typedef (VALUE_TYPE (*argp
));
1665 /* Follow pointers until we get to a non-pointer. */
1667 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1669 *argp
= value_ind (*argp
);
1670 /* Don't coerce fn pointer to fn and then back again! */
1671 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1672 COERCE_ARRAY (*argp
);
1673 t
= check_typedef (VALUE_TYPE (*argp
));
1676 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1677 error ("not implemented: member type in value_struct_elt");
1679 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1680 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1681 error ("Attempt to extract a component of a value that is not a %s.", err
);
1683 /* Assume it's not, unless we see that it is. */
1684 if (static_memfuncp
)
1685 *static_memfuncp
= 0;
1689 /* if there are no arguments ...do this... */
1691 /* Try as a field first, because if we succeed, there
1692 is less work to be done. */
1693 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1697 /* C++: If it was not found as a data field, then try to
1698 return it as a pointer to a method. */
1700 if (destructor_name_p (name
, t
))
1701 error ("Cannot get value of destructor");
1703 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1705 if (v
== (struct value
*) - 1)
1706 error ("Cannot take address of a method");
1709 if (TYPE_NFN_FIELDS (t
))
1710 error ("There is no member or method named %s.", name
);
1712 error ("There is no member named %s.", name
);
1717 if (destructor_name_p (name
, t
))
1721 /* Destructors are a special case. */
1722 int m_index
, f_index
;
1725 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
1727 v
= value_fn_field (NULL
, TYPE_FN_FIELDLIST1 (t
, m_index
),
1731 error ("could not find destructor function named %s.", name
);
1737 error ("destructor should not have any argument");
1741 v
= search_struct_method (name
, argp
, args
, 0, static_memfuncp
, t
);
1743 if (v
== (struct value
*) - 1)
1745 error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name
);
1749 /* See if user tried to invoke data as function. If so,
1750 hand it back. If it's not callable (i.e., a pointer to function),
1751 gdb should give an error. */
1752 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1756 error ("Structure has no component named %s.", name
);
1760 /* Search through the methods of an object (and its bases)
1761 * to find a specified method. Return the pointer to the
1762 * fn_field list of overloaded instances.
1763 * Helper function for value_find_oload_list.
1764 * ARGP is a pointer to a pointer to a value (the object)
1765 * METHOD is a string containing the method name
1766 * OFFSET is the offset within the value
1767 * TYPE is the assumed type of the object
1768 * NUM_FNS is the number of overloaded instances
1769 * BASETYPE is set to the actual type of the subobject where the method is found
1770 * BOFFSET is the offset of the base subobject where the method is found */
1772 static struct fn_field
*
1773 find_method_list (struct value
**argp
, char *method
, int offset
,
1774 struct type
*type
, int *num_fns
,
1775 struct type
**basetype
, int *boffset
)
1779 CHECK_TYPEDEF (type
);
1783 /* First check in object itself */
1784 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1786 /* pai: FIXME What about operators and type conversions? */
1787 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1788 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
1790 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1791 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1797 /* Resolve any stub methods. */
1798 check_stub_method_group (type
, i
);
1804 /* Not found in object, check in base subobjects */
1805 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1808 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1810 if (TYPE_HAS_VTABLE (type
))
1812 /* HP aCC compiled type, search for virtual base offset
1813 * according to HP/Taligent runtime spec. */
1815 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
1816 VALUE_CONTENTS_ALL (*argp
),
1817 offset
+ VALUE_EMBEDDED_OFFSET (*argp
),
1818 &base_offset
, &skip
);
1820 error ("Virtual base class offset not found in vtable");
1824 /* probably g++ runtime model */
1825 base_offset
= VALUE_OFFSET (*argp
) + offset
;
1827 baseclass_offset (type
, i
,
1828 VALUE_CONTENTS (*argp
) + base_offset
,
1829 VALUE_ADDRESS (*argp
) + base_offset
);
1830 if (base_offset
== -1)
1831 error ("virtual baseclass botch");
1835 /* non-virtual base, simply use bit position from debug info */
1837 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1839 f
= find_method_list (argp
, method
, base_offset
+ offset
,
1840 TYPE_BASECLASS (type
, i
), num_fns
, basetype
,
1848 /* Return the list of overloaded methods of a specified name.
1849 * ARGP is a pointer to a pointer to a value (the object)
1850 * METHOD is the method name
1851 * OFFSET is the offset within the value contents
1852 * NUM_FNS is the number of overloaded instances
1853 * BASETYPE is set to the type of the base subobject that defines the method
1854 * BOFFSET is the offset of the base subobject which defines the method */
1857 value_find_oload_method_list (struct value
**argp
, char *method
, int offset
,
1858 int *num_fns
, struct type
**basetype
,
1863 t
= check_typedef (VALUE_TYPE (*argp
));
1865 /* code snarfed from value_struct_elt */
1866 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1868 *argp
= value_ind (*argp
);
1869 /* Don't coerce fn pointer to fn and then back again! */
1870 if (TYPE_CODE (VALUE_TYPE (*argp
)) != TYPE_CODE_FUNC
)
1871 COERCE_ARRAY (*argp
);
1872 t
= check_typedef (VALUE_TYPE (*argp
));
1875 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
1876 error ("Not implemented: member type in value_find_oload_lis");
1878 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1879 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1880 error ("Attempt to extract a component of a value that is not a struct or union");
1882 return find_method_list (argp
, method
, 0, t
, num_fns
, basetype
, boffset
);
1885 /* Given an array of argument types (ARGTYPES) (which includes an
1886 entry for "this" in the case of C++ methods), the number of
1887 arguments NARGS, the NAME of a function whether it's a method or
1888 not (METHOD), and the degree of laxness (LAX) in conforming to
1889 overload resolution rules in ANSI C++, find the best function that
1890 matches on the argument types according to the overload resolution
1893 In the case of class methods, the parameter OBJ is an object value
1894 in which to search for overloaded methods.
1896 In the case of non-method functions, the parameter FSYM is a symbol
1897 corresponding to one of the overloaded functions.
1899 Return value is an integer: 0 -> good match, 10 -> debugger applied
1900 non-standard coercions, 100 -> incompatible.
1902 If a method is being searched for, VALP will hold the value.
1903 If a non-method is being searched for, SYMP will hold the symbol for it.
1905 If a method is being searched for, and it is a static method,
1906 then STATICP will point to a non-zero value.
1908 Note: This function does *not* check the value of
1909 overload_resolution. Caller must check it to see whether overload
1910 resolution is permitted.
1914 find_overload_match (struct type
**arg_types
, int nargs
, char *name
, int method
,
1915 int lax
, struct value
**objp
, struct symbol
*fsym
,
1916 struct value
**valp
, struct symbol
**symp
, int *staticp
)
1919 struct type
**parm_types
;
1920 int champ_nparms
= 0;
1921 struct value
*obj
= (objp
? *objp
: NULL
);
1923 short oload_champ
= -1; /* Index of best overloaded function */
1924 short oload_ambiguous
= 0; /* Current ambiguity state for overload resolution */
1925 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
1926 short oload_ambig_champ
= -1; /* 2nd contender for best match */
1927 short oload_non_standard
= 0; /* did we have to use non-standard conversions? */
1928 short oload_incompatible
= 0; /* are args supplied incompatible with any function? */
1930 struct badness_vector
*bv
; /* A measure of how good an overloaded instance is */
1931 struct badness_vector
*oload_champ_bv
= NULL
; /* The measure for the current best match */
1933 struct value
*temp
= obj
;
1934 struct fn_field
*fns_ptr
= NULL
; /* For methods, the list of overloaded methods */
1935 struct symbol
**oload_syms
= NULL
; /* For non-methods, the list of overloaded function symbols */
1936 int num_fns
= 0; /* Number of overloaded instances being considered */
1937 struct type
*basetype
= NULL
;
1942 struct cleanup
*cleanups
= NULL
;
1944 char *obj_type_name
= NULL
;
1945 char *func_name
= NULL
;
1947 /* Get the list of overloaded methods or functions */
1950 obj_type_name
= TYPE_NAME (VALUE_TYPE (obj
));
1951 /* Hack: evaluate_subexp_standard often passes in a pointer
1952 value rather than the object itself, so try again */
1953 if ((!obj_type_name
|| !*obj_type_name
) &&
1954 (TYPE_CODE (VALUE_TYPE (obj
)) == TYPE_CODE_PTR
))
1955 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj
)));
1957 fns_ptr
= value_find_oload_method_list (&temp
, name
, 0,
1959 &basetype
, &boffset
);
1960 if (!fns_ptr
|| !num_fns
)
1961 error ("Couldn't find method %s%s%s",
1963 (obj_type_name
&& *obj_type_name
) ? "::" : "",
1965 /* If we are dealing with stub method types, they should have
1966 been resolved by find_method_list via value_find_oload_method_list
1968 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
1973 func_name
= cplus_demangle (DEPRECATED_SYMBOL_NAME (fsym
), DMGL_NO_OPTS
);
1975 /* If the name is NULL this must be a C-style function.
1976 Just return the same symbol. */
1983 oload_syms
= make_symbol_overload_list (fsym
);
1984 cleanups
= make_cleanup (xfree
, oload_syms
);
1985 while (oload_syms
[++i
])
1988 error ("Couldn't find function %s", func_name
);
1991 oload_champ_bv
= NULL
;
1993 /* Consider each candidate in turn */
1994 for (ix
= 0; ix
< num_fns
; ix
++)
1999 if (TYPE_FN_FIELD_STATIC_P (fns_ptr
, ix
))
2001 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2005 /* If it's not a method, this is the proper place */
2006 nparms
=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms
[ix
]));
2009 /* Prepare array of parameter types */
2010 parm_types
= (struct type
**) xmalloc (nparms
* (sizeof (struct type
*)));
2011 for (jj
= 0; jj
< nparms
; jj
++)
2012 parm_types
[jj
] = (method
2013 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2014 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]), jj
));
2016 /* Compare parameter types to supplied argument types. Skip THIS for
2018 bv
= rank_function (parm_types
, nparms
, arg_types
+ static_offset
,
2019 nargs
- static_offset
);
2021 if (!oload_champ_bv
)
2023 oload_champ_bv
= bv
;
2025 champ_nparms
= nparms
;
2028 /* See whether current candidate is better or worse than previous best */
2029 switch (compare_badness (bv
, oload_champ_bv
))
2032 oload_ambiguous
= 1; /* top two contenders are equally good */
2033 oload_ambig_champ
= ix
;
2036 oload_ambiguous
= 2; /* incomparable top contenders */
2037 oload_ambig_champ
= ix
;
2040 oload_champ_bv
= bv
; /* new champion, record details */
2041 oload_ambiguous
= 0;
2043 oload_ambig_champ
= -1;
2044 champ_nparms
= nparms
;
2054 fprintf_filtered (gdb_stderr
,"Overloaded method instance %s, # of parms %d\n", fns_ptr
[ix
].physname
, nparms
);
2056 fprintf_filtered (gdb_stderr
,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]), nparms
);
2057 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2058 fprintf_filtered (gdb_stderr
,"...Badness @ %d : %d\n", jj
, bv
->rank
[jj
]);
2059 fprintf_filtered (gdb_stderr
,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ
, oload_ambiguous
);
2061 } /* end loop over all candidates */
2062 /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2063 if they have the exact same goodness. This is because there is no
2064 way to differentiate based on return type, which we need to in
2065 cases like overloads of .begin() <It's both const and non-const> */
2067 if (oload_ambiguous
)
2070 error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2072 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2075 error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2080 /* Check how bad the best match is. */
2082 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, oload_champ
))
2084 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2086 if (oload_champ_bv
->rank
[ix
] >= 100)
2087 oload_incompatible
= 1; /* truly mismatched types */
2089 else if (oload_champ_bv
->rank
[ix
] >= 10)
2090 oload_non_standard
= 1; /* non-standard type conversions needed */
2092 if (oload_incompatible
)
2095 error ("Cannot resolve method %s%s%s to any overloaded instance",
2097 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2100 error ("Cannot resolve function %s to any overloaded instance",
2103 else if (oload_non_standard
)
2106 warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2108 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2111 warning ("Using non-standard conversion to match function %s to supplied arguments",
2117 if (staticp
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, oload_champ
))
2121 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2122 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2124 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
, basetype
, boffset
);
2128 *symp
= oload_syms
[oload_champ
];
2134 if (TYPE_CODE (VALUE_TYPE (temp
)) != TYPE_CODE_PTR
2135 && TYPE_CODE (VALUE_TYPE (*objp
)) == TYPE_CODE_PTR
)
2137 temp
= value_addr (temp
);
2141 if (cleanups
!= NULL
)
2142 do_cleanups (cleanups
);
2144 return oload_incompatible
? 100 : (oload_non_standard
? 10 : 0);
2147 /* C++: return 1 is NAME is a legitimate name for the destructor
2148 of type TYPE. If TYPE does not have a destructor, or
2149 if NAME is inappropriate for TYPE, an error is signaled. */
2151 destructor_name_p (const char *name
, const struct type
*type
)
2153 /* destructors are a special case. */
2157 char *dname
= type_name_no_tag (type
);
2158 char *cp
= strchr (dname
, '<');
2161 /* Do not compare the template part for template classes. */
2163 len
= strlen (dname
);
2166 if (strlen (name
+ 1) != len
|| !STREQN (dname
, name
+ 1, len
))
2167 error ("name of destructor must equal name of class");
2174 /* Helper function for check_field: Given TYPE, a structure/union,
2175 return 1 if the component named NAME from the ultimate
2176 target structure/union is defined, otherwise, return 0. */
2179 check_field_in (register struct type
*type
, const char *name
)
2183 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2185 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2186 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2190 /* C++: If it was not found as a data field, then try to
2191 return it as a pointer to a method. */
2193 /* Destructors are a special case. */
2194 if (destructor_name_p (name
, type
))
2196 int m_index
, f_index
;
2198 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2201 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2203 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2207 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2208 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2215 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2216 return 1 if the component named NAME from the ultimate
2217 target structure/union is defined, otherwise, return 0. */
2220 check_field (struct value
*arg1
, const char *name
)
2222 register struct type
*t
;
2224 COERCE_ARRAY (arg1
);
2226 t
= VALUE_TYPE (arg1
);
2228 /* Follow pointers until we get to a non-pointer. */
2233 if (TYPE_CODE (t
) != TYPE_CODE_PTR
&& TYPE_CODE (t
) != TYPE_CODE_REF
)
2235 t
= TYPE_TARGET_TYPE (t
);
2238 if (TYPE_CODE (t
) == TYPE_CODE_MEMBER
)
2239 error ("not implemented: member type in check_field");
2241 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2242 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2243 error ("Internal error: `this' is not an aggregate");
2245 return check_field_in (t
, name
);
2248 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2249 return the address of this member as a "pointer to member"
2250 type. If INTYPE is non-null, then it will be the type
2251 of the member we are looking for. This will help us resolve
2252 "pointers to member functions". This function is used
2253 to resolve user expressions of the form "DOMAIN::NAME". */
2256 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2257 struct type
*curtype
, char *name
,
2258 struct type
*intype
)
2260 register struct type
*t
= curtype
;
2264 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2265 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2266 error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2268 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2270 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2272 if (t_field_name
&& STREQ (t_field_name
, name
))
2274 if (TYPE_FIELD_STATIC (t
, i
))
2276 v
= value_static_field (t
, i
);
2278 error ("static field %s has been optimized out",
2282 if (TYPE_FIELD_PACKED (t
, i
))
2283 error ("pointers to bitfield members not allowed");
2285 return value_from_longest
2286 (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t
, i
),
2288 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2292 /* C++: If it was not found as a data field, then try to
2293 return it as a pointer to a method. */
2295 /* Destructors are a special case. */
2296 if (destructor_name_p (name
, t
))
2298 error ("member pointers to destructors not implemented yet");
2301 /* Perform all necessary dereferencing. */
2302 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2303 intype
= TYPE_TARGET_TYPE (intype
);
2305 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2307 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2308 char dem_opname
[64];
2310 if (strncmp (t_field_name
, "__", 2) == 0 ||
2311 strncmp (t_field_name
, "op", 2) == 0 ||
2312 strncmp (t_field_name
, "type", 4) == 0)
2314 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2315 t_field_name
= dem_opname
;
2316 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2317 t_field_name
= dem_opname
;
2319 if (t_field_name
&& STREQ (t_field_name
, name
))
2321 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2322 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2324 check_stub_method_group (t
, i
);
2326 if (intype
== 0 && j
> 1)
2327 error ("non-unique member `%s' requires type instantiation", name
);
2331 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2334 error ("no member function matches that type instantiation");
2339 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2341 return value_from_longest
2342 (lookup_reference_type
2343 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2345 (LONGEST
) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f
, j
)));
2349 struct symbol
*s
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2350 0, VAR_DOMAIN
, 0, NULL
);
2357 v
= read_var_value (s
, 0);
2359 VALUE_TYPE (v
) = lookup_reference_type
2360 (lookup_member_type (TYPE_FN_FIELD_TYPE (f
, j
),
2368 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2373 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2376 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2377 v
= value_struct_elt_for_reference (domain
,
2378 offset
+ base_offset
,
2379 TYPE_BASECLASS (t
, i
),
2389 /* Given a pointer value V, find the real (RTTI) type
2390 of the object it points to.
2391 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2392 and refer to the values computed for the object pointed to. */
2395 value_rtti_target_type (struct value
*v
, int *full
, int *top
, int *using_enc
)
2397 struct value
*target
;
2399 target
= value_ind (v
);
2401 return value_rtti_type (target
, full
, top
, using_enc
);
2404 /* Given a value pointed to by ARGP, check its real run-time type, and
2405 if that is different from the enclosing type, create a new value
2406 using the real run-time type as the enclosing type (and of the same
2407 type as ARGP) and return it, with the embedded offset adjusted to
2408 be the correct offset to the enclosed object
2409 RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
2410 parameters, computed by value_rtti_type(). If these are available,
2411 they can be supplied and a second call to value_rtti_type() is avoided.
2412 (Pass RTYPE == NULL if they're not available */
2415 value_full_object (struct value
*argp
, struct type
*rtype
, int xfull
, int xtop
,
2418 struct type
*real_type
;
2422 struct value
*new_val
;
2429 using_enc
= xusing_enc
;
2432 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
2434 /* If no RTTI data, or if object is already complete, do nothing */
2435 if (!real_type
|| real_type
== VALUE_ENCLOSING_TYPE (argp
))
2438 /* If we have the full object, but for some reason the enclosing
2439 type is wrong, set it *//* pai: FIXME -- sounds iffy */
2442 argp
= value_change_enclosing_type (argp
, real_type
);
2446 /* Check if object is in memory */
2447 if (VALUE_LVAL (argp
) != lval_memory
)
2449 warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type
));
2454 /* All other cases -- retrieve the complete object */
2455 /* Go back by the computed top_offset from the beginning of the object,
2456 adjusting for the embedded offset of argp if that's what value_rtti_type
2457 used for its computation. */
2458 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
2459 (using_enc
? 0 : VALUE_EMBEDDED_OFFSET (argp
)),
2460 VALUE_BFD_SECTION (argp
));
2461 VALUE_TYPE (new_val
) = VALUE_TYPE (argp
);
2462 VALUE_EMBEDDED_OFFSET (new_val
) = using_enc
? top
+ VALUE_EMBEDDED_OFFSET (argp
) : top
;
2469 /* Return the value of the local variable, if one exists.
2470 Flag COMPLAIN signals an error if the request is made in an
2471 inappropriate context. */
2474 value_of_local (const char *name
, int complain
)
2476 struct symbol
*func
, *sym
;
2481 if (deprecated_selected_frame
== 0)
2484 error ("no frame selected");
2489 func
= get_frame_function (deprecated_selected_frame
);
2493 error ("no `%s' in nameless context", name
);
2498 b
= SYMBOL_BLOCK_VALUE (func
);
2499 i
= BLOCK_NSYMS (b
);
2503 error ("no args, no `%s'", name
);
2508 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2509 symbol instead of the LOC_ARG one (if both exist). */
2510 sym
= lookup_block_symbol (b
, name
, NULL
, VAR_DOMAIN
);
2514 error ("current stack frame does not contain a variable named `%s'", name
);
2519 ret
= read_var_value (sym
, deprecated_selected_frame
);
2520 if (ret
== 0 && complain
)
2521 error ("`%s' argument unreadable", name
);
2525 /* C++/Objective-C: return the value of the class instance variable,
2526 if one exists. Flag COMPLAIN signals an error if the request is
2527 made in an inappropriate context. */
2530 value_of_this (int complain
)
2532 if (current_language
->la_language
== language_objc
)
2533 return value_of_local ("self", complain
);
2535 return value_of_local ("this", complain
);
2538 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2539 long, starting at LOWBOUND. The result has the same lower bound as
2540 the original ARRAY. */
2543 value_slice (struct value
*array
, int lowbound
, int length
)
2545 struct type
*slice_range_type
, *slice_type
, *range_type
;
2546 LONGEST lowerbound
, upperbound
;
2547 struct value
*slice
;
2548 struct type
*array_type
;
2549 array_type
= check_typedef (VALUE_TYPE (array
));
2550 COERCE_VARYING_ARRAY (array
, array_type
);
2551 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
2552 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
2553 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
2554 error ("cannot take slice of non-array");
2555 range_type
= TYPE_INDEX_TYPE (array_type
);
2556 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
2557 error ("slice from bad array or bitstring");
2558 if (lowbound
< lowerbound
|| length
< 0
2559 || lowbound
+ length
- 1 > upperbound
)
2560 error ("slice out of range");
2561 /* FIXME-type-allocation: need a way to free this type when we are
2563 slice_range_type
= create_range_type ((struct type
*) NULL
,
2564 TYPE_TARGET_TYPE (range_type
),
2565 lowbound
, lowbound
+ length
- 1);
2566 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
2569 slice_type
= create_set_type ((struct type
*) NULL
, slice_range_type
);
2570 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
2571 slice
= value_zero (slice_type
, not_lval
);
2572 for (i
= 0; i
< length
; i
++)
2574 int element
= value_bit_index (array_type
,
2575 VALUE_CONTENTS (array
),
2578 error ("internal error accessing bitstring");
2579 else if (element
> 0)
2581 int j
= i
% TARGET_CHAR_BIT
;
2582 if (BITS_BIG_ENDIAN
)
2583 j
= TARGET_CHAR_BIT
- 1 - j
;
2584 VALUE_CONTENTS_RAW (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
2587 /* We should set the address, bitssize, and bitspos, so the clice
2588 can be used on the LHS, but that may require extensions to
2589 value_assign. For now, just leave as a non_lval. FIXME. */
2593 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
2595 = (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
2596 slice_type
= create_array_type ((struct type
*) NULL
, element_type
,
2598 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
2599 slice
= allocate_value (slice_type
);
2600 if (VALUE_LAZY (array
))
2601 VALUE_LAZY (slice
) = 1;
2603 memcpy (VALUE_CONTENTS (slice
), VALUE_CONTENTS (array
) + offset
,
2604 TYPE_LENGTH (slice_type
));
2605 if (VALUE_LVAL (array
) == lval_internalvar
)
2606 VALUE_LVAL (slice
) = lval_internalvar_component
;
2608 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2609 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2610 VALUE_OFFSET (slice
) = VALUE_OFFSET (array
) + offset
;
2615 /* Create a value for a FORTRAN complex number. Currently most of
2616 the time values are coerced to COMPLEX*16 (i.e. a complex number
2617 composed of 2 doubles. This really should be a smarter routine
2618 that figures out precision inteligently as opposed to assuming
2619 doubles. FIXME: fmb */
2622 value_literal_complex (struct value
*arg1
, struct value
*arg2
, struct type
*type
)
2625 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2627 val
= allocate_value (type
);
2628 arg1
= value_cast (real_type
, arg1
);
2629 arg2
= value_cast (real_type
, arg2
);
2631 memcpy (VALUE_CONTENTS_RAW (val
),
2632 VALUE_CONTENTS (arg1
), TYPE_LENGTH (real_type
));
2633 memcpy (VALUE_CONTENTS_RAW (val
) + TYPE_LENGTH (real_type
),
2634 VALUE_CONTENTS (arg2
), TYPE_LENGTH (real_type
));
2638 /* Cast a value into the appropriate complex data type. */
2640 static struct value
*
2641 cast_into_complex (struct type
*type
, struct value
*val
)
2643 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2644 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_COMPLEX
)
2646 struct type
*val_real_type
= TYPE_TARGET_TYPE (VALUE_TYPE (val
));
2647 struct value
*re_val
= allocate_value (val_real_type
);
2648 struct value
*im_val
= allocate_value (val_real_type
);
2650 memcpy (VALUE_CONTENTS_RAW (re_val
),
2651 VALUE_CONTENTS (val
), TYPE_LENGTH (val_real_type
));
2652 memcpy (VALUE_CONTENTS_RAW (im_val
),
2653 VALUE_CONTENTS (val
) + TYPE_LENGTH (val_real_type
),
2654 TYPE_LENGTH (val_real_type
));
2656 return value_literal_complex (re_val
, im_val
, type
);
2658 else if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
2659 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
)
2660 return value_literal_complex (val
, value_zero (real_type
, not_lval
), type
);
2662 error ("cannot cast non-number to complex");
2666 _initialize_valops (void)
2670 (add_set_cmd ("abandon", class_support
, var_boolean
, (char *) &auto_abandon
,
2671 "Set automatic abandonment of expressions upon failure.",
2677 (add_set_cmd ("overload-resolution", class_support
, var_boolean
, (char *) &overload_resolution
,
2678 "Set overload resolution in evaluating C++ functions.",
2681 overload_resolution
= 1;