Merge roland/dwarf-collector, fiddle constructors more.upstream/roland/dwarf_edit

17 files changed, 1110 insertions, 703 deletions

diff --git a/NEWS b/NEWS
index e3106f71..2933d35a 100644
--- a/NEWS
+++ b/NEWS
@@ -4,6 +4,8 @@ libelf: Add elf_getshdrnum alias for elf_getshnum and elf_getshdrstrndx alias
         for elf_getshstrndx and deprecate original names.  Sun screwed up
         their implementation and asked for a solution.
 
+readelf: Add -N option, speeds up DWARF printing without address->name lookups.
+
 Version 0.141:
 
 libebl: sparc backend fixes;
diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 9d185441..28cc39a5 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
@@ -1,3 +1,9 @@
+2009-07-01  Roland McGrath  <roland@redhat.com>
+
+	* c++/dwarf_tracker: Major revamp for efficiency and to handle
+	circular reference chains.
+	* c++/dwarf_comparator: Tracker interface changes.
+
 2009-06-19  Roland McGrath  <roland@redhat.com>
 
 	* c++/dwarf_comparator: New file.
diff --git a/libdw/c++/data-values.hh b/libdw/c++/data-values.hh
index ec1e5455..55860f5c 100644
--- a/libdw/c++/data-values.hh
+++ b/libdw/c++/data-values.hh
@@ -54,9 +54,9 @@
 namespace elfutils
 {
 
-  template<class impl, typename arg, typename v>
+  template<class impl, typename v>
   dwarf::value_space
-  dwarf_data::attr_value<impl, arg, v>::what_space () const
+  dwarf_data::attr_value<impl, v>::what_space () const
   {
     if (typeid (*_m_value) == typeid (typename v::value_flag))
       return dwarf::VS_flag;
diff --git a/libdw/c++/dwarf b/libdw/c++/dwarf
index a3bee5dd..311591fe 100644
--- a/libdw/c++/dwarf
+++ b/libdw/c++/dwarf
@@ -796,6 +796,10 @@ namespace elfutils
 	}
 
       public:
+	inline const_iterator ()
+	  : _m_stack ()
+	{}
+
 	inline const_iterator (const raw_iterator &i)
 	{
 	  _m_stack.push (i);
diff --git a/libdw/c++/dwarf_comparator b/libdw/c++/dwarf_comparator
index 8042a949..55a41717 100644
--- a/libdw/c++/dwarf_comparator
+++ b/libdw/c++/dwarf_comparator
@@ -57,9 +57,8 @@ namespace elfutils
   // Prototypical stub for reference tracker object.
   // This keeps no state, and no two contexts ever match.
   template<class dwarf1, class dwarf2>
-  class dwarf_tracker_base
+  struct dwarf_tracker_base
   {
-  protected:
     typedef typename dwarf1::compile_units::const_iterator cu1;
     typedef typename dwarf2::compile_units::const_iterator cu2;
     typedef typename dwarf1::debug_info_entry dwarf1_die;
@@ -69,19 +68,27 @@ namespace elfutils
     typedef typename dwarf1_die::attributes_type::const_iterator attr1;
     typedef typename dwarf2_die::attributes_type::const_iterator attr2;
 
-  public:
-    inline void start_walk (const cu1 &a, const cu2 &b)
-    {
-    }
-    inline void finish_walk (const cu1 &a, const cu2 &b)
-    {
-    }
-    inline void pre_order (const die1 &a, const die2 &b)
+    // This object is created to start a walk and destroyed to finish one.
+    struct walk
     {
-    }
-    inline void post_order (const die1 &a, const die2 &b)
+      inline walk (dwarf_tracker_base *, const cu1 &a, const cu2 &b)
+      {
+      }
+      inline ~walk ()
+      {
+      }
+    };
+
+    // This object is created in pre-order and destroyed in post-order.
+    struct step
     {
-    }
+      inline step (dwarf_tracker_base *, const die1 &a, const die2 &b)
+      {
+      }
+      inline ~step ()
+      {
+      }
+    };
 
     inline void visit (const typename dwarf1::debug_info_entry &a,
 		       const typename dwarf2::debug_info_entry &b)
@@ -104,12 +111,15 @@ namespace elfutils
     }
 
     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 &die)
     {
       return left_context_type ();
     }
 
-    struct right_context_type {};
+    // Return the rhs context of an arbitrary DIE.
     inline const right_context_type right_context (const die2 &die)
     {
       return right_context_type ();
@@ -127,6 +137,32 @@ namespace elfutils
     {
       return false;
     }
+
+    struct reference_match
+    {
+      inline bool cannot_match () const
+      {
+	return false;
+      }
+      inline void notice_match (const die2 &, bool) const
+      {
+      }
+    };
+
+    inline bool reference_matched (reference_match &,
+				   const die1 &, const die2 &)
+    {
+      return false;
+    }
+
+    inline dwarf_tracker_base ()
+    {}
+
+    inline dwarf_tracker_base (const dwarf_tracker_base &, reference_match &,
+			       const left_context_type &, const die1 &,
+			       const right_context_type &, const die2 &)
+    {}
+
   };
 
   template<class dwarf1, class dwarf2,
@@ -142,8 +178,8 @@ namespace elfutils
     template<typename item1, typename item2>
     struct matcher : public std::binary_function<item1, item2, bool>
     {
-      dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &_m_cmp;
-      matcher (dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &cmp)
+      dwarf_comparator &_m_cmp;
+      matcher (dwarf_comparator &cmp)
 	: _m_cmp (cmp)
       {}
 
@@ -153,7 +189,8 @@ namespace elfutils
       }
     };
 #define MATCHER(item) \
-    matcher<typename dwarf1::item, typename dwarf2::item>
+    matcher<typename dwarf1::item::const_iterator, \
+	    typename dwarf2::item::const_iterator> (*this)
 
     inline bool match (const dwarf1 &a, const dwarf2 &b)
     {
@@ -171,8 +208,7 @@ namespace elfutils
       const cu1_it end1 = a.end ();
       const cu2_it end2 = b.end ();
       if (subr::container_equal
-	  (it1, end1, it2, end2,
-	   MATCHER (compile_units::const_iterator) (*this)))
+	  (it1, end1, it2, end2, MATCHER (compile_units)))
 	return true;
       _m_tracker.mismatch (it1, end1, it2, end2);
       return false;
@@ -182,19 +218,8 @@ namespace elfutils
     typedef typename dwarf2::debug_info_entry die2;
     inline bool match (const cu1_it &a, const cu2_it &b)
     {
-      bool result;
-      _m_tracker.start_walk (a, b);
-      try
-	{
-	  result = match (static_cast<die1> (*a), static_cast<die2> (*b));
-	}
-      catch (...)
-	{
-	  _m_tracker.finish_walk (a, b);
-	  throw;
-	}
-      _m_tracker.finish_walk (a, b);
-      return result;
+      typename tracker::walk in (&_m_tracker, a, b);
+      return match (static_cast<die1> (*a), static_cast<die2> (*b));
     }
 
     inline bool match (const die1 &a, const die2 &b)
@@ -233,8 +258,8 @@ namespace elfutils
     struct match_rhs
       : public std::binary_function<ait1, ait2, bool>
     {
-      dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &_m_cmp;
-      match_rhs (dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &cmp)
+      dwarf_comparator &_m_cmp;
+      match_rhs (dwarf_comparator &cmp)
 	: _m_cmp (cmp)
       {}
 
@@ -249,7 +274,7 @@ namespace elfutils
 				    typename ait2_map::value_type,
 				    bool>
     {
-      dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &_m_cmp;
+      dwarf_comparator &_m_cmp;
       match_sorted (dwarf_comparator<dwarf1, dwarf2,
 		    ignore_refs, tracker> &cmp)
 	: _m_cmp (cmp)
@@ -312,38 +337,39 @@ namespace elfutils
     typedef typename dwarf2::debug_info_entry::children_type children2;
     typedef typename children1::const_iterator cit1;
     typedef typename children2::const_iterator cit2;
-    struct die_matcher
-      : public std::binary_function<cit1, cit2, bool>
+
+    inline bool match_child (const cit1 &a, const cit2 &b)
     {
-      dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &_m_cmp;
-      die_matcher (dwarf_comparator<dwarf1, dwarf2, ignore_refs, tracker> &cmp)
-	: _m_cmp (cmp)
-      {}
+      typename tracker::step into (&_m_tracker, a, b);
+      return match (*a, *b);
+    }
+
+    inline bool match (const cit1 &a, const cit2 &b)
+    {
+      // Maybe the tracker has already cached a correspondence of DIEs.
+      typename tracker::reference_match matched;
+      if (_m_tracker.reference_matched (matched, a, b))
+	return true;
+
+      if (matched.cannot_match ())
+	return false;
+
+      bool result = match_child (a, b);
+
+      // Let the tracker cache a result for its reference_matched.
+      matched.notice_match (b, result);
+
+      return result;
+    }
 
-      inline bool operator () (const cit1 &a, const cit2 &b)
-      {
-	bool result;
-	_m_cmp._m_tracker.pre_order (a, b);
-	try
-	  {
-	    result = _m_cmp.match (*a, *b);
-	  }
-	catch (...)
-	  {
-	    _m_cmp._m_tracker.post_order (a, b);
-	    throw;
-	  }
-	_m_cmp._m_tracker.post_order (a, b);
-	return 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 ();
-      if (subr::container_equal (it1, end1, it2, end2, die_matcher (*this)))
+      if (subr::container_equal (it1, end1, it2, end2,
+				 MATCHER (debug_info_entry::children_type)))
 	return true;
       _m_tracker.mismatch (it1, end1, it2, end2);
       return false;
@@ -434,25 +460,58 @@ namespace elfutils
 	return true;
 
       // Simplest mismatches with the cheapest checks first.
-      if (a.tag () != b.tag ()
-	  || a.has_children () != b.has_children ())
+      if (a.tag () != b.tag ())
+	return false;
+
+      const bool has_children = a.has_children ();
+      if (has_children != b.has_children ())
+	return false;
+
+      // 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 (matched.cannot_match ())
 	return false;
 
-      // Now we have to get the tracker involved.
+      // 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);
 
-      // First do the cheap mismatch check on the contexts, then check the
-      // contents and contexts in ascending order of costliness of a check.
-      return (!_m_tracker.context_quick_mismatch (lhs, rhs)
-	      && match (a.attributes (), b.attributes ())
-	      && _m_tracker.context_match (lhs, rhs)
-	      && match (a.children (), b.children ()));
+      /* 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)
+	  || !match (a.attributes (), b.attributes ())
+	  || !_m_tracker.context_match (lhs, rhs))
+	return false;
+
+      /* 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.  */
+      bool result = !has_children || (dwarf_comparator (tracker (_m_tracker,
+								 matched,
+								 lhs, ref1,
+								 rhs, ref2))
+				      .match (a.children (), b.children ()));
+
+      // Let the tracker cache a result for its reference_matched.
+      matched.notice_match (ref2, result);
+
+      return result;
     }
 
+    inline explicit dwarf_comparator (const tracker &t)
+      : _m_tracker (t)
+    {}
+
   public:
+    inline dwarf_comparator ()
+    {}
+
     inline bool operator () (const dwarf1 &a, const dwarf2 &b)
     {
       return match (a, b);
diff --git a/libdw/c++/dwarf_data b/libdw/c++/dwarf_data
index 1f92fddf..6d039009 100644
--- a/libdw/c++/dwarf_data
+++ b/libdw/c++/dwarf_data
@@ -673,7 +673,7 @@ namespace elfutils
   public:
     struct nothing {};
 
-    template<typename impl, typename constructor_arg_type>
+    template<typename impl>
     struct value
     {
       struct value_dispatch
@@ -681,9 +681,9 @@ namespace elfutils
 	virtual ~value_dispatch () {}
       };
 
-      template<typename flavor, typename input>
+      template<typename flavor, typename input, typename arg_type>
       static inline value_dispatch *
-      make (flavor *&result, const input &x, const constructor_arg_type &arg)
+      make (flavor *&result, const input &x, const arg_type &arg)
       {
 	return result = new flavor (x, arg);
       }
@@ -692,8 +692,8 @@ namespace elfutils
       {
 	inline value_string () {}
 
-	template<typename string>
-	inline value_string (const string &s, const constructor_arg_type &arg)
+	template<typename string, typename arg_type>
+	inline value_string (const string &s, const arg_type &arg)
 	  : std::string (s)
 	{}
 
@@ -708,8 +708,8 @@ namespace elfutils
 
       struct value_identifier : public value_string
       {
-	template<typename id>
-	inline value_identifier (const id &s, const constructor_arg_type &arg)
+	template<typename id, typename arg_type>
+	inline value_identifier (const id &s, const arg_type &arg)
 	  : value_string (s, arg)
 	{}
       };
@@ -717,29 +717,32 @@ namespace elfutils
       struct value_reference : public value_dispatch
       {
 	typename impl::debug_info_entry::children_type::iterator ref;
+
+	template<typename arg_type>
 	inline value_reference
 	(const typename impl::debug_info_entry::children_type::iterator &i,
-	 const constructor_arg_type &arg)
+	 const arg_type &arg)
 	  : ref (i)
 	{}
 
-	template<typename iter>	// XXX dummy
-	value_reference (const iter &i, const constructor_arg_type &arg)
+	template<typename iter, typename arg_type>	// XXX dummy
+	inline value_reference (const iter &i, const arg_type &arg)
 	  : ref () {}
       };
 
       struct value_unit_reference : public value_dispatch
       {
 	typename impl::compile_units::iterator ref;
+
+	template<typename arg_type>
 	inline value_unit_reference
 	(const typename impl::compile_units::iterator &i,
-	 const constructor_arg_type &arg)
+	 const arg_type &arg)
 	  : ref (i)
 	{}
 
-	template<typename iter>	// XXX dummy
-	value_unit_reference (const iter &i,
-			      const constructor_arg_type &arg)
+	template<typename iter, typename arg_type>	// XXX dummy
+	inline value_unit_reference (const iter &i, const arg_type &arg)
 	  : ref ()
 	{}
       };
@@ -752,7 +755,8 @@ namespace elfutils
 	  : flag (true)
 	{}
 
-	inline value_flag (bool t, const constructor_arg_type &arg)
+	template<typename arg_type>
+	inline value_flag (bool t, const arg_type &arg)
 	  : flag (t)
 	{}
       };
@@ -766,31 +770,28 @@ namespace elfutils
 	  : addr (0)
 	{}
 
-	inline value_address (::Dwarf_Addr a, const constructor_arg_type &arg)
-	  : addr (a)
+	template<typename arg_type>
+	inline value_address (::Dwarf_Addr x, const arg_type &arg)
+	  : addr (x)
 	{}
       };
 
       struct value_rangelistptr : public value_dispatch, public range_list
       {
-	inline value_rangelistptr ()
-	{}
+	inline value_rangelistptr () {}
 
-	template<typename list>
-	inline value_rangelistptr (const list &other,
-				   const constructor_arg_type &arg)
+	template<typename list, typename arg_type>
+	inline value_rangelistptr (const list &other, const arg_type &arg)
 	  : range_list (other)
 	{}
       };
 
       struct value_lineptr : public value_dispatch, public impl::line_info_table
       {
-	inline value_lineptr ()
-	{}
+	inline value_lineptr () {}
 
-	template<typename table>
-	inline value_lineptr (const table &other,
-			      const constructor_arg_type &arg)
+	template<typename table, typename arg_type>
+	inline value_lineptr (const table &other, const arg_type &arg)
 	  : impl::line_info_table (other)
 	{}
       };
