Re: [RFA v2 15/17] Convert DWARF expr functions to methods

Tom Tromey
2016-10-20T21:47:12Z

>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

Pedro> I notice that several of the intro comments to functions that
Pedro> are now methods still talk about CTX. Should they be
Pedro> tweaked? Maybe to "to this context's stack". Or maybe they're clear
Pedro> as is anyway.

I've updated this patch as appended.

Tom

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index c5ac1af..296c2fe 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,25 @@
2016-10-20 Tom Tromey <tom@tromey.com>

+ * dwarf2loc.c (per_cu_dwarf_call)
+ (dwarf_expr_push_dwarf_reg_entry_value)
+ (dwarf2_evaluate_loc_desc_full, dwarf2_locexpr_baton_eval)
+ (needs_dwarf_reg_entry_value)
+ (dwarf2_loc_desc_get_symbol_read_needs): Update.
+ * dwarf2expr.h (dwarf_expr_context) <push_address, eval, fetch,
+ fetch_address, fetch_in_stack_memory, address_type, grow_stack,
+ push, stack_empty_p, add_piece, get_base_type, execute_stack_op,
+ pop>: New method declarations.
+ (dwarf_expr_push_address, dwarf_expr_eval, dwarf_expr_fetch)
+ (dwarf_expr_fetch_address, dwarf_expr_fetch_in_stack_memory):
+ Don't declare.
+ * dwarf2expr.c (address_type, grow_stack, push, push_address)
+ (pop, fetch, fetch_address, fetch_in_stack_memory)
+ (stack_empty_p, add_piece, eval, get_base_type)
+ (execute_stack_op): Rename. Turn into methods.
+ * dwarf2-frame.c (execute_stack_op): Update.
+
+2016-10-20 Tom Tromey <tom@tromey.com>
+
* dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Stack-allocate
dwarf_expr_context. Remove cleanups.
(dwarf2_locexpr_baton_eval)
diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c
index 48963de..c93c362 100644
--- a/gdb/dwarf2-frame.c
+++ b/gdb/dwarf2-frame.c
@@ -382,14 +382,14 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
ctx.baton = this_frame;
ctx.funcs = &dwarf2_frame_ctx_funcs;

- dwarf_expr_push_address (&ctx, initial, initial_in_stack_memory);
- dwarf_expr_eval (&ctx, exp, len);
+ ctx.push_address (initial, initial_in_stack_memory);
+ ctx.eval (exp, len);

if (ctx.location == DWARF_VALUE_MEMORY)
- result = dwarf_expr_fetch_address (&ctx, 0);
+ result = ctx.fetch_address (0);
else if (ctx.location == DWARF_VALUE_REGISTER)
result = read_addr_from_reg (this_frame,
- value_as_long (dwarf_expr_fetch (&ctx, 0)));
+ value_as_long (ctx.fetch (0)));
else
{
/* This is actually invalid DWARF, but if we ever do run across
diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index e8487a6..1aa6afc 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -28,11 +28,6 @@
#include "dwarf2expr.h"
#include "dwarf2loc.h"

-/* Local prototypes. */
-
-static void execute_stack_op (struct dwarf_expr_context *,
- const gdb_byte *, const gdb_byte *);
-
/* Cookie for gdbarch data. */

static struct gdbarch_data *dwarf_arch_cookie;
@@ -62,28 +57,28 @@ dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
unspecified in the DWARF spec. Only certain sizes are
supported. */

-static struct type *
-dwarf_expr_address_type (struct dwarf_expr_context *ctx)
+struct type *
+dwarf_expr_context::address_type () const
{
struct dwarf_gdbarch_types *types
- = (struct dwarf_gdbarch_types *) gdbarch_data (ctx->gdbarch,
+ = (struct dwarf_gdbarch_types *) gdbarch_data (this->gdbarch,
dwarf_arch_cookie);
int ndx;

- if (ctx->addr_size == 2)
+ if (this->addr_size == 2)
ndx = 0;
- else if (ctx->addr_size == 4)
+ else if (this->addr_size == 4)
ndx = 1;
- else if (ctx->addr_size == 8)
+ else if (this->addr_size == 8)
ndx = 2;
else
error (_("Unsupported address size in DWARF expressions: %d bits"),
- 8 * ctx->addr_size);
+ 8 * this->addr_size);

if (types->dw_types[ndx] == NULL)
types->dw_types[ndx]
- = arch_integer_type (ctx->gdbarch,
- 8 * ctx->addr_size,
+ = arch_integer_type (this->gdbarch,
+ 8 * this->addr_size,
0, "<signed DWARF address type>");

return types->dw_types[ndx];
@@ -119,66 +114,62 @@ dwarf_expr_context::~dwarf_expr_context ()
xfree (this->pieces);
}

-/* Expand the memory allocated to CTX's stack to contain at least
+/* Expand the memory allocated stack to contain at least
NEED more elements than are currently used. */

-static void
-dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
+void
+dwarf_expr_context::grow_stack (size_t need)
{
- if (ctx->stack_len + need > ctx->stack_allocated)
+ if (this->stack_len + need > this->stack_allocated)
{
- size_t newlen = ctx->stack_len + need + 10;
+ size_t newlen = this->stack_len + need + 10;

- ctx->stack = XRESIZEVEC (struct dwarf_stack_value, ctx->stack, newlen);
- ctx->stack_allocated = newlen;
+ this->stack = XRESIZEVEC (struct dwarf_stack_value, this->stack, newlen);
+ this->stack_allocated = newlen;
}
}

-/* Push VALUE onto CTX's stack. */
+/* Push VALUE onto the stack. */

-static void
-dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value,
- int in_stack_memory)
+void
+dwarf_expr_context::push (struct value *value, int in_stack_memory)
{
struct dwarf_stack_value *v;

- dwarf_expr_grow_stack (ctx, 1);
- v = &ctx->stack[ctx->stack_len++];
+ grow_stack (1);
+ v = &this->stack[this->stack_len++];
v->value = value;
v->in_stack_memory = in_stack_memory;
}

-/* Push VALUE onto CTX's stack. */
+/* Push VALUE onto the stack. */

void
-dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value,
- int in_stack_memory)
+dwarf_expr_context::push_address (CORE_ADDR value, int in_stack_memory)
{
- dwarf_expr_push (ctx,
- value_from_ulongest (dwarf_expr_address_type (ctx), value),
- in_stack_memory);
+ push (value_from_ulongest (address_type (), value), in_stack_memory);
}

