--- /dev/null
+/* elfutils::dwarf_data common internal templates.
+ Copyright (C) 2009 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include "dwarf_data"
+
+template<typename v, typename subtype>
+static inline bool is_a (const typename v::value_dispatch *value)
+{
+ return dynamic_cast<const subtype *> (value) != NULL;
+}
+
+namespace elfutils
+{
+ template<class impl, typename v>
+ dwarf::value_space
+ dwarf_data::attr_value<impl, v>::what_space () const
+ {
+ if (is_a<v, typename v::value_flag> (_m_value))
+ return dwarf::VS_flag;
+ if (is_a<v, typename v::value_dwarf_constant> (_m_value))
+ return dwarf::VS_dwarf_constant;
+ if (is_a<v, typename v::value_reference> (_m_value))
+ return dwarf::VS_reference;
+ if (is_a<v, typename v::value_lineptr> (_m_value))
+ return dwarf::VS_lineptr;
+ if (is_a<v, typename v::value_macptr> (_m_value))
+ return dwarf::VS_macptr;
+ if (is_a<v, typename v::value_rangelistptr> (_m_value))
+ return dwarf::VS_rangelistptr;
+ if (is_a<v, typename v::value_identifier> (_m_value))
+ return dwarf::VS_identifier;
+ if (is_a<v, typename v::value_string> (_m_value))
+ return dwarf::VS_string;
+ if (is_a<v, typename v::value_source_file> (_m_value))
+ return dwarf::VS_source_file;
+ if (is_a<v, typename v::value_source_line> (_m_value))
+ return dwarf::VS_source_line;
+ if (is_a<v, typename v::value_source_column> (_m_value))
+ return dwarf::VS_source_column;
+ if (is_a<v, typename v::value_address> (_m_value))
+ return dwarf::VS_address;
+ if (is_a<v, typename v::value_constant> (_m_value)
+ || is_a<v, typename v::value_constant_block> (_m_value))
+ return dwarf::VS_constant;
+ if (is_a<v, typename v::value_location> (_m_value))
+ return dwarf::VS_location;
+
+ throw std::logic_error ("attr_value has no known value_space!");
+ }
+
+ template<typename attr_pair>
+ static inline std::string
+ attribute_string (const attr_pair &attr)
+ {
+ std::string result = dwarf::attributes::name (attr.first);
+ result += "=";
+ result += attr.second.to_string ();
+ return result;
+ }
+
+ template<typename die_type>
+ std::string
+ die_string (const die_type &die)
+ {
+ std::string result ("<");
+ result += dwarf::tags::name (die.tag ());
+
+ typename die_type::attributes_type::const_iterator name_attr
+ = die.attributes ().find (::DW_AT_name);
+ if (name_attr != die.attributes ().end ())
+ {
+ result += " ";
+ result += to_string (*name_attr);
+ }
+
+ result += die.has_children () ? ">" : "/>";
+ return result;
+ }
+
+};
--- /dev/null
+/* -*- C++ -*- interfaces for libdw.
+ Copyright (C) 2009-2011 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF
+#define _ELFUTILS_DWARF 1
+
+#include "libdw.h"
+#include "dwarf.h"
+#include "subr.hh"
+#include <stdexcept>
+
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <tr1/unordered_map>
+
+/* Abstractly, one DWARF object file consists of a few containers.
+ (We omit .debug_frame for now. It does not interact with the others.)
+
+ 1. list of compilation units (.debug_info)
+ 2. map of PC ranges to CU (.debug_aranges)
+ 3. map of global names to CU+DIE (.debug_pubnames)
+ 4. map of type names to CU+DIE (.debug_pubtypes)
+
+ These maps refer to the CUs in .debug_info and optimize lookups
+ compared to simple iteration.
+
+ A compile_unit is a debug_info_entry.
+ A debug_info_entry consists of a tag (int/enum), and two containers:
+ children and attributes. The attributes are an unordered map of name
+ (int/enum) to attribute value (complex variant record). Children are
+ in an ordered list, each also a debug_info_entry.
+
+ dwarf.compile_units () works like list<compile_unit>
+ -> compile_unit : debug_info_entry
+ .attributes () like unordered_map<int, attr_value>
+ .children () works like list<debug_info_entry>
+ -> debug_info_entry
+ .attributes ()
+ .children ()
+
+ A compile_unit is not deeply special, it's just a debug_info_entry.
+ It has its own class just for some convenience methods that only
+ make sense for a compile_unit DIE.
+
+ This is the "logical" view of the file, grafting and eliding parts of the
+ raw information that are purely the structural elements of DWARF and not
+ part of the abstract semantics. In the file reader (elfutils::dwarf),
+ these containers form a layer above the raw containers that expose the
+ file data directly (as the libdw C interfaces do).
+
+ dwarf.raw_compile_units () works like list<compile_unit>
+ -> compile_unit : debug_info_entry
+ .raw_attributes () like unordered_map<int, attr_value>
+ .raw_children () works like list<debug_info_entry>
+ -> debug_info_entry
+ .raw_attributes ()
+ .raw_children ()
+
+ compile_units () elides DW_TAG_partial_unit members,
+ raw_compile_units () includes them.
+
+ attributes () elides DW_AT_sibling, raw_attributes () includes it.
+
+ raw_children () reports DW_TAG_imported_unit as any other child.
+ children () flattens imported units into the containing list.
+
+ The == and != comparisons for dwarf and debug_info_entry objects compare
+ their logical containers, not the raw containers. The comparisons are
+ defined via templates, so you can compare elfutils::dwarf with any other
+ class that implements the same structure of containers with input iterators.
+
+ The elfutils::dwarf class and its inner classes form a thin, read-only
+ layer of virtual containers that ideally could inline away entirely to
+ calls into the C libdw API and small amounts of stack storage. The tree
+ of objects described above never exists in memory in its entirety. The
+ objects are constructed on the fly in each call to a container method.
+
+ See the dwarf_edit and dwarf_output headers for other classes that are
+ template-compatible with the "logical view" interface above, but do not
+ support any of the "raw" container variants. These == and != comparisons
+ are template-driven too, so all different classes can be compared.
+
+ The output classes have template-driven copy constructors, so they can be
+ copied from files or substructures of the elfutils::dwarf input classes.
+
+ ------ XXX to be done: more file-level containers
+
+ input side only:
+
+ units_by_addr : map<pair<begin,end>, CU> and map<address, CU>
+ use dwarf_getarange_addr
+
+ pub{names,types} : map<string, debug_info_entry> (across all CUs)
+
+ output too:
+
+ pubnames_map : map<string, debug_info_entry>
+ pub{names,types}_units : map<compile_unit, pubnames_map>
+ too much lang knowledge to autogenerate for now,
+ output will do it explicitly
+
+ */
+
+// DWARF reader interfaces: front end to <libdw.h> routines
+namespace elfutils
+{
+ template<typename type>
+ inline std::string to_string (const type &item)
+ {
+ return item.to_string ();
+ }
+
+ template<typename key1, typename value1, class pair2>
+ inline bool operator== (const std::pair<key1, value1> &a, const pair2 &b)
+ {
+ return a.first == b.first && a.second == b.second;
+ }
+
+ // Used like std::vector<elt>, but is really just a simple fixed array.
+ template<typename elt>
+ class const_vector
+ {
+ private:
+ size_t _m_size;
+ const elt *_m_array;
+
+ public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef elt value_type;
+ typedef const elt *const_iterator;
+
+ const_vector ()
+ : _m_size (0), _m_array (NULL) {}
+ const_vector (const const_vector &v)
+ : _m_size (v._m_size), _m_array (v._m_array) {}
+ const_vector (const elt *start, const elt *stop)
+ : _m_size (stop - start), _m_array (start) {}
+ const_vector (const ::Dwarf_Block &b)
+ : _m_size (b.length), _m_array (reinterpret_cast<const elt *> (b.data)) {}
+
+ inline const_vector &operator= (const const_vector &v)
+ {
+ _m_size = v._m_size;
+ _m_array = v._m_array;
+ return *this;
+ }
+
+ inline size_t size () const
+ {
+ return _m_size;
+ }
+ inline bool empty () const
+ {
+ return _m_size == 0;
+ }
+
+ const_iterator begin () const
+ {
+ return _m_array;
+ }
+ const_iterator end () const
+ {
+ return &_m_array[_m_size];
+ }
+
+ template<typename other>
+ inline operator other () const
+ {
+ return other (begin (), end ());
+ }
+
+ template<typename vec>
+ inline bool operator== (const vec &other) const
+ {
+ return (other.size () == size ()
+ && std::equal (begin (), end (), other.begin ()));
+ }
+ template<typename vec>
+ inline bool operator!= (const vec &other) const
+ {
+ return !(*this == other);
+ }
+
+ };
+
+ // One DWARF object file.
+ class dwarf
+ {
+ private:
+ static const char *known_tag (int);
+ static const char *known_attribute (int);
+
+ public:
+ typedef subr::known<__typeof ("DW_TAG_"), known_tag> tags;
+ typedef subr::known<__typeof ("DW_AT_"), known_attribute> attributes;
+
+ template<typename attribute>
+ static inline std::string attribute_name (const attribute &attr)
+ {
+ int code = attr.first;
+ return attributes::name (code);
+ }
+
+ template<int key>
+ class known_enum
+ {
+ public:
+ static size_t prefix_length ();
+ static const char *identifier (int);
+ inline static const char *name (int value)
+ {
+ const char *id = identifier (value);
+ return id != NULL ? id + prefix_length () : NULL;
+ }
+
+ // XXX perhaps have iterator/lookup methods like a read-only map?
+ };
+
+ typedef known_enum< ::DW_AT_producer> forms;
+ typedef known_enum< ::DW_AT_location> ops;
+
+ private:
+ static void throw_libdw (::Dwarf *dw); // XXX raises (...)
+ static void throw_libdw (::Dwarf_CU *); // XXX raises (...)
+
+ inline void xif (bool fail) const
+ {
+ if (unlikely (fail))
+ throw_libdw (_m_dw);
+ }
+ static inline void xif (::Dwarf_CU *cu, bool fail)
+ {
+ if (unlikely (fail))
+ throw_libdw (cu);
+ }
+
+ static inline void xif (const ::Dwarf_Attribute *attr, bool fail)
+ {
+ xif (attr->cu, fail);
+ }
+ static inline void xif (const ::Dwarf_Die *die, bool fail)
+ {
+ xif (die->cu, fail);
+ }
+
+ template<typename raw, typename raw_element, typename element,
+ bool skip (const raw_element &)>
+ class skipping_wrapper
+ {
+ protected:
+ typedef typename raw::const_iterator raw_iterator;
+
+ raw _m_raw;
+
+ protected:
+ inline skipping_wrapper (const raw &r) : _m_raw (r) {}
+
+ public:
+ inline skipping_wrapper (const skipping_wrapper &w) : _m_raw (w._m_raw) {}
+
+ /*
+ iterator: wraps raw iterator, skips DW_AT_sibling
+ size/empty: search for DW_AT_sibling, adjust raw size
+ */
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, element>
+ {
+ friend class skipping_wrapper<raw, raw_element, element, skip>;
+ private:
+ raw_iterator _m_raw;
+ const raw_iterator _m_end;
+
+ inline void jiggle ()
+ {
+ while (_m_raw != _m_end && unlikely (skip (*_m_raw)))
+ ++_m_raw;
+ }
+
+ public:
+ inline const_iterator ()
+ : _m_raw (), _m_end (raw::end ())
+ {
+ }
+
+ const_iterator (const const_iterator &i)
+ : _m_raw (i._m_raw), _m_end (i._m_end) {}
+
+ // Start at the raw position and skip as necessary.
+ const_iterator (const raw_iterator &begin, const raw_iterator &end)
+ : _m_raw (begin), _m_end (end)
+ {
+ jiggle ();
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_raw = other._m_raw;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return _m_raw == other._m_raw;
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ struct hasher : public std::unary_function<const_iterator, size_t>
+ {
+ size_t operator () (const const_iterator &i) const
+ {
+ return subr::hash_this (i._m_raw);
+ }
+ };
+
+ inline const_iterator &operator++ () // prefix
+ {
+ ++_m_raw;
+ jiggle ();
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+
+ inline element operator* () const
+ {
+ return static_cast<element> (*_m_raw);
+ }
+ };
+
+ inline const_iterator begin () const
+ {
+ return const_iterator (_m_raw.begin (), _m_raw.end ());
+ }
+ inline const_iterator end () const
+ {
+ const raw_iterator raw_end = _m_raw.end ();
+ return const_iterator (raw_end, raw_end);
+ }
+ };
+
+ public:
+ /*
+ getstring
+ */
+
+ class attribute;
+ class attr_value;
+ class location_attr;
+ class range_list;
+ class ranges;
+ class line_info_table;
+ class file_table;
+ class line_table;
+ class line_entry;
+ class dwarf_enum;
+
+ class debug_info_entry
+ {
+ private:
+ ::Dwarf_Die _m_die;
+ inline ::Dwarf_Die *thisdie () const
+ {
+ return const_cast< ::Dwarf_Die *> (&_m_die);
+ }
+
+ friend class dwarf;
+ friend class attr_value;
+ protected:
+
+ inline void xif (bool fail) const
+ {
+ dwarf::xif (_m_die.cu, fail);
+ }
+
+ inline debug_info_entry ()
+ {
+ memset (&_m_die, 0, sizeof _m_die);
+ }
+
+ public:
+ debug_info_entry (const debug_info_entry &die) : _m_die (die._m_die) {}
+
+ inline debug_info_entry (const dwarf &dw, ::Dwarf_Off off)
+ {
+ dw.xif (::dwarf_offdie (dw._m_dw, off, &_m_die) == NULL);
+ }
+
+ /* Return the compile_unit entry containing this entry.
+ Note this might be a DW_TAG_partial_unit. */
+ inline debug_info_entry compile_unit () const
+ {
+ debug_info_entry result;
+ xif (::dwarf_diecu (thisdie (), &result._m_die, NULL, NULL) == NULL);
+ return result;
+ }
+
+ // Containers, see class definitions below.
+ class raw_children_type;
+ inline raw_children_type raw_children () const;
+ class raw_attributes_type;
+ raw_attributes_type raw_attributes () const;
+ class children_type;
+ inline children_type children () const;
+ class attributes_type;
+ attributes_type attributes () const;
+
+ class const_pointer;
+
+ inline std::string to_string () const;
+
+ inline int tag () const
+ {
+ int t = ::dwarf_tag (thisdie ());
+ xif (t <= 0);
+ return t;
+ }
+
+ bool has_children () const
+ {
+ int has = ::dwarf_haschildren (thisdie ());
+ xif (has < 0);
+ return has != 0;
+ }
+
+ /*
+ const char *tag_name () const
+ const_string tag_name () const // "name" or "0x123"
+ */
+
+ template<typename die>
+ bool operator== (const die &other) const
+ {
+ return (tag () == other.tag ()
+ && attributes () == other.attributes ()
+ && children () == other.children ());
+ }
+ template<typename die>
+ bool operator!= (const die &other) const
+ {
+ return !(*this == other);
+ }
+
+ ::Dwarf_Off offset () const
+ {
+ return ::dwarf_dieoffset (thisdie ());
+ }
+
+ inline const dwarf::ranges ranges () const
+ {
+ return dwarf::ranges (*this);
+ }
+
+ /* This is an identity pointer that only matches the very same
+ DIE in the very same file (same opened Dwarf instance). */
+ typedef uintptr_t identity_type;
+ inline identity_type identity () const
+ {
+ return (uintptr_t) _m_die.addr;
+ }
+
+ ::Dwarf_Off cost () const;
+ };
+
+ // Container for raw list of child DIEs, intended to be a compatible with
+ // a read-only, unidirectional subset of std::list<debug_info_entry>.
+ class debug_info_entry::raw_children_type
+ {
+ friend class debug_info_entry;
+ private:
+ const debug_info_entry &_m_die;
+
+ protected:
+ inline raw_children_type (const debug_info_entry &die) : _m_die (die) {}
+
+ public:
+ typedef debug_info_entry value_type;
+
+ inline raw_children_type (const raw_children_type &c)
+ : _m_die (c._m_die)
+ {}
+
+ bool empty () const
+ {
+ return begin () == end ();
+ }
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, debug_info_entry>
+ {
+ friend class debug_info_entry;
+ friend class attr_value;
+ private:
+ debug_info_entry _m_die;
+
+ inline const_iterator ()
+ {}
+
+ inline const_iterator (const debug_info_entry &parent)
+ {
+ int result = ::dwarf_child (parent.thisdie (), &_m_die._m_die);
+ parent.xif (result < 0);
+ }
+
+ // Construct from a reference attribute.
+ inline const_iterator (Dwarf_Attribute *attr)
+ {
+ dwarf::xif (attr, ::dwarf_formref_die (attr, &_m_die._m_die) == NULL);
+ }
+
+ public:
+ inline const_iterator (const const_iterator &i) : _m_die (i._m_die) {}
+
+ inline const debug_info_entry &operator* () const
+ {
+ if (unlikely (_m_die._m_die.addr == NULL))
+ throw std::runtime_error ("dereferencing end iterator");
+ return _m_die;
+ }
+ inline const debug_info_entry *operator-> () const
+ {
+ return &(operator* ());
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_die = other._m_die;
+ return *this;
+ }
+
+ // Assign directly from a DIE, as if "taking its address".
+ inline const_iterator &operator= (const debug_info_entry &die)
+ {
+ _m_die = die;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return _m_die._m_die.addr == other._m_die._m_die.addr;
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ struct hasher : public std::unary_function<const_iterator, size_t>
+ {
+ size_t operator () (const const_iterator &i) const
+ {
+ return subr::hash_this ((uintptr_t) i._m_die._m_die.addr);
+ }
+ };
+
+ inline const_iterator &operator++ () // prefix
+ {
+ int result = ::dwarf_siblingof (&_m_die._m_die, &_m_die._m_die);
+ _m_die.xif (result < 0);
+ if (result > 0) // Hit the end.
+ *this = const_iterator ();
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+ };
+ const_iterator begin () const
+ {
+ return const_iterator (_m_die);
+ }
+ static inline const_iterator end ()
+ {
+ return const_iterator ();
+ }
+
+ template<typename other_children>
+ bool operator== (const other_children &other) const
+ {
+ return subr::container_equal (*this, other);
+ }
+ template<typename other_children>
+ bool operator!= (const other_children &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // Container for list of raw attributes as (name, value) pairs,
+ // intended to be compatible with a read-only, unidirectional
+ // subset of std::list<std::pair<int, attr_value>>.
+ class debug_info_entry::raw_attributes_type
+ {
+ friend class debug_info_entry;
+ private:
+ const debug_info_entry &_m_die;
+
+ raw_attributes_type (const debug_info_entry &die)
+ : _m_die (die)
+ {}
+
+ public:
+ typedef attribute value_type;
+
+ inline raw_attributes_type (const raw_attributes_type &a)
+ : _m_die (a._m_die)
+ {}
+
+ size_t size () const;
+ inline bool empty () const
+ {
+ return size () == 0;
+ }
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, attribute>
+ {
+ friend class raw_attributes_type;
+ private:
+ debug_info_entry _m_die;
+ ptrdiff_t _m_offset; // Offset for next iteration in dwarf_getattrs.
+ ::Dwarf_Attribute _m_attr;
+
+ /* We get called up to twice per iteration. The first time, we
+ store *ATTR in the instance variable and return DWARF_CB_OK so
+ that we might be called again. The second time, we return
+ DWARF_CB_ABORT so that the iteration will stop at the next
+ attribute's offset. */
+ static int getattrs_callback (Dwarf_Attribute *attr, void *arg)
+ {
+ const_iterator *i = static_cast<const_iterator *> (arg);
+ if (i->_m_attr.valp == NULL)
+ {
+ i->_m_attr = *attr;
+ return DWARF_CB_OK;
+ }
+ return DWARF_CB_ABORT;
+ }
+
+ inline const_iterator (const debug_info_entry &die, ptrdiff_t offset)
+ : _m_die (die), _m_offset (offset), _m_attr ()
+ {}
+
+ inline const_iterator (ptrdiff_t offset)
+ : _m_die (), _m_offset (offset), _m_attr ()
+ {}
+
+ public:
+ // Default constructor: invalid for anything but operator=.
+ inline const_iterator ()
+ : _m_die (), _m_offset (-1), _m_attr ()
+ {}
+
+ inline const_iterator (const const_iterator &i)
+ : _m_die (i._m_die), _m_offset (i._m_offset), _m_attr (i._m_attr)
+ {}
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_die = other._m_die;
+ _m_offset = other._m_offset;
+ _m_attr = other._m_attr;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return (_m_die._m_die.addr == other._m_die._m_die.addr
+ && _m_attr.valp == other._m_attr.valp);
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline const_iterator &operator++ () // prefix
+ {
+ _m_attr.valp = NULL;
+ int result = ::dwarf_getattrs (&_m_die._m_die, &getattrs_callback,
+ (void *) this, _m_offset);
+ _m_die.xif (result < 0);
+ _m_offset = result;
+ if (result == 1)
+ // End iterators have no live pointers.
+ _m_die._m_die.addr = NULL;
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+
+ inline attribute operator* () const
+ {
+ if (unlikely (_m_attr.valp == NULL))
+ throw std::runtime_error ("dereferencing end iterator");
+ return attribute (_m_die, _m_attr);
+ }
+ };
+ inline const_iterator begin () const
+ {
+ const_iterator i = const_iterator (_m_die, 0);
+ return ++i;
+ }
+ static inline const_iterator end ()
+ {
+ return const_iterator (1);
+ }
+
+ // XXX can do faster internal (?)
+ inline const_iterator find (int name) const
+ {
+ const_iterator i = begin ();
+ while (i != end () && (*i).first != name)
+ ++i;
+ return i;
+ }
+ };
+
+ // Container for list of child DIEs, intended to be a compatible with
+ // a read-only, unidirectional subset of std::list<debug_info_entry>.
+ // Same as raw_children, but flattens DW_TAG_imported_unit children.
+ class debug_info_entry::children_type
+ : public debug_info_entry::raw_children_type
+ {
+ friend class debug_info_entry;
+ private:
+
+ inline children_type (const debug_info_entry &die)
+ : raw_children_type::raw_children_type (die) {}
+
+ public:
+ typedef debug_info_entry value_type;
+
+ inline children_type (const children_type &c)
+ : raw_children_type (c)
+ {}
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, debug_info_entry>
+ {
+ friend class children_type;
+ private:
+
+ typedef raw_children_type::const_iterator raw_iterator;
+ subr::sharing_stack<raw_iterator> _m_stack;
+
+ /* Push and pop until _m_stack.top () == raw_children_type::end ()
+ or it's looking at a DIE other than DW_TAG_imported_unit. */
+ inline void jiggle ()
+ {
+ while (true)
+ {
+ const raw_iterator &i = _m_stack.const_top ();
+
+ if (i == raw_children_type::end ())
+ {
+ /* We're at the end of this raw DIE.
+ Pop out to the iterator on the importing unit. */
+ _m_stack.pop ();
+
+ if (_m_stack.empty ())
+ // That was the outermost unit, this is the end.
+ break;
+
+ continue;
+ }
+
+ if (i->tag () == ::DW_TAG_imported_unit)
+ // We have an imported unit. Look at its referent.
+ _m_stack.push (i->attributes ().at (::DW_AT_import)
+ .reference ()->raw_children ().begin ());
+ else
+ // This is some other DIE. Iterate on it.
+ break;
+ }
+ }
+
+ public:
+ inline const_iterator ()
+ : _m_stack ()
+ {}
+
+ inline const_iterator (const raw_iterator &i)
+ {
+ _m_stack.push (i);
+ jiggle ();
+ }
+
+ inline const_iterator (const const_iterator &i)
+ : _m_stack (i._m_stack)
+ {}
+
+ // Construct directly from a DIE, as if "taking its address".
+ inline const_iterator (const debug_info_entry &die)
+ {
+ raw_iterator it;
+ it = die;
+ _m_stack.push (it);
+ jiggle ();
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_stack = other._m_stack;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return _m_stack == other._m_stack;
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline const debug_info_entry &operator* () const
+ {
+ return *_m_stack.top ();
+ }
+ inline const debug_info_entry *operator-> () const
+ {
+ return &(operator* ());
+ }
+
+ inline const_iterator &operator++ () // prefix
+ {
+ ++_m_stack.top ();
+ jiggle ();
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+ };
+
+ // Actually always const.
+ typedef const_iterator iterator;
+
+ const_iterator begin () const
+ {
+ return const_iterator (raw_children_type::begin ());
+ }
+ const_iterator end () const
+ {
+ return const_iterator (raw_children_type::end ());
+ }
+
+ template<typename other_children>
+ bool operator== (const other_children &other) const
+ {
+ return subr::container_equal (*this, other);
+ }
+ template<typename other_children>
+ bool operator!= (const other_children &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ class debug_info_entry::const_pointer
+ : public debug_info_entry::children_type::const_iterator
+ {};
+
+ private:
+ static inline bool skip_sibling (const attribute &attr)
+ {
+ return attr.first == ::DW_AT_sibling;
+ }
+
+ // Circumvent C++ namespace lookup.
+ typedef class debug_info_entry::raw_attributes_type die_raw_attrs;
+ typedef skipping_wrapper<die_raw_attrs, attribute, attribute, skip_sibling>
+ attributes_base;
+
+ public:
+ // Container for attributes, indexed by name, intended to be compatible
+ // with a read-only subset of std::unordered_map<int, attr_value>.
+ // This excludes DW_AT_sibling.
+ class debug_info_entry::attributes_type : public attributes_base
+ {
+ friend class dwarf;
+ private:
+ inline attributes_type (const raw_attributes_type &raw)
+ : attributes_base (raw) {}
+
+ public:
+ typedef int key_type;
+ typedef attr_value mapped_type;
+ typedef attribute value_type;
+
+ static inline bool ordered ()
+ {
+ return false;
+ }
+
+ inline attributes_type (const attributes_type &a)
+ : attributes_base (a)
+ {}
+
+ typedef attributes_base::const_iterator const_iterator;
+
+ /*
+ iterator: wraps raw_attributes iterator, skips DW_AT_sibling
+ size/empty: search for DW_AT_sibling, adjust raw_attributes size
+ */
+
+ inline const_iterator find (int name) const
+ {
+ if (unlikely (name == ::DW_AT_sibling))
+ return end ();
+ return const_iterator (_m_raw.find (name), _m_raw.end ());
+ }
+
+ /*
+ Same as find (), but if the attribute name isn't found,
+ but there is is an abstract_origin or specification
+ attribute, then will try to find_integrate () the name
+ from that reference.
+ */
+ inline const_iterator find_integrate (int name) const
+ {
+ const_iterator result = find (name);
+ if (result != end ())
+ return result;
+
+ result = find (DW_AT_abstract_origin);
+ if (result == end ())
+ result = find (DW_AT_specification);
+
+ if (result != end ())
+ {
+ debug_info_entry integrate = (*(*result).second.reference ());
+ return integrate.attributes ().find_integrate (name);
+ }
+
+ return end ();
+ }
+
+ inline const attr_value at (int name)
+ {
+ const_iterator i = find (name);
+ if (unlikely (i == end ()))
+ throw std::out_of_range ("XXX");
+ return (*i).second;
+ }
+ inline const attr_value operator[] (int name)
+ {
+ return at (name);
+ }
+
+ // We are rvalue-coercible into a std::map, which is sorted by name.
+ inline operator std::map<int, attr_value> () const
+ {
+ return std::map<int, attr_value> (begin (), end ());
+ }
+ /*
+ template<typename attrs>
+ inline operator attrs () const
+ {
+ return attrs (begin (), end ());
+ }
+ */
+
+ template<typename attrs>
+ bool operator== (const attrs &other) const
+ {
+ /* Our container is unordered (i.e., in file order). A set of
+ attributes is conceptually equal if all the pairs match,
+ regardless of the order. But the container_equal algorithm will
+ compare corresponding elements in order. So we need an ordered
+ map of our attributes for the comparison. */
+ const std::map<int, attr_value> mine = *this;
+ const std::map<int, typename attrs::mapped_type> his = other;
+ return mine.size () == his.size () && subr::container_equal (mine, his);
+ }
+
+ template<typename attrs>
+ bool operator!= (const attrs &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ class compile_unit : public debug_info_entry
+ {
+ public:
+ inline compile_unit (const debug_info_entry &die)
+ : debug_info_entry (die) {}
+
+ // Fetch the CU's DW_AT_stmt_list.
+ const line_info_table line_info () const;
+
+ // Convenience methods for line_info_table sub-containers.
+ inline const file_table files () const
+ {
+ return line_info ().files ();
+ }
+ inline const line_table lines () const
+ {
+ return line_info ().lines ();
+ }
+
+ /*
+ containers/iterators:
+
+ XXX macros
+
+ abbrevs (punt)
+
+ */
+ };
+
+ // These are the kinds of values that attributes can have.
+ enum value_space
+ {
+ // These spaces refer purely to DWARF concepts.
+ VS_flag, // Boolean.
+ VS_dwarf_constant, // Known DW_X_* space of integer constants.
+ VS_discr_list, // Block as used for DW_AT_discr_list.
+ VS_reference, // Pointer to another DIE.
+ VS_lineptr, // Pointer into .debug_line section.
+ VS_macptr, // Pointer into .debug_macinfo section.
+ VS_rangelistptr, // Pointer into .debug_ranges section.
+
+ // These spaces refer to textual details of the program source.
+ VS_identifier, // String, identifier in source language.
+ VS_string, // String, miscellaneous use.
+ VS_source_file, // Source file, string or index into file table.
+ VS_source_line, // Line number in source file.
+ VS_source_column, // Column number in source file.
+
+ // These spaces refer to target-format values in the debuggee.
+ VS_address, // Address constant.
+ VS_constant, // Other constant, integer or in target formats.
+ VS_location, // Location expression or location list.
+ };
+
+ /* A source file can be just a file name. When represented in the
+ .debug_line file table, it can also have a modtime and a file size.
+ If the modtime or size stored is zero, it doesn't count. */
+ class source_file
+ {
+ friend class attr_value;
+ friend class file_table;
+ friend class line_entry;
+ private:
+ ::Dwarf_Attribute _m_attr;
+ inline ::Dwarf_Attribute *thisattr () const
+ {
+ return const_cast< ::Dwarf_Attribute *> (&_m_attr);
+ }
+
+ source_file (const Dwarf_Attribute &attr) : _m_attr (attr) {}
+
+ public:
+ std::string to_string () const;
+
+ const char *name () const;
+ ::Dwarf_Word mtime () const;
+ ::Dwarf_Word size () const;
+
+ template<typename other_file>
+ bool operator== (const other_file &other) const
+ {
+ if (mtime () != 0)
+ {
+ ::Dwarf_Word other_mtime = other.mtime ();
+ if (other_mtime != 0 && other_mtime != mtime ())
+ return false;
+ }
+ if (size () != 0)
+ {
+ ::Dwarf_Word other_size = other.size ();
+ if (other_size != 0 && other_size != size ())
+ return false;
+ }
+ return subr::name_equal<typeof (other.name ())> () (name (),
+ other.name ());
+ }
+ template<typename other_file>
+ inline bool operator!= (const other_file &other) const
+ {
+ return !(*this == other);
+ }
+
+ /* Return a value unique to us while we're in memory.
+ This is a stable pointer into the Dwarf_Files data
+ or to a static empty string. */
+ inline uintptr_t identity () const
+ {
+ return (uintptr_t) name ();
+ }
+ };
+
+ // This describes the value of an attribute.
+ class attr_value
+ {
+ friend class attribute;
+ friend class location_attr;
+ friend class range_list;
+ friend class dwarf_enum;
+ private:
+ const int _m_tag;
+ ::Dwarf_Attribute _m_attr;
+ inline ::Dwarf_Attribute *thisattr () const
+ {
+ return const_cast< ::Dwarf_Attribute *> (&_m_attr);
+ }
+ inline int whatattr () const
+ {
+ return ::dwarf_whatattr (thisattr ());
+ }
+
+ attr_value (int tag, const ::Dwarf_Attribute &attr)
+ : _m_tag (tag), _m_attr (attr) {}
+
+ inline bool same (const attr_value &other) const
+ {
+ return _m_attr.valp == other._m_attr.valp;
+ }
+
+ public:
+ // not copyable, don't worry about ref lifetime(?)
+ // attr_value (const attr_value &v) : _m_attr (v.attr) {}
+
+ value_space what_space () const;
+ inline std::string to_string () const;
+
+ // Return an iterator on which * will yield the referent debug_info_entry.
+ inline debug_info_entry::children_type::const_iterator
+ reference () const
+ {
+ return (debug_info_entry::raw_children_type::const_iterator
+ (thisattr ()));
+ }
+
+ // XXX reloc, dwfl
+ ::Dwarf_Addr address () const;
+
+ bool flag () const;
+
+ const location_attr location () const;
+
+ const char *string () const;
+ inline const char *identifier () const
+ {
+ return string ();
+ }
+
+ const dwarf::source_file source_file () const;
+ inline unsigned int source_line () const
+ {
+ return constant ();
+ }
+ inline unsigned int source_column () const
+ {
+ return constant ();
+ }
+
+ // XXX reloc
+ ::Dwarf_Word constant () const;
+ ::Dwarf_Sword signed_constant () const;
+ const_vector<uint8_t> constant_block () const;
+ bool constant_is_integer () const;
+
+ inline const dwarf_enum dwarf_constant () const
+ {
+ return dwarf_enum (*this);
+ }
+
+ inline const range_list ranges () const
+ {
+ return range_list (*this);
+ }
+
+ const line_info_table line_info () const;
+
+ // XXX macptr
+
+ template<typename value>
+ inline bool operator== (const value &other) const
+ {
+ const value_space what = what_space ();
+ if (likely (other.what_space () == what))
+ switch (what)
+ {
+ case VS_reference:
+ // Stateless reference equality is just identity.
+ return (reference ()->identity ()
+ == other.reference ()->identity ());
+
+ case VS_flag:
+ return flag () == other.flag ();
+
+ case VS_rangelistptr:
+ return ranges () == other.ranges ();
+
+ case VS_lineptr:
+ return line_info () == other.line_info ();
+
+ case VS_macptr: // XXX punt for now, treat as constant
+ /*FALLTHRU*/
+ case VS_dwarf_constant:
+ return constant () == other.constant ();
+
+ case VS_constant:
+ if (constant_is_integer ())
+ return (other.constant_is_integer ()
+ && constant () == other.constant ());
+ return (!other.constant_is_integer ()
+ && constant_block () == other.constant_block ());
+
+ case VS_source_line:
+ return source_line () == other.source_line ();
+ case VS_source_column:
+ return source_column () == other.source_column ();
+
+ case VS_identifier:
+ return subr::name_equal<typeof (other.identifier ())> ()
+ (identifier (), other.identifier ());
+
+ case VS_string:
+ return subr::name_equal<typeof (other.string ())> ()
+ (string (), other.string ());
+
+ case VS_address:
+ return address () == other.address ();
+
+ case VS_source_file:
+ return source_file () == other.source_file ();
+
+ case VS_location:
+ return location () == other.location ();
+
+ case VS_discr_list:
+ throw std::runtime_error ("XXX unimplemented");
+ }
+ return false;
+ }
+ template<typename value>
+ inline bool operator!= (const value &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ /* The DW_AT_ranges attribute yields a range list.
+ XXX reloc
+ This is equivalent to unordered_set<pair<Dwarf_Addr, Dwarf_Addr> >. */
+ class range_list
+ {
+ friend class attr_value;
+ private:
+ const attr_value _m_attr;
+
+ range_list (const attr_value &attr) : _m_attr (attr) {}
+
+ public:
+ typedef std::pair< ::Dwarf_Addr, ::Dwarf_Addr> key_type; // XXX reloc
+ typedef key_type value_type;
+
+ static inline bool ordered ()
+ {
+ return false;
+ }
+
+ inline bool canonical () const
+ {
+ return false;
+ }
+
+ inline range_list (const range_list &other)
+ : _m_attr (other._m_attr)
+ {}
+
+ std::string to_string () const;
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, value_type>
+ {
+ friend class range_list;
+ protected:
+ ::Dwarf_Addr _m_base; // XXX reloc
+ ::Dwarf_Addr _m_begin; // XXX reloc
+ ::Dwarf_Addr _m_end; // XXX reloc
+ ::Dwarf_CU *_m_cu;
+ unsigned char *_m_readptr;
+
+ static unsigned char *formptr (int secndx, Dwarf_Attribute *);
+ const_iterator (int secndx, Dwarf_Attribute *, unsigned char *readptr);
+
+ public:
+ // Default constructor: only valid for operator=.
+ inline const_iterator ()
+ : _m_base (-1), _m_begin (0), _m_end (0), _m_cu (NULL), _m_readptr ((unsigned char *)1)
+ {}
+
+ inline const_iterator (const const_iterator &i)
+ : _m_base (i._m_base), _m_begin (i._m_begin), _m_end (i._m_end),
+ _m_cu (i._m_cu), _m_readptr (i._m_readptr)
+ {}
+
+ inline value_type operator* () const
+ {
+ if (unlikely (_m_readptr == (unsigned char *)-1))
+ throw std::runtime_error ("dereferencing end iterator");
+ return std::make_pair (_m_base + _m_begin, _m_base + _m_end);
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_base = other._m_base;
+ _m_begin = other._m_begin;
+ _m_end = other._m_end;
+ _m_cu = other._m_cu;
+ _m_readptr = other._m_readptr;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return _m_readptr == other._m_readptr && _m_cu == other._m_cu;
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ const_iterator &operator++ (); // prefix
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+ };
+
+ const_iterator begin () const;
+ const_iterator end () const
+ {
+ return const_iterator (-1, _m_attr.thisattr (), (unsigned char *)-1);
+ }
+
+ const_iterator find (const key_type &match) const
+ {
+ return std::find (begin (), end (), match);
+ }
+
+ private:
+ struct entry_contains
+ : public std::binary_function<key_type, ::Dwarf_Addr, bool>
+ {
+ inline bool operator() (const key_type &range, const ::Dwarf_Addr addr)
+ const
+ {
+ return addr >= range.first && addr < range.second;
+ }
+ };
+
+ public:
+ const_iterator find (const ::Dwarf_Addr addr) const
+ {
+ return std::find_if (begin (), end (),
+ std::bind2nd (entry_contains (), addr));
+ }
+
+ inline operator std::set<key_type> () const
+ {
+ return std::set<key_type> (begin (), end ());
+ }
+
+ template<typename ranges>
+ inline bool operator== (const ranges &other) const
+ {
+ /* Our container is unordered (i.e., in file order). A range list
+ is conceptually equal if all the pairs match, regardless of the
+ order. But the std::equal algorithm will compare corresponding
+ elements in order. So we need an ordered set for comparison. */
+ std::set<key_type> mine = *this;
+ coalesce (mine);
+ std::set<key_type> his = other;
+ coalesce (his);
+ return mine == his;
+ }
+ template<typename ranges>
+ inline bool operator!= (const ranges &other) const
+ {
+ return !(*this == other);
+ }
+
+ // Not very wise to call.
+ size_t size () const
+ {
+ return subr::length (begin (), end ());
+ }
+ };
+
+ /* A location attribute yields a location expression.
+ Either it's a single expression, or a map of PC to location. */
+ class location_attr
+ {
+ friend class attr_value;
+ private:
+ attr_value _m_attr;
+
+ location_attr (const attr_value &attr) : _m_attr (attr) {}
+
+ inline bool same (const location_attr &it) const
+ {
+ return _m_attr.same (it._m_attr);
+ }
+
+ template<typename pair>
+ struct nonempty : public std::unary_function<pair, bool>
+ {
+ inline bool operator () (const pair &x)
+ {
+ return !x.second.empty ();
+ }
+ };
+
+ template<typename pair>
+ struct any : public std::unary_function<pair, bool>
+ {
+ inline bool operator () (const pair &)
+ {
+ return true;
+ }
+ };
+
+ public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ // XXX need proper type for exprs
+ typedef const_vector<uint8_t> mapped_type;
+ typedef std::pair< ::Dwarf_Addr, ::Dwarf_Addr> key_type; // XXX reloc
+ typedef std::pair<const key_type, mapped_type> value_type;
+
+ std::string to_string () const;
+
+ bool is_list () const;
+
+ inline mapped_type location () const
+ {
+ if (is_list ())
+ throw std::runtime_error ("location is list, not single location");
+ return _m_attr.constant_block ();
+ }
+
+ class const_iterator
+ : public range_list::const_iterator
+ {
+ friend class location_attr;
+ private:
+ ::Dwarf_Block _m_block;
+
+ void advance ();
+
+ // For end iterator.
+ inline explicit const_iterator (Dwarf_Attribute *attr)
+ : dwarf::range_list::const_iterator (-1, attr, (unsigned char *)-1)
+ , _m_block ()
+ {}
+
+ public:
+ typedef location_attr::value_type value_type;
+
+ inline const_iterator ()
+ : _m_block ()
+ {}
+
+ inline const_iterator (const const_iterator &i)
+ : range_list::const_iterator (i), _m_block (i._m_block)
+ {}
+
+ inline const_iterator &operator= (const const_iterator &i)
+ {
+ range_list::const_iterator::operator= (i);
+ _m_block = i._m_block;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &it) const
+ {
+ return _m_block.data == it._m_block.data;
+ }
+ inline bool operator!= (const const_iterator &it) const
+ {
+ return !(*this == it);
+ };
+
+ const_iterator &operator++ (); // prefix
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+
+ inline value_type operator* () const
+ {
+ if (unlikely (_m_block.data == NULL))
+ throw std::runtime_error ("dereferencing end iterator");
+
+ return value_type (key_type (_m_base + _m_begin, _m_base + _m_end),
+ const_vector<uint8_t> (_m_block));
+ }
+ };
+
+ const_iterator begin () const;
+ inline const_iterator end () const
+ {
+ return const_iterator (_m_attr.thisattr ());
+ }
+
+ inline bool empty () const
+ {
+ if (is_list ())
+ return std::find_if (begin (), end (),
+ nonempty<value_type> ()) == end ();
+ return location ().empty ();
+ }
+ inline size_type size () const
+ {
+ if (is_list ())
+ return subr::length (begin (), end ());
+ return location ().empty () ? 0 : 1;
+ }
+
+ template<typename other_attr>
+ bool operator== (const other_attr &other) const
+ {
+ if (empty ())
+ return (other.empty ()
+ || std::find_if (other.begin (), other.end (),
+ nonempty<typename other_attr::value_type> ()
+ ) == other.end ());
+
+ if (!is_list () && !other.is_list ())
+ return !other.empty () && location () == other.location ();
+
+ return subr::container_equal (*this, other);
+ }
+ template<typename other_file>
+ inline bool operator!= (const other_file &other) const
+ {
+ return !(*this == other);
+ }
+
+ /*
+ XXX missing: find, at; by key_type or by PC
+ XXX worse than that: multiple overlapping matches!
+ */
+ };
+
+ /* This describes a CU's file table. It works like a read-only
+ std::vector<source_file>, and also supports lookup by name. */
+ class file_table
+ {
+ private:
+ ::Dwarf_Files *_m_files;
+
+ public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef source_file value_type;
+
+ inline file_table (::Dwarf_Files *const files)
+ : _m_files (files) {}
+ inline file_table (const file_table &t)
+ : _m_files (t._m_files) {}
+
+ inline file_table &operator= (const file_table &t)
+ {
+ _m_files = t._m_files;
+ return *this;
+ }
+
+ typedef subr::indexed_iterator<file_table> const_iterator;
+
+ inline bool empty () const
+ {
+ return size () == 0;
+ }
+
+ size_t size () const;
+
+ inline const_iterator begin () const
+ {
+ return const_iterator (*this, 0);
+ }
+ inline const_iterator end () const
+ {
+ return const_iterator (*this, size ());
+ }
+
+ const source_file at (size_t idx) const;
+ const source_file operator[] (size_t idx) const
+ {
+ return at (idx);
+ }
+
+ // Look up by matching file name.
+ const_iterator find (const source_file &) const;
+ const_iterator find (const char *filename) const
+ {
+ const_iterator i = begin ();
+ while (i != end () && strcmp ((*i).name (), filename) != 0)
+ ++i;
+ return i;
+ }
+ template<typename string>
+ const_iterator find (const string &filename) const
+ {
+ const_iterator i = begin ();
+ while (i != end () && filename != (*i).name ())
+ ++i;
+ return i;
+ }
+ };
+
+ // This describes one entry in the line information table.
+ class line_entry
+ {
+ private:
+ ::Dwarf_Line *_m_line;
+
+ public:
+ line_entry (::Dwarf_Line *entry) : _m_line (entry) {}
+ line_entry (const line_entry &entry) : _m_line (entry._m_line) {}
+
+ // XXX reloc, dwfl
+ ::Dwarf_Addr address () const;
+
+ bool statement () const;
+ bool basic_block () const;
+ bool end_sequence () const;
+ bool prologue_end () const;
+ bool epilogue_begin () const;
+
+ const source_file file () const;
+ unsigned int line () const;
+ unsigned int column () const;
+
+ template<typename entry>
+ bool operator< (const entry &other) const
+ {
+ return address () < other.address ();
+ }
+ template<typename entry>
+ bool operator> (const entry &other) const
+ {
+ return address () > other.address ();
+ }
+ template<typename entry>
+ bool operator<= (const entry &other) const
+ {
+ return address () <= other.address ();
+ }
+ template<typename entry>
+ bool operator>= (const entry &other) const
+ {
+ return address () >= other.address ();
+ }
+
+ template<typename entry>
+ inline bool operator== (const entry &other) const
+ {
+ return (address () == other.address ()
+ && line () == other.line ()
+ && column () == other.column ()
+ && statement () == other.statement ()
+ && basic_block () == other.basic_block ()
+ && end_sequence () == other.end_sequence ()
+ && prologue_end () == other.prologue_end ()
+ && epilogue_begin () == other.epilogue_begin ()
+ && file () == other.file ());
+ }
+ template<typename entry>
+ inline bool operator!= (const entry &other) const
+ {
+ return !(*this == other);
+ }
+ // Short-circuit for our own type.
+ bool operator== (const line_entry &other) const;
+ };
+
+ /* This describes a CU's line information table.
+ It works like a read-only std::vector<line_entry>,
+ and also supports lookup by address.
+ XXX later, by file/line
+ */
+ class line_table
+ {
+ private:
+ ::Dwarf_Lines *_m_lines;
+
+ public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef line_entry value_type;
+
+ inline line_table (::Dwarf_Lines *const lines)
+ : _m_lines (lines) {}
+ inline line_table (const line_table &t)
+ : _m_lines (t._m_lines) {}
+
+ inline line_table &operator= (const line_table &t)
+ {
+ _m_lines = t._m_lines;
+ return *this;
+ }
+
+ std::string to_string () const;
+
+ typedef subr::indexed_iterator<line_table> const_iterator;
+
+ inline bool empty () const
+ {
+ return size () == 0;
+ }
+
+ size_t size () const;
+
+ inline const_iterator begin () const
+ {
+ return const_iterator (*this, 0);
+ }
+ inline const_iterator end () const
+ {
+ return const_iterator (*this, size ());
+ }
+
+ const line_entry at (size_t idx) const;
+ const line_entry operator[] (size_t idx) const
+ {
+ return at (idx);
+ }
+
+ template<typename table>
+ inline bool operator== (const table &other) const
+ {
+ return size () == other.size () && subr::container_equal (*this, other);
+ }
+ template<typename table>
+ inline bool operator!= (const table &other) const
+ {
+ return !(*this == other);
+ }
+ // Short-circuit for comparing to self.
+ inline bool operator== (const line_table &other) const
+ {
+ return (_m_lines == other._m_lines
+ || subr::container_equal (*this, other));
+ }
+
+ // Look up by matching address.
+ const_iterator find (::Dwarf_Addr) const;
+ };
+
+ // The DW_AT_stmt_list attribute yields a line info table.
+ class line_info_table
+ {
+ private:
+ ::Dwarf_Files *_m_files;
+
+ public:
+ inline line_info_table (::Dwarf_Files *const t)
+ : _m_files (t) {}
+ inline line_info_table (const line_info_table &t)
+ : _m_files (t._m_files) {}
+
+ inline line_info_table &operator= (const line_info_table &t)
+ {
+ _m_files = t._m_files;
+ return *this;
+ }
+
+ std::string to_string () const;
+
+ inline const file_table files () const
+ {
+ return file_table (_m_files);
+ }
+ const line_table lines () const;
+
+ template<typename table>
+ inline bool operator== (const table &other) const
+ {
+ return lines () == other.lines ();
+ }
+ template<typename table>
+ inline bool operator!= (const table &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ class dwarf_enum
+ {
+ friend class attr_value;
+ private:
+ const attr_value _m_attr;
+
+ dwarf_enum (const attr_value &attr) : _m_attr (attr) {}
+
+ public:
+ inline operator unsigned int () const
+ {
+ return _m_attr.constant ();
+ }
+
+ std::string to_string () const;
+
+ const char *identifier () const;
+ const char *name () const;
+
+ // Return the DW_AT_* indicating which enum this value belongs to.
+ unsigned int which () const
+ {
+ return _m_attr.whatattr ();
+ }
+
+ template<typename constant>
+ inline bool operator== (const constant &other) const
+ {
+ return (static_cast<unsigned int> (*this)
+ == static_cast<unsigned int> (other));
+ }
+ template<typename constant>
+ inline bool operator!= (const constant &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // This describes one attribute, equivalent to pair<const int, attr_value>.
+ class attribute
+ {
+ friend class debug_info_entry::raw_attributes_type::const_iterator;
+ friend class attr_value;
+ private:
+ inline ::Dwarf_Attribute *thisattr () const
+ {
+ return second.thisattr ();
+ }
+
+ class lhs
+ {
+ friend class attribute;
+ private:
+ const attribute &_m_attr;
+
+ lhs (attribute &attr) : _m_attr (attr) {}
+
+ public:
+ operator int () const
+ {
+ return ::dwarf_whatattr (_m_attr.thisattr ());
+ }
+ };
+
+ attribute (const debug_info_entry &die, const ::Dwarf_Attribute &attr)
+ : first (*this), second (die.tag (), attr) {}
+
+ public:
+ lhs first;
+ attr_value second;
+
+ inline attribute (const attribute &a)
+ : first (*this), second (a.second) {}
+
+ // This lets pair<...> x = (attribute) y work.
+ template<typename value>
+ operator std::pair<const int, value> () const
+ {
+ return std::make_pair (static_cast<int> (first), value (second));
+ }
+
+ template<typename pair>
+ inline bool operator== (const pair &other) const
+ {
+ return first == other.first && second == other.second;
+ }
+ template<typename pair>
+ inline bool operator!= (const pair &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline std::string to_string () const;
+ };
+
+ /* This works like range_list, but is based on a debug_info_entry using
+ dwarf_ranges. If the entry has DW_AT_low_pc and DW_AT_high_pc, this
+ will present a singleton list; if it has a DW_AT_ranges, it will be
+ the same as the range_list presentation. If neither, an empty list. */
+ class ranges
+ {
+ friend class debug_info_entry;
+ private:
+ debug_info_entry _m_die;
+
+ ranges (const debug_info_entry &die) : _m_die (die) {}
+
+ public:
+ typedef std::pair< ::Dwarf_Addr, ::Dwarf_Addr> key_type; // XXX reloc
+ typedef key_type value_type;
+
+ ranges (const ranges &other) : _m_die (other._m_die) {}
+
+ std::string to_string () const;
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, value_type>
+ {
+ friend class ranges;
+ private:
+ debug_info_entry _m_die;
+ ::Dwarf_Addr _m_base; // XXX reloc
+ ::Dwarf_Addr _m_begin; // XXX reloc
+ ::Dwarf_Addr _m_end; // XXX reloc
+ ptrdiff_t _m_offset;
+
+ inline const_iterator (const debug_info_entry &die)
+ : _m_die (die), _m_offset (0) {}
+
+ public:
+ inline const_iterator (const const_iterator &i)
+ : _m_die (i._m_die), _m_base (i._m_base),
+ _m_begin (i._m_begin), _m_end (i._m_end),
+ _m_offset (i._m_offset) {}
+
+ inline value_type operator* () const
+ {
+ if (unlikely (_m_offset == 0))
+ throw std::runtime_error ("dereferencing end iterator");
+ return std::make_pair (_m_begin, _m_end);
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_die = other._m_die;
+ _m_base = other._m_base;
+ _m_begin = other._m_begin;
+ _m_end = other._m_end;
+ _m_offset = other._m_offset;
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return (_m_die._m_die.addr == other._m_die._m_die.addr
+ && _m_offset == other._m_offset);
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ const_iterator &operator++ () // prefix
+ {
+ do
+ _m_offset = dwarf_ranges (_m_die.thisdie (), _m_offset,
+ &_m_base, &_m_begin, &_m_end);
+ // Skip over empty ranges.
+ while (_m_offset != 0 && _m_begin == _m_end);
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+ };
+
+ const_iterator begin () const
+ {
+ const_iterator it (_m_die);
+ return ++it;
+ }
+ const_iterator end () const
+ {
+ return const_iterator (_m_die);
+ }
+
+ inline bool empty () const
+ {
+ return begin () == end ();
+ }
+
+ const_iterator find (const key_type &match) const
+ {
+ return std::find (begin (), end (), match);
+ }
+
+ private:
+ struct entry_contains
+ : public std::binary_function<key_type, ::Dwarf_Addr, bool>
+ {
+ inline bool operator() (const key_type &range, const ::Dwarf_Addr addr)
+ const
+ {
+ return addr >= range.first && addr < range.second;
+ }
+ };
+
+ public:
+ const_iterator find (const ::Dwarf_Addr addr) const
+ {
+ return std::find_if (begin (), end (),
+ std::bind2nd (entry_contains (), addr));
+ }
+
+ inline operator std::set<key_type> () const
+ {
+ return std::set<key_type> (begin (), end ());
+ }
+
+ template<typename ranges>
+ inline bool operator== (const ranges &other) const
+ {
+ /* Our container is unordered (i.e., in file order). A range list
+ is conceptually equal if all the pairs match, regardless of the
+ order. But the std::equal algorithm will compare corresponding
+ elements in order. So we need an ordered set for comparison. */
+ std::set<key_type> mine = *this;
+ coalesce (mine);
+ std::set<key_type> his = other;
+ coalesce (his);
+ return mine == his;
+ }
+ template<typename ranges>
+ inline bool operator!= (const ranges &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // Container for raw CUs in file order, intended to be compatible
+ // with a read-only subset of std::list<compile_unit>.
+ class raw_compile_units_type
+ {
+ friend class dwarf;
+ private:
+ const dwarf &_m_file;
+
+ raw_compile_units_type (const dwarf &file) : _m_file (file) {}
+
+ public:
+ typedef compile_unit value_type;
+
+ inline raw_compile_units_type (const raw_compile_units_type &u)
+ : _m_file (u._m_file) {}
+
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, compile_unit>
+ {
+ friend class raw_compile_units_type;
+ private:
+ debug_info_entry _m_die;
+ const dwarf *_m_file; // XXX
+ ::Dwarf_Off _m_next; // XXX
+
+ inline const_iterator (const dwarf &file)
+ : _m_file (&file), _m_next (0) {}
+
+ public:
+ inline const_iterator ()
+ : _m_die (), _m_file (NULL), _m_next (-1)
+ {}
+
+ inline const_iterator (const const_iterator &i)
+ : _m_die (i._m_die), _m_file (i._m_file), _m_next (i._m_next) {}
+
+ inline const debug_info_entry &operator* () const
+ {
+ if (unlikely (_m_next == (::Dwarf_Off) -1))
+ throw std::runtime_error ("dereferencing end iterator");
+ return _m_die;
+ }
+ inline const debug_info_entry *operator-> () const
+ {
+ return &(operator* ());
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_die = other._m_die;
+ _m_next = other._m_next;
+ _m_file = other._m_file; // XXX
+ return *this;
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return _m_next == other._m_next && _m_file == other._m_file;
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline const_iterator &operator++ () // prefix
+ {
+ // XXX should be rewritten to use libdw_findcu internals
+ // slow way for first crack to avoid DSO issues
+ _m_next = _m_file->nextcu (_m_next, _m_die.thisdie ());
+ if (_m_next == (::Dwarf_Off) -1)
+ // End iterators have no file pointer.
+ _m_file = NULL;
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const_iterator prev = *this;
+ ++*this;
+ return prev;
+ }
+ };
+
+ const_iterator begin () const
+ {
+ const_iterator it (_m_file);
+ return ++it;
+ }
+ static inline const_iterator end ()
+ {
+ return const_iterator ();
+ }
+ };
+ inline raw_compile_units_type raw_compile_units () const
+ {
+ return raw_compile_units_type (*this);
+ }
+
+ private:
+ static inline bool skip_partial_unit (const compile_unit &unit)
+ {
+ switch (unit.tag ())
+ {
+ case ::DW_TAG_partial_unit:
+ return true;
+ case ::DW_TAG_compile_unit:
+ return false;
+ default:
+ throw std::exception(); // XXX invalid dwarf
+ }
+ }
+
+ typedef skipping_wrapper<class raw_compile_units_type,
+ compile_unit, compile_unit,
+ skip_partial_unit> compile_units_base;
+
+ public:
+
+ // Container for logical CUs in file order, intended to be compatible
+ // with a read-only subset of std::list<compile_unit>.
+ class compile_units_type : public compile_units_base
+ {
+ friend class dwarf;
+ private:
+ compile_units_type (class raw_compile_units_type raw) : compile_units_base (raw) {}
+
+ public:
+ typedef compile_unit value_type;
+
+ compile_units_type (const compile_units_type &u) : compile_units_base (u) {}
+
+ template<typename units>
+ bool operator== (const units &other) const
+ {
+ return subr::container_equal (*this, other);
+ }
+ template<typename units>
+ bool operator!= (const units &other) const
+ {
+ return !(*this == other);
+ }
+ };
+ inline class compile_units_type compile_units () const
+ {
+ return compile_units_type (raw_compile_units ());
+ }
+
+ private:
+ ::Dwarf *_m_dw;
+
+ public:
+ // XXX temp hack
+ inline ::Dwarf_Off nextcu (::Dwarf_Off offset, ::Dwarf_Die *die) const
+ {
+ ::Dwarf_Off next;
+ ::size_t header_size;
+ int result = ::dwarf_nextcu (_m_dw, offset, &next, &header_size,
+ NULL, NULL, NULL);
+ xif (result < 0);
+ if (result == 0)
+ xif (::dwarf_offdie (_m_dw, offset + header_size, die) == NULL);
+ else
+ memset (die, 0, sizeof *die);
+ return next;
+ }
+
+ inline dwarf (::Dwarf *dw) : _m_dw (dw) {};
+
+ inline dwarf (const dwarf &dw) : _m_dw (dw._m_dw) {};
+
+ template<typename file>
+ inline bool operator== (const file &other) const
+ {
+ return compile_units () == other.compile_units ();
+ }
+ template<typename file>
+ inline bool operator!= (const file &other) const
+ {
+ return !(*this == other);
+ }
+
+ // XXX reloc
+ class arange_list
+ : public std::set<std::pair< ::Dwarf_Addr, ::Dwarf_Addr> >
+ {
+ private:
+ typedef std::set<std::pair< ::Dwarf_Addr, ::Dwarf_Addr> > _base;
+
+ public:
+ typedef _base::key_type key_type;
+ typedef _base::value_type value_type;
+ typedef _base::iterator iterator;
+ typedef _base::const_iterator const_iterator;
+
+ static inline bool ordered ()
+ {
+ return true;
+ }
+
+ struct hasher : public subr::container_hasher<arange_list> {};
+
+ inline arange_list () {}
+ inline arange_list (const arange_list &other)
+ : _base (static_cast<const _base &> (other))
+ {}
+
+ template<typename iterator>
+ arange_list (iterator first, iterator last)
+ : _base (first, last)
+ {}
+
+ template<typename input>
+ inline arange_list (const input &other)
+ : _base (other.begin (), other.end ())
+ {}
+
+ std::string to_string () const;
+
+ inline std::string to_string ()
+ {
+ coalesce (*this);
+ return ((const arange_list *) this)->to_string ();
+ }
+
+ inline bool canonical () const
+ {
+ // Can't be sure.
+ return false;
+ }
+
+ inline bool canonical ()
+ {
+ // Make it so.
+ coalesce (*this);
+ return true;
+ }
+
+ inline bool operator== (arange_list &other)
+ {
+ // Since we are not const, coalesce both in place.
+ coalesce (other);
+ if (size () < other.size ())
+ // Coalescing can only make us smaller.
+ return false;
+ coalesce (*this);
+ return size () == other.size () && subr::container_equal (*this, other);
+ }
+
+ template<typename list>
+ inline bool operator== (const list &other)
+ {
+ // Since we are not const, coalesce in place.
+ coalesce (*this);
+
+ if (list::ordered () && other.canonical ()
+ && size () != other.size ())
+ return false;
+
+ // If he happens to be sorted and canonical, we'll match.
+ if (subr::container_equal (*this, other))
+ return true;
+
+ // If he was sorted and canonical and we didn't match, it's conclusive.
+ if (list::ordered () && other.canonical ())
+ return false;
+
+ // Make a sorted and canonicalized copy to compare to.
+ _base his (other);
+ if (size () > his.size ()
+ || (list::ordered () && size () == his.size ()))
+ // Coalescing can only make him smaller.
+ return false;
+ coalesce (his);
+ return subr::container_equal (*this, his);
+ }
+
+ template<typename list>
+ inline bool operator== (const list &other) const
+ {
+ if (list::ordered () && other.canonical ()
+ && size () < other.size ())
+ // Coalescing can only make us smaller.
+ return false;
+
+ // If we both happen to be sorted and canonical, we'll match.
+ if (subr::container_equal (*this, other))
+ return true;
+
+ // Make a non-const copy that will coalesce in its operator==.
+ if (list::ordered () && other.canonical ())
+ return size () != other.size () && arange_list (*this) == other;
+
+ return arange_list (other) == *this;
+ }
+ };
+
+ private:
+ struct arange_less
+ : public std::binary_function<compile_unit, compile_unit, bool>
+ {
+ inline bool operator() (const compile_unit &a, const compile_unit &b)
+ const
+ {
+ return a.offset () < b.offset ();
+ }
+ };
+
+ public:
+ typedef std::map<compile_unit, arange_list, arange_less> aranges_map;
+
+ aranges_map aranges () const;
+
+ private:
+ static bool adjacency (const arange_list::key_type &a,
+ const arange_list::key_type &b)
+ {
+ return a.second == b.first;
+ }
+
+ // Coalesce adjacent ranges.
+ static void coalesce (std::set<arange_list::key_type> &set)
+ {
+ for (std::set<arange_list::key_type>::iterator i = set.begin ();
+ (i = std::adjacent_find (i, set.end (), adjacency)) != set.end ();
+ ++i)
+ {
+ std::set<arange_list::key_type>::iterator j = i;
+ std::set<arange_list::key_type>::iterator k = ++j;
+ while (++k != set.end () && adjacency (*j, *k))
+ ++j;
+ const arange_list::key_type joined (i->first, j->second);
+ set.erase (i, k);
+ i = set.insert (joined).first;
+ }
+ }
+ };
+
+ inline class dwarf::debug_info_entry::raw_children_type
+ dwarf::debug_info_entry::raw_children () const
+ {
+ return raw_children_type (*this);
+ }
+
+ inline class dwarf::debug_info_entry::children_type
+ dwarf::debug_info_entry::children () const
+ {
+ return children_type (*this);
+ }
+
+ inline class dwarf::debug_info_entry::raw_attributes_type
+ dwarf::debug_info_entry::raw_attributes () const
+ {
+ return raw_attributes_type (*this);
+ }
+
+ inline class dwarf::debug_info_entry::attributes_type
+ dwarf::debug_info_entry::attributes () const
+ {
+ return attributes_type (raw_attributes ());
+ }
+
+ // Explicit specializations.
+ template<>
+ std::string
+ to_string<dwarf::debug_info_entry> (const dwarf::debug_info_entry &);
+ inline std::string dwarf::debug_info_entry::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+ template<>
+ std::string to_string<dwarf::attribute> (const dwarf::attribute &);
+ inline std::string dwarf::attribute::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+ template<>
+ std::string to_string<dwarf::attr_value> (const dwarf::attr_value &);
+ inline std::string dwarf::attr_value::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+ template<>
+ std::string to_string<dwarf::dwarf_enum> (const dwarf::dwarf_enum &);
+ inline std::string dwarf::dwarf_enum::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+
+};
+
+#endif // <elfutils/dwarf>
--- /dev/null
+/* -*- C++ -*- interfaces for libdw.
+ Copyright (C) 2009-2011 Red Hat, Inc.
+
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include "dwarf"
+
+using namespace std;
+using namespace elfutils;
+
+#define VS(what) (1U << dwarf::VS_##what)
+
+/* Return a bitmask of value spaces expected for this attribute of this tag.
+ Primarily culled from the DWARF 3 spec: 7.5.4, Figure 20. Updated to
+ DWARF 4, plus some GNU additions. */
+
+static unsigned int
+expected_value_space (int attr, int tag)
+{
+ switch (attr)
+ {
+ case DW_AT_sibling:
+ case DW_AT_common_reference:
+ case DW_AT_containing_type:
+ case DW_AT_default_value:
+ case DW_AT_abstract_origin:
+ case DW_AT_base_types:
+ case DW_AT_friend:
+ case DW_AT_priority:
+ case DW_AT_specification:
+ case DW_AT_type:
+ case DW_AT_use_location:
+ case DW_AT_data_location:
+ case DW_AT_extension:
+ case DW_AT_small:
+ case DW_AT_object_pointer:
+ case DW_AT_namelist_item:
+ return VS(reference);
+
+ case DW_AT_location:
+ case DW_AT_string_length:
+ case DW_AT_return_addr:
+ case DW_AT_frame_base:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_vtable_elem_location:
+ case DW_AT_GNU_call_site_value:
+ case DW_AT_GNU_call_site_data_value:
+ case DW_AT_GNU_call_site_target:
+ case DW_AT_GNU_call_site_target_clobbered:
+ return VS(location);
+
+ case DW_AT_data_member_location:
+ return VS(location) | VS(constant);
+
+ case DW_AT_name:
+ switch (tag)
+ {
+ case DW_TAG_compile_unit:
+ case DW_TAG_partial_unit:
+ return VS(source_file);
+ default:
+ return VS(identifier);
+ }
+
+ case DW_AT_ordering:
+ case DW_AT_language:
+ case DW_AT_visibility:
+ case DW_AT_inline:
+ case DW_AT_accessibility:
+ case DW_AT_address_class:
+ case DW_AT_calling_convention:
+ case DW_AT_encoding:
+ case DW_AT_identifier_case:
+ case DW_AT_virtuality:
+ case DW_AT_endianity:
+ return VS(dwarf_constant);
+
+ case DW_AT_byte_size:
+ case DW_AT_byte_stride:
+ case DW_AT_bit_size:
+ case DW_AT_bit_offset:
+ case DW_AT_bit_stride:
+ case DW_AT_lower_bound:
+ case DW_AT_upper_bound:
+ case DW_AT_count:
+ case DW_AT_allocated:
+ case DW_AT_associated:
+ return VS(reference) | VS(constant) | VS(location); // XXX non-loc expr
+
+ case DW_AT_stmt_list:
+ return VS(lineptr);
+ case DW_AT_macro_info:
+ return VS(macptr);
+ case DW_AT_ranges:
+ return VS(rangelistptr);
+
+ case DW_AT_low_pc:
+ case DW_AT_high_pc:
+ case DW_AT_entry_pc:
+ return VS(address);
+
+ case DW_AT_discr:
+ return VS(reference);
+ case DW_AT_discr_value:
+ return VS(constant);
+ case DW_AT_discr_list:
+ return VS(discr_list);
+
+ case DW_AT_import:
+ return VS(reference);
+
+ case DW_AT_comp_dir:
+ return VS(source_file);
+
+ case DW_AT_const_value:
+ return VS(constant) | VS(string) | VS(address);
+
+ case DW_AT_is_optional:
+ case DW_AT_prototyped:
+ case DW_AT_artificial:
+ case DW_AT_declaration:
+ case DW_AT_external:
+ case DW_AT_variable_parameter:
+ case DW_AT_use_UTF8:
+ case DW_AT_mutable:
+ case DW_AT_main_subprogram:
+ case DW_AT_threads_scaled:
+ case DW_AT_explicit:
+ case DW_AT_elemental:
+ case DW_AT_pure:
+ case DW_AT_recursive:
+ case DW_AT_const_expr:
+ case DW_AT_enum_class:
+ case DW_AT_GNU_tail_call:
+ case DW_AT_GNU_all_tail_call_sites:
+ case DW_AT_GNU_all_call_sites:
+ case DW_AT_GNU_all_source_call_sites:
+ case DW_AT_GNU_vector:
+ return VS(flag);
+
+ case DW_AT_producer:
+ return VS(string);
+
+ case DW_AT_start_scope:
+ case DW_AT_data_bit_offset:
+ return VS(constant);
+
+ case DW_AT_binary_scale:
+ case DW_AT_decimal_scale:
+ case DW_AT_decimal_sign:
+ case DW_AT_digit_count:
+ return VS(constant);
+
+ case DW_AT_decl_file:
+ case DW_AT_call_file:
+ return VS(source_file);
+ case DW_AT_decl_line:
+ case DW_AT_call_line:
+ return VS(source_line);
+ case DW_AT_decl_column:
+ case DW_AT_call_column:
+ return VS(source_column);
+
+ case DW_AT_trampoline:
+ return VS(address) | VS(flag) | VS(reference) | VS(string);
+
+ case DW_AT_description:
+ case DW_AT_picture_string:
+ return VS(string);
+
+ case DW_AT_linkage_name:
+ case DW_AT_MIPS_linkage_name:
+ case DW_AT_GNU_template_name:
+ return VS(identifier);
+
+ /* XXX Note these are not the same, the first is related to C++
+ ODR (one-definition-rule checking), the later to .debug_type
+ references. Should be its own class really. */
+ case DW_AT_GNU_odr_signature:
+ return VS(constant);
+ case DW_AT_signature:
+ return VS(reference);
+ }
+
+ return 0;
+}
--- /dev/null
+/* elfutils::dwarf_comparator -- -*- C++ -*- templates for comparing DWARF data
+ Copyright (C) 2009-2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_COMPARATOR
+#define _ELFUTILS_DWARF_COMPARATOR 1
+
+#include "dwarf"
+
+namespace elfutils
+{
+ // Prototypical stub for reference tracker object.
+ // This keeps no state, and no two contexts ever match.
+ template<class dwarf1, class dwarf2>
+ struct dwarf_tracker_base
+ {
+ typedef typename dwarf1::compile_units_type::const_iterator cu1;
+ typedef typename dwarf2::compile_units_type::const_iterator cu2;
+ typedef typename dwarf1::debug_info_entry dwarf1_die;
+ typedef typename dwarf2::debug_info_entry dwarf2_die;
+ typedef typename dwarf1_die::children_type::const_iterator die1;
+ typedef typename dwarf2_die::children_type::const_iterator die2;
+ typedef typename dwarf1_die::attributes_type::const_iterator attr1;
+ typedef typename dwarf2_die::attributes_type::const_iterator attr2;
+
+ // This object is created to start a walk and destroyed to finish one.
+ struct walk
+ {
+ inline walk (dwarf_tracker_base *, const cu1 &, const cu2 &)
+ {
+ }
+ inline ~walk ()
+ {
+ }
+ };
+
+ // This object is created in pre-order and destroyed in post-order.
+ struct step
+ {
+ inline step (dwarf_tracker_base *, const die1 &, const die2 &)
+ {
+ }
+ inline ~step ()
+ {
+ }
+ };
+
+ /* This is enough like step that they should probably be merged.
+ But it's separate. */
+ struct visitor
+ {
+ inline visitor (dwarf_tracker_base *,
+ const typename dwarf1::debug_info_entry &,
+ const typename dwarf2::debug_info_entry &)
+ {
+ }
+ inline ~visitor ()
+ {
+ }
+ };
+
+ inline bool mismatch (cu1 &, const cu1 &, // at, end
+ cu2 &, const cu2 &)
+ {
+ return false;
+ }
+
+ inline bool mismatch (die1 &, const die1 &, // at, end
+ die2 &, const die2 &)
+ {
+ return false;
+ }
+
+ inline bool mismatch (attr1 &, const attr1 &, // at, end
+ attr2 &, const attr2 &)
+ {
+ return false;
+ }
+
+ struct left_context_type {};
+ struct right_context_type {};
+
+ // Return the lhs context of an arbitrary DIE.
+ inline const left_context_type left_context (const die1 &)
+ {
+ return left_context_type ();
+ }
+
+ // Return the rhs context of an arbitrary DIE.
+ inline const right_context_type right_context (const die2 &)
+ {
+ return right_context_type ();
+ }
+
+ inline bool context_quick_mismatch (const left_context_type &,
+ const right_context_type &)
+
+ {
+ return true;
+ }
+
+ inline bool context_match (const left_context_type &,
+ const right_context_type &)
+ {
+ return false;
+ }
+
+ struct reference_match {};
+
+ // This call is used purely in hopes of a cache hit.
+ inline bool prematch (reference_match &, const die1 &, const die2 &)
+ {
+ return false;
+ }
+
+ // This call is used only as part of a real reference lookup.
+ inline bool reference_matched (reference_match &,
+ const die1 &, const die2 &)
+ {
+ return false;
+ }
+
+ // Check for a negative cache hit after prematch or reference_match.
+ inline bool cannot_match (reference_match &, const die1 &, const die2 &)
+ {
+ return false;
+ }
+
+ // This can cache a result.
+ inline bool notice_match (reference_match &, const die1 &, const die2 &,
+ bool result)
+ {
+ return result;
+ }
+
+ template<typename item1, typename item2>
+ inline bool identical (const item1 &, const item2 &)
+ {
+ return false;
+ }
+
+ inline dwarf_tracker_base ()
+ {}
+
+ typedef dwarf_tracker_base subtracker;
+ inline dwarf_tracker_base (const dwarf_tracker_base &, reference_match &,
+ const left_context_type &,
+ const right_context_type &)
+ {}
+ };
+
+ template<class dwarf1, class dwarf2,
+ bool ignore_refs = false,
+ class tracker = dwarf_tracker_base<dwarf1, dwarf2>
+ >
+ class dwarf_comparator
+ : public std::binary_function<dwarf1, dwarf2, bool>
+ {
+ private:
+ tracker &_m_tracker;
+
+ typedef dwarf_comparator<dwarf1, dwarf2, false,
+ typename tracker::subtracker> subcomparator;
+
+ template<typename item1, typename item2>
+ struct matcher : public std::binary_function<item1, item2, bool>
+ {
+ dwarf_comparator &_m_cmp;
+ matcher (dwarf_comparator &cmp)
+ : _m_cmp (cmp)
+ {}
+
+ inline bool operator () (const item1 &a, const item2 &b)
+ {
+ return _m_cmp.match_deref (a, b);
+ }
+ };
+#define MATCHER(item) \
+ matcher<typename dwarf1::item::const_iterator, \
+ typename dwarf2::item::const_iterator> (*this)
+
+ inline bool match (const dwarf1 &a, const dwarf2 &b)
+ {
+ return match (a.compile_units (), b.compile_units ());
+ }
+
+ typedef typename dwarf1::compile_units_type compile_units1;
+ typedef typename dwarf2::compile_units_type compile_units2;
+ typedef typename dwarf1::compile_units_type::const_iterator cu1_it;
+ typedef typename dwarf2::compile_units_type::const_iterator cu2_it;
+ inline bool match (const compile_units1 &a, const compile_units2 &b)
+ {
+ cu1_it it1 = a.begin ();
+ cu2_it it2 = b.begin ();
+ const cu1_it end1 = a.end ();
+ const cu2_it end2 = b.end ();
+ do
+ {
+ if (subr::container_equal
+ (it1, end1, it2, end2, MATCHER (compile_units_type)))
+ return true;
+ }
+ while (_m_tracker.mismatch (it1, end1, it2, end2));
+ return false;
+ }
+
+ typedef typename dwarf1::debug_info_entry die1;
+ typedef typename dwarf2::debug_info_entry die2;
+ inline bool match_deref (const cu1_it &a, const cu2_it &b)
+ {
+ typename tracker::walk in (&_m_tracker, a, b);
+ return equals (*a, *b);
+ }
+
+ inline bool match (const die1 &a, const die2 &b)
+ {
+ typename tracker::visitor visit (&_m_tracker, a, b);
+ if (a.tag () != b.tag ())
+ return nomatch (a, b, "DIE tag");
+ if (!equals (a.attributes (), b.attributes ()))
+ return nomatch (a, b, "DIE attrs");
+ if (!equals (a.children (), b.children ()))
+ return nomatch (a, b, "DIE children");
+ return true;
+ }
+
+ template<typename in, typename out>
+ static inline void populate (out &o, const in &map)
+ {
+ for (typename in::const_iterator i = map.begin ();
+ i != map.end ();
+ ++i)
+ o.insert (std::make_pair ((*i).first, i));
+ }
+
+ typedef typename dwarf1::debug_info_entry::attributes_type attributes1;
+ typedef typename dwarf2::debug_info_entry::attributes_type attributes2;
+ typedef typename attributes1::const_iterator ait1;
+ typedef typename attributes2::const_iterator ait2;
+ typedef std::map<int, ait1> ait1_map;
+ typedef std::map<int, ait2> ait2_map;
+
+ struct match_lhs
+ : public std::binary_function<ait1, ait2, bool>
+ {
+ inline bool operator () (const ait1 &it1, const ait2 &it2)
+ {
+ return (*it1).first == (*it2).first;
+ }
+ };
+
+ struct match_rhs
+ : public std::binary_function<ait1, ait2, bool>
+ {
+ dwarf_comparator &_m_cmp;
+ match_rhs (dwarf_comparator &cmp)
+ : _m_cmp (cmp)
+ {}
+
+ inline bool operator () (const ait1 &it1, const ait2 &it2)
+ {
+ return _m_cmp.equals ((*it1).second, (*it2).second);
+ }
+ };
+
+ struct match_sorted
+ : public std::binary_function<typename ait1_map::value_type,
+ typename ait2_map::value_type,
+ bool>
+ {
+ dwarf_comparator &_m_cmp;
+ match_sorted (dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &cmp)
+ : _m_cmp (cmp)
+ {}
+
+ inline bool operator () (const typename ait1_map::value_type &x,
+ const typename ait2_map::value_type &y)
+ {
+ return (x.first == y.first
+ && _m_cmp.equals ((*x.second).second, (*y.second).second));
+ }
+ };
+
+ inline bool match (const attributes1 &a, const attributes2 &b)
+ {
+ ait1 it1 = a.begin ();
+ ait2 it2 = b.begin ();
+ const ait1 end1 = a.end ();
+ const ait2 end2 = b.end ();
+ if (subr::container_equal (it1, end1, it2, end2, match_lhs ()))
+ {
+ // The set of attributes matches, in order. Compare the values.
+ it1 = a.begin ();
+ it2 = b.begin ();
+ do
+ {
+ if (subr::container_equal (it1, end1, it2, end2,
+ match_rhs (*this)))
+ return true;
+ }
+ while (_m_tracker.mismatch (it1, end1, it2, end2));
+ return false;
+ }
+
+ if (it1 != end1 && it2 != end2
+ && !(attributes1::ordered () && attributes2::ordered ()))
+ {
+ /* We have the same number of attributes, but the names don't
+ match. Populate two sorted maps and compare those. */
+
+ ait1_map sorted1;
+ populate (sorted1, a);
+
+ ait2_map sorted2;
+ populate (sorted2, b);
+
+ std::pair<typename ait1_map::iterator,
+ typename ait2_map::iterator> result
+ = std::mismatch (sorted1.begin (), sorted1.end (),
+ sorted2.begin (), match_sorted (*this));
+ if (result.first == sorted1.end ()
+ && result.second == sorted2.end ())
+ return true;
+
+ it1 = result.first->second;
+ it2 = result.second->second;
+ }
+
+ return _m_tracker.mismatch (it1, end1, it2, end2);
+ }
+
+ typedef typename dwarf1::debug_info_entry::children_type children1;
+ typedef typename dwarf2::debug_info_entry::children_type children2;
+ typedef typename children1::const_iterator cit1;
+ typedef typename children2::const_iterator cit2;
+
+ inline bool match_child (const cit1 &a, const cit2 &b)
+ {
+ typename tracker::step into (&_m_tracker, a, b);
+ return equals (*a, *b);
+ }
+
+ inline bool match_deref (const cit1 &a, const cit2 &b)
+ {
+ // Maybe the tracker has already cached a correspondence of DIEs.
+ typename tracker::reference_match matched;
+ if (_m_tracker.prematch (matched, a, b))
+ return true;
+
+ if (_m_tracker.cannot_match (matched, a, b))
+ return nomatch (*a, *b, "children cached");
+
+ bool result = match_child (a, b);
+
+ // Let the tracker cache a result for its reference_matched.
+ return _m_tracker.notice_match (matched, a, b, result);
+ }
+
+ inline bool match (const children1 &a, const children2 &b)
+ {
+ cit1 it1 = a.begin ();
+ cit2 it2 = b.begin ();
+ const cit1 end1 = a.end ();
+ const cit2 end2 = b.end ();
+ do
+ if (subr::container_equal (it1, end1, it2, end2,
+ MATCHER (debug_info_entry::children_type)))
+ return true;
+ while (_m_tracker.mismatch (it1, end1, it2, end2));
+ return false;
+ }
+
+ typedef typename dwarf1::attribute attribute1;
+ typedef typename dwarf2::attribute attribute2;
+ inline bool match (const attribute1 &a, const attribute2 &b)
+ {
+ return a.first == b.first && equals (a.second, b.second);
+ }
+
+ typedef typename dwarf1::attr_value attr_value1;
+ typedef typename dwarf2::attr_value attr_value2;
+ inline bool match (const attr_value1 &a, const attr_value2 &b)
+ {
+ const dwarf::value_space what = a.what_space ();
+ if (what == b.what_space ())
+ switch (what)
+ {
+ case dwarf::VS_reference:
+ return reference_match (a.reference (), b.reference ());
+
+ case dwarf::VS_flag:
+ return a.flag () == b.flag ();
+
+ case dwarf::VS_rangelistptr:
+ return a.ranges () == b.ranges ();
+
+ case dwarf::VS_lineptr:
+ return a.line_info () == b.line_info ();
+
+ case dwarf::VS_macptr: // XXX punt for now, treat as constant
+ return a.constant () == b.constant ();
+
+ case dwarf::VS_dwarf_constant:
+ return a.dwarf_constant () == b.dwarf_constant ();
+
+ case dwarf::VS_constant:
+ if (a.constant_is_integer ())
+ return (b.constant_is_integer ()
+ && a.constant () == b.constant ());
+ return (!b.constant_is_integer ()
+ && subr::container_equal (a.constant_block (),
+ b.constant_block ()));
+
+ case dwarf::VS_source_line:
+ return a.source_line () == b.source_line ();
+ case dwarf::VS_source_column:
+ return a.source_column () == b.source_column ();
+
+ case dwarf::VS_identifier:
+ return subr::name_equal<typeof (b.identifier ())> ()
+ (a.identifier (), b.identifier ());
+
+ case dwarf::VS_string:
+ return subr::name_equal<typeof (b.string ())> ()
+ (a.string (), b.string ());
+
+ case dwarf::VS_address:
+ return a.address () == b.address ();
+
+ case dwarf::VS_source_file:
+ return a.source_file () == b.source_file ();
+
+ case dwarf::VS_location:
+ return a.location () == b.location ();
+
+ case dwarf::VS_discr_list:
+ throw std::runtime_error ("XXX unimplemented");
+ }
+ return false;
+ }
+
+ // This is a convenient place to hack for debugging output and such.
+ inline bool nomatch (const die1 &, const die2 &, const char *)
+ {
+ return false;
+ }
+
+ /* We call references equal if they are literally the same DIE,
+ or if they are identical subtrees sitting in matching contexts.
+ The tracker's context_match method decides what that means. */
+ inline bool reference_match (const cit1 &ref1, const cit2 &ref2)
+ {
+ if (ignore_refs)
+ return true;
+
+ const die1 &a = *ref1;
+ const die2 &b = *ref2;
+
+ if (a.identity () == b.identity ()) // Object identity.
+ return true;
+
+ // Simplest mismatches with the cheapest checks first.
+ if (a.tag () != b.tag ())
+ return nomatch (a, b, "tag");
+
+ const bool has_children = a.has_children ();
+ if (has_children != b.has_children ())
+ return nomatch (a, b, "has_children");
+
+ // Maybe the tracker has already cached a correspondence of references.
+ typename tracker::reference_match matched;
+ if (_m_tracker.reference_matched (matched, ref1, ref2))
+ return true;
+
+ if (_m_tracker.cannot_match (matched, ref1, ref2))
+ return nomatch (a, b, "cached");
+
+ // Now we really have to get the tracker involved.
+ const typename tracker::left_context_type &lhs
+ = _m_tracker.left_context (ref1);
+ const typename tracker::right_context_type &rhs
+ = _m_tracker.right_context (ref2);
+
+ bool result = true;
+
+ /* First do the cheap mismatch check on the contexts, then check the
+ contents and contexts in ascending order of costliness of a check. */
+ if (_m_tracker.context_quick_mismatch (lhs, rhs))
+ result = nomatch (a, b, "quick context");
+
+ /* To compare the children, we have to clone the tracker and use a
+ new one, in case of any reference attributes in their subtrees.
+ The new tracker jump-starts its walk to the referenced DIE from
+ the root of the CU.
+
+ We use the subtracker and subcomparator for the attributes as well,
+ in case the main tracker has side-effects like printing. */
+
+ typename tracker::subtracker t (_m_tracker, matched, lhs, rhs);
+ subcomparator cmp (t);
+
+ if (result && !cmp.equals (a.attributes (), b.attributes ()))
+ result = nomatch (a, b, "attribute");
+
+ if (result && !_m_tracker.context_match (lhs, rhs))
+ result = nomatch (a, b, "context");
+
+ if (result && has_children && !cmp.equals (a.children (), b.children ()))
+ result = nomatch (a, b, "children");
+
+ // Let the tracker cache a result for its reference_matched.
+ return _m_tracker.notice_match (matched, ref1, ref2, result);
+ }
+
+ // This is what the public equals method uses for references.
+ inline bool match (const cit1 &a, const cit2 &b)
+ {
+ return reference_match (a, b);
+ }
+
+ public:
+ inline explicit dwarf_comparator (tracker &t)
+ : _m_tracker (t)
+ {}
+
+ inline bool operator () (const dwarf1 &a, const dwarf2 &b)
+ {
+ return match (a, b);
+ }
+
+ template<typename item1, typename item2>
+ inline bool equals (const item1 &a, const item2 &b)
+ {
+ return _m_tracker.identical (a, b) || match (a, b);
+ }
+
+ /* Predicate for DIEs "equal enough" to match as context for a subtree.
+ The definition we use is that the DIE has the same tag and all its
+ attributes are equal, excepting that references in attribute values
+ are not compared. */
+ static inline bool equal_enough (const die1 &a, const die2 &b)
+ {
+ dwarf_tracker_base<dwarf1, dwarf2> context_tracker;
+ return (a.tag () == b.tag ()
+ && (dwarf_comparator<dwarf1, dwarf2, true> (context_tracker)
+ .equals (a.attributes (), b.attributes ())));
+ }
+ };
+};
+
+#endif // <elfutils/dwarf_comparator>
--- /dev/null
+/* elfutils::dwarf_data -- internal DWARF data representations in -*- C++ -*-
+ Copyright (C) 2009-2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_DATA
+#define _ELFUTILS_DWARF_DATA 1
+
+#include "dwarf"
+#include <cassert>
+#include <bitset>
+
+/* This contains common classes/templates used by dwarf_output and dwarf_edit.
+
+ These are implementations of the "boring" components of the dwarf
+ object interface.
+*/
+
+namespace elfutils
+{
+ // This is a class only for scoping purposes.
+ // It contains no members, only inner classes.
+ class dwarf_data
+ {
+ public:
+
+ // Main container anchoring all the output.
+ template<class impl>
+ class compile_units_type : public std::list<typename impl::compile_unit>
+ {
+ friend class subr::create_container;
+
+ protected:
+ typedef std::list<typename impl::compile_unit> _base;
+
+ // Constructor copying CUs from input container.
+ template<typename input, typename arg_type>
+ inline compile_units_type (const input &other, arg_type &arg)
+ : _base (subr::argify<input, compile_units_type, arg_type &>
+ (other.begin (), arg),
+ subr::argify<input, compile_units_type, arg_type &>
+ (other.end (), arg))
+ {}
+
+ public:
+ // Default constructor: an empty container, no CUs.
+ inline compile_units_type () {}
+
+ template<typename other_children>
+ bool operator== (const other_children &other) const
+ {
+ return subr::container_equal (*this, other);
+ }
+ template<typename other_children>
+ bool operator!= (const other_children &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ template<class impl>
+ class compile_unit : public impl::debug_info_entry
+ {
+ friend class subr::create_container;
+ friend class impl::compile_units_type;
+
+ protected:
+ template<typename input>
+ static inline const input &require_cu (const input &cu)
+ {
+ if (cu.tag () != ::DW_TAG_compile_unit)
+ throw std::runtime_error
+ ("top-level debug_info_entry must be DW_TAG_compile_unit");
+ return cu;
+ }
+
+ template<typename die_type, typename arg_type>
+ inline void set (const die_type &die, arg_type &arg)
+ {
+ impl::debug_info_entry::set (require_cu (die), arg);
+ }
+
+ public:
+ explicit inline compile_unit ()
+ : impl::debug_info_entry ()
+ {
+ this->_m_tag = ::DW_TAG_compile_unit;
+ }
+
+ inline compile_unit (const compile_unit &other)
+ : impl::debug_info_entry (require_cu (other))
+ {}
+
+ template<typename input, typename arg_type>
+ inline compile_unit (const input &cu, arg_type &arg)
+ : impl::debug_info_entry (typename impl::debug_info_entry::pointer (),
+ require_cu (cu), arg)
+ {}
+
+ /* Assignment details are up to the base class.
+ We just ensure it's really a compile_unit. */
+ inline compile_unit &
+ operator= (const typename impl::debug_info_entry &other)
+ {
+ impl::debug_info_entry::operator= (require_cu (other));
+ return *this;
+ }
+
+ // Fetch the CU's DW_AT_stmt_list.
+ inline const typename impl::line_info_table &line_info () const
+ {
+ return this->attributes ().at (::DW_AT_stmt_list).line_info ();
+ }
+
+ // Convenience methods for line_info_table sub-containers.
+ inline const typename impl::line_table &lines () const
+ {
+ return line_info ().lines ();
+ }
+
+#if 0 // XXX const issues
+ inline typename impl::line_info_table &line_info ()
+ {
+ return this->attributes ()[::DW_AT_stmt_list].line_info ();
+ }
+
+ inline typename impl::line_table &lines ()
+ {
+ return line_info ().lines ();
+ }
+#endif
+ };
+
+ class source_file
+ {
+ private:
+ std::string _m_name;
+ ::Dwarf_Word _m_mtime;
+ ::Dwarf_Word _m_size;
+
+ public:
+
+ struct hasher
+ : public std::unary_function<source_file, size_t>
+ {
+ size_t operator () (const source_file &v) const
+ {
+ size_t hash = 0;
+ subr::hash_combine (hash, v._m_name);
+ subr::hash_combine (hash, v._m_mtime);
+ subr::hash_combine (hash, v._m_size);
+ return hash;
+ }
+ };
+
+ source_file () : _m_name (), _m_mtime (0), _m_size (0) {}
+ source_file (const std::string &n, ::Dwarf_Word m = 0, ::Dwarf_Word s = 0)
+ : _m_name (n), _m_mtime (m), _m_size (s) {}
+ source_file (const char *n, ::Dwarf_Word m = 0, ::Dwarf_Word s = 0)
+ : _m_name (n), _m_mtime (m), _m_size (s) {}
+
+ template<typename file>
+ source_file (const file &other)
+ : _m_name (other.name ()),
+ _m_mtime (other.mtime ()), _m_size (other.size ()) {}
+
+ template<typename file>
+ inline source_file &operator= (const file &other)
+ {
+ _m_name = other.name ();
+ _m_mtime = other.mtime ();
+ _m_size = other.size ();
+ return *this;
+ }
+ inline source_file &operator= (const std::string &n)
+ {
+ _m_name = n;
+ _m_mtime = 0;
+ _m_size = 0;
+ return *this;
+ }
+ inline source_file &operator= (const char *n)
+ {
+ _m_name = n;
+ _m_mtime = 0;
+ _m_size = 0;
+ return *this;
+ }
+
+ std::string to_string () const;
+
+ inline std::string &name ()
+ {
+ return _m_name;
+ }
+ inline const std::string &name () const
+ {
+ return _m_name;
+ }
+ inline ::Dwarf_Word &mtime ()
+ {
+ return _m_mtime;
+ }
+ inline ::Dwarf_Word mtime () const
+ {
+ return _m_mtime;
+ }
+ inline ::Dwarf_Word &size ()
+ {
+ return _m_size;
+ }
+ inline ::Dwarf_Word size () const
+ {
+ return _m_size;
+ }
+
+ template<typename other_file>
+ bool operator== (const other_file &other) const
+ {
+ if (mtime () != 0)
+ {
+ ::Dwarf_Word other_mtime = other.mtime ();
+ if (other_mtime != 0 && other_mtime != mtime ())
+ return false;
+ }
+ if (size () != 0)
+ {
+ ::Dwarf_Word other_size = other.size ();
+ if (other_size != 0 && other_size != size ())
+ return false;
+ }
+ return name () == other.name ();
+ }
+ template<typename other_file>
+ inline bool operator!= (const other_file &other) const
+ {
+ return !(*this == other);
+ }
+
+ // Return a value unique to us while we're in memory.
+ inline uintptr_t identity () const
+ {
+ return (uintptr_t) this;
+ }
+ };
+
+ private:
+
+ /* This is the common base class for all line_entry<T> instantiations.
+ For some reason beyond my ken, std::bitset<flag_count>::reference
+ as a return type is rejected by the compiler when used in a template
+ class, but not a non-template class. Go figure. */
+ class line_entry_common
+ {
+ protected:
+ unsigned int _m_line;
+ unsigned int _m_column;
+
+ enum flag_bit
+ {
+ flag_statement,
+ flag_basic_block,
+ flag_end_sequence,
+ flag_prologue_end,
+ flag_epilogue_begin,
+ flag_count
+ };
+ std::bitset<flag_count> _m_flags;
+
+ public:
+ line_entry_common ()
+ : _m_line (0), _m_column (0) {}
+
+ inline unsigned int &line ()
+ {
+ return _m_line;
+ }
+ inline unsigned int line () const
+ {
+ return _m_line;
+ }
+ inline unsigned int &column ()
+ {
+ return _m_column;
+ }
+ inline unsigned int column () const
+ {
+ return _m_column;
+ }
+
+#define _DWARF_EDIT_LE_FLAG(what) \
+ bool what () const \
+ { \
+ return _m_flags[flag_##what]; \
+ } \
+ std::bitset<flag_count>::reference what () \
+ { \
+ return _m_flags[flag_##what]; \
+ }
+ _DWARF_EDIT_LE_FLAG (statement)
+ _DWARF_EDIT_LE_FLAG (basic_block)
+ _DWARF_EDIT_LE_FLAG (end_sequence)
+ _DWARF_EDIT_LE_FLAG (prologue_end)
+ _DWARF_EDIT_LE_FLAG (epilogue_begin)
+#undef _DWARF_EDIT_LE_FLAG
+ };
+
+ public:
+ /* This holds a line table entry.
+ It's parameterized by the source_file representation. */
+ template<typename source_file>
+ class line_entry : public line_entry_common
+ {
+ private:
+ ::Dwarf_Addr _m_addr; // XXX dwfl, reloc
+ source_file _m_file;
+
+ public:
+
+ struct hasher
+ : public std::unary_function<line_entry, size_t>
+ {
+ size_t operator () (const line_entry &v) const
+ {
+ size_t hash = 0;
+ subr::hash_combine (hash, v._m_addr);
+ subr::hash_combine (hash, v._m_file);
+ subr::hash_combine (hash, v._m_line);
+ subr::hash_combine (hash, v._m_column);
+ return hash;
+ }
+ };
+
+ line_entry (::Dwarf_Addr addr)
+ : line_entry_common (), _m_addr (addr), _m_file ()
+ {}
+
+ template<typename entry>
+ line_entry (const entry &other)
+ : line_entry_common (), _m_addr (0), _m_file ()
+ {
+ *this = other;
+ }
+
+ template<typename entry>
+ line_entry &operator= (const entry &other)
+ {
+ _m_addr = other.address ();
+ _m_file = other.file ();
+ _m_line = other.line ();
+ _m_column = other.column ();
+ statement () = other.statement ();
+ basic_block () = other.basic_block ();
+ end_sequence () = other.end_sequence ();
+ prologue_end () = other.prologue_end ();
+ epilogue_begin () = other.epilogue_begin ();
+ return *this;
+ }
+
+ inline ::Dwarf_Addr &address ()
+ {
+ return _m_addr;
+ }
+ inline ::Dwarf_Addr address () const
+ {
+ return _m_addr;
+ }
+ inline source_file &file ()
+ {
+ return _m_file;
+ }
+ inline const source_file &file () const
+ {
+ return _m_file;
+ }
+
+ template<typename entry>
+ bool operator< (const entry &other) const
+ {
+ return address () < other.address ();
+ }
+ template<typename entry>
+ bool operator> (const entry &other) const
+ {
+ return address () > other.address ();
+ }
+ template<typename entry>
+ bool operator<= (const entry &other) const
+ {
+ return address () <= other.address ();
+ }
+ template<typename entry>
+ bool operator>= (const entry &other) const
+ {
+ return address () >= other.address ();
+ }
+
+ template<typename entry>
+ inline bool operator== (const entry &other) const
+ {
+ return (address () == other.address ()
+ && line () == other.line ()
+ && column () == other.column ()
+ && statement () == other.statement ()
+ && basic_block () == other.basic_block ()
+ && end_sequence () == other.end_sequence ()
+ && prologue_end () == other.prologue_end ()
+ && epilogue_begin () == other.epilogue_begin ()
+ && file () == other.file ());
+ }
+ template<typename entry>
+ inline bool operator!= (const entry &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ /* This holds a line table.
+ It's parameterized by the line_entry representation. */
+ template<typename line_entry>
+ class line_table : public std::vector<line_entry>
+ {
+ private:
+ typedef std::vector<line_entry> _base;
+
+ public:
+ typedef typename _base::size_type size_type;
+ typedef typename _base::difference_type difference_type;
+ typedef typename _base::value_type value_type;
+ typedef typename _base::iterator iterator;
+ typedef typename _base::const_iterator const_iterator;
+
+ struct hasher : public subr::container_hasher<line_table> {};
+
+ line_table () {}
+
+ template<typename table>
+ line_table (const table &other) : _base (other.begin (), other.end ()) {}
+
+ std::string to_string () const;
+
+ template<typename table>
+ inline bool operator== (const table &other) const
+ {
+ return (_base::size () == other.size ()
+ && subr::container_equal (*this, other));
+ }
+ template<typename table>
+ inline bool operator!= (const table &other) const
+ {
+ return !(*this == other);
+ }
+
+ // Look up by matching address.
+ iterator find (::Dwarf_Addr);
+ const_iterator find (::Dwarf_Addr) const;
+ };
+
+ /* This holds the entirety of line information.
+ The line_table is all there actually is. */
+ template<typename line_table>
+ class line_info_table
+ {
+ private:
+ line_table _m_lines;
+
+ public:
+ struct hasher : public std::unary_function<line_info_table, size_t>
+ {
+ inline size_t operator () (const line_info_table &info) const
+ {
+ return subr::hash_this (info._m_lines);
+ }
+ };
+
+ inline line_info_table () {}
+
+ template<typename table>
+ inline line_info_table (const table &other)
+ : _m_lines (other.lines ())
+ {}
+
+ template<typename table>
+ inline line_info_table &operator= (const table &other)
+ {
+ _m_lines = line_table (other.lines ());
+ return *this;
+ }
+
+ std::string to_string () const;
+
+ inline line_table &lines ()
+ {
+ return _m_lines;
+ }
+ inline const line_table &lines () const
+ {
+ return _m_lines;
+ }
+
+ template<typename table>
+ inline bool operator== (const table &other) const
+ {
+ return lines () == other.lines ();
+ }
+ template<typename table>
+ inline bool operator!= (const table &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ class dwarf_enum
+ : private std::pair< ::Dwarf_Word, unsigned int>
+ {
+ private:
+ typedef std::pair< ::Dwarf_Word, unsigned int> _base;
+
+ protected:
+ inline dwarf_enum ()
+ : _base (0, 0)
+ {}
+
+ public:
+ friend class subr::base_hasher<dwarf_enum, _base>;
+ typedef subr::base_hasher<dwarf_enum, _base> hasher;
+
+ inline dwarf_enum (unsigned int attr, unsigned int value)
+ : _base (value, attr)
+ {}
+
+ template<typename constant>
+ inline dwarf_enum (const constant &other)
+ : _base (static_cast<unsigned int> (other), other.which ())
+ {}
+
+ // Return the DW_AT_* indicating which enum this value belongs to.
+ inline unsigned int which () const
+ {
+ return this->second;
+ }
+
+ inline operator unsigned int () const
+ {
+ return this->first;
+ }
+
+ inline dwarf_enum &operator= (::Dwarf_Word value)
+ {
+ this->first = value;
+ return *this;
+ }
+
+ inline dwarf_enum &operator= (const dwarf_enum& other)
+ {
+ if (this->second == 0)
+ {
+ throw std::logic_error ("dwarf_enum default constructed");
+ this->second = other.second;
+ }
+ else if (this->second != other.second)
+ throw std::runtime_error
+ ("cannot assign dwarf_constant () from "
+ + dwarf::attributes::name (other.second) + "to "
+ + dwarf::attributes::name (this->second));
+
+ this->first = other.first;
+ return *this;
+ }
+
+ template<typename constant>
+ inline dwarf_enum &operator= (const constant& other)
+ {
+ return *this = dwarf_enum (other.which (), other);
+ }
+
+ std::string to_string () const;
+
+ const char *identifier () const;
+ const char *name () const;
+
+ template<typename constant>
+ inline bool operator== (const constant &other) const
+ {
+ return (static_cast<unsigned int> (*this)
+ == static_cast<unsigned int> (other));
+ }
+ template<typename constant>
+ inline bool operator!= (const constant &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // Same as set<pair<Dwarf_Addr, Dwarf_Addr>>.
+ typedef dwarf::arange_list range_list;
+
+ class location_attr
+ : public std::map<dwarf::location_attr::key_type, std::vector<uint8_t> >
+ {
+ private:
+ typedef std::map<dwarf::location_attr::key_type,
+ std::vector<uint8_t> > _base;
+
+ template<typename pair>
+ struct nonempty : public std::unary_function<pair, bool>
+ {
+ inline bool operator () (const pair &x)
+ {
+ return !x.second.empty ();
+ }
+ };
+
+ public:
+ typedef _base::size_type size_type;
+ typedef _base::difference_type difference_type;
+ typedef _base::key_type key_type;
+ typedef _base::mapped_type mapped_type;
+ typedef _base::value_type value_type;
+ typedef _base::iterator iterator;
+ typedef _base::const_iterator const_iterator;
+
+ struct hasher : public subr::container_hasher<location_attr> {};
+
+ inline location_attr () : _base () {}
+ inline location_attr (const location_attr &other)
+ : _base (static_cast<const _base &> (other)) {}
+ template<typename loc>
+ inline location_attr (const loc &other) : _base ()
+ {
+ *this = other;
+ }
+
+ template<typename loc>
+ inline location_attr &operator= (const loc &other)
+ {
+ clear ();
+ if (other.empty ())
+ ;
+ else if (other.is_list ())
+ for (typename loc::const_iterator i = other.begin ();
+ i != other.end ();
+ ++i)
+ {
+ const typename loc::mapped_type &x = (*i).second;
+ (*this)[(*i).first] = mapped_type (x.begin (), x.end ());
+ }
+ else
+ {
+ mapped_type v = other.location ();
+ (*this)[key_type (0, -1)] = v;
+ }
+ return *this;
+ }
+
+ inline bool is_list () const
+ {
+ if (empty ())
+ return false;
+ if (size () > 1)
+ return true;
+
+ const key_type &elt = begin ()->first;
+ return !(elt.first == 0 && elt.second == (Dwarf_Addr) -1);
+ }
+
+ inline mapped_type &location ()
+ {
+ if (empty ())
+ return (*this)[key_type (0, -1)];
+
+ value_type &v = *begin ();
+ if (v.first.first != 0 || v.first.second != (Dwarf_Addr) -1
+ || size () > 1)
+ throw std::runtime_error ("location is list, not single location");
+
+ return v.second;
+ }
+ inline const mapped_type &location () const
+ {
+ if (size () == 1)
+ {
+ const value_type &v = *begin ();
+ if (v.first.first == 0 && v.first.second == (Dwarf_Addr) -1)
+ return v.second;
+ }
+ throw std::runtime_error ("location is list, not single location");
+ }
+
+ template<typename other_attr>
+ bool operator== (const other_attr &other) const
+ {
+ if (empty ())
+ return (other.empty ()
+ || std::find_if (other.begin (), other.end (),
+ nonempty<typename other_attr::value_type> ()
+ ) == other.end ());
+ if (!is_list ())
+ return (!other.is_list () && !other.empty ()
+ && subr::container_equal (location (), other.location ()));
+
+ return other.is_list () && subr::container_equal (*this, other);
+ }
+ template<typename other_attr>
+ inline bool operator!= (const other_attr &other) const
+ {
+ return !(*this == other);
+ }
+
+ std::string to_string () const;
+ };
+
+ template<typename impl, bool alloc_values = true>
+ struct value
+ {
+ struct value_dispatch
+ {
+ virtual ~value_dispatch () {}
+ };
+
+ typedef value_dispatch value_cell_type;
+
+ static const bool delete_value = alloc_values;
+
+ template<typename flavor>
+ static inline flavor &
+ variant (flavor *&, const value_dispatch *&)
+ {
+ assert (!alloc_values);
+ throw std::logic_error ("can't happen!");
+ }
+
+ template<typename flavor>
+ static inline flavor &
+ variant (flavor *&result, value_dispatch *&value)
+ {
+ assert (alloc_values);
+ if (value == NULL)
+ {
+ result = new flavor;
+ value = result;
+ return *result;
+ }
+ result = dynamic_cast<flavor *> (value);
+ if (result == NULL)
+ throw std::runtime_error ("wrong value type");
+ return *result;
+ }
+
+ template<typename arg_type>
+ struct maker
+ {
+ inline explicit maker (const arg_type &) {}
+
+ template<typename flavor, typename input>
+ static inline void
+ make (value_dispatch *&v, flavor *&result,
+ int /*whatattr*/, const input &x, arg_type &arg)
+ {
+ assert (alloc_values);
+ v = result = new flavor (x, arg);
+ }
+ };
+
+ template<typename arg_type>
+ static inline maker<arg_type> make (arg_type &arg)
+ {
+ return maker<arg_type> (arg);
+ }
+
+ struct value_string : public value_dispatch, public std::string
+ {
+ typedef std::tr1::hash<std::string> hasher;
+
+ inline value_string () {}
+
+ template<typename string, typename arg_type>
+ inline value_string (const string &s, arg_type &)
+ : std::string (s)
+ {}
+
+ template<typename string>
+ inline value_string (const string &s)
+ : std::string (s)
+ {}
+
+ std::string to_string () const
+ {
+ std::string result ("\"");
+ result += *this;
+ result += "\"";
+ return result;
+ }
+ };
+
+ struct value_identifier : public value_string
+ {
+ inline value_identifier () {}
+
+ template<typename id, typename arg_type>
+ inline value_identifier (const id &s, arg_type &arg)
+ : value_string (s, arg)
+ {}
+
+ template<typename id>
+ inline value_identifier (const id &s)
+ : value_string (s)
+ {}
+ };
+
+ struct value_reference : public value_dispatch
+ {
+ typedef typename impl::debug_info_entry::pointer value_type;
+ value_type ref;
+
+ // Default constructor: reference to nowhere, invalid.
+ inline value_reference ()
+ : ref ()
+ {}
+
+ /* This is only kosher for a pointer into the same dwarf_edit
+ object. This is what plain assignment does. This just uses
+ this pointer, rather than translating it from another file
+ into this one (which requires a tracker). */
+ inline value_reference (const value_type &i, subr::nothing &)
+ : ref (i)
+ {}
+
+ template<typename iter, typename tracker>
+ inline value_reference (const iter &i, tracker &t)
+ : ref () // Invalid until t.finish ().
+ {
+ t.refer (&ref, i);
+ }
+ };
+
+ struct value_flag : public value_dispatch
+ {
+ bool flag;
+
+ inline value_flag (bool t = true)
+ : flag (t)
+ {}
+
+ template<typename arg_type>
+ inline value_flag (bool t, arg_type &)
+ : flag (t)
+ {}
+ };
+
+ struct value_address : public value_dispatch
+ {
+ // XXX dwfl, reloc
+ ::Dwarf_Addr addr;
+
+ inline value_address (::Dwarf_Addr x = 0)
+ : addr (x)
+ {}
+
+ template<typename arg_type>
+ inline value_address (::Dwarf_Addr x, arg_type &)
+ : addr (x)
+ {}
+
+ struct hasher : public std::unary_function<value_address, size_t>
+ {
+ inline size_t operator () (const value_address &c) const
+ {
+ return c.addr;
+ }
+ };
+
+ inline operator ::Dwarf_Addr () const
+ {
+ return addr;
+ }
+
+ inline bool operator== (::Dwarf_Addr x) const
+ {
+ return addr == x;
+ }
+ };
+
+ struct value_rangelistptr : public value_dispatch, public range_list
+ {
+ inline value_rangelistptr () {}
+
+ template<typename list, typename arg_type>
+ inline value_rangelistptr (const list &other, arg_type &)
+ : range_list (other)
+ {}
+
+ template<typename list>
+ inline value_rangelistptr (const list &other)
+ : range_list (other)
+ {}
+ };
+
+ struct value_lineptr : public value_dispatch, public impl::line_info_table
+ {
+ inline value_lineptr () {}
+
+ template<typename table, typename arg_type>
+ inline value_lineptr (const table &other, arg_type &)
+ : impl::line_info_table (other)
+ {}
+ };
+
+ struct value_constant : public value_dispatch
+ {
+ union
+ {
+ ::Dwarf_Word word;
+ ::Dwarf_Sword sword;
+ };
+
+ inline value_constant (::Dwarf_Word value = 0)
+ : word (value)
+ {}
+
+ template<typename arg_type>
+ inline value_constant (::Dwarf_Word x, arg_type &)
+ : word (x)
+ {}
+
+ struct hasher : public std::unary_function<value_constant, size_t>
+ {
+ inline size_t operator () (const value_constant &c) const
+ {
+ return c.word;
+ }
+ };
+
+ inline operator ::Dwarf_Word () const
+ {
+ return word;
+ }
+
+ inline bool operator== (::Dwarf_Word x) const
+ {
+ return word == x;
+ }
+ };
+
+ struct value_constant_block : public value_dispatch,
+ public std::vector<uint8_t>
+ {
+ typedef subr::hash<std::vector<uint8_t> > hasher;
+
+ inline value_constant_block () {}
+
+ template<typename block, typename arg_type>
+ inline value_constant_block (const block &b, arg_type &)
+ : std::vector<uint8_t> (b.begin (), b.end ())
+ {}
+
+ template<typename block>
+ inline value_constant_block (const block &b)
+ : std::vector<uint8_t> (b.begin (), b.end ())
+ {}
+ };
+
+ struct value_dwarf_constant : public value_dispatch, public dwarf_enum
+ {
+ inline value_dwarf_constant () {}
+
+ template<typename constant>
+ inline value_dwarf_constant (const constant &other)
+ : dwarf_enum (other)
+ {}
+
+ template<typename constant, typename arg_type>
+ inline value_dwarf_constant (const constant &other, arg_type &)
+ : dwarf_enum (other)
+ {}
+ };
+
+ struct value_source_file : public value_dispatch, public source_file
+ {
+ inline value_source_file () {}
+
+ template<typename file, typename arg_type>
+ inline value_source_file (const file &other, arg_type &)
+ : source_file (other)
+ {}
+
+ template<typename file>
+ inline value_source_file (const file &other)
+ : source_file (other)
+ {}
+ };
+
+ struct value_source_line : public value_dispatch
+ {
+ unsigned int n;
+
+ inline value_source_line (unsigned int x = 0)
+ : n (x)
+ {}
+
+ template<typename arg_type>
+ inline value_source_line (unsigned int m, arg_type &)
+ : n (m)
+ {}
+
+ struct hasher : public std::unary_function<value_source_line, size_t>
+ {
+ inline size_t operator () (const value_source_line &c) const
+ {
+ return c.n;
+ }
+ };
+
+ inline operator unsigned int () const
+ {
+ return n;
+ }
+
+ inline bool operator== (unsigned int x) const
+ {
+ return n == x;
+ }
+ };
+
+ class value_source_column : public value_source_line
+ {
+ };
+
+ struct value_macptr : public value_dispatch {};
+
+ struct value_location : public value_dispatch, public location_attr
+ {
+ inline value_location () {}
+
+ template<typename loc, typename arg_type>
+ inline value_location (const loc &other, arg_type &)
+ : location_attr (other)
+ {}
+
+ template<typename loc>
+ inline value_location (const loc &other)
+ : location_attr (other)
+ {}
+ };
+ };
+
+ // Forward decl.
+ template<class impl, typename v = value<impl> > class attributes_type;
+
+ template<class impl, typename vw = value<impl> >
+ class attr_value
+ {
+ friend class attributes_type<impl, vw>;
+ friend class value<impl>;
+
+ protected:
+ typename vw::value_cell_type *_m_value;
+ typedef typename impl::debug_info_entry::pointer die_ptr;
+
+ template<typename value, typename arg_type = subr::nothing>
+ struct init
+ {
+ inline init (attr_value *av, int whatattr,
+ const value &other, arg_type &arg)
+ {
+ do_init (av, whatattr, other, arg);
+ }
+
+ inline init (attr_value *av, int whatattr, const value &other)
+ {
+ arg_type dummy;
+ do_init (av, whatattr, other, dummy);
+ }
+
+ static inline void do_init (attr_value *av, int whatattr,
+ const value &other, arg_type &arg)
+ {
+ switch (other.what_space ())
+ {
+#define _DWARF_DATA_AV_MAKE(flavor, fetch) \
+ case dwarf::VS_##flavor: \
+ { \
+ typename vw::value_##flavor *p; \
+ vw::make (arg) \
+ .make (av->_m_value, p, whatattr, other.fetch (), arg); \
+ } \
+ break
+
+ _DWARF_DATA_AV_MAKE (identifier, identifier);
+ _DWARF_DATA_AV_MAKE (string, string);
+ _DWARF_DATA_AV_MAKE (flag, flag);
+ _DWARF_DATA_AV_MAKE (rangelistptr, ranges);
+ _DWARF_DATA_AV_MAKE (lineptr, line_info);
+ _DWARF_DATA_AV_MAKE (address, address);
+ _DWARF_DATA_AV_MAKE (source_line, source_line);
+ _DWARF_DATA_AV_MAKE (source_file, source_file);
+ _DWARF_DATA_AV_MAKE (dwarf_constant, dwarf_constant);
+ _DWARF_DATA_AV_MAKE (reference, reference);
+ _DWARF_DATA_AV_MAKE (location, location);
+ //_DWARF_DATA_AV_MAKE (macptr, macros); XXX
+
+ case dwarf::VS_constant:
+ if (other.constant_is_integer ())
+ {
+ typename vw::value_constant *p;
+ vw::make (arg).make (av->_m_value, p, whatattr,
+ other.constant (), arg);
+ }
+ else
+ {
+ typename vw::value_constant_block *p;
+ vw::make (arg).make (av->_m_value, p, whatattr,
+ other.constant_block (), arg);
+ }
+ break;
+
+ default:
+ case dwarf::VS_discr_list:
+ throw std::runtime_error ("XXX unimplemented");
+
+#undef _DWARF_DATA_AV_MAKE
+ }
+ }
+ };
+
+ // This is kosher only when freshly default-constructed.
+ template<typename value, typename arg_type>
+ inline void set (int whatattr, const value &other, arg_type &arg)
+ {
+ assert (_m_value == NULL);
+ init<value, arg_type> me (this, whatattr, other, arg);
+ }
+
+ template<typename flavor>
+ inline flavor &const_variant () const
+ {
+ flavor *p = dynamic_cast<flavor *> (_m_value);
+ if (p == NULL)
+ throw std::runtime_error (_m_value != NULL ? "wrong value type"
+ : "uninitialized attr_value (const?)");
+ return *p;
+ }
+
+ template<typename flavor>
+ inline const flavor &variant () const
+ {
+ return const_variant<const flavor> ();
+ }
+
+ template<typename flavor>
+ inline flavor &variant ()
+ {
+ flavor *p;
+ return vw::variant (p, _m_value);
+ }
+
+ template<typename value>
+ inline attr_value © (const value &other)
+ {
+ if (_m_value != NULL)
+ {
+ delete _m_value;
+ _m_value = NULL;
+ }
+ init<value> me (this, 0, other);
+ return *this;
+ }
+
+ public:
+ attr_value (const attr_value &other)
+ : _m_value (NULL)
+ {
+ if (other._m_value != NULL)
+ init<attr_value> me (this, 0, other);
+ }
+
+ inline attr_value ()
+ : _m_value (NULL)
+ {}
+
+ ~attr_value ()
+ {
+ if (vw::delete_value && _m_value != NULL)
+ delete _m_value;
+ }
+
+ template<typename value>
+ inline attr_value &operator= (const value &other)
+ {
+ return copy (other);
+ }
+
+ /* This is the same as the generic template one,
+ but we have to define it explicitly to override
+ the default assignment operator. */
+ inline attr_value &operator= (const attr_value &other)
+ {
+ return copy (other);
+ }
+
+ dwarf::value_space what_space () const;
+ inline std::string to_string () const;
+
+ inline const bool &flag () const
+ {
+ return variant<typename vw::value_flag> ().flag;
+ }
+
+ inline bool &flag ()
+ {
+ return variant<typename vw::value_flag> ().flag;
+ }
+
+ // XXX dwfl, reloc
+ inline const ::Dwarf_Addr &address () const
+ {
+ return variant<typename vw::value_address> ().addr;
+ }
+
+ // XXX dwfl, reloc
+ inline ::Dwarf_Addr &address ()
+ {
+ return variant<typename vw::value_address> ().addr;
+ }
+
+ inline const die_ptr &reference () const
+ {
+ return variant<typename vw::value_reference> ().ref;
+ }
+
+ inline die_ptr &reference ()
+ {
+ return variant<typename vw::value_reference> ().ref;
+ }
+
+ inline const location_attr &location () const
+ {
+ return static_cast<const location_attr &>
+ (variant<typename vw::value_location> ());
+ }
+
+ inline location_attr &location ()
+ {
+ return static_cast<location_attr &>
+ (variant<typename vw::value_location> ());
+ }
+
+ inline const std::string &string () const
+ {
+ if (dynamic_cast<const typename vw::value_source_file *> (_m_value))
+ return source_file ().name ();
+ return static_cast<const std::string &>
+ (variant<typename vw::value_string> ());
+ }
+
+ inline std::string &string ()
+ {
+ if (dynamic_cast<const typename vw::value_source_file *> (_m_value))
+ return source_file ().name ();
+ return static_cast<std::string &>
+ (variant<typename vw::value_string> ());
+ }
+
+ inline const std::string &identifier () const
+ {
+ return static_cast<const std::string &>
+ (variant<typename vw::value_identifier> ());
+ }
+
+ inline std::string &identifier ()
+ {
+ return static_cast<std::string &>
+ (variant<typename vw::value_identifier> ());
+ }
+
+ inline const typename impl::source_file &source_file () const
+ {
+ return static_cast<const typename impl::source_file &>
+ (variant<typename vw::value_source_file> ());
+ }
+
+ inline typename impl::source_file &source_file ()
+ {
+ return static_cast<typename impl::source_file &>
+ (variant<typename vw::value_source_file> ());
+ }
+
+ inline const unsigned int &source_line () const
+ {
+ return variant<typename vw::value_source_line> ().n;
+ }
+
+ inline unsigned int &source_line ()
+ {
+ return variant<typename vw::value_source_line> ().n;
+ }
+
+ inline const unsigned int &source_column () const
+ {
+ return variant<typename vw::value_source_column> ().n;
+ }
+
+ inline unsigned int &source_column ()
+ {
+ return variant<typename vw::value_source_column> ().n;
+ }
+
+ inline const ::Dwarf_Word &constant () const
+ {
+ return variant<typename vw::value_constant> ().word;
+ }
+
+ inline ::Dwarf_Word &constant ()
+ {
+ return variant<typename vw::value_constant> ().word;
+ }
+
+ inline const ::Dwarf_Sword &signed_constant () const
+ {
+ return variant<typename vw::value_constant> ().sword;
+ }
+
+ inline ::Dwarf_Sword &signed_constant ()
+ {
+ return variant<typename vw::value_constant> ().sword;
+ }
+
+ inline const std::vector<uint8_t> &constant_block () const
+ {
+ return static_cast<const std::vector<uint8_t> &>
+ (variant<typename vw::value_constant_block> ());
+ }
+
+ inline std::vector<uint8_t> &constant_block ()
+ {
+ return static_cast<std::vector<uint8_t> &>
+ (variant<typename vw::value_constant_block> ());
+ }
+
+ inline const typename impl::dwarf_enum &dwarf_constant () const
+ {
+ return variant<typename vw::value_dwarf_constant> ();
+ }
+
+ inline typename impl::dwarf_enum &dwarf_constant ()
+ {
+ return variant<typename vw::value_dwarf_constant> ();
+ }
+
+ inline bool constant_is_integer () const
+ {
+ return (dynamic_cast<const typename vw::value_constant *> (_m_value)
+ != NULL);
+ }
+
+ inline const typename impl::range_list &ranges () const
+ {
+ return static_cast<const range_list &>
+ (variant<const typename vw::value_rangelistptr> ());
+ }
+
+ inline typename impl::range_list &ranges ()
+ {
+ return static_cast<range_list &>
+ (variant<typename vw::value_rangelistptr> ());
+ }
+
+ inline const typename impl::line_info_table &line_info () const
+ {
+ return static_cast<const typename impl::line_info_table &>
+ (variant<const typename vw::value_lineptr> ());
+ }
+
+ inline typename impl::line_info_table &line_info ()
+ {
+ return static_cast<typename impl::line_info_table &>
+ (variant<typename vw::value_lineptr> ());
+ }
+
+ // macptr
+
+ template<typename value>
+ inline bool operator== (const value &other) const
+ {
+ const dwarf::value_space what = what_space ();
+ if (likely (other.what_space () == what))
+ switch (what)
+ {
+ case dwarf::VS_identifier:
+ return identifier () == other.identifier ();
+ case dwarf::VS_string:
+ return string () == other.string ();
+ case dwarf::VS_reference:
+ return reference () == other.reference ();
+ case dwarf::VS_flag:
+ return flag () == other.flag ();
+ case dwarf::VS_rangelistptr:
+ return ranges () == other.ranges ();
+ case dwarf::VS_lineptr:
+ return line_info () == other.line_info ();
+ case dwarf::VS_constant:
+ if (constant_is_integer ())
+ return (other.constant_is_integer ()
+ && constant () == other.constant ());
+ return (!other.constant_is_integer ()
+ && constant_block () == other.constant_block ());
+ case dwarf::VS_source_file:
+ return source_file () == other.source_file ();
+ case dwarf::VS_source_line:
+ return source_line () == other.source_line ();
+ case dwarf::VS_source_column:
+ return source_column () == other.source_column ();
+ case dwarf::VS_address:
+ return address () == other.address ();
+ case dwarf::VS_location:
+ return location () == other.location ();
+ case dwarf::VS_dwarf_constant:
+ return dwarf_constant () == other.dwarf_constant ();
+#if 0
+ case dwarf::VS_macptr:
+ return macptr () == other.macptr ();
+#endif
+ default:
+ case dwarf::VS_discr_list:
+ throw std::runtime_error ("XXX unimplemented");
+ }
+ return false;
+ }
+ template<typename value>
+ inline bool operator!= (const value &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ template<class impl, typename v>
+ class attributes_type
+ : public std::map<int, typename impl::attr_value>
+ {
+ friend class impl::me;
+ protected:
+ typedef std::map<int, typename impl::attr_value> base_type;
+
+ inline attributes_type () {}
+
+ template<typename iter>
+ inline attributes_type (const iter &from, const iter &to)
+ : base_type (from, to)
+ {}
+
+ template<typename input, typename arg_type>
+ inline void set (const input &other, arg_type &c)
+ {
+ for (typename input::const_iterator attr = other.begin ();
+ attr != other.end ();
+ ++attr)
+ (*this)[(*attr).first].set ((*attr).first, (*attr).second, c);
+ }
+
+ public: // XXX should be protected
+
+ /* We don't use the base_type (begin, end) iterator constructor here
+ for good reason. The ref-maker needs to collect back-pointers
+ into our mapped_value (attr_value) objects. It would not fly to
+ have that done in a temporary attr_value object that gets copied
+ into the map cell by assignment. We must make sure that when a
+ value_reference is constructed, it is really the one sitting in
+ our map that the ref-maker will want to update later. */
+ template<typename input, typename arg_type>
+ inline attributes_type (const input &other, arg_type &c)
+ : base_type ()
+ {
+ set (other, c);
+ }
+
+ public:
+ typedef typename base_type::key_type key_type;
+ typedef typename base_type::value_type value_type;
+ typedef typename base_type::mapped_type mapped_type;
+
+ static inline bool ordered ()
+ {
+ return true;
+ }
+
+ template<typename attrs>
+ inline operator attrs () const
+ {
+ return attrs (base_type::begin (), base_type::end ());
+ }
+ };
+
+ };
+
+ // Explicit specializations.
+ template<>
+ std::string to_string<dwarf_data::dwarf_enum> (const dwarf_data::dwarf_enum&);
+ inline std::string dwarf_data::dwarf_enum::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+
+ template<class impl, typename v>
+ inline std::string dwarf_data::attr_value<impl, v>::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+
+};
+
+#endif
--- /dev/null
+/* elfutils::dwarf_edit -- mutable DWARF representation in -*- C++ -*-
+ Copyright (C) 2009-2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_EDIT
+#define _ELFUTILS_DWARF_EDIT 1
+
+#include "dwarf"
+#include "dwarf_data"
+#include "dwarf_ref_maker"
+
+#include <type_traits>
+
+
+/* Read the comments for elfutils::dwarf first.
+
+ The elfutils::dwarf_edit class is template-compatible with the logical
+ containers described in elfutils::dwarf, and copy-constructible from the
+ input class.
+
+ The elfutils::dwarf_edit containers are mutable, unlike the input
+ classes. You can modify the DWARF directly in all the normal ways the
+ corresponding std containers have, or build it up from scratch. When
+ you have it how you want it, you can pass it into elfutils::dwarf_output.
+
+ The dwarf_edit classes will use unreasonable amounts of memory for large
+ DWARF data sets, like from reading in whole large program and DSO files.
+ To transform input files efficiently, you should construct dwarf_output
+ directly from input dwarf with transformations applied on the fly, and
+ not use dwarf_edit at all.
+
+ dwarf_edit is the only mutable representation and so it's easy to use in
+ a straightforward imperative style. Use it for transformations on small
+ data files, or for creating small data sets from scratch. */
+
+// DWARF manipulation interfaces (pure object construction)
+namespace elfutils
+{
+ template<typename elt>
+ inline bool operator== (const std::vector<elt> &a, const const_vector<elt> &b)
+ {
+ return a.size () == b.size () && subr::container_equal (a, b);
+ }
+
+ class dwarf_edit
+ {
+ private:
+ friend class dwarf_data;
+ typedef dwarf_edit me;
+
+ public:
+ typedef dwarf_data::source_file source_file;
+ typedef dwarf_data::line_entry<source_file> line_entry;
+ typedef dwarf_data::line_table<line_entry> line_table;
+ typedef dwarf_data::line_info_table<line_table> line_info_table;
+ typedef dwarf_data::dwarf_enum dwarf_enum;
+ typedef dwarf_data::range_list range_list;
+ typedef dwarf_data::location_attr location_attr;
+ typedef dwarf_data::attr_value<dwarf_edit> attr_value;
+
+ class debug_info_entry
+ {
+ friend class subr::create_container;
+
+ public:
+ typedef dwarf_data::attributes_type<dwarf_edit> attributes_type;
+
+ class children_type : public std::list<debug_info_entry>
+ {
+ friend class debug_info_entry;
+ private:
+ inline children_type () {}
+
+ template<typename input, typename tracker>
+ static inline void
+ equivalence (const iterator &out,
+ const typename input::const_iterator &in,
+ bool, // last-sibling
+ tracker &t)
+ {
+ out->set (*in, t);
+ t.equivalence (out, in);
+ }
+
+ template<typename input, typename tracker>
+ inline children_type (const input &other, tracker &t)
+ {
+ subr::create_container (this, other, t, equivalence<input, tracker>);
+ }
+
+ public:
+ typedef debug_info_entry value_type;
+
+ inline iterator add_entry (int tag, const iterator &pos)
+ {
+ return insert (pos, debug_info_entry (tag));
+ }
+
+ inline iterator add_entry (int tag)
+ {
+ return add_entry (tag, end ());
+ }
+ };
+
+ typedef children_type::iterator pointer;
+ typedef children_type::const_iterator const_pointer;
+
+ protected:
+ int _m_tag;
+ attributes_type _m_attributes;
+ children_type _m_children;
+
+ // This is can only be used by the children_type constructor,
+ // which immediately calls set.
+ inline debug_info_entry ()
+ : _m_tag (-1), _m_attributes (), _m_children ()
+ {}
+
+ template<typename die_type, typename arg_type>
+ inline void set (const die_type &die, arg_type &arg)
+ {
+ try
+ {
+ _m_tag = die.tag ();
+ attributes_type t_attrs (die.attributes (), arg);
+ _m_attributes.swap (t_attrs);
+ children_type t_children (die.children (), arg);
+ _m_children.swap (t_children);
+ }
+ catch (...)
+ {
+ // Never leave a partially-formed DIE.
+ _m_tag = -1;
+ _m_attributes.clear ();
+ _m_children.clear ();
+ throw;
+ };
+ }
+
+ public:
+ inline debug_info_entry (int t)
+ : _m_tag (t), _m_attributes (), _m_children ()
+ {
+ if (unlikely (t <= 0))
+ throw std::invalid_argument ("invalid tag");
+ }
+
+ /* The template constructor lets us copy in from any class that has
+ compatibly iterable containers for attributes and children. */
+ template<typename die_type, typename tracker>
+ debug_info_entry (const die_type &die, tracker &t)
+ : _m_tag (die.tag ()),
+ _m_attributes (die.attributes (), t),
+ _m_children (die.children (), t)
+ {}
+
+ inline std::string to_string () const;
+
+ inline int tag () const
+ {
+ return _m_tag;
+ }
+
+ inline bool has_children () const
+ {
+ return !_m_children.empty ();
+ }
+
+ inline children_type &children ()
+ {
+ return _m_children;
+ }
+ inline const children_type &children () const
+ {
+ return _m_children;
+ }
+
+ inline attributes_type &attributes ()
+ {
+ return _m_attributes;
+ }
+ inline const attributes_type &attributes () const
+ {
+ return _m_attributes;
+ }
+
+ template<typename die>
+ bool operator== (const die &other) const
+ {
+ return (other.tag () == tag ()
+ && other.attributes () == attributes ()
+ && other.children () == children ());
+ }
+ template<typename die>
+ bool operator!= (const die &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline dwarf::debug_info_entry::identity_type identity () const
+ {
+ return (uintptr_t) this;
+ }
+
+ inline ::Dwarf_Off offset () const
+ {
+ return identity ();
+ }
+
+ inline ::Dwarf_Off cost () const
+ {
+ return 0;
+ }
+
+ // Convenience entry point.
+ inline pointer add_entry (int child_tag)
+ {
+ return children ().add_entry (child_tag);
+ }
+ };
+
+ typedef debug_info_entry::attributes_type::value_type attribute;
+
+ typedef dwarf_data::compile_unit<dwarf_edit> compile_unit;
+
+ // Main container anchoring all the output.
+ class compile_units_type
+ : public dwarf_data::compile_units_type<dwarf_edit>
+ {
+ friend class dwarf_edit;
+
+ private:
+ inline compile_units_type (const compile_units_type &)
+ : dwarf_data::compile_units_type<dwarf_edit> ()
+ {
+ throw std::logic_error
+ ("must copy-construct top-level dwarf_edit object instead");
+ }
+
+ // Constructor copying CUs from input container.
+ template<typename input, typename tracker>
+ inline compile_units_type (const input &other, tracker &t)
+ {
+ subr::create_container (this, other, t);
+ }
+
+ public:
+ // Default constructor: an empty container, no CUs.
+ inline compile_units_type () {}
+
+ inline compile_unit &add_unit ()
+ {
+ push_back (compile_unit ());
+ return back ();
+ }
+ };
+
+ private:
+ compile_units_type _m_units;
+
+ typedef dwarf_ref_maker<dwarf_edit, dwarf_edit> edit_ref_maker;
+
+ public:
+ class compile_units_type &compile_units ()
+ {
+ return _m_units;
+ }
+ const class compile_units_type &compile_units () const
+ {
+ return _m_units;
+ }
+
+ // Convenience entry point.
+ inline compile_unit &add_unit ()
+ {
+ return compile_units ().add_unit ();
+ }
+
+ // Default constructor: an empty container, no CUs.
+ inline dwarf_edit () {}
+
+ // Constructor copying CUs from an input file (dwarf or dwarf_edit).
+ template<typename input, typename tracker>
+ inline dwarf_edit (const input &dw, tracker &t,
+ subr::guard<tracker> guard = subr::guard<tracker> ())
+ : _m_units (dw.compile_units (), guard (t))
+ {
+ guard.clear ();
+ }
+
+ // Copying constructor with default ref-maker.
+ template<typename input>
+ inline dwarf_edit (const input &dw,
+ dwarf_ref_maker<dwarf_edit, input> t
+ = dwarf_ref_maker<dwarf_edit, input> (),
+ subr::guard<dwarf_ref_maker<dwarf_edit, input> > guard
+ = subr::guard<dwarf_ref_maker<dwarf_edit, input> > ())
+ : _m_units (dw.compile_units (), guard (t))
+ {
+ guard.clear ();
+ }
+
+ // We have to write this explicitly or it will do default-copying!
+ inline dwarf_edit (const dwarf_edit &dw,
+ edit_ref_maker t = edit_ref_maker (),
+ subr::guard<edit_ref_maker > guard
+ = subr::guard<edit_ref_maker > ())
+ : _m_units (dw.compile_units (), guard (t))
+ {
+ guard.clear ();
+ }
+
+ template<typename file>
+ inline bool operator== (const file &other) const
+ {
+ return compile_units () == other.compile_units ();
+ }
+ template<typename file>
+ inline bool operator!= (const file &other) const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // Explicit specializations.
+ template<>
+ std::string to_string<dwarf_edit::debug_info_entry>
+ (const dwarf_edit::debug_info_entry &);
+ inline std::string dwarf_edit::debug_info_entry::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+ template<>
+ std::string to_string<dwarf_edit::attribute> (const dwarf_edit::attribute &);
+ template<>
+ std::string to_string<dwarf_edit::attr_value> (const dwarf_edit::attr_value&);
+
+ template<>
+ std::string dwarf_edit::line_table::to_string () const;
+ template<>
+ std::string dwarf_edit::line_info_table::to_string () const;
+
+ // Explicit instantiations.
+ extern template class dwarf_data::line_entry<dwarf_edit::source_file>;
+ extern template class dwarf_data::line_table<dwarf_edit::line_entry>;
+ extern template class dwarf_data::line_info_table<dwarf_edit::line_table>;
+ extern template class dwarf_data::attr_value<dwarf_edit>;
+ extern template class dwarf_data::value<dwarf_edit>;
+
+};
+
+#endif // <elfutils/dwarf_edit>
--- /dev/null
+/* elfutils::dwarf_output -- DWARF file generation in -*- C++ -*-
+ Copyright (C) 2009, 2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_OUTPUT
+#define _ELFUTILS_DWARF_OUTPUT 1
+
+#include "dwarf"
+#include "dwarf_edit"
+#include "dwarf_comparator"
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <vector>
+#include <stack>
+#include <queue>
+#include <bitset>
+#include <set>
+#include <tr1/unordered_set>
+
+/* Read the comments for elfutils::dwarf first.
+
+ The elfutils::dwarf_output class is template-compatible with the logical
+ containers described in elfutils::dwarf and elfutils::dwarf_edit.
+
+ The dwarf_output representation of the DWARF data is immutable once
+ created. The only way to create the object is by copy-construction
+ from another compatible object: dwarf, dwarf_edit, or dwarf_output.
+ Construction collects all the information necessary to generate the
+ formatted DWARF sections. */
+
+namespace elfutils
+{
+ class dwarf_output_collector;
+
+ class dwarf_output
+ {
+ private:
+ friend class dwarf_output_collector;
+ friend class dwarf_data;
+ typedef dwarf_output me;
+
+ public:
+ typedef dwarf_data::source_file source_file;
+ typedef dwarf_data::line_entry<source_file> line_entry;
+ typedef dwarf_data::line_table<line_entry> line_table;
+ typedef dwarf_data::line_info_table<line_table> line_info_table;
+ typedef dwarf_data::dwarf_enum dwarf_enum;
+ typedef dwarf_data::range_list range_list;
+ typedef dwarf_data::location_attr location_attr;
+
+ class compile_units_type;
+ class debug_info_entry;
+ class attr_value;
+
+ protected:
+ static inline void never_copy ()
+ {
+ throw std::logic_error
+ ("must copy-construct top-level dwarf_output object instead");
+ }
+
+ template<typename input> class copier; // Below.
+
+#if 0
+ /* An iterator adapter for use in iterator-based constructors.
+ collectify (iterator) yields an iterator on input where *i
+ constructs output::value_type (input::value_type v, collector). */
+ template<typename input, typename output>
+ static inline typename subr::argifier<input, output,
+ dwarf_output_collector &>::result_type
+ collectify (const typename input::const_iterator &in,
+ dwarf_output_collector &c)
+ {
+ return subr::argifier<input, output, dwarf_output_collector &> (c) (in);
+ }
+#endif
+
+ /* Every kind of value is made by calling into the copier, which
+ returns a const pointer into a value_set living in the collector. */
+ struct value
+ : public dwarf_data::value<dwarf_output, false>
+ {
+ typedef const value_dispatch value_cell_type;
+
+ typedef dwarf_data::value<dwarf_output> data;
+
+ template<typename copier_type> struct maker;
+
+ template<typename arg_type>
+ static inline maker<arg_type> make (arg_type &arg)
+ {
+ return maker<arg_type> (arg);
+ }
+
+ struct value_reference; // Defined below.
+ };
+
+ struct die_info;
+ typedef std::pair<const debug_info_entry, die_info> die_info_pair;
+
+ public:
+
+ class debug_info_entry
+ {
+ friend class dwarf_output;
+ friend class dwarf_output_collector;
+
+ __attribute__((used)) die_info_pair *info () const
+ {
+ return reinterpret_cast<die_info_pair *>
+ (const_cast<debug_info_entry *> (this));
+ }
+
+ public:
+ class attributes_type
+ : public dwarf_data::attributes_type<dwarf_output, value>
+ {
+ friend class dwarf_output;
+
+ private:
+ typedef dwarf_data::attributes_type<dwarf_output, value> _base;
+
+ size_t _m_hash;
+
+ inline attributes_type ()
+ : _base (), _m_hash (0)
+ {}
+
+ struct same_attr : public std::equal_to<value_type>
+ {
+ bool operator () (const value_type &a,
+ const value_type &b) const
+ {
+ return a.first == b.first && a.second.is (b.second);
+ }
+ };
+
+ inline void do_hash ()
+ {
+ // Precompute our hash value based on our contents.
+ for (iterator i = begin (); i != end (); ++i)
+ subr::hash_combine (_m_hash, *i);
+ }
+
+ inline const _base &base () const
+ {
+ return *this;
+ }
+
+ public:
+ template<typename iter>
+ inline attributes_type (const iter &from, const iter &to)
+ : _base (from, to), _m_hash (0)
+ {
+ do_hash ();
+ }
+
+ friend class subr::hashed_hasher<attributes_type>;
+ typedef subr::hashed_hasher<attributes_type> hasher;
+
+ template<typename input, typename arg_type>
+ inline attributes_type (const input &other, arg_type &c)
+ : _base (other, c), _m_hash (0)
+ {
+ do_hash ();
+ }
+
+ inline bool is (const attributes_type &these) const
+ {
+ return (_m_hash == these._m_hash
+ && size () == these.size ()
+ && std::equal (begin (), end (), these.begin (),
+ same_attr ()));
+ }
+ };
+
+ class children_type
+ : public std::vector<die_info_pair *>
+ {
+ friend class dwarf_output;
+ friend class dwarf_output_collector;
+
+ protected:
+ typedef std::vector<die_info_pair *> _base;
+
+ size_t _m_hash;
+
+ inline void set_hash ()
+ {
+ _m_hash = 0;
+ for (_base::iterator i = _base::begin (); i != _base::end (); ++i)
+ subr::hash_combine (_m_hash, (uintptr_t) *i);
+ }
+
+ inline children_type () {}
+
+ inline const _base &info () const
+ {
+ return *this;
+ }
+
+ struct deref
+ : public std::unary_function<die_info_pair *,
+ const debug_info_entry &>
+ {
+ inline deref (...) {}
+ inline const debug_info_entry &operator () (die_info_pair *) const;
+ };
+
+ template<typename circular>
+ inline void reify_children (die_info_pair *, bool, unsigned int &)
+ const;
+
+ public:
+ template<typename iter>
+ inline children_type (const iter &first, const iter &last)
+ : _base (first, last)
+ {
+ set_hash ();
+ }
+
+ friend class subr::hashed_hasher<children_type>;
+ typedef subr::hashed_hasher<children_type> hasher;
+
+ typedef debug_info_entry value_type;
+ typedef debug_info_entry &reference;
+ typedef debug_info_entry &const_reference;
+ typedef debug_info_entry *pointer;
+ typedef debug_info_entry *const_pointer;
+
+ inline bool is (const children_type &these) const
+ {
+ return (_m_hash == these._m_hash
+ && size () == these.size ()
+ && std::equal (_base::begin (), _base::end (),
+ these._base::begin ()));
+ }
+
+ typedef subr::wrapped_input_iterator<
+ _base, deref, const debug_info_entry> const_iterator;
+ typedef const_iterator iterator;
+
+ inline const_iterator begin () const
+ {
+ return const_iterator (_base::begin (), subr::nothing ());
+ }
+
+ inline const_iterator end () const
+ {
+ return const_iterator (_base::end (), subr::nothing ());
+ }
+ };
+
+ typedef children_type::iterator pointer;
+ typedef children_type::const_iterator const_pointer;
+
+ protected:
+ const children_type *_m_children;
+ const attributes_type *_m_attributes;
+ size_t _m_hash;
+ int _m_tag;
+
+ // This is can only be used by the children_type constructor,
+ // which immediately calls set.
+ inline debug_info_entry ()
+ : _m_children (NULL),
+ _m_attributes (NULL),
+ _m_hash (0),
+ _m_tag (-1)
+ {}
+
+ inline debug_info_entry (int what,
+ const children_type *childs,
+ const attributes_type *attrs)
+ : _m_children (childs),
+ _m_attributes (attrs),
+ _m_tag (what)
+ {
+ set_hash ();
+ }
+
+ inline void set_hash ()
+ {
+ _m_hash = _m_tag;
+ subr::hash_combine (_m_hash, *_m_attributes);
+ subr::hash_combine (_m_hash, *_m_children);
+ }
+
+ public:
+ friend class subr::hashed_hasher<debug_info_entry>;
+ typedef subr::hashed_hasher<debug_info_entry> hasher;
+
+ inline bool is (const debug_info_entry &that) const
+ {
+ return (_m_hash == that._m_hash
+ && _m_tag == that._m_tag
+ && _m_attributes == that._m_attributes
+ && _m_children == that._m_children);
+ }
+
+ inline std::string to_string () const;
+
+ inline int tag () const
+ {
+ return _m_tag;
+ }
+
+ inline bool has_children () const
+ {
+ return !_m_children->empty ();
+ }
+
+ inline const children_type &children () const
+ {
+ return *_m_children;
+ }
+
+ inline const attributes_type &attributes () const
+ {
+ return *_m_attributes;
+ }
+
+ template<typename die>
+ bool operator== (const die &other) const
+ {
+ return (other.tag () == tag ()
+ && other.attributes () == attributes ()
+ && other.children () == children ());
+ }
+ template<typename die>
+ bool operator!= (const die &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline dwarf::debug_info_entry::identity_type identity () const
+ {
+ return (uintptr_t) this;
+ }
+
+ inline ::Dwarf_Off offset () const
+ {
+ return identity ();
+ }
+
+ inline ::Dwarf_Off cost () const
+ {
+ return 0;
+ }
+ };
+
+ struct value::value_reference
+ : public dwarf_data::value<dwarf_output, false>::value_reference
+ {
+ typedef dwarf_data::value<dwarf_output, false>::value_reference _base;
+
+ // Default constructor: reference to nowhere, invalid.
+ inline value_reference ()
+ : _base ()
+ {}
+
+ inline value_reference (const value_type &i, subr::nothing &dummy)
+ : _base (i, dummy)
+ {}
+
+ /* The hash of a value_reference is its referent's local hash,
+ which only takes non-reference values into account. This
+ method is virtual for the circular_reference case, below. */
+ inline size_t hash () const
+ {
+ struct die_info *info = get_die_info ();
+ return info->_m_reference_hash;
+ }
+
+ virtual die_info *get_die_info () const
+ {
+ return &ref->info ()->second;
+ }
+ };
+
+ class attr_value
+ : public dwarf_data::attr_value<dwarf_output, value>
+ {
+ friend class dwarf_output;
+
+ private:
+ typedef dwarf_data::attr_value<dwarf_output, value> _base;
+
+ public:
+ inline std::string to_string () const;
+
+ /* These constructors can only be used by the containers
+ used in the collector. The attributes_type map in an
+ actual debug_info_entry object is always const. */
+ inline attr_value ()
+ : _base ()
+ {}
+
+ inline attr_value (const attr_value &other)
+ : _base ()
+ {
+ _m_value = other._m_value;
+ }
+
+ /* Two identical values in fact share the same cell in the collector.
+ So we can use simple pointer comparison here. */
+ inline bool is (const attr_value &that) const
+ {
+ return _m_value == that._m_value;
+ }
+
+ // The is () test works only on a dwarf_output sharing the same collector.
+ inline bool operator== (const attr_value &other) const
+ {
+ return is (other) || _base::operator== (other);
+ }
+ inline bool operator!= (const attr_value &other) const
+ {
+ return !(*this == other);
+ }
+
+ /* We can use the _m_value pointer itself as a perfect hash,
+ because all identical values share the same cell in the
+ collector. The exception to this is for references. See
+ value_reference::hash. */
+ struct hasher : public std::unary_function<attr_value, size_t>
+ {
+ inline size_t operator () (const attr_value &v) const
+ {
+ const value::value_reference *ref
+ = dynamic_cast<const value::value_reference *> (v._m_value);
+ return ref == NULL ? (uintptr_t) v._m_value : ref->hash ();
+ }
+ };
+ };
+
+ typedef debug_info_entry::attributes_type::value_type attribute;
+
+ typedef dwarf_data::compile_unit<dwarf_output> compile_unit;
+
+ /* Main container anchoring all the output.
+
+ This is the only container that actually lives in the dwarf_output
+ object. All others live in the dwarf_output_collector's sets, and
+ we return const references to those copies.
+
+ This list is actually mutable as a std::list. But note that you
+ should never remove a compile_unit, though you can reorder the
+ list. Nothing is ever removed from the collector, so your final
+ output file can wind up with unreferenced data being encoded. If
+ you do remove any elements, then you should start a fresh collector
+ and construct a new dwarf_output object by copying using that
+ collector (or, equivalently, call o.compile_units ().recollect (C)
+ on the new collector C). */
+ class compile_units_type
+ : public dwarf_data::compile_units_type<dwarf_output>
+ {
+ friend class dwarf_output;
+
+ private:
+ inline compile_units_type (const compile_units_type &)
+ : dwarf_data::compile_units_type<dwarf_output> ()
+ {
+ never_copy ();
+ }
+
+ template<typename input, typename copier_type>
+ static inline void
+ cu_maker (const iterator &out,
+ const typename input::const_iterator &in,
+ bool, // last-sibling
+ copier_type &c)
+ {
+ c.make_unit (in, out);
+ }
+
+ // Constructor copying CUs from input container.
+ template<typename input, typename copier>
+ inline compile_units_type (const input &other, copier &c)
+ {
+ subr::create_container (this, other, c, cu_maker<input, copier>);
+ }
+
+ public:
+ // Default constructor: an empty container, no CUs.
+ inline compile_units_type () {}
+ };
+
+ private:
+ compile_units_type _m_units;
+
+ public:
+ class compile_units_type &compile_units ()
+ {
+ return _m_units;
+ }
+ const class compile_units_type &compile_units () const
+ {
+ return _m_units;
+ }
+
+ private:
+ // Bind default copy-constructor and prevent it.
+ inline dwarf_output (const dwarf_output &)
+ {
+ throw std::logic_error ("copying dwarf_output requires a collector");
+ }
+
+ public:
+ // Constructor for an empty file, can add to its compile_units ().
+ inline dwarf_output () {}
+
+ /* Constructor copying CUs from an input file (can be any of dwarf,
+ dwarf_edit, or dwarf_output). Supply your own copier to reuse a
+ copier across multiple input files. This is worthwhile only if
+ they share a string table and such in memory. */
+ template<typename input>
+ inline dwarf_output (const input &dw, copier<input> &maker)
+ : _m_units (dw.compile_units (), maker)
+ {}
+
+ // Normal construction instantiates a copier derived from the collector.
+ template<typename input>
+ inline dwarf_output (const input &dw, dwarf_output_collector &c)
+ {
+ copier<input> maker (c);
+ compile_units_type tmp_units (dw.compile_units (), maker);
+ _m_units.swap (tmp_units);
+ }
+
+ template<typename file>
+ inline bool operator== (const file &other) const
+ {
+ return compile_units () == other.compile_units ();
+ }
+ template<typename file>
+ inline bool operator!= (const file &other) const
+ {
+ return !(*this == other);
+ }
+
+ protected:
+ struct die_info
+ {
+ die_info_pair *_m_parent;
+ std::queue<value::value_reference *> _m_refs;
+ std::set< ::Dwarf_Off> _m_originals; // XXX fix for cross-file sharing input
+ size_t _m_original_cost;
+ std::bitset<2> _m_with_sibling;
+ unsigned int _m_uses;
+
+ /* The local hash of the die, set when die_info is created.
+ Uses only none-reference values. */
+ size_t _m_local_hash;
+
+ /* The reference hash of the die, based on just reference
+ attribute values. Needs all local hashes of referenced dies
+ to be set. */
+ size_t _m_reference_hash;
+
+ inline die_info (size_t local_hash)
+ : _m_parent (NULL), _m_refs (),
+ _m_originals (), _m_original_cost (0),
+ _m_with_sibling (), _m_uses (0),
+ _m_local_hash (local_hash),
+ _m_reference_hash (0)
+ {}
+
+ inline ~die_info ()
+ {
+ while (!_m_refs.empty ())
+ {
+ delete _m_refs.front ();
+ _m_refs.pop ();
+ }
+ }
+
+ inline void original (unsigned int &incoming_count,
+ ::Dwarf_Off off, ::Dwarf_Off cost)
+ {
+ assert ((::Dwarf_Off) (size_t) cost == cost);
+ if (_m_originals.insert (off).second)
+ {
+ ++incoming_count;
+ _m_original_cost += cost;
+ }
+ }
+
+ inline std::set< ::Dwarf_Off>::size_type count_originals () const
+ {
+ return _m_originals.size ();
+ }
+
+ inline ptrdiff_t original_cost () const
+ {
+ return _m_original_cost;
+ }
+
+ inline ::Dwarf_Off original_offset () const
+ {
+ return *_m_originals.begin ();
+ }
+
+ template<typename streamish>
+ inline streamish &dump_originals (streamish &out) const
+ {
+ out << std::hex;
+ for (typename std::set< ::Dwarf_Off>::const_iterator i
+ = _m_originals.begin ();
+ i !=_m_originals.end ();
+ ++i)
+ out << " " << *i;
+ return out << std::dec;
+ }
+
+ inline ptrdiff_t output_cost () const
+ {
+ // XXX temporary proxy
+ return (double (_m_original_cost) / double (count_originals ())) + 0.5;
+ }
+
+ inline std::ostream &list_originals (std::ostream &o) const
+ {
+ for (std::set< ::Dwarf_Off>::const_iterator i = _m_originals.begin ();
+ i != _m_originals.end ();
+ ++i)
+ o << " " << std::hex << *i;
+ return o;
+ }
+
+ inline unsigned int uses () const
+ {
+ return _m_uses;
+ }
+
+ inline void assert_unused () const
+ {
+ assert (uses () == 0);
+ assert (_m_with_sibling.none ());
+ assert (_m_refs.empty ());
+ }
+
+ inline void self (value::value_reference *ref)
+ {
+ _m_refs.push (ref);
+ }
+
+ inline void
+ self (const debug_info_entry::pointer &ref)
+ {
+ subr::nothing dummy;
+ self (new value::value_reference (ref, dummy));
+ }
+
+ inline void
+ self (const debug_info_entry::children_type::_base::const_iterator &ref)
+ {
+ self (debug_info_entry::pointer (ref, subr::nothing ()));
+ }
+
+ inline bool selfless () const
+ {
+ return _m_refs.empty ();
+ }
+
+ inline value::value_reference *self () const
+ {
+ assert (!selfless ());
+ return _m_refs.front ();
+ }
+
+ template<typename circular>
+ inline void
+ reify_refs (const debug_info_entry::pointer &ref)
+ {
+ for (size_t n = _m_refs.size (); n > 0; --n)
+ {
+ value::value_reference *self_ref = _m_refs.front ();
+ self_ref->ref = ref;
+ _m_refs.pop ();
+ _m_refs.push (self_ref);
+
+ circular *circle = dynamic_cast<circular *> (self_ref);
+ if (circle != NULL && !circle->final ())
+ circle->placed ();
+ }
+ }
+
+ template<typename circular>
+ inline void
+ placed (die_info_pair *parent, const debug_info_entry::pointer &ref,
+ bool have_sibling, unsigned int &total)
+ {
+ // Record first parent.
+ if (_m_parent == NULL)
+ {
+ assert (uses () == 0 || parent == NULL);
+ _m_parent = parent;
+ }
+ else
+ assert (uses () > 0);
+
+ if (selfless ())
+ {
+ assert (uses () == 0);
+ self (ref);
+ }
+ else
+ reify_refs<circular> (ref);
+
+ ++total;
+ ++_m_uses;
+ _m_with_sibling[have_sibling] = true;
+ }
+ };
+ };
+
+ // Explicit specializations.
+ template<>
+ std::string to_string<dwarf_output::debug_info_entry>
+ (const dwarf_output::debug_info_entry &);
+ inline std::string dwarf_output::debug_info_entry::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+ template<>
+ std::string
+ to_string<dwarf_output::attribute> (const dwarf_output::attribute &);
+ template<>
+ std::string
+ to_string<dwarf_output::attr_value> (const dwarf_output::attr_value &);
+
+ inline std::string dwarf_output::attr_value::to_string () const
+ {
+ return elfutils::to_string (*this); // Use that.
+ }
+
+ template<typename copier_type>
+ struct dwarf_output::value::maker
+ {
+ inline explicit maker (copier_type &) {}
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_string *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_string (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_identifier *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_identifier (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_reference *&,
+ int, const input &x, copier_type &c)
+ {
+ c.add_reference (x, &v);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_flag *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_flag (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_address *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_address (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_rangelistptr *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_ranges (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_lineptr *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_line_info (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_constant *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_constant (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_constant_block *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_constant_block (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_dwarf_constant *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_dwarf_constant (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_source_file *&,
+ int attr, const input &x, copier_type &c)
+ {
+ v = c ().add_source_file (attr, x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_source_line *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_source_line (x);
+ }
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_source_column *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_source_column (x);
+ }
+
+ // XXX macptr
+
+ template<typename input>
+ inline void make (const value_dispatch *&v, value_location *&,
+ int, const input &x, copier_type &c)
+ {
+ v = c ().add_location (x);
+ }
+ };
+
+ template<>
+ struct dwarf_output::value::maker<subr::nothing>
+ {
+ inline explicit maker (subr::nothing &) {}
+
+ template<typename... args>
+ inline void make (args&&...)
+ {
+ throw std::logic_error ("dwarf_output cannot be default-constructed");
+ }
+ };
+
+ template<>
+ inline subr::nostream &
+ dwarf_output::die_info::dump_originals (subr::nostream &out) const
+ {
+ return out;
+ }
+
+ /* This is the wrapper in the guts of a children_type iterator.
+ It turns the real pointer we store into a debug_info_entry
+ reference for the generic tree-walk API. */
+ inline const dwarf_output::debug_info_entry &
+ dwarf_output::debug_info_entry::children_type::deref::operator ()
+ (dwarf_output::die_info_pair *p) const
+ {
+ return p->first;
+ }
+
+ /* This is called when a children_type is installed freshly in the collector.
+ Fill in its back pointers. */
+ template<typename circular>
+ inline void
+ dwarf_output::debug_info_entry::children_type::
+ reify_children (die_info_pair *parent, bool placed, unsigned int &total) const
+ {
+ _base::const_iterator i = _base::begin ();
+ bool have_sibling = i != _base::end ();
+ while (have_sibling)
+ {
+ const const_iterator here (i, subr::nothing ());
+ have_sibling = ++i != _base::end ();
+ die_info &child = (*here.base ())->second;
+ if (placed)
+ child.placed<circular> (parent, here, have_sibling, total);
+ else
+ child.reify_refs<circular> (here);
+ }
+ }
+
+ class dwarf_output_collector
+ {
+ friend class dwarf_output;
+
+ private:
+ unsigned int _m_total;
+ unsigned int _m_incoming;
+
+ typedef dwarf_output::die_info die_info;
+ typedef dwarf_output::die_info_pair die_info_pair;
+ typedef dwarf_output::debug_info_entry die_type;
+ typedef die_type::attributes_type attrs_type;
+ typedef die_type::children_type children_type;
+ typedef children_type::const_iterator die_ptr;
+
+ // Simple value sets for leaf types.
+ subr::value_set<dwarf_output::value::value_string> _m_strings;
+ subr::value_set<dwarf_output::value::value_identifier> _m_identifiers;
+ subr::value_set<dwarf_output::value::value_address> _m_address;
+ subr::value_set<dwarf_output::value::value_rangelistptr> _m_ranges;
+ subr::value_set<dwarf_output::value::value_lineptr> _m_line_info;
+ subr::value_set<dwarf_output::value::value_constant> _m_constants;
+ subr::value_set<dwarf_output::value::value_constant_block> _m_const_block;
+ subr::value_set<dwarf_output::value::value_dwarf_constant> _m_dwarf_const;
+ subr::value_set<dwarf_output::value::value_source_file> _m_source_file;
+ subr::value_set<dwarf_output::value::value_source_line> _m_source_line;
+ subr::value_set<dwarf_output::value::value_source_column> _m_source_column;
+ subr::value_set<dwarf_output::value::value_location> _m_locations;
+
+ // The set of Boolean flags is a doubleton.
+ static const dwarf_output::value::value_flag flag_true;
+ static const dwarf_output::value::value_flag flag_false;
+ static inline const dwarf_output::value::value_flag *flag (bool flag)
+ {
+ return flag ? &flag_true : &flag_false;
+ }
+
+ // Set of attribute maps.
+ typedef std::pair<attrs_type, int> attrs_pair;
+ subr::dynamic_equality_set<attrs_pair> _m_attr_sets;
+
+ template<typename match_type>
+ inline const attrs_pair *
+ add_attributes (int tag, const attrs_type &candidate, match_type &matcher)
+ {
+ return _m_attr_sets.add (std::make_pair (candidate, tag), matcher);
+ }
+
+ // Set of children lists.
+ subr::identity_set<children_type> _m_broods;
+
+ inline const children_type *
+ add_children (const children_type &candidate, bool &fresh)
+ {
+ std::pair<subr::identity_set<children_type>::iterator, bool> p
+ = _m_broods.insert (candidate);
+ const children_type &result = *p.first;
+ fresh = p.second;
+ return &result;
+ }
+
+ // Set of unique DIEs.
+ typedef subr::identity_map<die_type, die_info> die_map;
+ die_map _m_unique;
+
+ inline die_info_pair *add_entry (int tag,
+ const children_type *children,
+ const attrs_type *attrs,
+ die_info *info)
+ {
+ std::pair <die_map::iterator, bool>
+ ins = _m_unique.insert (std::make_pair (die_type (tag, children, attrs),
+ *info));
+ die_info_pair &x = *ins.first;
+ if (ins.second)
+ x.second.assert_unused ();
+
+ return &x;
+ }
+
+ struct stats_cmp
+ : public std::binary_function<const die_map::value_type *,
+ const die_map::value_type *,
+ void>
+ {
+ inline bool operator () (const die_map::value_type *a,
+ const die_map::value_type *b) const
+ {
+ // Sort by number of input entries collected into this one entry.
+ if (a->second.count_originals () != b->second.count_originals ())
+ return a->second.count_originals () > b->second.count_originals ();
+
+ // Secondarily sort by aggregate input cost.
+ if (a->second.original_cost () != b->second.original_cost ())
+ return a->second.original_cost () > b->second.original_cost ();
+
+ // Finally, sort by input file order.
+ return a->second.original_offset () > b->second.original_offset ();
+ }
+ };
+
+ typedef std::multiset<const die_map::value_type *, stats_cmp
+ > die_stats_order;
+
+ struct die_stats_sorter
+ : public std::unary_function<die_map::value_type, void>
+ {
+ die_stats_order &_m_order;
+ inline explicit die_stats_sorter (die_stats_order &o) : _m_order (o) {}
+
+ inline void operator () (const die_map::value_type &elt)
+ {
+ _m_order.insert (&elt);
+ }
+ };
+
+ static void die_stats (std::ostream &out, const die_map::value_type *elt)
+ {
+ const die_info *info = &elt->second;
+ out << std::dec << info->uses ()
+ << "\thash=" << std::hex << subr::hash_this (elt->first)
+ << "\t(" << info->_m_with_sibling.to_string () << ") "
+ << std::dec << info->original_cost ()
+ << " (" << (info->original_cost () - info->output_cost ())
+ << ")\t" << to_string (elt->first) << "\t";
+ info->list_originals (out)
+ << "\n";
+ }
+
+ struct attr_collision
+ {
+ std::ostream &_m_out;
+ inline explicit attr_collision (std::ostream &out) : _m_out (out) {}
+
+ inline void
+ operator () (size_t hash,
+ const subr::dynamic_equality_set<attrs_pair>::bucket_type &b)
+ const
+ {
+ _m_out << "attrs bucket " << std::hex << hash
+ << std::dec << ": " << b.size () << " collisions\n";
+ subr::for_each (b, *this);
+ }
+
+ inline void operator () (const attrs_pair &attrs) const
+ {
+ _m_out << "\t" << dwarf::tags::name (attrs.second)
+ << " " << attrs.first.size ();
+ subr::for_each (attrs.first, *this);
+ _m_out << "\n";
+ }
+
+ inline void operator () (const attrs_type::value_type &attr) const
+ {
+ _m_out << " " << dwarf::attributes::name (attr.first);
+ }
+ };
+
+ const bool _m_ignore_context;
+
+ inline dwarf_output_collector (const dwarf_output_collector &)
+ : _m_ignore_context (false)
+ {
+ throw std::logic_error ("cannot copy-construct");
+ }
+
+ public:
+ inline dwarf_output_collector (bool ignore = true) // XXX
+ : _m_total (0), _m_incoming (0), _m_ignore_context (ignore)
+ {}
+
+ inline bool ignore_context () const
+ {
+ return _m_ignore_context;
+ }
+
+ void stats (std::ostream &out = std::cout) const
+ {
+ out << "collected " << std::dec << _m_unique.size ()
+ << " unique of " << _m_total << " total from "
+ << _m_incoming << " DIEs\n";
+
+ subr::container_hash_stats (out, "strings", _m_strings);
+ subr::container_hash_stats (out, "identifiers", _m_identifiers);
+ subr::container_hash_stats (out, "address", _m_address);
+ subr::container_hash_stats (out, "ranges", _m_ranges);
+ subr::container_hash_stats (out, "line_info", _m_line_info);
+ subr::container_hash_stats (out, "constants", _m_constants);
+ subr::container_hash_stats (out, "const_block", _m_const_block);
+ subr::container_hash_stats (out, "dwarf_const", _m_dwarf_const);
+ subr::container_hash_stats (out, "source_file", _m_source_file);
+ subr::container_hash_stats (out, "source_line", _m_source_line);
+ subr::container_hash_stats (out, "source_column", _m_source_column);
+ subr::container_hash_stats (out, "locations", _m_locations);
+
+ subr::container_hash_stats (out, "broods", _m_broods);
+ _m_attr_sets.hash_stats (out, "attr_sets", attr_collision (out));
+
+ die_stats_order ordered;
+ subr::for_each (_m_unique, die_stats_sorter (ordered));
+ subr::for_each (ordered, std::bind1st (std::ptr_fun (die_stats), out));
+ }
+ };
+
+ template<typename dw>
+ class dwarf_output::copier
+ {
+ friend class dwarf_output;
+ private:
+ typedef typename dw::debug_info_entry input_die;
+ typedef typename input_die::children_type::const_iterator input_die_ptr;
+
+ dwarf_output_collector *_m_collector;
+
+ /* A copier::entry represents one dw::debug_info_entry from the input,
+ indexed by identity. With real input files (dw=dwarf), that means
+ one input entry for each unique DIE offset in each file. (We also
+ record its offset in the input file, just for use in debugging and
+ statistics output.) An entry is in one of four states:
+
+ undefined: we have seen references in attributes, but have not yet
+ seen the entry itself in the copying walk of the input DIE tree;
+
+ pending: the entry is in the midst of being copied, or it has
+ references to non-final entries;
+
+ final: the entry is finished and stored in the collector, but
+ is not yet pointed to by any real children_type vector;
+
+ placed: the entry is final and at least one logical parent's
+ children_type vector is also finished and stored in the collector,
+ permitting final bookkeeping and reference iterator updates.
+
+ Whenever there are no undefined entries outstanding, it should by
+ definition be possible to turn every pending entry into a final
+ entry. To avoid complex bookkeeping, we simply keep track of the
+ total count of undefined entries. When we first encounter an entry
+ or a reference to it before we've copied, we increment that count.
+ Upon completing the copying of an entry, we decrement it. If that
+ makes the count reach zero, we immediately "finalize" the entry,
+ which is recursive on all its references and children not yet final.
+
+ */
+
+ struct entry; // Below.
+ struct entry_copier; // Below.
+ struct entry_finalizer; // Below.
+
+ /* An attr_value cell points to one of these when it's a reference to
+ an entry not already in the collector at finalization time, i.e. a
+ circular reference. To compare circular references during attribute
+ finalization, we follow the pending () pointer; see dwarf_pending,
+ below. Thereafter, the base type's ref element is initialized and
+ we can use that directly. */
+ class circular_reference
+ : public value::value_reference
+ {
+ private:
+ const std::vector<entry *> *_m_entry;
+ bool _m_final;
+
+ inline circular_reference (const circular_reference &)
+ : value::value_reference ()
+ {
+ throw std::logic_error ("cannot copy-construct");
+ }
+
+ public:
+ inline circular_reference (const entry *die, copier *)
+ : value::value_reference (),
+ _m_entry (new std::vector<entry *> (1, const_cast<entry *> (die))),
+ _m_final (false)
+ {
+ die->dump () << " new circular_reference " << this << "\n";
+ }
+
+ inline bool final () const
+ {
+ // XXX was return _m_entry == NULL;
+ return _m_final;
+ }
+
+ inline typename std::vector<entry *>::const_iterator pending () const
+ {
+ return _m_entry->begin ();
+ }
+
+ inline entry *pending_entry () const
+ {
+ return *pending ();
+ }
+
+ // We've been stored in the collector, so we are no longer pending.
+ inline void placed ()
+ {
+ pending_entry ()->dump () << " placed circular_reference "
+ << this << "\n";
+ // XXX Keeping around for local hash...
+ _m_final = true;
+ // delete _m_entry;
+ // _m_entry = NULL;
+ }
+
+ inline ~circular_reference ()
+ {
+ if (unlikely (_m_entry != NULL))
+ {
+ pending_entry ()->dump () << " destroy circular_reference "
+ << this << "\n";
+ delete _m_entry;
+ }
+ }
+
+ /* We have a special case for a reference attribute that is part
+ of a circular chain. It gets calculated from the
+ pending_entry. */
+ virtual die_info *get_die_info () const
+ {
+ return pending_entry ()->get_die_info ();
+ }
+ };
+
+ struct pending_entry
+ {
+ /* Pointers to each entry that appears in _m_attributes.
+ When a referent is already final, the entry * does not
+ appear in the attr_value and does not count here. */
+ std::stack<const value::value_dispatch **> _m_pending_refs;
+
+ // Set if we are attempting to finalize this entry right now.
+ entry_finalizer *_m_finalizing;
+
+ // Reference to ourself, pre-built in a circularity.
+ circular_reference *_m_self;
+
+ /* Cache of the final entry we already know we will become.
+ We'll set this when the walk of a reference comparison hits
+ this entry while finalizing another entry and records that it
+ is identical to an existing final entry. When the main walk
+ doing finalization hits us, we can short-circuit matching our
+ redundant entry in the collector sets. */
+ die_info_pair *_m_matched;
+
+ std::set<uintptr_t> _m_mismatched;
+
+ typedef dwarf_data::attributes_type<dwarf_output, value> attr_map;
+ attr_map _m_attributes;
+ std::vector<entry *> _m_children;
+ const int _m_tag;
+
+ // Set if _m_children contains any entries not already final.
+ bool _m_unfinished_children;
+
+ // The die_info that will be used when putting the die into
+ // the collector. Stores local hash as soon as all children
+ // are defined in defined_self ().
+ die_info *_m_info;
+
+ inline pending_entry (int tag)
+ : _m_finalizing (NULL), _m_self (NULL), _m_matched (NULL),
+ _m_tag (tag), _m_unfinished_children (false), _m_info (NULL)
+ {}
+
+ inline ~pending_entry ()
+ {
+ if (unlikely (_m_self != NULL))
+ {
+ if (_m_self->final ())
+ entry::debug () << "XXX ~pending_entry _m_self is final\n";
+ else
+ _m_self->pending_entry ()->dump () << " ~pending_entry _m_self\n";
+ delete _m_self;
+ }
+ }
+
+ inline typename std::vector<entry *>::const_iterator
+ child (typename std::vector<entry *>::size_type i) const
+ {
+ return _m_children.begin () + i;
+ }
+
+ /* Finalize each pending entry that we refer to.
+ This is called only when we have a non-empty _m_pending_refs. */
+ inline void finalize_refs (copier *c)
+ {
+ do
+ {
+ const value::value_dispatch **const attr = _m_pending_refs.top ();
+ const entry *ref = dynamic_cast<const entry *> (*attr);
+ if (ref != NULL)
+ *attr = const_cast<entry *> (ref)->finalize_ref (c);
+ _m_pending_refs.pop ();
+ }
+ while (!_m_pending_refs.empty ());
+ }
+
+ // Finalize each unfinished child.
+ inline void finalize_children (copier *c)
+ {
+ _m_unfinished_children = false;
+ subr::for_each
+ (_m_children,
+ std::bind2nd (std::mem_fun (&entry::get_finalized),
+ std::make_pair (c, &_m_unfinished_children)));
+ }
+
+ /* This is called from finalize_ref (below) when we are
+ resolving a circular reference attribute. We cache the
+ uninitialized reference in _m_self, and return it. */
+ inline value::value_reference *
+ make_circular_reference (const entry *self, copier *c)
+ {
+ if (_m_self == NULL)
+ _m_self = new circular_reference (self, c);
+ return _m_self;
+ }
+
+ typedef std::pair <debug_info_entry::attributes_type, int> attrs_pair;
+ struct attrs_matcher
+ {
+ copier *_m_copier;
+ inline explicit attrs_matcher (copier *c) : _m_copier (c) {}
+
+ inline bool operator () (const attrs_pair &a, const attrs_pair &b)
+ {
+ return (a.second == b.second
+ && _m_copier->attrs_match (a.first, b.first));
+ }
+ };
+
+ /* We can only get here when all our children have been finalized.
+ So all we have to do is fetch that pointer. */
+ static inline die_info_pair *get_final_child (entry *child)
+ {
+ assert (child->_m_final != NULL);
+ return child->_m_final;
+ }
+
+ typedef typename subr::wrapped_input_iterator<
+ std::vector<entry *>,
+ std::pointer_to_unary_function<entry *, die_info_pair *>
+ > final_children_getter;
+ typedef typename final_children_getter::
+ template copy<debug_info_entry::children_type> get_final_children;
+
+ inline size_t get_reference_hash (std::vector<const entry *> &stack) const
+ {
+ assert (_m_info != NULL);
+
+ // Could already have been set by forward reference.
+ if (_m_info->_m_reference_hash != 0)
+ return _m_info->_m_reference_hash;
+
+ size_t rhash = _m_info->_m_local_hash;
+ size_t attr_rhashes = 0;
+ for (attr_map::const_iterator it = _m_attributes.begin ();
+ it != _m_attributes.end ();
+ ++it)
+ {
+ // XXX XOR is for order irrelevance, but shouldn't be necessary.
+ // See also calculate_local_hash, which does the same.
+ const entry *ref
+ = dynamic_cast<const entry *> (it->second._m_value);
+ if (ref != NULL)
+ {
+ // Workaround weird cases of self-referential DIE.
+ // This really is a bug in the producer and dwarflint
+ // should warn about it. But it is easy to work around
+ // so just do it for now, by ignoring such values.
+ if (ref->_m_pending == this)
+ continue;
+ else
+ attr_rhashes ^= ref->get_reference_hash (stack);
+ }
+ }
+ subr::hash_combine (rhash, attr_rhashes);
+
+ return rhash;
+ }
+
+ inline size_t calculate_local_hash ()
+ {
+ // Calculate the local hash for this new die.
+ // XOR the attribute values together (so order doesn't matter)
+ // but exclude reference attributes values (just include
+ // their tag). XXX - shouldn't be necessary, double check.
+ size_t lhash = _m_tag;
+ size_t attr_hash = 0;
+ for (attr_map::const_iterator it = _m_attributes.begin ();
+ it != _m_attributes.end ();
+ ++it)
+ {
+ if (it->second.what_space () != dwarf::VS_reference)
+ attr_hash ^= subr::hash_this (*it);
+ else
+ attr_hash ^= (it->first << 3);
+ }
+ subr::hash_combine (lhash, attr_hash);
+
+ size_t children_hash = 0;
+ for (typename std::vector<entry *>::const_iterator it
+ = _m_children.begin ();
+ it != _m_children.end ();
+ ++it)
+ {
+ // child lhash is always in the die_info, which might
+ // be in the pending_entry when not yet finalized, or
+ // part of the finalized child die_info.
+ size_t child_lhash;
+ struct pending_entry *pending = (*it)->_m_pending;
+ if (pending)
+ child_lhash = pending->_m_info->_m_local_hash;
+ else
+ {
+ die_info_pair *final_child = get_final_child (*it);
+ child_lhash = final_child->second._m_local_hash;
+ }
+ subr::hash_combine (children_hash, child_lhash);
+ }
+ subr::hash_combine (lhash, children_hash);
+
+ return lhash;
+ }
+
+ inline die_info_pair *final (copier *c,
+ ::Dwarf_Off offset, ::Dwarf_Off cost)
+ {
+ dwarf_output_collector *const co = c->_m_collector;
+
+ assert (_m_pending_refs.empty ());
+
+ bool fresh = false;
+ if (_m_matched == NULL)
+ {
+ attrs_matcher equalator (c);
+ const debug_info_entry::attributes_type *attrs
+ = &co->add_attributes (_m_tag, _m_attributes, equalator)->first;
+
+ const debug_info_entry::children_type *children
+ = co->add_children (get_final_children ()
+ (_m_children, std::ptr_fun (get_final_child)),
+ fresh);
+
+ _m_matched = co->add_entry (_m_tag, children, attrs, _m_info);
+ }
+
+ // Final bookkeeping in the collector for this copied entry.
+ _m_matched->second.original (co->_m_incoming, offset, cost);
+
+ /* Now our entry is finalized in the collector (either newly
+ created there, or discovered to be a duplicate already
+ there). If this was part of a circularity, it created the
+ _m_self object and stored pointers to it in the collector
+ attributes maps. Now move that object into the final
+ entry's _m_refs list. From there it will get initialized. */
+ if (_m_self != NULL)
+ {
+ assert (!_m_self->final ());
+ _m_self->pending_entry ()->dump ()
+ << " register circular_reference " << _m_self << " "
+ << _m_matched->first.to_string () << " from";
+ _m_matched->second.dump_originals (entry::debug ()) << "\n";
+ _m_matched->second.self (_m_self);
+ _m_self = NULL;
+ }
+
+ /* Now we have a children_type in the collector. Fix up all
+ the backpointers to point into that _m_broods copy. Also
+ make sure each child gets its _m_parent pointer. Even if
+ this candidate children_type didn't actually get inserted
+ into the set (was not unique), we may need to reify new refs
+ to these children. */
+ _m_matched->first._m_children->reify_children<circular_reference>
+ (_m_matched, fresh, co->_m_total);
+
+ return _m_matched;
+ }
+
+ inline void notice_mismatch (const die_info_pair *not_me)
+ {
+ _m_mismatched.insert ((uintptr_t) not_me);
+ }
+
+ inline bool cached_mismatch (const die_info_pair *not_me)
+ {
+ return _m_mismatched.find ((uintptr_t) not_me) != _m_mismatched.end ();
+ }
+
+ static inline void dump_pending_ref (const value::value_dispatch **attr)
+ {
+ const entry *ref = dynamic_cast<const entry *> (*attr);
+ if (ref != NULL)
+ ref->debug () << " " << std::hex << ref->_m_offset << std::dec;
+ else
+ {
+ const circular_reference *circular
+ = dynamic_cast<const circular_reference *> (*attr);
+ if (circular != NULL && !circular->final ())
+ {
+ ref = circular->pending_entry ();
+ ref->debug () << " *" << std::hex << ref->_m_offset << std::dec;
+ }
+ }
+ }
+
+ inline void dump_tree (const entry *self) const
+ {
+ self->dump (true) << " " << dwarf::tags::name (_m_tag) << " "
+ << _m_children.size () << " children, "
+ << _m_pending_refs.size () << " refs";
+ //subr::for_each (_m_pending_refs, dump_pending_ref); XXX
+ self->debug () << "\n";
+ subr::for_each (_m_children, std::mem_fun (&entry::dump_entry));
+ self->dump (false, true) << " ends\n";
+ }
+ };
+
+ // This keeps state in the pending_entry's _m_finalizing pointer while live.
+ struct entry_finalizer
+ {
+ entry *const _m_entry;
+
+ inline entry_finalizer (entry *die)
+ : _m_entry (die)
+ {
+ _m_entry->debug () << std::flush;
+ assert (_m_entry->_m_pending->_m_finalizing == NULL);
+ _m_entry->_m_pending->_m_finalizing = this;
+ _m_entry->dump (true) << " finalizing\n";
+ }
+
+ inline ~entry_finalizer ()
+ {
+ if (unlikely (_m_entry->_m_pending != NULL))
+ {
+ assert (_m_entry->_m_pending->_m_finalizing == this);
+ _m_entry->_m_pending->_m_finalizing = NULL;
+ _m_entry->dump (false, true) << " failed to finalize!\n";
+ }
+ else
+ {
+ _m_entry->dump (false, true) << " finalized\n";
+ assert (_m_entry->_m_final != NULL);
+ _m_entry->dump_entry ();
+ }
+ }
+ };
+
+ /* This is what we record about each input DIE we have considered.
+ An attr_value that is a dangling reference to a DIE not yet
+ built in the output has one of these in place of a value_reference.
+ These all live in the _m_entries map, one per input-side DIE. */
+ struct entry
+ : public value::value_reference
+ {
+ ::Dwarf_Off _m_offset; // For debugging and statistics only.
+ ::Dwarf_Off _m_cost; // For statistics only.
+
+ // Completed DIE in the collector, or NULL.
+ die_info_pair *_m_final;
+
+ // Pending entry made with new, or NULL.
+ pending_entry *_m_pending;
+
+ // Set if we are building this in the copying walk right now.
+ entry_copier *_m_building;
+
+ // Set if we are in attrs_match on this entry right now.
+ die_info_pair *_m_comparing;
+
+ /* When we're final but not placed, we allocate a singleton vector
+ here and set a value_reference to an iterator in that vector.
+ That will be replaced with the iterator into a proper children
+ vector when we're placed. */
+ debug_info_entry::children_type::_base *_m_final_ref;
+
+ // First parent, for tracker purposes.
+ entry *_m_parent;
+ typename std::vector<entry *>::size_type _m_self_idx;
+
+ inline entry ()
+ : _m_offset (0), _m_final (NULL), _m_pending (NULL),
+ _m_building (NULL), _m_comparing (NULL),
+ _m_final_ref (NULL), _m_parent (NULL), _m_self_idx (0)
+ {}
+
+ inline void setup (copier *c, const input_die &in)
+ {
+ if (_m_offset == 0)
+ {
+ _m_offset = in.offset ();
+ ++c->_m_undefined_entries;
+ dump () << " seen => " << c->_m_undefined_entries << "\n";
+ }
+ }
+
+ inline ~entry ()
+ {
+ assert (_m_building == NULL);
+ if (_m_final_ref != NULL)
+ delete _m_final_ref;
+
+ // This should only hit in an exception case abandoning the copier.
+ if (unlikely (_m_pending != NULL))
+ delete _m_pending;
+ }
+
+ /* If we need a reference before we're placed, fake one up with
+ a singleton vector pointing to us, stored in _m_final_ref. */
+ inline value::value_reference *self ()
+ {
+ if (_m_final->second.selfless ())
+ {
+ assert (_m_final_ref == NULL);
+ _m_final_ref
+ = new debug_info_entry::children_type::_base (1, _m_final);
+ _m_final->second.self (_m_final_ref->begin ());
+ }
+ return _m_final->second.self ();
+ };
+
+ /* Called by entry_copier::add_reference, below.
+ We're adding a reference attribute pointing to this input entry. */
+ inline void refer (entry *referrer, const value::value_dispatch **backptr)
+ {
+ referrer->dump () << " refers to "
+ << std::hex << _m_offset << std::dec
+ << " (" << (_m_final ? "final"
+ : _m_pending ? "pending" : "undefined")
+ << (_m_building ? ", building" : "") << ")\n";
+
+ if (_m_final != NULL)
+ // It's finished, resolve the final reference.
+ *backptr = self ();
+ else
+ {
+ *backptr = this;
+ referrer->_m_pending->_m_pending_refs.push (backptr);
+ }
+ }
+
+ /* We are no longer an undefined entry, so decrement the count.
+ But don't finalize yet. Since all children are known now we
+ can create a candidate die_info that includes the local hash
+ for this entry. */
+ inline void defined_self (copier *c)
+ {
+ assert (_m_final == NULL);
+ assert (_m_pending != NULL);
+ assert (c->_m_undefined_entries > 0);
+ --c->_m_undefined_entries;
+ dump () << " defined_self => " << c->_m_undefined_entries << "\n";
+
+ size_t lhash = _m_pending->calculate_local_hash ();
+ _m_pending->_m_info = new die_info (lhash);
+ }
+
+ /* A reference-following matching operation noticed along
+ the way that we have a doppleganger in the collector. */
+ inline void record_prematch (die_info_pair *doppleganger,
+ bool lhs)
+ {
+ doppleganger->second.dump_originals
+ (dump ()
+ << " record_prematch to " << doppleganger->first.to_string ()
+ << " from")
+ << (lhs ? " on lhs\n" : " on rhs\n");
+ /* XXX disabled! tentative circularity matches taint this record!
+ must record taint to avoid caching, or punt caching.
+ */
+ //_m_pending->_m_matched = doppleganger;
+ }
+
+ /* This is called by finalize_children. In case of imported_unit
+ use in the input, we could already have finalized this earlier
+ in the copying walk of the logical CU, so there is nothing to
+ do. Or, inside a circularity in finalize_refs, we might be
+ finalizing this child already in an outer recursion. In that
+ case, we can't finish it here. */
+ inline void get_finalized (const std::pair<copier *, bool *> p)
+ {
+ if (_m_final == NULL && _m_pending->_m_finalizing == NULL)
+ finalize (p.first);
+ if (_m_final == NULL)
+ *p.second = true;
+ }
+
+ /* Recursively sets up reference hashes for the die_info of this
+ pending_entry. Depends on all local hashes having been setup
+ already. At this point all entries are still pending. */
+ inline void setup_reference_hash () const
+ {
+ std::vector<const entry *> stack;
+ _m_pending->_m_info->_m_reference_hash = get_reference_hash (stack);
+ assert (stack.empty ());
+
+ for (typename std::vector<entry *>::const_iterator it
+ = _m_pending->_m_children.begin ();
+ it != _m_pending->_m_children.end ();
+ ++it)
+ (*it)->setup_reference_hash ();
+ }
+
+ inline size_t get_reference_hash (std::vector<const entry *> &stack) const
+ {
+ if (std::find (stack.begin (), stack.end (), this) != stack.end ())
+ {
+ std::cout << "Reference chain cycle detected\n"
+ << "offset=[0x" << std::hex << _m_offset << std::dec
+ << "] already on the reference chain stack\n";
+ typename std::vector<const entry *>::iterator it;
+ for (it = stack.begin ();
+ it != stack.end ();
+ it++)
+ {
+ std::cout << "offset=[0x" << std::hex << (*it)->_m_offset
+ << std::dec << "] "
+ << dwarf::tags::name ((*it)->_m_pending->_m_tag)
+ << "\n";
+ }
+ abort ();
+ }
+
+ stack.push_back (this);
+ size_t res = _m_pending->get_reference_hash (stack);
+ stack.pop_back ();
+ return res;
+ }
+
+ // Attempt to turn the pending entry into a final entry.
+ void finalize (copier *c)
+ {
+ entry_finalizer finalizing (this);
+
+ if (c->_m_undefined_entries == 0)
+ {
+ // Nothing is undefined, so we can resolve pending references.
+ if (!_m_pending->_m_pending_refs.empty ())
+ {
+ dump (true) << " finalize_refs\n";
+ _m_pending->finalize_refs (c);
+ dump (false, true) << " finalize_refs done\n";
+ }
+
+ // Now we can finish off all our children.
+ if (_m_pending->_m_unfinished_children)
+ {
+ dump (true) << " finalize_children\n";
+ _m_pending->finalize_children (c);
+ dump (false, true) << " finalize_children done\n";
+ }
+ }
+
+ /* If there were no pending references or children to finish, or
+ if we just finished them all off, we can finally finalize! */
+ if (_m_pending->_m_pending_refs.empty ()
+ && !_m_pending->_m_unfinished_children)
+ {
+ // Create it in the collector.
+ _m_final = _m_pending->final (c, _m_offset, _m_cost);
+
+ // No more pending_entry required!
+ delete _m_pending;
+ _m_pending = NULL;
+ }
+ }
+
+ // Called by a referrer trying to finalize us.
+ inline const value_dispatch *finalize_ref (copier *c)
+ {
+ assert (c->_m_undefined_entries == 0);
+ if (_m_final == NULL)
+ {
+ if (_m_pending->_m_finalizing == NULL)
+ finalize (c);
+ if (_m_final == NULL)
+ {
+ dump () << " finalize_ref caught circularity\n" << std::flush;
+
+ /* We are recursing inside a finalize call.
+ This means we have a circular reference. */
+ return _m_pending->make_circular_reference (this, c);
+ }
+ }
+ return self ();
+ }
+
+// Toggle this to enable massive debugging spew during construction.
+// #define _DWARF_OUTPUT_DEBUG_SPEW 1
+#ifdef _DWARF_OUTPUT_DEBUG_SPEW
+ static inline std::ostream &debug ()
+ {
+ return std::cout;
+ }
+
+ static inline std::ostream &
+ debug_prefix (bool in = false, bool out = false, bool print = true)
+ {
+ static std::string prefix;
+ if (out)
+ prefix.erase (--prefix.end ());
+ if (print)
+ debug () << prefix;
+ if (in)
+ prefix.push_back (' ');
+ return debug ();
+ }
+
+ std::ostream &dump (bool in = false, bool out = false) const
+ {
+ debug_prefix (in, out) << "XXX " << std::hex << _m_offset << std::dec;
+ if (_m_pending != NULL && _m_pending->_m_finalizing != NULL)
+ debug () << " (finalizing "
+ << (void *) _m_pending->_m_finalizing << ")";
+ return debug ();
+ }
+
+ void dump_entry () const
+ {
+ if (_m_final != NULL)
+ {
+ dump () << " final " << _m_final->first.to_string ()
+ << " hash=" << std::hex << subr::hash_this (_m_final->first)
+ << " from";
+ _m_final->second.dump_originals (debug ()) << "\n";
+ }
+ else if (_m_pending != NULL)
+ _m_pending->dump_tree (this);
+ else
+ dump () << " undefined\n";
+ }
+#else
+ static inline subr::nostream &debug ()
+ {
+ static subr::nostream n;
+ return n;
+ }
+
+ static inline subr::nostream &
+ debug_prefix (bool = false, bool = false, bool = true)
+ {
+ return debug ();
+ }
+
+ inline subr::nostream &dump (bool = false, bool = false) const
+ {
+ return debug ();
+ }
+
+ inline void dump_entry () const
+ {}
+#endif
+
+ // Find ourselves in a parent pending_entry's children vector.
+ inline typename std::vector<entry *>::const_iterator pending_self () const
+ {
+ debug () << std::flush;
+ assert (_m_pending != NULL);
+ return _m_parent->_m_pending->child (_m_self_idx);
+ }
+
+ /* The local hash of the debug_info_entry if we are already
+ final, otherwise get it from the pending_entry. */
+ inline die_info *get_die_info () const
+ {
+ if (_m_final)
+ return &_m_final->second;
+ return _m_pending->_m_info;
+ }
+ };
+
+ // This object lives while we are copying one particular input DIE.
+ struct entry_copier
+ {
+ copier *_m_copier;
+ entry *_m_in;
+ pending_entry *_m_out;
+
+ /* On creation we set _m_building in DIE's record.
+ It should never be set already. */
+ inline entry_copier (copier *c, entry *die, const input_die &in)
+ : _m_copier (c),
+ _m_in (die),
+ _m_out (new pending_entry (in.tag ()))
+ {
+ if (unlikely (_m_in->_m_building != NULL))
+ throw std::runtime_error ("detected cycle in logical DWARF tree");
+ _m_in->_m_building = this;
+ _m_in->_m_cost = in.cost ();
+ _m_in->dump (true) << " copying (cost=" << _m_in->_m_cost << ")\n";
+ }
+
+ // On destruction, we clear _m_building.
+ inline ~entry_copier ()
+ {
+ _m_in->dump (false, true) << " copied\n";
+ assert (_m_in->_m_building == this);
+ _m_in->_m_building = NULL;
+ if (unlikely (_m_out != NULL)) // Exception unwind case only.
+ delete _m_out;
+ }
+
+ /* Populate _m_out from the corresponding input DIE. This invokes
+ all the main work of copying. The interesting parts happen in
+ add_reference and add_child, below. */
+ inline void populate (const input_die &in)
+ {
+ assert (_m_in->_m_pending == NULL);
+ _m_in->_m_pending = _m_out;
+
+ try
+ {
+ // This calls add_reference for each pending reference.
+ _m_out->_m_attributes.set (in.attributes (), *this);
+
+ for (input_die_ptr i = in.children ().begin ();
+ i != in.children ().end ();
+ ++i)
+ add_child (*i);
+ }
+ catch (...)
+ {
+ _m_in->_m_pending = NULL;
+ throw;
+ }
+
+ _m_out = NULL;
+ _m_in->defined_self (_m_copier);
+ }
+
+ // We're adding a reference attribute inside populate, above.
+ inline void add_reference (const input_die_ptr &to,
+ const value::value_dispatch **backptr)
+ {
+ _m_copier->enter (*to)->refer (_m_in, backptr);
+ }
+
+ // We're adding a child entry inside populate, above.
+ inline void add_child (const input_die &in)
+ {
+ entry *child = _m_copier->enter (in);
+ _m_out->_m_children.push_back (child);
+
+ /* If the input used DW_TAG_imported_unit, then the logical walk
+ can hit the same DIE twice. If so, we short-circuit right here. */
+ if (child->_m_final == NULL && child->_m_pending == NULL)
+ {
+ child->_m_parent = _m_in;
+ child->_m_self_idx = _m_out->_m_children.size () - 1;
+ entry_copier (_m_copier, child, in).populate (in);
+ }
+
+ if (child->_m_final == NULL)
+ // Record that it didn't finalize immediately, we'll do it later.
+ _m_out->_m_unfinished_children = true;
+ }
+
+ // Use "c ()" as a shorthand to get the copier out of the entry_copier.
+ inline copier &operator () () const
+ {
+ return *_m_copier;
+ }
+
+ /* Walk over the whole cu again to set reference hashes up.
+ Then try to finalize everything at once.
+ Complain if we still have dangling references.
+ If not, it should be impossible to have pending entries left. */
+ inline die_info_pair *final_unit () const
+ {
+ assert (_m_out == NULL);
+
+ // First walk over the whole CU tree again to setup the
+ // reference hash for each die_info.
+ _m_in->setup_reference_hash ();
+
+ // We should now be able to finalize everything at once.
+ if (_m_copier->_m_undefined_entries == 0)
+ _m_in->finalize (_m_copier);
+
+ if (unlikely (_m_in->_m_final == NULL))
+ {
+ _m_in->dump_entry ();
+ _m_in->debug () << std::flush;
+ assert (_m_copier->_m_undefined_entries > 0);
+ throw std::runtime_error
+ ("compile_unit contains dangling reference attributes");
+ }
+ assert (_m_copier->_m_undefined_entries == 0);
+ return _m_in->_m_final;
+ }
+ };
+
+ struct unit_copier : public entry_copier
+ {
+ inline unit_copier (copier *c, const typename dw::compile_unit &in)
+ : entry_copier (c, c->enter (in), in)
+ {
+ populate (in);
+ }
+ };
+
+ struct dump_unplaced
+ : public std::unary_function<circular_reference *, void>
+ {
+ inline void operator () (circular_reference *ref)
+ {
+ std::cout << "XXX unplaced ref to "
+ << std::hex << (ref->pending_entry ())->_m_offset
+ << std::dec << "\n";
+ }
+ };
+
+ // Create a whole CU in the output.
+ inline void
+ make_unit (const typename dw::compile_units_type::const_iterator &in,
+ const compile_units_type::iterator &out)
+ {
+ die_info_pair *cu = unit_copier (this, *in).final_unit ();
+
+ // This really just increments _m_total for us, but also _m_uses.
+ cu->second.placed<circular_reference> (NULL,
+ cu->first.children ().end (),
+ false, _m_collector->_m_total);
+
+ *out = cu->first;
+ }
+
+ typedef std::tr1::unordered_map< ::Dwarf_Off, entry> entry_map;
+ entry_map _m_entries;
+ unsigned int _m_undefined_entries; // Count of _m_entries not copied yet.
+
+ inline entry *enter (const input_die &in)
+ {
+ entry *die = &_m_entries[in.identity ()];
+ die->setup (this, in);
+ return die;
+ }
+
+ /* This is an entire shadow of the dwarf:: interface, sufficient to
+ instantiate dwarf_comparator below. All its objects are
+ ephemeral and simply wrap a pending_entry and its constituents.
+ We always start with finalized attributes, but those can include
+ circular_reference objects pointing to pending entries that can't
+ be finalized until the finalization that this comparison is part
+ of has been done. Hence these objects have to bifurcate between
+ wrapping pending_entry and wrapping die_info_pair. */
+ class pending_dwarf
+ {
+ public:
+ class debug_info_entry;
+ class attr_value;
+ typedef std::pair<const int, attr_value> attribute;
+
+ typedef debug_info_entry compile_unit;
+
+ private:
+
+ // Both debug_info_entry and iterators just hold this pair of pointers.
+ struct entry_pointers
+ {
+ entry *pending;
+ die_info_pair *final;
+
+ inline entry_pointers (entry *a, die_info_pair *b)
+ : pending (a), final (b)
+ {}
+ };
+
+ struct pending_cu
+ : public std::unary_function<dwarf_output::compile_unit, compile_unit>
+ {
+ inline const compile_unit
+ operator () (const dwarf_output::compile_unit &) const
+ {
+ throw std::logic_error ("XXX implement me");
+ }
+ };
+
+ public:
+ // Not really used so far, just for completeness.
+ typedef subr::wrapped_input_container<class dwarf_output::compile_units_type,
+ pending_cu> compile_units_type;
+
+ class debug_info_entry
+ {
+ private:
+ entry_pointers _m_ptr;
+
+ static inline const debug_info_entry
+ child (const entry_pointers &ptr, size_t i)
+ {
+ if (ptr.final == NULL)
+ return debug_info_entry (ptr.pending->_m_pending->_m_children[i]);
+ return debug_info_entry (ptr.final->first.children ().info ()[i]);
+ }
+
+ // Turns an attribute into an attribute!
+ struct pending_attr
+ : public std::unary_function<dwarf_output::attribute, attribute>
+ {
+ inline pending_attr (const subr::nothing &) {}
+
+ inline const attribute
+ operator () (const dwarf_output::attribute &attr) const
+ {
+ return attribute (attr.first, attr.second);
+ }
+ };
+
+ public:
+ inline debug_info_entry ()
+ : _m_ptr (NULL, NULL)
+ {}
+
+ inline debug_info_entry (const debug_info_entry &entry)
+ : _m_ptr (entry._m_ptr)
+ {}
+
+ inline explicit debug_info_entry (die_info_pair *die)
+ : _m_ptr (NULL, die)
+ {}
+
+ inline explicit debug_info_entry (entry *die)
+ : _m_ptr (die, die->_m_final)
+ {}
+
+ inline bool final () const
+ {
+ return _m_ptr.final != NULL;
+ }
+
+ inline die_info_pair *get_final () const
+ {
+ assert (_m_ptr.final != NULL);
+ return _m_ptr.final;
+ }
+
+ inline entry *get_pending () const
+ {
+ assert (_m_ptr.pending != NULL);
+ return _m_ptr.pending;
+ }
+
+ inline bool is (const debug_info_entry &other) const
+ {
+ return (_m_ptr.final == other._m_ptr.final
+ && (final () || _m_ptr.pending == other._m_ptr.pending));
+ }
+
+ // Used by the tracker.
+ inline std::pair<die_info_pair *, entry *> context () const
+ {
+ return std::make_pair (_m_ptr.final, _m_ptr.pending);
+ }
+
+ inline int tag () const
+ {
+ return (_m_ptr.final != NULL
+ ? _m_ptr.final->first.tag ()
+ : _m_ptr.pending->_m_pending->_m_tag);
+ }
+
+ typedef subr::wrapped_input_container<typename pending_entry::attr_map,
+ pending_attr> attributes_type;
+
+ inline const attributes_type attributes () const
+ {
+ return attributes_type (_m_ptr.final == NULL
+ ? _m_ptr.pending->_m_pending->_m_attributes
+ : _m_ptr.final->first._m_attributes->base (),
+ subr::nothing ());
+ }
+
+ class children_type
+ {
+ friend class debug_info_entry;
+ private:
+ entry_pointers _m_ptr;
+
+ inline explicit children_type (const entry_pointers &ptr)
+ : _m_ptr (ptr)
+ {}
+
+ public:
+ class const_iterator
+ : public std::iterator<std::input_iterator_tag, debug_info_entry>
+ {
+ friend class children_type;
+ friend class attr_value;
+
+ private:
+ dwarf_output::debug_info_entry::children_type::
+ _base::const_iterator _m_final_iter;
+ typename std::vector<entry *>::const_iterator _m_pending_iter;
+ bool _m_final;
+
+ inline const_iterator
+ (const dwarf_output::debug_info_entry::const_pointer &i)
+ : _m_final_iter (i.base ()), _m_final (true)
+ {}
+
+ inline const_iterator
+ (const typename std::vector<entry *>::const_iterator &i)
+ : _m_pending_iter (i), _m_final (false)
+ {}
+
+ /* We have what appears to be a final reference attribute.
+ If it's actually a circular_reference, it might really
+ not be final after all. */
+ inline void init_from_ref (const value::value_reference *ref)
+ {
+ const circular_reference *circle
+ = dynamic_cast<const circular_reference *> (ref);
+ _m_final = circle == NULL || circle->final ();
+ if (_m_final)
+ _m_final_iter = ref->ref;
+ else
+ _m_pending_iter = circle->pending ();
+ }
+
+ // This is called only by attr_value::reference, below.
+ inline const_iterator (const value::value_reference *ref)
+ {
+ init_from_ref (ref);
+ assert ((**this).identity () == (**this).identity ());
+ }
+
+ /* This is called only by attr_value::reference, below.
+ We have what appears to be a reference to a pending entry.
+ In fact, this entry might already have been finalized even
+ though this reference to it has not been. */
+ inline const_iterator (entry *ref)
+ : _m_final (ref->_m_final != NULL)
+ {
+ if (_m_final)
+ init_from_ref (ref->self ());
+ else
+ _m_pending_iter = ref->pending_self ();
+ assert ((**this).identity () == (**this).identity ());
+ }
+
+ public:
+ inline const_iterator ()
+ {}
+
+ inline const_iterator (const const_iterator &other)
+ {
+ *this = other;
+ }
+
+ inline const debug_info_entry operator* () const
+ {
+ return (_m_final
+ ? debug_info_entry (*_m_final_iter)
+ : debug_info_entry (*_m_pending_iter));
+ }
+
+ inline bool operator== (const const_iterator &other) const
+ {
+ return (_m_final == other._m_final
+ && (_m_final
+ ? _m_final_iter == other._m_final_iter
+ : _m_pending_iter == other._m_pending_iter));
+ }
+ inline bool operator!= (const const_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline const_iterator &operator= (const const_iterator &other)
+ {
+ _m_final = other._m_final;
+ if (_m_final)
+ _m_final_iter = other._m_final_iter;
+ else
+ _m_pending_iter = other._m_pending_iter;
+ return *this;
+ }
+
+ inline const_iterator &operator++ () // prefix
+ {
+ if (_m_final)
+ ++_m_final_iter;
+ else
+ ++_m_pending_iter;
+ return *this;
+ }
+ inline const_iterator operator++ (int) // postfix
+ {
+ const const_iterator old = *this;
+ ++*this;
+ return old;
+ }
+ };
+
+ inline bool empty () const
+ {
+ return size () == 0;
+ }
+
+ inline size_t size () const
+ {
+ return (_m_ptr.final != NULL
+ ? _m_ptr.final->first.children ().size ()
+ : _m_ptr.pending->_m_pending->_m_children.size ());
+ }
+
+ inline const_iterator begin () const
+ {
+ return (_m_ptr.final != NULL
+ ? const_iterator (_m_ptr.final->first.children ()
+ .begin ())
+ : const_iterator (_m_ptr.pending->_m_pending->_m_children
+ .begin ()));
+ }
+
+ inline const_iterator end () const
+ {
+ return (_m_ptr.final != NULL
+ ? const_iterator (_m_ptr.final->first.children ()
+ .end ())
+ : const_iterator (_m_ptr.pending->_m_pending->_m_children
+ .end ()));
+ }
+ };
+
+ typedef typename children_type::const_iterator const_pointer;
+ typedef const_pointer pointer;
+
+ inline const children_type children () const
+ {
+ return children_type (_m_ptr);
+ }
+
+ inline bool has_children () const
+ {
+ return !children ().empty ();
+ }
+
+ inline uintptr_t identity () const
+ {
+ return (uintptr_t) _m_ptr.final ?: (uintptr_t) _m_ptr.pending;
+ }
+
+ inline ::Dwarf_Off original_offset () const
+ {
+ if (_m_ptr.final == NULL)
+ return _m_ptr.pending->_m_offset;
+ return _m_ptr.final->second.original_offset ();
+ }
+ };
+
+ // This wrapper class exists only to enhance reference variant.
+ struct attr_value
+ : public dwarf_output::attr_value
+ {
+ inline attr_value (const dwarf_output::attr_value &other)
+ : dwarf_output::attr_value (other)
+ {}
+
+ // An entry * in a pending_entry's attr_map counts as a reference.
+ inline dwarf::value_space what_space () const
+ {
+ return (dynamic_cast<const entry *> (this->_m_value) != NULL
+ ? dwarf::VS_reference
+ : dwarf_output::attr_value::what_space ());
+ }
+
+ inline typename debug_info_entry::const_pointer reference () const
+ {
+ const entry *ref = dynamic_cast<const entry *> (_m_value);
+ if (ref == NULL)
+ // Either really a final reference, or a circular reference.
+ return typename debug_info_entry::const_pointer
+ (dynamic_cast<const value::value_reference *> (_m_value));
+
+ /* This is an attribute comparison inside the attrs_match
+ comparator. The attribute sets passed to attrs_match
+ directly don't hit this--they've already been finalized.
+ But following those references we got to another
+ pending_entry and its attributes that are not yet
+ finalized. If attrs_match winds up returning true, these
+ will never be finalized because they are duplicates. */
+ return typename debug_info_entry::const_pointer
+ (const_cast<entry *> (ref));
+ }
+ };
+
+ // Convenience wrapper.
+ static inline const typename debug_info_entry::attributes_type
+ attributes (const dwarf_output::debug_info_entry::attributes_type &attrs)
+ {
+ return typename debug_info_entry::attributes_type (attrs.base (),
+ subr::nothing ());
+ }
+ };
+
+ /* This is a specialized tracker used solely in attrs_match, below.
+ We are comparing final entries already in the collector against
+ the almost-final pending_entry ready to be stored. Both sides
+ are pending_dwarf rather than dwarf_output begin the left-hand
+ side, because a reference attribute of a "final" entry can be a
+ circular_reference that still points back to a pending entry. */
+ class tracker
+ : public dwarf_tracker_base<pending_dwarf, pending_dwarf>
+ {
+ private:
+ typedef dwarf_tracker_base<pending_dwarf, pending_dwarf> _base;
+
+ const bool _m_ignore_context;
+
+ inline bool ignore_context () const
+ {
+ return _m_ignore_context;
+ }
+
+ public:
+ typedef typename _base::cu1 cu1;
+ typedef typename _base::cu2 cu2;
+ typedef typename _base::die1 die1;
+ typedef typename _base::die2 die2;
+
+ inline explicit tracker (copier *c)
+ : _m_ignore_context (c->_m_collector->ignore_context ())
+ {}
+
+ typedef die_info_pair *left_context_type;
+ typedef std::pair<die_info_pair *, entry *> right_context_type;
+
+ // Return the lhs context of an arbitrary DIE.
+ inline left_context_type left_context (const die1 &ref)
+ {
+ return (*ref).get_final ();
+ }
+
+ // Return the rhs context of an arbitrary DIE.
+ inline const right_context_type right_context (const die2 &ref)
+ {
+ return (*ref).context ();
+ }
+
+ /* Comparing two final DIEs for context. They match only if their
+ immediate parents are the same final entry in the collector, or
+ if they are both top-level children of a CU. */
+ inline bool final_context_match (die_info_pair *a, die_info_pair *b)
+ {
+ a = a->second._m_parent;
+ b = b->second._m_parent;
+ if (a == b)
+ return true;
+ if (a == NULL || b == NULL)
+ return false;
+ return a->second._m_parent == NULL && b->second._m_parent == NULL;
+ }
+
+ inline bool context_quick_mismatch (const left_context_type &lhs,
+ const right_context_type &rhs)
+
+ {
+ if (ignore_context ())
+ return false;
+
+ if (rhs.first != NULL)
+ // Comparing final to final.
+ return !final_context_match (lhs, rhs.first);
+
+ // Comparing final to pending. XXX track depth??
+ return ((rhs.second->_m_parent == NULL)
+ != (lhs->second._m_parent == NULL));
+ }
+
+ inline bool context_match (const left_context_type &lhs,
+ const right_context_type &rhs)
+ {
+ if (ignore_context ())
+ return true;
+
+ if (rhs.first != NULL)
+ // Comparing final to final.
+ return final_context_match (lhs, rhs.first);
+
+ // Comparing final to pending.
+ die_info_pair *a = lhs->second._m_parent;
+ entry *b = rhs.second->_m_parent;
+ while (a != NULL)
+ {
+ if (b == NULL)
+ return false;
+
+ if (a->second._m_parent == NULL)
+ /* A is the top-level CU entry.
+ We don't compare the CU attributes.
+ It's a match if B is also up to its top level. */
+ return b->_m_parent == NULL;
+
+ if (!(dwarf_comparator<dwarf_output, pending_dwarf>::equal_enough
+ (a->first, typename pending_dwarf::debug_info_entry (b))))
+ return false;
+
+ a = a->second._m_parent;
+ b = b->_m_parent;
+ }
+
+ // We can only get here if these were actually CU references.
+ return b == NULL;
+ }
+
+#ifdef _DWARF_OUTPUT_DEBUG_SPEW
+ static inline std::ostream &
+ dump (const typename pending_dwarf::debug_info_entry &a,
+ const typename pending_dwarf::debug_info_entry &b,
+ bool in = false, bool out = false)
+ {
+ return entry::debug_prefix (in, out)
+ << "XXX " << (a.final () ? "final " : "pending ")
+ << std::hex << a.original_offset ()
+ << " vs " << (b.final () ? "final " : "pending ")
+ << b.original_offset () << std::dec;
+ }
+
+ static inline std::ostream &
+ dump (const die1 &ref1, const die2 &ref2,
+ bool in = false, bool out = false)
+ {
+ return dump (*ref1, *ref2, in, out);
+ }
+
+ struct step : public _base::step
+ {
+ inline step (tracker *t, const die1 &a, const die2 &b)
+ : _base::step (t, a, b)
+ {
+ dump (*a, *b, true) << " cmp\n";
+ }
+ inline ~step ()
+ {
+ entry::debug_prefix (false, true, false);
+ }
+ };
+#else
+ static inline subr::nostream &
+ dump (const typename pending_dwarf::debug_info_entry &,
+ const typename pending_dwarf::debug_info_entry &,
+ bool = false, bool = false)
+ {
+ return entry::debug ();
+ }
+
+ static inline subr::nostream &
+ dump (const die1 &, const die2 &,
+ bool = false, bool = false)
+ {
+ return entry::debug ();
+ }
+#endif
+
+ class reference_match
+ {
+ entry *_m_pending;
+
+ public:
+ inline reference_match ()
+ : _m_pending (NULL)
+ {
+ entry::debug_prefix (true, false, false);
+ }
+
+ inline bool prematch (tracker *, const die1 &ref1, const die2 &ref2)
+ {
+ const typename pending_dwarf::debug_info_entry a = *ref1;
+ const typename pending_dwarf::debug_info_entry b = *ref2;
+
+ dump (a, b) << " reference_match\n";
+
+ if (!a.final ())
+ // XXX pending circular lhs can never match ???
+ return !b.final () && a.get_pending () == b.get_pending ();
+
+ die_info_pair *const lhs = a.get_final ();
+
+ if (b.final ())
+ return lhs == b.get_final ();
+
+ entry *const rhs = b.get_pending ();
+
+ if (rhs->_m_pending->_m_matched != NULL)
+ return lhs == rhs->_m_pending->_m_matched;
+
+ if (rhs->_m_comparing != NULL)
+ {
+ /* We have a circularity on the right-hand side. We can tell
+ because _m_comparing remains set from an outer recursion
+ still in progress.
+
+ The circular chain of references rooted at A matches B if B
+ is also the root of its own circularity and everything along
+ those parallel chains matches. If the chains hadn't matched
+ so far, we would not have kept following them to get here.
+
+ So, this matches if what we were comparing to was the same A.
+ If it didn't match, we have left _m_pending clear, which makes
+ negative_cache trigger (below). */
+
+ if (rhs->_m_comparing != lhs)
+ return false;
+
+ dump (a, b) << " tentative circular match\n";
+ return true;
+ }
+
+ if (rhs->_m_pending->cached_mismatch (lhs))
+ return false;
+
+ /* Record that we have a walk in progress crossing B. When this
+ reference_match object goes out of scope in our caller, its
+ destructor will reset _m_comparing to clear this record. */
+ rhs->_m_comparing = lhs;
+ _m_pending = rhs;
+ return false;
+ }
+
+ inline bool negative_cache () const
+ {
+ return _m_pending == NULL;
+ }
+
+ inline ~reference_match ()
+ {
+ if (_m_pending != NULL)
+ {
+ assert (_m_pending->_m_comparing != NULL);
+ _m_pending->_m_comparing = NULL;
+ }
+ entry::debug_prefix (false, true, false);
+ }
+ };
+
+ // This call is used purely in hopes of a cache hit.
+ inline bool prematch (reference_match &matched,
+ const die1 &a, const die2 &b)
+ {
+ bool same = matched.prematch (this, a, b);
+ dump (a, b) << " prematch => " << same << "\n";
+ return same;
+ }
+
+ // This call is used only as part of a real reference lookup.
+ inline bool reference_matched (reference_match &matched,
+ const die1 &a, const die2 &b)
+ {
+ bool same = matched.prematch (this, a, b);
+ dump (a, b) << " reference_matched => " << same << "\n";
+ return same;
+ }
+
+ // Check for a negative cache hit after prematch or reference_match.
+ inline bool cannot_match (reference_match &matched,
+ const die1 &, const die2 &)
+ {
+ return matched.negative_cache ();
+ }
+
+ // This can cache a result.
+ inline bool notice_match (reference_match &matched,
+ const die1 &ref1, const die2 &ref2,
+ bool result)
+ {
+ if (result && matched.negative_cache ())
+ {
+ /* This positive result is from a tentative match of congruent
+ circular references. That doesn't mean they really match,
+ only that they might if the rest of their trees do. Don't
+ cache it as a match now. */
+ dump (ref1, ref2) << " should ignore tentative match\n";
+ return result;
+ }
+
+ const typename pending_dwarf::debug_info_entry a = *ref1;
+ const typename pending_dwarf::debug_info_entry b = *ref2;
+ dump (a, b) << " notice_match (" << result << ")\n";
+ if (result)
+ {
+ /* We've found two matching entries. If we just matched a
+ final entry to a pending entry, cache that knowledge so
+ we don't bother with the whole hash lookup and comparison
+ when we come to finalizing that pending entry itself. */
+
+ if (a.final ())
+ {
+ if (!b.final ())
+ b.get_pending ()->record_prematch (a.get_final (), false);
+ }
+ else if (b.final ())
+ a.get_pending ()->record_prematch (b.get_final (), true);
+ }
+ else
+ b.get_pending ()->_m_pending->notice_mismatch (a.get_final ());
+ return result;
+ }
+
+ template<typename item1, typename item2>
+ inline bool identical (const item1 &, const item2 &)
+ {
+ return false;
+ }
+
+ inline bool identical (const typename pending_dwarf::debug_info_entry &a,
+ const typename pending_dwarf::debug_info_entry &b)
+ {
+ return a.is (b);
+ }
+
+ inline bool identical (const typename pending_dwarf::attr_value &a,
+ const typename pending_dwarf::attr_value &b)
+ {
+ return a.is (b);
+ }
+
+ typedef tracker subtracker;
+ inline tracker (const tracker &proto, reference_match &,
+ const left_context_type &,
+ const right_context_type &)
+ : _m_ignore_context (proto._m_ignore_context)
+ {}
+ };
+
+ typedef dwarf_comparator<pending_dwarf, pending_dwarf,
+ false, tracker> comparator;
+
+ // This is what the entire pending_dwarf class exists for.
+ inline bool attrs_match (const debug_info_entry::attributes_type &a,
+ const debug_info_entry::attributes_type &b)
+ {
+ tracker t (this);
+ return comparator (t).equals (pending_dwarf::attributes (a),
+ pending_dwarf::attributes (b));
+ }
+
+ /* We're likely to come across the same strings/identifiers and source
+ files many times in a copying run. When they are the very same
+ pointers into the input dwarf object data, we can optimize the
+ ordinary string hash lookup in the value_set by caching the mapping
+ of input pointers to output values. */
+ template<typename value_type>
+ struct string_cache
+ {
+ std::map<uintptr_t, const value_type *> _m_cache;
+
+ template<typename input>
+ inline const value_type *add (subr::value_set<value_type> &set,
+ uintptr_t key, const input &x)
+ {
+ const value_type *&cache = _m_cache[key];
+ if (cache == NULL)
+ cache = set.add (x);
+ return cache;
+ }
+
+ inline const value_type *add (subr::value_set<value_type> &set,
+ const char *x)
+ {
+ return add (set, (uintptr_t) x, x);
+ }
+
+ inline const value_type *add (subr::value_set<value_type> &set,
+ const std::string &x)
+ {
+ return add (set, (uintptr_t) &x, x);
+ }
+
+ template<typename input>
+ inline const value_type *add (subr::value_set<value_type> &set,
+ const input &x)
+ {
+ return set.add (x);
+ }
+ };
+
+ string_cache<value::value_string> _m_strings;
+ string_cache<value::value_identifier> _m_identifiers;
+
+ std::tr1::unordered_map<
+ uintptr_t, const value::value_source_file *> _m_source_file_cache;
+
+ template<typename input>
+ inline const value::value_source_file *add_source_file (int /*whatattr*/,
+ const input &x)
+ {
+ const value::value_source_file *&cache
+ = _m_source_file_cache[x.identity ()];
+ if (cache == NULL)
+ cache = _m_collector->_m_source_file.add (x);
+ return cache;
+ }
+
+ template<typename input>
+ inline const value::value_string *add_string (const input &x)
+ {
+ return _m_strings.add (_m_collector->_m_strings, x);
+ }
+
+ template<typename input>
+ inline const value::value_string *add_identifier (const input &x)
+ {
+ return _m_identifiers.add (_m_collector->_m_identifiers, x);
+ }
+
+ template<typename input>
+ inline const value::value_flag *add_flag (const input &x)
+ {
+ return dwarf_output_collector::flag (x);
+ }
+
+ template<typename input>
+ inline const value::value_address *add_address (const input &x)
+ {
+ return _m_collector->_m_address.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_rangelistptr *add_ranges (const input &x)
+ {
+ return _m_collector->_m_ranges.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_lineptr *add_line_info (const input &x)
+ {
+ return _m_collector->_m_line_info.add (x, *_m_collector);
+ }
+
+ template<typename input>
+ inline const value::value_constant *add_constant (const input &x)
+ {
+ return _m_collector->_m_constants.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_constant_block *
+ add_constant_block (const input &x)
+ {
+ return _m_collector->_m_const_block.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_dwarf_constant *
+ add_dwarf_constant (const input &x)
+ {
+ return _m_collector->_m_dwarf_const.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_source_line *add_source_line (const input &x)
+ {
+ return _m_collector->_m_source_line.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_source_column *add_source_column (const input &x)
+ {
+ return _m_collector->_m_source_column.add (x);
+ }
+
+ template<typename input>
+ inline const value::value_location *add_location (const input &x)
+ {
+ return _m_collector->_m_locations.add (x);
+ }
+
+ public:
+ inline explicit copier (dwarf_output_collector &c)
+ : _m_collector (&c), _m_entries (), _m_undefined_entries (0)
+ {}
+
+ inline operator dwarf_output_collector & () const
+ {
+ return *_m_collector;
+ }
+ };
+
+ // Explicit instantiations.
+ extern template class dwarf_data::value<dwarf_output, false>;
+ extern template class dwarf_data::attr_value<dwarf_output,
+ dwarf_output::value>;
+ extern template class dwarf_data::attributes_type<dwarf_output,
+ dwarf_output::value>;
+ extern template class dwarf_data::compile_unit<dwarf_output>;
+ extern template class dwarf_data::compile_units_type<dwarf_output>;
+
+ extern template class dwarf_output::copier<dwarf>;
+ extern template class dwarf_output::copier<dwarf_edit>;
+};
+
+#endif // <elfutils/dwarf_output>
--- /dev/null
+/* elfutils::dwarf_ref_maker -- -*- C++ -*- template type specification
+ Copyright (C) 2009-2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_REF_MAKER
+#define _ELFUTILS_DWARF_REF_MAKER 1
+
+#include "dwarf"
+#include <tr1/unordered_map>
+#include <vector>
+
+namespace elfutils
+{
+ // Prototypical stub for reference maker object.
+ // This keeps no state and can't really be used.
+ template<class output, class input>
+ struct dwarf_ref_maker_base
+ {
+ typedef typename input::debug_info_entry input_entry;
+ typedef typename input_entry::children_type::const_iterator input_ref;
+ typedef typename output::debug_info_entry::pointer output_ref;
+
+ // These are called around a whole-file construction.
+ inline void start () {}
+
+ // If called, all pointers passed in since start () before are bogus.
+ inline void abort () {}
+
+ // Construction is complete: now snap in all recorded references.
+ inline void finish (output &file) {}
+
+ // The referenced output DIE has been constructed to match the input DIE.
+ inline void equivalence (const output_ref &to, const input_ref &from)
+ {
+ }
+
+ // *REF is an uninitialized attr_value.reference ().
+ // It's meant to refer to the output DIE equivalent to the given input DIE.
+ inline void refer (output_ref *ref, const input_ref &target)
+ {
+ throw std::logic_error ("dwarf_ref_maker_base cannot make references");
+ }
+ };
+
+ // Simple maker used for a single copy-construction.
+ template<class output, class input>
+ class dwarf_ref_maker : public dwarf_ref_maker_base<output, input>
+ {
+ public:
+ typedef typename input::debug_info_entry input_entry;
+ typedef typename output::debug_info_entry output_entry;
+ typedef typename input_entry::children_type::const_iterator input_ref;
+ typedef typename output_entry::children_type::iterator output_ref;
+
+ private:
+
+ struct seen
+ {
+ bool _m_known;
+ output_ref _m_out;
+ std::vector<output_ref *> _m_refs;
+
+ inline seen ()
+ : _m_known (false), _m_out (), _m_refs ()
+ {}
+
+ // Copy construction only valid for initial state.
+ inline seen (const seen &other)
+ : _m_known (false), _m_out (), _m_refs ()
+ {
+ if (unlikely (other._m_known) || unlikely (!other._m_refs.empty ()))
+ throw std::logic_error
+ ("seen copy constructs only from default-constructed");
+ }
+
+ inline void resolve ()
+ {
+ for (; !_m_refs.empty (); _m_refs.pop_back ())
+ *_m_refs.back () = _m_out;
+ }
+
+ inline void resolve (const output_ref &to)
+ {
+ _m_out = to;
+ _m_known = true;
+ resolve ();
+ }
+
+ inline void refer (output_ref *out)
+ {
+ _m_refs.push_back (out);
+ if (_m_known)
+ resolve ();
+ }
+ };
+
+ std::tr1::unordered_map<dwarf::debug_info_entry::identity_type,
+ seen> _m_map;
+
+ public:
+ inline dwarf_ref_maker ()
+ : _m_map ()
+ {}
+
+ inline dwarf_ref_maker (const dwarf_ref_maker &other)
+ : _m_map ()
+ {
+ if (unlikely (!other._m_map.empty ()))
+ throw std::logic_error
+ ("dwarf_ref_maker copy constructs only from default-constructed");
+ }
+
+ inline ~dwarf_ref_maker ()
+ {}
+
+ inline void abort ()
+ {
+ _m_map.clear ();
+ }
+
+ inline void equivalence (const output_ref &out, const input_ref &in)
+ {
+ _m_map[in->identity ()].resolve (out);
+ }
+
+ inline void refer (output_ref *out, const input_ref &in)
+ {
+ _m_map[in->identity ()].refer (out);
+ }
+
+ inline void finish (output &file)
+ {
+ while (_m_map.begin () != _m_map.end ())
+ if (_m_map.begin ()->second._m_known)
+ _m_map.erase (_m_map.begin ());
+ else
+ throw std::logic_error ("construction finished with unresolved refs");
+ }
+ };
+
+};
+
+#endif // <elfutils/dwarf_ref_maker>
--- /dev/null
+/* elfutils::dwarf_ref_tracker -- DWARF reference tracking in -*- C++ -*-
+ Copyright (C) 2009-2011 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_DWARF_TRACKER
+#define _ELFUTILS_DWARF_TRACKER 1
+
+#include "subr.hh"
+#include "dwarf"
+#include "dwarf_comparator"
+#include <tr1/unordered_map>
+#include <tr1/unordered_set>
+
+namespace elfutils
+{
+ // Basic tracker of tree-walk paths to DIEs.
+ template<typename dw>
+ class dwarf_path_finder
+ {
+ public:
+ typedef typename dw::compile_units_type::const_iterator cu;
+ typedef typename dw::debug_info_entry::children_type::const_iterator die;
+
+ /* We maintain the current path down the logical DIE tree from the CU
+ as a stack of iterators pointing to the DIE at each level.
+
+ Note that the path to a DIE includes the iterator to that DIE
+ itself as the last element. This is necessary to permit sharing
+ our _m_seen cache across CUs. That sharing is useful when CUs
+ might share children (i.e. they use DW_TAG_imported_unit).
+ But when they do, then the "construct a derived tracker that
+ jump-starts a walk" case for following a reference might be for
+ a reference to another CU than the one the base tracker is
+ walking (_m_root). When path_to finds the "context" path to the
+ referent, the iterator that jump-starts a new walk must be an
+ iterator pointing to the referent, but must be an iterator
+ somewhere in the _m_root CU's tree, not another CU's.
+
+ NOTE!!! XXX
+ This scenario means we can have a die_path in our _m_seen that
+ is not from our current _m_root CU. This is only safe as long
+ as we are sure that we have already completely walked the other
+ CU that die_path came from so all its entries are in _m_seen.
+ This ensures that a derived tracker that jump-starts its walk at
+ a path in another CU will never actually have to do any walking.
+ If it ever walked, it could go awry failing to recognize the end
+ of its CU's children list--it's not _m_root->children ().end ().
+ If we want to generalize dwarf_path_finder so it can be used as
+ a generic cache when we might not have walked whole CUs, then we
+ need to change things. We'd have to store _m_root along with
+ _m_path in _m_seen so that a derived tracker made from path_to
+ "context" can use the right _m_root.
+ */
+ typedef subr::sharing_stack<die> die_path;
+
+ private:
+ // We use an empty list as a marker; every path includes at least one DIE.
+ static inline const die_path bad_die_path ()
+ {
+ return die_path ();
+ }
+ static inline bool bad_die_path (const die_path &path)
+ {
+ return path.empty ();
+ }
+
+ /* We record every DIE we have seen here, mapping its .identity () to
+ the die_path of parent DIEs taken to reach it, including itself. */
+ typedef std::tr1::unordered_map<dwarf::debug_info_entry::identity_type,
+ const die_path> die_map;
+ die_map *_m_seen;
+
+ /* The original object that this was cloned from, or NULL if this is
+ it. That object owns the _m_seen map and will delete it. */
+ dwarf_path_finder *_m_owner;
+
+ /* A cloned object used for walking ahead to satisfy path_to.
+ This is only ever set in an original object, where _m_owner is NULL. */
+ dwarf_path_finder *_m_walkahead;
+
+ // The total number of DIEs visited in this object's walk.
+ unsigned int _m_steps_taken;
+
+ cu _m_root;
+
+ die_path _m_path;
+
+ explicit dwarf_path_finder (const dwarf_path_finder &)
+ {
+ throw std::logic_error ("not copy-constructible");
+ }
+
+ explicit dwarf_path_finder (dwarf_path_finder *owner)
+ : _m_seen (owner->_m_seen), _m_owner (owner),
+ _m_walkahead (NULL), _m_steps_taken (owner->_m_steps_taken),
+ _m_root (owner->_m_root), _m_path (owner->_m_path)
+ {
+ }
+
+ inline bool at_top () const
+ {
+ return _m_path.empty ();
+ }
+
+ inline const die ¤t_die () const
+ {
+ assert (!at_top ());
+ return _m_path.top ();
+ }
+
+ inline dwarf::debug_info_entry::identity_type current_identity () const
+ {
+ return (*current_die ()).identity ();
+ }
+
+ inline die current_end () const
+ {
+ assert (!at_top ());
+ const typename die_path::const_reverse_iterator i = ++_m_path.rbegin ();
+ return (i == _m_path.rend ()
+ ? (*_m_root).children ().end ()
+ : (**i).children ().end ());
+ }
+
+ // Append this DIE to the path we'll record for it and its children.
+ inline void step_forward (const die &here)
+ {
+ _m_path.push (here);
+ assert (!bad_die_path (_m_path));
+ ++_m_steps_taken;
+ record_step ();
+ }
+
+ inline void step_back ()
+ {
+ _m_path.pop ();
+ }
+
+ inline void clear_walkahead ()
+ {
+ delete _m_walkahead;
+ _m_walkahead = NULL;
+ }
+
+ inline void clear_walk ()
+ {
+ if (_m_walkahead != NULL)
+ clear_walkahead ();
+ _m_steps_taken = 0;
+ }
+
+ // Record the path down from the CU to see this DIE.
+ inline void record_step ()
+ {
+ if (_m_walkahead != NULL)
+ {
+ if (_m_steps_taken == _m_walkahead->_m_steps_taken)
+ // We have caught up to the walkahead, so it's now superfluous.
+ clear_walkahead ();
+ else
+ // The walkahead is past us, so there is nothing to record.
+ assert (_m_steps_taken < _m_walkahead->_m_steps_taken);
+ }
+ else
+ _m_seen->insert (std::make_pair (current_identity (), _m_path));
+ }
+
+ public:
+ // Default constructor: an original tracker.
+ inline dwarf_path_finder ()
+ : _m_seen (new die_map), _m_owner (NULL),
+ _m_walkahead (NULL), _m_steps_taken (0)
+ {}
+
+ // Construct a derived tracker: does its own whole walk, but sharing caches.
+ inline dwarf_path_finder (const dwarf_path_finder &proto, bool)
+ : _m_seen (proto._m_seen), _m_owner (&proto),
+ _m_walkahead (NULL), _m_steps_taken (0)
+ {}
+
+ /* Construct a derived tracker that jump-starts a walk.
+ CONTEXT is from a path_to call made on PROTO. */
+ inline dwarf_path_finder (dwarf_path_finder &proto,
+ const die_path &context)
+ : _m_seen (proto._m_seen), _m_owner (proto._m_owner ?: &proto),
+ _m_walkahead (NULL), _m_steps_taken (0),
+ _m_root (proto._m_root), _m_path (context)
+ {}
+
+ inline ~dwarf_path_finder ()
+ {
+ if (_m_owner == NULL)
+ {
+ delete _m_seen;
+ // We should never be left with a partial walk on the books.
+ assert (_m_path.empty ());
+ }
+ }
+
+ // Main hooks for a normal walk.
+
+ /* A walk object does set-up work when constructed and tear-down
+ work when destroyed, so tear-down is done even for exceptions. */
+ struct walk
+ {
+ dwarf_path_finder *_m_tracker;
+ bool _m_jumped;
+
+ inline walk (dwarf_path_finder *w, const cu &root)
+ : _m_tracker (w), _m_jumped (false)
+ {
+ assert (_m_tracker->_m_path.empty ());
+ assert (_m_tracker->_m_steps_taken == 0);
+ assert (_m_tracker->_m_walkahead == NULL);
+ _m_tracker->_m_root = root;
+ }
+
+ inline ~walk ()
+ {
+ if (_m_jumped)
+ _m_tracker->_m_path.clear ();
+ else
+ assert (_m_tracker->_m_path.empty ());
+ _m_tracker->clear_walk ();
+ }
+
+ inline void jump (const typename dw::debug_info_entry &there)
+ {
+ _m_jumped = true;
+ _m_tracker->prime_path_to (there);
+ }
+ };
+
+ /* A step object does pre-order work when constructed and post-order
+ work when destroyed, so post-order is done even for exceptions.
+ While this object lives, HERE is on the _m_path stack. */
+ struct step
+ {
+ dwarf_path_finder *_m_walker;
+ inline step (dwarf_path_finder *w, const die &here)
+ : _m_walker (w)
+ {
+ _m_walker->step_forward (here);
+ }
+ inline ~step ()
+ {
+ _m_walker->step_back ();
+ }
+ };
+
+ inline void unreachable (const typename dw::debug_info_entry &) const
+ {
+ throw std::runtime_error ("DIE not reachable from CU!");
+ }
+
+ inline void prime_path_to (const typename dw::debug_info_entry &there)
+ {
+ if (_m_owner != NULL)
+ {
+ /* Since this is a cloned tracker,
+ _m_steps_taken counting does not matter. */
+ assert (this != _m_owner->_m_walkahead);
+ _m_path = path_to (there);
+ }
+ else
+ {
+ /* Spin the walk ahead until we get THERE. */
+ const dwarf::debug_info_entry::identity_type id = there.identity ();
+ if (_m_seen->find (id) != _m_seen->end ())
+ {
+ /* We're walking backwards now. We have to repeat the
+ whole walk to recover our _m_steps_taken state correctly. */
+ _m_path.clear ();
+ clear_walk ();
+ }
+
+ if (at_top ())
+ {
+ /* We have to get the walk started. */
+ const die first = (*_m_root).children ().begin ();
+ if (first == (*_m_root).children ().end ())
+ unreachable (there); // Empty CU!
+
+ step_forward (first);
+ if ((*first).identity () == id)
+ return;
+ }
+
+ /* We have not walked past it yet, so just keep walking. */
+ if (! walk_to (id))
+ unreachable (there);
+ }
+ }
+
+ // Random access to a DIE, find the path of the walk that gets there.
+ inline const die_path &path_to (const die &a)
+ {
+ return path_to (*a);
+ }
+
+ inline const die_path &path_to (const typename dw::debug_info_entry &a)
+ {
+ if (_m_owner != NULL)
+ return _m_owner->path_to (a);
+
+ const dwarf::debug_info_entry::identity_type id = a.identity ();
+ const typename die_map::const_iterator found = _m_seen->find (id);
+ if (found != _m_seen->end ())
+ return found->second;
+
+ /* It's not in our _m_seen map. Our main walk recording
+ into _m_seen is exhaustive, so this can only be a forward
+ reference. That is, we didn't already hit this DIE in
+ our top-level walk and so it is not in _m_seen yet.
+ We must walk ahead to find it. */
+ return walk_ahead_to (a, id);
+ }
+
+ private:
+ /* Do some walkahead to find the target entry.
+ This can only be used on the master object, not its clones. */
+ inline const die_path &
+ walk_ahead_to (const typename dw::debug_info_entry &a,
+ dwarf::debug_info_entry::identity_type id)
+ {
+ assert (_m_owner == NULL);
+ if (_m_walkahead == NULL)
+ // Create our walkahead clone.
+ _m_walkahead = new dwarf_path_finder (this);
+ if (! _m_walkahead->walk_to (id))
+ unreachable (a);
+ return _m_walkahead->_m_path;
+ }
+
+ // Do some actual walkahead. This is used only on the walkahead clone.
+ inline bool walk_to (dwarf::debug_info_entry::identity_type id)
+ {
+ return walk_down_to (id) || walk_over_to (id) || walk_up_to (id);
+ }
+
+ // Descend into child HERE (already pushed) looking for THERE.
+ inline bool walk_in_to (const typename die::value_type &here,
+ dwarf::debug_info_entry::identity_type there)
+ {
+ return (here.has_children ()
+ && walk_through_to (here.children ().begin (),
+ here.children ().end (),
+ there));
+ }
+
+ // Walk through siblings [IT,END) looking for THERE.
+ bool walk_through_to (die it, const die &end,
+ dwarf::debug_info_entry::identity_type there)
+ {
+ for (; it != end; ++it)
+ {
+ /* Do step_forward even for a childless non-match, because it
+ records this DIE in _m_seen, which we will rely on later. */
+ step_forward (it);
+
+ const typename die::value_type &child = *it;
+
+ /* Note that we compare identities here, rather than passing down
+ a THERE iterator and comparing iterators. In dwarf_output, we
+ can have multiple iterators into distinct children_type vectors
+ that all point to the same entry. A reference could be one of
+ these iterators, and all mean the same entry. */
+ if (child.identity () == there || walk_in_to (child, there))
+ return true;
+
+ // Come back out of this child to look at the next.
+ step_back ();
+ }
+ return false;
+ }
+
+ /* First descend into the current DIE's children.
+ _m_path already has the current DIE, so it is ready to go. */
+ // XXX is a reference to an owned DIE really possible??
+ inline bool walk_down_to (dwarf::debug_info_entry::identity_type there)
+ {
+ return walk_in_to (*current_die (), there);
+ }
+
+ /* Now wind the walk forward starting from the current DIE's
+ immediate sibling. If we fail, we wind up at this DIE's parent. */
+ inline bool walk_over_to (dwarf::debug_info_entry::identity_type there)
+ {
+ // Fetch the current DIE and end-point before we step back.
+ die here (current_die ());
+ const die end = current_end ();
+
+ step_back ();
+ return walk_through_to (++here, end, there);
+ }
+
+ /* We have already stepped back from the current DIE to its parent.
+ Now wind the walk forward from that parent's immediate sibling. */
+ inline bool walk_up_to (dwarf::debug_info_entry::identity_type there)
+ {
+ while (!at_top ())
+ if (walk_over_to (there))
+ return true;
+ return false;
+ }
+ };
+
+ // Standard tracker.
+ template<class dwarf1, class dwarf2>
+ class dwarf_ref_tracker : public dwarf_tracker_base<dwarf1, dwarf2>
+ {
+ private:
+ typedef dwarf_tracker_base<dwarf1, dwarf2> _base;
+
+ explicit dwarf_ref_tracker (const dwarf_ref_tracker &)
+ : _base ()
+ {
+ throw std::logic_error ("not copy-constructible");
+ }
+
+ public:
+ typedef typename _base::cu1 cu1;
+ typedef typename _base::cu2 cu2;
+ typedef typename _base::die1 die1;
+ typedef typename _base::die2 die2;
+ class reference_match;
+
+ protected:
+ typedef dwarf_path_finder<dwarf1> tracker1;
+ typedef dwarf_path_finder<dwarf2> tracker2;
+
+ tracker1 _m_left;
+ tracker2 _m_right;
+
+ struct ref_hasher : public std::unary_function<die2, size_t>
+ {
+ inline size_t operator () (const die2 &i) const
+ {
+ return (*i).identity ();
+ }
+ };
+
+ struct same_ref : public std::equal_to<die2>
+ {
+ inline bool operator () (const die2 &a, const die2 &b) const
+ {
+ return (*a).identity () == (*b).identity ();
+ }
+ };
+
+ typedef std::tr1::unordered_map<dwarf::debug_info_entry::identity_type,
+ reference_match *> active_map;
+ active_map _m_active;
+
+ typedef std::pair<const die2 *,
+ std::tr1::unordered_set<die2, ref_hasher, same_ref>
+ > equiv_list;
+ typedef std::tr1::unordered_map<dwarf::debug_info_entry::identity_type,
+ equiv_list> equiv_map;
+ equiv_map *_m_equiv;
+ bool _m_delete_equiv;
+
+ inline equiv_list *equiv_to (const die1 &a)
+ {
+ return &(*_m_equiv)[a->identity ()];
+ }
+
+ struct equal_enough : public std::binary_function<die1, die2, bool>
+ {
+ inline bool operator () (const die1 &a, const die2 &b)
+ {
+ return dwarf_comparator<dwarf1, dwarf2>::equal_enough (*a, *b);
+ }
+ };
+
+ public:
+ inline dwarf_ref_tracker ()
+ : _m_equiv (new equiv_map), _m_delete_equiv (true)
+ {}
+
+ inline dwarf_ref_tracker (const tracker1 &proto)
+ : _m_left (proto, true),
+ _m_equiv (new equiv_map), _m_delete_equiv (true)
+ {}
+
+ inline ~dwarf_ref_tracker ()
+ {
+ if (_m_delete_equiv)
+ delete _m_equiv;
+ }
+
+ inline void reset ()
+ {
+ _m_equiv->clear ();
+ assert (!_m_right->_m_delete_seen);
+ _m_right._m_seen->clear ();
+ }
+
+ struct walk
+ {
+ typename tracker1::walk _m_left;
+ typename tracker2::walk _m_right;
+
+ inline walk (dwarf_ref_tracker *w, const cu1 &a, const cu2 &b)
+ : _m_left (&w->_m_left, a), _m_right (&w->_m_right, b)
+ {}
+
+ // Wind forward to cache everything up through A and B.
+ inline void jump (const typename dwarf1::debug_info_entry &a,
+ const typename dwarf2::debug_info_entry &b)
+ {
+ _m_left.jump (a);
+ _m_right.jump (b);
+ }
+ };
+
+ struct step
+ {
+ typename tracker1::step _m_left;
+ typename tracker2::step _m_right;
+
+ inline step (dwarf_ref_tracker *w, const die1 &a, const die2 &b)
+ : _m_left (&w->_m_left, a), _m_right (&w->_m_right, b)
+ {}
+ };
+
+ typedef typename tracker1::die_path left_context_type;
+ inline const left_context_type &left_context (const die1 &die)
+ {
+ return _m_left.path_to (die);
+ }
+
+ typedef typename tracker2::die_path right_context_type;
+ inline const right_context_type &right_context (const die2 &die)
+ {
+ return _m_right.path_to (die);
+ }
+
+ // Very cheap check for an obvious mismatch of contexts.
+ inline bool context_quick_mismatch (const left_context_type &a,
+ const right_context_type &b)
+
+ {
+ return a.size () != b.size ();
+ }
+
+ // Full match when context_quick_mismatch has returned false.
+ inline bool context_match (const left_context_type &a,
+ const right_context_type &b)
+ {
+ equal_enough equalator;
+ // Ignore the top of the stack, which is the target DIE itself.
+ return a.equal (b, equalator, 1);
+ }
+
+ class reference_match
+ {
+ friend class dwarf_ref_tracker;
+ protected:
+ equiv_list *_m_lhs;
+ typename active_map::value_type *_m_rhs;
+ active_map *_m_active;
+
+ public:
+
+ inline reference_match ()
+ : _m_lhs (NULL), _m_rhs (NULL), _m_active (NULL)
+ {}
+
+ inline ~reference_match ()
+ {
+ if (_m_lhs != NULL)
+ _m_lhs->first = NULL;
+ if (_m_rhs != NULL)
+ _m_active->erase (_m_rhs->first);
+ }
+ };
+
+ /* A prematch during the main tree walk does the same cache lookup
+ as real reference matching. But it doesn't record itself as a
+ "walk in progress" for the circularity-catching logic. Doing so
+ can break that logic for comparison purposes. Since we key our
+ cache on identity, a lookup can hit a shared DIE as well as one
+ that is truly involved in our current walk. If we hit a shared
+ DIE on the main walk, and within that recursion (i.e. somewhere
+ in its children or along its own references) we encounter a
+ circularity, we'd take the main-walk's equiv_list record as the
+ root of the circularity on one side, while on the other side the
+ DIEs may not have been shared and so the same circularity is
+ actually rooted at the second instance of an identical DIE. */
+ inline bool prematch (reference_match &matched,
+ const die1 &a, const die2 &b)
+ {
+ return reference_matched (matched, a, b, false);
+ }
+
+ inline bool
+ reference_matched (reference_match &matched, const die1 &a, const die2 &b,
+ bool record = true)
+ {
+ equiv_list *elt = equiv_to (a);
+ if (elt->first == NULL)
+ {
+ matched._m_lhs = elt;
+
+ if (record)
+ /* Record that we have a walk in progress crossing A.
+ When MATCHED goes out of scope in our caller, its
+ destructor will reset ELT->first to clear this record. */
+ elt->first = &b;
+
+ // Short-circuit if we have already matched B to A.
+ return elt->second.find (b) != elt->second.end ();
+ }
+
+ /* We have a circularity on the left-hand side. We can tell because
+ ELT->first remains set from an outer recursion still in progress.
+
+ The circular chain of references rooted at A matches B if B is
+ also the root of its own circularity and everything along those
+ parallel chains matches. If the chains hadn't matched so far,
+ we would not have kept following them to get here.
+
+ We recorded the B that arrived at the first comparison with A.
+ We actually record the pointer on the caller's stack rather
+ than a copy of B, just because the iterator might be larger. */
+
+ if ((**elt->first).identity () == (*b).identity ())
+ return true;
+
+ /* Our right-hand side is not in lock-step on a matching circularity.
+ But it's still possible this is a matching reference nonetheless.
+ A difference in the sharing vs duplication of DIEs between the
+ left-hand and right-hand sides could mean that one side's chain of
+ references reaches the same cycle sooner than the other's.
+
+ Consider:
+
+ A1 -> A2 -> ... -> A1' -> A2 ...
+ B1 -> B2 -> ... -> B1 -> B2 ...
+
+ Here A1' is an identical copy of A1, duplicated in the A object.
+ Otherwise A1 matches B1, A2 matches B2, etc. The B walk started
+ at B1 and hits it again at the step comparing B1 to A1'. But the
+ A walk has not hit A1 again yet (and perhaps it never will), so
+ our test above does not match.
+
+ This is the simplest example. There might be more steps of the
+ reference chain that have duplicates on one side but have been
+ consolidated to a single entry on the other. There can also be
+ multiple reference attributes at each node that differ on this
+ issue, making all manner of tangled graphs that all really match
+ the same simpler graph (and thus each other).
+
+ Now we start recording the state of the right-hand side reference
+ chain walk, and keep going. When the right-hand side then becomes
+ circular, we check that it has coincided with the left-hand side.
+
+ This is guaranteed to terminate, at least. It should never have
+ any false positives, since that continuing walk would eventually
+ find the differences. We hope it doesn't have any false negatives
+ either, but to be sure of that would require more graph theory
+ than your humble writer can bring to bear. */
+
+ const std::pair<typename active_map::iterator, bool> p
+ = _m_active.insert (std::make_pair ((*b).identity (), &matched));
+ if (p.second)
+ {
+ assert (p.first->second == &matched);
+ matched._m_lhs = elt;
+ matched._m_active = &_m_active;
+ matched._m_rhs = &*p.first;
+ return false;
+ }
+
+ assert (p.first->second != &matched);
+ return p.first->second->_m_lhs == elt;
+ }
+
+ inline bool cannot_match (reference_match &matched,
+ const die1 &, const die2 &)
+ {
+ return matched._m_lhs == NULL && matched._m_rhs == NULL;
+ }
+
+ inline bool notice_match (reference_match &/*matched*/,
+ const die1 &, const die2 &/*b*/, bool matches)
+ {
+ /* XXX not reliable!
+ This match could be predicated on a tentative match of a
+ circular ref inside. We can't cache that!
+ if (matches && matched._m_lhs != NULL)
+ matched._m_lhs->second.insert (b);
+ */
+ return matches;
+ }
+
+ typedef dwarf_ref_tracker subtracker;
+
+ // Share the _m_seen maps with the prototype tracker,
+ // but start a fresh walk from the given starting point.
+ inline dwarf_ref_tracker (dwarf_ref_tracker &proto, reference_match &,
+ const left_context_type &lhs,
+ const right_context_type &rhs)
+ : _m_left (proto._m_left, lhs),
+ _m_right (proto._m_right, rhs),
+ _m_equiv (proto._m_equiv), _m_delete_equiv (false)
+ {
+ // We are starting a recursive consideration of LHS vs RHS.
+ }
+ };
+};
+
+#endif // <elfutils/dwarf_tracker>
--- /dev/null
+/* elfutils::dwarf_edit attribute value interfaces.
+ Copyright (C) 2009-2010 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include "dwarf_edit"
+#include "data-values.hh"
+
+using namespace elfutils;
+
+// Explicit instantiations.
+template class dwarf_data::line_entry<dwarf_edit::source_file>;
+template class dwarf_data::line_table<dwarf_edit::line_entry>;
+template class dwarf_data::line_info_table<dwarf_edit::line_table>;
+template class dwarf_data::attr_value<dwarf_edit>;
+template class dwarf_data::value<dwarf_edit>;
+
+template<>
+std::string
+to_string<dwarf_edit::attribute> (const dwarf_edit::attribute &attr)
+{
+ return attribute_string (attr);
+}
+
+namespace elfutils
+{
+ template<>
+ std::string to_string (const dwarf_edit::debug_info_entry &die)
+ {
+ return die_string (die);
+ }
+};
+
+std::string
+dwarf_data::source_file::to_string () const
+{
+ if (likely (_m_mtime == 0) && likely (_m_size == 0))
+ return "\"" + _m_name + "\"";
+
+ std::ostringstream os;
+ os << "{\"" << _m_name << "," << _m_mtime << "," << _m_size << "}";
+ return os.str ();
+}
--- /dev/null
+/* -*- C++ -*- exceptions for libdw.
+ Copyright (C) 2009 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <cassert>
+#include "dwarf"
+
+extern "C"
+{
+#include "libdwP.h"
+}
+
+using namespace elfutils;
+using namespace std;
+
+
+/* Throw
+ */
+void
+dwarf::throw_libdw (::Dwarf *)
+{
+ throw std::runtime_error (::dwarf_errmsg (-1));
+}
+
+// This is just for things that can't find the Dwarf pointer directly.
+void
+dwarf::throw_libdw (::Dwarf_CU *cu)
+{
+ throw_libdw (cu->dbg);
+}
--- /dev/null
+/* Known named integer values in DWARF.
+ Copyright (C) 2009 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include "dwarf"
+#include "dwarf_edit"
+#include "known-dwarf.h"
+
+using namespace elfutils;
+using namespace std;
+
+
+const char *
+dwarf::known_tag (int tag)
+{
+ switch (tag)
+ {
+#define ONE_KNOWN_DW_TAG(name, id) case id: return #id;
+#define ONE_KNOWN_DW_TAG_DESC(name, id, desc) ONE_KNOWN_DW_TAG (name, id)
+ ALL_KNOWN_DW_TAG
+ }
+ return NULL;
+}
+
+const char *
+dwarf::known_attribute (int name)
+{
+ switch (name)
+ {
+#define ONE_KNOWN_DW_AT(name, id) case id: return #id;
+#define ONE_KNOWN_DW_AT_DESC(name, id, desc) ONE_KNOWN_DW_AT (name, id)
+ ALL_KNOWN_DW_AT
+ }
+ return NULL;
+}
+
+namespace elfutils
+{
+ template<int key>
+ size_t
+ dwarf::known_enum<key>::prefix_length ()
+ {
+ return 0;
+ }
+
+ template<int key>
+ const char *
+ dwarf::known_enum<key>::identifier (int value)
+ {
+ return NULL;
+ }
+
+#define ALL_KNOWN_ENUM \
+ KNOWN_ENUM (accessibility, ACCESS) \
+ KNOWN_ENUM (encoding, ATE) \
+ KNOWN_ENUM (calling_convention, CC) \
+ KNOWN_ENUM (decimal_sign, DS) \
+ KNOWN_ENUM (endianity, END) \
+ KNOWN_ENUM (identifier_case, ID) \
+ KNOWN_ENUM (inline, INL) \
+ KNOWN_ENUM (language, LANG) \
+ KNOWN_ENUM (ordering, ORD) \
+ KNOWN_ENUM (virtuality, VIRTUALITY) \
+ KNOWN_ENUM (visibility, VIS)
+
+#define ONE_KNOWN_DW_ACCESS(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_ATE(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_CC(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_DS(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_END(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_ID(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_INL(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_LANG(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_LANG_DESC(name, id, desc) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_ORD(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_INL(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_VIRTUALITY(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_VIS(name, id) KNOWN_ENUM_CASE (id)
+
+ // Stupid C++ doesn't do [x] = y initializers.
+#define KNOWN_ENUM(attr, enum) \
+ template<> \
+ size_t \
+ dwarf::known_enum<DW_AT_##attr>::prefix_length () \
+ { \
+ return sizeof ("DW_" #enum "_") - 1; \
+ } \
+ template<> \
+ const char * \
+ dwarf::known_enum<DW_AT_##attr>::identifier (int value) \
+ { \
+ switch (value) \
+ { \
+ ALL_KNOWN_DW_##enum \
+ } \
+ return NULL; \
+ }
+#define KNOWN_ENUM_CASE(id) case id: return #id;
+
+ ALL_KNOWN_ENUM
+
+ // Not really enum cases, but pretend they are.
+#define ONE_KNOWN_DW_FORM(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_OP(name, id) KNOWN_ENUM_CASE (id)
+#define ONE_KNOWN_DW_OP_DESC(name, id, desc) KNOWN_ENUM_CASE (id)
+ KNOWN_ENUM (producer, FORM)
+ KNOWN_ENUM (location, OP)
+
+#undef KNOWN_ENUM
+#undef KNOWN_ENUM_CASE
+};
+
+static const char *
+known_identifier (unsigned int which, unsigned int value)
+{
+ switch (which)
+ {
+# define KNOWN_ENUM(attr, enum) \
+ case DW_AT_##attr: \
+ return dwarf::known_enum<DW_AT_##attr>::identifier (value);
+
+ ALL_KNOWN_ENUM
+
+# undef KNOWN_ENUM
+ }
+
+ return NULL;
+}
+
+static const char *
+known_name (unsigned int which, unsigned int value)
+{
+ switch (which)
+ {
+# define KNOWN_ENUM(attr, enum) \
+ case DW_AT_##attr: \
+ return dwarf::known_enum<DW_AT_##attr>::name (value);
+
+ ALL_KNOWN_ENUM
+
+# undef KNOWN_ENUM
+ }
+
+ return NULL;
+}
+
+template<typename constant>
+static inline const char *
+enum_identifier (const constant &value)
+{
+ return known_identifier (value.which (), value);
+}
+
+template<typename constant>
+static inline const char *
+enum_name (const constant &value)
+{
+ return known_name (value.which (), value);
+}
+
+const char *
+dwarf::dwarf_enum::identifier () const
+{
+ return enum_identifier (*this);
+}
+
+const char *
+dwarf::dwarf_enum::name () const
+{
+ return enum_name (*this);
+}
+
+const char *
+dwarf_data::dwarf_enum::identifier () const
+{
+ return enum_identifier (*this);
+}
+
+const char *
+dwarf_data::dwarf_enum::name () const
+{
+ return enum_name (*this);
+}
+
+template<class value_type>
+static inline std::string
+enum_string (const value_type &value)
+{
+ const char *known = value.name ();
+ return known == NULL ? subr::hex_string (value) : std::string (known);
+}
+
+template<>
+string
+to_string<dwarf::dwarf_enum> (const dwarf::dwarf_enum &value)
+{
+ return enum_string (value);
+}
+
+template<>
+string
+to_string<dwarf_data::dwarf_enum> (const dwarf_data::dwarf_enum &value)
+{
+ return enum_string (value);
+}
--- /dev/null
+/* -*- C++ -*- interfaces for libdw.
+ Copyright (C) 2009-2011 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <cassert>
+#include "dwarf"
+
+extern "C"
+{
+#include "libdwP.h"
+}
+
+using namespace elfutils;
+using namespace std;
+
+
+// dwarf::line_info_table
+
+const dwarf::line_info_table
+dwarf::attr_value::line_info () const
+{
+ assert (dwarf_whatattr (thisattr ()) == DW_AT_stmt_list);
+
+ CUDIE (cudie, _m_attr.cu);
+ Dwarf_Lines *lines;
+ size_t n;
+ xif (thisattr (), dwarf_getsrclines (&cudie, &lines, &n) < 0);
+
+ return line_info_table (_m_attr.cu->files);
+}
+
+const dwarf::line_table
+dwarf::line_info_table::lines () const
+{
+ return line_table (_m_files->cu->lines);
+}
+\f
+// dwarf::source_file
+
+const class dwarf::source_file
+dwarf::attr_value::source_file () const
+{
+ switch (what_space ())
+ {
+ case VS_string:
+ case VS_source_file:
+ break;
+ default:
+ throw std::runtime_error ("XXX not a file name");
+ }
+ return dwarf::source_file (_m_attr);
+}
+
+static bool
+stringform (Dwarf_Attribute *attr)
+{
+ if (attr->valp != NULL)
+ switch (dwarf_whatform (attr))
+ {
+ case DW_FORM_string:
+ case DW_FORM_strp:
+ return true;
+ }
+ return false;
+}
+
+/* Returns true if the attribute represents a valid zero udata.
+ This represents "no-file". */
+static bool
+zero_formudata (Dwarf_Attribute *attr)
+{
+ Dwarf_Word zero;
+ return dwarf_formudata (attr, &zero) == 0 && zero == 0;
+}
+
+/* Mock up a dummy attribute with a special kludge that get_files groks.
+ We use these for source_file objects consed directly from an index
+ rather than from a real attribute. */
+static inline const Dwarf_Attribute
+dummy_source_file (Dwarf_CU *cu, unsigned int idx)
+{
+ const Dwarf_Attribute dummy = { idx, DW_FORM_indirect, NULL, cu };
+ return dummy;
+}
+
+static bool
+get_files (const Dwarf_Attribute *attr, Dwarf_Files **files, Dwarf_Word *idx)
+{
+ if (attr->valp == NULL)
+ {
+ // Dummy hack created by dummy_source_file, above.
+ assert (attr->form == DW_FORM_indirect);
+ *files = attr->cu->files;
+ *idx = attr->code;
+ return false;
+ }
+
+ CUDIE (cudie, attr->cu);
+ return (dwarf_formudata (const_cast<Dwarf_Attribute *> (attr), idx) < 0
+ || dwarf_getsrcfiles (&cudie, files, NULL) < 0);
+}
+
+Dwarf_Word
+dwarf::source_file::mtime () const
+{
+ if (stringform (thisattr ()) || zero_formudata (thisattr ()))
+ return 0;
+
+ Dwarf_Files *files;
+ Dwarf_Word idx;
+ xif (thisattr (), get_files (thisattr (), &files, &idx));
+
+ Dwarf_Word result;
+ xif (thisattr (), dwarf_filesrc (files, idx, &result, NULL) == NULL);
+ return result;
+}
+
+Dwarf_Word
+dwarf::source_file::size () const
+{
+ if (stringform (thisattr ()) || zero_formudata (thisattr ()))
+ return 0;
+
+ Dwarf_Files *files;
+ Dwarf_Word idx;
+ xif (thisattr (), get_files (thisattr (), &files, &idx));
+
+ Dwarf_Word result;
+ xif (thisattr (), dwarf_filesrc (files, idx, NULL, &result) == NULL);
+ return result;
+}
+
+static const char *no_file = "";
+
+const char *
+dwarf::source_file::name () const
+{
+ const char *result;
+ if (stringform (thisattr ()))
+ result = dwarf_formstring (thisattr ());
+ else if (zero_formudata (thisattr ()))
+ result = no_file;
+ else
+ {
+ Dwarf_Files *files;
+ Dwarf_Word idx;
+ xif (thisattr (), get_files (thisattr (), &files, &idx));
+ result = dwarf_filesrc (files, idx, NULL, NULL);
+ }
+ xif (thisattr (), result == NULL);
+ return result;
+}
+
+static inline string
+plain_string (const char *filename)
+{
+ string result ("\"");
+ result += filename;
+ result += "\"";
+ return result;
+}
+
+string
+dwarf::source_file::to_string () const
+{
+ if (stringform (thisattr ()))
+ {
+ const char *result = dwarf_formstring (thisattr ());
+ xif (thisattr (), result == NULL);
+ return plain_string (result);
+ }
+
+ if (zero_formudata (thisattr ()))
+ return plain_string (no_file);
+
+ Dwarf_Files *files;
+ Dwarf_Word idx;
+ xif (thisattr (), get_files (thisattr (), &files, &idx));
+
+ Dwarf_Word file_mtime;
+ Dwarf_Word file_size;
+ const char *result = dwarf_filesrc (files, idx, &file_mtime, &file_size);
+ xif (thisattr (), result == NULL);
+
+ if (likely (file_mtime == 0) && likely (file_size == 0))
+ return plain_string (result);
+
+ std::ostringstream os;
+ os << "{\"" << result << "," << file_mtime << "," << file_size << "}";
+ return os.str ();
+}
+\f
+// dwarf::file_table
+
+size_t
+dwarf::file_table::size () const
+{
+ return _m_files->nfiles;
+}
+
+const dwarf::source_file
+dwarf::file_table::at (size_t idx) const
+{
+ if (unlikely (idx >= _m_files->nfiles))
+ throw std::out_of_range ("XXX fileidx");
+
+ return dwarf::source_file (dummy_source_file (_m_files->cu, idx));
+}
+
+dwarf::file_table::const_iterator
+dwarf::file_table::find (const source_file &src) const
+{
+ if (src._m_attr.cu->files == _m_files)
+ {
+ // Same table, just cons an iterator using its index.
+ Dwarf_Files *files;
+ Dwarf_Word idx;
+ xif (files->cu, get_files (&src._m_attr, &files, &idx));
+ return const_iterator (*this, idx);
+ }
+
+ // Not from this table, just match on file name.
+ return find (src.name ());
+}
+\f
+// dwarf::line_table
+
+size_t
+dwarf::line_table::size () const
+{
+ return _m_lines->nlines;
+}
+
+const dwarf::line_entry
+dwarf::line_table::at (size_t idx) const
+{
+ if (unlikely (idx >= _m_lines->nlines))
+ throw std::out_of_range ("XXX line table index");
+
+ return line_entry (reinterpret_cast<Dwarf_Line *> (&_m_lines->info[idx]));
+}
+
+dwarf::line_table::const_iterator
+dwarf::line_table::find (Dwarf_Addr address) const
+{
+ size_t idx = _m_lines->nlines; // end ()
+ if (likely (idx > 0))
+ {
+ CUDIE (cudie, _m_lines->info[0].files->cu);
+ Dwarf_Line *line = dwarf_getsrc_die (&cudie, address);
+ if (line != NULL)
+ idx = line - &_m_lines->info[0];
+ }
+ return const_iterator (*this, idx);
+}
+\f
+// dwarf::line_entry
+
+const dwarf::source_file
+dwarf::line_entry::file () const
+{
+ return dwarf::source_file (dummy_source_file (_m_line->files->cu,
+ _m_line->file));
+}
+
+#define LINEFIELD(type, method, field) \
+ type \
+ dwarf::line_entry::method () const \
+ { \
+ return _m_line->field; \
+ }
+
+LINEFIELD (Dwarf_Addr, address, addr) // XXX dwfl?
+LINEFIELD (unsigned int, line, line)
+LINEFIELD (unsigned int, column, column)
+LINEFIELD (bool, statement, is_stmt)
+LINEFIELD (bool, basic_block, basic_block)
+LINEFIELD (bool, end_sequence, end_sequence)
+LINEFIELD (bool, prologue_end, prologue_end)
+LINEFIELD (bool, epilogue_begin, epilogue_begin)
+
+#undef LINEFIELD
+
+bool
+dwarf::line_entry::operator== (const dwarf::line_entry &other) const
+{
+ Dwarf_Line *const a = _m_line;
+ Dwarf_Line *const b = other._m_line;
+
+ if (a == b)
+ return true;
+
+ if (a->addr != b->addr
+ || a->line != b->line
+ || a->column != b->column
+ || a->is_stmt != b->is_stmt
+ || a->basic_block != b->basic_block
+ || a->end_sequence != b->end_sequence
+ || a->prologue_end != b->prologue_end
+ || a->epilogue_begin != b->epilogue_begin)
+ return false;
+
+ // Everything else matches, now have to try the file.
+ if (a->files == b->files)
+ // Same table, just compare indices.
+ return a->file == b->file;
+
+ Dwarf_Word atime;
+ Dwarf_Word asize;
+ const char *aname = dwarf_linesrc (a, &atime, &asize);
+ xif (a->files->cu, aname == NULL);
+ Dwarf_Word btime;
+ Dwarf_Word bsize;
+ const char *bname = dwarf_linesrc (b, &btime, &bsize);
+ xif (b->files->cu, bname == NULL);
+
+ /* The mtime and size only count when encoded as nonzero.
+ If either side is zero, we don't consider the field. */
+
+ if (atime != btime && atime != 0 && btime != 0)
+ return false;
+
+ if (asize != bsize && asize != 0 && bsize != 0)
+ return false;
+
+ return !strcmp (aname, bname);
+}
+\f
+// dwarf::compile_unit convenience functions.
+
+const dwarf::line_info_table
+dwarf::compile_unit::line_info () const
+{
+ Dwarf_Lines *l;
+ size_t n;
+ xif (dwarf_getsrclines (thisdie (), &l, &n) < 0);
+
+ return line_info_table (thisdie ()->cu->files);
+}
--- /dev/null
+/* elfutils::dwarf_output attribute value interfaces.
+ Copyright (C) 2009 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include "dwarf_output"
+#include "data-values.hh"
+
+#include <typeinfo>
+
+using namespace elfutils;
+
+// Explicit instantiations.
+template class dwarf_data::value<dwarf_output, false>;
+template class dwarf_data::attr_value<dwarf_output, dwarf_output::value>;
+template class dwarf_data::attributes_type<dwarf_output, dwarf_output::value>;
+template class dwarf_data::compile_unit<dwarf_output>;
+template class dwarf_data::compile_units_type<dwarf_output>;
+
+template class dwarf_output::copier<dwarf>;
+template class dwarf_output::copier<dwarf_edit>;
+
+template<>
+std::string
+to_string<dwarf_output::attribute> (const dwarf_output::attribute &attr)
+{
+ return attribute_string (attr);
+}
+
+namespace elfutils
+{
+ template<>
+ std::string to_string (const dwarf_output::debug_info_entry &die)
+ {
+ return die_string (die);
+ }
+};
+
+const dwarf_output::value::value_flag dwarf_output_collector::flag_true (1);
+const dwarf_output::value::value_flag dwarf_output_collector::flag_false (0);
--- /dev/null
+/* Private helper classes for elfutils -*- C++ -*- interfaces.
+ Copyright (C) 2009-2011 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef _ELFUTILS_SUBR_HH
+#define _ELFUTILS_SUBR_HH 1
+
+#include <iterator>
+#include <functional>
+#include <cstring>
+#include <cassert>
+#include <iostream>
+#include <sstream>
+#include <tr1/unordered_map>
+#include <tr1/unordered_set>
+#include <vector>
+#include <deque>
+#include <stack>
+#include <set>
+#include <algorithm>
+#include <utility>
+#include <stdexcept>
+
+namespace elfutils
+{
+ namespace subr
+ {
+ template<typename container_type, typename op_type>
+ inline void for_each (container_type &container, op_type op)
+ {
+ std::for_each (container.begin (), container.end (), op);
+ }
+
+ template<typename T>
+ struct hash : public T::hasher {};
+
+ template<typename T>
+ static inline size_t hash_this (const T &v)
+ {
+ return hash<T> () (v);
+ }
+
+ template <typename T>
+ inline void hash_combine (size_t &seed, const T &v)
+ {
+ seed ^= hash_this (v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+ }
+
+ template <typename T1, typename T2>
+ inline void hash_combine (size_t &seed, const std::pair<T1,T2> &v)
+ {
+ hash_combine (seed, v.first);
+ hash_combine (seed, v.second);
+ }
+
+ template<typename T, typename B>
+ struct base_hasher : public std::unary_function<T, size_t>
+ {
+ size_t operator () (const T &v) const
+ {
+ return hash_this<B> (v);
+ }
+ };
+
+ template<typename T1, typename T2>
+ struct cast_hasher : public std::unary_function<T1, size_t>
+ {
+ inline size_t operator () (const T1 &x) const
+ {
+ return hash_this (static_cast<T2> (x));
+ }
+ };
+
+ template<typename T, T magic>
+ struct integer_hash : public std::unary_function<T, size_t>
+ {
+ inline size_t operator () (const T &x) const
+ {
+ return x * magic;
+ }
+ };
+ template<>
+ struct hash<unsigned int>
+ : public integer_hash<unsigned int, 0x9e370001U>
+ {};
+ template<>
+ struct hash<uint64_t>
+ : public integer_hash<uint64_t, 0x9e37fffffffc0001ULL>
+ {};
+
+ template<>
+ struct hash<int> : public cast_hasher<int, unsigned int> {};
+ template<>
+ struct hash<uint8_t> : public cast_hasher<uint8_t, unsigned int> {};
+ template<>
+ struct hash<bool> : public cast_hasher<bool, unsigned int> {};
+
+ template<typename T1, typename T2>
+ struct hash<std::pair<T1, T2> >
+ : public std::unary_function<std::pair<T1, T2>, size_t>
+ {
+ inline size_t operator () (const std::pair<T1, T2> &x) const
+ {
+ size_t h = 0;
+ hash_combine (h, x);
+ return h;
+ }
+ };
+
+ template<typename T,
+ void (*combiner) (size_t &, const typename T::value_type &)
+ = hash_combine<typename T::value_type>,
+ size_t initial_hash = 0>
+ class container_hasher
+ : public std::unary_function<T, size_t>
+ {
+ private:
+ struct hasher
+ {
+ size_t &_m_hash;
+ inline explicit hasher (size_t &hash) : _m_hash (hash) {}
+ inline void operator () (const typename T::value_type &x)
+ {
+ return (*combiner) (_m_hash, x);
+ }
+ };
+ public:
+ inline size_t operator () (const T &x) const
+ {
+ size_t hash = initial_hash;
+ for_each (x, hasher (hash));
+ return hash;
+ }
+ };
+
+ template<typename T>
+ struct hash<std::vector<T> >
+ : public container_hasher<std::vector<T> >
+ {
+ };
+
+ template<>
+ struct hash<std::string>
+ : public std::tr1::hash<std::string>
+ {
+ };
+
+ template<class T>
+ struct hashed_hasher
+ : public std::unary_function<T, size_t>
+ {
+ size_t operator () (const T &v) const
+ {
+ return v._m_hash;
+ }
+ };
+
+ template<typename string>
+ struct name_equal : public std::binary_function<const char *, string, bool>
+ {
+ template<typename mystring>
+ inline bool operator () (const mystring &me, const string &you) const
+ {
+ return you == me;
+ }
+ };
+
+ // Explicit specialization.
+ template<>
+ struct name_equal<const char *>
+ : public std::binary_function<const char *, const char *, bool>
+ {
+ bool operator () (const char *me, const char *you) const
+ {
+ return !strcmp (me, you);
+ }
+ template<typename mystring>
+ inline bool operator () (const mystring &me, const char *you) const
+ {
+ return me == you;
+ }
+ };
+
+ static inline std::string hex_string (int code)
+ {
+ std::ostringstream os;
+ os << std::hex << std::showbase << code;
+ return os.str ();
+ }
+
+ template<typename prefix_type, const char *lookup_known (int)>
+ struct known
+ {
+ // The names in the table are the identifiers, with prefix.
+ static inline std::string identifier (int code)
+ {
+ const char *known = lookup_known (code);
+ return known == NULL ? hex_string (code) : std::string (known);
+ }
+
+ // For the pretty name, skip over the prefix.
+ static inline std::string name (int code)
+ {
+ const char *known = lookup_known (code);
+ return (known == NULL ? hex_string (code)
+ : std::string (&known[sizeof (prefix_type) - 1]));
+ }
+ };
+
+ // This is like std::equal_to but for comparing two different types.
+ template<typename t1, typename t2>
+ struct equal_to : public std::binary_function<t1, t2, bool>
+ {
+ inline bool operator () (const t1 &a, const t2 &b) const
+ {
+ return a == b;
+ }
+ };
+
+ /* On a single type, our equal_to is like std::equal_to, but
+ we short-circuit for the case of matching pointers. */
+ template<typename T>
+ struct equal_to<T, T> : public std::binary_function<T, T, bool>
+ {
+ inline bool operator () (const T &a, const T &b) const
+ {
+ return &a == &b || a == b;
+ }
+ };
+
+ template<typename t1, typename t2, typename pred_type>
+ class deref
+ : public std::binary_function<typename t1::const_iterator,
+ typename t2::const_iterator,
+ bool>
+ {
+ private:
+ pred_type _m_pred;
+
+ public:
+ inline deref ()
+ : _m_pred ()
+ {}
+
+ inline deref (const pred_type &pred)
+ : _m_pred (pred)
+ {}
+
+ inline bool operator () (const typename t1::const_iterator &a,
+ const typename t2::const_iterator &b) const
+ {
+ return _m_pred (*a, *b);
+ }
+ };
+
+ template<typename t1, typename t2>
+ struct deref_equal_to
+ : public deref<t1, t2,
+ equal_to<typename t1::value_type, typename t2::value_type>
+ >
+ {};
+
+ template<typename iter1, typename iter2, typename pred_type>
+ inline bool container_equal (iter1 &first1, const iter1 &last1,
+ iter2 &first2, const iter2 &last2,
+ pred_type pred)
+ {
+ while (first1 != last1)
+ {
+ if (first2 == last2 || !pred (first1, first2))
+ return false;
+ ++first1;
+ ++first2;
+ }
+ return first2 == last2;
+ }
+
+ template<typename t1, typename t2, typename pred_type>
+ inline bool container_equal (const t1 &a, const t2 &b, pred_type pred,
+ typename t1::size_type skip = 0)
+ {
+ typename t1::const_iterator first1 = a.begin ();
+ typename t1::const_iterator last1 = a.end ();
+ typename t2::const_iterator first2 = b.begin ();
+ typename t2::const_iterator last2 = b.end ();
+ while (skip-- > 0)
+ {
+ if (first1 == last1)
+ return first2 == last2;
+ if (first2 == last2)
+ return first1 == last1;
+ ++first1;
+ ++first2;
+ }
+ return container_equal (first1, last1, first2, last2, pred);
+ }
+
+ template<typename t1, typename t2>
+ inline bool container_equal (const t1 &a, const t2 &b)
+ {
+ return container_equal (a, b, deref_equal_to<t1, t2> ());
+ }
+
+ template<typename t1, typename t2>
+ inline bool container_tail_equal (const t1 &a, const t2 &b,
+ typename t1::size_type skip = 0)
+ {
+ return container_equal (a, b, deref_equal_to<t1, t2> (), skip);
+ }
+
+ template<typename iter>
+ inline typename iter::difference_type length (iter i, const iter &end)
+ {
+ typename iter::difference_type n = 0;
+ while (i != end)
+ ++i, ++n;
+ return n;
+ }
+
+ template<typename array, typename element = typename array::value_type>
+ class indexed_iterator
+ : public std::iterator<std::random_access_iterator_tag,
+ typename array::value_type,
+ typename array::difference_type>
+ {
+ private:
+ typedef typename array::size_type index_type;
+
+ array _m_contents;
+ index_type _m_idx;
+
+ public:
+ indexed_iterator (array contents, index_type idx)
+ : _m_contents (contents), _m_idx (idx) {}
+ indexed_iterator (const indexed_iterator &i)
+ : _m_contents (i._m_contents), _m_idx (i._m_idx) {}
+
+ inline element operator* () const
+ {
+ return _m_contents[_m_idx];
+ }
+ template<typename elt>
+ inline elt operator* () const
+ {
+ return _m_contents[_m_idx];
+ }
+ template<typename elt>
+ inline elt *operator-> () const
+ {
+ return &_m_contents[_m_idx];
+ }
+ template<typename elt>
+ inline elt operator[] (const index_type &n) const
+ {
+ return _m_contents[_m_idx + n];
+ }
+
+ inline indexed_iterator operator+ (const indexed_iterator &i) const
+ {
+ return indexed_iterator (_m_contents, _m_idx + i._m_idx);
+ }
+ inline indexed_iterator operator+ (const typename array::difference_type
+ &i) const
+ {
+ return indexed_iterator (_m_contents, _m_idx + i);
+ }
+ inline typename array::difference_type
+ operator- (const indexed_iterator &i) const
+ {
+ return _m_idx - i._m_idx;
+ }
+
+ inline bool operator== (const indexed_iterator &i) const
+ {
+ return _m_idx == i._m_idx;
+ }
+ inline bool operator!= (const indexed_iterator &i) const
+ {
+ return _m_idx != i._m_idx;
+ }
+ inline bool operator< (const indexed_iterator &i) const
+ {
+ return _m_idx < i._m_idx;
+ }
+ inline bool operator> (const indexed_iterator &i) const
+ {
+ return _m_idx > i._m_idx;
+ }
+ inline bool operator<= (const indexed_iterator &i) const
+ {
+ return _m_idx <= i._m_idx;
+ }
+ inline bool operator>= (const indexed_iterator &i) const
+ {
+ return _m_idx >= i._m_idx;
+ }
+
+ inline indexed_iterator &operator= (const indexed_iterator &i)
+ {
+ _m_idx = i._m_idx;
+ return *this;
+ }
+ inline indexed_iterator &operator+= (const index_type &n)
+ {
+ _m_idx += n;
+ return *this;
+ }
+ inline indexed_iterator &operator-= (const index_type &n)
+ {
+ _m_idx -= n;
+ return *this;
+ }
+
+ inline indexed_iterator &operator++ () // prefix
+ {
+ ++_m_idx;
+ return *this;
+ }
+ inline indexed_iterator operator++ (int) // postfix
+ {
+ return indexed_iterator (_m_contents, _m_idx++);
+ }
+ inline indexed_iterator &operator-- () // prefix
+ {
+ --_m_idx;
+ return *this;
+ }
+ inline indexed_iterator operator-- (int) // postfix
+ {
+ return indexed_iterator (_m_contents, _m_idx--);
+ }
+ };
+
+ // Pair of some value and its precomputed hash.
+ template<typename T>
+ class hashed_value
+ : public std::pair<size_t, const T>
+ {
+ private:
+ typedef std::pair<size_t, const T> _base;
+
+ public:
+ typedef T value_type;
+
+ struct hasher
+ : public std::unary_function<hashed_value, size_t>
+ {
+ inline size_t operator () (const hashed_value &v) const
+ {
+ return v.first;
+ }
+ };
+
+ hashed_value (const value_type &v)
+ : _base (hash_this (v), v) {}
+ hashed_value (const hashed_value &v)
+ : _base (v.first, v.second) {}
+
+ bool operator== (const hashed_value &other) const
+ {
+ return other.first == this->first && other.second == this->second;
+ }
+ };
+
+ // Set of hashed_value's.
+ template<typename value_type>
+ class value_set
+ : public std::tr1::unordered_set<hashed_value<value_type>,
+ struct hashed_value<value_type>::hasher>
+ {
+ public:
+ typedef hashed_value<value_type> hashed_value_type;
+
+ private:
+ typedef std::tr1::unordered_set<hashed_value_type,
+ struct hashed_value_type::hasher> _base;
+
+ public:
+ const value_type *add (const value_type &v)
+ {
+ std::pair<class _base::iterator, bool> p
+ = _base::insert (hashed_value_type (v));
+ if (p.second)
+ {
+ // XXX hook for collection: abbrev building, etc.
+ }
+ return &p.first->second;
+ };
+
+ template<typename input>
+ const value_type *add (const input &v)
+ {
+ return add (value_type (v));
+ }
+
+ template<typename input, typename arg_type>
+ const value_type *add (const input &v, arg_type &arg)
+ {
+ return add (value_type (v, arg));
+ }
+ };
+
+ // A container of hashed_value's that itself acts like a hashed_value.
+ // The parameter class should be a std::container<hashed_value<something>>.
+ template<typename container>
+ class hashed_container : public container
+ {
+ private:
+ typedef container _base;
+ typedef typename container::value_type elt_type;
+
+ public:
+ typedef typename elt_type::value_type value_type;
+
+ protected:
+ size_t _m_hash;
+
+ inline void set_hash ()
+ {
+ _m_hash = container_hasher<container> () (*this);
+ }
+
+ public:
+ friend class hashed_hasher<hashed_container>;
+ typedef hashed_hasher<hashed_container> hasher;
+
+ template<typename iterator>
+ hashed_container (iterator first, iterator last)
+ : _base (first, last)
+ {
+ set_hash ();
+ }
+
+ template<typename other_container>
+ hashed_container (const other_container &other)
+ : _base (other.begin (), other.end ())
+ {
+ set_hash ();
+ }
+
+ bool operator== (const hashed_container &other) const
+ {
+ return (other._m_hash == _m_hash &&
+ other.size () == _base::size ()
+ && std::equal (_base::begin (), _base::end (), other.begin (),
+ equal_to<elt_type, elt_type> ()));
+ }
+ };
+
+ // A vector of hashed_value's that itself acts like a hashed_value.
+ template<typename value_type>
+ struct hashed_vector
+ : public hashed_container<std::vector<hashed_value<value_type> > >
+ {};
+
+ // An unordered_map of hashed_value's that itself acts like a hashed_value.
+ template<typename key_type, typename value_type>
+ class hashed_unordered_map
+ : public hashed_container<std::tr1::unordered_map<
+ key_type,
+ hashed_value<value_type>,
+ class hashed_value<value_type>::hasher>
+ >
+ {};
+#if 0
+ template<typename key_type, typename value_type>
+ class hashed_unordered_map
+ : public std::tr1::unordered_map<key_type,
+ hashed_value<value_type>,
+ class hashed_value<value_type>::hasher>
+ {
+ private:
+ typedef std::tr1::unordered_map<key_type,
+ hashed_value<value_type>,
+ class hashed_value<value_type>::hasher>
+ _base;
+
+ size_t _m_hash;
+
+ inline void set_hash ()
+ {
+ struct hashit
+ {
+ size_t &_m_hash;
+ hashit (size_t &h) : _m_hash (h) {}
+
+ inline void operator () (const typename _base::value_type &p)
+ {
+ hash_combine (_m_hash, hash_this (p.first));
+ hash_combine (_m_hash, p.second.first);
+ }
+ };
+ for_each (static_cast<_base &> (*this), hashit (_m_hash));
+ }
+
+ public:
+ friend class hashed_hasher<hashed_unordered_map>;
+ typedef hashed_hasher<hashed_unordered_map> hasher;
+
+ template<typename iterator>
+ hashed_unordered_map (iterator first, iterator last)
+ : _base (first, last), _m_hash (0)
+ {
+ set_hash ();
+ }
+
+ template<typename container>
+ hashed_unordered_map (const container &other)
+ : _base (other.begin (), other.end ()), _m_hash (0)
+ {
+ set_hash ();
+ }
+ };
+#endif
+
+ template<typename T>
+ class auto_ref
+ {
+ private:
+ T *_m_ptr;
+
+ public:
+ auto_ref (const T &other)
+ : _m_ptr (&other)
+ {}
+
+ inline operator T& () const
+ {
+ return *_m_ptr;
+ }
+
+ auto_ref (const auto_ref<T> &other)
+ : _m_ptr (other._m_ptr)
+ {}
+
+ template<typename other>
+ inline bool operator== (const auto_ref<other> &x) const
+ {
+ return *_m_ptr == static_cast<other &> (x);
+ }
+ template<typename other>
+ inline bool operator== (const other &x) const
+ {
+ return *_m_ptr == x;
+ }
+ template<typename other>
+ inline bool operator!= (const other &x) const
+ {
+ return !(*this == x);
+ }
+ };
+
+ /* A wrapped_input_iterator is like an input::const_iterator,
+ but *i returns wrapper (*i) instead; wrapper returns element
+ (or const element & or something). */
+ template<typename input, class wrapper,
+ typename element = typename wrapper::result_type>
+ class wrapped_input_iterator : public input::const_iterator
+ {
+ private:
+ typedef typename input::const_iterator _base;
+
+ wrapper _m_wrapper;
+
+ public:
+ typedef element value_type;
+
+ inline wrapped_input_iterator ()
+ : _base ()
+ {}
+
+ template<typename arg_type>
+ inline wrapped_input_iterator (const _base &i, const arg_type &arg)
+ : _base (static_cast<_base> (i)), _m_wrapper (arg)
+ {}
+
+ inline wrapped_input_iterator (const wrapped_input_iterator &i)
+ : _base (static_cast<_base> (i)), _m_wrapper (i._m_wrapper)
+ {}
+
+ inline typename wrapper::result_type operator* () const
+ {
+ return _m_wrapper (_base::operator* ());
+ }
+
+ inline element *operator-> () const
+ {
+ return &(_m_wrapper (_base::operator* ()));
+ }
+
+ inline wrapped_input_iterator &operator++ () // prefix
+ {
+ _base::operator++ ();
+ return *this;
+ }
+ inline wrapped_input_iterator operator++ (int) // postfix
+ {
+ wrapped_input_iterator pre = *this;
+ ++*this;
+ return pre;
+ }
+ inline wrapped_input_iterator &operator-- () // prefix
+ {
+ _base::operator-- ();
+ return *this;
+ }
+ inline wrapped_input_iterator operator-- (int) // postfix
+ {
+ wrapped_input_iterator pre = *this;
+ --*this;
+ return pre;
+ }
+
+ inline const _base &base () const
+ {
+ return *this;
+ }
+
+ inline _base &base ()
+ {
+ return *this;
+ }
+
+ template<typename container = input>
+ struct copy
+ {
+ template<typename arg_type>
+ inline container operator () (const input &in,
+ const arg_type &arg = arg_type ())
+ {
+ return container (wrapped_input_iterator (in.begin (), arg),
+ wrapped_input_iterator (in.end (), arg));
+ }
+ };
+ };
+
+ /* A wrapped_input_container provides begin and end methods that
+ wrap the real container's iterators with wrapped_input_iterator. */
+ template<typename input, class wrapper,
+ typename element = typename wrapper::result_type>
+ class wrapped_input_container
+ {
+ private:
+ const input &_m_container;
+ wrapper _m_wrapper;
+
+ public:
+ typedef wrapped_input_iterator<input, wrapper, element> const_iterator;
+ typedef const_iterator iterator;
+
+ template<typename arg_type>
+ inline wrapped_input_container (const input &container,
+ const arg_type &arg)
+ : _m_container (container), _m_wrapper (arg)
+ {}
+
+ inline const_iterator begin () const
+ {
+ return const_iterator (_m_container.begin (), _m_wrapper);
+ }
+
+ inline const_iterator end () const
+ {
+ return const_iterator (_m_container.end (), _m_wrapper);
+ }
+
+ static inline bool ordered ()
+ {
+ return input::ordered ();
+ }
+ };
+
+ /* An iterator adapter for use in iterator-based constructors.
+ collectify (iterator) yields an iterator on input where *i
+ constructs output::value_type (input::value_type v, collector). */
+ template<typename input, typename output, typename arg_type>
+ struct argifier
+ : public std::unary_function<typename input::const_iterator,
+ typename output::iterator> // not really
+ {
+ typedef typename input::const_iterator inny;
+ typedef typename output::iterator outty;
+ typedef typename input::value_type inlet;
+ typedef typename output::value_type outlet;
+
+ /* Wrapper worker passed to wrapped_input_iterator.
+ This object holds the collector pointer. */
+ struct maker
+ : public std::unary_function<inlet, outlet>
+ {
+ const arg_type _m_arg;
+
+ inline maker (const arg_type &c)
+ : _m_arg (c)
+ {}
+
+ inline maker (const maker &m)
+ : _m_arg (m._m_arg)
+ {}
+
+ inline outlet operator () (const inlet &x) const
+ {
+ return outlet (x, _m_arg);
+ }
+ } _m_maker;
+
+ explicit inline argifier (const arg_type &c)
+ : _m_maker (c)
+ {}
+
+ typedef wrapped_input_iterator<input, maker> result_type;
+
+ inline result_type operator () (const inny &i)
+ {
+ return result_type (i, _m_maker);
+ }
+ };
+
+ template<typename input, typename output, typename arg_type>
+ static inline typename argifier<input, output, arg_type>::result_type
+ argify (const typename input::const_iterator &in, const arg_type &arg)
+ {
+ return argifier<input, output, arg_type> (arg) (in);
+ }
+
+ template<typename input, typename output, typename arg_type>
+ struct argifier2nd
+ : public std::unary_function<typename input::const_iterator,
+ typename output::iterator>
+ {
+ typedef typename input::const_iterator inny;
+ typedef typename output::iterator outty;
+ typedef typename input::value_type inlet;
+ typedef typename output::value_type outlet;
+
+ /* Wrapper worker passed to wrapped_input_iterator.
+ This object holds the collector pointer. */
+ struct pair_maker
+ : public argifier<input, output, arg_type>::maker
+ {
+ typedef typename argifier<input, output, arg_type>::maker maker;
+
+ inline pair_maker (const arg_type &c) : maker (c) {}
+ inline pair_maker (const pair_maker &m) : maker (m) {}
+
+ inline outlet operator () (const inlet &x) const
+ {
+ return std::make_pair (x.first,
+ typename outlet::second_type (x.second,
+ this->_m_arg));
+ }
+ } _m_maker;
+
+ explicit inline argifier2nd (const arg_type &c)
+ : _m_maker (c)
+ {}
+
+ typedef wrapped_input_iterator<input, pair_maker> const_iterator;
+
+ inline const_iterator operator () (const inny &i)
+ {
+ return const_iterator (i, _m_maker);
+ }
+ };
+
+ template<typename input, typename output, typename arg_type>
+ static inline typename argifier2nd<input, output, arg_type>::const_iterator
+ argify2nd (const typename input::const_iterator &in, const arg_type &arg)
+ {
+ return argifier2nd<input, output, arg_type> (arg) (in);
+ }
+
+ /* A guard object is intended to be ephemeral, existing solely to be
+ destroyed in exception paths where it was not cleared explicitly.
+ In that case, it calls tracker::soiled ().
+
+ For convenience, it can be constructed from a tracker reference or
+ pointer, or default-constructed and then filled. It's fillable by
+ calling the guard object as a function, passing it the tracker
+ reference or pointer, which it passes through on return:
+
+ guard<tracker> g;
+ use (g (t));
+ g.clear ();
+
+ This first calls T.start (). When G goes out of scope,
+ it calls T.abort () iff G.clear () was never called. */
+
+ template<typename tracker>
+ class guard
+ {
+ private:
+ tracker *_m_tracker;
+
+ inline void start ()
+ {
+ _m_tracker->start ();
+ }
+
+ public:
+ inline guard (tracker *t)
+ : _m_tracker (t)
+ {
+ start ();
+ }
+
+ inline guard (tracker &t)
+ : _m_tracker (&t)
+ {
+ start ();
+ }
+
+ inline guard ()
+ : _m_tracker (NULL)
+ {}
+
+ inline tracker *operator () (tracker *t)
+ {
+ _m_tracker = t;
+ start ();
+ return t;
+ }
+
+ inline tracker &operator () (tracker &t)
+ {
+ _m_tracker = &t;
+ start ();
+ return t;
+ }
+
+ inline operator tracker * () const
+ {
+ return _m_tracker;
+ }
+
+ inline operator tracker & () const
+ {
+ return *_m_tracker;
+ }
+
+ inline void clear ()
+ {
+ _m_tracker = NULL;
+ }
+
+ inline ~guard ()
+ {
+ if (unlikely (_m_tracker != NULL))
+ _m_tracker->abort ();
+ }
+ };
+
+ struct nothing
+ {
+ };
+
+ // Class instead of function so it can be a friend.
+ struct create_container
+ {
+ struct setter
+ {
+ template<typename in_iter, typename out_iter, typename arg_type>
+ inline void operator () (const out_iter &out, const in_iter &in,
+ bool, arg_type arg) const
+ {
+ out->set (*in, arg);
+ }
+ };
+
+ template<typename container, typename input, typename arg_type,
+ typename hook_type = const setter>
+ inline create_container (container *me, const input &other,
+ arg_type &arg, hook_type &hook = hook_type ())
+ {
+ typename input::const_iterator in = other.begin ();
+ bool last = in == other.end ();
+ while (!last)
+ {
+ /* Don't copy-construct the entry from *in here because that
+ copies it again into the list and destroys the first copy. */
+ me->push_back (typename container::value_type ());
+ typename container::iterator out = --me->end ();
+ const typename input::const_iterator here = in++;
+ last = in == other.end ();
+ hook (out, here, last, arg);
+ }
+ }
+ };
+
+ template<typename T>
+ struct is : public std::equal_to<T>
+ {
+ bool operator () (const T &a, const T &b) const
+ {
+ return a.is (b);
+ }
+ };
+
+ template<typename T>
+ struct is<T *> : public std::equal_to<T *>
+ {
+ bool operator () (const T *a, const T *b) const
+ {
+ return a == b || a->is (*b);
+ }
+ };
+
+#if 0 // unused
+ template<typename T1, typename T2>
+ struct is<std::pair<T1, T2> > : public std::equal_to<std::pair<T1, T2> >
+ {
+ bool operator () (const std::pair<T1, T2> &a,
+ const std::pair<T1, T2> &b) const
+ {
+ return (is<T1> () (a.first, b.first)
+ && is<T2> () (a.second, b.second));
+ }
+ };
+#endif
+
+ template<typename T>
+ struct identity_set
+ : public std::tr1::unordered_set<T, typename T::hasher, is<T> >
+ {
+ };
+
+ template<typename key_type, typename mapped_type>
+ struct identity_map
+ : public std::tr1::unordered_map<key_type, mapped_type,
+ typename key_type::hasher,
+ is<key_type> >
+ {};
+
+ /* This is like an unordered_set, but the equality predicate cannot
+ be fixed statically. Instead, each insertion call must pass in
+ the specific predicate to match against existing elements for
+ that insertion. */
+ template<typename T, typename hasher_type = hash<T> >
+ class dynamic_equality_set
+ {
+ public:
+ typedef T value_type;
+ typedef size_t hash_type;
+ typedef std::deque<T> bucket_type;
+
+ private:
+ typedef std::tr1::unordered_map<hash_type, bucket_type> map_type;
+
+ map_type _m_map;
+ hasher_type _m_hasher;
+
+ public:
+ template<typename match_type>
+ inline const value_type *
+ add (const value_type &candidate, match_type &match)
+ {
+ bucket_type &bucket = _m_map[_m_hasher (candidate)];
+
+ for (typename bucket_type::iterator i = bucket.begin ();
+ i != bucket.end ();
+ ++i)
+ {
+ const value_type &elt = *i;
+ if (match (elt, candidate))
+ // We have a winner!
+ return &elt;
+ }
+
+ // No matches: new element.
+ bucket.push_back (candidate);
+ return &(bucket.back ());
+ }
+
+ // Unclear why you didn't just use a normal identity_set then!
+ inline const value_type *add (const value_type &candidate)
+ {
+ is<value_type> equalator;
+ return add (candidate, equalator);
+ }
+
+ template<typename reporter>
+ inline void hash_stats (std::ostream &out, const char *name,
+ const reporter &report_collisions) const
+ {
+ size_t collisions = 0;
+ size_t empty_buckets = 0;
+ size_t total = 0;
+ size_t largest = 0;
+ for (typename map_type::const_iterator i = _m_map.begin ();
+ i != _m_map.end ();
+ ++i)
+ {
+ if (i->second.empty ())
+ ++empty_buckets;
+ else
+ {
+ size_t n = i->second.size () - 1;
+ collisions += n;
+ if (n > 0)
+ report_collisions (i->first, i->second);
+ }
+ if (i->second.size () > largest)
+ largest = i->second.size ();
+ total += i->second.size ();
+ }
+ out << name << ": " << total << ", "
+ << collisions << " collisions, "
+ << largest << " in largest bucket";
+ if (empty_buckets > 0)
+ out << ", " << empty_buckets << " empty buckets\n";
+ else
+ out << "\n";
+ }
+ };
+
+ template<typename set_type>
+ inline void container_hash_stats (std::ostream &out, const char *name,
+ const set_type &set)
+ {
+ std::set<size_t> hashes;
+ for (typename set_type::const_iterator i = set.begin ();
+ i != set.end ();
+ ++i)
+ hashes.insert (hash_this (*i));
+ out << name << ": " << set.size () << ", "
+ << hashes.size () << " hashes = "
+ << (set.size () - hashes.size ()) << " collisions\n";
+ }
+
+ /* sharing_stack<T> is like std::stack<T>, but copies share list
+ tails to reduce the memory footprint. Any non-const call to the
+ top method copies the top element so it's no longer shared.
+ So be sure to use const calls for any non-modifying access.
+ The top_const method is a short-hand for a const access to
+ a non-const container. */
+ template<typename T>
+ class sharing_stack
+ {
+ public:
+ typedef T value_type;
+ typedef size_t size_type;
+ typedef value_type &reference;
+ typedef const value_type &const_reference;
+
+ protected:
+ class element
+ {
+ private:
+ friend class sharing_stack;
+ value_type _m_value;
+ element *_m_next;
+ unsigned int _m_count;
+
+ inline element &operator= (const element &)
+ {
+ throw std::logic_error ("cannot assign");
+ }
+
+ inline element ()
+ {
+ throw std::logic_error ("cannot default-construct");
+ }
+
+ public:
+ inline unsigned int count () const
+ {
+ return _m_count;
+ }
+
+ inline operator value_type & ()
+ {
+ return _m_value;
+ }
+
+ inline operator const value_type & () const
+ {
+ return _m_value;
+ }
+
+ inline element (const value_type &value, element *tail)
+ : _m_value (value), _m_next (tail), _m_count (1)
+ {
+ if (_m_next != NULL)
+ _m_next->acquire ();
+ }
+
+ inline element (const element &other)
+ : _m_value (other._m_value), _m_next (other._m_next), _m_count (1)
+ {
+ if (_m_next != NULL)
+ _m_next->acquire ();
+ }
+
+ inline ~element ()
+ {
+ if (_m_next != NULL)
+ _m_next->release ();
+ }
+
+ inline void acquire ()
+ {
+ assert (_m_count > 0);
+ ++_m_count;
+ }
+
+ inline void release ()
+ {
+ assert (_m_count > 0);
+ if (--_m_count == 0)
+ delete this;
+ }
+
+ inline const element *next () const
+ {
+ return _m_next;
+ }
+
+ inline bool shared () const
+ {
+ assert (_m_count > 0);
+ return _m_count > 1;
+ }
+ };
+
+ element *_m_head;
+ size_type _m_size;
+
+ inline void init (element *head, size_type n)
+ {
+ if (head == NULL)
+ assert (n == 0);
+ else
+ head->acquire ();
+ _m_head = head;
+ _m_size = n;
+ }
+
+ public:
+ inline void clear ()
+ {
+ if (_m_head == NULL)
+ assert (_m_size == 0);
+ else
+ {
+ _m_head->release ();
+ _m_head = NULL;
+ _m_size = 0;
+ }
+ }
+
+ inline bool empty () const
+ {
+ return _m_head == NULL;
+ }
+
+ inline size_type size () const
+ {
+ return _m_size;
+ }
+
+ inline void push (const value_type &value)
+ {
+ element *old = _m_head;
+ _m_head = new element (value, _m_head);
+ ++_m_size;
+ if (old != NULL)
+ old->release ();
+ }
+
+ inline void pop ()
+ {
+ --_m_size;
+ element *tail = _m_head->_m_next;
+ if (tail != NULL)
+ tail->acquire ();
+ _m_head->release ();
+ _m_head = tail;
+ }
+
+ inline const value_type &top () const
+ {
+ assert (_m_head != NULL);
+ return *_m_head;
+ }
+
+ inline const value_type &const_top () const
+ {
+ return top ();
+ }
+
+ inline value_type &top ()
+ {
+ element *prev = _m_head;
+ if (prev->shared ())
+ {
+ _m_head = new element (*prev);
+ prev->release ();
+ }
+ assert (!_m_head->shared ());
+ return *_m_head;
+ }
+
+ inline sharing_stack ()
+ : _m_head (NULL), _m_size (0)
+ {}
+
+ inline sharing_stack (const sharing_stack &other)
+ {
+ init (other._m_head, other._m_size);
+ }
+
+ inline ~sharing_stack ()
+ {
+ clear ();
+ }
+
+ inline sharing_stack &operator= (const sharing_stack &other)
+ {
+ if (&other != this)
+ {
+ clear ();
+ init (other._m_head, other._m_size);
+ }
+ return *this;
+ }
+
+ inline void swap (sharing_stack &other)
+ {
+ std::swap (_m_head, other._m_head);
+ std::swap (_m_size, other._m_size);
+ }
+
+ class const_reverse_iterator
+ : public std::iterator<std::input_iterator_tag, value_type>
+ {
+ private:
+ const element *_m_elt;
+
+ friend class sharing_stack;
+ inline const_reverse_iterator (const element *elt)
+ : _m_elt (elt)
+ {}
+
+ public:
+ inline const value_type &operator* () const
+ {
+ return *_m_elt;
+ }
+
+ inline bool operator== (const const_reverse_iterator &other) const
+ {
+ return _m_elt == other._m_elt;
+ }
+ inline bool operator!= (const const_reverse_iterator &other) const
+ {
+ return !(*this == other);
+ }
+
+ inline const_reverse_iterator &operator++ () // prefix
+ {
+ _m_elt = _m_elt->next ();
+ return *this;
+ }
+ inline const_reverse_iterator operator++ (int) // postfix
+ {
+ const const_reverse_iterator old = *this;
+ ++*this;
+ return old;
+ }
+ };
+
+ inline const_reverse_iterator rbegin () const
+ {
+ return const_reverse_iterator (_m_head);
+ }
+
+ inline const_reverse_iterator rend () const
+ {
+ return const_reverse_iterator (NULL);
+ }
+
+ template<typename other_value_type, typename pred_type>
+ inline bool equal (const sharing_stack<other_value_type> &other,
+ pred_type &pred, size_type skip = 0) const
+ {
+ if (other.size () != size ())
+ return false;
+
+ const_reverse_iterator a = rbegin ();
+ typename sharing_stack<other_value_type>::const_reverse_iterator b
+ = other.rbegin ();
+
+ std::advance (a, skip);
+ std::advance (b, skip);
+
+ return std::equal (a, rend (), b, pred);
+ }
+
+ template<typename other_value_type>
+ inline bool operator== (const sharing_stack<other_value_type> &other)
+ const
+ {
+ equal_to<value_type, other_value_type> equalator;
+ return equal (other, equalator);
+ }
+
+ template<typename other_value_type>
+ inline bool operator!= (const sharing_stack<other_value_type> &other)
+ const
+ {
+ return !(*this == other);
+ }
+ };
+
+ // Compatible with sharing_stack, but actually a std::stack.
+ template<typename T, typename container_type = std::deque<T> >
+ struct stackish
+ : public std::stack<T, container_type>
+ {
+ inline const T &const_top () const
+ {
+ return this->top ();
+ }
+
+ inline void clear ()
+ {
+ this->c.clear ();
+ }
+
+ typedef typename container_type::const_reverse_iterator
+ const_reverse_iterator;
+
+ inline const_reverse_iterator rbegin () const
+ {
+ return this->c.rbegin ();
+ }
+
+ inline const_reverse_iterator rend () const
+ {
+ return this->c.rend ();
+ }
+
+ template<typename other_value_type, typename other_container_type,
+ typename pred_type>
+ inline bool
+ equal (const stackish<other_value_type, other_container_type> &other,
+ pred_type &pred, typename container_type::size_type skip = 0) const
+ {
+ if (other.size () != this->size ())
+ return false;
+
+ typename container_type::const_reverse_iterator a = this->rbegin ();
+ typename other_container_type::const_reverse_iterator b
+ = other.rbegin ();
+
+ std::advance (a, skip);
+ std::advance (b, skip);
+
+ return std::equal (a, this->rend (), b, pred);
+ }
+ };
+
+ /* This is a dummy you can template/syntactically use in
+ place of std::cout et al for disabled debugging spew. */
+ struct nostream
+ {
+ inline const nostream &
+ operator<< (std::ostream &(*) (std::ostream &)) const
+ {
+ return *this;
+ }
+
+ template<typename arg>
+ inline const nostream &
+ operator<< (const arg &) const
+ {
+ return *this;
+ }
+ };
+ };
+};
+
+#endif // <elfutils/subr.hh>
--- /dev/null
+/* -*- C++ -*- interfaces for libdw.
+ Copyright (C) 2009-2011 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils 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 copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <cassert>
+#include "dwarf"
+#include "dwarf_edit"
+#include "dwarf_output"
+#include "data-values.hh"
+
+extern "C"
+{
+#include "libdwP.h"
+}
+
+using namespace elfutils;
+using namespace std;
+
+#include "dwarf-knowledge.cc"
+\f
+// dwarf::attr_value disambiguation and dispatch.
+
+/* For ambiguous the forms, we need to look up the expected
+ value spaces for this attribute to disambiguate.
+*/
+dwarf::value_space
+dwarf::attr_value::what_space () const
+{
+ const uint_fast16_t version = _m_attr.cu->version;
+ unsigned int expected = expected_value_space (dwarf_whatattr (thisattr ()),
+ _m_tag);
+ unsigned int possible = 0;
+ switch (dwarf_whatform (thisattr ()))
+ {
+ case DW_FORM_flag:
+ case DW_FORM_flag_present:
+ return VS_flag;
+
+ case DW_FORM_addr:
+ return VS_address;
+
+ case DW_FORM_block:
+ case DW_FORM_block1:
+ case DW_FORM_block2:
+ case DW_FORM_block4:
+ /* Location expression in DWARF 3, or target constant. */
+ possible = VS(constant);
+ if (version >= 4)
+ break;
+ possible |= VS(location);
+ if ((expected & possible) != possible)
+ /* When both are expected, a block is a location expression. */
+ break;
+ /* Fall through. */
+
+ case DW_FORM_exprloc:
+ return VS_location;
+
+ case DW_FORM_data1:
+ case DW_FORM_data2:
+ case DW_FORM_udata:
+ case DW_FORM_sdata:
+ /* Target constant, known DWARF constant. */
+ possible = (VS(dwarf_constant) | VS(constant)
+ | VS(source_file) | VS(source_line) | VS(source_column));
+ break;
+
+ case DW_FORM_data4:
+ case DW_FORM_data8:
+ // If a constant is not expected, these can be *ptr instead in DWARF 3.
+ possible = (VS(dwarf_constant) | VS(constant)
+ | VS(source_file) | VS(source_line) | VS(source_column));
+ if (version >= 4 || (expected & possible))
+ break;
+
+ case DW_FORM_sec_offset:
+ possible = VS(location) | VS(lineptr) | VS(macptr) | VS(rangelistptr);
+ break;
+
+ case DW_FORM_string:
+ case DW_FORM_strp:
+ /* Identifier, file name, or string. */
+ possible = VS(identifier) | VS(source_file) | VS(string);
+ break;
+
+ case DW_FORM_ref_addr:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref_sig8:
+ return VS_reference;
+
+ default:
+ throw std::runtime_error ("XXX bad form");
+ }
+
+ if (unlikely ((expected & possible) == 0))
+ {
+ // Otherwise we don't know enough to treat it robustly.
+ throw std::runtime_error ("XXX ambiguous form in unexpected attribute");
+ }
+
+ const int first = ffs (expected & possible) - 1;
+ if (likely ((expected & possible) == (1U << first)))
+ return static_cast<value_space> (first);
+
+ throw std::runtime_error ("XXX ambiguous form");
+}
+
+static string
+hex_string (Dwarf_Word value, const char *before = "", const char *after = "")
+{
+ std::ostringstream os;
+ os << std::hex << std::showbase << before << value << after;
+ return os.str ();
+}
+
+static string
+dec_string (Dwarf_Word value, const char *before = "", const char *after = "")
+{
+ std::ostringstream os;
+ os << before << value << after;
+ return os.str ();
+}
+
+static string
+addr_string (Dwarf_Addr value)
+{
+ // XXX some hook for symbol resolver??
+ return hex_string (value);
+}
+
+static inline string
+plain_string (const char *filename)
+{
+ return string ("\"") + filename + "\"";
+}
+
+static inline string
+plain_string (const string &filename)
+{
+ return "\"" + filename + "\"";
+}
+
+template<class value_type>
+static inline string
+value_string (const value_type &value)
+{
+ switch (value.what_space ())
+ {
+ case dwarf::VS_flag:
+ return value.flag () ? "1" : "0";
+
+ case dwarf::VS_rangelistptr:
+ return value.ranges ().to_string ();
+
+ case dwarf::VS_lineptr:
+ return value.line_info ().to_string ();
+
+ case dwarf::VS_macptr: // XXX punt for now, treat as constant
+ case dwarf::VS_constant:
+ if (value.constant_is_integer ())
+ return hex_string (value.constant ());
+ return dec_string (value.constant_block ().size (),
+ "{block of ", " bytes}");
+
+ case dwarf::VS_dwarf_constant:
+ return value.dwarf_constant ().to_string ();
+
+ case dwarf::VS_source_line:
+ return dec_string (value.source_line ());
+
+ case dwarf::VS_source_column:
+ return dec_string (value.source_column ());
+
+ case dwarf::VS_identifier:
+ return plain_string (value.identifier ());
+
+ case dwarf::VS_string:
+ return plain_string (value.string ());
+
+ case dwarf::VS_address:
+ return addr_string (value.address ());
+
+ case dwarf::VS_reference:
+ return hex_string (value.reference ()->offset (), "[", "]");
+
+ case dwarf::VS_source_file:
+ return value.source_file ().to_string ();
+
+ case dwarf::VS_location:
+ return value.location ().to_string ();
+
+ case dwarf::VS_discr_list:
+ break; // XXX DW_AT_discr_list unimplemented
+ }
+
+ throw std::runtime_error ("XXX unsupported value space");
+}
+
+template<>
+string
+to_string<dwarf::attribute> (const dwarf::attribute &attr)
+{
+ return attribute_string (attr);
+}
+
+template<>
+string
+to_string<dwarf::attr_value> (const dwarf::attr_value &value)
+{
+ return value_string (value);
+}
+
+template<>
+string
+to_string<dwarf_edit::attr_value> (const dwarf_edit::attr_value &value)
+{
+ return value_string (value);
+}
+
+template<>
+string
+to_string<dwarf_output::attr_value> (const dwarf_output::attr_value &value)
+{
+ return value_string (value);
+}
+
+// A few cases are trivial.
+#define SIMPLE(type, name, form) \
+ type \
+ dwarf::attr_value::name () const \
+ { \
+ type result; \
+ xif (thisattr (), dwarf_form##form (thisattr (), &result) < 0); \
+ return result; \
+ }
+
+SIMPLE (bool, flag, flag)
+
+// XXX check value_space is really constantish?? vs *ptr
+SIMPLE (Dwarf_Word, constant, udata)
+SIMPLE (Dwarf_Sword, signed_constant, sdata)
+
+SIMPLE (Dwarf_Addr, address, addr)
+
+const char *
+dwarf::attr_value::string () const
+{
+ const char *result = dwarf_formstring (thisattr ());
+ xif (thisattr(), result == NULL);
+ return result;
+}
+
+bool
+dwarf::attr_value::constant_is_integer () const
+{
+ switch (dwarf_whatform (thisattr ()))
+ {
+ case DW_FORM_block:
+ case DW_FORM_block1:
+ case DW_FORM_block2:
+ case DW_FORM_block4:
+ return false;
+
+ case DW_FORM_data1:
+ case DW_FORM_data2:
+ case DW_FORM_data4:
+ case DW_FORM_data8:
+ case DW_FORM_udata:
+ case DW_FORM_sdata:
+ return true;
+
+ default:
+ throw std::runtime_error ("XXX wrong form");
+ }
+}
+
+
+const_vector<uint8_t>
+dwarf::attr_value::constant_block () const
+{
+ Dwarf_Block block;
+
+ switch (dwarf_whatform (thisattr ()))
+ {
+ case DW_FORM_block:
+ case DW_FORM_block1:
+ case DW_FORM_block2:
+ case DW_FORM_block4:
+ case DW_FORM_exprloc:
+ xif (thisattr(), dwarf_formblock (thisattr (), &block) < 0);
+ break;
+
+ case DW_FORM_data1:
+ block.length = 1;
+ block.data = thisattr ()->valp;
+ break;
+
+ case DW_FORM_data2:
+ block.length = 2;
+ block.data = thisattr ()->valp;
+ break;
+
+ case DW_FORM_data4:
+ block.length = 4;
+ block.data = thisattr ()->valp;
+ break;
+
+ case DW_FORM_data8:
+ block.length = 8;
+ block.data = thisattr ()->valp;
+ break;
+
+ case DW_FORM_udata:
+ case DW_FORM_sdata:
+ // XXX ?
+ if ((*(const uint8_t *) thisattr ()->valp & 0x80) == 0)
+ {
+ block.length = 1;
+ block.data = thisattr ()->valp;
+ break;
+ }
+
+ default:
+ throw std::runtime_error ("XXX wrong form");
+ }
+
+ return const_vector<uint8_t> (block);
+}
+
+namespace elfutils
+{
+ template<>
+ std::string to_string (const dwarf::debug_info_entry &die)
+ {
+ return die_string (die);
+ }
+};
+\f
+// dwarf::range_list
+
+unsigned char *
+dwarf::range_list::const_iterator::formptr (int secndx, Dwarf_Attribute *attr)
+{
+ unsigned char *readptr = __libdw_formptr (attr, secndx,
+ DWARF_E_NO_DEBUG_RANGES,
+ NULL, NULL);
+ xif (attr, readptr == NULL);
+ return readptr;
+}
+
+dwarf::range_list::const_iterator
+dwarf::range_list::begin () const
+{
+ const_iterator it (IDX_debug_ranges, _m_attr.thisattr (), 0);
+ return ++it;
+}
+
+dwarf::range_list::const_iterator::const_iterator (int secndx,
+ Dwarf_Attribute *attr,
+ unsigned char *readptr)
+ : _m_base (-1), _m_begin (0), _m_end (0), _m_cu (attr->cu)
+ , _m_readptr (readptr)
+{
+ if (_m_readptr == NULL)
+ {
+ _m_readptr = formptr (secndx, attr);
+ xif (attr, _m_readptr == NULL);
+ }
+}
+
+static bool
+range_list_advance (int secndx,
+ Dwarf_CU *cu,
+ Dwarf_Addr &base,
+ Dwarf_Addr &begin,
+ Dwarf_Addr &end,
+ unsigned char *&readp,
+ unsigned char **valp)
+{
+ const Elf_Data *d = cu->dbg->sectiondata[secndx];
+ if (unlikely (d == NULL))
+ throw std::runtime_error ("XXX no ranges");
+
+ if (unlikely (readp >= (unsigned char *)d->d_buf + d->d_size))
+ throw std::runtime_error ("XXX bad readptr in ranges iterator");
+
+ unsigned char *const readendp
+ = reinterpret_cast<unsigned char *> (d->d_buf) + d->d_size;
+
+ while (true)
+ {
+ if (readendp - readp < cu->address_size * 2)
+ throw std::runtime_error ("XXX bad ranges");
+
+ if (cu->address_size == 8)
+ {
+ begin = read_8ubyte_unaligned_inc (cu->dbg, readp);
+ end = read_8ubyte_unaligned_inc (cu->dbg, readp);
+ if (begin == (uint64_t) -1l) /* Base address entry. */
+ {
+ base = end;
+ continue;
+ }
+ }
+ else
+ {
+ begin = read_4ubyte_unaligned_inc (cu->dbg, readp);
+ end = read_4ubyte_unaligned_inc (cu->dbg, readp);
+ if (begin == (uint32_t) -1) /* Base address entry. */
+ {
+ base = end;
+ continue;
+ }
+ }
+
+ break;
+ }
+
+ if (begin == 0 && end == 0) /* End of list entry. */
+ readp = (unsigned char *)-1;
+ else
+ {
+ if (valp)
+ *valp = readp;
+
+ if (base == (Dwarf_Addr) -1)
+ {
+ CUDIE (cudie, cu);
+
+ /* Find the base address of the compilation unit. It will
+ normally be specified by DW_AT_low_pc. In DWARF-3 draft 4,
+ the base address could be overridden by DW_AT_entry_pc. It's
+ been removed, but GCC emits DW_AT_entry_pc and not DW_AT_lowpc
+ for compilation units with discontinuous ranges. */
+ Dwarf_Attribute attr_mem;
+ if (unlikely (dwarf_lowpc (&cudie, &base) != 0)
+ && dwarf_formaddr (dwarf_attr (&cudie,
+ DW_AT_entry_pc,
+ &attr_mem),
+ &base) != 0)
+ {
+ return true; // XXX
+ }
+ }
+ }
+
+ return false;
+}
+
+dwarf::range_list::const_iterator &
+dwarf::range_list::const_iterator::operator++ ()
+{
+ xif (_m_cu, range_list_advance (IDX_debug_ranges, _m_cu, _m_base,
+ _m_begin, _m_end, _m_readptr, NULL));
+ return *this;
+}
+
+
+template<typename container>
+string
+__libdw_ranges_to_string (const container &c)
+{
+ std::ostringstream os;
+
+ os << "<" << std::hex << std::showbase;
+
+ bool first = true;
+ for (typename container::const_iterator i = c.begin (); i != c.end (); ++i)
+ {
+ const typename container::value_type range = *i;
+ if (!first)
+ os << ",";
+ os << range.first << "-" << range.second;
+ first = false;
+ }
+
+ os << ">";
+
+ return os.str ();
+}
+
+string
+dwarf::range_list::to_string () const
+{
+ return __libdw_ranges_to_string (*this);
+}
+
+string
+dwarf::ranges::to_string () const
+{
+ return __libdw_ranges_to_string (*this);
+}
+
+string
+dwarf::arange_list::to_string () const
+{
+ return __libdw_ranges_to_string (*this);
+}
+
+dwarf::aranges_map
+dwarf::aranges () const
+{
+ Dwarf_Aranges *these;
+ xif (dwarf_getaranges (_m_dw, &these, NULL) < 0);
+
+ if (these == NULL)
+ return aranges_map ();
+
+ aranges_map result;
+ for (const Dwarf_Aranges_s::Dwarf_Arange_s *r = &these->info[0];
+ r < &these->info[these->naranges];
+ ++r)
+ result[compile_unit (debug_info_entry (_m_dw, r->offset))].insert
+ (arange_list::value_type (r->addr, r->addr + r->length));
+
+ return result;
+}
+\f
+// dwarf::location_attr
+
+const dwarf::location_attr
+dwarf::attr_value::location () const
+{
+ if (what_space () != VS_location)
+ throw std::runtime_error ("XXX not a location");
+
+ return location_attr (*this);
+}
+
+bool
+dwarf::location_attr::is_list () const
+{
+ if (_m_attr.thisattr ()->cu->version >= 4)
+ return dwarf_whatform (_m_attr.thisattr ()) == DW_FORM_sec_offset;
+
+ switch (dwarf_whatform (_m_attr.thisattr ()))
+ {
+ case DW_FORM_block:
+ case DW_FORM_block1:
+ case DW_FORM_block2:
+ case DW_FORM_block4:
+ return false;
+ }
+
+ return true;
+}
+
+inline void
+dwarf::location_attr::const_iterator::advance ()
+{
+ xif (_m_cu, range_list_advance (IDX_debug_loc, _m_cu,
+ _m_base, _m_begin, _m_end, _m_readptr,
+ &_m_block.data));
+ // Special values are (unsigned char *){-1, 0, 1}.
+ if (((uintptr_t)_m_readptr + 1) > 2)
+ _m_readptr += 2 + (_m_block.length
+ = read_2ubyte_unaligned_inc (_m_cu->dbg, _m_block.data));
+ else
+ // End iterator.
+ _m_block = Dwarf_Block ();
+}
+
+dwarf::location_attr::const_iterator
+dwarf::location_attr::begin () const
+{
+ const_iterator i (_m_attr.thisattr ());
+ if (is_list ())
+ {
+ i._m_readptr = const_iterator::formptr (IDX_debug_loc,
+ _m_attr.thisattr ());
+ xif (_m_attr.thisattr (), i._m_readptr == NULL);
+ i.advance ();
+ }
+ else
+ {
+ xif (_m_attr.thisattr (),
+ dwarf_formblock (_m_attr.thisattr (), &i._m_block) < 0);
+ i._m_base = 0;
+ i._m_end = -1;
+ i._m_readptr = NULL;
+ }
+
+ return i;
+}
+
+dwarf::location_attr::const_iterator &
+dwarf::location_attr::const_iterator::operator++ ()
+{
+ if (unlikely (_m_readptr == (unsigned char *)-1))
+ throw std::runtime_error ("incrementing end iterator");
+
+ if (_m_readptr == NULL)
+ {
+ // Singleton, now at end.
+ _m_readptr = (unsigned char *)-1;
+ _m_block.data = NULL;
+ _m_block.length = 0;
+ }
+ else
+ // Advance to next list entry.
+ advance ();
+
+ return *this;
+}
+
+template<typename locattr>
+static string
+locattr_string (const locattr *loc)
+{
+ return (loc->is_list () ? dec_string (loc->size (), "{loclist ", " entries}")
+ : "{locexpr}");
+}
+
+string
+dwarf::location_attr::to_string () const
+{
+ return locattr_string (this);
+}
+
+string
+dwarf_data::location_attr::to_string () const
+{
+ return locattr_string (this);
+}
+\f
+// dwarf::line_info_table
+
+template<typename line_info_table>
+static inline std::string
+line_info_string (const line_info_table *table)
+{
+ return ("[" + table->lines ().to_string () + "]");
+}
+
+std::string
+dwarf::line_info_table::to_string () const
+{
+ return line_info_string (this);
+}
+
+namespace elfutils
+{
+ template<>
+ std::string
+ dwarf_edit::line_info_table::to_string () const
+ {
+ return line_info_string (this);
+ }
+
+};
+\f
+// dwarf::line_table
+
+std::string
+dwarf::line_table::to_string () const
+{
+ return dec_string (_m_lines->nlines, "{", " line entries}");
+}
+
+namespace elfutils
+{
+ template<>
+ std::string
+ dwarf_edit::line_table::to_string () const
+ {
+ return dec_string (size (), "{", " line entries}");
+ }
+};
+\f
+::Dwarf_Off
+dwarf::debug_info_entry::cost () const
+{
+ Dwarf_Die next;
+ int result = dwarf_siblingof (thisdie (), &next);
+ xif (result < 0);
+ if (result == 0)
+ return (const char *) next.addr - (const char *) _m_die.addr;
+ if (next.addr != NULL)
+ return (const char *) next.addr - (const char *) _m_die.addr + 1;
+ return _m_die.cu->end - dwarf_dieoffset (thisdie ());
+}
projects / thirdparty / elfutils.git / commitdiff
