dwarflint/messages.cc - external/elfutils - Git at Google

 /* Pedantic checking of DWARF files
    Copyright (C) 2009-2011 Red Hat, Inc.
    This file is part of elfutils.

    This file is free software; you can redistribute it and/or modify
    it under the terms of 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/>.  */

 #include "messages.hh"
 #include "coverage.hh"
 #include "option.hh"

 #include <vector>
 #include <sstream>
 #include <cassert>
 #include <cstdarg>
 #include <libintl.h>

 unsigned error_count = 0;
 bool message_context::_m_last_emitted;

 bool
 message_accept (struct message_criteria const *cri,
 		unsigned long cat)
 {
   for (size_t i = 0; i < cri->size (); ++i)
     {
       message_term const &t = cri->at (i);
       if ((t.positive & cat) == t.positive
 	  && (t.negative & cat) == 0)
 	return true;
     }

   return false;
 }

 namespace
 {
   struct cat_to_str
     : public std::vector<std::string>
   {
     cat_to_str ()
     {
       int count = 0;
 #define MC(CAT, ID) if (ID > count) count = ID;
       MESSAGE_CATEGORIES
 #undef MC

       resize (count + 1);
 #define MC(CAT, ID) (*this)[ID] = #CAT;
       MESSAGE_CATEGORIES
 #undef MC
     }
   } cat_names;
   size_t cat_max = cat_names.size ();
 }


 message_category
 operator | (message_category a, message_category b)
 {
   return static_cast<message_category> ((unsigned long)a | b);
 }

 message_category &
 operator |= (message_category &a, message_category b)
 {
   a = a | b;
   return a;
 }

 std::string
 message_term::str () const
 {
   std::ostringstream os;
   os << '(';

   bool got = false;
   for (size_t i = 0; i <= cat_max; ++i)
     {
       size_t mask = 1u << i;
       if ((positive & mask) != 0
 	  || (negative & mask) != 0)
 	{
 	  if (got)
 	    os << " & ";
 	  if ((negative & (1u << i)) != 0)
 	    os << '~';
 	  os << cat_names[i];
 	  got = true;
 	}
     }

   if (!got)
     os << '1';

   os << ')';
   return os.str ();
 }

 std::string
 message_criteria::str () const
 {
   std::ostringstream os;

   for (size_t i = 0; i < size (); ++i)
     {
       message_term const &t = at (i);
       if (i > 0)
 	os << " | ";
       os << t.str ();
     }

   return os.str ();
 }

 void
 message_criteria::operator &= (message_term const &term)
 {
   assert ((term.positive & term.negative) == 0);
   for (size_t i = 0; i < size (); )
     {
       message_term &t = at (i);
       t.positive = t.positive | term.positive;
       t.negative = t.negative | term.negative;
       if ((t.positive & t.negative) != 0)
 	/* A ^ ~A -> drop the term.  */
 	erase (begin () + i);
       else
 	++i;
     }
 }

 void
 message_criteria::operator |= (message_term const &term)
 {
   assert ((term.positive & term.negative) == 0);
   push_back (term);
 }

 // xxx this one is inaccessible from the outside.  Make it like &=, |=
 // above
 /* NEG(a&b&~c) -> (~a + ~b + c) */
 message_criteria
 operator ! (message_term const &term)
 {
   assert ((term.positive & term.negative) == 0);

   message_criteria ret;
   for (size_t i = 0; i < cat_max; ++i)
     {
       unsigned mask = 1u << i;
       if ((term.positive & mask) != 0)
 	ret |= message_term ((message_category)(1u << i), mc_none);
       else if ((term.negative & mask) != 0)
 	ret |= message_term (mc_none, (message_category)(1u << i));
     }

   return ret;
 }

 std::ostream &
 operator<< (std::ostream &o, message_category cat)
 {
   o << '(';

   bool got = false;
   for (size_t i = 0; i <= cat_max; ++i)
     {
       size_t mask = 1u << i;
       if ((cat & mask) != 0)
 	{
 	  if (got)
 	    o << ",";
 	  o << cat_names[i];
 	  got = true;
 	}
     }

   if (!got)
     o << "none";

   return o << ')';
 }

 std::ostream &
 operator<< (std::ostream &o, message_term const &term)
 {
   return o << term.str ();
 }

 std::ostream &
 operator<< (std::ostream &o, __attribute__ ((unused)) message_criteria const &criteria)
 {
   return o << criteria.str ();
 }

 /* MUL((a&b + c&d), (e&f + g&h)) -> (a&b&e&f + a&b&g&h + c&d&e&f + c&d&g&h) */
 void
 message_criteria::operator *= (message_criteria const &rhs)
 {
   message_criteria ret;
   for (size_t i = 0; i < size (); ++i)
     for (size_t j = 0; j < rhs.size (); ++j)
       {
 	message_term t1 = at (i);
 	message_term const &t2 = rhs.at (j);
 	t1.positive |= t2.positive;
 	t1.negative |= t2.negative;
 	if (t1.positive & t1.negative)
 	  /* A ^ ~A -> drop the term.  */
 	  continue;
 	ret |= t1;
       }

   *this = ret;
 }

 // xxx this one is inaccessible from the outside.  Bind it properly
 /* Reject message if TERM passes.  */
 void
 message_criteria::and_not (message_term const &term)
 {
   // xxxxx really??  "!"??
   message_criteria tmp = !message_term (term.negative, term.positive);
   *this *= tmp;
 }

 static void
 wr_verror (locus const &loc, const char *format, va_list ap)
 {
   printf ("error: %s", loc.format ().c_str ());
   vprintf (format, ap);
   ++error_count;
 }

 static void
 wr_vwarning (locus const &loc, const char *format, va_list ap)
 {
   printf ("%s", loc.format ().c_str ());
   vprintf (format, ap);
   ++error_count;
 }

 void
 wr_error (locus const *loc, const char *format, ...)
 {
   va_list ap;
   va_start (ap, format);
   wr_verror (*loc, format, ap);
   va_end (ap);
 }

 void
 wr_message (unsigned long category, locus const *loc,
 	    const char *format, ...)
 {
   va_list ap;
   va_start (ap, format);
   // Clumsy duplicate filtering. Use format as key.
   bool whether = false;
   message_category cat = (message_category) category;
   wr_message (cat).id (format, whether);
   if (whether && message_accept (&warning_criteria, category))
     {
       if (message_accept (&error_criteria, category))
 	wr_verror (*loc, format, ap);
       else
 	wr_vwarning (*loc, format, ap);
     }
   va_end (ap);
 }

 namespace
 {
   class nostream: public std::ostream {};
   static nostream nostream;

   std::ostream &
   get_stream ()
   {
     return std::cout;
   }
 }

 global_opt<unsigned_option>
   dup_threshold_opt ("Threshold for duplicate messages."
 		     " Defaults to 16."
 		     " Use zero for no limit.",
 		     "count", "dups");

 namespace
 {
   unsigned
   dup_threshold ()
   {
     static unsigned t = dup_threshold_opt.value (16);
     if (t == 0)
       t = -1;
     return t;
   }
 }

 int
 message_count_filter::should_emit (void const *key)
 {
   unsigned count = ++_m_counters[key];
   if (count > dup_threshold ())
     return 0;
   else if (count == dup_threshold ())
     return -1;
   else
     return 1;
 }

 message_context::message_context (message_count_filter *filter,
 				  locus const *loc, char const *prefix)
   : _m_filter (filter)
   , _m_loc (loc)
   , _m_prefix (prefix)
 {}

 std::ostream &
 message_context::when (bool whether) const
 {
   _m_last_emitted = false;
   if (whether)
     {
       ++error_count;
       _m_last_emitted = true;

       std::ostream &ret = get_stream ();
       ret << _m_prefix;
       if (_m_loc != NULL)
 	ret << _m_loc->format () << ": ";
       return ret;
     }
   else
     return nostream;
 }

 std::ostream &
 message_context::when_prev () const
 {
   return when (wr_prev_emitted ());
 }

 std::ostream &
 message_context::id (void const *key, bool &whether)
 {
   if (_m_filter == NULL)
     return nostream;
   else if (int status = _m_filter->should_emit (key))
     {
       if (status == -1)
 	get_stream () << "(threshold [--dups=" << dup_threshold ()
 		      << "] reached for the following message)"
 		      << std::endl;
       whether = true;
       return when (true);
     }
   else
     return nostream;
 }

 std::ostream &
 message_context::id (void const *key)
 {
   bool whether;
   return id (key, whether);
 }

 std::ostream &
 message_context::operator << (char const *message)
 {
   return id (message) << message;
 }

 std::ostream &
 message_context::operator << (std::string const &message)
 {
   return *this << message.c_str ();
 }

 std::ostream &
 wr_error ()
 {
   ++error_count;
   return get_stream () << gettext ("error: ");
 }

 std::ostream &
 wr_error (locus const &loc)
 {
   std::string fmt = loc.format ();
   return wr_error () << fmt << ": ";
 }

 message_context
 message_context::filter_message (locus const *loc, message_category category)
 {
   if (!message_accept (&warning_criteria, category))
     return message_context (NULL, NULL, NULL);
   else if (message_accept (&error_criteria, category))
     return message_context (message_count_filter::inst (),
 			    loc, "error: ");
   else
     return message_context (message_count_filter::inst (),
 			    loc, "warning: ");
 }

 message_context
 wr_message (message_category category)
 {
   return message_context::filter_message (NULL, category);
 }

 message_context
 wr_message (locus const &loc, message_category category)
 {
   return message_context::filter_message (&loc, category);
 }

 void
 wr_format_padding_message (message_category category,
 			   locus const &loc,
 			   uint64_t start, uint64_t end, char const *kind)
 {
   char msg[128];
   wr_message (loc, category)
     << range_fmt (msg, sizeof msg, start, end)
     << ": " << kind << "." << std::endl;
 }

 void
 wr_format_leb128_message (locus const &loc,
 			  const char *what,
 			  const char *purpose,
 			  const unsigned char *begin, const unsigned char *end)
 {
   message_category category = mc_leb128 | mc_acc_bloat | mc_impact_3;
   char buf[(end - begin) * 3 + 1]; // 2 hexa digits+" " per byte, and term. 0
   char *ptr = buf;
   for (; begin < end; ++begin)
     ptr += sprintf (ptr, " %02x", *begin);
   wr_message (loc, category)
     << what << ": value " << purpose << " encoded as `"
     << (buf + 1) << "'." << std::endl;
 }

 void
 wr_message_padding_0 (message_category category,
 		      locus const &loc,
 		      uint64_t start, uint64_t end)
 {
   wr_format_padding_message (category | mc_acc_bloat | mc_impact_1,
 			     loc, start, end,
 			     "unnecessary padding with zero bytes");
 }

 void
 wr_message_padding_n0 (message_category category,
 		       locus const &loc,
 		       uint64_t start, uint64_t end)
 {
   wr_format_padding_message (category | mc_acc_bloat | mc_impact_1,
 			     loc, start, end,
 			     "unreferenced non-zero bytes");
 }

 void
 wr_reset_counters ()
 {
   error_count = 0;
   message_count_filter::inst ()->clear ();
 }

 bool
 wr_prev_emitted ()
 {
   return message_context::_m_last_emitted;
 }
	/* Pedantic checking of DWARF files
	Copyright (C) 2009-2011 Red Hat, Inc.
	This file is part of elfutils.

	This file is free software; you can redistribute it and/or modify
	it under the terms of 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/>. */

	#include "messages.hh"
	#include "coverage.hh"
	#include "option.hh"

	#include <vector>
	#include <sstream>
	#include <cassert>
	#include <cstdarg>
	#include <libintl.h>

	unsigned error_count = 0;
	bool message_context::_m_last_emitted;

	bool
	message_accept (struct message_criteria const *cri,
	unsigned long cat)
	{
	for (size_t i = 0; i < cri->size (); ++i)
	{
	message_term const &t = cri->at (i);
	if ((t.positive & cat) == t.positive
	&& (t.negative & cat) == 0)
	return true;
	}

	return false;
	}

	namespace
	{
	struct cat_to_str
	: public std::vector<std::string>
	{
	cat_to_str ()
	{
	int count = 0;
	#define MC(CAT, ID) if (ID > count) count = ID;
	MESSAGE_CATEGORIES
	#undef MC

	resize (count + 1);
	#define MC(CAT, ID) (*this)[ID] = #CAT;
	MESSAGE_CATEGORIES
	#undef MC
	}
	} cat_names;
	size_t cat_max = cat_names.size ();
	}


	message_category
	operator \| (message_category a, message_category b)
	{
	return static_cast<message_category> ((unsigned long)a \| b);
	}

	message_category &
	operator \|= (message_category &a, message_category b)
	{
	a = a \| b;
	return a;
	}

	std::string
	message_term::str () const
	{
	std::ostringstream os;
	os << '(';

	bool got = false;
	for (size_t i = 0; i <= cat_max; ++i)
	{
	size_t mask = 1u << i;
	if ((positive & mask) != 0
	\|\| (negative & mask) != 0)
	{
	if (got)
	os << " & ";
	if ((negative & (1u << i)) != 0)
	os << '~';
	os << cat_names[i];
	got = true;
	}
	}

	if (!got)
	os << '1';

	os << ')';
	return os.str ();
	}

	std::string
	message_criteria::str () const
	{
	std::ostringstream os;

	for (size_t i = 0; i < size (); ++i)
	{
	message_term const &t = at (i);
	if (i > 0)
	os << " \| ";
	os << t.str ();
	}

	return os.str ();
	}

	void
	message_criteria::operator &= (message_term const &term)
	{
	assert ((term.positive & term.negative) == 0);
	for (size_t i = 0; i < size (); )
	{
	message_term &t = at (i);
	t.positive = t.positive \| term.positive;
	t.negative = t.negative \| term.negative;
	if ((t.positive & t.negative) != 0)
	/* A ^ ~A -> drop the term. */
	erase (begin () + i);
	else
	++i;
	}
	}

	void
	message_criteria::operator \|= (message_term const &term)
	{
	assert ((term.positive & term.negative) == 0);
	push_back (term);
	}

	// xxx this one is inaccessible from the outside. Make it like &=, \|=
	// above
	/* NEG(a&b&~c) -> (~a + ~b + c) */
	message_criteria
	operator ! (message_term const &term)
	{
	assert ((term.positive & term.negative) == 0);

	message_criteria ret;
	for (size_t i = 0; i < cat_max; ++i)
	{
	unsigned mask = 1u << i;
	if ((term.positive & mask) != 0)
	ret \|= message_term ((message_category)(1u << i), mc_none);
	else if ((term.negative & mask) != 0)
	ret \|= message_term (mc_none, (message_category)(1u << i));
	}

	return ret;
	}

	std::ostream &
	operator<< (std::ostream &o, message_category cat)
	{
	o << '(';

	bool got = false;
	for (size_t i = 0; i <= cat_max; ++i)
	{
	size_t mask = 1u << i;
	if ((cat & mask) != 0)
	{
	if (got)
	o << ",";
	o << cat_names[i];
	got = true;
	}
	}

	if (!got)
	o << "none";

	return o << ')';
	}

	std::ostream &
	operator<< (std::ostream &o, message_term const &term)
	{
	return o << term.str ();
	}

	std::ostream &
	operator<< (std::ostream &o, __attribute__ ((unused)) message_criteria const &criteria)
	{
	return o << criteria.str ();
	}

	/* MUL((a&b + c&d), (e&f + g&h)) -> (a&b&e&f + a&b&g&h + c&d&e&f + c&d&g&h) */
	void
	message_criteria::operator *= (message_criteria const &rhs)
	{
	message_criteria ret;
	for (size_t i = 0; i < size (); ++i)
	for (size_t j = 0; j < rhs.size (); ++j)
	{
	message_term t1 = at (i);
	message_term const &t2 = rhs.at (j);
	t1.positive \|= t2.positive;
	t1.negative \|= t2.negative;
	if (t1.positive & t1.negative)
	/* A ^ ~A -> drop the term. */
	continue;
	ret \|= t1;
	}

	*this = ret;
	}

	// xxx this one is inaccessible from the outside. Bind it properly
	/* Reject message if TERM passes. */
	void
	message_criteria::and_not (message_term const &term)
	{
	// xxxxx really?? "!"??
	message_criteria tmp = !message_term (term.negative, term.positive);
	this = tmp;
	}

	static void
	wr_verror (locus const &loc, const char *format, va_list ap)
	{
	printf ("error: %s", loc.format ().c_str ());
	vprintf (format, ap);
	++error_count;
	}

	static void
	wr_vwarning (locus const &loc, const char *format, va_list ap)
	{
	printf ("%s", loc.format ().c_str ());
	vprintf (format, ap);
	++error_count;
	}

	void
	wr_error (locus const loc, const char format, ...)
	{
	va_list ap;
	va_start (ap, format);
	wr_verror (*loc, format, ap);
	va_end (ap);
	}

	void
	wr_message (unsigned long category, locus const *loc,
	const char *format, ...)
	{
	va_list ap;
	va_start (ap, format);
	// Clumsy duplicate filtering. Use format as key.
	bool whether = false;
	message_category cat = (message_category) category;
	wr_message (cat).id (format, whether);
	if (whether && message_accept (&warning_criteria, category))
	{
	if (message_accept (&error_criteria, category))
	wr_verror (*loc, format, ap);
	else
	wr_vwarning (*loc, format, ap);
	}
	va_end (ap);
	}

	namespace
	{
	class nostream: public std::ostream {};
	static nostream nostream;

	std::ostream &
	get_stream ()
	{
	return std::cout;
	}
	}

	global_opt<unsigned_option>
	dup_threshold_opt ("Threshold for duplicate messages."
	" Defaults to 16."
	" Use zero for no limit.",
	"count", "dups");

	namespace
	{
	unsigned
	dup_threshold ()
	{
	static unsigned t = dup_threshold_opt.value (16);
	if (t == 0)
	t = -1;
	return t;
	}
	}

	int
	message_count_filter::should_emit (void const *key)
	{
	unsigned count = ++_m_counters[key];
	if (count > dup_threshold ())
	return 0;
	else if (count == dup_threshold ())
	return -1;
	else
	return 1;
	}

	message_context::message_context (message_count_filter *filter,
	locus const loc, char const prefix)
	: _m_filter (filter)
	, _m_loc (loc)
	, _m_prefix (prefix)
	{}

	std::ostream &
	message_context::when (bool whether) const
	{
	_m_last_emitted = false;
	if (whether)
	{
	++error_count;
	_m_last_emitted = true;

	std::ostream &ret = get_stream ();
	ret << _m_prefix;
	if (_m_loc != NULL)
	ret << _m_loc->format () << ": ";
	return ret;
	}
	else
	return nostream;
	}

	std::ostream &
	message_context::when_prev () const
	{
	return when (wr_prev_emitted ());
	}

	std::ostream &
	message_context::id (void const *key, bool &whether)
	{
	if (_m_filter == NULL)
	return nostream;
	else if (int status = _m_filter->should_emit (key))
	{
	if (status == -1)
	get_stream () << "(threshold [--dups=" << dup_threshold ()
	<< "] reached for the following message)"
	<< std::endl;
	whether = true;
	return when (true);
	}
	else
	return nostream;
	}

	std::ostream &
	message_context::id (void const *key)
	{
	bool whether;
	return id (key, whether);
	}

	std::ostream &
	message_context::operator << (char const *message)
	{
	return id (message) << message;
	}

	std::ostream &
	message_context::operator << (std::string const &message)
	{
	return *this << message.c_str ();
	}

	std::ostream &
	wr_error ()
	{
	++error_count;
	return get_stream () << gettext ("error: ");
	}

	std::ostream &
	wr_error (locus const &loc)
	{
	std::string fmt = loc.format ();
	return wr_error () << fmt << ": ";
	}

	message_context
	message_context::filter_message (locus const *loc, message_category category)
	{
	if (!message_accept (&warning_criteria, category))
	return message_context (NULL, NULL, NULL);
	else if (message_accept (&error_criteria, category))
	return message_context (message_count_filter::inst (),
	loc, "error: ");
	else
	return message_context (message_count_filter::inst (),
	loc, "warning: ");
	}

	message_context
	wr_message (message_category category)
	{
	return message_context::filter_message (NULL, category);
	}

	message_context
	wr_message (locus const &loc, message_category category)
	{
	return message_context::filter_message (&loc, category);
	}

	void
	wr_format_padding_message (message_category category,
	locus const &loc,
	uint64_t start, uint64_t end, char const *kind)
	{
	char msg[128];
	wr_message (loc, category)
	<< range_fmt (msg, sizeof msg, start, end)
	<< ": " << kind << "." << std::endl;
	}

	void
	wr_format_leb128_message (locus const &loc,
	const char *what,
	const char *purpose,
	const unsigned char begin, const unsigned char end)
	{
	message_category category = mc_leb128 \| mc_acc_bloat \| mc_impact_3;
	char buf[(end - begin) * 3 + 1]; // 2 hexa digits+" " per byte, and term. 0
	char *ptr = buf;
	for (; begin < end; ++begin)
	ptr += sprintf (ptr, " %02x", *begin);
	wr_message (loc, category)
	<< what << ": value " << purpose << " encoded as `"
	<< (buf + 1) << "'." << std::endl;
	}

	void
	wr_message_padding_0 (message_category category,
	locus const &loc,
	uint64_t start, uint64_t end)
	{
	wr_format_padding_message (category \| mc_acc_bloat \| mc_impact_1,
	loc, start, end,
	"unnecessary padding with zero bytes");
	}

	void
	wr_message_padding_n0 (message_category category,
	locus const &loc,
	uint64_t start, uint64_t end)
	{
	wr_format_padding_message (category \| mc_acc_bloat \| mc_impact_1,
	loc, start, end,
	"unreferenced non-zero bytes");
	}

	void
	wr_reset_counters ()
	{
	error_count = 0;
	message_count_filter::inst ()->clear ();
	}

	bool
	wr_prev_emitted ()
	{
	return message_context::_m_last_emitted;
	}