1 /* Perform non-arithmetic operations on values, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 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"
40 #include "user-regs.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
48 extern int overload_debug
;
49 /* Local functions. */
51 static int typecmp (int staticp
, int varargs
, int nargs
,
52 struct field t1
[], struct value
*t2
[]);
54 static struct value
*search_struct_field (char *, struct value
*,
55 int, struct type
*, int);
57 static struct value
*search_struct_method (char *, struct value
**,
59 int, int *, struct type
*);
61 static int find_oload_champ_namespace (struct type
**, int,
62 const char *, const char *,
64 struct badness_vector
**);
67 int find_oload_champ_namespace_loop (struct type
**, int,
68 const char *, const char *,
69 int, struct symbol
***,
70 struct badness_vector
**, int *);
72 static int find_oload_champ (struct type
**, int, int, int,
73 struct fn_field
*, struct symbol
**,
74 struct badness_vector
**);
76 static int oload_method_static (int, struct fn_field
*, int);
78 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
81 oload_classification
classify_oload_match (struct badness_vector
*,
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);
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 struct value VAL to type TYPE and return as a value.
195 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
196 for this to work. Typedef to one of the codes is permitted.
197 Returns NULL if the cast is neither an upcast nor a downcast. */
199 static struct value
*
200 value_cast_structs (struct type
*type
, struct value
*v2
)
206 gdb_assert (type
!= NULL
&& v2
!= NULL
);
208 t1
= check_typedef (type
);
209 t2
= check_typedef (value_type (v2
));
211 /* Check preconditions. */
212 gdb_assert ((TYPE_CODE (t1
) == TYPE_CODE_STRUCT
213 || TYPE_CODE (t1
) == TYPE_CODE_UNION
)
214 && !!"Precondition is that type is of STRUCT or UNION kind.");
215 gdb_assert ((TYPE_CODE (t2
) == TYPE_CODE_STRUCT
216 || TYPE_CODE (t2
) == TYPE_CODE_UNION
)
217 && !!"Precondition is that value is of STRUCT or UNION kind");
219 /* Upcasting: look in the type of the source to see if it contains the
220 type of the target as a superclass. If so, we'll need to
221 offset the pointer rather than just change its type. */
222 if (TYPE_NAME (t1
) != NULL
)
224 v
= search_struct_field (type_name_no_tag (t1
),
230 /* Downcasting: look in the type of the target to see if it contains the
231 type of the source as a superclass. If so, we'll need to
232 offset the pointer rather than just change its type.
233 FIXME: This fails silently with virtual inheritance. */
234 if (TYPE_NAME (t2
) != NULL
)
236 v
= search_struct_field (type_name_no_tag (t2
),
237 value_zero (t1
, not_lval
), 0, t1
, 1);
240 /* Downcasting is possible (t1 is superclass of v2). */
241 CORE_ADDR addr2
= VALUE_ADDRESS (v2
);
242 addr2
-= (VALUE_ADDRESS (v
)
244 + value_embedded_offset (v
));
245 return value_at (type
, addr2
);
252 /* Cast one pointer or reference type to another. Both TYPE and
253 the type of ARG2 should be pointer types, or else both should be
254 reference types. Returns the new pointer or reference. */
257 value_cast_pointers (struct type
*type
, struct value
*arg2
)
259 struct type
*type1
= check_typedef (type
);
260 struct type
*type2
= check_typedef (value_type (arg2
));
261 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
262 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
264 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
265 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
266 && !value_logical_not (arg2
))
270 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
271 v2
= coerce_ref (arg2
);
273 v2
= value_ind (arg2
);
274 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
))) == TYPE_CODE_STRUCT
275 && !!"Why did coercion fail?");
276 v2
= value_cast_structs (t1
, v2
);
277 /* At this point we have what we can have, un-dereference if needed. */
280 struct value
*v
= value_addr (v2
);
281 deprecated_set_value_type (v
, type
);
286 /* No superclass found, just change the pointer type. */
287 arg2
= value_copy (arg2
);
288 deprecated_set_value_type (arg2
, type
);
289 arg2
= value_change_enclosing_type (arg2
, type
);
290 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
294 /* Cast value ARG2 to type TYPE and return as a value.
295 More general than a C cast: accepts any two types of the same length,
296 and if ARG2 is an lvalue it can be cast into anything at all. */
297 /* In C++, casts may change pointer or object representations. */
300 value_cast (struct type
*type
, struct value
*arg2
)
302 enum type_code code1
;
303 enum type_code code2
;
307 int convert_to_boolean
= 0;
309 if (value_type (arg2
) == type
)
312 code1
= TYPE_CODE (check_typedef (type
));
314 /* Check if we are casting struct reference to struct reference. */
315 if (code1
== TYPE_CODE_REF
)
317 /* We dereference type; then we recurse and finally
318 we generate value of the given reference. Nothing wrong with
320 struct type
*t1
= check_typedef (type
);
321 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
322 struct value
*val
= value_cast (dereftype
, arg2
);
323 return value_ref (val
);
326 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
328 if (code2
== TYPE_CODE_REF
)
329 /* We deref the value and then do the cast. */
330 return value_cast (type
, coerce_ref (arg2
));
332 CHECK_TYPEDEF (type
);
333 code1
= TYPE_CODE (type
);
334 arg2
= coerce_ref (arg2
);
335 type2
= check_typedef (value_type (arg2
));
337 /* You can't cast to a reference type. See value_cast_pointers
339 gdb_assert (code1
!= TYPE_CODE_REF
);
341 /* A cast to an undetermined-length array_type, such as
342 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
343 where N is sizeof(OBJECT)/sizeof(TYPE). */
344 if (code1
== TYPE_CODE_ARRAY
)
346 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
347 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
348 if (element_length
> 0
349 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) == BOUND_CANNOT_BE_DETERMINED
)
351 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
352 int val_length
= TYPE_LENGTH (type2
);
353 LONGEST low_bound
, high_bound
, new_length
;
354 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
355 low_bound
= 0, high_bound
= 0;
356 new_length
= val_length
/ element_length
;
357 if (val_length
% element_length
!= 0)
358 warning (_("array element type size does not divide object size in cast"));
359 /* FIXME-type-allocation: need a way to free this type when
360 we are done with it. */
361 range_type
= create_range_type ((struct type
*) NULL
,
362 TYPE_TARGET_TYPE (range_type
),
364 new_length
+ low_bound
- 1);
365 deprecated_set_value_type (arg2
,
366 create_array_type ((struct type
*) NULL
,
373 if (current_language
->c_style_arrays
374 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
375 arg2
= value_coerce_array (arg2
);
377 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
378 arg2
= value_coerce_function (arg2
);
380 type2
= check_typedef (value_type (arg2
));
381 code2
= TYPE_CODE (type2
);
383 if (code1
== TYPE_CODE_COMPLEX
)
384 return cast_into_complex (type
, arg2
);
385 if (code1
== TYPE_CODE_BOOL
)
387 code1
= TYPE_CODE_INT
;
388 convert_to_boolean
= 1;
390 if (code1
== TYPE_CODE_CHAR
)
391 code1
= TYPE_CODE_INT
;
392 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
393 code2
= TYPE_CODE_INT
;
395 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
396 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
397 || code2
== TYPE_CODE_RANGE
);
399 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
400 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
401 && TYPE_NAME (type
) != 0)
403 struct value
*v
= value_cast_structs (type
, arg2
);
408 if (code1
== TYPE_CODE_FLT
&& scalar
)
409 return value_from_double (type
, value_as_double (arg2
));
410 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
412 int dec_len
= TYPE_LENGTH (type
);
415 if (code2
== TYPE_CODE_FLT
)
416 decimal_from_floating (arg2
, dec
, dec_len
);
417 else if (code2
== TYPE_CODE_DECFLOAT
)
418 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
421 /* The only option left is an integral type. */
422 decimal_from_integral (arg2
, dec
, dec_len
);
424 return value_from_decfloat (type
, dec
);
426 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
427 || code1
== TYPE_CODE_RANGE
)
428 && (scalar
|| code2
== TYPE_CODE_PTR
429 || code2
== TYPE_CODE_MEMBERPTR
))
433 /* When we cast pointers to integers, we mustn't use
434 gdbarch_pointer_to_address to find the address the pointer
435 represents, as value_as_long would. GDB should evaluate
436 expressions just as the compiler would --- and the compiler
437 sees a cast as a simple reinterpretation of the pointer's
439 if (code2
== TYPE_CODE_PTR
)
440 longest
= extract_unsigned_integer (value_contents (arg2
),
441 TYPE_LENGTH (type2
));
443 longest
= value_as_long (arg2
);
444 return value_from_longest (type
, convert_to_boolean
?
445 (LONGEST
) (longest
? 1 : 0) : longest
);
447 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
448 || code2
== TYPE_CODE_ENUM
449 || code2
== TYPE_CODE_RANGE
))
451 /* TYPE_LENGTH (type) is the length of a pointer, but we really
452 want the length of an address! -- we are really dealing with
453 addresses (i.e., gdb representations) not pointers (i.e.,
454 target representations) here.
456 This allows things like "print *(int *)0x01000234" to work
457 without printing a misleading message -- which would
458 otherwise occur when dealing with a target having two byte
459 pointers and four byte addresses. */
461 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
463 LONGEST longest
= value_as_long (arg2
);
464 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
466 if (longest
>= ((LONGEST
) 1 << addr_bit
)
467 || longest
<= -((LONGEST
) 1 << addr_bit
))
468 warning (_("value truncated"));
470 return value_from_longest (type
, longest
);
472 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
473 && value_as_long (arg2
) == 0)
475 struct value
*result
= allocate_value (type
);
476 cplus_make_method_ptr (value_contents_writeable (result
), 0, 0);
479 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
480 && value_as_long (arg2
) == 0)
482 /* The Itanium C++ ABI represents NULL pointers to members as
483 minus one, instead of biasing the normal case. */
484 return value_from_longest (type
, -1);
486 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
488 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
489 return value_cast_pointers (type
, arg2
);
491 arg2
= value_copy (arg2
);
492 deprecated_set_value_type (arg2
, type
);
493 arg2
= value_change_enclosing_type (arg2
, type
);
494 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
497 else if (VALUE_LVAL (arg2
) == lval_memory
)
498 return value_at_lazy (type
,
499 VALUE_ADDRESS (arg2
) + value_offset (arg2
));
500 else if (code1
== TYPE_CODE_VOID
)
502 return value_zero (builtin_type_void
, not_lval
);
506 error (_("Invalid cast."));
511 /* Create a value of type TYPE that is zero, and return it. */
514 value_zero (struct type
*type
, enum lval_type lv
)
516 struct value
*val
= allocate_value (type
);
517 VALUE_LVAL (val
) = lv
;
522 /* Create a value of numeric type TYPE that is one, and return it. */
525 value_one (struct type
*type
, enum lval_type lv
)
527 struct type
*type1
= check_typedef (type
);
528 struct value
*val
= NULL
; /* avoid -Wall warning */
530 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
532 struct value
*int_one
= value_from_longest (builtin_type_int
, 1);
536 decimal_from_integral (int_one
, v
, TYPE_LENGTH (builtin_type_int
));
537 val
= value_from_decfloat (type
, v
);
539 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
541 val
= value_from_double (type
, (DOUBLEST
) 1);
543 else if (is_integral_type (type1
))
545 val
= value_from_longest (type
, (LONGEST
) 1);
549 error (_("Not a numeric type."));
552 VALUE_LVAL (val
) = lv
;
556 /* Return a value with type TYPE located at ADDR.
558 Call value_at only if the data needs to be fetched immediately;
559 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
560 value_at_lazy instead. value_at_lazy simply records the address of
561 the data and sets the lazy-evaluation-required flag. The lazy flag
562 is tested in the value_contents macro, which is used if and when
563 the contents are actually required.
565 Note: value_at does *NOT* handle embedded offsets; perform such
566 adjustments before or after calling it. */
569 value_at (struct type
*type
, CORE_ADDR addr
)
573 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
574 error (_("Attempt to dereference a generic pointer."));
576 val
= allocate_value (type
);
578 read_memory (addr
, value_contents_all_raw (val
), TYPE_LENGTH (type
));
580 VALUE_LVAL (val
) = lval_memory
;
581 VALUE_ADDRESS (val
) = addr
;
586 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
589 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
593 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
594 error (_("Attempt to dereference a generic pointer."));
596 val
= allocate_value (type
);
598 VALUE_LVAL (val
) = lval_memory
;
599 VALUE_ADDRESS (val
) = addr
;
600 set_value_lazy (val
, 1);
605 /* Called only from the value_contents and value_contents_all()
606 macros, if the current data for a variable needs to be loaded into
607 value_contents(VAL). Fetches the data from the user's process, and
608 clears the lazy flag to indicate that the data in the buffer is
611 If the value is zero-length, we avoid calling read_memory, which
612 would abort. We mark the value as fetched anyway -- all 0 bytes of
615 This function returns a value because it is used in the
616 value_contents macro as part of an expression, where a void would
617 not work. The value is ignored. */
620 value_fetch_lazy (struct value
*val
)
622 if (VALUE_LVAL (val
) == lval_memory
)
624 CORE_ADDR addr
= VALUE_ADDRESS (val
) + value_offset (val
);
625 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
628 read_memory (addr
, value_contents_all_raw (val
), length
);
630 else if (VALUE_LVAL (val
) == lval_register
)
632 struct frame_info
*frame
;
634 struct type
*type
= check_typedef (value_type (val
));
635 struct value
*new_val
= val
, *mark
= value_mark ();
637 /* Offsets are not supported here; lazy register values must
638 refer to the entire register. */
639 gdb_assert (value_offset (val
) == 0);
641 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
643 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
644 regnum
= VALUE_REGNUM (new_val
);
646 gdb_assert (frame
!= NULL
);
648 /* Convertible register routines are used for multi-register
649 values and for interpretation in different types
650 (e.g. float or int from a double register). Lazy
651 register values should have the register's natural type,
652 so they do not apply. */
653 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
656 new_val
= get_frame_register_value (frame
, regnum
);
659 /* If it's still lazy (for instance, a saved register on the
661 if (value_lazy (new_val
))
662 value_fetch_lazy (new_val
);
664 /* If the register was not saved, mark it unavailable. */
665 if (value_optimized_out (new_val
))
666 set_value_optimized_out (val
, 1);
668 memcpy (value_contents_raw (val
), value_contents (new_val
),
673 struct gdbarch
*gdbarch
;
674 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
675 regnum
= VALUE_REGNUM (val
);
676 gdbarch
= get_frame_arch (frame
);
678 fprintf_unfiltered (gdb_stdlog
, "\
679 { value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
680 frame_relative_level (frame
), regnum
,
681 user_reg_map_regnum_to_name (gdbarch
, regnum
));
683 fprintf_unfiltered (gdb_stdlog
, "->");
684 if (value_optimized_out (new_val
))
685 fprintf_unfiltered (gdb_stdlog
, " optimized out");
689 const gdb_byte
*buf
= value_contents (new_val
);
691 if (VALUE_LVAL (new_val
) == lval_register
)
692 fprintf_unfiltered (gdb_stdlog
, " register=%d",
693 VALUE_REGNUM (new_val
));
694 else if (VALUE_LVAL (new_val
) == lval_memory
)
695 fprintf_unfiltered (gdb_stdlog
, " address=0x%s",
696 paddr_nz (VALUE_ADDRESS (new_val
)));
698 fprintf_unfiltered (gdb_stdlog
, " computed");
700 fprintf_unfiltered (gdb_stdlog
, " bytes=");
701 fprintf_unfiltered (gdb_stdlog
, "[");
702 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
703 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
704 fprintf_unfiltered (gdb_stdlog
, "]");
707 fprintf_unfiltered (gdb_stdlog
, " }\n");
710 /* Dispose of the intermediate values. This prevents
711 watchpoints from trying to watch the saved frame pointer. */
712 value_free_to_mark (mark
);
715 internal_error (__FILE__
, __LINE__
, "Unexpected lazy value type.");
717 set_value_lazy (val
, 0);
722 /* Store the contents of FROMVAL into the location of TOVAL.
723 Return a new value with the location of TOVAL and contents of FROMVAL. */
726 value_assign (struct value
*toval
, struct value
*fromval
)
730 struct frame_id old_frame
;
732 if (!deprecated_value_modifiable (toval
))
733 error (_("Left operand of assignment is not a modifiable lvalue."));
735 toval
= coerce_ref (toval
);
737 type
= value_type (toval
);
738 if (VALUE_LVAL (toval
) != lval_internalvar
)
740 toval
= value_coerce_to_target (toval
);
741 fromval
= value_cast (type
, fromval
);
745 /* Coerce arrays and functions to pointers, except for arrays
746 which only live in GDB's storage. */
747 if (!value_must_coerce_to_target (fromval
))
748 fromval
= coerce_array (fromval
);
751 CHECK_TYPEDEF (type
);
753 /* Since modifying a register can trash the frame chain, and
754 modifying memory can trash the frame cache, we save the old frame
755 and then restore the new frame afterwards. */
756 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
758 switch (VALUE_LVAL (toval
))
760 case lval_internalvar
:
761 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
762 val
= value_copy (VALUE_INTERNALVAR (toval
)->value
);
763 val
= value_change_enclosing_type (val
,
764 value_enclosing_type (fromval
));
765 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
766 set_value_pointed_to_offset (val
,
767 value_pointed_to_offset (fromval
));
770 case lval_internalvar_component
:
771 set_internalvar_component (VALUE_INTERNALVAR (toval
),
772 value_offset (toval
),
773 value_bitpos (toval
),
774 value_bitsize (toval
),
780 const gdb_byte
*dest_buffer
;
781 CORE_ADDR changed_addr
;
783 gdb_byte buffer
[sizeof (LONGEST
)];
785 if (value_bitsize (toval
))
787 /* We assume that the argument to read_memory is in units
788 of host chars. FIXME: Is that correct? */
789 changed_len
= (value_bitpos (toval
)
790 + value_bitsize (toval
)
794 if (changed_len
> (int) sizeof (LONGEST
))
795 error (_("Can't handle bitfields which don't fit in a %d bit word."),
796 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
798 read_memory (VALUE_ADDRESS (toval
) + value_offset (toval
),
799 buffer
, changed_len
);
800 modify_field (buffer
, value_as_long (fromval
),
801 value_bitpos (toval
), value_bitsize (toval
));
802 changed_addr
= VALUE_ADDRESS (toval
) + value_offset (toval
);
803 dest_buffer
= buffer
;
807 changed_addr
= VALUE_ADDRESS (toval
) + value_offset (toval
);
808 changed_len
= TYPE_LENGTH (type
);
809 dest_buffer
= value_contents (fromval
);
812 write_memory (changed_addr
, dest_buffer
, changed_len
);
813 if (deprecated_memory_changed_hook
)
814 deprecated_memory_changed_hook (changed_addr
, changed_len
);
820 struct frame_info
*frame
;
823 /* Figure out which frame this is in currently. */
824 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
825 value_reg
= VALUE_REGNUM (toval
);
828 error (_("Value being assigned to is no longer active."));
830 if (gdbarch_convert_register_p
831 (current_gdbarch
, VALUE_REGNUM (toval
), type
))
833 /* If TOVAL is a special machine register requiring
834 conversion of program values to a special raw
836 gdbarch_value_to_register (current_gdbarch
, frame
,
837 VALUE_REGNUM (toval
), type
,
838 value_contents (fromval
));
842 if (value_bitsize (toval
))
845 gdb_byte buffer
[sizeof (LONGEST
)];
847 changed_len
= (value_bitpos (toval
)
848 + value_bitsize (toval
)
852 if (changed_len
> (int) sizeof (LONGEST
))
853 error (_("Can't handle bitfields which don't fit in a %d bit word."),
854 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
856 get_frame_register_bytes (frame
, value_reg
,
857 value_offset (toval
),
858 changed_len
, buffer
);
860 modify_field (buffer
, value_as_long (fromval
),
861 value_bitpos (toval
),
862 value_bitsize (toval
));
864 put_frame_register_bytes (frame
, value_reg
,
865 value_offset (toval
),
866 changed_len
, buffer
);
870 put_frame_register_bytes (frame
, value_reg
,
871 value_offset (toval
),
873 value_contents (fromval
));
877 if (deprecated_register_changed_hook
)
878 deprecated_register_changed_hook (-1);
879 observer_notify_target_changed (¤t_target
);
884 error (_("Left operand of assignment is not an lvalue."));
887 /* Assigning to the stack pointer, frame pointer, and other
888 (architecture and calling convention specific) registers may
889 cause the frame cache to be out of date. Assigning to memory
890 also can. We just do this on all assignments to registers or
891 memory, for simplicity's sake; I doubt the slowdown matters. */
892 switch (VALUE_LVAL (toval
))
897 reinit_frame_cache ();
899 /* Having destroyed the frame cache, restore the selected
902 /* FIXME: cagney/2002-11-02: There has to be a better way of
903 doing this. Instead of constantly saving/restoring the
904 frame. Why not create a get_selected_frame() function that,
905 having saved the selected frame's ID can automatically
906 re-find the previously selected frame automatically. */
909 struct frame_info
*fi
= frame_find_by_id (old_frame
);
919 /* If the field does not entirely fill a LONGEST, then zero the sign
920 bits. If the field is signed, and is negative, then sign
922 if ((value_bitsize (toval
) > 0)
923 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
925 LONGEST fieldval
= value_as_long (fromval
);
926 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
929 if (!TYPE_UNSIGNED (type
)
930 && (fieldval
& (valmask
^ (valmask
>> 1))))
931 fieldval
|= ~valmask
;
933 fromval
= value_from_longest (type
, fieldval
);
936 val
= value_copy (toval
);
937 memcpy (value_contents_raw (val
), value_contents (fromval
),
939 deprecated_set_value_type (val
, type
);
940 val
= value_change_enclosing_type (val
,
941 value_enclosing_type (fromval
));
942 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
943 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
948 /* Extend a value VAL to COUNT repetitions of its type. */
951 value_repeat (struct value
*arg1
, int count
)
955 if (VALUE_LVAL (arg1
) != lval_memory
)
956 error (_("Only values in memory can be extended with '@'."));
958 error (_("Invalid number %d of repetitions."), count
);
960 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
962 read_memory (VALUE_ADDRESS (arg1
) + value_offset (arg1
),
963 value_contents_all_raw (val
),
964 TYPE_LENGTH (value_enclosing_type (val
)));
965 VALUE_LVAL (val
) = lval_memory
;
966 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg1
) + value_offset (arg1
);
972 value_of_variable (struct symbol
*var
, struct block
*b
)
975 struct frame_info
*frame
= NULL
;
978 frame
= NULL
; /* Use selected frame. */
979 else if (symbol_read_needs_frame (var
))
981 frame
= block_innermost_frame (b
);
984 if (BLOCK_FUNCTION (b
)
985 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
986 error (_("No frame is currently executing in block %s."),
987 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
989 error (_("No frame is currently executing in specified block"));
993 val
= read_var_value (var
, frame
);
995 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
1000 /* Return one if VAL does not live in target memory, but should in order
1001 to operate on it. Otherwise return zero. */
1004 value_must_coerce_to_target (struct value
*val
)
1006 struct type
*valtype
;
1008 /* The only lval kinds which do not live in target memory. */
1009 if (VALUE_LVAL (val
) != not_lval
1010 && VALUE_LVAL (val
) != lval_internalvar
)
1013 valtype
= check_typedef (value_type (val
));
1015 switch (TYPE_CODE (valtype
))
1017 case TYPE_CODE_ARRAY
:
1018 case TYPE_CODE_STRING
:
1025 /* Make sure that VAL lives in target memory if it's supposed to. For instance,
1026 strings are constructed as character arrays in GDB's storage, and this
1027 function copies them to the target. */
1030 value_coerce_to_target (struct value
*val
)
1035 if (!value_must_coerce_to_target (val
))
1038 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1039 addr
= allocate_space_in_inferior (length
);
1040 write_memory (addr
, value_contents (val
), length
);
1041 return value_at_lazy (value_type (val
), addr
);
1044 /* Given a value which is an array, return a value which is a pointer
1045 to its first element, regardless of whether or not the array has a
1046 nonzero lower bound.
1048 FIXME: A previous comment here indicated that this routine should
1049 be substracting the array's lower bound. It's not clear to me that
1050 this is correct. Given an array subscripting operation, it would
1051 certainly work to do the adjustment here, essentially computing:
1053 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1055 However I believe a more appropriate and logical place to account
1056 for the lower bound is to do so in value_subscript, essentially
1059 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1061 As further evidence consider what would happen with operations
1062 other than array subscripting, where the caller would get back a
1063 value that had an address somewhere before the actual first element
1064 of the array, and the information about the lower bound would be
1065 lost because of the coercion to pointer type.
1069 value_coerce_array (struct value
*arg1
)
1071 struct type
*type
= check_typedef (value_type (arg1
));
1073 /* If the user tries to do something requiring a pointer with an
1074 array that has not yet been pushed to the target, then this would
1075 be a good time to do so. */
1076 arg1
= value_coerce_to_target (arg1
);
1078 if (VALUE_LVAL (arg1
) != lval_memory
)
1079 error (_("Attempt to take address of value not located in memory."));
1081 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1082 (VALUE_ADDRESS (arg1
) + value_offset (arg1
)));
1085 /* Given a value which is a function, return a value which is a pointer
1089 value_coerce_function (struct value
*arg1
)
1091 struct value
*retval
;
1093 if (VALUE_LVAL (arg1
) != lval_memory
)
1094 error (_("Attempt to take address of value not located in memory."));
1096 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1097 (VALUE_ADDRESS (arg1
) + value_offset (arg1
)));
1101 /* Return a pointer value for the object for which ARG1 is the
1105 value_addr (struct value
*arg1
)
1109 struct type
*type
= check_typedef (value_type (arg1
));
1110 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1112 /* Copy the value, but change the type from (T&) to (T*). We
1113 keep the same location information, which is efficient, and
1114 allows &(&X) to get the location containing the reference. */
1115 arg2
= value_copy (arg1
);
1116 deprecated_set_value_type (arg2
,
1117 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1120 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1121 return value_coerce_function (arg1
);
1123 /* If this is an array that has not yet been pushed to the target,
1124 then this would be a good time to force it to memory. */
1125 arg1
= value_coerce_to_target (arg1
);
1127 if (VALUE_LVAL (arg1
) != lval_memory
)
1128 error (_("Attempt to take address of value not located in memory."));
1130 /* Get target memory address */
1131 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1132 (VALUE_ADDRESS (arg1
)
1133 + value_offset (arg1
)
1134 + value_embedded_offset (arg1
)));
1136 /* This may be a pointer to a base subobject; so remember the
1137 full derived object's type ... */
1138 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (value_enclosing_type (arg1
)));
1139 /* ... and also the relative position of the subobject in the full
1141 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1145 /* Return a reference value for the object for which ARG1 is the
1149 value_ref (struct value
*arg1
)
1153 struct type
*type
= check_typedef (value_type (arg1
));
1154 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1157 arg2
= value_addr (arg1
);
1158 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1162 /* Given a value of a pointer type, apply the C unary * operator to
1166 value_ind (struct value
*arg1
)
1168 struct type
*base_type
;
1171 arg1
= coerce_array (arg1
);
1173 base_type
= check_typedef (value_type (arg1
));
1175 /* Allow * on an integer so we can cast it to whatever we want.
1176 This returns an int, which seems like the most C-like thing to
1177 do. "long long" variables are rare enough that
1178 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
1179 if (TYPE_CODE (base_type
) == TYPE_CODE_INT
)
1180 return value_at_lazy (builtin_type_int
,
1181 (CORE_ADDR
) value_as_address (arg1
));
1182 else if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1184 struct type
*enc_type
;
1185 /* We may be pointing to something embedded in a larger object.
1186 Get the real type of the enclosing object. */
1187 enc_type
= check_typedef (value_enclosing_type (arg1
));
1188 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1190 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1191 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1192 /* For functions, go through find_function_addr, which knows
1193 how to handle function descriptors. */
1194 arg2
= value_at_lazy (enc_type
,
1195 find_function_addr (arg1
, NULL
));
1197 /* Retrieve the enclosing object pointed to */
1198 arg2
= value_at_lazy (enc_type
,
1199 (value_as_address (arg1
)
1200 - value_pointed_to_offset (arg1
)));
1202 /* Re-adjust type. */
1203 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1204 /* Add embedding info. */
1205 arg2
= value_change_enclosing_type (arg2
, enc_type
);
1206 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1208 /* We may be pointing to an object of some derived type. */
1209 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1213 error (_("Attempt to take contents of a non-pointer value."));
1214 return 0; /* For lint -- never reached. */
1217 /* Create a value for an array by allocating space in GDB, copying
1218 copying the data into that space, and then setting up an array
1221 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1222 is populated from the values passed in ELEMVEC.
1224 The element type of the array is inherited from the type of the
1225 first element, and all elements must have the same size (though we
1226 don't currently enforce any restriction on their types). */
1229 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1233 unsigned int typelength
;
1235 struct type
*rangetype
;
1236 struct type
*arraytype
;
1239 /* Validate that the bounds are reasonable and that each of the
1240 elements have the same size. */
1242 nelem
= highbound
- lowbound
+ 1;
1245 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1247 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1248 for (idx
= 1; idx
< nelem
; idx
++)
1250 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1252 error (_("array elements must all be the same size"));
1256 rangetype
= create_range_type ((struct type
*) NULL
,
1258 lowbound
, highbound
);
1259 arraytype
= create_array_type ((struct type
*) NULL
,
1260 value_enclosing_type (elemvec
[0]),
1263 if (!current_language
->c_style_arrays
)
1265 val
= allocate_value (arraytype
);
1266 for (idx
= 0; idx
< nelem
; idx
++)
1268 memcpy (value_contents_all_raw (val
) + (idx
* typelength
),
1269 value_contents_all (elemvec
[idx
]),
1275 /* Allocate space to store the array, and then initialize it by
1276 copying in each element. */
1278 val
= allocate_value (arraytype
);
1279 for (idx
= 0; idx
< nelem
; idx
++)
1280 memcpy (value_contents_writeable (val
) + (idx
* typelength
),
1281 value_contents_all (elemvec
[idx
]),
1286 /* Create a value for a string constant by allocating space in the
1287 inferior, copying the data into that space, and returning the
1288 address with type TYPE_CODE_STRING. PTR points to the string
1289 constant data; LEN is number of characters.
1291 Note that string types are like array of char types with a lower
1292 bound of zero and an upper bound of LEN - 1. Also note that the
1293 string may contain embedded null bytes. */
1296 value_string (char *ptr
, int len
)
1299 int lowbound
= current_language
->string_lower_bound
;
1300 struct type
*rangetype
= create_range_type ((struct type
*) NULL
,
1303 len
+ lowbound
- 1);
1304 struct type
*stringtype
1305 = create_string_type ((struct type
*) NULL
, rangetype
);
1308 if (current_language
->c_style_arrays
== 0)
1310 val
= allocate_value (stringtype
);
1311 memcpy (value_contents_raw (val
), ptr
, len
);
1316 /* Allocate space to store the string in the inferior, and then copy
1317 LEN bytes from PTR in gdb to that address in the inferior. */
1319 addr
= allocate_space_in_inferior (len
);
1320 write_memory (addr
, (gdb_byte
*) ptr
, len
);
1322 val
= value_at_lazy (stringtype
, addr
);
1327 value_bitstring (char *ptr
, int len
)
1330 struct type
*domain_type
= create_range_type (NULL
,
1333 struct type
*type
= create_set_type ((struct type
*) NULL
,
1335 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1336 val
= allocate_value (type
);
1337 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1341 /* See if we can pass arguments in T2 to a function which takes
1342 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1343 a NULL-terminated vector. If some arguments need coercion of some
1344 sort, then the coerced values are written into T2. Return value is
1345 0 if the arguments could be matched, or the position at which they
1348 STATICP is nonzero if the T1 argument list came from a static
1349 member function. T2 will still include the ``this'' pointer, but
1352 For non-static member functions, we ignore the first argument,
1353 which is the type of the instance variable. This is because we
1354 want to handle calls with objects from derived classes. This is
1355 not entirely correct: we should actually check to make sure that a
1356 requested operation is type secure, shouldn't we? FIXME. */
1359 typecmp (int staticp
, int varargs
, int nargs
,
1360 struct field t1
[], struct value
*t2
[])
1365 internal_error (__FILE__
, __LINE__
,
1366 _("typecmp: no argument list"));
1368 /* Skip ``this'' argument if applicable. T2 will always include
1374 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1377 struct type
*tt1
, *tt2
;
1382 tt1
= check_typedef (t1
[i
].type
);
1383 tt2
= check_typedef (value_type (t2
[i
]));
1385 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1386 /* We should be doing hairy argument matching, as below. */
1387 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1389 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1390 t2
[i
] = value_coerce_array (t2
[i
]);
1392 t2
[i
] = value_ref (t2
[i
]);
1396 /* djb - 20000715 - Until the new type structure is in the
1397 place, and we can attempt things like implicit conversions,
1398 we need to do this so you can take something like a map<const
1399 char *>, and properly access map["hello"], because the
1400 argument to [] will be a reference to a pointer to a char,
1401 and the argument will be a pointer to a char. */
1402 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1403 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1405 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1407 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1408 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1409 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1411 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1413 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1415 /* Array to pointer is a `trivial conversion' according to the
1418 /* We should be doing much hairier argument matching (see
1419 section 13.2 of the ARM), but as a quick kludge, just check
1420 for the same type code. */
1421 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1424 if (varargs
|| t2
[i
] == NULL
)
1429 /* Helper function used by value_struct_elt to recurse through
1430 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1431 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1432 TYPE. If found, return value, else return NULL.
1434 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1435 fields, look for a baseclass named NAME. */
1437 static struct value
*
1438 search_struct_field (char *name
, struct value
*arg1
, int offset
,
1439 struct type
*type
, int looking_for_baseclass
)
1442 int nbases
= TYPE_N_BASECLASSES (type
);
1444 CHECK_TYPEDEF (type
);
1446 if (!looking_for_baseclass
)
1447 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1449 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1451 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1454 if (TYPE_FIELD_STATIC (type
, i
))
1456 v
= value_static_field (type
, i
);
1458 error (_("field %s is nonexistent or has been optimised out"),
1463 v
= value_primitive_field (arg1
, offset
, i
, type
);
1465 error (_("there is no field named %s"), name
);
1471 && (t_field_name
[0] == '\0'
1472 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1473 && (strcmp_iw (t_field_name
, "else") == 0))))
1475 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1476 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1477 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1479 /* Look for a match through the fields of an anonymous
1480 union, or anonymous struct. C++ provides anonymous
1483 In the GNU Chill (now deleted from GDB)
1484 implementation of variant record types, each
1485 <alternative field> has an (anonymous) union type,
1486 each member of the union represents a <variant
1487 alternative>. Each <variant alternative> is
1488 represented as a struct, with a member for each
1492 int new_offset
= offset
;
1494 /* This is pretty gross. In G++, the offset in an
1495 anonymous union is relative to the beginning of the
1496 enclosing struct. In the GNU Chill (now deleted
1497 from GDB) implementation of variant records, the
1498 bitpos is zero in an anonymous union field, so we
1499 have to add the offset of the union here. */
1500 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1501 || (TYPE_NFIELDS (field_type
) > 0
1502 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1503 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1505 v
= search_struct_field (name
, arg1
, new_offset
,
1507 looking_for_baseclass
);
1514 for (i
= 0; i
< nbases
; i
++)
1517 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1518 /* If we are looking for baseclasses, this is what we get when
1519 we hit them. But it could happen that the base part's member
1520 name is not yet filled in. */
1521 int found_baseclass
= (looking_for_baseclass
1522 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1523 && (strcmp_iw (name
,
1524 TYPE_BASECLASS_NAME (type
,
1527 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1530 struct value
*v2
= allocate_value (basetype
);
1532 boffset
= baseclass_offset (type
, i
,
1533 value_contents (arg1
) + offset
,
1534 VALUE_ADDRESS (arg1
)
1535 + value_offset (arg1
) + offset
);
1537 error (_("virtual baseclass botch"));
1539 /* The virtual base class pointer might have been clobbered
1540 by the user program. Make sure that it still points to a
1541 valid memory location. */
1544 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
1546 CORE_ADDR base_addr
;
1549 VALUE_ADDRESS (arg1
) + value_offset (arg1
) + boffset
;
1550 if (target_read_memory (base_addr
,
1551 value_contents_raw (v2
),
1552 TYPE_LENGTH (basetype
)) != 0)
1553 error (_("virtual baseclass botch"));
1554 VALUE_LVAL (v2
) = lval_memory
;
1555 VALUE_ADDRESS (v2
) = base_addr
;
1559 VALUE_LVAL (v2
) = VALUE_LVAL (arg1
);
1560 VALUE_ADDRESS (v2
) = VALUE_ADDRESS (arg1
);
1561 VALUE_FRAME_ID (v2
) = VALUE_FRAME_ID (arg1
);
1562 set_value_offset (v2
, value_offset (arg1
) + boffset
);
1563 if (VALUE_LVAL (arg1
) == lval_memory
&& value_lazy (arg1
))
1564 set_value_lazy (v2
, 1);
1566 memcpy (value_contents_raw (v2
),
1567 value_contents_raw (arg1
) + boffset
,
1568 TYPE_LENGTH (basetype
));
1571 if (found_baseclass
)
1573 v
= search_struct_field (name
, v2
, 0,
1574 TYPE_BASECLASS (type
, i
),
1575 looking_for_baseclass
);
1577 else if (found_baseclass
)
1578 v
= value_primitive_field (arg1
, offset
, i
, type
);
1580 v
= search_struct_field (name
, arg1
,
1581 offset
+ TYPE_BASECLASS_BITPOS (type
,
1583 basetype
, looking_for_baseclass
);
1590 /* Helper function used by value_struct_elt to recurse through
1591 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1592 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1595 If found, return value, else if name matched and args not return
1596 (value) -1, else return NULL. */
1598 static struct value
*
1599 search_struct_method (char *name
, struct value
**arg1p
,
1600 struct value
**args
, int offset
,
1601 int *static_memfuncp
, struct type
*type
)
1605 int name_matched
= 0;
1606 char dem_opname
[64];
1608 CHECK_TYPEDEF (type
);
1609 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1611 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1612 /* FIXME! May need to check for ARM demangling here */
1613 if (strncmp (t_field_name
, "__", 2) == 0 ||
1614 strncmp (t_field_name
, "op", 2) == 0 ||
1615 strncmp (t_field_name
, "type", 4) == 0)
1617 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1618 t_field_name
= dem_opname
;
1619 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1620 t_field_name
= dem_opname
;
1622 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1624 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1625 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1628 check_stub_method_group (type
, i
);
1629 if (j
> 0 && args
== 0)
1630 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name
);
1631 else if (j
== 0 && args
== 0)
1633 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1640 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
1641 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
1642 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
1643 TYPE_FN_FIELD_ARGS (f
, j
), args
))
1645 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1646 return value_virtual_fn_field (arg1p
, f
, j
,
1648 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
1650 *static_memfuncp
= 1;
1651 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
1660 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1664 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1666 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
1667 const gdb_byte
*base_valaddr
;
1669 /* The virtual base class pointer might have been
1670 clobbered by the user program. Make sure that it
1671 still points to a valid memory location. */
1673 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
1675 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
1676 if (target_read_memory (VALUE_ADDRESS (*arg1p
)
1677 + value_offset (*arg1p
) + offset
,
1678 tmp
, TYPE_LENGTH (baseclass
)) != 0)
1679 error (_("virtual baseclass botch"));
1683 base_valaddr
= value_contents (*arg1p
) + offset
;
1685 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
1686 VALUE_ADDRESS (*arg1p
)
1687 + value_offset (*arg1p
) + offset
);
1688 if (base_offset
== -1)
1689 error (_("virtual baseclass botch"));
1693 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1695 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
1696 static_memfuncp
, TYPE_BASECLASS (type
, i
));
1697 if (v
== (struct value
*) - 1)
1703 /* FIXME-bothner: Why is this commented out? Why is it here? */
1704 /* *arg1p = arg1_tmp; */
1709 return (struct value
*) - 1;
1714 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1715 extract the component named NAME from the ultimate target
1716 structure/union and return it as a value with its appropriate type.
1717 ERR is used in the error message if *ARGP's type is wrong.
1719 C++: ARGS is a list of argument types to aid in the selection of
1720 an appropriate method. Also, handle derived types.
1722 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1723 where the truthvalue of whether the function that was resolved was
1724 a static member function or not is stored.
1726 ERR is an error message to be printed in case the field is not
1730 value_struct_elt (struct value
**argp
, struct value
**args
,
1731 char *name
, int *static_memfuncp
, char *err
)
1736 *argp
= coerce_array (*argp
);
1738 t
= check_typedef (value_type (*argp
));
1740 /* Follow pointers until we get to a non-pointer. */
1742 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1744 *argp
= value_ind (*argp
);
1745 /* Don't coerce fn pointer to fn and then back again! */
1746 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
1747 *argp
= coerce_array (*argp
);
1748 t
= check_typedef (value_type (*argp
));
1751 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1752 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1753 error (_("Attempt to extract a component of a value that is not a %s."), err
);
1755 /* Assume it's not, unless we see that it is. */
1756 if (static_memfuncp
)
1757 *static_memfuncp
= 0;
1761 /* if there are no arguments ...do this... */
1763 /* Try as a field first, because if we succeed, there is less
1765 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1769 /* C++: If it was not found as a data field, then try to
1770 return it as a pointer to a method. */
1772 if (destructor_name_p (name
, t
))
1773 error (_("Cannot get value of destructor"));
1775 v
= search_struct_method (name
, argp
, args
, 0,
1776 static_memfuncp
, t
);
1778 if (v
== (struct value
*) - 1)
1779 error (_("Cannot take address of method %s."), name
);
1782 if (TYPE_NFN_FIELDS (t
))
1783 error (_("There is no member or method named %s."), name
);
1785 error (_("There is no member named %s."), name
);
1790 if (destructor_name_p (name
, t
))
1794 /* Destructors are a special case. */
1795 int m_index
, f_index
;
1798 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
1800 v
= value_fn_field (NULL
,
1801 TYPE_FN_FIELDLIST1 (t
, m_index
),
1805 error (_("could not find destructor function named %s."),
1812 error (_("destructor should not have any argument"));
1816 v
= search_struct_method (name
, argp
, args
, 0,
1817 static_memfuncp
, t
);
1819 if (v
== (struct value
*) - 1)
1821 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name
);
1825 /* See if user tried to invoke data as function. If so, hand it
1826 back. If it's not callable (i.e., a pointer to function),
1827 gdb should give an error. */
1828 v
= search_struct_field (name
, *argp
, 0, t
, 0);
1829 /* If we found an ordinary field, then it is not a method call.
1830 So, treat it as if it were a static member function. */
1831 if (v
&& static_memfuncp
)
1832 *static_memfuncp
= 1;
1836 error (_("Structure has no component named %s."), name
);
1840 /* Search through the methods of an object (and its bases) to find a
1841 specified method. Return the pointer to the fn_field list of
1842 overloaded instances.
1844 Helper function for value_find_oload_list.
1845 ARGP is a pointer to a pointer to a value (the object).
1846 METHOD is a string containing the method name.
1847 OFFSET is the offset within the value.
1848 TYPE is the assumed type of the object.
1849 NUM_FNS is the number of overloaded instances.
1850 BASETYPE is set to the actual type of the subobject where the
1852 BOFFSET is the offset of the base subobject where the method is found.
1855 static struct fn_field
*
1856 find_method_list (struct value
**argp
, char *method
,
1857 int offset
, struct type
*type
, int *num_fns
,
1858 struct type
**basetype
, int *boffset
)
1862 CHECK_TYPEDEF (type
);
1866 /* First check in object itself. */
1867 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1869 /* pai: FIXME What about operators and type conversions? */
1870 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1871 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
1873 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1874 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1880 /* Resolve any stub methods. */
1881 check_stub_method_group (type
, i
);
1887 /* Not found in object, check in base subobjects. */
1888 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
1891 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1893 base_offset
= value_offset (*argp
) + offset
;
1894 base_offset
= baseclass_offset (type
, i
,
1895 value_contents (*argp
) + base_offset
,
1896 VALUE_ADDRESS (*argp
) + base_offset
);
1897 if (base_offset
== -1)
1898 error (_("virtual baseclass botch"));
1900 else /* Non-virtual base, simply use bit position from debug
1903 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
1905 f
= find_method_list (argp
, method
, base_offset
+ offset
,
1906 TYPE_BASECLASS (type
, i
), num_fns
,
1914 /* Return the list of overloaded methods of a specified name.
1916 ARGP is a pointer to a pointer to a value (the object).
1917 METHOD is the method name.
1918 OFFSET is the offset within the value contents.
1919 NUM_FNS is the number of overloaded instances.
1920 BASETYPE is set to the type of the base subobject that defines the
1922 BOFFSET is the offset of the base subobject which defines the method.
1926 value_find_oload_method_list (struct value
**argp
, char *method
,
1927 int offset
, int *num_fns
,
1928 struct type
**basetype
, int *boffset
)
1932 t
= check_typedef (value_type (*argp
));
1934 /* Code snarfed from value_struct_elt. */
1935 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
1937 *argp
= value_ind (*argp
);
1938 /* Don't coerce fn pointer to fn and then back again! */
1939 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
1940 *argp
= coerce_array (*argp
);
1941 t
= check_typedef (value_type (*argp
));
1944 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
1945 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
1946 error (_("Attempt to extract a component of a value that is not a struct or union"));
1948 return find_method_list (argp
, method
, 0, t
, num_fns
,
1952 /* Given an array of argument types (ARGTYPES) (which includes an
1953 entry for "this" in the case of C++ methods), the number of
1954 arguments NARGS, the NAME of a function whether it's a method or
1955 not (METHOD), and the degree of laxness (LAX) in conforming to
1956 overload resolution rules in ANSI C++, find the best function that
1957 matches on the argument types according to the overload resolution
1960 In the case of class methods, the parameter OBJ is an object value
1961 in which to search for overloaded methods.
1963 In the case of non-method functions, the parameter FSYM is a symbol
1964 corresponding to one of the overloaded functions.
1966 Return value is an integer: 0 -> good match, 10 -> debugger applied
1967 non-standard coercions, 100 -> incompatible.
1969 If a method is being searched for, VALP will hold the value.
1970 If a non-method is being searched for, SYMP will hold the symbol
1973 If a method is being searched for, and it is a static method,
1974 then STATICP will point to a non-zero value.
1976 Note: This function does *not* check the value of
1977 overload_resolution. Caller must check it to see whether overload
1978 resolution is permitted.
1982 find_overload_match (struct type
**arg_types
, int nargs
,
1983 char *name
, int method
, int lax
,
1984 struct value
**objp
, struct symbol
*fsym
,
1985 struct value
**valp
, struct symbol
**symp
,
1988 struct value
*obj
= (objp
? *objp
: NULL
);
1989 /* Index of best overloaded function. */
1991 /* The measure for the current best match. */
1992 struct badness_vector
*oload_champ_bv
= NULL
;
1993 struct value
*temp
= obj
;
1994 /* For methods, the list of overloaded methods. */
1995 struct fn_field
*fns_ptr
= NULL
;
1996 /* For non-methods, the list of overloaded function symbols. */
1997 struct symbol
**oload_syms
= NULL
;
1998 /* Number of overloaded instances being considered. */
2000 struct type
*basetype
= NULL
;
2004 struct cleanup
*old_cleanups
= NULL
;
2006 const char *obj_type_name
= NULL
;
2007 char *func_name
= NULL
;
2008 enum oload_classification match_quality
;
2010 /* Get the list of overloaded methods or functions. */
2014 obj_type_name
= TYPE_NAME (value_type (obj
));
2015 /* Hack: evaluate_subexp_standard often passes in a pointer
2016 value rather than the object itself, so try again. */
2017 if ((!obj_type_name
|| !*obj_type_name
)
2018 && (TYPE_CODE (value_type (obj
)) == TYPE_CODE_PTR
))
2019 obj_type_name
= TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj
)));
2021 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2023 &basetype
, &boffset
);
2024 if (!fns_ptr
|| !num_fns
)
2025 error (_("Couldn't find method %s%s%s"),
2027 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2029 /* If we are dealing with stub method types, they should have
2030 been resolved by find_method_list via
2031 value_find_oload_method_list above. */
2032 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2033 oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
2035 oload_syms
, &oload_champ_bv
);
2039 const char *qualified_name
= SYMBOL_CPLUS_DEMANGLED_NAME (fsym
);
2041 /* If we have a C++ name, try to extract just the function
2044 func_name
= cp_func_name (qualified_name
);
2046 /* If there was no C++ name, this must be a C-style function.
2047 Just return the same symbol. Do the same if cp_func_name
2048 fails for some reason. */
2049 if (func_name
== NULL
)
2055 old_cleanups
= make_cleanup (xfree
, func_name
);
2056 make_cleanup (xfree
, oload_syms
);
2057 make_cleanup (xfree
, oload_champ_bv
);
2059 oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
2066 /* Check how bad the best match is. */
2069 classify_oload_match (oload_champ_bv
, nargs
,
2070 oload_method_static (method
, fns_ptr
,
2073 if (match_quality
== INCOMPATIBLE
)
2076 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2078 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2081 error (_("Cannot resolve function %s to any overloaded instance"),
2084 else if (match_quality
== NON_STANDARD
)
2087 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2089 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2092 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2098 if (staticp
!= NULL
)
2099 *staticp
= oload_method_static (method
, fns_ptr
, oload_champ
);
2100 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2101 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
,
2104 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
,
2109 *symp
= oload_syms
[oload_champ
];
2114 if (TYPE_CODE (value_type (temp
)) != TYPE_CODE_PTR
2115 && (TYPE_CODE (value_type (*objp
)) == TYPE_CODE_PTR
2116 || TYPE_CODE (value_type (*objp
)) == TYPE_CODE_REF
))
2118 temp
= value_addr (temp
);
2122 if (old_cleanups
!= NULL
)
2123 do_cleanups (old_cleanups
);
2125 switch (match_quality
)
2131 default: /* STANDARD */
2136 /* Find the best overload match, searching for FUNC_NAME in namespaces
2137 contained in QUALIFIED_NAME until it either finds a good match or
2138 runs out of namespaces. It stores the overloaded functions in
2139 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2140 calling function is responsible for freeing *OLOAD_SYMS and
2144 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2145 const char *func_name
,
2146 const char *qualified_name
,
2147 struct symbol
***oload_syms
,
2148 struct badness_vector
**oload_champ_bv
)
2152 find_oload_champ_namespace_loop (arg_types
, nargs
,
2155 oload_syms
, oload_champ_bv
,
2161 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2162 how deep we've looked for namespaces, and the champ is stored in
2163 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2166 It is the caller's responsibility to free *OLOAD_SYMS and
2170 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2171 const char *func_name
,
2172 const char *qualified_name
,
2174 struct symbol
***oload_syms
,
2175 struct badness_vector
**oload_champ_bv
,
2178 int next_namespace_len
= namespace_len
;
2179 int searched_deeper
= 0;
2181 struct cleanup
*old_cleanups
;
2182 int new_oload_champ
;
2183 struct symbol
**new_oload_syms
;
2184 struct badness_vector
*new_oload_champ_bv
;
2185 char *new_namespace
;
2187 if (next_namespace_len
!= 0)
2189 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2190 next_namespace_len
+= 2;
2192 next_namespace_len
+=
2193 cp_find_first_component (qualified_name
+ next_namespace_len
);
2195 /* Initialize these to values that can safely be xfree'd. */
2197 *oload_champ_bv
= NULL
;
2199 /* First, see if we have a deeper namespace we can search in.
2200 If we get a good match there, use it. */
2202 if (qualified_name
[next_namespace_len
] == ':')
2204 searched_deeper
= 1;
2206 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2207 func_name
, qualified_name
,
2209 oload_syms
, oload_champ_bv
,
2216 /* If we reach here, either we're in the deepest namespace or we
2217 didn't find a good match in a deeper namespace. But, in the
2218 latter case, we still have a bad match in a deeper namespace;
2219 note that we might not find any match at all in the current
2220 namespace. (There's always a match in the deepest namespace,
2221 because this overload mechanism only gets called if there's a
2222 function symbol to start off with.) */
2224 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2225 old_cleanups
= make_cleanup (xfree
, *oload_champ_bv
);
2226 new_namespace
= alloca (namespace_len
+ 1);
2227 strncpy (new_namespace
, qualified_name
, namespace_len
);
2228 new_namespace
[namespace_len
] = '\0';
2229 new_oload_syms
= make_symbol_overload_list (func_name
,
2231 while (new_oload_syms
[num_fns
])
2234 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2235 NULL
, new_oload_syms
,
2236 &new_oload_champ_bv
);
2238 /* Case 1: We found a good match. Free earlier matches (if any),
2239 and return it. Case 2: We didn't find a good match, but we're
2240 not the deepest function. Then go with the bad match that the
2241 deeper function found. Case 3: We found a bad match, and we're
2242 the deepest function. Then return what we found, even though
2243 it's a bad match. */
2245 if (new_oload_champ
!= -1
2246 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2248 *oload_syms
= new_oload_syms
;
2249 *oload_champ
= new_oload_champ
;
2250 *oload_champ_bv
= new_oload_champ_bv
;
2251 do_cleanups (old_cleanups
);
2254 else if (searched_deeper
)
2256 xfree (new_oload_syms
);
2257 xfree (new_oload_champ_bv
);
2258 discard_cleanups (old_cleanups
);
2263 gdb_assert (new_oload_champ
!= -1);
2264 *oload_syms
= new_oload_syms
;
2265 *oload_champ
= new_oload_champ
;
2266 *oload_champ_bv
= new_oload_champ_bv
;
2267 discard_cleanups (old_cleanups
);
2272 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2273 the best match from among the overloaded methods or functions
2274 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2275 The number of methods/functions in the list is given by NUM_FNS.
2276 Return the index of the best match; store an indication of the
2277 quality of the match in OLOAD_CHAMP_BV.
2279 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2282 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2283 int num_fns
, struct fn_field
*fns_ptr
,
2284 struct symbol
**oload_syms
,
2285 struct badness_vector
**oload_champ_bv
)
2288 /* A measure of how good an overloaded instance is. */
2289 struct badness_vector
*bv
;
2290 /* Index of best overloaded function. */
2291 int oload_champ
= -1;
2292 /* Current ambiguity state for overload resolution. */
2293 int oload_ambiguous
= 0;
2294 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2296 *oload_champ_bv
= NULL
;
2298 /* Consider each candidate in turn. */
2299 for (ix
= 0; ix
< num_fns
; ix
++)
2302 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2304 struct type
**parm_types
;
2308 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2312 /* If it's not a method, this is the proper place. */
2313 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2316 /* Prepare array of parameter types. */
2317 parm_types
= (struct type
**)
2318 xmalloc (nparms
* (sizeof (struct type
*)));
2319 for (jj
= 0; jj
< nparms
; jj
++)
2320 parm_types
[jj
] = (method
2321 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2322 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2325 /* Compare parameter types to supplied argument types. Skip
2326 THIS for static methods. */
2327 bv
= rank_function (parm_types
, nparms
,
2328 arg_types
+ static_offset
,
2329 nargs
- static_offset
);
2331 if (!*oload_champ_bv
)
2333 *oload_champ_bv
= bv
;
2336 else /* See whether current candidate is better or worse than
2338 switch (compare_badness (bv
, *oload_champ_bv
))
2340 case 0: /* Top two contenders are equally good. */
2341 oload_ambiguous
= 1;
2343 case 1: /* Incomparable top contenders. */
2344 oload_ambiguous
= 2;
2346 case 2: /* New champion, record details. */
2347 *oload_champ_bv
= bv
;
2348 oload_ambiguous
= 0;
2359 fprintf_filtered (gdb_stderr
,
2360 "Overloaded method instance %s, # of parms %d\n",
2361 fns_ptr
[ix
].physname
, nparms
);
2363 fprintf_filtered (gdb_stderr
,
2364 "Overloaded function instance %s # of parms %d\n",
2365 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
2367 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2368 fprintf_filtered (gdb_stderr
,
2369 "...Badness @ %d : %d\n",
2371 fprintf_filtered (gdb_stderr
,
2372 "Overload resolution champion is %d, ambiguous? %d\n",
2373 oload_champ
, oload_ambiguous
);
2380 /* Return 1 if we're looking at a static method, 0 if we're looking at
2381 a non-static method or a function that isn't a method. */
2384 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
2386 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
2392 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2394 static enum oload_classification
2395 classify_oload_match (struct badness_vector
*oload_champ_bv
,
2401 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2403 if (oload_champ_bv
->rank
[ix
] >= 100)
2404 return INCOMPATIBLE
; /* Truly mismatched types. */
2405 else if (oload_champ_bv
->rank
[ix
] >= 10)
2406 return NON_STANDARD
; /* Non-standard type conversions
2410 return STANDARD
; /* Only standard conversions needed. */
2413 /* C++: return 1 is NAME is a legitimate name for the destructor of
2414 type TYPE. If TYPE does not have a destructor, or if NAME is
2415 inappropriate for TYPE, an error is signaled. */
2417 destructor_name_p (const char *name
, const struct type
*type
)
2419 /* Destructors are a special case. */
2423 char *dname
= type_name_no_tag (type
);
2424 char *cp
= strchr (dname
, '<');
2427 /* Do not compare the template part for template classes. */
2429 len
= strlen (dname
);
2432 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
2433 error (_("name of destructor must equal name of class"));
2440 /* Given TYPE, a structure/union,
2441 return 1 if the component named NAME from the ultimate target
2442 structure/union is defined, otherwise, return 0. */
2445 check_field (struct type
*type
, const char *name
)
2449 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2451 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2452 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2456 /* C++: If it was not found as a data field, then try to return it
2457 as a pointer to a method. */
2459 /* Destructors are a special case. */
2460 if (destructor_name_p (name
, type
))
2462 int m_index
, f_index
;
2464 return get_destructor_fn_field (type
, &m_index
, &f_index
);
2467 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2469 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2473 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2474 if (check_field (TYPE_BASECLASS (type
, i
), name
))
2480 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2481 return the appropriate member (or the address of the member, if
2482 WANT_ADDRESS). This function is used to resolve user expressions
2483 of the form "DOMAIN::NAME". For more details on what happens, see
2484 the comment before value_struct_elt_for_reference. */
2487 value_aggregate_elt (struct type
*curtype
,
2488 char *name
, int want_address
,
2491 switch (TYPE_CODE (curtype
))
2493 case TYPE_CODE_STRUCT
:
2494 case TYPE_CODE_UNION
:
2495 return value_struct_elt_for_reference (curtype
, 0, curtype
,
2497 want_address
, noside
);
2498 case TYPE_CODE_NAMESPACE
:
2499 return value_namespace_elt (curtype
, name
,
2500 want_address
, noside
);
2502 internal_error (__FILE__
, __LINE__
,
2503 _("non-aggregate type in value_aggregate_elt"));
2507 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2508 return the address of this member as a "pointer to member" type.
2509 If INTYPE is non-null, then it will be the type of the member we
2510 are looking for. This will help us resolve "pointers to member
2511 functions". This function is used to resolve user expressions of
2512 the form "DOMAIN::NAME". */
2514 static struct value
*
2515 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2516 struct type
*curtype
, char *name
,
2517 struct type
*intype
,
2521 struct type
*t
= curtype
;
2523 struct value
*v
, *result
;
2525 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2526 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2527 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2529 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2531 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2533 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2535 if (TYPE_FIELD_STATIC (t
, i
))
2537 v
= value_static_field (t
, i
);
2539 error (_("static field %s has been optimized out"),
2545 if (TYPE_FIELD_PACKED (t
, i
))
2546 error (_("pointers to bitfield members not allowed"));
2549 return value_from_longest
2550 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
2551 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2552 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2553 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
2555 error (_("Cannot reference non-static field \"%s\""), name
);
2559 /* C++: If it was not found as a data field, then try to return it
2560 as a pointer to a method. */
2562 /* Destructors are a special case. */
2563 if (destructor_name_p (name
, t
))
2565 error (_("member pointers to destructors not implemented yet"));
2568 /* Perform all necessary dereferencing. */
2569 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2570 intype
= TYPE_TARGET_TYPE (intype
);
2572 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2574 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2575 char dem_opname
[64];
2577 if (strncmp (t_field_name
, "__", 2) == 0
2578 || strncmp (t_field_name
, "op", 2) == 0
2579 || strncmp (t_field_name
, "type", 4) == 0)
2581 if (cplus_demangle_opname (t_field_name
,
2582 dem_opname
, DMGL_ANSI
))
2583 t_field_name
= dem_opname
;
2584 else if (cplus_demangle_opname (t_field_name
,
2586 t_field_name
= dem_opname
;
2588 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2590 int j
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2591 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2593 check_stub_method_group (t
, i
);
2595 if (intype
== 0 && j
> 1)
2596 error (_("non-unique member `%s' requires type instantiation"), name
);
2600 if (TYPE_FN_FIELD_TYPE (f
, j
) == intype
)
2603 error (_("no member function matches that type instantiation"));
2608 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
2611 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2617 return value_addr (read_var_value (s
, 0));
2619 return read_var_value (s
, 0);
2622 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2626 result
= allocate_value
2627 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
2628 cplus_make_method_ptr (value_contents_writeable (result
),
2629 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
2631 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2632 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
2634 error (_("Cannot reference virtual member function \"%s\""),
2640 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
2645 v
= read_var_value (s
, 0);
2650 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
2651 cplus_make_method_ptr (value_contents_writeable (result
),
2652 VALUE_ADDRESS (v
), 0);
2658 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
2663 if (BASETYPE_VIA_VIRTUAL (t
, i
))
2666 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
2667 v
= value_struct_elt_for_reference (domain
,
2668 offset
+ base_offset
,
2669 TYPE_BASECLASS (t
, i
),
2671 want_address
, noside
);
2676 /* As a last chance, pretend that CURTYPE is a namespace, and look
2677 it up that way; this (frequently) works for types nested inside
2680 return value_maybe_namespace_elt (curtype
, name
,
2681 want_address
, noside
);
2684 /* C++: Return the member NAME of the namespace given by the type
2687 static struct value
*
2688 value_namespace_elt (const struct type
*curtype
,
2689 char *name
, int want_address
,
2692 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
2697 error (_("No symbol \"%s\" in namespace \"%s\"."),
2698 name
, TYPE_TAG_NAME (curtype
));
2703 /* A helper function used by value_namespace_elt and
2704 value_struct_elt_for_reference. It looks up NAME inside the
2705 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
2706 is a class and NAME refers to a type in CURTYPE itself (as opposed
2707 to, say, some base class of CURTYPE). */
2709 static struct value
*
2710 value_maybe_namespace_elt (const struct type
*curtype
,
2711 char *name
, int want_address
,
2714 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
2716 struct value
*result
;
2718 sym
= cp_lookup_symbol_namespace (namespace_name
, name
, NULL
,
2719 get_selected_block (0),
2724 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
2725 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
2726 result
= allocate_value (SYMBOL_TYPE (sym
));
2728 result
= value_of_variable (sym
, get_selected_block (0));
2730 if (result
&& want_address
)
2731 result
= value_addr (result
);
2736 /* Given a pointer value V, find the real (RTTI) type of the object it
2739 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
2740 and refer to the values computed for the object pointed to. */
2743 value_rtti_target_type (struct value
*v
, int *full
,
2744 int *top
, int *using_enc
)
2746 struct value
*target
;
2748 target
= value_ind (v
);
2750 return value_rtti_type (target
, full
, top
, using_enc
);
2753 /* Given a value pointed to by ARGP, check its real run-time type, and
2754 if that is different from the enclosing type, create a new value
2755 using the real run-time type as the enclosing type (and of the same
2756 type as ARGP) and return it, with the embedded offset adjusted to
2757 be the correct offset to the enclosed object. RTYPE is the type,
2758 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
2759 by value_rtti_type(). If these are available, they can be supplied
2760 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
2761 NULL if they're not available. */
2764 value_full_object (struct value
*argp
,
2766 int xfull
, int xtop
,
2769 struct type
*real_type
;
2773 struct value
*new_val
;
2780 using_enc
= xusing_enc
;
2783 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
2785 /* If no RTTI data, or if object is already complete, do nothing. */
2786 if (!real_type
|| real_type
== value_enclosing_type (argp
))
2789 /* If we have the full object, but for some reason the enclosing
2790 type is wrong, set it. */
2791 /* pai: FIXME -- sounds iffy */
2794 argp
= value_change_enclosing_type (argp
, real_type
);
2798 /* Check if object is in memory */
2799 if (VALUE_LVAL (argp
) != lval_memory
)
2801 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
2802 TYPE_NAME (real_type
));
2807 /* All other cases -- retrieve the complete object. */
2808 /* Go back by the computed top_offset from the beginning of the
2809 object, adjusting for the embedded offset of argp if that's what
2810 value_rtti_type used for its computation. */
2811 new_val
= value_at_lazy (real_type
, VALUE_ADDRESS (argp
) - top
+
2812 (using_enc
? 0 : value_embedded_offset (argp
)));
2813 deprecated_set_value_type (new_val
, value_type (argp
));
2814 set_value_embedded_offset (new_val
, (using_enc
2815 ? top
+ value_embedded_offset (argp
)
2821 /* Return the value of the local variable, if one exists.
2822 Flag COMPLAIN signals an error if the request is made in an
2823 inappropriate context. */
2826 value_of_local (const char *name
, int complain
)
2828 struct symbol
*func
, *sym
;
2831 struct frame_info
*frame
;
2834 frame
= get_selected_frame (_("no frame selected"));
2837 frame
= deprecated_safe_get_selected_frame ();
2842 func
= get_frame_function (frame
);
2846 error (_("no `%s' in nameless context"), name
);
2851 b
= SYMBOL_BLOCK_VALUE (func
);
2852 if (dict_empty (BLOCK_DICT (b
)))
2855 error (_("no args, no `%s'"), name
);
2860 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2861 symbol instead of the LOC_ARG one (if both exist). */
2862 sym
= lookup_block_symbol (b
, name
, NULL
, VAR_DOMAIN
);
2866 error (_("current stack frame does not contain a variable named `%s'"),
2872 ret
= read_var_value (sym
, frame
);
2873 if (ret
== 0 && complain
)
2874 error (_("`%s' argument unreadable"), name
);
2878 /* C++/Objective-C: return the value of the class instance variable,
2879 if one exists. Flag COMPLAIN signals an error if the request is
2880 made in an inappropriate context. */
2883 value_of_this (int complain
)
2885 if (!current_language
->la_name_of_this
)
2887 return value_of_local (current_language
->la_name_of_this
, complain
);
2890 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
2891 elements long, starting at LOWBOUND. The result has the same lower
2892 bound as the original ARRAY. */
2895 value_slice (struct value
*array
, int lowbound
, int length
)
2897 struct type
*slice_range_type
, *slice_type
, *range_type
;
2898 LONGEST lowerbound
, upperbound
;
2899 struct value
*slice
;
2900 struct type
*array_type
;
2902 array_type
= check_typedef (value_type (array
));
2903 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
2904 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
2905 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
2906 error (_("cannot take slice of non-array"));
2908 range_type
= TYPE_INDEX_TYPE (array_type
);
2909 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
2910 error (_("slice from bad array or bitstring"));
2912 if (lowbound
< lowerbound
|| length
< 0
2913 || lowbound
+ length
- 1 > upperbound
)
2914 error (_("slice out of range"));
2916 /* FIXME-type-allocation: need a way to free this type when we are
2918 slice_range_type
= create_range_type ((struct type
*) NULL
,
2919 TYPE_TARGET_TYPE (range_type
),
2921 lowbound
+ length
- 1);
2922 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
2926 slice_type
= create_set_type ((struct type
*) NULL
,
2928 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
2929 slice
= value_zero (slice_type
, not_lval
);
2931 for (i
= 0; i
< length
; i
++)
2933 int element
= value_bit_index (array_type
,
2934 value_contents (array
),
2937 error (_("internal error accessing bitstring"));
2938 else if (element
> 0)
2940 int j
= i
% TARGET_CHAR_BIT
;
2941 if (gdbarch_bits_big_endian (current_gdbarch
))
2942 j
= TARGET_CHAR_BIT
- 1 - j
;
2943 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
2946 /* We should set the address, bitssize, and bitspos, so the
2947 slice can be used on the LHS, but that may require extensions
2948 to value_assign. For now, just leave as a non_lval.
2953 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
2955 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
2957 slice_type
= create_array_type ((struct type
*) NULL
,
2960 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
2962 slice
= allocate_value (slice_type
);
2963 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
2964 set_value_lazy (slice
, 1);
2966 memcpy (value_contents_writeable (slice
),
2967 value_contents (array
) + offset
,
2968 TYPE_LENGTH (slice_type
));
2970 if (VALUE_LVAL (array
) == lval_internalvar
)
2971 VALUE_LVAL (slice
) = lval_internalvar_component
;
2973 VALUE_LVAL (slice
) = VALUE_LVAL (array
);
2975 VALUE_ADDRESS (slice
) = VALUE_ADDRESS (array
);
2976 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
2977 set_value_offset (slice
, value_offset (array
) + offset
);
2982 /* Create a value for a FORTRAN complex number. Currently most of the
2983 time values are coerced to COMPLEX*16 (i.e. a complex number
2984 composed of 2 doubles. This really should be a smarter routine
2985 that figures out precision inteligently as opposed to assuming
2986 doubles. FIXME: fmb */
2989 value_literal_complex (struct value
*arg1
,
2994 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
2996 val
= allocate_value (type
);
2997 arg1
= value_cast (real_type
, arg1
);
2998 arg2
= value_cast (real_type
, arg2
);
3000 memcpy (value_contents_raw (val
),
3001 value_contents (arg1
), TYPE_LENGTH (real_type
));
3002 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3003 value_contents (arg2
), TYPE_LENGTH (real_type
));
3007 /* Cast a value into the appropriate complex data type. */
3009 static struct value
*
3010 cast_into_complex (struct type
*type
, struct value
*val
)
3012 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3014 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3016 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3017 struct value
*re_val
= allocate_value (val_real_type
);
3018 struct value
*im_val
= allocate_value (val_real_type
);
3020 memcpy (value_contents_raw (re_val
),
3021 value_contents (val
), TYPE_LENGTH (val_real_type
));
3022 memcpy (value_contents_raw (im_val
),
3023 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3024 TYPE_LENGTH (val_real_type
));
3026 return value_literal_complex (re_val
, im_val
, type
);
3028 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3029 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3030 return value_literal_complex (val
,
3031 value_zero (real_type
, not_lval
),
3034 error (_("cannot cast non-number to complex"));
3038 _initialize_valops (void)
3040 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3041 &overload_resolution
, _("\
3042 Set overload resolution in evaluating C++ functions."), _("\
3043 Show overload resolution in evaluating C++ functions."),
3045 show_overload_resolution
,
3046 &setlist
, &showlist
);
3047 overload_resolution
= 1;