1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
2 Copyright 1986, 87, 89, 91, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
36 /* Prototypes for exported functions. */
38 void _initialize_values (void);
40 /* Prototypes for local functions. */
42 static value_ptr
value_headof (value_ptr
, struct type
*, struct type
*);
44 static void show_values (char *, int);
46 static void show_convenience (char *, int);
48 static int vb_match (struct type
*, int, struct type
*);
50 /* The value-history records all the values printed
51 by print commands during this session. Each chunk
52 records 60 consecutive values. The first chunk on
53 the chain records the most recent values.
54 The total number of values is in value_history_count. */
56 #define VALUE_HISTORY_CHUNK 60
58 struct value_history_chunk
60 struct value_history_chunk
*next
;
61 value_ptr values
[VALUE_HISTORY_CHUNK
];
64 /* Chain of chunks now in use. */
66 static struct value_history_chunk
*value_history_chain
;
68 static int value_history_count
; /* Abs number of last entry stored */
70 /* List of all value objects currently allocated
71 (except for those released by calls to release_value)
72 This is so they can be freed after each command. */
74 static value_ptr all_values
;
76 /* Allocate a value that has the correct length for type TYPE. */
82 register value_ptr val
;
83 struct type
*atype
= check_typedef (type
);
85 val
= (struct value
*) xmalloc (sizeof (struct value
) + TYPE_LENGTH (atype
));
86 VALUE_NEXT (val
) = all_values
;
88 VALUE_TYPE (val
) = type
;
89 VALUE_ENCLOSING_TYPE (val
) = type
;
90 VALUE_LVAL (val
) = not_lval
;
91 VALUE_ADDRESS (val
) = 0;
92 VALUE_FRAME (val
) = 0;
93 VALUE_OFFSET (val
) = 0;
94 VALUE_BITPOS (val
) = 0;
95 VALUE_BITSIZE (val
) = 0;
96 VALUE_REGNO (val
) = -1;
98 VALUE_OPTIMIZED_OUT (val
) = 0;
99 VALUE_BFD_SECTION (val
) = NULL
;
100 VALUE_EMBEDDED_OFFSET (val
) = 0;
101 VALUE_POINTED_TO_OFFSET (val
) = 0;
106 /* Allocate a value that has the correct length
107 for COUNT repetitions type TYPE. */
110 allocate_repeat_value (type
, count
)
114 int low_bound
= current_language
->string_lower_bound
; /* ??? */
115 /* FIXME-type-allocation: need a way to free this type when we are
117 struct type
*range_type
118 = create_range_type ((struct type
*) NULL
, builtin_type_int
,
119 low_bound
, count
+ low_bound
- 1);
120 /* FIXME-type-allocation: need a way to free this type when we are
122 return allocate_value (create_array_type ((struct type
*) NULL
,
126 /* Return a mark in the value chain. All values allocated after the
127 mark is obtained (except for those released) are subject to being freed
128 if a subsequent value_free_to_mark is passed the mark. */
135 /* Free all values allocated since MARK was obtained by value_mark
136 (except for those released). */
138 value_free_to_mark (mark
)
143 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
145 next
= VALUE_NEXT (val
);
151 /* Free all the values that have been allocated (except for those released).
152 Called after each command, successful or not. */
157 register value_ptr val
, next
;
159 for (val
= all_values
; val
; val
= next
)
161 next
= VALUE_NEXT (val
);
168 /* Remove VAL from the chain all_values
169 so it will not be freed automatically. */
173 register value_ptr val
;
175 register value_ptr v
;
177 if (all_values
== val
)
179 all_values
= val
->next
;
183 for (v
= all_values
; v
; v
= v
->next
)
193 /* Release all values up to mark */
195 value_release_to_mark (mark
)
200 for (val
= next
= all_values
; next
; next
= VALUE_NEXT (next
))
201 if (VALUE_NEXT (next
) == mark
)
203 all_values
= VALUE_NEXT (next
);
204 VALUE_NEXT (next
) = 0;
211 /* Return a copy of the value ARG.
212 It contains the same contents, for same memory address,
213 but it's a different block of storage. */
219 register struct type
*encl_type
= VALUE_ENCLOSING_TYPE (arg
);
220 register value_ptr val
= allocate_value (encl_type
);
221 VALUE_TYPE (val
) = VALUE_TYPE (arg
);
222 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
223 VALUE_ADDRESS (val
) = VALUE_ADDRESS (arg
);
224 VALUE_OFFSET (val
) = VALUE_OFFSET (arg
);
225 VALUE_BITPOS (val
) = VALUE_BITPOS (arg
);
226 VALUE_BITSIZE (val
) = VALUE_BITSIZE (arg
);
227 VALUE_FRAME (val
) = VALUE_FRAME (arg
);
228 VALUE_REGNO (val
) = VALUE_REGNO (arg
);
229 VALUE_LAZY (val
) = VALUE_LAZY (arg
);
230 VALUE_OPTIMIZED_OUT (val
) = VALUE_OPTIMIZED_OUT (arg
);
231 VALUE_EMBEDDED_OFFSET (val
) = VALUE_EMBEDDED_OFFSET (arg
);
232 VALUE_POINTED_TO_OFFSET (val
) = VALUE_POINTED_TO_OFFSET (arg
);
233 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (arg
);
234 val
->modifiable
= arg
->modifiable
;
235 if (!VALUE_LAZY (val
))
237 memcpy (VALUE_CONTENTS_ALL_RAW (val
), VALUE_CONTENTS_ALL_RAW (arg
),
238 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
)));
244 /* Access to the value history. */
246 /* Record a new value in the value history.
247 Returns the absolute history index of the entry.
248 Result of -1 indicates the value was not saved; otherwise it is the
249 value history index of this new item. */
252 record_latest_value (val
)
257 /* We don't want this value to have anything to do with the inferior anymore.
258 In particular, "set $1 = 50" should not affect the variable from which
259 the value was taken, and fast watchpoints should be able to assume that
260 a value on the value history never changes. */
261 if (VALUE_LAZY (val
))
262 value_fetch_lazy (val
);
263 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
264 from. This is a bit dubious, because then *&$1 does not just return $1
265 but the current contents of that location. c'est la vie... */
269 /* Here we treat value_history_count as origin-zero
270 and applying to the value being stored now. */
272 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
275 register struct value_history_chunk
*new
276 = (struct value_history_chunk
*)
277 xmalloc (sizeof (struct value_history_chunk
));
278 memset (new->values
, 0, sizeof new->values
);
279 new->next
= value_history_chain
;
280 value_history_chain
= new;
283 value_history_chain
->values
[i
] = val
;
285 /* Now we regard value_history_count as origin-one
286 and applying to the value just stored. */
288 return ++value_history_count
;
291 /* Return a copy of the value in the history with sequence number NUM. */
294 access_value_history (num
)
297 register struct value_history_chunk
*chunk
;
299 register int absnum
= num
;
302 absnum
+= value_history_count
;
307 error ("The history is empty.");
309 error ("There is only one value in the history.");
311 error ("History does not go back to $$%d.", -num
);
313 if (absnum
> value_history_count
)
314 error ("History has not yet reached $%d.", absnum
);
318 /* Now absnum is always absolute and origin zero. */
320 chunk
= value_history_chain
;
321 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
- absnum
/ VALUE_HISTORY_CHUNK
;
325 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
328 /* Clear the value history entirely.
329 Must be done when new symbol tables are loaded,
330 because the type pointers become invalid. */
333 clear_value_history ()
335 register struct value_history_chunk
*next
;
337 register value_ptr val
;
339 while (value_history_chain
)
341 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
342 if ((val
= value_history_chain
->values
[i
]) != NULL
)
344 next
= value_history_chain
->next
;
345 free ((PTR
) value_history_chain
);
346 value_history_chain
= next
;
348 value_history_count
= 0;
352 show_values (num_exp
, from_tty
)
357 register value_ptr val
;
362 /* "info history +" should print from the stored position.
363 "info history <exp>" should print around value number <exp>. */
364 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
365 num
= parse_and_eval_address (num_exp
) - 5;
369 /* "info history" means print the last 10 values. */
370 num
= value_history_count
- 9;
376 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
378 val
= access_value_history (i
);
379 printf_filtered ("$%d = ", i
);
380 value_print (val
, gdb_stdout
, 0, Val_pretty_default
);
381 printf_filtered ("\n");
384 /* The next "info history +" should start after what we just printed. */
387 /* Hitting just return after this command should do the same thing as
388 "info history +". If num_exp is null, this is unnecessary, since
389 "info history +" is not useful after "info history". */
390 if (from_tty
&& num_exp
)
397 /* Internal variables. These are variables within the debugger
398 that hold values assigned by debugger commands.
399 The user refers to them with a '$' prefix
400 that does not appear in the variable names stored internally. */
402 static struct internalvar
*internalvars
;
404 /* Look up an internal variable with name NAME. NAME should not
405 normally include a dollar sign.
407 If the specified internal variable does not exist,
408 one is created, with a void value. */
411 lookup_internalvar (name
)
414 register struct internalvar
*var
;
416 for (var
= internalvars
; var
; var
= var
->next
)
417 if (STREQ (var
->name
, name
))
420 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
421 var
->name
= concat (name
, NULL
);
422 var
->value
= allocate_value (builtin_type_void
);
423 release_value (var
->value
);
424 var
->next
= internalvars
;
430 value_of_internalvar (var
)
431 struct internalvar
*var
;
433 register value_ptr val
;
435 #ifdef IS_TRAPPED_INTERNALVAR
436 if (IS_TRAPPED_INTERNALVAR (var
->name
))
437 return VALUE_OF_TRAPPED_INTERNALVAR (var
);
440 val
= value_copy (var
->value
);
441 if (VALUE_LAZY (val
))
442 value_fetch_lazy (val
);
443 VALUE_LVAL (val
) = lval_internalvar
;
444 VALUE_INTERNALVAR (val
) = var
;
449 set_internalvar_component (var
, offset
, bitpos
, bitsize
, newval
)
450 struct internalvar
*var
;
451 int offset
, bitpos
, bitsize
;
454 register char *addr
= VALUE_CONTENTS (var
->value
) + offset
;
456 #ifdef IS_TRAPPED_INTERNALVAR
457 if (IS_TRAPPED_INTERNALVAR (var
->name
))
458 SET_TRAPPED_INTERNALVAR (var
, newval
, bitpos
, bitsize
, offset
);
462 modify_field (addr
, value_as_long (newval
),
465 memcpy (addr
, VALUE_CONTENTS (newval
), TYPE_LENGTH (VALUE_TYPE (newval
)));
469 set_internalvar (var
, val
)
470 struct internalvar
*var
;
475 #ifdef IS_TRAPPED_INTERNALVAR
476 if (IS_TRAPPED_INTERNALVAR (var
->name
))
477 SET_TRAPPED_INTERNALVAR (var
, val
, 0, 0, 0);
480 newval
= value_copy (val
);
481 newval
->modifiable
= 1;
483 /* Force the value to be fetched from the target now, to avoid problems
484 later when this internalvar is referenced and the target is gone or
486 if (VALUE_LAZY (newval
))
487 value_fetch_lazy (newval
);
489 /* Begin code which must not call error(). If var->value points to
490 something free'd, an error() obviously leaves a dangling pointer.
491 But we also get a danling pointer if var->value points to
492 something in the value chain (i.e., before release_value is
493 called), because after the error free_all_values will get called before
495 free ((PTR
) var
->value
);
497 release_value (newval
);
498 /* End code which must not call error(). */
502 internalvar_name (var
)
503 struct internalvar
*var
;
508 /* Free all internalvars. Done when new symtabs are loaded,
509 because that makes the values invalid. */
512 clear_internalvars ()
514 register struct internalvar
*var
;
519 internalvars
= var
->next
;
520 free ((PTR
) var
->name
);
521 free ((PTR
) var
->value
);
527 show_convenience (ignore
, from_tty
)
531 register struct internalvar
*var
;
534 for (var
= internalvars
; var
; var
= var
->next
)
536 #ifdef IS_TRAPPED_INTERNALVAR
537 if (IS_TRAPPED_INTERNALVAR (var
->name
))
544 printf_filtered ("$%s = ", var
->name
);
545 value_print (var
->value
, gdb_stdout
, 0, Val_pretty_default
);
546 printf_filtered ("\n");
549 printf_unfiltered ("No debugger convenience variables now defined.\n\
550 Convenience variables have names starting with \"$\";\n\
551 use \"set\" as in \"set $foo = 5\" to define them.\n");
554 /* Extract a value as a C number (either long or double).
555 Knows how to convert fixed values to double, or
556 floating values to long.
557 Does not deallocate the value. */
561 register value_ptr val
;
563 /* This coerces arrays and functions, which is necessary (e.g.
564 in disassemble_command). It also dereferences references, which
565 I suspect is the most logical thing to do. */
567 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
571 value_as_double (val
)
572 register value_ptr val
;
577 foo
= unpack_double (VALUE_TYPE (val
), VALUE_CONTENTS (val
), &inv
);
579 error ("Invalid floating value found in program.");
582 /* Extract a value as a C pointer. Does not deallocate the value.
583 Note that val's type may not actually be a pointer; value_as_long
584 handles all the cases. */
586 value_as_pointer (val
)
589 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
590 whether we want this to be true eventually. */
592 /* ADDR_BITS_REMOVE is wrong if we are being called for a
593 non-address (e.g. argument to "signal", "info break", etc.), or
594 for pointers to char, in which the low bits *are* significant. */
595 return ADDR_BITS_REMOVE (value_as_long (val
));
597 return value_as_long (val
);
601 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
602 as a long, or as a double, assuming the raw data is described
603 by type TYPE. Knows how to convert different sizes of values
604 and can convert between fixed and floating point. We don't assume
605 any alignment for the raw data. Return value is in host byte order.
607 If you want functions and arrays to be coerced to pointers, and
608 references to be dereferenced, call value_as_long() instead.
610 C++: It is assumed that the front-end has taken care of
611 all matters concerning pointers to members. A pointer
612 to member which reaches here is considered to be equivalent
613 to an INT (or some size). After all, it is only an offset. */
616 unpack_long (type
, valaddr
)
620 register enum type_code code
= TYPE_CODE (type
);
621 register int len
= TYPE_LENGTH (type
);
622 register int nosign
= TYPE_UNSIGNED (type
);
624 if (current_language
->la_language
== language_scm
625 && is_scmvalue_type (type
))
626 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
630 case TYPE_CODE_TYPEDEF
:
631 return unpack_long (check_typedef (type
), valaddr
);
636 case TYPE_CODE_RANGE
:
638 return extract_unsigned_integer (valaddr
, len
);
640 return extract_signed_integer (valaddr
, len
);
643 return extract_floating (valaddr
, len
);
647 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
648 whether we want this to be true eventually. */
649 if (GDB_TARGET_IS_D10V
651 return D10V_MAKE_DADDR (extract_address (valaddr
, len
));
652 return extract_typed_address (valaddr
, type
);
654 case TYPE_CODE_MEMBER
:
655 error ("not implemented: member types in unpack_long");
658 error ("Value can't be converted to integer.");
660 return 0; /* Placate lint. */
663 /* Return a double value from the specified type and address.
664 INVP points to an int which is set to 0 for valid value,
665 1 for invalid value (bad float format). In either case,
666 the returned double is OK to use. Argument is in target
667 format, result is in host format. */
670 unpack_double (type
, valaddr
, invp
)
679 *invp
= 0; /* Assume valid. */
680 CHECK_TYPEDEF (type
);
681 code
= TYPE_CODE (type
);
682 len
= TYPE_LENGTH (type
);
683 nosign
= TYPE_UNSIGNED (type
);
684 if (code
== TYPE_CODE_FLT
)
687 if (INVALID_FLOAT (valaddr
, len
))
690 return 1.234567891011121314;
693 return extract_floating (valaddr
, len
);
697 /* Unsigned -- be sure we compensate for signed LONGEST. */
698 #if !defined (_MSC_VER) || (_MSC_VER > 900)
699 return (ULONGEST
) unpack_long (type
, valaddr
);
701 /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */
702 return (LONGEST
) unpack_long (type
, valaddr
);
703 #endif /* _MSC_VER */
707 /* Signed -- we are OK with unpack_long. */
708 return unpack_long (type
, valaddr
);
712 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
713 as a CORE_ADDR, assuming the raw data is described by type TYPE.
714 We don't assume any alignment for the raw data. Return value is in
717 If you want functions and arrays to be coerced to pointers, and
718 references to be dereferenced, call value_as_pointer() instead.
720 C++: It is assumed that the front-end has taken care of
721 all matters concerning pointers to members. A pointer
722 to member which reaches here is considered to be equivalent
723 to an INT (or some size). After all, it is only an offset. */
726 unpack_pointer (type
, valaddr
)
730 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
731 whether we want this to be true eventually. */
732 return unpack_long (type
, valaddr
);
736 /* Get the value of the FIELDN'th field (which must be static) of TYPE. */
739 value_static_field (type
, fieldno
)
745 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
747 addr
= TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
);
752 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
753 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
756 /* With some compilers, e.g. HP aCC, static data members are reported
757 as non-debuggable symbols */
758 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
763 addr
= SYMBOL_VALUE_ADDRESS (msym
);
764 sect
= SYMBOL_BFD_SECTION (msym
);
769 addr
= SYMBOL_VALUE_ADDRESS (sym
);
770 sect
= SYMBOL_BFD_SECTION (sym
);
772 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
), addr
);
774 return value_at (TYPE_FIELD_TYPE (type
, fieldno
), addr
, sect
);
777 /* Given a value ARG1 (offset by OFFSET bytes)
778 of a struct or union type ARG_TYPE,
779 extract and return the value of one of its (non-static) fields.
780 FIELDNO says which field. */
783 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
784 register value_ptr arg1
;
786 register int fieldno
;
787 register struct type
*arg_type
;
789 register value_ptr v
;
790 register struct type
*type
;
792 CHECK_TYPEDEF (arg_type
);
793 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
795 /* Handle packed fields */
797 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
799 v
= value_from_longest (type
,
800 unpack_field_as_long (arg_type
,
801 VALUE_CONTENTS (arg1
)
804 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
805 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
806 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
807 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
809 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
811 /* This field is actually a base subobject, so preserve the
812 entire object's contents for later references to virtual
814 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
815 VALUE_TYPE (v
) = arg_type
;
816 if (VALUE_LAZY (arg1
))
819 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
820 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
821 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
);
822 VALUE_EMBEDDED_OFFSET (v
)
824 VALUE_EMBEDDED_OFFSET (arg1
) +
825 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
829 /* Plain old data member */
830 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
831 v
= allocate_value (type
);
832 if (VALUE_LAZY (arg1
))
835 memcpy (VALUE_CONTENTS_RAW (v
),
836 VALUE_CONTENTS_RAW (arg1
) + offset
,
838 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
;
840 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
841 if (VALUE_LVAL (arg1
) == lval_internalvar
)
842 VALUE_LVAL (v
) = lval_internalvar_component
;
843 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
844 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
845 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
849 /* Given a value ARG1 of a struct or union type,
850 extract and return the value of one of its (non-static) fields.
851 FIELDNO says which field. */
854 value_field (arg1
, fieldno
)
855 register value_ptr arg1
;
856 register int fieldno
;
858 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
861 /* Return a non-virtual function as a value.
862 F is the list of member functions which contains the desired method.
863 J is an index into F which provides the desired method. */
866 value_fn_field (arg1p
, f
, j
, type
, offset
)
873 register value_ptr v
;
874 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
877 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
878 0, VAR_NAMESPACE
, 0, NULL
);
882 error ("Internal error: could not find physical method named %s",
883 TYPE_FN_FIELD_PHYSNAME (f, j));
886 v
= allocate_value (ftype
);
887 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
888 VALUE_TYPE (v
) = ftype
;
892 if (type
!= VALUE_TYPE (*arg1p
))
893 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
894 value_addr (*arg1p
)));
896 /* Move the `this' pointer according to the offset.
897 VALUE_OFFSET (*arg1p) += offset;
904 /* Return a virtual function as a value.
905 ARG1 is the object which provides the virtual function
906 table pointer. *ARG1P is side-effected in calling this function.
907 F is the list of member functions which contains the desired virtual
909 J is an index into F which provides the desired virtual function.
911 TYPE is the type in which F is located. */
913 value_virtual_fn_field (arg1p
, f
, j
, type
, offset
)
920 value_ptr arg1
= *arg1p
;
921 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
923 if (TYPE_HAS_VTABLE (type
))
925 /* Deal with HP/Taligent runtime model for virtual functions */
927 value_ptr argp
; /* arg1 cast to base */
928 CORE_ADDR coreptr
; /* pointer to target address */
929 int class_index
; /* which class segment pointer to use */
930 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
); /* method type */
932 argp
= value_cast (type
, *arg1p
);
934 if (VALUE_ADDRESS (argp
) == 0)
935 error ("Address of object is null; object may not have been created.");
937 /* pai: FIXME -- 32x64 possible problem? */
938 /* First word (4 bytes) in object layout is the vtable pointer */
939 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (argp
)); /* pai: (temp) */
940 /* + offset + VALUE_EMBEDDED_OFFSET (argp)); */
943 error ("Virtual table pointer is null for object; object may not have been created.");
946 * FIXME: The code here currently handles only
947 * the non-RRBC case of the Taligent/HP runtime spec; when RRBC
948 * is introduced, the condition for the "if" below will have to
949 * be changed to be a test for the RRBC case. */
953 /* Non-RRBC case; the virtual function pointers are stored at fixed
954 * offsets in the virtual table. */
956 /* Retrieve the offset in the virtual table from the debug
957 * info. The offset of the vfunc's entry is in words from
958 * the beginning of the vtable; but first we have to adjust
959 * by HP_ACC_VFUNC_START to account for other entries */
961 /* pai: FIXME: 32x64 problem here, a word may be 8 bytes in
962 * which case the multiplier should be 8 and values should be long */
963 vp
= value_at (builtin_type_int
,
964 coreptr
+ 4 * (TYPE_FN_FIELD_VOFFSET (f
, j
) + HP_ACC_VFUNC_START
), NULL
);
966 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
967 /* coreptr now contains the address of the virtual function */
968 /* (Actually, it contains the pointer to the plabel for the function. */
972 /* RRBC case; the virtual function pointers are found by double
973 * indirection through the class segment tables. */
975 /* Choose class segment depending on type we were passed */
976 class_index
= class_index_in_primary_list (type
);
978 /* Find class segment pointer. These are in the vtable slots after
979 * some other entries, so adjust by HP_ACC_VFUNC_START for that. */
980 /* pai: FIXME 32x64 problem here, if words are 8 bytes long
981 * the multiplier below has to be 8 and value should be long. */
982 vp
= value_at (builtin_type_int
,
983 coreptr
+ 4 * (HP_ACC_VFUNC_START
+ class_index
), NULL
);
984 /* Indirect once more, offset by function index */
985 /* pai: FIXME 32x64 problem here, again multiplier could be 8 and value long */
986 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
) + 4 * TYPE_FN_FIELD_VOFFSET (f
, j
));
987 vp
= value_at (builtin_type_int
, coreptr
, NULL
);
988 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
990 /* coreptr now contains the address of the virtual function */
991 /* (Actually, it contains the pointer to the plabel for the function.) */
996 error ("Address of virtual function is null; error in virtual table?");
998 /* Wrap this addr in a value and return pointer */
999 vp
= allocate_value (ftype
);
1000 VALUE_TYPE (vp
) = ftype
;
1001 VALUE_ADDRESS (vp
) = coreptr
;
1003 /* pai: (temp) do we need the value_ind stuff in value_fn_field? */
1007 { /* Not using HP/Taligent runtime conventions; so try to
1008 * use g++ conventions for virtual table */
1010 struct type
*entry_type
;
1011 /* First, get the virtual function table pointer. That comes
1012 with a strange type, so cast it to type `pointer to long' (which
1013 should serve just fine as a function type). Then, index into
1014 the table, and convert final value to appropriate function type. */
1015 value_ptr entry
, vfn
, vtbl
;
1016 value_ptr vi
= value_from_longest (builtin_type_int
,
1017 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
1018 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
1019 struct type
*context
;
1020 if (fcontext
== NULL
)
1021 /* We don't have an fcontext (e.g. the program was compiled with
1022 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
1023 This won't work right for multiple inheritance, but at least we
1024 should do as well as GDB 3.x did. */
1025 fcontext
= TYPE_VPTR_BASETYPE (type
);
1026 context
= lookup_pointer_type (fcontext
);
1027 /* Now context is a pointer to the basetype containing the vtbl. */
1028 if (TYPE_TARGET_TYPE (context
) != type1
)
1030 value_ptr tmp
= value_cast (context
, value_addr (arg1
));
1031 VALUE_POINTED_TO_OFFSET (tmp
) = 0;
1032 arg1
= value_ind (tmp
);
1033 type1
= check_typedef (VALUE_TYPE (arg1
));
1037 /* Now context is the basetype containing the vtbl. */
1039 /* This type may have been defined before its virtual function table
1040 was. If so, fill in the virtual function table entry for the
1042 if (TYPE_VPTR_FIELDNO (context
) < 0)
1043 fill_in_vptr_fieldno (context
);
1045 /* The virtual function table is now an array of structures
1046 which have the form { int16 offset, delta; void *pfn; }. */
1047 vtbl
= value_primitive_field (arg1
, 0, TYPE_VPTR_FIELDNO (context
),
1048 TYPE_VPTR_BASETYPE (context
));
1050 /* With older versions of g++, the vtbl field pointed to an array
1051 of structures. Nowadays it points directly to the structure. */
1052 if (TYPE_CODE (VALUE_TYPE (vtbl
)) == TYPE_CODE_PTR
1053 && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (vtbl
))) == TYPE_CODE_ARRAY
)
1055 /* Handle the case where the vtbl field points to an
1056 array of structures. */
1057 vtbl
= value_ind (vtbl
);
1059 /* Index into the virtual function table. This is hard-coded because
1060 looking up a field is not cheap, and it may be important to save
1061 time, e.g. if the user has set a conditional breakpoint calling
1062 a virtual function. */
1063 entry
= value_subscript (vtbl
, vi
);
1067 /* Handle the case where the vtbl field points directly to a structure. */
1068 vtbl
= value_add (vtbl
, vi
);
1069 entry
= value_ind (vtbl
);
1072 entry_type
= check_typedef (VALUE_TYPE (entry
));
1074 if (TYPE_CODE (entry_type
) == TYPE_CODE_STRUCT
)
1076 /* Move the `this' pointer according to the virtual function table. */
1077 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
1079 if (!VALUE_LAZY (arg1
))
1081 VALUE_LAZY (arg1
) = 1;
1082 value_fetch_lazy (arg1
);
1085 vfn
= value_field (entry
, 2);
1087 else if (TYPE_CODE (entry_type
) == TYPE_CODE_PTR
)
1090 error ("I'm confused: virtual function table has bad type");
1091 /* Reinstantiate the function pointer with the correct type. */
1092 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
1099 /* ARG is a pointer to an object we know to be at least
1100 a DTYPE. BTYPE is the most derived basetype that has
1101 already been searched (and need not be searched again).
1102 After looking at the vtables between BTYPE and DTYPE,
1103 return the most derived type we find. The caller must
1104 be satisfied when the return value == DTYPE.
1106 FIXME-tiemann: should work with dossier entries as well.
1107 NOTICE - djb: I see no good reason at all to keep this function now that
1108 we have RTTI support. It's used in literally one place, and it's
1109 hard to keep this function up to date when it's purpose is served
1110 by value_rtti_type efficiently.
1111 Consider it gone for 5.1. */
1114 value_headof (in_arg
, btype
, dtype
)
1116 struct type
*btype
, *dtype
;
1118 /* First collect the vtables we must look at for this object. */
1119 value_ptr arg
, vtbl
;
1121 char *demangled_name
;
1122 struct minimal_symbol
*msymbol
;
1124 btype
= TYPE_VPTR_BASETYPE (dtype
);
1125 CHECK_TYPEDEF (btype
);
1128 arg
= value_cast (lookup_pointer_type (btype
), arg
);
1129 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_REF
)
1132 * Copy the value, but change the type from (T&) to (T*).
1133 * We keep the same location information, which is efficient,
1134 * and allows &(&X) to get the location containing the reference.
1136 arg
= value_copy (arg
);
1137 VALUE_TYPE (arg
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg
)));
1139 if (VALUE_ADDRESS(value_field (value_ind(arg
), TYPE_VPTR_FIELDNO (btype
)))==0)
1142 vtbl
= value_ind (value_field (value_ind (arg
), TYPE_VPTR_FIELDNO (btype
)));
1143 /* Turn vtable into typeinfo function */
1144 VALUE_OFFSET(vtbl
)+=4;
1146 msymbol
= lookup_minimal_symbol_by_pc ( value_as_pointer(value_ind(vtbl
)) );
1148 || (demangled_name
= SYMBOL_NAME (msymbol
)) == NULL
)
1150 /* If we expected to find a vtable, but did not, let the user
1151 know that we aren't happy, but don't throw an error.
1152 FIXME: there has to be a better way to do this. */
1153 struct type
*error_type
= (struct type
*) xmalloc (sizeof (struct type
));
1154 memcpy (error_type
, VALUE_TYPE (in_arg
), sizeof (struct type
));
1155 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
1156 VALUE_TYPE (in_arg
) = error_type
;
1159 demangled_name
= cplus_demangle(demangled_name
,DMGL_ANSI
);
1160 *(strchr (demangled_name
, ' ')) = '\0';
1162 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1164 error ("could not find type declaration for `%s'", demangled_name
);
1167 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1171 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1172 function tables, probe ARG's tables (including the vtables
1173 of its baseclasses) to figure out the most derived type that ARG
1174 could actually be a pointer to. */
1177 value_from_vtable_info (arg
, type
)
1181 /* Take care of preliminaries. */
1182 if (TYPE_VPTR_FIELDNO (type
) < 0)
1183 fill_in_vptr_fieldno (type
);
1184 if (TYPE_VPTR_FIELDNO (type
) < 0)
1187 return value_headof (arg
, 0, type
);
1190 /* Return true if the INDEXth field of TYPE is a virtual baseclass
1191 pointer which is for the base class whose type is BASECLASS. */
1194 vb_match (type
, index
, basetype
)
1197 struct type
*basetype
;
1199 struct type
*fieldtype
;
1200 char *name
= TYPE_FIELD_NAME (type
, index
);
1201 char *field_class_name
= NULL
;
1205 /* gcc 2.4 uses _vb$. */
1206 if (name
[1] == 'v' && name
[2] == 'b' && is_cplus_marker (name
[3]))
1207 field_class_name
= name
+ 4;
1208 /* gcc 2.5 will use __vb_. */
1209 if (name
[1] == '_' && name
[2] == 'v' && name
[3] == 'b' && name
[4] == '_')
1210 field_class_name
= name
+ 5;
1212 if (field_class_name
== NULL
)
1213 /* This field is not a virtual base class pointer. */
1216 /* It's a virtual baseclass pointer, now we just need to find out whether
1217 it is for this baseclass. */
1218 fieldtype
= TYPE_FIELD_TYPE (type
, index
);
1219 if (fieldtype
== NULL
1220 || TYPE_CODE (fieldtype
) != TYPE_CODE_PTR
)
1221 /* "Can't happen". */
1224 /* What we check for is that either the types are equal (needed for
1225 nameless types) or have the same name. This is ugly, and a more
1226 elegant solution should be devised (which would probably just push
1227 the ugliness into symbol reading unless we change the stabs format). */
1228 if (TYPE_TARGET_TYPE (fieldtype
) == basetype
)
1231 if (TYPE_NAME (basetype
) != NULL
1232 && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
)) != NULL
1233 && STREQ (TYPE_NAME (basetype
),
1234 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
))))
1239 /* Compute the offset of the baseclass which is
1240 the INDEXth baseclass of class TYPE,
1241 for value at VALADDR (in host) at ADDRESS (in target).
1242 The result is the offset of the baseclass value relative
1243 to (the address of)(ARG) + OFFSET.
1245 -1 is returned on error. */
1248 baseclass_offset (type
, index
, valaddr
, address
)
1254 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1256 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1258 /* Must hunt for the pointer to this virtual baseclass. */
1259 register int i
, len
= TYPE_NFIELDS (type
);
1260 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1262 /* First look for the virtual baseclass pointer
1264 for (i
= n_baseclasses
; i
< len
; i
++)
1266 if (vb_match (type
, i
, basetype
))
1269 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1270 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1272 return addr
- (LONGEST
) address
;
1275 /* Not in the fields, so try looking through the baseclasses. */
1276 for (i
= index
+ 1; i
< n_baseclasses
; i
++)
1279 baseclass_offset (type
, i
, valaddr
, address
);
1287 /* Baseclass is easily computed. */
1288 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1291 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1294 Extracting bits depends on endianness of the machine. Compute the
1295 number of least significant bits to discard. For big endian machines,
1296 we compute the total number of bits in the anonymous object, subtract
1297 off the bit count from the MSB of the object to the MSB of the
1298 bitfield, then the size of the bitfield, which leaves the LSB discard
1299 count. For little endian machines, the discard count is simply the
1300 number of bits from the LSB of the anonymous object to the LSB of the
1303 If the field is signed, we also do sign extension. */
1306 unpack_field_as_long (type
, valaddr
, fieldno
)
1313 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1314 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1316 struct type
*field_type
;
1318 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1319 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1320 CHECK_TYPEDEF (field_type
);
1322 /* Extract bits. See comment above. */
1324 if (BITS_BIG_ENDIAN
)
1325 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1327 lsbcount
= (bitpos
% 8);
1330 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1331 If the field is signed, and is negative, then sign extend. */
1333 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1335 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1337 if (!TYPE_UNSIGNED (field_type
))
1339 if (val
& (valmask
^ (valmask
>> 1)))
1348 /* Modify the value of a bitfield. ADDR points to a block of memory in
1349 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1350 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1351 indicate which bits (in target bit order) comprise the bitfield. */
1354 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1357 int bitpos
, bitsize
;
1361 /* If a negative fieldval fits in the field in question, chop
1362 off the sign extension bits. */
1363 if (bitsize
< (8 * (int) sizeof (fieldval
))
1364 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1365 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1367 /* Warn if value is too big to fit in the field in question. */
1368 if (bitsize
< (8 * (int) sizeof (fieldval
))
1369 && 0 != (fieldval
& ~((1 << bitsize
) - 1)))
1371 /* FIXME: would like to include fieldval in the message, but
1372 we don't have a sprintf_longest. */
1373 warning ("Value does not fit in %d bits.", bitsize
);
1375 /* Truncate it, otherwise adjoining fields may be corrupted. */
1376 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1379 oword
= extract_signed_integer (addr
, sizeof oword
);
1381 /* Shifting for bit field depends on endianness of the target machine. */
1382 if (BITS_BIG_ENDIAN
)
1383 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1385 /* Mask out old value, while avoiding shifts >= size of oword */
1386 if (bitsize
< 8 * (int) sizeof (oword
))
1387 oword
&= ~(((((ULONGEST
) 1) << bitsize
) - 1) << bitpos
);
1389 oword
&= ~((~(ULONGEST
) 0) << bitpos
);
1390 oword
|= fieldval
<< bitpos
;
1392 store_signed_integer (addr
, sizeof oword
, oword
);
1395 /* Convert C numbers into newly allocated values */
1398 value_from_longest (type
, num
)
1400 register LONGEST num
;
1402 register value_ptr val
= allocate_value (type
);
1403 register enum type_code code
;
1406 code
= TYPE_CODE (type
);
1407 len
= TYPE_LENGTH (type
);
1411 case TYPE_CODE_TYPEDEF
:
1412 type
= check_typedef (type
);
1415 case TYPE_CODE_CHAR
:
1416 case TYPE_CODE_ENUM
:
1417 case TYPE_CODE_BOOL
:
1418 case TYPE_CODE_RANGE
:
1419 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1424 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1428 error ("Unexpected type (%d) encountered for integer constant.", code
);
1434 /* Create a value representing a pointer of type TYPE to the address
1437 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1439 value_ptr val
= allocate_value (type
);
1440 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1445 /* Create a value for a string constant to be stored locally
1446 (not in the inferior's memory space, but in GDB memory).
1447 This is analogous to value_from_longest, which also does not
1448 use inferior memory. String shall NOT contain embedded nulls. */
1451 value_from_string (ptr
)
1455 int len
= strlen (ptr
);
1456 int lowbound
= current_language
->string_lower_bound
;
1457 struct type
*rangetype
=
1458 create_range_type ((struct type
*) NULL
,
1460 lowbound
, len
+ lowbound
- 1);
1461 struct type
*stringtype
=
1462 create_array_type ((struct type
*) NULL
,
1463 *current_language
->string_char_type
,
1466 val
= allocate_value (stringtype
);
1467 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1472 value_from_double (type
, num
)
1476 register value_ptr val
= allocate_value (type
);
1477 struct type
*base_type
= check_typedef (type
);
1478 register enum type_code code
= TYPE_CODE (base_type
);
1479 register int len
= TYPE_LENGTH (base_type
);
1481 if (code
== TYPE_CODE_FLT
)
1483 store_floating (VALUE_CONTENTS_RAW (val
), len
, num
);
1486 error ("Unexpected type encountered for floating constant.");
1491 /* Deal with the value that is "about to be returned". */
1493 /* Return the value that a function returning now
1494 would be returning to its caller, assuming its type is VALTYPE.
1495 RETBUF is where we look for what ought to be the contents
1496 of the registers (in raw form). This is because it is often
1497 desirable to restore old values to those registers
1498 after saving the contents of interest, and then call
1499 this function using the saved values.
1500 struct_return is non-zero when the function in question is
1501 using the structure return conventions on the machine in question;
1502 0 when it is using the value returning conventions (this often
1503 means returning pointer to where structure is vs. returning value). */
1506 value_being_returned (valtype
, retbuf
, struct_return
)
1507 register struct type
*valtype
;
1512 register value_ptr val
;
1515 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1516 if (EXTRACT_STRUCT_VALUE_ADDRESS_P
)
1519 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1521 error ("Function return value unknown");
1522 return value_at (valtype
, addr
, NULL
);
1525 val
= allocate_value (valtype
);
1526 CHECK_TYPEDEF (valtype
);
1527 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1532 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1533 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1534 and TYPE is the type (which is known to be struct, union or array).
1536 On most machines, the struct convention is used unless we are
1537 using gcc and the type is of a special size. */
1538 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1539 native compiler. GCC 2.3.3 was the last release that did it the
1540 old way. Since gcc2_compiled was not changed, we have no
1541 way to correctly win in all cases, so we just do the right thing
1542 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1543 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1544 would cause more chaos than dealing with some struct returns being
1548 generic_use_struct_convention (gcc_p
, value_type
)
1550 struct type
*value_type
;
1552 return !((gcc_p
== 1)
1553 && (TYPE_LENGTH (value_type
) == 1
1554 || TYPE_LENGTH (value_type
) == 2
1555 || TYPE_LENGTH (value_type
) == 4
1556 || TYPE_LENGTH (value_type
) == 8));
1559 #ifndef USE_STRUCT_CONVENTION
1560 #define USE_STRUCT_CONVENTION(gcc_p,type) generic_use_struct_convention (gcc_p, type)
1564 /* Return true if the function specified is using the structure returning
1565 convention on this machine to return arguments, or 0 if it is using
1566 the value returning convention. FUNCTION is the value representing
1567 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1568 is the type returned by the function. GCC_P is nonzero if compiled
1572 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1575 struct type
*value_type
;
1579 register enum type_code code
= TYPE_CODE (value_type
);
1581 if (code
== TYPE_CODE_ERROR
)
1582 error ("Function return type unknown.");
1584 if (code
== TYPE_CODE_STRUCT
1585 || code
== TYPE_CODE_UNION
1586 || code
== TYPE_CODE_ARRAY
1587 || RETURN_VALUE_ON_STACK (value_type
))
1588 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1593 /* Store VAL so it will be returned if a function returns now.
1594 Does not verify that VAL's type matches what the current
1595 function wants to return. */
1598 set_return_value (val
)
1601 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1602 register enum type_code code
= TYPE_CODE (type
);
1604 if (code
== TYPE_CODE_ERROR
)
1605 error ("Function return type unknown.");
1607 if (code
== TYPE_CODE_STRUCT
1608 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1609 error ("GDB does not support specifying a struct or union return value.");
1611 STORE_RETURN_VALUE (type
, VALUE_CONTENTS (val
));
1615 _initialize_values ()
1617 add_cmd ("convenience", no_class
, show_convenience
,
1618 "Debugger convenience (\"$foo\") variables.\n\
1619 These variables are created when you assign them values;\n\
1620 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1621 A few convenience variables are given values automatically:\n\
1622 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1623 \"$__\" holds the contents of the last address examined with \"x\".",
1626 add_cmd ("values", no_class
, show_values
,
1627 "Elements of value history around item number IDX (or last ten).",