OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [diagnostic.c] - Blame information for rev 684

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Language-independent diagnostic subroutines for the GNU Compiler Collection
2
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3
   2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4
   Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
 
23
/* This file implements the language independent aspect of diagnostic
24
   message module.  */
25
 
26
#include "config.h"
27
#include "system.h"
28
#include "coretypes.h"
29
#include "version.h"
30
#include "input.h"
31
#include "intl.h"
32
#include "diagnostic.h"
33
 
34
#define pedantic_warning_kind(DC)                       \
35
  ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
36
#define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
37
#define permissive_error_option(DC) ((DC)->opt_permissive)
38
 
39
/* Prototypes.  */
40
static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
41
 
42
static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
43
 
44
static void diagnostic_action_after_output (diagnostic_context *,
45
                                            diagnostic_info *);
46
static void real_abort (void) ATTRIBUTE_NORETURN;
47
 
48
/* Name of program invoked, sans directories.  */
49
 
50
const char *progname;
51
 
52
/* A diagnostic_context surrogate for stderr.  */
53
static diagnostic_context global_diagnostic_context;
54
diagnostic_context *global_dc = &global_diagnostic_context;
55
 
56
 
57
/* Return a malloc'd string containing MSG formatted a la printf.  The
58
   caller is responsible for freeing the memory.  */
59
static char *
60
build_message_string (const char *msg, ...)
61
{
62
  char *str;
63
  va_list ap;
64
 
65
  va_start (ap, msg);
66
  vasprintf (&str, msg, ap);
67
  va_end (ap);
68
 
69
  return str;
70
}
71
 
72
/* Same as diagnostic_build_prefix, but only the source FILE is given.  */
73
char *
74
file_name_as_prefix (const char *f)
75
{
76
  return build_message_string ("%s: ", f);
77
}
78
 
79
 
80
 
81
/* Initialize the diagnostic message outputting machinery.  */
82
void
83
diagnostic_initialize (diagnostic_context *context, int n_opts)
84
{
85
  int i;
86
 
87
  /* Allocate a basic pretty-printer.  Clients will replace this a
88
     much more elaborated pretty-printer if they wish.  */
89
  context->printer = XNEW (pretty_printer);
90
  pp_construct (context->printer, NULL, 0);
91
  /* By default, diagnostics are sent to stderr.  */
92
  context->printer->buffer->stream = stderr;
93
  /* By default, we emit prefixes once per message.  */
94
  context->printer->wrapping.rule = DIAGNOSTICS_SHOW_PREFIX_ONCE;
95
 
96
  memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
97
  context->some_warnings_are_errors = false;
98
  context->warning_as_error_requested = false;
99
  context->n_opts = n_opts;
100
  context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
101
  for (i = 0; i < n_opts; i++)
102
    context->classify_diagnostic[i] = DK_UNSPECIFIED;
103
  context->show_option_requested = false;
104
  context->abort_on_error = false;
105
  context->show_column = false;
106
  context->pedantic_errors = false;
107
  context->permissive = false;
108
  context->opt_permissive = 0;
109
  context->fatal_errors = false;
110
  context->dc_inhibit_warnings = false;
111
  context->dc_warn_system_headers = false;
112
  context->max_errors = 0;
113
  context->internal_error = NULL;
114
  diagnostic_starter (context) = default_diagnostic_starter;
115
  diagnostic_finalizer (context) = default_diagnostic_finalizer;
116
  context->option_enabled = NULL;
117
  context->option_state = NULL;
118
  context->option_name = NULL;
119
  context->last_module = 0;
120
  context->x_data = NULL;
121
  context->lock = 0;
122
  context->inhibit_notes_p = false;
123
}
124
 
125
/* Do any cleaning up required after the last diagnostic is emitted.  */
126
 
127
void
128
diagnostic_finish (diagnostic_context *context)
129
{
130
  /* Some of the errors may actually have been warnings.  */
131
  if (context->some_warnings_are_errors)
132
    {
133
      /* -Werror was given.  */
134
      if (context->warning_as_error_requested)
135
        pp_verbatim (context->printer,
136
                     _("%s: all warnings being treated as errors"),
137
                     progname);
138
      /* At least one -Werror= was given.  */
139
      else
140
        pp_verbatim (context->printer,
141
                     _("%s: some warnings being treated as errors"),
142
                     progname);
143
      pp_flush (context->printer);
144
    }
145
}
146
 
