From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM10-MW2-obe.outbound.protection.outlook.com (mail-mw2nam10on2085.outbound.protection.outlook.com [40.107.94.85]) by sourceware.org (Postfix) with ESMTPS id 15E4A3857C5F for ; Fri, 5 Nov 2021 11:39:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 15E4A3857C5F ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=W0QsA4GKHOa8G2FMNy5aNZRri5WGgTTbjFY8MTO816Vjb++4PVcLOWw2NtZt8yOiA7NOp/FkCCccOUdcPk3KTcRo5U2AdFLXYycl5QJes/X2yjJCYgWMsO/vK02xdBG4rgt4v7baET38KigmMwhEsYG3/xjZdzE8Hffo1tuMoRmuB8zD9J82Xl7ztV7QEXY2gb8QKS/uA28ViCb0B0YKMXJ9NTfM26dPXVy1l/cvThs0drLOujIT1+MFDemJ2C+fmAhPrJiVbMEB2bS9g5ZvFS2QgSyODZvQWCNW+nSxAyjsvLHj0kDaqAQnb/nKU62AM9vz97pcb/Mnn7Po2l0GjA== 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=9fo7SadK3npxWOAowFUypk8mgmLZPeKYPHMWAqpAj7Y=; b=TVrRlYN/G/yofAgBP0Er2LKCybRnYynEOo+QQZgRSVVlLbmVDuMKjNQ1RYQiSB1Y8+FljAcGHqQg2aIyd46ZBdqkez6HM7WGyXJ0oMyK1tVelpGJ2tDP/G2b0RRUhSehtWxYEYCImtsjeZGQTR4FCyA1MWEPUMwBV+eetxfn6vjJRubZJZXCVZTQHzcqVwIIUcudX6Ah9RTeZtU8TXWjKjk3WvVQFHG58sGgpd+aLgHxkHbpqUYm3OmsqK5HdW7wBr8oSD7GYmkn4qOofVcqV8UQhHUKd2fe2oGIPHR74gW7U4k652fCnpjcOr/YWun8w7MTTrd65uAt2VU3OHgUbw== 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 MWHPR11CA0004.namprd11.prod.outlook.com (2603:10b6:301:1::14) by MWHPR12MB1389.namprd12.prod.outlook.com (2603:10b6:300:13::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4669.13; Fri, 5 Nov 2021 11:39:36 +0000 Received: from CO1NAM11FT043.eop-nam11.prod.protection.outlook.com (2603:10b6:301:1:cafe::3c) by MWHPR11CA0004.outlook.office365.com (2603:10b6:301:1::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.4669.11 via Frontend Transport; Fri, 5 Nov 2021 11:39:36 +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 CO1NAM11FT043.mail.protection.outlook.com (10.13.174.193) 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:36 +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:31 -0500 From: Zoran Zaric To: Subject: [PATCH v4 28/28] Add DW_OP_LLVM_select_bit_piece DWARF operation Date: Fri, 5 Nov 2021 11:38:49 +0000 Message-ID: <20211105113849.118800-29-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: 51c3a417-1886-4304-65e9-08d9a050f1ae X-MS-TrafficTypeDiagnostic: MWHPR12MB1389: X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:2399; X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: liQ+V0Xa1ZcCopanyLS1SQ/Q7hsL5s3k4Js07SqorwHiEop0n6yBtZs1xmW62QBOI1gA+mj6u297NHzPGq03KMSj7y5Ea/s0J3Znf8ibyWLBwx7gPhfyD8tD7d1VeGJog9PjJsiwOJhLX9Z2+yDQiswv+uQH5eXhIyBQqOOmbH7ajTv9O80hpgLk21IWknHsor5skmeRCygCAXPlrXpiNlvaDUX+rlA3qDQwJ3Q98sPmirIPMV2asvwr35J8WLtusbfZzpclOYUr4pmqb5kavqs2XfrCmMAMNMvDLHqnmftUi+xWcRaZyZm2H6Y++UpQiVbEecNIC9xmFewejcQlm3v8WyH3eL7IIyTpCgY+ufKavnHHYMlL6vw4IyMkSM7Uv+udd1s74BtTV2gunGIv+6wTsmTMCf64ed0u2za+coDcPgFateM5/lqHzqkv24qjhOk1Hxt+qfLiuIIGA289p8MSSAASw6YMvKNcVXAwHlPkYiZShPbQnog+rMIVF5xCFs9Hb1VXund17+O3QYi6Pw825ap5xxHjMTfpaN6C2obETlsRd5C+x2LOGQs81NzHHzvED3Jagb0ibNcEm5eQ69c4b3P26naFBxOahXZSN5x4upl/IXsuPD6uqnj6FnGSAP6TqctiuQoiBgZRJU/sXGARC80ulLvNSQBQ2OFPbmkR2OhdKkyuxwY8eU8nzeCRueYfwsHAAuFSGHZm/Uk9juvDyjHVkRmd8RYEc1DhaK3BA8TQQdj6oKZYlHWUH1RL0LIRYlYvkR3LgZ9r4/GCUv+nQrCmngH0BxQno99r8KLoSIa0i/Av+f7Ol3AxelvPYLuXHieWPiSYiS6E+z0ulA== 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)(36756003)(70206006)(5660300002)(36860700001)(82310400003)(86362001)(70586007)(83380400001)(81166007)(6666004)(356005)(2906002)(8936002)(316002)(44832011)(2616005)(426003)(4326008)(8676002)(30864003)(336012)(508600001)(6916009)(26005)(16526019)(47076005)(186003)(1076003)(2004002)(36900700001); DIR:OUT; SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Nov 2021 11:39:36.0543 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 51c3a417-1886-4304-65e9-08d9a050f1ae 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: CO1NAM11FT043.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR12MB1389 X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, 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:41 -0000 Second more complex DWARF expression operation, that is usefull for SIMD/SIMT like architectures is DW_OP_LLVM_select_bit_piece. This operation pops three stack entries, where the first must be an integral type value that represents a bit mask, the second must be a location description that represents the one-location description and the third must be a location description that represents the zero-location description. Resulting composite location description contains a given number of pieces of a given bit size, created with parts from either of the two location description, based on the bit mask. gdb/ChangeLog: * compile/compile-loc2c.c (compute_stack_depth_worker): Add new DW_OP_LLVM_select_bit_piece operation support. * dwarf2/expr.c (dwarf_expr_context::create_select_composite): New method that creates the select bit piece composite. (dwarf_location::slice): New method. (dwarf_composite::slice): New method. (dwarf_expr_context::execute_stack_op): Add new DW_OP_LLVM_select_bit_piece operation support. * dwarf2/loc.c (dwarf2_get_symbol_read_needs): Add new DW_OP_LLVM_select_bit_piece operation support. (disassemble_dwarf_expression): Add new DW_OP_LLVM_select_bit_piece operation support. include/ChangeLog: * dwarf2.def: Add new DW_OP_LLVM_select_bit_piece enumeration. gdb/testsuite/ChangeLog: * gdb.dwarf2/dw2-llvm-select-bit-piece.exp: New test. * lib/dwarf.exp: Add new DW_OP_LLVM_select_bit_piece operation support. --- gdb/compile/compile-loc2c.c | 4 + gdb/dwarf2/expr.c | 160 ++++++++++++++++++ gdb/dwarf2/loc.c | 12 ++ .../gdb.dwarf2/dw2-llvm-select-bit-piece.exp | 138 +++++++++++++++ gdb/testsuite/lib/dwarf.exp | 5 + include/dwarf2.def | 1 + 6 files changed, 320 insertions(+) create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-llvm-select-bit-piece.exp diff --git a/gdb/compile/compile-loc2c.c b/gdb/compile/compile-loc2c.c index 26a4def312c..83863276b4c 100644 --- a/gdb/compile/compile-loc2c.c +++ b/gdb/compile/compile-loc2c.c @@ -366,6 +366,10 @@ compute_stack_depth_worker (int start, int *need_tempvar, ++stack_depth; break; + case DW_OP_LLVM_select_bit_piece: + stack_depth -= 2; + break; + case DW_OP_LLVM_extend: case DW_OP_LLVM_piece_end: case DW_OP_LLVM_offset_constu: diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index f8c23a7842d..3ae1a6289dd 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -461,6 +461,15 @@ class dwarf_location : public dwarf_entry ill_formed_expression (); } + /* Make a slice of a location description with an added bit offset + BIT_OFFSET and BIT_SIZE size in bits. + + In the case of a composite location description, function returns + a minimum subset of that location description that starts on a + given offset of a given size. */ + virtual std::unique_ptr slice (LONGEST bit_offset, + LONGEST bit_size) const; + /* Read contents from the described location. The read operation is performed in the context of a FRAME. @@ -616,6 +625,17 @@ class dwarf_location : public dwarf_entry using dwarf_location_up = std::unique_ptr; +/* This is a default implementation used for + non-composite location descriptions. */ + +std::unique_ptr +dwarf_location::slice (LONGEST bit_offset, LONGEST bit_size) const +{ + dwarf_location_up location_slice = this->clone_location (); + location_slice->add_bit_offset (bit_offset); + return location_slice; +} + void dwarf_location::read_from_gdb_value (frame_info *frame, struct value *value, int value_bit_offset, @@ -1573,6 +1593,9 @@ class dwarf_composite final : public dwarf_location return make_unique (*this); } + std::unique_ptr slice (LONGEST bit_offset, + LONGEST bit_size) const override; + void add_piece (std::unique_ptr location, ULONGEST bit_size) { gdb_assert (location != nullptr); @@ -1659,6 +1682,64 @@ class dwarf_composite final : public dwarf_location bool m_completed = false; }; +std::unique_ptr +dwarf_composite::slice (LONGEST bit_offset, LONGEST bit_size) const +{ + /* Size 0 is never expected at this point. */ + gdb_assert (bit_size != 0); + + unsigned int pieces_num = m_pieces.size (); + LONGEST total_bit_size = bit_size; + LONGEST total_bits_to_skip = m_offset * HOST_CHAR_BIT + + m_bit_suboffset + bit_offset; + std::vector piece_slices; + unsigned int i; + + 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++) + { + if (total_bit_size == 0) + break; + + gdb_assert (total_bit_size > 0); + LONGEST slice_bit_size = m_pieces[i].size - total_bits_to_skip; + + if (total_bit_size < slice_bit_size) + slice_bit_size = total_bit_size; + + std::unique_ptr slice + = m_pieces[i].location->slice (total_bits_to_skip, slice_bit_size); + piece_slices.emplace_back (std::move (slice), slice_bit_size); + + total_bit_size -= slice_bit_size; + total_bits_to_skip = 0; + } + + unsigned int slices_num = piece_slices.size (); + + /* Only one piece found, so there is no reason to + make a composite location description. */ + if (slices_num == 1) + return std::move (piece_slices[0].location); + + std::unique_ptr composite_slice + = make_unique (m_arch, m_per_cu); + + for (piece &piece : piece_slices) + composite_slice->add_piece (std::move (piece.location), piece.size); + + return composite_slice; +} + void dwarf_composite::read (frame_info *frame, gdb_byte *buf, int buf_bit_offset, size_t bit_size, @@ -2534,6 +2615,20 @@ struct dwarf_expr_context void create_extend_composite (ULONGEST piece_bit_size, ULONGEST pieces_count); + /* It pops three stack entries. The first must be an integral type + value that represents a bit mask. The second must be a location + description that represents the one-location description. The + third must be a location description that represents the + zero-location description. + + A complete composite location description created with parts from + either of the two location description, based on the bit mask, + is pushed on top of the DWARF stack. PIECE_BIT_SIZE represent + a size in bits of each piece and PIECES_COUNT represents a number + of pieces required. */ + void create_select_composite (ULONGEST piece_bit_size, + ULONGEST pieces_count); + /* The engine for the expression evaluator. Using the context in this object, evaluate the expression between OP_PTR and OP_END. */ void execute_stack_op (const gdb_byte *op_ptr, const gdb_byte *op_end); @@ -2920,6 +3015,60 @@ dwarf_expr_context::create_extend_composite (ULONGEST piece_bit_size, push (std::move (composite)); } +void +dwarf_expr_context::create_select_composite (ULONGEST piece_bit_size, + ULONGEST pieces_count) +{ + gdb::byte_vector mask_buf; + gdbarch *arch = this->m_per_objfile->objfile->arch (); + + if (stack_empty_p () || piece_bit_size == 0 || pieces_count == 0) + ill_formed_expression (); + + dwarf_value_up mask = to_value (pop (), address_type ()); + + type *mask_type = mask->type (); + ULONGEST mask_size = TYPE_LENGTH (mask_type); + dwarf_require_integral (mask_type); + + if (mask_size * HOST_CHAR_BIT < pieces_count) + ill_formed_expression (); + + mask_buf.resize (mask_size); + + copy_bitwise (mask_buf.data (), 0, mask->contents ().data (), + 0, mask_size * HOST_CHAR_BIT, + type_byte_order (mask_type) == BFD_ENDIAN_BIG); + + if (stack_empty_p ()) + ill_formed_expression (); + + dwarf_location_up one = to_location (pop (), arch); + + if (stack_empty_p ()) + ill_formed_expression (); + + dwarf_location_up zero = to_location (pop (), arch); + + std::unique_ptr composite + = make_unique (arch, this->m_per_cu); + + for (ULONGEST i = 0; i < pieces_count; i++) + { + std::unique_ptr slice; + + if ((mask_buf.data ()[i / HOST_CHAR_BIT] >> (i % HOST_CHAR_BIT)) & 1) + slice = one->slice (i * piece_bit_size, piece_bit_size); + else + slice = zero->slice (i * piece_bit_size, piece_bit_size); + + composite->add_piece (std::move (slice), piece_bit_size); + } + + composite->set_completed (true); + push (std::move (composite)); +} + void dwarf_expr_context::eval (const gdb_byte *addr, size_t len) { @@ -4161,6 +4310,17 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, break; } + case DW_OP_LLVM_select_bit_piece: + { + uint64_t piece_bit_size, pieces_count; + + /* Record the piece. */ + op_ptr = safe_read_uleb128 (op_ptr, op_end, &piece_bit_size); + op_ptr = safe_read_uleb128 (op_ptr, op_end, &pieces_count); + create_select_composite (piece_bit_size, pieces_count); + break; + } + default: error (_("Unhandled dwarf expression opcode 0x%x"), op); } diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c index d8bcd542776..071baad76d1 100644 --- a/gdb/dwarf2/loc.c +++ b/gdb/dwarf2/loc.c @@ -1955,6 +1955,7 @@ dwarf2_get_symbol_read_needs (gdb::array_view expr, case DW_OP_bit_piece: case DW_OP_LLVM_extend: + case DW_OP_LLVM_select_bit_piece: op_ptr = safe_skip_leb128 (op_ptr, expr_end); op_ptr = safe_skip_leb128 (op_ptr, expr_end); break; @@ -3679,6 +3680,17 @@ disassemble_dwarf_expression (struct ui_file *stream, pulongest (ul), pulongest (count)); } break; + + case DW_OP_LLVM_select_bit_piece: + { + uint64_t count; + + data = safe_read_uleb128 (data, end, &ul); + data = safe_read_uleb128 (data, end, &count); + fprintf_filtered (stream, " piece size %s (bits) pieces count %s", + pulongest (ul), pulongest (count)); + } + break; } fprintf_filtered (stream, "\n"); diff --git a/gdb/testsuite/gdb.dwarf2/dw2-llvm-select-bit-piece.exp b/gdb/testsuite/gdb.dwarf2/dw2-llvm-select-bit-piece.exp new file mode 100644 index 00000000000..c5ed6efbd75 --- /dev/null +++ b/gdb/testsuite/gdb.dwarf2/dw2-llvm-select-bit-piece.exp @@ -0,0 +1,138 @@ +# Copyright (C) 2017-2021 Free Software Foundation, Inc. +# Copyright (C) 2020-2021 Advanced Micro Devices, Inc. All rights reserved. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Test the new DW_OP_LLVM_select_bit_piece operation. +# +# The test uses a composite location description, where all the pieces +# are selected from two registers in odd/even pattern using the new +# operation. + +load_lib dwarf.exp + +# This test can only be run on targets which support DWARF-2 and use gas. +if {![dwarf2_support]} { + return 0 +} + +# Choose suitable integer registers for the test. + +set dwarf_regnum {0 1} + +if { [is_aarch64_target] } { + set regname {x0 x1} +} elseif { [is_aarch32_target] + || [istarget "s390*-*-*" ] + || [istarget "powerpc*-*-*"] + || [istarget "rs6000*-*-aix*"] } { + set regname {r0 r1} +} elseif { [is_x86_like_target] } { + set regname {eax ecx} +} elseif { [is_amd64_regs_target] } { + set regname {rax rdx} +} else { + verbose "Skipping $gdb_test_file_name." + return +} + +standard_testfile var-access.c ${gdb_test_file_name}-dw.S + +# Make some DWARF for the test. + +set asm_file [standard_output_file $srcfile2] +Dwarf::assemble $asm_file { + global dwarf_regnum regname srcdir subdir srcfile + set buf_src [gdb_target_symbol buf] + + set main_result [function_range main ${srcdir}/${subdir}/${srcfile}] + set main_start [lindex $main_result 0] + set main_length [lindex $main_result 1] + + cu {} { + DW_TAG_compile_unit { + {DW_AT_name var-access.c} + {DW_AT_comp_dir /tmp} + } { + declare_labels int_type_label char_type_label array_type_label + + # define char type + char_type_label: DW_TAG_base_type { + {DW_AT_name "char"} + {DW_AT_encoding @DW_ATE_signed} + {DW_AT_byte_size 1 DW_FORM_sdata} + } + + int_type_label: DW_TAG_base_type { + {DW_AT_name "int"} + {DW_AT_encoding @DW_ATE_signed} + {DW_AT_byte_size 4 DW_FORM_sdata} + } + + array_type_label: DW_TAG_array_type { + {DW_AT_type :$char_type_label} + } { + DW_TAG_subrange_type { + {DW_AT_type :$int_type_label} + {DW_AT_upper_bound 7 DW_FORM_udata} + } + } + + DW_TAG_subprogram { + {DW_AT_name main} + {DW_AT_low_pc $main_start addr} + {DW_AT_high_pc $main_length data8} + } { + + # Odd array elements are in first byte of REGNAME 0 register, + # while even elements are in first byte of REGNAME 1 register. + DW_TAG_variable { + {DW_AT_name var_array} + {DW_AT_type :$array_type_label} + {DW_AT_location { + DW_OP_regx [lindex $dwarf_regnum 0] + DW_OP_LLVM_extend 8 8 + DW_OP_regx [lindex $dwarf_regnum 1] + DW_OP_LLVM_extend 8 8 + DW_OP_constu 0xaa + DW_OP_LLVM_select_bit_piece 8 8 + } SPECIAL_expr} + } + } + } + } +} + +if { [prepare_for_testing ${testfile}.exp ${testfile} \ + [list $srcfile $asm_file] {nodebug}] } { + return -1 +} + +if ![runto_main] { + return -1 +} + +gdb_test_no_output "set var \$[lindex $regname 0] = 0x04030201" "init reg 0" +gdb_test_no_output "set var \$[lindex $regname 1] = 0x01020304" "init reg 1" + +# Determine byte order. +set endian [get_endianness] + +switch $endian { + little {set val "0x1, 0x4, 0x1, 0x4, 0x1, 0x4, 0x1, 0x4"} + big {set val "0x4, 0x1, 0x4, 0x1, 0x4, 0x1, 0x4, 0x1"} +} + +gdb_test "print/x var_array" " = \\{${val}\\}" "var_array print" + diff --git a/gdb/testsuite/lib/dwarf.exp b/gdb/testsuite/lib/dwarf.exp index d2f3445c926..3bb9bdbd3d4 100644 --- a/gdb/testsuite/lib/dwarf.exp +++ b/gdb/testsuite/lib/dwarf.exp @@ -1230,6 +1230,11 @@ namespace eval Dwarf { _op .uleb128 [lindex $line 2] } + DW_OP_LLVM_select_bit_piece { + _op .uleb128 [lindex $line 1] + _op .uleb128 [lindex $line 2] + } + default { if {[llength $line] > 1} { error "Unimplemented: operands in location for $opcode" diff --git a/include/dwarf2.def b/include/dwarf2.def index 3d1d831d0fb..abc1125df2c 100644 --- a/include/dwarf2.def +++ b/include/dwarf2.def @@ -711,6 +711,7 @@ DW_OP_DUP (DW_OP_LLVM_bit_offset, 0xe5) DW_OP (DW_OP_LLVM_undefined, 0xe7) DW_OP_DUP (DW_OP_LLVM_piece_end, 0xea) DW_OP (DW_OP_LLVM_extend, 0xeb) +DW_OP (DW_OP_LLVM_select_bit_piece, 0xec) DW_END_OP DW_FIRST_ATE (DW_ATE_void, 0x0) -- 2.17.1