From patchwork Tue Sep 27 04:08:49 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 16050 Received: (qmail 88760 invoked by alias); 27 Sep 2016 04:43:03 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 88662 invoked by uid 89); 27 Sep 2016 04:43:02 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.0 required=5.0 tests=AWL, BAYES_00, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=no version=3.3.2 spammy=H*r:4.86_1, 8147, 4387, 438, 7 X-HELO: gproxy8-pub.mail.unifiedlayer.com Received: from gproxy8-pub.mail.unifiedlayer.com (HELO gproxy8-pub.mail.unifiedlayer.com) (67.222.33.93) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with SMTP; Tue, 27 Sep 2016 04:42:52 +0000 Received: (qmail 32366 invoked by uid 0); 27 Sep 2016 04:42:51 -0000 Received: from unknown (HELO cmgw4) (10.0.90.85) by gproxy8.mail.unifiedlayer.com with SMTP; 27 Sep 2016 04:42:51 -0000 Received: from box522.bluehost.com ([74.220.219.122]) by cmgw4 with id oUio1t0042f2jeq01UirRh; Mon, 26 Sep 2016 22:42:51 -0600 X-Authority-Analysis: v=2.1 cv=Hq7lRSjS c=1 sm=1 tr=0 a=GsOEXm/OWkKvwdLVJsfwcA==:117 a=GsOEXm/OWkKvwdLVJsfwcA==:17 a=L9H7d07YOLsA:10 a=9cW_t1CCXrUA:10 a=s5jvgZ67dGcA:10 a=GW1xBdLrtEIA:10 a=zstS-IiYAAAA:8 a=Wo1rpmkLBj1wxch3twwA:9 a=TkcAqOpcQWrG3iso:21 a=b39EPdbMO2XEtS_r:21 a=4G6NA9xxw8l3yy4pmD5M:22 Received: from 71-218-192-86.hlrn.qwest.net ([71.218.192.86]:56110 helo=bapiya.Home) by box522.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.86_1) (envelope-from ) id 1bojha-0006Nj-4x; Mon, 26 Sep 2016 22:09:07 -0600 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA 21/22] Convert DWARF expr functions to methods Date: Mon, 26 Sep 2016 22:08:49 -0600 Message-Id: <1474949330-4307-22-git-send-email-tom@tromey.com> In-Reply-To: <1474949330-4307-1-git-send-email-tom@tromey.com> References: <1474949330-4307-1-git-send-email-tom@tromey.com> X-BWhitelist: no X-Exim-ID: 1bojha-0006Nj-4x X-Source-Sender: 71-218-192-86.hlrn.qwest.net (bapiya.Home) [71.218.192.86]:56110 X-Source-Auth: tom+tromey.com X-Email-Count: 23 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTIyLmJsdWVob3N0LmNvbQ== This converts various DWARF expr functions to be members on dwarf_expr_context, then fixes up the various users. This results in somewhat less wordy code and sets the stage for the next patch. 2016-09-26 Tom Tromey * 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) : 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. --- gdb/ChangeLog | 20 +++ gdb/dwarf2-frame.c | 8 +- gdb/dwarf2expr.c | 374 ++++++++++++++++++++++++++--------------------------- gdb/dwarf2expr.h | 26 ++-- gdb/dwarf2loc.c | 22 ++-- 5 files changed, 234 insertions(+), 216 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e7de300..fbbd640 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,25 @@ 2016-09-26 Tom Tromey + * 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) : 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-09-26 Tom Tromey + * 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 a965987..2b22e0b 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, ""); return types->dw_types[ndx]; @@ -122,28 +117,27 @@ dwarf_expr_context::~dwarf_expr_context () /* Expand the memory allocated to CTX's 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. */ -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; } @@ -151,34 +145,31 @@ dwarf_expr_push (struct dwarf_expr_context *ctx, struct value *value, /* Push VALUE onto CTX's 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. */ -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. */ 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. */ @@ -239,10 +230,10 @@ get_signed_type (struct gdbarch *gdbarch, struct type *type) /* Retrieve the N'th item on CTX's 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,14 +247,14 @@ 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; @@ -272,68 +263,68 @@ dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n) /* 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) +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); } } @@ -341,16 +332,15 @@ add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset) CTX. */ 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. */ - 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. */ @@ -423,14 +413,14 @@ base_types_equal_p (struct type *t1, struct type *t2) 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) @@ -438,7 +428,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; } @@ -613,14 +603,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 @@ -628,15 +618,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) { @@ -697,26 +687,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; @@ -815,7 +805,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: @@ -824,7 +814,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: @@ -834,9 +824,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"); @@ -844,7 +834,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; @@ -852,21 +842,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"); } @@ -906,7 +896,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); @@ -916,7 +906,7 @@ execute_stack_op (struct dwarf_expr_context *ctx, { op_ptr = safe_read_uleb128 (op_ptr, op_end, ®); 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); } @@ -932,78 +922,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; } @@ -1011,12 +1001,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) { @@ -1024,12 +1014,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. */ @@ -1053,8 +1043,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) { @@ -1102,11 +1092,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")); @@ -1135,7 +1125,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); @@ -1170,7 +1160,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); } @@ -1187,7 +1177,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); } @@ -1238,7 +1228,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; @@ -1253,9 +1243,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; @@ -1271,11 +1261,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; @@ -1288,14 +1278,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; @@ -1306,14 +1296,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; @@ -1322,7 +1312,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: @@ -1331,7 +1321,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; @@ -1341,7 +1331,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; @@ -1359,7 +1349,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 */); @@ -1372,9 +1362,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; @@ -1392,7 +1382,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 */); @@ -1412,7 +1402,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; @@ -1426,8 +1416,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; @@ -1443,10 +1433,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); @@ -1466,7 +1456,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; @@ -1476,7 +1466,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: ; } @@ -1484,12 +1474,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 066f55b..d6ffd85 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;