-/* Pop the top item off of CTX's stack. */
+/* Pop the top item off of the stack. */

-static void
-dwarf_expr_pop (struct dwarf_expr_context *ctx)
+void
+dwarf_expr_context::pop ()
{
- if (ctx->stack_len <= 0)
+ if (this->stack_len <= 0)
error (_("dwarf expression stack underflow"));
- ctx->stack_len--;
+ this->stack_len--;
}

-/* Retrieve the N'th item on CTX's stack. */
+/* Retrieve the N'th item on the stack. */

struct value *
-dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
+dwarf_expr_context::fetch (int n)
{
- if (ctx->stack_len <= n)
+ if (this->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)].value;
+ n, this->stack_len);
+ return this->stack[this->stack_len - (1 + n)].value;
}

/* Require that TYPE be an integral type; throw an exception if not. */
@@ -236,13 +227,13 @@ get_signed_type (struct gdbarch *gdbarch, struct type *type)
}
}

-/* Retrieve the N'th item on CTX's stack, converted to an address. */
+/* Retrieve the N'th item on the stack, converted to an address. */

CORE_ADDR
-dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
+dwarf_expr_context::fetch_address (int n)
{
- struct value *result_val = dwarf_expr_fetch (ctx, n);
- enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+ struct value *result_val = fetch (n);
+ enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch);
ULONGEST result;

dwarf_require_integral (value_type (result_val));
@@ -256,101 +247,99 @@ dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n)
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))
+ if (gdbarch_integer_to_address_p (this->gdbarch))
{
- gdb_byte *buf = (gdb_byte *) alloca (ctx->addr_size);
- struct type *int_type = get_unsigned_type (ctx->gdbarch,
+ gdb_byte *buf = (gdb_byte *) alloca (this->addr_size);
+ struct type *int_type = get_unsigned_type (this->gdbarch,
value_type (result_val));

- store_unsigned_integer (buf, ctx->addr_size, byte_order, result);
- return gdbarch_integer_to_address (ctx->gdbarch, int_type, buf);
+ store_unsigned_integer (buf, this->addr_size, byte_order, result);
+ return gdbarch_integer_to_address (this->gdbarch, int_type, buf);
}

return (CORE_ADDR) result;
}

-/* Retrieve the in_stack_memory flag of the N'th item on CTX's stack. */
+/* Retrieve the in_stack_memory flag of the N'th item on the stack. */

int
-dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n)
+dwarf_expr_context::fetch_in_stack_memory (int n)
{
- if (ctx->stack_len <= n)
+ if (this->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;
+ n, this->stack_len);
+ return this->stack[this->stack_len - (1 + n)].in_stack_memory;
}

/* Return true if the expression stack is empty. */

-static int
-dwarf_expr_stack_empty_p (struct dwarf_expr_context *ctx)
+int
+dwarf_expr_context::stack_empty_p () const
{
- return ctx->stack_len == 0;
+ return this->stack_len == 0;
}

