[binutils.git] / gas / messages.c

/* messages.c - error reporter -
   Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   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 (char *);
static void as_show_where (void);
static void as_warn_internal (char *, unsigned int, char *);
static void as_bad_internal (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 (char *file)
{
  static int identified;

  if (identified)
    return;
  identified++;

  if (!file)
    {
      unsigned int x;
      as_where (&file, &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)
{
  char *file;
  unsigned int line;

  as_where (&file, &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 (char *file, unsigned int line, char *buffer)
{
  ++warning_count;

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

  identify (file);
  if (file)
    {
      if (line != 0)
	fprintf (stderr, "%s:%u: ", file, line);
      else
	fprintf (stderr, "%s: ", file);
    }
  fprintf (stderr, _("Warning: "));
  fputs (buffer, stderr);
  (void) putc ('\n', stderr);
#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 (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 (char *file, unsigned int line, char *buffer)
{
  ++error_count;

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

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

/* Send to stderr a string as a warning, and locate warning in input
   file(s).  Please us 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 (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 line %d.\n"),
	     fn, file, line);
  else
    fprintf (stderr, _("Assertion failure at %s line %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 line %d in %s\n"),
	     file, line, fn);
  else
    fprintf (stderr, _("Internal error, aborting at %s line %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 (char *    prefix,
				offsetT   val,
				offsetT   min,
				offsetT   max,
				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 (char *   prefix,
			   offsetT  value,
			   offsetT  min,
			   offsetT  max,
			   char *   file,
			   unsigned line)
{
  as_internal_value_out_of_range (prefix, value, min, max, file, line, 0);
}

void
as_bad_value_out_of_range (char *   prefix,
			   offsetT  value,
			   offsetT  min,
			   offsetT  max,
			   char *   file,
			   unsigned line)
{
  as_internal_value_out_of_range (prefix, value, min, max, file, line, 1);
}
Commit	Line	Data
252b5132	1	/* messages.c - error reporter -
2159ac21	2	Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
144886fa	3	2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
252b5132 RH	4	Free Software Foundation, Inc.
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
ec2655a6	9	the Free Software Foundation; either version 3, or (at your option)
252b5132 RH	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
4b4da160 NC	19	Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
4b4da160 NC	20	02110-1301, USA. */
252b5132 RH	21
	22	#include "as.h"
	23
254d758c KH	24	static void identify (char *);
	25	static void as_show_where (void);
	26	static void as_warn_internal (char , unsigned int, char );
	27	static void as_bad_internal (char , unsigned int, char );
252b5132	28
ef99799a	29	/* Despite the rest of the comments in this file, (FIXME-SOON),
5a1964ec NC	30	here is the current scheme for error messages etc:
	31
	32	as_fatal() is used when gas is quite confused and
	33	continuing the assembly is pointless. In this case we
	34	exit immediately with error status.
	35
	36	as_bad() is used to mark errors that result in what we
	37	presume to be a useless object file. Say, we ignored
	38	something that might have been vital. If we see any of
	39	these, assembly will continue to the end of the source,
	40	no object file will be produced, and we will terminate
	41	with error status. The new option, -Z, tells us to
	42	produce an object file anyway but we still exit with
	43	error status. The assumption here is that you don't want
	44	this object file but we could be wrong.
	45
	46	as_warn() is used when we have an error from which we
	47	have a plausible error recovery. eg, masking the top
	48	bits of a constant that is longer than will fit in the
	49	destination. In this case we will continue to assemble
	50	the source, although we may have made a bad assumption,
	51	and we will produce an object file and return normal exit
	52	status (ie, no error). The new option -X tells us to
	53	treat all as_warn() errors as as_bad() errors. That is,
	54	no object file will be produced and we will exit with
	55	error status. The idea here is that we don't kill an
	56	entire make because of an error that we knew how to
	57	correct. On the other hand, sometimes you might want to
	58	stop the make at these points.
	59
	60	as_tsktsk() is used when we see a minor error for which
	61	our error recovery action is almost certainly correct.
	62	In this case, we print a message and then assembly
	63	continues as though no error occurred. */
