void add_piece (std::unique_ptr<dwarf_location> location, ULONGEST bit_size)
{
gdb_assert (location != nullptr);
+ gdb_assert (!m_completed);
m_pieces.emplace_back (std::move (location), bit_size);
}
+ void set_completed (bool completed)
+ {
+ m_completed = completed;
+ };
+
+ bool is_completed () const
+ {
+ return m_completed;
+ };
+
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;
/* Vector of composite pieces. */
std::vector<piece> m_pieces;
+
+ /* True if location description is completed. */
+ bool m_completed = false;
};
void
LONGEST total_bits_to_skip = bits_to_skip;
unsigned int i;
+ if (!m_completed)
+ ill_formed_expression ();
+
total_bits_to_skip += m_offset * HOST_CHAR_BIT + m_bit_suboffset;
/* Skip pieces covered by the read offset. */
unsigned int pieces_num = m_pieces.size ();
unsigned int i;
+ if (!m_completed)
+ ill_formed_expression ();
+
total_bits_to_skip += m_offset * HOST_CHAR_BIT + m_bit_suboffset;
/* Skip pieces covered by the write offset. */
invalid_synthetic_pointer ();
computed_closure *closure;
+ std::unique_ptr<dwarf_composite> composite_copy
+ = make_unique<dwarf_composite> (*this);
+ composite_copy->set_completed (true);
/* If compilation unit information is not available
we are in a CFI context. */
if (m_per_cu == nullptr)
- closure = new computed_closure (make_unique<dwarf_composite> (*this),
- frame);
+ closure = new computed_closure (std::move (composite_copy), frame);
else
- closure = new computed_closure (make_unique<dwarf_composite> (*this),
+ closure = new computed_closure (std::move (composite_copy),
get_frame_id (frame));
closure->incref ();
/* Return true if the expression stack is empty. */
bool stack_empty_p () const;
- /* Pop a top element of the stack and add as a composite piece
- with an BIT_OFFSET offset and of a BIT_SIZE size.
+ /* Pop a top element of the stack and add as a composite piece.
+ The action is based on the context:
+
+ - If the stack is empty, then an incomplete composite location
+ description (comprised of one undefined location description),
+ is pushed on the stack.
+
+ - Otherwise, if the top stack entry is an incomplete composite
+ location description, then it is updated to append a new piece
+ comprised of one undefined location description. The
+ incomplete composite location description is then left on the
+ stack.
+
+ - Otherwise, if the top stack entry is a location description or
+ can be converted to one, it is popped. Then:
+
+ - If the top stack entry (after popping) is a location
+ description comprised of one incomplete composite location
+ description, then it is updated to append a new piece
+ specified by the previously popped location description.
+ The incomplete composite location description is then left
+ on the stack.
+
+ - Otherwise, a new location description comprised of one
+ incomplete composite location description, with a new piece
+ specified by the previously popped location description, is
+ pushed on the stack.
- If the following top element of the stack is a composite
- location description, the piece will be added to it. Otherwise
- a new composite location description will be created, pushed on
- the stack and the piece will be added to that composite. */
+ - Otherwise, the DWARF expression is ill-formed */
void add_piece (ULONGEST bit_size, ULONGEST bit_offset);
/* The engine for the expression evaluator. Using the context in this
dwarf_composite *top_entry_as_composite
= dynamic_cast <dwarf_composite *> (&top_entry);
- if (top_entry_as_composite == nullptr)
- piece = to_location (pop (), arch);
- else
+ if (top_entry_as_composite != nullptr
+ && !top_entry_as_composite->is_completed ())
piece = make_unique<dwarf_undefined> (arch);
+ else
+ piece = to_location (pop (), arch);
}
piece->add_bit_offset (bit_offset);
else
{
dwarf_entry &top_entry = fetch (0);
- composite = dynamic_cast <dwarf_composite *> (&top_entry);
+ dwarf_composite *top_entry_as_composite
+ = dynamic_cast <dwarf_composite *> (&top_entry);
- if (composite == nullptr)
+ if (top_entry_as_composite != nullptr
+ && !top_entry_as_composite->is_completed ())
+ composite = top_entry_as_composite;
+ else
{
std::unique_ptr<dwarf_composite> new_composite
= make_unique<dwarf_composite> (arch, this->m_per_cu);
push (make_unique<dwarf_undefined> (arch));
break;
+ case DW_OP_LLVM_piece_end:
+ {
+ dwarf_entry &entry = fetch (0);
+ dwarf_composite *composite
+ = dynamic_cast<dwarf_composite *> (&entry);
+
+ if (composite == nullptr || composite->is_completed ())
+ ill_formed_expression ();
+
+ composite->set_completed (true);
+ break;
+ }
+
default:
error (_("Unhandled dwarf expression opcode 0x%x"), op);
}
--- /dev/null
+# 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 nested composition location description by using the new
+# DW_OP_LLVM_piece_end operation.
+#
+# The test uses three nested levels of composite location descriptions
+# to define a location of an array.
+
+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 array_type_label int_type_label char_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}
+ } {
+ # Array spread in different pieces, of which some are
+ # undefined (1st and sixth bytes) and some are either
+ # in buf variable or REGNAME register.
+ #
+ # Location consists of three nested composite levels:
+ # - Third level consists of a composite location
+ # descriptions which hold a single simple location
+ # description each.
+ # - Second level consist of two more composite location
+ # descriptions that hold two of the third level
+ # composite location descriptions.
+ # - First level holds two of the second level composite
+ # location descriptions.
+
+ DW_TAG_variable {
+ {DW_AT_name var_array}
+ {DW_AT_type :$array_type_label}
+ {DW_AT_location {
+ # First level composite start
+ # Second level first composite start
+ # Third level first composite start
+ DW_OP_addr $buf_src
+ DW_OP_piece 0x2
+ DW_OP_LLVM_piece_end
+ # Third level first composite end
+
+ # Third level second composite start
+ DW_OP_LLVM_undefined
+ DW_OP_piece 0x1
+ DW_OP_LLVM_piece_end
+ # Third level second composite end
+
+ DW_OP_piece 0x1
+ DW_OP_swap
+ DW_OP_piece 0x2
+ DW_OP_LLVM_piece_end
+ # Second level first composite end
+
+ # Second level second composite start
+ # Third level third composite start
+ DW_OP_regx $dwarf_regnum
+ DW_OP_piece 0x4
+ DW_OP_LLVM_piece_end
+ # Third level third composite end
+
+ # Third level fourth composite start
+ DW_OP_LLVM_undefined
+ DW_OP_piece 0x1
+ DW_OP_LLVM_piece_end
+ # Third level fourth composite end
+
+ DW_OP_piece 0x1
+ DW_OP_swap
+ DW_OP_piece 0x4
+ DW_OP_LLVM_piece_end
+ # Second level second composite end
+
+ DW_OP_piece 0x5
+ DW_OP_swap
+ DW_OP_piece 0x3
+ DW_OP_LLVM_piece_end
+ # First level composite end
+
+ } 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 = 0x4030201" "init reg"
+
+# Determine byte order.
+set endian [get_endianness]
+set optimized "<optimized out>"
+
+switch $endian {
+ little {
+ set val "$optimized, 0x1, 0x2, 0x3, 0x4, $optimized, 0x0, 0x1"
+ }
+ big {
+ set val "$optimized, 0x4, 0x3, 0x2, 0x1, $optimized, 0x0, 0x1"
+ }
+}
+
+gdb_test "print/x var_array" " = \\{${val}\\}" "var_array print"
+
projects / thirdparty / binutils-gdb.git / commitdiff
