/* Low level packing and unpacking of values for GDB, the GNU Debugger.
- Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995, 1996
+ Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995, 1996, 1997
Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "target.h"
#include "language.h"
+#include "scm-lang.h"
#include "demangle.h"
/* Local function prototypes. */
static void show_convenience PARAMS ((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
records 60 consecutive values. The first chunk on
VALUE_REGNO (val) = -1;
VALUE_LAZY (val) = 0;
VALUE_OPTIMIZED_OUT (val) = 0;
+ VALUE_BFD_SECTION (val) = NULL;
val->modifiable = 1;
return val;
}
struct type *type;
int count;
{
- struct type *element_type = type;
int low_bound = current_language->string_lower_bound; /* ??? */
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
VALUE_REGNO (val) = VALUE_REGNO (arg);
VALUE_LAZY (val) = VALUE_LAZY (arg);
VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg);
+ VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (arg);
val->modifiable = arg->modifiable;
if (!VALUE_LAZY (val))
{
{
int i;
- /* Check error now if about to store an invalid float. We return -1
- to the caller, but allow them to continue, e.g. to print it as "Nan". */
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
- {
- unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i);
- if (i) return -1; /* Indicate value not saved in history */
- }
-
/* We don't want this value to have anything to do with the inferior anymore.
In particular, "set $1 = 50" should not affect the variable from which
the value was taken, and fast watchpoints should be able to assume that
return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
}
-double
+DOUBLEST
value_as_double (val)
register value_ptr val;
{
- double foo;
+ DOUBLEST foo;
int inv;
foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
case TYPE_CODE_REF:
/* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
whether we want this to be true eventually. */
+#ifdef GDB_TARGET_IS_D10V
+ if (len == 2)
+ return D10V_MAKE_DADDR(extract_address (valaddr, len));
+#endif
return extract_address (valaddr, len);
case TYPE_CODE_MEMBER:
the returned double is OK to use. Argument is in target
format, result is in host format. */
-double
+DOUBLEST
unpack_double (type, valaddr, invp)
struct type *type;
char *valaddr;
else if (nosign)
{
/* Unsigned -- be sure we compensate for signed LONGEST. */
- return (unsigned LONGEST) unpack_long (type, valaddr);
+#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
{
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;
+{
+ CORE_ADDR addr;
+ asection *sect;
+ if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno))
+ {
+ addr = TYPE_FIELD_STATIC_PHYSADDR (type, fieldno);
+ sect = NULL;
+ }
+ else
+ {
+ char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
+ struct symbol *sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
+ if (sym == NULL)
+ return NULL;
+ addr = SYMBOL_VALUE_ADDRESS (sym);
+ sect = SYMBOL_BFD_SECTION (sym);
+ SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), addr);
+ }
+ return value_at (TYPE_FIELD_TYPE (type, fieldno), addr, sect);
+}
+
/* 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 fields.
- FIELDNO says which field.
-
- For C++, must also be able to return values from static fields */
+ 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)
/* Handle packed fields */
- offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
{
v = value_from_longest (type,
- unpack_field_as_long (arg_type,
- VALUE_CONTENTS (arg1),
- fieldno));
+ unpack_field_as_long (arg_type,
+ VALUE_CONTENTS (arg1)
+ + offset,
+ fieldno));
VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
}
if (VALUE_LAZY (arg1))
VALUE_LAZY (v) = 1;
else
- memcpy (VALUE_CONTENTS_RAW (v), VALUE_CONTENTS_RAW (arg1) + offset,
+ memcpy (VALUE_CONTENTS_RAW (v),
+ VALUE_CONTENTS_RAW (arg1) + offset
+ + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8,
TYPE_LENGTH (type));
}
VALUE_LVAL (v) = VALUE_LVAL (arg1);
if (VALUE_LVAL (arg1) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
- VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
+ VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset
+ + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
return v;
}
/* Given a value ARG1 of a struct or union type,
- extract and return the value of one of its fields.
- FIELDNO says which field.
-
- For C++, must also be able to return values from static fields */
+ extract and return the value of one of its (non-static) fields.
+ FIELDNO says which field. */
value_ptr
value_field (arg1, fieldno)
char *valaddr;
int fieldno;
{
- unsigned LONGEST val;
- unsigned LONGEST valmask;
+ ULONGEST val;
+ ULONGEST valmask;
int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
int lsbcount;
+ struct type *field_type;
val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val));
+ field_type = TYPE_FIELD_TYPE (type, fieldno);
+ CHECK_TYPEDEF (field_type);
/* Extract bits. See comment above. */
/* If the field does not entirely fill a LONGEST, then zero the sign bits.
If the field is signed, and is negative, then sign extend. */
- if ((bitsize > 0) && (bitsize < 8 * sizeof (val)))
+ if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
{
- valmask = (((unsigned LONGEST) 1) << bitsize) - 1;
+ valmask = (((ULONGEST) 1) << bitsize) - 1;
val &= valmask;
- if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type, fieldno)))
+ if (!TYPE_UNSIGNED (field_type))
{
if (val & (valmask ^ (valmask >> 1)))
{
/* If a negative fieldval fits in the field in question, chop
off the sign extension bits. */
- if (bitsize < (8 * sizeof (fieldval))
+ if (bitsize < (8 * (int) sizeof (fieldval))
&& (~fieldval & ~((1 << (bitsize - 1)) - 1)) == 0)
fieldval = fieldval & ((1 << bitsize) - 1);
/* Warn if value is too big to fit in the field in question. */
- if (bitsize < (8 * sizeof (fieldval))
+ if (bitsize < (8 * (int) sizeof (fieldval))
&& 0 != (fieldval & ~((1<<bitsize)-1)))
{
/* FIXME: would like to include fieldval in the message, but
bitpos = sizeof (oword) * 8 - bitpos - bitsize;
/* Mask out old value, while avoiding shifts >= size of oword */
- if (bitsize < 8 * sizeof (oword))
- oword &= ~(((((unsigned LONGEST)1) << bitsize) - 1) << bitpos);
+ if (bitsize < 8 * (int) sizeof (oword))
+ oword &= ~(((((ULONGEST)1) << bitsize) - 1) << bitpos);
else
- oword &= ~((~(unsigned LONGEST)0) << bitpos);
+ oword &= ~((~(ULONGEST)0) << bitpos);
oword |= fieldval << bitpos;
store_signed_integer (addr, sizeof oword, oword);
have the same form. */
store_address (VALUE_CONTENTS_RAW (val), len, (CORE_ADDR) num);
break;
-
+
default:
- error ("Unexpected type encountered for integer constant.");
+ error ("Unexpected type (%d) encountered for integer constant.", code);
}
return val;
}
value_ptr
value_from_double (type, num)
struct type *type;
- double num;
+ DOUBLEST num;
{
register value_ptr val = allocate_value (type);
struct type *base_type = check_typedef (type);
addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
if (!addr)
error ("Function return value unknown");
- return value_at (valtype, addr);
+ return value_at (valtype, addr, NULL);
}
#endif
))
#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
the value returning convention. FUNCTION is the value representing
if (code == TYPE_CODE_ERROR)
error ("Function return type unknown.");
- if (code == TYPE_CODE_STRUCT ||
- code == TYPE_CODE_UNION ||
- code == TYPE_CODE_ARRAY)
+ if (code == TYPE_CODE_STRUCT
+ || code == TYPE_CODE_UNION
+ || code == TYPE_CODE_ARRAY
+ || RETURN_VALUE_ON_STACK (value_type))
return USE_STRUCT_CONVENTION (gcc_p, value_type);
return 0;