/* Low level packing and unpacking of values for GDB, the GNU Debugger.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
- 2009 Free Software Foundation, Inc.
+ Copyright (C) 1986-2013 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 "python/python.h"
+#include <ctype.h>
+#include "tracepoint.h"
+#include "cp-abi.h"
-/* Prototypes for exported functions. */
+/* Prototypes for exported functions. */
void _initialize_values (void);
void *cookie;
};
+/* Defines an [OFFSET, OFFSET + LENGTH) range. */
+
+struct range
+{
+ /* Lowest offset in the range. */
+ int offset;
+
+ /* Length of the range. */
+ int length;
+};
+
+typedef struct range range_s;
+
+DEF_VEC_O(range_s);
+
+/* Returns true if the ranges defined by [offset1, offset1+len1) and
+ [offset2, offset2+len2) overlap. */
+
+static int
+ranges_overlap (int offset1, int len1,
+ int offset2, int len2)
+{
+ ULONGEST h, l;
+
+ l = max (offset1, offset2);
+ h = min (offset1 + len1, offset2 + len2);
+ return (l < h);
+}
+
+/* Returns true if the first argument is strictly less than the
+ second, useful for VEC_lower_bound. We keep ranges sorted by
+ offset and coalesce overlapping and contiguous ranges, so this just
+ compares the starting offset. */
+
+static int
+range_lessthan (const range_s *r1, const range_s *r2)
+{
+ return r1->offset < r2->offset;
+}
+
+/* Returns true if RANGES contains any range that overlaps [OFFSET,
+ OFFSET+LENGTH). */
+
+static int
+ranges_contain (VEC(range_s) *ranges, int offset, int length)
+{
+ range_s what;
+ int i;
+
+ what.offset = offset;
+ what.length = length;
+
+ /* We keep ranges sorted by offset and coalesce overlapping and
+ contiguous ranges, so to check if a range list contains a given
+ range, we can do a binary search for the position the given range
+ would be inserted if we only considered the starting OFFSET of
+ ranges. We call that position I. Since we also have LENGTH to
+ care for (this is a range afterall), we need to check if the
+ _previous_ range overlaps the I range. E.g.,
+
+ R
+ |---|
+ |---| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=1
+
+ In the case above, the binary search would return `I=1', meaning,
+ this OFFSET should be inserted at position 1, and the current
+ position 1 should be pushed further (and before 2). But, `0'
+ overlaps with R.
+
+ Then we need to check if the I range overlaps the I range itself.
+ E.g.,
+
+ R
+ |---|
+ |---| |---| |-------| ... |--|
+ 0 1 2 N
+
+ I=1
+ */
+
+ i = VEC_lower_bound (range_s, ranges, &what, range_lessthan);
+
+ if (i > 0)
+ {
+ struct range *bef = VEC_index (range_s, ranges, i - 1);
+
+ if (ranges_overlap (bef->offset, bef->length, offset, length))
+ return 1;
+ }
+
+ if (i < VEC_length (range_s, ranges))
+ {
+ struct range *r = VEC_index (range_s, ranges, i);
+
+ if (ranges_overlap (r->offset, r->length, offset, length))
+ return 1;
+ }
+
+ return 0;
+}
+
static struct cmd_list_element *functionlist;
+/* Note that the fields in this structure are arranged to save a bit
+ of memory. */
+
struct value
{
/* Type of value; either not an lval, or one of the various
enum lval_type lval;
/* Is it modifiable? Only relevant if lval != not_lval. */
- int modifiable;
+ unsigned int modifiable : 1;
+
+ /* If zero, contents of this value are in the contents field. If
+ nonzero, contents are in inferior. If the lval field is lval_memory,
+ the contents are in inferior memory at location.address plus offset.
+ The lval field may also be lval_register.
+
+ WARNING: This field is used by the code which handles watchpoints
+ (see breakpoint.c) to decide whether a particular value can be
+ watched by hardware watchpoints. If the lazy flag is set for
+ some member of a value chain, it is assumed that this member of
+ the chain doesn't need to be watched as part of watching the
+ value itself. This is how GDB avoids watching the entire struct
+ or array when the user wants to watch a single struct member or
+ array element. If you ever change the way lazy flag is set and
+ reset, be sure to consider this use as well! */
+ unsigned int lazy : 1;
+
+ /* If nonzero, this is the value of a variable which does not
+ actually exist in the program. */
+ unsigned int optimized_out : 1;
+
+ /* If value is a variable, is it initialized or not. */
+ unsigned int initialized : 1;
+
+ /* If value is from the stack. If this is set, read_stack will be
+ used instead of read_memory to enable extra caching. */
+ unsigned int stack : 1;
+
+ /* If the value has been released. */
+ unsigned int released : 1;
/* Location of value (if lval). */
union
for them to use. */
struct
{
- struct lval_funcs *funcs; /* Functions to call. */
- void *closure; /* Closure for those functions to use. */
+ /* Functions to call. */
+ const struct lval_funcs *funcs;
+
+ /* Closure for those functions to use. */
+ void *closure;
} computed;
} location;
/* 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. */
+ gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
int 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
+ release_value is called, this value is removed from the chain but
+ the caller of release_value now has a reference to this value.
+ The caller must arrange for a call to value_free later. */
+ int reference_count;
+
+ /* Only used for bitfields; the containing value. This allows a
+ single read from the target when displaying multiple
+ bitfields. */
+ struct value *parent;
+
/* Frame register value is relative to. This will be described in
the lval enum above as "lval_register". */
struct frame_id frame_id;
/* Register number if the value is from a register. */
short regnum;
- /* If zero, contents of this value are in the contents field. If
- nonzero, contents are in inferior. If the lval field is lval_memory,
- the contents are in inferior memory at location.address plus offset.
- The lval field may also be lval_register.
-
- WARNING: This field is used by the code which handles watchpoints
- (see breakpoint.c) to decide whether a particular value can be
- watched by hardware watchpoints. If the lazy flag is set for
- some member of a value chain, it is assumed that this member of
- the chain doesn't need to be watched as part of watching the
- value itself. This is how GDB avoids watching the entire struct
- or array when the user wants to watch a single struct member or
- array element. If you ever change the way lazy flag is set and
- reset, be sure to consider this use as well! */
- char lazy;
-
- /* If nonzero, this is the value of a variable which does not
- actually exist in the program. */
- char optimized_out;
-
- /* If value is a variable, is it initialized or not. */
- int initialized;
-
/* Actual contents of the value. Target byte-order. NULL or not
valid if lazy is nonzero. */
gdb_byte *contents;
- /* The number of references to this value. When a value is created,
- the value chain holds a reference, so REFERENCE_COUNT is 1. If
- release_value is called, this value is removed from the chain but
- the caller of release_value now has a reference to this value.
- The caller must arrange for a call to value_free later. */
- int reference_count;
+ /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
+ rather than available, since the common and default case is for a
+ value to be available. This is filled in at value read time. */
+ VEC(range_s) *unavailable;
};
-/* Prototypes for local functions. */
+int
+value_bytes_available (const struct value *value, int offset, int length)
+{
+ gdb_assert (!value->lazy);
+
+ return !ranges_contain (value->unavailable, offset, length);
+}
+
+int
+value_entirely_available (struct value *value)
+{
+ /* We can only tell whether the whole value is available when we try
+ to read it. */
+ if (value->lazy)
+ value_fetch_lazy (value);
+
+ if (VEC_empty (range_s, value->unavailable))
+ return 1;
+ return 0;
+}
+
+void
+mark_value_bytes_unavailable (struct value *value, int offset, int length)
+{
+ range_s newr;
+ int i;
+
+ /* Insert the range sorted. If there's overlap or the new range
+ would be contiguous with an existing range, merge. */
+
+ newr.offset = offset;
+ newr.length = length;
+
+ /* Do a binary search for the position the given range would be
+ inserted if we only considered the starting OFFSET of ranges.
+ Call that position I. Since we also have LENGTH to care for
+ (this is a range afterall), we need to check if the _previous_
+ range overlaps the I range. E.g., calling R the new range:
+
+ #1 - overlaps with previous
+
+ R
+ |-...-|
+ |---| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=1
+
+ In the case #1 above, the binary search would return `I=1',
+ meaning, this OFFSET should be inserted at position 1, and the
+ current position 1 should be pushed further (and become 2). But,
+ note that `0' overlaps with R, so we want to merge them.
+
+ A similar consideration needs to be taken if the new range would
+ be contiguous with the previous range:
+
+ #2 - contiguous with previous
+
+ R
+ |-...-|
+ |--| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=1
+
+ If there's no overlap with the previous range, as in:
+
+ #3 - not overlapping and not contiguous
+
+ R
+ |-...-|
+ |--| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=1
+
+ or if I is 0:
+
+ #4 - R is the range with lowest offset
+
+ R
+ |-...-|
+ |--| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=0
+
+ ... we just push the new range to I.
+
+ All the 4 cases above need to consider that the new range may
+ also overlap several of the ranges that follow, or that R may be
+ contiguous with the following range, and merge. E.g.,
+
+ #5 - overlapping following ranges
+
+ R
+ |------------------------|
+ |--| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=0
+
+ or:
+
+ R
+ |-------|
+ |--| |---| |------| ... |--|
+ 0 1 2 N
+
+ I=1
+
+ */
+
+ i = VEC_lower_bound (range_s, value->unavailable, &newr, range_lessthan);
+ if (i > 0)
+ {
+ struct range *bef = VEC_index (range_s, value->unavailable, i - 1);
+
+ if (ranges_overlap (bef->offset, bef->length, offset, length))
+ {
+ /* #1 */
+ ULONGEST l = min (bef->offset, offset);
+ ULONGEST h = max (bef->offset + bef->length, offset + length);
+
+ bef->offset = l;
+ bef->length = h - l;
+ i--;
+ }
+ else if (offset == bef->offset + bef->length)
+ {
+ /* #2 */
+ bef->length += length;
+ i--;
+ }
+ else
+ {
+ /* #3 */
+ VEC_safe_insert (range_s, value->unavailable, i, &newr);
+ }
+ }
+ else
+ {
+ /* #4 */
+ VEC_safe_insert (range_s, value->unavailable, i, &newr);
+ }
+
+ /* Check whether the ranges following the one we've just added or
+ touched can be folded in (#5 above). */
+ if (i + 1 < VEC_length (range_s, value->unavailable))
+ {
+ struct range *t;
+ struct range *r;
+ int removed = 0;
+ int next = i + 1;
+
+ /* Get the range we just touched. */
+ t = VEC_index (range_s, value->unavailable, i);
+ removed = 0;
+
+ i = next;
+ for (; VEC_iterate (range_s, value->unavailable, i, r); i++)
+ if (r->offset <= t->offset + t->length)
+ {
+ ULONGEST l, h;
+
+ l = min (t->offset, r->offset);
+ h = max (t->offset + t->length, r->offset + r->length);
+
+ t->offset = l;
+ t->length = h - l;
+
+ removed++;
+ }
+ else
+ {
+ /* If we couldn't merge this one, we won't be able to
+ merge following ones either, since the ranges are
+ always sorted by OFFSET. */
+ break;
+ }
+
+ if (removed != 0)
+ VEC_block_remove (range_s, value->unavailable, next, removed);
+ }
+}
+
+/* Find the first range in RANGES that overlaps the range defined by
+ OFFSET and LENGTH, starting at element POS in the RANGES vector,
+ Returns the index into RANGES where such overlapping range was
+ found, or -1 if none was found. */
+
+static int
+find_first_range_overlap (VEC(range_s) *ranges, int pos,
+ int offset, int length)
+{
+ range_s *r;
+ int i;
+
+ for (i = pos; VEC_iterate (range_s, ranges, i, r); i++)
+ if (ranges_overlap (r->offset, r->length, offset, length))
+ return i;
+
+ return -1;
+}
+
+int
+value_available_contents_eq (const struct value *val1, int offset1,
+ const struct value *val2, int offset2,
+ int length)
+{
+ int idx1 = 0, idx2 = 0;
+
+ /* This routine is used by printing routines, where we should
+ already have read the value. Note that we only know whether a
+ value chunk is available if we've tried to read it. */
+ gdb_assert (!val1->lazy && !val2->lazy);
+
+ while (length > 0)
+ {
+ range_s *r1, *r2;
+ ULONGEST l1, h1;
+ ULONGEST l2, h2;
+
+ idx1 = find_first_range_overlap (val1->unavailable, idx1,
+ offset1, length);
+ idx2 = find_first_range_overlap (val2->unavailable, idx2,
+ offset2, length);
+
+ /* The usual case is for both values to be completely available. */
+ if (idx1 == -1 && idx2 == -1)
+ return (memcmp (val1->contents + offset1,
+ val2->contents + offset2,
+ length) == 0);
+ /* The contents only match equal if the available set matches as
+ well. */
+ else if (idx1 == -1 || idx2 == -1)
+ return 0;
+
+ gdb_assert (idx1 != -1 && idx2 != -1);
+
+ r1 = VEC_index (range_s, val1->unavailable, idx1);
+ r2 = VEC_index (range_s, val2->unavailable, idx2);
+
+ /* Get the unavailable windows intersected by the incoming
+ ranges. The first and last ranges that overlap the argument
+ range may be wider than said incoming arguments ranges. */
+ l1 = max (offset1, r1->offset);
+ h1 = min (offset1 + length, r1->offset + r1->length);
+
+ l2 = max (offset2, r2->offset);
+ h2 = min (offset2 + length, r2->offset + r2->length);
+
+ /* Make them relative to the respective start offsets, so we can
+ compare them for equality. */
+ l1 -= offset1;
+ h1 -= offset1;
+
+ l2 -= offset2;
+ h2 -= offset2;
+
+ /* Different availability, no match. */
+ if (l1 != l2 || h1 != h2)
+ return 0;
+
+ /* Compare the _available_ contents. */
+ if (memcmp (val1->contents + offset1,
+ val2->contents + offset2,
+ l1) != 0)
+ return 0;
+
+ length -= h1;
+ offset1 += h1;
+ offset2 += h1;
+ }
+
+ return 1;
+}
+
+/* Prototypes for local functions. */
static void show_values (char *, int);
static struct value_history_chunk *value_history_chain;
-static int value_history_count; /* Abs number of last entry stored */
+static int value_history_count; /* Abs number of last entry stored. */
\f
/* List of all value objects currently allocated
allocate_value_lazy (struct type *type)
{
struct value *val;
- struct type *atype = check_typedef (type);
+
+ /* Call check_typedef on our type to make sure that, if TYPE
+ is a TYPE_CODE_TYPEDEF, its length is set to the length
+ of the target type instead of zero. However, we do not
+ replace the typedef type by the target type, because we want
+ to keep the typedef in order to be able to set the VAL's type
+ description correctly. */
+ check_typedef (type);
val = (struct value *) xzalloc (sizeof (struct value));
val->contents = NULL;
allocate_value (struct type *type)
{
struct value *val = allocate_value_lazy (type);
+
allocate_value_contents (val);
val->lazy = 0;
return val;
done with it. */
struct type *array_type
= lookup_array_range_type (type, low_bound, count + low_bound - 1);
- return allocate_value (array_type);
-}
-/* Needed if another module needs to maintain its on list of values. */
-void
-value_prepend_to_list (struct value **head, struct value *val)
-{
- val->next = *head;
- *head = val;
-}
-
-/* Needed if another module needs to maintain its on list of values. */
-void
-value_remove_from_list (struct value **head, struct value *val)
-{
- struct value *prev;
-
- if (*head == val)
- *head = (*head)->next;
- else
- for (prev = *head; prev->next; prev = prev->next)
- if (prev->next == val)
- {
- prev->next = val->next;
- break;
- }
+ return allocate_value (array_type);
}
struct value *
allocate_computed_value (struct type *type,
- struct lval_funcs *funcs,
+ const struct lval_funcs *funcs,
void *closure)
{
- struct value *v = allocate_value (type);
+ struct value *v = allocate_value_lazy (type);
+
VALUE_LVAL (v) = lval_computed;
v->location.computed.funcs = funcs;
v->location.computed.closure = closure;
- set_value_lazy (v, 1);
return v;
}
+/* Allocate NOT_LVAL value for type TYPE being OPTIMIZED_OUT. */
+
+struct value *
+allocate_optimized_out_value (struct type *type)
+{
+ struct value *retval = allocate_value_lazy (type);
+
+ set_value_optimized_out (retval, 1);
+
+ return retval;
+}
+
/* Accessor methods. */
struct value *
}
struct type *
-value_type (struct value *value)
+value_type (const struct value *value)
{
return value->type;
}
}
int
-value_offset (struct value *value)
+value_offset (const struct value *value)
{
return value->offset;
}
}
int
-value_bitpos (struct value *value)
+value_bitpos (const struct value *value)
{
return value->bitpos;
}
}
int
-value_bitsize (struct value *value)
+value_bitsize (const struct value *value)
{
return value->bitsize;
}
value->bitsize = bit;
}
+struct value *
+value_parent (struct value *value)
+{
+ return value->parent;
+}
+
+/* See value.h. */
+
+void
+set_value_parent (struct value *value, struct value *parent)
+{
+ value->parent = parent;
+}
+
gdb_byte *
value_contents_raw (struct value *value)
{
return value->enclosing_type;
}
+/* Look at value.h for description. */
+
+struct type *
+value_actual_type (struct value *value, int resolve_simple_types,
+ int *real_type_found)
+{
+ struct value_print_options opts;
+ struct type *result;
+
+ get_user_print_options (&opts);
+
+ if (real_type_found)
+ *real_type_found = 0;
+ result = value_type (value);
+ if (opts.objectprint)
+ {
+ /* 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 (check_typedef (TYPE_TARGET_TYPE (result)))
+ == TYPE_CODE_STRUCT)
+ {
+ struct type *real_type;
+
+ real_type = value_rtti_indirect_type (value, NULL, NULL, NULL);
+ if (real_type)
+ {
+ if (real_type_found)
+ *real_type_found = 1;
+ result = real_type;
+ }
+ }
+ else if (resolve_simple_types)
+ {
+ if (real_type_found)
+ *real_type_found = 1;
+ result = value_enclosing_type (value);
+ }
+ }
+
+ return result;
+}
+
+static void
+require_not_optimized_out (const struct value *value)
+{
+ if (value->optimized_out)
+ error (_("value has been optimized out"));
+}
+
+static void
+require_available (const struct value *value)
+{
+ if (!VEC_empty (range_s, value->unavailable))
+ throw_error (NOT_AVAILABLE_ERROR, _("value is not available"));
+}
+
const gdb_byte *
-value_contents_all (struct value *value)
+value_contents_for_printing (struct value *value)
{
if (value->lazy)
value_fetch_lazy (value);
return value->contents;
}
+const gdb_byte *
+value_contents_for_printing_const (const struct value *value)
+{
+ gdb_assert (!value->lazy);
+ return value->contents;
+}
+
+const gdb_byte *
+value_contents_all (struct value *value)
+{
+ const gdb_byte *result = value_contents_for_printing (value);
+ require_not_optimized_out (value);
+ require_available (value);
+ return result;
+}
+
+/* Copy LENGTH bytes 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
+ unavailable accordingly. Neither DST nor SRC may be lazy
+ values.
+
+ It is assumed the contents of DST in the [DST_OFFSET,
+ 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)
+{
+ range_s *r;
+ int i;
+
+ /* 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
+ call, say), the contents would be overwritten. A lazy SRC would
+ mean we'd be copying garbage. */
+ gdb_assert (!dst->lazy && !src->lazy);
+
+ /* The overwritten DST range gets unavailability ORed in, not
+ replaced. Make sure to remember to implement replacing if it
+ turns out actually necessary. */
+ gdb_assert (value_bytes_available (dst, dst_offset, length));
+
+ /* Copy the data. */
+ memcpy (value_contents_all_raw (dst) + dst_offset,
+ value_contents_all_raw (src) + src_offset,
+ length);
+
+ /* Copy the meta-data, adjusted. */
+ for (i = 0; VEC_iterate (range_s, src->unavailable, i, r); i++)
+ {
+ ULONGEST h, l;
+
+ l = max (r->offset, src_offset);
+ h = min (r->offset + r->length, src_offset + length);
+
+ if (l < h)
+ mark_value_bytes_unavailable (dst,
+ dst_offset + (l - src_offset),
+ h - l);
+ }
+}
+
+/* Copy LENGTH bytes of SRC value's (all) contents
+ (value_contents_all) starting at SRC_OFFSET byte, into DST value's
+ (all) contents, starting at DST_OFFSET. If unavailable contents
+ are being copied from SRC, the corresponding DST contents are
+ marked unavailable accordingly. DST must not be lazy. If SRC is
+ lazy, it will be fetched now. If SRC is not valid (is optimized
+ out), an error is thrown.
+
+ It is assumed the contents of DST in the [DST_OFFSET,
+ 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)
+{
+ require_not_optimized_out (src);
+
+ if (src->lazy)
+ value_fetch_lazy (src);
+
+ value_contents_copy_raw (dst, dst_offset, src, src_offset, length);
+}
+
int
value_lazy (struct value *value)
{
value->lazy = val;
}
+int
+value_stack (struct value *value)
+{
+ return value->stack;
+}
+
+void
+set_value_stack (struct value *value, int val)
+{
+ value->stack = val;
+}
+
const gdb_byte *
value_contents (struct value *value)
{
- return value_contents_writeable (value);
+ const gdb_byte *result = value_contents_writeable (value);
+ require_not_optimized_out (value);
+ require_available (value);
+ return result;
}
gdb_byte *
{
struct type *type1;
struct type *type2;
- int len;
type1 = check_typedef (value_type (val1));
type2 = check_typedef (value_type (val2));
- len = TYPE_LENGTH (type1);
- if (len != TYPE_LENGTH (type2))
+ if (TYPE_LENGTH (type1) != TYPE_LENGTH (type2))
return 0;
- return (memcmp (value_contents (val1), value_contents (val2), len) == 0);
+ return (memcmp (value_contents (val1), value_contents (val2),
+ TYPE_LENGTH (type1)) == 0);
}
int
value->optimized_out = val;
}
+int
+value_entirely_optimized_out (const struct value *value)
+{
+ if (!value->optimized_out)
+ return 0;
+ if (value->lval != lval_computed
+ || !value->location.computed.funcs->check_any_valid)
+ return 1;
+ return !value->location.computed.funcs->check_any_valid (value);
+}
+
+int
+value_bits_valid (const struct value *value, int offset, int length)
+{
+ if (!value->optimized_out)
+ return 1;
+ if (value->lval != lval_computed
+ || !value->location.computed.funcs->check_validity)
+ return 0;
+ return value->location.computed.funcs->check_validity (value, offset,
+ length);
+}
+
+int
+value_bits_synthetic_pointer (const struct value *value,
+ int offset, int length)
+{
+ if (value->lval != lval_computed
+ || !value->location.computed.funcs->check_synthetic_pointer)
+ return 0;
+ return value->location.computed.funcs->check_synthetic_pointer (value,
+ offset,
+ length);
+}
+
int
value_embedded_offset (struct value *value)
{
value->pointed_to_offset = val;
}
-struct lval_funcs *
-value_computed_funcs (struct value *v)
+const struct lval_funcs *
+value_computed_funcs (const struct value *v)
{
- gdb_assert (VALUE_LVAL (v) == lval_computed);
+ gdb_assert (value_lval_const (v) == lval_computed);
return v->location.computed.funcs;
}
void *
-value_computed_closure (struct value *v)
+value_computed_closure (const struct value *v)
{
- gdb_assert (VALUE_LVAL (v) == lval_computed);
+ gdb_assert (v->lval == lval_computed);
return v->location.computed.closure;
}
return &value->lval;
}
+enum lval_type
+value_lval_const (const struct value *value)
+{
+ return value->lval;
+}
+
CORE_ADDR
-value_address (struct value *value)
+value_address (const struct value *value)
{
if (value->lval == lval_internalvar
|| value->lval == lval_internalvar_component)
return 0;
- return value->location.address + value->offset;
+ if (value->parent != NULL)
+ return value_address (value->parent) + value->offset;
+ else
+ return value->location.address + value->offset;
}
CORE_ADDR
{
return value->modifiable;
}
-void
-deprecated_set_value_modifiable (struct value *value, int modifiable)
-{
- value->modifiable = modifiable;
-}
\f
/* Return a mark in the value chain. All values allocated after the
mark is obtained (except for those released) are subject to being freed
if (val->reference_count > 0)
return;
+ /* If there's an associated parent value, drop our reference to
+ it. */
+ if (val->parent != NULL)
+ value_free (val->parent);
+
if (VALUE_LVAL (val) == lval_computed)
{
- struct lval_funcs *funcs = val->location.computed.funcs;
+ const struct lval_funcs *funcs = val->location.computed.funcs;
if (funcs->free_closure)
funcs->free_closure (val);
}
xfree (val->contents);
+ VEC_free (range_s, val->unavailable);
}
xfree (val);
}
for (val = all_values; val && val != mark; val = next)
{
next = val->next;
+ val->released = 1;
value_free (val);
}
all_values = val;
}
/* Free all the values that have been allocated (except for those released).
- Called after each command, successful or not. */
+ Call after each command, successful or not.
+ In practice this is called before each command, which is sufficient. */
void
free_all_values (void)
for (val = all_values; val; val = next)
{
next = val->next;
+ val->released = 1;
value_free (val);
}
all_values = 0;
}
+/* Frees all the elements in a chain of values. */
+
+void
+free_value_chain (struct value *v)
+{
+ struct value *next;
+
+ for (; v; v = next)
+ {
+ next = value_next (v);
+ value_free (v);
+ }
+}
+
/* Remove VAL from the chain all_values
so it will not be freed automatically. */
if (all_values == val)
{
all_values = val->next;
+ val->next = NULL;
+ val->released = 1;
return;
}
if (v->next == val)
{
v->next = val->next;
+ val->next = NULL;
+ val->released = 1;
break;
}
}
}
+/* If the value is not already released, release it.
+ If the value is already released, increment its reference count.
+ That is, this function ensures that the value is released from the
+ value chain and that the caller owns a reference to it. */
+
+void
+release_value_or_incref (struct value *val)
+{
+ if (val->released)
+ value_incref (val);
+ else
+ release_value (val);
+}
+
/* Release all values up to mark */
struct value *
value_release_to_mark (struct value *mark)
struct value *next;
for (val = next = all_values; next; next = next->next)
- if (next->next == mark)
- {
- all_values = next->next;
- next->next = NULL;
- return val;
- }
+ {
+ if (next->next == mark)
+ {
+ all_values = next->next;
+ next->next = NULL;
+ return val;
+ }
+ next->released = 1;
+ }
all_values = 0;
return val;
}
TYPE_LENGTH (value_enclosing_type (arg)));
}
+ val->unavailable = VEC_copy (range_s, arg->unavailable);
+ val->parent = arg->parent;
+ if (val->parent)
+ value_incref (val->parent);
if (VALUE_LVAL (val) == lval_computed)
{
- struct lval_funcs *funcs = val->location.computed.funcs;
+ const struct lval_funcs *funcs = val->location.computed.funcs;
if (funcs->copy_closure)
val->location.computed.closure = funcs->copy_closure (val);
return val;
}
+/* Return a version of ARG that is non-lvalue. */
+
+struct value *
+value_non_lval (struct value *arg)
+{
+ if (VALUE_LVAL (arg) != not_lval)
+ {
+ struct type *enc_type = value_enclosing_type (arg);
+ struct value *val = allocate_value (enc_type);
+
+ memcpy (value_contents_all_raw (val), value_contents_all (arg),
+ TYPE_LENGTH (enc_type));
+ val->type = arg->type;
+ set_value_embedded_offset (val, value_embedded_offset (arg));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (arg));
+ return val;
+ }
+ return arg;
+}
+
void
-set_value_component_location (struct value *component, struct value *whole)
+set_value_component_location (struct value *component,
+ const struct value *whole)
{
- if (VALUE_LVAL (whole) == lval_internalvar)
+ if (whole->lval == lval_internalvar)
VALUE_LVAL (component) = lval_internalvar_component;
else
- VALUE_LVAL (component) = VALUE_LVAL (whole);
+ VALUE_LVAL (component) = whole->lval;
component->location = whole->location;
- if (VALUE_LVAL (whole) == lval_computed)
+ if (whole->lval == lval_computed)
{
- struct lval_funcs *funcs = whole->location.computed.funcs;
+ const struct lval_funcs *funcs = whole->location.computed.funcs;
if (funcs->copy_closure)
component->location.computed.closure = funcs->copy_closure (whole);
if (i == 0)
{
struct value_history_chunk *new
- = (struct value_history_chunk *)
+ = (struct value_history_chunk *)
+
xmalloc (sizeof (struct value_history_chunk));
memset (new->values, 0, sizeof new->values);
new->next = value_history_chain;
/* Now absnum is always absolute and origin zero. */
chunk = value_history_chain;
- for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
+ for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK
+ - absnum / VALUE_HISTORY_CHUNK;
i > 0; i--)
chunk = chunk->next;
for (i = num; i < num + 10 && i <= value_history_count; i++)
{
struct value_print_options opts;
+
val = access_value_history (i);
printf_filtered (("$%d = "), i);
get_user_print_options (&opts);
/* The internal variable holds a GDB internal convenience function. */
INTERNALVAR_FUNCTION,
- /* The variable holds a simple scalar value. */
- INTERNALVAR_SCALAR,
+ /* The variable holds an integer value. */
+ INTERNALVAR_INTEGER,
/* The variable holds a GDB-provided string. */
INTERNALVAR_STRING,
struct value *value;
/* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
- internalvar_make_value 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
int canonical;
} fn;
- /* A scalar value used with INTERNALVAR_SCALAR. */
+ /* 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;
- union
- {
- LONGEST l; /* Used with TYPE_CODE_INT and NULL types. */
- CORE_ADDR a; /* Used with TYPE_CODE_PTR types. */
- } val;
- } scalar;
+ LONGEST val;
+ } integer;
/* A string value used with INTERNALVAR_STRING. */
char *string;
static struct internalvar *internalvars;
-/* If the variable does not already exist create it and give it the value given.
- If no value is given then the default is zero. */
+/* If the variable does not already exist create it and give it the
+ value given. If no value is given then the default is zero. */
static void
init_if_undefined_command (char* args, int from_tty)
{
/* Extract the variable from the parsed expression.
In the case of an assign the lvalue will be in elts[1] and elts[2]. */
if (expr->elts[1].opcode != OP_INTERNALVAR)
- error (_("The first parameter to init-if-undefined should be a GDB variable."));
+ error (_("The first parameter to init-if-undefined "
+ "should be a GDB variable."));
intvar = expr->elts[2].internalvar;
/* Only evaluate the expression if the lvalue is void.
if (strcmp (var->name, name) == 0)
return var;
- return NULL;
-}
+ return NULL;
+}
+
+/* Complete NAME by comparing it to the names of internal variables.
+ Returns a vector of newly allocated strings, or NULL if no matches
+ were found. */
+
+VEC (char_ptr) *
+complete_internalvar (const char *name)
+{
+ VEC (char_ptr) *result = NULL;
+ struct internalvar *var;
+ int len;
+
+ len = strlen (name);
+
+ for (var = internalvars; var; var = var->next)
+ if (strncmp (var->name, name, len) == 0)
+ {
+ char *r = xstrdup (var->name);
+
+ VEC_safe_push (char_ptr, result, r);
+ }
+ return result;
+}
/* Create an internal variable with name NAME and with a void value.
NAME should not normally include a dollar sign. */
create_internalvar (const char *name)
{
struct internalvar *var;
+
var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
var->name = concat (name, (char *)NULL);
var->kind = INTERNALVAR_VOID;
/* Create an internal variable with name NAME and register FUN as the
function that value_of_internalvar uses to create a value whenever
this variable is referenced. NAME should not normally include a
- dollar sign. */
+ dollar sign. DATA is passed uninterpreted to FUN when it is
+ called. CLEANUP, if not NULL, is called when the internal variable
+ is destroyed. It is passed DATA as its only argument. */
struct internalvar *
-create_internalvar_type_lazy (char *name, internalvar_make_value fun)
+create_internalvar_type_lazy (const char *name,
+ const struct internalvar_funcs *funcs,
+ void *data)
{
struct internalvar *var = create_internalvar (name);
+
var->kind = INTERNALVAR_MAKE_VALUE;
- var->u.make_value = fun;
+ var->u.make_value.functions = funcs;
+ var->u.make_value.data = data;
return var;
}
+/* See documentation in value.h. */
+
+int
+compile_internalvar_to_ax (struct internalvar *var,
+ struct agent_expr *expr,
+ struct axs_value *value)
+{
+ if (var->kind != INTERNALVAR_MAKE_VALUE
+ || var->u.make_value.functions->compile_to_ax == NULL)
+ return 0;
+
+ var->u.make_value.functions->compile_to_ax (var, expr, value,
+ var->u.make_value.data);
+ return 1;
+}
+
/* Look up an internal variable with name NAME. NAME should not
normally include a dollar sign.
value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
{
struct value *val;
+ struct trace_state_variable *tsv;
+
+ /* If there is a trace state variable of the same name, assume that
+ is what we really want to see. */
+ tsv = find_trace_state_variable (var->name);
+ if (tsv)
+ {
+ tsv->value_known = target_get_trace_state_variable_value (tsv->number,
+ &(tsv->value));
+ if (tsv->value_known)
+ val = value_from_longest (builtin_type (gdbarch)->builtin_int64,
+ tsv->value);
+ else
+ val = allocate_value (builtin_type (gdbarch)->builtin_void);
+ return val;
+ }
switch (var->kind)
{
val = allocate_value (builtin_type (gdbarch)->internal_fn);
break;
- case INTERNALVAR_SCALAR:
- if (!var->u.scalar.type)
+ case INTERNALVAR_INTEGER:
+ if (!var->u.integer.type)
val = value_from_longest (builtin_type (gdbarch)->builtin_int,
- var->u.scalar.val.l);
- else if (TYPE_CODE (var->u.scalar.type) == TYPE_CODE_INT)
- val = value_from_longest (var->u.scalar.type, var->u.scalar.val.l);
- else if (TYPE_CODE (var->u.scalar.type) == TYPE_CODE_PTR)
- val = value_from_pointer (var->u.scalar.type, var->u.scalar.val.a);
+ var->u.integer.val);
else
- internal_error (__FILE__, __LINE__, "bad type");
+ val = value_from_longest (var->u.integer.type, var->u.integer.val);
break;
case INTERNALVAR_STRING:
break;
case INTERNALVAR_MAKE_VALUE:
- val = (*var->u.make_value) (gdbarch, var);
+ val = (*var->u.make_value.functions->make_value) (gdbarch, var,
+ var->u.make_value.data);
break;
default:
- internal_error (__FILE__, __LINE__, "bad kind");
+ internal_error (__FILE__, __LINE__, _("bad kind"));
}
/* Change the VALUE_LVAL to lval_internalvar so that future operations
int
get_internalvar_integer (struct internalvar *var, LONGEST *result)
{
- switch (var->kind)
+ if (var->kind == INTERNALVAR_INTEGER)
+ {
+ *result = var->u.integer.val;
+ return 1;
+ }
+
+ if (var->kind == INTERNALVAR_VALUE)
{
- case INTERNALVAR_SCALAR:
- if (var->u.scalar.type == NULL
- || TYPE_CODE (var->u.scalar.type) == TYPE_CODE_INT)
+ struct type *type = check_typedef (value_type (var->u.value));
+
+ if (TYPE_CODE (type) == TYPE_CODE_INT)
{
- *result = var->u.scalar.val.l;
+ *result = value_as_long (var->u.value);
return 1;
}
- /* Fall through. */
-
- default:
- return 0;
}
+
+ return 0;
}
static int
default:
/* We can never get a component of any other kind. */
- internal_error (__FILE__, __LINE__, "set_internalvar_component");
+ internal_error (__FILE__, __LINE__, _("set_internalvar_component"));
}
}
/* Copies created here are never canonical. */
break;
- case TYPE_CODE_INT:
- new_kind = INTERNALVAR_SCALAR;
- new_data.scalar.type = value_type (val);
- new_data.scalar.val.l = value_as_long (val);
- break;
-
- case TYPE_CODE_PTR:
- new_kind = INTERNALVAR_SCALAR;
- new_data.scalar.type = value_type (val);
- new_data.scalar.val.a = value_as_address (val);
- break;
-
default:
new_kind = INTERNALVAR_VALUE;
new_data.value = value_copy (val);
/* Clean up old contents. */
clear_internalvar (var);
- var->kind = INTERNALVAR_SCALAR;
- var->u.scalar.type = NULL;
- var->u.scalar.val.l = l;
+ var->kind = INTERNALVAR_INTEGER;
+ var->u.integer.type = NULL;
+ var->u.integer.val = l;
}
void
xfree (var->u.string);
break;
+ case INTERNALVAR_MAKE_VALUE:
+ if (var->u.make_value.functions->destroy != NULL)
+ var->u.make_value.functions->destroy (var->u.make_value.data);
+ break;
+
default:
break;
}
internal_function_fn handler, void *cookie)
{
struct internal_function *ifn = XNEW (struct internal_function);
+
ifn->name = xstrdup (name);
ifn->handler = handler;
ifn->cookie = cookie;
/* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
prevent cycles / duplicates. */
-static void
+void
preserve_one_value (struct value *value, struct objfile *objfile,
htab_t copied_types)
{
{
switch (var->kind)
{
- case INTERNALVAR_SCALAR:
- if (var->u.scalar.type && TYPE_OBJFILE (var->u.scalar.type) == objfile)
- var->u.scalar.type
- = copy_type_recursive (objfile, var->u.scalar.type, copied_types);
+ case INTERNALVAR_INTEGER:
+ if (var->u.integer.type && TYPE_OBJFILE (var->u.integer.type) == objfile)
+ var->u.integer.type
+ = copy_type_recursive (objfile, var->u.integer.type, copied_types);
break;
case INTERNALVAR_VALUE:
htab_t copied_types;
struct value_history_chunk *cur;
struct internalvar *var;
- struct value *val;
int i;
/* Create the hash table. We allocate on the objfile's obstack, since
for (var = internalvars; var; var = var->next)
preserve_one_internalvar (var, objfile, copied_types);
- for (val = values_in_python; val; val = val->next)
- preserve_one_value (val, objfile, copied_types);
+ preserve_python_values (objfile, copied_types);
htab_delete (copied_types);
}
get_user_print_options (&opts);
for (var = internalvars; var; var = var->next)
{
+ volatile struct gdb_exception ex;
+
if (!varseen)
{
varseen = 1;
}
printf_filtered (("$%s = "), var->name);
- value_print (value_of_internalvar (gdbarch, var), gdb_stdout,
- &opts);
+
+ TRY_CATCH (ex, RETURN_MASK_ERROR)
+ {
+ 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);
printf_filtered (("\n"));
}
if (!varseen)
- printf_unfiltered (_("\
-No debugger convenience variables now defined.\n\
-Convenience variables have names starting with \"$\";\n\
-use \"set\" as in \"set $foo = 5\" to define them.\n"));
+ {
+ /* This text does not mention convenience functions on purpose.
+ The user can't create them except via Python, and if Python support
+ is installed this message will never be printed ($_streq will
+ exist). */
+ printf_unfiltered (_("No debugger convenience variables now defined.\n"
+ "Convenience variables have "
+ "names starting with \"$\";\n"
+ "use \"set\" as in \"set "
+ "$foo = 5\" to define them.\n"));
+ }
}
\f
/* Extract a value as a C number (either long or double).
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
int len;
int nosign;
- *invp = 0; /* Assume valid. */
+ *invp = 0; /* Assume valid. */
CHECK_TYPEDEF (type);
code = TYPE_CODE (type);
len = TYPE_LENGTH (type);
}
\f
-/* Get the value of the FIELDN'th field (which must be static) of
+/* Get the value of the FIELDNO'th field (which must be static) of
TYPE. Return NULL if the field doesn't exist or has been
- optimized out. */
+ optimized out. */
struct value *
value_static_field (struct type *type, int fieldno)
{
struct value *retval;
- if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
+ switch (TYPE_FIELD_LOC_KIND (type, fieldno))
{
- retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
- TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
- }
- else
+ case FIELD_LOC_KIND_PHYSADDR:
+ retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
+ TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
+ break;
+ case FIELD_LOC_KIND_PHYSNAME:
{
- char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
+ 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);
+
if (sym == NULL)
{
- /* With some compilers, e.g. HP aCC, static data members are reported
- as non-debuggable symbols */
- struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL);
+ /* With some compilers, e.g. HP aCC, static data members are
+ reported as non-debuggable symbols. */
+ struct minimal_symbol *msym = lookup_minimal_symbol (phys_name,
+ NULL, NULL);
+
if (!msym)
return NULL;
else
{
- retval = value_at (TYPE_FIELD_TYPE (type, fieldno),
- SYMBOL_VALUE_ADDRESS (msym));
+ retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
+ SYMBOL_VALUE_ADDRESS (msym));
}
}
else
- {
- /* SYM should never have a SYMBOL_CLASS which will require
- read_var_value to use the FRAME parameter. */
- if (symbol_read_needs_frame (sym))
- warning (_("static field's value depends on the current "
- "frame - bad debug info?"));
- retval = read_var_value (sym, NULL);
- }
- if (retval && VALUE_LVAL (retval) == lval_memory)
- SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno),
- value_address (retval));
+ retval = value_of_variable (sym, NULL);
+ break;
+ }
+ default:
+ gdb_assert_not_reached ("unexpected field location kind");
}
+
return retval;
}
-/* 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. */
+/* 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. */
-struct value *
-value_change_enclosing_type (struct value *val, struct type *new_encl_type)
+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));
val->enclosing_type = new_encl_type;
- return 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. */
+ FIELDNO says which field. */
struct value *
value_primitive_field (struct value *arg1, int offset,
CHECK_TYPEDEF (arg_type);
type = TYPE_FIELD_TYPE (arg_type, fieldno);
- /* Handle packed fields */
-
- if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
+ /* Call check_typedef on our type to make sure that, if TYPE
+ is a TYPE_CODE_TYPEDEF, its length is set to the length
+ of the target type instead of zero. However, we do not
+ replace the typedef type by the target type, because we want
+ to keep the typedef in order to be able to print the type
+ description correctly. */
+ check_typedef (type);
+
+ if (value_optimized_out (arg1))
+ v = allocate_optimized_out_value (type);
+ else if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
{
- v = value_from_longest (type,
- unpack_field_as_long (arg_type,
- value_contents (arg1)
- + offset,
- fieldno));
- v->bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
+ /* Handle packed fields.
+
+ Create a new value for the bitfield, with bitpos and bitsize
+ set. If possible, arrange offset and bitpos so that we can
+ do a single aligned read of the size of the containing type.
+ Otherwise, adjust offset to the byte containing the first
+ 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;
+
+ v = allocate_value_lazy (type);
v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
- v->offset = value_offset (arg1) + offset
- + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+ if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize
+ && TYPE_LENGTH (type) <= (int) sizeof (LONGEST))
+ v->bitpos = bitpos % container_bitsize;
+ else
+ v->bitpos = bitpos % 8;
+ v->offset = (value_embedded_offset (arg1)
+ + offset
+ + (bitpos - v->bitpos) / 8);
+ v->parent = arg1;
+ value_incref (v->parent);
+ if (!value_lazy (arg1))
+ value_fetch_lazy (v);
}
else if (fieldno < TYPE_N_BASECLASSES (arg_type))
{
/* This field is actually a base subobject, so preserve the
- entire object's contents for later references to virtual
- bases, etc. */
+ entire object's contents for later references to virtual
+ bases, etc. */
+ int boffset;
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
value_fetch_lazy (arg1);
+ /* We special case virtual inheritance here because this
+ requires access to the contents, which we would rather avoid
+ for references to ordinary fields of unavailable values. */
+ if (BASETYPE_VIA_VIRTUAL (arg_type, fieldno))
+ boffset = baseclass_offset (arg_type, fieldno,
+ value_contents (arg1),
+ value_embedded_offset (arg1),
+ value_address (arg1),
+ arg1);
+ else
+ boffset = TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+
if (value_lazy (arg1))
v = allocate_value_lazy (value_enclosing_type (arg1));
else
{
v = allocate_value (value_enclosing_type (arg1));
- memcpy (value_contents_all_raw (v), value_contents_all_raw (arg1),
- TYPE_LENGTH (value_enclosing_type (arg1)));
+ value_contents_copy_raw (v, 0, arg1, 0,
+ TYPE_LENGTH (value_enclosing_type (arg1)));
}
v->type = type;
v->offset = value_offset (arg1);
- v->embedded_offset = (offset + value_embedded_offset (arg1)
- + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8);
+ v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
}
else
{
else
{
v = allocate_value (type);
- memcpy (value_contents_raw (v),
- value_contents_raw (arg1) + offset,
- TYPE_LENGTH (type));
+ value_contents_copy_raw (v, value_embedded_offset (v),
+ arg1, value_embedded_offset (arg1) + offset,
+ TYPE_LENGTH (type));
}
v->offset = (value_offset (arg1) + offset
+ value_embedded_offset (arg1));
/* Given a value ARG1 of a struct or union type,
extract and return the value of one of its (non-static) fields.
- FIELDNO says which field. */
+ FIELDNO says which field. */
struct value *
value_field (struct value *arg1, int fieldno)
J is an index into F which provides the desired method.
We only use the symbol for its address, so be happy with either a
- full symbol or a minimal symbol.
- */
+ full symbol or a minimal symbol. */
struct value *
-value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type,
+value_fn_field (struct value **arg1p, struct fn_field *f,
+ int j, struct type *type,
int offset)
{
struct value *v;
struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
- char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
+ const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
struct symbol *sym;
struct minimal_symbol *msym;
value_addr (*arg1p)));
/* Move the `this' pointer according to the offset.
- VALUE_OFFSET (*arg1p) += offset;
- */
+ VALUE_OFFSET (*arg1p) += offset; */
}
return v;
}
\f
-/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
- VALADDR.
-
- 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. */
+/* 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. */
-LONGEST
-unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
+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)
{
- enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
ULONGEST val;
ULONGEST valmask;
- int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
- int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
int lsbcount;
- struct type *field_type;
+ int bytes_read;
+ int read_offset;
- val = extract_unsigned_integer (valaddr + bitpos / 8,
- sizeof (val), byte_order);
- field_type = TYPE_FIELD_TYPE (type, fieldno);
+ /* Read the minimum number of bytes required; there may not be
+ enough bytes to read an entire ULONGEST. */
CHECK_TYPEDEF (field_type);
+ if (bitsize)
+ bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
+ else
+ bytes_read = TYPE_LENGTH (field_type);
- /* Extract bits. See comment above. */
+ read_offset = bitpos / 8;
- if (gdbarch_bits_big_endian (get_type_arch (type)))
- lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
+ if (original_value != NULL
+ && !value_bytes_available (original_value, embedded_offset + read_offset,
+ bytes_read))
+ return 0;
+
+ val = extract_unsigned_integer (valaddr + embedded_offset + read_offset,
+ bytes_read, byte_order);
+
+ /* Extract bits. See comment above. */
+
+ if (gdbarch_bits_big_endian (get_type_arch (field_type)))
+ lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize);
else
lsbcount = (bitpos % 8);
val >>= lsbcount;
/* 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 the field is signed, and is negative, then sign extend. */
if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
{
}
}
}
- return (val);
+
+ *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);
+}
+
+/* Unpack a field FIELDNO of the specified TYPE, from the object at
+ VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
+ ORIGINAL_VALUE, which must not be NULL. See
+ unpack_value_bits_as_long for more details. */
+
+int
+unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
+ int embedded_offset, int fieldno,
+ const struct value *val, LONGEST *result)
+{
+ gdb_assert (val != NULL);
+
+ return unpack_value_field_as_long_1 (type, valaddr, embedded_offset,
+ fieldno, val, result);
+}
+
+/* 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. */
+
+LONGEST
+unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
+{
+ LONGEST result;
+
+ unpack_value_field_as_long_1 (type, valaddr, 0, fieldno, NULL, &result);
+ return result;
+}
+
+/* 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. */
+
+struct value *
+value_field_bitfield (struct type *type, int fieldno,
+ const gdb_byte *valaddr,
+ int embedded_offset, const struct value *val)
+{
+ LONGEST l;
+
+ 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);
+ }
}
/* Modify the value of a bitfield. ADDR points to a block of memory in
target byte order; the bitfield starts in the byte pointed to. FIELDVAL
is the desired value of the field, in host byte order. BITPOS and BITSIZE
- indicate which bits (in target bit order) comprise the bitfield.
- Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and
+ indicate which bits (in target bit order) comprise the bitfield.
+ Requires 0 < BITSIZE <= lbits, 0 <= BITPOS % 8 + BITSIZE <= lbits, and
0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
void
enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
ULONGEST oword;
ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
+ int bytesize;
+
+ /* Normalize BITPOS. */
+ addr += bitpos / 8;
+ bitpos %= 8;
/* If a negative fieldval fits in the field in question, chop
off the sign extension bits. */
fieldval &= mask;
}
- oword = extract_unsigned_integer (addr, sizeof oword, byte_order);
+ /* Ensure no bytes outside of the modified ones get accessed as it may cause
+ false valgrind reports. */
+
+ bytesize = (bitpos + bitsize + 7) / 8;
+ oword = extract_unsigned_integer (addr, bytesize, byte_order);
/* Shifting for bit field depends on endianness of the target machine. */
if (gdbarch_bits_big_endian (get_type_arch (type)))
- bitpos = sizeof (oword) * 8 - bitpos - bitsize;
+ bitpos = bytesize * 8 - bitpos - bitsize;
oword &= ~(mask << bitpos);
oword |= fieldval << bitpos;
- store_unsigned_integer (addr, sizeof oword, byte_order, oword);
+ store_unsigned_integer (addr, bytesize, byte_order, oword);
}
\f
/* Pack NUM into BUF using a target format of TYPE. */
}
+/* Pack NUM into BUF using a target format of TYPE. */
+
+static void
+pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
+{
+ int len;
+ enum bfd_endian byte_order;
+
+ type = check_typedef (type);
+ len = TYPE_LENGTH (type);
+ byte_order = gdbarch_byte_order (get_type_arch (type));
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_MEMBERPTR:
+ store_unsigned_integer (buf, len, byte_order, num);
+ break;
+
+ case TYPE_CODE_REF:
+ case TYPE_CODE_PTR:
+ store_typed_address (buf, type, (CORE_ADDR) num);
+ break;
+
+ default:
+ error (_("Unexpected type (%d) encountered "
+ "for unsigned integer constant."),
+ TYPE_CODE (type));
+ }
+}
+
+
/* Convert C numbers into newly allocated values. */
struct value *
struct value *val = allocate_value (type);
pack_long (value_contents_raw (val), type, num);
+ return val;
+}
+
+
+/* Convert C unsigned numbers into newly allocated values. */
+
+struct value *
+value_from_ulongest (struct type *type, ULONGEST num)
+{
+ struct value *val = allocate_value (type);
+
+ pack_unsigned_long (value_contents_raw (val), type, num);
return val;
}
value_from_pointer (struct type *type, CORE_ADDR addr)
{
struct value *val = allocate_value (type);
- store_typed_address (value_contents_raw (val), type, addr);
+
+ store_typed_address (value_contents_raw (val), check_typedef (type), addr);
return val;
}
const gdb_byte *valaddr,
CORE_ADDR address)
{
- struct value *v = allocate_value (type);
+ struct value *v;
+
if (valaddr == NULL)
- set_value_lazy (v, 1);
+ v = allocate_value_lazy (type);
else
- memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
+ {
+ v = allocate_value (type);
+ memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
+ }
set_value_address (v, address);
VALUE_LVAL (v) = lval_memory;
return v;
}
+/* Create a value of type TYPE holding the contents CONTENTS.
+ The new value is `not_lval'. */
+
+struct value *
+value_from_contents (struct type *type, const gdb_byte *contents)
+{
+ struct value *result;
+
+ result = allocate_value (type);
+ memcpy (value_contents_raw (result), contents, TYPE_LENGTH (type));
+ return result;
+}
+
struct value *
value_from_double (struct type *type, DOUBLEST num)
{
struct value *val = allocate_value (type);
struct type *base_type = check_typedef (type);
enum type_code code = TYPE_CODE (base_type);
- int len = TYPE_LENGTH (base_type);
if (code == TYPE_CODE_FLT)
{
struct value *val = allocate_value (type);
memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type));
-
return val;
}
+/* Extract a value from the history file. Input will be of the form
+ $digits or $$digits. See block comment above 'write_dollar_variable'
+ for details. */
+
+struct value *
+value_from_history_ref (char *h, char **endp)
+{
+ int index, len;
+
+ if (h[0] == '$')
+ len = 1;
+ else
+ return NULL;
+
+ if (h[1] == '$')
+ len = 2;
+
+ /* Find length of numeral string. */
+ for (; isdigit (h[len]); len++)
+ ;
+
+ /* Make sure numeral string is not part of an identifier. */
+ if (h[len] == '_' || isalpha (h[len]))
+ return NULL;
+
+ /* Now collect the index value. */
+ if (h[1] == '$')
+ {
+ if (len == 2)
+ {
+ /* For some bizarre reason, "$$" is equivalent to "$$1",
+ rather than to "$$0" as it ought to be! */
+ index = -1;
+ *endp += len;
+ }
+ else
+ index = -strtol (&h[2], endp, 10);
+ }
+ else
+ {
+ if (len == 1)
+ {
+ /* "$" is equivalent to "$0". */
+ index = 0;
+ *endp += len;
+ }
+ else
+ index = strtol (&h[1], endp, 10);
+ }
+
+ return access_value_history (index);
+}
+
+struct value *
+coerce_ref_if_computed (const struct value *arg)
+{
+ const struct lval_funcs *funcs;
+
+ if (TYPE_CODE (check_typedef (value_type (arg))) != TYPE_CODE_REF)
+ return NULL;
+
+ if (value_lval_const (arg) != lval_computed)
+ return NULL;
+
+ funcs = value_computed_funcs (arg);
+ if (funcs->coerce_ref == NULL)
+ return NULL;
+
+ return funcs->coerce_ref (arg);
+}
+
+/* Look at value.h for description. */
+
+struct value *
+readjust_indirect_value_type (struct value *value, struct type *enc_type,
+ struct type *original_type,
+ struct value *original_value)
+{
+ /* Re-adjust type. */
+ deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
+
+ /* Add embedding info. */
+ set_value_enclosing_type (value, enc_type);
+ set_value_embedded_offset (value, value_pointed_to_offset (original_value));
+
+ /* We may be pointing to an object of some derived type. */
+ return value_full_object (value, NULL, 0, 0, 0);
+}
+
struct value *
coerce_ref (struct value *arg)
{
struct type *value_type_arg_tmp = check_typedef (value_type (arg));
- if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)
- arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),
- unpack_pointer (value_type (arg),
- value_contents (arg)));
- return arg;
+ struct value *retval;
+ struct type *enc_type;
+
+ retval = coerce_ref_if_computed (arg);
+ if (retval)
+ return retval;
+
+ if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF)
+ return arg;
+
+ enc_type = check_typedef (value_enclosing_type (arg));
+ enc_type = TYPE_TARGET_TYPE (enc_type);
+
+ retval = value_at_lazy (enc_type,
+ unpack_pointer (value_type (arg),
+ value_contents (arg)));
+ return readjust_indirect_value_type (retval, enc_type,
+ value_type_arg_tmp, arg);
}
struct value *
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- if (current_language->c_style_arrays)
+ if (!TYPE_VECTOR (type) && current_language->c_style_arrays)
arg = value_coerce_array (arg);
break;
case TYPE_CODE_FUNC:
}
\f
-/* Return true if the function returning the specified type is using
- the convention of returning structures in memory (passing in the
- address as a hidden first parameter). */
+/* Return the return value convention that will be used for the
+ specified type. */
-int
-using_struct_return (struct gdbarch *gdbarch,
- struct type *func_type, struct type *value_type)
+enum return_value_convention
+struct_return_convention (struct gdbarch *gdbarch,
+ struct value *function, struct type *value_type)
{
enum type_code code = TYPE_CODE (value_type);
if (code == TYPE_CODE_ERROR)
error (_("Function return type unknown."));
- if (code == TYPE_CODE_VOID)
+ /* Probe the architecture for the return-value convention. */
+ return gdbarch_return_value (gdbarch, function, value_type,
+ NULL, NULL, NULL);
+}
+
+/* Return true if the function returning the specified type is using
+ the convention of returning structures in memory (passing in the
+ address as a hidden first parameter). */
+
+int
+using_struct_return (struct gdbarch *gdbarch,
+ struct value *function, struct type *value_type)
+{
+ if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
/* A void return value is never in memory. See also corresponding
code in "print_return_value". */
return 0;
- /* Probe the architecture for the return-value convention. */
- return (gdbarch_return_value (gdbarch, func_type, value_type,
- NULL, NULL, NULL)
+ return (struct_return_convention (gdbarch, function, value_type)
!= RETURN_VALUE_REGISTER_CONVENTION);
}
_initialize_values (void)
{
add_cmd ("convenience", no_class, show_convenience, _("\
-Debugger convenience (\"$foo\") variables.\n\
-These variables are created when you assign them values;\n\
-thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
+Debugger convenience (\"$foo\") variables and functions.\n\
+Convenience variables are created when you assign them values;\n\
+thus, \"set $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
\n\
A few convenience variables are given values automatically:\n\
\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
-\"$__\" holds the contents of the last address examined with \"x\"."),
- &showlist);
+\"$__\" holds the contents of the last address examined with \"x\"."
+#ifdef HAVE_PYTHON
+"\n\n\
+Convenience functions are defined via the Python API."
+#endif
+ ), &showlist);
+ add_alias_cmd ("conv", "convenience", no_class, 1, &showlist);
- add_cmd ("values", no_class, show_values,
- _("Elements of value history around item number IDX (or last ten)."),
+ add_cmd ("values", no_set_class, show_values, _("\
+Elements of value history around item number IDX (or last ten)."),
&showlist);
add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\
projects / deliverable / binutils-gdb.git / blobdiff