147
/* Initialize DIAGNOSTIC, where the message MSG has already been
148
   translated.  */
149
void
150
diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
151
                                va_list *args, location_t location,
152
                                diagnostic_t kind)
153
{
154
  diagnostic->message.err_no = errno;
155
  diagnostic->message.args_ptr = args;
156
  diagnostic->message.format_spec = msg;
157
  diagnostic->location = location;
158
  diagnostic->override_column = 0;
159
  diagnostic->kind = kind;
160
  diagnostic->option_index = 0;
161
}
162
 
163
/* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
164
   translated.  */
165
void
166
diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
167
                     va_list *args, location_t location,
168
                     diagnostic_t kind)
169
{
170
  diagnostic_set_info_translated (diagnostic, _(gmsgid), args, location, kind);
171
}
172
 
173
/* Return a malloc'd string describing a location.  The caller is
174
   responsible for freeing the memory.  */
175
char *
176
diagnostic_build_prefix (diagnostic_context *context,
177
                         diagnostic_info *diagnostic)
178
{
179
  static const char *const diagnostic_kind_text[] = {
180
#define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
181
#include "diagnostic.def"
182
#undef DEFINE_DIAGNOSTIC_KIND
183
    "must-not-happen"
184
  };
185
  const char *text = _(diagnostic_kind_text[diagnostic->kind]);
186
  expanded_location s = expand_location (diagnostic->location);
187
  if (diagnostic->override_column)
188
    s.column = diagnostic->override_column;
189
  gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
190
 
191
  return
192
    (s.file == NULL
193
     ? build_message_string ("%s: %s", progname, text)
194
     : context->show_column
195
     ? build_message_string ("%s:%d:%d: %s", s.file, s.line, s.column, text)
196
     : build_message_string ("%s:%d: %s", s.file, s.line, text));
197
}
198
 
199
/* Take any action which is expected to happen after the diagnostic
200
   is written out.  This function does not always return.  */
201
static void
202
diagnostic_action_after_output (diagnostic_context *context,
203
                                diagnostic_info *diagnostic)
204
{
205
  switch (diagnostic->kind)
206
    {
207
    case DK_DEBUG:
208
    case DK_NOTE:
209
    case DK_ANACHRONISM:
210
    case DK_WARNING:
211
      break;
212
 
213
    case DK_ERROR:
214
    case DK_SORRY:
215
      if (context->abort_on_error)
216
        real_abort ();
217
      if (context->fatal_errors)
218
        {
219
          fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
220
          diagnostic_finish (context);
221
          exit (FATAL_EXIT_CODE);
222
        }
223
      if (context->max_errors != 0
224
          && ((unsigned) (diagnostic_kind_count (context, DK_ERROR)
225
                          + diagnostic_kind_count (context, DK_SORRY))
226
              >= context->max_errors))
227
        {
228
          fnotice (stderr,
229
                   "compilation terminated due to -fmax-errors=%u.\n",
230
                   context->max_errors);
231
          diagnostic_finish (context);
232
          exit (FATAL_EXIT_CODE);
233
        }
234
      break;
235
 
236
    case DK_ICE:
237
      if (context->abort_on_error)
238
        real_abort ();
239
 
240
      fnotice (stderr, "Please submit a full bug report,\n"
241
               "with preprocessed source if appropriate.\n"
242
               "See %s for instructions.\n", bug_report_url);
243
      exit (ICE_EXIT_CODE);
244
 
245
    case DK_FATAL:
246
      if (context->abort_on_error)
247
        real_abort ();
248
      diagnostic_finish (context);
249
      fnotice (stderr, "compilation terminated.\n");
250
      exit (FATAL_EXIT_CODE);
251
 
252
    default:
253
      gcc_unreachable ();
254
    }
255
}
256
 
