/* 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);
+ per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
+ ctx->get_frame_pc, ctx->baton);
+}
+
+/* Callback function for dwarf2_evaluate_loc_desc. */
+
+static struct type *
+dwarf_expr_get_base_type (struct dwarf_expr_context *ctx, size_t die_offset)
+{
+ struct dwarf_expr_baton *debaton = ctx->baton;
+
+ return dwarf2_get_die_type (die_offset, debaton->per_cu);
}
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);
+ int i;
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);
memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
+ for (i = 0; i < n_pieces; ++i)
+ if (c->pieces[i].location == DWARF_VALUE_STACK)
+ value_incref (c->pieces[i].v.value);
return c;
}
{
unsigned int mask;
- gdb_assert (dest_offset_bits >= 0 && dest_offset_bits + nbits <= 8);
+ gdb_assert (dest_offset_bits + nbits <= 8);
mask = (1 << nbits) - 1;
if (bits_big_endian)
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;
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
int reg_offset = source_offset;
if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
if (gdb_regnum != -1)
{
- get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer);
+ int optim, unavail;
+
+ if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+ this_size, buffer,
+ &optim, &unavail))
+ {
+ /* Just so garbage doesn't ever shine through. */
+ memset (buffer, 0, this_size);
+
+ if (optim)
+ set_value_optimized_out (v, 1);
+ if (unavail)
+ mark_value_bytes_unavailable (v, offset, this_size);
+ }
}
else
{
error (_("Unable to access DWARF register number %s"),
- paddress (arch, p->v.value));
+ paddress (arch, p->v.regno));
}
}
break;
case DWARF_VALUE_MEMORY:
- if (p->v.mem.in_stack_memory)
- read_stack (p->v.mem.addr + source_offset, buffer, this_size);
- else
- read_memory (p->v.mem.addr + source_offset, buffer, this_size);
+ read_value_memory (v, offset,
+ p->v.mem.in_stack_memory,
+ p->v.mem.addr + source_offset,
+ buffer, this_size);
break;
case DWARF_VALUE_STACK:
{
- struct gdbarch *gdbarch = get_type_arch (value_type (v));
size_t n = this_size;
if (n > c->addr_size - source_offset)
{
/* Nothing. */
}
- else if (source_offset == 0)
- store_unsigned_integer (buffer, n,
- gdbarch_byte_order (gdbarch),
- p->v.value);
else
{
- gdb_byte bytes[sizeof (ULONGEST)];
+ const gdb_byte *val_bytes = value_contents_all (p->v.value);
- store_unsigned_integer (bytes, n + source_offset,
- gdbarch_byte_order (gdbarch),
- p->v.value);
- memcpy (buffer, bytes + source_offset, n);
+ intermediate_buffer = val_bytes + source_offset;
}
}
break;
}
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;
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.value);
+ int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
int reg_offset = dest_offset;
if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
{
if (need_bitwise)
{
- get_frame_register_bytes (frame, gdb_regnum, reg_offset,
- this_size, buffer);
+ int optim, unavail;
+
+ if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
+ this_size, buffer,
+ &optim, &unavail))
+ {
+ if (optim)
+ error (_("Can't do read-modify-write to "
+ "update bitfield; containing word has been "
+ "optimized out"));
+ if (unavail)
+ throw_error (NOT_AVAILABLE_ERROR,
+ _("Can't do read-modify-write to update "
+ "bitfield; containing word "
+ "is unavailable"));
+ }
copy_bitwise (buffer, dest_offset_bits,
contents, source_offset_bits,
this_size_bits,
else
{
error (_("Unable to write to DWARF register number %s"),
- paddress (arch, p->v.value));
+ paddress (arch, p->v.regno));
}
}
break;
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);
+
+ gdb_assert (piece);
+ 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)
{
+ int i;
+
+ for (i = 0; i < c->n_pieces; ++i)
+ if (c->pieces[i].location == DWARF_VALUE_STACK)
+ value_free (c->pieces[i].v.value);
+
xfree (c->pieces);
xfree (c);
}
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 dwarf_expr_context *ctx;
- struct cleanup *old_chain;
+ struct cleanup *old_chain, *value_chain;
struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
+ volatile struct gdb_exception ex;
+
+ if (byte_offset < 0)
+ invalid_synthetic_pointer ();
if (size == 0)
{
ctx = new_dwarf_expr_context ();
old_chain = make_cleanup_free_dwarf_expr_context (ctx);
+ value_chain = make_cleanup_value_free_to_mark (value_mark ());
ctx->gdbarch = get_objfile_arch (objfile);
ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
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;
+ ctx->get_base_type = dwarf_expr_get_base_type;
+
+ TRY_CATCH (ex, RETURN_MASK_ERROR)
+ {
+ dwarf_expr_eval (ctx, data, size);
+ }
+ if (ex.reason < 0)
+ {
+ if (ex.error == NOT_AVAILABLE_ERROR)
+ {
+ do_cleanups (old_chain);
+ retval = allocate_value (type);
+ mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
+ return retval;
+ }
+ else
+ throw_exception (ex);
+ }
- dwarf_expr_eval (ctx, data, size);
if (ctx->num_pieces > 0)
{
struct piece_closure *c;
struct frame_id frame_id = get_frame_id (frame);
+ ULONGEST bit_size = 0;
+ int i;
+
+ 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 (ctx->num_pieces, ctx->pieces,
+ c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
ctx->addr_size);
+ /* We must clean up the value chain after creating the piece
+ closure but before allocating the result. */
+ do_cleanups (value_chain);
retval = allocate_computed_value (type, &pieced_value_funcs, c);
VALUE_FRAME_ID (retval) = frame_id;
+ set_value_offset (retval, byte_offset);
}
else
{
case DWARF_VALUE_REGISTER:
{
struct gdbarch *arch = get_frame_arch (frame);
- ULONGEST dwarf_regnum = dwarf_expr_fetch (ctx, 0);
+ ULONGEST dwarf_regnum = value_as_long (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"));
+ do_cleanups (value_chain);
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);
+ do_cleanups (value_chain);
+ 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;
- size_t n = ctx->addr_size;
+ struct value *value = dwarf_expr_fetch (ctx, 0);
+ gdb_byte *contents;
+ const gdb_byte *val_bytes;
+ size_t n = TYPE_LENGTH (value_type (value));
+
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
+ val_bytes = value_contents_all (value);
+ val_bytes += byte_offset;
+ n -= byte_offset;
+
+ /* Preserve VALUE because we are going to free values back
+ to the mark, but we still need the value contents
+ below. */
+ value_incref (value);
+ do_cleanups (value_chain);
+ make_cleanup_value_free (value);
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, val_bytes, n);
}
break;
case DWARF_VALUE_LITERAL:
{
bfd_byte *contents;
+ const bfd_byte *ldata;
size_t n = ctx->len;
+ if (byte_offset + TYPE_LENGTH (type) > n)
+ invalid_synthetic_pointer ();
+
+ do_cleanups (value_chain);
retval = allocate_value (type);
contents = value_contents_raw (retval);
+
+ ldata = ctx->data + byte_offset;
+ n -= byte_offset;
+
if (n > TYPE_LENGTH (type))
n = TYPE_LENGTH (type);
- memcpy (contents, ctx->data, n);
+ memcpy (contents, ldata, n);
}
break;
+ case DWARF_VALUE_OPTIMIZED_OUT:
+ do_cleanups (value_chain);
+ retval = allocate_value (type);
+ VALUE_LVAL (retval) = not_lval;
+ set_value_optimized_out (retval, 1);
+ 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:
default:
internal_error (__FILE__, __LINE__, _("invalid location type"));
}
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);
+ 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 = new_dwarf_expr_context ();
old_chain = make_cleanup_free_dwarf_expr_context (ctx);
+ make_cleanup_value_free_to_mark (value_mark ());
ctx->gdbarch = get_objfile_arch (objfile);
ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
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;
static void
unimplemented (unsigned int op)
{
- error (_("DWARF operator %s cannot be translated to an agent expression"),
- dwarf_stack_op_name (op, 1));
+ const char *name = dwarf_stack_op_name (op);
+
+ if (name)
+ error (_("DWARF operator %s cannot be translated to an agent expression"),
+ name);
+ else
+ error (_("Unknown DWARF operator 0x%02x cannot be translated "
+ "to an agent expression"),
+ op);
}
/* A helper function to convert a DWARF register to an arch register.
}
}
+/* 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.
example, if the expression cannot be compiled, or if the expression
is invalid. */
-static void
-compile_dwarf_to_ax (struct agent_expr *expr, struct axs_value *loc,
- struct gdbarch *arch, unsigned int addr_size,
- const gdb_byte *op_ptr, const gdb_byte *op_end,
- struct dwarf2_per_cu_data *per_cu)
+void
+dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
+ struct gdbarch *arch, unsigned int addr_size,
+ const gdb_byte *op_ptr, const gdb_byte *op_end,
+ struct dwarf2_per_cu_data *per_cu)
{
struct cleanup *cleanups;
int i, *offsets;
&datastart, &datalen);
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
- compile_dwarf_to_ax (expr, loc, arch, addr_size, datastart,
- datastart + datalen, per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
+ datastart + datalen, per_cu);
if (offset != 0)
{
case DW_OP_pick:
offset = *op_ptr++;
- unimplemented (op);
+ ax_pick (expr, offset);
break;
case DW_OP_swap:
break;
case DW_OP_over:
- /* We can't directly support DW_OP_over, but GCC emits it as
- part of a sequence to implement signed modulus. As a
- hack, we recognize this sequence. Note that if GCC ever
- generates a branch to the middle of this sequence, then
- we will die somehow. */
- if (op_end - op_ptr >= 4
- && op_ptr[0] == DW_OP_over
- && op_ptr[1] == DW_OP_div
- && op_ptr[2] == DW_OP_mul
- && op_ptr[3] == DW_OP_minus)
- {
- /* Sign extend the operands. */
- ax_ext (expr, addr_size_bits);
- ax_simple (expr, aop_swap);
- ax_ext (expr, addr_size_bits);
- ax_simple (expr, aop_swap);
- ax_simple (expr, aop_rem_signed);
- op_ptr += 4;
- }
- else
- unimplemented (op);
+ ax_pick (expr, 1);
break;
case DW_OP_rot:
- unimplemented (op);
+ ax_simple (expr, aop_rot);
break;
case DW_OP_deref:
ax_simple (expr, aop_ref64);
break;
default:
+ /* Note that dwarf_stack_op_name will never return
+ NULL here. */
error (_("Unsupported size %d in %s"),
- size, dwarf_stack_op_name (op, 1));
+ size, dwarf_stack_op_name (op));
}
}
break;
break;
case DW_OP_call_frame_cfa:
- unimplemented (op);
+ dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
+ loc->kind = axs_lvalue_memory;
break;
case DW_OP_GNU_push_tls_address:
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);
- compile_dwarf_to_ax (expr, loc, arch, addr_size,
- block.data, block.data + block.size,
- per_cu);
+ dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
+ block.data, block.data + block.size,
+ per_cu);
}
break;
unimplemented (op);
default:
- error (_("Unhandled dwarf expression opcode 0x%x"), op);
+ unimplemented (op);
}
}
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
LONGEST l;
const char *name;
- name = dwarf_stack_op_name (op, 0);
+ name = dwarf_stack_op_name (op);
if (!name)
error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
- op, (long) (data - start));
- fprintf_filtered (stream, " % 4ld: %s", (long) (data - start), name);
+ op, (long) (data - 1 - start));
+ fprintf_filtered (stream, " % 4ld: %s", (long) (data - 1 - start), name);
switch (op)
{
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
- data = read_sleb128 (data, end, &ul);
- fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
+ data = read_sleb128 (data, end, &l);
+ fprintf_filtered (stream, " %s [$%s]", plongest (l),
gdbarch_register_name (arch, op - DW_OP_breg0));
break;
case DW_OP_bregx:
- {
- ULONGEST offset;
-
- data = read_uleb128 (data, end, &ul);
- data = read_sleb128 (data, end, &offset);
- fprintf_filtered (stream, " register %s [$%s] offset %s",
- pulongest (ul),
- gdbarch_register_name (arch, (int) ul),
- pulongest (offset));
- }
+ data = read_uleb128 (data, end, &ul);
+ data = read_sleb128 (data, end, &l);
+ fprintf_filtered (stream, " register %s [$%s] offset %s",
+ pulongest (ul),
+ gdbarch_register_name (arch, (int) ul),
+ plongest (l));
break;
case DW_OP_fbreg:
- data = read_sleb128 (data, end, &ul);
- fprintf_filtered (stream, " %s", pulongest (ul));
+ data = read_sleb128 (data, end, &l);
+ fprintf_filtered (stream, " %s", plongest (l));
break;
case DW_OP_xderef_size:
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);
}
if (dlbaton->data == NULL || dlbaton->size == 0)
value->optimized_out = 1;
else
- compile_dwarf_to_ax (ax, value, gdbarch, addr_size,
- dlbaton->data, dlbaton->data + dlbaton->size,
- dlbaton->per_cu);
+ dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
+ dlbaton->data, dlbaton->data + dlbaton->size,
+ dlbaton->per_cu);
}
/* The set of location functions used with the DWARF-2 expression
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
- compile_dwarf_to_ax (ax, value, gdbarch, addr_size, data, data + size,
- dlbaton->per_cu);
+ dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
+ dlbaton->per_cu);
}
/* The set of location functions used with the DWARF-2 expression
projects / deliverable / binutils-gdb.git / blobdiff