gas/messages.c - third_party/binutils-gdb - Git at Google

 /* messages.c - error reporter -
    Copyright (C) 1987-2016 Free Software Foundation, Inc.
    This file is part of GAS, the GNU Assembler.

    GAS 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, or (at your option)
    any later version.

    GAS 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 GAS; see the file COPYING.  If not, write to the Free
    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
    02110-1301, USA.  */

 #include "as.h"

 static void identify (const char *);
 static void as_show_where (void);
 static void as_warn_internal (const char *, unsigned int, char *);
 static void as_bad_internal (const char *, unsigned int, char *);

 /* Despite the rest of the comments in this file, (FIXME-SOON),
    here is the current scheme for error messages etc:

    as_fatal() is used when gas is quite confused and
    continuing the assembly is pointless.  In this case we
    exit immediately with error status.

    as_bad() is used to mark errors that result in what we
    presume to be a useless object file.  Say, we ignored
    something that might have been vital.  If we see any of
    these, assembly will continue to the end of the source,
    no object file will be produced, and we will terminate
    with error status.  The new option, -Z, tells us to
    produce an object file anyway but we still exit with
    error status.  The assumption here is that you don't want
    this object file but we could be wrong.

    as_warn() is used when we have an error from which we
    have a plausible error recovery.  eg, masking the top
    bits of a constant that is longer than will fit in the
    destination.  In this case we will continue to assemble
    the source, although we may have made a bad assumption,
    and we will produce an object file and return normal exit
    status (ie, no error).  The new option -X tells us to
    treat all as_warn() errors as as_bad() errors.  That is,
    no object file will be produced and we will exit with
    error status.  The idea here is that we don't kill an
    entire make because of an error that we knew how to
    correct.  On the other hand, sometimes you might want to
    stop the make at these points.

    as_tsktsk() is used when we see a minor error for which
    our error recovery action is almost certainly correct.
    In this case, we print a message and then assembly
    continues as though no error occurred.  */

 static void
 identify (const char *file)
 {
   static int identified;

   if (identified)
     return;
   identified++;

   if (!file)
     {
       unsigned int x;
       file = as_where (&x);
     }

   if (file)
     fprintf (stderr, "%s: ", file);
   fprintf (stderr, _("Assembler messages:\n"));
 }

 /* The number of warnings issued.  */
 static int warning_count;

 int
 had_warnings (void)
 {
   return warning_count;
 }

 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
    and exit with a nonzero error code.  */

 static int error_count;

 int
 had_errors (void)
 {
   return error_count;
 }

 /* Print the current location to stderr.  */

 static void
 as_show_where (void)
 {
   const char *file;
   unsigned int line;

   file = as_where (&line);
   identify (file);
   if (file)
     {
       if (line != 0)
 	fprintf (stderr, "%s:%u: ", file, line);
       else
 	fprintf (stderr, "%s: ", file);
     }
 }

 /* Send to stderr a string as a warning, and locate warning
    in input file(s).
    Please only use this for when we have some recovery action.
    Please explain in string (which may have '\n's) what recovery was
    done.  */

 void
 as_tsktsk (const char *format, ...)
 {
   va_list args;

   as_show_where ();
   va_start (args, format);
   vfprintf (stderr, format, args);
   va_end (args);
   (void) putc ('\n', stderr);
 }

 /* The common portion of as_warn and as_warn_where.  */

 static void
 as_warn_internal (const char *file, unsigned int line, char *buffer)
 {
   ++warning_count;

   if (file == NULL)
     file = as_where (&line);

   identify (file);
   if (file)
     {
       if (line != 0)
 	fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Warning: "), buffer);
       else
 	fprintf (stderr, "%s: %s%s\n", file, _("Warning: "), buffer);
     }
   else
     fprintf (stderr, "%s%s\n", _("Warning: "), buffer);
 #ifndef NO_LISTING
   listing_warning (buffer);
 #endif
 }

 /* Send to stderr a string as a warning, and locate warning
    in input file(s).
    Please only use this for when we have some recovery action.
    Please explain in string (which may have '\n's) what recovery was
    done.  */

 void
 as_warn (const char *format, ...)
 {
   va_list args;
   char buffer[2000];

   if (!flag_no_warnings)
     {
       va_start (args, format);
       vsnprintf (buffer, sizeof (buffer), format, args);
       va_end (args);
       as_warn_internal ((char *) NULL, 0, buffer);
     }
 }

 /* Like as_bad but the file name and line number are passed in.
    Unfortunately, we have to repeat the function in order to handle
    the varargs correctly and portably.  */

 void
 as_warn_where (const char *file, unsigned int line, const char *format, ...)
 {
   va_list args;
   char buffer[2000];

   if (!flag_no_warnings)
     {
       va_start (args, format);
       vsnprintf (buffer, sizeof (buffer), format, args);
       va_end (args);
       as_warn_internal (file, line, buffer);
     }
 }

 /* The common portion of as_bad and as_bad_where.  */

 static void
 as_bad_internal (const char *file, unsigned int line, char *buffer)
 {
   ++error_count;

   if (file == NULL)
     file = as_where (&line);

   identify (file);
   if (file)
     {
       if (line != 0)
 	fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Error: "), buffer);
       else
 	fprintf (stderr, "%s: %s%s\n", file, _("Error: "), buffer);
     }
   else
     fprintf (stderr, "%s%s\n", _("Error: "), buffer);
 #ifndef NO_LISTING
   listing_error (buffer);
 #endif
 }

 /* Send to stderr a string as a warning, and locate warning in input
    file(s).  Please use when there is no recovery, but we want to
    continue processing but not produce an object file.
    Please explain in string (which may have '\n's) what recovery was
    done.  */

 void
 as_bad (const char *format, ...)
 {
   va_list args;
   char buffer[2000];

   va_start (args, format);
   vsnprintf (buffer, sizeof (buffer), format, args);
   va_end (args);

   as_bad_internal ((char *) NULL, 0, buffer);
 }

 /* Like as_bad but the file name and line number are passed in.
    Unfortunately, we have to repeat the function in order to handle
    the varargs correctly and portably.  */

 void
 as_bad_where (const char *file, unsigned int line, const char *format, ...)
 {
   va_list args;
   char buffer[2000];

   va_start (args, format);
   vsnprintf (buffer, sizeof (buffer), format, args);
   va_end (args);

   as_bad_internal (file, line, buffer);
 }

 /* Send to stderr a string as a fatal message, and print location of
    error in input file(s).
    Please only use this for when we DON'T have some recovery action.
    It xexit()s with a warning status.  */

 void
 as_fatal (const char *format, ...)
 {
   va_list args;

   as_show_where ();
   va_start (args, format);
   fprintf (stderr, _("Fatal error: "));
   vfprintf (stderr, format, args);
   (void) putc ('\n', stderr);
   va_end (args);
   /* Delete the output file, if it exists.  This will prevent make from
      thinking that a file was created and hence does not need rebuilding.  */
   if (out_file_name != NULL)
     unlink_if_ordinary (out_file_name);
   xexit (EXIT_FAILURE);
 }

 /* Indicate assertion failure.
    Arguments: Filename, line number, optional function name.  */

 void
 as_assert (const char *file, int line, const char *fn)
 {
   as_show_where ();
   fprintf (stderr, _("Internal error!\n"));
   if (fn)
     fprintf (stderr, _("Assertion failure in %s at %s:%d.\n"),
 	     fn, file, line);
   else
     fprintf (stderr, _("Assertion failure at %s:%d.\n"), file, line);
   fprintf (stderr, _("Please report this bug.\n"));
   xexit (EXIT_FAILURE);
 }

 /* as_abort: Print a friendly message saying how totally hosed we are,
    and exit without producing a core file.  */

 void
 as_abort (const char *file, int line, const char *fn)
 {
   as_show_where ();
   if (fn)
     fprintf (stderr, _("Internal error, aborting at %s:%d in %s\n"),
 	     file, line, fn);
   else
     fprintf (stderr, _("Internal error, aborting at %s:%d\n"),
 	     file, line);
   fprintf (stderr, _("Please report this bug.\n"));
   xexit (EXIT_FAILURE);
 }

 /* Support routines.  */

 void
 sprint_value (char *buf, valueT val)
 {
   if (sizeof (val) <= sizeof (long))
     {
       sprintf (buf, "%ld", (long) val);
       return;
     }
   if (sizeof (val) <= sizeof (bfd_vma))
     {
       sprintf_vma (buf, val);
       return;
     }
   abort ();
 }

 #define HEX_MAX_THRESHOLD	1024
 #define HEX_MIN_THRESHOLD	-(HEX_MAX_THRESHOLD)

 static void
 as_internal_value_out_of_range (const char *prefix,
 				offsetT val,
 				offsetT min,
 				offsetT max,
 				const char *file,
 				unsigned line,
 				int bad)
 {
   const char * err;

   if (prefix == NULL)
     prefix = "";

   if (val >= min && val <= max)
     {
       addressT right = max & -max;

       if (max <= 1)
 	abort ();

       /* xgettext:c-format  */
       err = _("%s out of domain (%d is not a multiple of %d)");
       if (bad)
 	as_bad_where (file, line, err,
 		      prefix, (int) val, (int) right);
       else
 	as_warn_where (file, line, err,
 		       prefix, (int) val, (int) right);
       return;
     }

   if (   val < HEX_MAX_THRESHOLD
       && min < HEX_MAX_THRESHOLD
       && max < HEX_MAX_THRESHOLD
       && val > HEX_MIN_THRESHOLD
       && min > HEX_MIN_THRESHOLD
       && max > HEX_MIN_THRESHOLD)
     {
       /* xgettext:c-format  */
       err = _("%s out of range (%d is not between %d and %d)");

       if (bad)
 	as_bad_where (file, line, err,
 		      prefix, (int) val, (int) min, (int) max);
       else
 	as_warn_where (file, line, err,
 		       prefix, (int) val, (int) min, (int) max);
     }
   else
     {
       char val_buf [sizeof (val) * 3 + 2];
       char min_buf [sizeof (val) * 3 + 2];
       char max_buf [sizeof (val) * 3 + 2];

       if (sizeof (val) > sizeof (bfd_vma))
 	abort ();

       sprintf_vma (val_buf, (bfd_vma) val);
       sprintf_vma (min_buf, (bfd_vma) min);
       sprintf_vma (max_buf, (bfd_vma) max);

       /* xgettext:c-format.  */
       err = _("%s out of range (0x%s is not between 0x%s and 0x%s)");

       if (bad)
 	as_bad_where (file, line, err, prefix, val_buf, min_buf, max_buf);
       else
 	as_warn_where (file, line, err, prefix, val_buf, min_buf, max_buf);
     }
 }

 void
 as_warn_value_out_of_range (const char *prefix,
 			   offsetT value,
 			   offsetT min,
 			   offsetT max,
 			   const char *file,
 			   unsigned line)
 {
   as_internal_value_out_of_range (prefix, value, min, max, file, line, 0);
 }

 void
 as_bad_value_out_of_range (const char *prefix,
 			   offsetT value,
 			   offsetT min,
 			   offsetT max,
 			   const char *file,
 			   unsigned line)
 {
   as_internal_value_out_of_range (prefix, value, min, max, file, line, 1);
 }
	/* messages.c - error reporter -
	Copyright (C) 1987-2016 Free Software Foundation, Inc.
	This file is part of GAS, the GNU Assembler.

	GAS 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, or (at your option)
	any later version.

	GAS 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 GAS; see the file COPYING. If not, write to the Free
	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
	02110-1301, USA. */

	#include "as.h"

	static void identify (const char *);
	static void as_show_where (void);
	static void as_warn_internal (const char , unsigned int, char );
	static void as_bad_internal (const char , unsigned int, char );

	/* Despite the rest of the comments in this file, (FIXME-SOON),
	here is the current scheme for error messages etc:

	as_fatal() is used when gas is quite confused and
	continuing the assembly is pointless. In this case we
	exit immediately with error status.

	as_bad() is used to mark errors that result in what we
	presume to be a useless object file. Say, we ignored
	something that might have been vital. If we see any of
	these, assembly will continue to the end of the source,
	no object file will be produced, and we will terminate
	with error status. The new option, -Z, tells us to
	produce an object file anyway but we still exit with
	error status. The assumption here is that you don't want
	this object file but we could be wrong.

	as_warn() is used when we have an error from which we
	have a plausible error recovery. eg, masking the top
	bits of a constant that is longer than will fit in the
	destination. In this case we will continue to assemble
	the source, although we may have made a bad assumption,
	and we will produce an object file and return normal exit
	status (ie, no error). The new option -X tells us to
	treat all as_warn() errors as as_bad() errors. That is,
	no object file will be produced and we will exit with
	error status. The idea here is that we don't kill an
	entire make because of an error that we knew how to
	correct. On the other hand, sometimes you might want to
	stop the make at these points.

	as_tsktsk() is used when we see a minor error for which
	our error recovery action is almost certainly correct.
	In this case, we print a message and then assembly
	continues as though no error occurred. */

	static void
	identify (const char *file)
	{
	static int identified;

	if (identified)
	return;
	identified++;

	if (!file)
	{
	unsigned int x;
	file = as_where (&x);
	}

	if (file)
	fprintf (stderr, "%s: ", file);
	fprintf (stderr, _("Assembler messages:\n"));
	}

	/* The number of warnings issued. */
	static int warning_count;

	int
	had_warnings (void)
	{
	return warning_count;
	}

	/* Nonzero if we've hit a 'bad error', and should not write an obj file,
	and exit with a nonzero error code. */

	static int error_count;

	int
	had_errors (void)
	{
	return error_count;
	}

	/* Print the current location to stderr. */

	static void
	as_show_where (void)
	{
	const char *file;
	unsigned int line;

	file = as_where (&line);
	identify (file);
	if (file)
	{
	if (line != 0)
	fprintf (stderr, "%s:%u: ", file, line);
	else
	fprintf (stderr, "%s: ", file);
	}
	}

	/* Send to stderr a string as a warning, and locate warning
	in input file(s).
	Please only use this for when we have some recovery action.
	Please explain in string (which may have '\n's) what recovery was
	done. */

	void
	as_tsktsk (const char *format, ...)
	{
	va_list args;

	as_show_where ();
	va_start (args, format);
	vfprintf (stderr, format, args);
	va_end (args);
	(void) putc ('\n', stderr);
	}

	/* The common portion of as_warn and as_warn_where. */

	static void
	as_warn_internal (const char file, unsigned int line, char buffer)
	{
	++warning_count;

	if (file == NULL)
	file = as_where (&line);

	identify (file);
	if (file)
	{
	if (line != 0)
	fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Warning: "), buffer);
	else
	fprintf (stderr, "%s: %s%s\n", file, _("Warning: "), buffer);
	}
	else
	fprintf (stderr, "%s%s\n", _("Warning: "), buffer);
	#ifndef NO_LISTING
	listing_warning (buffer);
	#endif
	}

	/* Send to stderr a string as a warning, and locate warning
	in input file(s).
	Please only use this for when we have some recovery action.
	Please explain in string (which may have '\n's) what recovery was
	done. */

	void
	as_warn (const char *format, ...)
	{
	va_list args;
	char buffer[2000];

	if (!flag_no_warnings)
	{
	va_start (args, format);
	vsnprintf (buffer, sizeof (buffer), format, args);
	va_end (args);
	as_warn_internal ((char *) NULL, 0, buffer);
	}
	}

	/* Like as_bad but the file name and line number are passed in.
	Unfortunately, we have to repeat the function in order to handle
	the varargs correctly and portably. */

	void
	as_warn_where (const char file, unsigned int line, const char format, ...)
	{
	va_list args;
	char buffer[2000];

	if (!flag_no_warnings)
	{
	va_start (args, format);
	vsnprintf (buffer, sizeof (buffer), format, args);
	va_end (args);
	as_warn_internal (file, line, buffer);
	}
	}

	/* The common portion of as_bad and as_bad_where. */

	static void
	as_bad_internal (const char file, unsigned int line, char buffer)
	{
	++error_count;

	if (file == NULL)
	file = as_where (&line);

	identify (file);
	if (file)
	{
	if (line != 0)
	fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Error: "), buffer);
	else
	fprintf (stderr, "%s: %s%s\n", file, _("Error: "), buffer);
	}
	else
	fprintf (stderr, "%s%s\n", _("Error: "), buffer);
	#ifndef NO_LISTING
	listing_error (buffer);
	#endif
	}

	/* Send to stderr a string as a warning, and locate warning in input
	file(s). Please use when there is no recovery, but we want to
	continue processing but not produce an object file.
	Please explain in string (which may have '\n's) what recovery was
	done. */

	void
	as_bad (const char *format, ...)
	{
	va_list args;
	char buffer[2000];

	va_start (args, format);
	vsnprintf (buffer, sizeof (buffer), format, args);
	va_end (args);

	as_bad_internal ((char *) NULL, 0, buffer);
	}

	/* Like as_bad but the file name and line number are passed in.
	Unfortunately, we have to repeat the function in order to handle
	the varargs correctly and portably. */

	void
	as_bad_where (const char file, unsigned int line, const char format, ...)
	{
	va_list args;
	char buffer[2000];

	va_start (args, format);
	vsnprintf (buffer, sizeof (buffer), format, args);
	va_end (args);

	as_bad_internal (file, line, buffer);
	}

	/* Send to stderr a string as a fatal message, and print location of
	error in input file(s).
	Please only use this for when we DON'T have some recovery action.
	It xexit()s with a warning status. */

	void
	as_fatal (const char *format, ...)
	{
	va_list args;

	as_show_where ();
	va_start (args, format);
	fprintf (stderr, _("Fatal error: "));
	vfprintf (stderr, format, args);
	(void) putc ('\n', stderr);
	va_end (args);
	/* Delete the output file, if it exists. This will prevent make from
	thinking that a file was created and hence does not need rebuilding. */
	if (out_file_name != NULL)
	unlink_if_ordinary (out_file_name);
	xexit (EXIT_FAILURE);
	}

	/* Indicate assertion failure.
	Arguments: Filename, line number, optional function name. */

	void
	as_assert (const char file, int line, const char fn)
	{
	as_show_where ();
	fprintf (stderr, _("Internal error!\n"));
	if (fn)
	fprintf (stderr, _("Assertion failure in %s at %s:%d.\n"),
	fn, file, line);
	else
	fprintf (stderr, _("Assertion failure at %s:%d.\n"), file, line);
	fprintf (stderr, _("Please report this bug.\n"));
	xexit (EXIT_FAILURE);
	}

	/* as_abort: Print a friendly message saying how totally hosed we are,
	and exit without producing a core file. */

	void
	as_abort (const char file, int line, const char fn)
	{
	as_show_where ();
	if (fn)
	fprintf (stderr, _("Internal error, aborting at %s:%d in %s\n"),
	file, line, fn);
	else
	fprintf (stderr, _("Internal error, aborting at %s:%d\n"),
	file, line);
	fprintf (stderr, _("Please report this bug.\n"));
	xexit (EXIT_FAILURE);
	}

	/* Support routines. */

	void
	sprint_value (char *buf, valueT val)
	{
	if (sizeof (val) <= sizeof (long))
	{
	sprintf (buf, "%ld", (long) val);
	return;
	}
	if (sizeof (val) <= sizeof (bfd_vma))
	{
	sprintf_vma (buf, val);
	return;
	}
	abort ();
	}

	#define HEX_MAX_THRESHOLD 1024
	#define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD)

	static void
	as_internal_value_out_of_range (const char *prefix,
	offsetT val,
	offsetT min,
	offsetT max,
	const char *file,
	unsigned line,
	int bad)
	{
	const char * err;

	if (prefix == NULL)
	prefix = "";

	if (val >= min && val <= max)
	{
	addressT right = max & -max;

	if (max <= 1)
	abort ();

	/* xgettext:c-format */
	err = _("%s out of domain (%d is not a multiple of %d)");
	if (bad)
	as_bad_where (file, line, err,
	prefix, (int) val, (int) right);
	else
	as_warn_where (file, line, err,
	prefix, (int) val, (int) right);
	return;
	}

	if ( val < HEX_MAX_THRESHOLD
	&& min < HEX_MAX_THRESHOLD
	&& max < HEX_MAX_THRESHOLD
	&& val > HEX_MIN_THRESHOLD
	&& min > HEX_MIN_THRESHOLD
	&& max > HEX_MIN_THRESHOLD)
	{
	/* xgettext:c-format */
	err = _("%s out of range (%d is not between %d and %d)");

	if (bad)
	as_bad_where (file, line, err,
	prefix, (int) val, (int) min, (int) max);
	else
	as_warn_where (file, line, err,
	prefix, (int) val, (int) min, (int) max);
	}
	else
	{
	char val_buf [sizeof (val) * 3 + 2];
	char min_buf [sizeof (val) * 3 + 2];
	char max_buf [sizeof (val) * 3 + 2];

	if (sizeof (val) > sizeof (bfd_vma))
	abort ();

	sprintf_vma (val_buf, (bfd_vma) val);
	sprintf_vma (min_buf, (bfd_vma) min);
	sprintf_vma (max_buf, (bfd_vma) max);

	/* xgettext:c-format. */
	err = _("%s out of range (0x%s is not between 0x%s and 0x%s)");

	if (bad)
	as_bad_where (file, line, err, prefix, val_buf, min_buf, max_buf);
	else
	as_warn_where (file, line, err, prefix, val_buf, min_buf, max_buf);
	}
	}

	void
	as_warn_value_out_of_range (const char *prefix,
	offsetT value,
	offsetT min,
	offsetT max,
	const char *file,
	unsigned line)
	{
	as_internal_value_out_of_range (prefix, value, min, max, file, line, 0);
	}

	void
	as_bad_value_out_of_range (const char *prefix,
	offsetT value,
	offsetT min,
	offsetT max,
	const char *file,
	unsigned line)
	{
	as_internal_value_out_of_range (prefix, value, min, max, file, line, 1);
	}