257
void
258
diagnostic_report_current_module (diagnostic_context *context, location_t where)
259
{
260
  const struct line_map *map = NULL;
261
 
262
  if (pp_needs_newline (context->printer))
263
    {
264
      pp_newline (context->printer);
265
      pp_needs_newline (context->printer) = false;
266
    }
267
 
268
  if (where <= BUILTINS_LOCATION)
269
    return;
270
 
271
  linemap_resolve_location (line_table, where,
272
                            LRK_MACRO_DEFINITION_LOCATION,
273
                            &map);
274
 
275
  if (map && diagnostic_last_module_changed (context, map))
276
    {
277
      diagnostic_set_last_module (context, map);
278
      if (! MAIN_FILE_P (map))
279
        {
280
          map = INCLUDED_FROM (line_table, map);
281
          if (context->show_column)
282
            pp_verbatim (context->printer,
283
                         "In file included from %s:%d:%d",
284
                         LINEMAP_FILE (map),
285
                         LAST_SOURCE_LINE (map), LAST_SOURCE_COLUMN (map));
286
          else
287
            pp_verbatim (context->printer,
288
                         "In file included from %s:%d",
289
                         LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
290
          while (! MAIN_FILE_P (map))
291
            {
292
              map = INCLUDED_FROM (line_table, map);
293
              pp_verbatim (context->printer,
294
                           ",\n                 from %s:%d",
295
                           LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
296
            }
297
          pp_verbatim (context->printer, ":");
298
          pp_newline (context->printer);
299
        }
300
    }
301
}
302
 
303
void
304
default_diagnostic_starter (diagnostic_context *context,
305
                            diagnostic_info *diagnostic)
306
{
307
  diagnostic_report_current_module (context, diagnostic->location);
308
  pp_set_prefix (context->printer, diagnostic_build_prefix (context,
309
                                                            diagnostic));
310
}
311
 
312
void
313
default_diagnostic_finalizer (diagnostic_context *context,
314
                              diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
315
{
316
  pp_destroy_prefix (context->printer);
317
}
318
 
319
/* Interface to specify diagnostic kind overrides.  Returns the
320
   previous setting, or DK_UNSPECIFIED if the parameters are out of
321
   range.  */
322
diagnostic_t
323
diagnostic_classify_diagnostic (diagnostic_context *context,
324
                                int option_index,
325
                                diagnostic_t new_kind,
326
                                location_t where)
327
{
328
  diagnostic_t old_kind;
329
 
330
  if (option_index <= 0
331
      || option_index >= context->n_opts
332
      || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
333
    return DK_UNSPECIFIED;
334
 
335
  old_kind = context->classify_diagnostic[option_index];
336
 
337
  /* Handle pragmas separately, since we need to keep track of *where*
338
     the pragmas were.  */
339
  if (where != UNKNOWN_LOCATION)
340
    {
341
      int i;
342
 
343
      for (i = context->n_classification_history - 1; i >= 0; i --)
344
        if (context->classification_history[i].option == option_index)
345
          {
346
            old_kind = context->classification_history[i].kind;
347
            break;
348
          }
349
 
350
      i = context->n_classification_history;
351
      context->classification_history =
352
        (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
353
                                                         * sizeof (diagnostic_classification_change_t));
354
      context->classification_history[i].location = where;
355
      context->classification_history[i].option = option_index;
356
      context->classification_history[i].kind = new_kind;
357
      context->n_classification_history ++;
358
    }
359
  else
360
    context->classify_diagnostic[option_index] = new_kind;
361
 
362
  return old_kind;
363
}
364
 
365
/* Save all diagnostic classifications in a stack.  */
366
void
367
diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
368
{
369
  context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
370
  context->push_list[context->n_push ++] = context->n_classification_history;
371
}
372
 
373
/* Restore the topmost classification set off the stack.  If the stack
374
   is empty, revert to the state based on command line parameters.  */
375
void
376
diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
377
{
378
  int jump_to;
379
  int i;
380
 
381
  if (context->n_push)
382
    jump_to = context->push_list [-- context->n_push];
383
  else
384
    jump_to = 0;
385
 
386
  i = context->n_classification_history;
387
  context->classification_history =
388
    (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
389
                                                     * sizeof (diagnostic_classification_change_t));
390
  context->classification_history[i].location = where;
391
  context->classification_history[i].option = jump_to;
392
  context->classification_history[i].kind = DK_POP;
393
  context->n_classification_history ++;
394
}
395
 
396
/* Report a diagnostic message (an error or a warning) as specified by
397
   DC.  This function is *the* subroutine in terms of which front-ends
398
   should implement their specific diagnostic handling modules.  The
399
   front-end independent format specifiers are exactly those described
400
   in the documentation of output_format.
401
   Return true if a diagnostic was printed, false otherwise.  */
402
 
403
bool
404
diagnostic_report_diagnostic (diagnostic_context *context,
405
                              diagnostic_info *diagnostic)
406
{
407
  location_t location = diagnostic->location;
408
  diagnostic_t orig_diag_kind = diagnostic->kind;
409
  const char *saved_format_spec;
410
 
411
  /* Give preference to being able to inhibit warnings, before they
412
     get reclassified to something else.  */
413
  if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
414
      && !diagnostic_report_warnings_p (context, location))
415
    return false;
416
 
417
  if (diagnostic->kind == DK_PEDWARN)
418
    {
419
      diagnostic->kind = pedantic_warning_kind (context);
420
      /* We do this to avoid giving the message for -pedantic-errors.  */
421
      orig_diag_kind = diagnostic->kind;
422
    }
423
 
424
  if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
425
    return false;
426
 
427
  if (context->lock > 0)
428
    {
429
      /* If we're reporting an ICE in the middle of some other error,
430
         try to flush out the previous error, then let this one
431
         through.  Don't do this more than once.  */
432
      if (diagnostic->kind == DK_ICE && context->lock == 1)
433
        pp_flush (context->printer);
434
      else
435
        error_recursion (context);
436
    }
437
 
438
  /* If the user requested that warnings be treated as errors, so be
439
     it.  Note that we do this before the next block so that
440
     individual warnings can be overridden back to warnings with
441
     -Wno-error=*.  */
442
  if (context->warning_as_error_requested
443
      && diagnostic->kind == DK_WARNING)
444
    {
445
      diagnostic->kind = DK_ERROR;
446
    }
447
 
448
  if (diagnostic->option_index)
449
    {
450
      diagnostic_t diag_class = DK_UNSPECIFIED;
451
 
452
      /* This tests if the user provided the appropriate -Wfoo or
453
         -Wno-foo option.  */
454
      if (! context->option_enabled (diagnostic->option_index,
455
                                     context->option_state))
456
        return false;
457
 
458
      /* This tests for #pragma diagnostic changes.  */
459
      if (context->n_classification_history > 0)
460
        {
461
          int i;
462
          /* FIXME: Stupid search.  Optimize later. */
463
          for (i = context->n_classification_history - 1; i >= 0; i --)
464
            {
465
              if (linemap_location_before_p
466
                  (line_table,
467
                   context->classification_history[i].location,
468
                   location))
469
                {
470
                  if (context->classification_history[i].kind == (int) DK_POP)
471
                    {
472
                      i = context->classification_history[i].option;
473
                      continue;
474
                    }
475
                  if (context->classification_history[i].option == diagnostic->option_index)
476
                    {
477
                      diag_class = context->classification_history[i].kind;
478
                      if (diag_class != DK_UNSPECIFIED)
479
                        diagnostic->kind = diag_class;
480
                      break;
481
                    }
482
                }
483
            }
484
        }
485
      /* This tests if the user provided the appropriate -Werror=foo
486
         option.  */
487
      if (diag_class == DK_UNSPECIFIED
488
          && context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED)
489
        {
490
          diagnostic->kind = context->classify_diagnostic[diagnostic->option_index];
491
        }
492
      /* This allows for future extensions, like temporarily disabling
493
         warnings for ranges of source code.  */
494
      if (diagnostic->kind == DK_IGNORED)
495
        return false;
496
    }
497
 
498
  if (orig_diag_kind == DK_WARNING && diagnostic->kind == DK_ERROR)
499
    context->some_warnings_are_errors = true;
500
 
501
  context->lock++;
502
 
503
  if (diagnostic->kind == DK_ICE)
504
    {
505
#ifndef ENABLE_CHECKING
506
      /* When not checking, ICEs are converted to fatal errors when an
507
         error has already occurred.  This is counteracted by
508
         abort_on_error.  */
509
      if ((diagnostic_kind_count (context, DK_ERROR) > 0
510
           || diagnostic_kind_count (context, DK_SORRY) > 0)
511
          && !context->abort_on_error)
512
        {
513
          expanded_location s = expand_location (diagnostic->location);
514
          fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
515
                   s.file, s.line);
516
          exit (ICE_EXIT_CODE);
517
        }
518
#endif
519
      if (context->internal_error)
520
        (*context->internal_error) (context,
521
                                    diagnostic->message.format_spec,
522
                                    diagnostic->message.args_ptr);
523
    }
524
  ++diagnostic_kind_count (context, diagnostic->kind);
525
 
526
  saved_format_spec = diagnostic->message.format_spec;
527
  if (context->show_option_requested)
528
    {
529
      char *option_text;
530
 
531
      option_text = context->option_name (context, diagnostic->option_index,
532
                                          orig_diag_kind, diagnostic->kind);
533
 
534
      if (option_text)
535
        {
536
          diagnostic->message.format_spec
537
            = ACONCAT ((diagnostic->message.format_spec,
538
                        " ",
539
                        "[", option_text, "]",
540
                        NULL));
541
          free (option_text);
542
        }
543
    }
544
  diagnostic->message.locus = &diagnostic->location;
545
  diagnostic->message.x_data = &diagnostic->x_data;
546
  diagnostic->x_data = NULL;
547
  pp_format (context->printer, &diagnostic->message);
548
  (*diagnostic_starter (context)) (context, diagnostic);
549
  pp_output_formatted_text (context->printer);
550
  (*diagnostic_finalizer (context)) (context, diagnostic);
551
  pp_flush (context->printer);
552
  diagnostic_action_after_output (context, diagnostic);
553
  diagnostic->message.format_spec = saved_format_spec;
554
  diagnostic->x_data = NULL;
555
 
556
  context->lock--;
557
 
558
  return true;
559
}
560
 
561
/* Given a partial pathname as input, return another pathname that
562
   shares no directory elements with the pathname of __FILE__.  This
563
   is used by fancy_abort() to print `Internal compiler error in expr.c'
564
   instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
565
 
566
const char *
567
trim_filename (const char *name)
568
{
569
  static const char this_file[] = __FILE__;
570
  const char *p = name, *q = this_file;
571
 
572
  /* First skip any "../" in each filename.  This allows us to give a proper
573
     reference to a file in a subdirectory.  */
574
  while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
575
    p += 3;
576
 
577
  while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
578
    q += 3;
579
 
580
  /* Now skip any parts the two filenames have in common.  */
581
  while (*p == *q && *p != 0 && *q != 0)
582
    p++, q++;
583
 
584
  /* Now go backwards until the previous directory separator.  */
585
  while (p > name && !IS_DIR_SEPARATOR (p[-1]))
586
    p--;
587
 
588
  return p;
589
}
590
 
591
/* Standard error reporting routines in increasing order of severity.
592
   All of these take arguments like printf.  */
593
 
594
/* Text to be emitted verbatim to the error message stream; this
595
   produces no prefix and disables line-wrapping.  Use rarely.  */
596
void
597
verbatim (const char *gmsgid, ...)
598
{
599
  text_info text;
600
  va_list ap;
601
 
602
  va_start (ap, gmsgid);
603
  text.err_no = errno;
604
  text.args_ptr = &ap;
605
  text.format_spec = _(gmsgid);
606
  text.locus = NULL;
607
  text.x_data = NULL;
608
  pp_format_verbatim (global_dc->printer, &text);
609
  pp_flush (global_dc->printer);
610
  va_end (ap);
611
}
612
 
613
bool
614
emit_diagnostic (diagnostic_t kind, location_t location, int opt,
615
                 const char *gmsgid, ...)
616
{
617
  diagnostic_info diagnostic;
618
  va_list ap;
619
 
620
  va_start (ap, gmsgid);
621
  if (kind == DK_PERMERROR)
622
    {
623
      diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
624
                           permissive_error_kind (global_dc));
625
      diagnostic.option_index = permissive_error_option (global_dc);
626
    }
627
  else {
628
      diagnostic_set_info (&diagnostic, gmsgid, &ap, location, kind);
629
      if (kind == DK_WARNING || kind == DK_PEDWARN)
630
        diagnostic.option_index = opt;
631
  }
632
  va_end (ap);
633
 
634
  return report_diagnostic (&diagnostic);
635
}
636
 