-/* Add a new piece to CTX's piece list. */
-static void
-add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
+/* Add a new piece to the dwarf_expr_context's piece list. */
+void
+dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset)
{
struct dwarf_expr_piece *p;

- ctx->num_pieces++;
+ this->num_pieces++;

- ctx->pieces
- = XRESIZEVEC (struct dwarf_expr_piece, ctx->pieces, ctx->num_pieces);
+ this->pieces
+ = XRESIZEVEC (struct dwarf_expr_piece, this->pieces, this->num_pieces);

- p = &ctx->pieces[ctx->num_pieces - 1];
- p->location = ctx->location;
+ p = &this->pieces[this->num_pieces - 1];
+ p->location = this->location;
p->size = size;
p->offset = offset;

if (p->location == DWARF_VALUE_LITERAL)
{
- p->v.literal.data = ctx->data;
- p->v.literal.length = ctx->len;
+ p->v.literal.data = this->data;
+ p->v.literal.length = this->len;
}
- else if (dwarf_expr_stack_empty_p (ctx))
+ else if (stack_empty_p ())
{
p->location = DWARF_VALUE_OPTIMIZED_OUT;
/* Also reset the context's location, for our callers. This is
a somewhat strange approach, but this lets us avoid setting
the location to DWARF_VALUE_MEMORY in all the individual
cases in the evaluator. */
- ctx->location = DWARF_VALUE_OPTIMIZED_OUT;
+ this->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);
+ p->v.mem.addr = fetch_address (0);
+ p->v.mem.in_stack_memory = fetch_in_stack_memory (0);
}
else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
{
- p->v.ptr.die.sect_off = ctx->len;
- p->v.ptr.offset = value_as_long (dwarf_expr_fetch (ctx, 0));
+ p->v.ptr.die.sect_off = this->len;
+ p->v.ptr.offset = value_as_long (fetch (0));
}
else if (p->location == DWARF_VALUE_REGISTER)
- p->v.regno = value_as_long (dwarf_expr_fetch (ctx, 0));
+ p->v.regno = value_as_long (fetch (0));
else
{
- p->v.value = dwarf_expr_fetch (ctx, 0);
+ p->v.value = fetch (0);
}
}

-/* Evaluate the expression at ADDR (LEN bytes long) using the context
- CTX. */
+/* Evaluate the expression at ADDR (LEN bytes long). */

void
-dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
- size_t len)
+dwarf_expr_context::eval (const gdb_byte *addr, size_t len)
{
- int old_recursion_depth = ctx->recursion_depth;
+ int old_recursion_depth = this->recursion_depth;

- execute_stack_op (ctx, addr, addr + len);
+ execute_stack_op (addr, addr + len);

- /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here. */
+ /* RECURSION_DEPTH becomes invalid if an exception was thrown here. */

- gdb_assert (ctx->recursion_depth == old_recursion_depth);
+ gdb_assert (this->recursion_depth == old_recursion_depth);
}

/* Helper to read a uleb128 value or throw an error. */
@@ -417,19 +406,19 @@ base_types_equal_p (struct type *t1, struct type *t2)
return TYPE_LENGTH (t1) == TYPE_LENGTH (t2);
}

-/* A convenience function to call get_base_type on CTX and return the
- result. DIE is the DIE whose type we need. SIZE is non-zero if
- this function should verify that the resulting type has the correct
+/* A convenience function to call get_base_type and return the result.
+ DIE is the DIE whose type we need. SIZE is non-zero if this
+ function should verify that the resulting type has the correct
size. */

-static struct type *
-dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
+struct type *
+dwarf_expr_context::get_base_type (cu_offset die, int size)
{
struct type *result;

- if (ctx->funcs->get_base_type)
+ if (this->funcs->get_base_type)
{
- result = ctx->funcs->get_base_type (ctx, die);
+ result = this->funcs->get_base_type (this, die);
if (result == NULL)
error (_("Could not find type for DW_OP_GNU_const_type"));
if (size != 0 && TYPE_LENGTH (result) != size)
@@ -437,7 +426,7 @@ dwarf_get_base_type (struct dwarf_expr_context *ctx, cu_offset die, int size)
}
else
/* Anything will do. */
- result = builtin_type (ctx->gdbarch)->builtin_int;
+ result = builtin_type (this->gdbarch)->builtin_int;

return result;
}
@@ -612,14 +601,14 @@ dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
return 1;
}

-/* The engine for the expression evaluator. Using the context in CTX,
- evaluate the expression between OP_PTR and OP_END. */
+/* The engine for the expression evaluator. Using the context in this
+ object, evaluate the expression between OP_PTR and OP_END. */

