From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id UJDIKYH+PGAGJAAAWB0awg (envelope-from ) for ; Mon, 01 Mar 2021 09:47:29 -0500 Received: by simark.ca (Postfix, from userid 112) id 55A121E590; Mon, 1 Mar 2021 09:47:28 -0500 (EST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-1.1 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,MAILING_LIST_MULTI,MSGID_FROM_MTA_HEADER,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.2 Received: from sourceware.org (server2.sourceware.org [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 2C40B1EF64 for ; Mon, 1 Mar 2021 09:47:21 -0500 (EST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id E214D393A434; Mon, 1 Mar 2021 14:47:18 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E214D393A434 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1614610038; bh=jScnix3TyFDrckDgS6oJBFBd7NLoxEYt/iBWRGH6jEk=; 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=OojXlGWzGnnwGRmtXGNcISqOwiFcWqgyyndtN43qoU9VzDOv9iZrPay1C5k61DWTf vbGsexSUf8OKocE6SZVEvjaEoe+FeRJh3O59zdCf0Z/2i1hi3xMyyMDkOs2dRn3Jd8 rQue8eaPJxT5JnFNUGnjUjKCjCpSozshaoNrBFVc= Received: from NAM12-MW2-obe.outbound.protection.outlook.com (mail-mw2nam12on2056.outbound.protection.outlook.com [40.107.244.56]) by sourceware.org (Postfix) with ESMTPS id 33937393A42E for ; Mon, 1 Mar 2021 14:47:15 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 33937393A42E ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=akE7TXkMJYOPqdZ3lK1mPZlgfdSW+AdbdQNW0PWyzpVHYkri97aXCjZzCRzal4NjeR802vuZ9azg1HJcBg9D+5RPxfA63tWgnOcYleI15chrKa0mc+n0Q5aCoFvoAknZ9yXxf9lD+lDjSJ2eQgmSwHr28OwcJiyJnw6cS10avhAYtyKL1g/gociWZbvInjGzsN0XMVyTQUTJzcPaLfGIyc+7kKuCzGWkecfs5ZfdEIIRNwd+8JsjsEJ9B7SEW+P+aG8qGc972PnK8vcjXuLdCviP7Uckw+grS1asg2cRx3jYIbo9aJ0+dw716ZVAdoJPwPirE/uT7t1FefyRl8bWmA== 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=jScnix3TyFDrckDgS6oJBFBd7NLoxEYt/iBWRGH6jEk=; b=iS/ABcOq+CMUfiGATCZJOTb3uyAxyoqPov2b0kwi1SohMG0eWlItNKm+uCnRYeXOLqrRzCiwTw41GGq/K71AdCJzg8Sq3e87J0Aj2ICMJpGHdVgfDorKToZ+KuRvK+2Xx43qyWv1u2Gq+qDHr93oLsQAdyJKdXl40qihd/YJRgDsuiNS0M2E0upamviUjGL6Q52MbAxiGePviC8dC8G0CbN2rPhmmvFN2TJHd+Vykek/YBPlluYkOfuAXJBH+CX0wR7rIfYqk7XtXu+5mIwflTYJtG+gtuJ+zBR0AguBys0wS1aIp1j9cXuOn2Md0+s6kCrIsuToZfeQKDMGJMAg7g== 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:47:07 +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:47:05 +0000 To: gdb-patches@sourceware.org Subject: [PATCH 23/43] Add read method to location description classes Date: Mon, 1 Mar 2021 14:46:00 +0000 Message-Id: <20210301144620.103016-24-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 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:47:04 +0000 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 9526afc5-65fb-4432-c59b-08d8dcc0e174 X-MS-TrafficTypeDiagnostic: DM6PR12MB3676: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:2043; X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 0FBMpmRqgdUMxbYKlubTUHJJAC+cE+hGvJflFm+dAxKYQuyd3Q3uTB4iOj3bsd3lI32a0UGmenrnntwLRk11jGbSvs53rw3LN7bdtrP6G5TEnm0VFwIZ+1vMG6ANWJ5rQ3PEdtzrApzq3KdX3tcHz3/3tv6r+qpRR+asU/z+FflCZXvwHXptBj2hd4ZMmVJ0xIOL3T0jZ/RBhgjQUpUfPTosCSJtnyDj1mUSk0SF+pJuCI+xFf2Mie7wdC4BE6zWZe11dkIepaOHA0yKgJSWqge9+bWdCF9QbhwrjPnkrn7CrySKQkgtdKxExnIw7ofYG5HO8y656GbHxA5o+G2YuLMZF5UP6i8pu+6PZCya9ut7Y2Wi3zpORiZlG1JjrugkaxM9CD5HJiNom8r+cBPT06iebCwTo3H/3eOoNEftuE+d4S2LDuCoT6TwqoXsK6vQFNjqpV6XUnZf7XCWLpixgCgA1rfK745WnydQOyQFR+gIfApsVJW9aAUyi16hqBD11J8fQgNLxUld/EnK78JTEEx057LfUHtH58Y8pjkrSsfjMRbvHhozCyxWKsT4SF+RH9bdIJzNsvuNtiBPzQt5FQ== 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)(69590400012)(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: =?us-ascii?Q?bv/vrie4RlbhwtVLNuN5o+IEWVI6gf/qCLY0DP2kBkNMezmLHY8//3oKsbkv?= =?us-ascii?Q?4+xVjtViK9KcOVFa5fzn+JNyx8h4C4Kwtlnq7rrmeUA15NmLmFeSmUePB6WF?= =?us-ascii?Q?LYpghVdadxfimLb9RZzDcWJfdqBr3O15rAhCdv0EI7O/37FsLVqAky3dWZUp?= =?us-ascii?Q?eDIwTAv6AUFJP2YGt8e9NhPgp7prjhtsrQpdaP+3ZKo3k4iDl13Nzm3Usx1p?= =?us-ascii?Q?V/XZbOlf/qzxswf99hph9Q0to5bPt884pp9iZx5ZUX4gZn1U5rxx8YA0JdE3?= =?us-ascii?Q?fSPzWHGtIjbbJc8EAusJvvDGXteNZpvvUg/Xc20t/3D/3EUbXom8OzMkmadg?= =?us-ascii?Q?1u7vBaa2sxEDzem3vpwIbZ/2OjLljNnXHJt9GN74WoaLGwPTuufseiKFRC8A?= =?us-ascii?Q?2EL9fzv+1pSLqwgO7GAeqMsnNj9/AFELRTdAy0imDGWvgSdl2UBie5jK+6vs?= =?us-ascii?Q?11vZyVjr1bIk4y2iKksP8FVU6j7MH0LyaFX+knESSyb+aidUc1G82TqwlzRL?= =?us-ascii?Q?m9oi9l/8bM+QbX2l7plDU/tP5PnMM6QuBgprR2GwgOwwkbV4R/Wue/Q3YfKv?= =?us-ascii?Q?PaadsvJKq1LQ+oPmedXW2967Ft4clWWT38rzX30Cto7UkmNgPPbz7IkJ7oSA?= =?us-ascii?Q?oxfKWkTJ9dQ87pNdHY9WraONYoCU0ALxAkbzE0sdsdQRR5GiTZi3uAx+ddzd?= =?us-ascii?Q?xkDK3oPQzSSAqI6n0xVblcupSTiNAJ7x9E5YVq0h+AZ26kZfYoIii+5V5kax?= =?us-ascii?Q?YMVL4BADgNrgL7ntl+izIuYfYa9edHb9zBP92iFMvFau6/D19Xvko1/DkYaj?= =?us-ascii?Q?6C/V0e0EYu2bJaY1SZfv6O50uICzIui4nuG4sHJDs0G4yrpxB6rffr3C3IuK?= =?us-ascii?Q?yh0y8xrF+txTcJp2sPNHmUQ76TLMb0RSdda5EFs0onz99Gsa3NMYqVchDV3E?= =?us-ascii?Q?KT7Wdo+84e5q/dzEA42/hypvDMJzo+117RIxqlx8hFsp3rLKNS/Q1qcO41lN?= =?us-ascii?Q?Lwyp9PwTuBijzRFFiAzWJQaS6ifzEOH3B7gZJtylFfYeTdMQM4gSSX9tkHup?= =?us-ascii?Q?6CIG1CvYYWpsiojz5UYwTZMBF1W4eDCr4Y9I6ibCEqwo6htOpfx10Dwo4R3S?= =?us-ascii?Q?zsEmE6VRqwfTG8sw3RoYwBHJ6x5k/De645b3XfdIIxw12NTwNSOA8N5r/DF0?= =?us-ascii?Q?cfKyFA39PjgN3/NEh1rnMh19x6Cq8mJnmoy6lxgX7XHgDK4DifPPGfUGnAMe?= =?us-ascii?Q?WPXZNBdBx6Hca6Raqxoa835KI9UpAQcfa64PBue4bn3JW8VjZ1/RkecQolLr?= =?us-ascii?Q?6sYzaJtRTncufwc83bJoQYwl44x7ilF0bF1HNdxmnu2rlNbIzx7XWSf+DXFx?= =?us-ascii?Q?gQJW+X4vMjUeBm5jAOKGQ+EjqiXw?= X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-Network-Message-Id: 9526afc5-65fb-4432-c59b-08d8dcc0e174 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:47:04.9991 (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: aWlTvEzowL6W0smOmN4YnriPO3JCfkXWn2ZinqG6cvQoWdmrjAxg6fAxfNDPWIkAluD0h4roSPfoU+GpI7s3bw== 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" After adding the interface for register and memory location access, a new method for reading from any location derived from a dwarf_location class, can now be defined. In the case of implicit pointer location description the existing indirect_synthetic_pointer interface requiers a type of the pointer to be specified, so for a generic read interface the only type that makes sense is the DWARF generic type. This means that the existing address_type method of a dwarf_expr_context class needs to be exposed outside of that class. gdb/ChangeLog: * dwarf2/expr.c (dwarf_location::read): New method. (dwarf_undefined::read): New method. (dwarf_memory::read): New method. (dwarf_register::read): New method. (dwarf_implicit::read): New method. (dwarf_implicit_pointer::read): New method. (dwarf_composite::read): New method. (dwarf_expr_context::address_type): Change to use the new address_type function. (address_type): New function. --- gdb/dwarf2/expr.c | 305 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 283 insertions(+), 22 deletions(-) diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index 69be36fcf2d..35b2efa6cb5 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -285,6 +285,37 @@ write_to_memory (CORE_ADDR address, const gdb_byte *buffer, length, buffer); } +/* Return the type used for DWARF operations where the type is + generic in the DWARF spec, the ARCH is a target architecture. + of the type and ADDR_SIZE is expected size of the address. + Only certain sizes are supported. */ + +static struct type * +address_type (struct gdbarch *gdbarch, int addr_size) +{ + struct dwarf_gdbarch_types *types + = (struct dwarf_gdbarch_types *) gdbarch_data (gdbarch, + dwarf_arch_cookie); + int ndx; + + if (addr_size == 2) + ndx = 0; + else if (addr_size == 4) + ndx = 1; + else if (addr_size == 8) + ndx = 2; + else + error (_("Unsupported address size in DWARF expressions: %d bits"), + 8 * addr_size); + + if (types->dw_types[ndx] == NULL) + types->dw_types[ndx] + = arch_integer_type (gdbarch, HOST_CHAR_BIT * addr_size, + 0, ""); + + return types->dw_types[ndx]; +} + class dwarf_location; class dwarf_memory; class dwarf_value; @@ -369,6 +400,27 @@ class dwarf_location : public dwarf_entry return std::shared_ptr (nullptr); } + /* Read contents from the descripbed location. + + The read operation is performed in the context of a FRAME. + BIT_SIZE is the number of bits to read. The data read is copied + to the caller-managed buffer BUF. BIG_ENDIAN defines the + endianness of the target. BITS_TO_SKIP is a bit offset into the + location and BUF_BIT_OFFSET is buffer BUF's bit offset. + LOCATION_BIT_LIMIT is a maximum number of bits that location can + hold, where value zero signifies that there is no such + restriction. + + Note that some location types can be read without a FRAME context. + + If the location is optimized out or unavailable, the OPTIMIZED and + UNAVAILABLE outputs are set accordingly. */ + virtual void read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, + int *unavailable) const = 0; + protected: /* Architecture of the location. */ struct gdbarch *m_arch; @@ -475,6 +527,14 @@ class dwarf_undefined : public dwarf_location LONGEST bit_suboffset = 0) : dwarf_location (arch, offset, bit_suboffset) {} + + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const override + { + *unavailable = 0; + *optimized = 1; + } }; class dwarf_memory : public dwarf_location @@ -493,6 +553,11 @@ class dwarf_memory : public dwarf_location std::shared_ptr to_value (struct type *type) override; + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, + size_t location_bit_limit, bool big_endian, + int *optimized, int *unavailable) const override; + private: /* True if the location belongs to a stack memory region. */ bool m_stack; @@ -504,6 +569,46 @@ dwarf_memory::to_value (struct type *type) return std::make_shared (m_offset, type); } +void +dwarf_memory::read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const +{ + LONGEST total_bits_to_skip = bits_to_skip; + CORE_ADDR start_address + = m_offset + (m_bit_suboffset + total_bits_to_skip) / HOST_CHAR_BIT; + gdb::byte_vector temp_buf; + + *optimized = 0; + total_bits_to_skip += m_bit_suboffset; + + if (total_bits_to_skip % HOST_CHAR_BIT == 0 + && bit_size % HOST_CHAR_BIT == 0 + && buf_bit_offset % HOST_CHAR_BIT == 0) + { + /* Everything is byte-aligned, no buffer needed. */ + read_from_memory (start_address, + buf + buf_bit_offset / HOST_CHAR_BIT, + bit_size / HOST_CHAR_BIT, m_stack, unavailable); + } + else + { + LONGEST this_size = bits_to_bytes (total_bits_to_skip, bit_size); + temp_buf.resize (this_size); + + /* Can only read from memory on byte granularity so an + additional buffer is required. */ + read_from_memory (start_address, temp_buf.data (), this_size, + m_stack, unavailable); + + if (!*unavailable) + copy_bitwise (buf, buf_bit_offset, temp_buf.data (), + total_bits_to_skip % HOST_CHAR_BIT, + bit_size, big_endian); + } +} + /* Register location description entry. */ class dwarf_register : public dwarf_location @@ -515,11 +620,55 @@ class dwarf_register : public dwarf_location m_regnum (regnum) {} + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const override; + private: /* DWARF register number. */ unsigned int m_regnum; }; +void +dwarf_register::read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const +{ + LONGEST total_bits_to_skip = bits_to_skip; + size_t read_bit_limit = location_bit_limit; + int reg = dwarf_reg_to_regnum_or_error (m_arch, m_regnum); + ULONGEST reg_bits = HOST_CHAR_BIT * register_size (m_arch, reg); + gdb::byte_vector temp_buf; + + if (big_endian) + { + if (!read_bit_limit || reg_bits <= read_bit_limit) + read_bit_limit = bit_size; + + total_bits_to_skip += reg_bits - (m_offset * HOST_CHAR_BIT + + m_bit_suboffset + read_bit_limit); + } + else + total_bits_to_skip += m_offset * HOST_CHAR_BIT + m_bit_suboffset; + + LONGEST this_size = bits_to_bytes (total_bits_to_skip, bit_size); + temp_buf.resize (this_size); + + if (frame == NULL) + internal_error (__FILE__, __LINE__, _("invalid frame information")); + + /* Can only read from a register on byte granularity so an + additional buffer is required. */ + read_from_register (frame, reg, total_bits_to_skip / HOST_CHAR_BIT, + temp_buf, optimized, unavailable); + + /* Only copy data if valid. */ + if (!*optimized && !*unavailable) + copy_bitwise (buf, buf_bit_offset, temp_buf.data (), + total_bits_to_skip % HOST_CHAR_BIT, bit_size, big_endian); +} + /* Implicit location description entry. Describes a location description not found on the target but instead saved in a gdb-allocated buffer. */ @@ -539,6 +688,10 @@ class dwarf_implicit : public dwarf_location m_byte_order = byte_order; } + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const override; + private: /* Implicit location contents as a stream of bytes in target byte-order. */ gdb::unique_xmalloc_ptr m_contents; @@ -550,6 +703,45 @@ class dwarf_implicit : public dwarf_location enum bfd_endian m_byte_order; }; +void +dwarf_implicit::read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const +{ + ULONGEST implicit_bit_size = HOST_CHAR_BIT * m_size; + LONGEST total_bits_to_skip = bits_to_skip; + size_t read_bit_limit = location_bit_limit; + + *optimized = 0; + *unavailable = 0; + + /* Cut off at the end of the implicit value. */ + if (m_byte_order == BFD_ENDIAN_BIG) + { + if (!read_bit_limit || read_bit_limit > implicit_bit_size) + read_bit_limit = bit_size; + + total_bits_to_skip + += implicit_bit_size - (m_offset * HOST_CHAR_BIT + + m_bit_suboffset + read_bit_limit); + } + else + total_bits_to_skip += m_offset * HOST_CHAR_BIT + m_bit_suboffset; + + if (total_bits_to_skip >= implicit_bit_size) + { + (*unavailable) = 1; + return; + } + + if (bit_size > implicit_bit_size - total_bits_to_skip) + bit_size = implicit_bit_size - total_bits_to_skip; + + copy_bitwise (buf, buf_bit_offset, m_contents.get (), + total_bits_to_skip, bit_size, big_endian); +} + /* Implicit pointer location description entry. */ class dwarf_implicit_pointer : public dwarf_location @@ -565,6 +757,10 @@ class dwarf_implicit_pointer : public dwarf_location m_addr_size (addr_size), m_die_offset (die_offset) {} + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const override; + private: /* Per object file data of the implicit pointer. */ dwarf2_per_objfile *m_per_objfile; @@ -579,6 +775,44 @@ class dwarf_implicit_pointer : public dwarf_location sect_offset m_die_offset; }; +void +dwarf_implicit_pointer::read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, + int *unavailable) const +{ + struct frame_info *actual_frame = frame; + LONGEST total_bits_to_skip = bits_to_skip + m_bit_suboffset; + + if (actual_frame == nullptr) + actual_frame = get_selected_frame (_("No frame selected.")); + + struct type *type + = address_type (get_frame_arch (actual_frame), m_addr_size); + + struct value *value + = indirect_synthetic_pointer (m_die_offset, m_offset, m_per_cu, + m_per_objfile, actual_frame, type); + + gdb_byte *value_contents + = value_contents_raw (value) + total_bits_to_skip / HOST_CHAR_BIT; + + if (total_bits_to_skip % HOST_CHAR_BIT == 0 + && bit_size % HOST_CHAR_BIT == 0 + && buf_bit_offset % HOST_CHAR_BIT == 0) + { + memcpy (buf + buf_bit_offset / HOST_CHAR_BIT, + value_contents, bit_size / HOST_CHAR_BIT); + } + else + { + copy_bitwise (buf, buf_bit_offset, value_contents, + total_bits_to_skip % HOST_CHAR_BIT, + bit_size, big_endian); + } +} + /* Composite location description entry. */ class dwarf_composite : public dwarf_location @@ -595,6 +829,10 @@ class dwarf_composite : public dwarf_location m_pieces.emplace_back (location, bit_size); } + void read (struct frame_info *frame, gdb_byte *buf, int buf_bit_offset, + size_t bit_size, LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const override; + private: /* Composite piece that contains a piece location description and it's size. */ @@ -617,6 +855,50 @@ class dwarf_composite : public dwarf_location std::vector m_pieces; }; +void +dwarf_composite::read (struct frame_info *frame, gdb_byte *buf, + int buf_bit_offset, size_t bit_size, + LONGEST bits_to_skip, size_t location_bit_limit, + bool big_endian, int *optimized, int *unavailable) const +{ + unsigned int pieces_num = m_pieces.size (); + LONGEST total_bits_to_skip = bits_to_skip; + unsigned int i; + + total_bits_to_skip += m_offset * HOST_CHAR_BIT + m_bit_suboffset; + + /* Skip pieces covered by the read offset. */ + for (i = 0; i < pieces_num; i++) + { + LONGEST piece_bit_size = m_pieces[i].m_size; + + if (total_bits_to_skip < piece_bit_size) + break; + + total_bits_to_skip -= piece_bit_size; + } + + for (; i < pieces_num; i++) + { + LONGEST piece_bit_size = m_pieces[i].m_size; + LONGEST actual_bit_size = piece_bit_size; + + if (actual_bit_size > bit_size) + actual_bit_size = bit_size; + + m_pieces[i].m_location->read (frame, buf, buf_bit_offset, + actual_bit_size, total_bits_to_skip, + piece_bit_size, big_endian, + optimized, unavailable); + + if (bit_size == actual_bit_size || *optimized || *unavailable) + break; + + buf_bit_offset += actual_bit_size; + bit_size -= actual_bit_size; + } +} + struct piece_closure { /* Reference count. */ @@ -1198,28 +1480,7 @@ sect_variable_value (sect_offset sect_off, struct type * dwarf_expr_context::address_type () const { - struct dwarf_gdbarch_types *types - = (struct dwarf_gdbarch_types *) gdbarch_data (this->gdbarch, - dwarf_arch_cookie); - int ndx; - - if (this->addr_size == 2) - ndx = 0; - else if (this->addr_size == 4) - ndx = 1; - else if (this->addr_size == 8) - ndx = 2; - else - error (_("Unsupported address size in DWARF expressions: %d bits"), - 8 * this->addr_size); - - if (types->dw_types[ndx] == NULL) - types->dw_types[ndx] - = arch_integer_type (this->gdbarch, - 8 * this->addr_size, - 0, ""); - - return types->dw_types[ndx]; + return ::address_type (this->gdbarch, this->addr_size); } /* Create a new context for the expression evaluator. */ -- 2.17.1