1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
2 Copyright (C) 1999-2017 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file implements the language independent aspect of diagnostic
27 #include "coretypes.h"
31 #include "backtrace.h"
32 #include "diagnostic.h"
33 #include "diagnostic-color.h"
34 #include "edit-context.h"
41 #ifdef GWINSZ_IN_SYS_IOCTL
42 # include <sys/ioctl.h>
45 #define pedantic_warning_kind(DC) \
46 ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
47 #define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
48 #define permissive_error_option(DC) ((DC)->opt_permissive)
51 static bool diagnostic_impl (rich_location
*, int, const char *,
52 va_list *, diagnostic_t
) ATTRIBUTE_GCC_DIAG(3,0);
53 static bool diagnostic_n_impl (location_t
, int, int, const char *,
54 const char *, va_list *,
55 diagnostic_t
) ATTRIBUTE_GCC_DIAG(5,0);
56 static bool diagnostic_n_impl_richloc (rich_location
*, int, int, const char *,
57 const char *, va_list *,
58 diagnostic_t
) ATTRIBUTE_GCC_DIAG(5,0);
60 static void error_recursion (diagnostic_context
*) ATTRIBUTE_NORETURN
;
61 static void real_abort (void) ATTRIBUTE_NORETURN
;
63 /* Name of program invoked, sans directories. */
67 /* A diagnostic_context surrogate for stderr. */
68 static diagnostic_context global_diagnostic_context
;
69 diagnostic_context
*global_dc
= &global_diagnostic_context
;
71 /* Return a malloc'd string containing MSG formatted a la printf. The
72 caller is responsible for freeing the memory. */
74 build_message_string (const char *msg
, ...)
80 str
= xvasprintf (msg
, ap
);
86 /* Same as diagnostic_build_prefix, but only the source FILE is given. */
88 file_name_as_prefix (diagnostic_context
*context
, const char *f
)
91 = colorize_start (pp_show_color (context
->printer
), "locus");
92 const char *locus_ce
= colorize_stop (pp_show_color (context
->printer
));
93 return build_message_string ("%s%s:%s ", locus_cs
, f
, locus_ce
);
98 /* Return the value of the getenv("COLUMNS") as an integer. If the
99 value is not set to a positive integer, use ioctl to get the
100 terminal width. If it fails, return INT_MAX. */
102 get_terminal_width (void)
104 const char * s
= getenv ("COLUMNS");
114 if (ioctl (0, TIOCGWINSZ
, &w
) == 0 && w
.ws_col
> 0)
121 /* Set caret_max_width to value. */
123 diagnostic_set_caret_max_width (diagnostic_context
*context
, int value
)
125 /* One minus to account for the leading empty space. */
126 value
= value
? value
- 1
127 : (isatty (fileno (pp_buffer (context
->printer
)->stream
))
128 ? get_terminal_width () - 1: INT_MAX
);
133 context
->caret_max_width
= value
;
136 /* Initialize the diagnostic message outputting machinery. */
138 diagnostic_initialize (diagnostic_context
*context
, int n_opts
)
142 /* Allocate a basic pretty-printer. Clients will replace this a
143 much more elaborated pretty-printer if they wish. */
144 context
->printer
= XNEW (pretty_printer
);
145 new (context
->printer
) pretty_printer ();
147 memset (context
->diagnostic_count
, 0, sizeof context
->diagnostic_count
);
148 context
->warning_as_error_requested
= false;
149 context
->n_opts
= n_opts
;
150 context
->classify_diagnostic
= XNEWVEC (diagnostic_t
, n_opts
);
151 for (i
= 0; i
< n_opts
; i
++)
152 context
->classify_diagnostic
[i
] = DK_UNSPECIFIED
;
153 context
->show_caret
= false;
154 diagnostic_set_caret_max_width (context
, pp_line_cutoff (context
->printer
));
155 for (i
= 0; i
< rich_location::STATICALLY_ALLOCATED_RANGES
; i
++)
156 context
->caret_chars
[i
] = '^';
157 context
->show_option_requested
= false;
158 context
->abort_on_error
= false;
159 context
->show_column
= false;
160 context
->pedantic_errors
= false;
161 context
->permissive
= false;
162 context
->opt_permissive
= 0;
163 context
->fatal_errors
= false;
164 context
->dc_inhibit_warnings
= false;
165 context
->dc_warn_system_headers
= false;
166 context
->max_errors
= 0;
167 context
->internal_error
= NULL
;
168 diagnostic_starter (context
) = default_diagnostic_starter
;
169 context
->start_span
= default_diagnostic_start_span_fn
;
170 diagnostic_finalizer (context
) = default_diagnostic_finalizer
;
171 context
->option_enabled
= NULL
;
172 context
->option_state
= NULL
;
173 context
->option_name
= NULL
;
174 context
->last_location
= UNKNOWN_LOCATION
;
175 context
->last_module
= 0;
176 context
->x_data
= NULL
;
178 context
->inhibit_notes_p
= false;
179 context
->colorize_source_p
= false;
180 context
->show_ruler_p
= false;
181 context
->parseable_fixits_p
= false;
182 context
->edit_context_ptr
= NULL
;
185 /* Maybe initialize the color support. We require clients to do this
186 explicitly, since most clients don't want color. When called
187 without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */
190 diagnostic_color_init (diagnostic_context
*context
, int value
/*= -1 */)
192 /* value == -1 is the default value. */
195 /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to
196 -fdiagnostics-color=auto if GCC_COLORS is in the environment,
197 otherwise default to -fdiagnostics-color=never, for other
198 values default to that
199 -fdiagnostics-color={never,auto,always}. */
200 if (DIAGNOSTICS_COLOR_DEFAULT
== -1)
202 if (!getenv ("GCC_COLORS"))
204 value
= DIAGNOSTICS_COLOR_AUTO
;
207 value
= DIAGNOSTICS_COLOR_DEFAULT
;
209 pp_show_color (context
->printer
)
210 = colorize_init ((diagnostic_color_rule_t
) value
);
213 /* Do any cleaning up required after the last diagnostic is emitted. */
216 diagnostic_finish (diagnostic_context
*context
)
218 /* Some of the errors may actually have been warnings. */
219 if (diagnostic_kind_count (context
, DK_WERROR
))
221 /* -Werror was given. */
222 if (context
->warning_as_error_requested
)
223 pp_verbatim (context
->printer
,
224 _("%s: all warnings being treated as errors"),
226 /* At least one -Werror= was given. */
228 pp_verbatim (context
->printer
,
229 _("%s: some warnings being treated as errors"),
231 pp_newline_and_flush (context
->printer
);
234 diagnostic_file_cache_fini ();
236 XDELETEVEC (context
->classify_diagnostic
);
237 context
->classify_diagnostic
= NULL
;
239 /* diagnostic_initialize allocates context->printer using XNEW
240 and placement-new. */
241 context
->printer
->~pretty_printer ();
242 XDELETE (context
->printer
);
243 context
->printer
= NULL
;
245 if (context
->edit_context_ptr
)
247 delete context
->edit_context_ptr
;
248 context
->edit_context_ptr
= NULL
;
252 /* Initialize DIAGNOSTIC, where the message MSG has already been
255 diagnostic_set_info_translated (diagnostic_info
*diagnostic
, const char *msg
,
256 va_list *args
, rich_location
*richloc
,
259 gcc_assert (richloc
);
260 diagnostic
->message
.err_no
= errno
;
261 diagnostic
->message
.args_ptr
= args
;
262 diagnostic
->message
.format_spec
= msg
;
263 diagnostic
->message
.m_richloc
= richloc
;
264 diagnostic
->richloc
= richloc
;
265 diagnostic
->kind
= kind
;
266 diagnostic
->option_index
= 0;
269 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
272 diagnostic_set_info (diagnostic_info
*diagnostic
, const char *gmsgid
,
273 va_list *args
, rich_location
*richloc
,
276 gcc_assert (richloc
);
277 diagnostic_set_info_translated (diagnostic
, _(gmsgid
), args
, richloc
, kind
);
280 static const char *const diagnostic_kind_color
[] = {
281 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
282 #include "diagnostic.def"
283 #undef DEFINE_DIAGNOSTIC_KIND
287 /* Get a color name for diagnostics of type KIND
288 Result could be NULL. */
291 diagnostic_get_color_for_kind (diagnostic_t kind
)
293 return diagnostic_kind_color
[kind
];
296 /* Return a malloc'd string describing a location e.g. "foo.c:42:10".
297 The caller is responsible for freeing the memory. */
300 diagnostic_get_location_text (diagnostic_context
*context
,
303 pretty_printer
*pp
= context
->printer
;
304 const char *locus_cs
= colorize_start (pp_show_color (pp
), "locus");
305 const char *locus_ce
= colorize_stop (pp_show_color (pp
));
308 return build_message_string ("%s%s:%s", locus_cs
, progname
, locus_ce
);
310 if (!strcmp (s
.file
, N_("<built-in>")))
311 return build_message_string ("%s%s:%s", locus_cs
, s
.file
, locus_ce
);
313 if (context
->show_column
)
314 return build_message_string ("%s%s:%d:%d:%s", locus_cs
, s
.file
, s
.line
,
317 return build_message_string ("%s%s:%d:%s", locus_cs
, s
.file
, s
.line
,
321 /* Return a malloc'd string describing a location and the severity of the
322 diagnostic, e.g. "foo.c:42:10: error: ". The caller is responsible for
323 freeing the memory. */
325 diagnostic_build_prefix (diagnostic_context
*context
,
326 const diagnostic_info
*diagnostic
)
328 static const char *const diagnostic_kind_text
[] = {
329 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
330 #include "diagnostic.def"
331 #undef DEFINE_DIAGNOSTIC_KIND
334 gcc_assert (diagnostic
->kind
< DK_LAST_DIAGNOSTIC_KIND
);
336 const char *text
= _(diagnostic_kind_text
[diagnostic
->kind
]);
337 const char *text_cs
= "", *text_ce
= "";
338 pretty_printer
*pp
= context
->printer
;
340 if (diagnostic_kind_color
[diagnostic
->kind
])
342 text_cs
= colorize_start (pp_show_color (pp
),
343 diagnostic_kind_color
[diagnostic
->kind
]);
344 text_ce
= colorize_stop (pp_show_color (pp
));
347 expanded_location s
= diagnostic_expand_location (diagnostic
);
348 char *location_text
= diagnostic_get_location_text (context
, s
);
350 char *result
= build_message_string ("%s %s%s%s", location_text
,
351 text_cs
, text
, text_ce
);
352 free (location_text
);
356 /* Functions at which to stop the backtrace print. It's not
357 particularly helpful to print the callers of these functions. */
359 static const char * const bt_stop
[] =
367 /* A callback function passed to the backtrace_full function. */
370 bt_callback (void *data
, uintptr_t pc
, const char *filename
, int lineno
,
371 const char *function
)
373 int *pcount
= (int *) data
;
375 /* If we don't have any useful information, don't print
377 if (filename
== NULL
&& function
== NULL
)
380 /* Skip functions in diagnostic.c. */
383 && strcmp (lbasename (filename
), "diagnostic.c") == 0)
386 /* Print up to 20 functions. We could make this a --param, but
387 since this is only for debugging just use a constant for now. */
390 /* Returning a non-zero value stops the backtrace. */
396 if (function
!= NULL
)
398 char *str
= cplus_demangle_v3 (function
,
399 (DMGL_VERBOSE
| DMGL_ANSI
400 | DMGL_GNU_V3
| DMGL_PARAMS
));
407 for (size_t i
= 0; i
< ARRAY_SIZE (bt_stop
); ++i
)
409 size_t len
= strlen (bt_stop
[i
]);
410 if (strncmp (function
, bt_stop
[i
], len
) == 0
411 && (function
[len
] == '\0' || function
[len
] == '('))
415 /* Returning a non-zero value stops the backtrace. */
421 fprintf (stderr
, "0x%lx %s\n\t%s:%d\n",
423 function
== NULL
? "???" : function
,
424 filename
== NULL
? "???" : filename
,
433 /* A callback function passed to the backtrace_full function. This is
434 called if backtrace_full has an error. */
437 bt_err_callback (void *data ATTRIBUTE_UNUSED
, const char *msg
, int errnum
)
441 /* This means that no debug info was available. Just quietly
442 skip printing backtrace info. */
445 fprintf (stderr
, "%s%s%s\n", msg
, errnum
== 0 ? "" : ": ",
446 errnum
== 0 ? "" : xstrerror (errnum
));
449 /* Check if we've met the maximum error limit, and if so fatally exit
450 with a message. CONTEXT is the context to check, and FLUSH
451 indicates whether a diagnostic_finish call is needed. */
454 diagnostic_check_max_errors (diagnostic_context
*context
, bool flush
)
456 if (!context
->max_errors
)
459 int count
= (diagnostic_kind_count (context
, DK_ERROR
)
460 + diagnostic_kind_count (context
, DK_SORRY
)
461 + diagnostic_kind_count (context
, DK_WERROR
));
463 if (count
>= context
->max_errors
)
466 "compilation terminated due to -fmax-errors=%u.\n",
467 context
->max_errors
);
469 diagnostic_finish (context
);
470 exit (FATAL_EXIT_CODE
);
474 /* Take any action which is expected to happen after the diagnostic
475 is written out. This function does not always return. */
477 diagnostic_action_after_output (diagnostic_context
*context
,
478 diagnostic_t diag_kind
)
490 if (context
->abort_on_error
)
492 if (context
->fatal_errors
)
494 fnotice (stderr
, "compilation terminated due to -Wfatal-errors.\n");
495 diagnostic_finish (context
);
496 exit (FATAL_EXIT_CODE
);
503 struct backtrace_state
*state
= NULL
;
504 if (diag_kind
== DK_ICE
)
505 state
= backtrace_create_state (NULL
, 0, bt_err_callback
, NULL
);
508 backtrace_full (state
, 2, bt_callback
, bt_err_callback
,
511 if (context
->abort_on_error
)
514 fnotice (stderr
, "Please submit a full bug report,\n"
515 "with preprocessed source if appropriate.\n");
518 ("Please include the complete backtrace "
519 "with any bug report.\n"));
520 fnotice (stderr
, "See %s for instructions.\n", bug_report_url
);
522 exit (ICE_EXIT_CODE
);
526 if (context
->abort_on_error
)
528 diagnostic_finish (context
);
529 fnotice (stderr
, "compilation terminated.\n");
530 exit (FATAL_EXIT_CODE
);
538 diagnostic_report_current_module (diagnostic_context
*context
, location_t where
)
540 const line_map_ordinary
*map
= NULL
;
542 if (pp_needs_newline (context
->printer
))
544 pp_newline (context
->printer
);
545 pp_needs_newline (context
->printer
) = false;
548 if (where
<= BUILTINS_LOCATION
)
551 linemap_resolve_location (line_table
, where
,
552 LRK_MACRO_DEFINITION_LOCATION
,
555 if (map
&& diagnostic_last_module_changed (context
, map
))
557 diagnostic_set_last_module (context
, map
);
558 if (! MAIN_FILE_P (map
))
560 map
= INCLUDED_FROM (line_table
, map
);
561 if (context
->show_column
)
562 pp_verbatim (context
->printer
,
563 "In file included from %r%s:%d:%d%R", "locus",
565 LAST_SOURCE_LINE (map
), LAST_SOURCE_COLUMN (map
));
567 pp_verbatim (context
->printer
,
568 "In file included from %r%s:%d%R", "locus",
569 LINEMAP_FILE (map
), LAST_SOURCE_LINE (map
));
570 while (! MAIN_FILE_P (map
))
572 map
= INCLUDED_FROM (line_table
, map
);
573 pp_verbatim (context
->printer
,
574 ",\n from %r%s:%d%R", "locus",
575 LINEMAP_FILE (map
), LAST_SOURCE_LINE (map
));
577 pp_verbatim (context
->printer
, ":");
578 pp_newline (context
->printer
);
584 default_diagnostic_starter (diagnostic_context
*context
,
585 diagnostic_info
*diagnostic
)
587 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
588 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
593 default_diagnostic_start_span_fn (diagnostic_context
*context
,
594 expanded_location exploc
)
596 pp_set_prefix (context
->printer
,
597 diagnostic_get_location_text (context
, exploc
));
598 pp_string (context
->printer
, "");
599 pp_newline (context
->printer
);
603 default_diagnostic_finalizer (diagnostic_context
*context
,
604 diagnostic_info
*diagnostic
)
606 diagnostic_show_locus (context
, diagnostic
->richloc
, diagnostic
->kind
);
607 pp_destroy_prefix (context
->printer
);
608 pp_flush (context
->printer
);
611 /* Interface to specify diagnostic kind overrides. Returns the
612 previous setting, or DK_UNSPECIFIED if the parameters are out of
613 range. If OPTION_INDEX is zero, the new setting is for all the
616 diagnostic_classify_diagnostic (diagnostic_context
*context
,
618 diagnostic_t new_kind
,
621 diagnostic_t old_kind
;
624 || option_index
>= context
->n_opts
625 || new_kind
>= DK_LAST_DIAGNOSTIC_KIND
)
626 return DK_UNSPECIFIED
;
628 old_kind
= context
->classify_diagnostic
[option_index
];
630 /* Handle pragmas separately, since we need to keep track of *where*
632 if (where
!= UNKNOWN_LOCATION
)
636 /* Record the command-line status, so we can reset it back on DK_POP. */
637 if (old_kind
== DK_UNSPECIFIED
)
639 old_kind
= !context
->option_enabled (option_index
,
640 context
->option_state
)
641 ? DK_IGNORED
: (context
->warning_as_error_requested
642 ? DK_ERROR
: DK_WARNING
);
643 context
->classify_diagnostic
[option_index
] = old_kind
;
646 for (i
= context
->n_classification_history
- 1; i
>= 0; i
--)
647 if (context
->classification_history
[i
].option
== option_index
)
649 old_kind
= context
->classification_history
[i
].kind
;
653 i
= context
->n_classification_history
;
654 context
->classification_history
=
655 (diagnostic_classification_change_t
*) xrealloc (context
->classification_history
, (i
+ 1)
656 * sizeof (diagnostic_classification_change_t
));
657 context
->classification_history
[i
].location
= where
;
658 context
->classification_history
[i
].option
= option_index
;
659 context
->classification_history
[i
].kind
= new_kind
;
660 context
->n_classification_history
++;
663 context
->classify_diagnostic
[option_index
] = new_kind
;
668 /* Save all diagnostic classifications in a stack. */
670 diagnostic_push_diagnostics (diagnostic_context
*context
, location_t where ATTRIBUTE_UNUSED
)
672 context
->push_list
= (int *) xrealloc (context
->push_list
, (context
->n_push
+ 1) * sizeof (int));
673 context
->push_list
[context
->n_push
++] = context
->n_classification_history
;
676 /* Restore the topmost classification set off the stack. If the stack
677 is empty, revert to the state based on command line parameters. */
679 diagnostic_pop_diagnostics (diagnostic_context
*context
, location_t where
)
685 jump_to
= context
->push_list
[-- context
->n_push
];
689 i
= context
->n_classification_history
;
690 context
->classification_history
=
691 (diagnostic_classification_change_t
*) xrealloc (context
->classification_history
, (i
+ 1)
692 * sizeof (diagnostic_classification_change_t
));
693 context
->classification_history
[i
].location
= where
;
694 context
->classification_history
[i
].option
= jump_to
;
695 context
->classification_history
[i
].kind
= DK_POP
;
696 context
->n_classification_history
++;
699 /* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the
700 escaping rules for -fdiagnostics-parseable-fixits. */
703 print_escaped_string (pretty_printer
*pp
, const char *text
)
708 pp_character (pp
, '"');
709 for (const char *ch
= text
; *ch
; ch
++)
714 /* Escape backslash as two backslashes. */
715 pp_string (pp
, "\\\\");
718 /* Escape tab as "\t". */
719 pp_string (pp
, "\\t");
722 /* Escape newline as "\n". */
723 pp_string (pp
, "\\n");
726 /* Escape doublequotes as \". */
727 pp_string (pp
, "\\\"");
731 pp_character (pp
, *ch
);
733 /* Use octal for non-printable chars. */
735 unsigned char c
= (*ch
& 0xff);
736 pp_printf (pp
, "\\%o%o%o", (c
/ 64), (c
/ 8) & 007, c
& 007);
741 pp_character (pp
, '"');
744 /* Implementation of -fdiagnostics-parseable-fixits. Print a
745 machine-parseable version of all fixits in RICHLOC to PP. */
748 print_parseable_fixits (pretty_printer
*pp
, rich_location
*richloc
)
751 gcc_assert (richloc
);
753 for (unsigned i
= 0; i
< richloc
->get_num_fixit_hints (); i
++)
755 const fixit_hint
*hint
= richloc
->get_fixit_hint (i
);
756 source_location start_loc
= hint
->get_start_loc ();
757 expanded_location start_exploc
= expand_location (start_loc
);
758 pp_string (pp
, "fix-it:");
759 print_escaped_string (pp
, start_exploc
.file
);
760 /* For compatibility with clang, print as a half-open range. */
761 source_location next_loc
= hint
->get_next_loc ();
762 expanded_location next_exploc
= expand_location (next_loc
);
763 pp_printf (pp
, ":{%i:%i-%i:%i}:",
764 start_exploc
.line
, start_exploc
.column
,
765 next_exploc
.line
, next_exploc
.column
);
766 print_escaped_string (pp
, hint
->get_string ());
771 /* Report a diagnostic message (an error or a warning) as specified by
772 DC. This function is *the* subroutine in terms of which front-ends
773 should implement their specific diagnostic handling modules. The
774 front-end independent format specifiers are exactly those described
775 in the documentation of output_format.
776 Return true if a diagnostic was printed, false otherwise. */
779 diagnostic_report_diagnostic (diagnostic_context
*context
,
780 diagnostic_info
*diagnostic
)
782 location_t location
= diagnostic_location (diagnostic
);
783 diagnostic_t orig_diag_kind
= diagnostic
->kind
;
784 const char *saved_format_spec
;
786 /* Give preference to being able to inhibit warnings, before they
787 get reclassified to something else. */
788 if ((diagnostic
->kind
== DK_WARNING
|| diagnostic
->kind
== DK_PEDWARN
)
789 && !diagnostic_report_warnings_p (context
, location
))
792 if (diagnostic
->kind
== DK_PEDWARN
)
794 diagnostic
->kind
= pedantic_warning_kind (context
);
795 /* We do this to avoid giving the message for -pedantic-errors. */
796 orig_diag_kind
= diagnostic
->kind
;
799 if (diagnostic
->kind
== DK_NOTE
&& context
->inhibit_notes_p
)
802 if (context
->lock
> 0)
804 /* If we're reporting an ICE in the middle of some other error,
805 try to flush out the previous error, then let this one
806 through. Don't do this more than once. */
807 if ((diagnostic
->kind
== DK_ICE
|| diagnostic
->kind
== DK_ICE_NOBT
)
808 && context
->lock
== 1)
809 pp_newline_and_flush (context
->printer
);
811 error_recursion (context
);
814 /* If the user requested that warnings be treated as errors, so be
815 it. Note that we do this before the next block so that
816 individual warnings can be overridden back to warnings with
818 if (context
->warning_as_error_requested
819 && diagnostic
->kind
== DK_WARNING
)
820 diagnostic
->kind
= DK_ERROR
;
822 if (diagnostic
->option_index
823 && diagnostic
->option_index
!= permissive_error_option (context
))
825 diagnostic_t diag_class
= DK_UNSPECIFIED
;
827 /* This tests if the user provided the appropriate -Wfoo or
829 if (! context
->option_enabled (diagnostic
->option_index
,
830 context
->option_state
))
833 /* This tests for #pragma diagnostic changes. */
834 if (context
->n_classification_history
> 0)
836 /* FIXME: Stupid search. Optimize later. */
837 for (int i
= context
->n_classification_history
- 1; i
>= 0; i
--)
839 if (linemap_location_before_p
841 context
->classification_history
[i
].location
,
844 if (context
->classification_history
[i
].kind
== (int) DK_POP
)
846 i
= context
->classification_history
[i
].option
;
849 int option
= context
->classification_history
[i
].option
;
850 /* The option 0 is for all the diagnostics. */
851 if (option
== 0 || option
== diagnostic
->option_index
)
853 diag_class
= context
->classification_history
[i
].kind
;
854 if (diag_class
!= DK_UNSPECIFIED
)
855 diagnostic
->kind
= diag_class
;
862 /* This tests if the user provided the appropriate -Werror=foo
864 if (diag_class
== DK_UNSPECIFIED
865 && (context
->classify_diagnostic
[diagnostic
->option_index
]
868 = context
->classify_diagnostic
[diagnostic
->option_index
];
870 /* This allows for future extensions, like temporarily disabling
871 warnings for ranges of source code. */
872 if (diagnostic
->kind
== DK_IGNORED
)
876 if (diagnostic
->kind
!= DK_NOTE
)
877 diagnostic_check_max_errors (context
);
881 if (diagnostic
->kind
== DK_ICE
|| diagnostic
->kind
== DK_ICE_NOBT
)
883 /* When not checking, ICEs are converted to fatal errors when an
884 error has already occurred. This is counteracted by
887 && (diagnostic_kind_count (context
, DK_ERROR
) > 0
888 || diagnostic_kind_count (context
, DK_SORRY
) > 0)
889 && !context
->abort_on_error
)
892 = expand_location (diagnostic_location (diagnostic
));
893 fnotice (stderr
, "%s:%d: confused by earlier errors, bailing out\n",
895 exit (ICE_EXIT_CODE
);
897 if (context
->internal_error
)
898 (*context
->internal_error
) (context
,
899 diagnostic
->message
.format_spec
,
900 diagnostic
->message
.args_ptr
);
902 if (diagnostic
->kind
== DK_ERROR
&& orig_diag_kind
== DK_WARNING
)
903 ++diagnostic_kind_count (context
, DK_WERROR
);
905 ++diagnostic_kind_count (context
, diagnostic
->kind
);
907 saved_format_spec
= diagnostic
->message
.format_spec
;
908 if (context
->show_option_requested
)
912 option_text
= context
->option_name (context
, diagnostic
->option_index
,
913 orig_diag_kind
, diagnostic
->kind
);
918 = colorize_start (pp_show_color (context
->printer
),
919 diagnostic_kind_color
[diagnostic
->kind
]);
920 const char *ce
= colorize_stop (pp_show_color (context
->printer
));
921 diagnostic
->message
.format_spec
922 = ACONCAT ((diagnostic
->message
.format_spec
,
924 "[", cs
, option_text
, ce
, "]",
929 diagnostic
->message
.x_data
= &diagnostic
->x_data
;
930 diagnostic
->x_data
= NULL
;
931 pp_format (context
->printer
, &diagnostic
->message
);
932 (*diagnostic_starter (context
)) (context
, diagnostic
);
933 pp_output_formatted_text (context
->printer
);
934 (*diagnostic_finalizer (context
)) (context
, diagnostic
);
935 if (context
->parseable_fixits_p
)
937 print_parseable_fixits (context
->printer
, diagnostic
->richloc
);
938 pp_flush (context
->printer
);
940 diagnostic_action_after_output (context
, diagnostic
->kind
);
941 diagnostic
->message
.format_spec
= saved_format_spec
;
942 diagnostic
->x_data
= NULL
;
944 if (context
->edit_context_ptr
)
945 context
->edit_context_ptr
->add_fixits (diagnostic
->richloc
);
952 /* Given a partial pathname as input, return another pathname that
953 shares no directory elements with the pathname of __FILE__. This
954 is used by fancy_abort() to print `Internal compiler error in expr.c'
955 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
958 trim_filename (const char *name
)
960 static const char this_file
[] = __FILE__
;
961 const char *p
= name
, *q
= this_file
;
963 /* First skip any "../" in each filename. This allows us to give a proper
964 reference to a file in a subdirectory. */
965 while (p
[0] == '.' && p
[1] == '.' && IS_DIR_SEPARATOR (p
[2]))
968 while (q
[0] == '.' && q
[1] == '.' && IS_DIR_SEPARATOR (q
[2]))
971 /* Now skip any parts the two filenames have in common. */
972 while (*p
== *q
&& *p
!= 0 && *q
!= 0)
975 /* Now go backwards until the previous directory separator. */
976 while (p
> name
&& !IS_DIR_SEPARATOR (p
[-1]))
982 /* Standard error reporting routines in increasing order of severity.
983 All of these take arguments like printf. */
985 /* Text to be emitted verbatim to the error message stream; this
986 produces no prefix and disables line-wrapping. Use rarely. */
988 verbatim (const char *gmsgid
, ...)
993 va_start (ap
, gmsgid
);
996 text
.format_spec
= _(gmsgid
);
998 pp_format_verbatim (global_dc
->printer
, &text
);
999 pp_newline_and_flush (global_dc
->printer
);
1003 /* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT. */
1005 diagnostic_append_note (diagnostic_context
*context
,
1006 location_t location
,
1007 const char * gmsgid
, ...)
1009 diagnostic_info diagnostic
;
1011 const char *saved_prefix
;
1012 rich_location
richloc (line_table
, location
);
1014 va_start (ap
, gmsgid
);
1015 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
, DK_NOTE
);
1016 if (context
->inhibit_notes_p
)
1021 saved_prefix
= pp_get_prefix (context
->printer
);
1022 pp_set_prefix (context
->printer
,
1023 diagnostic_build_prefix (context
, &diagnostic
));
1024 pp_format (context
->printer
, &diagnostic
.message
);
1025 pp_output_formatted_text (context
->printer
);
1026 pp_destroy_prefix (context
->printer
);
1027 pp_set_prefix (context
->printer
, saved_prefix
);
1028 diagnostic_show_locus (context
, &richloc
, DK_NOTE
);
1032 /* Implement emit_diagnostic, inform, inform_at_rich_loc, warning, warning_at,
1033 warning_at_rich_loc, pedwarn, permerror, permerror_at_rich_loc, error,
1034 error_at, error_at_rich_loc, sorry, fatal_error, internal_error, and
1035 internal_error_no_backtrace, as documented and defined below. */
1037 diagnostic_impl (rich_location
*richloc
, int opt
,
1039 va_list *ap
, diagnostic_t kind
)
1041 diagnostic_info diagnostic
;
1042 if (kind
== DK_PERMERROR
)
1044 diagnostic_set_info (&diagnostic
, gmsgid
, ap
, richloc
,
1045 permissive_error_kind (global_dc
));
1046 diagnostic
.option_index
= permissive_error_option (global_dc
);
1050 diagnostic_set_info (&diagnostic
, gmsgid
, ap
, richloc
, kind
);
1051 if (kind
== DK_WARNING
|| kind
== DK_PEDWARN
)
1052 diagnostic
.option_index
= opt
;
1054 return report_diagnostic (&diagnostic
);
1057 /* Same as diagonostic_n_impl taking rich_location instead of location_t. */
1059 diagnostic_n_impl_richloc (rich_location
*richloc
, int opt
, int n
,
1060 const char *singular_gmsgid
,
1061 const char *plural_gmsgid
,
1062 va_list *ap
, diagnostic_t kind
)
1064 diagnostic_info diagnostic
;
1065 diagnostic_set_info_translated (&diagnostic
,
1066 ngettext (singular_gmsgid
, plural_gmsgid
, n
),
1068 if (kind
== DK_WARNING
)
1069 diagnostic
.option_index
= opt
;
1070 return report_diagnostic (&diagnostic
);
1073 /* Implement inform_n, warning_n, and error_n, as documented and
1076 diagnostic_n_impl (location_t location
, int opt
, int n
,
1077 const char *singular_gmsgid
,
1078 const char *plural_gmsgid
,
1079 va_list *ap
, diagnostic_t kind
)
1081 rich_location
richloc (line_table
, location
);
1082 return diagnostic_n_impl_richloc (&richloc
, opt
, n
,
1083 singular_gmsgid
, plural_gmsgid
, ap
, kind
);
1087 emit_diagnostic (diagnostic_t kind
, location_t location
, int opt
,
1088 const char *gmsgid
, ...)
1091 va_start (ap
, gmsgid
);
1092 rich_location
richloc (line_table
, location
);
1093 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, kind
);
1098 /* An informative note at LOCATION. Use this for additional details on an error
1101 inform (location_t location
, const char *gmsgid
, ...)
1104 va_start (ap
, gmsgid
);
1105 rich_location
richloc (line_table
, location
);
1106 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_NOTE
);
1110 /* Same as "inform", but at RICHLOC. */
1112 inform_at_rich_loc (rich_location
*richloc
, const char *gmsgid
, ...)
1115 va_start (ap
, gmsgid
);
1116 diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_NOTE
);
1120 /* An informative note at LOCATION. Use this for additional details on an
1123 inform_n (location_t location
, int n
, const char *singular_gmsgid
,
1124 const char *plural_gmsgid
, ...)
1127 va_start (ap
, plural_gmsgid
);
1128 diagnostic_n_impl (location
, -1, n
, singular_gmsgid
, plural_gmsgid
,
1133 /* A warning at INPUT_LOCATION. Use this for code which is correct according
1134 to the relevant language specification but is likely to be buggy anyway.
1135 Returns true if the warning was printed, false if it was inhibited. */
1137 warning (int opt
, const char *gmsgid
, ...)
1140 va_start (ap
, gmsgid
);
1141 rich_location
richloc (line_table
, input_location
);
1142 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1147 /* A warning at LOCATION. Use this for code which is correct according to the
1148 relevant language specification but is likely to be buggy anyway.
1149 Returns true if the warning was printed, false if it was inhibited. */
1152 warning_at (location_t location
, int opt
, const char *gmsgid
, ...)
1155 va_start (ap
, gmsgid
);
1156 rich_location
richloc (line_table
, location
);
1157 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1162 /* Same as warning at, but using RICHLOC. */
1165 warning_at_rich_loc (rich_location
*richloc
, int opt
, const char *gmsgid
, ...)
1168 va_start (ap
, gmsgid
);
1169 bool ret
= diagnostic_impl (richloc
, opt
, gmsgid
, &ap
, DK_WARNING
);
1174 /* Same as warning_at_rich_loc but for plural variant. */
1177 warning_at_rich_loc_n (rich_location
*richloc
, int opt
, int n
,
1178 const char *singular_gmsgid
, const char *plural_gmsgid
, ...)
1181 va_start (ap
, plural_gmsgid
);
1182 bool ret
= diagnostic_n_impl_richloc (richloc
, opt
, n
,
1183 singular_gmsgid
, plural_gmsgid
,
1189 /* A warning at LOCATION. Use this for code which is correct according to the
1190 relevant language specification but is likely to be buggy anyway.
1191 Returns true if the warning was printed, false if it was inhibited. */
1194 warning_n (location_t location
, int opt
, int n
, const char *singular_gmsgid
,
1195 const char *plural_gmsgid
, ...)
1198 va_start (ap
, plural_gmsgid
);
1199 bool ret
= diagnostic_n_impl (location
, opt
, n
,
1200 singular_gmsgid
, plural_gmsgid
,
1206 /* A "pedantic" warning at LOCATION: issues a warning unless
1207 -pedantic-errors was given on the command line, in which case it
1208 issues an error. Use this for diagnostics required by the relevant
1209 language standard, if you have chosen not to make them errors.
1211 Note that these diagnostics are issued independent of the setting
1212 of the -Wpedantic command-line switch. To get a warning enabled
1213 only with that switch, use either "if (pedantic) pedwarn
1214 (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
1215 pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1217 Returns true if the warning was printed, false if it was inhibited. */
1220 pedwarn (location_t location
, int opt
, const char *gmsgid
, ...)
1223 va_start (ap
, gmsgid
);
1224 rich_location
richloc (line_table
, location
);
1225 bool ret
= diagnostic_impl (&richloc
, opt
, gmsgid
, &ap
, DK_PEDWARN
);
1230 /* Same as pedwarn, but using RICHLOC. */
1233 pedwarn_at_rich_loc (rich_location
*richloc
, int opt
, const char *gmsgid
, ...)
1236 va_start (ap
, gmsgid
);
1237 bool ret
= diagnostic_impl (richloc
, opt
, gmsgid
, &ap
, DK_PEDWARN
);
1242 /* A "permissive" error at LOCATION: issues an error unless
1243 -fpermissive was given on the command line, in which case it issues
1244 a warning. Use this for things that really should be errors but we
1245 want to support legacy code.
1247 Returns true if the warning was printed, false if it was inhibited. */
1250 permerror (location_t location
, const char *gmsgid
, ...)
1253 va_start (ap
, gmsgid
);
1254 rich_location
richloc (line_table
, location
);
1255 bool ret
= diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_PERMERROR
);
1260 /* Same as "permerror", but at RICHLOC. */
1263 permerror_at_rich_loc (rich_location
*richloc
, const char *gmsgid
, ...)
1266 va_start (ap
, gmsgid
);
1267 bool ret
= diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_PERMERROR
);
1272 /* A hard error: the code is definitely ill-formed, and an object file
1273 will not be produced. */
1275 error (const char *gmsgid
, ...)
1278 va_start (ap
, gmsgid
);
1279 rich_location
richloc (line_table
, input_location
);
1280 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1284 /* A hard error: the code is definitely ill-formed, and an object file
1285 will not be produced. */
1287 error_n (location_t location
, int n
, const char *singular_gmsgid
,
1288 const char *plural_gmsgid
, ...)
1291 va_start (ap
, plural_gmsgid
);
1292 diagnostic_n_impl (location
, -1, n
, singular_gmsgid
, plural_gmsgid
,
1297 /* Same as above, but use location LOC instead of input_location. */
1299 error_at (location_t loc
, const char *gmsgid
, ...)
1302 va_start (ap
, gmsgid
);
1303 rich_location
richloc (line_table
, loc
);
1304 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1308 /* Same as above, but use RICH_LOC. */
1311 error_at_rich_loc (rich_location
*richloc
, const char *gmsgid
, ...)
1314 va_start (ap
, gmsgid
);
1315 diagnostic_impl (richloc
, -1, gmsgid
, &ap
, DK_ERROR
);
1319 /* "Sorry, not implemented." Use for a language feature which is
1320 required by the relevant specification but not implemented by GCC.
1321 An object file will not be produced. */
1323 sorry (const char *gmsgid
, ...)
1326 va_start (ap
, gmsgid
);
1327 rich_location
richloc (line_table
, input_location
);
1328 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_SORRY
);
1332 /* Return true if an error or a "sorry" has been seen. Various
1333 processing is disabled after errors. */
1337 return errorcount
|| sorrycount
;
1340 /* An error which is severe enough that we make no attempt to
1341 continue. Do not use this for internal consistency checks; that's
1342 internal_error. Use of this function should be rare. */
1344 fatal_error (location_t loc
, const char *gmsgid
, ...)
1347 va_start (ap
, gmsgid
);
1348 rich_location
richloc (line_table
, loc
);
1349 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_FATAL
);
1355 /* An internal consistency check has failed. We make no attempt to
1356 continue. Note that unless there is debugging value to be had from
1357 a more specific message, or some other good reason, you should use
1358 abort () instead of calling this function directly. */
1360 internal_error (const char *gmsgid
, ...)
1363 va_start (ap
, gmsgid
);
1364 rich_location
richloc (line_table
, input_location
);
1365 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ICE
);
1371 /* Like internal_error, but no backtrace will be printed. Used when
1372 the internal error does not happen at the current location, but happened
1375 internal_error_no_backtrace (const char *gmsgid
, ...)
1378 va_start (ap
, gmsgid
);
1379 rich_location
richloc (line_table
, input_location
);
1380 diagnostic_impl (&richloc
, -1, gmsgid
, &ap
, DK_ICE_NOBT
);
1386 /* Special case error functions. Most are implemented in terms of the
1387 above, or should be. */
1389 /* Print a diagnostic MSGID on FILE. This is just fprintf, except it
1390 runs its second argument through gettext. */
1392 fnotice (FILE *file
, const char *cmsgid
, ...)
1396 va_start (ap
, cmsgid
);
1397 vfprintf (file
, _(cmsgid
), ap
);
1401 /* Inform the user that an error occurred while trying to report some
1402 other error. This indicates catastrophic internal inconsistencies,
1403 so give up now. But do try to flush out the previous error.
1404 This mustn't use internal_error, that will cause infinite recursion. */
1407 error_recursion (diagnostic_context
*context
)
1409 if (context
->lock
< 3)
1410 pp_newline_and_flush (context
->printer
);
1413 "Internal compiler error: Error reporting routines re-entered.\n");
1415 /* Call diagnostic_action_after_output to get the "please submit a bug
1417 diagnostic_action_after_output (context
, DK_ICE
);
1419 /* Do not use gcc_unreachable here; that goes through internal_error
1420 and therefore would cause infinite recursion. */
1424 /* Report an internal compiler error in a friendly manner. This is
1425 the function that gets called upon use of abort() in the source
1426 code generally, thanks to a special macro. */
1429 fancy_abort (const char *file
, int line
, const char *function
)
1431 internal_error ("in %s, at %s:%d", function
, trim_filename (file
), line
);
1434 /* Really call the system 'abort'. This has to go right at the end of
1435 this file, so that there are no functions after it that call abort
1436 and get the system abort instead of our macro. */
1446 namespace selftest
{
1448 /* Helper function for test_print_escaped_string. */
1451 assert_print_escaped_string (const location
&loc
, const char *expected_output
,
1455 print_escaped_string (&pp
, input
);
1456 ASSERT_STREQ_AT (loc
, expected_output
, pp_formatted_text (&pp
));
1459 #define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \
1460 assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT)
1462 /* Tests of print_escaped_string. */
1465 test_print_escaped_string ()
1468 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", "");
1470 /* Non-empty string. */
1471 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world");
1473 /* Various things that need to be escaped: */
1475 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"",
1478 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"",
1481 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"",
1484 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"",
1487 /* Non-printable characters: BEL: '\a': 0x07 */
1488 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"",
1490 /* Non-printable characters: vertical tab: '\v': 0x0b */
1491 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"",
1495 /* Tests of print_parseable_fixits. */
1497 /* Verify that print_parseable_fixits emits the empty string if there
1501 test_print_parseable_fixits_none ()
1504 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1506 print_parseable_fixits (&pp
, &richloc
);
1507 ASSERT_STREQ ("", pp_formatted_text (&pp
));
1510 /* Verify that print_parseable_fixits does the right thing if there
1511 is an insertion fixit hint. */
1514 test_print_parseable_fixits_insert ()
1517 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1519 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1520 linemap_line_start (line_table
, 5, 100);
1521 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1522 location_t where
= linemap_position_for_column (line_table
, 10);
1523 richloc
.add_fixit_insert_before (where
, "added content");
1525 print_parseable_fixits (&pp
, &richloc
);
1526 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
1527 pp_formatted_text (&pp
));
1530 /* Verify that print_parseable_fixits does the right thing if there
1531 is an removal fixit hint. */
1534 test_print_parseable_fixits_remove ()
1537 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1539 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1540 linemap_line_start (line_table
, 5, 100);
1541 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1543 where
.m_start
= linemap_position_for_column (line_table
, 10);
1544 where
.m_finish
= linemap_position_for_column (line_table
, 20);
1545 richloc
.add_fixit_remove (where
);
1547 print_parseable_fixits (&pp
, &richloc
);
1548 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
1549 pp_formatted_text (&pp
));
1552 /* Verify that print_parseable_fixits does the right thing if there
1553 is an replacement fixit hint. */
1556 test_print_parseable_fixits_replace ()
1559 rich_location
richloc (line_table
, UNKNOWN_LOCATION
);
1561 linemap_add (line_table
, LC_ENTER
, false, "test.c", 0);
1562 linemap_line_start (line_table
, 5, 100);
1563 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1565 where
.m_start
= linemap_position_for_column (line_table
, 10);
1566 where
.m_finish
= linemap_position_for_column (line_table
, 20);
1567 richloc
.add_fixit_replace (where
, "replacement");
1569 print_parseable_fixits (&pp
, &richloc
);
1570 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
1571 pp_formatted_text (&pp
));
1574 /* Run all of the selftests within this file. */
1577 diagnostic_c_tests ()
1579 test_print_escaped_string ();
1580 test_print_parseable_fixits_none ();
1581 test_print_parseable_fixits_insert ();
1582 test_print_parseable_fixits_remove ();
1583 test_print_parseable_fixits_replace ();
1586 } // namespace selftest
1588 #endif /* #if CHECKING_P */