-static void
-execute_stack_op (struct dwarf_expr_context *ctx,
- const gdb_byte *op_ptr, const gdb_byte *op_end)
+void
+dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
+ const gdb_byte *op_end)
{
- enum bfd_endian byte_order = gdbarch_byte_order (ctx->gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (this->gdbarch);
/* Old-style "untyped" DWARF values need special treatment in a
couple of places, specifically DW_OP_mod and DW_OP_shr. We need
a special type for these values so we can distinguish them from
@@ -627,15 +616,15 @@ execute_stack_op (struct dwarf_expr_context *ctx,
values do not need special treatment. This special type must be
different (in the `==' sense) from any base type coming from the
CU. */
- struct type *address_type = dwarf_expr_address_type (ctx);
+ struct type *address_type = this->address_type ();

- ctx->location = DWARF_VALUE_MEMORY;
- ctx->initialized = 1; /* Default is initialized. */
+ this->location = DWARF_VALUE_MEMORY;
+ this->initialized = 1; /* Default is initialized. */

- if (ctx->recursion_depth > ctx->max_recursion_depth)
+ if (this->recursion_depth > this->max_recursion_depth)
error (_("DWARF-2 expression error: Loop detected (%d)."),
- ctx->recursion_depth);
- ctx->recursion_depth++;
+ this->recursion_depth);
+ this->recursion_depth++;

while (op_ptr < op_end)
{
@@ -696,26 +685,26 @@ execute_stack_op (struct dwarf_expr_context *ctx,

case DW_OP_addr:
result = extract_unsigned_integer (op_ptr,
- ctx->addr_size, byte_order);
- op_ptr += ctx->addr_size;
+ this->addr_size, byte_order);
+ op_ptr += this->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;
+ result += this->offset;
result_val = value_from_ulongest (address_type, result);
break;

case DW_OP_GNU_addr_index:
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
- result += ctx->offset;
+ result = (this->funcs->get_addr_index) (this->baton, uoffset);
+ result += this->offset;
result_val = value_from_ulongest (address_type, result);
break;
case DW_OP_GNU_const_index:
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
- result = (ctx->funcs->get_addr_index) (ctx->baton, uoffset);
+ result = (this->funcs->get_addr_index) (this->baton, uoffset);
result_val = value_from_ulongest (address_type, result);
break;

@@ -808,7 +797,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

result = op - DW_OP_reg0;
result_val = value_from_ulongest (address_type, result);
- ctx->location = DWARF_VALUE_REGISTER;
+ this->location = DWARF_VALUE_REGISTER;
break;

case DW_OP_regx:
@@ -817,7 +806,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

result = reg;
result_val = value_from_ulongest (address_type, result);
- ctx->location = DWARF_VALUE_REGISTER;
+ this->location = DWARF_VALUE_REGISTER;
break;

case DW_OP_implicit_value:
@@ -827,9 +816,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
if (op_ptr + len > op_end)
error (_("DW_OP_implicit_value: too few bytes available."));
- ctx->len = len;
- ctx->data = op_ptr;
- ctx->location = DWARF_VALUE_LITERAL;
+ this->len = len;
+ this->data = op_ptr;
+ this->location = DWARF_VALUE_LITERAL;
op_ptr += len;
dwarf_expr_require_composition (op_ptr, op_end,
"DW_OP_implicit_value");
@@ -837,7 +826,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
goto no_push;

case DW_OP_stack_value:
- ctx->location = DWARF_VALUE_STACK;
+ this->location = DWARF_VALUE_STACK;
dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
goto no_push;

@@ -845,21 +834,21 @@ execute_stack_op (struct dwarf_expr_context *ctx,
{
int64_t len;

- if (ctx->ref_addr_size == -1)
+ if (this->ref_addr_size == -1)
error (_("DWARF-2 expression error: DW_OP_GNU_implicit_pointer "
"is not allowed in frame context"));

/* The referred-to DIE of sect_offset kind. */
- ctx->len = extract_unsigned_integer (op_ptr, ctx->ref_addr_size,
+ this->len = extract_unsigned_integer (op_ptr, this->ref_addr_size,
byte_order);
- op_ptr += ctx->ref_addr_size;
+ op_ptr += this->ref_addr_size;

/* The byte offset into the data. */
op_ptr = safe_read_sleb128 (op_ptr, op_end, &len);
result = (ULONGEST) len;
result_val = value_from_ulongest (address_type, result);

- ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
+ this->location = DWARF_VALUE_IMPLICIT_POINTER;
dwarf_expr_require_composition (op_ptr, op_end,
"DW_OP_GNU_implicit_pointer");
}
@@ -899,7 +888,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
case DW_OP_breg31:
{
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->funcs->read_addr_from_reg) (ctx->baton,
+ result = (this->funcs->read_addr_from_reg) (this->baton,
op - DW_OP_breg0);
result += offset;
result_val = value_from_ulongest (address_type, result);
@@ -909,7 +898,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
{
op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
- result = (ctx->funcs->read_addr_from_reg) (ctx->baton, reg);
+ result = (this->funcs->read_addr_from_reg) (this->baton, reg);
result += offset;
result_val = value_from_ulongest (address_type, result);
}
@@ -925,78 +914,78 @@ execute_stack_op (struct dwarf_expr_context *ctx,
record the stack length before execution, then reset it
afterwards, effectively erasing whatever the recursive
call put there. */
- before_stack_len = ctx->stack_len;
+ before_stack_len = this->stack_len;
/* FIXME: cagney/2003-03-26: This code should be using
get_frame_base_address(), and then implement a dwarf2
specific this_base method. */
- (ctx->funcs->get_frame_base) (ctx->baton, &datastart, &datalen);
- dwarf_expr_eval (ctx, datastart, datalen);
- if (ctx->location == DWARF_VALUE_MEMORY)
- result = dwarf_expr_fetch_address (ctx, 0);
- else if (ctx->location == DWARF_VALUE_REGISTER)
- result = (ctx->funcs->read_addr_from_reg)
- (ctx->baton,
- value_as_long (dwarf_expr_fetch (ctx, 0)));
+ (this->funcs->get_frame_base) (this->baton, &datastart, &datalen);
+ eval (datastart, datalen);
+ if (this->location == DWARF_VALUE_MEMORY)
+ result = fetch_address (0);
+ else if (this->location == DWARF_VALUE_REGISTER)
+ result = (this->funcs->read_addr_from_reg)
+ (this->baton,
+ value_as_long (fetch (0)));
else
error (_("Not implemented: computing frame "
"base using explicit value operator"));
result = result + offset;
result_val = value_from_ulongest (address_type, result);
in_stack_memory = 1;
- ctx->stack_len = before_stack_len;
- ctx->location = DWARF_VALUE_MEMORY;
+ this->stack_len = before_stack_len;
+ this->location = DWARF_VALUE_MEMORY;
}
break;

case DW_OP_dup:
- result_val = dwarf_expr_fetch (ctx, 0);
- in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
+ result_val = fetch (0);
+ in_stack_memory = fetch_in_stack_memory (0);
break;

case DW_OP_drop:
- dwarf_expr_pop (ctx);
+ pop ();
goto no_push;

case DW_OP_pick:
offset = *op_ptr++;
- result_val = dwarf_expr_fetch (ctx, offset);
- in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, offset);
+ result_val = fetch (offset);
+ in_stack_memory = fetch_in_stack_memory (offset);
break;

case DW_OP_swap:
{
struct dwarf_stack_value t1, t2;

- if (ctx->stack_len < 2)
+ if (this->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;
+ this->stack_len);
+ t1 = this->stack[this->stack_len - 1];
+ t2 = this->stack[this->stack_len - 2];
+ this->stack[this->stack_len - 1] = t2;
+ this->stack[this->stack_len - 2] = t1;
goto no_push;
}

case DW_OP_over:
- result_val = dwarf_expr_fetch (ctx, 1);
- in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 1);
+ result_val = fetch (1);
+ in_stack_memory = fetch_in_stack_memory (1);
break;

case DW_OP_rot:
{
struct dwarf_stack_value t1, t2, t3;

- if (ctx->stack_len < 3)
+ if (this->stack_len < 3)
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];
- t3 = ctx->stack[ctx->stack_len - 3];
- ctx->stack[ctx->stack_len - 1] = t2;
- ctx->stack[ctx->stack_len - 2] = t3;
- ctx->stack[ctx->stack_len - 3] = t1;
+ this->stack_len);
+ t1 = this->stack[this->stack_len - 1];
+ t2 = this->stack[this->stack_len - 2];
+ t3 = this->stack[this->stack_len - 3];
+ this->stack[this->stack_len - 1] = t2;
+ this->stack[this->stack_len - 2] = t3;
+ this->stack[this->stack_len - 3] = t1;
goto no_push;
}

@@ -1004,12 +993,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
case DW_OP_deref_size:
case DW_OP_GNU_deref_type:
{
- int addr_size = (op == DW_OP_deref ? ctx->addr_size : *op_ptr++);
+ int addr_size = (op == DW_OP_deref ? this->addr_size : *op_ptr++);
gdb_byte *buf = (gdb_byte *) alloca (addr_size);
- CORE_ADDR addr = dwarf_expr_fetch_address (ctx, 0);
+ CORE_ADDR addr = fetch_address (0);
struct type *type;

- dwarf_expr_pop (ctx);
+ pop ();

if (op == DW_OP_GNU_deref_type)
{
@@ -1017,12 +1006,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,

op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;
- type = dwarf_get_base_type (ctx, type_die, 0);
+ type = get_base_type (type_die, 0);
}
else
type = address_type;

- (ctx->funcs->read_mem) (ctx->baton, buf, addr, addr_size);
+ (this->funcs->read_mem) (this->baton, buf, addr, addr_size);

/* If the size of the object read from memory is different
from the type length, we need to zero-extend it. */
@@ -1046,8 +1035,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
case DW_OP_plus_uconst:
{
/* Unary operations. */
- result_val = dwarf_expr_fetch (ctx, 0);
- dwarf_expr_pop (ctx);
+ result_val = fetch (0);
+ pop ();

switch (op)
{
@@ -1095,11 +1084,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,
/* Binary operations. */
struct value *first, *second;

- second = dwarf_expr_fetch (ctx, 0);
- dwarf_expr_pop (ctx);
+ second = fetch (0);
+ pop ();

- first = dwarf_expr_fetch (ctx, 0);
- dwarf_expr_pop (ctx);
+ first = fetch (0);
+ pop ();

if (! base_types_equal_p (value_type (first), value_type (second)))
error (_("Incompatible types on DWARF stack"));
@@ -1128,7 +1117,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (orig_type == address_type)
{
struct type *utype
- = get_unsigned_type (ctx->gdbarch, orig_type);
+ = get_unsigned_type (this->gdbarch, orig_type);

cast_back = 1;
first = value_cast (utype, first);
@@ -1163,7 +1152,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (!TYPE_UNSIGNED (value_type (first)))
{
struct type *utype
- = get_unsigned_type (ctx->gdbarch, value_type (first));
+ = get_unsigned_type (this->gdbarch, value_type (first));

first = value_cast (utype, first);
}
@@ -1180,7 +1169,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (TYPE_UNSIGNED (value_type (first)))
{
struct type *stype
- = get_signed_type (ctx->gdbarch, value_type (first));
+ = get_signed_type (this->gdbarch, value_type (first));

first = value_cast (stype, first);
}
@@ -1231,7 +1220,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
break;

case DW_OP_call_frame_cfa:
- result = (ctx->funcs->get_frame_cfa) (ctx->baton);
+ result = (this->funcs->get_frame_cfa) (this->baton);
result_val = value_from_ulongest (address_type, result);
in_stack_memory = 1;
break;
@@ -1246,9 +1235,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
control block at which the variable is located. Nothing
should follow this operator, so the top of stack would be
returned. */
- result = value_as_long (dwarf_expr_fetch (ctx, 0));
- dwarf_expr_pop (ctx);
- result = (ctx->funcs->get_tls_address) (ctx->baton, result);
+ result = value_as_long (fetch (0));
+ pop ();
+ result = (this->funcs->get_tls_address) (this->baton, result);
result_val = value_from_ulongest (address_type, result);
break;

@@ -1264,11 +1253,11 @@ execute_stack_op (struct dwarf_expr_context *ctx,

offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- val = dwarf_expr_fetch (ctx, 0);
+ val = fetch (0);
dwarf_require_integral (value_type (val));
if (value_as_long (val) != 0)
op_ptr += offset;
- dwarf_expr_pop (ctx);
+ pop ();
}
goto no_push;

@@ -1281,14 +1270,14 @@ execute_stack_op (struct dwarf_expr_context *ctx,

/* Record the piece. */
op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
- add_piece (ctx, 8 * size, 0);
+ add_piece (8 * size, 0);

/* Pop off the address/regnum, and reset the location
type. */
- if (ctx->location != DWARF_VALUE_LITERAL
- && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
- dwarf_expr_pop (ctx);
- ctx->location = DWARF_VALUE_MEMORY;
+ if (this->location != DWARF_VALUE_LITERAL
+ && this->location != DWARF_VALUE_OPTIMIZED_OUT)
+ pop ();
+ this->location = DWARF_VALUE_MEMORY;
}
goto no_push;

@@ -1299,14 +1288,14 @@ execute_stack_op (struct dwarf_expr_context *ctx,
/* Record the piece. */
op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
- add_piece (ctx, size, offset);
+ add_piece (size, offset);

/* Pop off the address/regnum, and reset the location
type. */
- if (ctx->location != DWARF_VALUE_LITERAL
- && ctx->location != DWARF_VALUE_OPTIMIZED_OUT)
- dwarf_expr_pop (ctx);
- ctx->location = DWARF_VALUE_MEMORY;
+ if (this->location != DWARF_VALUE_LITERAL
+ && this->location != DWARF_VALUE_OPTIMIZED_OUT)
+ pop ();
+ this->location = DWARF_VALUE_MEMORY;
}
goto no_push;

@@ -1315,7 +1304,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
error (_("DWARF-2 expression error: DW_OP_GNU_uninit must always "
"be the very last op."));

- ctx->initialized = 0;
+ this->initialized = 0;
goto no_push;

case DW_OP_call2:
@@ -1324,7 +1313,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

offset.cu_off = extract_unsigned_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- ctx->funcs->dwarf_call (ctx, offset);
+ this->funcs->dwarf_call (this, offset);
}
goto no_push;

@@ -1334,7 +1323,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

offset.cu_off = extract_unsigned_integer (op_ptr, 4, byte_order);
op_ptr += 4;
- ctx->funcs->dwarf_call (ctx, offset);
+ this->funcs->dwarf_call (this, offset);
}
goto no_push;

@@ -1352,7 +1341,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (kind_u.dwarf_reg != -1)
{
op_ptr += len;
- ctx->funcs->push_dwarf_reg_entry_value (ctx,
+ this->funcs->push_dwarf_reg_entry_value (this,
CALL_SITE_PARAMETER_DWARF_REG,
kind_u,
-1 /* deref_size */);
@@ -1365,9 +1354,9 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (kind_u.dwarf_reg != -1)
{
if (deref_size == -1)
- deref_size = ctx->addr_size;
+ deref_size = this->addr_size;
op_ptr += len;
- ctx->funcs->push_dwarf_reg_entry_value (ctx,
+ this->funcs->push_dwarf_reg_entry_value (this,
CALL_SITE_PARAMETER_DWARF_REG,
kind_u, deref_size);
goto no_push;
@@ -1385,7 +1374,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
kind_u.param_offset.cu_off = extract_unsigned_integer (op_ptr, 4,
byte_order);
op_ptr += 4;
- ctx->funcs->push_dwarf_reg_entry_value (ctx,
+ this->funcs->push_dwarf_reg_entry_value (this,
CALL_SITE_PARAMETER_PARAM_OFFSET,
kind_u,
-1 /* deref_size */);
@@ -1405,7 +1394,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,
data = op_ptr;
op_ptr += n;

- type = dwarf_get_base_type (ctx, type_die, n);
+ type = get_base_type (type_die, n);
result_val = value_from_contents (type, data);
}
break;
@@ -1419,8 +1408,8 @@ execute_stack_op (struct dwarf_expr_context *ctx,
op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
type_die.cu_off = uoffset;

- type = dwarf_get_base_type (ctx, type_die, 0);
- result_val = ctx->funcs->get_reg_value (ctx->baton, type, reg);
+ type = get_base_type (type_die, 0);
+ result_val = this->funcs->get_reg_value (this->baton, type, reg);
}
break;

@@ -1436,10 +1425,10 @@ execute_stack_op (struct dwarf_expr_context *ctx,
if (type_die.cu_off == 0)
type = address_type;
else
- type = dwarf_get_base_type (ctx, type_die, 0);
+ type = get_base_type (type_die, 0);

- result_val = dwarf_expr_fetch (ctx, 0);
- dwarf_expr_pop (ctx);
+ result_val = fetch (0);
+ pop ();

if (op == DW_OP_GNU_convert)
result_val = value_cast (type, result_val);
@@ -1459,7 +1448,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

case DW_OP_push_object_address:
/* Return the address of the object we are currently observing. */
- result = (ctx->funcs->get_object_address) (ctx->baton);
+ result = (this->funcs->get_object_address) (this->baton);
result_val = value_from_ulongest (address_type, result);
break;

@@ -1469,7 +1458,7 @@ execute_stack_op (struct dwarf_expr_context *ctx,

/* Most things push a result value. */
gdb_assert (result_val != NULL);
- dwarf_expr_push (ctx, result_val, in_stack_memory);
+ push (result_val, in_stack_memory);
no_push:
;
}
@@ -1477,12 +1466,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
/* 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);
+ if (this->location == DWARF_VALUE_IMPLICIT_POINTER)
+ add_piece (8 * this->addr_size, 0);

abort_expression:
- ctx->recursion_depth--;
- gdb_assert (ctx->recursion_depth >= 0);
+ this->recursion_depth--;
+ gdb_assert (this->recursion_depth >= 0);
}

/* Stub dwarf_expr_context_funcs.get_frame_base implementation. */
diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 0f94f1e..4706bb3 100644
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -133,6 +133,12 @@ struct dwarf_expr_context
dwarf_expr_context ();
~dwarf_expr_context ();

+ void push_address (CORE_ADDR value, int in_stack_memory);
+ void eval (const gdb_byte *addr, size_t len);
+ struct value *fetch (int n);
+ CORE_ADDR fetch_address (int n);
+ int fetch_in_stack_memory (int n);
+
/* The stack of values, allocated with xmalloc. */
struct dwarf_stack_value *stack;

@@ -203,6 +209,17 @@ struct dwarf_expr_context
two cases need to be handled separately.) */
int num_pieces;
struct dwarf_expr_piece *pieces;
+
+private:
+
+ struct type *address_type () const;
+ void grow_stack (size_t need);
+ void push (struct value *value, int in_stack_memory);
+ int stack_empty_p () const;
+ void add_piece (ULONGEST size, ULONGEST offset);
+ struct type *get_base_type (cu_offset die, int size);
+ void execute_stack_op (const gdb_byte *op_ptr, const gdb_byte *op_end);
+ void pop ();
};

@@ -253,15 +270,6 @@ struct dwarf_expr_piece
ULONGEST offset;
};

-void dwarf_expr_push_address (struct dwarf_expr_context *ctx,
- CORE_ADDR value,
- int in_stack_memory);
-void dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
- size_t len);
-struct value *dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
-CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
-int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
-
void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
const char *);

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 4914c16..1f946df 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -561,7 +561,7 @@ per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
/* DW_OP_call_ref is currently not supported. */
gdb_assert (block.per_cu == per_cu);

- dwarf_expr_eval (ctx, block.data, block.size);
+ ctx->eval (block.data, block.size);
}

/* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
@@ -1300,7 +1300,7 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
ctx->baton = &baton_local;

- dwarf_expr_eval (ctx, data_src, size);
+ ctx->eval (data_src, size);

ctx->gdbarch = saved_ctx.gdbarch;
ctx->addr_size = saved_ctx.addr_size;
@@ -2319,7 +2319,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,

TRY
{
- dwarf_expr_eval (&ctx, data, size);
+ ctx.eval (data, size);
}
CATCH (ex, RETURN_MASK_ERROR)
{
@@ -2371,7 +2371,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
{
struct gdbarch *arch = get_frame_arch (frame);
int dwarf_regnum
- = longest_to_int (value_as_long (dwarf_expr_fetch (&ctx, 0)));
+ = longest_to_int (value_as_long (ctx.fetch (0)));
int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum);

if (byte_offset != 0)
@@ -2399,8 +2399,8 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
case DWARF_VALUE_MEMORY:
{
struct type *ptr_type;
- CORE_ADDR address = dwarf_expr_fetch_address (&ctx, 0);
- int in_stack_memory = dwarf_expr_fetch_in_stack_memory (&ctx, 0);
+ CORE_ADDR address = ctx.fetch_address (0);
+ int in_stack_memory = ctx.fetch_in_stack_memory (0);

/* DW_OP_deref_size (and possibly other operations too) may
create a pointer instead of an address. Ideally, the
@@ -2431,7 +2431,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,

case DWARF_VALUE_STACK:
{
- struct value *value = dwarf_expr_fetch (&ctx, 0);
+ struct value *value = ctx.fetch (0);
gdb_byte *contents;
const gdb_byte *val_bytes;
size_t n = TYPE_LENGTH (value_type (value));
@@ -2559,14 +2559,14 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
ctx.funcs = &dwarf_expr_ctx_funcs;
ctx.baton = &baton;

- dwarf_expr_eval (&ctx, dlbaton->data, dlbaton->size);
+ ctx.eval (dlbaton->data, dlbaton->size);

switch (ctx.location)
{
case DWARF_VALUE_REGISTER:
case DWARF_VALUE_MEMORY:
case DWARF_VALUE_STACK:
- *valp = dwarf_expr_fetch_address (&ctx, 0);
+ *valp = ctx.fetch_address (0);
if (ctx.location == DWARF_VALUE_REGISTER)
*valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
return 1;
@@ -2809,7 +2809,7 @@ needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
nf_baton->needs = SYMBOL_NEEDS_FRAME;

/* The expression may require some stub values on DWARF stack. */
- dwarf_expr_push_address (ctx, 0, 0);
+ ctx->push_address (0, 0);
}

/* DW_OP_GNU_addr_index doesn't require a frame. */
@@ -2874,7 +2874,7 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size,
ctx.baton = &baton;
ctx.funcs = &symbol_needs_ctx_funcs;

- dwarf_expr_eval (&ctx, data, size);
+ ctx.eval (data, size);

in_reg = ctx.location == DWARF_VALUE_REGISTER;