637
/* An informative note at LOCATION.  Use this for additional details on an error
638
   message.  */
639
void
640
inform (location_t location, const char *gmsgid, ...)
641
{
642
  diagnostic_info diagnostic;
643
  va_list ap;
644
 
645
  va_start (ap, gmsgid);
646
  diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_NOTE);
647
  report_diagnostic (&diagnostic);
648
  va_end (ap);
649
}
650
 
651
/* An informative note at LOCATION.  Use this for additional details on an
652
   error message.  */
653
void
654
inform_n (location_t location, int n, const char *singular_gmsgid,
655
          const char *plural_gmsgid, ...)
656
{
657
  diagnostic_info diagnostic;
658
  va_list ap;
659
 
660
  va_start (ap, plural_gmsgid);
661
  diagnostic_set_info_translated (&diagnostic,
662
                                  ngettext (singular_gmsgid, plural_gmsgid, n),
663
                                  &ap, location, DK_NOTE);
664
  report_diagnostic (&diagnostic);
665
  va_end (ap);
666
}
667
 
668
/* A warning at INPUT_LOCATION.  Use this for code which is correct according
669
   to the relevant language specification but is likely to be buggy anyway.
670
   Returns true if the warning was printed, false if it was inhibited.  */
671
bool
672
warning (int opt, const char *gmsgid, ...)
673
{
674
  diagnostic_info diagnostic;
675
  va_list ap;
676
 
677
  va_start (ap, gmsgid);
678
  diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING);
