/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010
+ Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
static void execute_stack_op (struct dwarf_expr_context *,
const gdb_byte *, const gdb_byte *);
-static struct type *unsigned_address_type (struct gdbarch *, int);
/* Create a new context for the expression evaluator. */
/* Push VALUE onto CTX's stack. */
void
-dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value,
+dwarf_expr_push (struct dwarf_expr_context *ctx, ULONGEST value,
int in_stack_memory)
{
struct dwarf_stack_value *v;
+ /* We keep all stack elements within the range defined by the
+ DWARF address size. */
+ if (ctx->addr_size < sizeof (ULONGEST))
+ value &= ((ULONGEST) 1 << (ctx->addr_size * HOST_CHAR_BIT)) - 1;
+
dwarf_expr_grow_stack (ctx, 1);
v = &ctx->stack[ctx->stack_len++];
v->value = value;
/* Retrieve the N'th item on CTX's stack. */
-CORE_ADDR
+ULONGEST
dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
{
if (ctx->stack_len <= n)
- error (_("Asked for position %d of stack, stack only has %d elements on it."),
+ error (_("Asked for position %d of stack, "
+ "stack only has %d elements on it."),
n, ctx->stack_len);
return ctx->stack[ctx->stack_len - (1 + n)].value;
}
+/* Retrieve the N'th item on CTX's stack, converted to an address. */
+
+CORE_ADDR
+dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
+{
+ ULONGEST result = dwarf_expr_fetch (ctx, n);
+
+ /* For most architectures, calling extract_unsigned_integer() alone
+ is sufficient for extracting an address. However, some
+ architectures (e.g. MIPS) use signed addresses and using
+ extract_unsigned_integer() will not produce a correct
+ result. Make sure we invoke gdbarch_integer_to_address()
+ for those architectures which require it. */
+ if (gdbarch_integer_to_address_p (ctx->gdbarch))
+ {
+ enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+ gdb_byte *buf = alloca (ctx->addr_size);
+ struct type *int_type;
+
+ switch (ctx->addr_size)
+ {
+ case 2:
+ int_type = builtin_type (ctx->gdbarch)->builtin_uint16;
+ break;
+ case 4:
+ int_type = builtin_type (ctx->gdbarch)->builtin_uint32;
+ break;
+ case 8:
+ int_type = builtin_type (ctx->gdbarch)->builtin_uint64;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__,
+ _("Unsupported address size.\n"));
+ }
+
+ store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
+ return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
+ }
+
+ return (CORE_ADDR) result;
+}
+
/* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
int
dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
{
if (ctx->stack_len <= n)
- error (_("Asked for position %d of stack, stack only has %d elements on it."),
+ error (_("Asked for position %d of stack, "
+ "stack only has %d elements on it."),
n, ctx->stack_len);
return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
cases in the evaluator. */
ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
}
+ else if (p->location == DWARF_VALUE_MEMORY)
+ {
+ p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
+ p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+ }
+ else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
+ {
+ p->v.ptr.die = ctx->len;
+ p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0);
+ }
else
{
- p->v.expr.value = dwarf_expr_fetch (ctx, 0);
- p->v.expr.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+ p->v.value = dwarf_expr_fetch (ctx, 0);
}
}
*r = result;
return buf;
}
-
-/* Read an address of size ADDR_SIZE from BUF, and verify that it
- doesn't extend past BUF_END. */
-
-CORE_ADDR
-dwarf2_read_address (struct gdbarch *gdbarch, const gdb_byte *buf,
- const gdb_byte *buf_end, int addr_size)
-{
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-
- if (buf_end - buf < addr_size)
- error (_("dwarf2_read_address: Corrupted DWARF expression."));
-
- /* For most architectures, calling extract_unsigned_integer() alone
- is sufficient for extracting an address. However, some
- architectures (e.g. MIPS) use signed addresses and using
- extract_unsigned_integer() will not produce a correct
- result. Make sure we invoke gdbarch_integer_to_address()
- for those architectures which require it.
-
- The use of `unsigned_address_type' in the code below refers to
- the type of buf and has no bearing on the signedness of the
- address being returned. */
-
- if (gdbarch_integer_to_address_p (gdbarch))
- return gdbarch_integer_to_address
- (gdbarch, unsigned_address_type (gdbarch, addr_size), buf);
-
- return extract_unsigned_integer (buf, addr_size, byte_order);
-}
-
-/* Return the type of an address of size ADDR_SIZE,
- for unsigned arithmetic. */
-
-static struct type *
-unsigned_address_type (struct gdbarch *gdbarch, int addr_size)
-{
- switch (addr_size)
- {
- case 2:
- return builtin_type (gdbarch)->builtin_uint16;
- case 4:
- return builtin_type (gdbarch)->builtin_uint32;
- case 8:
- return builtin_type (gdbarch)->builtin_uint64;
- default:
- internal_error (__FILE__, __LINE__,
- _("Unsupported address size.\n"));
- }
-}
-
-/* Return the type of an address of size ADDR_SIZE,
- for signed arithmetic. */
-
-static struct type *
-signed_address_type (struct gdbarch *gdbarch, int addr_size)
-{
- switch (addr_size)
- {
- case 2:
- return builtin_type (gdbarch)->builtin_int16;
- case 4:
- return builtin_type (gdbarch)->builtin_int32;
- case 8:
- return builtin_type (gdbarch)->builtin_int64;
- default:
- internal_error (__FILE__, __LINE__,
- _("Unsupported address size.\n"));
- }
-}
\f
/* Check that the current operator is either at the end of an
expression, or that it is followed by a composition operator. */
-static void
-require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
- const char *op_name)
+void
+dwarf_expr_require_composition (const gdb_byte *op_ptr, const gdb_byte *op_end,
+ const char *op_name)
{
/* It seems like DW_OP_GNU_uninit should be handled here. However,
it doesn't seem to make sense for DW_OP_*_value, and it was not
execute_stack_op (struct dwarf_expr_context *ctx,
const gdb_byte *op_ptr, const gdb_byte *op_end)
{
+#define sign_ext(x) ((LONGEST) (((x) ^ sign_bit) - sign_bit))
+ ULONGEST sign_bit = (ctx->addr_size >= sizeof (ULONGEST) ? 0
+ : ((ULONGEST) 1) << (ctx->addr_size * 8 - 1));
enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
ctx->location = DWARF_VALUE_MEMORY;
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
- CORE_ADDR result;
+ ULONGEST result;
/* Assume the value is not in stack memory.
Code that knows otherwise sets this to 1.
Some arithmetic on stack addresses can probably be assumed to still
break;
case DW_OP_addr:
- result = dwarf2_read_address (ctx->gdbarch,
- op_ptr, op_end, ctx->addr_size);
+ result = extract_unsigned_integer (op_ptr,
+ ctx->addr_size, byte_order);
op_ptr += ctx->addr_size;
+ /* Some versions of GCC emit DW_OP_addr before
+ DW_OP_GNU_push_tls_address. In this case the value is an
+ index, not an address. We don't support things like
+ branching between the address and the TLS op. */
+ if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
+ result += ctx->offset;
break;
case DW_OP_const1u:
case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
- require_composition (op_ptr, op_end, "DW_OP_regx");
+ dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
result = reg;
ctx->location = DWARF_VALUE_REGISTER;
ctx->data = op_ptr;
ctx->location = DWARF_VALUE_LITERAL;
op_ptr += len;
- require_composition (op_ptr, op_end, "DW_OP_implicit_value");
+ dwarf_expr_require_composition (op_ptr, op_end,
+ "DW_OP_implicit_value");
}
goto no_push;
case DW_OP_stack_value:
ctx->location = DWARF_VALUE_STACK;
- require_composition (op_ptr, op_end, "DW_OP_stack_value");
+ dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
goto no_push;
+ case DW_OP_GNU_implicit_pointer:
+ {
+ ULONGEST die;
+ LONGEST len;
+
+ /* The referred-to DIE. */
+ ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
+ byte_order);
+ op_ptr += ctx->addr_size;
+
+ /* The byte offset into the data. */
+ op_ptr = read_sleb128 (op_ptr, op_end, &len);
+ result = (ULONGEST) len;
+
+ ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
+ dwarf_expr_require_composition (op_ptr, op_end,
+ "DW_OP_GNU_implicit_pointer");
+ }
+ break;
+
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
specific this_base method. */
(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
dwarf_expr_eval (ctx, datastart, datalen);
- if (ctx->location == DWARF_VALUE_LITERAL
- || ctx->location == DWARF_VALUE_STACK)
- error (_("Not implemented: computing frame base using explicit value operator"));
- result = dwarf_expr_fetch (ctx, 0);
- if (ctx->location == DWARF_VALUE_REGISTER)
- result = (ctx->read_reg) (ctx->baton, result);
+ if (ctx->location == DWARF_VALUE_MEMORY)
+ result = dwarf_expr_fetch_address (ctx, 0);
+ else if (ctx->location == DWARF_VALUE_REGISTER)
+ result = (ctx->read_reg) (ctx->baton, dwarf_expr_fetch (ctx, 0));
+ else
+ error (_("Not implemented: computing frame "
+ "base using explicit value operator"));
result = result + offset;
in_stack_memory = 1;
ctx->stack_len = before_stack_len;
struct dwarf_stack_value t1, t2;
if (ctx->stack_len < 2)
- error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
+ error (_("Not enough elements for "
+ "DW_OP_swap. Need 2, have %d."),
ctx->stack_len);
t1 = ctx->stack[ctx->stack_len - 1];
t2 = ctx->stack[ctx->stack_len - 2];
struct dwarf_stack_value t1, t2, t3;
if (ctx->stack_len < 3)
- error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
+ error (_("Not enough elements for "
+ "DW_OP_rot. Need 3, have %d."),
ctx->stack_len);
t1 = ctx->stack[ctx->stack_len - 1];
t2 = ctx->stack[ctx->stack_len - 2];
case DW_OP_deref:
case DW_OP_deref_size:
+ {
+ int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
+ gdb_byte *buf = alloca (addr_size);
+ CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
+ dwarf_expr_pop (ctx);
+
+ (ctx->read_mem) (ctx->baton, buf, addr, addr_size);
+ result = extract_unsigned_integer (buf, addr_size, byte_order);
+ break;
+ }
+
case DW_OP_abs:
case DW_OP_neg:
case DW_OP_not:
switch (op)
{
- case DW_OP_deref:
- {
- gdb_byte *buf = alloca (ctx->addr_size);
-
- (ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
- result = dwarf2_read_address (ctx->gdbarch,
- buf, buf + ctx->addr_size,
- ctx->addr_size);
- }
- break;
-
- case DW_OP_deref_size:
- {
- int addr_size = *op_ptr++;
- gdb_byte *buf = alloca (addr_size);
-
- (ctx->read_mem) (ctx->baton, buf, result, addr_size);
- result = dwarf2_read_address (ctx->gdbarch,
- buf, buf + addr_size,
- addr_size);
- }
- break;
-
case DW_OP_abs:
- if ((signed int) result < 0)
+ if (sign_ext (result) < 0)
result = -result;
break;
case DW_OP_neg:
case DW_OP_gt:
case DW_OP_ne:
{
- /* Binary operations. Use the value engine to do computations in
- the right width. */
- CORE_ADDR first, second;
- enum exp_opcode binop;
- struct value *val1 = NULL, *val2 = NULL;
- struct type *stype, *utype;
+ /* Binary operations. */
+ ULONGEST first, second;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
- utype = unsigned_address_type (ctx->gdbarch, ctx->addr_size);
- stype = signed_address_type (ctx->gdbarch, ctx->addr_size);
-
switch (op)
{
case DW_OP_and:
- binop = BINOP_BITWISE_AND;
+ result = first & second;
break;
case DW_OP_div:
- binop = BINOP_DIV;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ if (!second)
+ error (_("Division by zero"));
+ result = sign_ext (first) / sign_ext (second);
break;
case DW_OP_minus:
- binop = BINOP_SUB;
+ result = first - second;
break;
case DW_OP_mod:
- binop = BINOP_MOD;
+ if (!second)
+ error (_("Division by zero"));
+ result = first % second;
break;
case DW_OP_mul:
- binop = BINOP_MUL;
+ result = first * second;
break;
case DW_OP_or:
- binop = BINOP_BITWISE_IOR;
+ result = first | second;
break;
case DW_OP_plus:
- binop = BINOP_ADD;
+ result = first + second;
break;
case DW_OP_shl:
- binop = BINOP_LSH;
+ result = first << second;
break;
case DW_OP_shr:
- binop = BINOP_RSH;
+ result = first >> second;
break;
case DW_OP_shra:
- binop = BINOP_RSH;
- val1 = value_from_longest (stype, first);
+ result = sign_ext (first) >> second;
break;
case DW_OP_xor:
- binop = BINOP_BITWISE_XOR;
+ result = first ^ second;
break;
case DW_OP_le:
- binop = BINOP_LEQ;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) <= sign_ext (second);
break;
case DW_OP_ge:
- binop = BINOP_GEQ;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) >= sign_ext (second);
break;
case DW_OP_eq:
- binop = BINOP_EQUAL;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) == sign_ext (second);
break;
case DW_OP_lt:
- binop = BINOP_LESS;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) < sign_ext (second);
break;
case DW_OP_gt:
- binop = BINOP_GTR;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) > sign_ext (second);
break;
case DW_OP_ne:
- binop = BINOP_NOTEQUAL;
- val1 = value_from_longest (stype, first);
- val2 = value_from_longest (stype, second);
+ result = sign_ext (first) != sign_ext (second);
break;
default:
internal_error (__FILE__, __LINE__,
_("Can't be reached."));
}
-
- /* We use unsigned operands by default. */
- if (val1 == NULL)
- val1 = value_from_longest (utype, first);
- if (val2 == NULL)
- val2 = value_from_longest (utype, second);
-
- result = value_as_long (value_binop (val1, val2, binop));
}
break;
case DW_OP_GNU_push_tls_address:
/* Variable is at a constant offset in the thread-local
storage block into the objfile for the current thread and
- the dynamic linker module containing this expression. Here
+ the dynamic linker module containing this expression. Here
we return returns the offset from that base. The top of the
stack has the offset from the beginning of the thread
control block at which the variable is located. Nothing
op_ptr += 4;
ctx->dwarf_call (ctx, result);
goto no_push;
+
+ case DW_OP_GNU_entry_value:
+ /* This operation is not yet supported by GDB. */
+ ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
+ ctx->stack_len = 0;
+ ctx->num_pieces = 0;
+ goto abort_expression;
default:
error (_("Unhandled dwarf expression opcode 0x%x"), op);
/* Most things push a result value. */
dwarf_expr_push (ctx, result, in_stack_memory);
- no_push:;
+ no_push:
+ ;
}
+ /* To simplify our main caller, if the result is an implicit
+ pointer, then make a pieced value. This is ok because we can't
+ have implicit pointers in contexts where pieces are invalid. */
+ if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
+ add_piece (ctx, 8 * ctx->addr_size, 0);
+
+abort_expression:
ctx->recursion_depth--;
gdb_assert (ctx->recursion_depth >= 0);
+#undef sign_ext
}