/* DWARF 2 Expression Evaluator.
- Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009
+ Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Contributed by Daniel Berlin (dan@dberlin.org)
retval = xcalloc (1, sizeof (struct dwarf_expr_context));
retval->stack_len = 0;
retval->stack_allocated = 10;
- retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
+ retval->stack = xmalloc (retval->stack_allocated
+ * sizeof (struct dwarf_stack_value));
retval->num_pieces = 0;
retval->pieces = 0;
retval->max_recursion_depth = 0x100;
{
size_t newlen = ctx->stack_len + need + 10;
ctx->stack = xrealloc (ctx->stack,
- newlen * sizeof (CORE_ADDR));
+ newlen * sizeof (struct dwarf_stack_value));
ctx->stack_allocated = newlen;
}
}
/* 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, CORE_ADDR value,
+ int in_stack_memory)
{
+ struct dwarf_stack_value *v;
+
dwarf_expr_grow_stack (ctx, 1);
- ctx->stack[ctx->stack_len++] = value;
+ v = &ctx->stack[ctx->stack_len++];
+ v->value = value;
+ v->in_stack_memory = in_stack_memory;
}
/* Pop the top item off of CTX's stack. */
if (ctx->stack_len <= n)
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)];
+ return ctx->stack[ctx->stack_len - (1 + n)].value;
+
+}
+
+/* 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."),
+ n, ctx->stack_len);
+ return ctx->stack[ctx->stack_len - (1 + n)].in_stack_memory;
}
p->v.literal.length = ctx->len;
}
else
- p->v.value = dwarf_expr_fetch (ctx, 0);
+ {
+ p->v.expr.value = dwarf_expr_fetch (ctx, 0);
+ p->v.expr.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+ }
}
/* Evaluate the expression at ADDR (LEN bytes long) using the context
{
enum dwarf_location_atom op = *op_ptr++;
CORE_ADDR 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
+ be a stack address, but we skip this complication for now.
+ This is just an optimization, so it's always ok to punt
+ and leave this as 0. */
+ int in_stack_memory = 0;
ULONGEST uoffset, reg;
LONGEST offset;
if (ctx->location == DWARF_VALUE_REGISTER)
result = (ctx->read_reg) (ctx->baton, result);
result = result + offset;
+ in_stack_memory = 1;
ctx->stack_len = before_stack_len;
ctx->location = DWARF_VALUE_MEMORY;
}
break;
+
case DW_OP_dup:
result = dwarf_expr_fetch (ctx, 0);
+ in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
break;
case DW_OP_drop:
case DW_OP_pick:
offset = *op_ptr++;
result = dwarf_expr_fetch (ctx, offset);
+ in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
break;
case DW_OP_swap:
{
- CORE_ADDR t1, t2;
+ struct dwarf_stack_value t1, t2;
if (ctx->stack_len < 2)
error (_("Not enough elements for DW_OP_swap. Need 2, have %d."),
case DW_OP_over:
result = dwarf_expr_fetch (ctx, 1);
+ in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
break;
case DW_OP_rot:
{
- CORE_ADDR t1, t2, t3;
+ struct dwarf_stack_value t1, t2, t3;
if (ctx->stack_len < 3)
error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
the right width. */
CORE_ADDR first, second;
enum exp_opcode binop;
- struct value *val1, *val2;
+ struct value *val1 = NULL, *val2 = NULL;
struct type *stype, *utype;
second = dwarf_expr_fetch (ctx, 0);
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_div:
binop = BINOP_DIV;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_minus:
binop = BINOP_SUB;
break;
case DW_OP_le:
binop = BINOP_LEQ;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_ge:
binop = BINOP_GEQ;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_eq:
binop = BINOP_EQUAL;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_lt:
binop = BINOP_LESS;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_gt:
binop = BINOP_GTR;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, second);
break;
case DW_OP_ne:
binop = BINOP_NOTEQUAL;
+ val1 = value_from_longest (stype, first);
+ val2 = value_from_longest (stype, 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_call_frame_cfa:
result = (ctx->get_frame_cfa) (ctx->baton);
+ in_stack_memory = 1;
break;
case DW_OP_GNU_push_tls_address:
case DW_OP_piece:
{
ULONGEST size;
- CORE_ADDR addr_or_regnum;
/* Record the piece. */
op_ptr = read_uleb128 (op_ptr, op_end, &size);
}
/* Most things push a result value. */
- dwarf_expr_push (ctx, result);
+ dwarf_expr_push (ctx, result, in_stack_memory);
no_push:;
}
projects / deliverable / binutils-gdb.git / blobdiff