679
  diagnostic.option_index = opt;
680
 
681
  va_end (ap);
682
  return report_diagnostic (&diagnostic);
683
}
684
 
685
/* A warning at LOCATION.  Use this for code which is correct according to the
686
   relevant language specification but is likely to be buggy anyway.
687
   Returns true if the warning was printed, false if it was inhibited.  */
688
 
689
bool
690
warning_at (location_t location, int opt, const char *gmsgid, ...)
691
{
692
  diagnostic_info diagnostic;
693
  va_list ap;
694
 
695
  va_start (ap, gmsgid);
696
  diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_WARNING);
697
  diagnostic.option_index = opt;
698
  va_end (ap);
699
  return report_diagnostic (&diagnostic);
700
}
701
 
702
/* A "pedantic" warning at LOCATION: issues a warning unless
703
   -pedantic-errors was given on the command line, in which case it
704
   issues an error.  Use this for diagnostics required by the relevant
705
   language standard, if you have chosen not to make them errors.
706
 
707
   Note that these diagnostics are issued independent of the setting
708
   of the -pedantic command-line switch.  To get a warning enabled
709
   only with that switch, use either "if (pedantic) pedwarn
710
   (OPT_pedantic,...)" or just "pedwarn (OPT_pedantic,..)".  To get a
711
   pedwarn independently of the -pedantic switch use "pedwarn (0,...)".
712
 
713
   Returns true if the warning was printed, false if it was inhibited.  */
