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, 2009, 2010, 2011 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"
41 #include "tracepoint.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
49 #include "exceptions.h"
51 extern int overload_debug
;
52 /* Local functions. */
54 static int typecmp (int staticp
, int varargs
, int nargs
,
55 struct field t1
[], struct value
*t2
[]);
57 static struct value
*search_struct_field (const char *, struct value
*,
58 int, struct type
*, int);
60 static struct value
*search_struct_method (const char *, struct value
**,
62 int, int *, struct type
*);
64 static int find_oload_champ_namespace (struct type
**, int,
65 const char *, const char *,
67 struct badness_vector
**,
71 int find_oload_champ_namespace_loop (struct type
**, int,
72 const char *, const char *,
73 int, struct symbol
***,
74 struct badness_vector
**, int *,
77 static int find_oload_champ (struct type
**, int, int, int,
78 struct fn_field
*, struct symbol
**,
79 struct badness_vector
**);
81 static int oload_method_static (int, struct fn_field
*, int);
83 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
86 oload_classification
classify_oload_match (struct badness_vector
*,
89 static struct value
*value_struct_elt_for_reference (struct type
*,
95 static struct value
*value_namespace_elt (const struct type
*,
96 char *, int , enum noside
);
98 static struct value
*value_maybe_namespace_elt (const struct type
*,
102 static CORE_ADDR
allocate_space_in_inferior (int);
104 static struct value
*cast_into_complex (struct type
*, struct value
*);
106 static struct fn_field
*find_method_list (struct value
**, const char *,
107 int, struct type
*, int *,
108 struct type
**, int *);
110 void _initialize_valops (void);
113 /* Flag for whether we want to abandon failed expression evals by
116 static int auto_abandon
= 0;
119 int overload_resolution
= 0;
121 show_overload_resolution (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
,
125 fprintf_filtered (file
, _("Overload resolution in evaluating "
126 "C++ functions is %s.\n"),
130 /* Find the address of function name NAME in the inferior. If OBJF_P
131 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
135 find_function_in_inferior (const char *name
, struct objfile
**objf_p
)
139 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
142 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
144 error (_("\"%s\" exists in this program but is not a function."),
149 *objf_p
= SYMBOL_SYMTAB (sym
)->objfile
;
151 return value_of_variable (sym
, NULL
);
155 struct minimal_symbol
*msymbol
=
156 lookup_minimal_symbol (name
, NULL
, NULL
);
160 struct objfile
*objfile
= msymbol_objfile (msymbol
);
161 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
165 type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_char
);
166 type
= lookup_function_type (type
);
167 type
= lookup_pointer_type (type
);
168 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
173 return value_from_pointer (type
, maddr
);
177 if (!target_has_execution
)
178 error (_("evaluation of this expression "
179 "requires the target program to be active"));
181 error (_("evaluation of this expression requires the "
182 "program to have a function \"%s\"."),
188 /* Allocate NBYTES of space in the inferior using the inferior's
189 malloc and return a value that is a pointer to the allocated
193 value_allocate_space_in_inferior (int len
)
195 struct objfile
*objf
;
196 struct value
*val
= find_function_in_inferior ("malloc", &objf
);
197 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
198 struct value
*blocklen
;
200 blocklen
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, len
);
201 val
= call_function_by_hand (val
, 1, &blocklen
);
202 if (value_logical_not (val
))
204 if (!target_has_execution
)
205 error (_("No memory available to program now: "
206 "you need to start the target first"));
208 error (_("No memory available to program: call to malloc failed"));
214 allocate_space_in_inferior (int len
)
216 return value_as_long (value_allocate_space_in_inferior (len
));
219 /* Cast struct value VAL to type TYPE and return as a value.
220 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
221 for this to work. Typedef to one of the codes is permitted.
222 Returns NULL if the cast is neither an upcast nor a downcast. */
224 static struct value
*
225 value_cast_structs (struct type
*type
, struct value
*v2
)
231 gdb_assert (type
!= NULL
&& v2
!= NULL
);
233 t1
= check_typedef (type
);
234 t2
= check_typedef (value_type (v2
));
236 /* Check preconditions. */
237 gdb_assert ((TYPE_CODE (t1
) == TYPE_CODE_STRUCT
238 || TYPE_CODE (t1
) == TYPE_CODE_UNION
)
239 && !!"Precondition is that type is of STRUCT or UNION kind.");
240 gdb_assert ((TYPE_CODE (t2
) == TYPE_CODE_STRUCT
241 || TYPE_CODE (t2
) == TYPE_CODE_UNION
)
242 && !!"Precondition is that value is of STRUCT or UNION kind");
244 if (TYPE_NAME (t1
) != NULL
245 && TYPE_NAME (t2
) != NULL
246 && !strcmp (TYPE_NAME (t1
), TYPE_NAME (t2
)))
249 /* Upcasting: look in the type of the source to see if it contains the
250 type of the target as a superclass. If so, we'll need to
251 offset the pointer rather than just change its type. */
252 if (TYPE_NAME (t1
) != NULL
)
254 v
= search_struct_field (type_name_no_tag (t1
),
260 /* Downcasting: look in the type of the target to see if it contains the
261 type of the source as a superclass. If so, we'll need to
262 offset the pointer rather than just change its type. */
263 if (TYPE_NAME (t2
) != NULL
)
265 /* Try downcasting using the run-time type of the value. */
266 int full
, top
, using_enc
;
267 struct type
*real_type
;
269 real_type
= value_rtti_type (v2
, &full
, &top
, &using_enc
);
272 v
= value_full_object (v2
, real_type
, full
, top
, using_enc
);
273 v
= value_at_lazy (real_type
, value_address (v
));
275 /* We might be trying to cast to the outermost enclosing
276 type, in which case search_struct_field won't work. */
277 if (TYPE_NAME (real_type
) != NULL
278 && !strcmp (TYPE_NAME (real_type
), TYPE_NAME (t1
)))
281 v
= search_struct_field (type_name_no_tag (t2
), v
, 0, real_type
, 1);
286 /* Try downcasting using information from the destination type
287 T2. This wouldn't work properly for classes with virtual
288 bases, but those were handled above. */
289 v
= search_struct_field (type_name_no_tag (t2
),
290 value_zero (t1
, not_lval
), 0, t1
, 1);
293 /* Downcasting is possible (t1 is superclass of v2). */
294 CORE_ADDR addr2
= value_address (v2
);
296 addr2
-= value_address (v
) + value_embedded_offset (v
);
297 return value_at (type
, addr2
);
304 /* Cast one pointer or reference type to another. Both TYPE and
305 the type of ARG2 should be pointer types, or else both should be
306 reference types. Returns the new pointer or reference. */
309 value_cast_pointers (struct type
*type
, struct value
*arg2
)
311 struct type
*type1
= check_typedef (type
);
312 struct type
*type2
= check_typedef (value_type (arg2
));
313 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type1
));
314 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
316 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
317 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
318 && !value_logical_not (arg2
))
322 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
323 v2
= coerce_ref (arg2
);
325 v2
= value_ind (arg2
);
326 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
)))
327 == TYPE_CODE_STRUCT
&& !!"Why did coercion fail?");
328 v2
= value_cast_structs (t1
, v2
);
329 /* At this point we have what we can have, un-dereference if needed. */
332 struct value
*v
= value_addr (v2
);
334 deprecated_set_value_type (v
, type
);
339 /* No superclass found, just change the pointer type. */
340 arg2
= value_copy (arg2
);
341 deprecated_set_value_type (arg2
, type
);
342 set_value_enclosing_type (arg2
, type
);
343 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
347 /* Cast value ARG2 to type TYPE and return as a value.
348 More general than a C cast: accepts any two types of the same length,
349 and if ARG2 is an lvalue it can be cast into anything at all. */
350 /* In C++, casts may change pointer or object representations. */
353 value_cast (struct type
*type
, struct value
*arg2
)
355 enum type_code code1
;
356 enum type_code code2
;
360 int convert_to_boolean
= 0;
362 if (value_type (arg2
) == type
)
365 code1
= TYPE_CODE (check_typedef (type
));
367 /* Check if we are casting struct reference to struct reference. */
368 if (code1
== TYPE_CODE_REF
)
370 /* We dereference type; then we recurse and finally
371 we generate value of the given reference. Nothing wrong with
373 struct type
*t1
= check_typedef (type
);
374 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
375 struct value
*val
= value_cast (dereftype
, arg2
);
377 return value_ref (val
);
380 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
382 if (code2
== TYPE_CODE_REF
)
383 /* We deref the value and then do the cast. */
384 return value_cast (type
, coerce_ref (arg2
));
386 CHECK_TYPEDEF (type
);
387 code1
= TYPE_CODE (type
);
388 arg2
= coerce_ref (arg2
);
389 type2
= check_typedef (value_type (arg2
));
391 /* You can't cast to a reference type. See value_cast_pointers
393 gdb_assert (code1
!= TYPE_CODE_REF
);
395 /* A cast to an undetermined-length array_type, such as
396 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
397 where N is sizeof(OBJECT)/sizeof(TYPE). */
398 if (code1
== TYPE_CODE_ARRAY
)
400 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
401 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
403 if (element_length
> 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
405 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
406 int val_length
= TYPE_LENGTH (type2
);
407 LONGEST low_bound
, high_bound
, new_length
;
409 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
410 low_bound
= 0, high_bound
= 0;
411 new_length
= val_length
/ element_length
;
412 if (val_length
% element_length
!= 0)
413 warning (_("array element type size does not "
414 "divide object size in cast"));
415 /* FIXME-type-allocation: need a way to free this type when
416 we are done with it. */
417 range_type
= create_range_type ((struct type
*) NULL
,
418 TYPE_TARGET_TYPE (range_type
),
420 new_length
+ low_bound
- 1);
421 deprecated_set_value_type (arg2
,
422 create_array_type ((struct type
*) NULL
,
429 if (current_language
->c_style_arrays
430 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
431 && !TYPE_VECTOR (type2
))
432 arg2
= value_coerce_array (arg2
);
434 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
435 arg2
= value_coerce_function (arg2
);
437 type2
= check_typedef (value_type (arg2
));
438 code2
= TYPE_CODE (type2
);
440 if (code1
== TYPE_CODE_COMPLEX
)
441 return cast_into_complex (type
, arg2
);
442 if (code1
== TYPE_CODE_BOOL
)
444 code1
= TYPE_CODE_INT
;
445 convert_to_boolean
= 1;
447 if (code1
== TYPE_CODE_CHAR
)
448 code1
= TYPE_CODE_INT
;
449 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
450 code2
= TYPE_CODE_INT
;
452 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
453 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
454 || code2
== TYPE_CODE_RANGE
);
456 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
457 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
458 && TYPE_NAME (type
) != 0)
460 struct value
*v
= value_cast_structs (type
, arg2
);
466 if (code1
== TYPE_CODE_FLT
&& scalar
)
467 return value_from_double (type
, value_as_double (arg2
));
468 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
470 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
471 int dec_len
= TYPE_LENGTH (type
);
474 if (code2
== TYPE_CODE_FLT
)
475 decimal_from_floating (arg2
, dec
, dec_len
, byte_order
);
476 else if (code2
== TYPE_CODE_DECFLOAT
)
477 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
478 byte_order
, dec
, dec_len
, byte_order
);
480 /* The only option left is an integral type. */
481 decimal_from_integral (arg2
, dec
, dec_len
, byte_order
);
483 return value_from_decfloat (type
, dec
);
485 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
486 || code1
== TYPE_CODE_RANGE
)
487 && (scalar
|| code2
== TYPE_CODE_PTR
488 || code2
== TYPE_CODE_MEMBERPTR
))
492 /* When we cast pointers to integers, we mustn't use
493 gdbarch_pointer_to_address to find the address the pointer
494 represents, as value_as_long would. GDB should evaluate
495 expressions just as the compiler would --- and the compiler
496 sees a cast as a simple reinterpretation of the pointer's
498 if (code2
== TYPE_CODE_PTR
)
499 longest
= extract_unsigned_integer
500 (value_contents (arg2
), TYPE_LENGTH (type2
),
501 gdbarch_byte_order (get_type_arch (type2
)));
503 longest
= value_as_long (arg2
);
504 return value_from_longest (type
, convert_to_boolean
?
505 (LONGEST
) (longest
? 1 : 0) : longest
);
507 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
508 || code2
== TYPE_CODE_ENUM
509 || code2
== TYPE_CODE_RANGE
))
511 /* TYPE_LENGTH (type) is the length of a pointer, but we really
512 want the length of an address! -- we are really dealing with
513 addresses (i.e., gdb representations) not pointers (i.e.,
514 target representations) here.
516 This allows things like "print *(int *)0x01000234" to work
517 without printing a misleading message -- which would
518 otherwise occur when dealing with a target having two byte
519 pointers and four byte addresses. */
521 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
522 LONGEST longest
= value_as_long (arg2
);
524 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
526 if (longest
>= ((LONGEST
) 1 << addr_bit
)
527 || longest
<= -((LONGEST
) 1 << addr_bit
))
528 warning (_("value truncated"));
530 return value_from_longest (type
, longest
);
532 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
533 && value_as_long (arg2
) == 0)
535 struct value
*result
= allocate_value (type
);
537 cplus_make_method_ptr (type
, value_contents_writeable (result
), 0, 0);
540 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
541 && value_as_long (arg2
) == 0)
543 /* The Itanium C++ ABI represents NULL pointers to members as
544 minus one, instead of biasing the normal case. */
545 return value_from_longest (type
, -1);
547 else if (code1
== TYPE_CODE_ARRAY
&& TYPE_VECTOR (type
) && scalar
)
549 /* Widen the scalar to a vector. */
552 LONGEST low_bound
, high_bound
;
555 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
556 error (_("Could not determine the vector bounds"));
558 eltype
= check_typedef (TYPE_TARGET_TYPE (type
));
559 arg2
= value_cast (eltype
, arg2
);
560 val
= allocate_value (type
);
562 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
564 /* Duplicate the contents of arg2 into the destination vector. */
565 memcpy (value_contents_writeable (val
) + (i
* TYPE_LENGTH (eltype
)),
566 value_contents_all (arg2
), TYPE_LENGTH (eltype
));
570 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
572 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
573 return value_cast_pointers (type
, arg2
);
575 arg2
= value_copy (arg2
);
576 deprecated_set_value_type (arg2
, type
);
577 set_value_enclosing_type (arg2
, type
);
578 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
581 else if (VALUE_LVAL (arg2
) == lval_memory
)
582 return value_at_lazy (type
, value_address (arg2
));
583 else if (code1
== TYPE_CODE_VOID
)
585 return value_zero (type
, not_lval
);
589 error (_("Invalid cast."));
594 /* The C++ reinterpret_cast operator. */
597 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
599 struct value
*result
;
600 struct type
*real_type
= check_typedef (type
);
601 struct type
*arg_type
, *dest_type
;
603 enum type_code dest_code
, arg_code
;
605 /* Do reference, function, and array conversion. */
606 arg
= coerce_array (arg
);
608 /* Attempt to preserve the type the user asked for. */
611 /* If we are casting to a reference type, transform
612 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
613 if (TYPE_CODE (real_type
) == TYPE_CODE_REF
)
616 arg
= value_addr (arg
);
617 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
618 real_type
= lookup_pointer_type (real_type
);
621 arg_type
= value_type (arg
);
623 dest_code
= TYPE_CODE (real_type
);
624 arg_code
= TYPE_CODE (arg_type
);
626 /* We can convert pointer types, or any pointer type to int, or int
628 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
629 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
630 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
631 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
632 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
633 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
634 || (dest_code
== arg_code
635 && (dest_code
== TYPE_CODE_PTR
636 || dest_code
== TYPE_CODE_METHODPTR
637 || dest_code
== TYPE_CODE_MEMBERPTR
)))
638 result
= value_cast (dest_type
, arg
);
640 error (_("Invalid reinterpret_cast"));
643 result
= value_cast (type
, value_ref (value_ind (result
)));
648 /* A helper for value_dynamic_cast. This implements the first of two
649 runtime checks: we iterate over all the base classes of the value's
650 class which are equal to the desired class; if only one of these
651 holds the value, then it is the answer. */
654 dynamic_cast_check_1 (struct type
*desired_type
,
655 const bfd_byte
*contents
,
657 struct type
*search_type
,
659 struct type
*arg_type
,
660 struct value
**result
)
662 int i
, result_count
= 0;
664 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
666 int offset
= baseclass_offset (search_type
, i
, contents
, address
);
669 error (_("virtual baseclass botch"));
670 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
672 if (address
+ offset
>= arg_addr
673 && address
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
677 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
682 result_count
+= dynamic_cast_check_1 (desired_type
,
685 TYPE_BASECLASS (search_type
, i
),
694 /* A helper for value_dynamic_cast. This implements the second of two
695 runtime checks: we look for a unique public sibling class of the
696 argument's declared class. */
699 dynamic_cast_check_2 (struct type
*desired_type
,
700 const bfd_byte
*contents
,
702 struct type
*search_type
,
703 struct value
**result
)
705 int i
, result_count
= 0;
707 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
711 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
714 offset
= baseclass_offset (search_type
, i
, contents
, address
);
716 error (_("virtual baseclass botch"));
717 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
721 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
725 result_count
+= dynamic_cast_check_2 (desired_type
,
728 TYPE_BASECLASS (search_type
, i
),
735 /* The C++ dynamic_cast operator. */
738 value_dynamic_cast (struct type
*type
, struct value
*arg
)
740 int full
, top
, using_enc
;
741 struct type
*resolved_type
= check_typedef (type
);
742 struct type
*arg_type
= check_typedef (value_type (arg
));
743 struct type
*class_type
, *rtti_type
;
744 struct value
*result
, *tem
, *original_arg
= arg
;
746 int is_ref
= TYPE_CODE (resolved_type
) == TYPE_CODE_REF
;
748 if (TYPE_CODE (resolved_type
) != TYPE_CODE_PTR
749 && TYPE_CODE (resolved_type
) != TYPE_CODE_REF
)
750 error (_("Argument to dynamic_cast must be a pointer or reference type"));
751 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_VOID
752 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_CLASS
)
753 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
755 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
756 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
758 if (TYPE_CODE (arg_type
) != TYPE_CODE_PTR
759 && ! (TYPE_CODE (arg_type
) == TYPE_CODE_INT
760 && value_as_long (arg
) == 0))
761 error (_("Argument to dynamic_cast does not have pointer type"));
762 if (TYPE_CODE (arg_type
) == TYPE_CODE_PTR
)
764 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
765 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
766 error (_("Argument to dynamic_cast does "
767 "not have pointer to class type"));
770 /* Handle NULL pointers. */
771 if (value_as_long (arg
) == 0)
772 return value_zero (type
, not_lval
);
774 arg
= value_ind (arg
);
778 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
779 error (_("Argument to dynamic_cast does not have class type"));
782 /* If the classes are the same, just return the argument. */
783 if (class_types_same_p (class_type
, arg_type
))
784 return value_cast (type
, arg
);
786 /* If the target type is a unique base class of the argument's
787 declared type, just cast it. */
788 if (is_ancestor (class_type
, arg_type
))
790 if (is_unique_ancestor (class_type
, arg
))
791 return value_cast (type
, original_arg
);
792 error (_("Ambiguous dynamic_cast"));
795 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
797 error (_("Couldn't determine value's most derived type for dynamic_cast"));
799 /* Compute the most derived object's address. */
800 addr
= value_address (arg
);
808 addr
+= top
+ value_embedded_offset (arg
);
810 /* dynamic_cast<void *> means to return a pointer to the
811 most-derived object. */
812 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
813 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) == TYPE_CODE_VOID
)
814 return value_at_lazy (type
, addr
);
816 tem
= value_at (type
, addr
);
818 /* The first dynamic check specified in 5.2.7. */
819 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
821 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
824 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
825 value_contents (tem
), value_address (tem
),
829 return value_cast (type
,
830 is_ref
? value_ref (result
) : value_addr (result
));
833 /* The second dynamic check specified in 5.2.7. */
835 if (is_public_ancestor (arg_type
, rtti_type
)
836 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
837 value_contents (tem
), value_address (tem
),
838 rtti_type
, &result
) == 1)
839 return value_cast (type
,
840 is_ref
? value_ref (result
) : value_addr (result
));
842 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
843 return value_zero (type
, not_lval
);
845 error (_("dynamic_cast failed"));
848 /* Create a value of type TYPE that is zero, and return it. */
851 value_zero (struct type
*type
, enum lval_type lv
)
853 struct value
*val
= allocate_value (type
);
855 VALUE_LVAL (val
) = lv
;
859 /* Create a value of numeric type TYPE that is one, and return it. */
862 value_one (struct type
*type
, enum lval_type lv
)
864 struct type
*type1
= check_typedef (type
);
867 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
869 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
872 decimal_from_string (v
, TYPE_LENGTH (type
), byte_order
, "1");
873 val
= value_from_decfloat (type
, v
);
875 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
877 val
= value_from_double (type
, (DOUBLEST
) 1);
879 else if (is_integral_type (type1
))
881 val
= value_from_longest (type
, (LONGEST
) 1);
883 else if (TYPE_CODE (type1
) == TYPE_CODE_ARRAY
&& TYPE_VECTOR (type1
))
885 struct type
*eltype
= check_typedef (TYPE_TARGET_TYPE (type1
));
887 LONGEST low_bound
, high_bound
;
890 if (!get_array_bounds (type1
, &low_bound
, &high_bound
))
891 error (_("Could not determine the vector bounds"));
893 val
= allocate_value (type
);
894 for (i
= 0; i
< high_bound
- low_bound
+ 1; i
++)
896 tmp
= value_one (eltype
, lv
);
897 memcpy (value_contents_writeable (val
) + i
* TYPE_LENGTH (eltype
),
898 value_contents_all (tmp
), TYPE_LENGTH (eltype
));
903 error (_("Not a numeric type."));
906 VALUE_LVAL (val
) = lv
;
910 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
912 static struct value
*
913 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
917 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
918 error (_("Attempt to dereference a generic pointer."));
920 val
= value_from_contents_and_address (type
, NULL
, addr
);
923 value_fetch_lazy (val
);
928 /* Return a value with type TYPE located at ADDR.
930 Call value_at only if the data needs to be fetched immediately;
931 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
932 value_at_lazy instead. value_at_lazy simply records the address of
933 the data and sets the lazy-evaluation-required flag. The lazy flag
934 is tested in the value_contents macro, which is used if and when
935 the contents are actually required.
937 Note: value_at does *NOT* handle embedded offsets; perform such
938 adjustments before or after calling it. */
941 value_at (struct type
*type
, CORE_ADDR addr
)
943 return get_value_at (type
, addr
, 0);
946 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
949 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
951 return get_value_at (type
, addr
, 1);
954 /* Called only from the value_contents and value_contents_all()
955 macros, if the current data for a variable needs to be loaded into
956 value_contents(VAL). Fetches the data from the user's process, and
957 clears the lazy flag to indicate that the data in the buffer is
960 If the value is zero-length, we avoid calling read_memory, which
961 would abort. We mark the value as fetched anyway -- all 0 bytes of
964 This function returns a value because it is used in the
965 value_contents macro as part of an expression, where a void would
966 not work. The value is ignored. */
969 value_fetch_lazy (struct value
*val
)
971 gdb_assert (value_lazy (val
));
972 allocate_value_contents (val
);
973 if (value_bitsize (val
))
975 /* To read a lazy bitfield, read the entire enclosing value. This
976 prevents reading the same block of (possibly volatile) memory once
977 per bitfield. It would be even better to read only the containing
978 word, but we have no way to record that just specific bits of a
979 value have been fetched. */
980 struct type
*type
= check_typedef (value_type (val
));
981 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
982 struct value
*parent
= value_parent (val
);
983 LONGEST offset
= value_offset (val
);
985 int length
= TYPE_LENGTH (type
);
987 if (!value_bits_valid (val
,
988 TARGET_CHAR_BIT
* offset
+ value_bitpos (val
),
989 value_bitsize (val
)))
990 error (_("value has been optimized out"));
992 if (!unpack_value_bits_as_long (value_type (val
),
993 value_contents_for_printing (parent
),
996 value_bitsize (val
), parent
, &num
))
997 mark_value_bytes_unavailable (val
,
998 value_embedded_offset (val
),
1001 store_signed_integer (value_contents_raw (val
), length
,
1004 else if (VALUE_LVAL (val
) == lval_memory
)
1006 CORE_ADDR addr
= value_address (val
);
1007 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
1010 read_value_memory (val
, 0, value_stack (val
),
1011 addr
, value_contents_all_raw (val
), length
);
1013 else if (VALUE_LVAL (val
) == lval_register
)
1015 struct frame_info
*frame
;
1017 struct type
*type
= check_typedef (value_type (val
));
1018 struct value
*new_val
= val
, *mark
= value_mark ();
1020 /* Offsets are not supported here; lazy register values must
1021 refer to the entire register. */
1022 gdb_assert (value_offset (val
) == 0);
1024 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
1026 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
1027 regnum
= VALUE_REGNUM (new_val
);
1029 gdb_assert (frame
!= NULL
);
1031 /* Convertible register routines are used for multi-register
1032 values and for interpretation in different types
1033 (e.g. float or int from a double register). Lazy
1034 register values should have the register's natural type,
1035 so they do not apply. */
1036 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
1039 new_val
= get_frame_register_value (frame
, regnum
);
1042 /* If it's still lazy (for instance, a saved register on the
1043 stack), fetch it. */
1044 if (value_lazy (new_val
))
1045 value_fetch_lazy (new_val
);
1047 /* If the register was not saved, mark it optimized out. */
1048 if (value_optimized_out (new_val
))
1049 set_value_optimized_out (val
, 1);
1052 set_value_lazy (val
, 0);
1053 value_contents_copy (val
, value_embedded_offset (val
),
1054 new_val
, value_embedded_offset (new_val
),
1055 TYPE_LENGTH (type
));
1060 struct gdbarch
*gdbarch
;
1061 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1062 regnum
= VALUE_REGNUM (val
);
1063 gdbarch
= get_frame_arch (frame
);
1065 fprintf_unfiltered (gdb_stdlog
,
1066 "{ value_fetch_lazy "
1067 "(frame=%d,regnum=%d(%s),...) ",
1068 frame_relative_level (frame
), regnum
,
1069 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1071 fprintf_unfiltered (gdb_stdlog
, "->");
1072 if (value_optimized_out (new_val
))
1073 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1077 const gdb_byte
*buf
= value_contents (new_val
);
1079 if (VALUE_LVAL (new_val
) == lval_register
)
1080 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1081 VALUE_REGNUM (new_val
));
1082 else if (VALUE_LVAL (new_val
) == lval_memory
)
1083 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1085 value_address (new_val
)));
1087 fprintf_unfiltered (gdb_stdlog
, " computed");
1089 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1090 fprintf_unfiltered (gdb_stdlog
, "[");
1091 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1092 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1093 fprintf_unfiltered (gdb_stdlog
, "]");
1096 fprintf_unfiltered (gdb_stdlog
, " }\n");
1099 /* Dispose of the intermediate values. This prevents
1100 watchpoints from trying to watch the saved frame pointer. */
1101 value_free_to_mark (mark
);
1103 else if (VALUE_LVAL (val
) == lval_computed
)
1104 value_computed_funcs (val
)->read (val
);
1105 else if (value_optimized_out (val
))
1106 /* Keep it optimized out. */;
1108 internal_error (__FILE__
, __LINE__
, _("Unexpected lazy value type."));
1110 set_value_lazy (val
, 0);
1115 read_value_memory (struct value
*val
, int embedded_offset
,
1116 int stack
, CORE_ADDR memaddr
,
1117 gdb_byte
*buffer
, size_t length
)
1121 VEC(mem_range_s
) *available_memory
;
1123 if (get_traceframe_number () < 0
1124 || !traceframe_available_memory (&available_memory
, memaddr
, length
))
1127 read_stack (memaddr
, buffer
, length
);
1129 read_memory (memaddr
, buffer
, length
);
1133 struct target_section_table
*table
;
1134 struct cleanup
*old_chain
;
1139 /* Fallback to reading from read-only sections. */
1140 table
= target_get_section_table (&exec_ops
);
1142 section_table_available_memory (available_memory
,
1145 table
->sections_end
);
1147 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
),
1150 normalize_mem_ranges (available_memory
);
1152 /* Mark which bytes are unavailable, and read those which
1158 VEC_iterate (mem_range_s
, available_memory
, i
, r
);
1161 if (mem_ranges_overlap (r
->start
, r
->length
,
1164 CORE_ADDR lo1
, hi1
, lo2
, hi2
;
1165 CORE_ADDR start
, end
;
1167 /* Get the intersection window. */
1169 hi1
= memaddr
+ length
;
1171 hi2
= r
->start
+ r
->length
;
1172 start
= max (lo1
, lo2
);
1173 end
= min (hi1
, hi2
);
1175 gdb_assert (end
- memaddr
<= length
);
1177 if (start
> unavail
)
1178 mark_value_bytes_unavailable (val
,
1180 + unavail
- memaddr
),
1184 read_memory (start
, buffer
+ start
- memaddr
, end
- start
);
1188 if (unavail
!= memaddr
+ length
)
1189 mark_value_bytes_unavailable (val
,
1190 embedded_offset
+ unavail
- memaddr
,
1191 (memaddr
+ length
) - unavail
);
1193 do_cleanups (old_chain
);
1198 /* Store the contents of FROMVAL into the location of TOVAL.
1199 Return a new value with the location of TOVAL and contents of FROMVAL. */
1202 value_assign (struct value
*toval
, struct value
*fromval
)
1206 struct frame_id old_frame
;
1208 if (!deprecated_value_modifiable (toval
))
1209 error (_("Left operand of assignment is not a modifiable lvalue."));
1211 toval
= coerce_ref (toval
);
1213 type
= value_type (toval
);
1214 if (VALUE_LVAL (toval
) != lval_internalvar
)
1215 fromval
= value_cast (type
, fromval
);
1218 /* Coerce arrays and functions to pointers, except for arrays
1219 which only live in GDB's storage. */
1220 if (!value_must_coerce_to_target (fromval
))
1221 fromval
= coerce_array (fromval
);
1224 CHECK_TYPEDEF (type
);
1226 /* Since modifying a register can trash the frame chain, and
1227 modifying memory can trash the frame cache, we save the old frame
1228 and then restore the new frame afterwards. */
1229 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1231 switch (VALUE_LVAL (toval
))
1233 case lval_internalvar
:
1234 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1235 return value_of_internalvar (get_type_arch (type
),
1236 VALUE_INTERNALVAR (toval
));
1238 case lval_internalvar_component
:
1239 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1240 value_offset (toval
),
1241 value_bitpos (toval
),
1242 value_bitsize (toval
),
1248 const gdb_byte
*dest_buffer
;
1249 CORE_ADDR changed_addr
;
1251 gdb_byte buffer
[sizeof (LONGEST
)];
1253 if (value_bitsize (toval
))
1255 struct value
*parent
= value_parent (toval
);
1257 changed_addr
= value_address (parent
) + value_offset (toval
);
1258 changed_len
= (value_bitpos (toval
)
1259 + value_bitsize (toval
)
1260 + HOST_CHAR_BIT
- 1)
1263 /* If we can read-modify-write exactly the size of the
1264 containing type (e.g. short or int) then do so. This
1265 is safer for volatile bitfields mapped to hardware
1267 if (changed_len
< TYPE_LENGTH (type
)
1268 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1269 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1270 changed_len
= TYPE_LENGTH (type
);
1272 if (changed_len
> (int) sizeof (LONGEST
))
1273 error (_("Can't handle bitfields which "
1274 "don't fit in a %d bit word."),
1275 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1277 read_memory (changed_addr
, buffer
, changed_len
);
1278 modify_field (type
, buffer
, value_as_long (fromval
),
1279 value_bitpos (toval
), value_bitsize (toval
));
1280 dest_buffer
= buffer
;
1284 changed_addr
= value_address (toval
);
1285 changed_len
= TYPE_LENGTH (type
);
1286 dest_buffer
= value_contents (fromval
);
1289 write_memory (changed_addr
, dest_buffer
, changed_len
);
1290 observer_notify_memory_changed (changed_addr
, changed_len
,
1297 struct frame_info
*frame
;
1298 struct gdbarch
*gdbarch
;
1301 /* Figure out which frame this is in currently. */
1302 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1303 value_reg
= VALUE_REGNUM (toval
);
1306 error (_("Value being assigned to is no longer active."));
1308 gdbarch
= get_frame_arch (frame
);
1309 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
), type
))
1311 /* If TOVAL is a special machine register requiring
1312 conversion of program values to a special raw
1314 gdbarch_value_to_register (gdbarch
, frame
,
1315 VALUE_REGNUM (toval
), type
,
1316 value_contents (fromval
));
1320 if (value_bitsize (toval
))
1322 struct value
*parent
= value_parent (toval
);
1323 int offset
= value_offset (parent
) + value_offset (toval
);
1325 gdb_byte buffer
[sizeof (LONGEST
)];
1327 changed_len
= (value_bitpos (toval
)
1328 + value_bitsize (toval
)
1329 + HOST_CHAR_BIT
- 1)
1332 if (changed_len
> (int) sizeof (LONGEST
))
1333 error (_("Can't handle bitfields which "
1334 "don't fit in a %d bit word."),
1335 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1337 get_frame_register_bytes (frame
, value_reg
, offset
,
1338 changed_len
, buffer
);
1340 modify_field (type
, buffer
, value_as_long (fromval
),
1341 value_bitpos (toval
), value_bitsize (toval
));
1343 put_frame_register_bytes (frame
, value_reg
, offset
,
1344 changed_len
, buffer
);
1348 put_frame_register_bytes (frame
, value_reg
,
1349 value_offset (toval
),
1351 value_contents (fromval
));
1355 if (deprecated_register_changed_hook
)
1356 deprecated_register_changed_hook (-1);
1357 observer_notify_target_changed (¤t_target
);
1363 struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1365 funcs
->write (toval
, fromval
);
1370 error (_("Left operand of assignment is not an lvalue."));
1373 /* Assigning to the stack pointer, frame pointer, and other
1374 (architecture and calling convention specific) registers may
1375 cause the frame cache to be out of date. Assigning to memory
1376 also can. We just do this on all assignments to registers or
1377 memory, for simplicity's sake; I doubt the slowdown matters. */
1378 switch (VALUE_LVAL (toval
))
1384 reinit_frame_cache ();
1386 /* Having destroyed the frame cache, restore the selected
1389 /* FIXME: cagney/2002-11-02: There has to be a better way of
1390 doing this. Instead of constantly saving/restoring the
1391 frame. Why not create a get_selected_frame() function that,
1392 having saved the selected frame's ID can automatically
1393 re-find the previously selected frame automatically. */
1396 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1407 /* If the field does not entirely fill a LONGEST, then zero the sign
1408 bits. If the field is signed, and is negative, then sign
1410 if ((value_bitsize (toval
) > 0)
1411 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1413 LONGEST fieldval
= value_as_long (fromval
);
1414 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1416 fieldval
&= valmask
;
1417 if (!TYPE_UNSIGNED (type
)
1418 && (fieldval
& (valmask
^ (valmask
>> 1))))
1419 fieldval
|= ~valmask
;
1421 fromval
= value_from_longest (type
, fieldval
);
1424 /* The return value is a copy of TOVAL so it shares its location
1425 information, but its contents are updated from FROMVAL. This
1426 implies the returned value is not lazy, even if TOVAL was. */
1427 val
= value_copy (toval
);
1428 set_value_lazy (val
, 0);
1429 memcpy (value_contents_raw (val
), value_contents (fromval
),
1430 TYPE_LENGTH (type
));
1432 /* We copy over the enclosing type and pointed-to offset from FROMVAL
1433 in the case of pointer types. For object types, the enclosing type
1434 and embedded offset must *not* be copied: the target object refered
1435 to by TOVAL retains its original dynamic type after assignment. */
1436 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1438 set_value_enclosing_type (val
, value_enclosing_type (fromval
));
1439 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1445 /* Extend a value VAL to COUNT repetitions of its type. */
1448 value_repeat (struct value
*arg1
, int count
)
1452 if (VALUE_LVAL (arg1
) != lval_memory
)
1453 error (_("Only values in memory can be extended with '@'."));
1455 error (_("Invalid number %d of repetitions."), count
);
1457 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1459 read_memory (value_address (arg1
),
1460 value_contents_all_raw (val
),
1461 TYPE_LENGTH (value_enclosing_type (val
)));
1462 VALUE_LVAL (val
) = lval_memory
;
1463 set_value_address (val
, value_address (arg1
));
1469 value_of_variable (struct symbol
*var
, struct block
*b
)
1472 struct frame_info
*frame
;
1474 if (!symbol_read_needs_frame (var
))
1477 frame
= get_selected_frame (_("No frame selected."));
1480 frame
= block_innermost_frame (b
);
1483 if (BLOCK_FUNCTION (b
) && !block_inlined_p (b
)
1484 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
1485 error (_("No frame is currently executing in block %s."),
1486 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
1488 error (_("No frame is currently executing in specified block"));
1492 val
= read_var_value (var
, frame
);
1494 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
1500 address_of_variable (struct symbol
*var
, struct block
*b
)
1502 struct type
*type
= SYMBOL_TYPE (var
);
1505 /* Evaluate it first; if the result is a memory address, we're fine.
1506 Lazy evaluation pays off here. */
1508 val
= value_of_variable (var
, b
);
1510 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1511 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1513 CORE_ADDR addr
= value_address (val
);
1515 return value_from_pointer (lookup_pointer_type (type
), addr
);
1518 /* Not a memory address; check what the problem was. */
1519 switch (VALUE_LVAL (val
))
1523 struct frame_info
*frame
;
1524 const char *regname
;
1526 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1529 regname
= gdbarch_register_name (get_frame_arch (frame
),
1530 VALUE_REGNUM (val
));
1531 gdb_assert (regname
&& *regname
);
1533 error (_("Address requested for identifier "
1534 "\"%s\" which is in register $%s"),
1535 SYMBOL_PRINT_NAME (var
), regname
);
1540 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1541 SYMBOL_PRINT_NAME (var
));
1548 /* Return one if VAL does not live in target memory, but should in order
1549 to operate on it. Otherwise return zero. */
1552 value_must_coerce_to_target (struct value
*val
)
1554 struct type
*valtype
;
1556 /* The only lval kinds which do not live in target memory. */
1557 if (VALUE_LVAL (val
) != not_lval
1558 && VALUE_LVAL (val
) != lval_internalvar
)
1561 valtype
= check_typedef (value_type (val
));
1563 switch (TYPE_CODE (valtype
))
1565 case TYPE_CODE_ARRAY
:
1566 return TYPE_VECTOR (valtype
) ? 0 : 1;
1567 case TYPE_CODE_STRING
:
1574 /* Make sure that VAL lives in target memory if it's supposed to. For
1575 instance, strings are constructed as character arrays in GDB's
1576 storage, and this function copies them to the target. */
1579 value_coerce_to_target (struct value
*val
)
1584 if (!value_must_coerce_to_target (val
))
1587 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1588 addr
= allocate_space_in_inferior (length
);
1589 write_memory (addr
, value_contents (val
), length
);
1590 return value_at_lazy (value_type (val
), addr
);
1593 /* Given a value which is an array, return a value which is a pointer
1594 to its first element, regardless of whether or not the array has a
1595 nonzero lower bound.
1597 FIXME: A previous comment here indicated that this routine should
1598 be substracting the array's lower bound. It's not clear to me that
1599 this is correct. Given an array subscripting operation, it would
1600 certainly work to do the adjustment here, essentially computing:
1602 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1604 However I believe a more appropriate and logical place to account
1605 for the lower bound is to do so in value_subscript, essentially
1608 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1610 As further evidence consider what would happen with operations
1611 other than array subscripting, where the caller would get back a
1612 value that had an address somewhere before the actual first element
1613 of the array, and the information about the lower bound would be
1614 lost because of the coercion to pointer type. */
1617 value_coerce_array (struct value
*arg1
)
1619 struct type
*type
= check_typedef (value_type (arg1
));
1621 /* If the user tries to do something requiring a pointer with an
1622 array that has not yet been pushed to the target, then this would
1623 be a good time to do so. */
1624 arg1
= value_coerce_to_target (arg1
);
1626 if (VALUE_LVAL (arg1
) != lval_memory
)
1627 error (_("Attempt to take address of value not located in memory."));
1629 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1630 value_address (arg1
));
1633 /* Given a value which is a function, return a value which is a pointer
1637 value_coerce_function (struct value
*arg1
)
1639 struct value
*retval
;
1641 if (VALUE_LVAL (arg1
) != lval_memory
)
1642 error (_("Attempt to take address of value not located in memory."));
1644 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1645 value_address (arg1
));
1649 /* Return a pointer value for the object for which ARG1 is the
1653 value_addr (struct value
*arg1
)
1656 struct type
*type
= check_typedef (value_type (arg1
));
1658 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1660 /* Copy the value, but change the type from (T&) to (T*). We
1661 keep the same location information, which is efficient, and
1662 allows &(&X) to get the location containing the reference. */
1663 arg2
= value_copy (arg1
);
1664 deprecated_set_value_type (arg2
,
1665 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1668 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1669 return value_coerce_function (arg1
);
1671 /* If this is an array that has not yet been pushed to the target,
1672 then this would be a good time to force it to memory. */
1673 arg1
= value_coerce_to_target (arg1
);
1675 if (VALUE_LVAL (arg1
) != lval_memory
)
1676 error (_("Attempt to take address of value not located in memory."));
1678 /* Get target memory address. */
1679 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1680 (value_address (arg1
)
1681 + value_embedded_offset (arg1
)));
1683 /* This may be a pointer to a base subobject; so remember the
1684 full derived object's type ... */
1685 set_value_enclosing_type (arg2
,
1686 lookup_pointer_type (value_enclosing_type (arg1
)));
1687 /* ... and also the relative position of the subobject in the full
1689 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1693 /* Return a reference value for the object for which ARG1 is the
1697 value_ref (struct value
*arg1
)
1700 struct type
*type
= check_typedef (value_type (arg1
));
1702 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1705 arg2
= value_addr (arg1
);
1706 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1710 /* Given a value of a pointer type, apply the C unary * operator to
1714 value_ind (struct value
*arg1
)
1716 struct type
*base_type
;
1719 arg1
= coerce_array (arg1
);
1721 base_type
= check_typedef (value_type (arg1
));
1723 if (VALUE_LVAL (arg1
) == lval_computed
)
1725 struct lval_funcs
*funcs
= value_computed_funcs (arg1
);
1727 if (funcs
->indirect
)
1729 struct value
*result
= funcs
->indirect (arg1
);
1736 if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1738 struct type
*enc_type
;
1740 /* We may be pointing to something embedded in a larger object.
1741 Get the real type of the enclosing object. */
1742 enc_type
= check_typedef (value_enclosing_type (arg1
));
1743 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1745 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1746 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1747 /* For functions, go through find_function_addr, which knows
1748 how to handle function descriptors. */
1749 arg2
= value_at_lazy (enc_type
,
1750 find_function_addr (arg1
, NULL
));
1752 /* Retrieve the enclosing object pointed to. */
1753 arg2
= value_at_lazy (enc_type
,
1754 (value_as_address (arg1
)
1755 - value_pointed_to_offset (arg1
)));
1757 /* Re-adjust type. */
1758 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1759 /* Add embedding info. */
1760 set_value_enclosing_type (arg2
, enc_type
);
1761 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1763 /* We may be pointing to an object of some derived type. */
1764 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1768 error (_("Attempt to take contents of a non-pointer value."));
1769 return 0; /* For lint -- never reached. */
1772 /* Create a value for an array by allocating space in GDB, copying the
1773 data into that space, and then setting up an array value.
1775 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1776 is populated from the values passed in ELEMVEC.
1778 The element type of the array is inherited from the type of the
1779 first element, and all elements must have the same size (though we
1780 don't currently enforce any restriction on their types). */
1783 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1787 unsigned int typelength
;
1789 struct type
*arraytype
;
1791 /* Validate that the bounds are reasonable and that each of the
1792 elements have the same size. */
1794 nelem
= highbound
- lowbound
+ 1;
1797 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1799 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1800 for (idx
= 1; idx
< nelem
; idx
++)
1802 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1804 error (_("array elements must all be the same size"));
1808 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1809 lowbound
, highbound
);
1811 if (!current_language
->c_style_arrays
)
1813 val
= allocate_value (arraytype
);
1814 for (idx
= 0; idx
< nelem
; idx
++)
1815 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0,
1820 /* Allocate space to store the array, and then initialize it by
1821 copying in each element. */
1823 val
= allocate_value (arraytype
);
1824 for (idx
= 0; idx
< nelem
; idx
++)
1825 value_contents_copy (val
, idx
* typelength
, elemvec
[idx
], 0, typelength
);
1830 value_cstring (char *ptr
, int len
, struct type
*char_type
)
1833 int lowbound
= current_language
->string_lower_bound
;
1834 int highbound
= len
/ TYPE_LENGTH (char_type
);
1835 struct type
*stringtype
1836 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1838 val
= allocate_value (stringtype
);
1839 memcpy (value_contents_raw (val
), ptr
, len
);
1843 /* Create a value for a string constant by allocating space in the
1844 inferior, copying the data into that space, and returning the
1845 address with type TYPE_CODE_STRING. PTR points to the string
1846 constant data; LEN is number of characters.
1848 Note that string types are like array of char types with a lower
1849 bound of zero and an upper bound of LEN - 1. Also note that the
1850 string may contain embedded null bytes. */
1853 value_string (char *ptr
, int len
, struct type
*char_type
)
1856 int lowbound
= current_language
->string_lower_bound
;
1857 int highbound
= len
/ TYPE_LENGTH (char_type
);
1858 struct type
*stringtype
1859 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1861 val
= allocate_value (stringtype
);
1862 memcpy (value_contents_raw (val
), ptr
, len
);
1867 value_bitstring (char *ptr
, int len
, struct type
*index_type
)
1870 struct type
*domain_type
1871 = create_range_type (NULL
, index_type
, 0, len
- 1);
1872 struct type
*type
= create_set_type (NULL
, domain_type
);
1874 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1875 val
= allocate_value (type
);
1876 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1880 /* See if we can pass arguments in T2 to a function which takes
1881 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1882 a NULL-terminated vector. If some arguments need coercion of some
1883 sort, then the coerced values are written into T2. Return value is
1884 0 if the arguments could be matched, or the position at which they
1887 STATICP is nonzero if the T1 argument list came from a static
1888 member function. T2 will still include the ``this'' pointer, but
1891 For non-static member functions, we ignore the first argument,
1892 which is the type of the instance variable. This is because we
1893 want to handle calls with objects from derived classes. This is
1894 not entirely correct: we should actually check to make sure that a
1895 requested operation is type secure, shouldn't we? FIXME. */
1898 typecmp (int staticp
, int varargs
, int nargs
,
1899 struct field t1
[], struct value
*t2
[])
1904 internal_error (__FILE__
, __LINE__
,
1905 _("typecmp: no argument list"));
1907 /* Skip ``this'' argument if applicable. T2 will always include
1913 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1916 struct type
*tt1
, *tt2
;
1921 tt1
= check_typedef (t1
[i
].type
);
1922 tt2
= check_typedef (value_type (t2
[i
]));
1924 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1925 /* We should be doing hairy argument matching, as below. */
1926 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
)))
1927 == TYPE_CODE (tt2
)))
1929 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1930 t2
[i
] = value_coerce_array (t2
[i
]);
1932 t2
[i
] = value_ref (t2
[i
]);
1936 /* djb - 20000715 - Until the new type structure is in the
1937 place, and we can attempt things like implicit conversions,
1938 we need to do this so you can take something like a map<const
1939 char *>, and properly access map["hello"], because the
1940 argument to [] will be a reference to a pointer to a char,
1941 and the argument will be a pointer to a char. */
1942 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1943 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1945 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1947 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1948 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1949 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1951 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1953 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1955 /* Array to pointer is a `trivial conversion' according to the
1958 /* We should be doing much hairier argument matching (see
1959 section 13.2 of the ARM), but as a quick kludge, just check
1960 for the same type code. */
1961 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1964 if (varargs
|| t2
[i
] == NULL
)
1969 /* Helper function used by value_struct_elt to recurse through
1970 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1971 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1972 TYPE. If found, return value, else return NULL.
1974 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1975 fields, look for a baseclass named NAME. */
1977 static struct value
*
1978 search_struct_field (const char *name
, struct value
*arg1
, int offset
,
1979 struct type
*type
, int looking_for_baseclass
)
1984 CHECK_TYPEDEF (type
);
1985 nbases
= TYPE_N_BASECLASSES (type
);
1987 if (!looking_for_baseclass
)
1988 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1990 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1992 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1996 if (field_is_static (&TYPE_FIELD (type
, i
)))
1998 v
= value_static_field (type
, i
);
2000 error (_("field %s is nonexistent or "
2001 "has been optimized out"),
2006 v
= value_primitive_field (arg1
, offset
, i
, type
);
2008 error (_("there is no field named %s"), name
);
2014 && (t_field_name
[0] == '\0'
2015 || (TYPE_CODE (type
) == TYPE_CODE_UNION
2016 && (strcmp_iw (t_field_name
, "else") == 0))))
2018 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
2020 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
2021 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
2023 /* Look for a match through the fields of an anonymous
2024 union, or anonymous struct. C++ provides anonymous
2027 In the GNU Chill (now deleted from GDB)
2028 implementation of variant record types, each
2029 <alternative field> has an (anonymous) union type,
2030 each member of the union represents a <variant
2031 alternative>. Each <variant alternative> is
2032 represented as a struct, with a member for each
2036 int new_offset
= offset
;
2038 /* This is pretty gross. In G++, the offset in an
2039 anonymous union is relative to the beginning of the
2040 enclosing struct. In the GNU Chill (now deleted
2041 from GDB) implementation of variant records, the
2042 bitpos is zero in an anonymous union field, so we
2043 have to add the offset of the union here. */
2044 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
2045 || (TYPE_NFIELDS (field_type
) > 0
2046 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
2047 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
2049 v
= search_struct_field (name
, arg1
, new_offset
,
2051 looking_for_baseclass
);
2058 for (i
= 0; i
< nbases
; i
++)
2061 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
2062 /* If we are looking for baseclasses, this is what we get when
2063 we hit them. But it could happen that the base part's member
2064 name is not yet filled in. */
2065 int found_baseclass
= (looking_for_baseclass
2066 && TYPE_BASECLASS_NAME (type
, i
) != NULL
2067 && (strcmp_iw (name
,
2068 TYPE_BASECLASS_NAME (type
,
2071 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2076 boffset
= baseclass_offset (type
, i
,
2077 value_contents (arg1
) + offset
,
2078 value_address (arg1
)
2079 + value_embedded_offset (arg1
)
2082 error (_("virtual baseclass botch"));
2084 /* The virtual base class pointer might have been clobbered
2085 by the user program. Make sure that it still points to a
2086 valid memory location. */
2088 boffset
+= value_embedded_offset (arg1
) + offset
;
2090 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
2092 CORE_ADDR base_addr
;
2094 v2
= allocate_value (basetype
);
2095 base_addr
= value_address (arg1
) + boffset
;
2096 if (target_read_memory (base_addr
,
2097 value_contents_raw (v2
),
2098 TYPE_LENGTH (basetype
)) != 0)
2099 error (_("virtual baseclass botch"));
2100 VALUE_LVAL (v2
) = lval_memory
;
2101 set_value_address (v2
, base_addr
);
2105 v2
= value_copy (arg1
);
2106 deprecated_set_value_type (v2
, basetype
);
2107 set_value_embedded_offset (v2
, boffset
);
2110 if (found_baseclass
)
2112 v
= search_struct_field (name
, v2
, 0,
2113 TYPE_BASECLASS (type
, i
),
2114 looking_for_baseclass
);
2116 else if (found_baseclass
)
2117 v
= value_primitive_field (arg1
, offset
, i
, type
);
2119 v
= search_struct_field (name
, arg1
,
2120 offset
+ TYPE_BASECLASS_BITPOS (type
,
2122 basetype
, looking_for_baseclass
);
2129 /* Helper function used by value_struct_elt to recurse through
2130 baseclasses. Look for a field NAME in ARG1. Adjust the address of
2131 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
2134 If found, return value, else if name matched and args not return
2135 (value) -1, else return NULL. */
2137 static struct value
*
2138 search_struct_method (const char *name
, struct value
**arg1p
,
2139 struct value
**args
, int offset
,
2140 int *static_memfuncp
, struct type
*type
)
2144 int name_matched
= 0;
2145 char dem_opname
[64];
2147 CHECK_TYPEDEF (type
);
2148 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2150 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2152 /* FIXME! May need to check for ARM demangling here. */
2153 if (strncmp (t_field_name
, "__", 2) == 0 ||
2154 strncmp (t_field_name
, "op", 2) == 0 ||
2155 strncmp (t_field_name
, "type", 4) == 0)
2157 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
2158 t_field_name
= dem_opname
;
2159 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
2160 t_field_name
= dem_opname
;
2162 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2164 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
2165 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2168 check_stub_method_group (type
, i
);
2169 if (j
> 0 && args
== 0)
2170 error (_("cannot resolve overloaded method "
2171 "`%s': no arguments supplied"), name
);
2172 else if (j
== 0 && args
== 0)
2174 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2181 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2182 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
2183 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
2184 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2186 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2187 return value_virtual_fn_field (arg1p
, f
, j
,
2189 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2191 *static_memfuncp
= 1;
2192 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2201 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2205 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2207 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2208 const gdb_byte
*base_valaddr
;
2210 /* The virtual base class pointer might have been
2211 clobbered by the user program. Make sure that it
2212 still points to a valid memory location. */
2214 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2216 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
2218 if (target_read_memory (value_address (*arg1p
) + offset
,
2219 tmp
, TYPE_LENGTH (baseclass
)) != 0)
2220 error (_("virtual baseclass botch"));
2224 base_valaddr
= value_contents (*arg1p
) + offset
;
2226 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2227 value_address (*arg1p
) + offset
);
2228 if (base_offset
== -1)
2229 error (_("virtual baseclass botch"));
2233 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2235 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2236 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2237 if (v
== (struct value
*) - 1)
2243 /* FIXME-bothner: Why is this commented out? Why is it here? */
2244 /* *arg1p = arg1_tmp; */
2249 return (struct value
*) - 1;
2254 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2255 extract the component named NAME from the ultimate target
2256 structure/union and return it as a value with its appropriate type.
2257 ERR is used in the error message if *ARGP's type is wrong.
2259 C++: ARGS is a list of argument types to aid in the selection of
2260 an appropriate method. Also, handle derived types.
2262 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2263 where the truthvalue of whether the function that was resolved was
2264 a static member function or not is stored.
2266 ERR is an error message to be printed in case the field is not
2270 value_struct_elt (struct value
**argp
, struct value
**args
,
2271 const char *name
, int *static_memfuncp
, const char *err
)
2276 *argp
= coerce_array (*argp
);
2278 t
= check_typedef (value_type (*argp
));
2280 /* Follow pointers until we get to a non-pointer. */
2282 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2284 *argp
= value_ind (*argp
);
2285 /* Don't coerce fn pointer to fn and then back again! */
2286 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2287 *argp
= coerce_array (*argp
);
2288 t
= check_typedef (value_type (*argp
));
2291 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2292 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2293 error (_("Attempt to extract a component of a value that is not a %s."),
2296 /* Assume it's not, unless we see that it is. */
2297 if (static_memfuncp
)
2298 *static_memfuncp
= 0;
2302 /* if there are no arguments ...do this... */
2304 /* Try as a field first, because if we succeed, there is less
2306 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2310 /* C++: If it was not found as a data field, then try to
2311 return it as a pointer to a method. */
2312 v
= search_struct_method (name
, argp
, args
, 0,
2313 static_memfuncp
, t
);
2315 if (v
== (struct value
*) - 1)
2316 error (_("Cannot take address of method %s."), name
);
2319 if (TYPE_NFN_FIELDS (t
))
2320 error (_("There is no member or method named %s."), name
);
2322 error (_("There is no member named %s."), name
);
2327 v
= search_struct_method (name
, argp
, args
, 0,
2328 static_memfuncp
, t
);
2330 if (v
== (struct value
*) - 1)
2332 error (_("One of the arguments you tried to pass to %s could not "
2333 "be converted to what the function wants."), name
);
2337 /* See if user tried to invoke data as function. If so, hand it
2338 back. If it's not callable (i.e., a pointer to function),
2339 gdb should give an error. */
2340 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2341 /* If we found an ordinary field, then it is not a method call.
2342 So, treat it as if it were a static member function. */
2343 if (v
&& static_memfuncp
)
2344 *static_memfuncp
= 1;
2348 throw_error (NOT_FOUND_ERROR
,
2349 _("Structure has no component named %s."), name
);
2353 /* Search through the methods of an object (and its bases) to find a
2354 specified method. Return the pointer to the fn_field list of
2355 overloaded instances.
2357 Helper function for value_find_oload_list.
2358 ARGP is a pointer to a pointer to a value (the object).
2359 METHOD is a string containing the method name.
2360 OFFSET is the offset within the value.
2361 TYPE is the assumed type of the object.
2362 NUM_FNS is the number of overloaded instances.
2363 BASETYPE is set to the actual type of the subobject where the
2365 BOFFSET is the offset of the base subobject where the method is found. */
2367 static struct fn_field
*
2368 find_method_list (struct value
**argp
, const char *method
,
2369 int offset
, struct type
*type
, int *num_fns
,
2370 struct type
**basetype
, int *boffset
)
2374 CHECK_TYPEDEF (type
);
2378 /* First check in object itself. */
2379 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2381 /* pai: FIXME What about operators and type conversions? */
2382 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2384 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2386 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2387 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2393 /* Resolve any stub methods. */
2394 check_stub_method_group (type
, i
);
2400 /* Not found in object, check in base subobjects. */
2401 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2405 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2407 base_offset
= value_offset (*argp
) + offset
;
2408 base_offset
= baseclass_offset (type
, i
,
2409 value_contents (*argp
) + base_offset
,
2410 value_address (*argp
) + base_offset
);
2411 if (base_offset
== -1)
2412 error (_("virtual baseclass botch"));
2414 else /* Non-virtual base, simply use bit position from debug
2417 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2419 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2420 TYPE_BASECLASS (type
, i
), num_fns
,
2428 /* Return the list of overloaded methods of a specified name.
2430 ARGP is a pointer to a pointer to a value (the object).
2431 METHOD is the method name.
2432 OFFSET is the offset within the value contents.
2433 NUM_FNS is the number of overloaded instances.
2434 BASETYPE is set to the type of the base subobject that defines the
2436 BOFFSET is the offset of the base subobject which defines the method. */
2439 value_find_oload_method_list (struct value
**argp
, const char *method
,
2440 int offset
, int *num_fns
,
2441 struct type
**basetype
, int *boffset
)
2445 t
= check_typedef (value_type (*argp
));
2447 /* Code snarfed from value_struct_elt. */
2448 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2450 *argp
= value_ind (*argp
);
2451 /* Don't coerce fn pointer to fn and then back again! */
2452 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2453 *argp
= coerce_array (*argp
);
2454 t
= check_typedef (value_type (*argp
));
2457 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2458 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2459 error (_("Attempt to extract a component of a "
2460 "value that is not a struct or union"));
2462 return find_method_list (argp
, method
, 0, t
, num_fns
,
2466 /* Given an array of argument types (ARGTYPES) (which includes an
2467 entry for "this" in the case of C++ methods), the number of
2468 arguments NARGS, the NAME of a function whether it's a method or
2469 not (METHOD), and the degree of laxness (LAX) in conforming to
2470 overload resolution rules in ANSI C++, find the best function that
2471 matches on the argument types according to the overload resolution
2474 METHOD can be one of three values:
2475 NON_METHOD for non-member functions.
2476 METHOD: for member functions.
2477 BOTH: used for overload resolution of operators where the
2478 candidates are expected to be either member or non member
2479 functions. In this case the first argument ARGTYPES
2480 (representing 'this') is expected to be a reference to the
2481 target object, and will be dereferenced when attempting the
2484 In the case of class methods, the parameter OBJ is an object value
2485 in which to search for overloaded methods.
2487 In the case of non-method functions, the parameter FSYM is a symbol
2488 corresponding to one of the overloaded functions.
2490 Return value is an integer: 0 -> good match, 10 -> debugger applied
2491 non-standard coercions, 100 -> incompatible.
2493 If a method is being searched for, VALP will hold the value.
2494 If a non-method is being searched for, SYMP will hold the symbol
2497 If a method is being searched for, and it is a static method,
2498 then STATICP will point to a non-zero value.
2500 If NO_ADL argument dependent lookup is disabled. This is used to prevent
2501 ADL overload candidates when performing overload resolution for a fully
2504 Note: This function does *not* check the value of
2505 overload_resolution. Caller must check it to see whether overload
2506 resolution is permitted. */
2509 find_overload_match (struct type
**arg_types
, int nargs
,
2510 const char *name
, enum oload_search_type method
,
2511 int lax
, struct value
**objp
, struct symbol
*fsym
,
2512 struct value
**valp
, struct symbol
**symp
,
2513 int *staticp
, const int no_adl
)
2515 struct value
*obj
= (objp
? *objp
: NULL
);
2516 /* Index of best overloaded function. */
2517 int func_oload_champ
= -1;
2518 int method_oload_champ
= -1;
2520 /* The measure for the current best match. */
2521 struct badness_vector
*method_badness
= NULL
;
2522 struct badness_vector
*func_badness
= NULL
;
2524 struct value
*temp
= obj
;
2525 /* For methods, the list of overloaded methods. */
2526 struct fn_field
*fns_ptr
= NULL
;
2527 /* For non-methods, the list of overloaded function symbols. */
2528 struct symbol
**oload_syms
= NULL
;
2529 /* Number of overloaded instances being considered. */
2531 struct type
*basetype
= NULL
;
2534 struct cleanup
*all_cleanups
= make_cleanup (null_cleanup
, NULL
);
2536 const char *obj_type_name
= NULL
;
2537 const char *func_name
= NULL
;
2538 enum oload_classification match_quality
;
2539 enum oload_classification method_match_quality
= INCOMPATIBLE
;
2540 enum oload_classification func_match_quality
= INCOMPATIBLE
;
2542 /* Get the list of overloaded methods or functions. */
2543 if (method
== METHOD
|| method
== BOTH
)
2547 /* OBJ may be a pointer value rather than the object itself. */
2548 obj
= coerce_ref (obj
);
2549 while (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_PTR
)
2550 obj
= coerce_ref (value_ind (obj
));
2551 obj_type_name
= TYPE_NAME (value_type (obj
));
2553 /* First check whether this is a data member, e.g. a pointer to
2555 if (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_STRUCT
)
2557 *valp
= search_struct_field (name
, obj
, 0,
2558 check_typedef (value_type (obj
)), 0);
2566 /* Retrieve the list of methods with the name NAME. */
2567 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2569 &basetype
, &boffset
);
2570 /* If this is a method only search, and no methods were found
2571 the search has faild. */
2572 if (method
== METHOD
&& (!fns_ptr
|| !num_fns
))
2573 error (_("Couldn't find method %s%s%s"),
2575 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2577 /* If we are dealing with stub method types, they should have
2578 been resolved by find_method_list via
2579 value_find_oload_method_list above. */
2582 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2583 method_oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
2585 oload_syms
, &method_badness
);
2587 method_match_quality
=
2588 classify_oload_match (method_badness
, nargs
,
2589 oload_method_static (method
, fns_ptr
,
2590 method_oload_champ
));
2592 make_cleanup (xfree
, method_badness
);
2597 if (method
== NON_METHOD
|| method
== BOTH
)
2599 const char *qualified_name
= NULL
;
2601 /* If the the overload match is being search for both
2602 as a method and non member function, the first argument
2603 must now be dereferenced. */
2605 arg_types
[0] = TYPE_TARGET_TYPE (arg_types
[0]);
2609 qualified_name
= SYMBOL_NATURAL_NAME (fsym
);
2611 /* If we have a function with a C++ name, try to extract just
2612 the function part. Do not try this for non-functions (e.g.
2613 function pointers). */
2615 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym
)))
2620 temp
= cp_func_name (qualified_name
);
2622 /* If cp_func_name did not remove anything, the name of the
2623 symbol did not include scope or argument types - it was
2624 probably a C-style function. */
2627 make_cleanup (xfree
, temp
);
2628 if (strcmp (temp
, qualified_name
) == 0)
2638 qualified_name
= name
;
2641 /* If there was no C++ name, this must be a C-style function or
2642 not a function at all. Just return the same symbol. Do the
2643 same if cp_func_name fails for some reason. */
2644 if (func_name
== NULL
)
2650 func_oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
2657 if (func_oload_champ
>= 0)
2658 func_match_quality
= classify_oload_match (func_badness
, nargs
, 0);
2660 make_cleanup (xfree
, oload_syms
);
2661 make_cleanup (xfree
, func_badness
);
2664 /* Did we find a match ? */
2665 if (method_oload_champ
== -1 && func_oload_champ
== -1)
2666 throw_error (NOT_FOUND_ERROR
,
2667 _("No symbol \"%s\" in current context."),
2670 /* If we have found both a method match and a function
2671 match, find out which one is better, and calculate match
2673 if (method_oload_champ
>= 0 && func_oload_champ
>= 0)
2675 switch (compare_badness (func_badness
, method_badness
))
2677 case 0: /* Top two contenders are equally good. */
2678 /* FIXME: GDB does not support the general ambiguous
2679 case. All candidates should be collected and presented
2681 error (_("Ambiguous overload resolution"));
2683 case 1: /* Incomparable top contenders. */
2684 /* This is an error incompatible candidates
2685 should not have been proposed. */
2686 error (_("Internal error: incompatible "
2687 "overload candidates proposed"));
2689 case 2: /* Function champion. */
2690 method_oload_champ
= -1;
2691 match_quality
= func_match_quality
;
2693 case 3: /* Method champion. */
2694 func_oload_champ
= -1;
2695 match_quality
= method_match_quality
;
2698 error (_("Internal error: unexpected overload comparison result"));
2704 /* We have either a method match or a function match. */
2705 if (method_oload_champ
>= 0)
2706 match_quality
= method_match_quality
;
2708 match_quality
= func_match_quality
;
2711 if (match_quality
== INCOMPATIBLE
)
2713 if (method
== METHOD
)
2714 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2716 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2719 error (_("Cannot resolve function %s to any overloaded instance"),
2722 else if (match_quality
== NON_STANDARD
)
2724 if (method
== METHOD
)
2725 warning (_("Using non-standard conversion to match "
2726 "method %s%s%s to supplied arguments"),
2728 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2731 warning (_("Using non-standard conversion to match "
2732 "function %s to supplied arguments"),
2736 if (staticp
!= NULL
)
2737 *staticp
= oload_method_static (method
, fns_ptr
, method_oload_champ
);
2739 if (method_oload_champ
>= 0)
2741 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, method_oload_champ
))
2742 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, method_oload_champ
,
2745 *valp
= value_fn_field (&temp
, fns_ptr
, method_oload_champ
,
2749 *symp
= oload_syms
[func_oload_champ
];
2753 struct type
*temp_type
= check_typedef (value_type (temp
));
2754 struct type
*obj_type
= check_typedef (value_type (*objp
));
2756 if (TYPE_CODE (temp_type
) != TYPE_CODE_PTR
2757 && (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
2758 || TYPE_CODE (obj_type
) == TYPE_CODE_REF
))
2760 temp
= value_addr (temp
);
2765 do_cleanups (all_cleanups
);
2767 switch (match_quality
)
2773 default: /* STANDARD */
2778 /* Find the best overload match, searching for FUNC_NAME in namespaces
2779 contained in QUALIFIED_NAME until it either finds a good match or
2780 runs out of namespaces. It stores the overloaded functions in
2781 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2782 calling function is responsible for freeing *OLOAD_SYMS and
2783 *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2787 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2788 const char *func_name
,
2789 const char *qualified_name
,
2790 struct symbol
***oload_syms
,
2791 struct badness_vector
**oload_champ_bv
,
2796 find_oload_champ_namespace_loop (arg_types
, nargs
,
2799 oload_syms
, oload_champ_bv
,
2806 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2807 how deep we've looked for namespaces, and the champ is stored in
2808 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2809 if it isn't. Other arguments are the same as in
2810 find_oload_champ_namespace
2812 It is the caller's responsibility to free *OLOAD_SYMS and
2816 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2817 const char *func_name
,
2818 const char *qualified_name
,
2820 struct symbol
***oload_syms
,
2821 struct badness_vector
**oload_champ_bv
,
2825 int next_namespace_len
= namespace_len
;
2826 int searched_deeper
= 0;
2828 struct cleanup
*old_cleanups
;
2829 int new_oload_champ
;
2830 struct symbol
**new_oload_syms
;
2831 struct badness_vector
*new_oload_champ_bv
;
2832 char *new_namespace
;
2834 if (next_namespace_len
!= 0)
2836 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2837 next_namespace_len
+= 2;
2839 next_namespace_len
+=
2840 cp_find_first_component (qualified_name
+ next_namespace_len
);
2842 /* Initialize these to values that can safely be xfree'd. */
2844 *oload_champ_bv
= NULL
;
2846 /* First, see if we have a deeper namespace we can search in.
2847 If we get a good match there, use it. */
2849 if (qualified_name
[next_namespace_len
] == ':')
2851 searched_deeper
= 1;
2853 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2854 func_name
, qualified_name
,
2856 oload_syms
, oload_champ_bv
,
2857 oload_champ
, no_adl
))
2863 /* If we reach here, either we're in the deepest namespace or we
2864 didn't find a good match in a deeper namespace. But, in the
2865 latter case, we still have a bad match in a deeper namespace;
2866 note that we might not find any match at all in the current
2867 namespace. (There's always a match in the deepest namespace,
2868 because this overload mechanism only gets called if there's a
2869 function symbol to start off with.) */
2871 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2872 make_cleanup (xfree
, *oload_champ_bv
);
2873 new_namespace
= alloca (namespace_len
+ 1);
2874 strncpy (new_namespace
, qualified_name
, namespace_len
);
2875 new_namespace
[namespace_len
] = '\0';
2876 new_oload_syms
= make_symbol_overload_list (func_name
,
2879 /* If we have reached the deepest level perform argument
2880 determined lookup. */
2881 if (!searched_deeper
&& !no_adl
)
2882 make_symbol_overload_list_adl (arg_types
, nargs
, func_name
);
2884 while (new_oload_syms
[num_fns
])
2887 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2888 NULL
, new_oload_syms
,
2889 &new_oload_champ_bv
);
2891 /* Case 1: We found a good match. Free earlier matches (if any),
2892 and return it. Case 2: We didn't find a good match, but we're
2893 not the deepest function. Then go with the bad match that the
2894 deeper function found. Case 3: We found a bad match, and we're
2895 the deepest function. Then return what we found, even though
2896 it's a bad match. */
2898 if (new_oload_champ
!= -1
2899 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2901 *oload_syms
= new_oload_syms
;
2902 *oload_champ
= new_oload_champ
;
2903 *oload_champ_bv
= new_oload_champ_bv
;
2904 do_cleanups (old_cleanups
);
2907 else if (searched_deeper
)
2909 xfree (new_oload_syms
);
2910 xfree (new_oload_champ_bv
);
2911 discard_cleanups (old_cleanups
);
2916 *oload_syms
= new_oload_syms
;
2917 *oload_champ
= new_oload_champ
;
2918 *oload_champ_bv
= new_oload_champ_bv
;
2919 do_cleanups (old_cleanups
);
2924 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2925 the best match from among the overloaded methods or functions
2926 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2927 The number of methods/functions in the list is given by NUM_FNS.
2928 Return the index of the best match; store an indication of the
2929 quality of the match in OLOAD_CHAMP_BV.
2931 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2934 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2935 int num_fns
, struct fn_field
*fns_ptr
,
2936 struct symbol
**oload_syms
,
2937 struct badness_vector
**oload_champ_bv
)
2940 /* A measure of how good an overloaded instance is. */
2941 struct badness_vector
*bv
;
2942 /* Index of best overloaded function. */
2943 int oload_champ
= -1;
2944 /* Current ambiguity state for overload resolution. */
2945 int oload_ambiguous
= 0;
2946 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2948 *oload_champ_bv
= NULL
;
2950 /* Consider each candidate in turn. */
2951 for (ix
= 0; ix
< num_fns
; ix
++)
2954 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2956 struct type
**parm_types
;
2960 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2964 /* If it's not a method, this is the proper place. */
2965 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2968 /* Prepare array of parameter types. */
2969 parm_types
= (struct type
**)
2970 xmalloc (nparms
* (sizeof (struct type
*)));
2971 for (jj
= 0; jj
< nparms
; jj
++)
2972 parm_types
[jj
] = (method
2973 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2974 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2977 /* Compare parameter types to supplied argument types. Skip
2978 THIS for static methods. */
2979 bv
= rank_function (parm_types
, nparms
,
2980 arg_types
+ static_offset
,
2981 nargs
- static_offset
);
2983 if (!*oload_champ_bv
)
2985 *oload_champ_bv
= bv
;
2988 else /* See whether current candidate is better or worse than
2990 switch (compare_badness (bv
, *oload_champ_bv
))
2992 case 0: /* Top two contenders are equally good. */
2993 oload_ambiguous
= 1;
2995 case 1: /* Incomparable top contenders. */
2996 oload_ambiguous
= 2;
2998 case 2: /* New champion, record details. */
2999 *oload_champ_bv
= bv
;
3000 oload_ambiguous
= 0;
3011 fprintf_filtered (gdb_stderr
,
3012 "Overloaded method instance %s, # of parms %d\n",
3013 fns_ptr
[ix
].physname
, nparms
);
3015 fprintf_filtered (gdb_stderr
,
3016 "Overloaded function instance "
3017 "%s # of parms %d\n",
3018 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
3020 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
3021 fprintf_filtered (gdb_stderr
,
3022 "...Badness @ %d : %d\n",
3023 jj
, bv
->rank
[jj
].rank
);
3024 fprintf_filtered (gdb_stderr
, "Overload resolution "
3025 "champion is %d, ambiguous? %d\n",
3026 oload_champ
, oload_ambiguous
);
3033 /* Return 1 if we're looking at a static method, 0 if we're looking at
3034 a non-static method or a function that isn't a method. */
3037 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
3039 if (method
&& fns_ptr
&& index
>= 0
3040 && TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
3046 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3048 static enum oload_classification
3049 classify_oload_match (struct badness_vector
*oload_champ_bv
,
3055 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
3057 /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3058 or worse return INCOMPATIBLE. */
3059 if (compare_ranks (oload_champ_bv
->rank
[ix
],
3060 INCOMPATIBLE_TYPE_BADNESS
) <= 0)
3061 return INCOMPATIBLE
; /* Truly mismatched types. */
3062 /* Otherwise If this conversion is as bad as
3063 NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3064 else if (compare_ranks (oload_champ_bv
->rank
[ix
],
3065 NS_POINTER_CONVERSION_BADNESS
) <= 0)
3066 return NON_STANDARD
; /* Non-standard type conversions
3070 return STANDARD
; /* Only standard conversions needed. */
3073 /* C++: return 1 is NAME is a legitimate name for the destructor of
3074 type TYPE. If TYPE does not have a destructor, or if NAME is
3075 inappropriate for TYPE, an error is signaled. */
3077 destructor_name_p (const char *name
, const struct type
*type
)
3081 char *dname
= type_name_no_tag (type
);
3082 char *cp
= strchr (dname
, '<');
3085 /* Do not compare the template part for template classes. */
3087 len
= strlen (dname
);
3090 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
3091 error (_("name of destructor must equal name of class"));
3098 /* Given TYPE, a structure/union,
3099 return 1 if the component named NAME from the ultimate target
3100 structure/union is defined, otherwise, return 0. */
3103 check_field (struct type
*type
, const char *name
)
3107 /* The type may be a stub. */
3108 CHECK_TYPEDEF (type
);
3110 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
3112 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
3114 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
3118 /* C++: If it was not found as a data field, then try to return it
3119 as a pointer to a method. */
3121 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
3123 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
3127 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
3128 if (check_field (TYPE_BASECLASS (type
, i
), name
))
3134 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3135 return the appropriate member (or the address of the member, if
3136 WANT_ADDRESS). This function is used to resolve user expressions
3137 of the form "DOMAIN::NAME". For more details on what happens, see
3138 the comment before value_struct_elt_for_reference. */
3141 value_aggregate_elt (struct type
*curtype
, char *name
,
3142 struct type
*expect_type
, int want_address
,
3145 switch (TYPE_CODE (curtype
))
3147 case TYPE_CODE_STRUCT
:
3148 case TYPE_CODE_UNION
:
3149 return value_struct_elt_for_reference (curtype
, 0, curtype
,
3151 want_address
, noside
);
3152 case TYPE_CODE_NAMESPACE
:
3153 return value_namespace_elt (curtype
, name
,
3154 want_address
, noside
);
3156 internal_error (__FILE__
, __LINE__
,
3157 _("non-aggregate type in value_aggregate_elt"));
3161 /* Compares the two method/function types T1 and T2 for "equality"
3162 with respect to the the methods' parameters. If the types of the
3163 two parameter lists are the same, returns 1; 0 otherwise. This
3164 comparison may ignore any artificial parameters in T1 if
3165 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3166 the first artificial parameter in T1, assumed to be a 'this' pointer.
3168 The type T2 is expected to have come from make_params (in eval.c). */
3171 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
3175 if (TYPE_NFIELDS (t1
) > 0 && TYPE_FIELD_ARTIFICIAL (t1
, 0))
3178 /* If skipping artificial fields, find the first real field
3180 if (skip_artificial
)
3182 while (start
< TYPE_NFIELDS (t1
)
3183 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
3187 /* Now compare parameters. */
3189 /* Special case: a method taking void. T1 will contain no
3190 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3191 if ((TYPE_NFIELDS (t1
) - start
) == 0 && TYPE_NFIELDS (t2
) == 1
3192 && TYPE_CODE (TYPE_FIELD_TYPE (t2
, 0)) == TYPE_CODE_VOID
)
3195 if ((TYPE_NFIELDS (t1
) - start
) == TYPE_NFIELDS (t2
))
3199 for (i
= 0; i
< TYPE_NFIELDS (t2
); ++i
)
3201 if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1
, start
+ i
),
3202 TYPE_FIELD_TYPE (t2
, i
)),
3203 EXACT_MATCH_BADNESS
) != 0)
3213 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3214 return the address of this member as a "pointer to member" type.
3215 If INTYPE is non-null, then it will be the type of the member we
3216 are looking for. This will help us resolve "pointers to member
3217 functions". This function is used to resolve user expressions of
3218 the form "DOMAIN::NAME". */
3220 static struct value
*
3221 value_struct_elt_for_reference (struct type
*domain
, int offset
,
3222 struct type
*curtype
, char *name
,
3223 struct type
*intype
,
3227 struct type
*t
= curtype
;
3229 struct value
*v
, *result
;
3231 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
3232 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
3233 error (_("Internal error: non-aggregate type "
3234 "to value_struct_elt_for_reference"));
3236 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
3238 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
3240 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3242 if (field_is_static (&TYPE_FIELD (t
, i
)))
3244 v
= value_static_field (t
, i
);
3246 error (_("static field %s has been optimized out"),
3252 if (TYPE_FIELD_PACKED (t
, i
))
3253 error (_("pointers to bitfield members not allowed"));
3256 return value_from_longest
3257 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
3258 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
3259 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3260 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
3262 error (_("Cannot reference non-static field \"%s\""), name
);
3266 /* C++: If it was not found as a data field, then try to return it
3267 as a pointer to a method. */
3269 /* Perform all necessary dereferencing. */
3270 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
3271 intype
= TYPE_TARGET_TYPE (intype
);
3273 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
3275 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
3276 char dem_opname
[64];
3278 if (strncmp (t_field_name
, "__", 2) == 0
3279 || strncmp (t_field_name
, "op", 2) == 0
3280 || strncmp (t_field_name
, "type", 4) == 0)
3282 if (cplus_demangle_opname (t_field_name
,
3283 dem_opname
, DMGL_ANSI
))
3284 t_field_name
= dem_opname
;
3285 else if (cplus_demangle_opname (t_field_name
,
3287 t_field_name
= dem_opname
;
3289 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
3292 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3293 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
3295 check_stub_method_group (t
, i
);
3299 for (j
= 0; j
< len
; ++j
)
3301 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3302 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
),
3308 error (_("no member function matches "
3309 "that type instantiation"));
3316 for (ii
= 0; ii
< TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3319 /* Skip artificial methods. This is necessary if,
3320 for example, the user wants to "print
3321 subclass::subclass" with only one user-defined
3322 constructor. There is no ambiguity in this
3324 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3327 /* Desired method is ambiguous if more than one
3328 method is defined. */
3330 error (_("non-unique member `%s' requires "
3331 "type instantiation"), name
);
3337 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3340 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3347 return value_addr (read_var_value (s
, 0));
3349 return read_var_value (s
, 0);
3352 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3356 result
= allocate_value
3357 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3358 cplus_make_method_ptr (value_type (result
),
3359 value_contents_writeable (result
),
3360 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3362 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3363 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3365 error (_("Cannot reference virtual member function \"%s\""),
3371 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3377 v
= read_var_value (s
, 0);
3382 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3383 cplus_make_method_ptr (value_type (result
),
3384 value_contents_writeable (result
),
3385 value_address (v
), 0);
3391 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3396 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3399 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3400 v
= value_struct_elt_for_reference (domain
,
3401 offset
+ base_offset
,
3402 TYPE_BASECLASS (t
, i
),
3404 want_address
, noside
);
3409 /* As a last chance, pretend that CURTYPE is a namespace, and look
3410 it up that way; this (frequently) works for types nested inside
3413 return value_maybe_namespace_elt (curtype
, name
,
3414 want_address
, noside
);
3417 /* C++: Return the member NAME of the namespace given by the type
3420 static struct value
*
3421 value_namespace_elt (const struct type
*curtype
,
3422 char *name
, int want_address
,
3425 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3430 error (_("No symbol \"%s\" in namespace \"%s\"."),
3431 name
, TYPE_TAG_NAME (curtype
));
3436 /* A helper function used by value_namespace_elt and
3437 value_struct_elt_for_reference. It looks up NAME inside the
3438 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3439 is a class and NAME refers to a type in CURTYPE itself (as opposed
3440 to, say, some base class of CURTYPE). */
3442 static struct value
*
3443 value_maybe_namespace_elt (const struct type
*curtype
,
3444 char *name
, int want_address
,
3447 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
3449 struct value
*result
;
3451 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3452 get_selected_block (0), VAR_DOMAIN
);
3456 char *concatenated_name
= alloca (strlen (namespace_name
) + 2
3457 + strlen (name
) + 1);
3459 sprintf (concatenated_name
, "%s::%s", namespace_name
, name
);
3460 sym
= lookup_static_symbol_aux (concatenated_name
, VAR_DOMAIN
);
3465 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3466 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
3467 result
= allocate_value (SYMBOL_TYPE (sym
));
3469 result
= value_of_variable (sym
, get_selected_block (0));
3471 if (result
&& want_address
)
3472 result
= value_addr (result
);
3477 /* Given a pointer value V, find the real (RTTI) type of the object it
3480 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3481 and refer to the values computed for the object pointed to. */
3484 value_rtti_target_type (struct value
*v
, int *full
,
3485 int *top
, int *using_enc
)
3487 struct value
*target
;
3489 target
= value_ind (v
);
3491 return value_rtti_type (target
, full
, top
, using_enc
);
3494 /* Given a value pointed to by ARGP, check its real run-time type, and
3495 if that is different from the enclosing type, create a new value
3496 using the real run-time type as the enclosing type (and of the same
3497 type as ARGP) and return it, with the embedded offset adjusted to
3498 be the correct offset to the enclosed object. RTYPE is the type,
3499 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3500 by value_rtti_type(). If these are available, they can be supplied
3501 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3502 NULL if they're not available. */
3505 value_full_object (struct value
*argp
,
3507 int xfull
, int xtop
,
3510 struct type
*real_type
;
3514 struct value
*new_val
;
3521 using_enc
= xusing_enc
;
3524 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3526 /* If no RTTI data, or if object is already complete, do nothing. */
3527 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3530 /* If we have the full object, but for some reason the enclosing
3531 type is wrong, set it. */
3532 /* pai: FIXME -- sounds iffy */
3535 argp
= value_copy (argp
);
3536 set_value_enclosing_type (argp
, real_type
);
3540 /* Check if object is in memory. */
3541 if (VALUE_LVAL (argp
) != lval_memory
)
3543 warning (_("Couldn't retrieve complete object of RTTI "
3544 "type %s; object may be in register(s)."),
3545 TYPE_NAME (real_type
));
3550 /* All other cases -- retrieve the complete object. */
3551 /* Go back by the computed top_offset from the beginning of the
3552 object, adjusting for the embedded offset of argp if that's what
3553 value_rtti_type used for its computation. */
3554 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3555 (using_enc
? 0 : value_embedded_offset (argp
)));
3556 deprecated_set_value_type (new_val
, value_type (argp
));
3557 set_value_embedded_offset (new_val
, (using_enc
3558 ? top
+ value_embedded_offset (argp
)
3564 /* Return the value of the local variable, if one exists.
3565 Flag COMPLAIN signals an error if the request is made in an
3566 inappropriate context. */
3569 value_of_local (const char *name
, int complain
)
3571 struct symbol
*func
, *sym
;
3574 struct frame_info
*frame
;
3577 frame
= get_selected_frame (_("no frame selected"));
3580 frame
= deprecated_safe_get_selected_frame ();
3585 func
= get_frame_function (frame
);
3589 error (_("no `%s' in nameless context"), name
);
3594 b
= SYMBOL_BLOCK_VALUE (func
);
3595 if (dict_empty (BLOCK_DICT (b
)))
3598 error (_("no args, no `%s'"), name
);
3603 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3604 symbol instead of the LOC_ARG one (if both exist). */
3605 sym
= lookup_block_symbol (b
, name
, VAR_DOMAIN
);
3609 error (_("current stack frame does not contain a variable named `%s'"),
3615 ret
= read_var_value (sym
, frame
);
3616 if (ret
== 0 && complain
)
3617 error (_("`%s' argument unreadable"), name
);
3621 /* C++/Objective-C: return the value of the class instance variable,
3622 if one exists. Flag COMPLAIN signals an error if the request is
3623 made in an inappropriate context. */
3626 value_of_this (int complain
)
3628 if (!current_language
->la_name_of_this
)
3630 return value_of_local (current_language
->la_name_of_this
, complain
);
3633 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3634 elements long, starting at LOWBOUND. The result has the same lower
3635 bound as the original ARRAY. */
3638 value_slice (struct value
*array
, int lowbound
, int length
)
3640 struct type
*slice_range_type
, *slice_type
, *range_type
;
3641 LONGEST lowerbound
, upperbound
;
3642 struct value
*slice
;
3643 struct type
*array_type
;
3645 array_type
= check_typedef (value_type (array
));
3646 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3647 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3648 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3649 error (_("cannot take slice of non-array"));
3651 range_type
= TYPE_INDEX_TYPE (array_type
);
3652 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3653 error (_("slice from bad array or bitstring"));
3655 if (lowbound
< lowerbound
|| length
< 0
3656 || lowbound
+ length
- 1 > upperbound
)
3657 error (_("slice out of range"));
3659 /* FIXME-type-allocation: need a way to free this type when we are
3661 slice_range_type
= create_range_type ((struct type
*) NULL
,
3662 TYPE_TARGET_TYPE (range_type
),
3664 lowbound
+ length
- 1);
3665 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3669 slice_type
= create_set_type ((struct type
*) NULL
,
3671 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3672 slice
= value_zero (slice_type
, not_lval
);
3674 for (i
= 0; i
< length
; i
++)
3676 int element
= value_bit_index (array_type
,
3677 value_contents (array
),
3681 error (_("internal error accessing bitstring"));
3682 else if (element
> 0)
3684 int j
= i
% TARGET_CHAR_BIT
;
3686 if (gdbarch_bits_big_endian (get_type_arch (array_type
)))
3687 j
= TARGET_CHAR_BIT
- 1 - j
;
3688 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3691 /* We should set the address, bitssize, and bitspos, so the
3692 slice can be used on the LHS, but that may require extensions
3693 to value_assign. For now, just leave as a non_lval.
3698 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3700 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3702 slice_type
= create_array_type ((struct type
*) NULL
,
3705 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3707 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3708 slice
= allocate_value_lazy (slice_type
);
3711 slice
= allocate_value (slice_type
);
3712 value_contents_copy (slice
, 0, array
, offset
,
3713 TYPE_LENGTH (slice_type
));
3716 set_value_component_location (slice
, array
);
3717 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
3718 set_value_offset (slice
, value_offset (array
) + offset
);
3723 /* Create a value for a FORTRAN complex number. Currently most of the
3724 time values are coerced to COMPLEX*16 (i.e. a complex number
3725 composed of 2 doubles. This really should be a smarter routine
3726 that figures out precision inteligently as opposed to assuming
3727 doubles. FIXME: fmb */
3730 value_literal_complex (struct value
*arg1
,
3735 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3737 val
= allocate_value (type
);
3738 arg1
= value_cast (real_type
, arg1
);
3739 arg2
= value_cast (real_type
, arg2
);
3741 memcpy (value_contents_raw (val
),
3742 value_contents (arg1
), TYPE_LENGTH (real_type
));
3743 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3744 value_contents (arg2
), TYPE_LENGTH (real_type
));
3748 /* Cast a value into the appropriate complex data type. */
3750 static struct value
*
3751 cast_into_complex (struct type
*type
, struct value
*val
)
3753 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3755 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3757 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3758 struct value
*re_val
= allocate_value (val_real_type
);
3759 struct value
*im_val
= allocate_value (val_real_type
);
3761 memcpy (value_contents_raw (re_val
),
3762 value_contents (val
), TYPE_LENGTH (val_real_type
));
3763 memcpy (value_contents_raw (im_val
),
3764 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3765 TYPE_LENGTH (val_real_type
));
3767 return value_literal_complex (re_val
, im_val
, type
);
3769 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3770 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3771 return value_literal_complex (val
,
3772 value_zero (real_type
, not_lval
),
3775 error (_("cannot cast non-number to complex"));
3779 _initialize_valops (void)
3781 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3782 &overload_resolution
, _("\
3783 Set overload resolution in evaluating C++ functions."), _("\
3784 Show overload resolution in evaluating C++ functions."),
3786 show_overload_resolution
,
3787 &setlist
, &showlist
);
3788 overload_resolution
= 1;