@@ -807,7 +808,8 @@ namespace elfutils
 	  : word (0)
 	{}
 
-	inline value_constant (::Dwarf_Word x, const constructor_arg_type &arg)
+	template<typename arg_type>
+	inline value_constant (::Dwarf_Word x, const arg_type &arg)
 	  : word (x)
 	{}
       };
@@ -817,9 +819,8 @@ namespace elfutils
       {
 	inline value_constant_block () {}
 
-	template<typename block>
-	inline value_constant_block (const block &b,
-				     const constructor_arg_type &arg)
+	template<typename block, typename arg_type>
+	inline value_constant_block (const block &b, const arg_type &arg)
 	  : std::vector<uint8_t> (b.begin (), b.end ())
 	{}
       };
@@ -828,21 +829,20 @@ namespace elfutils
       {
 	inline value_dwarf_constant () {}
 
-	template<typename constant>
-	inline value_dwarf_constant (const constant &other,
-				     const constructor_arg_type &arg)
-	  : dwarf_enum (other) {}
+	template<typename constant, typename arg_type>
+	inline value_dwarf_constant (const constant &other, const arg_type &arg)
+	  : dwarf_enum (other)
+	{}
       };
 
       struct value_source_file : public value_dispatch, public source_file
       {
-	inline value_source_file ()
-	{}
+	inline value_source_file () {}
 
-	template<typename file>
-	inline value_source_file (const file &other,
-				  const constructor_arg_type &arg)
-	  : source_file (other) {}
+	template<typename file, typename arg_type>
+	inline value_source_file (const file &other, const arg_type &arg)
+	  : source_file (other)
+	{}
       };
 
       struct value_source_line : public value_dispatch
@@ -853,8 +853,8 @@ namespace elfutils
 	  : n (0)
 	{}
 
-	inline value_source_line (unsigned int m,
-				  const constructor_arg_type &arg)
+	template<typename arg_type>
+	inline value_source_line (unsigned int m, const arg_type &arg)
 	  : n (m)
 	{}
       };
@@ -864,75 +864,72 @@ namespace elfutils
 
       struct value_location : public value_dispatch, public location_attr
       {
-	inline value_location ()
-	{}
+	inline value_location () {}
 
-	template<typename loc>
-	inline value_location (const loc &other,
-			       const constructor_arg_type &arg)
+	template<typename loc, typename arg_type>
+	inline value_location (const loc &other, const arg_type &arg)
 	  : location_attr (other)
 	{}
       };
     };
 
-    template<class impl,
-	     typename constructor_arg_type = nothing,
-	     typename vw = value<impl, constructor_arg_type>
-	     >
+    template<class impl, typename vw = value<impl> >
     class attr_value
     {
     private:
       typename vw::value_dispatch *_m_value;
 
-      template<typename value>
-      inline void init (const value &other,
-			const constructor_arg_type &arg
-			= constructor_arg_type ())
+      template<typename value, typename arg_type = nothing>
+      struct init
       {
-	switch (other.what_space ())
-	  {
-#define _DWARF_DATA_AV_MAKE(flavor, fetch)				      \
-	  case dwarf::VS_##flavor:					      \
-	    {								      \
-	      typename vw::value_##flavor *p;				      \
-	      _m_value = vw::make (p, 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 (unit_reference, unit_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;
-		_m_value = vw::make (p, other.constant (), arg);
-	      }
-	    else
-	      {
-		typename vw::value_constant_block *p;
-		_m_value = vw::make (p, other.constant_block (), arg);
-	      }
-	    break;
-
-	  default:
-	  case dwarf::VS_discr_list:
-	    throw std::runtime_error ("XXX unimplemented");
+	inline init (attr_value *av,
+		     const value &other, const arg_type &arg = arg_type ())
+	{
+	  switch (other.what_space ())
+	    {
+#define _DWARF_DATA_AV_MAKE(flavor, fetch)				\
+	      case dwarf::VS_##flavor:					\
+		{							\
+		  typename vw::value_##flavor *p;			\
+		  av->_m_value = vw::make (p, 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 (unit_reference, unit_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;
+		  av->_m_value = vw::make (p, other.constant (), arg);
+		}
+	      else
+		{
+		  typename vw::value_constant_block *p;
+		  av->_m_value = vw::make (p, other.constant_block (), arg);
+		}
+	      break;
+
+	    default:
+	    case dwarf::VS_discr_list:
+	      throw std::runtime_error ("XXX unimplemented");
 
 #undef _DWARF_DATA_AV_MAKE
-	  }
-      }
+	    }
+	}
+      };
 
       template<typename flavor>
       inline flavor &const_variant () const
@@ -962,14 +959,14 @@ namespace elfutils
 	: _m_value (NULL)
       {
 	if (other._m_value != NULL)
-	  init (other);
+	  init<attr_value> me (this, other);
       }
 
-      template<typename value>
-      attr_value (const value &other, const constructor_arg_type &arg)
+      template<typename value, typename arg_type>
+      attr_value (const value &other, const arg_type &arg)
 	: _m_value (NULL)
       {
-	init (other, arg);
+	init<value, arg_type> me (this, other, arg);
       }
 
       inline attr_value ()
@@ -989,7 +986,7 @@ namespace elfutils
 	    delete _m_value;
 	    _m_value = NULL;
 	  }
-	init (other);
+	init<attr_value> me (this, other);
 	return *this;
       }
       template<typename value>
@@ -1000,7 +997,7 @@ namespace elfutils
 	    delete _m_value;
 	    _m_value = NULL;
 	  }
-	init (other);
+	init<value> me (this, other);
 	return *this;
       }
 
@@ -1215,110 +1212,24 @@ namespace elfutils
       }
     };
 
-    template<class dwarf_output, typename constructor_arg_type = nothing>
-    struct constructor_arg_adapter
-    {
-      template<typename input, typename output>
-      struct make_any
-	: public std::binary_function<typename input::value_type,
-				      constructor_arg_type,
-				      typename output::value_type>
-      {
-	inline typename output::value_type
-	operator () (const typename input::value_type &x,
-		     const constructor_arg_type &c) const
-	{
-	  return typename output::value_type (x, c);
-	}
-      };
-
-      template<typename input, typename output>
-      struct make_attribute
-	: public std::binary_function<typename input::value_type,
-				      constructor_arg_type,
-				      typename output::value_type>
-      {
-	inline typename output::value_type
-	operator () (const typename input::value_type &x,
-		     const constructor_arg_type &c) const
-	{
-	  return std::make_pair
-	    (x.first, typename output::value_type::second_type (x.second, c));
-	}
-      };
-
-      /* 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 make_outlet = make_any<input, output> >
-      struct argify
-	: 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 maker
-	  : public std::unary_function<inlet, outlet>
-	{
-	  constructor_arg_type _m_arg;
-	  explicit inline maker (const constructor_arg_type &c) : _m_arg (c) {}
-
-	  inline outlet operator () (const inlet &x) const
-	  {
-	    return make_outlet () (x, _m_arg);
-	  }
-	} _m_maker;
-
-	explicit inline argify (const constructor_arg_type &c)
-	  : _m_maker (c)
-	{}
-
-	typedef subr::wrapped_input_iterator<input, maker> wrapped;
-
-	inline wrapped operator () (const inny &i)
-	{
-	  return wrapped (i, _m_maker);
-	}
-      };
-
-      template<class input>
-      static inline argify<
-	input, typename dwarf_output::debug_info_entry::attributes_type,
-	make_attribute<input,
-		       typename dwarf_output::debug_info_entry::attributes_type>
-	> attr (const input &, const constructor_arg_type &c)
-      {
-	return argify<
-	  input, typename dwarf_output::debug_info_entry::attributes_type,
-	  make_attribute<
-	    input, typename dwarf_output::debug_info_entry::attributes_type>
-	    > (c);
-      };
-    };
-
-    template<class impl, typename arg = nothing, typename v = value<impl, arg> >
+    template<class impl, typename arg = nothing, typename v = value<impl> >
     class attributes_type
-      : public std::map<int, attr_value<impl, arg, v> >
+      : public std::map<int, attr_value<impl, v> >
     {
       friend class impl::debug_info_entry;
     private:
-      typedef std::map<int, attr_value<impl, arg, v> > base_type;
-      typedef constructor_arg_adapter<impl, arg> argify;
+      typedef std::map<int, attr_value<impl, v> > base_type;
 
     protected:
       inline attributes_type () {}
 
     public: // XXX should be protected
-      template<typename input>
-      inline attributes_type (const input &other, const arg &c)
-	: base_type (argify::attr (other, c) (other.begin ()),
-		     argify::attr (other, c) (other.end ()))
+      template<typename input, typename arg_type>
+      inline attributes_type (const input &other, const arg_type &c)
+	: base_type (subr::argify2nd<input, attributes_type, arg_type>
+		     (other.begin (), c),
+		     subr::argify2nd<input, attributes_type, arg_type>
+		     (other.end (), c))
       {}
 
     public:
@@ -1345,8 +1256,8 @@ namespace elfutils
     return elfutils::to_string (*this); // Use that.
   }
 
-  template<class impl, typename arg, typename v>
-  inline std::string dwarf_data::attr_value<impl, arg, v>::to_string () const
+  template<class impl, typename v>
+  inline std::string dwarf_data::attr_value<impl, v>::to_string () const
   {
     return elfutils::to_string (*this); // Use that.
   }
diff --git a/libdw/c++/dwarf_edit b/libdw/c++/dwarf_edit
index d936f1c8..8e12c5da 100644
--- a/libdw/c++/dwarf_edit
+++ b/libdw/c++/dwarf_edit
@@ -52,6 +52,7 @@
 
 #include "dwarf"
 #include "dwarf_data"
+#include "dwarf_tracker"
 
 /* Read the comments for elfutils::dwarf first.
 
@@ -109,9 +110,12 @@ namespace elfutils
       private:
         children_type () {}
 
-	template<typename childrens>
-	children_type (const childrens &other)
-	  : std::list<debug_info_entry> (other.begin (), other.end ()) {}
+	template<typename input, typename tracker>
+	children_type (const input &other, tracker *t)
+	  : std::list<debug_info_entry>
+	    (subr::argify<input, children_type, tracker *> (other.begin (), t),
+	     subr::argify<input, children_type, tracker *> (other.end (), t))
+	{}
 
       public:
 	typedef debug_info_entry value_type;
@@ -132,9 +136,9 @@ namespace elfutils
 
 	inline attributes_type () {}
 
-	template<typename attrs>
-	inline attributes_type (const attrs &other)
-	  : base_type (other, dwarf_data::nothing ())
+	template<typename attrs, typename tracker>
+	inline attributes_type (const attrs &other, tracker *t)
+	  : base_type (other, t)
 	{}
       };
 
@@ -152,11 +156,11 @@ namespace elfutils
 
       /* The template constructor lets us copy in from any class that has
 	 compatibly iterable containers for attributes and children.  */
-      template<typename die_type>
-      debug_info_entry (const die_type &die)
+      template<typename die_type, typename tracker>
+      debug_info_entry (const die_type &die, tracker *t)
 	: _m_tag (die.tag ()),
-	  _m_attributes (die.attributes ()),
-	  _m_children (die.children ())
+	  _m_attributes (die.attributes (), t),
+	  _m_children (die.children (), t)
       {}
 
       inline int tag () const
@@ -227,8 +231,9 @@ namespace elfutils
 
       // XXX should be private
     public:
-      template<typename die_type>
-      compile_unit (const die_type &die) : debug_info_entry (die)
+      template<typename die_type, typename tracker>
+      inline compile_unit (const die_type &die, tracker *t)
+	: debug_info_entry (die, t)
       {
 	if (die.tag () != ::DW_TAG_compile_unit)
 	  throw std::invalid_argument ("not a compile_unit entry");
@@ -248,12 +253,17 @@ namespace elfutils
       typedef std::list<compile_unit> _base;
 
       // Default constructor: an empty container, no CUs.
-      inline compile_units () {}
+      inline compile_units ()
+      {}
 
       // Constructor copying CUs from input container.
-      template<typename input>
-      compile_units(const input &units)
-	: _base (units.begin (), units.end ()) {}
+      template<typename input, typename tracker>
+      inline compile_units (const input &units, tracker *t)
+	: _base (subr::argify<input, compile_units, tracker *>
+		 (units.begin (), t),
+		 subr::argify<input, compile_units, tracker *>
+		 (units.end (), t))
+      {}
 
     public:
       typedef compile_unit value_type;
@@ -302,8 +312,10 @@ namespace elfutils
     inline dwarf_edit () {}
 
     // Constructor copying CUs from an input file (dwarf or dwarf_edit).
-    template<typename input>
-    dwarf_edit (const input &dw) : _m_units (dw.compile_units ()) {}
+    template<typename input, typename tracker>
+    dwarf_edit (const input &dw, tracker *t)
+      : _m_units (dw.compile_units (), t)
+    {}
 
     template<typename file>
     inline bool operator== (const file &other) const
diff --git a/libdw/c++/dwarf_output b/libdw/c++/dwarf_output
index 65bff72f..ff2621ba 100644
--- a/libdw/c++/dwarf_output
+++ b/libdw/c++/dwarf_output
@@ -291,19 +291,20 @@ namespace elfutils
     static inline const std::string &
     collect_string (dwarf_output_collector *, const input &);
 
-    template<typename input>
-    static inline const range_list &
-    collect (dwarf_output_collector *, const typename input::range_list &);
-
     /* 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).  */
-    typedef dwarf_data::constructor_arg_adapter<dwarf_output,
-						dwarf_output_collector *>
-    collectify;
+    template<typename input, typename output>
+    static inline typename subr::argifier<input, output,
+					  dwarf_output_collector *>::wrapped
+    collectify (const typename input::const_iterator &in,
+		dwarf_output_collector *c)
+    {
+      return subr::argifier<input, output, dwarf_output_collector *> (c) (in);
+    }
 
     struct value_wrapper
-      : public dwarf_data::value<dwarf_output, dwarf_output_collector *>
+      : public dwarf_data::value<dwarf_output>
     {
       struct value_string : public value_dispatch
       {
@@ -327,13 +328,33 @@ namespace elfutils
 	  return result;
 	}
       };
+
+      template<typename flavor, typename input>
+      static inline value_dispatch *
+      make (flavor *&result, const input &x, const dwarf_data::nothing &)
+      {
+	throw std::logic_error ("dwarf_output cannot be default-constructed");
+      }
+
+      template<typename flavor, typename input, typename arg_type>
+      static inline value_dispatch *
+      make (flavor *&result, const input &x, const arg_type &arg)
+      {
+	return result = new flavor (x, arg);
+      }
+
+      template<typename input>
+      static inline value_dispatch *
+      make (value_string *&result, const input &x, dwarf_output_collector *c)
+      {
+	return result = new value_string (x, c);
+      }
+
     };
 
   public:
 
-    typedef dwarf_data::attr_value<dwarf_output,
-				   dwarf_output_collector *,
-				   value_wrapper> attr_value;
+    typedef dwarf_data::attr_value<dwarf_output, value_wrapper> attr_value;
 
     class compile_units;
 
@@ -350,8 +371,8 @@ namespace elfutils
 	template<typename input>
 	inline children_type (const input &other, dwarf_output_collector *c)
 	  : std::list<debug_info_entry>
-	    (collectify::argify<input, children_type> (c) (other.begin ()),
-	     collectify::argify<input, children_type> (c) (other.end ()))
+	    (collectify<input, children_type> (other.begin (), c),
+	     collectify<input, children_type> (other.end (), c))
 	{}
 
       public:
@@ -478,8 +499,8 @@ namespace elfutils
       // Constructor copying CUs from input container.
       template<typename input>
       compile_units (const input &units, dwarf_output_collector *c)
-	: _base (collectify::argify<input, compile_units> (c) (units.begin ()),
-		 collectify::argify<input, compile_units> (c) (units.end ()))
+	: _base (collectify<input, compile_units> (units.begin (), c),
+		 collectify<input, compile_units> (units.end (), c))
       {
       }
 
@@ -563,14 +584,6 @@ namespace elfutils
     return c->_m_strings.add (s);
   }
 
