gas/messages.c

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