Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / 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 }