1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 /* Local function prototypes. */
34 value_headof
PARAMS ((value
, struct type
*, struct type
*));
37 show_values
PARAMS ((char *, int));
40 show_convenience
PARAMS ((char *, int));
42 /* The value-history records all the values printed
43 by print commands during this session. Each chunk
44 records 60 consecutive values. The first chunk on
45 the chain records the most recent values.
46 The total number of values is in value_history_count. */
48 #define VALUE_HISTORY_CHUNK 60
50 struct value_history_chunk
52 struct value_history_chunk
*next
;
53 value values
[VALUE_HISTORY_CHUNK
];
56 /* Chain of chunks now in use. */
58 static struct value_history_chunk
*value_history_chain
;
60 static int value_history_count
; /* Abs number of last entry stored */
62 /* List of all value objects currently allocated
63 (except for those released by calls to release_value)
64 This is so they can be freed after each command. */
66 static value all_values
;
68 /* Allocate a value that has the correct length for type TYPE. */
76 check_stub_type (type
);
78 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
));
79 VALUE_NEXT (val
) = all_values
;
81 VALUE_TYPE (val
) = type
;
82 VALUE_LVAL (val
) = not_lval
;
83 VALUE_ADDRESS (val
) = 0;
84 VALUE_FRAME (val
) = 0;
85 VALUE_OFFSET (val
) = 0;
86 VALUE_BITPOS (val
) = 0;
87 VALUE_BITSIZE (val
) = 0;
88 VALUE_REPEATED (val
) = 0;
89 VALUE_REPETITIONS (val
) = 0;
90 VALUE_REGNO (val
) = -1;
92 VALUE_OPTIMIZED_OUT (val
) = 0;
96 /* Allocate a value that has the correct length
97 for COUNT repetitions type TYPE. */
100 allocate_repeat_value (type
, count
)
106 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
) * count
);
107 VALUE_NEXT (val
) = all_values
;
109 VALUE_TYPE (val
) = type
;
110 VALUE_LVAL (val
) = not_lval
;
111 VALUE_ADDRESS (val
) = 0;
112 VALUE_FRAME (val
) = 0;
113 VALUE_OFFSET (val
) = 0;
114 VALUE_BITPOS (val
) = 0;
115 VALUE_BITSIZE (val
) = 0;
116 VALUE_REPEATED (val
) = 1;
117 VALUE_REPETITIONS (val
) = count
;
118 VALUE_REGNO (val
) = -1;
119 VALUE_LAZY (val
) = 0;
120 VALUE_OPTIMIZED_OUT (val
) = 0;
124 /* Return a mark in the value chain. All values allocated after the
125 mark is obtained (except for those released) are subject to being freed
126 if a subsequent value_free_to_mark is passed the mark. */
133 /* Free all values allocated since MARK was obtained by value_mark
134 (except for those released). */
136 value_free_to_mark (mark
)
141 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
143 next
= VALUE_NEXT (val
);
149 /* Free all the values that have been allocated (except for those released).
150 Called after each command, successful or not. */
155 register value val
, next
;
157 for (val
= all_values
; val
; val
= next
)
159 next
= VALUE_NEXT (val
);
166 /* Remove VAL from the chain all_values
167 so it will not be freed automatically. */
175 if (all_values
== val
)
177 all_values
= val
->next
;
181 for (v
= all_values
; v
; v
= v
->next
)
191 /* Return a copy of the value ARG.
192 It contains the same contents, for same memory address,
193 but it's a different block of storage. */
200 register struct type
*type
= VALUE_TYPE (arg
);
201 if (VALUE_REPEATED (arg
))
202 val
= allocate_repeat_value (type
, VALUE_REPETITIONS (arg
));
204 val
= allocate_value (type
);
205 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
206 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
207 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
208 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
209 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
210 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
211 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
212 if (!VALUE_LAZY (val
))
214 bcopy (VALUE_CONTENTS_RAW (arg
), VALUE_CONTENTS_RAW (val
),
215 TYPE_LENGTH (VALUE_TYPE (arg
))
216 * (VALUE_REPEATED (arg
) ? VALUE_REPETITIONS (arg
) : 1));
221 /* Access to the value history. */
223 /* Record a new value in the value history.
224 Returns the absolute history index of the entry.
225 Result of -1 indicates the value was not saved; otherwise it is the
226 value history index of this new item. */
229 record_latest_value (val
)
234 /* Check error now if about to store an invalid float. We return -1
235 to the caller, but allow them to continue, e.g. to print it as "Nan". */
236 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
) {
237 (void) unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &i
);
238 if (i
) return -1; /* Indicate value not saved in history */
241 /* Here we treat value_history_count as origin-zero
242 and applying to the value being stored now. */
244 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
247 register struct value_history_chunk
*new
248 = (struct value_history_chunk
*)
249 xmalloc (sizeof (struct value_history_chunk
));
250 bzero (new->values
, sizeof new->values
);
251 new->next
= value_history_chain
;
252 value_history_chain
= new;
255 value_history_chain
->values
[i
] = val
;
258 /* Now we regard value_history_count as origin-one
259 and applying to the value just stored. */
261 return ++value_history_count
;
264 /* Return a copy of the value in the history with sequence number NUM. */
267 access_value_history (num
)
270 register struct value_history_chunk
*chunk
;
272 register int absnum
= num
;
275 absnum
+= value_history_count
;
280 error ("The history is empty.");
282 error ("There is only one value in the history.");
284 error ("History does not go back to $$%d.", -num
);
286 if (absnum
> value_history_count
)
287 error ("History has not yet reached $%d.", absnum
);
291 /* Now absnum is always absolute and origin zero. */
293 chunk
= value_history_chain
;
294 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
298 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
301 /* Clear the value history entirely.
302 Must be done when new symbol tables are loaded,
303 because the type pointers become invalid. */
306 clear_value_history ()
308 register struct value_history_chunk
*next
;
312 while (value_history_chain
)
314 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
315 if (val
= value_history_chain
->values
[i
])
317 next
= value_history_chain
->next
;
318 free ((PTR
)value_history_chain
);
319 value_history_chain
= next
;
321 value_history_count
= 0;
325 show_values (num_exp
, from_tty
)
335 if (num_exp
[0] == '+' && num_exp
[1] == '\0')
336 /* "info history +" should print from the stored position. */
339 /* "info history <exp>" should print around value number <exp>. */
340 num
= parse_and_eval_address (num_exp
) - 5;
344 /* "info history" means print the last 10 values. */
345 num
= value_history_count
- 9;
351 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
353 val
= access_value_history (i
);
354 printf_filtered ("$%d = ", i
);
355 value_print (val
, stdout
, 0, Val_pretty_default
);
356 printf_filtered ("\n");
359 /* The next "info history +" should start after what we just printed. */
362 /* Hitting just return after this command should do the same thing as
363 "info history +". If num_exp is null, this is unnecessary, since
364 "info history +" is not useful after "info history". */
365 if (from_tty
&& num_exp
)
372 /* Internal variables. These are variables within the debugger
373 that hold values assigned by debugger commands.
374 The user refers to them with a '$' prefix
375 that does not appear in the variable names stored internally. */
377 static struct internalvar
*internalvars
;
379 /* Look up an internal variable with name NAME. NAME should not
380 normally include a dollar sign.
382 If the specified internal variable does not exist,
383 one is created, with a void value. */
386 lookup_internalvar (name
)
389 register struct internalvar
*var
;
391 for (var
= internalvars
; var
; var
= var
->next
)
392 if (!strcmp (var
->name
, name
))
395 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
396 var
->name
= concat (name
, NULL
);
397 var
->value
= allocate_value (builtin_type_void
);
398 release_value (var
->value
);
399 var
->next
= internalvars
;
405 value_of_internalvar (var
)
406 struct internalvar
*var
;
410 #ifdef IS_TRAPPED_INTERNALVAR
411 if (IS_TRAPPED_INTERNALVAR (var
->name
))
412 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
415 val
= value_copy (var
->value
);
416 if (VALUE_LAZY (val
))
417 value_fetch_lazy (val
);
418 VALUE_LVAL (val
) = lval_internalvar
;
419 VALUE_INTERNALVAR (val
) = var
;
424 set_internalvar_component (var
, offset
, bitpos
, bitsize
, newval
)
425 struct internalvar
*var
;
426 int offset
, bitpos
, bitsize
;
429 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
431 #ifdef IS_TRAPPED_INTERNALVAR
432 if (IS_TRAPPED_INTERNALVAR (var
->name
))
433 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
437 modify_field (addr
, (int) value_as_long (newval
),
440 bcopy (VALUE_CONTENTS (newval
), addr
,
441 TYPE_LENGTH (VALUE_TYPE (newval
)));
445 set_internalvar (var
, val
)
446 struct internalvar
*var
;
449 #ifdef IS_TRAPPED_INTERNALVAR
450 if (IS_TRAPPED_INTERNALVAR (var
->name
))
451 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
454 free ((PTR
)var
->value
);
455 var
->value
= value_copy (val
);
456 release_value (var
->value
);
460 internalvar_name (var
)
461 struct internalvar
*var
;
466 /* Free all internalvars. Done when new symtabs are loaded,
467 because that makes the values invalid. */
470 clear_internalvars ()
472 register struct internalvar
*var
;
477 internalvars
= var
->next
;
478 free ((PTR
)var
->name
);
479 free ((PTR
)var
->value
);
485 show_convenience (ignore
, from_tty
)
489 register struct internalvar
*var
;
492 for (var
= internalvars
; var
; var
= var
->next
)
494 #ifdef IS_TRAPPED_INTERNALVAR
495 if (IS_TRAPPED_INTERNALVAR (var
->name
))
502 printf_filtered ("$%s = ", var
->name
);
503 value_print (var
->value
, stdout
, 0, Val_pretty_default
);
504 printf_filtered ("\n");
507 printf ("No debugger convenience variables now defined.\n\
508 Convenience variables have names starting with \"$\";\n\
509 use \"set\" as in \"set $foo = 5\" to define them.\n");
512 /* Extract a value as a C number (either long or double).
513 Knows how to convert fixed values to double, or
514 floating values to long.
515 Does not deallocate the value. */
521 /* This coerces arrays and functions, which is necessary (e.g.
522 in disassemble_command). It also dereferences references, which
523 I suspect is the most logical thing to do. */
524 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_ENUM
)
526 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
530 value_as_double (val
)
536 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
538 error ("Invalid floating value found in program.");
541 /* Extract a value as a C pointer.
542 Does not deallocate the value. */
544 value_as_pointer (val
)
547 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
548 whether we want this to be true eventually. */
549 return value_as_long (val
);
552 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
553 as a long, or as a double, assuming the raw data is described
554 by type TYPE. Knows how to convert different sizes of values
555 and can convert between fixed and floating point. We don't assume
556 any alignment for the raw data. Return value is in host byte order.
558 If you want functions and arrays to be coerced to pointers, and
559 references to be dereferenced, call value_as_long() instead.
561 C++: It is assumed that the front-end has taken care of
562 all matters concerning pointers to members. A pointer
563 to member which reaches here is considered to be equivalent
564 to an INT (or some size). After all, it is only an offset. */
566 /* FIXME: This should be rewritten as a switch statement for speed and
567 ease of comprehension. */
570 unpack_long (type
, valaddr
)
574 register enum type_code code
= TYPE_CODE (type
);
575 register int len
= TYPE_LENGTH (type
);
576 register int nosign
= TYPE_UNSIGNED (type
);
578 if (code
== TYPE_CODE_ENUM
|| code
== TYPE_CODE_BOOL
)
579 code
= TYPE_CODE_INT
;
580 if (code
== TYPE_CODE_FLT
)
582 if (len
== sizeof (float))
585 bcopy (valaddr
, &retval
, sizeof (retval
));
586 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
590 if (len
== sizeof (double))
593 bcopy (valaddr
, &retval
, sizeof (retval
));
594 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
599 error ("Unexpected type of floating point number.");
602 else if (code
== TYPE_CODE_INT
&& nosign
)
604 if (len
== sizeof (char))
606 unsigned char retval
= * (unsigned char *) valaddr
;
607 /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
611 if (len
== sizeof (short))
613 unsigned short retval
;
614 bcopy (valaddr
, &retval
, sizeof (retval
));
615 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
619 if (len
== sizeof (int))
622 bcopy (valaddr
, &retval
, sizeof (retval
));
623 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
627 if (len
== sizeof (long))
629 unsigned long retval
;
630 bcopy (valaddr
, &retval
, sizeof (retval
));
631 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
635 if (len
== sizeof (long long))
637 unsigned long long retval
;
638 bcopy (valaddr
, &retval
, sizeof (retval
));
639 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
645 error ("That operation is not possible on an integer of that size.");
648 else if (code
== TYPE_CODE_INT
)
650 if (len
== sizeof (char))
652 SIGNED
char retval
; /* plain chars might be unsigned on host */
653 bcopy (valaddr
, &retval
, sizeof (retval
));
654 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
658 if (len
== sizeof (short))
661 bcopy (valaddr
, &retval
, sizeof (retval
));
662 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
666 if (len
== sizeof (int))
669 bcopy (valaddr
, &retval
, sizeof (retval
));
670 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
674 if (len
== sizeof (long))
677 bcopy (valaddr
, &retval
, sizeof (retval
));
678 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
683 if (len
== sizeof (long long))
686 bcopy (valaddr
, &retval
, sizeof (retval
));
687 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
693 error ("That operation is not possible on an integer of that size.");
696 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
697 whether we want this to be true eventually. */
698 else if (code
== TYPE_CODE_PTR
699 || code
== TYPE_CODE_REF
)
701 if (len
== sizeof(long))
704 bcopy (valaddr
, &retval
, sizeof(retval
));
705 SWAP_TARGET_AND_HOST (&retval
, sizeof(retval
));
708 else if (len
== sizeof(short))
711 bcopy (valaddr
, &retval
, len
);
712 SWAP_TARGET_AND_HOST (&retval
, len
);
716 else if (code
== TYPE_CODE_MEMBER
)
717 error ("not implemented: member types in unpack_long");
718 else if (code
== TYPE_CODE_CHAR
)
719 return *(unsigned char *)valaddr
;
721 error ("Value not integer or pointer.");
722 return 0; /* For lint -- never reached */
725 /* Return a double value from the specified type and address.
726 INVP points to an int which is set to 0 for valid value,
727 1 for invalid value (bad float format). In either case,
728 the returned double is OK to use. Argument is in target
729 format, result is in host format. */
732 unpack_double (type
, valaddr
, invp
)
737 register enum type_code code
= TYPE_CODE (type
);
738 register int len
= TYPE_LENGTH (type
);
739 register int nosign
= TYPE_UNSIGNED (type
);
741 *invp
= 0; /* Assume valid. */
742 if (code
== TYPE_CODE_FLT
)
744 if (INVALID_FLOAT (valaddr
, len
))
747 return 1.234567891011121314;
750 if (len
== sizeof (float))
753 bcopy (valaddr
, &retval
, sizeof (retval
));
754 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
758 if (len
== sizeof (double))
761 bcopy (valaddr
, &retval
, sizeof (retval
));
762 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
767 error ("Unexpected type of floating point number.");
768 return 0; /* Placate lint. */
772 /* Unsigned -- be sure we compensate for signed LONGEST. */
774 return (unsigned long long) unpack_long (type
, valaddr
);
776 return (unsigned long ) unpack_long (type
, valaddr
);
779 /* Signed -- we are OK with unpack_long. */
780 return unpack_long (type
, valaddr
);
784 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
785 as a CORE_ADDR, assuming the raw data is described by type TYPE.
786 We don't assume any alignment for the raw data. Return value is in
789 If you want functions and arrays to be coerced to pointers, and
790 references to be dereferenced, call value_as_pointer() instead.
792 C++: It is assumed that the front-end has taken care of
793 all matters concerning pointers to members. A pointer
794 to member which reaches here is considered to be equivalent
795 to an INT (or some size). After all, it is only an offset. */
798 unpack_pointer (type
, valaddr
)
803 /* The user should be able to use an int (e.g. 0x7892) in contexts
804 where a pointer is expected. So this doesn't do enough. */
805 register enum type_code code
= TYPE_CODE (type
);
806 register int len
= TYPE_LENGTH (type
);
808 if (code
== TYPE_CODE_PTR
809 || code
== TYPE_CODE_REF
)
811 if (len
== sizeof (CORE_ADDR
))
814 bcopy (valaddr
, &retval
, sizeof (retval
));
815 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
818 error ("Unrecognized pointer size.");
820 else if (code
== TYPE_CODE_MEMBER
)
821 error ("not implemented: member types in unpack_pointer");
823 error ("Value is not a pointer.");
824 return 0; /* For lint -- never reached */
826 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
827 whether we want this to be true eventually. */
828 return unpack_long (type
, valaddr
);
832 /* Given a value ARG1 (offset by OFFSET bytes)
833 of a struct or union type ARG_TYPE,
834 extract and return the value of one of its fields.
835 FIELDNO says which field.
837 For C++, must also be able to return values from static fields */
840 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
843 register int fieldno
;
844 register struct type
*arg_type
;
847 register struct type
*type
;
849 check_stub_type (arg_type
);
850 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
852 /* Handle packed fields */
854 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
855 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
857 v
= value_from_longest (type
,
858 unpack_field_as_long (arg_type
,
859 VALUE_CONTENTS (arg1
),
861 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
862 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
866 v
= allocate_value (type
);
867 if (VALUE_LAZY (arg1
))
870 bcopy (VALUE_CONTENTS_RAW (arg1
) + offset
,
871 VALUE_CONTENTS_RAW (v
),
874 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
875 if (VALUE_LVAL (arg1
) == lval_internalvar
)
876 VALUE_LVAL (v
) = lval_internalvar_component
;
877 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
878 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (arg1
);
882 /* Given a value ARG1 of a struct or union type,
883 extract and return the value of one of its fields.
884 FIELDNO says which field.
886 For C++, must also be able to return values from static fields */
889 value_field (arg1
, fieldno
)
891 register int fieldno
;
893 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
896 /* Return a non-virtual function as a value.
897 F is the list of member functions which contains the desired method.
898 J is an index into F which provides the desired method. */
901 value_fn_field (f
, j
)
906 register struct type
*type
= TYPE_FN_FIELD_TYPE (f
, j
);
909 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
910 0, VAR_NAMESPACE
, 0, NULL
);
911 if (! sym
) error ("Internal error: could not find physical method named %s",
912 TYPE_FN_FIELD_PHYSNAME (f
, j
));
914 v
= allocate_value (type
);
915 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
916 VALUE_TYPE (v
) = type
;
920 /* Return a virtual function as a value.
921 ARG1 is the object which provides the virtual function
922 table pointer. ARG1 is side-effected in calling this function.
923 F is the list of member functions which contains the desired virtual
925 J is an index into F which provides the desired virtual function.
927 TYPE is the type in which F is located. */
929 value_virtual_fn_field (arg1
, f
, j
, type
)
935 /* First, get the virtual function table pointer. That comes
936 with a strange type, so cast it to type `pointer to long' (which
937 should serve just fine as a function type). Then, index into
938 the table, and convert final value to appropriate function type. */
939 value entry
, vfn
, vtbl
;
940 value vi
= value_from_longest (builtin_type_int
,
941 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
942 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
943 struct type
*context
;
944 if (fcontext
== NULL
)
945 /* We don't have an fcontext (e.g. the program was compiled with
946 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
947 This won't work right for multiple inheritance, but at least we
948 should do as well as GDB 3.x did. */
949 fcontext
= TYPE_VPTR_BASETYPE (type
);
950 context
= lookup_pointer_type (fcontext
);
951 /* Now context is a pointer to the basetype containing the vtbl. */
952 if (TYPE_TARGET_TYPE (context
) != VALUE_TYPE (arg1
))
953 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
955 context
= VALUE_TYPE (arg1
);
956 /* Now context is the basetype containing the vtbl. */
958 /* This type may have been defined before its virtual function table
959 was. If so, fill in the virtual function table entry for the
961 if (TYPE_VPTR_FIELDNO (context
) < 0)
962 fill_in_vptr_fieldno (context
);
964 /* The virtual function table is now an array of structures
965 which have the form { int16 offset, delta; void *pfn; }. */
966 vtbl
= value_ind (value_field (arg1
, TYPE_VPTR_FIELDNO (context
)));
968 /* Index into the virtual function table. This is hard-coded because
969 looking up a field is not cheap, and it may be important to save
970 time, e.g. if the user has set a conditional breakpoint calling
971 a virtual function. */
972 entry
= value_subscript (vtbl
, vi
);
974 /* Move the `this' pointer according to the virtual function table. */
975 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
976 if (! VALUE_LAZY (arg1
))
978 VALUE_LAZY (arg1
) = 1;
979 value_fetch_lazy (arg1
);
982 vfn
= value_field (entry
, 2);
983 /* Reinstantiate the function pointer with the correct type. */
984 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
989 /* ARG is a pointer to an object we know to be at least
990 a DTYPE. BTYPE is the most derived basetype that has
991 already been searched (and need not be searched again).
992 After looking at the vtables between BTYPE and DTYPE,
993 return the most derived type we find. The caller must
994 be satisfied when the return value == DTYPE.
996 FIXME-tiemann: should work with dossier entries as well. */
999 value_headof (arg
, btype
, dtype
)
1001 struct type
*btype
, *dtype
;
1003 /* First collect the vtables we must look at for this object. */
1004 /* FIXME-tiemann: right now, just look at top-most vtable. */
1005 value vtbl
, entry
, best_entry
= 0;
1006 /* FIXME: entry_type is never used. */
1007 struct type
*entry_type
;
1009 int offset
, best_offset
= 0;
1011 CORE_ADDR pc_for_sym
;
1012 char *demangled_name
;
1013 struct minimal_symbol
*msymbol
;
1015 btype
= TYPE_VPTR_BASETYPE (dtype
);
1016 check_stub_type (btype
);
1018 vtbl
= value_cast (lookup_pointer_type (btype
), arg
);
1021 vtbl
= value_ind (value_field (value_ind (vtbl
), TYPE_VPTR_FIELDNO (btype
)));
1023 /* Check that VTBL looks like it points to a virtual function table. */
1024 msymbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl
));
1026 || !VTBL_PREFIX_P (demangled_name
= msymbol
-> name
))
1028 /* If we expected to find a vtable, but did not, let the user
1029 know that we aren't happy, but don't throw an error.
1030 FIXME: there has to be a better way to do this. */
1031 struct type
*error_type
= (struct type
*)xmalloc (sizeof (struct type
));
1032 bcopy (VALUE_TYPE (arg
), error_type
, sizeof (struct type
));
1033 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
1034 VALUE_TYPE (arg
) = error_type
;
1038 /* Now search through the virtual function table. */
1039 entry
= value_ind (vtbl
);
1040 nelems
= longest_to_int (value_as_long (value_field (entry
, 2)));
1041 for (i
= 1; i
<= nelems
; i
++)
1043 entry
= value_subscript (vtbl
, value_from_longest (builtin_type_int
,
1045 offset
= longest_to_int (value_as_long (value_field (entry
, 0)));
1046 /* If we use '<=' we can handle single inheritance
1047 * where all offsets are zero - just use the first entry found. */
1048 if (offset
<= best_offset
)
1050 best_offset
= offset
;
1054 /* Move the pointer according to BEST_ENTRY's offset, and figure
1055 out what type we should return as the new pointer. */
1056 if (best_entry
== 0)
1058 /* An alternative method (which should no longer be necessary).
1059 * But we leave it in for future use, when we will hopefully
1060 * have optimizes the vtable to use thunks instead of offsets. */
1061 /* Use the name of vtable itself to extract a base type. */
1062 demangled_name
+= 4; /* Skip _vt$ prefix. */
1066 pc_for_sym
= value_as_pointer (value_field (best_entry
, 2));
1067 sym
= find_pc_function (pc_for_sym
);
1068 demangled_name
= cplus_demangle (SYMBOL_NAME (sym
), -1);
1069 *(strchr (demangled_name
, ':')) = '\0';
1071 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1073 error ("could not find type declaration for `%s'", SYMBOL_NAME (sym
));
1076 free (demangled_name
);
1077 arg
= value_add (value_cast (builtin_type_int
, arg
),
1078 value_field (best_entry
, 0));
1080 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1084 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1085 function tables, probe ARG's tables (including the vtables
1086 of its baseclasses) to figure out the most derived type that ARG
1087 could actually be a pointer to. */
1090 value_from_vtable_info (arg
, type
)
1094 /* Take care of preliminaries. */
1095 if (TYPE_VPTR_FIELDNO (type
) < 0)
1096 fill_in_vptr_fieldno (type
);
1097 if (TYPE_VPTR_FIELDNO (type
) < 0 || VALUE_REPEATED (arg
))
1100 return value_headof (arg
, 0, type
);
1103 /* Compute the address of the baseclass which is
1104 the INDEXth baseclass of class TYPE. The TYPE base
1105 of the object is at VALADDR.
1107 If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1108 or 0 if no error. In that case the return value is not the address
1109 of the baseclasss, but the address which could not be read
1113 baseclass_addr (type
, index
, valaddr
, valuep
, errp
)
1120 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1125 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1127 /* Must hunt for the pointer to this virtual baseclass. */
1128 register int i
, len
= TYPE_NFIELDS (type
);
1129 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1130 char *vbase_name
, *type_name
= type_name_no_tag (basetype
);
1132 vbase_name
= (char *)alloca (strlen (type_name
) + 8);
1133 sprintf (vbase_name
, "_vb$%s", type_name
);
1134 /* First look for the virtual baseclass pointer
1136 for (i
= n_baseclasses
; i
< len
; i
++)
1138 if (! strcmp (vbase_name
, TYPE_FIELD_NAME (type
, i
)))
1140 value val
= allocate_value (basetype
);
1145 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1146 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1148 status
= target_read_memory (addr
,
1149 VALUE_CONTENTS_RAW (val
),
1150 TYPE_LENGTH (basetype
));
1151 VALUE_LVAL (val
) = lval_memory
;
1152 VALUE_ADDRESS (val
) = addr
;
1158 release_value (val
);
1162 return (char *)addr
;
1168 return (char *) VALUE_CONTENTS (val
);
1172 /* Not in the fields, so try looking through the baseclasses. */
1173 for (i
= index
+1; i
< n_baseclasses
; i
++)
1177 baddr
= baseclass_addr (type
, i
, valaddr
, valuep
, errp
);
1187 /* Baseclass is easily computed. */
1190 return valaddr
+ TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1194 unpack_field_as_long (type
, valaddr
, fieldno
)
1200 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1201 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1203 bcopy (valaddr
+ bitpos
/ 8, &val
, sizeof val
);
1204 SWAP_TARGET_AND_HOST (&val
, sizeof val
);
1206 /* Extracting bits depends on endianness of the machine. */
1208 val
= val
>> (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1210 val
= val
>> (bitpos
% 8);
1213 if (bitsize
< 8 * sizeof (val
))
1214 val
&= (((unsigned long)1) << bitsize
) - 1;
1218 /* Modify the value of a bitfield. ADDR points to a block of memory in
1219 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1220 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1221 indicate which bits (in target bit order) comprise the bitfield. */
1224 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1227 int bitpos
, bitsize
;
1231 /* Reject values too big to fit in the field in question,
1232 otherwise adjoining fields may be corrupted. */
1233 if (bitsize
< (8 * sizeof (fieldval
))
1234 && 0 != (fieldval
& ~((1<<bitsize
)-1)))
1235 error ("Value %d does not fit in %d bits.", fieldval
, bitsize
);
1237 bcopy (addr
, &oword
, sizeof oword
);
1238 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To host format */
1240 /* Shifting for bit field depends on endianness of the target machine. */
1242 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1245 /* Mask out old value, while avoiding shifts >= longword size */
1246 if (bitsize
< 8 * sizeof (oword
))
1247 oword
&= ~(((((unsigned long)1) << bitsize
) - 1) << bitpos
);
1249 oword
&= ~((-1) << bitpos
);
1250 oword
|= fieldval
<< bitpos
;
1252 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To target format */
1253 bcopy (&oword
, addr
, sizeof oword
);
1256 /* Convert C numbers into newly allocated values */
1259 value_from_longest (type
, num
)
1261 register LONGEST num
;
1263 register value val
= allocate_value (type
);
1264 register enum type_code code
= TYPE_CODE (type
);
1265 register int len
= TYPE_LENGTH (type
);
1267 /* FIXME, we assume that pointers have the same form and byte order as
1268 integers, and that all pointers have the same form. */
1269 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_ENUM
||
1270 code
== TYPE_CODE_CHAR
|| code
== TYPE_CODE_PTR
||
1271 code
== TYPE_CODE_REF
)
1273 if (len
== sizeof (char))
1274 * (char *) VALUE_CONTENTS_RAW (val
) = num
;
1275 else if (len
== sizeof (short))
1276 * (short *) VALUE_CONTENTS_RAW (val
) = num
;
1277 else if (len
== sizeof (int))
1278 * (int *) VALUE_CONTENTS_RAW (val
) = num
;
1279 else if (len
== sizeof (long))
1280 * (long *) VALUE_CONTENTS_RAW (val
) = num
;
1282 else if (len
== sizeof (long long))
1283 * (long long *) VALUE_CONTENTS_RAW (val
) = num
;
1286 error ("Integer type encountered with unexpected data length.");
1289 error ("Unexpected type encountered for integer constant.");
1291 /* num was in host byte order. So now put the value's contents
1292 into target byte order. */
1293 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1299 value_from_double (type
, num
)
1303 register value val
= allocate_value (type
);
1304 register enum type_code code
= TYPE_CODE (type
);
1305 register int len
= TYPE_LENGTH (type
);
1307 if (code
== TYPE_CODE_FLT
)
1309 if (len
== sizeof (float))
1310 * (float *) VALUE_CONTENTS_RAW (val
) = num
;
1311 else if (len
== sizeof (double))
1312 * (double *) VALUE_CONTENTS_RAW (val
) = num
;
1314 error ("Floating type encountered with unexpected data length.");
1317 error ("Unexpected type encountered for floating constant.");
1319 /* num was in host byte order. So now put the value's contents
1320 into target byte order. */
1321 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1326 /* Deal with the value that is "about to be returned". */
1328 /* Return the value that a function returning now
1329 would be returning to its caller, assuming its type is VALTYPE.
1330 RETBUF is where we look for what ought to be the contents
1331 of the registers (in raw form). This is because it is often
1332 desirable to restore old values to those registers
1333 after saving the contents of interest, and then call
1334 this function using the saved values.
1335 struct_return is non-zero when the function in question is
1336 using the structure return conventions on the machine in question;
1337 0 when it is using the value returning conventions (this often
1338 means returning pointer to where structure is vs. returning value). */
1341 value_being_returned (valtype
, retbuf
, struct_return
)
1342 register struct type
*valtype
;
1343 char retbuf
[REGISTER_BYTES
];
1350 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1351 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1352 if (struct_return
) {
1353 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1355 error ("Function return value unknown");
1356 return value_at (valtype
, addr
);
1360 val
= allocate_value (valtype
);
1361 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1366 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1367 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1368 and TYPE is the type (which is known to be struct, union or array).
1370 On most machines, the struct convention is used unless we are
1371 using gcc and the type is of a special size. */
1372 #if !defined (USE_STRUCT_CONVENTION)
1373 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1374 (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \
1375 || TYPE_LENGTH (value_type) == 2 \
1376 || TYPE_LENGTH (value_type) == 4 \
1377 || TYPE_LENGTH (value_type) == 8 \
1382 /* Return true if the function specified is using the structure returning
1383 convention on this machine to return arguments, or 0 if it is using
1384 the value returning convention. FUNCTION is the value representing
1385 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1386 is the type returned by the function. GCC_P is nonzero if compiled
1390 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1393 struct type
*value_type
;
1397 register enum type_code code
= TYPE_CODE (value_type
);
1399 if (code
== TYPE_CODE_ERROR
)
1400 error ("Function return type unknown.");
1402 if (code
== TYPE_CODE_STRUCT
||
1403 code
== TYPE_CODE_UNION
||
1404 code
== TYPE_CODE_ARRAY
)
1405 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1410 /* Store VAL so it will be returned if a function returns now.
1411 Does not verify that VAL's type matches what the current
1412 function wants to return. */
1415 set_return_value (val
)
1418 register enum type_code code
= TYPE_CODE (VALUE_TYPE (val
));
1422 if (code
== TYPE_CODE_ERROR
)
1423 error ("Function return type unknown.");
1425 if ( code
== TYPE_CODE_STRUCT
1426 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1427 error ("GDB does not support specifying a struct or union return value.");
1429 /* FIXME, this is bogus. We don't know what the return conventions
1430 are, or how values should be promoted.... */
1431 if (code
== TYPE_CODE_FLT
)
1433 dbuf
= value_as_double (val
);
1435 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&dbuf
);
1439 lbuf
= value_as_long (val
);
1440 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&lbuf
);
1445 _initialize_values ()
1447 add_cmd ("convenience", no_class
, show_convenience
,
1448 "Debugger convenience (\"$foo\") variables.\n\
1449 These variables are created when you assign them values;\n\
1450 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1451 A few convenience variables are given values automatically:\n\
1452 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1453 \"$__\" holds the contents of the last address examined with \"x\".",
1456 add_cmd ("values", no_class
, show_values
,
1457 "Elements of value history around item number IDX (or last ten).",