/* Low level packing and unpacking of values for GDB, the GNU Debugger.
- Copyright 1986, 87, 89, 91, 93, 94, 95, 96, 97, 1998
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000
Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbtypes.h"
#include "value.h"
#include "gdbcore.h"
-#include "frame.h"
#include "command.h"
#include "gdbcmd.h"
#include "target.h"
static void show_convenience (char *, int);
-static int vb_match (struct type *, int, struct type *);
/* The value-history records all the values printed
by print commands during this session. Each chunk
/* Allocate a value that has the correct length for type TYPE. */
value_ptr
-allocate_value (type)
- struct type *type;
+allocate_value (struct type *type)
{
register value_ptr val;
struct type *atype = check_typedef (type);
for COUNT repetitions type TYPE. */
value_ptr
-allocate_repeat_value (type, count)
- struct type *type;
- int count;
+allocate_repeat_value (struct type *type, int count)
{
int low_bound = current_language->string_lower_bound; /* ??? */
/* FIXME-type-allocation: need a way to free this type when we are
mark is obtained (except for those released) are subject to being freed
if a subsequent value_free_to_mark is passed the mark. */
value_ptr
-value_mark ()
+value_mark (void)
{
return all_values;
}
/* Free all values allocated since MARK was obtained by value_mark
(except for those released). */
void
-value_free_to_mark (mark)
- value_ptr mark;
+value_free_to_mark (value_ptr mark)
{
value_ptr val, next;
Called after each command, successful or not. */
void
-free_all_values ()
+free_all_values (void)
{
register value_ptr val, next;
so it will not be freed automatically. */
void
-release_value (val)
- register value_ptr val;
+release_value (register value_ptr val)
{
register value_ptr v;
/* Release all values up to mark */
value_ptr
-value_release_to_mark (mark)
- value_ptr mark;
+value_release_to_mark (value_ptr mark)
{
value_ptr val, next;
but it's a different block of storage. */
value_ptr
-value_copy (arg)
- value_ptr arg;
+value_copy (value_ptr arg)
{
register struct type *encl_type = VALUE_ENCLOSING_TYPE (arg);
register value_ptr val = allocate_value (encl_type);
value history index of this new item. */
int
-record_latest_value (val)
- value_ptr val;
+record_latest_value (value_ptr val)
{
int i;
/* Return a copy of the value in the history with sequence number NUM. */
value_ptr
-access_value_history (num)
- int num;
+access_value_history (int num)
{
register struct value_history_chunk *chunk;
register int i;
because the type pointers become invalid. */
void
-clear_value_history ()
+clear_value_history (void)
{
register struct value_history_chunk *next;
register int i;
{
for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
if ((val = value_history_chain->values[i]) != NULL)
- free ((PTR) val);
+ xfree (val);
next = value_history_chain->next;
- free ((PTR) value_history_chain);
+ xfree (value_history_chain);
value_history_chain = next;
}
value_history_count = 0;
}
static void
-show_values (num_exp, from_tty)
- char *num_exp;
- int from_tty;
+show_values (char *num_exp, int from_tty)
{
register int i;
register value_ptr val;
/* "info history +" should print from the stored position.
"info history <exp>" should print around value number <exp>. */
if (num_exp[0] != '+' || num_exp[1] != '\0')
- num = parse_and_eval_address (num_exp) - 5;
+ num = parse_and_eval_long (num_exp) - 5;
}
else
{
one is created, with a void value. */
struct internalvar *
-lookup_internalvar (name)
- char *name;
+lookup_internalvar (char *name)
{
register struct internalvar *var;
}
value_ptr
-value_of_internalvar (var)
- struct internalvar *var;
+value_of_internalvar (struct internalvar *var)
{
register value_ptr val;
}
void
-set_internalvar_component (var, offset, bitpos, bitsize, newval)
- struct internalvar *var;
- int offset, bitpos, bitsize;
- value_ptr newval;
+set_internalvar_component (struct internalvar *var, int offset, int bitpos,
+ int bitsize, value_ptr newval)
{
register char *addr = VALUE_CONTENTS (var->value) + offset;
}
void
-set_internalvar (var, val)
- struct internalvar *var;
- value_ptr val;
+set_internalvar (struct internalvar *var, value_ptr val)
{
value_ptr newval;
something in the value chain (i.e., before release_value is
called), because after the error free_all_values will get called before
long. */
- free ((PTR) var->value);
+ xfree (var->value);
var->value = newval;
release_value (newval);
/* End code which must not call error(). */
}
char *
-internalvar_name (var)
- struct internalvar *var;
+internalvar_name (struct internalvar *var)
{
return var->name;
}
because that makes the values invalid. */
void
-clear_internalvars ()
+clear_internalvars (void)
{
register struct internalvar *var;
{
var = internalvars;
internalvars = var->next;
- free ((PTR) var->name);
- free ((PTR) var->value);
- free ((PTR) var);
+ xfree (var->name);
+ xfree (var->value);
+ xfree (var);
}
}
static void
-show_convenience (ignore, from_tty)
- char *ignore;
- int from_tty;
+show_convenience (char *ignore, int from_tty)
{
register struct internalvar *var;
int varseen = 0;
Does not deallocate the value. */
LONGEST
-value_as_long (val)
- register value_ptr val;
+value_as_long (register value_ptr val)
{
/* This coerces arrays and functions, which is necessary (e.g.
in disassemble_command). It also dereferences references, which
}
DOUBLEST
-value_as_double (val)
- register value_ptr val;
+value_as_double (register value_ptr val)
{
DOUBLEST foo;
int inv;
Note that val's type may not actually be a pointer; value_as_long
handles all the cases. */
CORE_ADDR
-value_as_pointer (val)
- value_ptr val;
+value_as_pointer (value_ptr val)
{
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
for pointers to char, in which the low bits *are* significant. */
return ADDR_BITS_REMOVE (value_as_long (val));
#else
- return value_as_long (val);
+ COERCE_ARRAY (val);
+ /* In converting VAL to an address (CORE_ADDR), any small integers
+ are first cast to a generic pointer. The function unpack_long
+ will then correctly convert that pointer into a canonical address
+ (using POINTER_TO_ADDRESS).
+
+ Without the cast, the MIPS gets: 0xa0000000 -> (unsigned int)
+ 0xa0000000 -> (LONGEST) 0x00000000a0000000
+
+ With the cast, the MIPS gets: 0xa0000000 -> (unsigned int)
+ 0xa0000000 -> (void*) 0xa0000000 -> (LONGEST) 0xffffffffa0000000.
+
+ If the user specifies an integer that is larger than the target
+ pointer type, it is assumed that it was intentional and the value
+ is converted directly into an ADDRESS. This ensures that no
+ information is discarded.
+
+ NOTE: The cast operation may eventualy be converted into a TARGET
+ method (see POINTER_TO_ADDRESS() and ADDRESS_TO_POINTER()) so
+ that the TARGET ISA/ABI can apply an arbitrary conversion.
+
+ NOTE: In pure harvard architectures function and data pointers
+ can be different and may require different integer to pointer
+ conversions. */
+ if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
+ && (TYPE_LENGTH (VALUE_TYPE (val))
+ <= TYPE_LENGTH (builtin_type_void_data_ptr)))
+ {
+ val = value_cast (builtin_type_void_data_ptr, val);
+ }
+ return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
#endif
}
\f
to an INT (or some size). After all, it is only an offset. */
LONGEST
-unpack_long (type, valaddr)
- struct type *type;
- char *valaddr;
+unpack_long (struct type *type, char *valaddr)
{
register enum type_code code = TYPE_CODE (type);
register int len = TYPE_LENGTH (type);
format, result is in host format. */
DOUBLEST
-unpack_double (type, valaddr, invp)
- struct type *type;
- char *valaddr;
- int *invp;
+unpack_double (struct type *type, char *valaddr, int *invp)
{
enum type_code code;
int len;
else if (nosign)
{
/* Unsigned -- be sure we compensate for signed LONGEST. */
-#if !defined (_MSC_VER) || (_MSC_VER > 900)
return (ULONGEST) unpack_long (type, valaddr);
-#else
- /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */
- return (LONGEST) unpack_long (type, valaddr);
-#endif /* _MSC_VER */
}
else
{
to an INT (or some size). After all, it is only an offset. */
CORE_ADDR
-unpack_pointer (type, valaddr)
- struct type *type;
- char *valaddr;
+unpack_pointer (struct type *type, char *valaddr)
{
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
/* Get the value of the FIELDN'th field (which must be static) of TYPE. */
value_ptr
-value_static_field (type, fieldno)
- struct type *type;
- int fieldno;
+value_static_field (struct type *type, int fieldno)
{
CORE_ADDR addr;
asection *sect;
}
else
{
- addr = SYMBOL_VALUE_ADDRESS (sym);
- sect = SYMBOL_BFD_SECTION (sym);
- }
+ /* Anything static that isn't a constant, has an address */
+ if (SYMBOL_CLASS (sym) != LOC_CONST)
+ {
+ addr = SYMBOL_VALUE_ADDRESS (sym);
+ sect = SYMBOL_BFD_SECTION (sym);
+ }
+ /* However, static const's do not, the value is already known. */
+ else
+ {
+ return value_from_longest (TYPE_FIELD_TYPE (type, fieldno), SYMBOL_VALUE (sym));
+ }
+ }
SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), addr);
}
return value_at (TYPE_FIELD_TYPE (type, fieldno), addr, sect);
}
+/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
+ You have to be careful here, since the size of the data area for the value
+ is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
+ than the old enclosing type, you have to allocate more space for the data.
+ The return value is a pointer to the new version of this value structure. */
+
+value_ptr
+value_change_enclosing_type (value_ptr val, struct type *new_encl_type)
+{
+ if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)))
+ {
+ VALUE_ENCLOSING_TYPE (val) = new_encl_type;
+ return val;
+ }
+ else
+ {
+ value_ptr new_val;
+ register value_ptr prev;
+
+ new_val = (value_ptr) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type));
+
+ /* We have to make sure this ends up in the same place in the value
+ chain as the original copy, so it's clean-up behavior is the same.
+ If the value has been released, this is a waste of time, but there
+ is no way to tell that in advance, so... */
+
+ if (val != all_values)
+ {
+ for (prev = all_values; prev != NULL; prev = prev->next)
+ {
+ if (prev->next == val)
+ {
+ prev->next = new_val;
+ break;
+ }
+ }
+ }
+
+ return new_val;
+ }
+}
+
/* Given a value ARG1 (offset by OFFSET bytes)
of a struct or union type ARG_TYPE,
extract and return the value of one of its (non-static) fields.
FIELDNO says which field. */
value_ptr
-value_primitive_field (arg1, offset, fieldno, arg_type)
- register value_ptr arg1;
- int offset;
- register int fieldno;
- register struct type *arg_type;
+value_primitive_field (register value_ptr arg1, int offset,
+ register int fieldno, register struct type *arg_type)
{
register value_ptr v;
register struct type *type;
entire object's contents for later references to virtual
bases, etc. */
v = allocate_value (VALUE_ENCLOSING_TYPE (arg1));
- VALUE_TYPE (v) = arg_type;
+ VALUE_TYPE (v) = type;
if (VALUE_LAZY (arg1))
VALUE_LAZY (v) = 1;
else
FIELDNO says which field. */
value_ptr
-value_field (arg1, fieldno)
- register value_ptr arg1;
- register int fieldno;
+value_field (register value_ptr arg1, register int fieldno)
{
return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
}
J is an index into F which provides the desired method. */
value_ptr
-value_fn_field (arg1p, f, j, type, offset)
- value_ptr *arg1p;
- struct fn_field *f;
- int j;
- struct type *type;
- int offset;
+value_fn_field (value_ptr *arg1p, struct fn_field *f, int j, struct type *type,
+ int offset)
{
register value_ptr v;
register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
return v;
}
-/* Return a virtual function as a value.
- ARG1 is the object which provides the virtual function
- table pointer. *ARG1P is side-effected in calling this function.
- F is the list of member functions which contains the desired virtual
- function.
- J is an index into F which provides the desired virtual function.
-
- TYPE is the type in which F is located. */
-value_ptr
-value_virtual_fn_field (arg1p, f, j, type, offset)
- value_ptr *arg1p;
- struct fn_field *f;
- int j;
- struct type *type;
- int offset;
-{
- value_ptr arg1 = *arg1p;
- struct type *type1 = check_typedef (VALUE_TYPE (arg1));
-
- if (TYPE_HAS_VTABLE (type))
- {
- /* Deal with HP/Taligent runtime model for virtual functions */
- value_ptr vp;
- value_ptr argp; /* arg1 cast to base */
- CORE_ADDR coreptr; /* pointer to target address */
- int class_index; /* which class segment pointer to use */
- struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); /* method type */
-
- argp = value_cast (type, *arg1p);
-
- if (VALUE_ADDRESS (argp) == 0)
- error ("Address of object is null; object may not have been created.");
-
- /* pai: FIXME -- 32x64 possible problem? */
- /* First word (4 bytes) in object layout is the vtable pointer */
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (argp)); /* pai: (temp) */
- /* + offset + VALUE_EMBEDDED_OFFSET (argp)); */
-
- if (!coreptr)
- error ("Virtual table pointer is null for object; object may not have been created.");
-
- /* pai/1997-05-09
- * FIXME: The code here currently handles only
- * the non-RRBC case of the Taligent/HP runtime spec; when RRBC
- * is introduced, the condition for the "if" below will have to
- * be changed to be a test for the RRBC case. */
-
- if (1)
- {
- /* Non-RRBC case; the virtual function pointers are stored at fixed
- * offsets in the virtual table. */
-
- /* Retrieve the offset in the virtual table from the debug
- * info. The offset of the vfunc's entry is in words from
- * the beginning of the vtable; but first we have to adjust
- * by HP_ACC_VFUNC_START to account for other entries */
-
- /* pai: FIXME: 32x64 problem here, a word may be 8 bytes in
- * which case the multiplier should be 8 and values should be long */
- vp = value_at (builtin_type_int,
- coreptr + 4 * (TYPE_FN_FIELD_VOFFSET (f, j) + HP_ACC_VFUNC_START), NULL);
-
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
- /* coreptr now contains the address of the virtual function */
- /* (Actually, it contains the pointer to the plabel for the function. */
- }
- else
- {
- /* RRBC case; the virtual function pointers are found by double
- * indirection through the class segment tables. */
-
- /* Choose class segment depending on type we were passed */
- class_index = class_index_in_primary_list (type);
-
- /* Find class segment pointer. These are in the vtable slots after
- * some other entries, so adjust by HP_ACC_VFUNC_START for that. */
- /* pai: FIXME 32x64 problem here, if words are 8 bytes long
- * the multiplier below has to be 8 and value should be long. */
- vp = value_at (builtin_type_int,
- coreptr + 4 * (HP_ACC_VFUNC_START + class_index), NULL);
- /* Indirect once more, offset by function index */
- /* pai: FIXME 32x64 problem here, again multiplier could be 8 and value long */
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp) + 4 * TYPE_FN_FIELD_VOFFSET (f, j));
- vp = value_at (builtin_type_int, coreptr, NULL);
- coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
-
- /* coreptr now contains the address of the virtual function */
- /* (Actually, it contains the pointer to the plabel for the function.) */
-
- }
-
- if (!coreptr)
- error ("Address of virtual function is null; error in virtual table?");
-
- /* Wrap this addr in a value and return pointer */
- vp = allocate_value (ftype);
- VALUE_TYPE (vp) = ftype;
- VALUE_ADDRESS (vp) = coreptr;
-
- /* pai: (temp) do we need the value_ind stuff in value_fn_field? */
- return vp;
- }
- else
- { /* Not using HP/Taligent runtime conventions; so try to
- * use g++ conventions for virtual table */
-
- struct type *entry_type;
- /* First, get the virtual function table pointer. That comes
- with a strange type, so cast it to type `pointer to long' (which
- should serve just fine as a function type). Then, index into
- the table, and convert final value to appropriate function type. */
- value_ptr entry, vfn, vtbl;
- value_ptr vi = value_from_longest (builtin_type_int,
- (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
- struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
- struct type *context;
- if (fcontext == NULL)
- /* We don't have an fcontext (e.g. the program was compiled with
- g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE.
- This won't work right for multiple inheritance, but at least we
- should do as well as GDB 3.x did. */
- fcontext = TYPE_VPTR_BASETYPE (type);
- context = lookup_pointer_type (fcontext);
- /* Now context is a pointer to the basetype containing the vtbl. */
- if (TYPE_TARGET_TYPE (context) != type1)
- {
- value_ptr tmp = value_cast (context, value_addr (arg1));
- VALUE_POINTED_TO_OFFSET (tmp) = 0;
- arg1 = value_ind (tmp);
- type1 = check_typedef (VALUE_TYPE (arg1));
- }
-
- context = type1;
- /* Now context is the basetype containing the vtbl. */
-
- /* This type may have been defined before its virtual function table
- was. If so, fill in the virtual function table entry for the
- type now. */
- if (TYPE_VPTR_FIELDNO (context) < 0)
- fill_in_vptr_fieldno (context);
-
- /* The virtual function table is now an array of structures
- which have the form { int16 offset, delta; void *pfn; }. */
- vtbl = value_primitive_field (arg1, 0, TYPE_VPTR_FIELDNO (context),
- TYPE_VPTR_BASETYPE (context));
-
- /* With older versions of g++, the vtbl field pointed to an array
- of structures. Nowadays it points directly to the structure. */
- if (TYPE_CODE (VALUE_TYPE (vtbl)) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (vtbl))) == TYPE_CODE_ARRAY)
- {
- /* Handle the case where the vtbl field points to an
- array of structures. */
- vtbl = value_ind (vtbl);
-
- /* Index into the virtual function table. This is hard-coded because
- looking up a field is not cheap, and it may be important to save
- time, e.g. if the user has set a conditional breakpoint calling
- a virtual function. */
- entry = value_subscript (vtbl, vi);
- }
- else
- {
- /* Handle the case where the vtbl field points directly to a structure. */
- vtbl = value_add (vtbl, vi);
- entry = value_ind (vtbl);
- }
-
- entry_type = check_typedef (VALUE_TYPE (entry));
-
- if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT)
- {
- /* Move the `this' pointer according to the virtual function table. */
- VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0));
-
- if (!VALUE_LAZY (arg1))
- {
- VALUE_LAZY (arg1) = 1;
- value_fetch_lazy (arg1);
- }
-
- vfn = value_field (entry, 2);
- }
- else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR)
- vfn = entry;
- else
- error ("I'm confused: virtual function table has bad type");
- /* Reinstantiate the function pointer with the correct type. */
- VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
-
- *arg1p = arg1;
- return vfn;
- }
-}
-
/* ARG is a pointer to an object we know to be at least
a DTYPE. BTYPE is the most derived basetype that has
already been searched (and need not be searched again).
Consider it gone for 5.1. */
static value_ptr
-value_headof (in_arg, btype, dtype)
- value_ptr in_arg;
- struct type *btype, *dtype;
+value_headof (value_ptr in_arg, struct type *btype, struct type *dtype)
{
/* First collect the vtables we must look at for this object. */
value_ptr arg, vtbl;
could actually be a pointer to. */
value_ptr
-value_from_vtable_info (arg, type)
- value_ptr arg;
- struct type *type;
+value_from_vtable_info (value_ptr arg, struct type *type)
{
/* Take care of preliminaries. */
if (TYPE_VPTR_FIELDNO (type) < 0)
pointer which is for the base class whose type is BASECLASS. */
static int
-vb_match (type, index, basetype)
- struct type *type;
- int index;
- struct type *basetype;
+vb_match (struct type *type, int index, struct type *basetype)
{
struct type *fieldtype;
char *name = TYPE_FIELD_NAME (type, index);
-1 is returned on error. */
int
-baseclass_offset (type, index, valaddr, address)
- struct type *type;
- int index;
- char *valaddr;
- CORE_ADDR address;
+baseclass_offset (struct type *type, int index, char *valaddr,
+ CORE_ADDR address)
{
struct type *basetype = TYPE_BASECLASS (type, index);
If the field is signed, we also do sign extension. */
LONGEST
-unpack_field_as_long (type, valaddr, fieldno)
- struct type *type;
- char *valaddr;
- int fieldno;
+unpack_field_as_long (struct type *type, char *valaddr, int fieldno)
{
ULONGEST val;
ULONGEST valmask;
indicate which bits (in target bit order) comprise the bitfield. */
void
-modify_field (addr, fieldval, bitpos, bitsize)
- char *addr;
- LONGEST fieldval;
- int bitpos, bitsize;
+modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize)
{
LONGEST oword;
/* Convert C numbers into newly allocated values */
value_ptr
-value_from_longest (type, num)
- struct type *type;
- register LONGEST num;
+value_from_longest (struct type *type, register LONGEST num)
{
register value_ptr val = allocate_value (type);
register enum type_code code;
use inferior memory. String shall NOT contain embedded nulls. */
value_ptr
-value_from_string (ptr)
- char *ptr;
+value_from_string (char *ptr)
{
value_ptr val;
int len = strlen (ptr);
}
value_ptr
-value_from_double (type, num)
- struct type *type;
- DOUBLEST num;
+value_from_double (struct type *type, DOUBLEST num)
{
register value_ptr val = allocate_value (type);
struct type *base_type = check_typedef (type);
0 when it is using the value returning conventions (this often
means returning pointer to where structure is vs. returning value). */
+/* ARGSUSED */
value_ptr
-value_being_returned (valtype, retbuf, struct_return)
- register struct type *valtype;
- char *retbuf;
- int struct_return;
- /*ARGSUSED */
+value_being_returned (struct type *valtype, char *retbuf, int struct_return)
{
register value_ptr val;
CORE_ADDR addr;
/* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */
- if (EXTRACT_STRUCT_VALUE_ADDRESS_P)
+ if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
if (struct_return)
{
addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
handled wrong. */
int
-generic_use_struct_convention (gcc_p, value_type)
- int gcc_p;
- struct type *value_type;
+generic_use_struct_convention (int gcc_p, struct type *value_type)
{
return !((gcc_p == 1)
&& (TYPE_LENGTH (value_type) == 1
is the type returned by the function. GCC_P is nonzero if compiled
with GCC. */
+/* ARGSUSED */
int
-using_struct_return (function, funcaddr, value_type, gcc_p)
- value_ptr function;
- CORE_ADDR funcaddr;
- struct type *value_type;
- int gcc_p;
- /*ARGSUSED */
+using_struct_return (value_ptr function, CORE_ADDR funcaddr,
+ struct type *value_type, int gcc_p)
{
register enum type_code code = TYPE_CODE (value_type);
function wants to return. */
void
-set_return_value (val)
- value_ptr val;
+set_return_value (value_ptr val)
{
struct type *type = check_typedef (VALUE_TYPE (val));
register enum type_code code = TYPE_CODE (type);
}
\f
void
-_initialize_values ()
+_initialize_values (void)
{
add_cmd ("convenience", no_class, show_convenience,
"Debugger convenience (\"$foo\") variables.\n\