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 /* The value-history records all the values printed
32 by print commands during this session. Each chunk
33 records 60 consecutive values. The first chunk on
34 the chain records the most recent values.
35 The total number of values is in value_history_count. */
37 #define VALUE_HISTORY_CHUNK 60
39 struct value_history_chunk
41 struct value_history_chunk
*next
;
42 value values
[VALUE_HISTORY_CHUNK
];
45 /* Chain of chunks now in use. */
47 static struct value_history_chunk
*value_history_chain
;
49 static int value_history_count
; /* Abs number of last entry stored */
52 /* List of all value objects currently allocated
53 (except for those released by calls to release_value)
54 This is so they can be freed after each command. */
56 static value all_values
;
58 /* Allocate a value that has the correct length for type TYPE. */
66 check_stub_type (type
);
68 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
));
69 VALUE_NEXT (val
) = all_values
;
71 VALUE_TYPE (val
) = type
;
72 VALUE_LVAL (val
) = not_lval
;
73 VALUE_ADDRESS (val
) = 0;
74 VALUE_FRAME (val
) = 0;
75 VALUE_OFFSET (val
) = 0;
76 VALUE_BITPOS (val
) = 0;
77 VALUE_BITSIZE (val
) = 0;
78 VALUE_REPEATED (val
) = 0;
79 VALUE_REPETITIONS (val
) = 0;
80 VALUE_REGNO (val
) = -1;
82 VALUE_OPTIMIZED_OUT (val
) = 0;
86 /* Allocate a value that has the correct length
87 for COUNT repetitions type TYPE. */
90 allocate_repeat_value (type
, count
)
96 val
= (value
) xmalloc (sizeof (struct value
) + TYPE_LENGTH (type
) * count
);
97 VALUE_NEXT (val
) = all_values
;
99 VALUE_TYPE (val
) = type
;
100 VALUE_LVAL (val
) = not_lval
;
101 VALUE_ADDRESS (val
) = 0;
102 VALUE_FRAME (val
) = 0;
103 VALUE_OFFSET (val
) = 0;
104 VALUE_BITPOS (val
) = 0;
105 VALUE_BITSIZE (val
) = 0;
106 VALUE_REPEATED (val
) = 1;
107 VALUE_REPETITIONS (val
) = count
;
108 VALUE_REGNO (val
) = -1;
109 VALUE_LAZY (val
) = 0;
110 VALUE_OPTIMIZED_OUT (val
) = 0;
114 /* Free all the values that have been allocated (except for those released).
115 Called after each command, successful or not. */
120 register value val
, next
;
122 for (val
= all_values
; val
; val
= next
)
124 next
= VALUE_NEXT (val
);
131 /* Remove VAL from the chain all_values
132 so it will not be freed automatically. */
140 if (all_values
== val
)
142 all_values
= val
->next
;
146 for (v
= all_values
; v
; v
= v
->next
)
156 /* Return a copy of the value ARG.
157 It contains the same contents, for same memory address,
158 but it's a different block of storage. */
165 register struct type
*type
= VALUE_TYPE (arg
);
166 if (VALUE_REPEATED (arg
))
167 val
= allocate_repeat_value (type
, VALUE_REPETITIONS (arg
));
169 val
= allocate_value (type
);
170 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
171 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
172 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
173 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
174 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
175 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
176 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
177 if (!VALUE_LAZY (val
))
179 bcopy (VALUE_CONTENTS_RAW (arg
), VALUE_CONTENTS_RAW (val
),
180 TYPE_LENGTH (VALUE_TYPE (arg
))
181 * (VALUE_REPEATED (arg
) ? VALUE_REPETITIONS (arg
) : 1));
186 /* Access to the value history. */
188 /* Record a new value in the value history.
189 Returns the absolute history index of the entry.
190 Result of -1 indicates the value was not saved; otherwise it is the
191 value history index of this new item. */
194 record_latest_value (val
)
199 /* Check error now if about to store an invalid float. We return -1
200 to the caller, but allow them to continue, e.g. to print it as "Nan". */
201 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FLT
) {
202 (void) unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &i
);
203 if (i
) return -1; /* Indicate value not saved in history */
206 /* Here we treat value_history_count as origin-zero
207 and applying to the value being stored now. */
209 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
212 register struct value_history_chunk
*new
213 = (struct value_history_chunk
*)
214 xmalloc (sizeof (struct value_history_chunk
));
215 bzero (new->values
, sizeof new->values
);
216 new->next
= value_history_chain
;
217 value_history_chain
= new;
220 value_history_chain
->values
[i
] = val
;
223 /* Now we regard value_history_count as origin-one
224 and applying to the value just stored. */
226 return ++value_history_count
;
229 /* Return a copy of the value in the history with sequence number NUM. */
232 access_value_history (num
)
235 register struct value_history_chunk
*chunk
;
237 register int absnum
= num
;
240 absnum
+= value_history_count
;
245 error ("The history is empty.");
247 error ("There is only one value in the history.");
249 error ("History does not go back to $$%d.", -num
);
251 if (absnum
> value_history_count
)
252 error ("History has not yet reached $%d.", absnum
);
256 /* Now absnum is always absolute and origin zero. */
258 chunk
= value_history_chain
;
259 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
263 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
266 /* Clear the value history entirely.
267 Must be done when new symbol tables are loaded,
268 because the type pointers become invalid. */
271 clear_value_history ()
273 register struct value_history_chunk
*next
;
277 while (value_history_chain
)
279 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
280 if (val
= value_history_chain
->values
[i
])
282 next
= value_history_chain
->next
;
283 free (value_history_chain
);
284 value_history_chain
= next
;
286 value_history_count
= 0;
290 show_values (num_exp
, from_tty
)
300 if (num_exp
[0] == '+' && num_exp
[1] == '\0')
301 /* "info history +" should print from the stored position. */
304 /* "info history <exp>" should print around value number <exp>. */
305 num
= parse_and_eval_address (num_exp
) - 5;
309 /* "info history" means print the last 10 values. */
310 num
= value_history_count
- 9;
316 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
318 val
= access_value_history (i
);
319 printf_filtered ("$%d = ", i
);
320 value_print (val
, stdout
, 0, Val_pretty_default
);
321 printf_filtered ("\n");
324 /* The next "info history +" should start after what we just printed. */
327 /* Hitting just return after this command should do the same thing as
328 "info history +". If num_exp is null, this is unnecessary, since
329 "info history +" is not useful after "info history". */
330 if (from_tty
&& num_exp
)
337 /* Internal variables. These are variables within the debugger
338 that hold values assigned by debugger commands.
339 The user refers to them with a '$' prefix
340 that does not appear in the variable names stored internally. */
342 static struct internalvar
*internalvars
;
344 /* Look up an internal variable with name NAME. NAME should not
345 normally include a dollar sign.
347 If the specified internal variable does not exist,
348 one is created, with a void value. */
351 lookup_internalvar (name
)
354 register struct internalvar
*var
;
356 for (var
= internalvars
; var
; var
= var
->next
)
357 if (!strcmp (var
->name
, name
))
360 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
361 var
->name
= concat (name
, "", "");
362 var
->value
= allocate_value (builtin_type_void
);
363 release_value (var
->value
);
364 var
->next
= internalvars
;
370 value_of_internalvar (var
)
371 struct internalvar
*var
;
375 #ifdef IS_TRAPPED_INTERNALVAR
376 if (IS_TRAPPED_INTERNALVAR (var
->name
))
377 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
380 val
= value_copy (var
->value
);
381 if (VALUE_LAZY (val
))
382 value_fetch_lazy (val
);
383 VALUE_LVAL (val
) = lval_internalvar
;
384 VALUE_INTERNALVAR (val
) = var
;
389 set_internalvar_component (var
, offset
, bitpos
, bitsize
, newval
)
390 struct internalvar
*var
;
391 int offset
, bitpos
, bitsize
;
394 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
396 #ifdef IS_TRAPPED_INTERNALVAR
397 if (IS_TRAPPED_INTERNALVAR (var
->name
))
398 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
402 modify_field (addr
, (int) value_as_long (newval
),
405 bcopy (VALUE_CONTENTS (newval
), addr
,
406 TYPE_LENGTH (VALUE_TYPE (newval
)));
410 set_internalvar (var
, val
)
411 struct internalvar
*var
;
414 #ifdef IS_TRAPPED_INTERNALVAR
415 if (IS_TRAPPED_INTERNALVAR (var
->name
))
416 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
420 var
->value
= value_copy (val
);
421 release_value (var
->value
);
425 internalvar_name (var
)
426 struct internalvar
*var
;
431 /* Free all internalvars. Done when new symtabs are loaded,
432 because that makes the values invalid. */
435 clear_internalvars ()
437 register struct internalvar
*var
;
442 internalvars
= var
->next
;
452 register struct internalvar
*var
;
455 for (var
= internalvars
; var
; var
= var
->next
)
457 #ifdef IS_TRAPPED_INTERNALVAR
458 if (IS_TRAPPED_INTERNALVAR (var
->name
))
465 printf ("Debugger convenience variables:\n\n");
469 printf ("$%s = ", var
->name
);
470 value_print (var
->value
, stdout
, 0, Val_pretty_default
);
474 printf ("No debugger convenience variables now defined.\n\
475 Convenience variables have names starting with \"$\";\n\
476 use \"set\" as in \"set $foo = 5\" to define them.\n");
479 /* Extract a value as a C number (either long or double).
480 Knows how to convert fixed values to double, or
481 floating values to long.
482 Does not deallocate the value. */
488 /* This coerces arrays and functions, which is necessary (e.g.
489 in disassemble_command). It also dereferences references, which
490 I suspect is the most logical thing to do. */
491 if (TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_ENUM
)
493 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
497 value_as_double (val
)
503 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
505 error ("Invalid floating value found in program.");
509 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
510 as a long, or as a double, assuming the raw data is described
511 by type TYPE. Knows how to convert different sizes of values
512 and can convert between fixed and floating point. We don't assume
513 any alignment for the raw data. Return value is in host byte order.
515 If you want functions and arrays to be coerced to pointers, and
516 references to be dereferenced, call value_as_long() instead.
518 C++: It is assumed that the front-end has taken care of
519 all matters concerning pointers to members. A pointer
520 to member which reaches here is considered to be equivalent
521 to an INT (or some size). After all, it is only an offset. */
524 unpack_long (type
, valaddr
)
528 register enum type_code code
= TYPE_CODE (type
);
529 register int len
= TYPE_LENGTH (type
);
530 register int nosign
= TYPE_UNSIGNED (type
);
532 if (code
== TYPE_CODE_ENUM
)
533 code
= TYPE_CODE_INT
;
534 if (code
== TYPE_CODE_FLT
)
536 if (len
== sizeof (float))
539 bcopy (valaddr
, &retval
, sizeof (retval
));
540 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
544 if (len
== sizeof (double))
547 bcopy (valaddr
, &retval
, sizeof (retval
));
548 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
553 error ("Unexpected type of floating point number.");
556 else if (code
== TYPE_CODE_INT
&& nosign
)
558 if (len
== sizeof (char))
560 unsigned char retval
= * (unsigned char *) valaddr
;
561 /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
565 if (len
== sizeof (short))
567 unsigned short retval
;
568 bcopy (valaddr
, &retval
, sizeof (retval
));
569 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
573 if (len
== sizeof (int))
576 bcopy (valaddr
, &retval
, sizeof (retval
));
577 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
581 if (len
== sizeof (long))
583 unsigned long retval
;
584 bcopy (valaddr
, &retval
, sizeof (retval
));
585 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
589 if (len
== sizeof (long long))
591 unsigned long long retval
;
592 bcopy (valaddr
, &retval
, sizeof (retval
));
593 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
599 error ("That operation is not possible on an integer of that size.");
602 else if (code
== TYPE_CODE_INT
)
604 if (len
== sizeof (char))
607 bcopy (valaddr
, &retval
, sizeof (retval
));
608 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
612 if (len
== sizeof (short))
615 bcopy (valaddr
, &retval
, sizeof (retval
));
616 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
620 if (len
== sizeof (int))
623 bcopy (valaddr
, &retval
, sizeof (retval
));
624 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
628 if (len
== sizeof (long))
631 bcopy (valaddr
, &retval
, sizeof (retval
));
632 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
637 if (len
== sizeof (long long))
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_PTR
651 || code
== TYPE_CODE_REF
)
653 if (len
== sizeof (char *))
656 bcopy (valaddr
, &retval
, sizeof (retval
));
657 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
661 else if (code
== TYPE_CODE_MEMBER
)
662 error ("not implemented: member types in unpack_long");
664 error ("Value not integer or pointer.");
665 return 0; /* For lint -- never reached */
668 /* Return a double value from the specified type and address.
669 INVP points to an int which is set to 0 for valid value,
670 1 for invalid value (bad float format). In either case,
671 the returned double is OK to use. Argument is in target
672 format, result is in host format. */
675 unpack_double (type
, valaddr
, invp
)
680 register enum type_code code
= TYPE_CODE (type
);
681 register int len
= TYPE_LENGTH (type
);
682 register int nosign
= TYPE_UNSIGNED (type
);
684 *invp
= 0; /* Assume valid. */
685 if (code
== TYPE_CODE_FLT
)
687 if (INVALID_FLOAT (valaddr
, len
))
690 return 1.234567891011121314;
693 if (len
== sizeof (float))
696 bcopy (valaddr
, &retval
, sizeof (retval
));
697 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
701 if (len
== sizeof (double))
704 bcopy (valaddr
, &retval
, sizeof (retval
));
705 SWAP_TARGET_AND_HOST (&retval
, sizeof (retval
));
710 error ("Unexpected type of floating point number.");
714 /* Unsigned -- be sure we compensate for signed LONGEST. */
716 return (unsigned long long) unpack_long (type
, valaddr
);
718 return (unsigned long ) unpack_long (type
, valaddr
);
721 /* Signed -- we are OK with unpack_long. */
722 return unpack_long (type
, valaddr
);
726 /* Given a value ARG1 (offset by OFFSET bytes)
727 of a struct or union type ARG_TYPE,
728 extract and return the value of one of its fields.
729 FIELDNO says which field.
731 For C++, must also be able to return values from static fields */
734 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
737 register int fieldno
;
738 register struct type
*arg_type
;
741 register struct type
*type
;
743 check_stub_type (arg_type
);
744 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
746 /* Handle packed fields */
748 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
749 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
751 v
= value_from_long (type
,
752 unpack_field_as_long (arg_type
,
753 VALUE_CONTENTS (arg1
),
755 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
756 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
760 v
= allocate_value (type
);
761 if (VALUE_LAZY (arg1
))
764 bcopy (VALUE_CONTENTS_RAW (arg1
) + offset
,
765 VALUE_CONTENTS_RAW (v
),
768 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
769 if (VALUE_LVAL (arg1
) == lval_internalvar
)
770 VALUE_LVAL (v
) = lval_internalvar_component
;
771 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
772 VALUE_OFFSET (v
) = offset
+ VALUE_OFFSET (arg1
);
776 /* Given a value ARG1 of a struct or union type,
777 extract and return the value of one of its fields.
778 FIELDNO says which field.
780 For C++, must also be able to return values from static fields */
783 value_field (arg1
, fieldno
)
785 register int fieldno
;
787 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
791 value_fn_field (arg1
, fieldno
, subfieldno
)
793 register int fieldno
;
797 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (VALUE_TYPE (arg1
), fieldno
);
798 register struct type
*type
= TYPE_FN_FIELD_TYPE (f
, subfieldno
);
801 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, subfieldno
),
802 0, VAR_NAMESPACE
, 0, NULL
);
803 if (! sym
) error ("Internal error: could not find physical method named %s",
804 TYPE_FN_FIELD_PHYSNAME (f
, subfieldno
));
806 v
= allocate_value (type
);
807 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
808 VALUE_TYPE (v
) = type
;
812 /* Return a virtual function as a value.
813 ARG1 is the object which provides the virtual function
814 table pointer. ARG1 is side-effected in calling this function.
815 F is the list of member functions which contains the desired virtual
817 J is an index into F which provides the desired virtual function. */
819 value_virtual_fn_field (arg1
, f
, j
)
824 /* First, get the virtual function table pointer. That comes
825 with a strange type, so cast it to type `pointer to long' (which
826 should serve just fine as a function type). Then, index into
827 the table, and convert final value to appropriate function type. */
828 value entry
, vfn
, vtbl
;
829 value vi
= value_from_long (builtin_type_int
,
830 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
831 struct type
*context
= lookup_pointer_type (TYPE_FN_FIELD_FCONTEXT (f
, j
));
832 if (TYPE_TARGET_TYPE (context
) != VALUE_TYPE (arg1
))
833 arg1
= value_ind (value_cast (context
, value_addr (arg1
)));
835 context
= VALUE_TYPE (arg1
);
837 /* This type may have been defined before its virtual function table
838 was. If so, fill in the virtual function table entry for the
840 if (TYPE_VPTR_FIELDNO (context
) < 0)
841 TYPE_VPTR_FIELDNO (context
)
842 = fill_in_vptr_fieldno (context
);
844 /* The virtual function table is now an array of structures
845 which have the form { int16 offset, delta; void *pfn; }. */
846 vtbl
= value_ind (value_field (arg1
, TYPE_VPTR_FIELDNO (context
)));
848 /* Index into the virtual function table. This is hard-coded because
849 looking up a field is not cheap, and it may be important to save
850 time, e.g. if the user has set a conditional breakpoint calling
851 a virtual function. */
852 entry
= value_subscript (vtbl
, vi
);
854 /* Move the `this' pointer according to the virtual function table. */
855 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
856 if (! VALUE_LAZY (arg1
))
858 VALUE_LAZY (arg1
) = 1;
859 value_fetch_lazy (arg1
);
862 vfn
= value_field (entry
, 2);
863 /* Reinstantiate the function pointer with the correct type. */
864 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
869 /* The value of a static class member does not depend
870 on its instance, only on its type. If FIELDNO >= 0,
871 then fieldno is a valid field number and is used directly.
872 Otherwise, FIELDNAME is the name of the field we are
873 searching for. If it is not a static field name, an
874 error is signaled. TYPE is the type in which we look for the
875 static field member. */
877 value_static_field (type
, fieldname
, fieldno
)
878 register struct type
*type
;
880 register int fieldno
;
888 register struct type
*t
= type
;
889 /* Look for static field. */
893 for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); i
--)
894 if (! strcmp (TYPE_FIELD_NAME (t
, i
), fieldname
))
896 if (TYPE_FIELD_STATIC (t
, i
))
902 error ("field `%s' is not static");
904 /* FIXME: this does not recursively check multiple baseclasses. */
905 t
= TYPE_N_BASECLASSES (t
) ? TYPE_BASECLASS (t
, 0) : 0;
910 if (destructor_name_p (fieldname
, t
))
911 error ("Cannot get value of destructor");
917 for (i
= TYPE_NFN_FIELDS (t
) - 1; i
>= 0; i
--)
919 if (! strcmp (TYPE_FN_FIELDLIST_NAME (t
, i
), fieldname
))
921 error ("Cannot get value of method \"%s\"", fieldname
);
924 t
= TYPE_N_BASECLASSES (t
) ? TYPE_BASECLASS (t
, 0) : 0;
926 error("there is no field named %s", fieldname
);
930 phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
931 sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
932 if (! sym
) error ("Internal error: could not find physical static variable named %s", phys_name
);
934 type
= TYPE_FIELD_TYPE (type
, fieldno
);
935 v
= value_at (type
, (CORE_ADDR
)SYMBOL_BLOCK_VALUE (sym
));
939 /* Compute the address of the baseclass which is
940 the INDEXth baseclass of TYPE. The TYPE base
941 of the object is at VALADDR. */
944 baseclass_addr (type
, index
, valaddr
, valuep
)
950 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
952 if (BASETYPE_VIA_VIRTUAL (type
, index
))
954 /* Must hunt for the pointer to this virtual baseclass. */
955 register int i
, len
= TYPE_NFIELDS (type
);
956 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
957 char *vbase_name
, *type_name
= type_name_no_tag (basetype
);
959 if (TYPE_MAIN_VARIANT (basetype
))
960 basetype
= TYPE_MAIN_VARIANT (basetype
);
962 vbase_name
= (char *)alloca (strlen (type_name
) + 8);
963 sprintf (vbase_name
, "_vb$%s", type_name
);
964 /* First look for the virtual baseclass pointer
966 for (i
= n_baseclasses
; i
< len
; i
++)
968 if (! strcmp (vbase_name
, TYPE_FIELD_NAME (type
, i
)))
970 value v
= value_at (basetype
,
971 unpack_long (TYPE_FIELD_TYPE (type
, i
),
972 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8)));
975 return (char *) VALUE_CONTENTS (v
);
978 /* Not in the fields, so try looking through the baseclasses. */
979 for (i
= index
+1; i
< n_baseclasses
; i
++)
983 baddr
= baseclass_addr (type
, i
, valaddr
, valuep
);
993 /* Baseclass is easily computed. */
996 return valaddr
+ TYPE_BASECLASS_BITPOS (type
, index
) / 8;
999 /* Ugly hack to convert method stubs into method types.
1001 He ain't kiddin'. This demangles the name of the method into a string
1002 including argument types, parses out each argument type, generates
1003 a string casting a zero to that type, evaluates the string, and stuffs
1004 the resulting type into an argtype vector!!! Then it knows the type
1005 of the whole function (including argument types for overloading),
1006 which info used to be in the stab's but was removed to hack back
1007 the space required for them. */
1009 check_stub_method (type
, i
, j
)
1013 extern char *gdb_mangle_typename (), *strchr ();
1014 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1015 char *inner_name
= gdb_mangle_typename (type
);
1017 = (char *)xmalloc (strlen (TYPE_FN_FIELDLIST_NAME (type
, i
))
1018 + strlen (inner_name
)
1019 + strlen (TYPE_FN_FIELD_PHYSNAME (f
, j
))
1021 char *demangled_name
, *cplus_demangle ();
1022 char *argtypetext
, *p
;
1023 int depth
= 0, argcount
= 1;
1024 struct type
**argtypes
;
1026 strcpy (mangled_name
, TYPE_FN_FIELDLIST_NAME (type
, i
));
1027 strcat (mangled_name
, inner_name
);
1028 strcat (mangled_name
, TYPE_FN_FIELD_PHYSNAME (f
, j
));
1029 demangled_name
= cplus_demangle (mangled_name
, 0);
1031 /* Now, read in the parameters that define this type. */
1032 argtypetext
= strchr (demangled_name
, '(') + 1;
1040 else if (*p
== ',' && depth
== 0)
1045 /* We need one more slot for the void [...] or NULL [end of arglist] */
1046 argtypes
= (struct type
**)xmalloc ((argcount
+1) * sizeof (struct type
*));
1048 argtypes
[0] = lookup_pointer_type (type
);
1051 if (*p
!= ')') /* () means no args, skip while */
1060 if (depth
<= 0 && (*p
== ',' || *p
== ')'))
1062 char *tmp
= (char *)alloca (p
- argtypetext
+ 4);
1065 bcopy (argtypetext
, tmp
+1, p
- argtypetext
);
1066 tmp
[p
-argtypetext
+1] = ')';
1067 tmp
[p
-argtypetext
+2] = '0';
1068 tmp
[p
-argtypetext
+3] = '\0';
1069 val
= parse_and_eval (tmp
);
1070 argtypes
[argcount
] = VALUE_TYPE (val
);
1072 argtypetext
= p
+ 1;
1078 if (p
[-2] != '.') /* ... */
1079 argtypes
[argcount
] = builtin_type_void
; /* Ellist terminator */
1081 argtypes
[argcount
] = NULL
; /* List terminator */
1083 free (demangled_name
);
1084 smash_to_method_type (TYPE_FN_FIELD_TYPE (f
, j
), type
,
1085 TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1087 TYPE_FN_FIELD_PHYSNAME (f
, j
) = mangled_name
;
1088 TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, j
)) &= ~TYPE_FLAG_STUB
;
1092 unpack_field_as_long (type
, valaddr
, fieldno
)
1098 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1099 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1101 bcopy (valaddr
+ bitpos
/ 8, &val
, sizeof val
);
1102 SWAP_TARGET_AND_HOST (&val
, sizeof val
);
1104 /* Extracting bits depends on endianness of the machine. */
1105 #ifdef BITS_BIG_ENDIAN
1106 val
= val
>> (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1108 val
= val
>> (bitpos
% 8);
1111 val
&= (1 << bitsize
) - 1;
1115 /* Modify the value of a bitfield. ADDR points to a block of memory in
1116 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1117 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1118 indicate which bits (in target bit order) comprise the bitfield. */
1121 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1124 int bitpos
, bitsize
;
1128 /* Reject values too big to fit in the field in question.
1129 Otherwise adjoining fields may be corrupted. */
1130 if (fieldval
& ~((1<<bitsize
)-1))
1131 error ("Value %d does not fit in %d bits.", fieldval
, bitsize
);
1133 bcopy (addr
, &oword
, sizeof oword
);
1134 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To host format */
1136 /* Shifting for bit field depends on endianness of the target machine. */
1137 #ifdef BITS_BIG_ENDIAN
1138 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1141 oword
&= ~(((1 << bitsize
) - 1) << bitpos
);
1142 oword
|= fieldval
<< bitpos
;
1144 SWAP_TARGET_AND_HOST (&oword
, sizeof oword
); /* To target format */
1145 bcopy (&oword
, addr
, sizeof oword
);
1148 /* Convert C numbers into newly allocated values */
1151 value_from_long (type
, num
)
1153 register LONGEST num
;
1155 register value val
= allocate_value (type
);
1156 register enum type_code code
= TYPE_CODE (type
);
1157 register int len
= TYPE_LENGTH (type
);
1159 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_ENUM
)
1161 if (len
== sizeof (char))
1162 * (char *) VALUE_CONTENTS_RAW (val
) = num
;
1163 else if (len
== sizeof (short))
1164 * (short *) VALUE_CONTENTS_RAW (val
) = num
;
1165 else if (len
== sizeof (int))
1166 * (int *) VALUE_CONTENTS_RAW (val
) = num
;
1167 else if (len
== sizeof (long))
1168 * (long *) VALUE_CONTENTS_RAW (val
) = num
;
1170 else if (len
== sizeof (long long))
1171 * (long long *) VALUE_CONTENTS_RAW (val
) = num
;
1174 error ("Integer type encountered with unexpected data length.");
1177 error ("Unexpected type encountered for integer constant.");
1179 /* num was in host byte order. So now put the value's contents
1180 into target byte order. */
1181 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1187 value_from_double (type
, num
)
1191 register value val
= allocate_value (type
);
1192 register enum type_code code
= TYPE_CODE (type
);
1193 register int len
= TYPE_LENGTH (type
);
1195 if (code
== TYPE_CODE_FLT
)
1197 if (len
== sizeof (float))
1198 * (float *) VALUE_CONTENTS_RAW (val
) = num
;
1199 else if (len
== sizeof (double))
1200 * (double *) VALUE_CONTENTS_RAW (val
) = num
;
1202 error ("Floating type encountered with unexpected data length.");
1205 error ("Unexpected type encountered for floating constant.");
1207 /* num was in host byte order. So now put the value's contents
1208 into target byte order. */
1209 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val
), len
);
1214 /* Deal with the value that is "about to be returned". */
1216 /* Return the value that a function returning now
1217 would be returning to its caller, assuming its type is VALTYPE.
1218 RETBUF is where we look for what ought to be the contents
1219 of the registers (in raw form). This is because it is often
1220 desirable to restore old values to those registers
1221 after saving the contents of interest, and then call
1222 this function using the saved values.
1223 struct_return is non-zero when the function in question is
1224 using the structure return conventions on the machine in question;
1225 0 when it is using the value returning conventions (this often
1226 means returning pointer to where structure is vs. returning value). */
1229 value_being_returned (valtype
, retbuf
, struct_return
)
1230 register struct type
*valtype
;
1231 char retbuf
[REGISTER_BYTES
];
1238 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1239 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1240 if (struct_return
) {
1241 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1243 error ("Function return value unknown");
1244 return value_at (valtype
, addr
);
1248 val
= allocate_value (valtype
);
1249 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1254 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1255 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1256 and TYPE is the type (which is known to be struct, union or array).
1258 On most machines, the struct convention is used unless we are
1259 using gcc and the type is of a special size. */
1260 #if !defined (USE_STRUCT_CONVENTION)
1261 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1262 (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \
1263 || TYPE_LENGTH (value_type) == 2 \
1264 || TYPE_LENGTH (value_type) == 4 \
1265 || TYPE_LENGTH (value_type) == 8 \
1270 /* Return true if the function specified is using the structure returning
1271 convention on this machine to return arguments, or 0 if it is using
1272 the value returning convention. FUNCTION is the value representing
1273 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1274 is the type returned by the function. GCC_P is nonzero if compiled
1278 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1281 struct type
*value_type
;
1285 register enum type_code code
= TYPE_CODE (value_type
);
1287 if (code
== TYPE_CODE_ERROR
)
1288 error ("Function return type unknown.");
1290 if (code
== TYPE_CODE_STRUCT
||
1291 code
== TYPE_CODE_UNION
||
1292 code
== TYPE_CODE_ARRAY
)
1293 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1298 /* Store VAL so it will be returned if a function returns now.
1299 Does not verify that VAL's type matches what the current
1300 function wants to return. */
1303 set_return_value (val
)
1306 register enum type_code code
= TYPE_CODE (VALUE_TYPE (val
));
1310 if (code
== TYPE_CODE_ERROR
)
1311 error ("Function return type unknown.");
1313 if (code
== TYPE_CODE_STRUCT
1314 || code
== TYPE_CODE_UNION
)
1315 error ("Specifying a struct or union return value is not supported.");
1317 /* FIXME, this is bogus. We don't know what the return conventions
1318 are, or how values should be promoted.... */
1319 if (code
== TYPE_CODE_FLT
)
1321 dbuf
= value_as_double (val
);
1323 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&dbuf
);
1327 lbuf
= value_as_long (val
);
1328 STORE_RETURN_VALUE (VALUE_TYPE (val
), (char *)&lbuf
);
1333 _initialize_values ()
1335 add_cmd ("convenience", no_class
, show_convenience
,
1336 "Debugger convenience (\"$foo\") variables.\n\
1337 These variables are created when you assign them values;\n\
1338 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1339 A few convenience variables are given values automatically:\n\
1340 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1341 \"$__\" holds the contents of the last address examined with \"x\".",
1344 add_cmd ("values", no_class
, show_values
,
1345 "Elements of value history around item number IDX (or last ten).",