1 /* Language-independent diagnostic subroutines for the GNU C compiler
2 Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file implements the language independent aspect of diagnostic
27 #undef FLOAT /* This is for hpux. They should change hpux. */
28 #undef FFS /* Some systems define this in param.h. */
36 #include "insn-attr.h"
37 #include "insn-codes.h"
38 #include "insn-config.h"
41 #include "diagnostic.h"
43 #define obstack_chunk_alloc xmalloc
44 #define obstack_chunk_free free
46 #define output_formatted_integer(BUFFER, FORMAT, INTEGER) \
48 sprintf (digit_buffer, FORMAT, INTEGER); \
49 output_add_string (BUFFER, digit_buffer); \
52 #define output_text_length(BUFFER) (BUFFER)->line_length
53 #define is_starting_newline(BUFFER) (output_text_length (BUFFER) == 0)
54 #define output_prefix(BUFFER) (BUFFER)->state.prefix
55 #define line_wrap_cutoff(BUFFER) (BUFFER)->state.maximum_length
56 #define ideal_line_wrap_cutoff(BUFFER) (BUFFER)->state.ideal_maximum_length
57 #define prefix_was_emitted_for(BUFFER) (BUFFER)->state.emitted_prefix_p
58 #define prefixing_policy(BUFFER) (BUFFER)->state.prefixing_rule
59 #define output_buffer_ptr_to_format_args(BUFFER) (BUFFER)->state.format_args
61 #define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
62 #define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
65 static void finish_diagnostic PARAMS ((void));
66 static void output_do_verbatim PARAMS ((output_buffer *,
67 const char *, va_list *));
68 static void output_to_stream PARAMS ((output_buffer *, FILE *));
69 static void output_format PARAMS ((output_buffer *));
70 static void output_indent PARAMS ((output_buffer *));
72 static char *vbuild_message_string PARAMS ((const char *, va_list))
73 ATTRIBUTE_PRINTF (1, 0);
74 static char *build_message_string PARAMS ((const char *, ...))
76 static void output_do_printf PARAMS ((output_buffer *, const char *))
77 ATTRIBUTE_PRINTF (2, 0);
78 static void format_with_decl PARAMS ((output_buffer *, tree));
79 static void file_and_line_for_asm PARAMS ((rtx, const char **, int *));
80 static void diagnostic_for_asm PARAMS ((rtx, const char *, va_list *, int));
81 static void diagnostic_for_decl PARAMS ((tree, const char *, va_list *, int));
82 static void vnotice PARAMS ((FILE *, const char *, va_list))
83 ATTRIBUTE_PRINTF (2, 0);
84 static void set_real_maximum_length PARAMS ((output_buffer *));
86 static void output_unsigned_decimal PARAMS ((output_buffer *, unsigned int));
87 static void output_long_decimal PARAMS ((output_buffer *, long int));
88 static void output_long_unsigned_decimal PARAMS ((output_buffer *,
90 static void output_octal PARAMS ((output_buffer *, unsigned int));
91 static void output_long_octal PARAMS ((output_buffer *, unsigned long int));
92 static void output_hexadecimal PARAMS ((output_buffer *, unsigned int));
93 static void output_long_hexadecimal PARAMS ((output_buffer *,
95 static void output_append_r PARAMS ((output_buffer *, const char *, int));
96 static void wrap_text PARAMS ((output_buffer *, const char *, const char *));
97 static void maybe_wrap_text PARAMS ((output_buffer *, const char *,
99 static void clear_diagnostic_info PARAMS ((output_buffer *));
101 static void default_diagnostic_starter PARAMS ((output_buffer *,
102 diagnostic_context *));
103 static void default_diagnostic_finalizer PARAMS ((output_buffer *,
104 diagnostic_context *));
106 static void error_recursion PARAMS ((void)) ATTRIBUTE_NORETURN;
107 static const char *trim_filename PARAMS ((const char *));
109 extern int rtl_dump_and_exit;
110 extern int inhibit_warnings;
111 extern int warnings_are_errors;
112 extern int warningcount;
113 extern int errorcount;
115 /* Front-end specific tree formatter, if non-NULL. */
116 printer_fn lang_printer = NULL;
118 /* This must be large enough to hold any printed integer or
119 floating-point value. */
120 static char digit_buffer[128];
122 /* An output_buffer surrogate for stderr. */
123 static output_buffer global_output_buffer;
124 output_buffer *diagnostic_buffer = &global_output_buffer;
126 /* Function of last error message;
127 more generally, function such that if next error message is in it
128 then we don't have to mention the function name. */
129 static tree last_error_function = NULL;
131 /* Used to detect when input_file_stack has changed since last described. */
132 static int last_error_tick;
134 /* Called by report_error_function to print out function name.
135 Default may be overridden by language front-ends. */
137 void (*print_error_function) PARAMS ((const char *)) =
138 default_print_error_function;
140 /* Hooks for language specific diagnostic messages pager and finalizer. */
141 diagnostic_starter_fn lang_diagnostic_starter;
142 diagnostic_finalizer_fn lang_diagnostic_finalizer;
144 /* Maximum characters per line in automatic line wrapping mode.
145 Zero means don't wrap lines. */
147 int diagnostic_message_length_per_line;
149 /* Used to control every diagnostic message formatting. Front-ends should
150 call set_message_prefixing_rule to set up their policies. */
151 static int current_prefixing_rule;
153 /* Prevent recursion into the error handler. */
154 static int diagnostic_lock;
157 /* Return truthvalue if current input file is different from the most recent
158 file involved in a diagnostic message. */
161 error_module_changed ()
163 return last_error_tick != input_file_stack_tick;
166 /* Remember current file as being the most recent file involved in a
167 diagnostic message. */
170 record_last_error_module ()
172 last_error_tick = input_file_stack_tick;
175 /* Same as error_module_changed, but for function. */
178 error_function_changed ()
180 return last_error_function != current_function_decl;
183 /* Same as record_last_error_module, but for function. */
186 record_last_error_function ()
188 last_error_function = current_function_decl;
191 /* Initialize the diagnostic message outputting machinery. */
194 initialize_diagnostics ()
196 /* By default, we don't line-wrap messages. */
197 diagnostic_message_length_per_line = 0;
198 set_message_prefixing_rule (DIAGNOSTICS_SHOW_PREFIX_ONCE);
200 /* Proceed to actual initialization. */
201 default_initialize_buffer (diagnostic_buffer);
203 lang_diagnostic_starter = default_diagnostic_starter;
204 lang_diagnostic_finalizer = default_diagnostic_finalizer;
208 set_message_prefixing_rule (rule)
211 current_prefixing_rule = rule;
214 /* Returns true if BUFFER is in line-wrappind mode. */
217 output_is_line_wrapping (buffer)
218 output_buffer *buffer;
220 return ideal_line_wrap_cutoff (buffer) > 0;
223 /* Return BUFFER's prefix. */
226 output_get_prefix (buffer)
227 const output_buffer *buffer;
229 return output_prefix (buffer);
232 /* Subroutine of output_set_maximum_length. Set up BUFFER's
233 internal maximum characters per line. */
236 set_real_maximum_length (buffer)
237 output_buffer *buffer;
239 /* If we're told not to wrap lines then do the obvious thing. In case
240 we'll emit prefix only once per diagnostic message, it is appropriate
241 not to increase unncessarily the line-length cut-off. */
242 if (! output_is_line_wrapping (buffer)
243 || prefixing_policy (buffer) == DIAGNOSTICS_SHOW_PREFIX_ONCE
244 || prefixing_policy (buffer) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
245 line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer);
249 output_prefix (buffer) ? strlen (output_prefix (buffer)) : 0;
250 /* If the prefix is ridiculously too long, output at least
252 if (ideal_line_wrap_cutoff (buffer) - prefix_length < 32)
253 line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer) + 32;
255 line_wrap_cutoff (buffer) = ideal_line_wrap_cutoff (buffer);
259 /* Sets the number of maximum characters per line BUFFER can output
260 in line-wrapping mode. A LENGTH value 0 suppresses line-wrapping. */
263 output_set_maximum_length (buffer, length)
264 output_buffer *buffer;
267 ideal_line_wrap_cutoff (buffer) = length;
268 set_real_maximum_length (buffer);
271 /* Sets BUFFER's PREFIX. */
274 output_set_prefix (buffer, prefix)
275 output_buffer *buffer;
278 output_prefix (buffer) = prefix;
279 set_real_maximum_length (buffer);
280 prefix_was_emitted_for (buffer) = 0;
281 output_indentation (buffer) = 0;
284 /* Return a pointer to the last character emitted in the output
285 BUFFER area. A NULL pointer means no character available. */
287 output_last_position (buffer)
288 const output_buffer *buffer;
290 const char *p = NULL;
292 if (obstack_base (&buffer->obstack) != obstack_next_free (&buffer->obstack))
293 p = ((const char *) obstack_next_free (&buffer->obstack)) - 1;
297 /* Free BUFFER's prefix, a previously malloc'd string. */
300 output_destroy_prefix (buffer)
301 output_buffer *buffer;
303 if (output_prefix (buffer) != NULL)
305 free ((char *) output_prefix (buffer));
306 output_prefix (buffer) = NULL;
310 /* Zero out any text output so far in BUFFER. */
313 output_clear_message_text (buffer)
314 output_buffer *buffer;
316 obstack_free (&buffer->obstack, obstack_base (&buffer->obstack));
317 output_text_length (buffer) = 0;
320 /* Zero out any diagnostic data used so far by BUFFER. */
323 clear_diagnostic_info (buffer)
324 output_buffer *buffer;
326 output_buffer_text_cursor (buffer) = NULL;
327 output_buffer_ptr_to_format_args (buffer) = NULL;
328 prefix_was_emitted_for (buffer) = 0;
329 output_indentation (buffer) = 0;
332 /* Construct an output BUFFER with PREFIX and of MAXIMUM_LENGTH
333 characters per line. */
336 init_output_buffer (buffer, prefix, maximum_length)
337 output_buffer *buffer;
341 memset (buffer, 0, sizeof (output_buffer));
342 obstack_init (&buffer->obstack);
343 ideal_line_wrap_cutoff (buffer) = maximum_length;
344 prefixing_policy (buffer) = current_prefixing_rule;
345 output_set_prefix (buffer, prefix);
346 output_text_length (buffer) = 0;
347 clear_diagnostic_info (buffer);
350 /* Initialize BUFFER with a NULL prefix and current diagnostic message
354 default_initialize_buffer (buffer)
355 output_buffer *buffer;
357 init_output_buffer (buffer, NULL, diagnostic_message_length_per_line);
360 /* Recompute diagnostic_buffer's attributes to reflect any change
361 in diagnostic formatting global options. */
364 reshape_diagnostic_buffer ()
366 ideal_line_wrap_cutoff (diagnostic_buffer) =
367 diagnostic_message_length_per_line;
368 prefixing_policy (diagnostic_buffer) = current_prefixing_rule;
369 set_real_maximum_length (diagnostic_buffer);
372 /* Reinitialize BUFFER. */
375 output_clear (buffer)
376 output_buffer *buffer;
378 output_clear_message_text (buffer);
379 clear_diagnostic_info (buffer);
382 /* Finishes constructing a NULL-terminated character string representing
383 the BUFFERed message. */
386 output_finalize_message (buffer)
387 output_buffer *buffer;
389 obstack_1grow (&buffer->obstack, '\0');
390 return output_message_text (buffer);
394 flush_diagnostic_buffer ()
396 output_to_stream (diagnostic_buffer, stderr);
400 /* Return the amount of characters BUFFER can accept to
404 output_space_left (buffer)
405 const output_buffer *buffer;
407 return line_wrap_cutoff (buffer) - output_text_length (buffer);
410 /* Write out BUFFER's prefix. */
413 output_emit_prefix (buffer)
414 output_buffer *buffer;
416 if (output_prefix (buffer) != NULL)
418 switch (prefixing_policy (buffer))
421 case DIAGNOSTICS_SHOW_PREFIX_NEVER:
424 case DIAGNOSTICS_SHOW_PREFIX_ONCE:
425 if (prefix_was_emitted_for (buffer))
427 output_indent (buffer);
430 output_indentation (buffer) += 3;
433 case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
435 int prefix_length = strlen (output_prefix (buffer));
436 output_append_r (buffer, output_prefix (buffer), prefix_length);
437 prefix_was_emitted_for (buffer) = 1;
444 /* Have BUFFER start a new line. */
447 output_add_newline (buffer)
448 output_buffer *buffer;
450 obstack_1grow (&buffer->obstack, '\n');
451 output_text_length (buffer) = 0;
454 /* Appends a character to BUFFER. */
457 output_add_character (buffer, c)
458 output_buffer *buffer;
461 if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
462 output_add_newline (buffer);
463 obstack_1grow (&buffer->obstack, c);
464 ++output_text_length (buffer);
467 /* Adds a space to BUFFER. */
470 output_add_space (buffer)
471 output_buffer *buffer;
473 if (output_is_line_wrapping (buffer) && output_space_left (buffer) <= 0)
475 output_add_newline (buffer);
478 obstack_1grow (&buffer->obstack, ' ');
479 ++output_text_length (buffer);
482 /* These functions format an INTEGER into BUFFER as suggested by their
486 output_decimal (buffer, i)
487 output_buffer *buffer;
490 output_formatted_integer (buffer, "%d", i);
494 output_long_decimal (buffer, i)
495 output_buffer *buffer;
498 output_formatted_integer (buffer, "%ld", i);
502 output_unsigned_decimal (buffer, i)
503 output_buffer *buffer;
506 output_formatted_integer (buffer, "%u", i);
510 output_long_unsigned_decimal (buffer, i)
511 output_buffer *buffer;
514 output_formatted_integer (buffer, "%lu", i);
518 output_octal (buffer, i)
519 output_buffer *buffer;
522 output_formatted_integer (buffer, "%o", i);
526 output_long_octal (buffer, i)
527 output_buffer *buffer;
530 output_formatted_integer (buffer, "%lo", i);
534 output_hexadecimal (buffer, i)
535 output_buffer *buffer;
538 output_formatted_integer (buffer, "%x", i);
542 output_long_hexadecimal (buffer, i)
543 output_buffer *buffer;
546 output_formatted_integer (buffer, "%lx", i);
549 /* Append to BUFFER a string specified by its STARTING character
553 output_append_r (buffer, start, length)
554 output_buffer *buffer;
558 obstack_grow (&buffer->obstack, start, length);
559 output_text_length (buffer) += length;
562 /* Append a string deliminated by START and END to BUFFER. No wrapping is
563 done. However, if beginning a new line then emit output_prefix (BUFFER)
564 and skip any leading whitespace if appropriate. The caller must ensure
565 that it is safe to do so. */
568 output_append (buffer, start, end)
569 output_buffer *buffer;
573 /* Emit prefix and skip whitespace if we're starting a new line. */
574 if (is_starting_newline (buffer))
576 output_emit_prefix (buffer);
577 if (output_is_line_wrapping (buffer))
578 while (start != end && *start == ' ')
581 output_append_r (buffer, start, end - start);
585 output_indent (buffer)
586 output_buffer *buffer;
588 int n = output_indentation (buffer);
591 for (i = 0; i < n; ++i)
592 output_add_character (buffer, ' ');
595 /* Wrap a text delimited by START and END into BUFFER. */
598 wrap_text (buffer, start, end)
599 output_buffer *buffer;
603 int is_wrapping = output_is_line_wrapping (buffer);
607 /* Dump anything bodered by whitespaces. */
609 const char *p = start;
610 while (p != end && *p != ' ' && *p != '\n')
612 if (is_wrapping && p - start >= output_space_left (buffer))
613 output_add_newline (buffer);
614 output_append (buffer, start, p);
618 if (start != end && *start == ' ')
620 output_add_space (buffer);
623 if (start != end && *start == '\n')
625 output_add_newline (buffer);
631 /* Same as wrap_text but wrap text only when in line-wrapping mode. */
634 maybe_wrap_text (buffer, start, end)
635 output_buffer *buffer;
639 if (output_is_line_wrapping (buffer))
640 wrap_text (buffer, start, end);
642 output_append (buffer, start, end);
646 /* Append a STRING to BUFFER; the STRING might be line-wrapped if in
650 output_add_string (buffer, str)
651 output_buffer *buffer;
654 maybe_wrap_text (buffer, str, str + (str ? strlen (str) : 0));
657 /* Flush the content of BUFFER onto FILE and reinitialize BUFFER. */
660 output_to_stream (buffer, file)
661 output_buffer *buffer;
664 const char *text = output_finalize_message (buffer);
666 output_clear_message_text (buffer);
669 /* Format a message pointed to by output_buffer_text_cursor (BUFFER) using
670 output_buffer_format_args (BUFFER) as appropriate. The following format
671 specifiers are recognized as being language independent:
672 %d, %i: (signed) integer in base ten.
673 %u: unsigned integer in base ten.
674 %o: unsigned integer in base eight.
675 %x: unsigned integer in base sixteen.
676 %ld, %li, %lo, %lu, %lx: long versions of the above.
680 %*.s: a substring the length of which is specified by an integer. */
683 output_format (buffer)
684 output_buffer *buffer;
686 for (; *output_buffer_text_cursor (buffer);
687 ++output_buffer_text_cursor (buffer))
689 int long_integer = 0;
693 const char *p = output_buffer_text_cursor (buffer);
694 while (*p && *p != '%')
696 wrap_text (buffer, output_buffer_text_cursor (buffer), p);
697 output_buffer_text_cursor (buffer) = p;
700 if (!*output_buffer_text_cursor (buffer))
703 /* We got a '%'. Let's see what happens. Record whether we're
704 parsing a long integer format specifier. */
705 if (*++output_buffer_text_cursor (buffer) == 'l')
708 ++output_buffer_text_cursor (buffer);
711 /* Handle %c, %d, %i, %ld, %li, %lo, %lu, %lx, %o, %s, %u,
712 %x, %.*s; %%. And nothing else. Front-ends should install
713 printers to grok language specific format specifiers. */
714 switch (*output_buffer_text_cursor (buffer))
718 (buffer, va_arg (output_buffer_format_args (buffer), int));
725 (buffer, va_arg (output_buffer_format_args (buffer), long int));
728 (buffer, va_arg (output_buffer_format_args (buffer), int));
733 output_long_octal (buffer,
734 va_arg (output_buffer_format_args (buffer),
737 output_octal (buffer,
738 va_arg (output_buffer_format_args (buffer),
743 output_add_string (buffer,
744 va_arg (output_buffer_format_args (buffer),
750 output_long_unsigned_decimal
751 (buffer, va_arg (output_buffer_format_args (buffer),
754 output_unsigned_decimal
755 (buffer, va_arg (output_buffer_format_args (buffer),
761 output_long_hexadecimal
762 (buffer, va_arg (output_buffer_format_args (buffer),
766 (buffer, va_arg (output_buffer_format_args (buffer),
771 output_add_character (buffer, '%');
778 /* We handle no precision specifier but `%.*s'. */
779 if (*++output_buffer_text_cursor (buffer) != '*')
781 else if (*++output_buffer_text_cursor (buffer) != 's')
783 n = va_arg (output_buffer_format_args (buffer), int);
784 s = va_arg (output_buffer_format_args (buffer), const char *);
785 output_append (buffer, s, s + n);
790 if (! lang_printer || !(*lang_printer) (buffer))
792 /* Hmmm. The front-end failed to install a format translator
793 but called us with an unrecognized format. Sorry. */
801 vbuild_message_string (msgid, ap)
807 vasprintf (&str, msgid, ap);
811 /* Return a malloc'd string containing MSGID formatted a la
812 printf. The caller is reponsible for freeing the memory. */
815 build_message_string VPARAMS ((const char *msgid, ...))
817 #ifndef ANSI_PROTOTYPES
823 VA_START (ap, msgid);
825 #ifndef ANSI_PROTOTYPES
826 msgid = va_arg (ap, const char *);
829 str = vbuild_message_string (msgid, ap);
836 /* Return a malloc'd string describing a location. The caller is
837 responsible for freeing the memory. */
840 context_as_prefix (file, line, warn)
848 return build_message_string ("%s:%d: warning: ", file, line);
850 return build_message_string ("%s:%d: ", file, line);
855 return build_message_string ("%s: warning: ", progname);
857 return build_message_string ("%s: ", progname);
861 /* Same as context_as_prefix, but only the source FILE is given. */
864 file_name_as_prefix (f)
867 return build_message_string ("%s: ", f);
870 /* Format a MESSAGE into BUFFER. Automatically wrap lines. */
873 output_do_printf (buffer, msgid)
874 output_buffer *buffer;
877 char *message = vbuild_message_string (msgid,
878 output_buffer_format_args (buffer));
880 wrap_text (buffer, message, message + strlen (message));
885 /* Format a message into BUFFER a la printf. */
888 output_printf VPARAMS ((struct output_buffer *buffer, const char *msgid, ...))
890 #ifndef ANSI_PROTOTYPES
891 struct output_buffer *buffer;
897 VA_START (ap, msgid);
898 #ifndef ANSI_PROTOTYPES
899 buffer = va_arg (ap, output_buffer *);
900 msgid = va_arg (ap, const char *);
902 old_args = output_buffer_ptr_to_format_args (buffer);
903 output_buffer_ptr_to_format_args (buffer) = ≈
904 output_do_printf (buffer, msgid);
905 output_buffer_ptr_to_format_args (buffer) = old_args;
909 /* Print the message MSGID in FILE. */
912 vnotice (file, msgid, ap)
917 vfprintf (file, _(msgid), ap);
920 /* Print a message relevant to the given DECL. */
923 format_with_decl (buffer, decl)
924 output_buffer *buffer;
929 /* Do magic to get around lack of varargs support for insertion
930 of arguments into existing list. We know that the decl is first;
931 we ass_u_me that it will be printed with "%s". */
932 for (p = output_buffer_text_cursor (buffer); *p; ++p)
938 else if (*(p + 1) != 's')
945 /* Print the left-hand substring. */
946 maybe_wrap_text (buffer, output_buffer_text_cursor (buffer), p);
948 if (*p == '%') /* Print the name. */
950 const char *n = (DECL_NAME (decl)
951 ? (*decl_printable_name) (decl, 2)
952 : _("((anonymous))"));
953 output_add_string (buffer, n);
957 if (ISALPHA (*(p - 1) & 0xFF))
962 if (*p) /* Print the rest of the message. */
964 output_buffer_text_cursor (buffer) = p;
965 output_format (buffer);
969 /* Figure file and line of the given INSN. */
972 file_and_line_for_asm (insn, pfile, pline)
977 rtx body = PATTERN (insn);
980 /* Find the (or one of the) ASM_OPERANDS in the insn. */
981 if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
982 asmop = SET_SRC (body);
983 else if (GET_CODE (body) == ASM_OPERANDS)
985 else if (GET_CODE (body) == PARALLEL
986 && GET_CODE (XVECEXP (body, 0, 0)) == SET)
987 asmop = SET_SRC (XVECEXP (body, 0, 0));
988 else if (GET_CODE (body) == PARALLEL
989 && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
990 asmop = XVECEXP (body, 0, 0);
996 *pfile = ASM_OPERANDS_SOURCE_FILE (asmop);
997 *pline = ASM_OPERANDS_SOURCE_LINE (asmop);
1001 *pfile = input_filename;
1006 /* Report a diagnostic MESSAGE (an errror or a WARNING) at the line number
1007 of the insn INSN. This is used only when INSN is an `asm' with operands,
1008 and each ASM_OPERANDS records its own source file and line. */
1011 diagnostic_for_asm (insn, msg, args_ptr, warn)
1017 diagnostic_context dc;
1019 set_diagnostic_context (&dc, msg, args_ptr, NULL, 0, warn);
1020 file_and_line_for_asm (insn, &diagnostic_file_location (&dc),
1021 &diagnostic_line_location (&dc));
1022 report_diagnostic (&dc);
1025 /* Report a diagnostic MESSAGE at the declaration DECL.
1026 MSG is a format string which uses %s to substitute the declaration
1027 name; subsequent substitutions are a la output_format. */
1030 diagnostic_for_decl (decl, msg, args_ptr, warn)
1038 if (diagnostic_lock++)
1041 if (count_error (warn))
1043 os = output_buffer_state (diagnostic_buffer);
1044 report_error_function (DECL_SOURCE_FILE (decl));
1046 (diagnostic_buffer, context_as_prefix
1047 (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl), warn));
1048 output_buffer_ptr_to_format_args (diagnostic_buffer) = args_ptr;
1049 output_buffer_text_cursor (diagnostic_buffer) = msg;
1050 format_with_decl (diagnostic_buffer, decl);
1051 finish_diagnostic ();
1052 output_destroy_prefix (diagnostic_buffer);
1054 output_buffer_state (diagnostic_buffer) = os;
1060 /* Count an error or warning. Return 1 if the message should be printed. */
1063 count_error (warningp)
1067 && (inhibit_warnings
1068 || (in_system_header && !warn_system_headers)))
1071 if (warningp && !warnings_are_errors)
1075 static int warning_message = 0;
1077 if (warningp && !warning_message)
1079 verbatim ("%s: warnings being treated as errors\n", progname);
1080 warning_message = 1;
1088 /* Print a diagnistic MSGID on FILE. */
1091 fnotice VPARAMS ((FILE *file, const char *msgid, ...))
1093 #ifndef ANSI_PROTOTYPES
1099 VA_START (ap, msgid);
1101 #ifndef ANSI_PROTOTYPES
1102 file = va_arg (ap, FILE *);
1103 msgid = va_arg (ap, const char *);
1106 vnotice (file, msgid, ap);
1111 /* Print a fatal I/O error message. Argument are like printf.
1112 Also include a system error message based on `errno'. */
1115 fatal_io_error VPARAMS ((const char *msgid, ...))
1117 #ifndef ANSI_PROTOTYPES
1123 os = output_buffer_state (diagnostic_buffer);
1124 VA_START (ap, msgid);
1126 #ifndef ANSI_PROTOTYPES
1127 msgid = va_arg (ap, const char *);
1130 output_printf (diagnostic_buffer, "%s: %s: ", progname, xstrerror (errno));
1131 output_buffer_ptr_to_format_args (diagnostic_buffer) = ≈
1132 output_buffer_text_cursor (diagnostic_buffer) = msgid;
1133 output_format (diagnostic_buffer);
1134 finish_diagnostic ();
1135 output_buffer_state (diagnostic_buffer) = os;
1137 exit (FATAL_EXIT_CODE);
1140 /* Issue a pedantic warning MSGID. */
1143 pedwarn VPARAMS ((const char *msgid, ...))
1145 #ifndef ANSI_PROTOTYPES
1149 diagnostic_context dc;
1151 VA_START (ap, msgid);
1153 #ifndef ANSI_PROTOTYPES
1154 msgid = va_arg (ap, const char *);
1157 set_diagnostic_context
1158 (&dc, msgid, &ap, input_filename, lineno, !flag_pedantic_errors);
1159 report_diagnostic (&dc);
1163 /* Issue a pedantic waring about DECL. */
1166 pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1168 #ifndef ANSI_PROTOTYPES
1174 VA_START (ap, msgid);
1176 #ifndef ANSI_PROTOTYPES
1177 decl = va_arg (ap, tree);
1178 msgid = va_arg (ap, const char *);
1180 /* We don't want -pedantic-errors to cause the compilation to fail from
1181 "errors" in system header files. Sometimes fixincludes can't fix what's
1182 broken (eg: unsigned char bitfields - fixing it may change the alignment
1183 which will cause programs to mysteriously fail because the C library
1184 or kernel uses the original layout). There's no point in issuing a
1185 warning either, it's just unnecessary noise. */
1186 if (!DECL_IN_SYSTEM_HEADER (decl))
1187 diagnostic_for_decl (decl, msgid, &ap, !flag_pedantic_errors);
1191 /* Same as above but within the context FILE and LINE. */
1194 pedwarn_with_file_and_line VPARAMS ((const char *file, int line,
1195 const char *msgid, ...))
1197 #ifndef ANSI_PROTOTYPES
1203 diagnostic_context dc;
1205 VA_START (ap, msgid);
1207 #ifndef ANSI_PROTOTYPES
1208 file = va_arg (ap, const char *);
1209 line = va_arg (ap, int);
1210 msgid = va_arg (ap, const char *);
1213 set_diagnostic_context (&dc, msgid, &ap, file, line, !flag_pedantic_errors);
1214 report_diagnostic (&dc);
1218 /* Just apologize with MSGID. */
1221 sorry VPARAMS ((const char *msgid, ...))
1223 #ifndef ANSI_PROTOTYPES
1229 os = output_buffer_state (diagnostic_buffer);
1230 VA_START (ap, msgid);
1232 #ifndef ANSI_PROTOTYPES
1233 msgid = va_arg (ap, const char *);
1237 (diagnostic_buffer, context_as_prefix (input_filename, lineno, 0));
1238 output_printf (diagnostic_buffer, "sorry, not implemented: ");
1239 output_buffer_ptr_to_format_args (diagnostic_buffer) = ≈
1240 output_buffer_text_cursor (diagnostic_buffer) = msgid;
1241 output_format (diagnostic_buffer);
1242 finish_diagnostic ();
1243 output_buffer_state (diagnostic_buffer) = os;
1247 /* Called when the start of a function definition is parsed,
1248 this function prints on stderr the name of the function. */
1251 announce_function (decl)
1256 if (rtl_dump_and_exit)
1257 verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
1259 verbatim (" %s", (*decl_printable_name) (decl, 2));
1261 output_needs_newline (diagnostic_buffer) = 1;
1262 record_last_error_function ();
1266 /* The default function to print out name of current function that caused
1270 default_print_error_function (file)
1273 if (error_function_changed ())
1275 char *prefix = file ? build_message_string ("%s: ", file) : NULL;
1278 os = output_buffer_state (diagnostic_buffer);
1279 output_set_prefix (diagnostic_buffer, prefix);
1281 if (current_function_decl == NULL)
1282 output_add_string (diagnostic_buffer, "At top level:");
1285 if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
1287 (diagnostic_buffer, "In method `%s':",
1288 (*decl_printable_name) (current_function_decl, 2));
1291 (diagnostic_buffer, "In function `%s':",
1292 (*decl_printable_name) (current_function_decl, 2));
1294 output_add_newline (diagnostic_buffer);
1296 record_last_error_function ();
1297 output_to_stream (diagnostic_buffer, stderr);
1298 output_buffer_state (diagnostic_buffer) = os;
1299 free ((char*) prefix);
1303 /* Prints out, if necessary, the name of the current function
1304 that caused an error. Called from all error and warning functions.
1305 We ignore the FILE parameter, as it cannot be relied upon. */
1308 report_error_function (file)
1309 const char *file ATTRIBUTE_UNUSED;
1311 report_problematic_module (diagnostic_buffer);
1312 (*print_error_function) (input_filename);
1316 error_with_file_and_line VPARAMS ((const char *file, int line,
1317 const char *msgid, ...))
1319 #ifndef ANSI_PROTOTYPES
1325 diagnostic_context dc;
1327 VA_START (ap, msgid);
1329 #ifndef ANSI_PROTOTYPES
1330 file = va_arg (ap, const char *);
1331 line = va_arg (ap, int);
1332 msgid = va_arg (ap, const char *);
1335 set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 0);
1336 report_diagnostic (&dc);
1341 error_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1343 #ifndef ANSI_PROTOTYPES
1349 VA_START (ap, msgid);
1351 #ifndef ANSI_PROTOTYPES
1352 decl = va_arg (ap, tree);
1353 msgid = va_arg (ap, const char *);
1356 diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 0);
1361 error_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
1363 #ifndef ANSI_PROTOTYPES
1369 VA_START (ap, msgid);
1371 #ifndef ANSI_PROTOTYPES
1372 insn = va_arg (ap, rtx);
1373 msgid = va_arg (ap, const char *);
1376 diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 0);
1380 /* Report an error message. The arguments are like that of printf. */
1383 error VPARAMS ((const char *msgid, ...))
1385 #ifndef ANSI_PROTOTYPES
1389 diagnostic_context dc;
1391 VA_START (ap, msgid);
1393 #ifndef ANSI_PROTOTYPES
1394 msgid = va_arg (ap, const char *);
1397 set_diagnostic_context
1398 (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
1399 report_diagnostic (&dc);
1403 /* Likewise, except that the compilation is terminated after printing the
1407 fatal_error VPARAMS ((const char *msgid, ...))
1409 #ifndef ANSI_PROTOTYPES
1413 diagnostic_context dc;
1415 VA_START (ap, msgid);
1417 #ifndef ANSI_PROTOTYPES
1418 msgid = va_arg (ap, const char *);
1421 set_diagnostic_context
1422 (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 0);
1423 report_diagnostic (&dc);
1426 fprintf (stderr, "compilation terminated.\n");
1427 exit (FATAL_EXIT_CODE);
1430 /* Report a compiler error at the current line number. Allow a front end to
1431 intercept the message. */
1433 static void (*internal_error_function) PARAMS ((const char *, va_list *));
1435 /* Set the function to call when a compiler error occurs. */
1438 set_internal_error_function (f)
1439 void (*f) PARAMS ((const char *, va_list *));
1441 internal_error_function = f;
1445 internal_error VPARAMS ((const char *msgid, ...))
1447 #ifndef ANSI_PROTOTYPES
1451 diagnostic_context dc;
1453 VA_START (ap, msgid);
1455 #ifndef ANSI_PROTOTYPES
1456 msgid = va_arg (ap, const char *);
1459 if (errorcount > 0 || sorrycount > 0)
1461 fprintf (stderr, "%s:%d: confused by earlier errors, bailing out\n",
1462 input_filename, lineno);
1463 exit (FATAL_EXIT_CODE);
1466 if (internal_error_function != 0)
1467 (*internal_error_function) (_(msgid), &ap);
1469 set_diagnostic_context
1470 (&dc, msgid, &ap, input_filename, lineno, /* warn = */0);
1471 report_diagnostic (&dc);
1474 fprintf (stderr, "Please submit a full bug report, ");
1475 fprintf (stderr, "with preprocessed source if appropriate.\n");
1476 fprintf (stderr, "See %s for instructions.\n", GCCBUGURL);
1477 exit (FATAL_EXIT_CODE);
1481 _fatal_insn (msgid, insn, file, line, function)
1486 const char *function;
1488 error ("%s", msgid);
1490 /* The above incremented error_count, but isn't an error that we want to
1491 count, so reset it here. */
1495 fancy_abort (file, line, function);
1499 _fatal_insn_not_found (insn, file, line, function)
1503 const char *function;
1505 if (INSN_CODE (insn) < 0)
1506 _fatal_insn ("Unrecognizable insn:", insn, file, line, function);
1508 _fatal_insn ("Insn does not satisfy its constraints:",
1509 insn, file, line, function);
1513 warning_with_file_and_line VPARAMS ((const char *file, int line,
1514 const char *msgid, ...))
1516 #ifndef ANSI_PROTOTYPES
1522 diagnostic_context dc;
1524 VA_START (ap, msgid);
1526 #ifndef ANSI_PROTOTYPES
1527 file = va_arg (ap, const char *);
1528 line = va_arg (ap, int);
1529 msgid = va_arg (ap, const char *);
1532 set_diagnostic_context (&dc, msgid, &ap, file, line, /* warn = */ 1);
1533 report_diagnostic (&dc);
1538 warning_with_decl VPARAMS ((tree decl, const char *msgid, ...))
1540 #ifndef ANSI_PROTOTYPES
1546 VA_START (ap, msgid);
1548 #ifndef ANSI_PROTOTYPES
1549 decl = va_arg (ap, tree);
1550 msgid = va_arg (ap, const char *);
1553 diagnostic_for_decl (decl, msgid, &ap, /* warn = */ 1);
1558 warning_for_asm VPARAMS ((rtx insn, const char *msgid, ...))
1560 #ifndef ANSI_PROTOTYPES
1566 VA_START (ap, msgid);
1568 #ifndef ANSI_PROTOTYPES
1569 insn = va_arg (ap, rtx);
1570 msgid = va_arg (ap, const char *);
1573 diagnostic_for_asm (insn, msgid, &ap, /* warn = */ 1);
1578 warning VPARAMS ((const char *msgid, ...))
1580 #ifndef ANSI_PROTOTYPES
1584 diagnostic_context dc;
1586 VA_START (ap, msgid);
1588 #ifndef ANSI_PROTOTYPES
1589 msgid = va_arg (ap, const char *);
1592 set_diagnostic_context
1593 (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
1594 report_diagnostic (&dc);
1598 /* Flush diagnostic_buffer content on stderr. */
1601 finish_diagnostic ()
1603 output_to_stream (diagnostic_buffer, stderr);
1604 clear_diagnostic_info (diagnostic_buffer);
1605 fputc ('\n', stderr);
1609 /* Helper subroutine of output_verbatim and verbatim. Do the approriate
1610 settings needed by BUFFER for a verbatim formatting. */
1613 output_do_verbatim (buffer, msg, args_ptr)
1614 output_buffer *buffer;
1620 os = output_buffer_state (buffer);
1621 output_prefix (buffer) = NULL;
1622 prefixing_policy (buffer) = DIAGNOSTICS_SHOW_PREFIX_NEVER;
1623 output_buffer_text_cursor (buffer) = msg;
1624 output_buffer_ptr_to_format_args (buffer) = args_ptr;
1625 output_set_maximum_length (buffer, 0);
1626 output_format (buffer);
1627 output_buffer_state (buffer) = os;
1630 /* Output MESSAGE verbatim into BUFFER. */
1633 output_verbatim VPARAMS ((output_buffer *buffer, const char *msg, ...))
1635 #ifndef ANSI_PROTOTYPES
1636 output_buffer *buffer;
1642 #ifndef ANSI_PROTOTYPES
1643 buffer = va_arg (ap, output_buffer *);
1644 msg = va_arg (ap, const char *);
1646 output_do_verbatim (buffer, msg, &ap);
1650 /* Same as above but use diagnostic_buffer. */
1653 verbatim VPARAMS ((const char *msg, ...))
1655 #ifndef ANSI_PROTOTYPES
1661 #ifndef ANSI_PROTOTYPES
1662 msg = va_arg (ap, const char *);
1664 output_do_verbatim (diagnostic_buffer, msg, &ap);
1665 output_to_stream (diagnostic_buffer, stderr);
1669 /* Report a diagnostic message (an error or a warning) as specified by
1670 DC. This function is *the* subroutine in terms of which front-ends
1671 should implement their specific diagnostic handling modules. The
1672 front-end independent format specifiers are exactly those described
1673 in the documentation of output_format. */
1676 report_diagnostic (dc)
1677 diagnostic_context *dc;
1681 if (diagnostic_lock++)
1684 if (count_error (diagnostic_is_warning (dc)))
1686 os = output_buffer_state (diagnostic_buffer);
1687 diagnostic_msg = diagnostic_message (dc);
1688 diagnostic_args = diagnostic_argument_list (dc);
1689 (*diagnostic_starter (dc)) (diagnostic_buffer, dc);
1690 output_format (diagnostic_buffer);
1691 (*diagnostic_finalizer (dc)) (diagnostic_buffer, dc);
1692 finish_diagnostic ();
1693 output_buffer_state (diagnostic_buffer) = os;
1699 /* Inform the user that an error occurred while trying to report some
1700 other error. This indicates catastrophic internal inconsistencies,
1701 so give up now. But do try to flush out the previous error. */
1706 if (diagnostic_lock < 3)
1707 finish_diagnostic ();
1710 ("Internal compiler error: Error reporting routines re-entered.");
1713 /* Given a partial pathname as input, return another pathname that
1714 shares no directory elements with the pathname of __FILE__. This
1715 is used by fancy_abort() to print `Internal compiler error in expr.c'
1716 instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */
1719 trim_filename (name)
1722 static const char this_file[] = __FILE__;
1723 const char *p = name, *q = this_file;
1725 /* First skip any "../" in each filename. This allows us to give a proper
1726 reference to a file in a subdirectory. */
1727 while (p[0] == '.' && p[1] == '.'
1728 && (p[2] == DIR_SEPARATOR
1729 #ifdef DIR_SEPARATOR_2
1730 || p[2] == DIR_SEPARATOR_2
1735 while (q[0] == '.' && q[1] == '.'
1736 && (q[2] == DIR_SEPARATOR
1737 #ifdef DIR_SEPARATOR_2
1738 || p[2] == DIR_SEPARATOR_2
1743 /* Now skip any parts the two filenames have in common. */
1744 while (*p == *q && *p != 0 && *q != 0)
1747 /* Now go backwards until the previous directory separator. */
1748 while (p > name && p[-1] != DIR_SEPARATOR
1749 #ifdef DIR_SEPARATOR_2
1750 && p[-1] != DIR_SEPARATOR_2
1758 /* Report an internal compiler error in a friendly manner and without
1762 fancy_abort (file, line, function)
1765 const char *function;
1767 internal_error ("Internal compiler error in %s, at %s:%d",
1768 function, trim_filename (file), line);
1771 /* Setup DC for reporting a diagnostic MESSAGE (an error or a WARNING),
1772 using arguments pointed to by ARGS_PTR, issued at a location specified
1773 by FILE and LINE. */
1776 set_diagnostic_context (dc, message, args_ptr, file, line, warn)
1777 diagnostic_context *dc;
1778 const char *message;
1784 memset (dc, 0, sizeof (diagnostic_context));
1785 diagnostic_message (dc) = message;
1786 diagnostic_argument_list (dc) = args_ptr;
1787 diagnostic_file_location (dc) = file;
1788 diagnostic_line_location (dc) = line;
1789 diagnostic_is_warning (dc) = warn;
1790 diagnostic_starter (dc) = lang_diagnostic_starter;
1791 diagnostic_finalizer (dc) = lang_diagnostic_finalizer;
1795 report_problematic_module (buffer)
1796 output_buffer *buffer;
1798 struct file_stack *p;
1800 if (output_needs_newline (buffer))
1802 output_add_newline (buffer);
1803 output_needs_newline (buffer) = 0;
1806 if (input_file_stack && input_file_stack->next != 0
1807 && error_module_changed ())
1809 for (p = input_file_stack->next; p; p = p->next)
1810 if (p == input_file_stack->next)
1812 (buffer, "In file included from %s:%d", p->name, p->line);
1815 (buffer, ",\n from %s:%d", p->name, p->line);
1816 output_verbatim (buffer, ":\n");
1817 record_last_error_module ();
1822 default_diagnostic_starter (buffer, dc)
1823 output_buffer *buffer;
1824 diagnostic_context *dc;
1826 report_error_function (diagnostic_file_location (dc));
1827 output_set_prefix (buffer,
1828 context_as_prefix (diagnostic_file_location (dc),
1829 diagnostic_line_location (dc),
1830 diagnostic_is_warning (dc)));
1834 default_diagnostic_finalizer (buffer, dc)
1835 output_buffer *buffer;
1836 diagnostic_context *dc __attribute__((__unused__));
1838 output_destroy_prefix (buffer);