1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995, 1996, 1997
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
35 /* Local function prototypes. */
37 static value_ptr value_headof
PARAMS ((value_ptr
, struct type
*,
40 static void show_values
PARAMS ((char *, int));
42 static void show_convenience
PARAMS ((char *, int));
44 static int vb_match
PARAMS ((struct type
*, int, struct type
*));
46 /* The value-history records all the values printed
47 by print commands during this session. Each chunk
48 records 60 consecutive values. The first chunk on
49 the chain records the most recent values.
50 The total number of values is in value_history_count. */
52 #define VALUE_HISTORY_CHUNK 60
54 struct value_history_chunk
56 struct value_history_chunk
*next
;
57 value_ptr values
[VALUE_HISTORY_CHUNK
];
60 /* Chain of chunks now in use. */
62 static struct value_history_chunk
*value_history_chain
;
64 static int value_history_count
; /* Abs number of last entry stored */
66 /* List of all value objects currently allocated
67 (except for those released by calls to release_value)
68 This is so they can be freed after each command. */
70 static value_ptr all_values
;
72 /* Allocate a value that has the correct length for type TYPE. */
78 register value_ptr val
;
79 struct type
*atype
= check_typedef (type
);
81 val
= (struct value
*) xmalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
82 VALUE_NEXT (val
) = all_values
;
84 VALUE_TYPE (val
) = type
;
85 VALUE_LVAL (val
) = not_lval
;
86 VALUE_ADDRESS (val
) = 0;
87 VALUE_FRAME (val
) = 0;
88 VALUE_OFFSET (val
) = 0;
89 VALUE_BITPOS (val
) = 0;
90 VALUE_BITSIZE (val
) = 0;
91 VALUE_REGNO (val
) = -1;
93 VALUE_OPTIMIZED_OUT (val
) = 0;
94 VALUE_BFD_SECTION (val
) = NULL
;
99 /* Allocate a value that has the correct length
100 for COUNT repetitions type TYPE. */
103 allocate_repeat_value (type
, count
)
107 int low_bound
= current_language
->string_lower_bound
; /* ??? */
108 /* FIXME-type-allocation: need a way to free this type when we are
110 struct type
*range_type
111 = create_range_type ((struct type
*) NULL
, builtin_type_int
,
112 low_bound
, count
+ low_bound
- 1);
113 /* FIXME-type-allocation: need a way to free this type when we are
115 return allocate_value (create_array_type ((struct type
*) NULL
,
119 /* Return a mark in the value chain. All values allocated after the
120 mark is obtained (except for those released) are subject to being freed
121 if a subsequent value_free_to_mark is passed the mark. */
128 /* Free all values allocated since MARK was obtained by value_mark
129 (except for those released). */
131 value_free_to_mark (mark
)
136 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
138 next
= VALUE_NEXT (val
);
144 /* Free all the values that have been allocated (except for those released).
145 Called after each command, successful or not. */
150 register value_ptr val
, next
;
152 for (val
= all_values
; val
; val
= next
)
154 next
= VALUE_NEXT (val
);
161 /* Remove VAL from the chain all_values
162 so it will not be freed automatically. */
166 register value_ptr val
;
168 register value_ptr v
;
170 if (all_values
== val
)
172 all_values
= val
->next
;
176 for (v
= all_values
; v
; v
= v
->next
)
186 /* Release all values up to mark */
188 value_release_to_mark (mark
)
193 for (val
= next
= all_values
; next
; next
= VALUE_NEXT (next
))
194 if (VALUE_NEXT (next
) == mark
)
196 all_values
= VALUE_NEXT (next
);
197 VALUE_NEXT (next
) = 0;
204 /* Return a copy of the value ARG.
205 It contains the same contents, for same memory address,
206 but it's a different block of storage. */
212 register struct type
*type
= VALUE_TYPE (arg
);
213 register value_ptr val
= allocate_value (type
);
214 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
215 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
216 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
217 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
218 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
219 VALUE_FRAME (val
) = VALUE_FRAME (arg
);
220 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
221 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
222 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
223 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (arg
);
224 val
->modifiable
= arg
->modifiable
;
225 if (!VALUE_LAZY (val
))
227 memcpy (VALUE_CONTENTS_RAW (val
), VALUE_CONTENTS_RAW (arg
),
228 TYPE_LENGTH (VALUE_TYPE (arg
)));
233 /* Access to the value history. */
235 /* Record a new value in the value history.
236 Returns the absolute history index of the entry.
237 Result of -1 indicates the value was not saved; otherwise it is the
238 value history index of this new item. */
241 record_latest_value (val
)
246 /* We don't want this value to have anything to do with the inferior anymore.
247 In particular, "set $1 = 50" should not affect the variable from which
248 the value was taken, and fast watchpoints should be able to assume that
249 a value on the value history never changes. */
250 if (VALUE_LAZY (val
))
251 value_fetch_lazy (val
);
252 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
253 from. This is a bit dubious, because then *&$1 does not just return $1
254 but the current contents of that location. c'est la vie... */
258 /* Here we treat value_history_count as origin-zero
259 and applying to the value being stored now. */
261 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
264 register struct value_history_chunk
*new
265 = (struct value_history_chunk
*)
266 xmalloc (sizeof (struct value_history_chunk
));
267 memset (new->values
, 0, sizeof new->values
);
268 new->next
= value_history_chain
;
269 value_history_chain
= new;
272 value_history_chain
->values
[i
] = val
;
274 /* Now we regard value_history_count as origin-one
275 and applying to the value just stored. */
277 return ++value_history_count
;
280 /* Return a copy of the value in the history with sequence number NUM. */
283 access_value_history (num
)
286 register struct value_history_chunk
*chunk
;
288 register int absnum
= num
;
291 absnum
+= value_history_count
;
296 error ("The history is empty.");
298 error ("There is only one value in the history.");
300 error ("History does not go back to $$%d.", -num
);
302 if (absnum
> value_history_count
)
303 error ("History has not yet reached $%d.", absnum
);
307 /* Now absnum is always absolute and origin zero. */
309 chunk
= value_history_chain
;
310 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
314 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
317 /* Clear the value history entirely.
318 Must be done when new symbol tables are loaded,
319 because the type pointers become invalid. */
322 clear_value_history ()
324 register struct value_history_chunk
*next
;
326 register value_ptr val
;
328 while (value_history_chain
)
330 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
331 if ((val
= value_history_chain
->values
[i
]) != NULL
)
333 next
= value_history_chain
->next
;
334 free ((PTR
)value_history_chain
);
335 value_history_chain
= next
;
337 value_history_count
= 0;
341 show_values (num_exp
, from_tty
)
346 register value_ptr val
;
351 /* "info history +" should print from the stored position.
352 "info history <exp>" should print around value number <exp>. */
353 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
354 num
= parse_and_eval_address (num_exp
) - 5;
358 /* "info history" means print the last 10 values. */
359 num
= value_history_count
- 9;
365 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
367 val
= access_value_history (i
);
368 printf_filtered ("$%d = ", i
);
369 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
370 printf_filtered ("\n");
373 /* The next "info history +" should start after what we just printed. */
376 /* Hitting just return after this command should do the same thing as
377 "info history +". If num_exp is null, this is unnecessary, since
378 "info history +" is not useful after "info history". */
379 if (from_tty
&& num_exp
)
386 /* Internal variables. These are variables within the debugger
387 that hold values assigned by debugger commands.
388 The user refers to them with a '$' prefix
389 that does not appear in the variable names stored internally. */
391 static struct internalvar
*internalvars
;
393 /* Look up an internal variable with name NAME. NAME should not
394 normally include a dollar sign.
396 If the specified internal variable does not exist,
397 one is created, with a void value. */
400 lookup_internalvar (name
)
403 register struct internalvar
*var
;
405 for (var
= internalvars
; var
; var
= var
->next
)
406 if (STREQ (var
->name
, name
))
409 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
410 var
->name
= concat (name
, NULL
);
411 var
->value
= allocate_value (builtin_type_void
);
412 release_value (var
->value
);
413 var
->next
= internalvars
;
419 value_of_internalvar (var
)
420 struct internalvar
*var
;
422 register value_ptr val
;
424 #ifdef IS_TRAPPED_INTERNALVAR
425 if (IS_TRAPPED_INTERNALVAR (var
->name
))
426 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
429 val
= value_copy (var
->value
);
430 if (VALUE_LAZY (val
))
431 value_fetch_lazy (val
);
432 VALUE_LVAL (val
) = lval_internalvar
;
433 VALUE_INTERNALVAR (val
) = var
;
438 set_internalvar_component (var
, offset
, bitpos
, bitsize
, newval
)
439 struct internalvar
*var
;
440 int offset
, bitpos
, bitsize
;
443 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
445 #ifdef IS_TRAPPED_INTERNALVAR
446 if (IS_TRAPPED_INTERNALVAR (var
->name
))
447 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
451 modify_field (addr
, value_as_long (newval
),
454 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (VALUE_TYPE (newval
)));
458 set_internalvar (var
, val
)
459 struct internalvar
*var
;
464 #ifdef IS_TRAPPED_INTERNALVAR
465 if (IS_TRAPPED_INTERNALVAR (var
->name
))
466 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
469 newval
= value_copy (val
);
470 newval
->modifiable
= 1;
472 /* Force the value to be fetched from the target now, to avoid problems
473 later when this internalvar is referenced and the target is gone or
475 if (VALUE_LAZY (newval
))
476 value_fetch_lazy (newval
);
478 /* Begin code which must not call error(). If var->value points to
479 something free'd, an error() obviously leaves a dangling pointer.
480 But we also get a danling pointer if var->value points to
481 something in the value chain (i.e., before release_value is
482 called), because after the error free_all_values will get called before
484 free ((PTR
)var
->value
);
486 release_value (newval
);
487 /* End code which must not call error(). */
491 internalvar_name (var
)
492 struct internalvar
*var
;
497 /* Free all internalvars. Done when new symtabs are loaded,
498 because that makes the values invalid. */
501 clear_internalvars ()
503 register struct internalvar
*var
;
508 internalvars
= var
->next
;
509 free ((PTR
)var
->name
);
510 free ((PTR
)var
->value
);
516 show_convenience (ignore
, from_tty
)
520 register struct internalvar
*var
;
523 for (var
= internalvars
; var
; var
= var
->next
)
525 #ifdef IS_TRAPPED_INTERNALVAR
526 if (IS_TRAPPED_INTERNALVAR (var
->name
))
533 printf_filtered ("$%s = ", var
->name
);
534 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
535 printf_filtered ("\n");
538 printf_unfiltered ("No debugger convenience variables now defined.\n\
539 Convenience variables have names starting with \"$\";\n\
540 use \"set\" as in \"set $foo = 5\" to define them.\n");
543 /* Extract a value as a C number (either long or double).
544 Knows how to convert fixed values to double, or
545 floating values to long.
546 Does not deallocate the value. */
550 register value_ptr val
;
552 /* This coerces arrays and functions, which is necessary (e.g.
553 in disassemble_command). It also dereferences references, which
554 I suspect is the most logical thing to do. */
556 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
560 value_as_double (val
)
561 register value_ptr val
;
566 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
568 error ("Invalid floating value found in program.");
571 /* Extract a value as a C pointer.
572 Does not deallocate the value. */
574 value_as_pointer (val
)
577 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
578 whether we want this to be true eventually. */
580 /* ADDR_BITS_REMOVE is wrong if we are being called for a
581 non-address (e.g. argument to "signal", "info break", etc.), or
582 for pointers to char, in which the low bits *are* significant. */
583 return ADDR_BITS_REMOVE(value_as_long (val
));
585 return value_as_long (val
);
589 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
590 as a long, or as a double, assuming the raw data is described
591 by type TYPE. Knows how to convert different sizes of values
592 and can convert between fixed and floating point. We don't assume
593 any alignment for the raw data. Return value is in host byte order.
595 If you want functions and arrays to be coerced to pointers, and
596 references to be dereferenced, call value_as_long() instead.
598 C++: It is assumed that the front-end has taken care of
599 all matters concerning pointers to members. A pointer
600 to member which reaches here is considered to be equivalent
601 to an INT (or some size). After all, it is only an offset. */
604 unpack_long (type
, valaddr
)
608 register enum type_code code
= TYPE_CODE (type
);
609 register int len
= TYPE_LENGTH (type
);
610 register int nosign
= TYPE_UNSIGNED (type
);
612 if (current_language
->la_language
== language_scm
613 && is_scmvalue_type (type
))
614 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
618 case TYPE_CODE_TYPEDEF
:
619 return unpack_long (check_typedef (type
), valaddr
);
624 case TYPE_CODE_RANGE
:
626 return extract_unsigned_integer (valaddr
, len
);
628 return extract_signed_integer (valaddr
, len
);
631 return extract_floating (valaddr
, len
);
635 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
636 whether we want this to be true eventually. */
637 #ifdef GDB_TARGET_IS_D10V
639 return D10V_MAKE_DADDR(extract_address (valaddr
, len
));
641 return extract_address (valaddr
, len
);
643 case TYPE_CODE_MEMBER
:
644 error ("not implemented: member types in unpack_long");
647 error ("Value can't be converted to integer.");
649 return 0; /* Placate lint. */
652 /* Return a double value from the specified type and address.
653 INVP points to an int which is set to 0 for valid value,
654 1 for invalid value (bad float format). In either case,
655 the returned double is OK to use. Argument is in target
656 format, result is in host format. */
659 unpack_double (type
, valaddr
, invp
)
664 register enum type_code code
= TYPE_CODE (type
);
665 register int len
= TYPE_LENGTH (type
);
666 register int nosign
= TYPE_UNSIGNED (type
);
668 *invp
= 0; /* Assume valid. */
669 CHECK_TYPEDEF (type
);
670 if (code
== TYPE_CODE_FLT
)
673 if (INVALID_FLOAT (valaddr
, len
))
676 return 1.234567891011121314;
679 return extract_floating (valaddr
, len
);
683 /* Unsigned -- be sure we compensate for signed LONGEST. */
684 #if !defined (_MSC_VER) || (_MSC_VER > 900)
685 return (ULONGEST
) unpack_long (type
, valaddr
);
687 /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */
688 return (LONGEST
) unpack_long (type
, valaddr
);
689 #endif /* _MSC_VER */
693 /* Signed -- we are OK with unpack_long. */
694 return unpack_long (type
, valaddr
);
698 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
699 as a CORE_ADDR, assuming the raw data is described by type TYPE.
700 We don't assume any alignment for the raw data. Return value is in
703 If you want functions and arrays to be coerced to pointers, and
704 references to be dereferenced, call value_as_pointer() instead.
706 C++: It is assumed that the front-end has taken care of
707 all matters concerning pointers to members. A pointer
708 to member which reaches here is considered to be equivalent
709 to an INT (or some size). After all, it is only an offset. */
712 unpack_pointer (type
, valaddr
)
716 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
717 whether we want this to be true eventually. */
718 return unpack_long (type
, valaddr
);
721 /* Get the value of the FIELDN'th field (which must be static) of TYPE. */
724 value_static_field (type
, fieldno
)
730 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
732 addr
= TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
);
737 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
738 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
741 addr
= SYMBOL_VALUE_ADDRESS (sym
);
742 sect
= SYMBOL_BFD_SECTION (sym
);
743 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
), addr
);
745 return value_at (TYPE_FIELD_TYPE (type
, fieldno
), addr
, sect
);
748 /* Given a value ARG1 (offset by OFFSET bytes)
749 of a struct or union type ARG_TYPE,
750 extract and return the value of one of its (non-static) fields.
751 FIELDNO says which field. */
754 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
755 register value_ptr arg1
;
757 register int fieldno
;
758 register struct type
*arg_type
;
760 register value_ptr v
;
761 register struct type
*type
;
763 CHECK_TYPEDEF (arg_type
);
764 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
766 /* Handle packed fields */
768 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
770 v
= value_from_longest (type
,
771 unpack_field_as_long (arg_type
,
772 VALUE_CONTENTS (arg1
)
775 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
776 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
780 v
= allocate_value (type
);
781 if (VALUE_LAZY (arg1
))
784 memcpy (VALUE_CONTENTS_RAW (v
),
785 VALUE_CONTENTS_RAW (arg1
) + offset
786 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8,
789 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
790 if (VALUE_LVAL (arg1
) == lval_internalvar
)
791 VALUE_LVAL (v
) = lval_internalvar_component
;
792 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
793 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
794 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
798 /* Given a value ARG1 of a struct or union type,
799 extract and return the value of one of its (non-static) fields.
800 FIELDNO says which field. */
803 value_field (arg1
, fieldno
)
804 register value_ptr arg1
;
805 register int fieldno
;
807 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
810 /* Return a non-virtual function as a value.
811 F is the list of member functions which contains the desired method.
812 J is an index into F which provides the desired method. */
815 value_fn_field (arg1p
, f
, j
, type
, offset
)
822 register value_ptr v
;
823 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
826 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
827 0, VAR_NAMESPACE
, 0, NULL
);
831 error ("Internal error: could not find physical method named %s",
832 TYPE_FN_FIELD_PHYSNAME (f, j));
835 v
= allocate_value (ftype
);
836 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
837 VALUE_TYPE (v
) = ftype
;
841 if (type
!= VALUE_TYPE (*arg1p
))
842 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
843 value_addr (*arg1p
)));
845 /* Move the `this' pointer according to the offset.
846 VALUE_OFFSET (*arg1p) += offset;
853 /* Return a virtual function as a value.
854 ARG1 is the object which provides the virtual function
855 table pointer. *ARG1P is side-effected in calling this function.
856 F is the list of member functions which contains the desired virtual
858 J is an index into F which provides the desired virtual function.
860 TYPE is the type in which F is located. */
862 value_virtual_fn_field (arg1p
, f
, j
, type
, offset
)
869 value_ptr arg1
= *arg1p
;
870 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
871 struct type
*entry_type
;
872 /* First, get the virtual function table pointer. That comes
873 with a strange type, so cast it to type `pointer to long' (which
874 should serve just fine as a function type). Then, index into
875 the table, and convert final value to appropriate function type. */
876 value_ptr entry
, vfn
, vtbl
;
877 value_ptr vi
= value_from_longest (builtin_type_int
,
878 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
879 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
880 struct type
*context
;
881 if (fcontext
== NULL
)
882 /* We don't have an fcontext (e.g. the program was compiled with
883 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
884 This won't work right for multiple inheritance, but at least we
885 should do as well as GDB 3.x did. */
886 fcontext
= TYPE_VPTR_BASETYPE (type
);
887 context
= lookup_pointer_type (fcontext
);
888 /* Now context is a pointer to the basetype containing the vtbl. */
889 if (TYPE_TARGET_TYPE (context
) != type1
)
891 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
892 type1
= check_typedef (VALUE_TYPE (arg1
));
896 /* Now context is the basetype containing the vtbl. */
898 /* This type may have been defined before its virtual function table
899 was. If so, fill in the virtual function table entry for the
901 if (TYPE_VPTR_FIELDNO (context
) < 0)
902 fill_in_vptr_fieldno (context
);
904 /* The virtual function table is now an array of structures
905 which have the form { int16 offset, delta; void *pfn; }. */
906 vtbl
= value_ind (value_primitive_field (arg1
, 0,
907 TYPE_VPTR_FIELDNO (context
),
908 TYPE_VPTR_BASETYPE (context
)));
910 /* Index into the virtual function table. This is hard-coded because
911 looking up a field is not cheap, and it may be important to save
912 time, e.g. if the user has set a conditional breakpoint calling
913 a virtual function. */
914 entry
= value_subscript (vtbl
, vi
);
915 entry_type
= check_typedef (VALUE_TYPE (entry
));
917 if (TYPE_CODE (entry_type
) == TYPE_CODE_STRUCT
)
919 /* Move the `this' pointer according to the virtual function table. */
920 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
922 if (! VALUE_LAZY (arg1
))
924 VALUE_LAZY (arg1
) = 1;
925 value_fetch_lazy (arg1
);
928 vfn
= value_field (entry
, 2);
930 else if (TYPE_CODE (entry_type
) == TYPE_CODE_PTR
)
933 error ("I'm confused: virtual function table has bad type");
934 /* Reinstantiate the function pointer with the correct type. */
935 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
941 /* ARG is a pointer to an object we know to be at least
942 a DTYPE. BTYPE is the most derived basetype that has
943 already been searched (and need not be searched again).
944 After looking at the vtables between BTYPE and DTYPE,
945 return the most derived type we find. The caller must
946 be satisfied when the return value == DTYPE.
948 FIXME-tiemann: should work with dossier entries as well. */
951 value_headof (in_arg
, btype
, dtype
)
953 struct type
*btype
, *dtype
;
955 /* First collect the vtables we must look at for this object. */
956 /* FIXME-tiemann: right now, just look at top-most vtable. */
957 value_ptr arg
, vtbl
, entry
, best_entry
= 0;
959 int offset
, best_offset
= 0;
961 CORE_ADDR pc_for_sym
;
962 char *demangled_name
;
963 struct minimal_symbol
*msymbol
;
965 btype
= TYPE_VPTR_BASETYPE (dtype
);
966 CHECK_TYPEDEF (btype
);
969 arg
= value_cast (lookup_pointer_type (btype
), arg
);
970 vtbl
= value_ind (value_field (value_ind (arg
), TYPE_VPTR_FIELDNO (btype
)));
972 /* Check that VTBL looks like it points to a virtual function table. */
973 msymbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl
));
975 || (demangled_name
= SYMBOL_NAME (msymbol
)) == NULL
976 || !VTBL_PREFIX_P (demangled_name
))
978 /* If we expected to find a vtable, but did not, let the user
979 know that we aren't happy, but don't throw an error.
980 FIXME: there has to be a better way to do this. */
981 struct type
*error_type
= (struct type
*)xmalloc (sizeof (struct type
));
982 memcpy (error_type
, VALUE_TYPE (in_arg
), sizeof (struct type
));
983 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
984 VALUE_TYPE (in_arg
) = error_type
;
988 /* Now search through the virtual function table. */
989 entry
= value_ind (vtbl
);
990 nelems
= longest_to_int (value_as_long (value_field (entry
, 2)));
991 for (i
= 1; i
<= nelems
; i
++)
993 entry
= value_subscript (vtbl
, value_from_longest (builtin_type_int
,
995 /* This won't work if we're using thunks. */
996 if (TYPE_CODE (check_typedef (VALUE_TYPE (entry
))) != TYPE_CODE_STRUCT
)
998 offset
= longest_to_int (value_as_long (value_field (entry
, 0)));
999 /* If we use '<=' we can handle single inheritance
1000 * where all offsets are zero - just use the first entry found. */
1001 if (offset
<= best_offset
)
1003 best_offset
= offset
;
1007 /* Move the pointer according to BEST_ENTRY's offset, and figure
1008 out what type we should return as the new pointer. */
1009 if (best_entry
== 0)
1011 /* An alternative method (which should no longer be necessary).
1012 * But we leave it in for future use, when we will hopefully
1013 * have optimizes the vtable to use thunks instead of offsets. */
1014 /* Use the name of vtable itself to extract a base type. */
1015 demangled_name
+= 4; /* Skip _vt$ prefix. */
1019 pc_for_sym
= value_as_pointer (value_field (best_entry
, 2));
1020 sym
= find_pc_function (pc_for_sym
);
1021 demangled_name
= cplus_demangle (SYMBOL_NAME (sym
), DMGL_ANSI
);
1022 *(strchr (demangled_name
, ':')) = '\0';
1024 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1026 error ("could not find type declaration for `%s'", demangled_name
);
1029 free (demangled_name
);
1030 arg
= value_add (value_cast (builtin_type_int
, arg
),
1031 value_field (best_entry
, 0));
1034 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1038 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1039 function tables, probe ARG's tables (including the vtables
1040 of its baseclasses) to figure out the most derived type that ARG
1041 could actually be a pointer to. */
1044 value_from_vtable_info (arg
, type
)
1048 /* Take care of preliminaries. */
1049 if (TYPE_VPTR_FIELDNO (type
) < 0)
1050 fill_in_vptr_fieldno (type
);
1051 if (TYPE_VPTR_FIELDNO (type
) < 0)
1054 return value_headof (arg
, 0, type
);
1057 /* Return true if the INDEXth field of TYPE is a virtual baseclass
1058 pointer which is for the base class whose type is BASECLASS. */
1061 vb_match (type
, index
, basetype
)
1064 struct type
*basetype
;
1066 struct type
*fieldtype
;
1067 char *name
= TYPE_FIELD_NAME (type
, index
);
1068 char *field_class_name
= NULL
;
1072 /* gcc 2.4 uses _vb$. */
1073 if (name
[1] == 'v' && name
[2] == 'b' && is_cplus_marker (name
[3]))
1074 field_class_name
= name
+ 4;
1075 /* gcc 2.5 will use __vb_. */
1076 if (name
[1] == '_' && name
[2] == 'v' && name
[3] == 'b' && name
[4] == '_')
1077 field_class_name
= name
+ 5;
1079 if (field_class_name
== NULL
)
1080 /* This field is not a virtual base class pointer. */
1083 /* It's a virtual baseclass pointer, now we just need to find out whether
1084 it is for this baseclass. */
1085 fieldtype
= TYPE_FIELD_TYPE (type
, index
);
1086 if (fieldtype
== NULL
1087 || TYPE_CODE (fieldtype
) != TYPE_CODE_PTR
)
1088 /* "Can't happen". */
1091 /* What we check for is that either the types are equal (needed for
1092 nameless types) or have the same name. This is ugly, and a more
1093 elegant solution should be devised (which would probably just push
1094 the ugliness into symbol reading unless we change the stabs format). */
1095 if (TYPE_TARGET_TYPE (fieldtype
) == basetype
)
1098 if (TYPE_NAME (basetype
) != NULL
1099 && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
)) != NULL
1100 && STREQ (TYPE_NAME (basetype
),
1101 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
))))
1106 /* Compute the offset of the baseclass which is
1107 the INDEXth baseclass of class TYPE,
1108 for value at VALADDR (in host) at ADDRESS (in target).
1109 The result is the offset of the baseclass value relative
1110 to (the address of)(ARG) + OFFSET.
1112 -1 is returned on error. */
1115 baseclass_offset (type
, index
, valaddr
, address
)
1121 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1123 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1125 /* Must hunt for the pointer to this virtual baseclass. */
1126 register int i
, len
= TYPE_NFIELDS (type
);
1127 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1129 /* First look for the virtual baseclass pointer
1131 for (i
= n_baseclasses
; i
< len
; i
++)
1133 if (vb_match (type
, i
, basetype
))
1136 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1137 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1139 return addr
- (LONGEST
) address
;
1142 /* Not in the fields, so try looking through the baseclasses. */
1143 for (i
= index
+1; i
< n_baseclasses
; i
++)
1146 baseclass_offset (type
, i
, valaddr
, address
);
1154 /* Baseclass is easily computed. */
1155 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1158 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1161 Extracting bits depends on endianness of the machine. Compute the
1162 number of least significant bits to discard. For big endian machines,
1163 we compute the total number of bits in the anonymous object, subtract
1164 off the bit count from the MSB of the object to the MSB of the
1165 bitfield, then the size of the bitfield, which leaves the LSB discard
1166 count. For little endian machines, the discard count is simply the
1167 number of bits from the LSB of the anonymous object to the LSB of the
1170 If the field is signed, we also do sign extension. */
1173 unpack_field_as_long (type
, valaddr
, fieldno
)
1180 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1181 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1183 struct type
*field_type
;
1185 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1186 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1187 CHECK_TYPEDEF (field_type
);
1189 /* Extract bits. See comment above. */
1191 if (BITS_BIG_ENDIAN
)
1192 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1194 lsbcount
= (bitpos
% 8);
1197 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1198 If the field is signed, and is negative, then sign extend. */
1200 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1202 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1204 if (!TYPE_UNSIGNED (field_type
))
1206 if (val
& (valmask
^ (valmask
>> 1)))
1215 /* Modify the value of a bitfield. ADDR points to a block of memory in
1216 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1217 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1218 indicate which bits (in target bit order) comprise the bitfield. */
1221 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1224 int bitpos
, bitsize
;
1228 /* If a negative fieldval fits in the field in question, chop
1229 off the sign extension bits. */
1230 if (bitsize
< (8 * (int) sizeof (fieldval
))
1231 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1232 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1234 /* Warn if value is too big to fit in the field in question. */
1235 if (bitsize
< (8 * (int) sizeof (fieldval
))
1236 && 0 != (fieldval
& ~((1<<bitsize
)-1)))
1238 /* FIXME: would like to include fieldval in the message, but
1239 we don't have a sprintf_longest. */
1240 warning ("Value does not fit in %d bits.", bitsize
);
1242 /* Truncate it, otherwise adjoining fields may be corrupted. */
1243 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1246 oword
= extract_signed_integer (addr
, sizeof oword
);
1248 /* Shifting for bit field depends on endianness of the target machine. */
1249 if (BITS_BIG_ENDIAN
)
1250 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1252 /* Mask out old value, while avoiding shifts >= size of oword */
1253 if (bitsize
< 8 * (int) sizeof (oword
))
1254 oword
&= ~(((((ULONGEST
)1) << bitsize
) - 1) << bitpos
);
1256 oword
&= ~((~(ULONGEST
)0) << bitpos
);
1257 oword
|= fieldval
<< bitpos
;
1259 store_signed_integer (addr
, sizeof oword
, oword
);
1262 /* Convert C numbers into newly allocated values */
1265 value_from_longest (type
, num
)
1267 register LONGEST num
;
1269 register value_ptr val
= allocate_value (type
);
1270 register enum type_code code
;
1273 code
= TYPE_CODE (type
);
1274 len
= TYPE_LENGTH (type
);
1278 case TYPE_CODE_TYPEDEF
:
1279 type
= check_typedef (type
);
1282 case TYPE_CODE_CHAR
:
1283 case TYPE_CODE_ENUM
:
1284 case TYPE_CODE_BOOL
:
1285 case TYPE_CODE_RANGE
:
1286 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1291 /* This assumes that all pointers of a given length
1292 have the same form. */
1293 store_address (VALUE_CONTENTS_RAW (val
), len
, (CORE_ADDR
) num
);
1297 error ("Unexpected type (%d) encountered for integer constant.", code
);
1303 value_from_double (type
, num
)
1307 register value_ptr val
= allocate_value (type
);
1308 struct type
*base_type
= check_typedef (type
);
1309 register enum type_code code
= TYPE_CODE (base_type
);
1310 register int len
= TYPE_LENGTH (base_type
);
1312 if (code
== TYPE_CODE_FLT
)
1314 store_floating (VALUE_CONTENTS_RAW (val
), len
, num
);
1317 error ("Unexpected type encountered for floating constant.");
1322 /* Deal with the value that is "about to be returned". */
1324 /* Return the value that a function returning now
1325 would be returning to its caller, assuming its type is VALTYPE.
1326 RETBUF is where we look for what ought to be the contents
1327 of the registers (in raw form). This is because it is often
1328 desirable to restore old values to those registers
1329 after saving the contents of interest, and then call
1330 this function using the saved values.
1331 struct_return is non-zero when the function in question is
1332 using the structure return conventions on the machine in question;
1333 0 when it is using the value returning conventions (this often
1334 means returning pointer to where structure is vs. returning value). */
1337 value_being_returned (valtype
, retbuf
, struct_return
)
1338 register struct type
*valtype
;
1339 char retbuf
[REGISTER_BYTES
];
1343 register value_ptr val
;
1346 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1347 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1348 if (struct_return
) {
1349 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1351 error ("Function return value unknown");
1352 return value_at (valtype
, addr
, NULL
);
1356 val
= allocate_value (valtype
);
1357 CHECK_TYPEDEF (valtype
);
1358 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1363 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1364 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1365 and TYPE is the type (which is known to be struct, union or array).
1367 On most machines, the struct convention is used unless we are
1368 using gcc and the type is of a special size. */
1369 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1370 native compiler. GCC 2.3.3 was the last release that did it the
1371 old way. Since gcc2_compiled was not changed, we have no
1372 way to correctly win in all cases, so we just do the right thing
1373 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1374 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1375 would cause more chaos than dealing with some struct returns being
1377 #if !defined (USE_STRUCT_CONVENTION)
1378 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1379 (!((gcc_p == 1) && (TYPE_LENGTH (value_type) == 1 \
1380 || TYPE_LENGTH (value_type) == 2 \
1381 || TYPE_LENGTH (value_type) == 4 \
1382 || TYPE_LENGTH (value_type) == 8 \
1387 /* Some fundamental types (such as long double) are returned on the stack for
1388 certain architectures. This macro should return true for any type besides
1389 struct, union or array that gets returned on the stack. */
1391 #ifndef RETURN_VALUE_ON_STACK
1392 #define RETURN_VALUE_ON_STACK(TYPE) 0
1395 /* Return true if the function specified is using the structure returning
1396 convention on this machine to return arguments, or 0 if it is using
1397 the value returning convention. FUNCTION is the value representing
1398 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1399 is the type returned by the function. GCC_P is nonzero if compiled
1403 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1406 struct type
*value_type
;
1410 register enum type_code code
= TYPE_CODE (value_type
);
1412 if (code
== TYPE_CODE_ERROR
)
1413 error ("Function return type unknown.");
1415 if (code
== TYPE_CODE_STRUCT
1416 || code
== TYPE_CODE_UNION
1417 || code
== TYPE_CODE_ARRAY
1418 || RETURN_VALUE_ON_STACK (value_type
))
1419 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1424 /* Store VAL so it will be returned if a function returns now.
1425 Does not verify that VAL's type matches what the current
1426 function wants to return. */
1429 set_return_value (val
)
1432 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1433 register enum type_code code
= TYPE_CODE (type
);
1435 if (code
== TYPE_CODE_ERROR
)
1436 error ("Function return type unknown.");
1438 if ( code
== TYPE_CODE_STRUCT
1439 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1440 error ("GDB does not support specifying a struct or union return value.");
1442 STORE_RETURN_VALUE (type
, VALUE_CONTENTS (val
));
1446 _initialize_values ()
1448 add_cmd ("convenience", no_class
, show_convenience
,
1449 "Debugger convenience (\"$foo\") variables.\n\
1450 These variables are created when you assign them values;\n\
1451 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1452 A few convenience variables are given values automatically:\n\
1453 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1454 \"$__\" holds the contents of the last address examined with \"x\".",
1457 add_cmd ("values", no_class
, show_values
,
1458 "Elements of value history around item number IDX (or last ten).",