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
));
598 /* In converting VAL to an address (CORE_ADDR), any small integers
599 are first cast to a generic pointer. The function unpack_long
600 will then correctly convert that pointer into a canonical address
601 (using POINTER_TO_ADDRESS).
603 Without the cast, the MIPS gets: 0xa0000000 -> (unsigned int)
604 0xa0000000 -> (LONGEST) 0x00000000a0000000
606 With the cast, the MIPS gets: 0xa0000000 -> (unsigned int)
607 0xa0000000 -> (void*) 0xa0000000 -> (LONGEST) 0xffffffffa0000000.
609 If the user specifies an integer that is larger than the target
610 pointer type, it is assumed that it was intentional and the value
611 is converted directly into an ADDRESS. This ensures that no
612 information is discarded.
614 NOTE: The cast operation may eventualy be converted into a TARGET
615 method (see POINTER_TO_ADDRESS() and ADDRESS_TO_POINTER()) so
616 that the TARGET ISA/ABI can apply an arbitrary conversion.
618 NOTE: In pure harvard architectures function and data pointers
619 can be different and may require different integer to pointer
621 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
622 && TYPE_LENGTH (VALUE_TYPE (val
)) <= TYPE_LENGTH (builtin_type_ptr
))
624 val
= value_cast (builtin_type_ptr
, val
);
626 return unpack_long (VALUE_TYPE (val
), VALUE_CONTENTS (val
));
630 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
631 as a long, or as a double, assuming the raw data is described
632 by type TYPE. Knows how to convert different sizes of values
633 and can convert between fixed and floating point. We don't assume
634 any alignment for the raw data. Return value is in host byte order.
636 If you want functions and arrays to be coerced to pointers, and
637 references to be dereferenced, call value_as_long() instead.
639 C++: It is assumed that the front-end has taken care of
640 all matters concerning pointers to members. A pointer
641 to member which reaches here is considered to be equivalent
642 to an INT (or some size). After all, it is only an offset. */
645 unpack_long (type
, valaddr
)
649 register enum type_code code
= TYPE_CODE (type
);
650 register int len
= TYPE_LENGTH (type
);
651 register int nosign
= TYPE_UNSIGNED (type
);
653 if (current_language
->la_language
== language_scm
654 && is_scmvalue_type (type
))
655 return scm_unpack (type
, valaddr
, TYPE_CODE_INT
);
659 case TYPE_CODE_TYPEDEF
:
660 return unpack_long (check_typedef (type
), valaddr
);
665 case TYPE_CODE_RANGE
:
667 return extract_unsigned_integer (valaddr
, len
);
669 return extract_signed_integer (valaddr
, len
);
672 return extract_floating (valaddr
, len
);
676 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
677 whether we want this to be true eventually. */
678 if (GDB_TARGET_IS_D10V
680 return D10V_MAKE_DADDR (extract_address (valaddr
, len
));
681 return extract_typed_address (valaddr
, type
);
683 case TYPE_CODE_MEMBER
:
684 error ("not implemented: member types in unpack_long");
687 error ("Value can't be converted to integer.");
689 return 0; /* Placate lint. */
692 /* Return a double value from the specified type and address.
693 INVP points to an int which is set to 0 for valid value,
694 1 for invalid value (bad float format). In either case,
695 the returned double is OK to use. Argument is in target
696 format, result is in host format. */
699 unpack_double (type
, valaddr
, invp
)
708 *invp
= 0; /* Assume valid. */
709 CHECK_TYPEDEF (type
);
710 code
= TYPE_CODE (type
);
711 len
= TYPE_LENGTH (type
);
712 nosign
= TYPE_UNSIGNED (type
);
713 if (code
== TYPE_CODE_FLT
)
716 if (INVALID_FLOAT (valaddr
, len
))
719 return 1.234567891011121314;
722 return extract_floating (valaddr
, len
);
726 /* Unsigned -- be sure we compensate for signed LONGEST. */
727 #if !defined (_MSC_VER) || (_MSC_VER > 900)
728 return (ULONGEST
) unpack_long (type
, valaddr
);
730 /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */
731 return (LONGEST
) unpack_long (type
, valaddr
);
732 #endif /* _MSC_VER */
736 /* Signed -- we are OK with unpack_long. */
737 return unpack_long (type
, valaddr
);
741 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
742 as a CORE_ADDR, assuming the raw data is described by type TYPE.
743 We don't assume any alignment for the raw data. Return value is in
746 If you want functions and arrays to be coerced to pointers, and
747 references to be dereferenced, call value_as_pointer() instead.
749 C++: It is assumed that the front-end has taken care of
750 all matters concerning pointers to members. A pointer
751 to member which reaches here is considered to be equivalent
752 to an INT (or some size). After all, it is only an offset. */
755 unpack_pointer (type
, valaddr
)
759 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
760 whether we want this to be true eventually. */
761 return unpack_long (type
, valaddr
);
765 /* Get the value of the FIELDN'th field (which must be static) of TYPE. */
768 value_static_field (type
, fieldno
)
774 if (TYPE_FIELD_STATIC_HAS_ADDR (type
, fieldno
))
776 addr
= TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
);
781 char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
782 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_NAMESPACE
, 0, NULL
);
785 /* With some compilers, e.g. HP aCC, static data members are reported
786 as non-debuggable symbols */
787 struct minimal_symbol
*msym
= lookup_minimal_symbol (phys_name
, NULL
, NULL
);
792 addr
= SYMBOL_VALUE_ADDRESS (msym
);
793 sect
= SYMBOL_BFD_SECTION (msym
);
798 addr
= SYMBOL_VALUE_ADDRESS (sym
);
799 sect
= SYMBOL_BFD_SECTION (sym
);
801 SET_FIELD_PHYSADDR (TYPE_FIELD (type
, fieldno
), addr
);
803 return value_at (TYPE_FIELD_TYPE (type
, fieldno
), addr
, sect
);
806 /* Given a value ARG1 (offset by OFFSET bytes)
807 of a struct or union type ARG_TYPE,
808 extract and return the value of one of its (non-static) fields.
809 FIELDNO says which field. */
812 value_primitive_field (arg1
, offset
, fieldno
, arg_type
)
813 register value_ptr arg1
;
815 register int fieldno
;
816 register struct type
*arg_type
;
818 register value_ptr v
;
819 register struct type
*type
;
821 CHECK_TYPEDEF (arg_type
);
822 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
824 /* Handle packed fields */
826 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
828 v
= value_from_longest (type
,
829 unpack_field_as_long (arg_type
,
830 VALUE_CONTENTS (arg1
)
833 VALUE_BITPOS (v
) = TYPE_FIELD_BITPOS (arg_type
, fieldno
) % 8;
834 VALUE_BITSIZE (v
) = TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
835 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
836 + TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
838 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
840 /* This field is actually a base subobject, so preserve the
841 entire object's contents for later references to virtual
843 v
= allocate_value (VALUE_ENCLOSING_TYPE (arg1
));
844 VALUE_TYPE (v
) = arg_type
;
845 if (VALUE_LAZY (arg1
))
848 memcpy (VALUE_CONTENTS_ALL_RAW (v
), VALUE_CONTENTS_ALL_RAW (arg1
),
849 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1
)));
850 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
);
851 VALUE_EMBEDDED_OFFSET (v
)
853 VALUE_EMBEDDED_OFFSET (arg1
) +
854 TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
858 /* Plain old data member */
859 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
860 v
= allocate_value (type
);
861 if (VALUE_LAZY (arg1
))
864 memcpy (VALUE_CONTENTS_RAW (v
),
865 VALUE_CONTENTS_RAW (arg1
) + offset
,
867 VALUE_OFFSET (v
) = VALUE_OFFSET (arg1
) + offset
;
869 VALUE_LVAL (v
) = VALUE_LVAL (arg1
);
870 if (VALUE_LVAL (arg1
) == lval_internalvar
)
871 VALUE_LVAL (v
) = lval_internalvar_component
;
872 VALUE_ADDRESS (v
) = VALUE_ADDRESS (arg1
);
873 VALUE_REGNO (v
) = VALUE_REGNO (arg1
);
874 /* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
875 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
879 /* Given a value ARG1 of a struct or union type,
880 extract and return the value of one of its (non-static) fields.
881 FIELDNO says which field. */
884 value_field (arg1
, fieldno
)
885 register value_ptr arg1
;
886 register int fieldno
;
888 return value_primitive_field (arg1
, 0, fieldno
, VALUE_TYPE (arg1
));
891 /* Return a non-virtual function as a value.
892 F is the list of member functions which contains the desired method.
893 J is an index into F which provides the desired method. */
896 value_fn_field (arg1p
, f
, j
, type
, offset
)
903 register value_ptr v
;
904 register struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
907 sym
= lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, j
),
908 0, VAR_NAMESPACE
, 0, NULL
);
912 error ("Internal error: could not find physical method named %s",
913 TYPE_FN_FIELD_PHYSNAME (f, j));
916 v
= allocate_value (ftype
);
917 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym
));
918 VALUE_TYPE (v
) = ftype
;
922 if (type
!= VALUE_TYPE (*arg1p
))
923 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
924 value_addr (*arg1p
)));
926 /* Move the `this' pointer according to the offset.
927 VALUE_OFFSET (*arg1p) += offset;
934 /* Return a virtual function as a value.
935 ARG1 is the object which provides the virtual function
936 table pointer. *ARG1P is side-effected in calling this function.
937 F is the list of member functions which contains the desired virtual
939 J is an index into F which provides the desired virtual function.
941 TYPE is the type in which F is located. */
943 value_virtual_fn_field (arg1p
, f
, j
, type
, offset
)
950 value_ptr arg1
= *arg1p
;
951 struct type
*type1
= check_typedef (VALUE_TYPE (arg1
));
953 if (TYPE_HAS_VTABLE (type
))
955 /* Deal with HP/Taligent runtime model for virtual functions */
957 value_ptr argp
; /* arg1 cast to base */
958 CORE_ADDR coreptr
; /* pointer to target address */
959 int class_index
; /* which class segment pointer to use */
960 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
); /* method type */
962 argp
= value_cast (type
, *arg1p
);
964 if (VALUE_ADDRESS (argp
) == 0)
965 error ("Address of object is null; object may not have been created.");
967 /* pai: FIXME -- 32x64 possible problem? */
968 /* First word (4 bytes) in object layout is the vtable pointer */
969 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (argp
)); /* pai: (temp) */
970 /* + offset + VALUE_EMBEDDED_OFFSET (argp)); */
973 error ("Virtual table pointer is null for object; object may not have been created.");
976 * FIXME: The code here currently handles only
977 * the non-RRBC case of the Taligent/HP runtime spec; when RRBC
978 * is introduced, the condition for the "if" below will have to
979 * be changed to be a test for the RRBC case. */
983 /* Non-RRBC case; the virtual function pointers are stored at fixed
984 * offsets in the virtual table. */
986 /* Retrieve the offset in the virtual table from the debug
987 * info. The offset of the vfunc's entry is in words from
988 * the beginning of the vtable; but first we have to adjust
989 * by HP_ACC_VFUNC_START to account for other entries */
991 /* pai: FIXME: 32x64 problem here, a word may be 8 bytes in
992 * which case the multiplier should be 8 and values should be long */
993 vp
= value_at (builtin_type_int
,
994 coreptr
+ 4 * (TYPE_FN_FIELD_VOFFSET (f
, j
) + HP_ACC_VFUNC_START
), NULL
);
996 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
997 /* coreptr now contains the address of the virtual function */
998 /* (Actually, it contains the pointer to the plabel for the function. */
1002 /* RRBC case; the virtual function pointers are found by double
1003 * indirection through the class segment tables. */
1005 /* Choose class segment depending on type we were passed */
1006 class_index
= class_index_in_primary_list (type
);
1008 /* Find class segment pointer. These are in the vtable slots after
1009 * some other entries, so adjust by HP_ACC_VFUNC_START for that. */
1010 /* pai: FIXME 32x64 problem here, if words are 8 bytes long
1011 * the multiplier below has to be 8 and value should be long. */
1012 vp
= value_at (builtin_type_int
,
1013 coreptr
+ 4 * (HP_ACC_VFUNC_START
+ class_index
), NULL
);
1014 /* Indirect once more, offset by function index */
1015 /* pai: FIXME 32x64 problem here, again multiplier could be 8 and value long */
1016 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
) + 4 * TYPE_FN_FIELD_VOFFSET (f
, j
));
1017 vp
= value_at (builtin_type_int
, coreptr
, NULL
);
1018 coreptr
= *(CORE_ADDR
*) (VALUE_CONTENTS (vp
));
1020 /* coreptr now contains the address of the virtual function */
1021 /* (Actually, it contains the pointer to the plabel for the function.) */
1026 error ("Address of virtual function is null; error in virtual table?");
1028 /* Wrap this addr in a value and return pointer */
1029 vp
= allocate_value (ftype
);
1030 VALUE_TYPE (vp
) = ftype
;
1031 VALUE_ADDRESS (vp
) = coreptr
;
1033 /* pai: (temp) do we need the value_ind stuff in value_fn_field? */
1037 { /* Not using HP/Taligent runtime conventions; so try to
1038 * use g++ conventions for virtual table */
1040 struct type
*entry_type
;
1041 /* First, get the virtual function table pointer. That comes
1042 with a strange type, so cast it to type `pointer to long' (which
1043 should serve just fine as a function type). Then, index into
1044 the table, and convert final value to appropriate function type. */
1045 value_ptr entry
, vfn
, vtbl
;
1046 value_ptr vi
= value_from_longest (builtin_type_int
,
1047 (LONGEST
) TYPE_FN_FIELD_VOFFSET (f
, j
));
1048 struct type
*fcontext
= TYPE_FN_FIELD_FCONTEXT (f
, j
);
1049 struct type
*context
;
1050 if (fcontext
== NULL
)
1051 /* We don't have an fcontext (e.g. the program was compiled with
1052 g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
1053 This won't work right for multiple inheritance, but at least we
1054 should do as well as GDB 3.x did. */
1055 fcontext
= TYPE_VPTR_BASETYPE (type
);
1056 context
= lookup_pointer_type (fcontext
);
1057 /* Now context is a pointer to the basetype containing the vtbl. */
1058 if (TYPE_TARGET_TYPE (context
) != type1
)
1060 value_ptr tmp
= value_cast (context
, value_addr (arg1
));
1061 VALUE_POINTED_TO_OFFSET (tmp
) = 0;
1062 arg1
= value_ind (tmp
);
1063 type1
= check_typedef (VALUE_TYPE (arg1
));
1067 /* Now context is the basetype containing the vtbl. */
1069 /* This type may have been defined before its virtual function table
1070 was. If so, fill in the virtual function table entry for the
1072 if (TYPE_VPTR_FIELDNO (context
) < 0)
1073 fill_in_vptr_fieldno (context
);
1075 /* The virtual function table is now an array of structures
1076 which have the form { int16 offset, delta; void *pfn; }. */
1077 vtbl
= value_primitive_field (arg1
, 0, TYPE_VPTR_FIELDNO (context
),
1078 TYPE_VPTR_BASETYPE (context
));
1080 /* With older versions of g++, the vtbl field pointed to an array
1081 of structures. Nowadays it points directly to the structure. */
1082 if (TYPE_CODE (VALUE_TYPE (vtbl
)) == TYPE_CODE_PTR
1083 && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (vtbl
))) == TYPE_CODE_ARRAY
)
1085 /* Handle the case where the vtbl field points to an
1086 array of structures. */
1087 vtbl
= value_ind (vtbl
);
1089 /* Index into the virtual function table. This is hard-coded because
1090 looking up a field is not cheap, and it may be important to save
1091 time, e.g. if the user has set a conditional breakpoint calling
1092 a virtual function. */
1093 entry
= value_subscript (vtbl
, vi
);
1097 /* Handle the case where the vtbl field points directly to a structure. */
1098 vtbl
= value_add (vtbl
, vi
);
1099 entry
= value_ind (vtbl
);
1102 entry_type
= check_typedef (VALUE_TYPE (entry
));
1104 if (TYPE_CODE (entry_type
) == TYPE_CODE_STRUCT
)
1106 /* Move the `this' pointer according to the virtual function table. */
1107 VALUE_OFFSET (arg1
) += value_as_long (value_field (entry
, 0));
1109 if (!VALUE_LAZY (arg1
))
1111 VALUE_LAZY (arg1
) = 1;
1112 value_fetch_lazy (arg1
);
1115 vfn
= value_field (entry
, 2);
1117 else if (TYPE_CODE (entry_type
) == TYPE_CODE_PTR
)
1120 error ("I'm confused: virtual function table has bad type");
1121 /* Reinstantiate the function pointer with the correct type. */
1122 VALUE_TYPE (vfn
) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
1129 /* ARG is a pointer to an object we know to be at least
1130 a DTYPE. BTYPE is the most derived basetype that has
1131 already been searched (and need not be searched again).
1132 After looking at the vtables between BTYPE and DTYPE,
1133 return the most derived type we find. The caller must
1134 be satisfied when the return value == DTYPE.
1136 FIXME-tiemann: should work with dossier entries as well.
1137 NOTICE - djb: I see no good reason at all to keep this function now that
1138 we have RTTI support. It's used in literally one place, and it's
1139 hard to keep this function up to date when it's purpose is served
1140 by value_rtti_type efficiently.
1141 Consider it gone for 5.1. */
1144 value_headof (in_arg
, btype
, dtype
)
1146 struct type
*btype
, *dtype
;
1148 /* First collect the vtables we must look at for this object. */
1149 value_ptr arg
, vtbl
;
1151 char *demangled_name
;
1152 struct minimal_symbol
*msymbol
;
1154 btype
= TYPE_VPTR_BASETYPE (dtype
);
1155 CHECK_TYPEDEF (btype
);
1158 arg
= value_cast (lookup_pointer_type (btype
), arg
);
1159 if (TYPE_CODE (VALUE_TYPE (arg
)) == TYPE_CODE_REF
)
1162 * Copy the value, but change the type from (T&) to (T*).
1163 * We keep the same location information, which is efficient,
1164 * and allows &(&X) to get the location containing the reference.
1166 arg
= value_copy (arg
);
1167 VALUE_TYPE (arg
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg
)));
1169 if (VALUE_ADDRESS(value_field (value_ind(arg
), TYPE_VPTR_FIELDNO (btype
)))==0)
1172 vtbl
= value_ind (value_field (value_ind (arg
), TYPE_VPTR_FIELDNO (btype
)));
1173 /* Turn vtable into typeinfo function */
1174 VALUE_OFFSET(vtbl
)+=4;
1176 msymbol
= lookup_minimal_symbol_by_pc ( value_as_pointer(value_ind(vtbl
)) );
1178 || (demangled_name
= SYMBOL_NAME (msymbol
)) == NULL
)
1180 /* If we expected to find a vtable, but did not, let the user
1181 know that we aren't happy, but don't throw an error.
1182 FIXME: there has to be a better way to do this. */
1183 struct type
*error_type
= (struct type
*) xmalloc (sizeof (struct type
));
1184 memcpy (error_type
, VALUE_TYPE (in_arg
), sizeof (struct type
));
1185 TYPE_NAME (error_type
) = savestring ("suspicious *", sizeof ("suspicious *"));
1186 VALUE_TYPE (in_arg
) = error_type
;
1189 demangled_name
= cplus_demangle(demangled_name
,DMGL_ANSI
);
1190 *(strchr (demangled_name
, ' ')) = '\0';
1192 sym
= lookup_symbol (demangled_name
, 0, VAR_NAMESPACE
, 0, 0);
1194 error ("could not find type declaration for `%s'", demangled_name
);
1197 VALUE_TYPE (arg
) = lookup_pointer_type (SYMBOL_TYPE (sym
));
1201 /* ARG is a pointer object of type TYPE. If TYPE has virtual
1202 function tables, probe ARG's tables (including the vtables
1203 of its baseclasses) to figure out the most derived type that ARG
1204 could actually be a pointer to. */
1207 value_from_vtable_info (arg
, type
)
1211 /* Take care of preliminaries. */
1212 if (TYPE_VPTR_FIELDNO (type
) < 0)
1213 fill_in_vptr_fieldno (type
);
1214 if (TYPE_VPTR_FIELDNO (type
) < 0)
1217 return value_headof (arg
, 0, type
);
1220 /* Return true if the INDEXth field of TYPE is a virtual baseclass
1221 pointer which is for the base class whose type is BASECLASS. */
1224 vb_match (type
, index
, basetype
)
1227 struct type
*basetype
;
1229 struct type
*fieldtype
;
1230 char *name
= TYPE_FIELD_NAME (type
, index
);
1231 char *field_class_name
= NULL
;
1235 /* gcc 2.4 uses _vb$. */
1236 if (name
[1] == 'v' && name
[2] == 'b' && is_cplus_marker (name
[3]))
1237 field_class_name
= name
+ 4;
1238 /* gcc 2.5 will use __vb_. */
1239 if (name
[1] == '_' && name
[2] == 'v' && name
[3] == 'b' && name
[4] == '_')
1240 field_class_name
= name
+ 5;
1242 if (field_class_name
== NULL
)
1243 /* This field is not a virtual base class pointer. */
1246 /* It's a virtual baseclass pointer, now we just need to find out whether
1247 it is for this baseclass. */
1248 fieldtype
= TYPE_FIELD_TYPE (type
, index
);
1249 if (fieldtype
== NULL
1250 || TYPE_CODE (fieldtype
) != TYPE_CODE_PTR
)
1251 /* "Can't happen". */
1254 /* What we check for is that either the types are equal (needed for
1255 nameless types) or have the same name. This is ugly, and a more
1256 elegant solution should be devised (which would probably just push
1257 the ugliness into symbol reading unless we change the stabs format). */
1258 if (TYPE_TARGET_TYPE (fieldtype
) == basetype
)
1261 if (TYPE_NAME (basetype
) != NULL
1262 && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
)) != NULL
1263 && STREQ (TYPE_NAME (basetype
),
1264 TYPE_NAME (TYPE_TARGET_TYPE (fieldtype
))))
1269 /* Compute the offset of the baseclass which is
1270 the INDEXth baseclass of class TYPE,
1271 for value at VALADDR (in host) at ADDRESS (in target).
1272 The result is the offset of the baseclass value relative
1273 to (the address of)(ARG) + OFFSET.
1275 -1 is returned on error. */
1278 baseclass_offset (type
, index
, valaddr
, address
)
1284 struct type
*basetype
= TYPE_BASECLASS (type
, index
);
1286 if (BASETYPE_VIA_VIRTUAL (type
, index
))
1288 /* Must hunt for the pointer to this virtual baseclass. */
1289 register int i
, len
= TYPE_NFIELDS (type
);
1290 register int n_baseclasses
= TYPE_N_BASECLASSES (type
);
1292 /* First look for the virtual baseclass pointer
1294 for (i
= n_baseclasses
; i
< len
; i
++)
1296 if (vb_match (type
, i
, basetype
))
1299 = unpack_pointer (TYPE_FIELD_TYPE (type
, i
),
1300 valaddr
+ (TYPE_FIELD_BITPOS (type
, i
) / 8));
1302 return addr
- (LONGEST
) address
;
1305 /* Not in the fields, so try looking through the baseclasses. */
1306 for (i
= index
+ 1; i
< n_baseclasses
; i
++)
1309 baseclass_offset (type
, i
, valaddr
, address
);
1317 /* Baseclass is easily computed. */
1318 return TYPE_BASECLASS_BITPOS (type
, index
) / 8;
1321 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1324 Extracting bits depends on endianness of the machine. Compute the
1325 number of least significant bits to discard. For big endian machines,
1326 we compute the total number of bits in the anonymous object, subtract
1327 off the bit count from the MSB of the object to the MSB of the
1328 bitfield, then the size of the bitfield, which leaves the LSB discard
1329 count. For little endian machines, the discard count is simply the
1330 number of bits from the LSB of the anonymous object to the LSB of the
1333 If the field is signed, we also do sign extension. */
1336 unpack_field_as_long (type
, valaddr
, fieldno
)
1343 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
1344 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
1346 struct type
*field_type
;
1348 val
= extract_unsigned_integer (valaddr
+ bitpos
/ 8, sizeof (val
));
1349 field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
1350 CHECK_TYPEDEF (field_type
);
1352 /* Extract bits. See comment above. */
1354 if (BITS_BIG_ENDIAN
)
1355 lsbcount
= (sizeof val
* 8 - bitpos
% 8 - bitsize
);
1357 lsbcount
= (bitpos
% 8);
1360 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1361 If the field is signed, and is negative, then sign extend. */
1363 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
1365 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
1367 if (!TYPE_UNSIGNED (field_type
))
1369 if (val
& (valmask
^ (valmask
>> 1)))
1378 /* Modify the value of a bitfield. ADDR points to a block of memory in
1379 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
1380 is the desired value of the field, in host byte order. BITPOS and BITSIZE
1381 indicate which bits (in target bit order) comprise the bitfield. */
1384 modify_field (addr
, fieldval
, bitpos
, bitsize
)
1387 int bitpos
, bitsize
;
1391 /* If a negative fieldval fits in the field in question, chop
1392 off the sign extension bits. */
1393 if (bitsize
< (8 * (int) sizeof (fieldval
))
1394 && (~fieldval
& ~((1 << (bitsize
- 1)) - 1)) == 0)
1395 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1397 /* Warn if value is too big to fit in the field in question. */
1398 if (bitsize
< (8 * (int) sizeof (fieldval
))
1399 && 0 != (fieldval
& ~((1 << bitsize
) - 1)))
1401 /* FIXME: would like to include fieldval in the message, but
1402 we don't have a sprintf_longest. */
1403 warning ("Value does not fit in %d bits.", bitsize
);
1405 /* Truncate it, otherwise adjoining fields may be corrupted. */
1406 fieldval
= fieldval
& ((1 << bitsize
) - 1);
1409 oword
= extract_signed_integer (addr
, sizeof oword
);
1411 /* Shifting for bit field depends on endianness of the target machine. */
1412 if (BITS_BIG_ENDIAN
)
1413 bitpos
= sizeof (oword
) * 8 - bitpos
- bitsize
;
1415 /* Mask out old value, while avoiding shifts >= size of oword */
1416 if (bitsize
< 8 * (int) sizeof (oword
))
1417 oword
&= ~(((((ULONGEST
) 1) << bitsize
) - 1) << bitpos
);
1419 oword
&= ~((~(ULONGEST
) 0) << bitpos
);
1420 oword
|= fieldval
<< bitpos
;
1422 store_signed_integer (addr
, sizeof oword
, oword
);
1425 /* Convert C numbers into newly allocated values */
1428 value_from_longest (type
, num
)
1430 register LONGEST num
;
1432 register value_ptr val
= allocate_value (type
);
1433 register enum type_code code
;
1436 code
= TYPE_CODE (type
);
1437 len
= TYPE_LENGTH (type
);
1441 case TYPE_CODE_TYPEDEF
:
1442 type
= check_typedef (type
);
1445 case TYPE_CODE_CHAR
:
1446 case TYPE_CODE_ENUM
:
1447 case TYPE_CODE_BOOL
:
1448 case TYPE_CODE_RANGE
:
1449 store_signed_integer (VALUE_CONTENTS_RAW (val
), len
, num
);
1454 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, (CORE_ADDR
) num
);
1458 error ("Unexpected type (%d) encountered for integer constant.", code
);
1464 /* Create a value representing a pointer of type TYPE to the address
1467 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
1469 value_ptr val
= allocate_value (type
);
1470 store_typed_address (VALUE_CONTENTS_RAW (val
), type
, addr
);
1475 /* Create a value for a string constant to be stored locally
1476 (not in the inferior's memory space, but in GDB memory).
1477 This is analogous to value_from_longest, which also does not
1478 use inferior memory. String shall NOT contain embedded nulls. */
1481 value_from_string (ptr
)
1485 int len
= strlen (ptr
);
1486 int lowbound
= current_language
->string_lower_bound
;
1487 struct type
*rangetype
=
1488 create_range_type ((struct type
*) NULL
,
1490 lowbound
, len
+ lowbound
- 1);
1491 struct type
*stringtype
=
1492 create_array_type ((struct type
*) NULL
,
1493 *current_language
->string_char_type
,
1496 val
= allocate_value (stringtype
);
1497 memcpy (VALUE_CONTENTS_RAW (val
), ptr
, len
);
1502 value_from_double (type
, num
)
1506 register value_ptr val
= allocate_value (type
);
1507 struct type
*base_type
= check_typedef (type
);
1508 register enum type_code code
= TYPE_CODE (base_type
);
1509 register int len
= TYPE_LENGTH (base_type
);
1511 if (code
== TYPE_CODE_FLT
)
1513 store_floating (VALUE_CONTENTS_RAW (val
), len
, num
);
1516 error ("Unexpected type encountered for floating constant.");
1521 /* Deal with the value that is "about to be returned". */
1523 /* Return the value that a function returning now
1524 would be returning to its caller, assuming its type is VALTYPE.
1525 RETBUF is where we look for what ought to be the contents
1526 of the registers (in raw form). This is because it is often
1527 desirable to restore old values to those registers
1528 after saving the contents of interest, and then call
1529 this function using the saved values.
1530 struct_return is non-zero when the function in question is
1531 using the structure return conventions on the machine in question;
1532 0 when it is using the value returning conventions (this often
1533 means returning pointer to where structure is vs. returning value). */
1536 value_being_returned (valtype
, retbuf
, struct_return
)
1537 register struct type
*valtype
;
1542 register value_ptr val
;
1545 /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
1546 if (EXTRACT_STRUCT_VALUE_ADDRESS_P
)
1549 addr
= EXTRACT_STRUCT_VALUE_ADDRESS (retbuf
);
1551 error ("Function return value unknown");
1552 return value_at (valtype
, addr
, NULL
);
1555 val
= allocate_value (valtype
);
1556 CHECK_TYPEDEF (valtype
);
1557 EXTRACT_RETURN_VALUE (valtype
, retbuf
, VALUE_CONTENTS_RAW (val
));
1562 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1563 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
1564 and TYPE is the type (which is known to be struct, union or array).
1566 On most machines, the struct convention is used unless we are
1567 using gcc and the type is of a special size. */
1568 /* As of about 31 Mar 93, GCC was changed to be compatible with the
1569 native compiler. GCC 2.3.3 was the last release that did it the
1570 old way. Since gcc2_compiled was not changed, we have no
1571 way to correctly win in all cases, so we just do the right thing
1572 for gcc1 and for gcc2 after this change. Thus it loses for gcc
1573 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled
1574 would cause more chaos than dealing with some struct returns being
1578 generic_use_struct_convention (gcc_p
, value_type
)
1580 struct type
*value_type
;
1582 return !((gcc_p
== 1)
1583 && (TYPE_LENGTH (value_type
) == 1
1584 || TYPE_LENGTH (value_type
) == 2
1585 || TYPE_LENGTH (value_type
) == 4
1586 || TYPE_LENGTH (value_type
) == 8));
1589 #ifndef USE_STRUCT_CONVENTION
1590 #define USE_STRUCT_CONVENTION(gcc_p,type) generic_use_struct_convention (gcc_p, type)
1594 /* Return true if the function specified is using the structure returning
1595 convention on this machine to return arguments, or 0 if it is using
1596 the value returning convention. FUNCTION is the value representing
1597 the function, FUNCADDR is the address of the function, and VALUE_TYPE
1598 is the type returned by the function. GCC_P is nonzero if compiled
1602 using_struct_return (function
, funcaddr
, value_type
, gcc_p
)
1605 struct type
*value_type
;
1609 register enum type_code code
= TYPE_CODE (value_type
);
1611 if (code
== TYPE_CODE_ERROR
)
1612 error ("Function return type unknown.");
1614 if (code
== TYPE_CODE_STRUCT
1615 || code
== TYPE_CODE_UNION
1616 || code
== TYPE_CODE_ARRAY
1617 || RETURN_VALUE_ON_STACK (value_type
))
1618 return USE_STRUCT_CONVENTION (gcc_p
, value_type
);
1623 /* Store VAL so it will be returned if a function returns now.
1624 Does not verify that VAL's type matches what the current
1625 function wants to return. */
1628 set_return_value (val
)
1631 struct type
*type
= check_typedef (VALUE_TYPE (val
));
1632 register enum type_code code
= TYPE_CODE (type
);
1634 if (code
== TYPE_CODE_ERROR
)
1635 error ("Function return type unknown.");
1637 if (code
== TYPE_CODE_STRUCT
1638 || code
== TYPE_CODE_UNION
) /* FIXME, implement struct return. */
1639 error ("GDB does not support specifying a struct or union return value.");
1641 STORE_RETURN_VALUE (type
, VALUE_CONTENTS (val
));
1645 _initialize_values ()
1647 add_cmd ("convenience", no_class
, show_convenience
,
1648 "Debugger convenience (\"$foo\") variables.\n\
1649 These variables are created when you assign them values;\n\
1650 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\
1651 A few convenience variables are given values automatically:\n\
1652 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1653 \"$__\" holds the contents of the last address examined with \"x\".",
1656 add_cmd ("values", no_class
, show_values
,
1657 "Elements of value history around item number IDX (or last ten).",