1 /* Low level packing and unpacking of values for GDB.
2 Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB 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 1, or (at your option)
11 GDB 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 GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
31 extern char *cplus_demangle ();
32 extern char *cplus_mangle_opname ();
34 /* The value-history records all the values printed
35 by print commands during this session. Each chunk
36 records 60 consecutive values. The first chunk on
37 the chain records the most recent values.
38 The total number of values is in value_history_count. */
40 #define VALUE_HISTORY_CHUNK 60
42 struct value_history_chunk
44 struct value_history_chunk
*next
;
45 value values
[VALUE_HISTORY_CHUNK
];
48 /* Chain of chunks now in use. */
50 static struct value_history_chunk
*value_history_chain
;
52 static int value_history_count
; /* Abs number of last entry stored */
54 /* List of all value objects currently allocated
55 (except for those released by calls to release_value)
56 This is so they can be freed after each command. */
58 static value all_values
;
60 /* Allocate a value that has the correct length for type TYPE. */
68 check_stub_type (type
);
70 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
));
71 VALUE_NEXT (val
) = all_values
;
73 VALUE_TYPE (val
) = type
;
74 VALUE_LVAL (val
) = not_lval
;
75 VALUE_ADDRESS (val
) = 0;
76 VALUE_FRAME (val
) = 0;
77 VALUE_OFFSET (val
) = 0;
78 VALUE_BITPOS (val
) = 0;
79 VALUE_BITSIZE (val
) = 0;
80 VALUE_REPEATED (val
) = 0;
81 VALUE_REPETITIONS (val
) = 0;
82 VALUE_REGNO (val
) = -1;
84 VALUE_OPTIMIZED_OUT (val
) = 0;
88 /* Allocate a value that has the correct length
89 for COUNT repetitions type TYPE. */
92 allocate_repeat_value (type
, count
)
98 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
) * count
);
99 VALUE_NEXT (val
) = all_values
;
101 VALUE_TYPE (val
) = type
;
102 VALUE_LVAL (val
) = not_lval
;
103 VALUE_ADDRESS (val
) = 0;
104 VALUE_FRAME (val
) = 0;
105 VALUE_OFFSET (val
) = 0;
106 VALUE_BITPOS (val
) = 0;
107 VALUE_BITSIZE (val
) = 0;
108 VALUE_REPEATED (val
) = 1;
109 VALUE_REPETITIONS (val
) = count
;
110 VALUE_REGNO (val
) = -1;
111 VALUE_LAZY (val
) = 0;
112 VALUE_OPTIMIZED_OUT (val
) = 0;
116 /* Return a mark in the value chain. All values allocated after the
117 mark is obtained (except for those released) are subject to being freed
118 if a subsequent value_free_to_mark is passed the mark. */
125 /* Free all values allocated since MARK was obtained by value_mark
126 (except for those released). */
128 value_free_to_mark (mark
)
133 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
135 next
= VALUE_NEXT (val
);
141 /* Free all the values that have been allocated (except for those released).
142 Called after each command, successful or not. */
147 register value val
, next
;
149 for (val
= all_values
; val
; val
= next
)
151 next
= VALUE_NEXT (val
);
158 /* Remove VAL from the chain all_values
159 so it will not be freed automatically. */
167 if (all_values
== val
)
169 all_values
= val
->next
;
173 for (v
= all_values
; v
; v
= v
->next
)
183 /* Return a copy of the value ARG.
184 It contains the same contents, for same memory address,
185 but it's a different block of storage. */
192 register struct type
*type
= VALUE_TYPE (arg
);
193 if (VALUE_REPEATED (arg
))
194 val
= allocate_repeat_value (type
, VALUE_REPETITIONS (arg
));
196 val
= allocate_value (type
);
197 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
198 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
199 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
200 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
201 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
202 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
203 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
204 if (!VALUE_LAZY (val
))
206 bcopy (VALUE_CONTENTS_RAW (arg
), VALUE_CONTENTS_RAW (val
),
207 TYPE_LENGTH (VALUE_TYPE (arg
))
208 * (VALUE_REPEATED (arg
) ? VALUE_REPETITIONS (arg
) : 1));
213 /* Access to the value history. */
215 /* Record a new value in the value history.
216 Returns the absolute history index of the entry.
217 Result of -1 indicates the value was not saved; otherwise it is the
218 value history index of this new item. */
221 record_latest_value (val
)
226 /* Check error now if about to store an invalid float. We return -1
227 to the caller, but allow them to continue, e.g. to print it as "Nan". */
228 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
) {
229 (void) unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &i
);
230 if (i
) return -1; /* Indicate value not saved in history */
233 /* Here we treat value_history_count as origin-zero
234 and applying to the value being stored now. */
236 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
239 register struct value_history_chunk
*new
240 = (struct value_history_chunk
*)
241 xmalloc (sizeof (struct value_history_chunk
));
242 bzero (new->values
, sizeof new->values
);
243 new->next
= value_history_chain
;
244 value_history_chain
= new;
247 value_history_chain
->values
[i
] = val
;
250 /* Now we regard value_history_count as origin-one
251 and applying to the value just stored. */
253 return ++value_history_count
;
256 /* Return a copy of the value in the history with sequence number NUM. */
259 access_value_history (num
)
262 register struct value_history_chunk
*chunk
;
264 register int absnum
= num
;
267 absnum
+= value_history_count
;
272 error ("The history is empty.");
274 error ("There is only one value in the history.");
276 error ("History does not go back to $$%d.", -num
);
278 if (absnum
> value_history_count
)
279 error ("History has not yet reached $%d.", absnum
);
283 /* Now absnum is always absolute and origin zero. */
285 chunk
= value_history_chain
;
286 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
290 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
293 /* Clear the value history entirely.
294 Must be done when new symbol tables are loaded,
295 because the type pointers become invalid. */
298 clear_value_history ()
300 register struct value_history_chunk
*next
;
304 while (value_history_chain
)
306 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
307 if (val
= value_history_chain
->values
[i
])
309 next
= value_history_chain
->next
;
310 free (value_history_chain
);
311 value_history_chain
= next
;
313 value_history_count
= 0;
317 show_values (num_exp
, from_tty
)
327 if (num_exp
[0] == '+' && num_exp
[1] == '\0')
328 /* "info history +" should print from the stored position. */
331 /* "info history <exp>" should print around value number <exp>. */
332 num
= parse_and_eval_address (num_exp
) - 5;
336 /* "info history" means print the last 10 values. */
337 num
= value_history_count
- 9;
343 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
345 val
= access_value_history (i
);
346 printf_filtered ("$%d = ", i
);
347 value_print (val
, stdout
, 0, Val_pretty_default
);
348 printf_filtered ("\n");
351 /* The next "info history +" should start after what we just printed. */
354 /* Hitting just return after this command should do the same thing as
355 "info history +". If num_exp is null, this is unnecessary, since
356 "info history +" is not useful after "info history". */
357 if (from_tty
&& num_exp
)
364 /* Internal variables. These are variables within the debugger
365 that hold values assigned by debugger commands.
366 The user refers to them with a '$' prefix
367 that does not appear in the variable names stored internally. */
369 static struct internalvar
*internalvars
;
371 /* Look up an internal variable with name NAME. NAME should not
372 normally include a dollar sign.
374 If the specified internal variable does not exist,
375 one is created, with a void value. */
378 lookup_internalvar (name
)
381 register struct internalvar
*var
;
383 for (var
= internalvars
; var
; var
= var
->next
)
384 if (!strcmp (var
->name
, name
))
387 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
388 var
->name
= concat (name
, "", "");
389 var
->value
= allocate_value (builtin_type_void
);
390 release_value (var
->value
);
391 var
->next
= internalvars
;
397 value_of_internalvar (var
)
398 struct internalvar
*var
;
402 #ifdef IS_TRAPPED_INTERNALVAR
403 if (IS_TRAPPED_INTERNALVAR (var
->name
))
404 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
407 val
= value_copy (var
->value
);
408 if (VALUE_LAZY (val
))
409 value_fetch_lazy (val
);
410 VALUE_LVAL (val
) = lval_internalvar
;
411 VALUE_INTERNALVAR (val
) = var
;
416 set_internalvar_component (var
, offset
, bitpos
, bitsize
, newval
)
417 struct internalvar
*var
;
418 int offset
, bitpos
, bitsize
;
421 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
423 #ifdef IS_TRAPPED_INTERNALVAR
424 if (IS_TRAPPED_INTERNALVAR (var
->name
))
425 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
429 modify_field (addr
, (int) value_as_long (newval
),
432 bcopy (VALUE_CONTENTS (newval
), addr
,
433 TYPE_LENGTH (VALUE_TYPE (newval
)));
437 set_internalvar (var
, val
)
438 struct internalvar
*var
;
441 #ifdef IS_TRAPPED_INTERNALVAR
442 if (IS_TRAPPED_INTERNALVAR (var
->name
))
443 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
447 var
->value
= value_copy (val
);
448 release_value (var
->value
);
452 internalvar_name (var
)
453 struct internalvar
*var
;
458 /* Free all internalvars. Done when new symtabs are loaded,
459 because that makes the values invalid. */
462 clear_internalvars ()
464 register struct internalvar
*var
;
469 internalvars
= var
->next
;
479 register struct internalvar
*var
;
482 for (var
= internalvars
; var
; var
= var
->next
)
484 #ifdef IS_TRAPPED_INTERNALVAR
485 if (IS_TRAPPED_INTERNALVAR (var
->name
))
492 printf ("Debugger convenience variables:\n\n");
496 printf ("$%s = ", var
->name
);
497 value_print (var
->value
, stdout
, 0, Val_pretty_default
);
501 printf ("No debugger convenience variables now defined.\n\
502 Convenience variables have names starting with \"$\";\n\
503 use \"set\" as in \"set $foo = 5\" to define them.\n");
506 /* Extract a value as a C number (either long or double).
507 Knows how to convert fixed values to double, or
508 floating values to long.
509 Does not deallocate the value. */
515 /* This coerces arrays and functions, which is necessary (e.g.
516 in disassemble_command). It also dereferences references, which
517 I suspect is the most logical thing to do. */
518 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_ENUM
)
520 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
524 value_as_double (val
)
530 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
532 error ("Invalid floating value found in program.");
536 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
537 as a long, or as a double, assuming the raw data is described
538 by type TYPE. Knows how to convert different sizes of values
539 and can convert between fixed and floating point. We don't assume
540 any alignment for the raw data. Return value is in host byte order.
542 If you want functions and arrays to be coerced to pointers, and
543 references to be dereferenced, call value_as_long() instead.
545 C++: It is assumed that the front-end has taken care of
546 all matters concerning pointers to members. A pointer
547 to member which reaches here is considered to be equivalent
548 to an INT (or some size). After all, it is only an offset. */
551 unpack_long (type
, valaddr
)
555 register enum type_code code
= TYPE_CODE (type
);
556 register int len
= TYPE_LENGTH (type
);
557 register int nosign
= TYPE_UNSIGNED (type
);
559 if (code
== TYPE_CODE_ENUM
)
560 code
= TYPE_CODE_INT
;
561 if (code
== TYPE_CODE_FLT
)
563 if (len
== sizeof (float))
566 bcopy (valaddr
, &retval
, sizeof (retval
));
567 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
571 if (len
== sizeof (double))
574 bcopy (valaddr
, &retval
, sizeof (retval
));
575 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
580 error ("Unexpected type of floating point number.");
583 else if (code
== TYPE_CODE_INT
&& nosign
)
585 if (len
== sizeof (char))
587 unsigned char retval
= * (unsigned char *) valaddr
;
588 /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
592 if (len
== sizeof (short))
594 unsigned short retval
;
595 bcopy (valaddr
, &retval
, sizeof (retval
));
596 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
600 if (len
== sizeof (int))
603 bcopy (valaddr
, &retval
, sizeof (retval
));
604 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
608 if (len
== sizeof (long))
610 unsigned long retval
;
611 bcopy (valaddr
, &retval
, sizeof (retval
));
612 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
616 if (len
== sizeof (long long))
618 unsigned long long retval
;
619 bcopy (valaddr
, &retval
, sizeof (retval
));
620 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
626 error ("That operation is not possible on an integer of that size.");
629 else if (code
== TYPE_CODE_INT
)
631 if (len
== sizeof (char))
634 bcopy (valaddr
, &retval
, sizeof (retval
));
635 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
639 if (len
== sizeof (short))
642 bcopy (valaddr
, &retval
, sizeof (retval
));
643 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
647 if (len
== sizeof (int))
650 bcopy (valaddr
, &retval
, sizeof (retval
));
651 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
655 if (len
== sizeof (long))
658 bcopy (valaddr
, &retval
, sizeof (retval
));
659 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
664 if (len
== sizeof (long long))
667 bcopy (valaddr
, &retval
, sizeof (retval
));
668 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
674 error ("That operation is not possible on an integer of that size.");
677 else if (code
== TYPE_CODE_PTR
678 || code
== TYPE_CODE_REF
)
680 if (len
== sizeof (char *))
683 bcopy (valaddr
, &retval
, sizeof (retval
));
684 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
688 else if (code
== TYPE_CODE_MEMBER
)
689 error ("not implemented: member types in unpack_long");
691 error ("Value not integer or pointer.");
692 return 0; /* For lint -- never reached */
695 /* Return a double value from the specified type and address.
696 INVP points to an int which is set to 0 for valid value,
697 1 for invalid value (bad float format). In either case,
698 the returned double is OK to use. Argument is in target
699 format, result is in host format. */
702 unpack_double (type
, valaddr
, invp
)
707 register enum type_code code
= TYPE_CODE (type
);
708 register int len
= TYPE_LENGTH (type
);
709 register int nosign
= TYPE_UNSIGNED (type
);
711 *invp
= 0; /* Assume valid. */
712 if (code
== TYPE_CODE_FLT
)
714 if (INVALID_FLOAT (valaddr
, len
))
717 return 1.234567891011121314;
720 if (len
== sizeof (float))
723 bcopy (valaddr
, &retval
, sizeof (retval
));
724 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
728 if (len
== sizeof (double))
731 bcopy (valaddr
, &retval
, sizeof (retval
));
732 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
737 error ("Unexpected type of floating point number.");
741 /* Unsigned -- be sure we compensate for signed LONGEST. */
743 return (unsigned long long) unpack_long (type
, valaddr
);
745 return (unsigned long ) unpack_long (type
, valaddr
);
748 /* Signed -- we are OK with unpack_long. */
749 return unpack_long (type
, valaddr
);
753 /* Given a value ARG1 (offset by OFFSET bytes)
754 of a struct or union type ARG_TYPE,
755 extract and return the value of one of its fields.
756 FIELDNO says which field.
758 For C++, must also be able to return values from static fields */
761 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
764 register int fieldno
;
765 register struct type
*arg_type
;
768 register struct type
*type
;
770 check_stub_type (arg_type
);
771 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
773 /* Handle packed fields */
775 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
776 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
778 v
= value_from_long (type
,
779 unpack_field_as_long (arg_type
,
780 VALUE_CONTENTS (arg1
),
782 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
783 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
787 v
= allocate_value (type
);
788 if (VALUE_LAZY (arg1
))
791 bcopy (VALUE_CONTENTS_RAW (arg1
) + offset
,
792 VALUE_CONTENTS_RAW (v
),
795 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
796 if (VALUE_LVAL (arg1
) == lval_internalvar
)
797 VALUE_LVAL (v
) = lval_internalvar_component
;
798 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
799 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (arg1
);
803 /* Given a value ARG1 of a struct or union type,
804 extract and return the value of one of its fields.
805 FIELDNO says which field.
807 For C++, must also be able to return values from static fields */
810 value_field (arg1
, fieldno
)
812 register int fieldno
;
814 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
818 value_fn_field (arg1
, fieldno
, subfieldno
)
820 register int fieldno
;
824 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (VALUE_TYPE (arg1
), fieldno
);
825 register struct type
*type
= TYPE_FN_FIELD_TYPE (f
, subfieldno
);
828 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, subfieldno
),
829 0, VAR_NAMESPACE
, 0, NULL
);
830 if (! sym
) error ("Internal error: could not find physical method named %s",
831 TYPE_FN_FIELD_PHYSNAME (f
, subfieldno
));
833 v
= allocate_value (type
);
834 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
835 VALUE_TYPE (v
) = type
;
839 /* Return a virtual function as a value.
840 ARG1 is the object which provides the virtual function
841 table pointer. ARG1 is side-effected in calling this function.
842 F is the list of member functions which contains the desired virtual
844 J is an index into F which provides the desired virtual function.
846 TYPE is the type in which F is located. */
848 value_virtual_fn_field (arg1
, f
, j
, type
)
854 /* First, get the virtual function table pointer. That comes
855 with a strange type, so cast it to type `pointer to long' (which
856 should serve just fine as a function type). Then, index into
857 the table, and convert final value to appropriate function type. */
858 value entry
, vfn
, vtbl
;
859 value vi
= value_from_long (builtin_type_int
,
860 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
861 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
862 struct type
*context
;
863 if (fcontext
== NULL
)
864 /* We don't have an fcontext (e.g. the program was compiled with
865 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
866 This won't work right for multiple inheritance, but at least we
867 should do as well as GDB 3.x did. */
868 fcontext
= TYPE_VPTR_BASETYPE (type
);
869 context
= lookup_pointer_type (fcontext
);
870 /* Now context is a pointer to the basetype containing the vtbl. */
871 if (TYPE_TARGET_TYPE (context
) != VALUE_TYPE (arg1
))
872 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
874 context
= VALUE_TYPE (arg1
);
875 /* Now context is the basetype containing the vtbl. */
877 /* This type may have been defined before its virtual function table
878 was. If so, fill in the virtual function table entry for the
880 if (TYPE_VPTR_FIELDNO (context
) < 0)
881 fill_in_vptr_fieldno (context
);
883 /* The virtual function table is now an array of structures
884 which have the form { int16 offset, delta; void *pfn; }. */
885 vtbl
= value_ind (value_field (arg1
, TYPE_VPTR_FIELDNO (context
)));
887 /* Index into the virtual function table. This is hard-coded because
888 looking up a field is not cheap, and it may be important to save
889 time, e.g. if the user has set a conditional breakpoint calling
890 a virtual function. */
891 entry
= value_subscript (vtbl
, vi
);
893 /* Move the `this' pointer according to the virtual function table. */
894 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
895 if (! VALUE_LAZY (arg1
))
897 VALUE_LAZY (arg1
) = 1;
898 value_fetch_lazy (arg1
);
901 vfn
= value_field (entry
, 2);
902 /* Reinstantiate the function pointer with the correct type. */
903 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
908 /* ARG is a pointer to an object we know to be at least
909 a DTYPE. BTYPE is the most derived basetype that has
910 already been searched (and need not be searched again).
911 After looking at the vtables between BTYPE and DTYPE,
912 return the most derived type we find. The caller must
913 be satisfied when the return value == DTYPE.
915 FIXME-tiemann: should work with dossier entries as well. */
918 value_headof (arg
, btype
, dtype
)
920 struct type
*btype
, *dtype
;
922 /* First collect the vtables we must look at for this object. */
923 /* FIXME-tiemann: right now, just look at top-most vtable. */
924 value vtbl
, entry
, best_entry
= 0;
925 struct type
*entry_type
;
927 int offset
, best_offset
= 0;
929 CORE_ADDR pc_for_sym
;
930 char *demangled_name
;
932 btype
= TYPE_VPTR_BASETYPE (dtype
);
933 check_stub_type (btype
);
935 vtbl
= value_cast (lookup_pointer_type (btype
), arg
);
938 vtbl
= value_ind (value_field (value_ind (vtbl
), TYPE_VPTR_FIELDNO (btype
)));
940 /* Check that VTBL looks like it points to a virtual function table. */
941 i
= find_pc_misc_function (VALUE_ADDRESS (vtbl
));
942 if (i
< 0 || ! VTBL_PREFIX_P (misc_function_vector
[i
].name
))
944 /* If we expected to find a vtable, but did not, let the user
945 know that we aren't happy, but don't throw an error.
946 FIXME: there has to be a better way to do this. */
947 struct type
*error_type
= (struct type
*)xmalloc (sizeof (struct type
));
948 bcopy (VALUE_TYPE (arg
), error_type
, sizeof (struct type
));
949 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
950 VALUE_TYPE (arg
) = error_type
;
954 /* Now search through the virtual function table. */
955 entry
= value_ind (vtbl
);
956 entry_type
= VALUE_TYPE (entry
);
957 nelems
= value_as_long (value_field (entry
, 2));
958 for (i
= 1; i
<= nelems
; i
++)
960 entry
= value_subscript (vtbl
, value_from_long (builtin_type_int
, i
));
961 offset
= value_as_long (value_field (entry
, 0));
962 if (offset
< best_offset
)
964 best_offset
= offset
;
971 /* Move the pointer according to BEST_ENTRY's offset, and figure
972 out what type we should return as the new pointer. */
973 pc_for_sym
= value_as_long (value_field (best_entry
, 2));
974 sym
= find_pc_function (pc_for_sym
);
975 demangled_name
= cplus_demangle (SYMBOL_NAME (sym
), -1);
976 *(strchr (demangled_name
, ':')) = '\0';
977 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
979 error ("could not find type declaration for `%s'", SYMBOL_NAME (sym
));
980 free (demangled_name
);
981 arg
= value_add (value_cast (builtin_type_int
, arg
),
982 value_field (best_entry
, 0));
983 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
987 /* ARG is a pointer object of type TYPE. If TYPE has virtual
988 function tables, probe ARG's tables (including the vtables
989 of its baseclasses) to figure out the most derived type that ARG
990 could actually be a pointer to. */
993 value_from_vtable_info (arg
, type
)
997 /* Take care of preliminaries. */
998 if (TYPE_VPTR_FIELDNO (type
) < 0)
999 fill_in_vptr_fieldno (type
);
1000 if (TYPE_VPTR_FIELDNO (type
) < 0 || VALUE_REPEATED (arg
))
1003 return value_headof (arg
, 0, type
);
1006 /* The value of a static class member does not depend
1007 on its instance, only on its type. If FIELDNO >= 0,
1008 then fieldno is a valid field number and is used directly.
1009 Otherwise, FIELDNAME is the name of the field we are
1010 searching for. If it is not a static field name, an
1011 error is signaled. TYPE is the type in which we look for the
1012 static field member.
1014 Return zero if we couldn't find anything; the caller may signal
1015 an error in that case. */
1018 value_static_field (type
, fieldname
, fieldno
)
1019 register struct type
*type
;
1021 register int fieldno
;
1029 /* Look for static field. */
1031 for (i
= TYPE_NFIELDS (type
) - 1; i
>= TYPE_N_BASECLASSES (type
); i
--)
1032 if (! strcmp (TYPE_FIELD_NAME (type
, i
), fieldname
))
1034 if (TYPE_FIELD_STATIC (type
, i
))
1040 error ("field `%s' is not static", fieldname
);
1044 v
= value_static_field (TYPE_BASECLASS (type
, i
), fieldname
, -1);
1049 if (destructor_name_p (fieldname
, type
))
1050 error ("Cannot get value of destructor");
1052 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; i
--)
1054 if (! strcmp (TYPE_FN_FIELDLIST_NAME (type
, i
), fieldname
))
1055 error ("Cannot get value of method \"%s\"", fieldname
);
1057 error("there is no field named %s", fieldname
);
1061 phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
1062 sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
1063 if (! sym
) error ("Internal error: could not find physical static variable named %s", phys_name
);
1065 type
= TYPE_FIELD_TYPE (type
, fieldno
);
1066 v
= value_at (type
, (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
1070 /* Compute the address of the baseclass which is
1071 the INDEXth baseclass of TYPE. The TYPE base
1072 of the object is at VALADDR.
1074 If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1075 or 0 if no error. In that case the return value is not the address
1076 of the baseclasss, but the address which could not be read
1080 baseclass_addr (type
, index
, valaddr
, valuep
, errp
)
1087 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1092 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1094 /* Must hunt for the pointer to this virtual baseclass. */
1095 register int i
, len
= TYPE_NFIELDS (type
);
1096 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1097 char *vbase_name
, *type_name
= type_name_no_tag (basetype
);
1099 if (TYPE_MAIN_VARIANT (basetype
))
1100 basetype
= TYPE_MAIN_VARIANT (basetype
);
1102 vbase_name
= (char *)alloca (strlen (type_name
) + 8);
1103 sprintf (vbase_name
, "_vb$%s", type_name
);
1104 /* First look for the virtual baseclass pointer
1106 for (i
= n_baseclasses
; i
< len
; i
++)
1108 if (! strcmp (vbase_name
, TYPE_FIELD_NAME (type
, i
)))
1110 value val
= allocate_value (basetype
);
1114 addr
= unpack_long (TYPE_FIELD_TYPE (type
, i
),
1115 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1117 status
= target_read_memory (addr
,
1118 VALUE_CONTENTS_RAW (val
),
1119 TYPE_LENGTH (type
));
1120 VALUE_LVAL (val
) = lval_memory
;
1121 VALUE_ADDRESS (val
) = addr
;
1127 release_value (val
);
1131 return (char *)addr
;
1137 return (char *) VALUE_CONTENTS (val
);
1141 /* Not in the fields, so try looking through the baseclasses. */
1142 for (i
= index
+1; i
< n_baseclasses
; i
++)
1146 baddr
= baseclass_addr (type
, i
, valaddr
, valuep
);
1156 /* Baseclass is easily computed. */
1159 return valaddr
+ TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1162 /* Ugly hack to convert method stubs into method types.
1164 He ain't kiddin'. This demangles the name of the method into a string
1165 including argument types, parses out each argument type, generates
1166 a string casting a zero to that type, evaluates the string, and stuffs
1167 the resulting type into an argtype vector!!! Then it knows the type
1168 of the whole function (including argument types for overloading),
1169 which info used to be in the stab's but was removed to hack back
1170 the space required for them. */
1172 check_stub_method (type
, i
, j
)
1176 extern char *gdb_mangle_typename (), *strchr ();
1177 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1178 char *field_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1179 char *inner_name
= gdb_mangle_typename (type
);
1180 int mangled_name_len
= (strlen (field_name
)
1181 + strlen (inner_name
)
1182 + strlen (TYPE_FN_FIELD_PHYSNAME (f
, j
))
1185 char *demangled_name
;
1186 char *argtypetext
, *p
;
1187 int depth
= 0, argcount
= 1;
1188 struct type
**argtypes
;
1190 if (OPNAME_PREFIX_P (field_name
))
1192 char *opname
= cplus_mangle_opname (field_name
+ 3);
1193 mangled_name_len
+= strlen (opname
);
1194 mangled_name
= (char *)xmalloc (mangled_name_len
);
1196 strncpy (mangled_name
, field_name
, 3);
1197 mangled_name
[3] = '\0';
1198 strcat (mangled_name
, opname
);
1202 mangled_name
= (char *)xmalloc (mangled_name_len
);
1203 strcpy (mangled_name
, TYPE_FN_FIELDLIST_NAME (type
, i
));
1205 strcat (mangled_name
, inner_name
);
1206 strcat (mangled_name
, TYPE_FN_FIELD_PHYSNAME (f
, j
));
1207 demangled_name
= cplus_demangle (mangled_name
, 0);
1209 /* Now, read in the parameters that define this type. */
1210 argtypetext
= strchr (demangled_name
, '(') + 1;
1218 else if (*p
== ',' && depth
== 0)
1223 /* We need one more slot for the void [...] or NULL [end of arglist] */
1224 argtypes
= (struct type
**)xmalloc ((argcount
+1) * sizeof (struct type
*));
1226 argtypes
[0] = lookup_pointer_type (type
);
1229 if (*p
!= ')') /* () means no args, skip while */
1238 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1240 char *tmp
= (char *)alloca (p
- argtypetext
+ 4);
1243 bcopy (argtypetext
, tmp
+1, p
- argtypetext
);
1244 tmp
[p
-argtypetext
+1] = ')';
1245 tmp
[p
-argtypetext
+2] = '0';
1246 tmp
[p
-argtypetext
+3] = '\0';
1247 val
= parse_and_eval (tmp
);
1248 argtypes
[argcount
] = VALUE_TYPE (val
);
1250 argtypetext
= p
+ 1;
1256 if (p
[-2] != '.') /* ... */
1257 argtypes
[argcount
] = builtin_type_void
; /* Ellist terminator */
1259 argtypes
[argcount
] = NULL
; /* List terminator */
1261 free (demangled_name
);
1263 type
= lookup_method_type (type
, TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)), argtypes
);
1264 /* Free the stub type...it's no longer needed. */
1265 free (TYPE_FN_FIELD_TYPE (f
, j
));
1266 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1267 TYPE_FN_FIELD_TYPE (f
, j
) = type
;
1271 unpack_field_as_long (type
, valaddr
, fieldno
)
1277 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1278 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1280 bcopy (valaddr
+ bitpos
/ 8, &val
, sizeof val
);
1281 SWAP_TARGET_AND_HOST (&val
, sizeof val
);
1283 /* Extracting bits depends on endianness of the machine. */
1285 val
= val
>> (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1287 val
= val
>> (bitpos
% 8);
1290 val
&= (1 << bitsize
) - 1;
1294 /* Modify the value of a bitfield. ADDR points to a block of memory in
1295 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1296 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1297 indicate which bits (in target bit order) comprise the bitfield. */
1300 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1303 int bitpos
, bitsize
;
1307 /* Reject values too big to fit in the field in question.
1308 Otherwise adjoining fields may be corrupted. */
1309 if (fieldval
& ~((1<<bitsize
)-1))
1310 error ("Value %d does not fit in %d bits.", fieldval
, bitsize
);
1312 bcopy (addr
, &oword
, sizeof oword
);
1313 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To host format */
1315 /* Shifting for bit field depends on endianness of the target machine. */
1317 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1320 oword
&= ~(((1 << bitsize
) - 1) << bitpos
);
1321 oword
|= fieldval
<< bitpos
;
1323 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To target format */
1324 bcopy (&oword
, addr
, sizeof oword
);
1327 /* Convert C numbers into newly allocated values */
1330 value_from_long (type
, num
)
1332 register LONGEST num
;
1334 register value val
= allocate_value (type
);
1335 register enum type_code code
= TYPE_CODE (type
);
1336 register int len
= TYPE_LENGTH (type
);
1338 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_ENUM
)
1340 if (len
== sizeof (char))
1341 * (char *) VALUE_CONTENTS_RAW (val
) = num
;
1342 else if (len
== sizeof (short))
1343 * (short *) VALUE_CONTENTS_RAW (val
) = num
;
1344 else if (len
== sizeof (int))
1345 * (int *) VALUE_CONTENTS_RAW (val
) = num
;
1346 else if (len
== sizeof (long))
1347 * (long *) VALUE_CONTENTS_RAW (val
) = num
;
1349 else if (len
== sizeof (long long))
1350 * (long long *) VALUE_CONTENTS_RAW (val
) = num
;
1353 error ("Integer type encountered with unexpected data length.");
1356 error ("Unexpected type encountered for integer constant.");
1358 /* num was in host byte order. So now put the value's contents
1359 into target byte order. */
1360 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1366 value_from_double (type
, num
)
1370 register value val
= allocate_value (type
);
1371 register enum type_code code
= TYPE_CODE (type
);
1372 register int len
= TYPE_LENGTH (type
);
1374 if (code
== TYPE_CODE_FLT
)
1376 if (len
== sizeof (float))
1377 * (float *) VALUE_CONTENTS_RAW (val
) = num
;
1378 else if (len
== sizeof (double))
1379 * (double *) VALUE_CONTENTS_RAW (val
) = num
;
1381 error ("Floating type encountered with unexpected data length.");
1384 error ("Unexpected type encountered for floating constant.");
1386 /* num was in host byte order. So now put the value's contents
1387 into target byte order. */
1388 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1393 /* Deal with the value that is "about to be returned". */
1395 /* Return the value that a function returning now
1396 would be returning to its caller, assuming its type is VALTYPE.
1397 RETBUF is where we look for what ought to be the contents
1398 of the registers (in raw form). This is because it is often
1399 desirable to restore old values to those registers
1400 after saving the contents of interest, and then call
1401 this function using the saved values.
1402 struct_return is non-zero when the function in question is
1403 using the structure return conventions on the machine in question;
1404 0 when it is using the value returning conventions (this often
1405 means returning pointer to where structure is vs. returning value). */
1408 value_being_returned (valtype
, retbuf
, struct_return
)
1409 register struct type
*valtype
;
1410 char retbuf
[REGISTER_BYTES
];
1417 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1418 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1419 if (struct_return
) {
1420 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1422 error ("Function return value unknown");
1423 return value_at (valtype
, addr
);
1427 val
= allocate_value (valtype
);
1428 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1433 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1434 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1435 and TYPE is the type (which is known to be struct, union or array).
1437 On most machines, the struct convention is used unless we are
1438 using gcc and the type is of a special size. */
1439 #if !defined (USE_STRUCT_CONVENTION)
1440 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1441 (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \
1442 || TYPE_LENGTH (value_type) == 2 \
1443 || TYPE_LENGTH (value_type) == 4 \
1444 || TYPE_LENGTH (value_type) == 8 \
1449 /* Return true if the function specified is using the structure returning
1450 convention on this machine to return arguments, or 0 if it is using
1451 the value returning convention. FUNCTION is the value representing
1452 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1453 is the type returned by the function. GCC_P is nonzero if compiled
1457 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1460 struct type
*value_type
;
1464 register enum type_code code
= TYPE_CODE (value_type
);
1466 if (code
== TYPE_CODE_ERROR
)
1467 error ("Function return type unknown.");
1469 if (code
== TYPE_CODE_STRUCT
||
1470 code
== TYPE_CODE_UNION
||
1471 code
== TYPE_CODE_ARRAY
)
1472 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1477 /* Store VAL so it will be returned if a function returns now.
1478 Does not verify that VAL's type matches what the current
1479 function wants to return. */
1482 set_return_value (val
)
1485 register enum type_code code
= TYPE_CODE (VALUE_TYPE (val
));
1489 if (code
== TYPE_CODE_ERROR
)
1490 error ("Function return type unknown.");
1492 if (code
== TYPE_CODE_STRUCT
1493 || code
== TYPE_CODE_UNION
)
1494 error ("Specifying a struct or union return value is not supported.");
1496 /* FIXME, this is bogus. We don't know what the return conventions
1497 are, or how values should be promoted.... */
1498 if (code
== TYPE_CODE_FLT
)
1500 dbuf
= value_as_double (val
);
1502 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&dbuf
);
1506 lbuf
= value_as_long (val
);
1507 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&lbuf
);
1512 _initialize_values ()
1514 add_cmd ("convenience", no_class
, show_convenience
,
1515 "Debugger convenience (\"$foo\") variables.\n\
1516 These variables are created when you assign them values;\n\
1517 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1518 A few convenience variables are given values automatically:\n\
1519 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1520 \"$__\" holds the contents of the last address examined with \"x\".",
1523 add_cmd ("values", no_class
, show_values
,
1524 "Elements of value history around item number IDX (or last ten).",