/* Low level packing and unpacking of values for GDB, the GNU Debugger.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
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;
}
}
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;
bit_length);
}
-/* Copy LENGTH bytes of SRC value's (all) contents
+/* 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
value_contents_copy_raw (struct value *dst, int dst_offset,
struct value *src, int src_offset, int length)
{
- range_s *r;
- int i;
int 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;
+ 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;
value_ranges_copy_adjusted (dst, dst_bit_offset,
src, src_bit_offset,
}
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);
}
}
int
-value_embedded_offset (struct value *value)
+value_embedded_offset (const struct value *value)
{
return value->embedded_offset;
}
}
int
-value_pointed_to_offset (struct value *value)
+value_pointed_to_offset (const struct value *value)
{
return value->pointed_to_offset;
}
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;
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 *newobj
- = (struct value_history_chunk *)
+ struct value_history_chunk *newobj = XCNEW (struct value_history_chunk);
- xmalloc (sizeof (struct value_history_chunk));
- memset (newobj->values, 0, sizeof newobj->values);
newobj->next = value_history_chain;
value_history_chain = newobj;
}
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;
int 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;
}
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:
{
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;
}
{
struct value *v;
struct type *type;
+ struct gdbarch *arch = get_value_arch (arg1);
+ int unit_size = gdbarch_addressable_memory_unit_size (arch);
arg_type = check_typedef (arg_type);
type = TYPE_FIELD_TYPE (arg_type, fieldno);
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 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));
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;
}
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)
{
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-gdb.git / blobdiff