From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM11-DM6-obe.outbound.protection.outlook.com (mail-dm6nam11on2041.outbound.protection.outlook.com [40.107.223.41]) by sourceware.org (Postfix) with ESMTPS id 3C40C3857C56 for ; Thu, 14 Oct 2021 09:33:06 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 3C40C3857C56 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=EqomHDQnz9nabzQUuldh31VvZ14qXTLdh0n2SZtLjv6iW/MK/hNsBZCQacCkASbY0k/4R4yWFo34VHF+xI4qvxuK584NRhSloqM4Ba92j607cZwwZzVL6pnGPxFlSYvv4MMgZmgvWAWDfMkwY691PH0qMzYhuixB5FlsJtD2BKFordBy97b5gOiGUNXNNqL9YQY2RSPjCsPgJiyOnmriq/0ElnHtfzG6UwEvL2vIU3tMYFP44o/IZ3jhR91EbFAkbKGQltyfZXLlWUS6ymAljjYDiM6VDh4L7fAVid6RHTllgMnHMSKCv2lyoTY/TP2ua6eaYBEL1ipqZGVVhTFBig== 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=vdIlAFV/7H8vmiMWJetLJUrT4GuP6bOHctz4DNtqAQE=; b=fw2o/P78DEhBC7AQLpCwdpYHaZWtDG1n88VB3J2xFLlnZ9g0/XzP01UIfzRzycqlyRyu8rOoC5g9fISQnYRFcBSeR2yawCdIpCTv7pmzCjUtfJs+/eJCYcFLuAv1rEAUfcZCuATzMXWAQgsM5/JufR2mufnT9jm8JweaZ+Frh4KdBGvMuPfjSbtcBCr+sEudR4eWp7oVpWNGj74pYgTvAH+JBYjMcPUL11Fewd2HUl8ixy/pxzSy+qwYmLBfrLtl7vmewsGOn7HJc+LJcV5i3jS2L8cbvaxiDZSKQrQtOoHsJpTBMNpKSyU1zhyThFqwwRrqEHNGI5WD5eRLlkpbsg== 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 DM5PR13CA0044.namprd13.prod.outlook.com (2603:10b6:3:7b::30) by DM6PR12MB2777.namprd12.prod.outlook.com (2603:10b6:5:51::25) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4587.25; Thu, 14 Oct 2021 09:33:04 +0000 Received: from DM6NAM11FT047.eop-nam11.prod.protection.outlook.com (2603:10b6:3:7b:cafe::90) by DM5PR13CA0044.outlook.office365.com (2603:10b6:3:7b::30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4628.8 via Frontend Transport; Thu, 14 Oct 2021 09:33:04 +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 DM6NAM11FT047.mail.protection.outlook.com (10.13.172.139) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.4608.15 via Frontend Transport; Thu, 14 Oct 2021 09:33:04 +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.8; Thu, 14 Oct 2021 04:32:59 -0500 From: Zoran Zaric To: Subject: [PATCH v3 06/28] Add read method to location description classes Date: Thu, 14 Oct 2021 10:32:13 +0100 Message-ID: <20211014093235.69756-7-zoran.zaric@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20211014093235.69756-1-zoran.zaric@amd.com> References: <20211014093235.69756-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: SATLEXMB03.amd.com (10.181.40.144) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: af899b3f-4314-41d7-facd-08d98ef59f53 X-MS-TrafficTypeDiagnostic: DM6PR12MB2777: 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: 2svqqshESO+8HAXD2DmgFUHMORdImuMJOK5ElcJx5Bjy00kNc+bCAOR1tTds2mXbEiO2BMlhYynsd/f+uDmv+1VR/vfqpMqEMnaVZCTybp6VW1VCPZPSfGd01Wz40I17lb8KnOyXAlGKsrWivbQ8LaOiEGfc/o4OTGk2NBzoCh5qy1/LngMPXWz9ektVVmeOHQNVGltLrwVe1VMiXIZKXVE7LRSuMv3TN30V2DYi4Hswr9YWWZEBEZXd/h05I1stiaz4V4TBKd44ZWLfvpWxts+VrY/6lkhf0Fm+8wR0Lzwf4J/TvmnUtxItV+CmNO5lLlA6aNTS+l84QXr6mvSHMhuKUGYTXOOpHztxQ7gY5zeuEdjby843V2QgdY/8LbkuOlVNtHVzuxzJv9wpgYzzobs8mLZiiVfvTQ6QCiZTnjhPw1eiiPsPvWvgky673Kzf41hs9RZDYRWMtfaJBa+n7oobnXv1Jxep1LVtIF7RcU6rS4M/EyggH0+K9KjLp6MvBeUPtZPwQ2jmhX4cdUa3Cs7c3O9SRYKc1h0et4+eDSI8qpsoBMmvPlr3gCfMV2LiLhfgw+VmfqrnS8B4HpdEKwjQdGF6k7nPq1avWaL3zT3WP30hiNJ8PSA+Jd3LHnFc+XGmbqe3/lCM2s8+7lunbpvOs9M2Wy6rZjbh3M4n7YEEnzRhs/aNxoD8QFz6qqP0ccFLDOZ+qsWa+5RIw5nMItjbEFv4VfTuHSsnFn5QlPk= 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)(508600001)(86362001)(4326008)(2906002)(81166007)(316002)(8676002)(83380400001)(70206006)(70586007)(5660300002)(47076005)(6666004)(8936002)(36756003)(2616005)(36860700001)(16526019)(336012)(44832011)(30864003)(356005)(82310400003)(1076003)(26005)(186003)(6916009)(426003)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Oct 2021 09:33:04.0050 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: af899b3f-4314-41d7-facd-08d98ef59f53 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: DM6NAM11FT047.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM6PR12MB2777 X-Spam-Status: No, score=-11.7 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: Thu, 14 Oct 2021 09:33:08 -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 56f17f52756..3f3e09db7cc 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -289,6 +289,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] == NULL) + types->dw_types[ndx] + = arch_integer_type (arch, HOST_CHAR_BIT * addr_size, + 0, ""); + + return types->dw_types[ndx]; +} + class dwarf_location; class dwarf_memory; class dwarf_value; @@ -349,6 +379,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; @@ -426,6 +477,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 @@ -442,6 +501,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; @@ -468,6 +532,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 @@ -477,11 +581,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 == 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. */ @@ -497,6 +646,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; @@ -505,6 +658,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 @@ -520,6 +712,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; @@ -534,6 +730,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) + 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 @@ -549,6 +783,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. */ @@ -570,6 +808,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. */ @@ -1185,27 +1467,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