-  template<typename input>
-  inline const dwarf_output::range_list &
-  dwarf_output::collect (dwarf_output_collector *c,
-			 const typename input::range_list &rl)
-  {
-    return c->_m_ranges.add (rl);
-  }
-
 };
 
 #endif	// <elfutils/dwarf_output>
diff --git a/libdw/c++/dwarf_tracker b/libdw/c++/dwarf_tracker
index 8382d2e1..c27a737f 100644
--- a/libdw/c++/dwarf_tracker
+++ b/libdw/c++/dwarf_tracker
@@ -52,6 +52,8 @@
 
 #include "dwarf"
 #include "dwarf_comparator"
+#include <tr1/unordered_map>
+#include <tr1/unordered_set>
 
 namespace elfutils
 {
@@ -62,95 +64,262 @@ namespace elfutils
   private:
     typedef dwarf_tracker_base<dwarf1, dwarf2> _base;
 
+  public:
     typedef typename _base::cu1 cu1;
     typedef typename _base::cu2 cu2;
     typedef typename _base::die1 die1;
     typedef typename _base::die2 die2;
 
-    /* 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.  */
+  private:
     template<typename cu, typename die>
     struct tracker
     {
-      cu _m_root;
-
+      /* 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.  */
       typedef std::list<die> die_path;
-      die_path _m_path;
+
+      // We use a singleton list of a default-constructed iterator as a marker.
+      static inline const die_path bad_die_path ()
+      {
+	return die_path (1);
+      }
+      static inline bool bad_die_path (const die_path &path)
+      {
+	typename die_path::const_iterator it = path.begin ();
+	if (it == path.end ())
+	  return false;
+	const die &elt = *it;
+	return ++it == path.end () && elt == die ();
+      }
 
       /* We record every DIE we have seen here, mapping its .identity ()
 	 to the die_path of parent DIEs taken to reach it.  */
       typedef std::tr1::unordered_map< ::Dwarf_Off, const die_path> die_map;
-      die_map _m_seen;
+      die_map *_m_seen;
+      bool _m_delete_seen;
+
+      cu _m_root;
+
+      die_path _m_path;
+
+      // Default constructor: an original tracker.
+      inline tracker ()
+	: _m_seen (new die_map), _m_delete_seen (true)
+      {}
 
-      ~tracker ()
+      // Construct a derived tracker: does its own walk, but sharing caches.
+      inline tracker (const tracker &proto,
+		      const die_path &context, const die &there)
+	: _m_seen (proto._m_seen), _m_delete_seen (false),
+	  _m_root (proto._m_root), _m_path (context)
       {
-	// We should never be left with a partial walk on the books.
-	assert (_m_path.empty ());
+	_m_path.push_back (there);
       }
 
-      inline const die_path &path_to (const die &a)
+      inline ~tracker ()
       {
-	typename die_map::iterator it = _m_seen.find (a->identity ());
-	if (it == _m_seen.end ())
+	if (_m_delete_seen)
 	  {
-	    ::Dwarf_Off id = a->identity ();
-	    die_path path;
-	    if (!walk_to (*_m_root, id, path))
-	      throw std::runtime_error ("DIE not reachable from CU!");
-	    it = _m_seen.insert (std::make_pair (id, path)).first;
+	    delete _m_seen;
+	    // We should never be left with a partial walk on the books.
+	    assert (_m_path.empty ());
 	  }
-	return it->second;
       }
 
-      // Return true if this is the droid we're looking for,
-      // or recurse on its children.
-      bool walk_to (const typename die::value_type from, ::Dwarf_Off to,
-		    die_path &path)
-      {
-	if (from.identity () == to)
-	  return true;
-	for (die it = from.children ().begin ();
-	     it != from.children ().end ();
-	     ++it)
-	  if (walk_to (it, to, path))
-	    return true;
-	return false;
+      // 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
+      {
+	tracker *_m_tracker;
+	inline walk (tracker *w, const cu &root)
+	  : _m_tracker (w)
+	{
+	  assert (_m_tracker->_m_path.empty ());
+	  _m_tracker->_m_root = root;
+	}
+	inline ~walk ()
+	{
+	  assert (_m_tracker->_m_path.empty ());
+	  _m_tracker->_m_root = cu ();
+	}
+      };
+
+      /* 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
+      {
+	tracker *_m_walker;
+	inline step (tracker *w, const die &here)
+	  : _m_walker (w)
+	{
+	  // Record the path down from the CU to see this DIE.
+	  _m_walker->_m_seen->insert (std::make_pair (here->identity (),
+						      _m_walker->_m_path));
+
+	  // Append this DIE to the path we'll record for its children.
+	  _m_walker->_m_path.push_back (here);
+	}
+	inline ~step ()
+	{
+	  _m_walker->_m_path.pop_back ();
+	}
+      };
+
+      // Random access to a DIE, find the path of the walk that gets there.
+      inline const die_path &path_to (const die &a)
+      {
+	::Dwarf_Off id = a->identity ();
+	std::pair<typename die_map::iterator, bool> found
+	  = _m_seen->insert (std::make_pair (id, bad_die_path ()));
+	if (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 do a separate walk to find it.  Since we know
+	       this is a forward reference, we don't have to start a
+	       fresh walk from the root, just momentarily wind forward
+	       from where we are.  */
+	    && !walk_down_to (a, found.first)
+	    && !walk_over_to (a, found.first)
+	    && !walk_up_to (a, found.first))
+	  throw std::runtime_error ("DIE not reachable from CU!");
+	assert (&found.first->second != NULL);
+	assert (!bad_die_path (found.first->second));
+	return found.first->second;
+      }
+
+      inline bool walk_to (const typename die::value_type &here,
+			   const die &there, typename die_map::iterator &cache)
+      {
+	return walk_to (here.children ().begin (),
+			here.children ().end (),
+			there, cache);
       }
 
-      // Recursing on a child, include FROM in the path if the child matches.
-      bool walk_to (const die from, ::Dwarf_Off to, die_path &path)
+      bool walk_to (die it, const die &end,
+		    const die &there, typename die_map::iterator &cache)
       {
-	if (walk_to (*from, to, path))
+	for (; it != end; ++it)
 	  {
-	    path.push_front (from);
-	    return true;
+	    if (it == there)
+	      {
+		/* We can't keep the old CACHE iterator and avoid this
+		   find (hash lookup), because there could have been
+		   other insertions in the map since it was taken.
+		   Those can invalidate old iterators.  */
+		cache = _m_seen->find (there->identity ());
+		_m_seen->erase (cache);
+		cache = _m_seen->insert (cache,
+					 std::make_pair (there->identity (),
+							 _m_path));
+		return true;
+	      }
+	    else
+	      {
+		/* Do "step into" even for !has_children ()
+		   because it records this child in _m_seen,
+		   which we will rely on later.  */
+		step into (this, it);
+		const typename die::value_type &child = *it;
+		if (child.has_children () && walk_to (child, there, cache))
+		  return true;
+	      }
 	  }
 	return false;
       }
 
-      inline void start_walk (const cu &a)
+      /* 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 (const die &there,
+				typename die_map::iterator &cache)
       {
-	assert (_m_path.empty ());
-	_m_root = a;
-      }
+	const die &start = _m_path.back ();
+	const typename die::value_type &here = *start;
 
-      inline void finish_walk (const cu &a)
-      {
-	assert (_m_path.empty ());
-	_m_root = cu ();
+	/* It's common to have a reference to the next sibling DIE.
+	   So bypass the descent to HERE's children if THERE is
+	   HERE's immediate next sibling.  */
+	if (!here.has_children () || there == ++die (start))
+	  return false;
+
+	return walk_to (here, there, cache);
       }
 
-      inline void pre_order (const die &a)
+      /* A step_back object pops the current DIE off _m_path when
+	 constructed, and pushes it back when destroyed.  */
+      struct step_back
+      {
+	tracker *_m_walker;
+	const die _m_here;
+	inline step_back (tracker *w, die &copy)
+	  : _m_walker (w), _m_here (w->_m_path.back ())
+	{
+	  w->_m_path.pop_back ();
+	  copy = _m_here;
+	}
+	inline ~step_back ()
+	{
+	  _m_walker->_m_path.push_back (_m_here);
+	}
+      };
+
+      /* Now wind the walk forward starting from the current DIE's
+	 immediate sibling.  */
+      inline bool walk_over_to (const die &there,
+				typename die_map::iterator &cache)
       {
-	// Record the path down from the CU to see this DIE.
-	_m_seen.insert (std::make_pair (a->identity (), _m_path));
-	// Append this DIE to the path we'll record for its children.
-	_m_path.push_back (a);
+	die next;
+	step_back from (this, next);
+	++next;
+
+	return walk_to (next, (_m_path.empty ()
+			       ? (*_m_root).children ().end ()
+			       : _m_path.back ()->children ().end ()),
+			there, cache);
       }
 
-      inline void post_order (const die &a)
+      /* A step_up object saves _m_path when constructed
+	 and restores it when destroyed.  */
+      struct step_up
       {
-	_m_path.pop_back ();
+	tracker *_m_walker;
+	die_path _m_save;
+	inline step_up (tracker *w)
+	  : _m_walker (w), _m_save (w->_m_path)
+	{
+	}
+	inline ~step_up ()
+	{
+	  _m_walker->_m_path.swap (_m_save);
+	}
+      };
+
+      /* Now wind the walk forward starting from the current DIE's
+	 parent's immediate sibling.  */
+      inline bool walk_up_to (const die &there,
+			      typename die_map::iterator &cache)
+      {
+	if (_m_path.empty ())
+	  return false;
+
+	step_up from (this);
+
+	do
+	  {
+	    _m_path.pop_back ();
+	    assert (!_m_path.empty ());
+	    if (walk_over_to (there, cache))
+	      return true;
+	  }
+	while (!_m_path.empty ());
+
+	return false;
       }
     };
 
@@ -160,6 +329,13 @@ namespace elfutils
     tracker1 _m_left;
     tracker2 _m_right;
 
+    typedef std::tr1::unordered_map<
+      ::Dwarf_Off, std::pair<const die2 *,
+			     std::tr1::unordered_set< ::Dwarf_Off> >
+      > equiv_map;
+    equiv_map *_m_equiv;
+    bool _m_delete_equiv;
+
     /* 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
@@ -175,37 +351,44 @@ namespace elfutils
     };
 
   public:
-    inline void start_walk (const cu1 &a, const cu2 &b)
-    {
-      _m_left.start_walk (a);
-      _m_right.start_walk (b);
-    }
+    inline dwarf_ref_tracker ()
+      : _m_equiv (new equiv_map), _m_delete_equiv (true)
+    {}
 
-    inline void finish_walk (const cu1 &a, const cu2 &b)
+    inline void reset ()
     {
-      _m_left.finish_walk (a);
-      _m_right.finish_walk (b);
+      _m_equiv->clear ();
+      assert (!_m_right->_m_delete_seen);
+      _m_right._m_seen->clear ();
     }
 
-    inline void pre_order (const die1 &a, const die2 &b)
+    struct walk
     {
-      _m_left.pre_order (a);
-      _m_right.pre_order (b);
-    }
+      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)
+      {}
+    };
 
-    inline void post_order (const die1 &a, const die2 &b)
+    struct step
     {
-      _m_left.post_order (a);
-      _m_right.post_order (b);
-    }
+      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 std::list<die1> left_context_type;
+    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 std::list<die2> right_context_type;
+    typedef typename tracker2::die_path right_context_type;
     inline const right_context_type &right_context (const die2 &die)
     {
       return _m_right.path_to (die);
@@ -225,6 +408,80 @@ namespace elfutils
     {
       return std::equal (a.begin (), a.end (), b.begin (), equal_enough ());
     }
+
+    class reference_match
+    {
+      friend class dwarf_ref_tracker;
+    private:
+      typename equiv_map::mapped_type *_m_elt;
+
+    public:
+
+      inline reference_match ()
+	: _m_elt (NULL)
+      {}
+
+      inline ~reference_match ()
+      {
+	if (_m_elt != NULL)
+	  _m_elt->first = NULL;
+      }
+
+      inline bool cannot_match () const
+      {
+	return _m_elt == NULL;
+      }
+
+      inline void notice_match (const die2 &b, bool matches) const
+      {
+	if (matches && _m_elt != NULL)
+	  _m_elt->second.insert (b->identity ());
+      }
+    };
+
+    inline bool
+    reference_matched (reference_match &matched, const die1 &a, const die2 &b)
+    {
+      typename equiv_map::mapped_type *elt = &(*_m_equiv)[a->identity ()];
+      if (elt->first == NULL)
+	{
+	  /* 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;
+	  matched._m_elt = elt;
+
+	  // Short-circuit if we have already matched B to A.
+	  return elt->second.find (b->identity ()) != elt->second.end ();
+	}
+
+      /* We have a circularity.  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.  */
+
+      return *elt->first == b;
+    }
+
+    // Share the _m_seen maps with the prototype tracker,
+    // but start a fresh walk from the given starting point.
+    inline dwarf_ref_tracker (const dwarf_ref_tracker &proto,
+			      reference_match &matched,
+			      const left_context_type &lhs, const die1 &a,
+			      const right_context_type &rhs, const die2 &b)
+      : _m_left (tracker1 (proto._m_left, lhs, a)),
+	_m_right (tracker2 (proto._m_right, rhs, b)),
+	_m_equiv (proto._m_equiv), _m_delete_equiv (false)
+    {
+      // We are starting a recursive consideration of a vs b.
+    }
   };
 };
 
