/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008
+ Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
#include "gdbtypes.h"
#include "value.h"
#include "gdbcore.h"
-#include "elf/dwarf2.h"
+#include "dwarf2.h"
#include "dwarf2expr.h"
+#include "gdb_assert.h"
/* Local prototypes. */
static void execute_stack_op (struct dwarf_expr_context *,
gdb_byte *, gdb_byte *);
-static struct type *unsigned_address_type (int);
+static struct type *unsigned_address_type (struct gdbarch *, int);
/* Create a new context for the expression evaluator. */
retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
retval->num_pieces = 0;
retval->pieces = 0;
+ retval->max_recursion_depth = 0x100;
return retval;
}
void
dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len)
{
+ int old_recursion_depth = ctx->recursion_depth;
+
execute_stack_op (ctx, addr, addr + len);
+
+ /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
+
+ gdb_assert (ctx->recursion_depth == old_recursion_depth);
}
/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
doesn't extend past BUF_END. */
CORE_ADDR
-dwarf2_read_address (gdb_byte *buf, gdb_byte *buf_end, int addr_size)
+dwarf2_read_address (struct gdbarch *gdbarch, gdb_byte *buf,
+ gdb_byte *buf_end, int addr_size)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR result;
if (buf_end - buf < addr_size)
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. Turning the unsigned integer into a value and then
- decomposing that value as an address will cause
- gdbarch_integer_to_address() to be invoked for those
- architectures which require it. Thus, using value_as_address()
- will produce the correct result for both types of architectures.
-
- One concern regarding the use of values for this purpose is
- efficiency. Obviously, these extra calls will take more time to
- execute and creating a value takes more space, space which will
- have to be garbage collected at a later time. If constructing
- and then decomposing a value for this purpose proves to be too
- inefficient, then gdbarch_integer_to_address() can be called
- directly.
+ 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. */
- result = value_as_address (value_from_longest
- (unsigned_address_type (addr_size),
- extract_unsigned_integer (buf, addr_size)));
- return result;
+ 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 (int addr_size)
+unsigned_address_type (struct gdbarch *gdbarch, int addr_size)
{
switch (addr_size)
{
case 2:
- return builtin_type_uint16;
+ return builtin_type (gdbarch)->builtin_uint16;
case 4:
- return builtin_type_uint32;
+ return builtin_type (gdbarch)->builtin_uint32;
case 8:
- return builtin_type_uint64;
+ return builtin_type (gdbarch)->builtin_uint64;
default:
internal_error (__FILE__, __LINE__,
_("Unsupported address size.\n"));
for signed arithmetic. */
static struct type *
-signed_address_type (int addr_size)
+signed_address_type (struct gdbarch *gdbarch, int addr_size)
{
switch (addr_size)
{
case 2:
- return builtin_type_int16;
+ return builtin_type (gdbarch)->builtin_int16;
case 4:
- return builtin_type_int32;
+ return builtin_type (gdbarch)->builtin_int32;
case 8:
- return builtin_type_int64;
+ return builtin_type (gdbarch)->builtin_int64;
default:
internal_error (__FILE__, __LINE__,
_("Unsupported address size.\n"));
execute_stack_op (struct dwarf_expr_context *ctx,
gdb_byte *op_ptr, gdb_byte *op_end)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+
ctx->in_reg = 0;
ctx->initialized = 1; /* Default is initialized. */
+ if (ctx->recursion_depth > ctx->max_recursion_depth)
+ error (_("DWARF-2 expression error: Loop detected (%d)."),
+ ctx->recursion_depth);
+ ctx->recursion_depth++;
+
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
break;
case DW_OP_addr:
- result = dwarf2_read_address (op_ptr, op_end, ctx->addr_size);
+ result = dwarf2_read_address (ctx->gdbarch,
+ op_ptr, op_end, ctx->addr_size);
op_ptr += ctx->addr_size;
break;
case DW_OP_const1u:
- result = extract_unsigned_integer (op_ptr, 1);
+ result = extract_unsigned_integer (op_ptr, 1, byte_order);
op_ptr += 1;
break;
case DW_OP_const1s:
- result = extract_signed_integer (op_ptr, 1);
+ result = extract_signed_integer (op_ptr, 1, byte_order);
op_ptr += 1;
break;
case DW_OP_const2u:
- result = extract_unsigned_integer (op_ptr, 2);
+ result = extract_unsigned_integer (op_ptr, 2, byte_order);
op_ptr += 2;
break;
case DW_OP_const2s:
- result = extract_signed_integer (op_ptr, 2);
+ result = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
break;
case DW_OP_const4u:
- result = extract_unsigned_integer (op_ptr, 4);
+ result = extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
break;
case DW_OP_const4s:
- result = extract_signed_integer (op_ptr, 4);
+ result = extract_signed_integer (op_ptr, 4, byte_order);
op_ptr += 4;
break;
case DW_OP_const8u:
- result = extract_unsigned_integer (op_ptr, 8);
+ result = extract_unsigned_integer (op_ptr, 8, byte_order);
op_ptr += 8;
break;
case DW_OP_const8s:
- result = extract_signed_integer (op_ptr, 8);
+ result = extract_signed_integer (op_ptr, 8, byte_order);
op_ptr += 8;
break;
case DW_OP_constu:
offset = *op_ptr++;
result = dwarf_expr_fetch (ctx, offset);
break;
+
+ case DW_OP_swap:
+ {
+ CORE_ADDR t1, t2;
+
+ if (ctx->stack_len < 2)
+ 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];
+ ctx->stack[ctx->stack_len - 1] = t2;
+ ctx->stack[ctx->stack_len - 2] = t1;
+ goto no_push;
+ }
case DW_OP_over:
result = dwarf_expr_fetch (ctx, 1);
{
gdb_byte *buf = alloca (ctx->addr_size);
(ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
- result = dwarf2_read_address (buf, buf + ctx->addr_size,
+ result = dwarf2_read_address (ctx->gdbarch,
+ buf, buf + ctx->addr_size,
ctx->addr_size);
}
break;
int addr_size = *op_ptr++;
gdb_byte *buf = alloca (addr_size);
(ctx->read_mem) (ctx->baton, buf, result, addr_size);
- result = dwarf2_read_address (buf, buf + addr_size,
+ result = dwarf2_read_address (ctx->gdbarch,
+ buf, buf + addr_size,
addr_size);
}
break;
CORE_ADDR first, second;
enum exp_opcode binop;
struct value *val1, *val2;
+ struct type *stype, *utype;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
- val1 = value_from_longest
- (unsigned_address_type (ctx->addr_size), first);
- val2 = value_from_longest
- (unsigned_address_type (ctx->addr_size), second);
+ utype = unsigned_address_type (ctx->gdbarch, ctx->addr_size);
+ stype = signed_address_type (ctx->gdbarch, ctx->addr_size);
+ val1 = value_from_longest (utype, first);
+ val2 = value_from_longest (utype, second);
switch (op)
{
break;
case DW_OP_shra:
binop = BINOP_RSH;
- val1 = value_from_longest
- (signed_address_type (ctx->addr_size), first);
+ val1 = value_from_longest (stype, first);
break;
case DW_OP_xor:
binop = BINOP_BITWISE_XOR;
break;
case DW_OP_skip:
- offset = extract_signed_integer (op_ptr, 2);
+ offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
op_ptr += offset;
goto no_push;
case DW_OP_bra:
- offset = extract_signed_integer (op_ptr, 2);
+ offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
if (dwarf_expr_fetch (ctx, 0) != 0)
op_ptr += offset;
case DW_OP_GNU_uninit:
if (op_ptr != op_end)
- error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
+ error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
"be the very last op."));
ctx->initialized = 0;
dwarf_expr_push (ctx, result);
no_push:;
}
+
+ ctx->recursion_depth--;
+ gdb_assert (ctx->recursion_depth >= 0);
}
projects / deliverable / binutils-gdb.git / blobdiff