tests/print-die.cc - external/elfutils - Git at Google

 /* Pseudo-XMLish printing for elfutils::dwarf* tests.
    Copyright (C) 2009 Red Hat, Inc.
    This file is part of elfutils.

    This file is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    elfutils is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif

 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <clocale>
 #include <libintl.h>
 #include <ostream>
 #include <iomanip>
 #include <tr1/unordered_map>
 #include <functional>
 #include <algorithm>

 #include "c++/dwarf_edit"
 #include "c++/dwarf_output"

 using namespace elfutils;
 using namespace std;

 static bool print_offset;
 static bool sort_attrs;
 static bool elide_refs;
 static bool dump_refs;
 static bool no_print;
 static bool output_stats;
 static bool refs_shared_cu;
 static bool refs_shared_file;

 static enum { copy_none, copy_edit, copy_output } make_copy;

 void
 print_die_main (int &argc, char **&argv, unsigned int &depth)
 {
   /* Set locale.  */
   (void) setlocale (LC_ALL, "");

   /* Make sure the message catalog can be found.  */
   (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);

   /* Initialize the message catalog.  */
   (void) textdomain (PACKAGE_TARNAME);

   cout << hex << setiosflags (ios::showbase);

   if (argc > 1 && !strcmp (argv[1], "--offsets"))
     {
       print_offset = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--norefs"))
     {
       elide_refs = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--dump-refs"))
     {
       dump_refs = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--refs-shared-cu"))
     {
       refs_shared_cu = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--refs-shared-file"))
     {
       refs_shared_file = refs_shared_cu = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--sort-attrs"))
     {
       sort_attrs = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--edit"))
     {
       make_copy = copy_edit;
       --argc;
       ++argv;
     }
   else if (argc > 1 && !strcmp (argv[1], "--output"))
     {
       make_copy = copy_output;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--stats"))
     {
       output_stats = true;
       --argc;
       ++argv;
     }

   if (argc > 1 && !strcmp (argv[1], "--silent"))
     {
       no_print = true;
       --argc;
       ++argv;
     }

   depth = 0;
   if (argc > 1 && sscanf (argv[1], "--depth=%u", &depth) == 1)
     {
       --argc;
       ++argv;
     }
 }

 static int next_ref = 1;
 typedef tr1::unordered_map<dwarf::debug_info_entry::identity_type,
 			   int> refs_map;

 template<typename attrs_type,
 	 void (*act) (const typename attrs_type::value_type &, refs_map &)
 	 >
 class attr_walker
 {
 private:
   refs_map &refs;
   inline attr_walker (refs_map &r) : refs (r) {}

   typedef typename attrs_type::const_iterator iterator;
   typedef typename iterator::value_type attr_type;

 public:
   inline void operator () (const pair<int, iterator> &p) const
   {
     (*act) (*p.second, refs);
   }

   static inline void walk (const attrs_type &attrs, refs_map &r)
   {
     if (attrs_type::ordered () || !sort_attrs)
       for (iterator i = attrs.begin (); i != attrs.end (); ++i)
 	(*act) (*i, r);
     else
       {
 	map<int, iterator> sorted;
 	for (iterator i = attrs.begin (); i != attrs.end (); ++i)
 	  sorted[(*i).first] = i;
 	for_each (sorted.begin (), sorted.end (),
 		  attr_walker<attrs_type, act> (r));
       }
   }
 };

 template<typename attrs_type>
 void
 print_attr (const typename attrs_type::value_type &attr, refs_map &refs)
 {
   if (!print_offset && attr.second.what_space () == dwarf::VS_reference)
     {
       if (elide_refs)
 	cout << " " << dwarf::attributes::name (attr.first) << "=\"ref\"";
       else
 	cout << " " << dwarf::attributes::name (attr.first) << "=\"#ref"
 	     << dec << refs[attr.second.reference ()->identity ()] << "\"";
     }
   else
     cout << " " << to_string (attr);
 }

 template<typename attrs_type>
 static void
 print_attrs (const attrs_type &attrs, refs_map &refs)
 {
   attr_walker<attrs_type, print_attr<attrs_type> >::walk (attrs, refs);
 }

 template<typename attrs_type>
 void
 prewalk_attr (const typename attrs_type::value_type &attr, refs_map &refs)
 {
   if (attr.second.what_space () == dwarf::VS_reference
       && refs.insert (make_pair (attr.second.reference ()->identity (),
 				 next_ref)).second)
     ++next_ref;
 }

 template<typename attrs_type>
 static void
 prewalk_attrs (const attrs_type &attrs, refs_map &refs)
 {
   attr_walker<attrs_type, prewalk_attr<attrs_type> >::walk (attrs, refs);
 }

 template<typename file>
 static void
 prewalk_die (const typename file::debug_info_entry &die, refs_map &refs)
 {
   for (typename file::debug_info_entry::children_type::const_iterator i
 	 = die.children ().begin (); i != die.children ().end (); ++i)
     prewalk_die<file> (*i, refs);

   prewalk_attrs (die.attributes (), refs);
 }

 static int nth;
 static std::map<int, int> nth_ref;

 template<typename file>
 static void
 print_die (const typename file::debug_info_entry &die,
 	   unsigned int indent, unsigned int limit, refs_map &refs)
 {
   string prefix (indent, ' ');
   const string tag = dwarf::tags::name (die.tag ());

   ++nth;
   if (dump_refs)
     cout << dec << nth << ": ";

   cout << prefix << "<" << tag;
   if (print_offset)
     cout << " offset=[" << hex << die.offset () << "]";
   else if (!elide_refs)
     {
       refs_map::const_iterator it = refs.find (die.identity ());
       if (it != refs.end ())
 	{
 	  cout << " ref=\"ref" << dec << it->second << "\"";
 	  nth_ref[nth] = it->second;
 	}
     }

   print_attrs (die.attributes (), refs);

   if (die.has_children ())
     {
       if (limit != 0 && indent >= limit)
 	{
 	  cout << ">...\n";
 	  return;
 	}

       cout << ">\n";

       for (typename file::debug_info_entry::children_type::const_iterator i
 	     = die.children ().begin (); i != die.children ().end (); ++i)
 	print_die<file> (*i, indent + 1, limit, refs);

       cout << prefix << "</" << tag << ">\n";
     }
   else
     cout << "/>\n";
 }

 static inline void
 dump_nth (pair<int, int> p)
 {
   cout << dec << p.first << ": ref" << p.second << "\n";
 }

 template<typename file>
 static void
 print_cu (const typename file::compile_unit &cu, const unsigned int limit,
 	  refs_map &refs)
 {
   const typename file::debug_info_entry &die
     = static_cast<const typename file::debug_info_entry &> (cu);

   if (!print_offset && !elide_refs)
     prewalk_die<file> (die, refs);

   print_die<file> (die, 1, limit, refs);
 }

 template<typename file>
 static void
 print_file (const file &dw, const unsigned int limit)
 {
   if (no_print)
     return;

   static refs_map common_refs;
   refs_map file_refs;

   for (typename file::compile_units_type::const_iterator i
 	 = dw.compile_units ().begin (); i != dw.compile_units ().end (); ++i)
     if (refs_shared_cu)
       print_cu<file> (*i, limit, refs_shared_file ? common_refs : file_refs);
     else
       {
 	refs_map refs;
 	print_cu<file> (*i, limit, refs);
       }

   if (dump_refs)
     for_each (nth_ref.begin (), nth_ref.end (), dump_nth);
 }

 template<typename file>
 void
 print_file (const char *name, const file &dw, const unsigned int limit)
 {
   cout << name << ":\n";

   switch (make_copy)
     {
     case copy_none:
       print_file (dw, limit);
       break;
     case copy_edit:
       print_file (dwarf_edit (dw), limit);
       break;
     case copy_output:
       {
 	dwarf_output_collector c; // We'll just throw it away.
 	dwarf_output out (dw, c);
 	if (output_stats)
 	  c.stats ();
 	print_file (out, limit);
       }
       break;
     default:
       abort ();
     }
 }

 // Explicit instantiations.
 template void print_file (const char *, const dwarf &,
 			  const unsigned int);
 template void print_file (const char *, const dwarf_edit &,
 			  const unsigned int);
 template void print_file (const char *, const dwarf_output &,
 			  const unsigned int);
	/* Pseudo-XMLish printing for elfutils::dwarf* tests.
	Copyright (C) 2009 Red Hat, Inc.
	This file is part of elfutils.

	This file is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 3 of the License, or
	(at your option) any later version.

	elfutils is distributed in the hope that it will be useful, but
	WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program. If not, see <http://www.gnu.org/licenses/>. */

	#ifdef HAVE_CONFIG_H
	# include <config.h>
	#endif

	#include <cstring>
	#include <cstdio>
	#include <cstdlib>
	#include <clocale>
	#include <libintl.h>
	#include <ostream>
	#include <iomanip>
	#include <tr1/unordered_map>
	#include <functional>
	#include <algorithm>

	#include "c++/dwarf_edit"
	#include "c++/dwarf_output"

	using namespace elfutils;
	using namespace std;

	static bool print_offset;
	static bool sort_attrs;
	static bool elide_refs;
	static bool dump_refs;
	static bool no_print;
	static bool output_stats;
	static bool refs_shared_cu;
	static bool refs_shared_file;

	static enum { copy_none, copy_edit, copy_output } make_copy;

	void
	print_die_main (int &argc, char **&argv, unsigned int &depth)
	{
	/* Set locale. */
	(void) setlocale (LC_ALL, "");

	/* Make sure the message catalog can be found. */
	(void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);

	/* Initialize the message catalog. */
	(void) textdomain (PACKAGE_TARNAME);

	cout << hex << setiosflags (ios::showbase);

	if (argc > 1 && !strcmp (argv[1], "--offsets"))
	{
	print_offset = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--norefs"))
	{
	elide_refs = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--dump-refs"))
	{
	dump_refs = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--refs-shared-cu"))
	{
	refs_shared_cu = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--refs-shared-file"))
	{
	refs_shared_file = refs_shared_cu = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--sort-attrs"))
	{
	sort_attrs = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--edit"))
	{
	make_copy = copy_edit;
	--argc;
	++argv;
	}
	else if (argc > 1 && !strcmp (argv[1], "--output"))
	{
	make_copy = copy_output;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--stats"))
	{
	output_stats = true;
	--argc;
	++argv;
	}

	if (argc > 1 && !strcmp (argv[1], "--silent"))
	{
	no_print = true;
	--argc;
	++argv;
	}

	depth = 0;
	if (argc > 1 && sscanf (argv[1], "--depth=%u", &depth) == 1)
	{
	--argc;
	++argv;
	}
	}

	static int next_ref = 1;
	typedef tr1::unordered_map<dwarf::debug_info_entry::identity_type,
	int> refs_map;

	template<typename attrs_type,
	void (*act) (const typename attrs_type::value_type &, refs_map &)
	>
	class attr_walker
	{
	private:
	refs_map &refs;
	inline attr_walker (refs_map &r) : refs (r) {}

	typedef typename attrs_type::const_iterator iterator;
	typedef typename iterator::value_type attr_type;

	public:
	inline void operator () (const pair<int, iterator> &p) const
	{
	(act) (p.second, refs);
	}

	static inline void walk (const attrs_type &attrs, refs_map &r)
	{
	if (attrs_type::ordered () \|\| !sort_attrs)
	for (iterator i = attrs.begin (); i != attrs.end (); ++i)
	(act) (i, r);
	else
	{
	map<int, iterator> sorted;
	for (iterator i = attrs.begin (); i != attrs.end (); ++i)
	sorted[(*i).first] = i;
	for_each (sorted.begin (), sorted.end (),
	attr_walker<attrs_type, act> (r));
	}
	}
	};

	template<typename attrs_type>
	void
	print_attr (const typename attrs_type::value_type &attr, refs_map &refs)
	{
	if (!print_offset && attr.second.what_space () == dwarf::VS_reference)
	{
	if (elide_refs)
	cout << " " << dwarf::attributes::name (attr.first) << "=\"ref\"";
	else
	cout << " " << dwarf::attributes::name (attr.first) << "=\"#ref"
	<< dec << refs[attr.second.reference ()->identity ()] << "\"";
	}
	else
	cout << " " << to_string (attr);
	}

	template<typename attrs_type>
	static void
	print_attrs (const attrs_type &attrs, refs_map &refs)
	{
	attr_walker<attrs_type, print_attr<attrs_type> >::walk (attrs, refs);
	}

	template<typename attrs_type>
	void
	prewalk_attr (const typename attrs_type::value_type &attr, refs_map &refs)
	{
	if (attr.second.what_space () == dwarf::VS_reference
	&& refs.insert (make_pair (attr.second.reference ()->identity (),
	next_ref)).second)
	++next_ref;
	}

	template<typename attrs_type>
	static void
	prewalk_attrs (const attrs_type &attrs, refs_map &refs)
	{
	attr_walker<attrs_type, prewalk_attr<attrs_type> >::walk (attrs, refs);
	}

	template<typename file>
	static void
	prewalk_die (const typename file::debug_info_entry &die, refs_map &refs)
	{
	for (typename file::debug_info_entry::children_type::const_iterator i
	= die.children ().begin (); i != die.children ().end (); ++i)
	prewalk_die<file> (*i, refs);

	prewalk_attrs (die.attributes (), refs);
	}

	static int nth;
	static std::map<int, int> nth_ref;

	template<typename file>
	static void
	print_die (const typename file::debug_info_entry &die,
	unsigned int indent, unsigned int limit, refs_map &refs)
	{
	string prefix (indent, ' ');
	const string tag = dwarf::tags::name (die.tag ());

	++nth;
	if (dump_refs)
	cout << dec << nth << ": ";

	cout << prefix << "<" << tag;
	if (print_offset)
	cout << " offset=[" << hex << die.offset () << "]";
	else if (!elide_refs)
	{
	refs_map::const_iterator it = refs.find (die.identity ());
	if (it != refs.end ())
	{
	cout << " ref=\"ref" << dec << it->second << "\"";
	nth_ref[nth] = it->second;
	}
	}

	print_attrs (die.attributes (), refs);

	if (die.has_children ())
	{
	if (limit != 0 && indent >= limit)
	{
	cout << ">...\n";
	return;
	}

	cout << ">\n";

	for (typename file::debug_info_entry::children_type::const_iterator i
	= die.children ().begin (); i != die.children ().end (); ++i)
	print_die<file> (*i, indent + 1, limit, refs);

	cout << prefix << "</" << tag << ">\n";
	}
	else
	cout << "/>\n";
	}

	static inline void
	dump_nth (pair<int, int> p)
	{
	cout << dec << p.first << ": ref" << p.second << "\n";
	}

	template<typename file>
	static void
	print_cu (const typename file::compile_unit &cu, const unsigned int limit,
	refs_map &refs)
	{
	const typename file::debug_info_entry &die
	= static_cast<const typename file::debug_info_entry &> (cu);

	if (!print_offset && !elide_refs)
	prewalk_die<file> (die, refs);

	print_die<file> (die, 1, limit, refs);
	}

	template<typename file>
	static void
	print_file (const file &dw, const unsigned int limit)
	{
	if (no_print)
	return;

	static refs_map common_refs;
	refs_map file_refs;

	for (typename file::compile_units_type::const_iterator i
	= dw.compile_units ().begin (); i != dw.compile_units ().end (); ++i)
	if (refs_shared_cu)
	print_cu<file> (*i, limit, refs_shared_file ? common_refs : file_refs);
	else
	{
	refs_map refs;
	print_cu<file> (*i, limit, refs);
	}

	if (dump_refs)
	for_each (nth_ref.begin (), nth_ref.end (), dump_nth);
	}

	template<typename file>
	void
	print_file (const char *name, const file &dw, const unsigned int limit)
	{
	cout << name << ":\n";

	switch (make_copy)
	{
	case copy_none:
	print_file (dw, limit);
	break;
	case copy_edit:
	print_file (dwarf_edit (dw), limit);
	break;
	case copy_output:
	{
	dwarf_output_collector c; // We'll just throw it away.
	dwarf_output out (dw, c);
	if (output_stats)
	c.stats ();
	print_file (out, limit);
	}
	break;
	default:
	abort ();
	}
	}

	// Explicit instantiations.
	template void print_file (const char *, const dwarf &,
	const unsigned int);
	template void print_file (const char *, const dwarf_edit &,
	const unsigned int);
	template void print_file (const char *, const dwarf_output &,
	const unsigned int);