From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id QHVEFXT+PGAGJAAAWB0awg (envelope-from ) for ; Mon, 01 Mar 2021 09:47:16 -0500 Received: by simark.ca (Postfix, from userid 112) id 52AF21EF7E; Mon, 1 Mar 2021 09:47:15 -0500 (EST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on simark.ca X-Spam-Level: X-Spam-Status: No, score=0.2 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,RDNS_NONE, URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.2 Received: from sourceware.org (unknown [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 227F21EF7C for ; Mon, 1 Mar 2021 09:47:14 -0500 (EST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 9C612393A427; Mon, 1 Mar 2021 14:47:12 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 9C612393A427 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1614610032; bh=XcDrrbXK4TjCI9wLmogHwl9jG0ItzlAFJf7CrlpoNbI=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=Vlx1jrzdIUYX1TL3Y3rjJxqACa2UafCR0l1doP7WcZrYnVIWMlk7eJAFeIQujQG2c 90CRc1QNAzcbaVALnz2tAznQomxL9SvqdqaflQbistqVJyTJvfDPi5d+o9PufEiVmr zy8hKQNxiHp7jgEl0R5kV2tQpyhRp4GR7ZiEzc04= Received: from NAM12-MW2-obe.outbound.protection.outlook.com (mail-mw2nam12on2070.outbound.protection.outlook.com [40.107.244.70]) by sourceware.org (Postfix) with ESMTPS id A797C393A41E for ; Mon, 1 Mar 2021 14:47:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org A797C393A41E ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=J5Px3Dx5FxvhjWBcoxZqfgU1SF1G0/ihdKVLkRQVU5gNwdjO++fnmM3oUbSFfW+OLUXShZaALtY1YJWog01ftQd+0K3t6PMzImaDZ5rNbcYYmpmcBsWXEft+/OzIBGNWN8fkLMQ/fCdPI+ihx39Z5NRE4eCzQZ/sTi7wfStlEcTfhnJjBFoVdsmhWmKq29X1D/fnR5EaJ794Tq6mCeOc7CwkBWbIQYaAAY/eXEt8XfKiE782mKMnGYJf3vQt9Sz2iNNeOBCDx1XAxtoXf0ogSplwWxFiEg9Yc773W01IqhXBH0lqUWNiw7OLc//bjXMFQwdzaGVj3LHbjkVDNOTVjw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=XcDrrbXK4TjCI9wLmogHwl9jG0ItzlAFJf7CrlpoNbI=; b=iF+Qt+dNZDkND39MGt2p8Wi/I87Y0nEdUCY+mP56BcX+pb0UKXmqzsGLg95aOg/leYfto6sty0Z7wxk17vcqvF1x988tF6GxPpnd8tMfzImHZfsFOMMLHCHIkPNgCFxJwgM8YWSJYJlSX2N5bM2HM3SmLcprVD9xOcn/KmnRJGA0o3hf3YNqBVwgrRTN1kGwN2a9tIMzZWUQIY4gJpWXxC6xl1vnWbW9MzDi9OLJim9iUXmxWfmTRkP6/JOpFLGOv1gudTN9aayUnt/YGAzi35hLgP4PXuPsHsQthU4xOrnsJWRETPzQx6x25QGTQbj1cjZB5wldyIYWK2nFQdVmCQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=amd.com; dmarc=pass action=none header.from=amd.com; dkim=pass header.d=amd.com; arc=none Received: from DM6PR12MB2762.namprd12.prod.outlook.com (2603:10b6:5:45::15) by DM6PR12MB3676.namprd12.prod.outlook.com (2603:10b6:5:1c7::29) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3890.19; Mon, 1 Mar 2021 14:46:57 +0000 Received: from DM6PR12MB2762.namprd12.prod.outlook.com ([fe80::31d8:f503:f7b2:f44]) by DM6PR12MB2762.namprd12.prod.outlook.com ([fe80::31d8:f503:f7b2:f44%3]) with mapi id 15.20.3868.033; Mon, 1 Mar 2021 14:46:57 +0000 To: gdb-patches@sourceware.org Subject: [PATCH 16/43] Simplify dwarf_expr_context class interface Date: Mon, 1 Mar 2021 14:45:53 +0000 Message-Id: <20210301144620.103016-17-Zoran.Zaric@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210301144620.103016-1-Zoran.Zaric@amd.com> References: <20210301144620.103016-1-Zoran.Zaric@amd.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Originating-IP: [2a00:23c7:5a85:6801:b4ed:fe7b:8064:d4d] X-ClientProxiedBy: AM0PR04CA0073.eurprd04.prod.outlook.com (2603:10a6:208:be::14) To DM6PR12MB2762.namprd12.prod.outlook.com (2603:10b6:5:45::15) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from localhost.localdomain (2a00:23c7:5a85:6801:b4ed:fe7b:8064:d4d) by AM0PR04CA0073.eurprd04.prod.outlook.com (2603:10a6:208:be::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3890.19 via Frontend Transport; Mon, 1 Mar 2021 14:46:56 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 6963b966-08e8-4e19-b320-08d8dcc0dcec X-MS-TrafficTypeDiagnostic: DM6PR12MB3676: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:10000; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Lig61aa1Y3au53q8PcHgUUzM5oEgH8H1boW6N2D3yvHDuovM384sS2w2SKYYIxXHkUTqkN5t4XK6VLoKyJy1vt3AnOiQr8ZWJuXw2oyOsD+HL70TGz2Y0V0TDPYGzXFH9wwtYrkFwS821UyTxLU7/7bAxGhr9fjmcpVD4UIRIRvcd6W4d2On3hWpHrV9bKZWuvDBEFmFh4uiatn7B0LGouDkr6xzcXUBjK2P6SIYMW2ZiCqdWeV4djvy7Kwt8uS4yQIeex5LgwKhioSue4JoWRFPCmO7WHTuU2RhaxS24eUYEqR6HBB3Nvl8X5UhA1izr3NXTUUndfaFXlWv+9KUOEOIjrQ1b6KwDvv5e09iQ7IHv1t2YA55xDUuoCtJktLrbENsRk9IVlk0TgTrapqrWvHrTtlIFfj+zWOwwXq+eOor0F6w2gwpacEH3jbaZmiqACt9VDYf9P5dW219q7UJppZ/YXT0IZzBnaqWiQzBHyqKerJ9JXSdQ+qfvuKAlbW2j6aCitNf1X3AO/DLkJ8TdA== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DM6PR12MB2762.namprd12.prod.outlook.com; PTR:; CAT:NONE; SFS:(4636009)(376002)(366004)(396003)(346002)(136003)(39860400002)(6666004)(16526019)(1076003)(83380400001)(2616005)(2906002)(186003)(36756003)(66946007)(316002)(66476007)(8936002)(52116002)(86362001)(6506007)(478600001)(5660300002)(4326008)(6486002)(8676002)(30864003)(6916009)(6512007)(66556008); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData: =?utf-8?B?RFF6aGxsZ3BlU2FXUy96Uk1PWEYvYVordWFzdmZ1SUFQWDFJVklsbTc5MkRJ?= =?utf-8?B?UU5GOEkzR3dDeEpWeFVFUmhZbHdzYzZmVXlBMmRlZzZ4SkExS0IxanFNR2w5?= =?utf-8?B?bHVNcnZ4MlptRHJtSHFCT1IrR21tTnJCN2VjcEhlWU4zUi9QaWRVU2g3ZkZ0?= =?utf-8?B?Vk5hSVh0dzU1TUJJWHIxQ1FnSTNUb1pIU1ZXZk0yV0RoanB4Vm9QSGtQNTNy?= =?utf-8?B?RFdEcGtNMWdubG1WT0RVWEY2a0xxc3ZVWmlKTmgxYkVBVkhhKzNvbmRWaVBx?= =?utf-8?B?eHp5b1lnNVVhLzRQWDEyWDJqbWJsSUpDUVJxdmprL1ZDb3ZXMy9jVW9tSm9a?= =?utf-8?B?Q0pTSlhGbUZTTGhZdVJna09tQy9NZWRTZVlKZ2pJSWZ2UjJGelRRbzVRTlhh?= =?utf-8?B?QTBrazFHL3NXdEFoR1hlNmFIRkptdGVXcUIyMWRCVHNHalFEaDJqL1FUMXVq?= =?utf-8?B?MTdGSk1RekF4Ylp3bE0xekRrM3ZCTTFFV0NDdHcxcEhXVlVxcUtPN1ZMdmhB?= =?utf-8?B?V1RLTjd1Z05sUXpITXhIZkxiWHVXZG9rZEswbldLaFAyRkh1RUlIdkxvRVlK?= =?utf-8?B?ZU5TRVA5Mm5ySDZ4RnRtUUFnUUhRSmJJNWlGWVFObzhJcCs4azVPZW02UzB5?= =?utf-8?B?eWxMbVUydXd6VUpLQTQ1V3RmenRITzl6cTRRZVlpU1FHNFhZSlhMKzY3b3B5?= =?utf-8?B?RDZYZjFBV3dwNkNXMFgzVHI4OS9UN3NqT0Job24zaVMxV2tLTG5ZeVRaTEpv?= =?utf-8?B?L0lMeUZ6Z0oyMndmd0hFNEYrMXBDQy9WYzZZaEhkdkJrNTBqRzNSSUFzcWZS?= =?utf-8?B?enprWnhVZ05mTlMxc3pkUVZET2FCdDQwYURKR3NlWXc4VjBoSWkzSUpEWkZu?= =?utf-8?B?b1Z5ak1zZm1EbFRBaFpBZHhBSklLdXNOcWFCaThrZ0xVQ3Q4UTl6NWZKWVpx?= =?utf-8?B?TFFONytZMHJPY2VtWS9BUW51QnZMM2R3ck04cGVjU2huMzczTFJLS0R6djJy?= =?utf-8?B?eGg3Z0Jyc2tMMzZ3VGdYYWNtNVdoTTFjYjljYzNheHM1UFJ5VThiZGlLSDZ2?= =?utf-8?B?KzhsaVFLYTI2QklRWStHcUQwUDFaUkp5RDBoZnpoOGlTbnZka1hUcjAvTndh?= =?utf-8?B?ZG5wY1VFUmVhM2tPNGtBRlJQVTVYejJibENDdXc5TDltN1NDY0VaQmFnT0Z4?= =?utf-8?B?ZVNwRXhnWmhsQWVGYmhhMFlKOXE2RVBKM3JUQ0dmNEpjOXlwOEVxSkFQZGtw?= =?utf-8?B?Ty9lUnMrM0RBN21Jc25EdWQxNlgrY3UyODQ2ZWhTYWVSd2lmamFwckI5U1N3?= =?utf-8?B?bGY3T0dQZXExM25yUUVLVkt2cko2THJNNVFSWXBzbW9Jc0ljK0twKzZyd0hG?= =?utf-8?B?MzZCSnFWYVkxbHNYM1JYOFNmYmhYQUtiTzQ0WXFkTndJd1FZUE5qMnlKN2Vr?= =?utf-8?B?SzJPNnAvNWY3bUMzaTBIVi9HQUJyd29lNTI4VDZveUdBOWdHZ1huVUdTeFNx?= =?utf-8?B?Qy84M2lvOFhBK1RhVFUzWlcreE1ENVg2d0F5NFR4THBTL2taVU5jclR5ZXpz?= =?utf-8?B?YU5JM0c3WENvaklOU21RbFJ2ZmRnSmg4OW92MzNKYlRZT3hYMzk3OGgvWVpm?= =?utf-8?B?c3BsOEw4aTVjR0dRVDIvYXd4Qm5IcXBUSmZBSEhZSThWeFlteTVCQWpLZU5J?= =?utf-8?B?cGtJOVhTek9sL1czK0dWdmpYUC9SazU3RDdvTnBLeEhlTDJRcTBaZFBnZlpD?= =?utf-8?B?VGRSSUY1K3NLUktiTEpzSFIxMDZ0RWRGY1o5eWNOTi83bWxPTlJISGgxWVZQ?= =?utf-8?B?L3hNSk9RL3NmaHpaa09YTWNISjBRMlBLczRvTDBSeHpZRGRnM1RvUklpUjRo?= =?utf-8?Q?nCFjpA9SFVPEY?= X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-Network-Message-Id: 6963b966-08e8-4e19-b320-08d8dcc0dcec X-MS-Exchange-CrossTenant-AuthSource: DM6PR12MB2762.namprd12.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 01 Mar 2021 14:46:57.4564 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: fSgksj/oXk5mlM9SHOjQH4NKCx0bjdXOhV+yIV9V6JMc3YR6VrI7Z2mjpYjrfriEaMzSIDeB3Jnl5jUhbr42Ew== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR12MB3676 X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Zoran Zaric via Gdb-patches Reply-To: Zoran Zaric Errors-To: gdb-patches-bounces@sourceware.org Sender: "Gdb-patches" From: Zoran Zaric Idea of this patch is to get a clean and simple public interface for the dwarf_expr_context class, looking like: - constructor, - destructor, - push_address method and - evaluate method. Where constructor should only ever require a target architecture information. This information is held in per object file (dwarf2_per_objfile) structure, so it makes sense to keep that structure as a constructor argument. It also makes sense to get the address size from that structure, but unfortunately that interface doesn’t exist at the moment, so the dwarf_expr_context class user needs to provide that information. The push_address method is used to push a CORE_ADDR as a value on top of the DWARF stack before the evaluation. This method can be later changed to push any struct value object on the stack. The evaluate method is the method that evaluates a DWARF expression and provides the evaluation result, in a form of a single struct value object that describes a location. To do this, the method requires a context of the evaluation, as well as expected result type information. If the type information is not provided, the DWARF generic type will be used instead. gdb/ChangeLog: * dwarf2/expr.c (dwarf_expr_context::dwarf_expr_context): Add address size argument. (dwarf_expr_context::read_mem): Change to use property_addr_info structure. (dwarf_expr_context::evaluate): New function. (dwarf_expr_context::execute_stack_op): Change to use property_addr_info structure. * dwarf2/expr.h (struct dwarf_expr_context): New evaluate declaration. Change eval and fetch_result method to private. * dwarf2/frame.c (execute_stack_op): Change to call evaluate method. * dwarf2/loc.c (dwarf2_evaluate_loc_desc_full): Change to call evaluate method. (dwarf2_locexpr_baton_eval): Change to call evaluate method. --- gdb/dwarf2/expr.c | 49 ++++++++++++++++++++++++++++++++++++---------- gdb/dwarf2/expr.h | 44 +++++++++++++++++++++++++++-------------- gdb/dwarf2/frame.c | 18 ++++------------- gdb/dwarf2/loc.c | 41 ++++++++++++-------------------------- 4 files changed, 85 insertions(+), 67 deletions(-) diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index b2248681899..1645f477d74 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -699,8 +699,11 @@ dwarf_expr_context::address_type () const /* Create a new context for the expression evaluator. */ -dwarf_expr_context::dwarf_expr_context (dwarf2_per_objfile *per_objfile) -: per_objfile (per_objfile) +dwarf_expr_context::dwarf_expr_context (dwarf2_per_objfile *per_objfile, + int addr_size) +: gdbarch (per_objfile->objfile->arch ()), + addr_size (addr_size), + per_objfile (per_objfile) { } @@ -825,13 +828,17 @@ dwarf_expr_context::read_mem (gdb_byte *buf, CORE_ADDR addr, return; /* Prefer the passed-in memory, if it exists. */ - CORE_ADDR offset = addr - obj_address; + if (addr_info != nullptr) + { + CORE_ADDR offset = addr - addr_info->addr; - if (offset < data_view.size () && offset + length <= data_view.size ()) + if (offset < addr_info->valaddr.size () + && offset + length <= addr_info->valaddr.size ()) { - memcpy (buf, data_view.data (), length); + memcpy (buf, addr_info->valaddr.data (), length); return; } + } read_memory (addr, buf, length); } @@ -874,8 +881,8 @@ dwarf_expr_context::push_dwarf_reg_entry_value caller_frame); scoped_restore save_per_cu = make_scoped_restore (&this->per_cu, caller_per_cu); - scoped_restore save_obj_addr = make_scoped_restore (&this->obj_address, - (CORE_ADDR) 0); + scoped_restore save_addr_info = make_scoped_restore (&this->addr_info, + nullptr); scoped_restore save_per_objfile = make_scoped_restore (&this->per_objfile, caller_per_objfile); @@ -1043,6 +1050,28 @@ dwarf_expr_context::fetch_result (struct type *type, return retval; } +/* See expr.h. */ + +struct value * +dwarf_expr_context::evaluate (const gdb_byte *addr, size_t len, + struct dwarf2_per_cu_data *per_cu, + struct frame_info *frame, + const struct property_addr_info *addr_info, + struct type *type, + struct type *subobj_type, + LONGEST subobj_offset) +{ + this->per_cu = per_cu; + this->frame = frame; + this->addr_info = addr_info; + + if (per_cu != nullptr) + this->ref_addr_size = per_cu->ref_addr_size (); + + eval (addr, len); + return fetch_result (type, subobj_type, subobj_offset); +} + /* Require that TYPE be an integral type; throw an exception if not. */ static void @@ -2313,11 +2342,11 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, case DW_OP_push_object_address: /* Return the address of the object we are currently observing. */ - if (this->data_view.data () == nullptr - && this->obj_address == 0) + if (addr_info == nullptr) error (_("Location address is not set.")); - result_val = value_from_ulongest (address_type, this->obj_address); + result_val + = value_from_ulongest (address_type, this->addr_info->addr); break; default: diff --git a/gdb/dwarf2/expr.h b/gdb/dwarf2/expr.h index a0ac21f2ed1..d1374068732 100644 --- a/gdb/dwarf2/expr.h +++ b/gdb/dwarf2/expr.h @@ -119,19 +119,30 @@ struct dwarf_stack_value its current state and its callbacks. */ struct dwarf_expr_context { - dwarf_expr_context (dwarf2_per_objfile *per_objfile); + /* We should ever only pass in the PER_OBJFILE, while the ADDR_SIZE + information should be retrievable from there. The PER_OBJFILE + contains a pointer to the PER_BFD information anyway and the + address size information must be the same for the whole BFD. */ + dwarf_expr_context (struct dwarf2_per_objfile *per_objfile, + int addr_size); virtual ~dwarf_expr_context () = default; void push_address (CORE_ADDR value, bool in_stack_memory); - void eval (const gdb_byte *addr, size_t len); - /* Fetch the result of the expression evaluation in a form of - a struct value, where TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET - describe the source level representation of that result. */ - struct value *fetch_result (struct type *type = nullptr, - struct type *subobj_type = nullptr, - LONGEST subobj_offset = 0); + /* Evaluate the expression at ADDR (LEN bytes long) in a given PER_CU + FRAME context. Where TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET describe + expected struct value representation of the evaluation result. + The ADDR_INFO property can be specified to override the range of + memory addresses with the passed in buffer. */ + struct value *evaluate (const gdb_byte *addr, size_t len, + struct dwarf2_per_cu_data *per_cu, + struct frame_info *frame, + const struct property_addr_info *addr_info = nullptr, + struct type *type = nullptr, + struct type *subobj_type = nullptr, + LONGEST subobj_offset = 0); +private: /* The stack of values. */ std::vector stack; @@ -196,14 +207,10 @@ struct dwarf_expr_context /* Compilation unit used for the evaluation. */ struct dwarf2_per_cu_data *per_cu = nullptr; - /* Object address used for the evaluation. */ - CORE_ADDR obj_address = 0; - - /* The data that was passed in. */ - gdb::array_view data_view; - -private: + /* Property address info used for the evaluation. */ + const struct property_addr_info *addr_info = nullptr; + void eval (const gdb_byte *addr, size_t len); struct type *address_type () const; void push (struct value *value, bool in_stack_memory); bool stack_empty_p () const; @@ -214,6 +221,13 @@ struct dwarf_expr_context CORE_ADDR fetch_address (int n); bool fetch_in_stack_memory (int n); + /* Fetch the result of the expression evaluation in a form of + a struct value, where TYPE, SUBOBJ_TYPE and SUBOBJ_OFFSET + describe the source level representation of that result. */ + struct value *fetch_result (struct type *type, + struct type *subobj_type, + LONGEST subobj_offset); + /* Return the location expression for the frame base attribute, in START and LENGTH. The result must be live until the current expression evaluation is complete. */ diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c index 21daecec61c..07667c3dee5 100644 --- a/gdb/dwarf2/frame.c +++ b/gdb/dwarf2/frame.c @@ -228,26 +228,16 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size, struct frame_info *this_frame, CORE_ADDR initial, int initial_in_stack_memory, dwarf2_per_objfile *per_objfile) { - dwarf_expr_context ctx (per_objfile); + dwarf_expr_context ctx (per_objfile, addr_size); scoped_value_mark free_values; - ctx.frame = this_frame; - ctx.gdbarch = get_frame_arch (this_frame); - ctx.addr_size = addr_size; - ctx.ref_addr_size = -1; - ctx.push_address (initial, initial_in_stack_memory); - ctx.eval (exp, len); - - CORE_ADDR result; - struct value *result_val = ctx.fetch_result (); + struct value *result_val = ctx.evaluate (exp, len, nullptr, this_frame); if (VALUE_LVAL (result_val) == lval_memory) - result = value_address (result_val); + return value_address (result_val); else - result = value_as_address (result_val); - - return result; + return value_as_address (result_val); } diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c index e2d6b32717b..55445021ad4 100644 --- a/gdb/dwarf2/loc.c +++ b/gdb/dwarf2/loc.c @@ -1430,8 +1430,6 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, struct type *subobj_type, LONGEST subobj_byte_offset) { - struct value *retval; - if (subobj_type == NULL) { subobj_type = type; @@ -1443,22 +1441,15 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame, if (size == 0) return allocate_optimized_out_value (subobj_type); - dwarf_expr_context ctx (per_objfile); - ctx.frame = frame; - ctx.per_cu = per_cu; - ctx.obj_address = 0; + dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); + struct value *retval; scoped_value_mark free_values; - ctx.gdbarch = per_objfile->objfile->arch (); - ctx.addr_size = per_cu->addr_size (); - ctx.ref_addr_size = per_cu->ref_addr_size (); - try { - ctx.eval (data, size); - retval = ctx.fetch_result (type, subobj_type, - subobj_byte_offset); + retval = ctx.evaluate (data, size, per_cu, frame, nullptr, type, + subobj_type, subobj_byte_offset); } catch (const gdb_exception_error &ex) { @@ -1528,30 +1519,24 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton, return 0; dwarf2_per_objfile *per_objfile = dlbaton->per_objfile; - dwarf_expr_context ctx (per_objfile); + struct dwarf2_per_cu_data *per_cu = dlbaton->per_cu; + dwarf_expr_context ctx (per_objfile, per_cu->addr_size ()); struct value *result; scoped_value_mark free_values; - ctx.frame = frame; - ctx.per_cu = dlbaton->per_cu; - if (addr_stack != nullptr) + if (push_initial_value) { - ctx.obj_address = addr_stack->addr; - ctx.data_view = addr_stack->valaddr; + if (addr_stack != nullptr) + ctx.push_address (addr_stack->addr, false); + else + ctx.push_address (0, false); } - ctx.gdbarch = per_objfile->objfile->arch (); - ctx.addr_size = dlbaton->per_cu->addr_size (); - ctx.ref_addr_size = dlbaton->per_cu->ref_addr_size (); - - if (push_initial_value) - ctx.push_address (ctx.obj_address, false); - try { - ctx.eval (dlbaton->data, dlbaton->size); - result = ctx.fetch_result (); + result = ctx.evaluate (dlbaton->data, dlbaton->size, + per_cu, frame, addr_stack); } catch (const gdb_exception_error &ex) { -- 2.17.1