252b5132 RH	64
252b5132 RH	65	static void
254d758c	66	identify (char *file)
252b5132 RH	67	{
252b5132 RH	68	static int identified;
5a1964ec	69
252b5132 RH	70	if (identified)
	71	return;
	72	identified++;
	73
	74	if (!file)
	75	{
	76	unsigned int x;
	77	as_where (&file, &x);
	78	}
	79
	80	if (file)
	81	fprintf (stderr, "%s: ", file);
	82	fprintf (stderr, _("Assembler messages:\n"));
	83	}
	84
ef99799a KH	85	/* The number of warnings issued. */
ef99799a KH	86	static int warning_count;
252b5132	87
c488923f	88	int
254d758c	89	had_warnings (void)
252b5132	90	{
5a1964ec	91	return warning_count;
252b5132 RH	92	}
	93
	94	/* Nonzero if we've hit a 'bad error', and should not write an obj file,
ef99799a	95	and exit with a nonzero error code. */
252b5132 RH	96
	97	static int error_count;
	98
c488923f	99	int
254d758c	100	had_errors (void)
252b5132	101	{
5a1964ec	102	return error_count;
252b5132 RH	103	}
252b5132 RH	104
252b5132 RH	105	/* Print the current location to stderr. */
	106
	107	static void
254d758c	108	as_show_where (void)
252b5132 RH	109	{
	110	char *file;
	111	unsigned int line;
	112
	113	as_where (&file, &line);
	114	identify (file);
	115	if (file)
144886fa AM	116	{
	117	if (line != 0)
	118	fprintf (stderr, "%s:%u: ", file, line);
	119	else
	120	fprintf (stderr, "%s: ", file);
	121	}
252b5132 RH	122	}
252b5132 RH	123
ef99799a KH	124	/* Send to stderr a string as a warning, and locate warning
	125	in input file(s).
	126	Please only use this for when we have some recovery action.
	127	Please explain in string (which may have '\n's) what recovery was
	128	done. */
252b5132	129
c488923f	130	void
ef99799a	131	as_tsktsk (const char *format, ...)
252b5132 RH	132	{
	133	va_list args;
	134
	135	as_show_where ();
	136	va_start (args, format);
	137	vfprintf (stderr, format, args);
	138	va_end (args);
	139	(void) putc ('\n', stderr);
ef99799a	140	}
252b5132 RH	141
	142	/* The common portion of as_warn and as_warn_where. */
	143
	144	static void
254d758c	145	as_warn_internal (char file, unsigned int line, char buffer)
252b5132 RH	146	{
	147	++warning_count;
	148
	149	if (file == NULL)
	150	as_where (&file, &line);
	151
	152	identify (file);
	153	if (file)
144886fa AM	154	{
	155	if (line != 0)
	156	fprintf (stderr, "%s:%u: ", file, line);
	157	else
	158	fprintf (stderr, "%s: ", file);
	159	}
252b5132 RH	160	fprintf (stderr, _("Warning: "));
	161	fputs (buffer, stderr);
	162	(void) putc ('\n', stderr);
	163	#ifndef NO_LISTING
	164	listing_warning (buffer);
	165	#endif
	166	}
	167
ef99799a KH	168	/* Send to stderr a string as a warning, and locate warning
	169	in input file(s).
	170	Please only use this for when we have some recovery action.
	171	Please explain in string (which may have '\n's) what recovery was
	172	done. */
252b5132	173
c488923f	174	void
ef99799a	175	as_warn (const char *format, ...)
252b5132 RH	176	{
	177	va_list args;
	178	char buffer[2000];
	179
	180	if (!flag_no_warnings)
	181	{
	182	va_start (args, format);
a9bfff94	183	vsnprintf (buffer, sizeof (buffer), format, args);
252b5132 RH	184	va_end (args);
	185	as_warn_internal ((char *) NULL, 0, buffer);
	186	}
ef99799a	187	}
252b5132	188
ef99799a KH	189	/* Like as_bad but the file name and line number are passed in.
	190	Unfortunately, we have to repeat the function in order to handle
	191	the varargs correctly and portably. */
252b5132	192
c488923f	193	void
ef99799a	194	as_warn_where (char file, unsigned int line, const char format, ...)
252b5132 RH	195	{
	196	va_list args;
	197	char buffer[2000];
	198
	199	if (!flag_no_warnings)
	200	{
	201	va_start (args, format);
a9bfff94	202	vsnprintf (buffer, sizeof (buffer), format, args);
252b5132 RH	203	va_end (args);
	204	as_warn_internal (file, line, buffer);
	205	}
ef99799a	206	}
252b5132 RH	207
	208	/* The common portion of as_bad and as_bad_where. */
	209
	210	static void
