/* Low level packing and unpacking of values for GDB, the GNU Debugger.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
#include "objfiles.h"
#include "valprint.h"
#include "cli/cli-decode.h"
-#include "exceptions.h"
#include "extension.h"
#include <ctype.h>
#include "tracepoint.h"
struct range
{
/* Lowest offset in the range. */
- int offset;
+ LONGEST offset;
/* Length of the range. */
- int length;
+ LONGEST length;
};
typedef struct range range_s;
[offset2, offset2+len2) overlap. */
static int
-ranges_overlap (int offset1, int len1,
- int offset2, int len2)
+ranges_overlap (LONGEST offset1, LONGEST len1,
+ LONGEST offset2, LONGEST len2)
{
ULONGEST h, l;
OFFSET+LENGTH). */
static int
-ranges_contain (VEC(range_s) *ranges, int offset, int length)
+ranges_contain (VEC(range_s) *ranges, LONGEST offset, LONGEST length)
{
range_s what;
- int i;
+ LONGEST i;
what.offset = offset;
what.length = length;
} computed;
} location;
- /* Describes offset of a value within lval of a structure in bytes.
- If lval == lval_memory, this is an offset to the address. If
- lval == lval_register, this is a further offset from
- location.address within the registers structure. Note also the
- member embedded_offset below. */
- int offset;
+ /* Describes offset of a value within lval of a structure in target
+ addressable memory units. If lval == lval_memory, this is an offset to
+ the address. If lval == lval_register, this is a further offset from
+ location.address within the registers structure. Note also the member
+ embedded_offset below. */
+ LONGEST offset;
/* Only used for bitfields; number of bits contained in them. */
- int bitsize;
+ LONGEST bitsize;
/* Only used for bitfields; position of start of field. For
gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
- int bitpos;
+ LONGEST bitpos;
/* The number of references to this value. When a value is created,
the value chain holds a reference, so REFERENCE_COUNT is 1. If
When we store the entire object, `enclosing_type' is the run-time
type -- the complete object -- and `embedded_offset' is the
- offset of `type' within that larger type, in bytes. The
- value_contents() macro takes `embedded_offset' into account, so
- most GDB code continues to see the `type' portion of the value,
- just as the inferior would.
+ offset of `type' within that larger type, in target addressable memory
+ units. The value_contents() macro takes `embedded_offset' into account,
+ so most GDB code continues to see the `type' portion of the value, just
+ as the inferior would.
If `type' is a pointer to an object, then `enclosing_type' is a
pointer to the object's run-time type, and `pointed_to_offset' is
- the offset in bytes from the full object to the pointed-to object
- -- that is, the value `embedded_offset' would have if we followed
- the pointer and fetched the complete object. (I don't really see
- the point. Why not just determine the run-time type when you
- indirect, and avoid the special case? The contents don't matter
- until you indirect anyway.)
+ the offset in target addressable memory units from the full object
+ to the pointed-to object -- that is, the value `embedded_offset' would
+ have if we followed the pointer and fetched the complete object.
+ (I don't really see the point. Why not just determine the
+ run-time type when you indirect, and avoid the special case? The
+ contents don't matter until you indirect anyway.)
If we're not doing anything fancy, `enclosing_type' is equal to
`type', and `embedded_offset' is zero, so everything works
normally. */
struct type *enclosing_type;
- int embedded_offset;
- int pointed_to_offset;
+ LONGEST embedded_offset;
+ LONGEST pointed_to_offset;
/* Values are stored in a chain, so that they can be deleted easily
over calls to the inferior. Values assigned to internal
VEC(range_s) *optimized_out;
};
+/* See value.h. */
+
+struct gdbarch *
+get_value_arch (const struct value *value)
+{
+ return get_type_arch (value_type (value));
+}
+
int
-value_bits_available (const struct value *value, int offset, int length)
+value_bits_available (const struct value *value, LONGEST offset, LONGEST length)
{
gdb_assert (!value->lazy);
}
int
-value_bytes_available (const struct value *value, int offset, int length)
+value_bytes_available (const struct value *value,
+ LONGEST offset, LONGEST length)
{
return value_bits_available (value,
offset * TARGET_CHAR_BIT,
OFFSET bits, and extending for the next LENGTH bits. */
static void
-insert_into_bit_range_vector (VEC(range_s) **vectorp, int offset, int length)
+insert_into_bit_range_vector (VEC(range_s) **vectorp,
+ LONGEST offset, LONGEST length)
{
range_s newr;
int i;
}
void
-mark_value_bits_unavailable (struct value *value, int offset, int length)
+mark_value_bits_unavailable (struct value *value,
+ LONGEST offset, LONGEST length)
{
insert_into_bit_range_vector (&value->unavailable, offset, length);
}
void
-mark_value_bytes_unavailable (struct value *value, int offset, int length)
+mark_value_bytes_unavailable (struct value *value,
+ LONGEST offset, LONGEST length)
{
mark_value_bits_unavailable (value,
offset * TARGET_CHAR_BIT,
static int
find_first_range_overlap (VEC(range_s) *ranges, int pos,
- int offset, int length)
+ LONGEST offset, LONGEST length)
{
range_s *r;
int i;
static int
find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
struct ranges_and_idx *rp2,
- int offset1, int offset2,
- int length, ULONGEST *l, ULONGEST *h)
+ LONGEST offset1, LONGEST offset2,
+ LONGEST length, ULONGEST *l, ULONGEST *h)
{
rp1->idx = find_first_range_overlap (rp1->ranges, rp1->idx,
offset1, length);
}
int
-value_contents_eq (const struct value *val1, int offset1,
- const struct value *val2, int offset2,
- int length)
+value_contents_eq (const struct value *val1, LONGEST offset1,
+ const struct value *val2, LONGEST offset2,
+ LONGEST length)
{
return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT,
val2, offset2 * TARGET_CHAR_BIT,
description correctly. */
check_typedef (type);
- val = (struct value *) xzalloc (sizeof (struct value));
+ val = XCNEW (struct value);
val->contents = NULL;
val->next = all_values;
all_values = val;
return val;
}
+/* The maximum size, in bytes, that GDB will try to allocate for a value.
+ The initial value of 64k was not selected for any specific reason, it is
+ just a reasonable starting point. */
+
+static int max_value_size = 65536; /* 64k bytes */
+
+/* It is critical that the MAX_VALUE_SIZE is at least as big as the size of
+ LONGEST, otherwise GDB will not be able to parse integer values from the
+ CLI; for example if the MAX_VALUE_SIZE could be set to 1 then GDB would
+ be unable to parse "set max-value-size 2".
+
+ As we want a consistent GDB experience across hosts with different sizes
+ of LONGEST, this arbitrary minimum value was selected, so long as this
+ is bigger than LONGEST on all GDB supported hosts we're fine. */
+
+#define MIN_VALUE_FOR_MAX_VALUE_SIZE 16
+gdb_static_assert (sizeof (LONGEST) <= MIN_VALUE_FOR_MAX_VALUE_SIZE);
+
+/* Implement the "set max-value-size" command. */
+
+static void
+set_max_value_size (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ gdb_assert (max_value_size == -1 || max_value_size >= 0);
+
+ if (max_value_size > -1 && max_value_size < MIN_VALUE_FOR_MAX_VALUE_SIZE)
+ {
+ max_value_size = MIN_VALUE_FOR_MAX_VALUE_SIZE;
+ error (_("max-value-size set too low, increasing to %d bytes"),
+ max_value_size);
+ }
+}
+
+/* Implement the "show max-value-size" command. */
+
+static void
+show_max_value_size (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ if (max_value_size == -1)
+ fprintf_filtered (file, _("Maximum value size is unlimited.\n"));
+ else
+ fprintf_filtered (file, _("Maximum value size is %d bytes.\n"),
+ max_value_size);
+}
+
+/* Called before we attempt to allocate or reallocate a buffer for the
+ contents of a value. TYPE is the type of the value for which we are
+ allocating the buffer. If the buffer is too large (based on the user
+ controllable setting) then throw an error. If this function returns
+ then we should attempt to allocate the buffer. */
+
+static void
+check_type_length_before_alloc (const struct type *type)
+{
+ unsigned int length = TYPE_LENGTH (type);
+
+ if (max_value_size > -1 && length > max_value_size)
+ {
+ if (TYPE_NAME (type) != NULL)
+ error (_("value of type `%s' requires %u bytes, which is more "
+ "than max-value-size"), TYPE_NAME (type), length);
+ else
+ error (_("value requires %u bytes, which is more than "
+ "max-value-size"), length);
+ }
+}
+
/* Allocate the contents of VAL if it has not been allocated yet. */
static void
allocate_value_contents (struct value *val)
{
if (!val->contents)
- val->contents = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type));
+ {
+ check_type_length_before_alloc (val->enclosing_type);
+ val->contents
+ = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type));
+ }
}
/* Allocate a value and its contents for type TYPE. */
/* Accessor methods. */
struct value *
-value_next (struct value *value)
+value_next (const struct value *value)
{
return value->next;
}
value->type = type;
}
-int
+LONGEST
value_offset (const struct value *value)
{
return value->offset;
}
void
-set_value_offset (struct value *value, int offset)
+set_value_offset (struct value *value, LONGEST offset)
{
value->offset = offset;
}
-int
+LONGEST
value_bitpos (const struct value *value)
{
return value->bitpos;
}
void
-set_value_bitpos (struct value *value, int bit)
+set_value_bitpos (struct value *value, LONGEST bit)
{
value->bitpos = bit;
}
-int
+LONGEST
value_bitsize (const struct value *value)
{
return value->bitsize;
}
void
-set_value_bitsize (struct value *value, int bit)
+set_value_bitsize (struct value *value, LONGEST bit)
{
value->bitsize = bit;
}
struct value *
-value_parent (struct value *value)
+value_parent (const struct value *value)
{
return value->parent;
}
gdb_byte *
value_contents_raw (struct value *value)
{
+ struct gdbarch *arch = get_value_arch (value);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
+
allocate_value_contents (value);
- return value->contents + value->embedded_offset;
+ return value->contents + value->embedded_offset * unit_size;
}
gdb_byte *
}
struct type *
-value_enclosing_type (struct value *value)
+value_enclosing_type (const struct value *value)
{
return value->enclosing_type;
}
/* If result's target type is TYPE_CODE_STRUCT, proceed to
fetch its rtti type. */
if ((TYPE_CODE (result) == TYPE_CODE_PTR
- || TYPE_CODE (result) == TYPE_CODE_REF)
+ || TYPE_CODE (result) == TYPE_CODE_REF)
&& TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result)))
- == TYPE_CODE_STRUCT)
+ == TYPE_CODE_STRUCT
+ && !value_optimized_out (value))
{
struct type *real_type;
}
}
-/* Copy LENGTH bytes of SRC value's (all) contents
+/* Copy the ranges metadata in SRC that overlaps [SRC_BIT_OFFSET,
+ SRC_BIT_OFFSET+BIT_LENGTH) into DST, adjusted. */
+
+static void
+value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset,
+ const struct value *src, int src_bit_offset,
+ int bit_length)
+{
+ ranges_copy_adjusted (&dst->unavailable, dst_bit_offset,
+ src->unavailable, src_bit_offset,
+ bit_length);
+ ranges_copy_adjusted (&dst->optimized_out, dst_bit_offset,
+ src->optimized_out, src_bit_offset,
+ bit_length);
+}
+
+/* Copy LENGTH target addressable memory units of SRC value's (all) contents
(value_contents_all) starting at SRC_OFFSET, into DST value's (all)
contents, starting at DST_OFFSET. If unavailable contents are
being copied from SRC, the corresponding DST contents are marked
DST_OFFSET+LENGTH) range are wholly available. */
void
-value_contents_copy_raw (struct value *dst, int dst_offset,
- struct value *src, int src_offset, int length)
+value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset, LONGEST length)
{
- range_s *r;
- int i;
- int src_bit_offset, dst_bit_offset, bit_length;
+ LONGEST src_bit_offset, dst_bit_offset, bit_length;
+ struct gdbarch *arch = get_value_arch (src);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
/* A lazy DST would make that this copy operation useless, since as
soon as DST's contents were un-lazied (by a later value_contents
TARGET_CHAR_BIT * length));
/* Copy the data. */
- memcpy (value_contents_all_raw (dst) + dst_offset,
- value_contents_all_raw (src) + src_offset,
- length);
+ memcpy (value_contents_all_raw (dst) + dst_offset * unit_size,
+ value_contents_all_raw (src) + src_offset * unit_size,
+ length * unit_size);
/* Copy the meta-data, adjusted. */
- src_bit_offset = src_offset * TARGET_CHAR_BIT;
- dst_bit_offset = dst_offset * TARGET_CHAR_BIT;
- bit_length = length * TARGET_CHAR_BIT;
-
- ranges_copy_adjusted (&dst->unavailable, dst_bit_offset,
- src->unavailable, src_bit_offset,
- bit_length);
+ src_bit_offset = src_offset * unit_size * HOST_CHAR_BIT;
+ dst_bit_offset = dst_offset * unit_size * HOST_CHAR_BIT;
+ bit_length = length * unit_size * HOST_CHAR_BIT;
- ranges_copy_adjusted (&dst->optimized_out, dst_bit_offset,
- src->optimized_out, src_bit_offset,
- bit_length);
+ value_ranges_copy_adjusted (dst, dst_bit_offset,
+ src, src_bit_offset,
+ bit_length);
}
/* Copy LENGTH bytes of SRC value's (all) contents
DST_OFFSET+LENGTH) range are wholly available. */
void
-value_contents_copy (struct value *dst, int dst_offset,
- struct value *src, int src_offset, int length)
+value_contents_copy (struct value *dst, LONGEST dst_offset,
+ struct value *src, LONGEST src_offset, LONGEST length)
{
if (src->lazy)
value_fetch_lazy (src);
}
int
-value_lazy (struct value *value)
+value_lazy (const struct value *value)
{
return value->lazy;
}
}
int
-value_stack (struct value *value)
+value_stack (const struct value *value)
{
return value->stack;
}
/* We can only know if a value is optimized out once we have tried to
fetch it. */
if (VEC_empty (range_s, value->optimized_out) && value->lazy)
- value_fetch_lazy (value);
+ {
+ TRY
+ {
+ value_fetch_lazy (value);
+ }
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ /* Fall back to checking value->optimized_out. */
+ }
+ END_CATCH
+ }
return !VEC_empty (range_s, value->optimized_out);
}
/* See value.h. */
void
-mark_value_bits_optimized_out (struct value *value, int offset, int length)
+mark_value_bits_optimized_out (struct value *value,
+ LONGEST offset, LONGEST length)
{
insert_into_bit_range_vector (&value->optimized_out, offset, length);
}
int
value_bits_synthetic_pointer (const struct value *value,
- int offset, int length)
+ LONGEST offset, LONGEST length)
{
if (value->lval != lval_computed
|| !value->location.computed.funcs->check_synthetic_pointer)
length);
}
-int
-value_embedded_offset (struct value *value)
+LONGEST
+value_embedded_offset (const struct value *value)
{
return value->embedded_offset;
}
void
-set_value_embedded_offset (struct value *value, int val)
+set_value_embedded_offset (struct value *value, LONGEST val)
{
value->embedded_offset = val;
}
-int
-value_pointed_to_offset (struct value *value)
+LONGEST
+value_pointed_to_offset (const struct value *value)
{
return value->pointed_to_offset;
}
void
-set_value_pointed_to_offset (struct value *value, int val)
+set_value_pointed_to_offset (struct value *value, LONGEST val)
{
value->pointed_to_offset = val;
}
return 0;
if (value->parent != NULL)
return value_address (value->parent) + value->offset;
- else
- return value->location.address + value->offset;
+ if (NULL != TYPE_DATA_LOCATION (value_type (value)))
+ {
+ gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value_type (value)));
+ return TYPE_DATA_LOCATION_ADDR (value_type (value));
+ }
+
+ return value->location.address + value->offset;
}
CORE_ADDR
-value_raw_address (struct value *value)
+value_raw_address (const struct value *value)
{
if (value->lval == lval_internalvar
|| value->lval == lval_internalvar_component
}
int
-deprecated_value_modifiable (struct value *value)
+deprecated_value_modifiable (const struct value *value)
{
return value->modifiable;
}
/* Free all values allocated since MARK was obtained by value_mark
(except for those released). */
void
-value_free_to_mark (struct value *mark)
+value_free_to_mark (const struct value *mark)
{
struct value *val;
struct value *next;
/* Release all values up to mark */
struct value *
-value_release_to_mark (struct value *mark)
+value_release_to_mark (const struct value *mark)
{
struct value *val;
struct value *next;
return val;
}
+/* Return a "const" and/or "volatile" qualified version of the value V.
+ If CNST is true, then the returned value will be qualified with
+ "const".
+ if VOLTL is true, then the returned value will be qualified with
+ "volatile". */
+
+struct value *
+make_cv_value (int cnst, int voltl, struct value *v)
+{
+ struct type *val_type = value_type (v);
+ struct type *enclosing_type = value_enclosing_type (v);
+ struct value *cv_val = value_copy (v);
+
+ deprecated_set_value_type (cv_val,
+ make_cv_type (cnst, voltl, val_type, NULL));
+ set_value_enclosing_type (cv_val,
+ make_cv_type (cnst, voltl, enclosing_type, NULL));
+
+ return cv_val;
+}
+
/* Return a version of ARG that is non-lvalue. */
struct value *
return arg;
}
+/* Write contents of V at ADDR and set its lval type to be LVAL_MEMORY. */
+
+void
+value_force_lval (struct value *v, CORE_ADDR addr)
+{
+ gdb_assert (VALUE_LVAL (v) == not_lval);
+
+ write_memory (addr, value_contents_raw (v), TYPE_LENGTH (value_type (v)));
+ v->lval = lval_memory;
+ v->location.address = addr;
+}
+
void
set_value_component_location (struct value *component,
const struct value *whole)
{
+ struct type *type;
+
gdb_assert (whole->lval != lval_xcallable);
if (whole->lval == lval_internalvar)
if (funcs->copy_closure)
component->location.computed.closure = funcs->copy_closure (whole);
}
+
+ /* If type has a dynamic resolved location property
+ update it's value address. */
+ type = value_type (whole);
+ if (NULL != TYPE_DATA_LOCATION (type)
+ && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
+ set_value_address (component, TYPE_DATA_LOCATION_ADDR (type));
}
-\f
/* Access to the value history. */
/* Record a new value in the value history.
i = value_history_count % VALUE_HISTORY_CHUNK;
if (i == 0)
{
- struct value_history_chunk *new
- = (struct value_history_chunk *)
+ struct value_history_chunk *newobj = XCNEW (struct value_history_chunk);
- xmalloc (sizeof (struct value_history_chunk));
- memset (new->values, 0, sizeof new->values);
- new->next = value_history_chain;
- value_history_chain = new;
+ newobj->next = value_history_chain;
+ value_history_chain = newobj;
}
value_history_chain->values[i] = val;
}
}
\f
+enum internalvar_kind
+{
+ /* The internal variable is empty. */
+ INTERNALVAR_VOID,
+
+ /* The value of the internal variable is provided directly as
+ a GDB value object. */
+ INTERNALVAR_VALUE,
+
+ /* A fresh value is computed via a call-back routine on every
+ access to the internal variable. */
+ INTERNALVAR_MAKE_VALUE,
+
+ /* The internal variable holds a GDB internal convenience function. */
+ INTERNALVAR_FUNCTION,
+
+ /* The variable holds an integer value. */
+ INTERNALVAR_INTEGER,
+
+ /* The variable holds a GDB-provided string. */
+ INTERNALVAR_STRING,
+};
+
+union internalvar_data
+{
+ /* A value object used with INTERNALVAR_VALUE. */
+ struct value *value;
+
+ /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
+ struct
+ {
+ /* The functions to call. */
+ const struct internalvar_funcs *functions;
+
+ /* The function's user-data. */
+ void *data;
+ } make_value;
+
+ /* The internal function used with INTERNALVAR_FUNCTION. */
+ struct
+ {
+ struct internal_function *function;
+ /* True if this is the canonical name for the function. */
+ int canonical;
+ } fn;
+
+ /* An integer value used with INTERNALVAR_INTEGER. */
+ struct
+ {
+ /* If type is non-NULL, it will be used as the type to generate
+ a value for this internal variable. If type is NULL, a default
+ integer type for the architecture is used. */
+ struct type *type;
+ LONGEST val;
+ } integer;
+
+ /* A string value used with INTERNALVAR_STRING. */
+ char *string;
+};
+
/* Internal variables. These are variables within the debugger
that hold values assigned by debugger commands.
The user refers to them with a '$' prefix
enum internalvar_kind specifies the kind, and union internalvar_data
provides the data associated with this particular kind. */
- enum internalvar_kind
- {
- /* The internal variable is empty. */
- INTERNALVAR_VOID,
-
- /* The value of the internal variable is provided directly as
- a GDB value object. */
- INTERNALVAR_VALUE,
-
- /* A fresh value is computed via a call-back routine on every
- access to the internal variable. */
- INTERNALVAR_MAKE_VALUE,
-
- /* The internal variable holds a GDB internal convenience function. */
- INTERNALVAR_FUNCTION,
-
- /* The variable holds an integer value. */
- INTERNALVAR_INTEGER,
-
- /* The variable holds a GDB-provided string. */
- INTERNALVAR_STRING,
+ enum internalvar_kind kind;
- } kind;
-
- union internalvar_data
- {
- /* A value object used with INTERNALVAR_VALUE. */
- struct value *value;
-
- /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
- struct
- {
- /* The functions to call. */
- const struct internalvar_funcs *functions;
-
- /* The function's user-data. */
- void *data;
- } make_value;
-
- /* The internal function used with INTERNALVAR_FUNCTION. */
- struct
- {
- struct internal_function *function;
- /* True if this is the canonical name for the function. */
- int canonical;
- } fn;
-
- /* An integer value used with INTERNALVAR_INTEGER. */
- struct
- {
- /* If type is non-NULL, it will be used as the type to generate
- a value for this internal variable. If type is NULL, a default
- integer type for the architecture is used. */
- struct type *type;
- LONGEST val;
- } integer;
-
- /* A string value used with INTERNALVAR_STRING. */
- char *string;
- } u;
+ union internalvar_data u;
};
static struct internalvar *internalvars;
struct internalvar *
create_internalvar (const char *name)
{
- struct internalvar *var;
+ struct internalvar *var = XNEW (struct internalvar);
- var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
var->name = concat (name, (char *)NULL);
var->kind = INTERNALVAR_VOID;
var->next = internalvars;
}
void
-set_internalvar_component (struct internalvar *var, int offset, int bitpos,
- int bitsize, struct value *newval)
+set_internalvar_component (struct internalvar *var,
+ LONGEST offset, LONGEST bitpos,
+ LONGEST bitsize, struct value *newval)
{
gdb_byte *addr;
+ struct gdbarch *arch;
+ int unit_size;
switch (var->kind)
{
case INTERNALVAR_VALUE:
addr = value_contents_writeable (var->u.value);
+ arch = get_value_arch (var->u.value);
+ unit_size = gdbarch_addressable_memory_unit_size (arch);
if (bitsize)
modify_field (value_type (var->u.value), addr + offset,
value_as_long (newval), bitpos, bitsize);
else
- memcpy (addr + offset, value_contents (newval),
+ memcpy (addr + offset * unit_size, value_contents (newval),
TYPE_LENGTH (value_type (newval)));
break;
call error () until new_data is installed into the var->u to avoid
leaking memory. */
release_value (new_data.value);
+
+ /* Internal variables which are created from values with a dynamic
+ location don't need the location property of the origin anymore.
+ The resolved dynamic location is used prior then any other address
+ when accessing the value.
+ If we keep it, we would still refer to the origin value.
+ Remove the location property in case it exist. */
+ remove_dyn_prop (DYN_PROP_DATA_LOCATION, value_type (new_data.value));
+
break;
}
}
char *
-internalvar_name (struct internalvar *var)
+internalvar_name (const struct internalvar *var)
{
return var->name;
}
get_user_print_options (&opts);
for (var = internalvars; var; var = var->next)
{
- volatile struct gdb_exception ex;
if (!varseen)
{
}
printf_filtered (("$%s = "), var->name);
- TRY_CATCH (ex, RETURN_MASK_ERROR)
+ TRY
{
struct value *val;
val = value_of_internalvar (gdbarch, var);
value_print (val, gdb_stdout, &opts);
}
- if (ex.reason < 0)
- fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
+ }
+ END_CATCH
+
printf_filtered (("\n"));
}
if (!varseen)
return worker->value;
}
+/* Return the type of the result of TYPE_CODE_XMETHOD value METHOD. */
+
+struct type *
+result_type_of_xmethod (struct value *method, int argc, struct value **argv)
+{
+ gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD
+ && method->lval == lval_xcallable && argc > 0);
+
+ return get_xmethod_result_type (method->location.xm_worker,
+ argv[0], argv + 1, argc - 1);
+}
+
/* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */
struct value *
return extract_signed_integer (valaddr, len, byte_order);
case TYPE_CODE_FLT:
- return extract_typed_floating (valaddr, type);
+ return (LONGEST) extract_typed_floating (valaddr, type);
case TYPE_CODE_DECFLOAT:
/* libdecnumber has a function to convert from decimal to integer, but
it doesn't work when the decimal number has a fractional part. */
- return decimal_to_doublest (valaddr, len, byte_order);
+ return (LONGEST) decimal_to_doublest (valaddr, len, byte_order);
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
int nosign;
*invp = 0; /* Assume valid. */
- CHECK_TYPEDEF (type);
+ type = check_typedef (type);
code = TYPE_CODE (type);
len = TYPE_LENGTH (type);
nosign = TYPE_UNSIGNED (type);
{
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
/* TYPE_FIELD_NAME (type, fieldno); */
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+ struct block_symbol sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
- if (sym == NULL)
+ if (sym.symbol == NULL)
{
/* With some compilers, e.g. HP aCC, static data members are
reported as non-debuggable symbols. */
}
}
else
- retval = value_of_variable (sym, NULL);
+ retval = value_of_variable (sym.symbol, sym.block);
break;
}
default:
void
set_value_enclosing_type (struct value *val, struct type *new_encl_type)
{
- if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val)))
- val->contents =
- (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type));
+ if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val)))
+ {
+ check_type_length_before_alloc (new_encl_type);
+ val->contents
+ = (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type));
+ }
val->enclosing_type = new_encl_type;
}
FIELDNO says which field. */
struct value *
-value_primitive_field (struct value *arg1, int offset,
+value_primitive_field (struct value *arg1, LONGEST offset,
int fieldno, struct type *arg_type)
{
struct value *v;
struct type *type;
+ struct gdbarch *arch = get_value_arch (arg1);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
- CHECK_TYPEDEF (arg_type);
+ arg_type = check_typedef (arg_type);
type = TYPE_FIELD_TYPE (arg_type, fieldno);
/* Call check_typedef on our type to make sure that, if TYPE
bit. Assume that the address, offset, and embedded offset
are sufficiently aligned. */
- int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
- int container_bitsize = TYPE_LENGTH (type) * 8;
+ LONGEST bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
+ LONGEST container_bitsize = TYPE_LENGTH (type) * 8;
v = allocate_value_lazy (type);
v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
/* This field is actually a base subobject, so preserve the
entire object's contents for later references to virtual
bases, etc. */
- int boffset;
+ LONGEST boffset;
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
v->offset = value_offset (arg1);
v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
}
+ else if (NULL != TYPE_DATA_LOCATION (type))
+ {
+ /* Field is a dynamic data member. */
+
+ gdb_assert (0 == offset);
+ /* We expect an already resolved data location. */
+ gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (type));
+ /* For dynamic data types defer memory allocation
+ until we actual access the value. */
+ v = allocate_value_lazy (type);
+ }
else
{
/* Plain old data member */
- offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+ offset += (TYPE_FIELD_BITPOS (arg_type, fieldno)
+ / (HOST_CHAR_BIT * unit_size));
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
v = allocate_value (type);
value_contents_copy_raw (v, value_embedded_offset (v),
arg1, value_embedded_offset (arg1) + offset,
- TYPE_LENGTH (type));
+ type_length_units (type));
}
v->offset = (value_offset (arg1) + offset
+ value_embedded_offset (arg1));
struct value *
value_fn_field (struct value **arg1p, struct fn_field *f,
int j, struct type *type,
- int offset)
+ LONGEST offset)
{
struct value *v;
struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
struct symbol *sym;
struct bound_minimal_symbol msym;
- sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;
if (sym != NULL)
{
memset (&msym, 0, sizeof (msym));
\f
-/* Helper function for both unpack_value_bits_as_long and
- unpack_bits_as_long. See those functions for more details on the
- interface; the only difference is that this function accepts either
- a NULL or a non-NULL ORIGINAL_VALUE. */
+/* Unpack a bitfield of the specified FIELD_TYPE, from the object at
+ VALADDR, and store the result in *RESULT.
+ The bitfield starts at BITPOS bits and contains BITSIZE bits.
-static int
-unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr,
- int embedded_offset, int bitpos, int bitsize,
- const struct value *original_value,
- LONGEST *result)
+ Extracting bits depends on endianness of the machine. Compute the
+ number of least significant bits to discard. For big endian machines,
+ we compute the total number of bits in the anonymous object, subtract
+ off the bit count from the MSB of the object to the MSB of the
+ bitfield, then the size of the bitfield, which leaves the LSB discard
+ count. For little endian machines, the discard count is simply the
+ number of bits from the LSB of the anonymous object to the LSB of the
+ bitfield.
+
+ If the field is signed, we also do sign extension. */
+
+static LONGEST
+unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
+ LONGEST bitpos, LONGEST bitsize)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
ULONGEST val;
ULONGEST valmask;
int lsbcount;
- int bytes_read;
- int read_offset;
+ LONGEST bytes_read;
+ LONGEST read_offset;
/* Read the minimum number of bytes required; there may not be
enough bytes to read an entire ULONGEST. */
- CHECK_TYPEDEF (field_type);
+ field_type = check_typedef (field_type);
if (bitsize)
bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
else
read_offset = bitpos / 8;
- if (original_value != NULL
- && !value_bits_available (original_value, embedded_offset + bitpos,
- bitsize))
- return 0;
-
- val = extract_unsigned_integer (valaddr + embedded_offset + read_offset,
+ val = extract_unsigned_integer (valaddr + read_offset,
bytes_read, byte_order);
/* Extract bits. See comment above. */
}
}
- *result = val;
- return 1;
-}
-
-/* Unpack a bitfield of the specified FIELD_TYPE, from the object at
- VALADDR + EMBEDDED_OFFSET, and store the result in *RESULT.
- VALADDR points to the contents of ORIGINAL_VALUE, which must not be
- NULL. The bitfield starts at BITPOS bits and contains BITSIZE
- bits.
-
- Returns false if the value contents are unavailable, otherwise
- returns true, indicating a valid value has been stored in *RESULT.
-
- Extracting bits depends on endianness of the machine. Compute the
- number of least significant bits to discard. For big endian machines,
- we compute the total number of bits in the anonymous object, subtract
- off the bit count from the MSB of the object to the MSB of the
- bitfield, then the size of the bitfield, which leaves the LSB discard
- count. For little endian machines, the discard count is simply the
- number of bits from the LSB of the anonymous object to the LSB of the
- bitfield.
-
- If the field is signed, we also do sign extension. */
-
-int
-unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
- int embedded_offset, int bitpos, int bitsize,
- const struct value *original_value,
- LONGEST *result)
-{
- gdb_assert (original_value != NULL);
-
- return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset,
- bitpos, bitsize, original_value, result);
-
-}
-
-/* Unpack a field FIELDNO of the specified TYPE, from the object at
- VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
- ORIGINAL_VALUE. See unpack_value_bits_as_long for more
- details. */
-
-static int
-unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, int fieldno,
- const struct value *val, LONGEST *result)
-{
- int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
- int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
- struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
-
- return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset,
- bitpos, bitsize, val,
- result);
+ return val;
}
/* Unpack a field FIELDNO of the specified TYPE, from the object at
int
unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
- int embedded_offset, int fieldno,
+ LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result)
{
+ int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+ int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+ struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
+ int bit_offset;
+
gdb_assert (val != NULL);
- return unpack_value_field_as_long_1 (type, valaddr, embedded_offset,
- fieldno, val, result);
+ bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos;
+ if (value_bits_any_optimized_out (val, bit_offset, bitsize)
+ || !value_bits_available (val, bit_offset, bitsize))
+ return 0;
+
+ *result = unpack_bits_as_long (field_type, valaddr + embedded_offset,
+ bitpos, bitsize);
+ return 1;
}
/* Unpack a field FIELDNO of the specified TYPE, from the anonymous
- object at VALADDR. See unpack_value_bits_as_long for more details.
- This function differs from unpack_value_field_as_long in that it
- operates without a struct value object. */
+ object at VALADDR. See unpack_bits_as_long for more details. */
LONGEST
unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
{
- LONGEST result;
+ int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+ int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+ struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
- unpack_value_field_as_long_1 (type, valaddr, 0, fieldno, NULL, &result);
- return result;
+ return unpack_bits_as_long (field_type, valaddr, bitpos, bitsize);
+}
+
+/* Unpack a bitfield of BITSIZE bits found at BITPOS in the object at
+ VALADDR + EMBEDDEDOFFSET that has the type of DEST_VAL and store
+ the contents in DEST_VAL, zero or sign extending if the type of
+ DEST_VAL is wider than BITSIZE. VALADDR points to the contents of
+ VAL. If the VAL's contents required to extract the bitfield from
+ are unavailable/optimized out, DEST_VAL is correspondingly
+ marked unavailable/optimized out. */
+
+void
+unpack_value_bitfield (struct value *dest_val,
+ LONGEST bitpos, LONGEST bitsize,
+ const gdb_byte *valaddr, LONGEST embedded_offset,
+ const struct value *val)
+{
+ enum bfd_endian byte_order;
+ int src_bit_offset;
+ int dst_bit_offset;
+ struct type *field_type = value_type (dest_val);
+
+ byte_order = gdbarch_byte_order (get_type_arch (field_type));
+
+ /* First, unpack and sign extend the bitfield as if it was wholly
+ valid. Optimized out/unavailable bits are read as zero, but
+ that's OK, as they'll end up marked below. If the VAL is
+ wholly-invalid we may have skipped allocating its contents,
+ though. See allocate_optimized_out_value. */
+ if (valaddr != NULL)
+ {
+ LONGEST num;
+
+ num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
+ bitpos, bitsize);
+ store_signed_integer (value_contents_raw (dest_val),
+ TYPE_LENGTH (field_type), byte_order, num);
+ }
+
+ /* Now copy the optimized out / unavailability ranges to the right
+ bits. */
+ src_bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos;
+ if (byte_order == BFD_ENDIAN_BIG)
+ dst_bit_offset = TYPE_LENGTH (field_type) * TARGET_CHAR_BIT - bitsize;
+ else
+ dst_bit_offset = 0;
+ value_ranges_copy_adjusted (dest_val, dst_bit_offset,
+ val, src_bit_offset, bitsize);
}
/* Return a new value with type TYPE, which is FIELDNO field of the
object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents
of VAL. If the VAL's contents required to extract the bitfield
- from are unavailable, the new value is correspondingly marked as
- unavailable. */
+ from are unavailable/optimized out, the new value is
+ correspondingly marked unavailable/optimized out. */
struct value *
value_field_bitfield (struct type *type, int fieldno,
const gdb_byte *valaddr,
- int embedded_offset, const struct value *val)
+ LONGEST embedded_offset, const struct value *val)
{
- LONGEST l;
+ int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+ int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+ struct value *res_val = allocate_value (TYPE_FIELD_TYPE (type, fieldno));
- if (!unpack_value_field_as_long (type, valaddr, embedded_offset, fieldno,
- val, &l))
- {
- struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);
- struct value *retval = allocate_value (field_type);
- mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (field_type));
- return retval;
- }
- else
- {
- return value_from_longest (TYPE_FIELD_TYPE (type, fieldno), l);
- }
+ unpack_value_bitfield (res_val, bitpos, bitsize,
+ valaddr, embedded_offset, val);
+
+ return res_val;
}
/* Modify the value of a bitfield. ADDR points to a block of memory in
void
modify_field (struct type *type, gdb_byte *addr,
- LONGEST fieldval, int bitpos, int bitsize)
+ LONGEST fieldval, LONGEST bitpos, LONGEST bitsize)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
ULONGEST oword;
ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
- int bytesize;
+ LONGEST bytesize;
/* Normalize BITPOS. */
addr += bitpos / 8;
{
/* FIXME: would like to include fieldval in the message, but
we don't have a sprintf_longest. */
- warning (_("Value does not fit in %d bits."), bitsize);
+ warning (_("Value does not fit in %s bits."), plongest (bitsize));
/* Truncate it, otherwise adjoining fields may be corrupted. */
fieldval &= mask;
pack_long (gdb_byte *buf, struct type *type, LONGEST num)
{
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
- int len;
+ LONGEST len;
type = check_typedef (type);
len = TYPE_LENGTH (type);
static void
pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
{
- int len;
+ LONGEST len;
enum bfd_endian byte_order;
type = check_typedef (type);
const gdb_byte *valaddr,
CORE_ADDR address)
{
- struct type *resolved_type = resolve_dynamic_type (type, address);
+ struct type *resolved_type = resolve_dynamic_type (type, valaddr, address);
struct type *resolved_type_no_typedef = check_typedef (resolved_type);
struct value *v;
struct value *
readjust_indirect_value_type (struct value *value, struct type *enc_type,
- struct type *original_type,
- struct value *original_value)
+ const struct type *original_type,
+ const struct value *original_value)
{
/* Re-adjust type. */
deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
/* Return the initialized field in a value struct. */
int
-value_initialized (struct value *val)
+value_initialized (const struct value *val)
{
return val->initialized;
}
-/* Called only from the value_contents and value_contents_all()
- macros, if the current data for a variable needs to be loaded into
- value_contents(VAL). Fetches the data from the user's process, and
- clears the lazy flag to indicate that the data in the buffer is
- valid.
+/* Load the actual content of a lazy value. Fetch the data from the
+ user's process and clear the lazy flag to indicate that the data in
+ the buffer is valid.
If the value is zero-length, we avoid calling read_memory, which
would abort. We mark the value as fetched anyway -- all 0 bytes of
- it.
+ it. */
- This function returns a value because it is used in the
- value_contents macro as part of an expression, where a void would
- not work. The value is ignored. */
-
-int
+void
value_fetch_lazy (struct value *val)
{
gdb_assert (value_lazy (val));
word, but we have no way to record that just specific bits of a
value have been fetched. */
struct type *type = check_typedef (value_type (val));
- enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
struct value *parent = value_parent (val);
- LONGEST offset = value_offset (val);
- LONGEST num;
if (value_lazy (parent))
value_fetch_lazy (parent);
- if (value_bits_any_optimized_out (parent,
- TARGET_CHAR_BIT * offset + value_bitpos (val),
- value_bitsize (val)))
- mark_value_bytes_optimized_out (val, value_embedded_offset (val),
- TYPE_LENGTH (type));
- else if (!unpack_value_bits_as_long (value_type (val),
- value_contents_for_printing (parent),
- offset,
- value_bitpos (val),
- value_bitsize (val), parent, &num))
- mark_value_bytes_unavailable (val,
- value_embedded_offset (val),
- TYPE_LENGTH (type));
- else
- store_signed_integer (value_contents_raw (val), TYPE_LENGTH (type),
- byte_order, num);
+ unpack_value_bitfield (val,
+ value_bitpos (val), value_bitsize (val),
+ value_contents_for_printing (parent),
+ value_offset (val), parent);
}
else if (VALUE_LVAL (val) == lval_memory)
{
if (TYPE_LENGTH (type))
read_value_memory (val, 0, value_stack (val),
addr, value_contents_all_raw (val),
- TYPE_LENGTH (type));
+ type_length_units (type));
}
else if (VALUE_LVAL (val) == lval_register)
{
set_value_lazy (val, 0);
value_contents_copy (val, value_embedded_offset (val),
new_val, value_embedded_offset (new_val),
- TYPE_LENGTH (type));
+ type_length_units (type));
if (frame_debug)
{
internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
set_value_lazy (val, 0);
- return 0;
}
/* Implementation of the convenience function $_isvoid. */
Usage: $_isvoid (expression)\n\
Return 1 if the expression is void, zero otherwise."),
isvoid_internal_fn, NULL);
+
+ add_setshow_zuinteger_unlimited_cmd ("max-value-size",
+ class_support, &max_value_size, _("\
+Set maximum sized value gdb will load from the inferior."), _("\
+Show maximum sized value gdb will load from the inferior."), _("\
+Use this to control the maximum size, in bytes, of a value that gdb\n\
+will load from the inferior. Setting this value to 'unlimited'\n\
+disables checking.\n\
+Setting this does not invalidate already allocated values, it only\n\
+prevents future values, larger than this size, from being allocated."),
+ set_max_value_size,
+ show_max_value_size,
+ &setlist, &showlist);
}
projects / binutils.git / blobdiff