gas/messages.c

   1 /* messages.c - error reporter -
   2    Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
   3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   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
   9    the Free Software Foundation; either version 3, or (at your option)
  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
  19    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "as.h"
  23
  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 *);
  28
  29 /* Despite the rest of the comments in this file, (FIXME-SOON),
  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.  */
  64
  65 static void
  66 identify (char *file)
  67 {
  68   static int identified;
  69
  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
  85 /* The number of warnings issued.  */
  86 static int warning_count;
  87
  88 int
  89 had_warnings (void)
  90 {
  91   return warning_count;
  92 }
  93
  94 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
  95    and exit with a nonzero error code.  */
  96
  97 static int error_count;
  98
  99 int
 100 had_errors (void)
 101 {
 102   return error_count;
 103 }
 104
 105 /* Print the current location to stderr.  */
 106
 107 static void
 108 as_show_where (void)
 109 {
 110   char *file;
 111   unsigned int line;
 112
 113   as_where (&file, &line);
 114   identify (file);
 115   if (file)
 116     {
 117       if (line != 0)
 118         fprintf (stderr, "%s:%u: ", file, line);
 119       else
 120         fprintf (stderr, "%s: ", file);
 121     }
 122 }
 123
 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.  */
 129
 130 void
 131 as_tsktsk (const char *format, ...)
 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);
 140 }
 141
 142 /* The common portion of as_warn and as_warn_where.  */
 143
 144 static void
 145 as_warn_internal (char *file, unsigned int line, char *buffer)
 146 {
 147   ++warning_count;
 148
 149   if (file == NULL)
 150     as_where (&file, &line);
 151
 152   identify (file);
 153   if (file)
 154     {
 155       if (line != 0)
 156         fprintf (stderr, "%s:%u: ", file, line);
 157       else
 158         fprintf (stderr, "%s: ", file);
 159     }
 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
 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.  */
 173
 174 void
 175 as_warn (const char *format, ...)
 176 {
 177   va_list args;
 178   char buffer[2000];
 179
 180   if (!flag_no_warnings)
 181     {
 182       va_start (args, format);
 183       vsnprintf (buffer, sizeof (buffer), format, args);
 184       va_end (args);
 185       as_warn_internal ((char *) NULL, 0, buffer);
 186     }
 187 }
 188
 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.  */
 192
 193 void
 194 as_warn_where (char *file, unsigned int line, const char *format, ...)
 195 {
 196   va_list args;
 197   char buffer[2000];
 198
 199   if (!flag_no_warnings)
 200     {
 201       va_start (args, format);
 202       vsnprintf (buffer, sizeof (buffer), format, args);
 203       va_end (args);
 204       as_warn_internal (file, line, buffer);
 205     }
 206 }
 207
 208 /* The common portion of as_bad and as_bad_where.  */
 209
 210 static void
 211 as_bad_internal (char *file, unsigned int line, char *buffer)
 212 {
 213   ++error_count;
 214
 215   if (file == NULL)
 216     as_where (&file, &line);
 217
 218   identify (file);
 219   if (file)
 220     {
 221       if (line != 0)
 222         fprintf (stderr, "%s:%u: ", file, line);
 223       else
 224         fprintf (stderr, "%s: ", file);
 225     }
 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
 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
 238    done.  */
 239
 240 void
 241 as_bad (const char *format, ...)
 242 {
 243   va_list args;
 244   char buffer[2000];
 245
 246   va_start (args, format);
 247   vsnprintf (buffer, sizeof (buffer), format, args);
 248   va_end (args);
 249
 250   as_bad_internal ((char *) NULL, 0, buffer);
 251 }
 252
 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.  */
 256
 257 void
 258 as_bad_where (char *file, unsigned int line, const char *format, ...)
 259 {
 260   va_list args;
 261   char buffer[2000];
 262
 263   va_start (args, format);
 264   vsnprintf (buffer, sizeof (buffer), format, args);
 265   va_end (args);
 266
 267   as_bad_internal (file, line, buffer);
 268 }
 269
 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.  */
 274
 275 void
 276 as_fatal (const char *format, ...)
 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);
 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)
 289     unlink_if_ordinary (out_file_name);
 290   xexit (EXIT_FAILURE);
 291 }
 292
 293 /* Indicate assertion failure.
 294    Arguments: Filename, line number, optional function name.  */
 295
 296 void
 297 as_assert (const char *file, int line, const char *fn)
 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.  */
 312
 313 void
 314 as_abort (const char *file, int line, const char *fn)
 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
 329 void
 330 sprint_value (char *buf, valueT val)
 331 {
 332   if (sizeof (val) <= sizeof (long))
 333     {
 334       sprintf (buf, "%ld", (long) val);
 335       return;
 336     }
 337   if (sizeof (val) <= sizeof (bfd_vma))
 338     {
 339       sprintf_vma (buf, val);
 340       return;
 341     }
 342   abort ();
 343 }
 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
 362   if (val >= min && val <= max)
 363     {
 364       addressT right = max & -max;
 365
 366       if (max <= 1)
 367         abort ();
 368
 369       /* xgettext:c-format  */
 370       err = _("%s out of domain (%d is not a multiple of %d)");
 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);
 377       return;
 378     }
 379
 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)
 386     {
 387       /* xgettext:c-format  */
 388       err = _("%s out of range (%d is not between %d and %d)");
 389
 390       if (bad)
 391         as_bad_where (file, line, err,
 392                       prefix, (int) val, (int) min, (int) max);
 393       else
 394         as_warn_where (file, line, err,
 395                        prefix, (int) val, (int) min, (int) max);
 396     }
 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
 406       sprintf_vma (val_buf, (bfd_vma) val);
 407       sprintf_vma (min_buf, (bfd_vma) min);
 408       sprintf_vma (max_buf, (bfd_vma) max);
 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     }
 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 }