Re: [PATCH v3 27/28] Add DW_OP_LLVM_extend DWARF operation

[Lancelot SIX <lsix@lancelotsix.com>]

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<dwarf_composite> composite
> +    = make_unique<dwarf_composite> (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<const gdb_byte> 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 <http://www.gnu.org/licenses/>.
> +
> +# 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
>