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>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21
22/* This file implements the language independent aspect of diagnostic
23 message module. */
24
25#include "config.h"
26#include "system.h"
27#include "coretypes.h"
28#include "version.h"
29#include "demangle.h"
30#include "intl.h"
31#include "backtrace.h"
32#include "diagnostic.h"
33#include "diagnostic-color.h"
34#include "edit-context.h"
35#include "selftest.h"
36#include "selftest-diagnostic.h"
37
38#ifdef HAVE_TERMIOS_H
39# include <termios.h>
40#endif
41
42#ifdef GWINSZ_IN_SYS_IOCTL
43# include <sys/ioctl.h>
44#endif
45
46#define pedantic_warning_kind(DC) \
47 ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
48#define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
49#define permissive_error_option(DC) ((DC)->opt_permissive)
50
51/* Prototypes. */
52static bool diagnostic_impl (rich_location *, int, const char *,
53 va_list *, diagnostic_t) ATTRIBUTE_GCC_DIAG(3,0);
54static bool diagnostic_n_impl (rich_location *, int, int, const char *,
55 const char *, va_list *,
56 diagnostic_t) ATTRIBUTE_GCC_DIAG(5,0);
57
58static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
59static void real_abort (void) ATTRIBUTE_NORETURN;
60
61/* Name of program invoked, sans directories. */
62
63const char *progname;
64
65/* A diagnostic_context surrogate for stderr. */
66static diagnostic_context global_diagnostic_context;
67diagnostic_context *global_dc = &global_diagnostic_context;
68
69/* Return a malloc'd string containing MSG formatted a la printf. The
70 caller is responsible for freeing the memory. */
71char *
72build_message_string (const char *msg, ...)
73{
74 char *str;
75 va_list ap;
76
77 va_start (ap, msg);
78 str = xvasprintf (msg, ap);
79 va_end (ap);
80
81 return str;
82}
83
84/* Same as diagnostic_build_prefix, but only the source FILE is given. */
85char *
86file_name_as_prefix (diagnostic_context *context, const char *f)
87{
88 const char *locus_cs
89 = colorize_start (pp_show_color (context->printer), "locus");
90 const char *locus_ce = colorize_stop (pp_show_color (context->printer));
91 return build_message_string ("%s%s:%s ", locus_cs, f, locus_ce);
92}
93
94
95
96/* Return the value of the getenv("COLUMNS") as an integer. If the
97 value is not set to a positive integer, use ioctl to get the
98 terminal width. If it fails, return INT_MAX. */
99int
100get_terminal_width (void)
101{
102 const char * s = getenv ("COLUMNS");
103 if (s != NULL) {
104 int n = atoi (s);
105 if (n > 0)
106 return n;
107 }
108
109#ifdef TIOCGWINSZ
110 struct winsize w;
111 w.ws_col = 0;
112 if (ioctl (0, TIOCGWINSZ, &w) == 0 && w.ws_col > 0)
113 return w.ws_col;
114#endif
115
116 return INT_MAX;
117}
118
119/* Set caret_max_width to value. */
120void
121diagnostic_set_caret_max_width (diagnostic_context *context, int value)
122{
123 /* One minus to account for the leading empty space. */
124 value = value ? value - 1
125 : (isatty (fileno (pp_buffer (context->printer)->stream))
126 ? get_terminal_width () - 1: INT_MAX);
127
128 if (value <= 0)
129 value = INT_MAX;
130
131 context->caret_max_width = value;
132}
133
134/* Initialize the diagnostic message outputting machinery. */
135void
136diagnostic_initialize (diagnostic_context *context, int n_opts)
137{
138 int i;
139
140 /* Allocate a basic pretty-printer. Clients will replace this a
141 much more elaborated pretty-printer if they wish. */
142 context->printer = XNEW (pretty_printer);
143 new (context->printer) pretty_printer ();
144
145 memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
146 context->warning_as_error_requested = false;
147 context->n_opts = n_opts;
148 context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
149 for (i = 0; i < n_opts; i++)
150 context->classify_diagnostic[i] = DK_UNSPECIFIED;
151 context->show_caret = false;
152 diagnostic_set_caret_max_width (context, pp_line_cutoff (context->printer));
153 for (i = 0; i < rich_location::STATICALLY_ALLOCATED_RANGES; i++)
154 context->caret_chars[i] = '^';
155 context->show_option_requested = false;
156 context->abort_on_error = false;
157 context->show_column = false;
158 context->pedantic_errors = false;
159 context->permissive = false;
160 context->opt_permissive = 0;
161 context->fatal_errors = false;
162 context->dc_inhibit_warnings = false;
163 context->dc_warn_system_headers = false;
164 context->max_errors = 0;
165 context->internal_error = NULL;
166 diagnostic_starter (context) = default_diagnostic_starter;
167 context->start_span = default_diagnostic_start_span_fn;
168 diagnostic_finalizer (context) = default_diagnostic_finalizer;
169 context->option_enabled = NULL;
170 context->option_state = NULL;
171 context->option_name = NULL;
172 context->last_location = UNKNOWN_LOCATION;
173 context->last_module = 0;
174 context->x_data = NULL;
175 context->lock = 0;
176 context->inhibit_notes_p = false;
177 context->colorize_source_p = false;
178 context->show_ruler_p = false;
179 context->parseable_fixits_p = false;
180 context->edit_context_ptr = NULL;
181}
182
183/* Maybe initialize the color support. We require clients to do this
184 explicitly, since most clients don't want color. When called
185 without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */
186
187void
188diagnostic_color_init (diagnostic_context *context, int value /*= -1 */)
189{
190 /* value == -1 is the default value. */
191 if (value < 0)
192 {
193 /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to
194 -fdiagnostics-color=auto if GCC_COLORS is in the environment,
195 otherwise default to -fdiagnostics-color=never, for other
196 values default to that
197 -fdiagnostics-color={never,auto,always}. */
198 if (DIAGNOSTICS_COLOR_DEFAULT == -1)
199 {
200 if (!getenv ("GCC_COLORS"))
201 return;
202 value = DIAGNOSTICS_COLOR_AUTO;
203 }
204 else
205 value = DIAGNOSTICS_COLOR_DEFAULT;
206 }
207 pp_show_color (context->printer)
208 = colorize_init ((diagnostic_color_rule_t) value);
209}
210
211/* Do any cleaning up required after the last diagnostic is emitted. */
212
213void
214diagnostic_finish (diagnostic_context *context)
215{
216 /* Some of the errors may actually have been warnings. */
217 if (diagnostic_kind_count (context, DK_WERROR))
218 {
219 /* -Werror was given. */
220 if (context->warning_as_error_requested)
221 pp_verbatim (context->printer,
222 _("%s: all warnings being treated as errors"),
223 progname);
224 /* At least one -Werror= was given. */
225 else
226 pp_verbatim (context->printer,
227 _("%s: some warnings being treated as errors"),
228 progname);
229 pp_newline_and_flush (context->printer);
230 }
231
232 diagnostic_file_cache_fini ();
233
234 XDELETEVEC (context->classify_diagnostic);
235 context->classify_diagnostic = NULL;
236
237 /* diagnostic_initialize allocates context->printer using XNEW
238 and placement-new. */
239 context->printer->~pretty_printer ();
240 XDELETE (context->printer);
241 context->printer = NULL;
242
243 if (context->edit_context_ptr)
244 {
245 delete context->edit_context_ptr;
246 context->edit_context_ptr = NULL;
247 }
248}
249
250/* Initialize DIAGNOSTIC, where the message MSG has already been
251 translated. */
252void
253diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
254 va_list *args, rich_location *richloc,
255 diagnostic_t kind)
256{
257 gcc_assert (richloc);
258 diagnostic->message.err_no = errno;
259 diagnostic->message.args_ptr = args;
260 diagnostic->message.format_spec = msg;
261 diagnostic->message.m_richloc = richloc;
262 diagnostic->richloc = richloc;
263 diagnostic->kind = kind;
264 diagnostic->option_index = 0;
265}
266
267/* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
268 translated. */
269void
270diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
271 va_list *args, rich_location *richloc,
272 diagnostic_t kind)
273{
274 gcc_assert (richloc);
275 diagnostic_set_info_translated (diagnostic, _(gmsgid), args, richloc, kind);
276}
277
278static const char *const diagnostic_kind_color[] = {
279#define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
280#include "diagnostic.def"
281#undef DEFINE_DIAGNOSTIC_KIND
282 NULL
283};
284
285/* Get a color name for diagnostics of type KIND
286 Result could be NULL. */
287
288const char *
289diagnostic_get_color_for_kind (diagnostic_t kind)
290{
291 return diagnostic_kind_color[kind];
292}
293
294/* Return a formatted line and column ':%line:%column'. Elided if
295 zero. The result is a statically allocated buffer. */
296
297static const char *
298maybe_line_and_column (int line, int col)
299{
300 static char result[32];
301
302 if (line)
303 {
304 size_t l = snprintf (result, sizeof (result),
305 col ? ":%d:%d" : ":%d", line, col);
306 gcc_checking_assert (l < sizeof (result));
307 }
308 else
309 result[0] = 0;
310 return result;
311}
312
313/* Return a malloc'd string describing a location e.g. "foo.c:42:10".
314 The caller is responsible for freeing the memory. */
315
316static char *
317diagnostic_get_location_text (diagnostic_context *context,
318 expanded_location s)
319{
320 pretty_printer *pp = context->printer;
321 const char *locus_cs = colorize_start (pp_show_color (pp), "locus");
322 const char *locus_ce = colorize_stop (pp_show_color (pp));
323 const char *file = s.file ? s.file : progname;
324 int line = strcmp (file, N_("<built-in>")) ? s.line : 0;
325 int col = context->show_column ? s.column : 0;
326
327 const char *line_col = maybe_line_and_column (line, col);
328 return build_message_string ("%s%s%s:%s", locus_cs, file,
329 line_col, locus_ce);
330}
331
332/* Return a malloc'd string describing a location and the severity of the
333 diagnostic, e.g. "foo.c:42:10: error: ". The caller is responsible for
334 freeing the memory. */
335char *
336diagnostic_build_prefix (diagnostic_context *context,
337 const diagnostic_info *diagnostic)
338{
339 static const char *const diagnostic_kind_text[] = {
340#define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
341#include "diagnostic.def"
342#undef DEFINE_DIAGNOSTIC_KIND
343 "must-not-happen"
344 };
345 gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
346
347 const char *text = _(diagnostic_kind_text[diagnostic->kind]);
348 const char *text_cs = "", *text_ce = "";
349 pretty_printer *pp = context->printer;
350
351 if (diagnostic_kind_color[diagnostic->kind])
352 {
353 text_cs = colorize_start (pp_show_color (pp),
354 diagnostic_kind_color[diagnostic->kind]);
355 text_ce = colorize_stop (pp_show_color (pp));
356 }
357
358 expanded_location s = diagnostic_expand_location (diagnostic);
359 char *location_text = diagnostic_get_location_text (context, s);
360
361 char *result = build_message_string ("%s %s%s%s", location_text,
362 text_cs, text, text_ce);
363 free (location_text);
364 return result;
365}
366
367/* Functions at which to stop the backtrace print. It's not
368 particularly helpful to print the callers of these functions. */
369
370static const char * const bt_stop[] =
371{
372 "main",
373 "toplev::main",
374 "execute_one_pass",
375 "compile_file",
376};
377
378/* A callback function passed to the backtrace_full function. */
379
380static int
381bt_callback (void *data, uintptr_t pc, const char *filename, int lineno,
382 const char *function)
383{
384 int *pcount = (int *) data;
385
386 /* If we don't have any useful information, don't print
387 anything. */
388 if (filename == NULL && function == NULL)
389 return 0;
390
391 /* Skip functions in diagnostic.c. */
392 if (*pcount == 0
393 && filename != NULL
394 && strcmp (lbasename (filename), "diagnostic.c") == 0)
395 return 0;
396
397 /* Print up to 20 functions. We could make this a --param, but
398 since this is only for debugging just use a constant for now. */
399 if (*pcount >= 20)
400 {
401 /* Returning a non-zero value stops the backtrace. */
402 return 1;
403 }
404 ++*pcount;
405
406 char *alc = NULL;
407 if (function != NULL)
408 {
409 char *str = cplus_demangle_v3 (function,
410 (DMGL_VERBOSE | DMGL_ANSI
411 | DMGL_GNU_V3 | DMGL_PARAMS));
412 if (str != NULL)
413 {
414 alc = str;
415 function = str;
416 }
417
418 for (size_t i = 0; i < ARRAY_SIZE (bt_stop); ++i)
419 {
420 size_t len = strlen (bt_stop[i]);
421 if (strncmp (function, bt_stop[i], len) == 0
422 && (function[len] == '\0' || function[len] == '('))
423 {
424 if (alc != NULL)
425 free (alc);
426 /* Returning a non-zero value stops the backtrace. */
427 return 1;
428 }
429 }
430 }
431
432 fprintf (stderr, "0x%lx %s\n\t%s:%d\n",
433 (unsigned long) pc,
434 function == NULL ? "???" : function,
435 filename == NULL ? "???" : filename,
436 lineno);
437
438 if (alc != NULL)
439 free (alc);
440
441 return 0;
442}
443
444/* A callback function passed to the backtrace_full function. This is
445 called if backtrace_full has an error. */
446
447static void
448bt_err_callback (void *data ATTRIBUTE_UNUSED, const char *msg, int errnum)
449{
450 if (errnum < 0)
451 {
452 /* This means that no debug info was available. Just quietly
453 skip printing backtrace info. */
454 return;
455 }
456 fprintf (stderr, "%s%s%s\n", msg, errnum == 0 ? "" : ": ",
457 errnum == 0 ? "" : xstrerror (errnum));
458}
459
460/* Check if we've met the maximum error limit, and if so fatally exit
461 with a message. CONTEXT is the context to check, and FLUSH
462 indicates whether a diagnostic_finish call is needed. */
463
464void
465diagnostic_check_max_errors (diagnostic_context *context, bool flush)
466{
467 if (!context->max_errors)
468 return;
469
470 int count = (diagnostic_kind_count (context, DK_ERROR)
471 + diagnostic_kind_count (context, DK_SORRY)
472 + diagnostic_kind_count (context, DK_WERROR));
473
474 if (count >= context->max_errors)
475 {
476 fnotice (stderr,
477 "compilation terminated due to -fmax-errors=%u.\n",
478 context->max_errors);
479 if (flush)
480 diagnostic_finish (context);
481 exit (FATAL_EXIT_CODE);
482 }
483}
484
485/* Take any action which is expected to happen after the diagnostic
486 is written out. This function does not always return. */
487void
488diagnostic_action_after_output (diagnostic_context *context,
489 diagnostic_t diag_kind)
490{
491 switch (diag_kind)
492 {
493 case DK_DEBUG:
494 case DK_NOTE:
495 case DK_ANACHRONISM:
496 case DK_WARNING:
497 break;
498
499 case DK_ERROR:
500 case DK_SORRY:
501 if (context->abort_on_error)
502 real_abort ();
503 if (context->fatal_errors)
504 {
505 fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
506 diagnostic_finish (context);
507 exit (FATAL_EXIT_CODE);
508 }
509 break;
510
511 case DK_ICE:
512 case DK_ICE_NOBT:
513 {
514 struct backtrace_state *state = NULL;
515 if (diag_kind == DK_ICE)
516 state = backtrace_create_state (NULL, 0, bt_err_callback, NULL);
517 int count = 0;
518 if (state != NULL)
519 backtrace_full (state, 2, bt_callback, bt_err_callback,
520 (void *) &count);
521
522 if (context->abort_on_error)
523 real_abort ();
524
525 fnotice (stderr, "Please submit a full bug report,\n"
526 "with preprocessed source if appropriate.\n");
527 if (count > 0)
528 fnotice (stderr,
529 ("Please include the complete backtrace "
530 "with any bug report.\n"));
531 fnotice (stderr, "See %s for instructions.\n", bug_report_url);
532
533 exit (ICE_EXIT_CODE);
534 }
535
536 case DK_FATAL:
537 if (context->abort_on_error)
538 real_abort ();
539 diagnostic_finish (context);
540 fnotice (stderr, "compilation terminated.\n");
541 exit (FATAL_EXIT_CODE);
542
543 default:
544 gcc_unreachable ();
545 }
546}
547
548/* True if the last module or file in which a diagnostic was reported is
549 different from the current one. */
550
551static bool
552last_module_changed_p (diagnostic_context *context,
553 const line_map_ordinary *map)
554{
555 return context->last_module != map;
556}
557
558/* Remember the current module or file as being the last one in which we
559 report a diagnostic. */
560
561static void
562set_last_module (diagnostic_context *context, const line_map_ordinary *map)
563{
564 context->last_module = map;
565}
566
567void
568diagnostic_report_current_module (diagnostic_context *context, location_t where)
569{
570 const line_map_ordinary *map = NULL;
571
572 if (pp_needs_newline (context->printer))
573 {
574 pp_newline (context->printer);
575 pp_needs_newline (context->printer) = false;
576 }
577
578 if (where <= BUILTINS_LOCATION)
579 return;
580
581 linemap_resolve_location (line_table, where,
582 LRK_MACRO_DEFINITION_LOCATION,
583 &map);
584
585 if (map && last_module_changed_p (context, map))
586 {
587 set_last_module (context, map);
588 if (! MAIN_FILE_P (map))
589 {
590 map = INCLUDED_FROM (line_table, map);
591 const char *line_col
592 = maybe_line_and_column (LAST_SOURCE_LINE (map),
593 context->show_column
594 ? LAST_SOURCE_COLUMN (map) : 0);
595 pp_verbatim (context->printer,
596 "In file included from %r%s%s%R", "locus",
597 LINEMAP_FILE (map), line_col);
598 while (! MAIN_FILE_P (map))
599 {
600 map = INCLUDED_FROM (line_table, map);
601 line_col = maybe_line_and_column (LAST_SOURCE_LINE (map), 0);
602 pp_verbatim (context->printer,
603 ",\n from %r%s%s%R", "locus",
604 LINEMAP_FILE (map), line_col);
605 }
606 pp_verbatim (context->printer, ":");
607 pp_newline (context->printer);
608 }
609 }
610}
611
612void
613default_diagnostic_starter (diagnostic_context *context,
614 diagnostic_info *diagnostic)
615{
616 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
617 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
618 diagnostic));
619}
620
621void
622default_diagnostic_start_span_fn (diagnostic_context *context,
623 expanded_location exploc)
624{
625 pp_set_prefix (context->printer,
626 diagnostic_get_location_text (context, exploc));
627 pp_string (context->printer, "");
628 pp_newline (context->printer);
629}
630
631void
632default_diagnostic_finalizer (diagnostic_context *context,
633 diagnostic_info *diagnostic)
634{
635 diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind);
636 pp_destroy_prefix (context->printer);
637 pp_flush (context->printer);
638}
639
640/* Interface to specify diagnostic kind overrides. Returns the
641 previous setting, or DK_UNSPECIFIED if the parameters are out of
642 range. If OPTION_INDEX is zero, the new setting is for all the
643 diagnostics. */
644diagnostic_t
645diagnostic_classify_diagnostic (diagnostic_context *context,
646 int option_index,
647 diagnostic_t new_kind,
648 location_t where)
649{
650 diagnostic_t old_kind;
651
652 if (option_index < 0
653 || option_index >= context->n_opts
654 || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
655 return DK_UNSPECIFIED;
656
657 old_kind = context->classify_diagnostic[option_index];
658
659 /* Handle pragmas separately, since we need to keep track of *where*
660 the pragmas were. */
661 if (where != UNKNOWN_LOCATION)
662 {
663 int i;
664
665 /* Record the command-line status, so we can reset it back on DK_POP. */
666 if (old_kind == DK_UNSPECIFIED)
667 {
668 old_kind = !context->option_enabled (option_index,
669 context->option_state)
670 ? DK_IGNORED : (context->warning_as_error_requested
671 ? DK_ERROR : DK_WARNING);
672 context->classify_diagnostic[option_index] = old_kind;
673 }
674
675 for (i = context->n_classification_history - 1; i >= 0; i --)
676 if (context->classification_history[i].option == option_index)
677 {
678 old_kind = context->classification_history[i].kind;
679 break;
680 }
681
682 i = context->n_classification_history;
683 context->classification_history =
684 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
685 * sizeof (diagnostic_classification_change_t));
686 context->classification_history[i].location = where;
687 context->classification_history[i].option = option_index;
688 context->classification_history[i].kind = new_kind;
689 context->n_classification_history ++;
690 }
691 else
692 context->classify_diagnostic[option_index] = new_kind;
693
694 return old_kind;
695}
696
697/* Save all diagnostic classifications in a stack. */
698void
699diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
700{
701 context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
702 context->push_list[context->n_push ++] = context->n_classification_history;
703}
704
705/* Restore the topmost classification set off the stack. If the stack
706 is empty, revert to the state based on command line parameters. */
707void
708diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
709{
710 int jump_to;
711 int i;
712
713 if (context->n_push)
714 jump_to = context->push_list [-- context->n_push];
715 else
716 jump_to = 0;
717
718 i = context->n_classification_history;
719 context->classification_history =
720 (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
721 * sizeof (diagnostic_classification_change_t));
722 context->classification_history[i].location = where;
723 context->classification_history[i].option = jump_to;
724 context->classification_history[i].kind = DK_POP;
725 context->n_classification_history ++;
726}
727
728/* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the
729 escaping rules for -fdiagnostics-parseable-fixits. */
730
731static void
732print_escaped_string (pretty_printer *pp, const char *text)
733{
734 gcc_assert (pp);
735 gcc_assert (text);
736
737 pp_character (pp, '"');
738 for (const char *ch = text; *ch; ch++)
739 {
740 switch (*ch)
741 {
742 case '\\':
743 /* Escape backslash as two backslashes. */
744 pp_string (pp, "\\\\");
745 break;
746 case '\t':
747 /* Escape tab as "\t". */
748 pp_string (pp, "\\t");
749 break;
750 case '\n':
751 /* Escape newline as "\n". */
752 pp_string (pp, "\\n");
753 break;
754 case '"':
755 /* Escape doublequotes as \". */
756 pp_string (pp, "\\\"");
757 break;
758 default:
759 if (ISPRINT (*ch))
760 pp_character (pp, *ch);
761 else
762 /* Use octal for non-printable chars. */
763 {
764 unsigned char c = (*ch & 0xff);
765 pp_printf (pp, "\\%o%o%o", (c / 64), (c / 8) & 007, c & 007);
766 }
767 break;
768 }
769 }
770 pp_character (pp, '"');
771}
772
773/* Implementation of -fdiagnostics-parseable-fixits. Print a
774 machine-parseable version of all fixits in RICHLOC to PP. */
775
776static void
777print_parseable_fixits (pretty_printer *pp, rich_location *richloc)
778{
779 gcc_assert (pp);
780 gcc_assert (richloc);
781
782 for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++)
783 {
784 const fixit_hint *hint = richloc->get_fixit_hint (i);
785 source_location start_loc = hint->get_start_loc ();
786 expanded_location start_exploc = expand_location (start_loc);
787 pp_string (pp, "fix-it:");
788 print_escaped_string (pp, start_exploc.file);
789 /* For compatibility with clang, print as a half-open range. */
790 source_location next_loc = hint->get_next_loc ();
791 expanded_location next_exploc = expand_location (next_loc);
792 pp_printf (pp, ":{%i:%i-%i:%i}:",
793 start_exploc.line, start_exploc.column,
794 next_exploc.line, next_exploc.column);
795 print_escaped_string (pp, hint->get_string ());
796 pp_newline (pp);
797 }
798}
799
800/* Update the diag_class of DIAGNOSTIC based on its location
801 relative to any
802 #pragma GCC diagnostic
803 directives recorded within CONTEXT.
804
805 Return the new diag_class of DIAGNOSTIC if it was updated, or
806 DK_UNSPECIFIED otherwise. */
807
808static diagnostic_t
809update_effective_level_from_pragmas (diagnostic_context *context,
810 diagnostic_info *diagnostic)
811{
812 diagnostic_t diag_class = DK_UNSPECIFIED;
813
814 if (context->n_classification_history > 0)
815 {
816 location_t location = diagnostic_location (diagnostic);
817
818 /* FIXME: Stupid search. Optimize later. */
819 for (int i = context->n_classification_history - 1; i >= 0; i --)
820 {
821 if (linemap_location_before_p
822 (line_table,
823 context->classification_history[i].location,
824 location))
825 {
826 if (context->classification_history[i].kind == (int) DK_POP)
827 {
828 i = context->classification_history[i].option;
829 continue;
830 }
831 int option = context->classification_history[i].option;
832 /* The option 0 is for all the diagnostics. */
833 if (option == 0 || option == diagnostic->option_index)
834 {
835 diag_class = context->classification_history[i].kind;
836 if (diag_class != DK_UNSPECIFIED)
837 diagnostic->kind = diag_class;
838 break;
839 }
840 }
841 }
842 }
843
844 return diag_class;
845}
846
847/* Print any metadata about the option used to control DIAGNOSTIC to CONTEXT's
848 printer, e.g. " [-Werror=uninitialized]".
849 Subroutine of diagnostic_report_diagnostic. */
850
851static void
852print_option_information (diagnostic_context *context,
853 const diagnostic_info *diagnostic,
854 diagnostic_t orig_diag_kind)
855{
856 char *option_text;
857
858 option_text = context->option_name (context, diagnostic->option_index,
859 orig_diag_kind, diagnostic->kind);
860
861 if (option_text)
862 {
863 pretty_printer *pp = context->printer;
864 pp_string (pp, " [");
865 pp_string (pp, colorize_start (pp_show_color (pp),
866 diagnostic_kind_color[diagnostic->kind]));
867 pp_string (pp, option_text);
868 pp_string (pp, colorize_stop (pp_show_color (pp)));
869 pp_character (pp, ']');
870 free (option_text);
871 }
872}
873
874/* Report a diagnostic message (an error or a warning) as specified by
875 DC. This function is *the* subroutine in terms of which front-ends
876 should implement their specific diagnostic handling modules. The
877 front-end independent format specifiers are exactly those described
878 in the documentation of output_format.
879 Return true if a diagnostic was printed, false otherwise. */
880
881bool
882diagnostic_report_diagnostic (diagnostic_context *context,
883 diagnostic_info *diagnostic)
884{
885 location_t location = diagnostic_location (diagnostic);
886 diagnostic_t orig_diag_kind = diagnostic->kind;
887
888 /* Give preference to being able to inhibit warnings, before they
889 get reclassified to something else. */
890 if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
891 && !diagnostic_report_warnings_p (context, location))
892 return false;
893
894 if (diagnostic->kind == DK_PEDWARN)
895 {
896 diagnostic->kind = pedantic_warning_kind (context);
897 /* We do this to avoid giving the message for -pedantic-errors. */
898 orig_diag_kind = diagnostic->kind;
899 }
900
901 if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
902 return false;
903
904 if (context->lock > 0)
905 {
906 /* If we're reporting an ICE in the middle of some other error,
907 try to flush out the previous error, then let this one
908 through. Don't do this more than once. */
909 if ((diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
910 && context->lock == 1)
911 pp_newline_and_flush (context->printer);
912 else
913 error_recursion (context);
914 }
915
916 /* If the user requested that warnings be treated as errors, so be
917 it. Note that we do this before the next block so that
918 individual warnings can be overridden back to warnings with
919 -Wno-error=*. */
920 if (context->warning_as_error_requested
921 && diagnostic->kind == DK_WARNING)
922 diagnostic->kind = DK_ERROR;
923
924 if (diagnostic->option_index
925 && diagnostic->option_index != permissive_error_option (context))
926 {
927 /* This tests if the user provided the appropriate -Wfoo or
928 -Wno-foo option. */
929 if (! context->option_enabled (diagnostic->option_index,
930 context->option_state))
931 return false;
932
933 /* This tests for #pragma diagnostic changes. */
934 diagnostic_t diag_class
935 = update_effective_level_from_pragmas (context, diagnostic);
936
937 /* This tests if the user provided the appropriate -Werror=foo
938 option. */
939 if (diag_class == DK_UNSPECIFIED
940 && (context->classify_diagnostic[diagnostic->option_index]
941 != DK_UNSPECIFIED))
942 diagnostic->kind
943 = context->classify_diagnostic[diagnostic->option_index];
944
945 /* This allows for future extensions, like temporarily disabling
946 warnings for ranges of source code. */
947 if (diagnostic->kind == DK_IGNORED)
948 return false;
949 }
950
951 if (diagnostic->kind != DK_NOTE)
952 diagnostic_check_max_errors (context);
953
954 context->lock++;
955
956 if (diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
957 {
958 /* When not checking, ICEs are converted to fatal errors when an
959 error has already occurred. This is counteracted by
960 abort_on_error. */
961 if (!CHECKING_P
962 && (diagnostic_kind_count (context, DK_ERROR) > 0
963 || diagnostic_kind_count (context, DK_SORRY) > 0)
964 && !context->abort_on_error)
965 {
966 expanded_location s
967 = expand_location (diagnostic_location (diagnostic));
968 fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
969 s.file, s.line);
970 exit (ICE_EXIT_CODE);
971 }
972 if (context->internal_error)
973 (*context->internal_error) (context,
974 diagnostic->message.format_spec,
975 diagnostic->message.args_ptr);
976 }
977 if (diagnostic->kind == DK_ERROR && orig_diag_kind == DK_WARNING)
978 ++diagnostic_kind_count (context, DK_WERROR);
979 else
980 ++diagnostic_kind_count (context, diagnostic->kind);
981
982 diagnostic->message.x_data = &diagnostic->x_data;
983 diagnostic->x_data = NULL;
984 pp_format (context->printer, &diagnostic->message);
985 (*diagnostic_starter (context)) (context, diagnostic);
986 pp_output_formatted_text (context->printer);
987 if (context->show_option_requested)
988 print_option_information (context, diagnostic, orig_diag_kind);
989 (*diagnostic_finalizer (context)) (context, diagnostic);
990 if (context->parseable_fixits_p)
991 {
992 print_parseable_fixits (context->printer, diagnostic->richloc);
993 pp_flush (context->printer);
994 }
995 diagnostic_action_after_output (context, diagnostic->kind);
996 diagnostic->x_data = NULL;
997
998 if (context->edit_context_ptr)
999 if (diagnostic->richloc->fixits_can_be_auto_applied_p ())
1000 context->edit_context_ptr->add_fixits (diagnostic->richloc);
1001
1002 context->lock--;
1003
1004 return true;
1005}
1006
1007/* Given a partial pathname as input, return another pathname that
1008 shares no directory elements with the pathname of __FILE__. This
1009 is used by fancy_abort() to print `Internal compiler error in expr.c'
1010 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1011
1012const char *
1013trim_filename (const char *name)
1014{
1015 static const char this_file[] = __FILE__;
1016 const char *p = name, *q = this_file;
1017
1018 /* First skip any "../" in each filename. This allows us to give a proper
1019 reference to a file in a subdirectory. */
1020 while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
1021 p += 3;
1022
1023 while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
1024 q += 3;
1025
1026 /* Now skip any parts the two filenames have in common. */
1027 while (*p == *q && *p != 0 && *q != 0)
1028 p++, q++;
1029
1030 /* Now go backwards until the previous directory separator. */
1031 while (p > name && !IS_DIR_SEPARATOR (p[-1]))
1032 p--;
1033
1034 return p;
1035}
1036
1037/* Standard error reporting routines in increasing order of severity.
1038 All of these take arguments like printf. */
1039
1040/* Text to be emitted verbatim to the error message stream; this
1041 produces no prefix and disables line-wrapping. Use rarely. */
1042void
1043verbatim (const char *gmsgid, ...)
1044{
1045 text_info text;
1046 va_list ap;
1047
1048 va_start (ap, gmsgid);
1049 text.err_no = errno;
1050 text.args_ptr = &ap;
1051 text.format_spec = _(gmsgid);
1052 text.x_data = NULL;
1053 pp_format_verbatim (global_dc->printer, &text);
1054 pp_newline_and_flush (global_dc->printer);
1055 va_end (ap);
1056}
1057
1058/* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT. */
1059void
1060diagnostic_append_note (diagnostic_context *context,
1061 location_t location,
1062 const char * gmsgid, ...)
1063{
1064 diagnostic_info diagnostic;
1065 va_list ap;
1066 const char *saved_prefix;
1067 rich_location richloc (line_table, location);
1068
1069 va_start (ap, gmsgid);
1070 diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc, DK_NOTE);
1071 if (context->inhibit_notes_p)
1072 {
1073 va_end (ap);
1074 return;
1075 }
1076 saved_prefix = pp_get_prefix (context->printer);
1077 pp_set_prefix (context->printer,
1078 diagnostic_build_prefix (context, &diagnostic));
1079 pp_format (context->printer, &diagnostic.message);
1080 pp_output_formatted_text (context->printer);
1081 pp_destroy_prefix (context->printer);
1082 pp_set_prefix (context->printer, saved_prefix);
1083 diagnostic_show_locus (context, &richloc, DK_NOTE);
1084 va_end (ap);
1085}
1086
1087/* Implement emit_diagnostic, inform, warning, warning_at, pedwarn,
1088 permerror, error, error_at, error_at, sorry, fatal_error, internal_error,
1089 and internal_error_no_backtrace, as documented and defined below. */
1090static bool
1091diagnostic_impl (rich_location *richloc, int opt,
1092 const char *gmsgid,
1093 va_list *ap, diagnostic_t kind)
1094{
1095 diagnostic_info diagnostic;
1096 if (kind == DK_PERMERROR)
1097 {
1098 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc,
1099 permissive_error_kind (global_dc));
1100 diagnostic.option_index = permissive_error_option (global_dc);
1101 }
1102 else
1103 {
1104 diagnostic_set_info (&diagnostic, gmsgid, ap, richloc, kind);
1105 if (kind == DK_WARNING || kind == DK_PEDWARN)
1106 diagnostic.option_index = opt;
1107 }
1108 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1109}
1110
1111/* Implement inform_n, warning_n, and error_n, as documented and
1112 defined below. */
1113static bool
1114diagnostic_n_impl (rich_location *richloc, int opt, int n,
1115 const char *singular_gmsgid,
1116 const char *plural_gmsgid,
1117 va_list *ap, diagnostic_t kind)
1118{
1119 diagnostic_info diagnostic;
1120 diagnostic_set_info_translated (&diagnostic,
1121 ngettext (singular_gmsgid, plural_gmsgid, n),
1122 ap, richloc, kind);
1123 if (kind == DK_WARNING)
1124 diagnostic.option_index = opt;
1125 return diagnostic_report_diagnostic (global_dc, &diagnostic);
1126}
1127
1128/* Wrapper around diagnostic_impl taking a variable argument list. */
1129
1130bool
1131emit_diagnostic (diagnostic_t kind, location_t location, int opt,
1132 const char *gmsgid, ...)
1133{
1134 va_list ap;
1135 va_start (ap, gmsgid);
1136 rich_location richloc (line_table, location);
1137 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, kind);
1138 va_end (ap);
1139 return ret;
1140}
1141
1142/* Wrapper around diagnostic_impl taking a va_list parameter. */
1143
1144bool
1145emit_diagnostic_valist (diagnostic_t kind, location_t location, int opt,
1146 const char *gmsgid, va_list *ap)
1147{
1148 rich_location richloc (line_table, location);
1149 return diagnostic_impl (&richloc, opt, gmsgid, ap, kind);
1150}
1151
1152/* An informative note at LOCATION. Use this for additional details on an error
1153 message. */
1154void
1155inform (location_t location, const char *gmsgid, ...)
1156{
1157 va_list ap;
1158 va_start (ap, gmsgid);
1159 rich_location richloc (line_table, location);
1160 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_NOTE);
1161 va_end (ap);
1162}
1163
1164/* Same as "inform" above, but at RICHLOC. */
1165void
1166inform (rich_location *richloc, const char *gmsgid, ...)
1167{
1168 gcc_assert (richloc);
1169
1170 va_list ap;
1171 va_start (ap, gmsgid);
1172 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_NOTE);
1173 va_end (ap);
1174}
1175
1176/* An informative note at LOCATION. Use this for additional details on an
1177 error message. */
1178void
1179inform_n (location_t location, int n, const char *singular_gmsgid,
1180 const char *plural_gmsgid, ...)
1181{
1182 va_list ap;
1183 va_start (ap, plural_gmsgid);
1184 rich_location richloc (line_table, location);
1185 diagnostic_n_impl (&richloc, -1, n, singular_gmsgid, plural_gmsgid,
1186 &ap, DK_NOTE);
1187 va_end (ap);
1188}
1189
1190/* A warning at INPUT_LOCATION. Use this for code which is correct according
1191 to the relevant language specification but is likely to be buggy anyway.
1192 Returns true if the warning was printed, false if it was inhibited. */
1193bool
1194warning (int opt, const char *gmsgid, ...)
1195{
1196 va_list ap;
1197 va_start (ap, gmsgid);
1198 rich_location richloc (line_table, input_location);
1199 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1200 va_end (ap);
1201 return ret;
1202}
1203
1204/* A warning at LOCATION. Use this for code which is correct according to the
1205 relevant language specification but is likely to be buggy anyway.
1206 Returns true if the warning was printed, false if it was inhibited. */
1207
1208bool
1209warning_at (location_t location, int opt, const char *gmsgid, ...)
1210{
1211 va_list ap;
1212 va_start (ap, gmsgid);
1213 rich_location richloc (line_table, location);
1214 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_WARNING);
1215 va_end (ap);
1216 return ret;
1217}
1218
1219/* Same as "warning at" above, but using RICHLOC. */
1220
1221bool
1222warning_at (rich_location *richloc, int opt, const char *gmsgid, ...)
1223{
1224 gcc_assert (richloc);
1225
1226 va_list ap;
1227 va_start (ap, gmsgid);
1228 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_WARNING);
1229 va_end (ap);
1230 return ret;
1231}
1232
1233/* Same as warning_n plural variant below, but using RICHLOC. */
1234
1235bool
1236warning_n (rich_location *richloc, int opt, int n,
1237 const char *singular_gmsgid, const char *plural_gmsgid, ...)
1238{
1239 gcc_assert (richloc);
1240
1241 va_list ap;
1242 va_start (ap, plural_gmsgid);
1243 bool ret = diagnostic_n_impl (richloc, opt, n,
1244 singular_gmsgid, plural_gmsgid,
1245 &ap, DK_WARNING);
1246 va_end (ap);
1247 return ret;
1248}
1249
1250/* A warning at LOCATION. Use this for code which is correct according to the
1251 relevant language specification but is likely to be buggy anyway.
1252 Returns true if the warning was printed, false if it was inhibited. */
1253
1254bool
1255warning_n (location_t location, int opt, int n, const char *singular_gmsgid,
1256 const char *plural_gmsgid, ...)
1257{
1258 va_list ap;
1259 va_start (ap, plural_gmsgid);
1260 rich_location richloc (line_table, location);
1261 bool ret = diagnostic_n_impl (&richloc, opt, n,
1262 singular_gmsgid, plural_gmsgid,
1263 &ap, DK_WARNING);
1264 va_end (ap);
1265 return ret;
1266}
1267
1268/* A "pedantic" warning at LOCATION: issues a warning unless
1269 -pedantic-errors was given on the command line, in which case it
1270 issues an error. Use this for diagnostics required by the relevant
1271 language standard, if you have chosen not to make them errors.
1272
1273 Note that these diagnostics are issued independent of the setting
1274 of the -Wpedantic command-line switch. To get a warning enabled
1275 only with that switch, use either "if (pedantic) pedwarn
1276 (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)". To get a
1277 pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1278
1279 Returns true if the warning was printed, false if it was inhibited. */
1280
1281bool
1282pedwarn (location_t location, int opt, const char *gmsgid, ...)
1283{
1284 va_list ap;
1285 va_start (ap, gmsgid);
1286 rich_location richloc (line_table, location);
1287 bool ret = diagnostic_impl (&richloc, opt, gmsgid, &ap, DK_PEDWARN);
1288 va_end (ap);
1289 return ret;
1290}
1291
1292/* Same as pedwarn above, but using RICHLOC. */
1293
1294bool
1295pedwarn (rich_location *richloc, int opt, const char *gmsgid, ...)
1296{
1297 gcc_assert (richloc);
1298
1299 va_list ap;
1300 va_start (ap, gmsgid);
1301 bool ret = diagnostic_impl (richloc, opt, gmsgid, &ap, DK_PEDWARN);
1302 va_end (ap);
1303 return ret;
1304}
1305
1306/* A "permissive" error at LOCATION: issues an error unless
1307 -fpermissive was given on the command line, in which case it issues
1308 a warning. Use this for things that really should be errors but we
1309 want to support legacy code.
1310
1311 Returns true if the warning was printed, false if it was inhibited. */
1312
1313bool
1314permerror (location_t location, const char *gmsgid, ...)
1315{
1316 va_list ap;
1317 va_start (ap, gmsgid);
1318 rich_location richloc (line_table, location);
1319 bool ret = diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_PERMERROR);
1320 va_end (ap);
1321 return ret;
1322}
1323
1324/* Same as "permerror" above, but at RICHLOC. */
1325
1326bool
1327permerror (rich_location *richloc, const char *gmsgid, ...)
1328{
1329 gcc_assert (richloc);
1330
1331 va_list ap;
1332 va_start (ap, gmsgid);
1333 bool ret = diagnostic_impl (richloc, -1, gmsgid, &ap, DK_PERMERROR);
1334 va_end (ap);
1335 return ret;
1336}
1337
1338/* A hard error: the code is definitely ill-formed, and an object file
1339 will not be produced. */
1340void
1341error (const char *gmsgid, ...)
1342{
1343 va_list ap;
1344 va_start (ap, gmsgid);
1345 rich_location richloc (line_table, input_location);
1346 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1347 va_end (ap);
1348}
1349
1350/* A hard error: the code is definitely ill-formed, and an object file
1351 will not be produced. */
1352void
1353error_n (location_t location, int n, const char *singular_gmsgid,
1354 const char *plural_gmsgid, ...)
1355{
1356 va_list ap;
1357 va_start (ap, plural_gmsgid);
1358 rich_location richloc (line_table, location);
1359 diagnostic_n_impl (&richloc, -1, n, singular_gmsgid, plural_gmsgid,
1360 &ap, DK_ERROR);
1361 va_end (ap);
1362}
1363
1364/* Same as above, but use location LOC instead of input_location. */
1365void
1366error_at (location_t loc, const char *gmsgid, ...)
1367{
1368 va_list ap;
1369 va_start (ap, gmsgid);
1370 rich_location richloc (line_table, loc);
1371 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ERROR);
1372 va_end (ap);
1373}
1374
1375/* Same as above, but use RICH_LOC. */
1376
1377void
1378error_at (rich_location *richloc, const char *gmsgid, ...)
1379{
1380 gcc_assert (richloc);
1381
1382 va_list ap;
1383 va_start (ap, gmsgid);
1384 diagnostic_impl (richloc, -1, gmsgid, &ap, DK_ERROR);
1385 va_end (ap);
1386}
1387
1388/* "Sorry, not implemented." Use for a language feature which is
1389 required by the relevant specification but not implemented by GCC.
1390 An object file will not be produced. */
1391void
1392sorry (const char *gmsgid, ...)
1393{
1394 va_list ap;
1395 va_start (ap, gmsgid);
1396 rich_location richloc (line_table, input_location);
1397 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_SORRY);
1398 va_end (ap);
1399}
1400
1401/* Return true if an error or a "sorry" has been seen. Various
1402 processing is disabled after errors. */
1403bool
1404seen_error (void)
1405{
1406 return errorcount || sorrycount;
1407}
1408
1409/* An error which is severe enough that we make no attempt to
1410 continue. Do not use this for internal consistency checks; that's
1411 internal_error. Use of this function should be rare. */
1412void
1413fatal_error (location_t loc, const char *gmsgid, ...)
1414{
1415 va_list ap;
1416 va_start (ap, gmsgid);
1417 rich_location richloc (line_table, loc);
1418 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_FATAL);
1419 va_end (ap);
1420
1421 gcc_unreachable ();
1422}
1423
1424/* An internal consistency check has failed. We make no attempt to
1425 continue. Note that unless there is debugging value to be had from
1426 a more specific message, or some other good reason, you should use
1427 abort () instead of calling this function directly. */
1428void
1429internal_error (const char *gmsgid, ...)
1430{
1431 va_list ap;
1432 va_start (ap, gmsgid);
1433 rich_location richloc (line_table, input_location);
1434 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE);
1435 va_end (ap);
1436
1437 gcc_unreachable ();
1438}
1439
1440/* Like internal_error, but no backtrace will be printed. Used when
1441 the internal error does not happen at the current location, but happened
1442 somewhere else. */
1443void
1444internal_error_no_backtrace (const char *gmsgid, ...)
1445{
1446 va_list ap;
1447 va_start (ap, gmsgid);
1448 rich_location richloc (line_table, input_location);
1449 diagnostic_impl (&richloc, -1, gmsgid, &ap, DK_ICE_NOBT);
1450 va_end (ap);
1451
1452 gcc_unreachable ();
1453}
1454
1455/* Special case error functions. Most are implemented in terms of the
1456 above, or should be. */
1457
1458/* Print a diagnostic MSGID on FILE. This is just fprintf, except it
1459 runs its second argument through gettext. */
1460void
1461fnotice (FILE *file, const char *cmsgid, ...)
1462{
1463 va_list ap;
1464
1465 va_start (ap, cmsgid);
1466 vfprintf (file, _(cmsgid), ap);
1467 va_end (ap);
1468}
1469
1470/* Inform the user that an error occurred while trying to report some
1471 other error. This indicates catastrophic internal inconsistencies,
1472 so give up now. But do try to flush out the previous error.
1473 This mustn't use internal_error, that will cause infinite recursion. */
1474
1475static void
1476error_recursion (diagnostic_context *context)
1477{
1478 if (context->lock < 3)
1479 pp_newline_and_flush (context->printer);
1480
1481 fnotice (stderr,
1482 "Internal compiler error: Error reporting routines re-entered.\n");
1483
1484 /* Call diagnostic_action_after_output to get the "please submit a bug
1485 report" message. */
1486 diagnostic_action_after_output (context, DK_ICE);
1487
1488 /* Do not use gcc_unreachable here; that goes through internal_error
1489 and therefore would cause infinite recursion. */
1490 real_abort ();
1491}
1492
1493/* Report an internal compiler error in a friendly manner. This is
1494 the function that gets called upon use of abort() in the source
1495 code generally, thanks to a special macro. */
1496
1497void
1498fancy_abort (const char *file, int line, const char *function)
1499{
1500 internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
1501}
1502
1503/* Really call the system 'abort'. This has to go right at the end of
1504 this file, so that there are no functions after it that call abort
1505 and get the system abort instead of our macro. */
1506#undef abort
1507static void
1508real_abort (void)
1509{
1510 abort ();
1511}
1512
1513#if CHECKING_P
1514
1515namespace selftest {
1516
1517/* Helper function for test_print_escaped_string. */
1518
1519static void
1520assert_print_escaped_string (const location &loc, const char *expected_output,
1521 const char *input)
1522{
1523 pretty_printer pp;
1524 print_escaped_string (&pp, input);
1525 ASSERT_STREQ_AT (loc, expected_output, pp_formatted_text (&pp));
1526}
1527
1528#define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \
1529 assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT)
1530
1531/* Tests of print_escaped_string. */
1532
1533static void
1534test_print_escaped_string ()
1535{
1536 /* Empty string. */
1537 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", "");
1538
1539 /* Non-empty string. */
1540 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world");
1541
1542 /* Various things that need to be escaped: */
1543 /* Backslash. */
1544 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"",
1545 "before\\after");
1546 /* Tab. */
1547 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"",
1548 "before\tafter");
1549 /* Newline. */
1550 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"",
1551 "before\nafter");
1552 /* Double quote. */
1553 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"",
1554 "before\"after");
1555
1556 /* Non-printable characters: BEL: '\a': 0x07 */
1557 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"",
1558 "before\aafter");
1559 /* Non-printable characters: vertical tab: '\v': 0x0b */
1560 ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"",
1561 "before\vafter");
1562}
1563
1564/* Tests of print_parseable_fixits. */
1565
1566/* Verify that print_parseable_fixits emits the empty string if there
1567 are no fixits. */
1568
1569static void
1570test_print_parseable_fixits_none ()
1571{
1572 pretty_printer pp;
1573 rich_location richloc (line_table, UNKNOWN_LOCATION);
1574
1575 print_parseable_fixits (&pp, &richloc);
1576 ASSERT_STREQ ("", pp_formatted_text (&pp));
1577}
1578
1579/* Verify that print_parseable_fixits does the right thing if there
1580 is an insertion fixit hint. */
1581
1582static void
1583test_print_parseable_fixits_insert ()
1584{
1585 pretty_printer pp;
1586 rich_location richloc (line_table, UNKNOWN_LOCATION);
1587
1588 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1589 linemap_line_start (line_table, 5, 100);
1590 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1591 location_t where = linemap_position_for_column (line_table, 10);
1592 richloc.add_fixit_insert_before (where, "added content");
1593
1594 print_parseable_fixits (&pp, &richloc);
1595 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n",
1596 pp_formatted_text (&pp));
1597}
1598
1599/* Verify that print_parseable_fixits does the right thing if there
1600 is an removal fixit hint. */
1601
1602static void
1603test_print_parseable_fixits_remove ()
1604{
1605 pretty_printer pp;
1606 rich_location richloc (line_table, UNKNOWN_LOCATION);
1607
1608 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1609 linemap_line_start (line_table, 5, 100);
1610 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1611 source_range where;
1612 where.m_start = linemap_position_for_column (line_table, 10);
1613 where.m_finish = linemap_position_for_column (line_table, 20);
1614 richloc.add_fixit_remove (where);
1615
1616 print_parseable_fixits (&pp, &richloc);
1617 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n",
1618 pp_formatted_text (&pp));
1619}
1620
1621/* Verify that print_parseable_fixits does the right thing if there
1622 is an replacement fixit hint. */
1623
1624static void
1625test_print_parseable_fixits_replace ()
1626{
1627 pretty_printer pp;
1628 rich_location richloc (line_table, UNKNOWN_LOCATION);
1629
1630 linemap_add (line_table, LC_ENTER, false, "test.c", 0);
1631 linemap_line_start (line_table, 5, 100);
1632 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
1633 source_range where;
1634 where.m_start = linemap_position_for_column (line_table, 10);
1635 where.m_finish = linemap_position_for_column (line_table, 20);
1636 richloc.add_fixit_replace (where, "replacement");
1637
1638 print_parseable_fixits (&pp, &richloc);
1639 ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n",
1640 pp_formatted_text (&pp));
1641}
1642
1643/* Verify that
1644 diagnostic_get_location_text (..., SHOW_COLUMN)
1645 generates EXPECTED_LOC_TEXT, given FILENAME, LINE, COLUMN, with
1646 colorization disabled. */
1647
1648static void
1649assert_location_text (const char *expected_loc_text,
1650 const char *filename, int line, int column,
1651 bool show_column)
1652{
1653 test_diagnostic_context dc;
1654 dc.show_column = show_column;
1655
1656 expanded_location xloc;
1657 xloc.file = filename;
1658 xloc.line = line;
1659 xloc.column = column;
1660 xloc.data = NULL;
1661 xloc.sysp = false;
1662
1663 char *actual_loc_text = diagnostic_get_location_text (&dc, xloc);
1664 ASSERT_STREQ (expected_loc_text, actual_loc_text);
1665 free (actual_loc_text);
1666}
1667
1668/* Verify that diagnostic_get_location_text works as expected. */
1669
1670static void
1671test_diagnostic_get_location_text ()
1672{
1673 const char *old_progname = progname;
1674 progname = "PROGNAME";
1675 assert_location_text ("PROGNAME:", NULL, 0, 0, true);
1676 assert_location_text ("<built-in>:", "<built-in>", 42, 10, true);
1677 assert_location_text ("foo.c:42:10:", "foo.c", 42, 10, true);
1678 assert_location_text ("foo.c:42:", "foo.c", 42, 0, true);
1679 assert_location_text ("foo.c:", "foo.c", 0, 10, true);
1680 assert_location_text ("foo.c:42:", "foo.c", 42, 10, false);
1681 assert_location_text ("foo.c:", "foo.c", 0, 10, false);
1682
1683 maybe_line_and_column (INT_MAX, INT_MAX);
1684 maybe_line_and_column (INT_MIN, INT_MIN);
1685
1686 progname = old_progname;
1687}
1688
1689/* Run all of the selftests within this file. */
1690
1691void
1692diagnostic_c_tests ()
1693{
1694 test_print_escaped_string ();
1695 test_print_parseable_fixits_none ();
1696 test_print_parseable_fixits_insert ();
1697 test_print_parseable_fixits_remove ();
1698 test_print_parseable_fixits_replace ();
1699 test_diagnostic_get_location_text ();
1700}
1701
1702} // namespace selftest
1703
1704#endif /* #if CHECKING_P */
1705