Add DW_OP_LLVM_extend DWARF operation
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.
diff --git a/gdb/compile/compile-loc2c.c b/gdb/compile/compile-loc2c.c
index ba17772..26a4def 100644
--- a/gdb/compile/compile-loc2c.c
+++ b/gdb/compile/compile-loc2c.c
@@ -366,6 +366,7 @@
++stack_depth;
break;
+ case DW_OP_LLVM_extend:
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 e767966..f8c23a7 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -2525,6 +2525,15 @@
- 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);
@@ -2888,6 +2897,30 @@
}
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)
{
int old_recursion_depth = this->m_recursion_depth;
@@ -4117,6 +4150,17 @@
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 8bda817..d8bcd54 100644
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -1954,6 +1954,7 @@
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;
@@ -3667,6 +3668,17 @@
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 0000000..f682c40
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-llvm-extend.exp
@@ -0,0 +1,147 @@
+# Copyright (C) 2017-2021 Free Software Foundation, Inc.
+
+# 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 48a10ae..d2f3445 100644
--- a/gdb/testsuite/lib/dwarf.exp
+++ b/gdb/testsuite/lib/dwarf.exp
@@ -1225,6 +1225,11 @@
_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 c666922..3d1d831 100644
--- a/include/dwarf2.def
+++ b/include/dwarf2.def
@@ -710,6 +710,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_END_OP
DW_FIRST_ATE (DW_ATE_void, 0x0)
