From patchwork Fri Jul 11 09:21:13 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Keven Boell X-Patchwork-Id: 2009 Received: (qmail 29262 invoked by alias); 11 Jul 2014 09:21:45 -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 29039 invoked by uid 89); 11 Jul 2014 09:21:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mga11.intel.com Received: from mga11.intel.com (HELO mga11.intel.com) (192.55.52.93) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 11 Jul 2014 09:21:40 +0000 Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga102.fm.intel.com with ESMTP; 11 Jul 2014 02:21:39 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga002.fm.intel.com with ESMTP; 11 Jul 2014 02:21:38 -0700 Received: from ullecvh004g04.iul.intel.com (ullecvh004g04.iul.intel.com [172.28.50.14]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id s6B9Lbtq020703; Fri, 11 Jul 2014 10:21:37 +0100 Received: from ullecvh004g04.iul.intel.com (ullecvh004g04.iul.intel.com [127.0.0.1]) by ullecvh004g04.iul.intel.com (8.13.8/8.13.8) with ESMTP id s6B9Lc6l006997; Fri, 11 Jul 2014 11:21:38 +0200 Received: (from kboell@localhost) by ullecvh004g04.iul.intel.com (8.13.8/8.13.8/Submit) id s6B9Lcn1006996; Fri, 11 Jul 2014 11:21:38 +0200 From: Keven Boell To: gdb-patches@sourceware.org Cc: keven.boell@intel.com, sanimir.agovic@intel.com Subject: [V2 01/23] dwarf: add dwarf3 DW_OP_push_object_address opcode Date: Fri, 11 Jul 2014 11:21:13 +0200 Message-Id: <1405070495-6948-2-git-send-email-keven.boell@intel.com> In-Reply-To: <1405070495-6948-1-git-send-email-keven.boell@intel.com> References: <1405070495-6948-1-git-send-email-keven.boell@intel.com> The opcode pushes the address of the object being evaluated. The semantic is equivalent to the implicit push of the base address of a data member location. Address fields were introduced in order to store the address to push for an object into the baton. 2014-05-28 Sanimir Agovic Keven Boell * dwarf2expr.c (execute_stack_op) : New case. * dwarf2expr.h (struct dwarf_expr_context_funcs) : New function pointer get_object_addr. * dwarf2loc.c (struct dwarf_expr_baton): Add obj_address. (dwarf_expr_get_obj_addr): New function. (struct dwarf_expr_context_funcs): Add dwarf_expr_get_obj_addr to dwarf_expr_ctx_funcs. (dwarf2_evaluate_loc_desc_full): Initialize baton.obj_address. (dwarf2_locexpr_baton_eval): Set baton.obj_address to addr. (needs_get_obj_addr): New function. (struct dwarf_expr_context_funcs): Add needs_get_obj_addr to needs_frame_ctx_funcs. Change-Id: Ied9e1ba632e8d35d0ec00cc832b96d432449fd82 Signed-off-by: Keven Boell --- gdb/dwarf2expr.c | 6 ++++++ gdb/dwarf2expr.h | 4 ---- gdb/dwarf2loc.c | 45 +++++++++++++++++++++++++++++++++++++++++---- gdb/dwarf2loc.h | 1 + gdb/gdbtypes.c | 20 ++++++++++---------- 5 files changed, 58 insertions(+), 18 deletions(-) diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c index 36c9f66..274ba62 100644 --- a/gdb/dwarf2expr.c +++ b/gdb/dwarf2expr.c @@ -1478,6 +1478,12 @@ execute_stack_op (struct dwarf_expr_context *ctx, } break; + 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_val = value_from_ulongest (address_type, result); + break; + default: error (_("Unhandled dwarf expression opcode 0x%x"), op); } diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h index 39dadf3..8cebbe8 100644 --- a/gdb/dwarf2expr.h +++ b/gdb/dwarf2expr.h @@ -84,12 +84,8 @@ struct dwarf_expr_context_funcs This can throw an exception if the index is out of range. */ CORE_ADDR (*get_addr_index) (void *baton, unsigned int index); -#if 0 - /* Not yet implemented. */ - /* Return the `object address' for DW_OP_push_object_address. */ CORE_ADDR (*get_object_address) (void *baton); -#endif }; /* The location of a value. */ diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index fcab9b9..eaa499e 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -306,6 +306,7 @@ struct dwarf_expr_baton { struct frame_info *frame; struct dwarf2_per_cu_data *per_cu; + CORE_ADDR obj_address; }; /* Helper functions for dwarf2_evaluate_loc_desc. */ @@ -1209,6 +1210,7 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx, baton_local.frame = caller_frame; baton_local.per_cu = caller_per_cu; + baton_local.obj_address = 0; saved_ctx.gdbarch = ctx->gdbarch; saved_ctx.addr_size = ctx->addr_size; @@ -1238,6 +1240,22 @@ dwarf_expr_get_addr_index (void *baton, unsigned int index) return dwarf2_read_addr_index (debaton->per_cu, index); } +/* Callback function for get_object_address. Return the address of the VLA + object. */ + +static CORE_ADDR +dwarf_expr_get_obj_addr (void *baton) +{ + struct dwarf_expr_baton *debaton = baton; + + gdb_assert (debaton != NULL); + + if (debaton->obj_address == 0) + error (_("Location address is not set.")); + + return debaton->obj_address; +} + /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform the indirect method on it, that is use its stored target value, the sole purpose of entry_data_value_funcs.. */ @@ -2202,7 +2220,8 @@ static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs = dwarf_expr_dwarf_call, dwarf_expr_get_base_type, dwarf_expr_push_dwarf_reg_entry_value, - dwarf_expr_get_addr_index + dwarf_expr_get_addr_index, + dwarf_expr_get_obj_addr }; /* Evaluate a location description, starting at DATA and with length @@ -2231,6 +2250,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, baton.frame = frame; baton.per_cu = per_cu; + baton.obj_address = 0; ctx = new_dwarf_expr_context (); old_chain = make_cleanup_free_dwarf_expr_context (ctx); @@ -2436,6 +2456,7 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame, static int dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, + CORE_ADDR addr, CORE_ADDR *valp) { struct dwarf_expr_context *ctx; @@ -2451,6 +2472,7 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, baton.frame = get_selected_frame (NULL); baton.per_cu = dlbaton->per_cu; + baton.obj_address = addr; objfile = dwarf2_per_cu_objfile (dlbaton->per_cu); @@ -2491,7 +2513,8 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, /* See dwarf2loc.h. */ int -dwarf2_evaluate_property (const struct dynamic_prop *prop, CORE_ADDR *value) +dwarf2_evaluate_property (const struct dynamic_prop *prop, CORE_ADDR address, + CORE_ADDR *value) { if (prop == NULL) return 0; @@ -2502,7 +2525,7 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop, CORE_ADDR *value) { const struct dwarf2_property_baton *baton = prop->data.baton; - if (dwarf2_locexpr_baton_eval (&baton->locexpr, value)) + if (dwarf2_locexpr_baton_eval (&baton->locexpr, address, value)) { if (baton->referenced_type) { @@ -2653,6 +2676,15 @@ needs_get_addr_index (void *baton, unsigned int index) return 1; } +/* DW_OP_push_object_address has a frame already passed through. */ + +static CORE_ADDR +needs_get_obj_addr (void *baton) +{ + /* Nothing to do. */ + return 1; +} + /* Virtual method table for dwarf2_loc_desc_needs_frame below. */ static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs = @@ -2667,7 +2699,8 @@ static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs = needs_frame_dwarf_call, NULL, /* get_base_type */ needs_dwarf_reg_entry_value, - needs_get_addr_index + needs_get_addr_index, + needs_get_obj_addr }; /* Return non-zero iff the location expression at DATA (length SIZE) @@ -3316,6 +3349,10 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc, unimplemented (op); break; + case DW_OP_push_object_address: + unimplemented (op); + break; + case DW_OP_skip: offset = extract_signed_integer (op_ptr, 2, byte_order); op_ptr += 2; diff --git a/gdb/dwarf2loc.h b/gdb/dwarf2loc.h index 8ad5fa9..04e2792 100644 --- a/gdb/dwarf2loc.h +++ b/gdb/dwarf2loc.h @@ -96,6 +96,7 @@ struct value *dwarf2_evaluate_loc_desc (struct type *type, into VALUE, otherwise returns 0. */ int dwarf2_evaluate_property (const struct dynamic_prop *prop, + CORE_ADDR address, CORE_ADDR *value); CORE_ADDR dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu, diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index d0c002f..08e5884 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1653,11 +1653,11 @@ is_dynamic_type (struct type *type) return 0; } -/* Given a dynamic range type (dyn_range_type), return a static version - of that type. */ +/* Given a dynamic range type (dyn_range_type) and address, + return a static version of that type. */ static struct type * -resolve_dynamic_range (struct type *dyn_range_type) +resolve_dynamic_range (struct type *dyn_range_type, CORE_ADDR addr) { CORE_ADDR value; struct type *static_range_type; @@ -1668,7 +1668,7 @@ resolve_dynamic_range (struct type *dyn_range_type) gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE); prop = &TYPE_RANGE_DATA (dyn_range_type)->low; - if (dwarf2_evaluate_property (prop, &value)) + if (dwarf2_evaluate_property (prop, addr, &value)) { low_bound.kind = PROP_CONST; low_bound.data.const_val = value; @@ -1680,7 +1680,7 @@ resolve_dynamic_range (struct type *dyn_range_type) } prop = &TYPE_RANGE_DATA (dyn_range_type)->high; - if (dwarf2_evaluate_property (prop, &value)) + if (dwarf2_evaluate_property (prop, addr, &value)) { high_bound.kind = PROP_CONST; high_bound.data.const_val = value; @@ -1707,7 +1707,7 @@ resolve_dynamic_range (struct type *dyn_range_type) of the associated array. */ static struct type * -resolve_dynamic_array (struct type *type) +resolve_dynamic_array (struct type *type, CORE_ADDR addr) { CORE_ADDR value; struct type *elt_type; @@ -1718,12 +1718,12 @@ resolve_dynamic_array (struct type *type) elt_type = type; range_type = check_typedef (TYPE_INDEX_TYPE (elt_type)); - range_type = resolve_dynamic_range (range_type); + range_type = resolve_dynamic_range (range_type, addr); ary_dim = check_typedef (TYPE_TARGET_TYPE (elt_type)); if (ary_dim != NULL && TYPE_CODE (ary_dim) == TYPE_CODE_ARRAY) - elt_type = resolve_dynamic_array (TYPE_TARGET_TYPE (type)); + elt_type = resolve_dynamic_array (TYPE_TARGET_TYPE (type), addr); else elt_type = TYPE_TARGET_TYPE (type); @@ -1853,11 +1853,11 @@ resolve_dynamic_type (struct type *type, CORE_ADDR addr) } case TYPE_CODE_ARRAY: - resolved_type = resolve_dynamic_array (type); + resolved_type = resolve_dynamic_array (type, addr); break; case TYPE_CODE_RANGE: - resolved_type = resolve_dynamic_range (type); + resolved_type = resolve_dynamic_range (type, addr); break; case TYPE_CODE_UNION: