#include "infcall.h"
#include "dictionary.h"
#include "cp-support.h"
+#include "dfp.h"
+#include "user-regs.h"
#include <errno.h>
#include "gdb_string.h"
oload_classification classify_oload_match (struct badness_vector *,
int, int);
-static int check_field_in (struct type *, const char *);
-
static struct value *value_struct_elt_for_reference (struct type *,
int, struct type *,
char *,
find_function_in_inferior (const char *name)
{
struct symbol *sym;
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL);
+ sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
if (sym != NULL)
{
if (SYMBOL_CLASS (sym) != LOC_BLOCK)
return value_as_long (value_allocate_space_in_inferior (len));
}
+/* Cast struct value VAL to type TYPE and return as a value.
+ Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
+ for this to work. Typedef to one of the codes is permitted. */
+
+static struct value *
+value_cast_structs (struct type *type, struct value *v2)
+{
+ struct type *t1;
+ struct type *t2;
+ struct value *v;
+
+ gdb_assert (type != NULL && v2 != NULL);
+
+ t1 = check_typedef (type);
+ t2 = check_typedef (value_type (v2));
+
+ /* Check preconditions. */
+ gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
+ || TYPE_CODE (t1) == TYPE_CODE_UNION)
+ && !!"Precondition is that type is of STRUCT or UNION kind.");
+ gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
+ || TYPE_CODE (t2) == TYPE_CODE_UNION)
+ && !!"Precondition is that value is of STRUCT or UNION kind");
+
+ /* Upcasting: look in the type of the source to see if it contains the
+ type of the target as a superclass. If so, we'll need to
+ offset the pointer rather than just change its type. */
+ if (TYPE_NAME (t1) != NULL)
+ {
+ v = search_struct_field (type_name_no_tag (t1),
+ v2, 0, t2, 1);
+ if (v)
+ return v;
+ }
+
+ /* Downcasting: look in the type of the target to see if it contains the
+ type of the source as a superclass. If so, we'll need to
+ offset the pointer rather than just change its type.
+ FIXME: This fails silently with virtual inheritance. */
+ if (TYPE_NAME (t2) != NULL)
+ {
+ v = search_struct_field (type_name_no_tag (t2),
+ value_zero (t1, not_lval), 0, t1, 1);
+ if (v)
+ {
+ /* Downcasting is possible (t1 is superclass of v2). */
+ CORE_ADDR addr2 = VALUE_ADDRESS (v2);
+ addr2 -= (VALUE_ADDRESS (v)
+ + value_offset (v)
+ + value_embedded_offset (v));
+ return value_at (type, addr2);
+ }
+ }
+ return v2;
+}
+
/* Cast one pointer or reference type to another. Both TYPE and
the type of ARG2 should be pointer types, or else both should be
reference types. Returns the new pointer or reference. */
struct value *
value_cast_pointers (struct type *type, struct value *arg2)
{
+ struct type *type1 = check_typedef (type);
struct type *type2 = check_typedef (value_type (arg2));
struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
&& TYPE_CODE (t2) == TYPE_CODE_STRUCT
&& !value_logical_not (arg2))
{
- struct value *v;
-
- /* Look in the type of the source to see if it contains the
- type of the target as a superclass. If so, we'll need to
- offset the pointer rather than just change its type. */
- if (TYPE_NAME (t1) != NULL)
- {
- struct value *v2;
-
- if (TYPE_CODE (type2) == TYPE_CODE_REF)
- v2 = coerce_ref (arg2);
- else
- v2 = value_ind (arg2);
- v = search_struct_field (type_name_no_tag (t1),
- v2, 0, t2, 1);
- if (v)
- {
- v = value_addr (v);
- deprecated_set_value_type (v, type);
- return v;
- }
- }
+ struct value *v2;
- /* Look in the type of the target to see if it contains the
- type of the source as a superclass. If so, we'll need to
- offset the pointer rather than just change its type.
- FIXME: This fails silently with virtual inheritance. */
- if (TYPE_NAME (t2) != NULL)
+ if (TYPE_CODE (type2) == TYPE_CODE_REF)
+ v2 = coerce_ref (arg2);
+ else
+ v2 = value_ind (arg2);
+ gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) == TYPE_CODE_STRUCT
+ && !!"Why did coercion fail?");
+ v2 = value_cast_structs (t1, v2);
+ /* At this point we have what we can have, un-dereference if needed. */
+ if (v2)
{
- v = search_struct_field (type_name_no_tag (t2),
- value_zero (t1, not_lval), 0, t1, 1);
- if (v)
- {
- CORE_ADDR addr2 = value_as_address (arg2);
- addr2 -= (VALUE_ADDRESS (v)
- + value_offset (v)
- + value_embedded_offset (v));
- return value_from_pointer (type, addr2);
- }
+ struct value *v = value_addr (v2);
+ deprecated_set_value_type (v, type);
+ return v;
}
- }
+ }
/* No superclass found, just change the pointer type. */
arg2 = value_copy (arg2);
if (value_type (arg2) == type)
return arg2;
+ code1 = TYPE_CODE (check_typedef (type));
+
+ /* Check if we are casting struct reference to struct reference. */
+ if (code1 == TYPE_CODE_REF)
+ {
+ /* We dereference type; then we recurse and finally
+ we generate value of the given reference. Nothing wrong with
+ that. */
+ struct type *t1 = check_typedef (type);
+ struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
+ struct value *val = value_cast (dereftype, arg2);
+ return value_ref (val);
+ }
+
+ code2 = TYPE_CODE (check_typedef (value_type (arg2)));
+
+ if (code2 == TYPE_CODE_REF)
+ /* We deref the value and then do the cast. */
+ return value_cast (type, coerce_ref (arg2));
+
CHECK_TYPEDEF (type);
code1 = TYPE_CODE (type);
arg2 = coerce_ref (arg2);
code2 = TYPE_CODE_INT;
scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
- || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
+ || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
+ || code2 == TYPE_CODE_RANGE);
- if (code1 == TYPE_CODE_STRUCT
- && code2 == TYPE_CODE_STRUCT
+ if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
+ && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
&& TYPE_NAME (type) != 0)
- {
- /* Look in the type of the source to see if it contains the
- type of the target as a superclass. If so, we'll need to
- offset the object in addition to changing its type. */
- struct value *v = search_struct_field (type_name_no_tag (type),
- arg2, 0, type2, 1);
- if (v)
- {
- deprecated_set_value_type (v, type);
- return v;
- }
- }
+ return value_cast_structs (type, arg2);
if (code1 == TYPE_CODE_FLT && scalar)
return value_from_double (type, value_as_double (arg2));
+ else if (code1 == TYPE_CODE_DECFLOAT && scalar)
+ {
+ int dec_len = TYPE_LENGTH (type);
+ gdb_byte dec[16];
+
+ if (code2 == TYPE_CODE_FLT)
+ decimal_from_floating (arg2, dec, dec_len);
+ else if (code2 == TYPE_CODE_DECFLOAT)
+ decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
+ dec, dec_len);
+ else
+ /* The only option left is an integral type. */
+ decimal_from_integral (arg2, dec, dec_len);
+
+ return value_from_decfloat (type, dec);
+ }
else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
|| code1 == TYPE_CODE_RANGE)
&& (scalar || code2 == TYPE_CODE_PTR
return val;
}
+/* Create a value of numeric type TYPE that is one, and return it. */
+
+struct value *
+value_one (struct type *type, enum lval_type lv)
+{
+ struct type *type1 = check_typedef (type);
+ struct value *val = NULL; /* avoid -Wall warning */
+
+ if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
+ {
+ struct value *int_one = value_from_longest (builtin_type_int, 1);
+ struct value *val;
+ gdb_byte v[16];
+
+ decimal_from_integral (int_one, v, TYPE_LENGTH (builtin_type_int));
+ val = value_from_decfloat (type, v);
+ }
+ else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
+ {
+ val = value_from_double (type, (DOUBLEST) 1);
+ }
+ else if (is_integral_type (type1))
+ {
+ val = value_from_longest (type, (LONGEST) 1);
+ }
+ else
+ {
+ error (_("Not a numeric type."));
+ }
+
+ VALUE_LVAL (val) = lv;
+ return val;
+}
+
/* Return a value with type TYPE located at ADDR.
Call value_at only if the data needs to be fetched immediately;
int
value_fetch_lazy (struct value *val)
{
- CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
- int length = TYPE_LENGTH (value_enclosing_type (val));
+ if (VALUE_LVAL (val) == lval_memory)
+ {
+ CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
+ int length = TYPE_LENGTH (value_enclosing_type (val));
+
+ struct type *type = value_type (val);
+ if (length)
+ read_memory (addr, value_contents_all_raw (val), length);
+ }
+ else if (VALUE_LVAL (val) == lval_register)
+ {
+ struct frame_info *frame;
+ int regnum;
+ struct type *type = check_typedef (value_type (val));
+ struct value *new_val = val, *mark = value_mark ();
+
+ /* Offsets are not supported here; lazy register values must
+ refer to the entire register. */
+ gdb_assert (value_offset (val) == 0);
+
+ while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
+ {
+ frame = frame_find_by_id (VALUE_FRAME_ID (new_val));
+ regnum = VALUE_REGNUM (new_val);
- struct type *type = value_type (val);
- if (length)
- read_memory (addr, value_contents_all_raw (val), length);
+ gdb_assert (frame != NULL);
+
+ /* Convertible register routines are used for multi-register
+ values and for interpretation in different types
+ (e.g. float or int from a double register). Lazy
+ register values should have the register's natural type,
+ so they do not apply. */
+ gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame),
+ regnum, type));
+
+ new_val = get_frame_register_value (frame, regnum);
+ }
+
+ /* If it's still lazy (for instance, a saved register on the
+ stack), fetch it. */
+ if (value_lazy (new_val))
+ value_fetch_lazy (new_val);
+
+ /* If the register was not saved, mark it unavailable. */
+ if (value_optimized_out (new_val))
+ set_value_optimized_out (val, 1);
+ else
+ memcpy (value_contents_raw (val), value_contents (new_val),
+ TYPE_LENGTH (type));
+
+ if (frame_debug)
+ {
+ struct gdbarch *gdbarch;
+ frame = frame_find_by_id (VALUE_FRAME_ID (val));
+ regnum = VALUE_REGNUM (val);
+ gdbarch = get_frame_arch (frame);
+
+ fprintf_unfiltered (gdb_stdlog, "\
+{ value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
+ frame_relative_level (frame), regnum,
+ user_reg_map_regnum_to_name (gdbarch, regnum));
+
+ fprintf_unfiltered (gdb_stdlog, "->");
+ if (value_optimized_out (new_val))
+ fprintf_unfiltered (gdb_stdlog, " optimized out");
+ else
+ {
+ int i;
+ const gdb_byte *buf = value_contents (new_val);
+
+ if (VALUE_LVAL (new_val) == lval_register)
+ fprintf_unfiltered (gdb_stdlog, " register=%d",
+ VALUE_REGNUM (new_val));
+ else if (VALUE_LVAL (new_val) == lval_memory)
+ fprintf_unfiltered (gdb_stdlog, " address=0x%s",
+ paddr_nz (VALUE_ADDRESS (new_val)));
+ else
+ fprintf_unfiltered (gdb_stdlog, " computed");
+
+ fprintf_unfiltered (gdb_stdlog, " bytes=");
+ fprintf_unfiltered (gdb_stdlog, "[");
+ for (i = 0; i < register_size (gdbarch, regnum); i++)
+ fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
+ fprintf_unfiltered (gdb_stdlog, "]");
+ }
+
+ fprintf_unfiltered (gdb_stdlog, " }\n");
+ }
+
+ /* Dispose of the intermediate values. This prevents
+ watchpoints from trying to watch the saved frame pointer. */
+ value_free_to_mark (mark);
+ }
+ else
+ internal_error (__FILE__, __LINE__, "Unexpected lazy value type.");
set_value_lazy (val, 0);
return 0;
type = value_type (toval);
if (VALUE_LVAL (toval) != lval_internalvar)
- fromval = value_cast (type, fromval);
+ {
+ toval = value_coerce_to_target (toval);
+ fromval = value_cast (type, fromval);
+ }
else
- fromval = coerce_array (fromval);
+ {
+ /* Coerce arrays and functions to pointers, except for arrays
+ which only live in GDB's storage. */
+ if (!value_must_coerce_to_target (fromval))
+ fromval = coerce_array (fromval);
+ }
+
CHECK_TYPEDEF (type);
/* Since modifying a register can trash the frame chain, and
return val;
}
+/* Return one if VAL does not live in target memory, but should in order
+ to operate on it. Otherwise return zero. */
+
+int
+value_must_coerce_to_target (struct value *val)
+{
+ struct type *valtype;
+
+ /* The only lval kinds which do not live in target memory. */
+ if (VALUE_LVAL (val) != not_lval
+ && VALUE_LVAL (val) != lval_internalvar)
+ return 0;
+
+ valtype = check_typedef (value_type (val));
+
+ switch (TYPE_CODE (valtype))
+ {
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRING:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+/* Make sure that VAL lives in target memory if it's supposed to. For instance,
+ strings are constructed as character arrays in GDB's storage, and this
+ function copies them to the target. */
+
+struct value *
+value_coerce_to_target (struct value *val)
+{
+ LONGEST length;
+ CORE_ADDR addr;
+
+ if (!value_must_coerce_to_target (val))
+ return val;
+
+ length = TYPE_LENGTH (check_typedef (value_type (val)));
+ addr = allocate_space_in_inferior (length);
+ write_memory (addr, value_contents (val), length);
+ return value_at_lazy (value_type (val), addr);
+}
+
/* Given a value which is an array, return a value which is a pointer
to its first element, regardless of whether or not the array has a
nonzero lower bound.
{
struct type *type = check_typedef (value_type (arg1));
+ /* If the user tries to do something requiring a pointer with an
+ array that has not yet been pushed to the target, then this would
+ be a good time to do so. */
+ arg1 = value_coerce_to_target (arg1);
+
if (VALUE_LVAL (arg1) != lval_memory)
error (_("Attempt to take address of value not located in memory."));
if (TYPE_CODE (type) == TYPE_CODE_FUNC)
return value_coerce_function (arg1);
+ /* If this is an array that has not yet been pushed to the target,
+ then this would be a good time to force it to memory. */
+ arg1 = value_coerce_to_target (arg1);
+
if (VALUE_LVAL (arg1) != lval_memory)
error (_("Attempt to take address of value not located in memory."));
return 0; /* For lint -- never reached. */
}
\f
-/* Create a value for an array by allocating space in the inferior,
+/* Create a value for an array by allocating space in GDB, copying
copying the data into that space, and then setting up an array
value.
return val;
}
- /* Allocate space to store the array in the inferior, and then
- initialize it by copying in each element. FIXME: Is it worth it
- to create a local buffer in which to collect each value and then
- write all the bytes in one operation? */
+ /* Allocate space to store the array, and then initialize it by
+ copying in each element. */
- addr = allocate_space_in_inferior (nelem * typelength);
+ val = allocate_value (arraytype);
for (idx = 0; idx < nelem; idx++)
- {
- write_memory (addr + (idx * typelength),
- value_contents_all (elemvec[idx]),
- typelength);
- }
-
- /* Create the array type and set up an array value to be evaluated
- lazily. */
-
- val = value_at_lazy (arraytype, addr);
- return (val);
+ memcpy (value_contents_writeable (val) + (idx * typelength),
+ value_contents_all (elemvec[idx]),
+ typelength);
+ return val;
}
/* Create a value for a string constant by allocating space in the
VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
set_value_offset (v2, value_offset (arg1) + boffset);
- if (value_lazy (arg1))
+ if (VALUE_LVAL (arg1) == lval_memory && value_lazy (arg1))
set_value_lazy (v2, 1);
else
memcpy (value_contents_raw (v2),
back. If it's not callable (i.e., a pointer to function),
gdb should give an error. */
v = search_struct_field (name, *argp, 0, t, 0);
+ /* If we found an ordinary field, then it is not a method call.
+ So, treat it as if it were a static member function. */
+ if (v && static_memfuncp)
+ *static_memfuncp = 1;
}
if (!v)
if (objp)
{
if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
- && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR)
+ && (TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR
+ || TYPE_CODE (value_type (*objp)) == TYPE_CODE_REF))
{
temp = value_addr (temp);
}
return 0;
}
-/* Helper function for check_field: Given TYPE, a structure/union,
+/* Given TYPE, a structure/union,
return 1 if the component named NAME from the ultimate target
structure/union is defined, otherwise, return 0. */
-static int
-check_field_in (struct type *type, const char *name)
+int
+check_field (struct type *type, const char *name)
{
int i;
}
for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
- if (check_field_in (TYPE_BASECLASS (type, i), name))
+ if (check_field (TYPE_BASECLASS (type, i), name))
return 1;
return 0;
}
-
-/* C++: Given ARG1, a value of type (pointer to a)* structure/union,
- return 1 if the component named NAME from the ultimate target
- structure/union is defined, otherwise, return 0. */
-
-int
-check_field (struct value *arg1, const char *name)
-{
- struct type *t;
-
- arg1 = coerce_array (arg1);
-
- t = value_type (arg1);
-
- /* Follow pointers until we get to a non-pointer. */
-
- for (;;)
- {
- CHECK_TYPEDEF (t);
- if (TYPE_CODE (t) != TYPE_CODE_PTR
- && TYPE_CODE (t) != TYPE_CODE_REF)
- break;
- t = TYPE_TARGET_TYPE (t);
- }
-
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
- error (_("Internal error: `this' is not an aggregate"));
-
- return check_field_in (t, name);
-}
-
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
return the appropriate member (or the address of the member, if
WANT_ADDRESS). This function is used to resolve user expressions
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0, NULL);
+ 0, VAR_DOMAIN, 0);
if (s == NULL)
return NULL;
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0, NULL);
+ 0, VAR_DOMAIN, 0);
if (s == NULL)
return NULL;
sym = cp_lookup_symbol_namespace (namespace_name, name, NULL,
get_selected_block (0),
- VAR_DOMAIN, NULL);
+ VAR_DOMAIN);
if (sym == NULL)
return NULL;
struct value *
value_of_this (int complain)
{
- if (current_language->la_language == language_objc)
- return value_of_local ("self", complain);
- else
- return value_of_local ("this", complain);
+ if (!current_language->la_name_of_this)
+ return 0;
+ return value_of_local (current_language->la_name_of_this, complain);
}
/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
else if (element > 0)
{
int j = i % TARGET_CHAR_BIT;
- if (BITS_BIG_ENDIAN)
+ if (gdbarch_bits_big_endian (current_gdbarch))
j = TARGET_CHAR_BIT - 1 - j;
value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
}
TYPE_CODE (slice_type) = TYPE_CODE (array_type);
slice = allocate_value (slice_type);
- if (value_lazy (array))
+ if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
set_value_lazy (slice, 1);
else
memcpy (value_contents_writeable (slice),
projects / deliverable / binutils-gdb.git / blobdiff