From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lndn.lancelotsix.com (lndn.lancelotsix.com [51.195.220.111]) by sourceware.org (Postfix) with ESMTPS id E10513858403 for ; Mon, 1 Nov 2021 21:49:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E10513858403 Received: from ubuntu.lan (unknown [IPv6:2a02:390:9086::635]) by lndn.lancelotsix.com (Postfix) with ESMTPSA id 49613819D4; Mon, 1 Nov 2021 21:49:00 +0000 (UTC) Date: Mon, 1 Nov 2021 21:48:55 +0000 From: Lancelot SIX To: Zoran Zaric Cc: gdb-patches@sourceware.org Subject: Re: [PATCH v3 27/28] Add DW_OP_LLVM_extend DWARF operation Message-ID: <20211101214855.2rgdzus44rp6kpiu@ubuntu.lan> References: <20211014093235.69756-1-zoran.zaric@amd.com> <20211014093235.69756-28-zoran.zaric@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20211014093235.69756-28-zoran.zaric@amd.com> X-Greylist: Sender succeeded SMTP AUTH, not delayed by milter-greylist-4.5.11 (lndn.lancelotsix.com [0.0.0.0]); Mon, 01 Nov 2021 21:49:00 +0000 (UTC) X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, SPF_HELO_NONE, 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: Mon, 01 Nov 2021 21:49:05 -0000 Hi, On Thu, Oct 14, 2021 at 10:32:34AM +0100, Zoran Zaric via Gdb-patches wrote: > Previous changes allow a new set of more complex DWARF expression > operations to be added which are very usefull for SIMD/SIMT like > architectures. First of which is the DW_OP_LLVM_extend operation > that pops one stack element (which must be a location description) > and treat it as a number of pieces of a new composite location > description. > > This means that a resulting composite location contains a given > number of pieces of a given bit size, where all the pieces are > described by the same location description found on top of the stack. > > gdb/ChangeLog: > > * compile/compile-loc2c.c (compute_stack_depth_worker): Add > new DW_OP_LLVM_extend operation support. > * dwarf2/expr.c (dwarf_expr_context::create_extend_composite): > New method that creates the extend composite. > (dwarf_expr_context::execute_stack_op): Add new > DW_OP_LLVM_extend operation support. > * dwarf2/loc.c (dwarf2_get_symbol_read_needs): Add new > DW_OP_LLVM_extend operation support. > (disassemble_dwarf_expression): Add new DW_OP_LLVM_extend > operation support. > > include/ChangeLog: > > * dwarf2.def: Add new DW_OP_LLVM_extend enumeration. > > gdb/testsuite/ChangeLog: > > * gdb.dwarf2/dw2-llvm-extend.exp: New test. > * lib/dwarf.exp: Add new DW_OP_LLVM_extend operation support. > --- > gdb/compile/compile-loc2c.c | 4 + > gdb/dwarf2/expr.c | 44 ++++++ > gdb/dwarf2/loc.c | 12 ++ > gdb/testsuite/gdb.dwarf2/dw2-llvm-extend.exp | 148 +++++++++++++++++++ > gdb/testsuite/lib/dwarf.exp | 5 + > include/dwarf2.def | 1 + > 6 files changed, 214 insertions(+) > create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-llvm-extend.exp > > diff --git a/gdb/compile/compile-loc2c.c b/gdb/compile/compile-loc2c.c > index ba177726d4f..2c5e13cfb6c 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_extend: > + stack_depth -= 2; If DW_OP_LLVM_extend pops one element from the stack and pushes one composite value back, shouldn't the net result be 0i stack_depth wise? Best, Lancelot. > + break; > + > case DW_OP_LLVM_piece_end: > case DW_OP_LLVM_offset_constu: > case DW_OP_nop: > diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c > index 3cf4c78e4dc..711a5918946 100644 > --- a/gdb/dwarf2/expr.c > +++ b/gdb/dwarf2/expr.c > @@ -2498,6 +2498,15 @@ struct dwarf_expr_context > - Otherwise, the DWARF expression is ill-formed */ > void add_piece (ULONGEST bit_size, ULONGEST bit_offset); > > + /* It pops one stack entry that must be a location description and is > + treated as a piece location description. > + > + A complete composite location storage is created with PIECES_COUNT > + identical pieces and pushed on the DWARF stack. Each pieces has a > + bit size of PIECE_BIT_SIZE. */ > + void create_extend_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); > @@ -2860,6 +2869,30 @@ dwarf_expr_context::add_piece (ULONGEST bit_size, ULONGEST bit_offset) > composite->add_piece (std::move (piece), bit_size); > } > > +void > +dwarf_expr_context::create_extend_composite (ULONGEST piece_bit_size, > + ULONGEST pieces_count) > +{ > + gdbarch *arch = this->m_per_objfile->objfile->arch (); > + > + if (stack_empty_p () || piece_bit_size == 0 || pieces_count == 0) > + ill_formed_expression (); > + > + dwarf_location_up location = to_location (pop (), arch); > + > + std::unique_ptr composite > + = make_unique (arch, this->m_per_cu); > + > + for (ULONGEST i = 0; i < pieces_count; i++) > + { > + dwarf_location_up piece = location->clone_location (); > + composite->add_piece (std::move (piece), piece_bit_size); > + } > + > + composite->set_completed (true); > + push (std::move (composite)); > +} > + > void > dwarf_expr_context::eval (const gdb_byte *addr, size_t len) > { > @@ -4090,6 +4123,17 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr, > break; > } > > + case DW_OP_LLVM_extend: > + { > + 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_extend_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 c93981e9721..de3a904695a 100644 > --- a/gdb/dwarf2/loc.c > +++ b/gdb/dwarf2/loc.c > @@ -1953,6 +1953,7 @@ dwarf2_get_symbol_read_needs (gdb::array_view expr, > break; > > case DW_OP_bit_piece: > + case DW_OP_LLVM_extend: > op_ptr = safe_skip_leb128 (op_ptr, expr_end); > op_ptr = safe_skip_leb128 (op_ptr, expr_end); > break; > @@ -3666,6 +3667,17 @@ disassemble_dwarf_expression (struct ui_file *stream, > data = safe_read_uleb128 (data, end, &ul); > fprintf_filtered (stream, " %s", pulongest (ul)); > break; > + > + case DW_OP_LLVM_extend: > + { > + 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-extend.exp b/gdb/testsuite/gdb.dwarf2/dw2-llvm-extend.exp > new file mode 100644 > index 00000000000..2a82eed02b8 > --- /dev/null > +++ b/gdb/testsuite/gdb.dwarf2/dw2-llvm-extend.exp > @@ -0,0 +1,148 @@ > +# 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_extend operation. > +# > +# The test uses a composite location description, where all the pieces > +# are allocated in the same register by 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 > + > +if { [is_aarch64_target] } { > + set regname x0 > +} elseif { [is_aarch32_target] > + || [istarget "s390*-*-*" ] > + || [istarget "powerpc*-*-*"] > + || [istarget "rs6000*-*-aix*"] } { > + set regname r0 > +} elseif { [is_x86_like_target] } { > + set regname eax > +} elseif { [is_amd64_regs_target] } { > + set regname rax > +} 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} > + } { > + > + # All array elements are in first byte of REGNAME register. > + DW_TAG_variable { > + {DW_AT_name var_array_1} > + {DW_AT_type :$array_type_label} > + {DW_AT_location { > + DW_OP_regx $dwarf_regnum > + DW_OP_LLVM_extend 8 8 > + } SPECIAL_expr} > + } > + > + # All array elements are in fourth byte of REGNAME register. > + DW_TAG_variable { > + {DW_AT_name var_array_2} > + {DW_AT_type :$array_type_label} > + {DW_AT_location { > + DW_OP_regx $dwarf_regnum > + DW_OP_LLVM_offset_constu 3 > + DW_OP_LLVM_extend 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 \$$regname = 0x04030201" "init reg" > + > +# Determine byte order. > +set endian [get_endianness] > + > +switch $endian { > + little {set val "0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1"} > + big {set val "0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4"} > +} > + > +gdb_test "print/x var_array_1" " = \\{${val}\\}" "var_array_1 print" > + > +switch $endian { > + little {set val "0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4"} > + big {set val "0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1"} > +} > + > +gdb_test "print/x var_array_2" " = \\{${val}\\}" "var_array_2 print" > diff --git a/gdb/testsuite/lib/dwarf.exp b/gdb/testsuite/lib/dwarf.exp > index ac943cb0419..41415986e64 100644 > --- a/gdb/testsuite/lib/dwarf.exp > +++ b/gdb/testsuite/lib/dwarf.exp > @@ -1225,6 +1225,11 @@ namespace eval Dwarf { > _op .uleb128 [lindex $line 1] > } > > + DW_OP_LLVM_extend { > + _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 c6669221041..3d1d831d0fb 100644 > --- a/include/dwarf2.def > +++ b/include/dwarf2.def > @@ -710,6 +710,7 @@ DW_OP_DUP (DW_OP_LLVM_offset_constu, 0xe4) > 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_END_OP > > DW_FIRST_ATE (DW_ATE_void, 0x0) > -- > 2.17.1 >