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 return extract_address (valaddr
, len
);
639 case TYPE_CODE_MEMBER
:
640 error ("not implemented: member types in unpack_long");
643 error ("Value can't be converted to integer.");
645 return 0; /* Placate lint. */
648 /* Return a double value from the specified type and address.
649 INVP points to an int which is set to 0 for valid value,
650 1 for invalid value (bad float format). In either case,
651 the returned double is OK to use. Argument is in target
652 format, result is in host format. */
655 unpack_double (type
, valaddr
, invp
)
660 register enum type_code code
= TYPE_CODE (type
);
661 register int len
= TYPE_LENGTH (type
);
662 register int nosign
= TYPE_UNSIGNED (type
);
664 *invp
= 0; /* Assume valid. */
665 CHECK_TYPEDEF (type
);
666 if (code
== TYPE_CODE_FLT
)
669 if (INVALID_FLOAT (valaddr
, len
))
672 return 1.234567891011121314;
675 return extract_floating (valaddr
, len
);
679 /* Unsigned -- be sure we compensate for signed LONGEST. */
680 #if !defined (_MSC_VER) || (_MSC_VER > 900)
681 return (ULONGEST
) unpack_long (type
, valaddr
);
683 /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */
684 return (LONGEST
) unpack_long (type
, valaddr
);
685 #endif /* _MSC_VER */
689 /* Signed -- we are OK with unpack_long. */
690 return unpack_long (type
, valaddr
);
694 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
695 as a CORE_ADDR, assuming the raw data is described by type TYPE.
696 We don't assume any alignment for the raw data. Return value is in
699 If you want functions and arrays to be coerced to pointers, and
700 references to be dereferenced, call value_as_pointer() instead.
702 C++: It is assumed that the front-end has taken care of
703 all matters concerning pointers to members. A pointer
704 to member which reaches here is considered to be equivalent
705 to an INT (or some size). After all, it is only an offset. */
708 unpack_pointer (type
, valaddr
)
712 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
713 whether we want this to be true eventually. */
714 return unpack_long (type
, valaddr
);
717 /* Get the value of the FIELDN'th field (which must be static) of TYPE. */
720 value_static_field (type
, fieldno
)
726 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
728 addr
= TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
);
733 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
734 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
737 addr
= SYMBOL_VALUE_ADDRESS (sym
);
738 sect
= SYMBOL_BFD_SECTION (sym
);
739 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
), addr
);
741 return value_at (TYPE_FIELD_TYPE (type
, fieldno
), addr
, sect
);
744 /* Given a value ARG1 (offset by OFFSET bytes)
745 of a struct or union type ARG_TYPE,
746 extract and return the value of one of its (non-static) fields.
747 FIELDNO says which field. */
750 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
751 register value_ptr arg1
;
753 register int fieldno
;
754 register struct type
*arg_type
;
756 register value_ptr v
;
757 register struct type
*type
;
759 CHECK_TYPEDEF (arg_type
);
760 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
762 /* Handle packed fields */
764 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
766 v
= value_from_longest (type
,
767 unpack_field_as_long (arg_type
,
768 VALUE_CONTENTS (arg1
)
771 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
772 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
776 v
= allocate_value (type
);
777 if (VALUE_LAZY (arg1
))
780 memcpy (VALUE_CONTENTS_RAW (v
),
781 VALUE_CONTENTS_RAW (arg1
) + offset
782 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8,
785 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
786 if (VALUE_LVAL (arg1
) == lval_internalvar
)
787 VALUE_LVAL (v
) = lval_internalvar_component
;
788 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
789 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
790 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
794 /* Given a value ARG1 of a struct or union type,
795 extract and return the value of one of its (non-static) fields.
796 FIELDNO says which field. */
799 value_field (arg1
, fieldno
)
800 register value_ptr arg1
;
801 register int fieldno
;
803 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
806 /* Return a non-virtual function as a value.
807 F is the list of member functions which contains the desired method.
808 J is an index into F which provides the desired method. */
811 value_fn_field (arg1p
, f
, j
, type
, offset
)
818 register value_ptr v
;
819 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
822 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
823 0, VAR_NAMESPACE
, 0, NULL
);
827 error ("Internal error: could not find physical method named %s",
828 TYPE_FN_FIELD_PHYSNAME (f, j));
831 v
= allocate_value (ftype
);
832 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
833 VALUE_TYPE (v
) = ftype
;
837 if (type
!= VALUE_TYPE (*arg1p
))
838 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
839 value_addr (*arg1p
)));
841 /* Move the `this' pointer according to the offset.
842 VALUE_OFFSET (*arg1p) += offset;
849 /* Return a virtual function as a value.
850 ARG1 is the object which provides the virtual function
851 table pointer. *ARG1P is side-effected in calling this function.
852 F is the list of member functions which contains the desired virtual
854 J is an index into F which provides the desired virtual function.
856 TYPE is the type in which F is located. */
858 value_virtual_fn_field (arg1p
, f
, j
, type
, offset
)
865 value_ptr arg1
= *arg1p
;
866 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
867 struct type
*entry_type
;
868 /* First, get the virtual function table pointer. That comes
869 with a strange type, so cast it to type `pointer to long' (which
870 should serve just fine as a function type). Then, index into
871 the table, and convert final value to appropriate function type. */
872 value_ptr entry
, vfn
, vtbl
;
873 value_ptr vi
= value_from_longest (builtin_type_int
,
874 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
875 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
876 struct type
*context
;
877 if (fcontext
== NULL
)
878 /* We don't have an fcontext (e.g. the program was compiled with
879 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
880 This won't work right for multiple inheritance, but at least we
881 should do as well as GDB 3.x did. */
882 fcontext
= TYPE_VPTR_BASETYPE (type
);
883 context
= lookup_pointer_type (fcontext
);
884 /* Now context is a pointer to the basetype containing the vtbl. */
885 if (TYPE_TARGET_TYPE (context
) != type1
)
887 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
888 type1
= check_typedef (VALUE_TYPE (arg1
));
892 /* Now context is the basetype containing the vtbl. */
894 /* This type may have been defined before its virtual function table
895 was. If so, fill in the virtual function table entry for the
897 if (TYPE_VPTR_FIELDNO (context
) < 0)
898 fill_in_vptr_fieldno (context
);
900 /* The virtual function table is now an array of structures
901 which have the form { int16 offset, delta; void *pfn; }. */
902 vtbl
= value_ind (value_primitive_field (arg1
, 0,
903 TYPE_VPTR_FIELDNO (context
),
904 TYPE_VPTR_BASETYPE (context
)));
906 /* Index into the virtual function table. This is hard-coded because
907 looking up a field is not cheap, and it may be important to save
908 time, e.g. if the user has set a conditional breakpoint calling
909 a virtual function. */
910 entry
= value_subscript (vtbl
, vi
);
911 entry_type
= check_typedef (VALUE_TYPE (entry
));
913 if (TYPE_CODE (entry_type
) == TYPE_CODE_STRUCT
)
915 /* Move the `this' pointer according to the virtual function table. */
916 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
918 if (! VALUE_LAZY (arg1
))
920 VALUE_LAZY (arg1
) = 1;
921 value_fetch_lazy (arg1
);
924 vfn
= value_field (entry
, 2);
926 else if (TYPE_CODE (entry_type
) == TYPE_CODE_PTR
)
929 error ("I'm confused: virtual function table has bad type");
930 /* Reinstantiate the function pointer with the correct type. */
931 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
937 /* ARG is a pointer to an object we know to be at least
938 a DTYPE. BTYPE is the most derived basetype that has
939 already been searched (and need not be searched again).
940 After looking at the vtables between BTYPE and DTYPE,
941 return the most derived type we find. The caller must
942 be satisfied when the return value == DTYPE.
944 FIXME-tiemann: should work with dossier entries as well. */
947 value_headof (in_arg
, btype
, dtype
)
949 struct type
*btype
, *dtype
;
951 /* First collect the vtables we must look at for this object. */
952 /* FIXME-tiemann: right now, just look at top-most vtable. */
953 value_ptr arg
, vtbl
, entry
, best_entry
= 0;
955 int offset
, best_offset
= 0;
957 CORE_ADDR pc_for_sym
;
958 char *demangled_name
;
959 struct minimal_symbol
*msymbol
;
961 btype
= TYPE_VPTR_BASETYPE (dtype
);
962 CHECK_TYPEDEF (btype
);
965 arg
= value_cast (lookup_pointer_type (btype
), arg
);
966 vtbl
= value_ind (value_field (value_ind (arg
), TYPE_VPTR_FIELDNO (btype
)));
968 /* Check that VTBL looks like it points to a virtual function table. */
969 msymbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl
));
971 || (demangled_name
= SYMBOL_NAME (msymbol
)) == NULL
972 || !VTBL_PREFIX_P (demangled_name
))
974 /* If we expected to find a vtable, but did not, let the user
975 know that we aren't happy, but don't throw an error.
976 FIXME: there has to be a better way to do this. */
977 struct type
*error_type
= (struct type
*)xmalloc (sizeof (struct type
));
978 memcpy (error_type
, VALUE_TYPE (in_arg
), sizeof (struct type
));
979 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
980 VALUE_TYPE (in_arg
) = error_type
;
984 /* Now search through the virtual function table. */
985 entry
= value_ind (vtbl
);
986 nelems
= longest_to_int (value_as_long (value_field (entry
, 2)));
987 for (i
= 1; i
<= nelems
; i
++)
989 entry
= value_subscript (vtbl
, value_from_longest (builtin_type_int
,
991 /* This won't work if we're using thunks. */
992 if (TYPE_CODE (check_typedef (VALUE_TYPE (entry
))) != TYPE_CODE_STRUCT
)
994 offset
= longest_to_int (value_as_long (value_field (entry
, 0)));
995 /* If we use '<=' we can handle single inheritance
996 * where all offsets are zero - just use the first entry found. */
997 if (offset
<= best_offset
)
999 best_offset
= offset
;
1003 /* Move the pointer according to BEST_ENTRY's offset, and figure
1004 out what type we should return as the new pointer. */
1005 if (best_entry
== 0)
1007 /* An alternative method (which should no longer be necessary).
1008 * But we leave it in for future use, when we will hopefully
1009 * have optimizes the vtable to use thunks instead of offsets. */
1010 /* Use the name of vtable itself to extract a base type. */
1011 demangled_name
+= 4; /* Skip _vt$ prefix. */
1015 pc_for_sym
= value_as_pointer (value_field (best_entry
, 2));
1016 sym
= find_pc_function (pc_for_sym
);
1017 demangled_name
= cplus_demangle (SYMBOL_NAME (sym
), DMGL_ANSI
);
1018 *(strchr (demangled_name
, ':')) = '\0';
1020 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1022 error ("could not find type declaration for `%s'", demangled_name
);
1025 free (demangled_name
);
1026 arg
= value_add (value_cast (builtin_type_int
, arg
),
1027 value_field (best_entry
, 0));
1030 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1034 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1035 function tables, probe ARG's tables (including the vtables
1036 of its baseclasses) to figure out the most derived type that ARG
1037 could actually be a pointer to. */
1040 value_from_vtable_info (arg
, type
)
1044 /* Take care of preliminaries. */
1045 if (TYPE_VPTR_FIELDNO (type
) < 0)
1046 fill_in_vptr_fieldno (type
);
1047 if (TYPE_VPTR_FIELDNO (type
) < 0)
1050 return value_headof (arg
, 0, type
);
1053 /* Return true if the INDEXth field of TYPE is a virtual baseclass
1054 pointer which is for the base class whose type is BASECLASS. */
1057 vb_match (type
, index
, basetype
)
1060 struct type
*basetype
;
1062 struct type
*fieldtype
;
1063 char *name
= TYPE_FIELD_NAME (type
, index
);
1064 char *field_class_name
= NULL
;
1068 /* gcc 2.4 uses _vb$. */
1069 if (name
[1] == 'v' && name
[2] == 'b' && is_cplus_marker (name
[3]))
1070 field_class_name
= name
+ 4;
1071 /* gcc 2.5 will use __vb_. */
1072 if (name
[1] == '_' && name
[2] == 'v' && name
[3] == 'b' && name
[4] == '_')
1073 field_class_name
= name
+ 5;
1075 if (field_class_name
== NULL
)
1076 /* This field is not a virtual base class pointer. */
1079 /* It's a virtual baseclass pointer, now we just need to find out whether
1080 it is for this baseclass. */
1081 fieldtype
= TYPE_FIELD_TYPE (type
, index
);
1082 if (fieldtype
== NULL
1083 || TYPE_CODE (fieldtype
) != TYPE_CODE_PTR
)
1084 /* "Can't happen". */
1087 /* What we check for is that either the types are equal (needed for
1088 nameless types) or have the same name. This is ugly, and a more
1089 elegant solution should be devised (which would probably just push
1090 the ugliness into symbol reading unless we change the stabs format). */
1091 if (TYPE_TARGET_TYPE (fieldtype
) == basetype
)
1094 if (TYPE_NAME (basetype
) != NULL
1095 && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
)) != NULL
1096 && STREQ (TYPE_NAME (basetype
),
1097 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
))))
1102 /* Compute the offset of the baseclass which is
1103 the INDEXth baseclass of class TYPE,
1104 for value at VALADDR (in host) at ADDRESS (in target).
1105 The result is the offset of the baseclass value relative
1106 to (the address of)(ARG) + OFFSET.
1108 -1 is returned on error. */
1111 baseclass_offset (type
, index
, valaddr
, address
)
1117 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1119 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1121 /* Must hunt for the pointer to this virtual baseclass. */
1122 register int i
, len
= TYPE_NFIELDS (type
);
1123 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1125 /* First look for the virtual baseclass pointer
1127 for (i
= n_baseclasses
; i
< len
; i
++)
1129 if (vb_match (type
, i
, basetype
))
1132 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1133 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1135 return addr
- (LONGEST
) address
;
1138 /* Not in the fields, so try looking through the baseclasses. */
1139 for (i
= index
+1; i
< n_baseclasses
; i
++)
1142 baseclass_offset (type
, i
, valaddr
, address
);
1150 /* Baseclass is easily computed. */
1151 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1154 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1157 Extracting bits depends on endianness of the machine. Compute the
1158 number of least significant bits to discard. For big endian machines,
1159 we compute the total number of bits in the anonymous object, subtract
1160 off the bit count from the MSB of the object to the MSB of the
1161 bitfield, then the size of the bitfield, which leaves the LSB discard
1162 count. For little endian machines, the discard count is simply the
1163 number of bits from the LSB of the anonymous object to the LSB of the
1166 If the field is signed, we also do sign extension. */
1169 unpack_field_as_long (type
, valaddr
, fieldno
)
1176 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1177 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1180 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1182 /* Extract bits. See comment above. */
1184 if (BITS_BIG_ENDIAN
)
1185 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1187 lsbcount
= (bitpos
% 8);
1190 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1191 If the field is signed, and is negative, then sign extend. */
1193 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1195 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1197 if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type
, fieldno
)))
1199 if (val
& (valmask
^ (valmask
>> 1)))
1208 /* Modify the value of a bitfield. ADDR points to a block of memory in
1209 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1210 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1211 indicate which bits (in target bit order) comprise the bitfield. */
1214 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1217 int bitpos
, bitsize
;
1221 /* If a negative fieldval fits in the field in question, chop
1222 off the sign extension bits. */
1223 if (bitsize
< (8 * (int) sizeof (fieldval
))
1224 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1225 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1227 /* Warn if value is too big to fit in the field in question. */
1228 if (bitsize
< (8 * (int) sizeof (fieldval
))
1229 && 0 != (fieldval
& ~((1<<bitsize
)-1)))
1231 /* FIXME: would like to include fieldval in the message, but
1232 we don't have a sprintf_longest. */
1233 warning ("Value does not fit in %d bits.", bitsize
);
1235 /* Truncate it, otherwise adjoining fields may be corrupted. */
1236 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1239 oword
= extract_signed_integer (addr
, sizeof oword
);
1241 /* Shifting for bit field depends on endianness of the target machine. */
1242 if (BITS_BIG_ENDIAN
)
1243 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1245 /* Mask out old value, while avoiding shifts >= size of oword */
1246 if (bitsize
< 8 * (int) sizeof (oword
))
1247 oword
&= ~(((((ULONGEST
)1) << bitsize
) - 1) << bitpos
);
1249 oword
&= ~((~(ULONGEST
)0) << bitpos
);
1250 oword
|= fieldval
<< bitpos
;
1252 store_signed_integer (addr
, sizeof oword
, oword
);
1255 /* Convert C numbers into newly allocated values */
1258 value_from_longest (type
, num
)
1260 register LONGEST num
;
1262 register value_ptr val
= allocate_value (type
);
1263 register enum type_code code
;
1266 code
= TYPE_CODE (type
);
1267 len
= TYPE_LENGTH (type
);
1271 case TYPE_CODE_TYPEDEF
:
1272 type
= check_typedef (type
);
1275 case TYPE_CODE_CHAR
:
1276 case TYPE_CODE_ENUM
:
1277 case TYPE_CODE_BOOL
:
1278 case TYPE_CODE_RANGE
:
1279 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1284 /* This assumes that all pointers of a given length
1285 have the same form. */
1286 store_address (VALUE_CONTENTS_RAW (val
), len
, (CORE_ADDR
) num
);
1290 error ("Unexpected type encountered for integer constant.");
1296 value_from_double (type
, num
)
1300 register value_ptr val
= allocate_value (type
);
1301 struct type
*base_type
= check_typedef (type
);
1302 register enum type_code code
= TYPE_CODE (base_type
);
1303 register int len
= TYPE_LENGTH (base_type
);
1305 if (code
== TYPE_CODE_FLT
)
1307 store_floating (VALUE_CONTENTS_RAW (val
), len
, num
);
1310 error ("Unexpected type encountered for floating constant.");
1315 /* Deal with the value that is "about to be returned". */
1317 /* Return the value that a function returning now
1318 would be returning to its caller, assuming its type is VALTYPE.
1319 RETBUF is where we look for what ought to be the contents
1320 of the registers (in raw form). This is because it is often
1321 desirable to restore old values to those registers
1322 after saving the contents of interest, and then call
1323 this function using the saved values.
1324 struct_return is non-zero when the function in question is
1325 using the structure return conventions on the machine in question;
1326 0 when it is using the value returning conventions (this often
1327 means returning pointer to where structure is vs. returning value). */
1330 value_being_returned (valtype
, retbuf
, struct_return
)
1331 register struct type
*valtype
;
1332 char retbuf
[REGISTER_BYTES
];
1336 register value_ptr val
;
1339 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1340 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1341 if (struct_return
) {
1342 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1344 error ("Function return value unknown");
1345 return value_at (valtype
, addr
, NULL
);
1349 val
= allocate_value (valtype
);
1350 CHECK_TYPEDEF (valtype
);
1351 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1356 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1357 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1358 and TYPE is the type (which is known to be struct, union or array).
1360 On most machines, the struct convention is used unless we are
1361 using gcc and the type is of a special size. */
1362 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1363 native compiler. GCC 2.3.3 was the last release that did it the
1364 old way. Since gcc2_compiled was not changed, we have no
1365 way to correctly win in all cases, so we just do the right thing
1366 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1367 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1368 would cause more chaos than dealing with some struct returns being
1370 #if !defined (USE_STRUCT_CONVENTION)
1371 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1372 (!((gcc_p == 1) && (TYPE_LENGTH (value_type) == 1 \
1373 || TYPE_LENGTH (value_type) == 2 \
1374 || TYPE_LENGTH (value_type) == 4 \
1375 || TYPE_LENGTH (value_type) == 8 \
1380 /* Some fundamental types (such as long double) are returned on the stack for
1381 certain architectures. This macro should return true for any type besides
1382 struct, union or array that gets returned on the stack. */
1384 #ifndef RETURN_VALUE_ON_STACK
1385 #define RETURN_VALUE_ON_STACK(TYPE) 0
1388 /* Return true if the function specified is using the structure returning
1389 convention on this machine to return arguments, or 0 if it is using
1390 the value returning convention. FUNCTION is the value representing
1391 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1392 is the type returned by the function. GCC_P is nonzero if compiled
1396 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1399 struct type
*value_type
;
1403 register enum type_code code
= TYPE_CODE (value_type
);
1405 if (code
== TYPE_CODE_ERROR
)
1406 error ("Function return type unknown.");
1408 if (code
== TYPE_CODE_STRUCT
1409 || code
== TYPE_CODE_UNION
1410 || code
== TYPE_CODE_ARRAY
1411 || RETURN_VALUE_ON_STACK (value_type
))
1412 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1417 /* Store VAL so it will be returned if a function returns now.
1418 Does not verify that VAL's type matches what the current
1419 function wants to return. */
1422 set_return_value (val
)
1425 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1426 register enum type_code code
= TYPE_CODE (type
);
1428 if (code
== TYPE_CODE_ERROR
)
1429 error ("Function return type unknown.");
1431 if ( code
== TYPE_CODE_STRUCT
1432 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1433 error ("GDB does not support specifying a struct or union return value.");
1435 STORE_RETURN_VALUE (type
, VALUE_CONTENTS (val
));
1439 _initialize_values ()
1441 add_cmd ("convenience", no_class
, show_convenience
,
1442 "Debugger convenience (\"$foo\") variables.\n\
1443 These variables are created when you assign them values;\n\
1444 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1445 A few convenience variables are given values automatically:\n\
1446 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1447 \"$__\" holds the contents of the last address examined with \"x\".",
1450 add_cmd ("values", no_class
, show_values
,
1451 "Elements of value history around item number IDX (or last ten).",