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 ((void));
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 (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);
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
;
487 register struct internalvar
*var
;
490 for (var
= internalvars
; var
; var
= var
->next
)
492 #ifdef IS_TRAPPED_INTERNALVAR
493 if (IS_TRAPPED_INTERNALVAR (var
->name
))
500 printf ("Debugger convenience variables:\n\n");
504 printf_filtered ("$%s = ", var
->name
);
505 value_print (var
->value
, stdout
, 0, Val_pretty_default
);
506 printf_filtered ("\n");
509 printf ("No debugger convenience variables now defined.\n\
510 Convenience variables have names starting with \"$\";\n\
511 use \"set\" as in \"set $foo = 5\" to define them.\n");
514 /* Extract a value as a C number (either long or double).
515 Knows how to convert fixed values to double, or
516 floating values to long.
517 Does not deallocate the value. */
523 /* This coerces arrays and functions, which is necessary (e.g.
524 in disassemble_command). It also dereferences references, which
525 I suspect is the most logical thing to do. */
526 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_ENUM
)
528 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
532 value_as_double (val
)
538 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
540 error ("Invalid floating value found in program.");
543 /* Extract a value as a C pointer.
544 Does not deallocate the value. */
546 value_as_pointer (val
)
549 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
550 whether we want this to be true eventually. */
551 return value_as_long (val
);
554 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
555 as a long, or as a double, assuming the raw data is described
556 by type TYPE. Knows how to convert different sizes of values
557 and can convert between fixed and floating point. We don't assume
558 any alignment for the raw data. Return value is in host byte order.
560 If you want functions and arrays to be coerced to pointers, and
561 references to be dereferenced, call value_as_long() instead.
563 C++: It is assumed that the front-end has taken care of
564 all matters concerning pointers to members. A pointer
565 to member which reaches here is considered to be equivalent
566 to an INT (or some size). After all, it is only an offset. */
568 /* FIXME: This should be rewritten as a switch statement for speed and
569 ease of comprehension. */
572 unpack_long (type
, valaddr
)
576 register enum type_code code
= TYPE_CODE (type
);
577 register int len
= TYPE_LENGTH (type
);
578 register int nosign
= TYPE_UNSIGNED (type
);
580 if (code
== TYPE_CODE_ENUM
|| code
== TYPE_CODE_BOOL
)
581 code
= TYPE_CODE_INT
;
582 if (code
== TYPE_CODE_FLT
)
584 if (len
== sizeof (float))
587 bcopy (valaddr
, &retval
, sizeof (retval
));
588 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
592 if (len
== sizeof (double))
595 bcopy (valaddr
, &retval
, sizeof (retval
));
596 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
601 error ("Unexpected type of floating point number.");
604 else if (code
== TYPE_CODE_INT
&& nosign
)
606 if (len
== sizeof (char))
608 unsigned char retval
= * (unsigned char *) valaddr
;
609 /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
613 if (len
== sizeof (short))
615 unsigned short retval
;
616 bcopy (valaddr
, &retval
, sizeof (retval
));
617 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
621 if (len
== sizeof (int))
624 bcopy (valaddr
, &retval
, sizeof (retval
));
625 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
629 if (len
== sizeof (long))
631 unsigned long retval
;
632 bcopy (valaddr
, &retval
, sizeof (retval
));
633 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
637 if (len
== sizeof (long long))
639 unsigned long long retval
;
640 bcopy (valaddr
, &retval
, sizeof (retval
));
641 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
647 error ("That operation is not possible on an integer of that size.");
650 else if (code
== TYPE_CODE_INT
)
652 if (len
== sizeof (char))
655 bcopy (valaddr
, &retval
, sizeof (retval
));
656 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
660 if (len
== sizeof (short))
663 bcopy (valaddr
, &retval
, sizeof (retval
));
664 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
668 if (len
== sizeof (int))
671 bcopy (valaddr
, &retval
, sizeof (retval
));
672 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
676 if (len
== sizeof (long))
679 bcopy (valaddr
, &retval
, sizeof (retval
));
680 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
685 if (len
== sizeof (long long))
688 bcopy (valaddr
, &retval
, sizeof (retval
));
689 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
695 error ("That operation is not possible on an integer of that size.");
698 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
699 whether we want this to be true eventually. */
700 else if (code
== TYPE_CODE_PTR
701 || code
== TYPE_CODE_REF
)
703 if (len
== sizeof(long))
706 bcopy (valaddr
, &retval
, sizeof(retval
));
707 SWAP_TARGET_AND_HOST (&retval
, sizeof(retval
));
710 else if (len
== sizeof(short))
713 bcopy (valaddr
, &retval
, len
);
714 SWAP_TARGET_AND_HOST (&retval
, len
);
718 else if (code
== TYPE_CODE_MEMBER
)
719 error ("not implemented: member types in unpack_long");
720 else if (code
== TYPE_CODE_CHAR
)
721 return *(unsigned char *)valaddr
;
723 error ("Value not integer or pointer.");
724 return 0; /* For lint -- never reached */
727 /* Return a double value from the specified type and address.
728 INVP points to an int which is set to 0 for valid value,
729 1 for invalid value (bad float format). In either case,
730 the returned double is OK to use. Argument is in target
731 format, result is in host format. */
734 unpack_double (type
, valaddr
, invp
)
739 register enum type_code code
= TYPE_CODE (type
);
740 register int len
= TYPE_LENGTH (type
);
741 register int nosign
= TYPE_UNSIGNED (type
);
743 *invp
= 0; /* Assume valid. */
744 if (code
== TYPE_CODE_FLT
)
746 if (INVALID_FLOAT (valaddr
, len
))
749 return 1.234567891011121314;
752 if (len
== sizeof (float))
755 bcopy (valaddr
, &retval
, sizeof (retval
));
756 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
760 if (len
== sizeof (double))
763 bcopy (valaddr
, &retval
, sizeof (retval
));
764 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
769 error ("Unexpected type of floating point number.");
770 return 0; /* Placate lint. */
774 /* Unsigned -- be sure we compensate for signed LONGEST. */
776 return (unsigned long long) unpack_long (type
, valaddr
);
778 return (unsigned long ) unpack_long (type
, valaddr
);
781 /* Signed -- we are OK with unpack_long. */
782 return unpack_long (type
, valaddr
);
786 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
787 as a CORE_ADDR, assuming the raw data is described by type TYPE.
788 We don't assume any alignment for the raw data. Return value is in
791 If you want functions and arrays to be coerced to pointers, and
792 references to be dereferenced, call value_as_pointer() instead.
794 C++: It is assumed that the front-end has taken care of
795 all matters concerning pointers to members. A pointer
796 to member which reaches here is considered to be equivalent
797 to an INT (or some size). After all, it is only an offset. */
800 unpack_pointer (type
, valaddr
)
805 /* The user should be able to use an int (e.g. 0x7892) in contexts
806 where a pointer is expected. So this doesn't do enough. */
807 register enum type_code code
= TYPE_CODE (type
);
808 register int len
= TYPE_LENGTH (type
);
810 if (code
== TYPE_CODE_PTR
811 || code
== TYPE_CODE_REF
)
813 if (len
== sizeof (CORE_ADDR
))
816 bcopy (valaddr
, &retval
, sizeof (retval
));
817 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
820 error ("Unrecognized pointer size.");
822 else if (code
== TYPE_CODE_MEMBER
)
823 error ("not implemented: member types in unpack_pointer");
825 error ("Value is not a pointer.");
826 return 0; /* For lint -- never reached */
828 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
829 whether we want this to be true eventually. */
830 return unpack_long (type
, valaddr
);
834 /* Given a value ARG1 (offset by OFFSET bytes)
835 of a struct or union type ARG_TYPE,
836 extract and return the value of one of its fields.
837 FIELDNO says which field.
839 For C++, must also be able to return values from static fields */
842 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
845 register int fieldno
;
846 register struct type
*arg_type
;
849 register struct type
*type
;
851 check_stub_type (arg_type
);
852 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
854 /* Handle packed fields */
856 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
857 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
859 v
= value_from_longest (type
,
860 unpack_field_as_long (arg_type
,
861 VALUE_CONTENTS (arg1
),
863 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
864 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
868 v
= allocate_value (type
);
869 if (VALUE_LAZY (arg1
))
872 bcopy (VALUE_CONTENTS_RAW (arg1
) + offset
,
873 VALUE_CONTENTS_RAW (v
),
876 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
877 if (VALUE_LVAL (arg1
) == lval_internalvar
)
878 VALUE_LVAL (v
) = lval_internalvar_component
;
879 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
880 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (arg1
);
884 /* Given a value ARG1 of a struct or union type,
885 extract and return the value of one of its fields.
886 FIELDNO says which field.
888 For C++, must also be able to return values from static fields */
891 value_field (arg1
, fieldno
)
893 register int fieldno
;
895 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
898 /* Return a non-virtual function as a value.
899 F is the list of member functions which contains the desired method.
900 J is an index into F which provides the desired method. */
903 value_fn_field (f
, j
)
908 register struct type
*type
= TYPE_FN_FIELD_TYPE (f
, j
);
911 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
912 0, VAR_NAMESPACE
, 0, NULL
);
913 if (! sym
) error ("Internal error: could not find physical method named %s",
914 TYPE_FN_FIELD_PHYSNAME (f
, j
));
916 v
= allocate_value (type
);
917 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
918 VALUE_TYPE (v
) = type
;
922 /* Return a virtual function as a value.
923 ARG1 is the object which provides the virtual function
924 table pointer. ARG1 is side-effected in calling this function.
925 F is the list of member functions which contains the desired virtual
927 J is an index into F which provides the desired virtual function.
929 TYPE is the type in which F is located. */
931 value_virtual_fn_field (arg1
, f
, j
, type
)
937 /* First, get the virtual function table pointer. That comes
938 with a strange type, so cast it to type `pointer to long' (which
939 should serve just fine as a function type). Then, index into
940 the table, and convert final value to appropriate function type. */
941 value entry
, vfn
, vtbl
;
942 value vi
= value_from_longest (builtin_type_int
,
943 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
944 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
945 struct type
*context
;
946 if (fcontext
== NULL
)
947 /* We don't have an fcontext (e.g. the program was compiled with
948 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
949 This won't work right for multiple inheritance, but at least we
950 should do as well as GDB 3.x did. */
951 fcontext
= TYPE_VPTR_BASETYPE (type
);
952 context
= lookup_pointer_type (fcontext
);
953 /* Now context is a pointer to the basetype containing the vtbl. */
954 if (TYPE_TARGET_TYPE (context
) != VALUE_TYPE (arg1
))
955 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
957 context
= VALUE_TYPE (arg1
);
958 /* Now context is the basetype containing the vtbl. */
960 /* This type may have been defined before its virtual function table
961 was. If so, fill in the virtual function table entry for the
963 if (TYPE_VPTR_FIELDNO (context
) < 0)
964 fill_in_vptr_fieldno (context
);
966 /* The virtual function table is now an array of structures
967 which have the form { int16 offset, delta; void *pfn; }. */
968 vtbl
= value_ind (value_field (arg1
, TYPE_VPTR_FIELDNO (context
)));
970 /* Index into the virtual function table. This is hard-coded because
971 looking up a field is not cheap, and it may be important to save
972 time, e.g. if the user has set a conditional breakpoint calling
973 a virtual function. */
974 entry
= value_subscript (vtbl
, vi
);
976 /* Move the `this' pointer according to the virtual function table. */
977 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
978 if (! VALUE_LAZY (arg1
))
980 VALUE_LAZY (arg1
) = 1;
981 value_fetch_lazy (arg1
);
984 vfn
= value_field (entry
, 2);
985 /* Reinstantiate the function pointer with the correct type. */
986 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
991 /* ARG is a pointer to an object we know to be at least
992 a DTYPE. BTYPE is the most derived basetype that has
993 already been searched (and need not be searched again).
994 After looking at the vtables between BTYPE and DTYPE,
995 return the most derived type we find. The caller must
996 be satisfied when the return value == DTYPE.
998 FIXME-tiemann: should work with dossier entries as well. */
1001 value_headof (arg
, btype
, dtype
)
1003 struct type
*btype
, *dtype
;
1005 /* First collect the vtables we must look at for this object. */
1006 /* FIXME-tiemann: right now, just look at top-most vtable. */
1007 value vtbl
, entry
, best_entry
= 0;
1008 /* FIXME: entry_type is never used. */
1009 struct type
*entry_type
;
1011 int offset
, best_offset
= 0;
1013 CORE_ADDR pc_for_sym
;
1014 char *demangled_name
;
1015 struct minimal_symbol
*msymbol
;
1017 btype
= TYPE_VPTR_BASETYPE (dtype
);
1018 check_stub_type (btype
);
1020 vtbl
= value_cast (lookup_pointer_type (btype
), arg
);
1023 vtbl
= value_ind (value_field (value_ind (vtbl
), TYPE_VPTR_FIELDNO (btype
)));
1025 /* Check that VTBL looks like it points to a virtual function table. */
1026 msymbol
= lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl
));
1028 || !VTBL_PREFIX_P (demangled_name
= msymbol
-> name
))
1030 /* If we expected to find a vtable, but did not, let the user
1031 know that we aren't happy, but don't throw an error.
1032 FIXME: there has to be a better way to do this. */
1033 struct type
*error_type
= (struct type
*)xmalloc (sizeof (struct type
));
1034 bcopy (VALUE_TYPE (arg
), error_type
, sizeof (struct type
));
1035 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
1036 VALUE_TYPE (arg
) = error_type
;
1040 /* Now search through the virtual function table. */
1041 entry
= value_ind (vtbl
);
1042 nelems
= longest_to_int (value_as_long (value_field (entry
, 2)));
1043 for (i
= 1; i
<= nelems
; i
++)
1045 entry
= value_subscript (vtbl
, value_from_longest (builtin_type_int
,
1047 offset
= longest_to_int (value_as_long (value_field (entry
, 0)));
1048 /* If we use '<=' we can handle single inheritance
1049 * where all offsets are zero - just use the first entry found. */
1050 if (offset
<= best_offset
)
1052 best_offset
= offset
;
1056 /* Move the pointer according to BEST_ENTRY's offset, and figure
1057 out what type we should return as the new pointer. */
1058 if (best_entry
== 0)
1060 /* An alternative method (which should no longer be necessary).
1061 * But we leave it in for future use, when we will hopefully
1062 * have optimizes the vtable to use thunks instead of offsets. */
1063 /* Use the name of vtable itself to extract a base type. */
1064 demangled_name
+= 4; /* Skip _vt$ prefix. */
1068 pc_for_sym
= value_as_pointer (value_field (best_entry
, 2));
1069 sym
= find_pc_function (pc_for_sym
);
1070 demangled_name
= cplus_demangle (SYMBOL_NAME (sym
), -1);
1071 *(strchr (demangled_name
, ':')) = '\0';
1073 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1075 error ("could not find type declaration for `%s'", SYMBOL_NAME (sym
));
1078 free (demangled_name
);
1079 arg
= value_add (value_cast (builtin_type_int
, arg
),
1080 value_field (best_entry
, 0));
1082 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1086 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1087 function tables, probe ARG's tables (including the vtables
1088 of its baseclasses) to figure out the most derived type that ARG
1089 could actually be a pointer to. */
1092 value_from_vtable_info (arg
, type
)
1096 /* Take care of preliminaries. */
1097 if (TYPE_VPTR_FIELDNO (type
) < 0)
1098 fill_in_vptr_fieldno (type
);
1099 if (TYPE_VPTR_FIELDNO (type
) < 0 || VALUE_REPEATED (arg
))
1102 return value_headof (arg
, 0, type
);
1105 /* The value of a static class member does not depend
1106 on its instance, only on its type. If FIELDNO >= 0,
1107 then fieldno is a valid field number and is used directly.
1108 Otherwise, FIELDNAME is the name of the field we are
1109 searching for. If it is not a static field name, an
1110 error is signaled. TYPE is the type in which we look for the
1111 static field member.
1113 Return zero if we couldn't find anything; the caller may signal
1114 an error in that case. */
1117 value_static_field (type
, fieldname
, fieldno
)
1118 register struct type
*type
;
1120 register int fieldno
;
1128 /* Look for static field. */
1130 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1131 if (! strcmp (TYPE_FIELD_NAME (type
, i
), fieldname
))
1133 if (TYPE_FIELD_STATIC (type
, i
))
1139 error ("field `%s' is not static", fieldname
);
1143 v
= value_static_field (TYPE_BASECLASS (type
, i
), fieldname
, -1);
1148 if (destructor_name_p (fieldname
, type
))
1149 error ("Cannot get value of destructor");
1151 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1153 if (! strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), fieldname
))
1154 error ("Cannot get value of method \"%s\"", fieldname
);
1156 error("there is no field named %s", fieldname
);
1160 phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1161 sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1162 if (! sym
) error ("Internal error: could not find physical static variable named %s", phys_name
);
1164 type
= TYPE_FIELD_TYPE (type
, fieldno
);
1165 v
= value_at (type
, (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1169 /* Compute the address of the baseclass which is
1170 the INDEXth baseclass of class TYPE. The TYPE base
1171 of the object is at VALADDR.
1173 If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1174 or 0 if no error. In that case the return value is not the address
1175 of the baseclasss, but the address which could not be read
1179 baseclass_addr (type
, index
, valaddr
, valuep
, errp
)
1186 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1191 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1193 /* Must hunt for the pointer to this virtual baseclass. */
1194 register int i
, len
= TYPE_NFIELDS (type
);
1195 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1196 char *vbase_name
, *type_name
= type_name_no_tag (basetype
);
1198 vbase_name
= (char *)alloca (strlen (type_name
) + 8);
1199 sprintf (vbase_name
, "_vb$%s", type_name
);
1200 /* First look for the virtual baseclass pointer
1202 for (i
= n_baseclasses
; i
< len
; i
++)
1204 if (! strcmp (vbase_name
, TYPE_FIELD_NAME (type
, i
)))
1206 value val
= allocate_value (basetype
);
1211 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1212 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1214 status
= target_read_memory (addr
,
1215 VALUE_CONTENTS_RAW (val
),
1216 TYPE_LENGTH (basetype
));
1217 VALUE_LVAL (val
) = lval_memory
;
1218 VALUE_ADDRESS (val
) = addr
;
1224 release_value (val
);
1228 return (char *)addr
;
1234 return (char *) VALUE_CONTENTS (val
);
1238 /* Not in the fields, so try looking through the baseclasses. */
1239 for (i
= index
+1; i
< n_baseclasses
; i
++)
1243 baddr
= baseclass_addr (type
, i
, valaddr
, valuep
, errp
);
1253 /* Baseclass is easily computed. */
1256 return valaddr
+ TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1260 unpack_field_as_long (type
, valaddr
, fieldno
)
1266 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1267 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1269 bcopy (valaddr
+ bitpos
/ 8, &val
, sizeof val
);
1270 SWAP_TARGET_AND_HOST (&val
, sizeof val
);
1272 /* Extracting bits depends on endianness of the machine. */
1274 val
= val
>> (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1276 val
= val
>> (bitpos
% 8);
1279 if (bitsize
< 8 * sizeof (val
))
1280 val
&= (((unsigned long)1) << bitsize
) - 1;
1284 /* Modify the value of a bitfield. ADDR points to a block of memory in
1285 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1286 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1287 indicate which bits (in target bit order) comprise the bitfield. */
1290 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1293 int bitpos
, bitsize
;
1297 /* Reject values too big to fit in the field in question,
1298 otherwise adjoining fields may be corrupted. */
1299 if (bitsize
< (8 * sizeof (fieldval
))
1300 && 0 != (fieldval
& ~((1<<bitsize
)-1)))
1301 error ("Value %d does not fit in %d bits.", fieldval
, bitsize
);
1303 bcopy (addr
, &oword
, sizeof oword
);
1304 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To host format */
1306 /* Shifting for bit field depends on endianness of the target machine. */
1308 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1311 /* Mask out old value, while avoiding shifts >= longword size */
1312 if (bitsize
< 8 * sizeof (oword
))
1313 oword
&= ~(((((unsigned long)1) << bitsize
) - 1) << bitpos
);
1315 oword
&= ~((-1) << bitpos
);
1316 oword
|= fieldval
<< bitpos
;
1318 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To target format */
1319 bcopy (&oword
, addr
, sizeof oword
);
1322 /* Convert C numbers into newly allocated values */
1325 value_from_longest (type
, num
)
1327 register LONGEST num
;
1329 register value val
= allocate_value (type
);
1330 register enum type_code code
= TYPE_CODE (type
);
1331 register int len
= TYPE_LENGTH (type
);
1333 /* FIXME, we assume that pointers have the same form and byte order as
1334 integers, and that all pointers have the same form. */
1335 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_ENUM
||
1336 code
== TYPE_CODE_CHAR
|| code
== TYPE_CODE_PTR
)
1338 if (len
== sizeof (char))
1339 * (char *) VALUE_CONTENTS_RAW (val
) = num
;
1340 else if (len
== sizeof (short))
1341 * (short *) VALUE_CONTENTS_RAW (val
) = num
;
1342 else if (len
== sizeof (int))
1343 * (int *) VALUE_CONTENTS_RAW (val
) = num
;
1344 else if (len
== sizeof (long))
1345 * (long *) VALUE_CONTENTS_RAW (val
) = num
;
1347 else if (len
== sizeof (long long))
1348 * (long long *) VALUE_CONTENTS_RAW (val
) = num
;
1351 error ("Integer type encountered with unexpected data length.");
1354 error ("Unexpected type encountered for integer constant.");
1356 /* num was in host byte order. So now put the value's contents
1357 into target byte order. */
1358 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1364 value_from_double (type
, num
)
1368 register value val
= allocate_value (type
);
1369 register enum type_code code
= TYPE_CODE (type
);
1370 register int len
= TYPE_LENGTH (type
);
1372 if (code
== TYPE_CODE_FLT
)
1374 if (len
== sizeof (float))
1375 * (float *) VALUE_CONTENTS_RAW (val
) = num
;
1376 else if (len
== sizeof (double))
1377 * (double *) VALUE_CONTENTS_RAW (val
) = num
;
1379 error ("Floating type encountered with unexpected data length.");
1382 error ("Unexpected type encountered for floating constant.");
1384 /* num was in host byte order. So now put the value's contents
1385 into target byte order. */
1386 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1391 /* Deal with the value that is "about to be returned". */
1393 /* Return the value that a function returning now
1394 would be returning to its caller, assuming its type is VALTYPE.
1395 RETBUF is where we look for what ought to be the contents
1396 of the registers (in raw form). This is because it is often
1397 desirable to restore old values to those registers
1398 after saving the contents of interest, and then call
1399 this function using the saved values.
1400 struct_return is non-zero when the function in question is
1401 using the structure return conventions on the machine in question;
1402 0 when it is using the value returning conventions (this often
1403 means returning pointer to where structure is vs. returning value). */
1406 value_being_returned (valtype
, retbuf
, struct_return
)
1407 register struct type
*valtype
;
1408 char retbuf
[REGISTER_BYTES
];
1415 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1416 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1417 if (struct_return
) {
1418 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1420 error ("Function return value unknown");
1421 return value_at (valtype
, addr
);
1425 val
= allocate_value (valtype
);
1426 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1431 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1432 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1433 and TYPE is the type (which is known to be struct, union or array).
1435 On most machines, the struct convention is used unless we are
1436 using gcc and the type is of a special size. */
1437 #if !defined (USE_STRUCT_CONVENTION)
1438 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1439 (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \
1440 || TYPE_LENGTH (value_type) == 2 \
1441 || TYPE_LENGTH (value_type) == 4 \
1442 || TYPE_LENGTH (value_type) == 8 \
1447 /* Return true if the function specified is using the structure returning
1448 convention on this machine to return arguments, or 0 if it is using
1449 the value returning convention. FUNCTION is the value representing
1450 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1451 is the type returned by the function. GCC_P is nonzero if compiled
1455 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1458 struct type
*value_type
;
1462 register enum type_code code
= TYPE_CODE (value_type
);
1464 if (code
== TYPE_CODE_ERROR
)
1465 error ("Function return type unknown.");
1467 if (code
== TYPE_CODE_STRUCT
||
1468 code
== TYPE_CODE_UNION
||
1469 code
== TYPE_CODE_ARRAY
)
1470 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1475 /* Store VAL so it will be returned if a function returns now.
1476 Does not verify that VAL's type matches what the current
1477 function wants to return. */
1480 set_return_value (val
)
1483 register enum type_code code
= TYPE_CODE (VALUE_TYPE (val
));
1487 if (code
== TYPE_CODE_ERROR
)
1488 error ("Function return type unknown.");
1490 if ( code
== TYPE_CODE_STRUCT
1491 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1492 error ("GDB does not support specifying a struct or union return value.");
1494 /* FIXME, this is bogus. We don't know what the return conventions
1495 are, or how values should be promoted.... */
1496 if (code
== TYPE_CODE_FLT
)
1498 dbuf
= value_as_double (val
);
1500 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&dbuf
);
1504 lbuf
= value_as_long (val
);
1505 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&lbuf
);
1510 _initialize_values ()
1512 add_cmd ("convenience", no_class
, show_convenience
,
1513 "Debugger convenience (\"$foo\") variables.\n\
1514 These variables are created when you assign them values;\n\
1515 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1516 A few convenience variables are given values automatically:\n\
1517 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1518 \"$__\" holds the contents of the last address examined with \"x\".",
1521 add_cmd ("values", no_class
, show_values
,
1522 "Elements of value history around item number IDX (or last ten).",