| /* Language-independent diagnostic subroutines for the GNU Compiler Collection | |
| Copyright (C) 1999-2026 Free Software Foundation, Inc. | |
| Contributed by Gabriel Dos Reis <gdr@codesourcery.com> | |
| This file is part of GCC. | |
| GCC is free software; you can redistribute it and/or modify it under | |
| the terms of the GNU General Public License as published by the Free | |
| Software Foundation; either version 3, or (at your option) any later | |
| version. | |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GCC; see the file COPYING3. If not see | |
| <http://www.gnu.org/licenses/>. */ | |
| /* This file implements the language independent aspect of diagnostic | |
| message module. */ | |
| #include "config.h" | |
| #define INCLUDE_VECTOR | |
| #include "system.h" | |
| #include "coretypes.h" | |
| #include "version.h" | |
| #include "demangle.h" | |
| #include "intl.h" | |
| #include "backtrace.h" | |
| #include "diagnostic.h" | |
| #include "diagnostics/color.h" | |
| #include "diagnostics/url.h" | |
| #include "diagnostics/metadata.h" | |
| #include "diagnostics/paths.h" | |
| #include "diagnostics/client-data-hooks.h" | |
| #include "diagnostics/diagram.h" | |
| #include "diagnostics/sink.h" | |
| #include "diagnostics/sarif-sink.h" | |
| #include "diagnostics/text-sink.h" | |
| #include "diagnostics/changes.h" | |
| #include "selftest.h" | |
| #include "diagnostics/selftest-context.h" | |
| #include "opts.h" | |
| #include "cpplib.h" | |
| #include "text-art/theme.h" | |
| #include "pretty-print-urlifier.h" | |
| #include "diagnostics/logical-locations.h" | |
| #include "diagnostics/buffering.h" | |
| #include "diagnostics/file-cache.h" | |
| #include "diagnostics/dumping.h" | |
| #include "diagnostics/logging.h" | |
| #ifdef HAVE_TERMIOS_H | |
| # include <termios.h> | |
| #endif | |
| #ifdef GWINSZ_IN_SYS_IOCTL | |
| # include <sys/ioctl.h> | |
| #endif | |
| /* Disable warnings about quoting issues in the pp_xxx calls below | |
| that (intentionally) don't follow GCC diagnostic conventions. */ | |
| #if __GNUC__ >= 10 | |
| # pragma GCC diagnostic push | |
| # pragma GCC diagnostic ignored "-Wformat-diag" | |
| #endif | |
| static void real_abort (void) ATTRIBUTE_NORETURN; | |
| /* Name of program invoked, sans directories. */ | |
| const char *progname; | |
| /* Return a malloc'd string containing MSG formatted a la printf. The | |
| caller is responsible for freeing the memory. */ | |
| char * | |
| build_message_string (const char *msg, ...) | |
| { | |
| char *str; | |
| va_list ap; | |
| va_start (ap, msg); | |
| str = xvasprintf (msg, ap); | |
| va_end (ap); | |
| return str; | |
| } | |
| /* Return the value of the getenv("COLUMNS") as an integer. If the | |
| value is not set to a positive integer, use ioctl to get the | |
| terminal width. If it fails, return INT_MAX. */ | |
| int | |
| get_terminal_width (void) | |
| { | |
| const char * s = getenv ("COLUMNS"); | |
| if (s != nullptr) { | |
| int n = atoi (s); | |
| if (n > 0) | |
| return n; | |
| } | |
| #ifdef TIOCGWINSZ | |
| struct winsize w; | |
| w.ws_col = 0; | |
| if (ioctl (0, TIOCGWINSZ, &w) == 0 && w.ws_col > 0) | |
| return w.ws_col; | |
| #endif | |
| return INT_MAX; | |
| } | |
| namespace diagnostics { | |
| /* Set caret_max_width to value. */ | |
| void | |
| context::set_caret_max_width (int value) | |
| { | |
| /* One minus to account for the leading empty space. */ | |
| value = value ? value - 1 | |
| : (isatty (fileno (pp_buffer (get_reference_printer ())->m_stream)) | |
| ? get_terminal_width () - 1 : INT_MAX); | |
| if (value <= 0) | |
| value = INT_MAX; | |
| m_source_printing.max_width = value; | |
| } | |
| /* Initialize the diagnostic message outputting machinery. */ | |
| void | |
| context::initialize (int n_opts) | |
| { | |
| /* Allocate a basic pretty-printer. Clients will replace this a | |
| much more elaborated pretty-printer if they wish. */ | |
| m_reference_printer = std::make_unique<pretty_printer> ().release (); | |
| m_file_cache = new file_cache (); | |
| m_diagnostic_counters.clear (); | |
| m_warning_as_error_requested = false; | |
| m_n_opts = n_opts; | |
| m_option_classifier.init (n_opts); | |
| m_source_printing.enabled = false; | |
| set_caret_max_width (pp_line_cutoff (get_reference_printer ())); | |
| for (int i = 0; i < rich_location::STATICALLY_ALLOCATED_RANGES; i++) | |
| m_source_printing.caret_chars[i] = '^'; | |
| m_show_cwe = false; | |
| m_show_rules = false; | |
| m_path_format = DPF_NONE; | |
| m_show_path_depths = false; | |
| m_show_option_requested = false; | |
| m_abort_on_error = false; | |
| m_show_column = false; | |
| m_pedantic_errors = false; | |
| m_permissive = false; | |
| m_opt_permissive = 0; | |
| m_fatal_errors = false; | |
| m_inhibit_warnings = false; | |
| m_warn_system_headers = false; | |
| m_max_errors = 0; | |
| m_internal_error = nullptr; | |
| m_adjust_diagnostic_info = nullptr; | |
| m_text_callbacks.m_begin_diagnostic = default_text_starter; | |
| m_text_callbacks.m_text_start_span | |
| = default_start_span_fn<to_text>; | |
| m_text_callbacks.m_html_start_span | |
| = default_start_span_fn<to_html>; | |
| m_text_callbacks.m_end_diagnostic = default_text_finalizer; | |
| m_option_id_mgr = nullptr; | |
| m_urlifier_stack = new auto_vec<urlifier_stack_node> (); | |
| m_last_location = UNKNOWN_LOCATION; | |
| m_client_aux_data = nullptr; | |
| m_lock = 0; | |
| m_inhibit_notes_p = false; | |
| m_source_printing.colorize_source_p = false; | |
| m_source_printing.show_labels_p = false; | |
| m_source_printing.show_line_numbers_p = false; | |
| m_source_printing.min_margin_width = 0; | |
| m_source_printing.show_ruler_p = false; | |
| m_source_printing.show_event_links_p = false; | |
| m_column_options.m_column_unit = DIAGNOSTICS_COLUMN_UNIT_DISPLAY; | |
| m_column_options.m_column_origin = 1; | |
| m_column_options.m_tabstop = 8; | |
| m_report_bug = false; | |
| m_extra_output_kind = EXTRA_DIAGNOSTIC_OUTPUT_none; | |
| if (const char *var = getenv ("GCC_EXTRA_DIAGNOSTIC_OUTPUT")) | |
| { | |
| if (!strcmp (var, "fixits-v1")) | |
| m_extra_output_kind = EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1; | |
| else if (!strcmp (var, "fixits-v2")) | |
| m_extra_output_kind = EXTRA_DIAGNOSTIC_OUTPUT_fixits_v2; | |
| /* Silently ignore unrecognized values. */ | |
| } | |
| m_escape_format = DIAGNOSTICS_ESCAPE_FORMAT_UNICODE; | |
| m_fixits_change_set = nullptr; | |
| m_diagnostic_groups.m_group_nesting_depth = 0; | |
| m_diagnostic_groups.m_diagnostic_nesting_level = 0; | |
| m_diagnostic_groups.m_emission_count = 0; | |
| m_diagnostic_groups.m_inhibiting_notes_from = 0; | |
| m_sinks.safe_push (new text_sink (*this, nullptr, true)); | |
| m_set_locations_cb = nullptr; | |
| m_client_data_hooks = nullptr; | |
| m_diagrams.m_theme = nullptr; | |
| m_original_argv = nullptr; | |
| m_diagnostic_buffer = nullptr; | |
| m_logger = nullptr; | |
| enum diagnostic_text_art_charset text_art_charset | |
| = DIAGNOSTICS_TEXT_ART_CHARSET_EMOJI; | |
| if (const char *lang = getenv ("LANG")) | |
| { | |
| /* For LANG=C, don't assume the terminal supports anything | |
| other than ASCII. */ | |
| if (!strcmp (lang, "C")) | |
| text_art_charset = DIAGNOSTICS_TEXT_ART_CHARSET_ASCII; | |
| } | |
| set_text_art_charset (text_art_charset); | |
| if (const char *name = getenv ("GCC_DIAGNOSTICS_LOG")) | |
| { | |
| if (name[0] != '\0') | |
| { | |
| /* Try to write a log to the named path. */ | |
| if (FILE *outfile = fopen (name, "w")) | |
| m_logger = new logging::logger | |
| (output_file (outfile, true, | |
| label_text::take (xstrdup (name)))); | |
| } | |
| else | |
| /* Write a log to stderr. */ | |
| m_logger = new logging::logger | |
| (output_file | |
| (stderr, false, | |
| label_text::borrow ("stderr"))); | |
| } | |
| if (m_logger) | |
| m_logger->log_printf ("diagnostics::context::initialize"); | |
| } | |
| /* Maybe initialize the color support. We require clients to do this | |
| explicitly, since most clients don't want color. When called | |
| without a VALUE, it initializes with DIAGNOSTICS_COLOR_DEFAULT. */ | |
| void | |
| context::color_init (int value) | |
| { | |
| /* value == -1 is the default value. */ | |
| if (value < 0) | |
| { | |
| /* If DIAGNOSTICS_COLOR_DEFAULT is -1, default to | |
| -fdiagnostics-color=auto if GCC_COLORS is in the environment, | |
| otherwise default to -fdiagnostics-color=never, for other | |
| values default to that | |
| -fdiagnostics-color={never,auto,always}. */ | |
| if (DIAGNOSTICS_COLOR_DEFAULT == -1) | |
| { | |
| if (!getenv ("GCC_COLORS")) | |
| return; | |
| value = DIAGNOSTICS_COLOR_AUTO; | |
| } | |
| else | |
| value = DIAGNOSTICS_COLOR_DEFAULT; | |
| } | |
| pp_show_color (m_reference_printer) | |
| = colorize_init ((diagnostic_color_rule_t) value); | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| pp_show_color (sink_->get_printer ()) | |
| = pp_show_color (m_reference_printer); | |
| } | |
| /* Initialize URL support within this context based on VALUE, | |
| handling "auto". */ | |
| void | |
| context::urls_init (int value) | |
| { | |
| /* value == -1 is the default value. */ | |
| if (value < 0) | |
| { | |
| /* If DIAGNOSTICS_URLS_DEFAULT is -1, default to | |
| -fdiagnostics-urls=auto if GCC_URLS or TERM_URLS is in the | |
| environment, otherwise default to -fdiagnostics-urls=never, | |
| for other values default to that | |
| -fdiagnostics-urls={never,auto,always}. */ | |
| if (DIAGNOSTICS_URLS_DEFAULT == -1) | |
| { | |
| if (!getenv ("GCC_URLS") && !getenv ("TERM_URLS")) | |
| return; | |
| value = DIAGNOSTICS_URL_AUTO; | |
| } | |
| else | |
| value = DIAGNOSTICS_URLS_DEFAULT; | |
| } | |
| m_reference_printer->set_url_format | |
| (determine_url_format ((diagnostic_url_rule_t) value)); | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| sink_->get_printer ()->set_url_format | |
| (m_reference_printer->get_url_format ()); | |
| } | |
| void | |
| context::set_show_nesting (bool val) | |
| { | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| if (auto text_sink_ = sink_->dyn_cast_text_sink ()) | |
| text_sink_->set_show_nesting (val); | |
| } | |
| void | |
| context::set_show_nesting_locations (bool val) | |
| { | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| if (auto text_sink_ = sink_->dyn_cast_text_sink ()) | |
| text_sink_->set_show_locations_in_nesting (val); | |
| } | |
| void | |
| context::set_show_nesting_levels (bool val) | |
| { | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| if (auto text_sink_ = sink_->dyn_cast_text_sink ()) | |
| text_sink_->set_show_nesting_levels (val); | |
| } | |
| /* Create the file_cache, if not already created, and tell it how to | |
| translate files on input. */ | |
| void | |
| context::initialize_input_context (diagnostic_input_charset_callback ccb, | |
| bool should_skip_bom) | |
| { | |
| m_file_cache->initialize_input_context (ccb, should_skip_bom); | |
| } | |
| /* Do any cleaning up required after the last diagnostic is emitted. */ | |
| void | |
| context::finish () | |
| { | |
| if (m_logger) | |
| { | |
| m_logger->log_printf ("diagnostics::context::finish"); | |
| /* We're cleaning up the logger before this function exits, | |
| so we can't use auto_inc_depth here. */ | |
| m_logger->inc_depth (); | |
| dump (m_logger->get_stream (), m_logger->get_indent ()); | |
| } | |
| for (auto iter : m_sinks) | |
| iter->finalize_extensions (); | |
| /* We might be handling a fatal error. | |
| Close any active diagnostic groups, which may trigger flushing | |
| sinks. */ | |
| while (m_diagnostic_groups.m_group_nesting_depth > 0) | |
| end_group (); | |
| set_diagnostic_buffer (nullptr); | |
| /* Clean ups. */ | |
| while (!m_sinks.is_empty ()) | |
| delete m_sinks.pop (); | |
| if (m_diagrams.m_theme) | |
| { | |
| delete m_diagrams.m_theme; | |
| m_diagrams.m_theme = nullptr; | |
| } | |
| delete m_file_cache; | |
| m_file_cache = nullptr; | |
| m_option_classifier.fini (); | |
| delete m_reference_printer; | |
| m_reference_printer = nullptr; | |
| if (m_fixits_change_set) | |
| { | |
| delete m_fixits_change_set; | |
| m_fixits_change_set = nullptr; | |
| } | |
| if (m_client_data_hooks) | |
| { | |
| delete m_client_data_hooks; | |
| m_client_data_hooks = nullptr; | |
| } | |
| delete m_option_id_mgr; | |
| m_option_id_mgr = nullptr; | |
| if (m_urlifier_stack) | |
| { | |
| while (!m_urlifier_stack->is_empty ()) | |
| pop_urlifier (); | |
| delete m_urlifier_stack; | |
| m_urlifier_stack = nullptr; | |
| } | |
| freeargv (m_original_argv); | |
| m_original_argv = nullptr; | |
| delete m_logger; | |
| m_logger = nullptr; | |
| } | |
| /* Dump state of this diagnostics::context to OUT, for debugging. */ | |
| void | |
| context::dump (FILE *outfile, int indent) const | |
| { | |
| dumping::emit_heading (outfile, indent, "diagnostics::context"); | |
| m_diagnostic_counters.dump (outfile, indent + 2); | |
| dumping::emit_heading (outfile, indent + 2, "reference printer"); | |
| if (m_reference_printer) | |
| m_reference_printer->dump (outfile, indent + 4); | |
| else | |
| dumping::emit_none (outfile, indent + 4); | |
| dumping::emit_heading (outfile, indent + 2, "output sinks"); | |
| if (m_sinks.length () > 0) | |
| { | |
| for (unsigned i = 0; i < m_sinks.length (); ++i) | |
| { | |
| dumping::emit_indent (outfile, indent + 4); | |
| const sink *s = m_sinks[i]; | |
| fprintf (outfile, "sink %i (", i); | |
| s->dump_kind (outfile); | |
| fprintf (outfile, "):\n"); | |
| s->dump (outfile, indent + 6); | |
| } | |
| } | |
| else | |
| dumping::emit_none (outfile, indent + 4); | |
| dumping::emit_heading (outfile, indent + 2, "diagnostic buffer"); | |
| if (m_diagnostic_buffer) | |
| m_diagnostic_buffer->dump (outfile, indent + 4); | |
| else | |
| dumping::emit_none (outfile, indent + 4); | |
| dumping::emit_heading (outfile, indent + 2, "file cache"); | |
| if (m_file_cache) | |
| m_file_cache->dump (outfile, indent + 4); | |
| else | |
| dumping::emit_none (outfile, indent + 4); | |
| dumping::emit_heading (outfile, indent + 2, "client data hooks"); | |
| if (m_client_data_hooks) | |
| m_client_data_hooks->dump (outfile, indent + 4); | |
| else | |
| dumping::emit_none (outfile, indent + 4); | |
| } | |
| /* Return true if sufficiently severe diagnostics have been seen that | |
| we ought to exit with a non-zero exit code. */ | |
| bool | |
| context::execution_failed_p () const | |
| { | |
| return (diagnostic_count (kind::fatal) | |
| || diagnostic_count (kind::error) | |
| || diagnostic_count (kind::sorry) | |
| || diagnostic_count (kind::werror)); | |
| } | |
| void | |
| context::remove_all_output_sinks () | |
| { | |
| while (!m_sinks.is_empty ()) | |
| delete m_sinks.pop (); | |
| } | |
| void | |
| context::set_sink (std::unique_ptr<sink> sink_) | |
| { | |
| DIAGNOSTICS_LOG_SCOPE_PRINTF0 (m_logger, "diagnostics::context::set_sink"); | |
| if (m_logger) | |
| sink_->dump (m_logger->get_stream (), m_logger->get_indent ()); | |
| remove_all_output_sinks (); | |
| m_sinks.safe_push (sink_.release ()); | |
| } | |
| sink & | |
| context::get_sink (size_t idx) const | |
| { | |
| gcc_assert (idx < m_sinks.length ()); | |
| gcc_assert (m_sinks[idx]); | |
| return *m_sinks[idx]; | |
| } | |
| void | |
| context::add_sink (std::unique_ptr<sink> sink_) | |
| { | |
| DIAGNOSTICS_LOG_SCOPE_PRINTF0 (m_logger, "diagnostics::context::add_sink"); | |
| if (m_logger) | |
| sink_->dump (m_logger->get_stream (), m_logger->get_indent ()); | |
| m_sinks.safe_push (sink_.release ()); | |
| } | |
| /* Return true if there are no machine-readable formats writing to stderr. */ | |
| bool | |
| context::supports_fnotice_on_stderr_p () const | |
| { | |
| for (auto sink_ : m_sinks) | |
| if (sink_->machine_readable_stderr_p ()) | |
| return false; | |
| return true; | |
| } | |
| void | |
| context::set_main_input_filename (const char *filename) | |
| { | |
| for (auto sink_ : m_sinks) | |
| sink_->set_main_input_filename (filename); | |
| } | |
| std::unique_ptr<client_data_hooks> | |
| context::set_client_data_hooks (std::unique_ptr<client_data_hooks> hooks) | |
| { | |
| std::unique_ptr<client_data_hooks> old_hooks (m_client_data_hooks); | |
| /* Ideally the field would be a std::unique_ptr here. */ | |
| m_client_data_hooks = hooks.release (); | |
| return old_hooks; | |
| } | |
| void | |
| context::set_original_argv (unique_argv original_argv) | |
| { | |
| /* Ideally we'd use a unique_argv for m_original_argv, but | |
| diagnostics::context doesn't yet have a ctor/dtor pair. */ | |
| // Ensure any old value is freed | |
| freeargv (m_original_argv); | |
| // Take ownership of the new value | |
| m_original_argv = original_argv.release (); | |
| } | |
| void | |
| context::set_option_id_manager (std::unique_ptr<option_id_manager> mgr, | |
| unsigned lang_mask) | |
| { | |
| delete m_option_id_mgr; | |
| m_option_id_mgr = mgr.release (); | |
| m_lang_mask = lang_mask; | |
| } | |
| void | |
| context::push_owned_urlifier (std::unique_ptr<urlifier> ptr) | |
| { | |
| gcc_assert (m_urlifier_stack); | |
| const urlifier_stack_node node = { ptr.release (), true }; | |
| m_urlifier_stack->safe_push (node); | |
| } | |
| void | |
| context::push_borrowed_urlifier (const urlifier &loan) | |
| { | |
| gcc_assert (m_urlifier_stack); | |
| const urlifier_stack_node node = { const_cast <urlifier *> (&loan), false }; | |
| m_urlifier_stack->safe_push (node); | |
| } | |
| void | |
| context::pop_urlifier () | |
| { | |
| gcc_assert (m_urlifier_stack); | |
| gcc_assert (m_urlifier_stack->length () > 0); | |
| const urlifier_stack_node node = m_urlifier_stack->pop (); | |
| if (node.m_owned) | |
| delete node.m_urlifier; | |
| } | |
| const logical_locations::manager * | |
| context::get_logical_location_manager () const | |
| { | |
| if (!m_client_data_hooks) | |
| return nullptr; | |
| return m_client_data_hooks->get_logical_location_manager (); | |
| } | |
| const urlifier * | |
| context::get_urlifier () const | |
| { | |
| if (!m_urlifier_stack) | |
| return nullptr; | |
| if (m_urlifier_stack->is_empty ()) | |
| return nullptr; | |
| return m_urlifier_stack->last ().m_urlifier; | |
| } | |
| /* Set PP as the reference printer for this context. | |
| Refresh all output sinks. */ | |
| void | |
| context::set_pretty_printer (std::unique_ptr<pretty_printer> pp) | |
| { | |
| delete m_reference_printer; | |
| m_reference_printer = pp.release (); | |
| refresh_output_sinks (); | |
| } | |
| /* Give all output sinks a chance to rebuild their pretty_printer. */ | |
| void | |
| context::refresh_output_sinks () | |
| { | |
| for (auto sink_ : m_sinks) | |
| sink_->update_printer (); | |
| } | |
| /* Set FORMAT_DECODER on the reference printer and on the pretty_printer | |
| of all output sinks. */ | |
| void | |
| context::set_format_decoder (printer_fn format_decoder) | |
| { | |
| pp_format_decoder (m_reference_printer) = format_decoder; | |
| for (auto sink_ : m_sinks) | |
| pp_format_decoder (sink_->get_printer ()) = format_decoder; | |
| } | |
| void | |
| context::set_show_highlight_colors (bool val) | |
| { | |
| pp_show_highlight_colors (m_reference_printer) = val; | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| pp_show_highlight_colors (sink_->get_printer ()) = val; | |
| } | |
| void | |
| context::set_prefixing_rule (diagnostic_prefixing_rule_t rule) | |
| { | |
| pp_prefixing_rule (m_reference_printer) = rule; | |
| for (auto sink_ : m_sinks) | |
| if (sink_->follows_reference_printer_p ()) | |
| pp_prefixing_rule (sink_->get_printer ()) = rule; | |
| } | |
| void | |
| context::initialize_fixits_change_set () | |
| { | |
| delete m_fixits_change_set; | |
| gcc_assert (m_file_cache); | |
| m_fixits_change_set = new changes::change_set (*m_file_cache); | |
| } | |
| // class client_data_hooks | |
| void | |
| client_data_hooks::dump (FILE *outfile, int indent) const | |
| { | |
| dumping::emit_heading (outfile, indent, "logical location manager"); | |
| if (auto mgr = get_logical_location_manager ()) | |
| mgr->dump (outfile, indent + 2); | |
| else | |
| dumping::emit_none (outfile, indent + 2); | |
| } | |
| } // namespace diagnostics | |
| /* Initialize DIAGNOSTIC, where the message MSG has already been | |
| translated. */ | |
| void | |
| diagnostic_set_info_translated (diagnostics::diagnostic_info *diagnostic, | |
| const char *msg, va_list *args, | |
| rich_location *richloc, | |
| enum diagnostics::kind kind) | |
| { | |
| gcc_assert (richloc); | |
| diagnostic->m_message.m_err_no = errno; | |
| diagnostic->m_message.m_args_ptr = args; | |
| diagnostic->m_message.m_format_spec = msg; | |
| diagnostic->m_message.m_richloc = richloc; | |
| diagnostic->m_richloc = richloc; | |
| diagnostic->m_metadata = nullptr; | |
| diagnostic->m_kind = kind; | |
| diagnostic->m_option_id = 0; | |
| } | |
| /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been | |
| translated. */ | |
| void | |
| diagnostic_set_info (diagnostics::diagnostic_info *diagnostic, | |
| const char *gmsgid, va_list *args, | |
| rich_location *richloc, | |
| enum diagnostics::kind kind) | |
| { | |
| gcc_assert (richloc); | |
| diagnostic_set_info_translated (diagnostic, _(gmsgid), args, richloc, kind); | |
| } | |
| namespace diagnostics { | |
| static const char *const diagnostic_kind_text[] = { | |
| #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T), | |
| #include "diagnostics/kinds.def" | |
| #undef DEFINE_DIAGNOSTIC_KIND | |
| "must-not-happen" | |
| }; | |
| /* Get unlocalized string describing KIND. */ | |
| const char * | |
| get_text_for_kind (enum kind kind) | |
| { | |
| return diagnostic_kind_text[static_cast<int> (kind)]; | |
| } | |
| static const char *const diagnostic_kind_debug_text[] = { | |
| #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (#K), | |
| #include "diagnostics/kinds.def" | |
| #undef DEFINE_DIAGNOSTIC_KIND | |
| "must-not-happen" | |
| }; | |
| const char * | |
| get_debug_string_for_kind (enum kind kind) | |
| { | |
| return diagnostic_kind_debug_text[static_cast<int> (kind)]; | |
| } | |
| static const char *const diagnostic_kind_color[] = { | |
| #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C), | |
| #include "diagnostics/kinds.def" | |
| #undef DEFINE_DIAGNOSTIC_KIND | |
| nullptr | |
| }; | |
| /* Get a color name for diagnostics of type KIND | |
| Result could be nullptr. */ | |
| const char * | |
| get_color_for_kind (enum kind kind) | |
| { | |
| return diagnostic_kind_color[static_cast<int> (kind)]; | |
| } | |
| /* Given an expanded_location, convert the column (which is in 1-based bytes) | |
| to the requested units, without converting the origin. | |
| Return -1 if the column is invalid (<= 0). */ | |
| static int | |
| convert_column_unit (file_cache &fc, | |
| enum diagnostics_column_unit column_unit, | |
| int tabstop, | |
| expanded_location s) | |
| { | |
| if (s.column <= 0) | |
| return -1; | |
| switch (column_unit) | |
| { | |
| default: | |
| gcc_unreachable (); | |
| case DIAGNOSTICS_COLUMN_UNIT_DISPLAY: | |
| { | |
| cpp_char_column_policy policy (tabstop, cpp_wcwidth); | |
| return location_compute_display_column (fc, s, policy); | |
| } | |
| case DIAGNOSTICS_COLUMN_UNIT_BYTE: | |
| return s.column; | |
| } | |
| } | |
| /* Given an expanded_location, convert the column (which is in 1-based bytes) | |
| to the requested units and origin. Return -1 if the column is | |
| invalid (<= 0). */ | |
| int | |
| column_options::convert_column (file_cache &fc, | |
| expanded_location s) const | |
| { | |
| int one_based_col = convert_column_unit (fc, m_column_unit, m_tabstop, s); | |
| if (one_based_col <= 0) | |
| return -1; | |
| return one_based_col + (m_column_origin - 1); | |
| } | |
| column_policy::column_policy (const context &dc) | |
| : m_file_cache (dc.get_file_cache ()), | |
| m_column_options (dc.get_column_options ()) | |
| { | |
| } | |
| /* Given an expanded_location, convert the column (which is in 1-based bytes) | |
| to the requested units and origin. Return -1 if the column is | |
| invalid (<= 0). */ | |
| int | |
| column_policy::converted_column (expanded_location s) const | |
| { | |
| return m_column_options.convert_column (m_file_cache, s); | |
| } | |
| /* Return a string describing a location e.g. "foo.c:42:10". */ | |
| label_text | |
| column_policy::get_location_text (const expanded_location &s, | |
| bool show_column, | |
| bool colorize) const | |
| { | |
| const char *locus_cs = colorize_start (colorize, "locus"); | |
| const char *locus_ce = colorize_stop (colorize); | |
| const char *file = s.file ? s.file : progname; | |
| int line = 0; | |
| int col = -1; | |
| if (strcmp (file, special_fname_builtin ())) | |
| { | |
| line = s.line; | |
| if (show_column) | |
| col = converted_column (s); | |
| } | |
| const char *line_col = text_sink::maybe_line_and_column (line, col); | |
| return label_text::take (build_message_string ("%s%s%s:%s", locus_cs, file, | |
| line_col, locus_ce)); | |
| } | |
| location_print_policy:: | |
| location_print_policy (const context &dc) | |
| : m_column_policy (dc), | |
| m_show_column (dc.m_show_column) | |
| { | |
| } | |
| location_print_policy:: | |
| location_print_policy (const text_sink &text_output) | |
| : | |
| m_column_policy (text_output.get_context ()), | |
| m_show_column (text_output.get_context ().m_show_column) | |
| { | |
| } | |
| } // namespace diagnostics | |
| /* Functions at which to stop the backtrace print. It's not | |
| particularly helpful to print the callers of these functions. */ | |
| static const char * const bt_stop[] = | |
| { | |
| "main", | |
| "toplev::main", | |
| "execute_one_pass", | |
| "compile_file", | |
| }; | |
| /* A callback function passed to the backtrace_full function. */ | |
| static int | |
| bt_callback (void *data, uintptr_t pc, const char *filename, int lineno, | |
| const char *function) | |
| { | |
| int *pcount = (int *) data; | |
| /* If we don't have any useful information, don't print | |
| anything. */ | |
| if (filename == nullptr && function == nullptr) | |
| return 0; | |
| /* Skip functions in context.cc. */ | |
| if (*pcount == 0 | |
| && filename != nullptr | |
| && strcmp (lbasename (filename), "context.cc") == 0) | |
| return 0; | |
| /* Print up to 20 functions. We could make this a --param, but | |
| since this is only for debugging just use a constant for now. */ | |
| if (*pcount >= 20) | |
| { | |
| /* Returning a non-zero value stops the backtrace. */ | |
| return 1; | |
| } | |
| ++*pcount; | |
| char *alc = nullptr; | |
| if (function != nullptr) | |
| { | |
| char *str = cplus_demangle_v3 (function, | |
| (DMGL_VERBOSE | DMGL_ANSI | |
| | DMGL_GNU_V3 | DMGL_PARAMS)); | |
| if (str != nullptr) | |
| { | |
| alc = str; | |
| function = str; | |
| } | |
| for (size_t i = 0; i < ARRAY_SIZE (bt_stop); ++i) | |
| { | |
| size_t len = strlen (bt_stop[i]); | |
| if (strncmp (function, bt_stop[i], len) == 0 | |
| && (function[len] == '\0' || function[len] == '(')) | |
| { | |
| if (alc != nullptr) | |
| free (alc); | |
| /* Returning a non-zero value stops the backtrace. */ | |
| return 1; | |
| } | |
| } | |
| } | |
| fprintf (stderr, "0x%lx %s\n\t%s:%d\n", | |
| (unsigned long) pc, | |
| function == nullptr ? "???" : function, | |
| filename == nullptr ? "???" : filename, | |
| lineno); | |
| if (alc != nullptr) | |
| free (alc); | |
| return 0; | |
| } | |
| /* A callback function passed to the backtrace_full function. This is | |
| called if backtrace_full has an error. */ | |
| static void | |
| bt_err_callback (void *data ATTRIBUTE_UNUSED, const char *msg, int errnum) | |
| { | |
| if (errnum < 0) | |
| { | |
| /* This means that no debug info was available. Just quietly | |
| skip printing backtrace info. */ | |
| return; | |
| } | |
| fprintf (stderr, "%s%s%s\n", msg, errnum == 0 ? "" : ": ", | |
| errnum == 0 ? "" : xstrerror (errnum)); | |
| } | |
| namespace diagnostics { | |
| /* Check if we've met the maximum error limit, and if so fatally exit | |
| with a message. | |
| FLUSH indicates whether a diagnostics::context::finish call is needed. */ | |
| void | |
| context::check_max_errors (bool flush) | |
| { | |
| if (!m_max_errors) | |
| return; | |
| int count = (diagnostic_count (kind::error) | |
| + diagnostic_count (kind::sorry) | |
| + diagnostic_count (kind::werror)); | |
| if (count >= m_max_errors) | |
| { | |
| fnotice (stderr, | |
| "compilation terminated due to -fmax-errors=%u.\n", | |
| m_max_errors); | |
| if (flush) | |
| finish (); | |
| exit (FATAL_EXIT_CODE); | |
| } | |
| } | |
| /* Take any action which is expected to happen after the diagnostic | |
| is written out. This function does not always return. */ | |
| void | |
| context::action_after_output (enum kind diag_kind) | |
| { | |
| switch (diag_kind) | |
| { | |
| case kind::debug: | |
| case kind::note: | |
| case kind::anachronism: | |
| case kind::warning: | |
| break; | |
| case kind::error: | |
| case kind::sorry: | |
| if (m_abort_on_error) | |
| real_abort (); | |
| if (m_fatal_errors) | |
| { | |
| fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n"); | |
| finish (); | |
| exit (FATAL_EXIT_CODE); | |
| } | |
| break; | |
| case kind::ice: | |
| case kind::ice_nobt: | |
| { | |
| /* Attempt to ensure that any outputs are flushed e.g. that .sarif | |
| files are written out. | |
| Only do it once. */ | |
| static char **saved_argv = nullptr; | |
| if (!saved_argv) | |
| { | |
| saved_argv = m_original_argv; | |
| m_original_argv = nullptr; | |
| finish (); | |
| } | |
| struct backtrace_state *state = nullptr; | |
| if (diag_kind == kind::ice) | |
| state = backtrace_create_state (nullptr, 0, bt_err_callback, nullptr); | |
| int count = 0; | |
| if (state != nullptr) | |
| backtrace_full (state, 2, bt_callback, bt_err_callback, | |
| (void *) &count); | |
| if (m_abort_on_error) | |
| real_abort (); | |
| bool space = false; | |
| for (auto *argv = saved_argv; *argv; space = true) | |
| fnotice (stderr, &" %s"[1 - space], *argv++); | |
| fnotice (stderr, "\n"); | |
| freeargv (saved_argv); | |
| if (m_report_bug) | |
| fnotice (stderr, "Please submit a full bug report, " | |
| "with preprocessed source.\n"); | |
| else | |
| fnotice (stderr, "Please submit a full bug report, " | |
| "with preprocessed source (by using -freport-bug).\n"); | |
| if (count > 0) | |
| fnotice (stderr, "Please include the complete backtrace " | |
| "with any bug report.\n"); | |
| fnotice (stderr, "See %s for instructions.\n", bug_report_url); | |
| exit (ICE_EXIT_CODE); | |
| } | |
| case kind::fatal: | |
| if (m_abort_on_error) | |
| real_abort (); | |
| fnotice (stderr, "compilation terminated.\n"); | |
| finish (); | |
| exit (FATAL_EXIT_CODE); | |
| default: | |
| gcc_unreachable (); | |
| } | |
| } | |
| /* State whether we should inhibit notes in the current diagnostic_group and | |
| its future children if any. */ | |
| void | |
| context::inhibit_notes_in_group (bool inhibit) | |
| { | |
| int curr_depth = (m_diagnostic_groups.m_group_nesting_depth | |
| + m_diagnostic_groups.m_diagnostic_nesting_level); | |
| if (inhibit) | |
| { | |
| /* If we're already inhibiting, there's nothing to do. */ | |
| if (m_diagnostic_groups.m_inhibiting_notes_from) | |
| return; | |
| /* Since we're called via warning/error/... that all have their own | |
| diagnostic_group, we must consider that we started inhibiting in their | |
| parent. */ | |
| gcc_assert (m_diagnostic_groups.m_group_nesting_depth > 0); | |
| m_diagnostic_groups.m_inhibiting_notes_from = curr_depth - 1; | |
| } | |
| else if (m_diagnostic_groups.m_inhibiting_notes_from) | |
| { | |
| /* Only cancel inhibition at the depth that set it up. */ | |
| if (curr_depth >= m_diagnostic_groups.m_inhibiting_notes_from) | |
| return; | |
| m_diagnostic_groups.m_inhibiting_notes_from = 0; | |
| } | |
| } | |
| /* Return whether notes must be inhibited in the current diagnostic_group. */ | |
| bool | |
| context::notes_inhibited_in_group () const | |
| { | |
| if (m_diagnostic_groups.m_inhibiting_notes_from | |
| && (m_diagnostic_groups.m_group_nesting_depth | |
| + m_diagnostic_groups.m_diagnostic_nesting_level | |
| >= m_diagnostic_groups.m_inhibiting_notes_from)) | |
| return true; | |
| return false; | |
| } | |
| /* class diagnostics::logical_locations::manager. */ | |
| /* Return true iff this is a function or method. */ | |
| bool | |
| logical_locations::manager::function_p (key k) const | |
| { | |
| switch (get_kind (k)) | |
| { | |
| default: | |
| gcc_unreachable (); | |
| case kind::unknown: | |
| case kind::module_: | |
| case kind::namespace_: | |
| case kind::type: | |
| case kind::return_type: | |
| case kind::parameter: | |
| case kind::variable: | |
| return false; | |
| case kind::function: | |
| case kind::member: | |
| return true; | |
| } | |
| } | |
| /* Helper function for print_parseable_fixits. Print TEXT to PP, obeying the | |
| escaping rules for -fdiagnostics-parseable-fixits. */ | |
| static void | |
| print_escaped_string (pretty_printer *pp, const char *text) | |
| { | |
| gcc_assert (pp); | |
| gcc_assert (text); | |
| pp_character (pp, '"'); | |
| for (const char *ch = text; *ch; ch++) | |
| { | |
| switch (*ch) | |
| { | |
| case '\\': | |
| /* Escape backslash as two backslashes. */ | |
| pp_string (pp, "\\\\"); | |
| break; | |
| case '\t': | |
| /* Escape tab as "\t". */ | |
| pp_string (pp, "\\t"); | |
| break; | |
| case '\n': | |
| /* Escape newline as "\n". */ | |
| pp_string (pp, "\\n"); | |
| break; | |
| case '"': | |
| /* Escape doublequotes as \". */ | |
| pp_string (pp, "\\\""); | |
| break; | |
| default: | |
| if (ISPRINT (*ch)) | |
| pp_character (pp, *ch); | |
| else | |
| /* Use octal for non-printable chars. */ | |
| { | |
| unsigned char c = (*ch & 0xff); | |
| pp_printf (pp, "\\%o%o%o", (c / 64), (c / 8) & 007, c & 007); | |
| } | |
| break; | |
| } | |
| } | |
| pp_character (pp, '"'); | |
| } | |
| /* Implementation of -fdiagnostics-parseable-fixits and | |
| GCC_EXTRA_DIAGNOSTIC_OUTPUT. | |
| Print a machine-parseable version of all fixits in RICHLOC to PP, | |
| using COLUMN_UNIT to express columns. | |
| Use TABSTOP when handling DIAGNOSTICS_COLUMN_UNIT_DISPLAY. */ | |
| static void | |
| print_parseable_fixits (file_cache &fc, | |
| pretty_printer *pp, rich_location *richloc, | |
| enum diagnostics_column_unit column_unit, | |
| int tabstop) | |
| { | |
| gcc_assert (pp); | |
| gcc_assert (richloc); | |
| char *saved_prefix = pp_take_prefix (pp); | |
| pp_set_prefix (pp, nullptr); | |
| for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++) | |
| { | |
| const fixit_hint *hint = richloc->get_fixit_hint (i); | |
| location_t start_loc = hint->get_start_loc (); | |
| expanded_location start_exploc = expand_location (start_loc); | |
| pp_string (pp, "fix-it:"); | |
| print_escaped_string (pp, start_exploc.file); | |
| /* For compatibility with clang, print as a half-open range. */ | |
| location_t next_loc = hint->get_next_loc (); | |
| expanded_location next_exploc = expand_location (next_loc); | |
| int start_col | |
| = convert_column_unit (fc, column_unit, tabstop, start_exploc); | |
| int next_col | |
| = convert_column_unit (fc, column_unit, tabstop, next_exploc); | |
| pp_printf (pp, ":{%i:%i-%i:%i}:", | |
| start_exploc.line, start_col, | |
| next_exploc.line, next_col); | |
| print_escaped_string (pp, hint->get_string ()); | |
| pp_newline (pp); | |
| } | |
| pp_set_prefix (pp, saved_prefix); | |
| } | |
| /* Update the inlining info in this context for a DIAGNOSTIC. */ | |
| void | |
| context::get_any_inlining_info (diagnostic_info *diagnostic) | |
| { | |
| auto &ilocs = diagnostic->m_iinfo.m_ilocs; | |
| if (m_set_locations_cb) | |
| /* Retrieve the locations into which the expression about to be | |
| diagnosed has been inlined, including those of all the callers | |
| all the way down the inlining stack. */ | |
| m_set_locations_cb (*this, diagnostic); | |
| else | |
| { | |
| /* When there's no callback use just the one location provided | |
| by the caller of the diagnostic function. */ | |
| location_t loc = diagnostic_location (diagnostic); | |
| ilocs.safe_push (loc); | |
| diagnostic->m_iinfo.m_allsyslocs = in_system_header_at (loc); | |
| } | |
| } | |
| /* Generate a URL string describing CWE. The caller is responsible for | |
| freeing the string. */ | |
| char * | |
| get_cwe_url (int cwe) | |
| { | |
| return xasprintf ("https://cwe.mitre.org/data/definitions/%i.html", cwe); | |
| } | |
| /* Returns whether a DIAGNOSTIC should be printed, and adjusts diagnostic->kind | |
| as appropriate for #pragma GCC diagnostic and -Werror=foo. */ | |
| bool | |
| context::diagnostic_enabled (diagnostic_info *diagnostic) | |
| { | |
| /* Update the inlining stack for this diagnostic. */ | |
| get_any_inlining_info (diagnostic); | |
| /* Diagnostics with no option or -fpermissive are always enabled. */ | |
| if (!diagnostic->m_option_id.m_idx | |
| || diagnostic->m_option_id == m_opt_permissive) | |
| return true; | |
| /* This tests if the user provided the appropriate -Wfoo or | |
| -Wno-foo option. */ | |
| if (!option_enabled_p (diagnostic->m_option_id)) | |
| return false; | |
| /* This tests for #pragma diagnostic changes. */ | |
| enum kind diag_class | |
| = m_option_classifier.update_effective_level_from_pragmas (diagnostic); | |
| /* This tests if the user provided the appropriate -Werror=foo | |
| option. */ | |
| if (diag_class == kind::unspecified | |
| && !option_unspecified_p (diagnostic->m_option_id)) | |
| { | |
| const enum kind new_kind | |
| = m_option_classifier.get_current_override (diagnostic->m_option_id); | |
| if (new_kind != kind::any) | |
| /* kind::any means the diagnostic is not to be ignored, but we don't want | |
| to change it specifically to kind::error or kind::warning; we want to | |
| preserve whatever the caller has specified. */ | |
| diagnostic->m_kind = new_kind; | |
| } | |
| /* This allows for future extensions, like temporarily disabling | |
| warnings for ranges of source code. */ | |
| if (diagnostic->m_kind == kind::ignored) | |
| return false; | |
| return true; | |
| } | |
| /* Returns whether warning OPT_ID is enabled at LOC. */ | |
| bool | |
| context::warning_enabled_at (location_t loc, | |
| option_id opt_id) | |
| { | |
| if (!diagnostic_report_warnings_p (this, loc)) | |
| return false; | |
| rich_location richloc (line_table, loc); | |
| diagnostic_info diagnostic = {}; | |
| diagnostic.m_option_id = opt_id; | |
| diagnostic.m_richloc = &richloc; | |
| diagnostic.m_message.m_richloc = &richloc; | |
| diagnostic.m_kind = kind::warning; | |
| return diagnostic_enabled (&diagnostic); | |
| } | |
| /* Emit a diagnostic within a diagnostic group on this context. */ | |
| bool | |
| context::emit_diagnostic_with_group (enum kind kind, | |
| rich_location &richloc, | |
| const metadata *metadata, | |
| option_id opt_id, | |
| const char *gmsgid, ...) | |
| { | |
| begin_group (); | |
| va_list ap; | |
| va_start (ap, gmsgid); | |
| bool ret = emit_diagnostic_with_group_va (kind, richloc, metadata, opt_id, | |
| gmsgid, &ap); | |
| va_end (ap); | |
| end_group (); | |
| return ret; | |
| } | |
| /* As above, but taking a va_list *. */ | |
| bool | |
| context::emit_diagnostic_with_group_va (enum kind kind, | |
| rich_location &richloc, | |
| const metadata *metadata, | |
| option_id opt_id, | |
| const char *gmsgid, va_list *ap) | |
| { | |
| begin_group (); | |
| bool ret = diagnostic_impl (&richloc, metadata, opt_id, | |
| gmsgid, ap, kind); | |
| end_group (); | |
| return ret; | |
| } | |
| /* Report a diagnostic message (an error or a warning) as specified by | |
| this diagnostics::context. | |
| front-end independent format specifiers are exactly those described | |
| in the documentation of output_format. | |
| Return true if a diagnostic was printed, false otherwise. */ | |
| bool | |
| context::report_diagnostic (diagnostic_info *diagnostic) | |
| { | |
| auto logger = get_logger (); | |
| DIAGNOSTICS_LOG_SCOPE_PRINTF0 (logger, "diagnostics::context::report_diagnostic"); | |
| enum kind orig_diag_kind = diagnostic->m_kind; | |
| /* Every call to report_diagnostic should be within a | |
| begin_group/end_group pair so that output formats can reliably | |
| flush diagnostics with on_end_group when the topmost group is ended. */ | |
| gcc_assert (m_diagnostic_groups.m_group_nesting_depth > 0); | |
| /* Give preference to being able to inhibit warnings, before they | |
| get reclassified to something else. */ | |
| bool was_warning = (diagnostic->m_kind == kind::warning | |
| || diagnostic->m_kind == kind::pedwarn); | |
| if (was_warning && m_inhibit_warnings) | |
| { | |
| inhibit_notes_in_group (); | |
| if (m_logger) | |
| m_logger->log_printf ("rejecting: inhibiting warnings"); | |
| return false; | |
| } | |
| if (m_adjust_diagnostic_info) | |
| m_adjust_diagnostic_info (*this, diagnostic); | |
| if (diagnostic->m_kind == kind::pedwarn) | |
| { | |
| diagnostic->m_kind = m_pedantic_errors ? kind::error : kind::warning; | |
| /* We do this to avoid giving the message for -pedantic-errors. */ | |
| orig_diag_kind = diagnostic->m_kind; | |
| } | |
| if (diagnostic->m_kind == kind::note && m_inhibit_notes_p) | |
| { | |
| if (m_logger) | |
| m_logger->log_printf ("rejecting: inhibiting notes"); | |
| return false; | |
| } | |
| /* If the user requested that warnings be treated as errors, so be | |
| it. Note that we do this before the next block so that | |
| individual warnings can be overridden back to warnings with | |
| -Wno-error=*. */ | |
| if (m_warning_as_error_requested | |
| && diagnostic->m_kind == kind::warning) | |
| diagnostic->m_kind = kind::error; | |
| diagnostic->m_message.m_data = &diagnostic->m_x_data; | |
| /* Check to see if the diagnostic is enabled at the location and | |
| not disabled by #pragma GCC diagnostic anywhere along the inlining | |
| stack. . */ | |
| if (!diagnostic_enabled (diagnostic)) | |
| { | |
| if (m_logger) | |
| m_logger->log_printf ("rejecting: diagnostic not enabled"); | |
| inhibit_notes_in_group (); | |
| return false; | |
| } | |
| if ((was_warning || diagnostic->m_kind == kind::warning) | |
| && ((!m_warn_system_headers | |
| && diagnostic->m_iinfo.m_allsyslocs) | |
| || m_inhibit_warnings)) | |
| { | |
| /* Bail if the warning is not to be reported because all locations in the | |
| inlining stack (if there is one) are in system headers. */ | |
| if (m_logger) | |
| m_logger->log_printf ("rejecting: warning in system header"); | |
| return false; | |
| } | |
| if (diagnostic->m_kind == kind::note && notes_inhibited_in_group ()) | |
| { | |
| /* Bail for all the notes in the diagnostic_group that started to inhibit notes. */ | |
| if (m_logger) | |
| m_logger->log_printf ("rejecting: notes inhibited within group"); | |
| return false; | |
| } | |
| if (diagnostic->m_kind != kind::note && diagnostic->m_kind != kind::ice) | |
| check_max_errors (false); | |
| if (m_lock > 0) | |
| { | |
| /* If we're reporting an ICE in the middle of some other error, | |
| try to flush out the previous error, then let this one | |
| through. Don't do this more than once. */ | |
| if ((diagnostic->m_kind == kind::ice | |
| || diagnostic->m_kind == kind::ice_nobt) | |
| && m_lock == 1) | |
| pp_newline_and_flush (m_reference_printer); | |
| else | |
| error_recursion (); | |
| } | |
| /* We are accepting the diagnostic, so should stop inhibiting notes. */ | |
| inhibit_notes_in_group (/*inhibit=*/false); | |
| m_lock++; | |
| if (diagnostic->m_kind == kind::ice || diagnostic->m_kind == kind::ice_nobt) | |
| { | |
| /* When not checking, ICEs are converted to fatal errors when an | |
| error has already occurred. This is counteracted by | |
| abort_on_error. */ | |
| if (!CHECKING_P | |
| && (diagnostic_count (kind::error) > 0 | |
| || diagnostic_count (kind::sorry) > 0) | |
| && !m_abort_on_error) | |
| { | |
| expanded_location s | |
| = expand_location (diagnostic_location (diagnostic)); | |
| fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n", | |
| s.file, s.line); | |
| exit (ICE_EXIT_CODE); | |
| } | |
| if (m_internal_error) | |
| (*m_internal_error) (this, | |
| diagnostic->m_message.m_format_spec, | |
| diagnostic->m_message.m_args_ptr); | |
| } | |
| /* Increment the counter for the appropriate diagnostic kind, either | |
| within this context, or within the diagnostic_buffer. */ | |
| { | |
| const enum kind kind_for_count = | |
| ((diagnostic->m_kind == kind::error && orig_diag_kind == kind::warning) | |
| ? kind::werror | |
| : diagnostic->m_kind); | |
| counters &cs | |
| = (m_diagnostic_buffer | |
| ? m_diagnostic_buffer->m_diagnostic_counters | |
| : m_diagnostic_counters); | |
| ++cs.m_count_for_kind[static_cast<size_t> (kind_for_count)]; | |
| } | |
| /* Is this the initial diagnostic within the stack of groups? */ | |
| if (m_diagnostic_groups.m_emission_count == 0) | |
| { | |
| DIAGNOSTICS_LOG_SCOPE_PRINTF0 | |
| (get_logger (), | |
| "diagnostics::context: beginning group"); | |
| for (auto sink_ : m_sinks) | |
| sink_->on_begin_group (); | |
| } | |
| m_diagnostic_groups.m_emission_count++; | |
| va_list *orig_args = diagnostic->m_message.m_args_ptr; | |
| for (auto sink_ : m_sinks) | |
| { | |
| /* Formatting the message is done per-diagnostic-sink | |
| so that each diagnostic sink gets its own set of pp_token_lists | |
| to work with. | |
| Run phases 1 and 2 of formatting the message before calling | |
| the sink's on_report_diagnostic. | |
| In particular, some format codes may have side-effects here which | |
| need to happen before sending the diagnostic to the diagnostic sink. | |
| For example, Fortran's %C and %L formatting codes populate the | |
| rich_location. | |
| Such side-effects must be idempotent, since they are run per | |
| diagnostic sink. | |
| Make a duplicate of the varargs for each call to pp_format, | |
| so that each sink has its own set to consume. */ | |
| va_list copied_args; | |
| va_copy (copied_args, *orig_args); | |
| diagnostic->m_message.m_args_ptr = &copied_args; | |
| pp_format (sink_->get_printer (), &diagnostic->m_message); | |
| va_end (copied_args); | |
| /* Call vfunc in the diagnostic sink. This is responsible for | |
| phase 3 of formatting, and for printing the result. */ | |
| sink_->on_report_diagnostic (*diagnostic, orig_diag_kind); | |
| } | |
| const int tabstop = get_column_options ().m_tabstop; | |
| switch (m_extra_output_kind) | |
| { | |
| default: | |
| break; | |
| case EXTRA_DIAGNOSTIC_OUTPUT_fixits_v1: | |
| print_parseable_fixits (get_file_cache (), | |
| m_reference_printer, diagnostic->m_richloc, | |
| DIAGNOSTICS_COLUMN_UNIT_BYTE, | |
| tabstop); | |
| pp_flush (m_reference_printer); | |
| break; | |
| case EXTRA_DIAGNOSTIC_OUTPUT_fixits_v2: | |
| print_parseable_fixits (get_file_cache (), | |
| m_reference_printer, diagnostic->m_richloc, | |
| DIAGNOSTICS_COLUMN_UNIT_DISPLAY, | |
| tabstop); | |
| pp_flush (m_reference_printer); | |
| break; | |
| } | |
| if (m_diagnostic_buffer == nullptr | |
| || diagnostic->m_kind == kind::ice | |
| || diagnostic->m_kind == kind::ice_nobt) | |
| action_after_output (diagnostic->m_kind); | |
| diagnostic->m_x_data = nullptr; | |
| if (m_fixits_change_set) | |
| if (diagnostic->m_richloc->fixits_can_be_auto_applied_p ()) | |
| if (!m_diagnostic_buffer) | |
| m_fixits_change_set->add_fixits (diagnostic->m_richloc); | |
| m_lock--; | |
| if (!m_diagnostic_buffer) | |
| for (auto sink_ : m_sinks) | |
| sink_->after_diagnostic (*diagnostic); | |
| return true; | |
| } | |
| void | |
| context::report_verbatim (text_info &text) | |
| { | |
| va_list *orig_args = text.m_args_ptr; | |
| for (auto sink_ : m_sinks) | |
| { | |
| va_list copied_args; | |
| va_copy (copied_args, *orig_args); | |
| text.m_args_ptr = &copied_args; | |
| sink_->on_report_verbatim (text); | |
| va_end (copied_args); | |
| } | |
| } | |
| void | |
| context::report_global_digraph (const lazily_created<digraphs::digraph> &ldg) | |
| { | |
| for (auto sink_ : m_sinks) | |
| sink_->report_global_digraph (ldg); | |
| } | |
| /* Get the number of digits in the decimal representation of VALUE. */ | |
| int | |
| num_digits (uint64_t value) | |
| { | |
| /* Perhaps simpler to use log10 for this, but doing it this way avoids | |
| using floating point. */ | |
| if (value == 0) | |
| return 1; | |
| int digits = 0; | |
| while (value > 0) | |
| { | |
| digits++; | |
| value /= 10; | |
| } | |
| return digits; | |
| } | |
| } // namespace diagnostics | |
| /* Given a partial pathname as input, return another pathname that | |
| shares no directory elements with the pathname of __FILE__. This | |
| is used by fancy_abort() to print `internal compiler error in expr.cc' | |
| instead of `internal compiler error in ../../GCC/gcc/expr.cc'. */ | |
| const char * | |
| trim_filename (const char *name) | |
| { | |
| static const char this_file[] = __FILE__; | |
| const char *p = name, *q = this_file; | |
| /* First skip any "../" in each filename. This allows us to give a proper | |
| reference to a file in a subdirectory. */ | |
| while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2])) | |
| p += 3; | |
| while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2])) | |
| q += 3; | |
| /* Now skip any parts the two filenames have in common. */ | |
| while (*p == *q && *p != 0 && *q != 0) | |
| p++, q++; | |
| /* Now go backwards until the previous directory separator. */ | |
| while (p > name && !IS_DIR_SEPARATOR (p[-1])) | |
| p--; | |
| return p; | |
| } | |
| namespace diagnostics { | |
| /* Implement emit_diagnostic, inform, warning, warning_at, pedwarn, | |
| permerror, error, error_at, error_at, sorry, fatal_error, internal_error, | |
| and internal_error_no_backtrace, as documented and defined below. */ | |
| bool | |
| context::diagnostic_impl (rich_location *richloc, | |
| const metadata *metadata, | |
| option_id opt_id, | |
| const char *gmsgid, | |
| va_list *ap, enum kind kind) | |
| { | |
| logging::log_function_params | |
| (m_logger, "diagnostics::context::diagnostic_impl") | |
| .log_param_option_id ("option_id", opt_id) | |
| .log_param_kind ("kind", kind) | |
| .log_param_string ("gmsgid", gmsgid); | |
| logging::auto_inc_depth depth_sentinel (m_logger); | |
| diagnostic_info diagnostic; | |
| if (kind == diagnostics::kind::permerror) | |
| { | |
| diagnostic_set_info (&diagnostic, gmsgid, ap, richloc, | |
| (m_permissive | |
| ? diagnostics::kind::warning | |
| : diagnostics::kind::error)); | |
| diagnostic.m_option_id = (opt_id.m_idx != -1 ? opt_id : m_opt_permissive); | |
| } | |
| else | |
| { | |
| diagnostic_set_info (&diagnostic, gmsgid, ap, richloc, kind); | |
| if (kind == diagnostics::kind::warning | |
| || kind == diagnostics::kind::pedwarn) | |
| diagnostic.m_option_id = opt_id; | |
| } | |
| diagnostic.m_metadata = metadata; | |
| bool ret = report_diagnostic (&diagnostic); | |
| if (m_logger) | |
| m_logger->log_bool_return ("diagnostics::context::diagnostic_impl", ret); | |
| return ret; | |
| } | |
| /* Implement inform_n, warning_n, and error_n, as documented and | |
| defined below. */ | |
| bool | |
| context::diagnostic_n_impl (rich_location *richloc, | |
| const metadata *metadata, | |
| option_id opt_id, | |
| unsigned HOST_WIDE_INT n, | |
| const char *singular_gmsgid, | |
| const char *plural_gmsgid, | |
| va_list *ap, enum kind kind) | |
| { | |
| logging::log_function_params | |
| (m_logger, "diagnostics::context::diagnostic_n_impl") | |
| .log_param_option_id ("option_id", opt_id) | |
| .log_param_kind ("kind", kind) | |
| .log_params_n_gmsgids (n, singular_gmsgid, plural_gmsgid); | |
| logging::auto_inc_depth depth_sentinel (m_logger); | |
| diagnostic_info diagnostic; | |
| unsigned long gtn; | |
| if (sizeof n <= sizeof gtn) | |
| gtn = n; | |
| else | |
| /* Use the largest number ngettext can handle, otherwise | |
| preserve the six least significant decimal digits for | |
| languages where the plural form depends on them. */ | |
| gtn = n <= ULONG_MAX ? n : n % 1000000LU + 1000000LU; | |
| const char *text = ngettext (singular_gmsgid, plural_gmsgid, gtn); | |
| diagnostic_set_info_translated (&diagnostic, text, ap, richloc, kind); | |
| if (kind == diagnostics::kind::warning) | |
| diagnostic.m_option_id = opt_id; | |
| diagnostic.m_metadata = metadata; | |
| bool ret = report_diagnostic (&diagnostic); | |
| if (m_logger) | |
| m_logger->log_bool_return ("diagnostics::context::diagnostic_n_impl", ret); | |
| return ret; | |
| } | |
| /* Emit DIAGRAM to this context, respecting the output format. */ | |
| void | |
| context::emit_diagram (const diagram &diag) | |
| { | |
| if (m_diagrams.m_theme == nullptr) | |
| return; | |
| for (auto sink_ : m_sinks) | |
| sink_->on_diagram (diag); | |
| } | |
| /* Inform the user that an error occurred while trying to report some | |
| other error. This indicates catastrophic internal inconsistencies, | |
| so give up now. But do try to flush out the previous error. | |
| This mustn't use internal_error, that will cause infinite recursion. */ | |
| void | |
| context::error_recursion () | |
| { | |
| if (m_lock < 3) | |
| pp_newline_and_flush (m_reference_printer); | |
| fnotice (stderr, | |
| "internal compiler error: error reporting routines re-entered.\n"); | |
| /* Call action_after_output to get the "please submit a bug report" | |
| message. */ | |
| action_after_output (kind::ice); | |
| /* Do not use gcc_unreachable here; that goes through internal_error | |
| and therefore would cause infinite recursion. */ | |
| real_abort (); | |
| } | |
| } // namespace diagnostics | |
| /* Report an internal compiler error in a friendly manner. This is | |
| the function that gets called upon use of abort() in the source | |
| code generally, thanks to a special macro. */ | |
| void | |
| fancy_abort (const char *file, int line, const char *function) | |
| { | |
| /* If fancy_abort is called before the diagnostic subsystem is initialized, | |
| internal_error will crash internally in a way that prevents a | |
| useful message reaching the user. | |
| This can happen with libgccjit in the case of gcc_assert failures | |
| that occur outside of the libgccjit mutex that guards the rest of | |
| gcc's state, including global_dc (when global_dc may not be | |
| initialized yet, or might be in use by another thread). | |
| Handle such cases as gracefully as possible by falling back to a | |
| minimal abort handler that only relies on i18n. */ | |
| if (global_dc->get_reference_printer () == nullptr) | |
| { | |
| /* Print the error message. */ | |
| fnotice (stderr, diagnostics::get_text_for_kind (diagnostics::kind::ice)); | |
| fnotice (stderr, "in %s, at %s:%d", function, trim_filename (file), line); | |
| fputc ('\n', stderr); | |
| /* Attempt to print a backtrace. */ | |
| struct backtrace_state *state | |
| = backtrace_create_state (nullptr, 0, bt_err_callback, nullptr); | |
| int count = 0; | |
| if (state != nullptr) | |
| backtrace_full (state, 2, bt_callback, bt_err_callback, | |
| (void *) &count); | |
| /* We can't call warn_if_plugins or emergency_dump_function as these | |
| rely on GCC state that might not be initialized, or might be in | |
| use by another thread. */ | |
| /* Abort the process. */ | |
| real_abort (); | |
| } | |
| internal_error ("in %s, at %s:%d", function, trim_filename (file), line); | |
| } | |
| namespace diagnostics { | |
| /* class diagnostics::context. */ | |
| void | |
| context::begin_group () | |
| { | |
| m_diagnostic_groups.m_group_nesting_depth++; | |
| } | |
| void | |
| context::end_group () | |
| { | |
| if (--m_diagnostic_groups.m_group_nesting_depth == 0) | |
| { | |
| /* Handle the case where we've popped the final diagnostic group. | |
| If any diagnostics were emitted, give the context a chance | |
| to do something. */ | |
| if (m_diagnostic_groups.m_emission_count > 0) | |
| { | |
| DIAGNOSTICS_LOG_SCOPE_PRINTF0 | |
| (get_logger (), | |
| "diagnostics::context::end_group: ending group"); | |
| for (auto sink_ : m_sinks) | |
| sink_->on_end_group (); | |
| } | |
| m_diagnostic_groups.m_emission_count = 0; | |
| } | |
| /* We're popping one level, so might need to stop inhibiting notes. */ | |
| inhibit_notes_in_group (/*inhibit=*/false); | |
| } | |
| void | |
| context::push_nesting_level () | |
| { | |
| ++m_diagnostic_groups.m_diagnostic_nesting_level; | |
| } | |
| void | |
| context::pop_nesting_level () | |
| { | |
| --m_diagnostic_groups.m_diagnostic_nesting_level; | |
| /* We're popping one level, so might need to stop inhibiting notes. */ | |
| inhibit_notes_in_group (/*inhibit=*/false); | |
| } | |
| void | |
| context::set_nesting_level (int new_level) | |
| { | |
| m_diagnostic_groups.m_diagnostic_nesting_level = new_level; | |
| } | |
| void | |
| sink::dump (FILE *out, int indent) const | |
| { | |
| dumping::emit_heading (out, indent, "printer"); | |
| m_printer->dump (out, indent + 2); | |
| dumping::emit_heading (out, indent, "extensions"); | |
| if (m_extensions.empty ()) | |
| dumping::emit_none (out, indent + 2); | |
| else | |
| for (auto &ext : m_extensions) | |
| ext->dump (out, indent + 2); | |
| } | |
| void | |
| sink::finalize_extensions () | |
| { | |
| for (auto &ext : m_extensions) | |
| ext->finalize (); | |
| } | |
| void | |
| sink::on_report_verbatim (text_info &) | |
| { | |
| /* No-op. */ | |
| } | |
| /* Set the output format for DC to FORMAT, using BASE_FILE_NAME for | |
| file-based output formats. */ | |
| void | |
| output_format_init (context &dc, | |
| const char *main_input_filename_, | |
| const char *base_file_name, | |
| enum diagnostics_output_format format, | |
| bool json_formatting) | |
| { | |
| sink *new_sink = nullptr; | |
| switch (format) | |
| { | |
| default: | |
| gcc_unreachable (); | |
| case DIAGNOSTICS_OUTPUT_FORMAT_TEXT: | |
| /* The default; do nothing. */ | |
| break; | |
| case DIAGNOSTICS_OUTPUT_FORMAT_SARIF_STDERR: | |
| new_sink = &init_sarif_stderr (dc, | |
| line_table, | |
| json_formatting); | |
| break; | |
| case DIAGNOSTICS_OUTPUT_FORMAT_SARIF_FILE: | |
| new_sink = &init_sarif_file (dc, | |
| line_table, | |
| json_formatting, | |
| base_file_name); | |
| break; | |
| } | |
| if (new_sink) | |
| new_sink->set_main_input_filename (main_input_filename_); | |
| } | |
| /* Initialize this context's m_diagrams based on CHARSET. | |
| Specifically, make a text_art::theme object for m_diagrams.m_theme, | |
| (or nullptr for "no diagrams"). */ | |
| void | |
| context::set_text_art_charset (enum diagnostic_text_art_charset charset) | |
| { | |
| delete m_diagrams.m_theme; | |
| switch (charset) | |
| { | |
| default: | |
| gcc_unreachable (); | |
| case DIAGNOSTICS_TEXT_ART_CHARSET_NONE: | |
| m_diagrams.m_theme = nullptr; | |
| break; | |
| case DIAGNOSTICS_TEXT_ART_CHARSET_ASCII: | |
| m_diagrams.m_theme = new text_art::ascii_theme (); | |
| break; | |
| case DIAGNOSTICS_TEXT_ART_CHARSET_UNICODE: | |
| m_diagrams.m_theme = new text_art::unicode_theme (); | |
| break; | |
| case DIAGNOSTICS_TEXT_ART_CHARSET_EMOJI: | |
| m_diagrams.m_theme = new text_art::emoji_theme (); | |
| break; | |
| } | |
| } | |
| /* struct diagnostics::counters. */ | |
| counters::counters () | |
| { | |
| clear (); | |
| } | |
| void | |
| counters::dump (FILE *out, int indent) const | |
| { | |
| dumping::emit_heading (out, indent, "counts"); | |
| bool none = true; | |
| for (int i = 0; i < static_cast<int> (kind::last_diagnostic_kind); i++) | |
| if (m_count_for_kind[i] > 0) | |
| { | |
| dumping::emit_indent (out, indent + 2); | |
| fprintf (out, "%s%i\n", | |
| get_text_for_kind (static_cast<enum kind> (i)), | |
| m_count_for_kind[i]); | |
| none = false; | |
| } | |
| if (none) | |
| dumping::emit_none (out, indent + 2); | |
| } | |
| void | |
| counters::move_to (counters &dest) | |
| { | |
| for (int i = 0; i < static_cast<int> (kind::last_diagnostic_kind); i++) | |
| dest.m_count_for_kind[i] += m_count_for_kind[i]; | |
| clear (); | |
| } | |
| void | |
| counters::clear () | |
| { | |
| memset (&m_count_for_kind, 0, sizeof m_count_for_kind); | |
| } | |
| #if CHECKING_P | |
| namespace selftest { | |
| using line_table_test = ::selftest::line_table_test; | |
| using temp_source_file = ::selftest::temp_source_file; | |
| /* Helper function for test_print_escaped_string. */ | |
| static void | |
| assert_print_escaped_string (const ::selftest::location &loc, | |
| const char *expected_output, | |
| const char *input) | |
| { | |
| pretty_printer pp; | |
| print_escaped_string (&pp, input); | |
| ASSERT_STREQ_AT (loc, expected_output, pp_formatted_text (&pp)); | |
| } | |
| #define ASSERT_PRINT_ESCAPED_STRING_STREQ(EXPECTED_OUTPUT, INPUT) \ | |
| assert_print_escaped_string (SELFTEST_LOCATION, EXPECTED_OUTPUT, INPUT) | |
| /* Tests of print_escaped_string. */ | |
| static void | |
| test_print_escaped_string () | |
| { | |
| /* Empty string. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"\"", ""); | |
| /* Non-empty string. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"hello world\"", "hello world"); | |
| /* Various things that need to be escaped: */ | |
| /* Backslash. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\\after\"", | |
| "before\\after"); | |
| /* Tab. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\tafter\"", | |
| "before\tafter"); | |
| /* Newline. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\nafter\"", | |
| "before\nafter"); | |
| /* Double quote. */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\\"after\"", | |
| "before\"after"); | |
| /* Non-printable characters: BEL: '\a': 0x07 */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\007after\"", | |
| "before\aafter"); | |
| /* Non-printable characters: vertical tab: '\v': 0x0b */ | |
| ASSERT_PRINT_ESCAPED_STRING_STREQ ("\"before\\013after\"", | |
| "before\vafter"); | |
| } | |
| /* Tests of print_parseable_fixits. */ | |
| /* Verify that print_parseable_fixits emits the empty string if there | |
| are no fixits. */ | |
| static void | |
| test_print_parseable_fixits_none () | |
| { | |
| pretty_printer pp; | |
| file_cache fc; | |
| rich_location richloc (line_table, UNKNOWN_LOCATION); | |
| print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8); | |
| ASSERT_STREQ ("", pp_formatted_text (&pp)); | |
| } | |
| /* Verify that print_parseable_fixits does the right thing if there | |
| is an insertion fixit hint. */ | |
| static void | |
| test_print_parseable_fixits_insert () | |
| { | |
| pretty_printer pp; | |
| file_cache fc; | |
| rich_location richloc (line_table, UNKNOWN_LOCATION); | |
| linemap_add (line_table, LC_ENTER, false, "test.c", 0); | |
| linemap_line_start (line_table, 5, 100); | |
| linemap_add (line_table, LC_LEAVE, false, nullptr, 0); | |
| location_t where = linemap_position_for_column (line_table, 10); | |
| richloc.add_fixit_insert_before (where, "added content"); | |
| print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8); | |
| ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:10}:\"added content\"\n", | |
| pp_formatted_text (&pp)); | |
| } | |
| /* Verify that print_parseable_fixits does the right thing if there | |
| is an removal fixit hint. */ | |
| static void | |
| test_print_parseable_fixits_remove () | |
| { | |
| pretty_printer pp; | |
| file_cache fc; | |
| rich_location richloc (line_table, UNKNOWN_LOCATION); | |
| linemap_add (line_table, LC_ENTER, false, "test.c", 0); | |
| linemap_line_start (line_table, 5, 100); | |
| linemap_add (line_table, LC_LEAVE, false, nullptr, 0); | |
| source_range where; | |
| where.m_start = linemap_position_for_column (line_table, 10); | |
| where.m_finish = linemap_position_for_column (line_table, 20); | |
| richloc.add_fixit_remove (where); | |
| print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8); | |
| ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"\"\n", | |
| pp_formatted_text (&pp)); | |
| } | |
| /* Verify that print_parseable_fixits does the right thing if there | |
| is an replacement fixit hint. */ | |
| static void | |
| test_print_parseable_fixits_replace () | |
| { | |
| pretty_printer pp; | |
| file_cache fc; | |
| rich_location richloc (line_table, UNKNOWN_LOCATION); | |
| linemap_add (line_table, LC_ENTER, false, "test.c", 0); | |
| linemap_line_start (line_table, 5, 100); | |
| linemap_add (line_table, LC_LEAVE, false, nullptr, 0); | |
| source_range where; | |
| where.m_start = linemap_position_for_column (line_table, 10); | |
| where.m_finish = linemap_position_for_column (line_table, 20); | |
| richloc.add_fixit_replace (where, "replacement"); | |
| print_parseable_fixits (fc, &pp, &richloc, DIAGNOSTICS_COLUMN_UNIT_BYTE, 8); | |
| ASSERT_STREQ ("fix-it:\"test.c\":{5:10-5:21}:\"replacement\"\n", | |
| pp_formatted_text (&pp)); | |
| } | |
| /* Verify that print_parseable_fixits correctly handles | |
| DIAGNOSTICS_COLUMN_UNIT_BYTE vs DIAGNOSTICS_COLUMN_UNIT_COLUMN. */ | |
| static void | |
| test_print_parseable_fixits_bytes_vs_display_columns () | |
| { | |
| line_table_test ltt; | |
| rich_location richloc (line_table, UNKNOWN_LOCATION); | |
| /* 1-based byte offsets: 12345677778888999900001234567. */ | |
| const char *const content = "smile \xf0\x9f\x98\x82 colour\n"; | |
| /* 1-based display cols: 123456[......7-8.....]9012345. */ | |
| const int tabstop = 8; | |
| temp_source_file tmp (SELFTEST_LOCATION, ".c", content); | |
| file_cache fc; | |
| const char *const fname = tmp.get_filename (); | |
| linemap_add (line_table, LC_ENTER, false, fname, 0); | |
| linemap_line_start (line_table, 1, 100); | |
| linemap_add (line_table, LC_LEAVE, false, nullptr, 0); | |
| source_range where; | |
| where.m_start = linemap_position_for_column (line_table, 12); | |
| where.m_finish = linemap_position_for_column (line_table, 17); | |
| richloc.add_fixit_replace (where, "color"); | |
| /* Escape fname. */ | |
| pretty_printer tmp_pp; | |
| print_escaped_string (&tmp_pp, fname); | |
| char *escaped_fname = xstrdup (pp_formatted_text (&tmp_pp)); | |
| const int buf_len = strlen (escaped_fname) + 100; | |
| char *const expected = XNEWVEC (char, buf_len); | |
| { | |
| pretty_printer pp; | |
| print_parseable_fixits (fc, &pp, &richloc, | |
| DIAGNOSTICS_COLUMN_UNIT_BYTE, | |
| tabstop); | |
| snprintf (expected, buf_len, | |
| "fix-it:%s:{1:12-1:18}:\"color\"\n", escaped_fname); | |
| ASSERT_STREQ (expected, pp_formatted_text (&pp)); | |
| } | |
| { | |
| pretty_printer pp; | |
| print_parseable_fixits (fc, &pp, &richloc, | |
| DIAGNOSTICS_COLUMN_UNIT_DISPLAY, | |
| tabstop); | |
| snprintf (expected, buf_len, | |
| "fix-it:%s:{1:10-1:16}:\"color\"\n", escaped_fname); | |
| ASSERT_STREQ (expected, pp_formatted_text (&pp)); | |
| } | |
| XDELETEVEC (expected); | |
| free (escaped_fname); | |
| } | |
| /* Verify that | |
| diagnostics::column_policy::get_location_text (..., SHOW_COLUMN, ...) | |
| generates EXPECTED_LOC_TEXT, given FILENAME, LINE, COLUMN, with | |
| colorization disabled. */ | |
| static void | |
| assert_location_text (const char *expected_loc_text, | |
| const char *filename, int line, int column, | |
| bool show_column, | |
| int origin = 1, | |
| enum diagnostics_column_unit column_unit | |
| = DIAGNOSTICS_COLUMN_UNIT_BYTE) | |
| { | |
| diagnostics::selftest::test_context dc; | |
| dc.get_column_options ().m_column_unit = column_unit; | |
| dc.get_column_options ().m_column_origin = origin; | |
| expanded_location xloc; | |
| xloc.file = filename; | |
| xloc.line = line; | |
| xloc.column = column; | |
| xloc.data = nullptr; | |
| xloc.sysp = false; | |
| diagnostics::column_policy column_policy (dc); | |
| label_text actual_loc_text | |
| = column_policy.get_location_text (xloc, show_column, false); | |
| ASSERT_STREQ (expected_loc_text, actual_loc_text.get ()); | |
| } | |
| /* Verify that get_location_text works as expected. */ | |
| static void | |
| test_get_location_text () | |
| { | |
| const char *old_progname = progname; | |
| progname = "PROGNAME"; | |
| assert_location_text ("PROGNAME:", nullptr, 0, 0, true); | |
| char *built_in_colon = concat (special_fname_builtin (), ":", (char *) 0); | |
| assert_location_text (built_in_colon, special_fname_builtin (), | |
| 42, 10, true); | |
| free (built_in_colon); | |
| assert_location_text ("foo.c:42:10:", "foo.c", 42, 10, true); | |
| assert_location_text ("foo.c:42:9:", "foo.c", 42, 10, true, 0); | |
| assert_location_text ("foo.c:42:1010:", "foo.c", 42, 10, true, 1001); | |
| for (int origin = 0; origin != 2; ++origin) | |
| assert_location_text ("foo.c:42:", "foo.c", 42, 0, true, origin); | |
| assert_location_text ("foo.c:", "foo.c", 0, 10, true); | |
| assert_location_text ("foo.c:42:", "foo.c", 42, 10, false); | |
| assert_location_text ("foo.c:", "foo.c", 0, 10, false); | |
| diagnostics::text_sink::maybe_line_and_column (INT_MAX, INT_MAX); | |
| diagnostics::text_sink::maybe_line_and_column (INT_MIN, INT_MIN); | |
| { | |
| /* In order to test display columns vs byte columns, we need to create a | |
| file for location_get_source_line() to read. */ | |
| const char *const content = "smile \xf0\x9f\x98\x82\n"; | |
| const int line_bytes = strlen (content) - 1; | |
| const int def_tabstop = 8; | |
| const cpp_char_column_policy policy (def_tabstop, cpp_wcwidth); | |
| const int display_width = cpp_display_width (content, line_bytes, policy); | |
| ASSERT_EQ (line_bytes - 2, display_width); | |
| temp_source_file tmp (SELFTEST_LOCATION, ".c", content); | |
| const char *const fname = tmp.get_filename (); | |
| const int buf_len = strlen (fname) + 16; | |
| char *const expected = XNEWVEC (char, buf_len); | |
| snprintf (expected, buf_len, "%s:1:%d:", fname, line_bytes); | |
| assert_location_text (expected, fname, 1, line_bytes, true, | |
| 1, DIAGNOSTICS_COLUMN_UNIT_BYTE); | |
| snprintf (expected, buf_len, "%s:1:%d:", fname, line_bytes - 1); | |
| assert_location_text (expected, fname, 1, line_bytes, true, | |
| 0, DIAGNOSTICS_COLUMN_UNIT_BYTE); | |
| snprintf (expected, buf_len, "%s:1:%d:", fname, display_width); | |
| assert_location_text (expected, fname, 1, line_bytes, true, | |
| 1, DIAGNOSTICS_COLUMN_UNIT_DISPLAY); | |
| snprintf (expected, buf_len, "%s:1:%d:", fname, display_width - 1); | |
| assert_location_text (expected, fname, 1, line_bytes, true, | |
| 0, DIAGNOSTICS_COLUMN_UNIT_DISPLAY); | |
| XDELETEVEC (expected); | |
| } | |
| progname = old_progname; | |
| } | |
| /* Selftest for num_digits. */ | |
| static void | |
| test_num_digits () | |
| { | |
| ASSERT_EQ (1, num_digits (0)); | |
| ASSERT_EQ (1, num_digits (9)); | |
| ASSERT_EQ (2, num_digits (10)); | |
| ASSERT_EQ (2, num_digits (99)); | |
| ASSERT_EQ (3, num_digits (100)); | |
| ASSERT_EQ (3, num_digits (999)); | |
| ASSERT_EQ (4, num_digits (1000)); | |
| ASSERT_EQ (4, num_digits (9999)); | |
| ASSERT_EQ (5, num_digits (10000)); | |
| ASSERT_EQ (5, num_digits (99999)); | |
| ASSERT_EQ (6, num_digits (100000)); | |
| ASSERT_EQ (6, num_digits (999999)); | |
| ASSERT_EQ (7, num_digits (1000000)); | |
| ASSERT_EQ (7, num_digits (9999999)); | |
| ASSERT_EQ (8, num_digits (10000000)); | |
| ASSERT_EQ (8, num_digits (99999999)); | |
| ASSERT_EQ (20, num_digits (uint64_t (-1))); | |
| } | |
| /* Run all of the selftests within this file. | |
| According to https://gcc.gnu.org/pipermail/gcc/2021-November/237703.html | |
| there are some language-specific assumptions within these tests, so only | |
| run them from C/C++. */ | |
| void | |
| context_cc_tests () | |
| { | |
| test_print_escaped_string (); | |
| test_print_parseable_fixits_none (); | |
| test_print_parseable_fixits_insert (); | |
| test_print_parseable_fixits_remove (); | |
| test_print_parseable_fixits_replace (); | |
| test_print_parseable_fixits_bytes_vs_display_columns (); | |
| test_get_location_text (); | |
| test_num_digits (); | |
| } | |
| } // namespace diagnostics::selftest | |
| #endif /* #if CHECKING_P */ | |
| } // namespace diagnostics | |
| #if __GNUC__ >= 10 | |
| # pragma GCC diagnostic pop | |
| #endif | |
| static void real_abort (void) ATTRIBUTE_NORETURN; | |
| /* Really call the system 'abort'. This has to go right at the end of | |
| this file, so that there are no functions after it that call abort | |
| and get the system abort instead of our macro. */ | |
| #undef abort | |
| static void | |
| real_abort (void) | |
| { | |
| abort (); | |
| } |