{
struct dwarf_expr_context *retval;
retval = xcalloc (1, sizeof (struct dwarf_expr_context));
- retval->stack_len = 10;
- retval->stack = xmalloc (10 * sizeof (CORE_ADDR));
+ retval->stack_len = 0;
+ retval->stack_allocated = 10;
+ retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
return retval;
}
{
if (ctx->stack_len + need > ctx->stack_allocated)
{
- size_t templen = ctx->stack_len * 2;
- while (templen < (ctx->stack_len + need))
- templen *= 2;
+ size_t newlen = ctx->stack_len + need + 10;
ctx->stack = xrealloc (ctx->stack,
- templen * sizeof (CORE_ADDR));
- ctx->stack_allocated = templen;
+ newlen * sizeof (CORE_ADDR));
+ ctx->stack_allocated = newlen;
}
}
error ("dwarf2_read_address: Corrupted DWARF expression.");
*bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
- result = extract_address (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+ /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
+ address is always unsigned. That may or may not be true. */
+ result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
return result;
}
execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
unsigned char *op_end)
{
+ ctx->in_reg = 0;
+
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
- CORE_ADDR result, memaddr;
+ CORE_ADDR result;
ULONGEST uoffset, reg;
LONGEST offset;
int bytes_read;
- enum lval_type expr_lval;
-
- ctx->in_reg = 0;
switch (op)
{
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
- /* NOTE: in the presence of DW_OP_piece this check is incorrect. */
- if (op_ptr != op_end)
+ if (op_ptr != op_end && *op_ptr != DW_OP_piece)
error ("DWARF-2 expression error: DW_OP_reg operations must be "
- "used alone.");
-
- /* FIXME drow/2003-02-21: This call to read_reg could be pushed
- into the evaluator's caller by changing the semantics for in_reg.
- Then we wouldn't need to return an lval_type and a memaddr. */
- result = (ctx->read_reg) (ctx->baton, op - DW_OP_reg0, &expr_lval,
- &memaddr);
+ "used either alone or in conjuction with DW_OP_piece.");
- if (expr_lval == lval_register)
- {
- ctx->regnum = op - DW_OP_reg0;
- ctx->in_reg = 1;
- }
- else
- result = memaddr;
+ result = op - DW_OP_reg0;
+ ctx->in_reg = 1;
break;
case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, op_end, ®);
- if (op_ptr != op_end)
+ if (op_ptr != op_end && *op_ptr != DW_OP_piece)
error ("DWARF-2 expression error: DW_OP_reg operations must be "
- "used alone.");
-
- result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
-
- if (expr_lval == lval_register)
- {
- ctx->regnum = reg;
- ctx->in_reg = 1;
- }
- else
- result = memaddr;
+ "used either alone or in conjuction with DW_OP_piece.");
+ result = reg;
+ ctx->in_reg = 1;
break;
case DW_OP_breg0:
case DW_OP_breg31:
{
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0,
- &expr_lval, &memaddr);
+ result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
result += offset;
}
break;
{
op_ptr = read_uleb128 (op_ptr, op_end, ®);
op_ptr = read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
+ result = (ctx->read_reg) (ctx->baton, reg);
result += offset;
}
break;
(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
dwarf_expr_eval (ctx, datastart, datalen);
result = dwarf_expr_fetch (ctx, 0);
- if (! ctx->in_reg)
- {
- char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
- int bytes_read;
-
- (ctx->read_mem) (ctx->baton, buf, result,
- TARGET_ADDR_BIT / TARGET_CHAR_BIT);
- result = dwarf2_read_address (buf,
- buf + (TARGET_ADDR_BIT
- / TARGET_CHAR_BIT),
- &bytes_read);
- }
+ if (ctx->in_reg)
+ result = (ctx->read_reg) (ctx->baton, result);
result = result + offset;
ctx->stack_len = before_stack_len;
ctx->in_reg = 0;
second = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
- first = dwarf_expr_fetch (ctx, 1);
+ first = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
val1 = value_from_longest (unsigned_address_type (), first);
break;
case DW_OP_div:
binop = BINOP_DIV;
+ break;
case DW_OP_minus:
binop = BINOP_SUB;
break;
break;
case DW_OP_shr:
binop = BINOP_RSH;
+ break;
case DW_OP_shra:
binop = BINOP_RSH;
val1 = value_from_longest (signed_address_type (), first);
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
+ 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
+ should follow this operator, so the top of stack would be
+ returned. */
result = dwarf_expr_fetch (ctx, 0);
dwarf_expr_pop (ctx);
result = (ctx->get_tls_address) (ctx->baton, result);
goto no_push;
default:
- error ("Unhandled dwarf expression opcode");
+ error ("Unhandled dwarf expression opcode 0x%x", op);
}
/* Most things push a result value. */
projects / deliverable / binutils-gdb.git / blobdiff