/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001, 2002, 2003, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009
+ Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
#include "gdbcore.h"
#include "elf/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 (void);
+static struct type *unsigned_address_type (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
return buf;
}
-/* Read an address from BUF, and verify that it doesn't extend past
- BUF_END. The address is returned, and *BYTES_READ is set to the
- number of bytes read from 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 (gdb_byte *buf, gdb_byte *buf_end, int *bytes_read)
+dwarf2_read_address (struct gdbarch *gdbarch, gdb_byte *buf,
+ gdb_byte *buf_end, int addr_size)
{
CORE_ADDR result;
- if (buf_end - buf < gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
+ if (buf_end - buf < addr_size)
error (_("dwarf2_read_address: Corrupted DWARF expression."));
- *bytes_read = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT;
-
/* 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. 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 (),
- extract_unsigned_integer
- (buf,
- gdbarch_addr_bit (current_gdbarch)
- / TARGET_CHAR_BIT)));
+ if (gdbarch_integer_to_address_p (gdbarch))
+ return gdbarch_integer_to_address
+ (gdbarch, unsigned_address_type (addr_size), buf);
- return result;
+ return extract_unsigned_integer (buf, addr_size);
}
-/* Return the type of an address, for unsigned arithmetic. */
+/* Return the type of an address of size ADDR_SIZE,
+ for unsigned arithmetic. */
static struct type *
-unsigned_address_type (void)
+unsigned_address_type (int addr_size)
{
- switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
+ switch (addr_size)
{
case 2:
return builtin_type_uint16;
}
}
-/* Return the type of an address, for signed arithmetic. */
+/* Return the type of an address of size ADDR_SIZE,
+ for signed arithmetic. */
static struct type *
-signed_address_type (void)
+signed_address_type (int addr_size)
{
- switch (gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT)
+ switch (addr_size)
{
case 2:
return builtin_type_int16;
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++;
CORE_ADDR result;
ULONGEST uoffset, reg;
LONGEST offset;
- int bytes_read;
switch (op)
{
break;
case DW_OP_addr:
- result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
- op_ptr += bytes_read;
+ result = dwarf2_read_address (ctx->gdbarch,
+ op_ptr, op_end, ctx->addr_size);
+ op_ptr += ctx->addr_size;
break;
case DW_OP_const1u:
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);
{
case DW_OP_deref:
{
- gdb_byte *buf = alloca (gdbarch_addr_bit (current_gdbarch)
- / TARGET_CHAR_BIT);
- int bytes_read;
-
- (ctx->read_mem) (ctx->baton, buf, result,
- gdbarch_addr_bit (current_gdbarch)
- / TARGET_CHAR_BIT);
- result = dwarf2_read_address (buf,
- buf + (gdbarch_addr_bit
- (current_gdbarch)
- / TARGET_CHAR_BIT),
- &bytes_read);
+ 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:
{
- gdb_byte *buf
- = alloca (gdbarch_addr_bit (current_gdbarch)
- / TARGET_CHAR_BIT);
- int bytes_read;
-
- (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
- result = dwarf2_read_address (buf,
- buf + (gdbarch_addr_bit
- (current_gdbarch)
- / TARGET_CHAR_BIT),
- &bytes_read);
+ 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;
first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
- val1 = value_from_longest (unsigned_address_type (), first);
- val2 = value_from_longest (unsigned_address_type (), second);
+ val1 = value_from_longest
+ (unsigned_address_type (ctx->addr_size), first);
+ val2 = value_from_longest
+ (unsigned_address_type (ctx->addr_size), second);
switch (op)
{
break;
case DW_OP_shra:
binop = BINOP_RSH;
- val1 = value_from_longest (signed_address_type (), first);
+ val1 = value_from_longest
+ (signed_address_type (ctx->addr_size), first);
break;
case DW_OP_xor:
binop = BINOP_BITWISE_XOR;
dwarf_expr_push (ctx, result);
no_push:;
}
+
+ ctx->recursion_depth--;
+ gdb_assert (ctx->recursion_depth >= 0);
}