diff --git a/libdw/c++/subr.hh b/libdw/c++/subr.hh
index 4a90e50c..7a799eeb 100644
--- a/libdw/c++/subr.hh
+++ b/libdw/c++/subr.hh
@@ -603,6 +603,98 @@ namespace elfutils
 	return (*_m_wrapper) (_base::operator* ());
       }
     };
+
+    /* 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>
+    {
+      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>
+      {
+	arg_type _m_arg;
+	explicit inline maker (const arg_type &c) : _m_arg (c) {}
+
+	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 subr::wrapped_input_iterator<input, maker> wrapped;
+
+      inline wrapped operator () (const inny &i)
+      {
+	return wrapped (i, _m_maker);
+      }
+    };
+
+    template<typename input, typename output, typename arg_type>
+    static inline typename argifier<input, output, arg_type>::wrapped
+    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 maker
+	: public std::unary_function<inlet, outlet>
+      {
+	arg_type _m_arg;
+	explicit inline maker (const arg_type &c) : _m_arg (c) {}
+
+	inline outlet operator () (const inlet &x) const
+	{
+	  return std::make_pair (x.first,
+				 typename outlet::second_type (x.second,
+							       _m_arg));
+	}
+      } _m_maker;
+
+      explicit inline argifier2nd (const arg_type &c)
+	: _m_maker (c)
+      {}
+
+      typedef subr::wrapped_input_iterator<input, maker> wrapped;
+
+      inline wrapped operator () (const inny &i)
+      {
+	return wrapped (i, _m_maker);
+      }
+    };
+
+    template<typename input, typename output, typename arg_type>
+    static inline typename argifier2nd<input, output, arg_type>::wrapped
+    argify2nd (const typename input::const_iterator &in, const arg_type &arg)
+    {
+      return argifier2nd<input, output, arg_type> (arg) (in);
+    }
+
   };
 };
 
diff --git a/po/de.po b/po/de.po
index d0476b1e..1e9f1d68 100644
--- a/po/de.po
+++ b/po/de.po
@@ -6,14 +6,14 @@
 #
 # Thomas Spura <tomspur@fedoraproject.org>, 2009.
 # Cornelius Neckenig <tbull@fedoraproject.org>, 2009.
-# Michael Münch <micm@fsfe.org>, 2009.
+# Michael Münch <micm@fedoraproject.org>, 2009.
 msgid ""
 msgstr ""
 "Project-Id-Version: elfutils VERSION\n"
 "Report-Msgid-Bugs-To: http://bugzilla.redhat.com/\n"
-"POT-Creation-Date: 2009-06-19 02:18+0000\n"
-"PO-Revision-Date: 2009-06-19 10:59+0200\n"
-"Last-Translator: Michael Münch <micm@fsfe.org>\n"
+"POT-Creation-Date: 2009-06-29 08:35+0000\n"
+"PO-Revision-Date: 2009-06-29 15:15+0200\n"
+"Last-Translator: Michael Münch <micm@fedoraproject.org>\n"
 "Language-Team: German\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -22,7 +22,7 @@ msgstr ""
 "X-Generator: Lokalize 0.3\n"
 
 #: ../lib/xmalloc.c:51 ../lib/xmalloc.c:65 ../lib/xmalloc.c:79
-#: ../src/readelf.c:2788 ../src/readelf.c:3126 ../src/unstrip.c:2086
+#: ../src/readelf.c:2796 ../src/readelf.c:3135 ../src/unstrip.c:2086
 #: ../src/unstrip.c:2294
 #, c-format
 msgid "memory exhausted"
@@ -56,7 +56,7 @@ msgstr "ungültige Grösse des Quell-Operanden"
 msgid "invalid size of destination operand"
 msgstr "ungültige Grösse des Ziel-Operanden"
 
-#: ../libelf/elf_error.c:108 ../src/readelf.c:4677
+#: ../libelf/elf_error.c:108 ../src/readelf.c:4686
 #, c-format
 msgid "invalid encoding"
 msgstr "ungültige Kodierung"
@@ -152,7 +152,7 @@ msgstr "data/scn Unterschied"
 msgid "invalid section header"
 msgstr "ungültiger Abschnitts-Header"
 
-#: ../libelf/elf_error.c:208 ../src/readelf.c:6147 ../src/readelf.c:6248
+#: ../libelf/elf_error.c:208 ../src/readelf.c:6156 ../src/readelf.c:6257
 #, c-format
 msgid "invalid data"
 msgstr "Ungültige Daten"
@@ -209,7 +209,7 @@ msgstr "ungültiger Parameter"
 
 #: ../libasm/asm_error.c:66
 msgid "cannot change mode of output file"
-msgstr ""
+msgstr "konnte Modus der Ausgabedatei nicht ändern"
 
 #. Something went wrong.
 #: ../libasm/asm_error.c:67 ../src/ldgeneric.c:7001
@@ -578,7 +578,7 @@ msgstr "'%' ist nur mit der Option 'x' von Bedeutung"
 msgid "archive name required"
 msgstr "Archivname erforderlich"
 
-#: ../src/ar.c:289 ../src/nm.c:253 ../src/readelf.c:434 ../src/size.c:219
+#: ../src/ar.c:289 ../src/nm.c:253 ../src/readelf.c:442 ../src/size.c:219
 #: ../src/strip.c:203 ../src/ld.c:957 ../src/elflint.c:238
 #: ../src/addr2line.c:185 ../src/findtextrel.c:170 ../src/elfcmp.c:522
 #: ../src/ranlib.c:136 ../src/strings.c:227 ../src/unstrip.c:233
@@ -594,7 +594,7 @@ msgstr ""
 "GARANTIE,\n"
 "auch nicht für Marktgängigkeit oder Eignung für einen Bestimmten Zweck.\n"
 
-#: ../src/ar.c:294 ../src/nm.c:258 ../src/readelf.c:439 ../src/size.c:224
+#: ../src/ar.c:294 ../src/nm.c:258 ../src/readelf.c:447 ../src/size.c:224
 #: ../src/strip.c:208 ../src/ld.c:962 ../src/elflint.c:243
 #: ../src/addr2line.c:190 ../src/findtextrel.c:175 ../src/elfcmp.c:527
 #: ../src/ranlib.c:141 ../src/strings.c:232 ../src/unstrip.c:238
@@ -731,7 +731,7 @@ msgstr "\"Konnte ELF-Kopf von %s(%s): %s nicht lesen"
 
 #: ../src/nm.c:74 ../src/readelf.c:72 ../src/strip.c:72
 msgid "Output selection:"
-msgstr "Auswahl der Ausgabe:"
+msgstr ""
 
 #: ../src/nm.c:75
 msgid "Display debugger-only symbols"
@@ -885,12 +885,12 @@ msgstr "%s%s%s: Dateiformat nicht erkannt"
 msgid "cannot create search tree"
 msgstr "Kann Suchbaum nicht erstellen"
 
-#: ../src/nm.c:740 ../src/nm.c:1002 ../src/readelf.c:852 ../src/readelf.c:995
-#: ../src/readelf.c:1136 ../src/readelf.c:1318 ../src/readelf.c:1516
-#: ../src/readelf.c:1702 ../src/readelf.c:1912 ../src/readelf.c:2166
-#: ../src/readelf.c:2232 ../src/readelf.c:2310 ../src/readelf.c:2807
-#: ../src/readelf.c:2843 ../src/readelf.c:2905 ../src/readelf.c:6397
-#: ../src/readelf.c:7263 ../src/readelf.c:7408 ../src/readelf.c:7477
+#: ../src/nm.c:740 ../src/nm.c:1002 ../src/readelf.c:860 ../src/readelf.c:1003
+#: ../src/readelf.c:1144 ../src/readelf.c:1326 ../src/readelf.c:1524
+#: ../src/readelf.c:1710 ../src/readelf.c:1920 ../src/readelf.c:2174
+#: ../src/readelf.c:2240 ../src/readelf.c:2318 ../src/readelf.c:2815
+#: ../src/readelf.c:2851 ../src/readelf.c:2913 ../src/readelf.c:6406
+#: ../src/readelf.c:7272 ../src/readelf.c:7417 ../src/readelf.c:7486
 #: ../src/size.c:425 ../src/size.c:499 ../src/strip.c:482 ../src/objdump.c:744
 #, c-format
 msgid "cannot get section header string table index"
@@ -969,11 +969,11 @@ msgstr ""
 
 #: ../src/readelf.c:78
 msgid "Display the program headers"
-msgstr ""
+msgstr "Programm-Köpfe anzeigen"
 
 #: ../src/readelf.c:80
 msgid "Display relocations"
-msgstr ""
+msgstr "Relocations anzeigen"
 
 #: ../src/readelf.c:81
 msgid "Display the sections' header"
@@ -981,11 +981,11 @@ msgstr ""
 
 #: ../src/readelf.c:83
 msgid "Display the symbol table"
-msgstr ""
+msgstr "Symboltabelle anzeigen"
 
 #: ../src/readelf.c:84
 msgid "Display versioning information"
-msgstr ""
+msgstr "Versionierungsinformationen anzeigen"
 
 #: ../src/readelf.c:86
 msgid ""
@@ -995,11 +995,11 @@ msgstr ""
 
 #: ../src/readelf.c:89
 msgid "Display the core notes"
-msgstr ""
+msgstr "Kernnotizen anzeigen"
 
 #: ../src/readelf.c:91
 msgid "Display architecture specific information (if any)"
-msgstr ""
+msgstr "Architekturspezifische Informationen anzeigen (falls vorhanden)"
 
 #: ../src/readelf.c:93
 msgid "Dump the uninterpreted contents of SECTION, by number or name"
@@ -1011,283 +1011,287 @@ msgstr ""
 
 #: ../src/readelf.c:98
 msgid "Display the symbol index of an archive"
-msgstr ""
+msgstr "Symbolindex des Archivs anzeigen"
 
 #: ../src/readelf.c:99
 msgid "Display sections for exception handling"
-msgstr ""
+msgstr "Abschnitte für Ausnahmebehandlung anzeigen"
 
 #: ../src/readelf.c:102
 msgid "Output control:"
-msgstr ""
+msgstr "Ausgabekontrolle:"
+
+#: ../src/readelf.c:104
+msgid "Do not find symbol names for addresses in DWARF data"
+msgstr "Keine symbolischen Namen für Adressen in DWARF-Daten suchen"
 
 #. Short description of program.
-#: ../src/readelf.c:108
+#: ../src/readelf.c:110
 msgid "Print information from ELF file in human-readable form."
-msgstr ""
+msgstr "Informationen aus der ELF-Datei in menschenlesbarer Form ausgeben."
 
 #. Strings for arguments in help texts.
-#: ../src/readelf.c:112 ../src/elflint.c:85
+#: ../src/readelf.c:114 ../src/elflint.c:85
 msgid "FILE..."
-msgstr ""
+msgstr "DATEI..."
 
-#: ../src/readelf.c:261 ../src/elflint.c:158
+#: ../src/readelf.c:266 ../src/elflint.c:158
 #, c-format
 msgid "cannot open input file"
 msgstr "Kann Eingabedatei nicht öffnen"
 
-#: ../src/readelf.c:389
+#: ../src/readelf.c:394
 #, c-format
 msgid "Unknown DWARF debug section `%s'.\n"
 msgstr ""
 
-#: ../src/readelf.c:410 ../src/elflint.c:222
+#: ../src/readelf.c:418 ../src/elflint.c:222
 msgid "Missing file name.\n"
 msgstr "Dateiname fehlt.\n"
 
-#: ../src/readelf.c:415 ../src/objdump.c:236
+#: ../src/readelf.c:423 ../src/objdump.c:236
 msgid "No operation specified.\n"
 msgstr "Keine Operation angegeben.\n"
 
-#: ../src/readelf.c:450
+#: ../src/readelf.c:458
 #, c-format
 msgid "cannot generate Elf descriptor: %s"
-msgstr ""
+msgstr "konnte Elf-Deskriptor nicht erzeugen: %s"
 
-#: ../src/readelf.c:462
+#: ../src/readelf.c:470
 #, c-format
 msgid "'%s' is not an archive, cannot print archive index"
 msgstr ""
 
-#: ../src/readelf.c:467
+#: ../src/readelf.c:475
 #, c-format
 msgid "error while closing Elf descriptor: %s"
 msgstr ""
 
-#: ../src/readelf.c:559
+#: ../src/readelf.c:567
 #, c-format
 msgid "cannot stat input file"
 msgstr ""
 
-#: ../src/readelf.c:561
+#: ../src/readelf.c:569
 #, c-format
 msgid "input file is empty"
 msgstr ""
 
-#: ../src/readelf.c:563
+#: ../src/readelf.c:571
 #, c-format
 msgid "failed reading '%s': %s"
 msgstr "Konnte '%s' nicht lesen: %s"
 
-#: ../src/readelf.c:598
+#: ../src/readelf.c:606
 #, c-format
 msgid "cannot read ELF header: %s"
 msgstr ""
 
-#: ../src/readelf.c:606
+#: ../src/readelf.c:614
 #, c-format
 msgid "cannot create EBL handle"
 msgstr ""
 
-#: ../src/readelf.c:613 ../src/strip.c:542 ../src/ldgeneric.c:661
+#: ../src/readelf.c:621 ../src/strip.c:542 ../src/ldgeneric.c:661
 #: ../src/ldgeneric.c:1122
 #, c-format
 msgid "cannot determine number of sections: %s"
 msgstr ""
 
-#: ../src/readelf.c:699
+#: ../src/readelf.c:707
 msgid "NONE (None)"
 msgstr ""
 
-#: ../src/readelf.c:700
+#: ../src/readelf.c:708
 msgid "REL (Relocatable file)"
 msgstr ""
 
-#: ../src/readelf.c:701
+#: ../src/readelf.c:709
 msgid "EXEC (Executable file)"
 msgstr ""
 
-#: ../src/readelf.c:702
+#: ../src/readelf.c:710
 msgid "DYN (Shared object file)"
 msgstr ""
 
-#: ../src/readelf.c:703
+#: ../src/readelf.c:711
 msgid "CORE (Core file)"
 msgstr ""
 
-#: ../src/readelf.c:708
+#: ../src/readelf.c:716
 #, c-format
 msgid "OS Specific: (%x)\n"
 msgstr ""
 
 #. && e_type <= ET_HIPROC always true
-#: ../src/readelf.c:710
+#: ../src/readelf.c:718
 #, c-format
 msgid "Processor Specific: (%x)\n"
 msgstr ""
 
-#: ../src/readelf.c:720
+#: ../src/readelf.c:728
 msgid ""
 "ELF Header:\n"
 "  Magic:  "
 msgstr ""
 
-#: ../src/readelf.c:724
+#: ../src/readelf.c:732
 #, c-format
 msgid ""
 "\n"
 "  Class:                             %s\n"
 msgstr ""
 
-#: ../src/readelf.c:729
-#, c-format
+#: ../src/readelf.c:737
+#, fuzzy, c-format
 msgid "  Data:                              %s\n"
-msgstr ""
+msgstr "  Daten:                             %s\n"
 
-#: ../src/readelf.c:735
+#: ../src/readelf.c:743
 #, c-format
 msgid "  Ident Version:                     %hhd %s\n"
 msgstr ""
 
-#: ../src/readelf.c:737 ../src/readelf.c:754
+#: ../src/readelf.c:745 ../src/readelf.c:762
 msgid "(current)"
-msgstr ""
+msgstr "(aktuell)"
 
-#: ../src/readelf.c:741
+#: ../src/readelf.c:749
 #, c-format
 msgid "  OS/ABI:                            %s\n"
 msgstr ""
 
-#: ../src/readelf.c:744
+#: ../src/readelf.c:752
 #, c-format
 msgid "  ABI Version:                       %hhd\n"
 msgstr ""
 
-#: ../src/readelf.c:747
+#: ../src/readelf.c:755
 msgid "  Type:                              "
-msgstr ""
+msgstr "  Typ:                               "
 
-#: ../src/readelf.c:750
+#: ../src/readelf.c:758
 #, c-format
 msgid "  Machine:                           %s\n"
 msgstr ""
 
-#: ../src/readelf.c:752
+#: ../src/readelf.c:760
 #, c-format
 msgid "  Version:                           %d %s\n"
 msgstr ""
 
-#: ../src/readelf.c:756
+#: ../src/readelf.c:764
 #, c-format
 msgid "  Entry point address:               %#<PRIx64>\n"
 msgstr ""
 
-#: ../src/readelf.c:759
+#: ../src/readelf.c:767
 #, c-format
 msgid "  Start of program headers:          %<PRId64> %s\n"
 msgstr ""
 
-#: ../src/readelf.c:760 ../src/readelf.c:763
+#: ../src/readelf.c:768 ../src/readelf.c:771
 msgid "(bytes into file)"
 msgstr ""
 
-#: ../src/readelf.c:762
+#: ../src/readelf.c:770
 #, c-format
 msgid "  Start of section headers:          %<PRId64> %s\n"
 msgstr ""
 
-#: ../src/readelf.c:765
+#: ../src/readelf.c:773
 #, c-format
 msgid "  Flags:                             %s\n"
 msgstr ""
 
-#: ../src/readelf.c:768
+#: ../src/readelf.c:776
 #, c-format
 msgid "  Size of this header:               %<PRId16> %s\n"
 msgstr ""
 
-#: ../src/readelf.c:769 ../src/readelf.c:772 ../src/readelf.c:778
+#: ../src/readelf.c:777 ../src/readelf.c:780 ../src/readelf.c:786
 msgid "(bytes)"
-msgstr ""
+msgstr "(Bytes)"
 
-#: ../src/readelf.c:771
+#: ../src/readelf.c:779
 #, c-format
 msgid "  Size of program header entries:    %<PRId16> %s\n"
 msgstr ""
 
-#: ../src/readelf.c:774
+#: ../src/readelf.c:782
 #, c-format
 msgid "  Number of program headers entries: %<PRId16>\n"
 msgstr ""
 
-#: ../src/readelf.c:777
+#: ../src/readelf.c:785
 #, c-format
 msgid "  Size of section header entries:    %<PRId16> %s\n"
 msgstr ""
 
-#: ../src/readelf.c:780
+#: ../src/readelf.c:788
 #, c-format
 msgid "  Number of section headers entries: %<PRId16>"
 msgstr ""
 
-#: ../src/readelf.c:787
+#: ../src/readelf.c:795
 #, c-format
 msgid " (%<PRIu32> in [0].sh_size)"
 msgstr ""
 
-#: ../src/readelf.c:790 ../src/readelf.c:804
+#: ../src/readelf.c:798 ../src/readelf.c:812
 msgid " ([0] not available)"
 msgstr ""
 
 #. We managed to get the zeroth section.
-#: ../src/readelf.c:800
+#: ../src/readelf.c:808
 #, c-format
 msgid " (%<PRIu32> in [0].sh_link)"
 msgstr ""
 
-#: ../src/readelf.c:808
+#: ../src/readelf.c:816
 #, c-format
 msgid ""
 "  Section header string table index: XINDEX%s\n"
 "\n"
 msgstr ""
 
-#: ../src/readelf.c:812
+#: ../src/readelf.c:820
 #, c-format
 msgid ""
 "  Section header string table index: %<PRId16>\n"
 "\n"
 msgstr ""
 
-#: ../src/readelf.c:844
+#: ../src/readelf.c:852
 #, c-format
 msgid ""
 "There are %d section headers, starting at offset %#<PRIx64>:\n"
 "\n"
 msgstr ""
 
-#: ../src/readelf.c:854
+#: ../src/readelf.c:862
 msgid "Section Headers:"
 msgstr ""
 
-#: ../src/readelf.c:857
+#: ../src/readelf.c:865
 msgid ""
 "[Nr] Name                 Type         Addr     Off    Size   ES Flags Lk "
 "Inf Al"
 msgstr ""
 
-#: ../src/readelf.c:859
+#: ../src/readelf.c:867
 msgid ""
 "[Nr] Name                 Type         Addr             Off      Size     ES "
 "Flags Lk Inf Al"
 msgstr ""
 
-#: ../src/readelf.c:866 ../src/readelf.c:1019
+#: ../src/readelf.c:874 ../src/readelf.c:1027
 #, c-format
 msgid "cannot get section: %s"
 msgstr ""
 
-#: ../src/readelf.c:873 ../src/readelf.c:1027 ../src/readelf.c:7428
+#: ../src/readelf.c:881 ../src/readelf.c:1035 ../src/readelf.c:7437
 #: ../src/unstrip.c:352 ../src/unstrip.c:376 ../src/unstrip.c:426
 #: ../src/unstrip.c:535 ../src/unstrip.c:552 ../src/unstrip.c:590
 #: ../src/unstrip.c:788 ../src/unstrip.c:1056 ../src/unstrip.c:1243
@@ -1297,40 +1301,40 @@ msgstr ""
 msgid "cannot get section header: %s"
 msgstr ""
 
-#: ../src/readelf.c:931
+#: ../src/readelf.c:939
 msgid "Program Headers:"
-msgstr ""
+msgstr "Programm-Köpfe:"
 
-#: ../src/readelf.c:933
+#: ../src/readelf.c:941
 msgid ""
 "  Type           Offset   VirtAddr   PhysAddr   FileSiz  MemSiz   Flg Align"
 msgstr ""
 
-#: ../src/readelf.c:936
+#: ../src/readelf.c:944
 msgid ""
 "  Type           Offset   VirtAddr           PhysAddr           FileSiz  "
 "MemSiz   Flg Align"
 msgstr ""
 
-#: ../src/readelf.c:976
+#: ../src/readelf.c:984
 #, c-format
 msgid "\t[Requesting program interpreter: %s]\n"
 msgstr ""
 
-#: ../src/readelf.c:997
+#: ../src/readelf.c:1005
 msgid ""
 "\n"
 " Section to Segment mapping:\n"
 "  Segment Sections..."
 msgstr ""
 
-#: ../src/readelf.c:1008 ../src/unstrip.c:1823 ../src/unstrip.c:1862
+#: ../src/readelf.c:1016 ../src/unstrip.c:1823 ../src/unstrip.c:1862
 #: ../src/unstrip.c:1869
 #, c-format
 msgid "cannot get program header: %s"
 msgstr ""
 
-#: ../src/readelf.c:1142
+#: ../src/readelf.c:1150
 #, c-format
 msgid ""
 "\n"
@@ -1341,7 +1345,7 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1147
+#: ../src/readelf.c:1155
 #, c-format
 msgid ""
 "\n"
@@ -1352,15 +1356,15 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1155
+#: ../src/readelf.c:1163
 msgid "<INVALID SYMBOL>"
 msgstr ""
 
-#: ../src/readelf.c:1169
+#: ../src/readelf.c:1177
 msgid "<INVALID SECTION>"
 msgstr ""
 
-#: ../src/readelf.c:1320
+#: ../src/readelf.c:1328
 #, c-format
 msgid ""
 "\n"
@@ -1373,43 +1377,43 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1332
+#: ../src/readelf.c:1340
 msgid "  Type              Value\n"
 msgstr ""
 
-#: ../src/readelf.c:1356
+#: ../src/readelf.c:1364
 #, c-format
 msgid "Shared library: [%s]\n"
 msgstr ""
 
-#: ../src/readelf.c:1361
+#: ../src/readelf.c:1369
 #, c-format
 msgid "Library soname: [%s]\n"
 msgstr ""
 
-#: ../src/readelf.c:1366
+#: ../src/readelf.c:1374
 #, c-format
 msgid "Library rpath: [%s]\n"
 msgstr ""
 
-#: ../src/readelf.c:1371
+#: ../src/readelf.c:1379
 #, c-format
 msgid "Library runpath: [%s]\n"
 msgstr ""
 
-#: ../src/readelf.c:1391
+#: ../src/readelf.c:1399
 #, c-format
 msgid "%<PRId64> (bytes)\n"
 msgstr ""
 
-#: ../src/readelf.c:1501 ../src/readelf.c:1687
+#: ../src/readelf.c:1509 ../src/readelf.c:1695
 #, c-format
 msgid ""
 "\n"
 "Invalid symbol table at offset %#0<PRIx64>\n"
 msgstr ""
 
-#: ../src/readelf.c:1519 ../src/readelf.c:1704
+#: ../src/readelf.c:1527 ../src/readelf.c:1712
 #, c-format
 msgid ""
 "\n"
@@ -1425,7 +1429,7 @@ msgstr[1] ""
 #. The .rel.dyn section does not refer to a specific section but
 #. instead of section index zero.  Do not try to print a section
 #. name.
-#: ../src/readelf.c:1534
+#: ../src/readelf.c:1542
 #, c-format
 msgid ""
 "\n"
@@ -1436,38 +1440,38 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1544
+#: ../src/readelf.c:1552
 msgid "  Offset      Type                 Value       Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1546
+#: ../src/readelf.c:1554
 msgid "  Offset              Type                 Value               Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1599 ../src/readelf.c:1610 ../src/readelf.c:1623
-#: ../src/readelf.c:1641 ../src/readelf.c:1653 ../src/readelf.c:1772
-#: ../src/readelf.c:1784 ../src/readelf.c:1798 ../src/readelf.c:1817
-#: ../src/readelf.c:1830
+#: ../src/readelf.c:1607 ../src/readelf.c:1618 ../src/readelf.c:1631
+#: ../src/readelf.c:1649 ../src/readelf.c:1661 ../src/readelf.c:1780
+#: ../src/readelf.c:1792 ../src/readelf.c:1806 ../src/readelf.c:1825
+#: ../src/readelf.c:1838
 msgid "<INVALID RELOC>"
 msgstr ""
 
-#: ../src/readelf.c:1611 ../src/readelf.c:1785 ../src/objdump.c:379
+#: ../src/readelf.c:1619 ../src/readelf.c:1793 ../src/objdump.c:379
 msgid "INVALID SYMBOL"
 msgstr ""
 
-#: ../src/readelf.c:1642 ../src/readelf.c:1818 ../src/objdump.c:394
+#: ../src/readelf.c:1650 ../src/readelf.c:1826 ../src/objdump.c:394
 msgid "INVALID SECTION"
 msgstr ""
 
-#: ../src/readelf.c:1716
+#: ../src/readelf.c:1724
 msgid "  Offset      Type            Value       Addend Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1718
+#: ../src/readelf.c:1726
 msgid "  Offset              Type            Value               Addend Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1919
+#: ../src/readelf.c:1927
 #, c-format
 msgid ""
 "\n"
@@ -1478,40 +1482,40 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1925
+#: ../src/readelf.c:1933
 #, c-format
 msgid " %lu local symbol  String table: [%2u] '%s'\n"
 msgid_plural " %lu local symbols  String table: [%2u] '%s'\n"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:1935
+#: ../src/readelf.c:1943
 msgid "  Num:    Value   Size Type    Bind   Vis          Ndx Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1937
+#: ../src/readelf.c:1945
 msgid "  Num:            Value   Size Type    Bind   Vis          Ndx Name\n"
 msgstr ""
 
-#: ../src/readelf.c:1957
+#: ../src/readelf.c:1965
 #, c-format
 msgid "%5u: %0*<PRIx64> %6<PRId64> %-7s %-6s %-9s %6s %s"
 msgstr ""
 
-#: ../src/readelf.c:2045
+#: ../src/readelf.c:2053
 #, c-format
 msgid "bad dynamic symbol"
 msgstr ""
 
-#: ../src/readelf.c:2127
+#: ../src/readelf.c:2135
 msgid "none"
 msgstr "keine"
 
-#: ../src/readelf.c:2144
+#: ../src/readelf.c:2152
 msgid "| <unknown>"
 msgstr "| <unbekannt>"
 
-#: ../src/readelf.c:2169
+#: ../src/readelf.c:2177
 #, c-format
 msgid ""
 "\n"
@@ -1524,17 +1528,17 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:2192
+#: ../src/readelf.c:2200
 #, fuzzy, c-format
 msgid "  %#06x: Version: %hu  File: %s  Cnt: %hu\n"
 msgstr "  %#06x: Version: %hu  Datei: %s  Cnt: %hu\n"
 
-#: ../src/readelf.c:2205
+#: ../src/readelf.c:2213
 #, c-format
 msgid "  %#06x: Name: %s  Flags: %s  Version: %hu\n"
 msgstr "  %#06x: Name: %s  Flags: %s  Version: %hu\n"
 
-#: ../src/readelf.c:2236
+#: ../src/readelf.c:2244
 #, c-format
 msgid ""
 "\n"
@@ -1547,17 +1551,17 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:2266
+#: ../src/readelf.c:2274
 #, c-format
 msgid "  %#06x: Version: %hd  Flags: %s  Index: %hd  Cnt: %hd  Name: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:2281
+#: ../src/readelf.c:2289
 #, c-format
 msgid "  %#06x: Parent %d: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:2513
+#: ../src/readelf.c:2521
 #, c-format
 msgid ""
 "\n"
@@ -1570,15 +1574,15 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:2543
+#: ../src/readelf.c:2551
 msgid "   0 *local*                     "
 msgstr "   0 *lokal*                     "
 
-#: ../src/readelf.c:2548
+#: ../src/readelf.c:2556
 msgid "   1 *global*                    "
 msgstr "   1 *global*                    "
 
-#: ../src/readelf.c:2579
+#: ../src/readelf.c:2587
 #, c-format
 msgid ""
 "\n"
@@ -1593,41 +1597,41 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:2602
+#: ../src/readelf.c:2610
 #, c-format
 msgid " Length  Number  % of total  Coverage\n"
 msgstr ""
 
-#: ../src/readelf.c:2604
+#: ../src/readelf.c:2612
 #, c-format
 msgid "      0  %6<PRIu32>      %5.1f%%\n"
 msgstr "      0  %6<PRIu32>      %5.1f%%\n"
 
-#: ../src/readelf.c:2611
+#: ../src/readelf.c:2619
 #, c-format
 msgid "%7d  %6<PRIu32>      %5.1f%%    %5.1f%%\n"
 msgstr "%7d  %6<PRIu32>      %5.1f%%    %5.1f%%\n"
 
-#: ../src/readelf.c:2624
+#: ../src/readelf.c:2632
 #, c-format
 msgid ""
 " Average number of tests:   successful lookup: %f\n"
 "                          unsuccessful lookup: %f\n"
 msgstr ""
 
-#: ../src/readelf.c:2642 ../src/readelf.c:2684 ../src/readelf.c:2725
+#: ../src/readelf.c:2650 ../src/readelf.c:2692 ../src/readelf.c:2733
 #, c-format
 msgid "cannot get data for section %d: %s"
 msgstr ""
 
-#: ../src/readelf.c:2779
+#: ../src/readelf.c:2787
 #, c-format
 msgid ""
 " Symbol Bias: %u\n"
 " Bitmask Size: %zu bytes  %<PRIuFAST32>%% bits set  2nd hash shift: %u\n"
 msgstr ""
 
-#: ../src/readelf.c:2853
+#: ../src/readelf.c:2861
 #, c-format
 msgid ""
 "\n"
@@ -1638,13 +1642,13 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:2867
+#: ../src/readelf.c:2875
 msgid ""
 "       Library                       Time Stamp          Checksum Version "
 "Flags"
 msgstr ""
 
-#: ../src/readelf.c:2917
+#: ../src/readelf.c:2925
 #, c-format
 msgid ""
 "\n"
@@ -1652,132 +1656,132 @@ msgid ""
 "#0<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:2933
+#: ../src/readelf.c:2941
 msgid "  Owner          Size\n"
 msgstr ""
 
-#: ../src/readelf.c:2959
+#: ../src/readelf.c:2967
 #, c-format
 msgid "  %-13s  %4<PRIu32>\n"
 msgstr "  %-13s  %4<PRIu32>\n"
 
-#: ../src/readelf.c:2991
+#: ../src/readelf.c:2999
 #, c-format
 msgid "    %-4u %12<PRIu32>\n"
 msgstr "    %-4u %12<PRIu32>\n"
 
 #. Tag_File
-#: ../src/readelf.c:2996
+#: ../src/readelf.c:3004
 #, c-format
 msgid "    File: %11<PRIu32>\n"
 msgstr "    File: %11<PRIu32>\n"
 
-#: ../src/readelf.c:3031
+#: ../src/readelf.c:3039
 #, c-format
 msgid "      %s: %<PRId64>, %s\n"
 msgstr "      %s: %<PRId64>, %s\n"
 
-#: ../src/readelf.c:3034
+#: ../src/readelf.c:3042
 #, c-format
 msgid "      %s: %<PRId64>\n"
 msgstr "      %s: %<PRId64>\n"
 
-#: ../src/readelf.c:3037
+#: ../src/readelf.c:3045
 #, c-format
 msgid "      %s: %s\n"
 msgstr "      %s: %s\n"
 
-#: ../src/readelf.c:3044
+#: ../src/readelf.c:3052
 #, c-format
 msgid "      %u: %<PRId64>\n"
 msgstr "      %u: %<PRId64>\n"
 
-#: ../src/readelf.c:3047
+#: ../src/readelf.c:3055
 #, c-format
 msgid "      %u: %s\n"
 msgstr "      %u: %s\n"
 
-#: ../src/readelf.c:3082
+#: ../src/readelf.c:3091
 #, c-format
 msgid "%s+%#<PRIx64> <%s+%#<PRIx64>>"
 msgstr "%s+%#<PRIx64> <%s+%#<PRIx64>>"
 
-#: ../src/readelf.c:3085
+#: ../src/readelf.c:3094
 #, c-format
 msgid "%s+%#0*<PRIx64> <%s+%#<PRIx64>>"
 msgstr "%s+%#0*<PRIx64> <%s+%#<PRIx64>>"
 
-#: ../src/readelf.c:3090
+#: ../src/readelf.c:3099
 #, c-format
 msgid "%#<PRIx64> <%s+%#<PRIx64>>"
 msgstr "%#<PRIx64> <%s+%#<PRIx64>>"
 
-#: ../src/readelf.c:3093
+#: ../src/readelf.c:3102
 #, c-format
 msgid "%#0*<PRIx64> <%s+%#<PRIx64>>"
 msgstr "%#0*<PRIx64> <%s+%#<PRIx64>>"
 
-#: ../src/readelf.c:3099
+#: ../src/readelf.c:3108
 #, c-format
 msgid "%s+%#<PRIx64> <%s>"
 msgstr "%s+%#<PRIx64> <%s>"
 
-#: ../src/readelf.c:3102
+#: ../src/readelf.c:3111
 #, c-format
 msgid "%s+%#0*<PRIx64> <%s>"
 msgstr "%s+%#0*<PRIx64> <%s>"
 
-#: ../src/readelf.c:3106
+#: ../src/readelf.c:3115
 #, c-format
 msgid "%#<PRIx64> <%s>"
 msgstr "%#<PRIx64> <%s>"
 
-#: ../src/readelf.c:3109
+#: ../src/readelf.c:3118
 #, c-format
 msgid "%#0*<PRIx64> <%s>"
 msgstr "%#0*<PRIx64> <%s>"
 
-#: ../src/readelf.c:3114
+#: ../src/readelf.c:3123
 #, c-format
 msgid "%s+%#<PRIx64>"
 msgstr "%s+%#<PRIx64>"
 
-#: ../src/readelf.c:3117
+#: ../src/readelf.c:3126
 #, c-format
 msgid "%s+%#0*<PRIx64>"
 msgstr "%s+%#0*<PRIx64>"
 
-#: ../src/readelf.c:3225
+#: ../src/readelf.c:3234
 #, c-format
 msgid "unknown tag %hx"
-msgstr ""
+msgstr "unbekannter Tag %hx"
 
-#: ../src/readelf.c:3227
+#: ../src/readelf.c:3236
 #, c-format
 msgid "unknown user tag %hx"
-msgstr ""
+msgstr "unbekannter Benutzer-Tag %hx"
 
-#: ../src/readelf.c:3437
+#: ../src/readelf.c:3446
 #, c-format
 msgid "unknown attribute %hx"
-msgstr ""
+msgstr "unbekanntes Attribut %hx"
 
-#: ../src/readelf.c:3440
+#: ../src/readelf.c:3449
 #, c-format
 msgid "unknown user attribute %hx"
-msgstr ""
+msgstr "unbekanntes Benutzer-Attribut %hx"
 
-#: ../src/readelf.c:3486
+#: ../src/readelf.c:3495
 #, c-format
 msgid "unknown form %<PRIx64>"
-msgstr ""
+msgstr "unbekannte Form %<PRIx64>"
 
-#: ../src/readelf.c:4102
+#: ../src/readelf.c:4111
 #, c-format
 msgid "%*s[%4<PRIuMAX>] %s  <TRUNCATED>\n"
 msgstr ""
 
-#: ../src/readelf.c:4115
+#: ../src/readelf.c:4124
 #, c-format
 msgid ""
 "\n"
@@ -1785,37 +1789,37 @@ msgid ""
 " [ Code]\n"
 msgstr ""
 
-#: ../src/readelf.c:4122
+#: ../src/readelf.c:4131
 #, c-format
 msgid ""
 "\n"
 "Abbreviation section at offset %<PRIu64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:4135
+#: ../src/readelf.c:4144
 #, c-format
 msgid " *** error while reading abbreviation: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:4151
+#: ../src/readelf.c:4160
 #, c-format
 msgid " [%5u] offset: %<PRId64>, children: %s, tag: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:4154
+#: ../src/readelf.c:4163
 msgid "yes"
-msgstr ""
+msgstr "ja"
 
-#: ../src/readelf.c:4154
+#: ../src/readelf.c:4163
 msgid "no"
-msgstr ""
+msgstr "nein"
 
-#: ../src/readelf.c:4190
+#: ../src/readelf.c:4199
 #, c-format
 msgid "cannot get .debug_aranges content: %s"
 msgstr ""
 
-#: ../src/readelf.c:4195
+#: ../src/readelf.c:4204
 #, c-format
 msgid ""
 "\n"
@@ -1826,120 +1830,120 @@ msgid_plural ""
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:4225
+#: ../src/readelf.c:4234
 #, c-format
 msgid " [%*zu] ???\n"
-msgstr ""
+msgstr " [%*zu] ???\n"
 
-#: ../src/readelf.c:4227
+#: ../src/readelf.c:4236
 #, c-format
 msgid ""
 " [%*zu] start: %0#*<PRIx64>, length: %5<PRIu64>, CU DIE offset: %6<PRId64>\n"
 msgstr ""
 
-#: ../src/readelf.c:4246
+#: ../src/readelf.c:4255
 #, c-format
 msgid "cannot get .debug_ranges content: %s"
 msgstr ""
 
-#: ../src/readelf.c:4251 ../src/readelf.c:4708 ../src/readelf.c:5357
-#: ../src/readelf.c:5802 ../src/readelf.c:5897 ../src/readelf.c:6069
+#: ../src/readelf.c:4260 ../src/readelf.c:4717 ../src/readelf.c:5366
+#: ../src/readelf.c:5811 ../src/readelf.c:5906 ../src/readelf.c:6078
 #, c-format
 msgid ""
 "\n"
 "DWARF section [%2zu] '%s' at offset %#<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:4265 ../src/readelf.c:5816
+#: ../src/readelf.c:4274 ../src/readelf.c:5825
 #, c-format
 msgid " [%6tx]  <INVALID DATA>\n"
 msgstr ""
 
-#: ../src/readelf.c:4287 ../src/readelf.c:5838
+#: ../src/readelf.c:4296 ../src/readelf.c:5847
 #, c-format
 msgid " [%6tx]  base address %s\n"
 msgstr ""
 
 #. We have an address range entry.
 #. First address range entry in a list.
-#: ../src/readelf.c:4298
+#: ../src/readelf.c:4307
 #, c-format
 msgid " [%6tx]  %s..%s\n"
-msgstr ""
+msgstr " [%6tx]  %s..%s\n"
 
-#: ../src/readelf.c:4300
+#: ../src/readelf.c:4309
 #, c-format
 msgid "           %s..%s\n"
-msgstr ""
+msgstr "           %s..%s\n"
 
-#: ../src/readelf.c:4697 ../src/readelf.c:6135 ../src/readelf.c:6237
+#: ../src/readelf.c:4706 ../src/readelf.c:6144 ../src/readelf.c:6246
 #, c-format
 msgid "cannot get %s content: %s"
 msgstr ""
 
-#: ../src/readelf.c:4704
+#: ../src/readelf.c:4713
 #, c-format
 msgid ""
 "\n"
 "Call frame information section [%2zu] '%s' at offset %#<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:4731 ../src/readelf.c:5391
+#: ../src/readelf.c:4740 ../src/readelf.c:5400
 #, c-format
 msgid "invalid data in section [%zu] '%s'"
 msgstr ""
 
-#: ../src/readelf.c:4753
+#: ../src/readelf.c:4762
 #, c-format
 msgid ""
 "\n"
 " [%6tx] Zero terminator\n"
 msgstr ""
 
-#: ../src/readelf.c:4831
+#: ../src/readelf.c:4840
 msgid "FDE address encoding: "
 msgstr ""
 
-#: ../src/readelf.c:4837
+#: ../src/readelf.c:4846
 msgid "LSDA pointer encoding: "
 msgstr ""
 
-#: ../src/readelf.c:4882
+#: ../src/readelf.c:4891
 #, c-format
 msgid "invalid augmentation encoding"
 msgstr ""
 
-#: ../src/readelf.c:4953
+#: ../src/readelf.c:4962
 #, c-format
 msgid " (offset: %#<PRIx64>)"
 msgstr ""
 
-#: ../src/readelf.c:4960
+#: ../src/readelf.c:4969
 #, c-format
 msgid " (end offset: %#<PRIx64>)"
 msgstr ""
 
-#: ../src/readelf.c:4987
+#: ../src/readelf.c:4996
 #, c-format
 msgid "   %-26sLSDA pointer: %#<PRIx64>\n"
 msgstr ""
 
-#: ../src/readelf.c:5033
+#: ../src/readelf.c:5042
 #, c-format
 msgid "cannot get attribute code: %s"
 msgstr ""
 
-#: ../src/readelf.c:5041
+#: ../src/readelf.c:5050
 #, c-format
 msgid "cannot get attribute form: %s"
 msgstr ""
 
-#: ../src/readelf.c:5054
+#: ../src/readelf.c:5063
 #, c-format
 msgid "cannot get attribute value: %s"
 msgstr ""
 
-#: ../src/readelf.c:5236
+#: ../src/readelf.c:5245
 #, c-format
 msgid ""
 "\n"
@@ -1947,7 +1951,7 @@ msgid ""
 " [Offset]\n"
 msgstr ""
 
-#: ../src/readelf.c:5261
+#: ../src/readelf.c:5270
 #, c-format
 msgid ""
 " Compilation unit at offset %<PRIu64>:\n"
@@ -1955,37 +1959,37 @@ msgid ""
 "<PRIu8>, Offset size: %<PRIu8>\n"
 msgstr ""
 
-#: ../src/readelf.c:5279
+#: ../src/readelf.c:5288
 #, c-format
 msgid "cannot get DIE at offset %<PRIu64> in section '%s': %s"
 msgstr ""
 
-#: ../src/readelf.c:5290
+#: ../src/readelf.c:5299
 #, c-format
 msgid "cannot get DIE offset: %s"
 msgstr ""
 
-#: ../src/readelf.c:5298
+#: ../src/readelf.c:5307
 #, c-format
 msgid "cannot get tag of DIE at offset %<PRIu64> in section '%s': %s"
 msgstr ""
 
-#: ../src/readelf.c:5327
+#: ../src/readelf.c:5336
 #, c-format
 msgid "cannot get next DIE: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:5334
+#: ../src/readelf.c:5343
 #, c-format
 msgid "cannot get next DIE: %s"
 msgstr ""
 
-#: ../src/readelf.c:5369
+#: ../src/readelf.c:5378
 #, c-format
 msgid "cannot get line data section data: %s"
 msgstr ""
 
-#: ../src/readelf.c:5382
+#: ../src/readelf.c:5391
 #, c-format
 msgid ""
 "\n"
@@ -1993,7 +1997,7 @@ msgid ""
 msgstr ""
 
 #. Print what we got so far.
-#: ../src/readelf.c:5434
+#: ../src/readelf.c:5443
 #, c-format
 msgid ""
 "\n"
@@ -2009,163 +2013,163 @@ msgid ""
 "Opcodes:\n"
 msgstr ""
 
-#: ../src/readelf.c:5453
+#: ../src/readelf.c:5462
 #, c-format
 msgid "invalid data at offset %tu in section [%zu] '%s'"
 msgstr ""
 
-#: ../src/readelf.c:5468
+#: ../src/readelf.c:5477
 #, c-format
 msgid "  [%*<PRIuFAST8>]  %hhu argument\n"
 msgid_plural "  [%*<PRIuFAST8>]  %hhu arguments\n"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:5476
+#: ../src/readelf.c:5485
 msgid ""
 "\n"
 "Directory table:"
 msgstr ""
 
-#: ../src/readelf.c:5492
+#: ../src/readelf.c:5501
 msgid ""
 "\n"
 "File name table:\n"
 " Entry Dir   Time      Size      Name"
 msgstr ""
 
-#: ../src/readelf.c:5521
+#: ../src/readelf.c:5530
 msgid ""
 "\n"
 "Line number statements:"
 msgstr ""
 
-#: ../src/readelf.c:5582
+#: ../src/readelf.c:5591
 #, c-format
 msgid " special opcode %u: address+%u = %s, line%+d = %zu\n"
 msgstr ""
 
-#: ../src/readelf.c:5602
+#: ../src/readelf.c:5611
 #, c-format
 msgid " extended opcode %u: "
 msgstr ""
 
-#: ../src/readelf.c:5607
+#: ../src/readelf.c:5616
 msgid "end of sequence"
 msgstr ""
 
-#: ../src/readelf.c:5622
+#: ../src/readelf.c:5631
 #, c-format
 msgid "set address to %s\n"
 msgstr ""
 
-#: ../src/readelf.c:5643
+#: ../src/readelf.c:5652
 #, c-format
 msgid "define new file: dir=%u, mtime=%<PRIu64>, length=%<PRIu64>, name=%s\n"
 msgstr ""
 
 #. Unknown, ignore it.
-#: ../src/readelf.c:5652
+#: ../src/readelf.c:5661
 msgid "unknown opcode"
 msgstr ""
 
 #. Takes no argument.
-#: ../src/readelf.c:5664
+#: ../src/readelf.c:5673
 msgid " copy"
 msgstr ""
 
-#: ../src/readelf.c:5674
+#: ../src/readelf.c:5683
 #, c-format
 msgid "advance address by %u to %s\n"
 msgstr ""
 
-#: ../src/readelf.c:5685
+#: ../src/readelf.c:5694
 #, c-format
 msgid " advance line by constant %d to %<PRId64>\n"
 msgstr ""
 
-#: ../src/readelf.c:5693
+#: ../src/readelf.c:5702
 #, c-format
 msgid " set file to %<PRIu64>\n"
 msgstr ""
 
-#: ../src/readelf.c:5703
+#: ../src/readelf.c:5712
 #, c-format
 msgid " set column to %<PRIu64>\n"
 msgstr ""
 
-#: ../src/readelf.c:5710
+#: ../src/readelf.c:5719
 #, c-format
 msgid " set '%s' to %<PRIuFAST8>\n"
 msgstr ""
 
 #. Takes no argument.
-#: ../src/readelf.c:5716
+#: ../src/readelf.c:5725
 msgid " set basic block flag"
 msgstr ""
 
-#: ../src/readelf.c:5726
+#: ../src/readelf.c:5735
 #, c-format
 msgid "advance address by constant %u to %s\n"
 msgstr ""
 
-#: ../src/readelf.c:5742
+#: ../src/readelf.c:5751
 #, c-format
 msgid "advance address by fixed value %u to %s\n"
 msgstr ""
 
 #. Takes no argument.
-#: ../src/readelf.c:5751
+#: ../src/readelf.c:5760
 msgid " set prologue end flag"
 msgstr ""
 
 #. Takes no argument.
-#: ../src/readelf.c:5756
+#: ../src/readelf.c:5765
 msgid " set epilogue begin flag"
 msgstr ""
 
 #. This is a new opcode the generator but not we know about.
 #. Read the parameters associated with it but then discard
 #. everything.  Read all the parameters for this opcode.
-#: ../src/readelf.c:5765
+#: ../src/readelf.c:5774
 #, c-format
 msgid " unknown opcode with %<PRIu8> parameter:"
 msgid_plural " unknown opcode with %<PRIu8> parameters:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ../src/readelf.c:5797
+#: ../src/readelf.c:5806
 #, c-format
 msgid "cannot get .debug_loc content: %s"
 msgstr ""
 
 #. First entry in a list.
-#: ../src/readelf.c:5852
+#: ../src/readelf.c:5861
 #, c-format
 msgid " [%6tx]  %s..%s"
-msgstr ""
+msgstr " [%6tx]  %s..%s"
 
-#: ../src/readelf.c:5854
+#: ../src/readelf.c:5863
 #, c-format
 msgid "           %s..%s"
-msgstr ""
+msgstr "           %s..%s"
 
-#: ../src/readelf.c:5907
+#: ../src/readelf.c:5916
 #, c-format
 msgid "cannot get macro information section data: %s"
 msgstr ""
 
-#: ../src/readelf.c:5986
+#: ../src/readelf.c:5995
 #, c-format
 msgid "%*s*** non-terminated string at end of section"
 msgstr ""
 
-#: ../src/readelf.c:6054
+#: ../src/readelf.c:6063
 #, c-format
 msgid " [%5d] DIE offset: %6<PRId64>, CU DIE offset: %6<PRId64>, name: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:6093
+#: ../src/readelf.c:6102
 #, c-format
 msgid ""
 "\n"
@@ -2173,47 +2177,47 @@ msgid ""
 " %*s  String\n"
 msgstr ""
 
-#: ../src/readelf.c:6107
+#: ../src/readelf.c:6116
 #, c-format
 msgid " *** error while reading strings: %s\n"
 msgstr ""
 
-#: ../src/readelf.c:6127
+#: ../src/readelf.c:6136
 #, c-format
 msgid ""
 "\n"
 "Call frame search table section [%2zu] '.eh_frame_hdr':\n"
 msgstr ""
 
-#: ../src/readelf.c:6229
+#: ../src/readelf.c:6238
 #, c-format
 msgid ""
 "\n"
 "Exception handling table section [%2zu] '.gcc_except_table':\n"
 msgstr ""
 
-#: ../src/readelf.c:6252
+#: ../src/readelf.c:6261
 #, c-format
 msgid " LPStart encoding:    %#x "
 msgstr ""
 
-#: ../src/readelf.c:6264
+#: ../src/readelf.c:6273
 #, c-format
 msgid " TType encoding:      %#x "
 msgstr ""
 
-#: ../src/readelf.c:6278
+#: ../src/readelf.c:6287
 #, c-format
 msgid " Call site encoding:  %#x "
 msgstr ""
 
-#: ../src/readelf.c:6291
+#: ../src/readelf.c:6300
 msgid ""
 "\n"
 " Call site table:"
 msgstr ""
 
-#: ../src/readelf.c:6305
+#: ../src/readelf.c:6314
 #, c-format
 msgid ""
 " [%4u] Call site start:   %#<PRIx64>\n"
@@ -2222,143 +2226,143 @@ msgid ""
 "        Action:            %u\n"
 msgstr ""
 
-#: ../src/readelf.c:6365
+#: ../src/readelf.c:6374
 #, c-format
 msgid "invalid TType encoding"
 msgstr ""
 
-#: ../src/readelf.c:6388
+#: ../src/readelf.c:6397
 #, c-format
 msgid "cannot get debug context descriptor: %s"
 msgstr ""
 
-#: ../src/readelf.c:6523 ../src/readelf.c:7101
+#: ../src/readelf.c:6532 ../src/readelf.c:7110
 #, c-format
 msgid "cannot convert core note data: %s"
 msgstr ""
 
-#: ../src/readelf.c:6828
+#: ../src/readelf.c:6837
 #, c-format
 msgid ""
 "\n"
 "%*s... <repeats %u more times> ..."
 msgstr ""
 
-#: ../src/readelf.c:6870
+#: ../src/readelf.c:6879
 #, c-format
 msgid "unable to handle register number %d"
 msgstr ""
 
-#: ../src/readelf.c:7017
+#: ../src/readelf.c:7026
 #, c-format
 msgid "cannot get register info: %s"
 msgstr ""
 
-#: ../src/readelf.c:7041
+#: ../src/readelf.c:7050
 #, c-format
 msgid "cannot register info: %s"
 msgstr ""
 
-#: ../src/readelf.c:7199
+#: ../src/readelf.c:7208
 msgid "  Owner          Data size  Type\n"
 msgstr ""
 
-#: ../src/readelf.c:7217
+#: ../src/readelf.c:7226
 #, c-format
 msgid "  %-13.*s  %9<PRId32>  %s\n"
 msgstr ""
 
-#: ../src/readelf.c:7248
+#: ../src/readelf.c:7257
 #, c-format
 msgid "cannot get content of note section: %s"
 msgstr ""
 
-#: ../src/readelf.c:7275
+#: ../src/readelf.c:7284
 #, c-format
 msgid ""
 "\n"
 "Note section [%2zu] '%s' of %<PRIu64> bytes at offset %#0<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:7298
+#: ../src/readelf.c:7307
 #, c-format
 msgid ""
 "\n"
 "Note segment of %<PRIu64> bytes at offset %#0<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:7344
+#: ../src/readelf.c:7353
 #, c-format
 msgid ""
 "\n"
 "Section [%Zu] '%s' has no data to dump.\n"
 msgstr ""
 
-#: ../src/readelf.c:7350 ../src/readelf.c:7372
+#: ../src/readelf.c:7359 ../src/readelf.c:7381
 #, c-format
 msgid "cannot get data for section [%Zu] '%s': %s"
 msgstr ""
 
-#: ../src/readelf.c:7354
+#: ../src/readelf.c:7363
 #, c-format
 msgid ""
 "\n"
 "Hex dump of section [%Zu] '%s', %<PRIu64> bytes at offset %#0<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:7367
+#: ../src/readelf.c:7376
 #, c-format
 msgid ""
 "\n"
 "Section [%Zu] '%s' is empty.\n"
 msgstr ""
 
-#: ../src/readelf.c:7376
+#: ../src/readelf.c:7385
 #, c-format
 msgid ""
 "\n"
 "String section [%Zu] '%s' contains %<PRIu64> bytes at offset %#0<PRIx64>:\n"
 msgstr ""
 
-#: ../src/readelf.c:7423
+#: ../src/readelf.c:7432
 #, c-format
 msgid ""
 "\n"
 "section [%lu] does not exist"
 msgstr ""
 
-#: ../src/readelf.c:7449
+#: ../src/readelf.c:7458
 #, c-format
 msgid ""
 "\n"
 "section '%s' does not exist"
 msgstr ""
 
-#: ../src/readelf.c:7510
+#: ../src/readelf.c:7519
 #, c-format
 msgid "cannot get symbol index of archive '%s': %s"
 msgstr ""
 
-#: ../src/readelf.c:7513
+#: ../src/readelf.c:7522
 #, c-format
 msgid ""
 "\n"
 "Archive '%s' has no symbol index\n"
 msgstr ""
 
-#: ../src/readelf.c:7517
+#: ../src/readelf.c:7526
 #, c-format
 msgid ""
 "\n"
 "Index of archive '%s' has %Zu entries:\n"
 msgstr ""
 
-#: ../src/readelf.c:7535
+#: ../src/readelf.c:7544
 #, c-format
 msgid "cannot extract member at offset %Zu in '%s': %s"
 msgstr ""
 
-#: ../src/readelf.c:7540
+#: ../src/readelf.c:7549
 #, c-format
 msgid "Archive member '%s' contains:\n"
 msgstr ""
@@ -2409,7 +2413,7 @@ msgstr ""
 #: ../src/size.c:269
 #, c-format
 msgid "Invalid format: %s"
-msgstr ""
+msgstr "Ungültiges Format: %s"
 
 #: ../src/size.c:280
 #, c-format
@@ -2689,7 +2693,7 @@ msgstr ""
 
 #: ../src/ld.c:138
 msgid "ADDRESS"
-msgstr ""
+msgstr "ADRESSE"
 
 #: ../src/ld.c:138
 msgid "Set entry point address."
@@ -2824,7 +2828,7 @@ msgstr "[DATEI]..."
 #: ../src/ld.c:333
 #, c-format
 msgid "At least one input file needed"
-msgstr ""
+msgstr "Mindestens eine Eingabedatei benötigt"
 
 #: ../src/ld.c:349
 #, c-format
@@ -2839,12 +2843,12 @@ msgstr ""
 #: ../src/ld.c:397
 #, c-format
 msgid "-( without matching -)"
-msgstr ""
+msgstr "-( ohne Übereinstimmung -)"
 
 #: ../src/ld.c:572 ../src/ld.c:610
 #, c-format
 msgid "only one option of -G and -r is allowed"
-msgstr ""
+msgstr "nur eine Option aus -G und -r erlaubt"
 
 #: ../src/ld.c:594
 #, c-format
@@ -2874,7 +2878,7 @@ msgstr ""
 #: ../src/ld.c:785
 #, c-format
 msgid "More than one output file name given."
-msgstr ""
+msgstr "Mehr als ein Name der Ausgabedatei angegeben."
 
 #: ../src/ld.c:802
 #, c-format
@@ -2889,12 +2893,12 @@ msgstr ""
 #: ../src/ld.c:869
 #, c-format
 msgid "-) without matching -("
-msgstr ""
+msgstr "-) ohne Übereinstimmung -("
 
 #: ../src/ld.c:1046
 #, c-format
 msgid "unknown option '-%c %s'"
-msgstr ""
+msgstr "unbekannte Option '-%c %s'"
 
 #: ../src/ld.c:1150
 #, c-format
@@ -3148,7 +3152,7 @@ msgstr ""
 #: ../src/ldgeneric.c:5745
 #, c-format
 msgid "cannot create versioning section: %s"
-msgstr ""
+msgstr "konnte Versionierungsabschnitt nicht erstellen: %s"
 
 #: ../src/ldgeneric.c:5818
 #, c-format
@@ -3158,7 +3162,7 @@ msgstr ""
 #: ../src/ldgeneric.c:5994
 #, c-format
 msgid "cannot create versioning data: %s"
-msgstr ""
+msgstr "konnte Versionierungsdaten nicht erstellen: %s"
 
 #: ../src/ldgeneric.c:6094 ../src/ldgeneric.c:6107 ../src/ldgeneric.c:6171
 #: ../src/ldgeneric.c:6179
@@ -3174,7 +3178,7 @@ msgstr ""
 #: ../src/ldgeneric.c:6259
 #, c-format
 msgid "cannot create program header: %s"
-msgstr ""
+msgstr "konnte Programm-Kopf nicht erstellen: %s"
 
 #: ../src/ldgeneric.c:6267
 #, c-format
@@ -4921,9 +4925,9 @@ msgid "[ADDR...]"
 msgstr ""
 
 #: ../src/addr2line.c:405
-#, c-format
+#, fuzzy, c-format
 msgid "Section syntax requires exactly one module"
-msgstr ""
+msgstr "Abschnitt syntax benötigt genau ein Modul"
 
 #: ../src/addr2line.c:428
 #, c-format
@@ -4933,7 +4937,7 @@ msgstr ""
 #: ../src/addr2line.c:461
 #, c-format
 msgid "cannot find symbol '%s'"
-msgstr ""
+msgstr "Konnte Symbol '%s' nicht finden"
 
 #: ../src/addr2line.c:466
 #, c-format
@@ -5068,12 +5072,13 @@ msgstr ""
 
 #. Strings for arguments in help texts.
 #: ../src/elfcmp.c:84
+#, fuzzy
 msgid "FILE1 FILE2"
-msgstr ""
+msgstr "DATEI1 DATEI2"
 
 #: ../src/elfcmp.c:140
 msgid "Invalid number of parameters.\n"
-msgstr ""
+msgstr "Ungültige Anzahl von Parametern.\n"
 
 #: ../src/elfcmp.c:168 ../src/elfcmp.c:173
 #, c-format
@@ -5305,12 +5310,12 @@ msgstr "-n kann nicht mit expliziten Dateien oder -o oder -d verwendet werden"
 #: ../src/unstrip.c:189
 #, c-format
 msgid "output directory '%s'"
-msgstr ""
+msgstr "Ausgabeverzeichnis '%s'"
 
 #: ../src/unstrip.c:198
 #, c-format
 msgid "exactly two file arguments are required"
-msgstr ""
+msgstr "genau zwei Datei-Argumente werden benötigt"
 
 #: ../src/unstrip.c:204
 #, c-format
@@ -5335,12 +5340,12 @@ msgstr ""
 #: ../src/unstrip.c:263 ../src/unstrip.c:1816
 #, c-format
 msgid "cannot create program headers: %s"
-msgstr ""
+msgstr "konnte Programm-Kopf nicht erstellen: %s"
 
 #: ../src/unstrip.c:269
 #, c-format
 msgid "cannot copy program header: %s"
-msgstr ""
+msgstr "konnte Programm-Kopf nicht kopieren: %s"
 
 #: ../src/unstrip.c:279
 #, c-format
@@ -5350,29 +5355,29 @@ msgstr ""
 #: ../src/unstrip.c:282 ../src/unstrip.c:1504
 #, c-format
 msgid "cannot get section data: %s"
-msgstr ""
+msgstr "konnte Abschnittsdaten nicht holen: %s"
 
 #: ../src/unstrip.c:284 ../src/unstrip.c:1506
 #, c-format
 msgid "cannot copy section data: %s"
-msgstr ""
+msgstr "konnte Abschnittsdaten nicht kopieren: %s"
 
 #: ../src/unstrip.c:308
 #, c-format
 msgid "cannot create directory '%s'"
-msgstr ""
+msgstr "konnte Verzeichnis nicht erstellen: %s"
 
 #: ../src/unstrip.c:348 ../src/unstrip.c:762 ../src/unstrip.c:1539
 #, c-format
 msgid "cannot get symbol table entry: %s"
-msgstr ""
+msgstr "konnte Eintrag aus der Symboltabelle nicht holen: %s"
 
 #: ../src/unstrip.c:364 ../src/unstrip.c:579 ../src/unstrip.c:600
 #: ../src/unstrip.c:612 ../src/unstrip.c:1560 ../src/unstrip.c:1690
 #: ../src/unstrip.c:1714
 #, c-format
 msgid "cannot update symbol table: %s"
-msgstr ""
+msgstr "konnte Symboltabelle nicht aktualisieren: %s"
 
 #: ../src/unstrip.c:381 ../src/unstrip.c:431 ../src/unstrip.c:561
 #: ../src/unstrip.c:1208 ../src/unstrip.c:1524 ../src/unstrip.c:1719
@@ -5464,7 +5469,7 @@ msgstr ""
 #: ../src/unstrip.c:1826
 #, c-format
 msgid "cannot update program header: %s"
-msgstr ""
+msgstr "konnte Programm-Kopf nicht aktualisieren: %s"
 
 #: ../src/unstrip.c:1831 ../src/unstrip.c:1910
 #, c-format
diff --git a/src/ChangeLog b/src/ChangeLog
index a0402416..190a33d7 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,7 @@
+2009-07-01  Roland McGrath  <roland@redhat.com>
+
+	* dwarfcmp.cc (talker): Update constructor parameters.
+
 2009-06-19  Roland McGrath  <roland@redhat.com>
 
 	* dwarfcmp.cc: Revamp using dwarf_comparator.
@@ -179,6 +183,12 @@
 	* dwarflint.c: Checking for zero padding and unreferenced bytes.
 	CU size and padding at the end of CU are now checked.
 
+2009-06-28  Roland McGrath  <roland@redhat.com>
+
+	* readelf.c (print_address_names): New static variable.
+	(options, parse_opt): Grok -N/--numeric-addresses to clear it.
+	(format_dwarf_addr): Don't look up name if !print_address_names.
+
 2009-06-13  Ulrich Drepper  <drepper@redhat.com>
 
 	* ldgeneric.c: Don't use deprecated libelf functions.
diff --git a/src/dwarfcmp.cc b/src/dwarfcmp.cc
index cffa5fa1..677a5beb 100644
--- a/src/dwarfcmp.cc
+++ b/src/dwarfcmp.cc
@@ -129,6 +129,7 @@ template<class dwarf1, class dwarf2>
 struct talker : public dwarf_ref_tracker<dwarf1, dwarf2>
 {
   typedef dwarf_tracker_base<dwarf1, dwarf2> _base;
+  typedef dwarf_ref_tracker<dwarf1, dwarf2> _tracker;
   typedef typename _base::cu1 cu1;
   typedef typename _base::cu2 cu2;
   typedef typename _base::die1 die1;
@@ -139,7 +140,17 @@ struct talker : public dwarf_ref_tracker<dwarf1, dwarf2>
   const typename dwarf1::debug_info_entry *a_;
   const typename dwarf2::debug_info_entry *b_;
 
-  inline talker () : a_ (NULL), b_ (NULL) {}
+  inline talker ()
+    : a_ (NULL), b_ (NULL)
+  {}
+
+  inline talker (const talker &proto, typename _tracker::reference_match &m,
+		 const typename _tracker::left_context_type &l, const die1 &a,
+		 const typename _tracker::right_context_type &r, const die2 &b)
+    : _tracker (static_cast<const _tracker &> (proto), m, l, a, r, b),
+      a_ (NULL), b_ (NULL)
+  {
+  }
 
   inline ostream &location () const
   {
@@ -314,8 +325,10 @@ main (int argc, char *argv[])
 
       if (test_writer)
 	{
-	  dwarf_edit edit1 (file1);
-	  dwarf_edit edit2 (file2);
+	  dwarf_ref_tracker<dwarf_edit, dwarf> t1;
+	  dwarf_ref_tracker<dwarf_edit, dwarf> t2;
+	  dwarf_edit edit1 (file1, &t1);
+	  dwarf_edit edit2 (file2, &t2);
 	  test_classes (file1, file2, edit1, edit2, same);
 
 	  {
diff --git a/src/readelf.c b/src/readelf.c
index 8564c6ad..e925565b 100644
--- a/src/readelf.c
+++ b/src/readelf.c
@@ -101,6 +101,8 @@ static const struct argp_option options[] =
     0 },
 
   { NULL, 0, NULL, 0, N_("Output control:"), 0 },
+  { "numeric-addresses", 'N', NULL, 0,
+    N_("Do not find symbol names for addresses in DWARF data"), 0 },
 
   { NULL, 0, NULL, 0, NULL, 0 }
 };
@@ -166,6 +168,9 @@ static bool print_archive_index;
 /* True if any of the control options except print_archive_index is set.  */
 static bool any_control_option;
 
