From: Zoran Zaric Date: Mon, 7 Dec 2020 19:00:19 +0000 (+0000) Subject: Add new classes that model DWARF stack element X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=fda7ca2701ba9096a4b0dce8997f8cd944279513;p=thirdparty%2Fbinutils-gdb.git Add new classes that model DWARF stack element The rest of the patch series addresses the issues described in a "Motivation" section of the AMD's DWARF standard extensions that can be found at: https://llvm.org/docs/AMDGPUDwarfExtensionsForHeterogeneousDebugging.html The document describes a couple of main issues found when using the current DWARF 5 version to describe optimized code for SIMD and SIMT architectures. Without going much into details described in the document, the main point is that DWARF version 5 does not allow a proper support for address spaces and it does not allow a location description to be part of a DWARF expression, unless it is a leaf node of that expression. Both issues can be solved in a clean way by introducing a new set of classes that describe all entry types which can be placed on a DWARF stack, while keeping a full backward compatibility with the previous standard version. These entry types can now be either a typed value or any location description. Currently, the result of an expression evaluation is kept in a separate data structure, while with the new approach, it will be always found as a top element of the DWARF stack. The reason why this approach is backward compatible is because in version 5, a location description is only allowed to be a leaf node of the expression or a composite piece. Question here is, why do we need a new set of classes and why not just use the struct value instead? As it stands, there are couple of issues with using the struct value to describe a DWARF stack element: - It is not designed to represent a DWARF location description specifically, instead it behaves more like unified debug information format that represents an actual target resource. One example of this is accessing data of a struct value register location description, where if the amount of data accessed is larger then the register, results in accessing more then one register. In DWARF this is not a valid behavior and locations that span more then one register should be described as a composite location description. - There is a tight coupling between struct value and it's type information, regardless if the data represented is describing a value (not_lval) or a location description. While the type information dictates how the data is accessed for a struct value case, in DWARF, location description doesn't have a type so data access is not bound by it. - DWARF values only support much simpler base types, while struct value can be linked to any type. Admittedly, new classes are still using the same struct value infrastructure for a value based operations at the moment, but that is planned to change in the near future. - struct value register location description requires a frame id information which makes them unsuitable for CFA expression evaluation. So, there seems to be a lack of separation of concerns in the design of a struct value infrastructure, while the new classes are handling one specific purpose and are completely encapsulated in the expr.c. Additional benefit of this design is that it makes a step in a right direction for being able to evaluate DWARF expressions on a gdbserver side in the near future, which sounds like a desirable thing. It is also worth mentioning that this new location description representation is based on a bit granularity (the bit_suboffset class member) even though the DWARF standard has a very limited support for it (mostly used for DW_OP_bit_piece operation). By allowing any location description to define a bit sub-offset of the location, we are able to give more options for supporting of new concepts (like the existing packed arrays in Ada language). In this patch, a new set of classes that describe a DWARF stack element are added. The new classes are: - Value - describes a numerical value with a DWARF base type. - Location description - describes a DWARF location description. - Undefined location - describes a location that is not defined. - Memory location - describes a location in memory. - Register location - describes a register location in a frame context. - Implicit location - describes a location that implicitly holds a value that it describes. - Implicit pointer - describes a concept of an implicit pointer to a source variable. - Composite location - describes a location that is composed from pieces of other location descriptions. For now, these classes are just defined, and they are planned to be used by the following patches. gdb/ChangeLog: * dwarf2/expr.c (class dwarf_entry): New class. (class dwarf_value): New class. (class dwarf_location): New class. (class dwarf_undefined): New class. (class dwarf_memory): New class. (class dwarf_register): New class. (class dwarf_implicit): New class. (class dwarf_implicit_pointer): New class. (class dwarf_composite): New class. * value.c (pack_unsigned_long): Expose function. * value.h (pack_unsigned_long): Expose function. Change-Id: If19996cd9778d4dd12e9c141af788f0fdbf16227 --- diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c index 0c9ea51e5b8..c0bb06fc4cc 100644 --- a/gdb/dwarf2/expr.c +++ b/gdb/dwarf2/expr.c @@ -267,6 +267,352 @@ write_to_memory (CORE_ADDR address, const gdb_byte *buffer, length, buffer); } +/* Base class that describes entries found on a DWARF expression + evaluation stack. */ + +class dwarf_entry : public refcounted_object +{ +public: + /* Not expected to be called on it's own. */ + dwarf_entry () = default; + + virtual ~dwarf_entry () = 0; +}; + +dwarf_entry::~dwarf_entry () = default; + +/* Value entry found on a DWARF expression evaluation stack. */ + +class dwarf_value : public dwarf_entry +{ +public: + dwarf_value (const gdb_byte* contents, struct type *type) + { + size_t type_len = TYPE_LENGTH (type); + m_contents.reset ((gdb_byte *) xzalloc (type_len)); + + memcpy (m_contents.get (), contents, type_len); + m_type = type; + } + + dwarf_value (ULONGEST value, struct type *type) + { + m_contents.reset ((gdb_byte *) xzalloc (TYPE_LENGTH (type))); + + pack_unsigned_long (m_contents.get (), type, value); + m_type = type; + } + + dwarf_value (LONGEST value, struct type *type) + { + m_contents.reset ((gdb_byte *) xzalloc (TYPE_LENGTH (type))); + + pack_long (m_contents.get (), type, value); + m_type = type; + } + + virtual ~dwarf_value () = default; + + const gdb_byte* get_contents () const + { + return m_contents.get (); + } + + struct type* get_type () const + { + return m_type; + } + + LONGEST to_long () const + { + return unpack_long (m_type, m_contents.get ()); + } + +private: + /* Value contents as a stream of bytes in target byte order. */ + gdb::unique_xmalloc_ptr m_contents; + + /* Type of the value held by the entry. */ + struct type *m_type; +}; + +/* Location description entry found on a DWARF expression evaluation stack. + + Types of locations descirbed can be: register location, memory location, + implicit location, implicit pointer location, undefined location and + composite location (made out of any of the location types including + another composite location). */ + +class dwarf_location : public dwarf_entry +{ +public: + /* Not expected to be called on it's own. */ + dwarf_location (LONGEST offset = 0, LONGEST bit_suboffset = 0) + : m_initialised (true) + { + m_offset = offset; + m_offset += bit_suboffset / HOST_CHAR_BIT; + m_bit_suboffset = bit_suboffset % HOST_CHAR_BIT; + } + + virtual ~dwarf_location () = default; + + LONGEST get_offset () const + { + return m_offset; + }; + + LONGEST get_bit_suboffset () const + { + return m_bit_suboffset; + }; + + void add_bit_offset (LONGEST bit_offset) + { + LONGEST bit_total_offset = m_bit_suboffset + bit_offset; + + m_offset += bit_total_offset / HOST_CHAR_BIT; + m_bit_suboffset = bit_total_offset % HOST_CHAR_BIT; + }; + + void set_initialised (bool initialised) + { + m_initialised = initialised; + }; + + bool is_initialised () const + { + return m_initialised; + }; + +private: + /* Byte offset into the location. */ + LONGEST m_offset; + + /* Bit suboffset of the last byte. */ + LONGEST m_bit_suboffset; + + /* Whether the location is initialized. Used for non-standard + DW_OP_GNU_uninit operation. */ + bool m_initialised; +}; + +/* Undefined location description entry. This is a special location + description type that describes the location description that is + not known. */ + +class dwarf_undefined : public dwarf_location +{ +public: + dwarf_undefined (LONGEST offset = 0, LONGEST bit_suboffset = 0) + : dwarf_location (offset, bit_suboffset) + {} +}; + +class dwarf_memory : public dwarf_location +{ +public: + dwarf_memory (LONGEST offset, LONGEST bit_suboffset = 0, + bool stack = false) + : dwarf_location (offset, bit_suboffset), + m_stack (stack) + {} + + bool in_stack () const + { + return m_stack; + }; + + void set_stack (bool stack) + { + m_stack = stack; + }; +private: + /* True if the location belongs to a stack memory region. */ + bool m_stack; +}; + +/* Register location description entry. */ + +class dwarf_register : public dwarf_location +{ +public: + dwarf_register (unsigned int regnum, + LONGEST offset = 0, LONGEST bit_suboffset = 0) + : dwarf_location (offset, bit_suboffset), + m_regnum (regnum) + {} + + unsigned int get_regnum () const + { + return m_regnum; + }; + +private: + /* DWARF register number. */ + unsigned int m_regnum; +}; + +/* Implicit location description entry. Describes a location + description not found on the target but instead saved in a + gdb-allocated buffer. */ + +class dwarf_implicit : public dwarf_location +{ +public: + + dwarf_implicit (const gdb_byte* contents, size_t size, + enum bfd_endian byte_order) + { + m_contents.reset ((gdb_byte *) xzalloc (size)); + + memcpy (m_contents.get (), contents, size); + m_size = size; + m_byte_order = byte_order; + } + + const gdb_byte* get_contents () const + { + return m_contents.get (); + } + + size_t get_size () const + { + return m_size; + } + + size_t get_byte_order () const + { + return m_byte_order; + } + +private: + /* Implicit location contents as a stream of bytes in target byte-order. */ + gdb::unique_xmalloc_ptr m_contents; + + /* Contents byte stream size. */ + size_t m_size; + + /* Contents original byte order. */ + enum bfd_endian m_byte_order; +}; + +/* Implicit pointer location description entry. */ + +class dwarf_implicit_pointer : public dwarf_location +{ +public: + dwarf_implicit_pointer (dwarf2_per_objfile *per_objfile, + struct dwarf2_per_cu_data *per_cu, + int addr_size, sect_offset die_offset, + LONGEST offset, LONGEST bit_suboffset = 0) + : dwarf_location (offset, bit_suboffset), + m_per_objfile (per_objfile), m_per_cu (per_cu), + m_addr_size (addr_size), m_die_offset (die_offset) + {} + + dwarf2_per_objfile *get_per_objfile () const + { + return m_per_objfile; + } + + dwarf2_per_cu_data *get_per_cu () const + { + return m_per_cu; + } + + int get_addr_size () const + { + return m_addr_size; + } + + sect_offset get_die_offset () const + { + return m_die_offset; + } + +private: + /* Per object file data of the implicit pointer. */ + dwarf2_per_objfile *m_per_objfile; + + /* Compilation unit context of the implicit pointer. */ + struct dwarf2_per_cu_data *m_per_cu; + + /* Address size for the evaluation. */ + int m_addr_size; + + /* DWARF die offset pointed by the implicit pointer. */ + sect_offset m_die_offset; +}; + +/* Composite location description entry. */ + +class dwarf_composite : public dwarf_location +{ +public: + dwarf_composite (LONGEST offset = 0, LONGEST bit_suboffset = 0) + : dwarf_location (offset, bit_suboffset) + {} + + /* A composite location gets detached from its factory object for + the purpose of lval_computed resolution, which means that it + needs to take care of garbage collecting its pieces. */ + ~dwarf_composite () override + { + for (unsigned int i = 0; i < m_pieces.size (); i++) + { + dwarf_location* location = m_pieces[i].m_location; + + location->decref (); + + if (location->refcount () == 0) + delete location; + } + } + + void add_piece (dwarf_location* location, ULONGEST bit_size) + { + gdb_assert (location != nullptr); + location->incref (); + m_pieces.emplace_back (location, bit_size); + } + + const dwarf_location* get_piece_at (unsigned int index) const + { + gdb_assert (index < m_pieces.size ()); + return m_pieces[index].m_location; + } + + ULONGEST get_bit_size_at (unsigned int index) const + { + gdb_assert (index < m_pieces.size ()); + return m_pieces[index].m_size; + } + + size_t get_pieces_num () const + { + return m_pieces.size (); + } + +private: + /* Composite piece that contains a piece location + description and it's size. */ + class piece + { + public: + piece (dwarf_location *location, ULONGEST size) + : m_location (location), + m_size (size) + {} + + dwarf_location *m_location; + ULONGEST m_size; + }; + + /* Vector of composite pieces. */ + std::vector m_pieces; +}; + struct piece_closure { /* Reference count. */ diff --git a/gdb/value.c b/gdb/value.c index eba5bce6d2e..5f52c2d566d 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -3401,7 +3401,7 @@ pack_long (gdb_byte *buf, struct type *type, LONGEST num) /* Pack NUM into BUF using a target format of TYPE. */ -static void +void pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num) { LONGEST len; diff --git a/gdb/value.h b/gdb/value.h index d026c8ed950..2eaba574875 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -677,6 +677,8 @@ extern struct value *value_field_bitfield (struct type *type, int fieldno, const struct value *val); extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num); +extern void pack_unsigned_long (gdb_byte *buf, struct type *type, + ULONGEST num); extern struct value *value_from_longest (struct type *type, LONGEST num); extern struct value *value_from_ulongest (struct type *type, ULONGEST num);