254d758c	211	as_bad_internal (char file, unsigned int line, char buffer)
252b5132 RH	212	{
	213	++error_count;
	214
	215	if (file == NULL)
	216	as_where (&file, &line);
	217
	218	identify (file);
	219	if (file)
144886fa AM	220	{
	221	if (line != 0)
	222	fprintf (stderr, "%s:%u: ", file, line);
	223	else
	224	fprintf (stderr, "%s: ", file);
	225	}
252b5132 RH	226	fprintf (stderr, _("Error: "));
	227	fputs (buffer, stderr);
	228	(void) putc ('\n', stderr);
	229	#ifndef NO_LISTING
	230	listing_error (buffer);
	231	#endif
	232	}
	233
ef99799a KH	234	/* Send to stderr a string as a warning, and locate warning in input
	235	file(s). Please us when there is no recovery, but we want to
	236	continue processing but not produce an object file.
	237	Please explain in string (which may have '\n's) what recovery was
43ad3147	238	done. */
252b5132	239
c488923f	240	void
ef99799a	241	as_bad (const char *format, ...)
252b5132 RH	242	{
	243	va_list args;
	244	char buffer[2000];
	245
	246	va_start (args, format);
a9bfff94	247	vsnprintf (buffer, sizeof (buffer), format, args);
252b5132 RH	248	va_end (args);
	249
	250	as_bad_internal ((char *) NULL, 0, buffer);
	251	}
	252
ef99799a KH	253	/* Like as_bad but the file name and line number are passed in.
	254	Unfortunately, we have to repeat the function in order to handle
	255	the varargs correctly and portably. */
252b5132	256
c488923f	257	void
ef99799a	258	as_bad_where (char file, unsigned int line, const char format, ...)
252b5132 RH	259	{
	260	va_list args;
	261	char buffer[2000];
	262
	263	va_start (args, format);
a9bfff94	264	vsnprintf (buffer, sizeof (buffer), format, args);
252b5132 RH	265	va_end (args);
	266
	267	as_bad_internal (file, line, buffer);
	268	}
	269
ef99799a KH	270	/* Send to stderr a string as a fatal message, and print location of
	271	error in input file(s).
	272	Please only use this for when we DON'T have some recovery action.
	273	It xexit()s with a warning status. */
252b5132	274
c488923f	275	void
ef99799a	276	as_fatal (const char *format, ...)
252b5132 RH	277	{
	278	va_list args;
	279
	280	as_show_where ();
	281	va_start (args, format);
	282	fprintf (stderr, _("Fatal error: "));
	283	vfprintf (stderr, format, args);
	284	(void) putc ('\n', stderr);
	285	va_end (args);
d4887adc NC	286	/* Delete the output file, if it exists. This will prevent make from
	287	thinking that a file was created and hence does not need rebuilding. */
	288	if (out_file_name != NULL)
bb14f524	289	unlink_if_ordinary (out_file_name);
252b5132	290	xexit (EXIT_FAILURE);
ef99799a	291	}
252b5132	292
ef99799a KH	293	/* Indicate assertion failure.
ef99799a KH	294	Arguments: Filename, line number, optional function name. */
252b5132 RH	295
252b5132 RH	296	void
254d758c	297	as_assert (const char file, int line, const char fn)
252b5132 RH	298	{
	299	as_show_where ();
	300	fprintf (stderr, _("Internal error!\n"));
	301	if (fn)
	302	fprintf (stderr, _("Assertion failure in %s at %s line %d.\n"),
	303	fn, file, line);
	304	else
	305	fprintf (stderr, _("Assertion failure at %s line %d.\n"), file, line);
	306	fprintf (stderr, _("Please report this bug.\n"));
	307	xexit (EXIT_FAILURE);
	308	}
	309
	310	/* as_abort: Print a friendly message saying how totally hosed we are,
	311	and exit without producing a core file. */
