1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
5 2006, 2007 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "dictionary.h"
38 #include "cp-support.h"
41 #include "gdb_string.h"
42 #include "gdb_assert.h"
43 #include "cp-support.h"
46 extern int overload_debug
;
47 /* Local functions. */
49 static int typecmp (int staticp
, int varargs
, int nargs
,
50 struct field t1
[], struct value
*t2
[]);
52 static struct value
*search_struct_field (char *, struct value
*,
53 int, struct type
*, int);
55 static struct value
*search_struct_method (char *, struct value
**,
57 int, int *, struct type
*);
59 static int find_oload_champ_namespace (struct type
**, int,
60 const char *, const char *,
62 struct badness_vector
**);
65 int find_oload_champ_namespace_loop (struct type
**, int,
66 const char *, const char *,
67 int, struct symbol
***,
68 struct badness_vector
**, int *);
70 static int find_oload_champ (struct type
**, int, int, int,
71 struct fn_field
*, struct symbol
**,
72 struct badness_vector
**);
74 static int oload_method_static (int, struct fn_field
*, int);
76 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
79 oload_classification
classify_oload_match (struct badness_vector
*,
82 static int check_field_in (struct type
*, const char *);
84 static struct value
*value_struct_elt_for_reference (struct type
*,
90 static struct value
*value_namespace_elt (const struct type
*,
91 char *, int , enum noside
);
93 static struct value
*value_maybe_namespace_elt (const struct type
*,
97 static CORE_ADDR
allocate_space_in_inferior (int);
99 static struct value
*cast_into_complex (struct type
*, struct value
*);
101 static struct fn_field
*find_method_list (struct value
**, char *,
102 int, struct type
*, int *,
103 struct type
**, int *);
105 void _initialize_valops (void);
108 /* Flag for whether we want to abandon failed expression evals by
111 static int auto_abandon
= 0;
114 int overload_resolution
= 0;
116 show_overload_resolution (struct ui_file
*file
, int from_tty
,
117 struct cmd_list_element
*c
,
120 fprintf_filtered (file
, _("\
121 Overload resolution in evaluating C++ functions is %s.\n"),
125 /* Find the address of function name NAME in the inferior. */
128 find_function_in_inferior (const char *name
)
131 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0, NULL
);
134 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
136 error (_("\"%s\" exists in this program but is not a function."),
139 return value_of_variable (sym
, NULL
);
143 struct minimal_symbol
*msymbol
=
144 lookup_minimal_symbol (name
, NULL
, NULL
);
149 type
= lookup_pointer_type (builtin_type_char
);
150 type
= lookup_function_type (type
);
151 type
= lookup_pointer_type (type
);
152 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
153 return value_from_pointer (type
, maddr
);
157 if (!target_has_execution
)
158 error (_("evaluation of this expression requires the target program to be active"));
160 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name
);
165 /* Allocate NBYTES of space in the inferior using the inferior's
166 malloc and return a value that is a pointer to the allocated
170 value_allocate_space_in_inferior (int len
)
172 struct value
*blocklen
;
174 find_function_in_inferior (gdbarch_name_of_malloc (current_gdbarch
));
176 blocklen
= value_from_longest (builtin_type_int
, (LONGEST
) len
);
177 val
= call_function_by_hand (val
, 1, &blocklen
);
178 if (value_logical_not (val
))
180 if (!target_has_execution
)
181 error (_("No memory available to program now: you need to start the target first"));
183 error (_("No memory available to program: call to malloc failed"));
189 allocate_space_in_inferior (int len
)
191 return value_as_long (value_allocate_space_in_inferior (len
));
194 /* Cast one pointer or reference type to another. Both TYPE and
195 the type of ARG2 should be pointer types, or else both should be
196 reference types. Returns the new pointer or reference. */
199 value_cast_pointers (struct type
*type
, struct value
*arg2
)
201 struct type
*type2
= check_typedef (value_type (arg2
));
202 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
203 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
205 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
206 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
207 && !value_logical_not (arg2
))
211 /* Look in the type of the source to see if it contains the
212 type of the target as a superclass. If so, we'll need to
213 offset the pointer rather than just change its type. */
214 if (TYPE_NAME (t1
) != NULL
)
218 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
219 v2
= coerce_ref (arg2
);
221 v2
= value_ind (arg2
);
222 v
= search_struct_field (type_name_no_tag (t1
),
227 deprecated_set_value_type (v
, type
);
232 /* Look in the type of the target to see if it contains the
233 type of the source as a superclass. If so, we'll need to
234 offset the pointer rather than just change its type.
235 FIXME: This fails silently with virtual inheritance. */
236 if (TYPE_NAME (t2
) != NULL
)
238 v
= search_struct_field (type_name_no_tag (t2
),
239 value_zero (t1
, not_lval
), 0, t1
, 1);
242 CORE_ADDR addr2
= value_as_address (arg2
);
243 addr2
-= (VALUE_ADDRESS (v
)
245 + value_embedded_offset (v
));
246 return value_from_pointer (type
, addr2
);
251 /* No superclass found, just change the pointer type. */
252 arg2
= value_copy (arg2
);
253 deprecated_set_value_type (arg2
, type
);
254 arg2
= value_change_enclosing_type (arg2
, type
);
255 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
259 /* Cast value ARG2 to type TYPE and return as a value.
260 More general than a C cast: accepts any two types of the same length,
261 and if ARG2 is an lvalue it can be cast into anything at all. */
262 /* In C++, casts may change pointer or object representations. */
265 value_cast (struct type
*type
, struct value
*arg2
)
267 enum type_code code1
;
268 enum type_code code2
;
272 int convert_to_boolean
= 0;
274 if (value_type (arg2
) == type
)
277 CHECK_TYPEDEF (type
);
278 code1
= TYPE_CODE (type
);
279 arg2
= coerce_ref (arg2
);
280 type2
= check_typedef (value_type (arg2
));
282 /* You can't cast to a reference type. See value_cast_pointers
284 gdb_assert (code1
!= TYPE_CODE_REF
);
286 /* A cast to an undetermined-length array_type, such as
287 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
288 where N is sizeof(OBJECT)/sizeof(TYPE). */
289 if (code1
== TYPE_CODE_ARRAY
)
291 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
292 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
293 if (element_length
> 0
294 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
296 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
297 int val_length
= TYPE_LENGTH (type2
);
298 LONGEST low_bound
, high_bound
, new_length
;
299 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
300 low_bound
= 0, high_bound
= 0;
301 new_length
= val_length
/ element_length
;
302 if (val_length
% element_length
!= 0)
303 warning (_("array element type size does not divide object size in cast"));
304 /* FIXME-type-allocation: need a way to free this type when
305 we are done with it. */
306 range_type
= create_range_type ((struct type
*) NULL
,
307 TYPE_TARGET_TYPE (range_type
),
309 new_length
+ low_bound
- 1);
310 deprecated_set_value_type (arg2
,
311 create_array_type ((struct type
*) NULL
,
318 if (current_language
->c_style_arrays
319 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
320 arg2
= value_coerce_array (arg2
);
322 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
323 arg2
= value_coerce_function (arg2
);
325 type2
= check_typedef (value_type (arg2
));
326 code2
= TYPE_CODE (type2
);
328 if (code1
== TYPE_CODE_COMPLEX
)
329 return cast_into_complex (type
, arg2
);
330 if (code1
== TYPE_CODE_BOOL
)
332 code1
= TYPE_CODE_INT
;
333 convert_to_boolean
= 1;
335 if (code1
== TYPE_CODE_CHAR
)
336 code1
= TYPE_CODE_INT
;
337 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
338 code2
= TYPE_CODE_INT
;
340 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
341 || code2
== TYPE_CODE_ENUM
|| code2
== TYPE_CODE_RANGE
);
343 if (code1
== TYPE_CODE_STRUCT
344 && code2
== TYPE_CODE_STRUCT
345 && TYPE_NAME (type
) != 0)
347 /* Look in the type of the source to see if it contains the
348 type of the target as a superclass. If so, we'll need to
349 offset the object in addition to changing its type. */
350 struct value
*v
= search_struct_field (type_name_no_tag (type
),
354 deprecated_set_value_type (v
, type
);
358 if (code1
== TYPE_CODE_FLT
&& scalar
)
359 return value_from_double (type
, value_as_double (arg2
));
360 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
361 || code1
== TYPE_CODE_RANGE
)
362 && (scalar
|| code2
== TYPE_CODE_PTR
363 || code2
== TYPE_CODE_MEMBERPTR
))
367 /* When we cast pointers to integers, we mustn't use
368 gdbarch_pointer_to_address to find the address the pointer
369 represents, as value_as_long would. GDB should evaluate
370 expressions just as the compiler would --- and the compiler
371 sees a cast as a simple reinterpretation of the pointer's
373 if (code2
== TYPE_CODE_PTR
)
374 longest
= extract_unsigned_integer (value_contents (arg2
),
375 TYPE_LENGTH (type2
));
377 longest
= value_as_long (arg2
);
378 return value_from_longest (type
, convert_to_boolean
?
379 (LONGEST
) (longest
? 1 : 0) : longest
);
381 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
382 || code2
== TYPE_CODE_ENUM
383 || code2
== TYPE_CODE_RANGE
))
385 /* TYPE_LENGTH (type) is the length of a pointer, but we really
386 want the length of an address! -- we are really dealing with
387 addresses (i.e., gdb representations) not pointers (i.e.,
388 target representations) here.
390 This allows things like "print *(int *)0x01000234" to work
391 without printing a misleading message -- which would
392 otherwise occur when dealing with a target having two byte
393 pointers and four byte addresses. */
395 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
397 LONGEST longest
= value_as_long (arg2
);
398 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
400 if (longest
>= ((LONGEST
) 1 << addr_bit
)
401 || longest
<= -((LONGEST
) 1 << addr_bit
))
402 warning (_("value truncated"));
404 return value_from_longest (type
, longest
);
406 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
407 && value_as_long (arg2
) == 0)
409 struct value
*result
= allocate_value (type
);
410 cplus_make_method_ptr (value_contents_writeable (result
), 0, 0);
413 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
414 && value_as_long (arg2
) == 0)
416 /* The Itanium C++ ABI represents NULL pointers to members as
417 minus one, instead of biasing the normal case. */
418 return value_from_longest (type
, -1);
420 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
422 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
423 return value_cast_pointers (type
, arg2
);
425 arg2
= value_copy (arg2
);
426 deprecated_set_value_type (arg2
, type
);
427 arg2
= value_change_enclosing_type (arg2
, type
);
428 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
431 else if (VALUE_LVAL (arg2
) == lval_memory
)
432 return value_at_lazy (type
,
433 VALUE_ADDRESS (arg2
) + value_offset (arg2
));
434 else if (code1
== TYPE_CODE_VOID
)
436 return value_zero (builtin_type_void
, not_lval
);
440 error (_("Invalid cast."));
445 /* Create a value of type TYPE that is zero, and return it. */
448 value_zero (struct type
*type
, enum lval_type lv
)
450 struct value
*val
= allocate_value (type
);
451 VALUE_LVAL (val
) = lv
;
456 /* Return a value with type TYPE located at ADDR.
458 Call value_at only if the data needs to be fetched immediately;
459 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
460 value_at_lazy instead. value_at_lazy simply records the address of
461 the data and sets the lazy-evaluation-required flag. The lazy flag
462 is tested in the value_contents macro, which is used if and when
463 the contents are actually required.
465 Note: value_at does *NOT* handle embedded offsets; perform such
466 adjustments before or after calling it. */
469 value_at (struct type
*type
, CORE_ADDR addr
)
473 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
474 error (_("Attempt to dereference a generic pointer."));
476 val
= allocate_value (type
);
478 read_memory (addr
, value_contents_all_raw (val
), TYPE_LENGTH (type
));
480 VALUE_LVAL (val
) = lval_memory
;
481 VALUE_ADDRESS (val
) = addr
;
486 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
489 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
493 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
494 error (_("Attempt to dereference a generic pointer."));
496 val
= allocate_value (type
);
498 VALUE_LVAL (val
) = lval_memory
;
499 VALUE_ADDRESS (val
) = addr
;
500 set_value_lazy (val
, 1);
505 /* Called only from the value_contents and value_contents_all()
506 macros, if the current data for a variable needs to be loaded into
507 value_contents(VAL). Fetches the data from the user's process, and
508 clears the lazy flag to indicate that the data in the buffer is
511 If the value is zero-length, we avoid calling read_memory, which
512 would abort. We mark the value as fetched anyway -- all 0 bytes of
515 This function returns a value because it is used in the
516 value_contents macro as part of an expression, where a void would
517 not work. The value is ignored. */
520 value_fetch_lazy (struct value
*val
)
522 CORE_ADDR addr
= VALUE_ADDRESS (val
) + value_offset (val
);
523 int length
= TYPE_LENGTH (value_enclosing_type (val
));
525 struct type
*type
= value_type (val
);
527 read_memory (addr
, value_contents_all_raw (val
), length
);
529 set_value_lazy (val
, 0);
534 /* Store the contents of FROMVAL into the location of TOVAL.
535 Return a new value with the location of TOVAL and contents of FROMVAL. */
538 value_assign (struct value
*toval
, struct value
*fromval
)
542 struct frame_id old_frame
;
544 if (!deprecated_value_modifiable (toval
))
545 error (_("Left operand of assignment is not a modifiable lvalue."));
547 toval
= coerce_ref (toval
);
549 type
= value_type (toval
);
550 if (VALUE_LVAL (toval
) != lval_internalvar
)
551 fromval
= value_cast (type
, fromval
);
553 fromval
= coerce_array (fromval
);
554 CHECK_TYPEDEF (type
);
556 /* Since modifying a register can trash the frame chain, and
557 modifying memory can trash the frame cache, we save the old frame
558 and then restore the new frame afterwards. */
559 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
561 switch (VALUE_LVAL (toval
))
563 case lval_internalvar
:
564 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
565 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
566 val
= value_change_enclosing_type (val
,
567 value_enclosing_type (fromval
));
568 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
569 set_value_pointed_to_offset (val
,
570 value_pointed_to_offset (fromval
));
573 case lval_internalvar_component
:
574 set_internalvar_component (VALUE_INTERNALVAR (toval
),
575 value_offset (toval
),
576 value_bitpos (toval
),
577 value_bitsize (toval
),
583 const gdb_byte
*dest_buffer
;
584 CORE_ADDR changed_addr
;
586 gdb_byte buffer
[sizeof (LONGEST
)];
588 if (value_bitsize (toval
))
590 /* We assume that the argument to read_memory is in units
591 of host chars. FIXME: Is that correct? */
592 changed_len
= (value_bitpos (toval
)
593 + value_bitsize (toval
)
597 if (changed_len
> (int) sizeof (LONGEST
))
598 error (_("Can't handle bitfields which don't fit in a %d bit word."),
599 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
601 read_memory (VALUE_ADDRESS (toval
) + value_offset (toval
),
602 buffer
, changed_len
);
603 modify_field (buffer
, value_as_long (fromval
),
604 value_bitpos (toval
), value_bitsize (toval
));
605 changed_addr
= VALUE_ADDRESS (toval
) + value_offset (toval
);
606 dest_buffer
= buffer
;
610 changed_addr
= VALUE_ADDRESS (toval
) + value_offset (toval
);
611 changed_len
= TYPE_LENGTH (type
);
612 dest_buffer
= value_contents (fromval
);
615 write_memory (changed_addr
, dest_buffer
, changed_len
);
616 if (deprecated_memory_changed_hook
)
617 deprecated_memory_changed_hook (changed_addr
, changed_len
);
623 struct frame_info
*frame
;
626 /* Figure out which frame this is in currently. */
627 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
628 value_reg
= VALUE_REGNUM (toval
);
631 error (_("Value being assigned to is no longer active."));
633 if (gdbarch_convert_register_p
634 (current_gdbarch
, VALUE_REGNUM (toval
), type
))
636 /* If TOVAL is a special machine register requiring
637 conversion of program values to a special raw
639 gdbarch_value_to_register (current_gdbarch
, frame
,
640 VALUE_REGNUM (toval
), type
,
641 value_contents (fromval
));
645 if (value_bitsize (toval
))
648 gdb_byte buffer
[sizeof (LONGEST
)];
650 changed_len
= (value_bitpos (toval
)
651 + value_bitsize (toval
)
655 if (changed_len
> (int) sizeof (LONGEST
))
656 error (_("Can't handle bitfields which don't fit in a %d bit word."),
657 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
659 get_frame_register_bytes (frame
, value_reg
,
660 value_offset (toval
),
661 changed_len
, buffer
);
663 modify_field (buffer
, value_as_long (fromval
),
664 value_bitpos (toval
),
665 value_bitsize (toval
));
667 put_frame_register_bytes (frame
, value_reg
,
668 value_offset (toval
),
669 changed_len
, buffer
);
673 put_frame_register_bytes (frame
, value_reg
,
674 value_offset (toval
),
676 value_contents (fromval
));
680 if (deprecated_register_changed_hook
)
681 deprecated_register_changed_hook (-1);
682 observer_notify_target_changed (¤t_target
);
687 error (_("Left operand of assignment is not an lvalue."));
690 /* Assigning to the stack pointer, frame pointer, and other
691 (architecture and calling convention specific) registers may
692 cause the frame cache to be out of date. Assigning to memory
693 also can. We just do this on all assignments to registers or
694 memory, for simplicity's sake; I doubt the slowdown matters. */
695 switch (VALUE_LVAL (toval
))
700 reinit_frame_cache ();
702 /* Having destroyed the frame cache, restore the selected
705 /* FIXME: cagney/2002-11-02: There has to be a better way of
706 doing this. Instead of constantly saving/restoring the
707 frame. Why not create a get_selected_frame() function that,
708 having saved the selected frame's ID can automatically
709 re-find the previously selected frame automatically. */
712 struct frame_info
*fi
= frame_find_by_id (old_frame
);
722 /* If the field does not entirely fill a LONGEST, then zero the sign
723 bits. If the field is signed, and is negative, then sign
725 if ((value_bitsize (toval
) > 0)
726 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
728 LONGEST fieldval
= value_as_long (fromval
);
729 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
732 if (!TYPE_UNSIGNED (type
)
733 && (fieldval
& (valmask
^ (valmask
>> 1))))
734 fieldval
|= ~valmask
;
736 fromval
= value_from_longest (type
, fieldval
);
739 val
= value_copy (toval
);
740 memcpy (value_contents_raw (val
), value_contents (fromval
),
742 deprecated_set_value_type (val
, type
);
743 val
= value_change_enclosing_type (val
,
744 value_enclosing_type (fromval
));
745 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
746 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
751 /* Extend a value VAL to COUNT repetitions of its type. */
754 value_repeat (struct value
*arg1
, int count
)
758 if (VALUE_LVAL (arg1
) != lval_memory
)
759 error (_("Only values in memory can be extended with '@'."));
761 error (_("Invalid number %d of repetitions."), count
);
763 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
765 read_memory (VALUE_ADDRESS (arg1
) + value_offset (arg1
),
766 value_contents_all_raw (val
),
767 TYPE_LENGTH (value_enclosing_type (val
)));
768 VALUE_LVAL (val
) = lval_memory
;
769 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + value_offset (arg1
);
775 value_of_variable (struct symbol
*var
, struct block
*b
)
778 struct frame_info
*frame
= NULL
;
781 frame
= NULL
; /* Use selected frame. */
782 else if (symbol_read_needs_frame (var
))
784 frame
= block_innermost_frame (b
);
787 if (BLOCK_FUNCTION (b
)
788 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
789 error (_("No frame is currently executing in block %s."),
790 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
792 error (_("No frame is currently executing in specified block"));
796 val
= read_var_value (var
, frame
);
798 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
803 /* Given a value which is an array, return a value which is a pointer
804 to its first element, regardless of whether or not the array has a
807 FIXME: A previous comment here indicated that this routine should
808 be substracting the array's lower bound. It's not clear to me that
809 this is correct. Given an array subscripting operation, it would
810 certainly work to do the adjustment here, essentially computing:
812 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
814 However I believe a more appropriate and logical place to account
815 for the lower bound is to do so in value_subscript, essentially
818 (&array[0] + ((index - lowerbound) * sizeof array[0]))
820 As further evidence consider what would happen with operations
821 other than array subscripting, where the caller would get back a
822 value that had an address somewhere before the actual first element
823 of the array, and the information about the lower bound would be
824 lost because of the coercion to pointer type.
828 value_coerce_array (struct value
*arg1
)
830 struct type
*type
= check_typedef (value_type (arg1
));
832 if (VALUE_LVAL (arg1
) != lval_memory
)
833 error (_("Attempt to take address of value not located in memory."));
835 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
836 (VALUE_ADDRESS (arg1
) + value_offset (arg1
)));
839 /* Given a value which is a function, return a value which is a pointer
843 value_coerce_function (struct value
*arg1
)
845 struct value
*retval
;
847 if (VALUE_LVAL (arg1
) != lval_memory
)
848 error (_("Attempt to take address of value not located in memory."));
850 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
851 (VALUE_ADDRESS (arg1
) + value_offset (arg1
)));
855 /* Return a pointer value for the object for which ARG1 is the
859 value_addr (struct value
*arg1
)
863 struct type
*type
= check_typedef (value_type (arg1
));
864 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
866 /* Copy the value, but change the type from (T&) to (T*). We
867 keep the same location information, which is efficient, and
868 allows &(&X) to get the location containing the reference. */
869 arg2
= value_copy (arg1
);
870 deprecated_set_value_type (arg2
,
871 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
874 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
875 return value_coerce_function (arg1
);
877 if (VALUE_LVAL (arg1
) != lval_memory
)
878 error (_("Attempt to take address of value not located in memory."));
880 /* Get target memory address */
881 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
882 (VALUE_ADDRESS (arg1
)
883 + value_offset (arg1
)
884 + value_embedded_offset (arg1
)));
886 /* This may be a pointer to a base subobject; so remember the
887 full derived object's type ... */
888 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (value_enclosing_type (arg1
)));
889 /* ... and also the relative position of the subobject in the full
891 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
895 /* Return a reference value for the object for which ARG1 is the
899 value_ref (struct value
*arg1
)
903 struct type
*type
= check_typedef (value_type (arg1
));
904 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
907 arg2
= value_addr (arg1
);
908 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
912 /* Given a value of a pointer type, apply the C unary * operator to
916 value_ind (struct value
*arg1
)
918 struct type
*base_type
;
921 arg1
= coerce_array (arg1
);
923 base_type
= check_typedef (value_type (arg1
));
925 /* Allow * on an integer so we can cast it to whatever we want.
926 This returns an int, which seems like the most C-like thing to
927 do. "long long" variables are rare enough that
928 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
929 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
930 return value_at_lazy (builtin_type_int
,
931 (CORE_ADDR
) value_as_address (arg1
));
932 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
934 struct type
*enc_type
;
935 /* We may be pointing to something embedded in a larger object.
936 Get the real type of the enclosing object. */
937 enc_type
= check_typedef (value_enclosing_type (arg1
));
938 enc_type
= TYPE_TARGET_TYPE (enc_type
);
940 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
941 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
942 /* For functions, go through find_function_addr, which knows
943 how to handle function descriptors. */
944 arg2
= value_at_lazy (enc_type
,
945 find_function_addr (arg1
, NULL
));
947 /* Retrieve the enclosing object pointed to */
948 arg2
= value_at_lazy (enc_type
,
949 (value_as_address (arg1
)
950 - value_pointed_to_offset (arg1
)));
952 /* Re-adjust type. */
953 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
954 /* Add embedding info. */
955 arg2
= value_change_enclosing_type (arg2
, enc_type
);
956 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
958 /* We may be pointing to an object of some derived type. */
959 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
963 error (_("Attempt to take contents of a non-pointer value."));
964 return 0; /* For lint -- never reached. */
967 /* Create a value for an array by allocating space in the inferior,
968 copying the data into that space, and then setting up an array
971 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
972 is populated from the values passed in ELEMVEC.
974 The element type of the array is inherited from the type of the
975 first element, and all elements must have the same size (though we
976 don't currently enforce any restriction on their types). */
979 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
983 unsigned int typelength
;
985 struct type
*rangetype
;
986 struct type
*arraytype
;
989 /* Validate that the bounds are reasonable and that each of the
990 elements have the same size. */
992 nelem
= highbound
- lowbound
+ 1;
995 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
997 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
998 for (idx
= 1; idx
< nelem
; idx
++)
1000 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1002 error (_("array elements must all be the same size"));
1006 rangetype
= create_range_type ((struct type
*) NULL
,
1008 lowbound
, highbound
);
1009 arraytype
= create_array_type ((struct type
*) NULL
,
1010 value_enclosing_type (elemvec
[0]),
1013 if (!current_language
->c_style_arrays
)
1015 val
= allocate_value (arraytype
);
1016 for (idx
= 0; idx
< nelem
; idx
++)
1018 memcpy (value_contents_all_raw (val
) + (idx
* typelength
),
1019 value_contents_all (elemvec
[idx
]),
1025 /* Allocate space to store the array in the inferior, and then
1026 initialize it by copying in each element. FIXME: Is it worth it
1027 to create a local buffer in which to collect each value and then
1028 write all the bytes in one operation? */
1030 addr
= allocate_space_in_inferior (nelem
* typelength
);
1031 for (idx
= 0; idx
< nelem
; idx
++)
1033 write_memory (addr
+ (idx
* typelength
),
1034 value_contents_all (elemvec
[idx
]),
1038 /* Create the array type and set up an array value to be evaluated
1041 val
= value_at_lazy (arraytype
, addr
);
1045 /* Create a value for a string constant by allocating space in the
1046 inferior, copying the data into that space, and returning the
1047 address with type TYPE_CODE_STRING. PTR points to the string
1048 constant data; LEN is number of characters.
1050 Note that string types are like array of char types with a lower
1051 bound of zero and an upper bound of LEN - 1. Also note that the
1052 string may contain embedded null bytes. */
1055 value_string (char *ptr
, int len
)
1058 int lowbound
= current_language
->string_lower_bound
;
1059 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1062 len
+ lowbound
- 1);
1063 struct type
*stringtype
1064 = create_string_type ((struct type
*) NULL
, rangetype
);
1067 if (current_language
->c_style_arrays
== 0)
1069 val
= allocate_value (stringtype
);
1070 memcpy (value_contents_raw (val
), ptr
, len
);
1075 /* Allocate space to store the string in the inferior, and then copy
1076 LEN bytes from PTR in gdb to that address in the inferior. */
1078 addr
= allocate_space_in_inferior (len
);
1079 write_memory (addr
, (gdb_byte
*) ptr
, len
);
1081 val
= value_at_lazy (stringtype
, addr
);
1086 value_bitstring (char *ptr
, int len
)
1089 struct type
*domain_type
= create_range_type (NULL
,
1092 struct type
*type
= create_set_type ((struct type
*) NULL
,
1094 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1095 val
= allocate_value (type
);
1096 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1100 /* See if we can pass arguments in T2 to a function which takes
1101 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1102 a NULL-terminated vector. If some arguments need coercion of some
1103 sort, then the coerced values are written into T2. Return value is
1104 0 if the arguments could be matched, or the position at which they
1107 STATICP is nonzero if the T1 argument list came from a static
1108 member function. T2 will still include the ``this'' pointer, but
1111 For non-static member functions, we ignore the first argument,
1112 which is the type of the instance variable. This is because we
1113 want to handle calls with objects from derived classes. This is
1114 not entirely correct: we should actually check to make sure that a
1115 requested operation is type secure, shouldn't we? FIXME. */
1118 typecmp (int staticp
, int varargs
, int nargs
,
1119 struct field t1
[], struct value
*t2
[])
1124 internal_error (__FILE__
, __LINE__
,
1125 _("typecmp: no argument list"));
1127 /* Skip ``this'' argument if applicable. T2 will always include
1133 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1136 struct type
*tt1
, *tt2
;
1141 tt1
= check_typedef (t1
[i
].type
);
1142 tt2
= check_typedef (value_type (t2
[i
]));
1144 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1145 /* We should be doing hairy argument matching, as below. */
1146 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1148 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1149 t2
[i
] = value_coerce_array (t2
[i
]);
1151 t2
[i
] = value_ref (t2
[i
]);
1155 /* djb - 20000715 - Until the new type structure is in the
1156 place, and we can attempt things like implicit conversions,
1157 we need to do this so you can take something like a map<const
1158 char *>, and properly access map["hello"], because the
1159 argument to [] will be a reference to a pointer to a char,
1160 and the argument will be a pointer to a char. */
1161 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1162 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1164 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1166 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1167 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1168 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1170 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1172 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1174 /* Array to pointer is a `trivial conversion' according to the
1177 /* We should be doing much hairier argument matching (see
1178 section 13.2 of the ARM), but as a quick kludge, just check
1179 for the same type code. */
1180 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1183 if (varargs
|| t2
[i
] == NULL
)
1188 /* Helper function used by value_struct_elt to recurse through
1189 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1190 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1191 TYPE. If found, return value, else return NULL.
1193 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1194 fields, look for a baseclass named NAME. */
1196 static struct value
*
1197 search_struct_field (char *name
, struct value
*arg1
, int offset
,
1198 struct type
*type
, int looking_for_baseclass
)
1201 int nbases
= TYPE_N_BASECLASSES (type
);
1203 CHECK_TYPEDEF (type
);
1205 if (!looking_for_baseclass
)
1206 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1208 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1210 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1213 if (TYPE_FIELD_STATIC (type
, i
))
1215 v
= value_static_field (type
, i
);
1217 error (_("field %s is nonexistent or has been optimised out"),
1222 v
= value_primitive_field (arg1
, offset
, i
, type
);
1224 error (_("there is no field named %s"), name
);
1230 && (t_field_name
[0] == '\0'
1231 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1232 && (strcmp_iw (t_field_name
, "else") == 0))))
1234 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1235 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1236 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1238 /* Look for a match through the fields of an anonymous
1239 union, or anonymous struct. C++ provides anonymous
1242 In the GNU Chill (now deleted from GDB)
1243 implementation of variant record types, each
1244 <alternative field> has an (anonymous) union type,
1245 each member of the union represents a <variant
1246 alternative>. Each <variant alternative> is
1247 represented as a struct, with a member for each
1251 int new_offset
= offset
;
1253 /* This is pretty gross. In G++, the offset in an
1254 anonymous union is relative to the beginning of the
1255 enclosing struct. In the GNU Chill (now deleted
1256 from GDB) implementation of variant records, the
1257 bitpos is zero in an anonymous union field, so we
1258 have to add the offset of the union here. */
1259 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1260 || (TYPE_NFIELDS (field_type
) > 0
1261 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1262 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1264 v
= search_struct_field (name
, arg1
, new_offset
,
1266 looking_for_baseclass
);
1273 for (i
= 0; i
< nbases
; i
++)
1276 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1277 /* If we are looking for baseclasses, this is what we get when
1278 we hit them. But it could happen that the base part's member
1279 name is not yet filled in. */
1280 int found_baseclass
= (looking_for_baseclass
1281 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1282 && (strcmp_iw (name
,
1283 TYPE_BASECLASS_NAME (type
,
1286 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1289 struct value
*v2
= allocate_value (basetype
);
1291 boffset
= baseclass_offset (type
, i
,
1292 value_contents (arg1
) + offset
,
1293 VALUE_ADDRESS (arg1
)
1294 + value_offset (arg1
) + offset
);
1296 error (_("virtual baseclass botch"));
1298 /* The virtual base class pointer might have been clobbered
1299 by the user program. Make sure that it still points to a
1300 valid memory location. */
1303 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
1305 CORE_ADDR base_addr
;
1308 VALUE_ADDRESS (arg1
) + value_offset (arg1
) + boffset
;
1309 if (target_read_memory (base_addr
,
1310 value_contents_raw (v2
),
1311 TYPE_LENGTH (basetype
)) != 0)
1312 error (_("virtual baseclass botch"));
1313 VALUE_LVAL (v2
) = lval_memory
;
1314 VALUE_ADDRESS (v2
) = base_addr
;
1318 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
1319 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
1320 VALUE_FRAME_ID (v2
) = VALUE_FRAME_ID (arg1
);
1321 set_value_offset (v2
, value_offset (arg1
) + boffset
);
1322 if (value_lazy (arg1
))
1323 set_value_lazy (v2
, 1);
1325 memcpy (value_contents_raw (v2
),
1326 value_contents_raw (arg1
) + boffset
,
1327 TYPE_LENGTH (basetype
));
1330 if (found_baseclass
)
1332 v
= search_struct_field (name
, v2
, 0,
1333 TYPE_BASECLASS (type
, i
),
1334 looking_for_baseclass
);
1336 else if (found_baseclass
)
1337 v
= value_primitive_field (arg1
, offset
, i
, type
);
1339 v
= search_struct_field (name
, arg1
,
1340 offset
+ TYPE_BASECLASS_BITPOS (type
,
1342 basetype
, looking_for_baseclass
);
1350 /* Return the offset (in bytes) of the virtual base of type BASETYPE
1351 * in an object pointed to by VALADDR (on the host), assumed to be of
1352 * type TYPE. OFFSET is number of bytes beyond start of ARG to start
1353 * looking (in case VALADDR is the contents of an enclosing object).
1355 * This routine recurses on the primary base of the derived class
1356 * because the virtual base entries of the primary base appear before
1357 * the other virtual base entries.
1359 * If the virtual base is not found, a negative integer is returned.
1360 * The magnitude of the negative integer is the number of entries in
1361 * the virtual table to skip over (entries corresponding to various
1362 * ancestral classes in the chain of primary bases).
1364 * Important: This assumes the HP / Taligent C++ runtime conventions.
1365 * Use baseclass_offset() instead to deal with g++ conventions. */
1368 find_rt_vbase_offset (struct type
*type
, struct type
*basetype
,
1369 const gdb_byte
*valaddr
, int offset
,
1370 int *boffset_p
, int *skip_p
)
1372 int boffset
; /* Offset of virtual base. */
1373 int index
; /* Displacement to use in virtual
1378 CORE_ADDR vtbl
; /* The virtual table pointer. */
1379 struct type
*pbc
; /* The primary base class. */
1381 /* Look for the virtual base recursively in the primary base, first.
1382 * This is because the derived class object and its primary base
1383 * subobject share the primary virtual table. */
1386 pbc
= TYPE_PRIMARY_BASE (type
);
1389 find_rt_vbase_offset (pbc
, basetype
, valaddr
,
1390 offset
, &boffset
, &skip
);
1393 *boffset_p
= boffset
;
1402 /* Find the index of the virtual base according to HP/Taligent
1403 runtime spec. (Depth-first, left-to-right.) */
1404 index
= virtual_base_index_skip_primaries (basetype
, type
);
1408 *skip_p
= skip
+ virtual_base_list_length_skip_primaries (type
);
1413 /* pai: FIXME -- 32x64 possible problem. */
1414 /* First word (4 bytes) in object layout is the vtable pointer. */
1415 vtbl
= *(CORE_ADDR
*) (valaddr
+ offset
);
1417 /* Before the constructor is invoked, things are usually zero'd
1420 error (_("Couldn't find virtual table -- object may not be constructed yet."));
1423 /* Find virtual base's offset -- jump over entries for primary base
1424 * ancestors, then use the index computed above. But also adjust by
1425 * HP_ACC_VBASE_START for the vtable slots before the start of the
1426 * virtual base entries. Offset is negative -- virtual base entries
1427 * appear _before_ the address point of the virtual table. */
1429 /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
1432 /* epstein : FIXME -- added param for overlay section. May not be
1434 vp
= value_at (builtin_type_int
,
1435 vtbl
+ 4 * (-skip
- index
- HP_ACC_VBASE_START
));
1436 boffset
= value_as_long (vp
);
1438 *boffset_p
= boffset
;
1443 /* Helper function used by value_struct_elt to recurse through
1444 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1445 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1448 If found, return value, else if name matched and args not return
1449 (value) -1, else return NULL. */
1451 static struct value
*
1452 search_struct_method (char *name
, struct value
**arg1p
,
1453 struct value
**args
, int offset
,
1454 int *static_memfuncp
, struct type
*type
)
1458 int name_matched
= 0;
1459 char dem_opname
[64];
1461 CHECK_TYPEDEF (type
);
1462 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1464 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1465 /* FIXME! May need to check for ARM demangling here */
1466 if (strncmp (t_field_name
, "__", 2) == 0 ||
1467 strncmp (t_field_name
, "op", 2) == 0 ||
1468 strncmp (t_field_name
, "type", 4) == 0)
1470 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1471 t_field_name
= dem_opname
;
1472 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1473 t_field_name
= dem_opname
;
1475 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1477 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1478 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1481 check_stub_method_group (type
, i
);
1482 if (j
> 0 && args
== 0)
1483 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name
);
1484 else if (j
== 0 && args
== 0)
1486 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1493 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1494 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
1495 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
1496 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1498 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1499 return value_virtual_fn_field (arg1p
, f
, j
,
1501 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
1503 *static_memfuncp
= 1;
1504 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1513 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1517 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1519 if (TYPE_HAS_VTABLE (type
))
1521 /* HP aCC compiled type, search for virtual base offset
1522 according to HP/Taligent runtime spec. */
1524 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
1525 value_contents_all (*arg1p
),
1526 offset
+ value_embedded_offset (*arg1p
),
1527 &base_offset
, &skip
);
1529 error (_("Virtual base class offset not found in vtable"));
1533 struct type
*baseclass
=
1534 check_typedef (TYPE_BASECLASS (type
, i
));
1535 const gdb_byte
*base_valaddr
;
1537 /* The virtual base class pointer might have been
1538 clobbered by the user program. Make sure that it
1539 still points to a valid memory location. */
1541 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
1543 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
1544 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
1545 + value_offset (*arg1p
) + offset
,
1546 tmp
, TYPE_LENGTH (baseclass
)) != 0)
1547 error (_("virtual baseclass botch"));
1551 base_valaddr
= value_contents (*arg1p
) + offset
;
1554 baseclass_offset (type
, i
, base_valaddr
,
1555 VALUE_ADDRESS (*arg1p
)
1556 + value_offset (*arg1p
) + offset
);
1557 if (base_offset
== -1)
1558 error (_("virtual baseclass botch"));
1563 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1565 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1566 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1567 if (v
== (struct value
*) - 1)
1573 /* FIXME-bothner: Why is this commented out? Why is it here? */
1574 /* *arg1p = arg1_tmp; */
1579 return (struct value
*) - 1;
1584 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1585 extract the component named NAME from the ultimate target
1586 structure/union and return it as a value with its appropriate type.
1587 ERR is used in the error message if *ARGP's type is wrong.
1589 C++: ARGS is a list of argument types to aid in the selection of
1590 an appropriate method. Also, handle derived types.
1592 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1593 where the truthvalue of whether the function that was resolved was
1594 a static member function or not is stored.
1596 ERR is an error message to be printed in case the field is not
1600 value_struct_elt (struct value
**argp
, struct value
**args
,
1601 char *name
, int *static_memfuncp
, char *err
)
1606 *argp
= coerce_array (*argp
);
1608 t
= check_typedef (value_type (*argp
));
1610 /* Follow pointers until we get to a non-pointer. */
1612 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1614 *argp
= value_ind (*argp
);
1615 /* Don't coerce fn pointer to fn and then back again! */
1616 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
1617 *argp
= coerce_array (*argp
);
1618 t
= check_typedef (value_type (*argp
));
1621 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1622 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1623 error (_("Attempt to extract a component of a value that is not a %s."), err
);
1625 /* Assume it's not, unless we see that it is. */
1626 if (static_memfuncp
)
1627 *static_memfuncp
= 0;
1631 /* if there are no arguments ...do this... */
1633 /* Try as a field first, because if we succeed, there is less
1635 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1639 /* C++: If it was not found as a data field, then try to
1640 return it as a pointer to a method. */
1642 if (destructor_name_p (name
, t
))
1643 error (_("Cannot get value of destructor"));
1645 v
= search_struct_method (name
, argp
, args
, 0,
1646 static_memfuncp
, t
);
1648 if (v
== (struct value
*) - 1)
1649 error (_("Cannot take address of method %s."), name
);
1652 if (TYPE_NFN_FIELDS (t
))
1653 error (_("There is no member or method named %s."), name
);
1655 error (_("There is no member named %s."), name
);
1660 if (destructor_name_p (name
, t
))
1664 /* Destructors are a special case. */
1665 int m_index
, f_index
;
1668 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
1670 v
= value_fn_field (NULL
,
1671 TYPE_FN_FIELDLIST1 (t
, m_index
),
1675 error (_("could not find destructor function named %s."),
1682 error (_("destructor should not have any argument"));
1686 v
= search_struct_method (name
, argp
, args
, 0,
1687 static_memfuncp
, t
);
1689 if (v
== (struct value
*) - 1)
1691 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name
);
1695 /* See if user tried to invoke data as function. If so, hand it
1696 back. If it's not callable (i.e., a pointer to function),
1697 gdb should give an error. */
1698 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1702 error (_("Structure has no component named %s."), name
);
1706 /* Search through the methods of an object (and its bases) to find a
1707 specified method. Return the pointer to the fn_field list of
1708 overloaded instances.
1710 Helper function for value_find_oload_list.
1711 ARGP is a pointer to a pointer to a value (the object).
1712 METHOD is a string containing the method name.
1713 OFFSET is the offset within the value.
1714 TYPE is the assumed type of the object.
1715 NUM_FNS is the number of overloaded instances.
1716 BASETYPE is set to the actual type of the subobject where the
1718 BOFFSET is the offset of the base subobject where the method is found.
1721 static struct fn_field
*
1722 find_method_list (struct value
**argp
, char *method
,
1723 int offset
, struct type
*type
, int *num_fns
,
1724 struct type
**basetype
, int *boffset
)
1728 CHECK_TYPEDEF (type
);
1732 /* First check in object itself. */
1733 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1735 /* pai: FIXME What about operators and type conversions? */
1736 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1737 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
1739 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1740 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1746 /* Resolve any stub methods. */
1747 check_stub_method_group (type
, i
);
1753 /* Not found in object, check in base subobjects. */
1754 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1757 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1759 if (TYPE_HAS_VTABLE (type
))
1761 /* HP aCC compiled type, search for virtual base offset
1762 * according to HP/Taligent runtime spec. */
1764 find_rt_vbase_offset (type
, TYPE_BASECLASS (type
, i
),
1765 value_contents_all (*argp
),
1766 offset
+ value_embedded_offset (*argp
),
1767 &base_offset
, &skip
);
1769 error (_("Virtual base class offset not found in vtable"));
1773 /* probably g++ runtime model */
1774 base_offset
= value_offset (*argp
) + offset
;
1776 baseclass_offset (type
, i
,
1777 value_contents (*argp
) + base_offset
,
1778 VALUE_ADDRESS (*argp
) + base_offset
);
1779 if (base_offset
== -1)
1780 error (_("virtual baseclass botch"));
1783 else /* Non-virtual base, simply use bit position from debug
1786 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1788 f
= find_method_list (argp
, method
, base_offset
+ offset
,
1789 TYPE_BASECLASS (type
, i
), num_fns
,
1797 /* Return the list of overloaded methods of a specified name.
1799 ARGP is a pointer to a pointer to a value (the object).
1800 METHOD is the method name.
1801 OFFSET is the offset within the value contents.
1802 NUM_FNS is the number of overloaded instances.
1803 BASETYPE is set to the type of the base subobject that defines the
1805 BOFFSET is the offset of the base subobject which defines the method.
1809 value_find_oload_method_list (struct value
**argp
, char *method
,
1810 int offset
, int *num_fns
,
1811 struct type
**basetype
, int *boffset
)
1815 t
= check_typedef (value_type (*argp
));
1817 /* Code snarfed from value_struct_elt. */
1818 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1820 *argp
= value_ind (*argp
);
1821 /* Don't coerce fn pointer to fn and then back again! */
1822 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
1823 *argp
= coerce_array (*argp
);
1824 t
= check_typedef (value_type (*argp
));
1827 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1828 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1829 error (_("Attempt to extract a component of a value that is not a struct or union"));
1831 return find_method_list (argp
, method
, 0, t
, num_fns
,
1835 /* Given an array of argument types (ARGTYPES) (which includes an
1836 entry for "this" in the case of C++ methods), the number of
1837 arguments NARGS, the NAME of a function whether it's a method or
1838 not (METHOD), and the degree of laxness (LAX) in conforming to
1839 overload resolution rules in ANSI C++, find the best function that
1840 matches on the argument types according to the overload resolution
1843 In the case of class methods, the parameter OBJ is an object value
1844 in which to search for overloaded methods.
1846 In the case of non-method functions, the parameter FSYM is a symbol
1847 corresponding to one of the overloaded functions.
1849 Return value is an integer: 0 -> good match, 10 -> debugger applied
1850 non-standard coercions, 100 -> incompatible.
1852 If a method is being searched for, VALP will hold the value.
1853 If a non-method is being searched for, SYMP will hold the symbol
1856 If a method is being searched for, and it is a static method,
1857 then STATICP will point to a non-zero value.
1859 Note: This function does *not* check the value of
1860 overload_resolution. Caller must check it to see whether overload
1861 resolution is permitted.
1865 find_overload_match (struct type
**arg_types
, int nargs
,
1866 char *name
, int method
, int lax
,
1867 struct value
**objp
, struct symbol
*fsym
,
1868 struct value
**valp
, struct symbol
**symp
,
1871 struct value
*obj
= (objp
? *objp
: NULL
);
1872 /* Index of best overloaded function. */
1874 /* The measure for the current best match. */
1875 struct badness_vector
*oload_champ_bv
= NULL
;
1876 struct value
*temp
= obj
;
1877 /* For methods, the list of overloaded methods. */
1878 struct fn_field
*fns_ptr
= NULL
;
1879 /* For non-methods, the list of overloaded function symbols. */
1880 struct symbol
**oload_syms
= NULL
;
1881 /* Number of overloaded instances being considered. */
1883 struct type
*basetype
= NULL
;
1887 struct cleanup
*old_cleanups
= NULL
;
1889 const char *obj_type_name
= NULL
;
1890 char *func_name
= NULL
;
1891 enum oload_classification match_quality
;
1893 /* Get the list of overloaded methods or functions. */
1897 obj_type_name
= TYPE_NAME (value_type (obj
));
1898 /* Hack: evaluate_subexp_standard often passes in a pointer
1899 value rather than the object itself, so try again. */
1900 if ((!obj_type_name
|| !*obj_type_name
)
1901 && (TYPE_CODE (value_type (obj
)) == TYPE_CODE_PTR
))
1902 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj
)));
1904 fns_ptr
= value_find_oload_method_list (&temp
, name
,
1906 &basetype
, &boffset
);
1907 if (!fns_ptr
|| !num_fns
)
1908 error (_("Couldn't find method %s%s%s"),
1910 (obj_type_name
&& *obj_type_name
) ? "::" : "",
1912 /* If we are dealing with stub method types, they should have
1913 been resolved by find_method_list via
1914 value_find_oload_method_list above. */
1915 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
1916 oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
1918 oload_syms
, &oload_champ_bv
);
1922 const char *qualified_name
= SYMBOL_CPLUS_DEMANGLED_NAME (fsym
);
1924 /* If we have a C++ name, try to extract just the function
1927 func_name
= cp_func_name (qualified_name
);
1929 /* If there was no C++ name, this must be a C-style function.
1930 Just return the same symbol. Do the same if cp_func_name
1931 fails for some reason. */
1932 if (func_name
== NULL
)
1938 old_cleanups
= make_cleanup (xfree
, func_name
);
1939 make_cleanup (xfree
, oload_syms
);
1940 make_cleanup (xfree
, oload_champ_bv
);
1942 oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
1949 /* Check how bad the best match is. */
1952 classify_oload_match (oload_champ_bv
, nargs
,
1953 oload_method_static (method
, fns_ptr
,
1956 if (match_quality
== INCOMPATIBLE
)
1959 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
1961 (obj_type_name
&& *obj_type_name
) ? "::" : "",
1964 error (_("Cannot resolve function %s to any overloaded instance"),
1967 else if (match_quality
== NON_STANDARD
)
1970 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
1972 (obj_type_name
&& *obj_type_name
) ? "::" : "",
1975 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
1981 if (staticp
!= NULL
)
1982 *staticp
= oload_method_static (method
, fns_ptr
, oload_champ
);
1983 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
1984 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
,
1987 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
,
1992 *symp
= oload_syms
[oload_champ
];
1997 if (TYPE_CODE (value_type (temp
)) != TYPE_CODE_PTR
1998 && TYPE_CODE (value_type (*objp
)) == TYPE_CODE_PTR
)
2000 temp
= value_addr (temp
);
2004 if (old_cleanups
!= NULL
)
2005 do_cleanups (old_cleanups
);
2007 switch (match_quality
)
2013 default: /* STANDARD */
2018 /* Find the best overload match, searching for FUNC_NAME in namespaces
2019 contained in QUALIFIED_NAME until it either finds a good match or
2020 runs out of namespaces. It stores the overloaded functions in
2021 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2022 calling function is responsible for freeing *OLOAD_SYMS and
2026 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2027 const char *func_name
,
2028 const char *qualified_name
,
2029 struct symbol
***oload_syms
,
2030 struct badness_vector
**oload_champ_bv
)
2034 find_oload_champ_namespace_loop (arg_types
, nargs
,
2037 oload_syms
, oload_champ_bv
,
2043 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2044 how deep we've looked for namespaces, and the champ is stored in
2045 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2048 It is the caller's responsibility to free *OLOAD_SYMS and
2052 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2053 const char *func_name
,
2054 const char *qualified_name
,
2056 struct symbol
***oload_syms
,
2057 struct badness_vector
**oload_champ_bv
,
2060 int next_namespace_len
= namespace_len
;
2061 int searched_deeper
= 0;
2063 struct cleanup
*old_cleanups
;
2064 int new_oload_champ
;
2065 struct symbol
**new_oload_syms
;
2066 struct badness_vector
*new_oload_champ_bv
;
2067 char *new_namespace
;
2069 if (next_namespace_len
!= 0)
2071 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2072 next_namespace_len
+= 2;
2074 next_namespace_len
+=
2075 cp_find_first_component (qualified_name
+ next_namespace_len
);
2077 /* Initialize these to values that can safely be xfree'd. */
2079 *oload_champ_bv
= NULL
;
2081 /* First, see if we have a deeper namespace we can search in.
2082 If we get a good match there, use it. */
2084 if (qualified_name
[next_namespace_len
] == ':')
2086 searched_deeper
= 1;
2088 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2089 func_name
, qualified_name
,
2091 oload_syms
, oload_champ_bv
,
2098 /* If we reach here, either we're in the deepest namespace or we
2099 didn't find a good match in a deeper namespace. But, in the
2100 latter case, we still have a bad match in a deeper namespace;
2101 note that we might not find any match at all in the current
2102 namespace. (There's always a match in the deepest namespace,
2103 because this overload mechanism only gets called if there's a
2104 function symbol to start off with.) */
2106 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2107 old_cleanups
= make_cleanup (xfree
, *oload_champ_bv
);
2108 new_namespace
= alloca (namespace_len
+ 1);
2109 strncpy (new_namespace
, qualified_name
, namespace_len
);
2110 new_namespace
[namespace_len
] = '\0';
2111 new_oload_syms
= make_symbol_overload_list (func_name
,
2113 while (new_oload_syms
[num_fns
])
2116 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2117 NULL
, new_oload_syms
,
2118 &new_oload_champ_bv
);
2120 /* Case 1: We found a good match. Free earlier matches (if any),
2121 and return it. Case 2: We didn't find a good match, but we're
2122 not the deepest function. Then go with the bad match that the
2123 deeper function found. Case 3: We found a bad match, and we're
2124 the deepest function. Then return what we found, even though
2125 it's a bad match. */
2127 if (new_oload_champ
!= -1
2128 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2130 *oload_syms
= new_oload_syms
;
2131 *oload_champ
= new_oload_champ
;
2132 *oload_champ_bv
= new_oload_champ_bv
;
2133 do_cleanups (old_cleanups
);
2136 else if (searched_deeper
)
2138 xfree (new_oload_syms
);
2139 xfree (new_oload_champ_bv
);
2140 discard_cleanups (old_cleanups
);
2145 gdb_assert (new_oload_champ
!= -1);
2146 *oload_syms
= new_oload_syms
;
2147 *oload_champ
= new_oload_champ
;
2148 *oload_champ_bv
= new_oload_champ_bv
;
2149 discard_cleanups (old_cleanups
);
2154 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2155 the best match from among the overloaded methods or functions
2156 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2157 The number of methods/functions in the list is given by NUM_FNS.
2158 Return the index of the best match; store an indication of the
2159 quality of the match in OLOAD_CHAMP_BV.
2161 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2164 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2165 int num_fns
, struct fn_field
*fns_ptr
,
2166 struct symbol
**oload_syms
,
2167 struct badness_vector
**oload_champ_bv
)
2170 /* A measure of how good an overloaded instance is. */
2171 struct badness_vector
*bv
;
2172 /* Index of best overloaded function. */
2173 int oload_champ
= -1;
2174 /* Current ambiguity state for overload resolution. */
2175 int oload_ambiguous
= 0;
2176 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2178 *oload_champ_bv
= NULL
;
2180 /* Consider each candidate in turn. */
2181 for (ix
= 0; ix
< num_fns
; ix
++)
2184 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2186 struct type
**parm_types
;
2190 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2194 /* If it's not a method, this is the proper place. */
2195 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2198 /* Prepare array of parameter types. */
2199 parm_types
= (struct type
**)
2200 xmalloc (nparms
* (sizeof (struct type
*)));
2201 for (jj
= 0; jj
< nparms
; jj
++)
2202 parm_types
[jj
] = (method
2203 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2204 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2207 /* Compare parameter types to supplied argument types. Skip
2208 THIS for static methods. */
2209 bv
= rank_function (parm_types
, nparms
,
2210 arg_types
+ static_offset
,
2211 nargs
- static_offset
);
2213 if (!*oload_champ_bv
)
2215 *oload_champ_bv
= bv
;
2218 else /* See whether current candidate is better or worse than
2220 switch (compare_badness (bv
, *oload_champ_bv
))
2222 case 0: /* Top two contenders are equally good. */
2223 oload_ambiguous
= 1;
2225 case 1: /* Incomparable top contenders. */
2226 oload_ambiguous
= 2;
2228 case 2: /* New champion, record details. */
2229 *oload_champ_bv
= bv
;
2230 oload_ambiguous
= 0;
2241 fprintf_filtered (gdb_stderr
,
2242 "Overloaded method instance %s, # of parms %d\n",
2243 fns_ptr
[ix
].physname
, nparms
);
2245 fprintf_filtered (gdb_stderr
,
2246 "Overloaded function instance %s # of parms %d\n",
2247 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
2249 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2250 fprintf_filtered (gdb_stderr
,
2251 "...Badness @ %d : %d\n",
2253 fprintf_filtered (gdb_stderr
,
2254 "Overload resolution champion is %d, ambiguous? %d\n",
2255 oload_champ
, oload_ambiguous
);
2262 /* Return 1 if we're looking at a static method, 0 if we're looking at
2263 a non-static method or a function that isn't a method. */
2266 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
2268 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
2274 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2276 static enum oload_classification
2277 classify_oload_match (struct badness_vector
*oload_champ_bv
,
2283 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2285 if (oload_champ_bv
->rank
[ix
] >= 100)
2286 return INCOMPATIBLE
; /* Truly mismatched types. */
2287 else if (oload_champ_bv
->rank
[ix
] >= 10)
2288 return NON_STANDARD
; /* Non-standard type conversions
2292 return STANDARD
; /* Only standard conversions needed. */
2295 /* C++: return 1 is NAME is a legitimate name for the destructor of
2296 type TYPE. If TYPE does not have a destructor, or if NAME is
2297 inappropriate for TYPE, an error is signaled. */
2299 destructor_name_p (const char *name
, const struct type
*type
)
2301 /* Destructors are a special case. */
2305 char *dname
= type_name_no_tag (type
);
2306 char *cp
= strchr (dname
, '<');
2309 /* Do not compare the template part for template classes. */
2311 len
= strlen (dname
);
2314 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
2315 error (_("name of destructor must equal name of class"));
2322 /* Helper function for check_field: Given TYPE, a structure/union,
2323 return 1 if the component named NAME from the ultimate target
2324 structure/union is defined, otherwise, return 0. */
2327 check_field_in (struct type
*type
, const char *name
)
2331 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2333 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2334 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2338 /* C++: If it was not found as a data field, then try to return it
2339 as a pointer to a method. */
2341 /* Destructors are a special case. */
2342 if (destructor_name_p (name
, type
))
2344 int m_index
, f_index
;
2346 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2349 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2351 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2355 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2356 if (check_field_in (TYPE_BASECLASS (type
, i
), name
))
2363 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2364 return 1 if the component named NAME from the ultimate target
2365 structure/union is defined, otherwise, return 0. */
2368 check_field (struct value
*arg1
, const char *name
)
2372 arg1
= coerce_array (arg1
);
2374 t
= value_type (arg1
);
2376 /* Follow pointers until we get to a non-pointer. */
2381 if (TYPE_CODE (t
) != TYPE_CODE_PTR
2382 && TYPE_CODE (t
) != TYPE_CODE_REF
)
2384 t
= TYPE_TARGET_TYPE (t
);
2387 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2388 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2389 error (_("Internal error: `this' is not an aggregate"));
2391 return check_field_in (t
, name
);
2394 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2395 return the appropriate member (or the address of the member, if
2396 WANT_ADDRESS). This function is used to resolve user expressions
2397 of the form "DOMAIN::NAME". For more details on what happens, see
2398 the comment before value_struct_elt_for_reference. */
2401 value_aggregate_elt (struct type
*curtype
,
2402 char *name
, int want_address
,
2405 switch (TYPE_CODE (curtype
))
2407 case TYPE_CODE_STRUCT
:
2408 case TYPE_CODE_UNION
:
2409 return value_struct_elt_for_reference (curtype
, 0, curtype
,
2411 want_address
, noside
);
2412 case TYPE_CODE_NAMESPACE
:
2413 return value_namespace_elt (curtype
, name
,
2414 want_address
, noside
);
2416 internal_error (__FILE__
, __LINE__
,
2417 _("non-aggregate type in value_aggregate_elt"));
2421 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2422 return the address of this member as a "pointer to member" type.
2423 If INTYPE is non-null, then it will be the type of the member we
2424 are looking for. This will help us resolve "pointers to member
2425 functions". This function is used to resolve user expressions of
2426 the form "DOMAIN::NAME". */
2428 static struct value
*
2429 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2430 struct type
*curtype
, char *name
,
2431 struct type
*intype
,
2435 struct type
*t
= curtype
;
2437 struct value
*v
, *result
;
2439 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2440 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2441 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2443 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2445 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2447 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2449 if (TYPE_FIELD_STATIC (t
, i
))
2451 v
= value_static_field (t
, i
);
2453 error (_("static field %s has been optimized out"),
2459 if (TYPE_FIELD_PACKED (t
, i
))
2460 error (_("pointers to bitfield members not allowed"));
2463 return value_from_longest
2464 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
2465 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2466 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2467 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
2469 error (_("Cannot reference non-static field \"%s\""), name
);
2473 /* C++: If it was not found as a data field, then try to return it
2474 as a pointer to a method. */
2476 /* Destructors are a special case. */
2477 if (destructor_name_p (name
, t
))
2479 error (_("member pointers to destructors not implemented yet"));
2482 /* Perform all necessary dereferencing. */
2483 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2484 intype
= TYPE_TARGET_TYPE (intype
);
2486 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2488 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2489 char dem_opname
[64];
2491 if (strncmp (t_field_name
, "__", 2) == 0
2492 || strncmp (t_field_name
, "op", 2) == 0
2493 || strncmp (t_field_name
, "type", 4) == 0)
2495 if (cplus_demangle_opname (t_field_name
,
2496 dem_opname
, DMGL_ANSI
))
2497 t_field_name
= dem_opname
;
2498 else if (cplus_demangle_opname (t_field_name
,
2500 t_field_name
= dem_opname
;
2502 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2504 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2505 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2507 check_stub_method_group (t
, i
);
2509 if (intype
== 0 && j
> 1)
2510 error (_("non-unique member `%s' requires type instantiation"), name
);
2514 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2517 error (_("no member function matches that type instantiation"));
2522 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
2525 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2526 0, VAR_DOMAIN
, 0, NULL
);
2531 return value_addr (read_var_value (s
, 0));
2533 return read_var_value (s
, 0);
2536 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2540 result
= allocate_value
2541 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
2542 cplus_make_method_ptr (value_contents_writeable (result
),
2543 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
2545 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2546 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
2548 error (_("Cannot reference virtual member function \"%s\""),
2554 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2555 0, VAR_DOMAIN
, 0, NULL
);
2559 v
= read_var_value (s
, 0);
2564 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
2565 cplus_make_method_ptr (value_contents_writeable (result
),
2566 VALUE_ADDRESS (v
), 0);
2572 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2577 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2580 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2581 v
= value_struct_elt_for_reference (domain
,
2582 offset
+ base_offset
,
2583 TYPE_BASECLASS (t
, i
),
2585 want_address
, noside
);
2590 /* As a last chance, pretend that CURTYPE is a namespace, and look
2591 it up that way; this (frequently) works for types nested inside
2594 return value_maybe_namespace_elt (curtype
, name
,
2595 want_address
, noside
);
2598 /* C++: Return the member NAME of the namespace given by the type
2601 static struct value
*
2602 value_namespace_elt (const struct type
*curtype
,
2603 char *name
, int want_address
,
2606 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
2611 error (_("No symbol \"%s\" in namespace \"%s\"."),
2612 name
, TYPE_TAG_NAME (curtype
));
2617 /* A helper function used by value_namespace_elt and
2618 value_struct_elt_for_reference. It looks up NAME inside the
2619 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
2620 is a class and NAME refers to a type in CURTYPE itself (as opposed
2621 to, say, some base class of CURTYPE). */
2623 static struct value
*
2624 value_maybe_namespace_elt (const struct type
*curtype
,
2625 char *name
, int want_address
,
2628 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
2630 struct value
*result
;
2632 sym
= cp_lookup_symbol_namespace (namespace_name
, name
, NULL
,
2633 get_selected_block (0),
2638 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
2639 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
2640 result
= allocate_value (SYMBOL_TYPE (sym
));
2642 result
= value_of_variable (sym
, get_selected_block (0));
2644 if (result
&& want_address
)
2645 result
= value_addr (result
);
2650 /* Given a pointer value V, find the real (RTTI) type of the object it
2653 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2654 and refer to the values computed for the object pointed to. */
2657 value_rtti_target_type (struct value
*v
, int *full
,
2658 int *top
, int *using_enc
)
2660 struct value
*target
;
2662 target
= value_ind (v
);
2664 return value_rtti_type (target
, full
, top
, using_enc
);
2667 /* Given a value pointed to by ARGP, check its real run-time type, and
2668 if that is different from the enclosing type, create a new value
2669 using the real run-time type as the enclosing type (and of the same
2670 type as ARGP) and return it, with the embedded offset adjusted to
2671 be the correct offset to the enclosed object. RTYPE is the type,
2672 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
2673 by value_rtti_type(). If these are available, they can be supplied
2674 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
2675 NULL if they're not available. */
2678 value_full_object (struct value
*argp
,
2680 int xfull
, int xtop
,
2683 struct type
*real_type
;
2687 struct value
*new_val
;
2694 using_enc
= xusing_enc
;
2697 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
2699 /* If no RTTI data, or if object is already complete, do nothing. */
2700 if (!real_type
|| real_type
== value_enclosing_type (argp
))
2703 /* If we have the full object, but for some reason the enclosing
2704 type is wrong, set it. */
2705 /* pai: FIXME -- sounds iffy */
2708 argp
= value_change_enclosing_type (argp
, real_type
);
2712 /* Check if object is in memory */
2713 if (VALUE_LVAL (argp
) != lval_memory
)
2715 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
2716 TYPE_NAME (real_type
));
2721 /* All other cases -- retrieve the complete object. */
2722 /* Go back by the computed top_offset from the beginning of the
2723 object, adjusting for the embedded offset of argp if that's what
2724 value_rtti_type used for its computation. */
2725 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
2726 (using_enc
? 0 : value_embedded_offset (argp
)));
2727 deprecated_set_value_type (new_val
, value_type (argp
));
2728 set_value_embedded_offset (new_val
, (using_enc
2729 ? top
+ value_embedded_offset (argp
)
2735 /* Return the value of the local variable, if one exists.
2736 Flag COMPLAIN signals an error if the request is made in an
2737 inappropriate context. */
2740 value_of_local (const char *name
, int complain
)
2742 struct symbol
*func
, *sym
;
2745 struct frame_info
*frame
;
2748 frame
= get_selected_frame (_("no frame selected"));
2751 frame
= deprecated_safe_get_selected_frame ();
2756 func
= get_frame_function (frame
);
2760 error (_("no `%s' in nameless context"), name
);
2765 b
= SYMBOL_BLOCK_VALUE (func
);
2766 if (dict_empty (BLOCK_DICT (b
)))
2769 error (_("no args, no `%s'"), name
);
2774 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2775 symbol instead of the LOC_ARG one (if both exist). */
2776 sym
= lookup_block_symbol (b
, name
, NULL
, VAR_DOMAIN
);
2780 error (_("current stack frame does not contain a variable named `%s'"),
2786 ret
= read_var_value (sym
, frame
);
2787 if (ret
== 0 && complain
)
2788 error (_("`%s' argument unreadable"), name
);
2792 /* C++/Objective-C: return the value of the class instance variable,
2793 if one exists. Flag COMPLAIN signals an error if the request is
2794 made in an inappropriate context. */
2797 value_of_this (int complain
)
2799 if (current_language
->la_language
== language_objc
)
2800 return value_of_local ("self", complain
);
2802 return value_of_local ("this", complain
);
2805 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
2806 elements long, starting at LOWBOUND. The result has the same lower
2807 bound as the original ARRAY. */
2810 value_slice (struct value
*array
, int lowbound
, int length
)
2812 struct type
*slice_range_type
, *slice_type
, *range_type
;
2813 LONGEST lowerbound
, upperbound
;
2814 struct value
*slice
;
2815 struct type
*array_type
;
2817 array_type
= check_typedef (value_type (array
));
2818 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
2819 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
2820 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
2821 error (_("cannot take slice of non-array"));
2823 range_type
= TYPE_INDEX_TYPE (array_type
);
2824 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
2825 error (_("slice from bad array or bitstring"));
2827 if (lowbound
< lowerbound
|| length
< 0
2828 || lowbound
+ length
- 1 > upperbound
)
2829 error (_("slice out of range"));
2831 /* FIXME-type-allocation: need a way to free this type when we are
2833 slice_range_type
= create_range_type ((struct type
*) NULL
,
2834 TYPE_TARGET_TYPE (range_type
),
2836 lowbound
+ length
- 1);
2837 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
2841 slice_type
= create_set_type ((struct type
*) NULL
,
2843 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
2844 slice
= value_zero (slice_type
, not_lval
);
2846 for (i
= 0; i
< length
; i
++)
2848 int element
= value_bit_index (array_type
,
2849 value_contents (array
),
2852 error (_("internal error accessing bitstring"));
2853 else if (element
> 0)
2855 int j
= i
% TARGET_CHAR_BIT
;
2856 if (BITS_BIG_ENDIAN
)
2857 j
= TARGET_CHAR_BIT
- 1 - j
;
2858 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
2861 /* We should set the address, bitssize, and bitspos, so the
2862 slice can be used on the LHS, but that may require extensions
2863 to value_assign. For now, just leave as a non_lval.
2868 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
2870 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
2872 slice_type
= create_array_type ((struct type
*) NULL
,
2875 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
2877 slice
= allocate_value (slice_type
);
2878 if (value_lazy (array
))
2879 set_value_lazy (slice
, 1);
2881 memcpy (value_contents_writeable (slice
),
2882 value_contents (array
) + offset
,
2883 TYPE_LENGTH (slice_type
));
2885 if (VALUE_LVAL (array
) == lval_internalvar
)
2886 VALUE_LVAL (slice
) = lval_internalvar_component
;
2888 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2890 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2891 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
2892 set_value_offset (slice
, value_offset (array
) + offset
);
2897 /* Create a value for a FORTRAN complex number. Currently most of the
2898 time values are coerced to COMPLEX*16 (i.e. a complex number
2899 composed of 2 doubles. This really should be a smarter routine
2900 that figures out precision inteligently as opposed to assuming
2901 doubles. FIXME: fmb */
2904 value_literal_complex (struct value
*arg1
,
2909 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2911 val
= allocate_value (type
);
2912 arg1
= value_cast (real_type
, arg1
);
2913 arg2
= value_cast (real_type
, arg2
);
2915 memcpy (value_contents_raw (val
),
2916 value_contents (arg1
), TYPE_LENGTH (real_type
));
2917 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
2918 value_contents (arg2
), TYPE_LENGTH (real_type
));
2922 /* Cast a value into the appropriate complex data type. */
2924 static struct value
*
2925 cast_into_complex (struct type
*type
, struct value
*val
)
2927 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2929 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
2931 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
2932 struct value
*re_val
= allocate_value (val_real_type
);
2933 struct value
*im_val
= allocate_value (val_real_type
);
2935 memcpy (value_contents_raw (re_val
),
2936 value_contents (val
), TYPE_LENGTH (val_real_type
));
2937 memcpy (value_contents_raw (im_val
),
2938 value_contents (val
) + TYPE_LENGTH (val_real_type
),
2939 TYPE_LENGTH (val_real_type
));
2941 return value_literal_complex (re_val
, im_val
, type
);
2943 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
2944 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
2945 return value_literal_complex (val
,
2946 value_zero (real_type
, not_lval
),
2949 error (_("cannot cast non-number to complex"));
2953 _initialize_valops (void)
2955 add_setshow_boolean_cmd ("overload-resolution", class_support
,
2956 &overload_resolution
, _("\
2957 Set overload resolution in evaluating C++ functions."), _("\
2958 Show overload resolution in evaluating C++ functions."),
2960 show_overload_resolution
,
2961 &setlist
, &showlist
);
2962 overload_resolution
= 1;