/* DWARF 2 location expression support for GDB.
- Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
+ Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length);
-/* A helper function for dealing with location lists. Given a
+static struct value *
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu,
+ LONGEST byte_offset);
+
+/* A function for dealing with location lists. Given a
symbol baton (BATON) and a pc value (PC), find the appropriate
location expression, set *LOCEXPR_LENGTH, and return a pointer
to the beginning of the expression. Returns NULL on failure.
For now, only return the first matching location expression; there
can be more than one in the list. */
-static const gdb_byte *
-find_location_expression (struct dwarf2_loclist_baton *baton,
- size_t *locexpr_length, CORE_ADDR pc)
+const gdb_byte *
+dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
+ size_t *locexpr_length, CORE_ADDR pc)
{
CORE_ADDR low, high;
const gdb_byte *loc_ptr, *buf_end;
while (1)
{
if (buf_end - loc_ptr < 2 * addr_size)
- error (_("find_location_expression: Corrupted DWARF expression."));
+ error (_("dwarf2_find_location_expression: "
+ "Corrupted DWARF expression."));
if (signed_addr_p)
low = extract_signed_integer (loc_ptr, addr_size, byte_order);
struct dwarf2_loclist_baton *symbaton;
symbaton = SYMBOL_LOCATION_BATON (framefunc);
- *start = find_location_expression (symbaton, length, pc);
+ *start = dwarf2_find_location_expression (symbaton, length, pc);
}
else
{
return dwarf2_frame_cfa (debaton->frame);
}
+/* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
+ the frame in BATON. */
+
+static CORE_ADDR
+dwarf_expr_frame_pc (void *baton)
+{
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+
+ return get_frame_address_in_block (debaton->frame);
+}
+
/* Using the objfile specified in BATON, find the address for the
current thread's thread-local storage with offset OFFSET. */
static CORE_ADDR
return target_translate_tls_address (objfile, offset);
}
-/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in current CU
- (as is PER_CU). State of the CTX is not affected by the call and return. */
+/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
+ current CU (as is PER_CU). State of the CTX is not affected by the
+ call and return. */
static void
per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
- struct dwarf2_per_cu_data *per_cu)
+ struct dwarf2_per_cu_data *per_cu,
+ CORE_ADDR (*get_frame_pc) (void *baton),
+ void *baton)
{
struct dwarf2_locexpr_baton block;
- block = dwarf2_fetch_die_location_block (die_offset, per_cu);
+ block = dwarf2_fetch_die_location_block (die_offset, per_cu,
+ get_frame_pc, baton);
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);
{
struct dwarf_expr_baton *debaton = ctx->baton;
- return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu);
+ return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
+ ctx->get_frame_pc, ctx->baton);
}
struct piece_closure
/* Reference count. */
int refc;
+ /* The CU from which this closure's expression came. */
+ struct dwarf2_per_cu_data *per_cu;
+
/* The number of pieces used to describe this variable. */
int n_pieces;
PIECES. */
static struct piece_closure *
-allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
+allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
+ int n_pieces, struct dwarf_expr_piece *pieces,
int addr_size)
{
struct piece_closure *c = XZALLOC (struct piece_closure);
c->refc = 1;
+ c->per_cu = per_cu;
c->n_pieces = n_pieces;
c->addr_size = addr_size;
c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
long offset = 0;
ULONGEST bits_to_skip;
gdb_byte *contents;
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
size_t type_len;
size_t buffer_size = 0;
}
break;
+ /* These bits show up as zeros -- but do not cause the value
+ to be considered optimized-out. */
+ case DWARF_VALUE_IMPLICIT_POINTER:
+ break;
+
case DWARF_VALUE_OPTIMIZED_OUT:
set_value_optimized_out (v, 1);
break;
internal_error (__FILE__, __LINE__, _("invalid location type"));
}
- if (p->location != DWARF_VALUE_OPTIMIZED_OUT)
+ if (p->location != DWARF_VALUE_OPTIMIZED_OUT
+ && p->location != DWARF_VALUE_IMPLICIT_POINTER)
copy_bitwise (contents, dest_offset_bits,
intermediate_buffer, source_offset_bits % 8,
this_size_bits, bits_big_endian);
long offset = 0;
ULONGEST bits_to_skip;
const gdb_byte *contents;
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (to);
struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
size_t type_len;
size_t buffer_size = 0;
do_cleanups (cleanup);
}
+/* A helper function that checks bit validity in a pieced value.
+ CHECK_FOR indicates the kind of validity checking.
+ DWARF_VALUE_MEMORY means to check whether any bit is valid.
+ DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
+ optimized out.
+ DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
+ implicit pointer. */
+
static int
check_pieced_value_bits (const struct value *value, int bit_offset,
- int bit_length, int validity)
+ int bit_length,
+ enum dwarf_value_location check_for)
{
struct piece_closure *c
= (struct piece_closure *) value_computed_closure (value);
int i;
+ int validity = (check_for == DWARF_VALUE_MEMORY
+ || check_for == DWARF_VALUE_IMPLICIT_POINTER);
bit_offset += 8 * value_offset (value);
if (value_bitsize (value))
else
bit_length -= this_size_bits;
- if (p->location == DWARF_VALUE_OPTIMIZED_OUT)
+ if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
+ {
+ if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+ return 0;
+ }
+ else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
+ || p->location == DWARF_VALUE_IMPLICIT_POINTER)
{
if (validity)
return 0;
check_pieced_value_validity (const struct value *value, int bit_offset,
int bit_length)
{
- return check_pieced_value_bits (value, bit_offset, bit_length, 1);
+ return check_pieced_value_bits (value, bit_offset, bit_length,
+ DWARF_VALUE_MEMORY);
}
static int
check_pieced_value_invalid (const struct value *value)
{
return check_pieced_value_bits (value, 0,
- 8 * TYPE_LENGTH (value_type (value)), 0);
+ 8 * TYPE_LENGTH (value_type (value)),
+ DWARF_VALUE_OPTIMIZED_OUT);
+}
+
+/* An implementation of an lval_funcs method to see whether a value is
+ a synthetic pointer. */
+
+static int
+check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
+ int bit_length)
+{
+ return check_pieced_value_bits (value, bit_offset, bit_length,
+ DWARF_VALUE_IMPLICIT_POINTER);
+}
+
+/* A wrapper function for get_frame_address_in_block. */
+
+static CORE_ADDR
+get_frame_address_in_block_wrapper (void *baton)
+{
+ return get_frame_address_in_block (baton);
+}
+
+/* An implementation of an lval_funcs method to indirect through a
+ pointer. This handles the synthetic pointer case when needed. */
+
+static struct value *
+indirect_pieced_value (struct value *value)
+{
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (value);
+ struct type *type;
+ struct frame_info *frame;
+ struct dwarf2_locexpr_baton baton;
+ int i, bit_offset, bit_length;
+ struct dwarf_expr_piece *piece = NULL;
+ struct value *result;
+ LONGEST byte_offset;
+
+ type = value_type (value);
+ if (TYPE_CODE (type) != TYPE_CODE_PTR)
+ return NULL;
+
+ bit_length = 8 * TYPE_LENGTH (type);
+ bit_offset = 8 * value_offset (value);
+ if (value_bitsize (value))
+ bit_offset += value_bitpos (value);
+
+ for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+ {
+ struct dwarf_expr_piece *p = &c->pieces[i];
+ size_t this_size_bits = p->size;
+
+ if (bit_offset > 0)
+ {
+ if (bit_offset >= this_size_bits)
+ {
+ bit_offset -= this_size_bits;
+ continue;
+ }
+
+ bit_length -= this_size_bits - bit_offset;
+ bit_offset = 0;
+ }
+ else
+ bit_length -= this_size_bits;
+
+ if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+ return NULL;
+
+ if (bit_length != 0)
+ error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
+
+ piece = p;
+ break;
+ }
+
+ frame = get_selected_frame (_("No frame selected."));
+ byte_offset = value_as_address (value);
+
+ baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
+ get_frame_address_in_block_wrapper,
+ frame);
+
+ result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
+ baton.data, baton.size, baton.per_cu,
+ byte_offset);
+
+ return result;
}
static void *
copy_pieced_value_closure (const struct value *v)
{
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
++c->refc;
return c;
static void
free_pieced_value_closure (struct value *v)
{
- struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
+ struct piece_closure *c
+ = (struct piece_closure *) value_computed_closure (v);
--c->refc;
if (c->refc == 0)
write_pieced_value,
check_pieced_value_validity,
check_pieced_value_invalid,
+ indirect_pieced_value,
+ check_pieced_synthetic_pointer,
copy_pieced_value_closure,
free_pieced_value_closure
};
+/* Helper function which throws an error if a synthetic pointer is
+ invalid. */
+
+static void
+invalid_synthetic_pointer (void)
+{
+ error (_("access outside bounds of object "
+ "referenced via synthetic pointer"));
+}
+
/* Evaluate a location description, starting at DATA and with length
- SIZE, to find the current location of variable of TYPE in the context
- of FRAME. */
+ SIZE, to find the current location of variable of TYPE in the
+ context of FRAME. BYTE_OFFSET is applied after the contents are
+ computed. */
static struct value *
-dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
- const gdb_byte *data, unsigned short size,
- struct dwarf2_per_cu_data *per_cu)
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu,
+ LONGEST byte_offset)
{
struct value *retval;
struct dwarf_expr_baton baton;
struct cleanup *old_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
+ if (byte_offset < 0)
+ invalid_synthetic_pointer ();
+
if (size == 0)
{
retval = allocate_value (type);
ctx->read_mem = dwarf_expr_read_mem;
ctx->get_frame_base = dwarf_expr_frame_base;
ctx->get_frame_cfa = dwarf_expr_frame_cfa;
+ ctx->get_frame_pc = dwarf_expr_frame_pc;
ctx->get_tls_address = dwarf_expr_tls_address;
ctx->dwarf_call = dwarf_expr_dwarf_call;
{
struct piece_closure *c;
struct frame_id frame_id = get_frame_id (frame);
+ ULONGEST bit_size = 0;
+ int i;
- c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
+ for (i = 0; i < ctx->num_pieces; ++i)
+ bit_size += ctx->pieces[i].size;
+ if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
+ invalid_synthetic_pointer ();
+
+ c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
ctx->addr_size);
retval = allocate_computed_value (type, &pieced_value_funcs, c);
VALUE_FRAME_ID (retval) = frame_id;
+ set_value_offset (retval, byte_offset);
}
else
{
ULONGEST dwarf_regnum = dwarf_expr_fetch (ctx, 0);
int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
+ if (byte_offset != 0)
+ error (_("cannot use offset on synthetic pointer to register"));
if (gdb_regnum != -1)
retval = value_from_register (type, gdb_regnum, frame);
else
CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
- retval = allocate_value (type);
+ retval = allocate_value_lazy (type);
VALUE_LVAL (retval) = lval_memory;
- set_value_lazy (retval, 1);
if (in_stack_memory)
set_value_stack (retval, 1);
- set_value_address (retval, address);
+ set_value_address (retval, address + byte_offset);
}
break;
case DWARF_VALUE_STACK:
{
ULONGEST value = dwarf_expr_fetch (ctx, 0);
- bfd_byte *contents;
+ bfd_byte *contents, *tem;
size_t n = ctx->addr_size;
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
+ tem = alloca (n);
+ store_unsigned_integer (tem, n,
+ gdbarch_byte_order (ctx->gdbarch),
+ value);
+
+ tem += byte_offset;
+ n -= byte_offset;
+
retval = allocate_value (type);
contents = value_contents_raw (retval);
if (n > TYPE_LENGTH (type))
n = TYPE_LENGTH (type);
- store_unsigned_integer (contents, n,
- gdbarch_byte_order (ctx->gdbarch),
- value);
+ memcpy (contents, tem, n);
}
break;
case DWARF_VALUE_LITERAL:
{
bfd_byte *contents;
+ const bfd_byte *data;
size_t n = ctx->len;
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
retval = allocate_value (type);
contents = value_contents_raw (retval);
+
+ data = ctx->data + byte_offset;
+ n -= byte_offset;
+
if (n > TYPE_LENGTH (type))
n = TYPE_LENGTH (type);
- memcpy (contents, ctx->data, n);
+ memcpy (contents, data, n);
}
break;
+ /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
+ operation by execute_stack_op. */
+ case DWARF_VALUE_IMPLICIT_POINTER:
/* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
it can only be encountered when making a piece. */
case DWARF_VALUE_OPTIMIZED_OUT:
return retval;
}
+
+/* The exported interface to dwarf2_evaluate_loc_desc_full; it always
+ passes 0 as the byte_offset. */
+
+struct value *
+dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
+ const gdb_byte *data, unsigned short size,
+ struct dwarf2_per_cu_data *per_cu)
+{
+ return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
+}
+
\f
/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
{
struct needs_frame_baton *nf_baton = ctx->baton;
- return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu);
+ return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
+ ctx->get_frame_pc, ctx->baton);
}
/* Return non-zero iff the location expression at DATA (length SIZE)
ctx->read_mem = needs_frame_read_mem;
ctx->get_frame_base = needs_frame_frame_base;
ctx->get_frame_cfa = needs_frame_frame_cfa;
+ ctx->get_frame_pc = needs_frame_frame_cfa;
ctx->get_tls_address = needs_frame_tls_address;
ctx->dwarf_call = needs_frame_dwarf_call;
}
}
+/* A helper function to return the frame's PC. */
+
+static CORE_ADDR
+get_ax_pc (void *baton)
+{
+ struct agent_expr *expr = baton;
+
+ return expr->scope;
+}
+
/* Compile a DWARF location expression to an agent expression.
EXPR is the agent expression we are building.
uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
op_ptr += size;
- block = dwarf2_fetch_die_location_block (uoffset, per_cu);
+ block = dwarf2_fetch_die_location_block (uoffset, per_cu,
+ get_ax_pc, expr);
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);
struct symbol *framefunc;
int frame_reg = 0;
LONGEST frame_offset;
- const gdb_byte *base_data, *new_data;
+ const gdb_byte *base_data, *new_data, *save_data = data;
size_t base_size;
LONGEST base_offset = 0;
buf_end = read_sleb128 (base_data + 1,
base_data + base_size, &base_offset);
if (buf_end != base_data + base_size)
- error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
+ error (_("Unexpected opcode after "
+ "DW_OP_breg%u for symbol \"%s\"."),
frame_reg, SYMBOL_PRINT_NAME (symbol));
}
else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
{
/* We don't know what to do with the frame base expression,
so we can't trace this variable; give up. */
- error (_("Cannot describe location of symbol \"%s\"; "
- "DWARF 2 encoding not handled, "
- "first opcode in base data is 0x%x."),
- SYMBOL_PRINT_NAME (symbol), base_data[0]);
+ return save_data;
}
regno = gdbarch_dwarf2_reg_to_regnum (gdbarch, frame_reg);
- fprintf_filtered (stream, _("a variable at frame base reg $%s offset %s+%s"),
+ fprintf_filtered (stream,
+ _("a variable at frame base reg $%s offset %s+%s"),
gdbarch_register_name (gdbarch, regno),
plongest (base_offset), plongest (frame_offset));
}
as the size of an address on the target machine (here is 8
bytes). Note that more recent version of GCC emit DW_OP_const4u
or DW_OP_const8u, depending on address size, rather than
- DW_OP_addr. 0xe0 is the encoding for
- DW_OP_GNU_push_tls_address. The operand represents the offset at
- which the variable is within the thread local storage. */
+ DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
+ The operand represents the offset at which the variable is within
+ the thread local storage. */
else if (data + 1 + addr_size < end
&& (data[0] == DW_OP_addr
pulongest (ul), pulongest (offset));
}
break;
+
+ case DW_OP_GNU_implicit_pointer:
+ {
+ ul = extract_unsigned_integer (data, offset_size,
+ gdbarch_byte_order (arch));
+ data += offset_size;
+
+ data = read_sleb128 (data, end, &l);
+
+ fprintf_filtered (stream, " DIE %s offset %s",
+ phex_nz (ul, offset_size),
+ plongest (l));
+ }
+ break;
}
fprintf_filtered (stream, "\n");
if (!dwarf2_always_disassemble)
{
- data = locexpr_describe_location_piece (symbol, stream, addr, objfile,
+ data = locexpr_describe_location_piece (symbol, stream,
+ addr, objfile,
data, end, addr_size);
/* If we printed anything, or if we have an empty piece,
then don't disassemble. */
disassemble = 0;
}
if (disassemble)
- data = disassemble_dwarf_expression (stream, get_objfile_arch (objfile),
+ data = disassemble_dwarf_expression (stream,
+ get_objfile_arch (objfile),
addr_size, offset_size, data, end,
dwarf2_always_disassemble);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
- locexpr_describe_location_1 (symbol, addr, stream, dlbaton->data, dlbaton->size,
+ locexpr_describe_location_1 (symbol, addr, stream,
+ dlbaton->data, dlbaton->size,
objfile, addr_size, offset_size);
}
struct value *val;
const gdb_byte *data;
size_t size;
+ CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
- data = find_location_expression (dlbaton, &size,
- frame ? get_frame_address_in_block (frame)
- : 0);
+ data = dwarf2_find_location_expression (dlbaton, &size, pc);
if (data == NULL)
{
val = allocate_value (SYMBOL_TYPE (symbol));
size_t size;
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
- data = find_location_expression (dlbaton, &size, ax->scope);
+ data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
if (data == NULL || size == 0)
value->optimized_out = 1;
else
projects / deliverable / binutils-gdb.git / blobdiff