From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM04-BN8-obe.outbound.protection.outlook.com (mail-bn8nam08on2053.outbound.protection.outlook.com [40.107.100.53]) by sourceware.org (Postfix) with ESMTPS id 0B4463858411 for ; Fri, 5 Nov 2021 11:39:17 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 0B4463858411 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=M4dOLFVPFNbR5kbpPy6mwdR/APJMpCYrpV1BhinMXvdYpZwcXgUwqopj0V41E0l4U3THn5BbubXDs6/kmiXUvB0h3KHHizxooLiDvBnoJNawY2n58AmctwrbUep0rTP+QC54XbzDwec9tSGXIbDPvO6jwzIet1+5DS3IvIvXn9TOmNRNoyeoaan/zr1NBb9SDELV6zeUl3m9FYY9lc2Q1lZlJgM8rWM8NvBZReRUDoK+JEOYvgDV/mr7+2CGhKmDuZL3HSvtYRWQqMiVNsL8dPd9JG3JkLnRlu4b/b9YrxlcZl4oiMMnYg4uxC9QzdMctTjyycfTXilSZV+qMtq83g== 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-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=+SH3ERx2Cab8g3nm28wgOkRkAELex8ou7H2CT+LVWtI=; b=IsfNmMzbfHqqBAiH4lWg2ffxHvAAPVFPGSnFFrBnqh20HbK9Af72DMFYApb5eT4mMR5w2VU61Rqjgc3167TlX4dsElL7cfzMVEpmZTqjk1U5Ps7/kDKjp/SdJR/fjnRxznTxjCXPuoUttTVdF3hAakvp13+4jCHo++zTXERk8/A0v5qrNMRk3AsuIswvAr7l4Xfk3i/XujBUU0GTxtJY3Yzc4gvznC+JXhxdqUk8Y9Gpb8z8NVGtDcAPlCahG7lYb6zx6O0mGu2wF4xp0b6NVVDFIoMm7tBrYq2ymv/j8Vv/0VO85fF/hqFFCoSLe0Jph4eqeiktRsFhktEUAvUBWQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=sourceware.org smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none Received: from MW4PR04CA0151.namprd04.prod.outlook.com (2603:10b6:303:85::6) by MN2PR12MB4336.namprd12.prod.outlook.com (2603:10b6:208:1df::9) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4669.11; Fri, 5 Nov 2021 11:39:15 +0000 Received: from CO1NAM11FT047.eop-nam11.prod.protection.outlook.com (2603:10b6:303:85:cafe::a4) by MW4PR04CA0151.outlook.office365.com (2603:10b6:303:85::6) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4669.13 via Frontend Transport; Fri, 5 Nov 2021 11:39:15 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; sourceware.org; dkim=none (message not signed) header.d=none;sourceware.org; dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; Received: from SATLEXMB04.amd.com (165.204.84.17) by CO1NAM11FT047.mail.protection.outlook.com (10.13.174.132) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.4669.10 via Frontend Transport; Fri, 5 Nov 2021 11:39:14 +0000 Received: from localhost.localdomain (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2308.15; Fri, 5 Nov 2021 06:39:10 -0500 From: Zoran Zaric To: Subject: [PATCH v4 06/28] Add read method to location description classes Date: Fri, 5 Nov 2021 11:38:27 +0000 Message-ID: <20211105113849.118800-7-zoran.zaric@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20211105113849.118800-1-zoran.zaric@amd.com> References: <20211105113849.118800-1-zoran.zaric@amd.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Originating-IP: [10.180.168.240] X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 8584d09e-2ef4-420e-1961-08d9a050e510 X-MS-TrafficTypeDiagnostic: MN2PR12MB4336: X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:2043; X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: +eDc7cM2g7Uqr5BZhZz4c3E1vKjMrm0zb5OhIbnJXLKM6BwKrxS3uEn5+XaNd1svyRaW75lWimI/zHVp7JxHikgFbUvPGdJOJ/AYeJW4/YEC8SG9AK8DnWsPx9D+aOyqrBm8TgW2epZicgPnEjHj67tyJZc3u7gaMeU6M/dsQlnQ+xQrxw4ZNqkur5eF6bBcDNdC4TWIeSD0pHNbrUCvM27OBkt5CVtO27dwZApMdg3QWdMXjBG/GZS064A8vhGS/3WS5UK8AkNJuAJTFUW3KAibDAU7GSWjw6k8K4LdQjTJjdyVsWBcAA6Y8FkOtDltfcL5uZP13UyAGDgWQpieCM+vbJ21+di+MjMdPduZU589POkXPHF0HgKNc4JJCMiKQFBXWM8g1PP3kv6VCO3aKAeogra07eLu8iKI6xKSINWA3SauX/3lTGfLxSQ7x/YfEpDighlM5BwvrlzqhDAcmoST9JYpUEmuN3p5itbWEM8q5Il5OQirH4obpoocBGwMZUPh4cBOMy0wA8x7/jQrjl7G/lT5MxXGMl4gyVW1drQ9EN5lPQyMEY3/rECz919o+XLXHHaXGVvqCvcze15nenbpYFMD/7O8ECIaTrehwXljyDxeAYxXjQ3NyzO4RhsBgYWm5bvDF9f8VIXJTBaz9QYFrwjm8k+Xp//GW04quXwxgBz28XGaErXxcN0x92I3JCUXf7FbrKnBRoDxQhVhcyKr7p8sKn8TuU501uw63lA= X-Forefront-Antispam-Report: CIP:165.204.84.17; CTRY:US; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:SATLEXMB04.amd.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(4636009)(36840700001)(46966006)(26005)(86362001)(508600001)(186003)(36860700001)(426003)(2616005)(8676002)(336012)(6916009)(70586007)(70206006)(6666004)(16526019)(5660300002)(44832011)(8936002)(4326008)(2906002)(30864003)(316002)(1076003)(82310400003)(83380400001)(356005)(81166007)(36756003)(47076005)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Nov 2021 11:39:14.8782 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 8584d09e-2ef4-420e-1961-08d9a050e510 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d; Ip=[165.204.84.17]; Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: CO1NAM11FT047.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: MN2PR12MB4336 X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org 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: , X-List-Received-Date: Fri, 05 Nov 2021 11:39:19 -0000 From: Zoran Zaric 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, 284 insertions(+), 21 deletions(-) diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index e9e5e55ca61..f2349208412 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -279,6 +279,36 @@ 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 type * +address_type (gdbarch *arch, int addr_size) +{ + dwarf_gdbarch_types *types + = (dwarf_gdbarch_types *) gdbarch_data (arch, 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"), + HOST_CHAR_BIT * addr_size); + + if (types->dw_types[ndx] == nullptr) + types->dw_types[ndx] + = arch_integer_type (arch, HOST_CHAR_BIT * addr_size, + 0, ""); + + return types->dw_types[ndx]; +} + class dwarf_location; class dwarf_value; @@ -340,6 +370,27 @@ class dwarf_location : public dwarf_entry ill_formed_expression (); } + /* Read contents from the described 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 (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. */ gdbarch *m_arch; @@ -422,6 +473,14 @@ class dwarf_undefined final : public dwarf_location dwarf_undefined (gdbarch *arch) : dwarf_location (arch, 0) {} + + void read (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 final : public dwarf_location @@ -438,6 +497,11 @@ class dwarf_memory final : public dwarf_location dwarf_value_up to_value (struct type *type) const override; + void read (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; @@ -464,6 +528,46 @@ dwarf_memory::to_value (struct type *type) const return make_unique (m_offset, type); } +void +dwarf_memory::read (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 final : public dwarf_location @@ -473,11 +577,56 @@ class dwarf_register final : public dwarf_location : dwarf_location (arch, offset), m_regnum (regnum) {} + void read (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 (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; + gdbarch *frame_arch = get_frame_arch (frame); + int reg = dwarf_reg_to_regnum_or_error (frame_arch, m_regnum); + ULONGEST reg_bits = HOST_CHAR_BIT * register_size (frame_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 == nullptr) + 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. */ @@ -493,6 +642,10 @@ class dwarf_implicit final : public dwarf_location m_byte_order (byte_order) {} + void read (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::byte_vector m_contents; @@ -501,6 +654,45 @@ class dwarf_implicit final : public dwarf_location bfd_endian m_byte_order; }; +void +dwarf_implicit::read (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_contents.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.data (), + total_bits_to_skip, bit_size, big_endian); +} + /* Implicit pointer location description entry. */ class dwarf_implicit_pointer final : public dwarf_location @@ -516,6 +708,10 @@ class dwarf_implicit_pointer final : public dwarf_location m_addr_size (addr_size), m_die_offset (die_offset) {} + void read (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; @@ -530,6 +726,44 @@ class dwarf_implicit_pointer final : public dwarf_location sect_offset m_die_offset; }; +void +dwarf_implicit_pointer::read (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 +{ + 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).data () + + 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 final : public dwarf_location @@ -545,6 +779,10 @@ class dwarf_composite final : public dwarf_location m_pieces.emplace_back (std::move (location), bit_size); } + void read (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. */ @@ -566,6 +804,50 @@ class dwarf_composite final : public dwarf_location std::vector m_pieces; }; +void +dwarf_composite::read (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].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].size; + LONGEST actual_bit_size = piece_bit_size; + + if (actual_bit_size > bit_size) + actual_bit_size = bit_size; + + m_pieces[i].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. */ @@ -1181,27 +1463,8 @@ sect_variable_value (sect_offset sect_off, struct type * dwarf_expr_context::address_type () const { - gdbarch *arch = this->m_per_objfile->objfile->arch (); - dwarf_gdbarch_types *types - = (dwarf_gdbarch_types *) gdbarch_data (arch, dwarf_arch_cookie); - int ndx; - - if (this->m_addr_size == 2) - ndx = 0; - else if (this->m_addr_size == 4) - ndx = 1; - else if (this->m_addr_size == 8) - ndx = 2; - else - error (_("Unsupported address size in DWARF expressions: %d bits"), - 8 * this->m_addr_size); - - if (types->dw_types[ndx] == NULL) - types->dw_types[ndx] - = arch_integer_type (arch, 8 * this->m_addr_size, - 0, ""); - - return types->dw_types[ndx]; + return ::address_type (this->m_per_objfile->objfile->arch (), + this->m_addr_size); } /* Create a new context for the expression evaluator. */ -- 2.17.1