From patchwork Tue Sep 27 04:08:48 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 16049 Received: (qmail 87178 invoked by alias); 27 Sep 2016 04:42:23 -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 87162 invoked by uid 89); 27 Sep 2016 04:42:23 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.1 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, sk:dwarf_s, H*F:U*tom, 9145 X-HELO: gproxy9-pub.mail.unifiedlayer.com Received: from gproxy9-pub.mail.unifiedlayer.com (HELO gproxy9-pub.mail.unifiedlayer.com) (69.89.20.122) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with SMTP; Tue, 27 Sep 2016 04:42:18 +0000 Received: (qmail 7486 invoked by uid 0); 27 Sep 2016 04:42:16 -0000 Received: from unknown (HELO cmgw2) (10.0.90.83) by gproxy9.mail.unifiedlayer.com with SMTP; 27 Sep 2016 04:42:16 -0000 Received: from box522.bluehost.com ([74.220.219.122]) by cmgw2 with id oUiB1t00U2f2jeq01UiEJv; Mon, 26 Sep 2016 22:42:15 -0600 X-Authority-Analysis: v=2.1 cv=F4vEKMRN 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=k_7O8pE2R6ChHxvf3rAA:9 a=JpZdXb_ByCaimk3-:21 a=z-mgT33jKDf7CQqJ: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 1bojhY-0006Nj-Lg; Mon, 26 Sep 2016 22:09:05 -0600 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA 20/22] Initial conversion of dwarf_expr_ctx Date: Mon, 26 Sep 2016 22:08:48 -0600 Message-Id: <1474949330-4307-21-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: 1bojhY-0006Nj-Lg 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 is the first step in the conversion of dwarf_expr_ctx to a C++ class. This conversion is done in steps to make the patches, and the reviews, a bit simpler. This patch changes dwarf_expr_ctx to be stack-allocated and removes the assocatied cleanup. 2016-09-26 Tom Tromey * dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Stack-allocate dwarf_expr_context. Remove cleanups. (dwarf2_locexpr_baton_eval) (dwarf2_loc_desc_get_symbol_read_needs): Likewise. * dwarf2expr.h (dwarf_expr_context, ~dwarf_expr_context): Add constructors and destructors. (new_dwarf_expr_context, free_dwarf_expr_context) (make_cleanup_free_dwarf_expr_context): Don't declare. * dwarf2-frame.c (execute_stack_op): Stack-allocate dwarf_expr_context. Remove cleanups. (dwarf_expr_context): Rename from new_dwarf_expr_context. Turn into constructor. (free_dwarf_expr_context, free_dwarf_expr_context_cleanup): Remove. (~dwarf_expr_context): Rename from make_cleanup_free_dwarf_expr_context. Turn into destructor. --- gdb/ChangeLog | 19 +++++++++ gdb/dwarf2-frame.c | 30 +++++++------- gdb/dwarf2expr.c | 55 ++++++++++--------------- gdb/dwarf2expr.h | 8 ++-- gdb/dwarf2loc.c | 115 ++++++++++++++++++++++++----------------------------- 5 files changed, 110 insertions(+), 117 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index bae4443..e7de300 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,24 @@ 2016-09-26 Tom Tromey + * dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Stack-allocate + dwarf_expr_context. Remove cleanups. + (dwarf2_locexpr_baton_eval) + (dwarf2_loc_desc_get_symbol_read_needs): Likewise. + * dwarf2expr.h (dwarf_expr_context, ~dwarf_expr_context): Add + constructors and destructors. + (new_dwarf_expr_context, free_dwarf_expr_context) + (make_cleanup_free_dwarf_expr_context): Don't declare. + * dwarf2-frame.c (execute_stack_op): Stack-allocate + dwarf_expr_context. Remove cleanups. + (dwarf_expr_context): Rename from new_dwarf_expr_context. Turn + into constructor. + (free_dwarf_expr_context, free_dwarf_expr_context_cleanup): + Remove. + (~dwarf_expr_context): Rename from + make_cleanup_free_dwarf_expr_context. Turn into destructor. + +2016-09-26 Tom Tromey + * tid-parse.h (tid_range_parser): New class. (tid_range_parser_get_tid, tid_range_parser_get_tid_range) (tid_range_parser_star_range, tid_range_parser_finished) diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c index 11258ea..48963de 100644 --- a/gdb/dwarf2-frame.c +++ b/gdb/dwarf2-frame.c @@ -369,29 +369,27 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size, CORE_ADDR offset, struct frame_info *this_frame, CORE_ADDR initial, int initial_in_stack_memory) { - struct dwarf_expr_context *ctx; CORE_ADDR result; struct cleanup *old_chain; - ctx = new_dwarf_expr_context (); - old_chain = make_cleanup_free_dwarf_expr_context (ctx); - make_cleanup_value_free_to_mark (value_mark ()); + dwarf_expr_context ctx; + old_chain = make_cleanup_value_free_to_mark (value_mark ()); - ctx->gdbarch = get_frame_arch (this_frame); - ctx->addr_size = addr_size; - ctx->ref_addr_size = -1; - ctx->offset = offset; - ctx->baton = this_frame; - ctx->funcs = &dwarf2_frame_ctx_funcs; + ctx.gdbarch = get_frame_arch (this_frame); + ctx.addr_size = addr_size; + ctx.ref_addr_size = -1; + ctx.offset = offset; + 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); + dwarf_expr_push_address (&ctx, initial, initial_in_stack_memory); + dwarf_expr_eval (&ctx, exp, len); - if (ctx->location == DWARF_VALUE_MEMORY) - result = dwarf_expr_fetch_address (ctx, 0); - else if (ctx->location == DWARF_VALUE_REGISTER) + if (ctx.location == DWARF_VALUE_MEMORY) + result = dwarf_expr_fetch_address (&ctx, 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 (dwarf_expr_fetch (&ctx, 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 7eb1982..a965987 100644 --- a/gdb/dwarf2expr.c +++ b/gdb/dwarf2expr.c @@ -91,45 +91,32 @@ dwarf_expr_address_type (struct dwarf_expr_context *ctx) /* Create a new context for the expression evaluator. */ -struct dwarf_expr_context * -new_dwarf_expr_context (void) +dwarf_expr_context::dwarf_expr_context () +: stack (nullptr), + stack_len (0), + stack_allocated (10), + gdbarch (nullptr), + addr_size (0), + ref_addr_size (0), + offset (0), + recursion_depth (0), + max_recursion_depth (0x100), + location (DWARF_VALUE_MEMORY), + len (0), + data (nullptr), + initialized (0), + num_pieces (0), + pieces (nullptr) { - struct dwarf_expr_context *retval; - - retval = XCNEW (struct dwarf_expr_context); - retval->stack_len = 0; - retval->stack_allocated = 10; - retval->stack = XNEWVEC (struct dwarf_stack_value, retval->stack_allocated); - retval->num_pieces = 0; - retval->pieces = 0; - retval->max_recursion_depth = 0x100; - return retval; + this->stack = XNEWVEC (struct dwarf_stack_value, this->stack_allocated); } -/* Release the memory allocated to CTX. */ +/* Clean up a dwarf_expr_context. */ -void -free_dwarf_expr_context (struct dwarf_expr_context *ctx) -{ - xfree (ctx->stack); - xfree (ctx->pieces); - xfree (ctx); -} - -/* Helper for make_cleanup_free_dwarf_expr_context. */ - -static void -free_dwarf_expr_context_cleanup (void *arg) -{ - free_dwarf_expr_context ((struct dwarf_expr_context *) arg); -} - -/* Return a cleanup that calls free_dwarf_expr_context. */ - -struct cleanup * -make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx) +dwarf_expr_context::~dwarf_expr_context () { - return make_cleanup (free_dwarf_expr_context_cleanup, ctx); + xfree (this->stack); + xfree (this->pieces); } /* Expand the memory allocated to CTX's stack to contain at least diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h index cbab45b..0f94f1e 100644 --- a/gdb/dwarf2expr.h +++ b/gdb/dwarf2expr.h @@ -130,6 +130,9 @@ struct dwarf_stack_value its current state and its callbacks. */ struct dwarf_expr_context { + dwarf_expr_context (); + ~dwarf_expr_context (); + /* The stack of values, allocated with xmalloc. */ struct dwarf_stack_value *stack; @@ -250,11 +253,6 @@ struct dwarf_expr_piece ULONGEST offset; }; -struct dwarf_expr_context *new_dwarf_expr_context (void); -void free_dwarf_expr_context (struct dwarf_expr_context *ctx); -struct cleanup * - make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx); - void dwarf_expr_push_address (struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory); diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index 7b3a2b2..066f55b 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -2294,8 +2294,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, { struct value *retval; struct dwarf_expr_baton baton; - struct dwarf_expr_context *ctx; - struct cleanup *old_chain, *value_chain; + struct cleanup *value_chain; struct objfile *objfile = dwarf2_per_cu_objfile (per_cu); if (byte_offset < 0) @@ -2308,26 +2307,25 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, baton.per_cu = per_cu; baton.obj_address = 0; - ctx = new_dwarf_expr_context (); - old_chain = make_cleanup_free_dwarf_expr_context (ctx); + dwarf_expr_context ctx; value_chain = make_cleanup_value_free_to_mark (value_mark ()); - ctx->gdbarch = get_objfile_arch (objfile); - ctx->addr_size = dwarf2_per_cu_addr_size (per_cu); - ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu); - ctx->offset = dwarf2_per_cu_text_offset (per_cu); - ctx->baton = &baton; - ctx->funcs = &dwarf_expr_ctx_funcs; + ctx.gdbarch = get_objfile_arch (objfile); + ctx.addr_size = dwarf2_per_cu_addr_size (per_cu); + ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu); + ctx.offset = dwarf2_per_cu_text_offset (per_cu); + ctx.baton = &baton; + ctx.funcs = &dwarf_expr_ctx_funcs; TRY { - dwarf_expr_eval (ctx, data, size); + dwarf_expr_eval (&ctx, data, size); } CATCH (ex, RETURN_MASK_ERROR) { if (ex.error == NOT_AVAILABLE_ERROR) { - do_cleanups (old_chain); + do_cleanups (value_chain); retval = allocate_value (type); mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type)); return retval; @@ -2336,7 +2334,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, { if (entry_values_debug) exception_print (gdb_stdout, ex); - do_cleanups (old_chain); + do_cleanups (value_chain); return allocate_optimized_out_value (type); } else @@ -2344,20 +2342,20 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, } END_CATCH - if (ctx->num_pieces > 0) + if (ctx.num_pieces > 0) { struct piece_closure *c; struct frame_id frame_id = get_frame_id (frame); ULONGEST bit_size = 0; int i; - for (i = 0; i < ctx->num_pieces; ++i) - bit_size += ctx->pieces[i].size; + for (i = 0; i < ctx.num_pieces; ++i) + bit_size += ctx.pieces[i].size; if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size) invalid_synthetic_pointer (); - c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces, - ctx->addr_size); + c = allocate_piece_closure (per_cu, ctx.num_pieces, ctx.pieces, + ctx.addr_size); /* We must clean up the value chain after creating the piece closure but before allocating the result. */ do_cleanups (value_chain); @@ -2367,13 +2365,13 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, } else { - switch (ctx->location) + switch (ctx.location) { case DWARF_VALUE_REGISTER: { 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 (dwarf_expr_fetch (&ctx, 0))); int gdb_regnum = dwarf_reg_to_regnum_or_error (arch, dwarf_regnum); if (byte_offset != 0) @@ -2401,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 = dwarf_expr_fetch_address (&ctx, 0); + int in_stack_memory = dwarf_expr_fetch_in_stack_memory (&ctx, 0); /* DW_OP_deref_size (and possibly other operations too) may create a pointer instead of an address. Ideally, the @@ -2416,10 +2414,10 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, { case TYPE_CODE_FUNC: case TYPE_CODE_METHOD: - ptr_type = builtin_type (ctx->gdbarch)->builtin_func_ptr; + ptr_type = builtin_type (ctx.gdbarch)->builtin_func_ptr; break; default: - ptr_type = builtin_type (ctx->gdbarch)->builtin_data_ptr; + ptr_type = builtin_type (ctx.gdbarch)->builtin_data_ptr; break; } address = value_as_address (value_from_pointer (ptr_type, address)); @@ -2433,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 = dwarf_expr_fetch (&ctx, 0); gdb_byte *contents; const gdb_byte *val_bytes; size_t n = TYPE_LENGTH (value_type (value)); @@ -2470,7 +2468,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, { bfd_byte *contents; const bfd_byte *ldata; - size_t n = ctx->len; + size_t n = ctx.len; if (byte_offset + TYPE_LENGTH (type) > n) invalid_synthetic_pointer (); @@ -2479,7 +2477,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, retval = allocate_value (type); contents = value_contents_raw (retval); - ldata = ctx->data + byte_offset; + ldata = ctx.data + byte_offset; n -= byte_offset; if (n > TYPE_LENGTH (type)) @@ -2509,9 +2507,9 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, } } - set_value_initialized (retval, ctx->initialized); + set_value_initialized (retval, ctx.initialized); - do_cleanups (old_chain); + do_cleanups (value_chain); return retval; } @@ -2539,7 +2537,6 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, CORE_ADDR addr, CORE_ADDR *valp) { - struct dwarf_expr_context *ctx; struct dwarf_expr_baton baton; struct objfile *objfile; struct cleanup *cleanup; @@ -2547,8 +2544,7 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, if (dlbaton == NULL || dlbaton->size == 0) return 0; - ctx = new_dwarf_expr_context (); - cleanup = make_cleanup_free_dwarf_expr_context (ctx); + dwarf_expr_context ctx; baton.frame = frame; baton.per_cu = dlbaton->per_cu; @@ -2556,29 +2552,27 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, objfile = dwarf2_per_cu_objfile (dlbaton->per_cu); - ctx->gdbarch = get_objfile_arch (objfile); - ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); - ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu); - ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu); - ctx->funcs = &dwarf_expr_ctx_funcs; - ctx->baton = &baton; + ctx.gdbarch = get_objfile_arch (objfile); + ctx.addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu); + ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu); + ctx.offset = dwarf2_per_cu_text_offset (dlbaton->per_cu); + ctx.funcs = &dwarf_expr_ctx_funcs; + ctx.baton = &baton; - dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size); + dwarf_expr_eval (&ctx, dlbaton->data, dlbaton->size); - switch (ctx->location) + switch (ctx.location) { case DWARF_VALUE_REGISTER: case DWARF_VALUE_MEMORY: case DWARF_VALUE_STACK: - *valp = dwarf_expr_fetch_address (ctx, 0); - if (ctx->location == DWARF_VALUE_REGISTER) + *valp = dwarf_expr_fetch_address (&ctx, 0); + if (ctx.location == DWARF_VALUE_REGISTER) *valp = dwarf_expr_read_addr_from_reg (&baton, *valp); - do_cleanups (cleanup); return 1; case DWARF_VALUE_LITERAL: - *valp = extract_signed_integer (ctx->data, ctx->len, - gdbarch_byte_order (ctx->gdbarch)); - do_cleanups (cleanup); + *valp = extract_signed_integer (ctx.data, ctx.len, + gdbarch_byte_order (ctx.gdbarch)); return 1; /* Unsupported dwarf values. */ case DWARF_VALUE_OPTIMIZED_OUT: @@ -2586,7 +2580,6 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, break; } - do_cleanups (cleanup); return 0; } @@ -2864,7 +2857,6 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu) { struct symbol_needs_baton baton; - struct dwarf_expr_context *ctx; int in_reg; struct cleanup *old_chain; struct objfile *objfile = dwarf2_per_cu_objfile (per_cu); @@ -2872,29 +2864,28 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size, baton.needs = SYMBOL_NEEDS_NONE; baton.per_cu = per_cu; - ctx = new_dwarf_expr_context (); - old_chain = make_cleanup_free_dwarf_expr_context (ctx); - make_cleanup_value_free_to_mark (value_mark ()); + dwarf_expr_context ctx; + old_chain = make_cleanup_value_free_to_mark (value_mark ()); - ctx->gdbarch = get_objfile_arch (objfile); - ctx->addr_size = dwarf2_per_cu_addr_size (per_cu); - ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu); - ctx->offset = dwarf2_per_cu_text_offset (per_cu); - ctx->baton = &baton; - ctx->funcs = &symbol_needs_ctx_funcs; + ctx.gdbarch = get_objfile_arch (objfile); + ctx.addr_size = dwarf2_per_cu_addr_size (per_cu); + ctx.ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu); + ctx.offset = dwarf2_per_cu_text_offset (per_cu); + ctx.baton = &baton; + ctx.funcs = &symbol_needs_ctx_funcs; - dwarf_expr_eval (ctx, data, size); + dwarf_expr_eval (&ctx, data, size); - in_reg = ctx->location == DWARF_VALUE_REGISTER; + in_reg = ctx.location == DWARF_VALUE_REGISTER; - if (ctx->num_pieces > 0) + if (ctx.num_pieces > 0) { int i; /* If the location has several pieces, and any of them are in registers, then we will need a frame to fetch them from. */ - for (i = 0; i < ctx->num_pieces; i++) - if (ctx->pieces[i].location == DWARF_VALUE_REGISTER) + for (i = 0; i < ctx.num_pieces; i++) + if (ctx.pieces[i].location == DWARF_VALUE_REGISTER) in_reg = 1; }