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 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
37 #include "dictionary.h"
38 #include "cp-support.h"
40 #include "user-regs.h"
43 #include "gdb_string.h"
44 #include "gdb_assert.h"
45 #include "cp-support.h"
50 extern int overload_debug
;
51 /* Local functions. */
53 static int typecmp (int staticp
, int varargs
, int nargs
,
54 struct field t1
[], struct value
*t2
[]);
56 static struct value
*search_struct_field (const char *, struct value
*,
57 int, struct type
*, int);
59 static struct value
*search_struct_method (const char *, struct value
**,
61 int, int *, struct type
*);
63 static int find_oload_champ_namespace (struct type
**, int,
64 const char *, const char *,
66 struct badness_vector
**);
69 int find_oload_champ_namespace_loop (struct type
**, int,
70 const char *, const char *,
71 int, struct symbol
***,
72 struct badness_vector
**, int *);
74 static int find_oload_champ (struct type
**, int, int, int,
75 struct fn_field
*, struct symbol
**,
76 struct badness_vector
**);
78 static int oload_method_static (int, struct fn_field
*, int);
80 enum oload_classification
{ STANDARD
, NON_STANDARD
, INCOMPATIBLE
};
83 oload_classification
classify_oload_match (struct badness_vector
*,
86 static struct value
*value_struct_elt_for_reference (struct type
*,
92 static struct value
*value_namespace_elt (const struct type
*,
93 char *, int , enum noside
);
95 static struct value
*value_maybe_namespace_elt (const struct type
*,
99 static CORE_ADDR
allocate_space_in_inferior (int);
101 static struct value
*cast_into_complex (struct type
*, struct value
*);
103 static struct fn_field
*find_method_list (struct value
**, const char *,
104 int, struct type
*, int *,
105 struct type
**, int *);
107 void _initialize_valops (void);
110 /* Flag for whether we want to abandon failed expression evals by
113 static int auto_abandon
= 0;
116 int overload_resolution
= 0;
118 show_overload_resolution (struct ui_file
*file
, int from_tty
,
119 struct cmd_list_element
*c
,
122 fprintf_filtered (file
, _("\
123 Overload resolution in evaluating C++ functions is %s.\n"),
127 /* Find the address of function name NAME in the inferior. If OBJF_P
128 is non-NULL, *OBJF_P will be set to the OBJFILE where the function
132 find_function_in_inferior (const char *name
, struct objfile
**objf_p
)
135 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
138 if (SYMBOL_CLASS (sym
) != LOC_BLOCK
)
140 error (_("\"%s\" exists in this program but is not a function."),
145 *objf_p
= SYMBOL_SYMTAB (sym
)->objfile
;
147 return value_of_variable (sym
, NULL
);
151 struct minimal_symbol
*msymbol
=
152 lookup_minimal_symbol (name
, NULL
, NULL
);
155 struct objfile
*objfile
= msymbol_objfile (msymbol
);
156 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
160 type
= lookup_pointer_type (builtin_type (gdbarch
)->builtin_char
);
161 type
= lookup_function_type (type
);
162 type
= lookup_pointer_type (type
);
163 maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
168 return value_from_pointer (type
, maddr
);
172 if (!target_has_execution
)
173 error (_("evaluation of this expression requires the target program to be active"));
175 error (_("evaluation of this expression requires the program to have a function \"%s\"."), name
);
180 /* Allocate NBYTES of space in the inferior using the inferior's
181 malloc and return a value that is a pointer to the allocated
185 value_allocate_space_in_inferior (int len
)
187 struct objfile
*objf
;
188 struct value
*val
= find_function_in_inferior ("malloc", &objf
);
189 struct gdbarch
*gdbarch
= get_objfile_arch (objf
);
190 struct value
*blocklen
;
192 blocklen
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, len
);
193 val
= call_function_by_hand (val
, 1, &blocklen
);
194 if (value_logical_not (val
))
196 if (!target_has_execution
)
197 error (_("No memory available to program now: you need to start the target first"));
199 error (_("No memory available to program: call to malloc failed"));
205 allocate_space_in_inferior (int len
)
207 return value_as_long (value_allocate_space_in_inferior (len
));
210 /* Cast struct value VAL to type TYPE and return as a value.
211 Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
212 for this to work. Typedef to one of the codes is permitted.
213 Returns NULL if the cast is neither an upcast nor a downcast. */
215 static struct value
*
216 value_cast_structs (struct type
*type
, struct value
*v2
)
222 gdb_assert (type
!= NULL
&& v2
!= NULL
);
224 t1
= check_typedef (type
);
225 t2
= check_typedef (value_type (v2
));
227 /* Check preconditions. */
228 gdb_assert ((TYPE_CODE (t1
) == TYPE_CODE_STRUCT
229 || TYPE_CODE (t1
) == TYPE_CODE_UNION
)
230 && !!"Precondition is that type is of STRUCT or UNION kind.");
231 gdb_assert ((TYPE_CODE (t2
) == TYPE_CODE_STRUCT
232 || TYPE_CODE (t2
) == TYPE_CODE_UNION
)
233 && !!"Precondition is that value is of STRUCT or UNION kind");
235 if (TYPE_NAME (t1
) != NULL
236 && TYPE_NAME (t2
) != NULL
237 && !strcmp (TYPE_NAME (t1
), TYPE_NAME (t2
)))
240 /* Upcasting: look in the type of the source to see if it contains the
241 type of the target as a superclass. If so, we'll need to
242 offset the pointer rather than just change its type. */
243 if (TYPE_NAME (t1
) != NULL
)
245 v
= search_struct_field (type_name_no_tag (t1
),
251 /* Downcasting: look in the type of the target to see if it contains the
252 type of the source as a superclass. If so, we'll need to
253 offset the pointer rather than just change its type. */
254 if (TYPE_NAME (t2
) != NULL
)
256 /* Try downcasting using the run-time type of the value. */
257 int full
, top
, using_enc
;
258 struct type
*real_type
;
260 real_type
= value_rtti_type (v2
, &full
, &top
, &using_enc
);
263 v
= value_full_object (v2
, real_type
, full
, top
, using_enc
);
264 v
= value_at_lazy (real_type
, value_address (v
));
266 /* We might be trying to cast to the outermost enclosing
267 type, in which case search_struct_field won't work. */
268 if (TYPE_NAME (real_type
) != NULL
269 && !strcmp (TYPE_NAME (real_type
), TYPE_NAME (t1
)))
272 v
= search_struct_field (type_name_no_tag (t2
), v
, 0, real_type
, 1);
277 /* Try downcasting using information from the destination type
278 T2. This wouldn't work properly for classes with virtual
279 bases, but those were handled above. */
280 v
= search_struct_field (type_name_no_tag (t2
),
281 value_zero (t1
, not_lval
), 0, t1
, 1);
284 /* Downcasting is possible (t1 is superclass of v2). */
285 CORE_ADDR addr2
= value_address (v2
);
286 addr2
-= value_address (v
) + value_embedded_offset (v
);
287 return value_at (type
, addr2
);
294 /* Cast one pointer or reference type to another. Both TYPE and
295 the type of ARG2 should be pointer types, or else both should be
296 reference types. Returns the new pointer or reference. */
299 value_cast_pointers (struct type
*type
, struct value
*arg2
)
301 struct type
*type1
= check_typedef (type
);
302 struct type
*type2
= check_typedef (value_type (arg2
));
303 struct type
*t1
= check_typedef (TYPE_TARGET_TYPE (type
));
304 struct type
*t2
= check_typedef (TYPE_TARGET_TYPE (type2
));
306 if (TYPE_CODE (t1
) == TYPE_CODE_STRUCT
307 && TYPE_CODE (t2
) == TYPE_CODE_STRUCT
308 && !value_logical_not (arg2
))
312 if (TYPE_CODE (type2
) == TYPE_CODE_REF
)
313 v2
= coerce_ref (arg2
);
315 v2
= value_ind (arg2
);
316 gdb_assert (TYPE_CODE (check_typedef (value_type (v2
))) == TYPE_CODE_STRUCT
317 && !!"Why did coercion fail?");
318 v2
= value_cast_structs (t1
, v2
);
319 /* At this point we have what we can have, un-dereference if needed. */
322 struct value
*v
= value_addr (v2
);
323 deprecated_set_value_type (v
, type
);
328 /* No superclass found, just change the pointer type. */
329 arg2
= value_copy (arg2
);
330 deprecated_set_value_type (arg2
, type
);
331 arg2
= value_change_enclosing_type (arg2
, type
);
332 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
336 /* Cast value ARG2 to type TYPE and return as a value.
337 More general than a C cast: accepts any two types of the same length,
338 and if ARG2 is an lvalue it can be cast into anything at all. */
339 /* In C++, casts may change pointer or object representations. */
342 value_cast (struct type
*type
, struct value
*arg2
)
344 enum type_code code1
;
345 enum type_code code2
;
349 int convert_to_boolean
= 0;
351 if (value_type (arg2
) == type
)
354 code1
= TYPE_CODE (check_typedef (type
));
356 /* Check if we are casting struct reference to struct reference. */
357 if (code1
== TYPE_CODE_REF
)
359 /* We dereference type; then we recurse and finally
360 we generate value of the given reference. Nothing wrong with
362 struct type
*t1
= check_typedef (type
);
363 struct type
*dereftype
= check_typedef (TYPE_TARGET_TYPE (t1
));
364 struct value
*val
= value_cast (dereftype
, arg2
);
365 return value_ref (val
);
368 code2
= TYPE_CODE (check_typedef (value_type (arg2
)));
370 if (code2
== TYPE_CODE_REF
)
371 /* We deref the value and then do the cast. */
372 return value_cast (type
, coerce_ref (arg2
));
374 CHECK_TYPEDEF (type
);
375 code1
= TYPE_CODE (type
);
376 arg2
= coerce_ref (arg2
);
377 type2
= check_typedef (value_type (arg2
));
379 /* You can't cast to a reference type. See value_cast_pointers
381 gdb_assert (code1
!= TYPE_CODE_REF
);
383 /* A cast to an undetermined-length array_type, such as
384 (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
385 where N is sizeof(OBJECT)/sizeof(TYPE). */
386 if (code1
== TYPE_CODE_ARRAY
)
388 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
389 unsigned element_length
= TYPE_LENGTH (check_typedef (element_type
));
390 if (element_length
> 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
392 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
393 int val_length
= TYPE_LENGTH (type2
);
394 LONGEST low_bound
, high_bound
, new_length
;
395 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
396 low_bound
= 0, high_bound
= 0;
397 new_length
= val_length
/ element_length
;
398 if (val_length
% element_length
!= 0)
399 warning (_("array element type size does not divide object size in cast"));
400 /* FIXME-type-allocation: need a way to free this type when
401 we are done with it. */
402 range_type
= create_range_type ((struct type
*) NULL
,
403 TYPE_TARGET_TYPE (range_type
),
405 new_length
+ low_bound
- 1);
406 deprecated_set_value_type (arg2
,
407 create_array_type ((struct type
*) NULL
,
414 if (current_language
->c_style_arrays
415 && TYPE_CODE (type2
) == TYPE_CODE_ARRAY
)
416 arg2
= value_coerce_array (arg2
);
418 if (TYPE_CODE (type2
) == TYPE_CODE_FUNC
)
419 arg2
= value_coerce_function (arg2
);
421 type2
= check_typedef (value_type (arg2
));
422 code2
= TYPE_CODE (type2
);
424 if (code1
== TYPE_CODE_COMPLEX
)
425 return cast_into_complex (type
, arg2
);
426 if (code1
== TYPE_CODE_BOOL
)
428 code1
= TYPE_CODE_INT
;
429 convert_to_boolean
= 1;
431 if (code1
== TYPE_CODE_CHAR
)
432 code1
= TYPE_CODE_INT
;
433 if (code2
== TYPE_CODE_BOOL
|| code2
== TYPE_CODE_CHAR
)
434 code2
= TYPE_CODE_INT
;
436 scalar
= (code2
== TYPE_CODE_INT
|| code2
== TYPE_CODE_FLT
437 || code2
== TYPE_CODE_DECFLOAT
|| code2
== TYPE_CODE_ENUM
438 || code2
== TYPE_CODE_RANGE
);
440 if ((code1
== TYPE_CODE_STRUCT
|| code1
== TYPE_CODE_UNION
)
441 && (code2
== TYPE_CODE_STRUCT
|| code2
== TYPE_CODE_UNION
)
442 && TYPE_NAME (type
) != 0)
444 struct value
*v
= value_cast_structs (type
, arg2
);
449 if (code1
== TYPE_CODE_FLT
&& scalar
)
450 return value_from_double (type
, value_as_double (arg2
));
451 else if (code1
== TYPE_CODE_DECFLOAT
&& scalar
)
453 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
454 int dec_len
= TYPE_LENGTH (type
);
457 if (code2
== TYPE_CODE_FLT
)
458 decimal_from_floating (arg2
, dec
, dec_len
, byte_order
);
459 else if (code2
== TYPE_CODE_DECFLOAT
)
460 decimal_convert (value_contents (arg2
), TYPE_LENGTH (type2
),
461 byte_order
, dec
, dec_len
, byte_order
);
463 /* The only option left is an integral type. */
464 decimal_from_integral (arg2
, dec
, dec_len
, byte_order
);
466 return value_from_decfloat (type
, dec
);
468 else if ((code1
== TYPE_CODE_INT
|| code1
== TYPE_CODE_ENUM
469 || code1
== TYPE_CODE_RANGE
)
470 && (scalar
|| code2
== TYPE_CODE_PTR
471 || code2
== TYPE_CODE_MEMBERPTR
))
475 /* When we cast pointers to integers, we mustn't use
476 gdbarch_pointer_to_address to find the address the pointer
477 represents, as value_as_long would. GDB should evaluate
478 expressions just as the compiler would --- and the compiler
479 sees a cast as a simple reinterpretation of the pointer's
481 if (code2
== TYPE_CODE_PTR
)
482 longest
= extract_unsigned_integer
483 (value_contents (arg2
), TYPE_LENGTH (type2
),
484 gdbarch_byte_order (get_type_arch (type2
)));
486 longest
= value_as_long (arg2
);
487 return value_from_longest (type
, convert_to_boolean
?
488 (LONGEST
) (longest
? 1 : 0) : longest
);
490 else if (code1
== TYPE_CODE_PTR
&& (code2
== TYPE_CODE_INT
491 || code2
== TYPE_CODE_ENUM
492 || code2
== TYPE_CODE_RANGE
))
494 /* TYPE_LENGTH (type) is the length of a pointer, but we really
495 want the length of an address! -- we are really dealing with
496 addresses (i.e., gdb representations) not pointers (i.e.,
497 target representations) here.
499 This allows things like "print *(int *)0x01000234" to work
500 without printing a misleading message -- which would
501 otherwise occur when dealing with a target having two byte
502 pointers and four byte addresses. */
504 int addr_bit
= gdbarch_addr_bit (get_type_arch (type2
));
506 LONGEST longest
= value_as_long (arg2
);
507 if (addr_bit
< sizeof (LONGEST
) * HOST_CHAR_BIT
)
509 if (longest
>= ((LONGEST
) 1 << addr_bit
)
510 || longest
<= -((LONGEST
) 1 << addr_bit
))
511 warning (_("value truncated"));
513 return value_from_longest (type
, longest
);
515 else if (code1
== TYPE_CODE_METHODPTR
&& code2
== TYPE_CODE_INT
516 && value_as_long (arg2
) == 0)
518 struct value
*result
= allocate_value (type
);
519 cplus_make_method_ptr (type
, value_contents_writeable (result
), 0, 0);
522 else if (code1
== TYPE_CODE_MEMBERPTR
&& code2
== TYPE_CODE_INT
523 && value_as_long (arg2
) == 0)
525 /* The Itanium C++ ABI represents NULL pointers to members as
526 minus one, instead of biasing the normal case. */
527 return value_from_longest (type
, -1);
529 else if (TYPE_LENGTH (type
) == TYPE_LENGTH (type2
))
531 if (code1
== TYPE_CODE_PTR
&& code2
== TYPE_CODE_PTR
)
532 return value_cast_pointers (type
, arg2
);
534 arg2
= value_copy (arg2
);
535 deprecated_set_value_type (arg2
, type
);
536 arg2
= value_change_enclosing_type (arg2
, type
);
537 set_value_pointed_to_offset (arg2
, 0); /* pai: chk_val */
540 else if (VALUE_LVAL (arg2
) == lval_memory
)
541 return value_at_lazy (type
, value_address (arg2
));
542 else if (code1
== TYPE_CODE_VOID
)
544 return value_zero (type
, not_lval
);
548 error (_("Invalid cast."));
553 /* The C++ reinterpret_cast operator. */
556 value_reinterpret_cast (struct type
*type
, struct value
*arg
)
558 struct value
*result
;
559 struct type
*real_type
= check_typedef (type
);
560 struct type
*arg_type
, *dest_type
;
562 enum type_code dest_code
, arg_code
;
564 /* Do reference, function, and array conversion. */
565 arg
= coerce_array (arg
);
567 /* Attempt to preserve the type the user asked for. */
570 /* If we are casting to a reference type, transform
571 reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
572 if (TYPE_CODE (real_type
) == TYPE_CODE_REF
)
575 arg
= value_addr (arg
);
576 dest_type
= lookup_pointer_type (TYPE_TARGET_TYPE (dest_type
));
577 real_type
= lookup_pointer_type (real_type
);
580 arg_type
= value_type (arg
);
582 dest_code
= TYPE_CODE (real_type
);
583 arg_code
= TYPE_CODE (arg_type
);
585 /* We can convert pointer types, or any pointer type to int, or int
587 if ((dest_code
== TYPE_CODE_PTR
&& arg_code
== TYPE_CODE_INT
)
588 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_PTR
)
589 || (dest_code
== TYPE_CODE_METHODPTR
&& arg_code
== TYPE_CODE_INT
)
590 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_METHODPTR
)
591 || (dest_code
== TYPE_CODE_MEMBERPTR
&& arg_code
== TYPE_CODE_INT
)
592 || (dest_code
== TYPE_CODE_INT
&& arg_code
== TYPE_CODE_MEMBERPTR
)
593 || (dest_code
== arg_code
594 && (dest_code
== TYPE_CODE_PTR
595 || dest_code
== TYPE_CODE_METHODPTR
596 || dest_code
== TYPE_CODE_MEMBERPTR
)))
597 result
= value_cast (dest_type
, arg
);
599 error (_("Invalid reinterpret_cast"));
602 result
= value_cast (type
, value_ref (value_ind (result
)));
607 /* A helper for value_dynamic_cast. This implements the first of two
608 runtime checks: we iterate over all the base classes of the value's
609 class which are equal to the desired class; if only one of these
610 holds the value, then it is the answer. */
613 dynamic_cast_check_1 (struct type
*desired_type
,
614 const bfd_byte
*contents
,
616 struct type
*search_type
,
618 struct type
*arg_type
,
619 struct value
**result
)
621 int i
, result_count
= 0;
623 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
625 int offset
= baseclass_offset (search_type
, i
, contents
, address
);
627 error (_("virtual baseclass botch"));
628 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
630 if (address
+ offset
>= arg_addr
631 && address
+ offset
< arg_addr
+ TYPE_LENGTH (arg_type
))
635 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
640 result_count
+= dynamic_cast_check_1 (desired_type
,
643 TYPE_BASECLASS (search_type
, i
),
652 /* A helper for value_dynamic_cast. This implements the second of two
653 runtime checks: we look for a unique public sibling class of the
654 argument's declared class. */
657 dynamic_cast_check_2 (struct type
*desired_type
,
658 const bfd_byte
*contents
,
660 struct type
*search_type
,
661 struct value
**result
)
663 int i
, result_count
= 0;
665 for (i
= 0; i
< TYPE_N_BASECLASSES (search_type
) && result_count
< 2; ++i
)
669 if (! BASETYPE_VIA_PUBLIC (search_type
, i
))
672 offset
= baseclass_offset (search_type
, i
, contents
, address
);
674 error (_("virtual baseclass botch"));
675 if (class_types_same_p (desired_type
, TYPE_BASECLASS (search_type
, i
)))
679 *result
= value_at_lazy (TYPE_BASECLASS (search_type
, i
),
683 result_count
+= dynamic_cast_check_2 (desired_type
,
686 TYPE_BASECLASS (search_type
, i
),
693 /* The C++ dynamic_cast operator. */
696 value_dynamic_cast (struct type
*type
, struct value
*arg
)
698 int unambiguous
= 0, full
, top
, using_enc
;
699 struct type
*resolved_type
= check_typedef (type
);
700 struct type
*arg_type
= check_typedef (value_type (arg
));
701 struct type
*class_type
, *rtti_type
;
702 struct value
*result
, *tem
, *original_arg
= arg
;
704 int is_ref
= TYPE_CODE (resolved_type
) == TYPE_CODE_REF
;
706 if (TYPE_CODE (resolved_type
) != TYPE_CODE_PTR
707 && TYPE_CODE (resolved_type
) != TYPE_CODE_REF
)
708 error (_("Argument to dynamic_cast must be a pointer or reference type"));
709 if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_VOID
710 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) != TYPE_CODE_CLASS
)
711 error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
713 class_type
= check_typedef (TYPE_TARGET_TYPE (resolved_type
));
714 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
716 if (TYPE_CODE (arg_type
) != TYPE_CODE_PTR
717 && ! (TYPE_CODE (arg_type
) == TYPE_CODE_INT
718 && value_as_long (arg
) == 0))
719 error (_("Argument to dynamic_cast does not have pointer type"));
720 if (TYPE_CODE (arg_type
) == TYPE_CODE_PTR
)
722 arg_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
723 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
724 error (_("Argument to dynamic_cast does not have pointer to class type"));
727 /* Handle NULL pointers. */
728 if (value_as_long (arg
) == 0)
729 return value_zero (type
, not_lval
);
731 arg
= value_ind (arg
);
735 if (TYPE_CODE (arg_type
) != TYPE_CODE_CLASS
)
736 error (_("Argument to dynamic_cast does not have class type"));
739 /* If the classes are the same, just return the argument. */
740 if (class_types_same_p (class_type
, arg_type
))
741 return value_cast (type
, arg
);
743 /* If the target type is a unique base class of the argument's
744 declared type, just cast it. */
745 if (is_ancestor (class_type
, arg_type
))
747 if (is_unique_ancestor (class_type
, arg
))
748 return value_cast (type
, original_arg
);
749 error (_("Ambiguous dynamic_cast"));
752 rtti_type
= value_rtti_type (arg
, &full
, &top
, &using_enc
);
754 error (_("Couldn't determine value's most derived type for dynamic_cast"));
756 /* Compute the most derived object's address. */
757 addr
= value_address (arg
);
765 addr
+= top
+ value_embedded_offset (arg
);
767 /* dynamic_cast<void *> means to return a pointer to the
768 most-derived object. */
769 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
770 && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type
)) == TYPE_CODE_VOID
)
771 return value_at_lazy (type
, addr
);
773 tem
= value_at (type
, addr
);
775 /* The first dynamic check specified in 5.2.7. */
776 if (is_public_ancestor (arg_type
, TYPE_TARGET_TYPE (resolved_type
)))
778 if (class_types_same_p (rtti_type
, TYPE_TARGET_TYPE (resolved_type
)))
781 if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type
),
782 value_contents (tem
), value_address (tem
),
786 return value_cast (type
,
787 is_ref
? value_ref (result
) : value_addr (result
));
790 /* The second dynamic check specified in 5.2.7. */
792 if (is_public_ancestor (arg_type
, rtti_type
)
793 && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type
),
794 value_contents (tem
), value_address (tem
),
795 rtti_type
, &result
) == 1)
796 return value_cast (type
,
797 is_ref
? value_ref (result
) : value_addr (result
));
799 if (TYPE_CODE (resolved_type
) == TYPE_CODE_PTR
)
800 return value_zero (type
, not_lval
);
802 error (_("dynamic_cast failed"));
805 /* Create a value of type TYPE that is zero, and return it. */
808 value_zero (struct type
*type
, enum lval_type lv
)
810 struct value
*val
= allocate_value (type
);
811 VALUE_LVAL (val
) = lv
;
816 /* Create a value of numeric type TYPE that is one, and return it. */
819 value_one (struct type
*type
, enum lval_type lv
)
821 struct type
*type1
= check_typedef (type
);
824 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
)
826 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
828 decimal_from_string (v
, TYPE_LENGTH (type
), byte_order
, "1");
829 val
= value_from_decfloat (type
, v
);
831 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
)
833 val
= value_from_double (type
, (DOUBLEST
) 1);
835 else if (is_integral_type (type1
))
837 val
= value_from_longest (type
, (LONGEST
) 1);
841 error (_("Not a numeric type."));
844 VALUE_LVAL (val
) = lv
;
848 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */
850 static struct value
*
851 get_value_at (struct type
*type
, CORE_ADDR addr
, int lazy
)
855 if (TYPE_CODE (check_typedef (type
)) == TYPE_CODE_VOID
)
856 error (_("Attempt to dereference a generic pointer."));
860 val
= allocate_value_lazy (type
);
864 val
= allocate_value (type
);
865 read_memory (addr
, value_contents_all_raw (val
), TYPE_LENGTH (type
));
868 VALUE_LVAL (val
) = lval_memory
;
869 set_value_address (val
, addr
);
874 /* Return a value with type TYPE located at ADDR.
876 Call value_at only if the data needs to be fetched immediately;
877 if we can be 'lazy' and defer the fetch, perhaps indefinately, call
878 value_at_lazy instead. value_at_lazy simply records the address of
879 the data and sets the lazy-evaluation-required flag. The lazy flag
880 is tested in the value_contents macro, which is used if and when
881 the contents are actually required.
883 Note: value_at does *NOT* handle embedded offsets; perform such
884 adjustments before or after calling it. */
887 value_at (struct type
*type
, CORE_ADDR addr
)
889 return get_value_at (type
, addr
, 0);
892 /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
895 value_at_lazy (struct type
*type
, CORE_ADDR addr
)
897 return get_value_at (type
, addr
, 1);
900 /* Called only from the value_contents and value_contents_all()
901 macros, if the current data for a variable needs to be loaded into
902 value_contents(VAL). Fetches the data from the user's process, and
903 clears the lazy flag to indicate that the data in the buffer is
906 If the value is zero-length, we avoid calling read_memory, which
907 would abort. We mark the value as fetched anyway -- all 0 bytes of
910 This function returns a value because it is used in the
911 value_contents macro as part of an expression, where a void would
912 not work. The value is ignored. */
915 value_fetch_lazy (struct value
*val
)
917 gdb_assert (value_lazy (val
));
918 allocate_value_contents (val
);
919 if (value_bitsize (val
))
921 /* To read a lazy bitfield, read the entire enclosing value. This
922 prevents reading the same block of (possibly volatile) memory once
923 per bitfield. It would be even better to read only the containing
924 word, but we have no way to record that just specific bits of a
925 value have been fetched. */
926 struct type
*type
= check_typedef (value_type (val
));
927 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
928 struct value
*parent
= value_parent (val
);
929 LONGEST offset
= value_offset (val
);
930 LONGEST num
= unpack_bits_as_long (value_type (val
),
931 value_contents (parent
) + offset
,
933 value_bitsize (val
));
934 int length
= TYPE_LENGTH (type
);
935 store_signed_integer (value_contents_raw (val
), length
, byte_order
, num
);
937 else if (VALUE_LVAL (val
) == lval_memory
)
939 CORE_ADDR addr
= value_address (val
);
940 int length
= TYPE_LENGTH (check_typedef (value_enclosing_type (val
)));
944 if (value_stack (val
))
945 read_stack (addr
, value_contents_all_raw (val
), length
);
947 read_memory (addr
, value_contents_all_raw (val
), length
);
950 else if (VALUE_LVAL (val
) == lval_register
)
952 struct frame_info
*frame
;
954 struct type
*type
= check_typedef (value_type (val
));
955 struct value
*new_val
= val
, *mark
= value_mark ();
957 /* Offsets are not supported here; lazy register values must
958 refer to the entire register. */
959 gdb_assert (value_offset (val
) == 0);
961 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
963 frame
= frame_find_by_id (VALUE_FRAME_ID (new_val
));
964 regnum
= VALUE_REGNUM (new_val
);
966 gdb_assert (frame
!= NULL
);
968 /* Convertible register routines are used for multi-register
969 values and for interpretation in different types
970 (e.g. float or int from a double register). Lazy
971 register values should have the register's natural type,
972 so they do not apply. */
973 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
976 new_val
= get_frame_register_value (frame
, regnum
);
979 /* If it's still lazy (for instance, a saved register on the
981 if (value_lazy (new_val
))
982 value_fetch_lazy (new_val
);
984 /* If the register was not saved, mark it unavailable. */
985 if (value_optimized_out (new_val
))
986 set_value_optimized_out (val
, 1);
988 memcpy (value_contents_raw (val
), value_contents (new_val
),
993 struct gdbarch
*gdbarch
;
994 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
995 regnum
= VALUE_REGNUM (val
);
996 gdbarch
= get_frame_arch (frame
);
998 fprintf_unfiltered (gdb_stdlog
, "\
999 { value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
1000 frame_relative_level (frame
), regnum
,
1001 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1003 fprintf_unfiltered (gdb_stdlog
, "->");
1004 if (value_optimized_out (new_val
))
1005 fprintf_unfiltered (gdb_stdlog
, " optimized out");
1009 const gdb_byte
*buf
= value_contents (new_val
);
1011 if (VALUE_LVAL (new_val
) == lval_register
)
1012 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1013 VALUE_REGNUM (new_val
));
1014 else if (VALUE_LVAL (new_val
) == lval_memory
)
1015 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1017 value_address (new_val
)));
1019 fprintf_unfiltered (gdb_stdlog
, " computed");
1021 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1022 fprintf_unfiltered (gdb_stdlog
, "[");
1023 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1024 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1025 fprintf_unfiltered (gdb_stdlog
, "]");
1028 fprintf_unfiltered (gdb_stdlog
, " }\n");
1031 /* Dispose of the intermediate values. This prevents
1032 watchpoints from trying to watch the saved frame pointer. */
1033 value_free_to_mark (mark
);
1035 else if (VALUE_LVAL (val
) == lval_computed
)
1036 value_computed_funcs (val
)->read (val
);
1038 internal_error (__FILE__
, __LINE__
, "Unexpected lazy value type.");
1040 set_value_lazy (val
, 0);
1045 /* Store the contents of FROMVAL into the location of TOVAL.
1046 Return a new value with the location of TOVAL and contents of FROMVAL. */
1049 value_assign (struct value
*toval
, struct value
*fromval
)
1053 struct frame_id old_frame
;
1055 if (!deprecated_value_modifiable (toval
))
1056 error (_("Left operand of assignment is not a modifiable lvalue."));
1058 toval
= coerce_ref (toval
);
1060 type
= value_type (toval
);
1061 if (VALUE_LVAL (toval
) != lval_internalvar
)
1063 toval
= value_coerce_to_target (toval
);
1064 fromval
= value_cast (type
, fromval
);
1068 /* Coerce arrays and functions to pointers, except for arrays
1069 which only live in GDB's storage. */
1070 if (!value_must_coerce_to_target (fromval
))
1071 fromval
= coerce_array (fromval
);
1074 CHECK_TYPEDEF (type
);
1076 /* Since modifying a register can trash the frame chain, and
1077 modifying memory can trash the frame cache, we save the old frame
1078 and then restore the new frame afterwards. */
1079 old_frame
= get_frame_id (deprecated_safe_get_selected_frame ());
1081 switch (VALUE_LVAL (toval
))
1083 case lval_internalvar
:
1084 set_internalvar (VALUE_INTERNALVAR (toval
), fromval
);
1085 val
= value_copy (fromval
);
1086 val
= value_change_enclosing_type (val
,
1087 value_enclosing_type (fromval
));
1088 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1089 set_value_pointed_to_offset (val
,
1090 value_pointed_to_offset (fromval
));
1093 case lval_internalvar_component
:
1094 set_internalvar_component (VALUE_INTERNALVAR (toval
),
1095 value_offset (toval
),
1096 value_bitpos (toval
),
1097 value_bitsize (toval
),
1103 const gdb_byte
*dest_buffer
;
1104 CORE_ADDR changed_addr
;
1106 gdb_byte buffer
[sizeof (LONGEST
)];
1108 if (value_bitsize (toval
))
1110 struct value
*parent
= value_parent (toval
);
1111 changed_addr
= value_address (parent
) + value_offset (toval
);
1113 changed_len
= (value_bitpos (toval
)
1114 + value_bitsize (toval
)
1115 + HOST_CHAR_BIT
- 1)
1118 /* If we can read-modify-write exactly the size of the
1119 containing type (e.g. short or int) then do so. This
1120 is safer for volatile bitfields mapped to hardware
1122 if (changed_len
< TYPE_LENGTH (type
)
1123 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
)
1124 && ((LONGEST
) changed_addr
% TYPE_LENGTH (type
)) == 0)
1125 changed_len
= TYPE_LENGTH (type
);
1127 if (changed_len
> (int) sizeof (LONGEST
))
1128 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1129 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1131 read_memory (changed_addr
, buffer
, changed_len
);
1132 modify_field (type
, buffer
, value_as_long (fromval
),
1133 value_bitpos (toval
), value_bitsize (toval
));
1134 dest_buffer
= buffer
;
1138 changed_addr
= value_address (toval
);
1139 changed_len
= TYPE_LENGTH (type
);
1140 dest_buffer
= value_contents (fromval
);
1143 write_memory (changed_addr
, dest_buffer
, changed_len
);
1144 observer_notify_memory_changed (changed_addr
, changed_len
,
1151 struct frame_info
*frame
;
1152 struct gdbarch
*gdbarch
;
1155 /* Figure out which frame this is in currently. */
1156 frame
= frame_find_by_id (VALUE_FRAME_ID (toval
));
1157 value_reg
= VALUE_REGNUM (toval
);
1160 error (_("Value being assigned to is no longer active."));
1162 gdbarch
= get_frame_arch (frame
);
1163 if (gdbarch_convert_register_p (gdbarch
, VALUE_REGNUM (toval
), type
))
1165 /* If TOVAL is a special machine register requiring
1166 conversion of program values to a special raw
1168 gdbarch_value_to_register (gdbarch
, frame
,
1169 VALUE_REGNUM (toval
), type
,
1170 value_contents (fromval
));
1174 if (value_bitsize (toval
))
1176 struct value
*parent
= value_parent (toval
);
1177 int offset
= value_offset (parent
) + value_offset (toval
);
1179 gdb_byte buffer
[sizeof (LONGEST
)];
1181 changed_len
= (value_bitpos (toval
)
1182 + value_bitsize (toval
)
1183 + HOST_CHAR_BIT
- 1)
1186 if (changed_len
> (int) sizeof (LONGEST
))
1187 error (_("Can't handle bitfields which don't fit in a %d bit word."),
1188 (int) sizeof (LONGEST
) * HOST_CHAR_BIT
);
1190 get_frame_register_bytes (frame
, value_reg
, offset
,
1191 changed_len
, buffer
);
1193 modify_field (type
, buffer
, value_as_long (fromval
),
1194 value_bitpos (toval
), value_bitsize (toval
));
1196 put_frame_register_bytes (frame
, value_reg
, offset
,
1197 changed_len
, buffer
);
1201 put_frame_register_bytes (frame
, value_reg
,
1202 value_offset (toval
),
1204 value_contents (fromval
));
1208 if (deprecated_register_changed_hook
)
1209 deprecated_register_changed_hook (-1);
1210 observer_notify_target_changed (¤t_target
);
1216 struct lval_funcs
*funcs
= value_computed_funcs (toval
);
1218 funcs
->write (toval
, fromval
);
1223 error (_("Left operand of assignment is not an lvalue."));
1226 /* Assigning to the stack pointer, frame pointer, and other
1227 (architecture and calling convention specific) registers may
1228 cause the frame cache to be out of date. Assigning to memory
1229 also can. We just do this on all assignments to registers or
1230 memory, for simplicity's sake; I doubt the slowdown matters. */
1231 switch (VALUE_LVAL (toval
))
1236 reinit_frame_cache ();
1238 /* Having destroyed the frame cache, restore the selected
1241 /* FIXME: cagney/2002-11-02: There has to be a better way of
1242 doing this. Instead of constantly saving/restoring the
1243 frame. Why not create a get_selected_frame() function that,
1244 having saved the selected frame's ID can automatically
1245 re-find the previously selected frame automatically. */
1248 struct frame_info
*fi
= frame_find_by_id (old_frame
);
1258 /* If the field does not entirely fill a LONGEST, then zero the sign
1259 bits. If the field is signed, and is negative, then sign
1261 if ((value_bitsize (toval
) > 0)
1262 && (value_bitsize (toval
) < 8 * (int) sizeof (LONGEST
)))
1264 LONGEST fieldval
= value_as_long (fromval
);
1265 LONGEST valmask
= (((ULONGEST
) 1) << value_bitsize (toval
)) - 1;
1267 fieldval
&= valmask
;
1268 if (!TYPE_UNSIGNED (type
)
1269 && (fieldval
& (valmask
^ (valmask
>> 1))))
1270 fieldval
|= ~valmask
;
1272 fromval
= value_from_longest (type
, fieldval
);
1275 val
= value_copy (toval
);
1276 memcpy (value_contents_raw (val
), value_contents (fromval
),
1277 TYPE_LENGTH (type
));
1278 deprecated_set_value_type (val
, type
);
1279 val
= value_change_enclosing_type (val
,
1280 value_enclosing_type (fromval
));
1281 set_value_embedded_offset (val
, value_embedded_offset (fromval
));
1282 set_value_pointed_to_offset (val
, value_pointed_to_offset (fromval
));
1287 /* Extend a value VAL to COUNT repetitions of its type. */
1290 value_repeat (struct value
*arg1
, int count
)
1294 if (VALUE_LVAL (arg1
) != lval_memory
)
1295 error (_("Only values in memory can be extended with '@'."));
1297 error (_("Invalid number %d of repetitions."), count
);
1299 val
= allocate_repeat_value (value_enclosing_type (arg1
), count
);
1301 read_memory (value_address (arg1
),
1302 value_contents_all_raw (val
),
1303 TYPE_LENGTH (value_enclosing_type (val
)));
1304 VALUE_LVAL (val
) = lval_memory
;
1305 set_value_address (val
, value_address (arg1
));
1311 value_of_variable (struct symbol
*var
, struct block
*b
)
1314 struct frame_info
*frame
;
1316 if (!symbol_read_needs_frame (var
))
1319 frame
= get_selected_frame (_("No frame selected."));
1322 frame
= block_innermost_frame (b
);
1325 if (BLOCK_FUNCTION (b
) && !block_inlined_p (b
)
1326 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)))
1327 error (_("No frame is currently executing in block %s."),
1328 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b
)));
1330 error (_("No frame is currently executing in specified block"));
1334 val
= read_var_value (var
, frame
);
1336 error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
1342 address_of_variable (struct symbol
*var
, struct block
*b
)
1344 struct type
*type
= SYMBOL_TYPE (var
);
1347 /* Evaluate it first; if the result is a memory address, we're fine.
1348 Lazy evaluation pays off here. */
1350 val
= value_of_variable (var
, b
);
1352 if ((VALUE_LVAL (val
) == lval_memory
&& value_lazy (val
))
1353 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1355 CORE_ADDR addr
= value_address (val
);
1356 return value_from_pointer (lookup_pointer_type (type
), addr
);
1359 /* Not a memory address; check what the problem was. */
1360 switch (VALUE_LVAL (val
))
1364 struct frame_info
*frame
;
1365 const char *regname
;
1367 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
1370 regname
= gdbarch_register_name (get_frame_arch (frame
),
1371 VALUE_REGNUM (val
));
1372 gdb_assert (regname
&& *regname
);
1374 error (_("Address requested for identifier "
1375 "\"%s\" which is in register $%s"),
1376 SYMBOL_PRINT_NAME (var
), regname
);
1381 error (_("Can't take address of \"%s\" which isn't an lvalue."),
1382 SYMBOL_PRINT_NAME (var
));
1389 /* Return one if VAL does not live in target memory, but should in order
1390 to operate on it. Otherwise return zero. */
1393 value_must_coerce_to_target (struct value
*val
)
1395 struct type
*valtype
;
1397 /* The only lval kinds which do not live in target memory. */
1398 if (VALUE_LVAL (val
) != not_lval
1399 && VALUE_LVAL (val
) != lval_internalvar
)
1402 valtype
= check_typedef (value_type (val
));
1404 switch (TYPE_CODE (valtype
))
1406 case TYPE_CODE_ARRAY
:
1407 case TYPE_CODE_STRING
:
1414 /* Make sure that VAL lives in target memory if it's supposed to. For instance,
1415 strings are constructed as character arrays in GDB's storage, and this
1416 function copies them to the target. */
1419 value_coerce_to_target (struct value
*val
)
1424 if (!value_must_coerce_to_target (val
))
1427 length
= TYPE_LENGTH (check_typedef (value_type (val
)));
1428 addr
= allocate_space_in_inferior (length
);
1429 write_memory (addr
, value_contents (val
), length
);
1430 return value_at_lazy (value_type (val
), addr
);
1433 /* Given a value which is an array, return a value which is a pointer
1434 to its first element, regardless of whether or not the array has a
1435 nonzero lower bound.
1437 FIXME: A previous comment here indicated that this routine should
1438 be substracting the array's lower bound. It's not clear to me that
1439 this is correct. Given an array subscripting operation, it would
1440 certainly work to do the adjustment here, essentially computing:
1442 (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1444 However I believe a more appropriate and logical place to account
1445 for the lower bound is to do so in value_subscript, essentially
1448 (&array[0] + ((index - lowerbound) * sizeof array[0]))
1450 As further evidence consider what would happen with operations
1451 other than array subscripting, where the caller would get back a
1452 value that had an address somewhere before the actual first element
1453 of the array, and the information about the lower bound would be
1454 lost because of the coercion to pointer type.
1458 value_coerce_array (struct value
*arg1
)
1460 struct type
*type
= check_typedef (value_type (arg1
));
1462 /* If the user tries to do something requiring a pointer with an
1463 array that has not yet been pushed to the target, then this would
1464 be a good time to do so. */
1465 arg1
= value_coerce_to_target (arg1
);
1467 if (VALUE_LVAL (arg1
) != lval_memory
)
1468 error (_("Attempt to take address of value not located in memory."));
1470 return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1471 value_address (arg1
));
1474 /* Given a value which is a function, return a value which is a pointer
1478 value_coerce_function (struct value
*arg1
)
1480 struct value
*retval
;
1482 if (VALUE_LVAL (arg1
) != lval_memory
)
1483 error (_("Attempt to take address of value not located in memory."));
1485 retval
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1486 value_address (arg1
));
1490 /* Return a pointer value for the object for which ARG1 is the
1494 value_addr (struct value
*arg1
)
1498 struct type
*type
= check_typedef (value_type (arg1
));
1499 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1501 /* Copy the value, but change the type from (T&) to (T*). We
1502 keep the same location information, which is efficient, and
1503 allows &(&X) to get the location containing the reference. */
1504 arg2
= value_copy (arg1
);
1505 deprecated_set_value_type (arg2
,
1506 lookup_pointer_type (TYPE_TARGET_TYPE (type
)));
1509 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1510 return value_coerce_function (arg1
);
1512 /* If this is an array that has not yet been pushed to the target,
1513 then this would be a good time to force it to memory. */
1514 arg1
= value_coerce_to_target (arg1
);
1516 if (VALUE_LVAL (arg1
) != lval_memory
)
1517 error (_("Attempt to take address of value not located in memory."));
1519 /* Get target memory address */
1520 arg2
= value_from_pointer (lookup_pointer_type (value_type (arg1
)),
1521 (value_address (arg1
)
1522 + value_embedded_offset (arg1
)));
1524 /* This may be a pointer to a base subobject; so remember the
1525 full derived object's type ... */
1526 arg2
= value_change_enclosing_type (arg2
, lookup_pointer_type (value_enclosing_type (arg1
)));
1527 /* ... and also the relative position of the subobject in the full
1529 set_value_pointed_to_offset (arg2
, value_embedded_offset (arg1
));
1533 /* Return a reference value for the object for which ARG1 is the
1537 value_ref (struct value
*arg1
)
1541 struct type
*type
= check_typedef (value_type (arg1
));
1542 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
1545 arg2
= value_addr (arg1
);
1546 deprecated_set_value_type (arg2
, lookup_reference_type (type
));
1550 /* Given a value of a pointer type, apply the C unary * operator to
1554 value_ind (struct value
*arg1
)
1556 struct type
*base_type
;
1559 arg1
= coerce_array (arg1
);
1561 base_type
= check_typedef (value_type (arg1
));
1563 if (TYPE_CODE (base_type
) == TYPE_CODE_PTR
)
1565 struct type
*enc_type
;
1566 /* We may be pointing to something embedded in a larger object.
1567 Get the real type of the enclosing object. */
1568 enc_type
= check_typedef (value_enclosing_type (arg1
));
1569 enc_type
= TYPE_TARGET_TYPE (enc_type
);
1571 if (TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_FUNC
1572 || TYPE_CODE (check_typedef (enc_type
)) == TYPE_CODE_METHOD
)
1573 /* For functions, go through find_function_addr, which knows
1574 how to handle function descriptors. */
1575 arg2
= value_at_lazy (enc_type
,
1576 find_function_addr (arg1
, NULL
));
1578 /* Retrieve the enclosing object pointed to */
1579 arg2
= value_at_lazy (enc_type
,
1580 (value_as_address (arg1
)
1581 - value_pointed_to_offset (arg1
)));
1583 /* Re-adjust type. */
1584 deprecated_set_value_type (arg2
, TYPE_TARGET_TYPE (base_type
));
1585 /* Add embedding info. */
1586 arg2
= value_change_enclosing_type (arg2
, enc_type
);
1587 set_value_embedded_offset (arg2
, value_pointed_to_offset (arg1
));
1589 /* We may be pointing to an object of some derived type. */
1590 arg2
= value_full_object (arg2
, NULL
, 0, 0, 0);
1594 error (_("Attempt to take contents of a non-pointer value."));
1595 return 0; /* For lint -- never reached. */
1598 /* Create a value for an array by allocating space in GDB, copying
1599 copying the data into that space, and then setting up an array
1602 The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1603 is populated from the values passed in ELEMVEC.
1605 The element type of the array is inherited from the type of the
1606 first element, and all elements must have the same size (though we
1607 don't currently enforce any restriction on their types). */
1610 value_array (int lowbound
, int highbound
, struct value
**elemvec
)
1614 unsigned int typelength
;
1616 struct type
*arraytype
;
1619 /* Validate that the bounds are reasonable and that each of the
1620 elements have the same size. */
1622 nelem
= highbound
- lowbound
+ 1;
1625 error (_("bad array bounds (%d, %d)"), lowbound
, highbound
);
1627 typelength
= TYPE_LENGTH (value_enclosing_type (elemvec
[0]));
1628 for (idx
= 1; idx
< nelem
; idx
++)
1630 if (TYPE_LENGTH (value_enclosing_type (elemvec
[idx
])) != typelength
)
1632 error (_("array elements must all be the same size"));
1636 arraytype
= lookup_array_range_type (value_enclosing_type (elemvec
[0]),
1637 lowbound
, highbound
);
1639 if (!current_language
->c_style_arrays
)
1641 val
= allocate_value (arraytype
);
1642 for (idx
= 0; idx
< nelem
; idx
++)
1644 memcpy (value_contents_all_raw (val
) + (idx
* typelength
),
1645 value_contents_all (elemvec
[idx
]),
1651 /* Allocate space to store the array, and then initialize it by
1652 copying in each element. */
1654 val
= allocate_value (arraytype
);
1655 for (idx
= 0; idx
< nelem
; idx
++)
1656 memcpy (value_contents_writeable (val
) + (idx
* typelength
),
1657 value_contents_all (elemvec
[idx
]),
1663 value_cstring (char *ptr
, int len
, struct type
*char_type
)
1666 int lowbound
= current_language
->string_lower_bound
;
1667 int highbound
= len
/ TYPE_LENGTH (char_type
);
1668 struct type
*stringtype
1669 = lookup_array_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1671 val
= allocate_value (stringtype
);
1672 memcpy (value_contents_raw (val
), ptr
, len
);
1676 /* Create a value for a string constant by allocating space in the
1677 inferior, copying the data into that space, and returning the
1678 address with type TYPE_CODE_STRING. PTR points to the string
1679 constant data; LEN is number of characters.
1681 Note that string types are like array of char types with a lower
1682 bound of zero and an upper bound of LEN - 1. Also note that the
1683 string may contain embedded null bytes. */
1686 value_string (char *ptr
, int len
, struct type
*char_type
)
1689 int lowbound
= current_language
->string_lower_bound
;
1690 int highbound
= len
/ TYPE_LENGTH (char_type
);
1691 struct type
*stringtype
1692 = lookup_string_range_type (char_type
, lowbound
, highbound
+ lowbound
- 1);
1694 val
= allocate_value (stringtype
);
1695 memcpy (value_contents_raw (val
), ptr
, len
);
1700 value_bitstring (char *ptr
, int len
, struct type
*index_type
)
1703 struct type
*domain_type
1704 = create_range_type (NULL
, index_type
, 0, len
- 1);
1705 struct type
*type
= create_set_type (NULL
, domain_type
);
1706 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
1707 val
= allocate_value (type
);
1708 memcpy (value_contents_raw (val
), ptr
, TYPE_LENGTH (type
));
1712 /* See if we can pass arguments in T2 to a function which takes
1713 arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1714 a NULL-terminated vector. If some arguments need coercion of some
1715 sort, then the coerced values are written into T2. Return value is
1716 0 if the arguments could be matched, or the position at which they
1719 STATICP is nonzero if the T1 argument list came from a static
1720 member function. T2 will still include the ``this'' pointer, but
1723 For non-static member functions, we ignore the first argument,
1724 which is the type of the instance variable. This is because we
1725 want to handle calls with objects from derived classes. This is
1726 not entirely correct: we should actually check to make sure that a
1727 requested operation is type secure, shouldn't we? FIXME. */
1730 typecmp (int staticp
, int varargs
, int nargs
,
1731 struct field t1
[], struct value
*t2
[])
1736 internal_error (__FILE__
, __LINE__
,
1737 _("typecmp: no argument list"));
1739 /* Skip ``this'' argument if applicable. T2 will always include
1745 (i
< nargs
) && TYPE_CODE (t1
[i
].type
) != TYPE_CODE_VOID
;
1748 struct type
*tt1
, *tt2
;
1753 tt1
= check_typedef (t1
[i
].type
);
1754 tt2
= check_typedef (value_type (t2
[i
]));
1756 if (TYPE_CODE (tt1
) == TYPE_CODE_REF
1757 /* We should be doing hairy argument matching, as below. */
1758 && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1
))) == TYPE_CODE (tt2
)))
1760 if (TYPE_CODE (tt2
) == TYPE_CODE_ARRAY
)
1761 t2
[i
] = value_coerce_array (t2
[i
]);
1763 t2
[i
] = value_ref (t2
[i
]);
1767 /* djb - 20000715 - Until the new type structure is in the
1768 place, and we can attempt things like implicit conversions,
1769 we need to do this so you can take something like a map<const
1770 char *>, and properly access map["hello"], because the
1771 argument to [] will be a reference to a pointer to a char,
1772 and the argument will be a pointer to a char. */
1773 while (TYPE_CODE(tt1
) == TYPE_CODE_REF
1774 || TYPE_CODE (tt1
) == TYPE_CODE_PTR
)
1776 tt1
= check_typedef( TYPE_TARGET_TYPE(tt1
) );
1778 while (TYPE_CODE(tt2
) == TYPE_CODE_ARRAY
1779 || TYPE_CODE(tt2
) == TYPE_CODE_PTR
1780 || TYPE_CODE(tt2
) == TYPE_CODE_REF
)
1782 tt2
= check_typedef (TYPE_TARGET_TYPE(tt2
));
1784 if (TYPE_CODE (tt1
) == TYPE_CODE (tt2
))
1786 /* Array to pointer is a `trivial conversion' according to the
1789 /* We should be doing much hairier argument matching (see
1790 section 13.2 of the ARM), but as a quick kludge, just check
1791 for the same type code. */
1792 if (TYPE_CODE (t1
[i
].type
) != TYPE_CODE (value_type (t2
[i
])))
1795 if (varargs
|| t2
[i
] == NULL
)
1800 /* Helper function used by value_struct_elt to recurse through
1801 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1802 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1803 TYPE. If found, return value, else return NULL.
1805 If LOOKING_FOR_BASECLASS, then instead of looking for struct
1806 fields, look for a baseclass named NAME. */
1808 static struct value
*
1809 search_struct_field (const char *name
, struct value
*arg1
, int offset
,
1810 struct type
*type
, int looking_for_baseclass
)
1815 CHECK_TYPEDEF (type
);
1816 nbases
= TYPE_N_BASECLASSES (type
);
1818 if (!looking_for_baseclass
)
1819 for (i
= TYPE_NFIELDS (type
) - 1; i
>= nbases
; i
--)
1821 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1823 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1826 if (field_is_static (&TYPE_FIELD (type
, i
)))
1828 v
= value_static_field (type
, i
);
1830 error (_("field %s is nonexistent or has been optimised out"),
1835 v
= value_primitive_field (arg1
, offset
, i
, type
);
1837 error (_("there is no field named %s"), name
);
1843 && (t_field_name
[0] == '\0'
1844 || (TYPE_CODE (type
) == TYPE_CODE_UNION
1845 && (strcmp_iw (t_field_name
, "else") == 0))))
1847 struct type
*field_type
= TYPE_FIELD_TYPE (type
, i
);
1848 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
1849 || TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
)
1851 /* Look for a match through the fields of an anonymous
1852 union, or anonymous struct. C++ provides anonymous
1855 In the GNU Chill (now deleted from GDB)
1856 implementation of variant record types, each
1857 <alternative field> has an (anonymous) union type,
1858 each member of the union represents a <variant
1859 alternative>. Each <variant alternative> is
1860 represented as a struct, with a member for each
1864 int new_offset
= offset
;
1866 /* This is pretty gross. In G++, the offset in an
1867 anonymous union is relative to the beginning of the
1868 enclosing struct. In the GNU Chill (now deleted
1869 from GDB) implementation of variant records, the
1870 bitpos is zero in an anonymous union field, so we
1871 have to add the offset of the union here. */
1872 if (TYPE_CODE (field_type
) == TYPE_CODE_STRUCT
1873 || (TYPE_NFIELDS (field_type
) > 0
1874 && TYPE_FIELD_BITPOS (field_type
, 0) == 0))
1875 new_offset
+= TYPE_FIELD_BITPOS (type
, i
) / 8;
1877 v
= search_struct_field (name
, arg1
, new_offset
,
1879 looking_for_baseclass
);
1886 for (i
= 0; i
< nbases
; i
++)
1889 struct type
*basetype
= check_typedef (TYPE_BASECLASS (type
, i
));
1890 /* If we are looking for baseclasses, this is what we get when
1891 we hit them. But it could happen that the base part's member
1892 name is not yet filled in. */
1893 int found_baseclass
= (looking_for_baseclass
1894 && TYPE_BASECLASS_NAME (type
, i
) != NULL
1895 && (strcmp_iw (name
,
1896 TYPE_BASECLASS_NAME (type
,
1899 if (BASETYPE_VIA_VIRTUAL (type
, i
))
1904 boffset
= baseclass_offset (type
, i
,
1905 value_contents (arg1
) + offset
,
1906 value_address (arg1
)
1907 + value_embedded_offset (arg1
)
1910 error (_("virtual baseclass botch"));
1912 /* The virtual base class pointer might have been clobbered
1913 by the user program. Make sure that it still points to a
1914 valid memory location. */
1916 boffset
+= value_embedded_offset (arg1
) + offset
;
1918 || boffset
>= TYPE_LENGTH (value_enclosing_type (arg1
)))
1920 CORE_ADDR base_addr
;
1922 v2
= allocate_value (basetype
);
1923 base_addr
= value_address (arg1
) + boffset
;
1924 if (target_read_memory (base_addr
,
1925 value_contents_raw (v2
),
1926 TYPE_LENGTH (basetype
)) != 0)
1927 error (_("virtual baseclass botch"));
1928 VALUE_LVAL (v2
) = lval_memory
;
1929 set_value_address (v2
, base_addr
);
1933 v2
= value_copy (arg1
);
1934 deprecated_set_value_type (v2
, basetype
);
1935 set_value_embedded_offset (v2
, boffset
);
1938 if (found_baseclass
)
1940 v
= search_struct_field (name
, v2
, 0,
1941 TYPE_BASECLASS (type
, i
),
1942 looking_for_baseclass
);
1944 else if (found_baseclass
)
1945 v
= value_primitive_field (arg1
, offset
, i
, type
);
1947 v
= search_struct_field (name
, arg1
,
1948 offset
+ TYPE_BASECLASS_BITPOS (type
,
1950 basetype
, looking_for_baseclass
);
1957 /* Helper function used by value_struct_elt to recurse through
1958 baseclasses. Look for a field NAME in ARG1. Adjust the address of
1959 ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1962 If found, return value, else if name matched and args not return
1963 (value) -1, else return NULL. */
1965 static struct value
*
1966 search_struct_method (const char *name
, struct value
**arg1p
,
1967 struct value
**args
, int offset
,
1968 int *static_memfuncp
, struct type
*type
)
1972 int name_matched
= 0;
1973 char dem_opname
[64];
1975 CHECK_TYPEDEF (type
);
1976 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1978 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1979 /* FIXME! May need to check for ARM demangling here */
1980 if (strncmp (t_field_name
, "__", 2) == 0 ||
1981 strncmp (t_field_name
, "op", 2) == 0 ||
1982 strncmp (t_field_name
, "type", 4) == 0)
1984 if (cplus_demangle_opname (t_field_name
, dem_opname
, DMGL_ANSI
))
1985 t_field_name
= dem_opname
;
1986 else if (cplus_demangle_opname (t_field_name
, dem_opname
, 0))
1987 t_field_name
= dem_opname
;
1989 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
1991 int j
= TYPE_FN_FIELDLIST_LENGTH (type
, i
) - 1;
1992 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1995 check_stub_method_group (type
, i
);
1996 if (j
> 0 && args
== 0)
1997 error (_("cannot resolve overloaded method `%s': no arguments supplied"), name
);
1998 else if (j
== 0 && args
== 0)
2000 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2007 if (!typecmp (TYPE_FN_FIELD_STATIC_P (f
, j
),
2008 TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f
, j
)),
2009 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f
, j
)),
2010 TYPE_FN_FIELD_ARGS (f
, j
), args
))
2012 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
2013 return value_virtual_fn_field (arg1p
, f
, j
,
2015 if (TYPE_FN_FIELD_STATIC_P (f
, j
)
2017 *static_memfuncp
= 1;
2018 v
= value_fn_field (arg1p
, f
, j
, type
, offset
);
2027 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2031 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2033 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
2034 const gdb_byte
*base_valaddr
;
2036 /* The virtual base class pointer might have been
2037 clobbered by the user program. Make sure that it
2038 still points to a valid memory location. */
2040 if (offset
< 0 || offset
>= TYPE_LENGTH (type
))
2042 gdb_byte
*tmp
= alloca (TYPE_LENGTH (baseclass
));
2043 if (target_read_memory (value_address (*arg1p
) + offset
,
2044 tmp
, TYPE_LENGTH (baseclass
)) != 0)
2045 error (_("virtual baseclass botch"));
2049 base_valaddr
= value_contents (*arg1p
) + offset
;
2051 base_offset
= baseclass_offset (type
, i
, base_valaddr
,
2052 value_address (*arg1p
) + offset
);
2053 if (base_offset
== -1)
2054 error (_("virtual baseclass botch"));
2058 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2060 v
= search_struct_method (name
, arg1p
, args
, base_offset
+ offset
,
2061 static_memfuncp
, TYPE_BASECLASS (type
, i
));
2062 if (v
== (struct value
*) - 1)
2068 /* FIXME-bothner: Why is this commented out? Why is it here? */
2069 /* *arg1p = arg1_tmp; */
2074 return (struct value
*) - 1;
2079 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2080 extract the component named NAME from the ultimate target
2081 structure/union and return it as a value with its appropriate type.
2082 ERR is used in the error message if *ARGP's type is wrong.
2084 C++: ARGS is a list of argument types to aid in the selection of
2085 an appropriate method. Also, handle derived types.
2087 STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2088 where the truthvalue of whether the function that was resolved was
2089 a static member function or not is stored.
2091 ERR is an error message to be printed in case the field is not
2095 value_struct_elt (struct value
**argp
, struct value
**args
,
2096 const char *name
, int *static_memfuncp
, const char *err
)
2101 *argp
= coerce_array (*argp
);
2103 t
= check_typedef (value_type (*argp
));
2105 /* Follow pointers until we get to a non-pointer. */
2107 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2109 *argp
= value_ind (*argp
);
2110 /* Don't coerce fn pointer to fn and then back again! */
2111 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2112 *argp
= coerce_array (*argp
);
2113 t
= check_typedef (value_type (*argp
));
2116 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2117 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2118 error (_("Attempt to extract a component of a value that is not a %s."), err
);
2120 /* Assume it's not, unless we see that it is. */
2121 if (static_memfuncp
)
2122 *static_memfuncp
= 0;
2126 /* if there are no arguments ...do this... */
2128 /* Try as a field first, because if we succeed, there is less
2130 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2134 /* C++: If it was not found as a data field, then try to
2135 return it as a pointer to a method. */
2136 v
= search_struct_method (name
, argp
, args
, 0,
2137 static_memfuncp
, t
);
2139 if (v
== (struct value
*) - 1)
2140 error (_("Cannot take address of method %s."), name
);
2143 if (TYPE_NFN_FIELDS (t
))
2144 error (_("There is no member or method named %s."), name
);
2146 error (_("There is no member named %s."), name
);
2151 v
= search_struct_method (name
, argp
, args
, 0,
2152 static_memfuncp
, t
);
2154 if (v
== (struct value
*) - 1)
2156 error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name
);
2160 /* See if user tried to invoke data as function. If so, hand it
2161 back. If it's not callable (i.e., a pointer to function),
2162 gdb should give an error. */
2163 v
= search_struct_field (name
, *argp
, 0, t
, 0);
2164 /* If we found an ordinary field, then it is not a method call.
2165 So, treat it as if it were a static member function. */
2166 if (v
&& static_memfuncp
)
2167 *static_memfuncp
= 1;
2171 error (_("Structure has no component named %s."), name
);
2175 /* Search through the methods of an object (and its bases) to find a
2176 specified method. Return the pointer to the fn_field list of
2177 overloaded instances.
2179 Helper function for value_find_oload_list.
2180 ARGP is a pointer to a pointer to a value (the object).
2181 METHOD is a string containing the method name.
2182 OFFSET is the offset within the value.
2183 TYPE is the assumed type of the object.
2184 NUM_FNS is the number of overloaded instances.
2185 BASETYPE is set to the actual type of the subobject where the
2187 BOFFSET is the offset of the base subobject where the method is found.
2190 static struct fn_field
*
2191 find_method_list (struct value
**argp
, const char *method
,
2192 int offset
, struct type
*type
, int *num_fns
,
2193 struct type
**basetype
, int *boffset
)
2197 CHECK_TYPEDEF (type
);
2201 /* First check in object itself. */
2202 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
2204 /* pai: FIXME What about operators and type conversions? */
2205 char *fn_field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
2206 if (fn_field_name
&& (strcmp_iw (fn_field_name
, method
) == 0))
2208 int len
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
2209 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
2215 /* Resolve any stub methods. */
2216 check_stub_method_group (type
, i
);
2222 /* Not found in object, check in base subobjects. */
2223 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2226 if (BASETYPE_VIA_VIRTUAL (type
, i
))
2228 base_offset
= value_offset (*argp
) + offset
;
2229 base_offset
= baseclass_offset (type
, i
,
2230 value_contents (*argp
) + base_offset
,
2231 value_address (*argp
) + base_offset
);
2232 if (base_offset
== -1)
2233 error (_("virtual baseclass botch"));
2235 else /* Non-virtual base, simply use bit position from debug
2238 base_offset
= TYPE_BASECLASS_BITPOS (type
, i
) / 8;
2240 f
= find_method_list (argp
, method
, base_offset
+ offset
,
2241 TYPE_BASECLASS (type
, i
), num_fns
,
2249 /* Return the list of overloaded methods of a specified name.
2251 ARGP is a pointer to a pointer to a value (the object).
2252 METHOD is the method name.
2253 OFFSET is the offset within the value contents.
2254 NUM_FNS is the number of overloaded instances.
2255 BASETYPE is set to the type of the base subobject that defines the
2257 BOFFSET is the offset of the base subobject which defines the method.
2261 value_find_oload_method_list (struct value
**argp
, const char *method
,
2262 int offset
, int *num_fns
,
2263 struct type
**basetype
, int *boffset
)
2267 t
= check_typedef (value_type (*argp
));
2269 /* Code snarfed from value_struct_elt. */
2270 while (TYPE_CODE (t
) == TYPE_CODE_PTR
|| TYPE_CODE (t
) == TYPE_CODE_REF
)
2272 *argp
= value_ind (*argp
);
2273 /* Don't coerce fn pointer to fn and then back again! */
2274 if (TYPE_CODE (value_type (*argp
)) != TYPE_CODE_FUNC
)
2275 *argp
= coerce_array (*argp
);
2276 t
= check_typedef (value_type (*argp
));
2279 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2280 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2281 error (_("Attempt to extract a component of a value that is not a struct or union"));
2283 return find_method_list (argp
, method
, 0, t
, num_fns
,
2287 /* Given an array of argument types (ARGTYPES) (which includes an
2288 entry for "this" in the case of C++ methods), the number of
2289 arguments NARGS, the NAME of a function whether it's a method or
2290 not (METHOD), and the degree of laxness (LAX) in conforming to
2291 overload resolution rules in ANSI C++, find the best function that
2292 matches on the argument types according to the overload resolution
2295 In the case of class methods, the parameter OBJ is an object value
2296 in which to search for overloaded methods.
2298 In the case of non-method functions, the parameter FSYM is a symbol
2299 corresponding to one of the overloaded functions.
2301 Return value is an integer: 0 -> good match, 10 -> debugger applied
2302 non-standard coercions, 100 -> incompatible.
2304 If a method is being searched for, VALP will hold the value.
2305 If a non-method is being searched for, SYMP will hold the symbol
2308 If a method is being searched for, and it is a static method,
2309 then STATICP will point to a non-zero value.
2311 Note: This function does *not* check the value of
2312 overload_resolution. Caller must check it to see whether overload
2313 resolution is permitted.
2317 find_overload_match (struct type
**arg_types
, int nargs
,
2318 const char *name
, int method
, int lax
,
2319 struct value
**objp
, struct symbol
*fsym
,
2320 struct value
**valp
, struct symbol
**symp
,
2323 struct value
*obj
= (objp
? *objp
: NULL
);
2324 /* Index of best overloaded function. */
2326 /* The measure for the current best match. */
2327 struct badness_vector
*oload_champ_bv
= NULL
;
2328 struct value
*temp
= obj
;
2329 /* For methods, the list of overloaded methods. */
2330 struct fn_field
*fns_ptr
= NULL
;
2331 /* For non-methods, the list of overloaded function symbols. */
2332 struct symbol
**oload_syms
= NULL
;
2333 /* Number of overloaded instances being considered. */
2335 struct type
*basetype
= NULL
;
2339 struct cleanup
*old_cleanups
= NULL
;
2341 const char *obj_type_name
= NULL
;
2342 char *func_name
= NULL
;
2343 enum oload_classification match_quality
;
2345 /* Get the list of overloaded methods or functions. */
2350 /* OBJ may be a pointer value rather than the object itself. */
2351 obj
= coerce_ref (obj
);
2352 while (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_PTR
)
2353 obj
= coerce_ref (value_ind (obj
));
2354 obj_type_name
= TYPE_NAME (value_type (obj
));
2356 /* First check whether this is a data member, e.g. a pointer to
2358 if (TYPE_CODE (check_typedef (value_type (obj
))) == TYPE_CODE_STRUCT
)
2360 *valp
= search_struct_field (name
, obj
, 0,
2361 check_typedef (value_type (obj
)), 0);
2369 fns_ptr
= value_find_oload_method_list (&temp
, name
,
2371 &basetype
, &boffset
);
2372 if (!fns_ptr
|| !num_fns
)
2373 error (_("Couldn't find method %s%s%s"),
2375 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2377 /* If we are dealing with stub method types, they should have
2378 been resolved by find_method_list via
2379 value_find_oload_method_list above. */
2380 gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr
[0].type
) != NULL
);
2381 oload_champ
= find_oload_champ (arg_types
, nargs
, method
,
2383 oload_syms
, &oload_champ_bv
);
2387 const char *qualified_name
= SYMBOL_NATURAL_NAME (fsym
);
2389 /* If we have a function with a C++ name, try to extract just
2390 the function part. Do not try this for non-functions (e.g.
2391 function pointers). */
2393 && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym
))) == TYPE_CODE_FUNC
)
2395 func_name
= cp_func_name (qualified_name
);
2397 /* If cp_func_name did not remove anything, the name of the
2398 symbol did not include scope or argument types - it was
2399 probably a C-style function. */
2400 if (func_name
&& strcmp (func_name
, qualified_name
) == 0)
2407 /* If there was no C++ name, this must be a C-style function or
2408 not a function at all. Just return the same symbol. Do the
2409 same if cp_func_name fails for some reason. */
2410 if (func_name
== NULL
)
2416 old_cleanups
= make_cleanup (xfree
, func_name
);
2417 make_cleanup (xfree
, oload_syms
);
2418 make_cleanup (xfree
, oload_champ_bv
);
2420 oload_champ
= find_oload_champ_namespace (arg_types
, nargs
,
2427 /* Check how bad the best match is. */
2430 classify_oload_match (oload_champ_bv
, nargs
,
2431 oload_method_static (method
, fns_ptr
,
2434 if (match_quality
== INCOMPATIBLE
)
2437 error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2439 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2442 error (_("Cannot resolve function %s to any overloaded instance"),
2445 else if (match_quality
== NON_STANDARD
)
2448 warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2450 (obj_type_name
&& *obj_type_name
) ? "::" : "",
2453 warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2459 if (staticp
!= NULL
)
2460 *staticp
= oload_method_static (method
, fns_ptr
, oload_champ
);
2461 if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr
, oload_champ
))
2462 *valp
= value_virtual_fn_field (&temp
, fns_ptr
, oload_champ
,
2465 *valp
= value_fn_field (&temp
, fns_ptr
, oload_champ
,
2470 *symp
= oload_syms
[oload_champ
];
2475 struct type
*temp_type
= check_typedef (value_type (temp
));
2476 struct type
*obj_type
= check_typedef (value_type (*objp
));
2477 if (TYPE_CODE (temp_type
) != TYPE_CODE_PTR
2478 && (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
2479 || TYPE_CODE (obj_type
) == TYPE_CODE_REF
))
2481 temp
= value_addr (temp
);
2485 if (old_cleanups
!= NULL
)
2486 do_cleanups (old_cleanups
);
2488 switch (match_quality
)
2494 default: /* STANDARD */
2499 /* Find the best overload match, searching for FUNC_NAME in namespaces
2500 contained in QUALIFIED_NAME until it either finds a good match or
2501 runs out of namespaces. It stores the overloaded functions in
2502 *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2503 calling function is responsible for freeing *OLOAD_SYMS and
2507 find_oload_champ_namespace (struct type
**arg_types
, int nargs
,
2508 const char *func_name
,
2509 const char *qualified_name
,
2510 struct symbol
***oload_syms
,
2511 struct badness_vector
**oload_champ_bv
)
2515 find_oload_champ_namespace_loop (arg_types
, nargs
,
2518 oload_syms
, oload_champ_bv
,
2524 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2525 how deep we've looked for namespaces, and the champ is stored in
2526 OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2529 It is the caller's responsibility to free *OLOAD_SYMS and
2533 find_oload_champ_namespace_loop (struct type
**arg_types
, int nargs
,
2534 const char *func_name
,
2535 const char *qualified_name
,
2537 struct symbol
***oload_syms
,
2538 struct badness_vector
**oload_champ_bv
,
2541 int next_namespace_len
= namespace_len
;
2542 int searched_deeper
= 0;
2544 struct cleanup
*old_cleanups
;
2545 int new_oload_champ
;
2546 struct symbol
**new_oload_syms
;
2547 struct badness_vector
*new_oload_champ_bv
;
2548 char *new_namespace
;
2550 if (next_namespace_len
!= 0)
2552 gdb_assert (qualified_name
[next_namespace_len
] == ':');
2553 next_namespace_len
+= 2;
2555 next_namespace_len
+=
2556 cp_find_first_component (qualified_name
+ next_namespace_len
);
2558 /* Initialize these to values that can safely be xfree'd. */
2560 *oload_champ_bv
= NULL
;
2562 /* First, see if we have a deeper namespace we can search in.
2563 If we get a good match there, use it. */
2565 if (qualified_name
[next_namespace_len
] == ':')
2567 searched_deeper
= 1;
2569 if (find_oload_champ_namespace_loop (arg_types
, nargs
,
2570 func_name
, qualified_name
,
2572 oload_syms
, oload_champ_bv
,
2579 /* If we reach here, either we're in the deepest namespace or we
2580 didn't find a good match in a deeper namespace. But, in the
2581 latter case, we still have a bad match in a deeper namespace;
2582 note that we might not find any match at all in the current
2583 namespace. (There's always a match in the deepest namespace,
2584 because this overload mechanism only gets called if there's a
2585 function symbol to start off with.) */
2587 old_cleanups
= make_cleanup (xfree
, *oload_syms
);
2588 old_cleanups
= make_cleanup (xfree
, *oload_champ_bv
);
2589 new_namespace
= alloca (namespace_len
+ 1);
2590 strncpy (new_namespace
, qualified_name
, namespace_len
);
2591 new_namespace
[namespace_len
] = '\0';
2592 new_oload_syms
= make_symbol_overload_list (func_name
,
2594 while (new_oload_syms
[num_fns
])
2597 new_oload_champ
= find_oload_champ (arg_types
, nargs
, 0, num_fns
,
2598 NULL
, new_oload_syms
,
2599 &new_oload_champ_bv
);
2601 /* Case 1: We found a good match. Free earlier matches (if any),
2602 and return it. Case 2: We didn't find a good match, but we're
2603 not the deepest function. Then go with the bad match that the
2604 deeper function found. Case 3: We found a bad match, and we're
2605 the deepest function. Then return what we found, even though
2606 it's a bad match. */
2608 if (new_oload_champ
!= -1
2609 && classify_oload_match (new_oload_champ_bv
, nargs
, 0) == STANDARD
)
2611 *oload_syms
= new_oload_syms
;
2612 *oload_champ
= new_oload_champ
;
2613 *oload_champ_bv
= new_oload_champ_bv
;
2614 do_cleanups (old_cleanups
);
2617 else if (searched_deeper
)
2619 xfree (new_oload_syms
);
2620 xfree (new_oload_champ_bv
);
2621 discard_cleanups (old_cleanups
);
2626 gdb_assert (new_oload_champ
!= -1);
2627 *oload_syms
= new_oload_syms
;
2628 *oload_champ
= new_oload_champ
;
2629 *oload_champ_bv
= new_oload_champ_bv
;
2630 discard_cleanups (old_cleanups
);
2635 /* Look for a function to take NARGS args of types ARG_TYPES. Find
2636 the best match from among the overloaded methods or functions
2637 (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2638 The number of methods/functions in the list is given by NUM_FNS.
2639 Return the index of the best match; store an indication of the
2640 quality of the match in OLOAD_CHAMP_BV.
2642 It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2645 find_oload_champ (struct type
**arg_types
, int nargs
, int method
,
2646 int num_fns
, struct fn_field
*fns_ptr
,
2647 struct symbol
**oload_syms
,
2648 struct badness_vector
**oload_champ_bv
)
2651 /* A measure of how good an overloaded instance is. */
2652 struct badness_vector
*bv
;
2653 /* Index of best overloaded function. */
2654 int oload_champ
= -1;
2655 /* Current ambiguity state for overload resolution. */
2656 int oload_ambiguous
= 0;
2657 /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
2659 *oload_champ_bv
= NULL
;
2661 /* Consider each candidate in turn. */
2662 for (ix
= 0; ix
< num_fns
; ix
++)
2665 int static_offset
= oload_method_static (method
, fns_ptr
, ix
);
2667 struct type
**parm_types
;
2671 nparms
= TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr
, ix
));
2675 /* If it's not a method, this is the proper place. */
2676 nparms
= TYPE_NFIELDS (SYMBOL_TYPE (oload_syms
[ix
]));
2679 /* Prepare array of parameter types. */
2680 parm_types
= (struct type
**)
2681 xmalloc (nparms
* (sizeof (struct type
*)));
2682 for (jj
= 0; jj
< nparms
; jj
++)
2683 parm_types
[jj
] = (method
2684 ? (TYPE_FN_FIELD_ARGS (fns_ptr
, ix
)[jj
].type
)
2685 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms
[ix
]),
2688 /* Compare parameter types to supplied argument types. Skip
2689 THIS for static methods. */
2690 bv
= rank_function (parm_types
, nparms
,
2691 arg_types
+ static_offset
,
2692 nargs
- static_offset
);
2694 if (!*oload_champ_bv
)
2696 *oload_champ_bv
= bv
;
2699 else /* See whether current candidate is better or worse than
2701 switch (compare_badness (bv
, *oload_champ_bv
))
2703 case 0: /* Top two contenders are equally good. */
2704 oload_ambiguous
= 1;
2706 case 1: /* Incomparable top contenders. */
2707 oload_ambiguous
= 2;
2709 case 2: /* New champion, record details. */
2710 *oload_champ_bv
= bv
;
2711 oload_ambiguous
= 0;
2722 fprintf_filtered (gdb_stderr
,
2723 "Overloaded method instance %s, # of parms %d\n",
2724 fns_ptr
[ix
].physname
, nparms
);
2726 fprintf_filtered (gdb_stderr
,
2727 "Overloaded function instance %s # of parms %d\n",
2728 SYMBOL_DEMANGLED_NAME (oload_syms
[ix
]),
2730 for (jj
= 0; jj
< nargs
- static_offset
; jj
++)
2731 fprintf_filtered (gdb_stderr
,
2732 "...Badness @ %d : %d\n",
2734 fprintf_filtered (gdb_stderr
,
2735 "Overload resolution champion is %d, ambiguous? %d\n",
2736 oload_champ
, oload_ambiguous
);
2743 /* Return 1 if we're looking at a static method, 0 if we're looking at
2744 a non-static method or a function that isn't a method. */
2747 oload_method_static (int method
, struct fn_field
*fns_ptr
, int index
)
2749 if (method
&& TYPE_FN_FIELD_STATIC_P (fns_ptr
, index
))
2755 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
2757 static enum oload_classification
2758 classify_oload_match (struct badness_vector
*oload_champ_bv
,
2764 for (ix
= 1; ix
<= nargs
- static_offset
; ix
++)
2766 if (oload_champ_bv
->rank
[ix
] >= 100)
2767 return INCOMPATIBLE
; /* Truly mismatched types. */
2768 else if (oload_champ_bv
->rank
[ix
] >= 10)
2769 return NON_STANDARD
; /* Non-standard type conversions
2773 return STANDARD
; /* Only standard conversions needed. */
2776 /* C++: return 1 is NAME is a legitimate name for the destructor of
2777 type TYPE. If TYPE does not have a destructor, or if NAME is
2778 inappropriate for TYPE, an error is signaled. */
2780 destructor_name_p (const char *name
, const struct type
*type
)
2784 char *dname
= type_name_no_tag (type
);
2785 char *cp
= strchr (dname
, '<');
2788 /* Do not compare the template part for template classes. */
2790 len
= strlen (dname
);
2793 if (strlen (name
+ 1) != len
|| strncmp (dname
, name
+ 1, len
) != 0)
2794 error (_("name of destructor must equal name of class"));
2801 /* Given TYPE, a structure/union,
2802 return 1 if the component named NAME from the ultimate target
2803 structure/union is defined, otherwise, return 0. */
2806 check_field (struct type
*type
, const char *name
)
2810 /* The type may be a stub. */
2811 CHECK_TYPEDEF (type
);
2813 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
2815 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
2816 if (t_field_name
&& (strcmp_iw (t_field_name
, name
) == 0))
2820 /* C++: If it was not found as a data field, then try to return it
2821 as a pointer to a method. */
2823 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
2825 if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type
, i
), name
) == 0)
2829 for (i
= TYPE_N_BASECLASSES (type
) - 1; i
>= 0; i
--)
2830 if (check_field (TYPE_BASECLASS (type
, i
), name
))
2836 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2837 return the appropriate member (or the address of the member, if
2838 WANT_ADDRESS). This function is used to resolve user expressions
2839 of the form "DOMAIN::NAME". For more details on what happens, see
2840 the comment before value_struct_elt_for_reference. */
2843 value_aggregate_elt (struct type
*curtype
, char *name
,
2844 struct type
*expect_type
, int want_address
,
2847 switch (TYPE_CODE (curtype
))
2849 case TYPE_CODE_STRUCT
:
2850 case TYPE_CODE_UNION
:
2851 return value_struct_elt_for_reference (curtype
, 0, curtype
,
2853 want_address
, noside
);
2854 case TYPE_CODE_NAMESPACE
:
2855 return value_namespace_elt (curtype
, name
,
2856 want_address
, noside
);
2858 internal_error (__FILE__
, __LINE__
,
2859 _("non-aggregate type in value_aggregate_elt"));
2863 /* Compares the two method/function types T1 and T2 for "equality"
2864 with respect to the the methods' parameters. If the types of the
2865 two parameter lists are the same, returns 1; 0 otherwise. This
2866 comparison may ignore any artificial parameters in T1 if
2867 SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
2868 the first artificial parameter in T1, assumed to be a 'this' pointer.
2870 The type T2 is expected to have come from make_params (in eval.c). */
2873 compare_parameters (struct type
*t1
, struct type
*t2
, int skip_artificial
)
2877 if (TYPE_FIELD_ARTIFICIAL (t1
, 0))
2880 /* If skipping artificial fields, find the first real field
2882 if (skip_artificial
)
2884 while (start
< TYPE_NFIELDS (t1
)
2885 && TYPE_FIELD_ARTIFICIAL (t1
, start
))
2889 /* Now compare parameters */
2891 /* Special case: a method taking void. T1 will contain no
2892 non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
2893 if ((TYPE_NFIELDS (t1
) - start
) == 0 && TYPE_NFIELDS (t2
) == 1
2894 && TYPE_CODE (TYPE_FIELD_TYPE (t2
, 0)) == TYPE_CODE_VOID
)
2897 if ((TYPE_NFIELDS (t1
) - start
) == TYPE_NFIELDS (t2
))
2900 for (i
= 0; i
< TYPE_NFIELDS (t2
); ++i
)
2902 if (rank_one_type (TYPE_FIELD_TYPE (t1
, start
+ i
),
2903 TYPE_FIELD_TYPE (t2
, i
))
2914 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2915 return the address of this member as a "pointer to member" type.
2916 If INTYPE is non-null, then it will be the type of the member we
2917 are looking for. This will help us resolve "pointers to member
2918 functions". This function is used to resolve user expressions of
2919 the form "DOMAIN::NAME". */
2921 static struct value
*
2922 value_struct_elt_for_reference (struct type
*domain
, int offset
,
2923 struct type
*curtype
, char *name
,
2924 struct type
*intype
,
2928 struct type
*t
= curtype
;
2930 struct value
*v
, *result
;
2932 if (TYPE_CODE (t
) != TYPE_CODE_STRUCT
2933 && TYPE_CODE (t
) != TYPE_CODE_UNION
)
2934 error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
2936 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
2938 char *t_field_name
= TYPE_FIELD_NAME (t
, i
);
2940 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2942 if (field_is_static (&TYPE_FIELD (t
, i
)))
2944 v
= value_static_field (t
, i
);
2946 error (_("static field %s has been optimized out"),
2952 if (TYPE_FIELD_PACKED (t
, i
))
2953 error (_("pointers to bitfield members not allowed"));
2956 return value_from_longest
2957 (lookup_memberptr_type (TYPE_FIELD_TYPE (t
, i
), domain
),
2958 offset
+ (LONGEST
) (TYPE_FIELD_BITPOS (t
, i
) >> 3));
2959 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2960 return allocate_value (TYPE_FIELD_TYPE (t
, i
));
2962 error (_("Cannot reference non-static field \"%s\""), name
);
2966 /* C++: If it was not found as a data field, then try to return it
2967 as a pointer to a method. */
2969 /* Perform all necessary dereferencing. */
2970 while (intype
&& TYPE_CODE (intype
) == TYPE_CODE_PTR
)
2971 intype
= TYPE_TARGET_TYPE (intype
);
2973 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; --i
)
2975 char *t_field_name
= TYPE_FN_FIELDLIST_NAME (t
, i
);
2976 char dem_opname
[64];
2978 if (strncmp (t_field_name
, "__", 2) == 0
2979 || strncmp (t_field_name
, "op", 2) == 0
2980 || strncmp (t_field_name
, "type", 4) == 0)
2982 if (cplus_demangle_opname (t_field_name
,
2983 dem_opname
, DMGL_ANSI
))
2984 t_field_name
= dem_opname
;
2985 else if (cplus_demangle_opname (t_field_name
,
2987 t_field_name
= dem_opname
;
2989 if (t_field_name
&& strcmp (t_field_name
, name
) == 0)
2992 int len
= TYPE_FN_FIELDLIST_LENGTH (t
, i
);
2993 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, i
);
2995 check_stub_method_group (t
, i
);
2999 for (j
= 0; j
< len
; ++j
)
3001 if (compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 0)
3002 || compare_parameters (TYPE_FN_FIELD_TYPE (f
, j
), intype
, 1))
3007 error (_("no member function matches that type instantiation"));
3014 for (ii
= 0; ii
< TYPE_FN_FIELDLIST_LENGTH (t
, i
);
3017 /* Skip artificial methods. This is necessary if,
3018 for example, the user wants to "print
3019 subclass::subclass" with only one user-defined
3020 constructor. There is no ambiguity in this
3022 if (TYPE_FN_FIELD_ARTIFICIAL (f
, ii
))
3025 /* Desired method is ambiguous if more than one
3026 method is defined. */
3028 error (_("non-unique member `%s' requires type instantiation"), name
);
3034 if (TYPE_FN_FIELD_STATIC_P (f
, j
))
3037 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3043 return value_addr (read_var_value (s
, 0));
3045 return read_var_value (s
, 0);
3048 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
3052 result
= allocate_value
3053 (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3054 cplus_make_method_ptr (value_type (result
),
3055 value_contents_writeable (result
),
3056 TYPE_FN_FIELD_VOFFSET (f
, j
), 1);
3058 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3059 return allocate_value (TYPE_FN_FIELD_TYPE (f
, j
));
3061 error (_("Cannot reference virtual member function \"%s\""),
3067 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
3072 v
= read_var_value (s
, 0);
3077 result
= allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f
, j
)));
3078 cplus_make_method_ptr (value_type (result
),
3079 value_contents_writeable (result
),
3080 value_address (v
), 0);
3086 for (i
= TYPE_N_BASECLASSES (t
) - 1; i
>= 0; i
--)
3091 if (BASETYPE_VIA_VIRTUAL (t
, i
))
3094 base_offset
= TYPE_BASECLASS_BITPOS (t
, i
) / 8;
3095 v
= value_struct_elt_for_reference (domain
,
3096 offset
+ base_offset
,
3097 TYPE_BASECLASS (t
, i
),
3099 want_address
, noside
);
3104 /* As a last chance, pretend that CURTYPE is a namespace, and look
3105 it up that way; this (frequently) works for types nested inside
3108 return value_maybe_namespace_elt (curtype
, name
,
3109 want_address
, noside
);
3112 /* C++: Return the member NAME of the namespace given by the type
3115 static struct value
*
3116 value_namespace_elt (const struct type
*curtype
,
3117 char *name
, int want_address
,
3120 struct value
*retval
= value_maybe_namespace_elt (curtype
, name
,
3125 error (_("No symbol \"%s\" in namespace \"%s\"."),
3126 name
, TYPE_TAG_NAME (curtype
));
3131 /* A helper function used by value_namespace_elt and
3132 value_struct_elt_for_reference. It looks up NAME inside the
3133 context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3134 is a class and NAME refers to a type in CURTYPE itself (as opposed
3135 to, say, some base class of CURTYPE). */
3137 static struct value
*
3138 value_maybe_namespace_elt (const struct type
*curtype
,
3139 char *name
, int want_address
,
3142 const char *namespace_name
= TYPE_TAG_NAME (curtype
);
3144 struct value
*result
;
3146 sym
= cp_lookup_symbol_namespace (namespace_name
, name
,
3147 get_selected_block (0),
3152 else if ((noside
== EVAL_AVOID_SIDE_EFFECTS
)
3153 && (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
))
3154 result
= allocate_value (SYMBOL_TYPE (sym
));
3156 result
= value_of_variable (sym
, get_selected_block (0));
3158 if (result
&& want_address
)
3159 result
= value_addr (result
);
3164 /* Given a pointer value V, find the real (RTTI) type of the object it
3167 Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3168 and refer to the values computed for the object pointed to. */
3171 value_rtti_target_type (struct value
*v
, int *full
,
3172 int *top
, int *using_enc
)
3174 struct value
*target
;
3176 target
= value_ind (v
);
3178 return value_rtti_type (target
, full
, top
, using_enc
);
3181 /* Given a value pointed to by ARGP, check its real run-time type, and
3182 if that is different from the enclosing type, create a new value
3183 using the real run-time type as the enclosing type (and of the same
3184 type as ARGP) and return it, with the embedded offset adjusted to
3185 be the correct offset to the enclosed object. RTYPE is the type,
3186 and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3187 by value_rtti_type(). If these are available, they can be supplied
3188 and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3189 NULL if they're not available. */
3192 value_full_object (struct value
*argp
,
3194 int xfull
, int xtop
,
3197 struct type
*real_type
;
3201 struct value
*new_val
;
3208 using_enc
= xusing_enc
;
3211 real_type
= value_rtti_type (argp
, &full
, &top
, &using_enc
);
3213 /* If no RTTI data, or if object is already complete, do nothing. */
3214 if (!real_type
|| real_type
== value_enclosing_type (argp
))
3217 /* If we have the full object, but for some reason the enclosing
3218 type is wrong, set it. */
3219 /* pai: FIXME -- sounds iffy */
3222 argp
= value_change_enclosing_type (argp
, real_type
);
3226 /* Check if object is in memory */
3227 if (VALUE_LVAL (argp
) != lval_memory
)
3229 warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
3230 TYPE_NAME (real_type
));
3235 /* All other cases -- retrieve the complete object. */
3236 /* Go back by the computed top_offset from the beginning of the
3237 object, adjusting for the embedded offset of argp if that's what
3238 value_rtti_type used for its computation. */
3239 new_val
= value_at_lazy (real_type
, value_address (argp
) - top
+
3240 (using_enc
? 0 : value_embedded_offset (argp
)));
3241 deprecated_set_value_type (new_val
, value_type (argp
));
3242 set_value_embedded_offset (new_val
, (using_enc
3243 ? top
+ value_embedded_offset (argp
)
3249 /* Return the value of the local variable, if one exists.
3250 Flag COMPLAIN signals an error if the request is made in an
3251 inappropriate context. */
3254 value_of_local (const char *name
, int complain
)
3256 struct symbol
*func
, *sym
;
3259 struct frame_info
*frame
;
3262 frame
= get_selected_frame (_("no frame selected"));
3265 frame
= deprecated_safe_get_selected_frame ();
3270 func
= get_frame_function (frame
);
3274 error (_("no `%s' in nameless context"), name
);
3279 b
= SYMBOL_BLOCK_VALUE (func
);
3280 if (dict_empty (BLOCK_DICT (b
)))
3283 error (_("no args, no `%s'"), name
);
3288 /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3289 symbol instead of the LOC_ARG one (if both exist). */
3290 sym
= lookup_block_symbol (b
, name
, VAR_DOMAIN
);
3294 error (_("current stack frame does not contain a variable named `%s'"),
3300 ret
= read_var_value (sym
, frame
);
3301 if (ret
== 0 && complain
)
3302 error (_("`%s' argument unreadable"), name
);
3306 /* C++/Objective-C: return the value of the class instance variable,
3307 if one exists. Flag COMPLAIN signals an error if the request is
3308 made in an inappropriate context. */
3311 value_of_this (int complain
)
3313 if (!current_language
->la_name_of_this
)
3315 return value_of_local (current_language
->la_name_of_this
, complain
);
3318 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3319 elements long, starting at LOWBOUND. The result has the same lower
3320 bound as the original ARRAY. */
3323 value_slice (struct value
*array
, int lowbound
, int length
)
3325 struct type
*slice_range_type
, *slice_type
, *range_type
;
3326 LONGEST lowerbound
, upperbound
;
3327 struct value
*slice
;
3328 struct type
*array_type
;
3330 array_type
= check_typedef (value_type (array
));
3331 if (TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
3332 && TYPE_CODE (array_type
) != TYPE_CODE_STRING
3333 && TYPE_CODE (array_type
) != TYPE_CODE_BITSTRING
)
3334 error (_("cannot take slice of non-array"));
3336 range_type
= TYPE_INDEX_TYPE (array_type
);
3337 if (get_discrete_bounds (range_type
, &lowerbound
, &upperbound
) < 0)
3338 error (_("slice from bad array or bitstring"));
3340 if (lowbound
< lowerbound
|| length
< 0
3341 || lowbound
+ length
- 1 > upperbound
)
3342 error (_("slice out of range"));
3344 /* FIXME-type-allocation: need a way to free this type when we are
3346 slice_range_type
= create_range_type ((struct type
*) NULL
,
3347 TYPE_TARGET_TYPE (range_type
),
3349 lowbound
+ length
- 1);
3350 if (TYPE_CODE (array_type
) == TYPE_CODE_BITSTRING
)
3354 slice_type
= create_set_type ((struct type
*) NULL
,
3356 TYPE_CODE (slice_type
) = TYPE_CODE_BITSTRING
;
3357 slice
= value_zero (slice_type
, not_lval
);
3359 for (i
= 0; i
< length
; i
++)
3361 int element
= value_bit_index (array_type
,
3362 value_contents (array
),
3365 error (_("internal error accessing bitstring"));
3366 else if (element
> 0)
3368 int j
= i
% TARGET_CHAR_BIT
;
3369 if (gdbarch_bits_big_endian (get_type_arch (array_type
)))
3370 j
= TARGET_CHAR_BIT
- 1 - j
;
3371 value_contents_raw (slice
)[i
/ TARGET_CHAR_BIT
] |= (1 << j
);
3374 /* We should set the address, bitssize, and bitspos, so the
3375 slice can be used on the LHS, but that may require extensions
3376 to value_assign. For now, just leave as a non_lval.
3381 struct type
*element_type
= TYPE_TARGET_TYPE (array_type
);
3383 (lowbound
- lowerbound
) * TYPE_LENGTH (check_typedef (element_type
));
3385 slice_type
= create_array_type ((struct type
*) NULL
,
3388 TYPE_CODE (slice_type
) = TYPE_CODE (array_type
);
3390 if (VALUE_LVAL (array
) == lval_memory
&& value_lazy (array
))
3391 slice
= allocate_value_lazy (slice_type
);
3394 slice
= allocate_value (slice_type
);
3395 memcpy (value_contents_writeable (slice
),
3396 value_contents (array
) + offset
,
3397 TYPE_LENGTH (slice_type
));
3400 set_value_component_location (slice
, array
);
3401 VALUE_FRAME_ID (slice
) = VALUE_FRAME_ID (array
);
3402 set_value_offset (slice
, value_offset (array
) + offset
);
3407 /* Create a value for a FORTRAN complex number. Currently most of the
3408 time values are coerced to COMPLEX*16 (i.e. a complex number
3409 composed of 2 doubles. This really should be a smarter routine
3410 that figures out precision inteligently as opposed to assuming
3411 doubles. FIXME: fmb */
3414 value_literal_complex (struct value
*arg1
,
3419 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3421 val
= allocate_value (type
);
3422 arg1
= value_cast (real_type
, arg1
);
3423 arg2
= value_cast (real_type
, arg2
);
3425 memcpy (value_contents_raw (val
),
3426 value_contents (arg1
), TYPE_LENGTH (real_type
));
3427 memcpy (value_contents_raw (val
) + TYPE_LENGTH (real_type
),
3428 value_contents (arg2
), TYPE_LENGTH (real_type
));
3432 /* Cast a value into the appropriate complex data type. */
3434 static struct value
*
3435 cast_into_complex (struct type
*type
, struct value
*val
)
3437 struct type
*real_type
= TYPE_TARGET_TYPE (type
);
3439 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_COMPLEX
)
3441 struct type
*val_real_type
= TYPE_TARGET_TYPE (value_type (val
));
3442 struct value
*re_val
= allocate_value (val_real_type
);
3443 struct value
*im_val
= allocate_value (val_real_type
);
3445 memcpy (value_contents_raw (re_val
),
3446 value_contents (val
), TYPE_LENGTH (val_real_type
));
3447 memcpy (value_contents_raw (im_val
),
3448 value_contents (val
) + TYPE_LENGTH (val_real_type
),
3449 TYPE_LENGTH (val_real_type
));
3451 return value_literal_complex (re_val
, im_val
, type
);
3453 else if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FLT
3454 || TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
3455 return value_literal_complex (val
,
3456 value_zero (real_type
, not_lval
),
3459 error (_("cannot cast non-number to complex"));
3463 _initialize_valops (void)
3465 add_setshow_boolean_cmd ("overload-resolution", class_support
,
3466 &overload_resolution
, _("\
3467 Set overload resolution in evaluating C++ functions."), _("\
3468 Show overload resolution in evaluating C++ functions."),
3470 show_overload_resolution
,
3471 &setlist
, &showlist
);
3472 overload_resolution
= 1;