714
 
715
bool
716
pedwarn (location_t location, int opt, const char *gmsgid, ...)
717
{
718
  diagnostic_info diagnostic;
719
  va_list ap;
720
 
721
  va_start (ap, gmsgid);
722
  diagnostic_set_info (&diagnostic, gmsgid, &ap, location,  DK_PEDWARN);
723
  diagnostic.option_index = opt;
724
  va_end (ap);
725
  return report_diagnostic (&diagnostic);
726
}
727
 
728
/* A "permissive" error at LOCATION: issues an error unless
729
   -fpermissive was given on the command line, in which case it issues
730
   a warning.  Use this for things that really should be errors but we
731
   want to support legacy code.
732
 
733
   Returns true if the warning was printed, false if it was inhibited.  */
734
 
735
bool
736
permerror (location_t location, const char *gmsgid, ...)
737
{
738
  diagnostic_info diagnostic;
739
  va_list ap;
740
 
741
  va_start (ap, gmsgid);
742
  diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
743
                       permissive_error_kind (global_dc));
744
  diagnostic.option_index = permissive_error_option (global_dc);
745
  va_end (ap);
746
  return report_diagnostic (&diagnostic);
747
}
748
 
749
/* A hard error: the code is definitely ill-formed, and an object file
750
   will not be produced.  */
751
void
752
error (const char *gmsgid, ...)
753
{
754
  diagnostic_info diagnostic;
755
  va_list ap;
756
 
757
  va_start (ap, gmsgid);
758
  diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR);
759
  report_diagnostic (&diagnostic);
760
  va_end (ap);
761
}
762
 
763
/* A hard error: the code is definitely ill-formed, and an object file
764
   will not be produced.  */
765
void
766
error_n (location_t location, int n, const char *singular_gmsgid,
767
         const char *plural_gmsgid, ...)
768
{
769
  diagnostic_info diagnostic;
770
  va_list ap;
771
 
772
  va_start (ap, plural_gmsgid);
773
  diagnostic_set_info_translated (&diagnostic,
774
                                  ngettext (singular_gmsgid, plural_gmsgid, n),
775
                                  &ap, location, DK_ERROR);
776
  report_diagnostic (&diagnostic);
777
  va_end (ap);
778
}
779
 