+/* True if we should print addresses from DWARF in symbolic form.  */
+static bool print_address_names = true;
+
 /* Select printing of debugging sections.  */
 static enum section_e
 {
@@ -407,6 +412,9 @@ parse_opt (int key, char *arg,
       add_dump_section (arg);
       any_control_option = true;
       break;
+    case 'N':
+      print_address_names = false;
+      break;
     case ARGP_KEY_NO_ARGS:
       fputs (gettext ("Missing file name.\n"), stderr);
       goto do_argp_help;
@@ -3062,7 +3070,8 @@ format_dwarf_addr (Dwfl_Module *dwflmod,
 {
   /* See if there is a name we can give for this address.  */
   GElf_Sym sym;
-  const char *name = dwfl_module_addrsym (dwflmod, address, &sym, NULL);
+  const char *name = print_address_names
+    ? dwfl_module_addrsym (dwflmod, address, &sym, NULL) : NULL;
   if (name != NULL)
     sym.st_value = address - sym.st_value;
 
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 3c734f45..b988cfec 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,8 @@
+2009-07-01  Roland McGrath  <roland@redhat.com>
+
+	* run-dwarfcmp-self.sh: Run on dwarflint too.
+	Fiddle failure output.
+
 2009-06-15  Roland McGrath  <roland@redhat.com>
 
 	* dwarf-print.cc: Include <cstdio>.
diff --git a/tests/dwarf_edit.cc b/tests/dwarf_edit.cc
index 7c4b3ecf..35e6b1c2 100644
--- a/tests/dwarf_edit.cc
+++ b/tests/dwarf_edit.cc
@@ -56,8 +56,11 @@ main (int argc, char **argv)
 
   cu.attributes ()[DW_AT_name].source_file () = "source-file.c";
 
-  cu.add_entry (DW_TAG_subprogram)
-    .attributes ()[DW_AT_name].identifier () = "foo";
+  dwarf_edit::debug_info_entry &ent = cu.add_entry (DW_TAG_subprogram);
+
+  ent.attributes ()[DW_AT_name].identifier () = "foo";
+
+  ent.attributes ()[DW_AT_description] = ent.attributes ()[DW_AT_name];
 
   print_file ("consed", f, depth);
 
diff --git a/tests/run-dwarfcmp-self.sh b/tests/run-dwarfcmp-self.sh
index 927083ed..cce6641a 100755
--- a/tests/run-dwarfcmp-self.sh
+++ b/tests/run-dwarfcmp-self.sh
@@ -26,21 +26,27 @@
 . $srcdir/test-subr.sh
 
 status=0
+run_one()
+{
+  file="$1"; shift
+  testrun ../src/dwarfcmp "$@" "$file" "$file" ||
+  { echo "*** failure in dwarfcmp-self $* on $file"; status=1; }
+}
+
 runtest()
 {
   for file; do
     if [ -f $file ]; then
-      { testrun ../src/dwarfcmp -q -i $file $file &&
-	testrun ../src/dwarfcmp -i $file $file &&
-	testrun ../src/dwarfcmp -T -q -i $file $file
-      } ||
-      { echo "*** failure in $file"; status=1; }
+      run_one "$file" -i -q
+      run_one "$file" -i
+      run_one "$file" -i -q -T
     fi
   done
 }
 
 runtest ../src/addr2line
 runtest ../src/dwarfcmp
+runtest ../src/dwarflint
 runtest ../src/elfcmp
 runtest ../src/elflint
 runtest ../src/findtextrel