ef99799a	312
252b5132	313	void
254d758c	314	as_abort (const char file, int line, const char fn)
252b5132 RH	315	{
	316	as_show_where ();
	317	if (fn)
	318	fprintf (stderr, _("Internal error, aborting at %s line %d in %s\n"),
	319	file, line, fn);
	320	else
	321	fprintf (stderr, _("Internal error, aborting at %s line %d\n"),
	322	file, line);
	323	fprintf (stderr, _("Please report this bug.\n"));
	324	xexit (EXIT_FAILURE);
	325	}
	326
	327	/* Support routines. */
	328
252b5132	329	void
254d758c	330	sprint_value (char *buf, valueT val)
252b5132 RH	331	{
	332	if (sizeof (val) <= sizeof (long))
	333	{
	334	sprintf (buf, "%ld", (long) val);
	335	return;
	336	}
252b5132 RH	337	if (sizeof (val) <= sizeof (bfd_vma))
	338	{
	339	sprintf_vma (buf, val);
	340	return;
	341	}
252b5132 RH	342	abort ();
252b5132 RH	343	}
e5976317 NC	344
	345	#define HEX_MAX_THRESHOLD 1024
	346	#define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD)
	347
	348	static void
	349	as_internal_value_out_of_range (char * prefix,
	350	offsetT val,
	351	offsetT min,
	352	offsetT max,
	353	char * file,
	354	unsigned line,
	355	int bad)
	356	{
	357	const char * err;
	358
	359	if (prefix == NULL)
	360	prefix = "";
	361
b84bf58a AM	362	if (val >= min && val <= max)
	363	{
	364	addressT right = max & -max;
	365
	366	if (max <= 1)
	367	abort ();
	368
	369	/* xgettext:c-format */
931774a9	370	err = _("%s out of domain (%d is not a multiple of %d)");
b84bf58a AM	371	if (bad)
	372	as_bad_where (file, line, err,
	373	prefix, (int) val, (int) right);
	374	else
	375	as_warn_where (file, line, err,
	376	prefix, (int) val, (int) right);
931774a9	377	return;
b84bf58a AM	378	}
b84bf58a AM	379
e5976317 NC	380	if ( val < HEX_MAX_THRESHOLD
	381	&& min < HEX_MAX_THRESHOLD
	382	&& max < HEX_MAX_THRESHOLD
	383	&& val > HEX_MIN_THRESHOLD
	384	&& min > HEX_MIN_THRESHOLD
	385	&& max > HEX_MIN_THRESHOLD)
e5976317 NC	386	{
	387	/* xgettext:c-format */
	388	err = _("%s out of range (%d is not between %d and %d)");
	389
	390	if (bad)
2159ac21 AM	391	as_bad_where (file, line, err,
2159ac21 AM	392	prefix, (int) val, (int) min, (int) max);
e5976317	393	else
2159ac21 AM	394	as_warn_where (file, line, err,
2159ac21 AM	395	prefix, (int) val, (int) min, (int) max);
e5976317	396	}
e5976317 NC	397	else
	398	{
	399	char val_buf [sizeof (val) * 3 + 2];
	400	char min_buf [sizeof (val) * 3 + 2];
	401	char max_buf [sizeof (val) * 3 + 2];
	402
	403	if (sizeof (val) > sizeof (bfd_vma))
	404	abort ();
	405
0af1713e AM	406	sprintf_vma (val_buf, (bfd_vma) val);
	407	sprintf_vma (min_buf, (bfd_vma) min);
	408	sprintf_vma (max_buf, (bfd_vma) max);
e5976317 NC	409
	410	/* xgettext:c-format. */
	411	err = _("%s out of range (0x%s is not between 0x%s and 0x%s)");
	412
	413	if (bad)
	414	as_bad_where (file, line, err, prefix, val_buf, min_buf, max_buf);
	415	else
	416	as_warn_where (file, line, err, prefix, val_buf, min_buf, max_buf);
	417	}
e5976317 NC	418	}
	419
	420	void
	421	as_warn_value_out_of_range (char * prefix,
	422	offsetT value,
	423	offsetT min,
	424	offsetT max,
	425	char * file,
	426	unsigned line)
	427	{
	428	as_internal_value_out_of_range (prefix, value, min, max, file, line, 0);
	429	}
	430
	431	void
	432	as_bad_value_out_of_range (char * prefix,
	433	offsetT value,
	434	offsetT min,
	435	offsetT max,
	436	char * file,
	437	unsigned line)
	438	{
	439	as_internal_value_out_of_range (prefix, value, min, max, file, line, 1);
	440	}