780
/* Same as ebove, but use location LOC instead of input_location.  */
781
void
782
error_at (location_t loc, const char *gmsgid, ...)
783
{
784
  diagnostic_info diagnostic;
785
  va_list ap;
786
 
787
  va_start (ap, gmsgid);
788
  diagnostic_set_info (&diagnostic, gmsgid, &ap, loc, DK_ERROR);
789
  report_diagnostic (&diagnostic);
790
  va_end (ap);
791
}
792
 
793
/* "Sorry, not implemented."  Use for a language feature which is
794
   required by the relevant specification but not implemented by GCC.
795
   An object file will not be produced.  */
796
void
797
sorry (const char *gmsgid, ...)
798
{
799
  diagnostic_info diagnostic;
800
  va_list ap;
801
 
802
  va_start (ap, gmsgid);
803
  diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_SORRY);
804
  report_diagnostic (&diagnostic);
805
  va_end (ap);
806
}
807
 
808
/* Return true if an error or a "sorry" has been seen.  Various
809
   processing is disabled after errors.  */
810
bool
811
seen_error (void)
812
{
813
  return errorcount || sorrycount;
814
}
815
 
816
/* An error which is severe enough that we make no attempt to
817
   continue.  Do not use this for internal consistency checks; that's
818
   internal_error.  Use of this function should be rare.  */
819
void
820
fatal_error (const char *gmsgid, ...)
821
{
822
  diagnostic_info diagnostic;
823
  va_list ap;
824
 
825
  va_start (ap, gmsgid);
826
  diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_FATAL);
827
  report_diagnostic (&diagnostic);
828
  va_end (ap);
829
 
830
  gcc_unreachable ();
831
}
832
 
833
/* An internal consistency check has failed.  We make no attempt to
834
   continue.  Note that unless there is debugging value to be had from
835
   a more specific message, or some other good reason, you should use
836
   abort () instead of calling this function directly.  */
837
void
838
internal_error (const char *gmsgid, ...)
839
{
840
  diagnostic_info diagnostic;
841
  va_list ap;
842
 
843
  va_start (ap, gmsgid);
844
  diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ICE);
845
  report_diagnostic (&diagnostic);
846
  va_end (ap);
847
 
848
  gcc_unreachable ();
849
}
850
 
851
/* Special case error functions.  Most are implemented in terms of the
852
   above, or should be.  */
853
 
854
/* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
855
   runs its second argument through gettext.  */
856
void
857
fnotice (FILE *file, const char *cmsgid, ...)
858
{
859
  va_list ap;
860
 
861
  va_start (ap, cmsgid);
862
  vfprintf (file, _(cmsgid), ap);
863
  va_end (ap);
864
}
865
 
866
/* Inform the user that an error occurred while trying to report some
867
   other error.  This indicates catastrophic internal inconsistencies,
868
   so give up now.  But do try to flush out the previous error.
869
   This mustn't use internal_error, that will cause infinite recursion.  */
870
 
871
static void
872
error_recursion (diagnostic_context *context)
873
{
874
  diagnostic_info diagnostic;
875
 
876
  if (context->lock < 3)
877
    pp_flush (context->printer);
878
 
879
  fnotice (stderr,
880
           "Internal compiler error: Error reporting routines re-entered.\n");
881
 
882
  /* Call diagnostic_action_after_output to get the "please submit a bug
883
     report" message.  It only looks at the kind field of diagnostic_info.  */
884
  diagnostic.kind = DK_ICE;
885
  diagnostic_action_after_output (context, &diagnostic);
886
 
887
  /* Do not use gcc_unreachable here; that goes through internal_error
888
     and therefore would cause infinite recursion.  */
889
  real_abort ();
890
}
891
 
892
/* Report an internal compiler error in a friendly manner.  This is
893
   the function that gets called upon use of abort() in the source
894
   code generally, thanks to a special macro.  */
895
 
896
void
897
fancy_abort (const char *file, int line, const char *function)
898
{
899
  internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
900
}
901
 
902
/* Really call the system 'abort'.  This has to go right at the end of
903
   this file, so that there are no functions after it that call abort
904
   and get the system abort instead of our macro.  */
905
#undef abort
906
static void
907
real_abort (void)
908
{
909
  abort ();
910
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.