/* 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"
/* Prototypes for exported functions. */
-void _initialize_values PARAMS ((void));
+void _initialize_values (void);
/* Prototypes for local functions. */
-static value_ptr value_headof PARAMS ((value_ptr, struct type *,
- struct type *));
+static value_ptr value_headof (value_ptr, struct type *, struct type *);
-static void show_values PARAMS ((char *, int));
+static void show_values (char *, int);
-static void show_convenience PARAMS ((char *, int));
+static void show_convenience (char *, int);
-static int vb_match PARAMS ((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;
error ("Invalid floating value found in program.");
return foo;
}
-/* Extract a value as a C pointer.
- Does not deallocate the value. */
+/* Extract a value as a C pointer. Does not deallocate the value.
+ 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);
if (GDB_TARGET_IS_D10V
&& len == 2)
return D10V_MAKE_DADDR (extract_address (valaddr, len));
- return extract_address (valaddr, len);
+ return extract_typed_address (valaddr, type);
case TYPE_CODE_MEMBER:
error ("not implemented: member types in unpack_long");
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. */
return unpack_long (type, valaddr);
}
+
\f
/* 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;
fieldno));
VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
+ VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+ + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
}
else if (fieldno < TYPE_N_BASECLASSES (arg_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
if (VALUE_LVAL (arg1) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
+ VALUE_REGNO (v) = VALUE_REGNO (arg1);
/* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+ TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */
return v;
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);
*arg1p = value_ind (value_cast (lookup_pointer_type (type),
value_addr (*arg1p)));
- /* Move the `this' pointer according to the offset.
+ /* Move the `this' pointer according to the offset.
VALUE_OFFSET (*arg1p) += offset;
*/
}
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).
return the most derived type we find. The caller must
be satisfied when the return value == DTYPE.
- FIXME-tiemann: should work with dossier entries as well. */
+ FIXME-tiemann: should work with dossier entries as well.
+ NOTICE - djb: I see no good reason at all to keep this function now that
+ we have RTTI support. It's used in literally one place, and it's
+ hard to keep this function up to date when it's purpose is served
+ by value_rtti_type efficiently.
+ 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. */
- /* FIXME-tiemann: right now, just look at top-most vtable. */
- value_ptr arg, vtbl, entry, best_entry = 0;
- int i, nelems;
- int offset, best_offset = 0;
+ value_ptr arg, vtbl;
struct symbol *sym;
- CORE_ADDR pc_for_sym;
char *demangled_name;
struct minimal_symbol *msymbol;
CHECK_TYPEDEF (btype);
arg = in_arg;
if (btype != dtype)
- arg = value_cast (lookup_pointer_type (btype), arg);
+ arg = value_cast (lookup_pointer_type (btype), arg);
+ if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)
+ {
+ /*
+ * Copy the value, but change the type from (T&) to (T*).
+ * We keep the same location information, which is efficient,
+ * and allows &(&X) to get the location containing the reference.
+ */
+ arg = value_copy (arg);
+ VALUE_TYPE (arg) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg)));
+ }
+ if (VALUE_ADDRESS(value_field (value_ind(arg), TYPE_VPTR_FIELDNO (btype)))==0)
+ return arg;
+
vtbl = value_ind (value_field (value_ind (arg), TYPE_VPTR_FIELDNO (btype)));
+ /* Turn vtable into typeinfo function */
+ VALUE_OFFSET(vtbl)+=4;
- /* Check that VTBL looks like it points to a virtual function table. */
- msymbol = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl));
+ msymbol = lookup_minimal_symbol_by_pc ( value_as_pointer(value_ind(vtbl)) );
if (msymbol == NULL
- || (demangled_name = SYMBOL_NAME (msymbol)) == NULL
- || !VTBL_PREFIX_P (demangled_name))
- {
- /* If we expected to find a vtable, but did not, let the user
- know that we aren't happy, but don't throw an error.
- FIXME: there has to be a better way to do this. */
- struct type *error_type = (struct type *) xmalloc (sizeof (struct type));
- memcpy (error_type, VALUE_TYPE (in_arg), sizeof (struct type));
- TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
- VALUE_TYPE (in_arg) = error_type;
- return in_arg;
- }
+ || (demangled_name = SYMBOL_NAME (msymbol)) == NULL)
+ {
+ /* If we expected to find a vtable, but did not, let the user
+ know that we aren't happy, but don't throw an error.
+ FIXME: there has to be a better way to do this. */
+ struct type *error_type = (struct type *) xmalloc (sizeof (struct type));
+ memcpy (error_type, VALUE_TYPE (in_arg), sizeof (struct type));
+ TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
+ VALUE_TYPE (in_arg) = error_type;
+ return in_arg;
+ }
+ demangled_name = cplus_demangle(demangled_name,DMGL_ANSI);
+ *(strchr (demangled_name, ' ')) = '\0';
- /* Now search through the virtual function table. */
- entry = value_ind (vtbl);
- nelems = longest_to_int (value_as_long (value_field (entry, 2)));
- for (i = 1; i <= nelems; i++)
- {
- entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
- (LONGEST) i));
- /* This won't work if we're using thunks. */
- if (TYPE_CODE (check_typedef (VALUE_TYPE (entry))) != TYPE_CODE_STRUCT)
- break;
- offset = longest_to_int (value_as_long (value_field (entry, 0)));
- /* If we use '<=' we can handle single inheritance
- * where all offsets are zero - just use the first entry found. */
- if (offset <= best_offset)
- {
- best_offset = offset;
- best_entry = entry;
- }
- }
- /* Move the pointer according to BEST_ENTRY's offset, and figure
- out what type we should return as the new pointer. */
- if (best_entry == 0)
- {
- /* An alternative method (which should no longer be necessary).
- * But we leave it in for future use, when we will hopefully
- * have optimizes the vtable to use thunks instead of offsets. */
- /* Use the name of vtable itself to extract a base type. */
- demangled_name += 4; /* Skip _vt$ prefix. */
- }
- else
- {
- pc_for_sym = value_as_pointer (value_field (best_entry, 2));
- sym = find_pc_function (pc_for_sym);
- demangled_name = cplus_demangle (SYMBOL_NAME (sym), DMGL_ANSI);
- *(strchr (demangled_name, ':')) = '\0';
- }
sym = lookup_symbol (demangled_name, 0, VAR_NAMESPACE, 0, 0);
if (sym == NULL)
- error ("could not find type declaration for `%s'", demangled_name);
- if (best_entry)
- {
- free (demangled_name);
- arg = value_add (value_cast (builtin_type_int, arg),
- value_field (best_entry, 0));
- }
- else
- arg = in_arg;
+ error ("could not find type declaration for `%s'", demangled_name);
+
+ arg = in_arg;
VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym));
return arg;
}
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;
case TYPE_CODE_REF:
case TYPE_CODE_PTR:
- /* This assumes that all pointers of a given length
- have the same form. */
- store_address (VALUE_CONTENTS_RAW (val), len, (CORE_ADDR) num);
+ store_typed_address (VALUE_CONTENTS_RAW (val), type, (CORE_ADDR) num);
break;
default:
return val;
}
+
+/* Create a value representing a pointer of type TYPE to the address
+ ADDR. */
+value_ptr
+value_from_pointer (struct type *type, CORE_ADDR addr)
+{
+ value_ptr val = allocate_value (type);
+ store_typed_address (VALUE_CONTENTS_RAW (val), type, addr);
+ return val;
+}
+
+
/* Create a value for a string constant to be stored locally
- (not in the inferior's memory space, but in GDB memory).
+ (not in the inferior's memory space, but in GDB memory).
This is analogous to value_from_longest, which also does not
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
#define USE_STRUCT_CONVENTION(gcc_p,type) generic_use_struct_convention (gcc_p, type)
#endif
-/* Some fundamental types (such as long double) are returned on the stack for
- certain architectures. This macro should return true for any type besides
- struct, union or array that gets returned on the stack. */
-
-#ifndef RETURN_VALUE_ON_STACK
-#define RETURN_VALUE_ON_STACK(TYPE) 0
-#endif
/* Return true if the function specified is using the structure returning
convention on this machine to return arguments, or 0 if it is using
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\