Merge branch 'master' into gfortran-testdevel/gfortran-test

1 files changed, 219 insertions, 60 deletions

diff --git a/gcc/diagnostics/context.cc b/gcc/diagnostics/context.cc
index 0dbc148..0f8670b 100644
--- a/gcc/diagnostics/context.cc
+++ b/gcc/diagnostics/context.cc
@@ -50,6 +50,8 @@ along with GCC; see the file COPYING3.  If not see
 #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>
@@ -170,18 +172,24 @@ context::initialize (int n_opts)
   m_text_callbacks.m_html_start_span
     = default_start_span_fn<to_html>;
   m_text_callbacks.m_end_diagnostic = default_text_finalizer;
-  m_option_mgr = nullptr;
+  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"))
@@ -192,9 +200,6 @@ context::initialize (int n_opts)
 	m_extra_output_kind = EXTRA_DIAGNOSTIC_OUTPUT_fixits_v2;
       /* Silently ignore unrecognized values.  */
     }
-  m_column_unit = DIAGNOSTICS_COLUMN_UNIT_DISPLAY;
-  m_column_origin = 1;
-  m_tabstop = 8;
   m_escape_format = DIAGNOSTICS_ESCAPE_FORMAT_UNICODE;
   m_fixits_change_set = nullptr;
   m_diagnostic_groups.m_group_nesting_depth = 0;
@@ -207,6 +212,7 @@ context::initialize (int n_opts)
   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;
@@ -218,6 +224,27 @@ context::initialize (int n_opts)
 	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
@@ -284,6 +311,33 @@ context::urls_init (int value)
 	(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
@@ -298,6 +352,15 @@ context::initialize_input_context (diagnostic_input_charset_callback ccb,
 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 ());
+    }
+
   /* We might be handling a fatal error.
      Close any active diagnostic groups, which may trigger flushing
      sinks.  */
@@ -337,8 +400,8 @@ context::finish ()
       m_client_data_hooks = nullptr;
     }
 
-  delete m_option_mgr;
-  m_option_mgr = nullptr;
+  delete m_option_id_mgr;
+  m_option_id_mgr = nullptr;
 
   if (m_urlifier_stack)
     {
@@ -350,38 +413,48 @@ context::finish ()
 
   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 *out) const
+context::dump (FILE *outfile, int indent) const
 {
-  fprintf (out, "diagnostics::context:\n");
-  m_diagnostic_counters.dump (out, 2);
-  fprintf (out, "  reference printer:\n");
-  m_reference_printer->dump (out, 4);
-  fprintf (out, "  output sinks:\n");
+  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)
 	{
-	  fprintf (out, "  sink %i:\n", i);
-	  m_sinks[i]->dump (out, 4);
+	  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
-    fprintf (out, "    (none):\n");
-  fprintf (out, "  diagnostic buffer:\n");
+    dumping::emit_none (outfile, indent + 4);
+  dumping::emit_heading (outfile, indent + 2, "diagnostic buffer");
   if (m_diagnostic_buffer)
-    m_diagnostic_buffer->dump (out, 4);
+    m_diagnostic_buffer->dump (outfile, indent + 4);
   else
-    fprintf (out, "    (none):\n");
-  fprintf (out, "  file cache:\n");
+    dumping::emit_none (outfile, indent + 4);
+  dumping::emit_heading (outfile, indent + 2, "file cache");
   if (m_file_cache)
-    m_file_cache->dump (out, 4);
+    m_file_cache->dump (outfile, indent + 4);
   else
-    fprintf (out, "    (none):\n");
+    dumping::emit_none (outfile, indent + 4);
 }
 
 /* Return true if sufficiently severe diagnostics have been seen that
@@ -407,6 +480,9 @@ context::remove_all_output_sinks ()
 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 ());
 }
@@ -422,6 +498,9 @@ context::get_sink (size_t idx) const
 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 ());
 }
 
@@ -465,11 +544,11 @@ context::set_original_argv (unique_argv original_argv)
 }
 
 void
-context::set_option_manager (std::unique_ptr<option_manager> mgr,
-			     unsigned lang_mask)
+context::set_option_id_manager (std::unique_ptr<option_id_manager> mgr,
+				unsigned lang_mask)
 {
-  delete m_option_mgr;
-  m_option_mgr = mgr.release ();
+  delete m_option_id_mgr;
+  m_option_id_mgr = mgr.release ();
   m_lang_mask = lang_mask;
 }
 
@@ -626,6 +705,19 @@ 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"
@@ -671,11 +763,22 @@ convert_column_unit (file_cache &fc,
     }
 }
 
+/* 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_unit (dc.m_column_unit),
-  m_column_origin (dc.m_column_origin),
-  m_tabstop (dc.m_tabstop)
+  m_column_options (dc.get_column_options ())
 {
 }
 
@@ -685,11 +788,7 @@ column_policy::column_policy (const context &dc)
 int
 column_policy::converted_column (expanded_location s) const
 {
-  int one_based_col = convert_column_unit (m_file_cache,
-					   m_column_unit, m_tabstop, s);
-  if (one_based_col <= 0)
-    return -1;
-  return one_based_col + (m_column_origin - 1);
+  return m_column_options.convert_column (m_file_cache, s);
 }
 
 /* Return a string describing a location e.g. "foo.c:42:10".  */
@@ -711,7 +810,7 @@ column_policy::get_location_text (const expanded_location &s,
 	col = converted_column (s);
     }
 
-  const char *line_col = maybe_line_and_column (line, col);
+  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));
 }
@@ -1098,7 +1197,7 @@ context::get_any_inlining_info (diagnostic_info *diagnostic)
     /* 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);
+    m_set_locations_cb (*this, diagnostic);
   else
     {
       /* When there's no callback use just the one location provided
@@ -1231,6 +1330,9 @@ context::emit_diagnostic_with_group_va (enum kind kind,
 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
@@ -1245,11 +1347,13 @@ context::report_diagnostic (diagnostic_info *diagnostic)
   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);
+    m_adjust_diagnostic_info (*this, diagnostic);
 
   if (diagnostic->m_kind == kind::pedwarn)
     {
@@ -1260,7 +1364,11 @@ context::report_diagnostic (diagnostic_info *diagnostic)
     }
 
   if (diagnostic->m_kind == kind::note && m_inhibit_notes_p)
-    return false;
+    {
+      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
@@ -1277,6 +1385,8 @@ context::report_diagnostic (diagnostic_info *diagnostic)
      stack.  .  */
   if (!diagnostic_enabled (diagnostic))
     {
+      if (m_logger)
+	m_logger->log_printf ("rejecting: diagnostic not enabled");
       inhibit_notes_in_group ();
       return false;
     }
@@ -1285,13 +1395,21 @@ context::report_diagnostic (diagnostic_info *diagnostic)
       && ((!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.  */
-    return false;
+    {
+      /* 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.  */
-    return false;
+    {
+      /* 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);
@@ -1352,8 +1470,13 @@ context::report_diagnostic (diagnostic_info *diagnostic)
 
   /* Is this the initial diagnostic within the stack of groups?  */
   if (m_diagnostic_groups.m_emission_count == 0)
-    for (auto sink_ : m_sinks)
-      sink_->on_begin_group ();
+    {
+      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;
@@ -1385,6 +1508,8 @@ context::report_diagnostic (diagnostic_info *diagnostic)
       sink_->on_report_diagnostic (*diagnostic, orig_diag_kind);
     }
 
+  const int tabstop = get_column_options ().m_tabstop;
+
   switch (m_extra_output_kind)
     {
     default:
@@ -1393,14 +1518,14 @@ context::report_diagnostic (diagnostic_info *diagnostic)
       print_parseable_fixits (get_file_cache (),
 			      m_reference_printer, diagnostic->m_richloc,
 			      DIAGNOSTICS_COLUMN_UNIT_BYTE,
-			      m_tabstop);
+			      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,
-			      m_tabstop);
+			      tabstop);
       pp_flush (m_reference_printer);
       break;
     }
@@ -1510,6 +1635,13 @@ context::diagnostic_impl (rich_location *richloc,
 			  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)
     {
@@ -1527,7 +1659,11 @@ context::diagnostic_impl (rich_location *richloc,
 	diagnostic.m_option_id = opt_id;
     }
   diagnostic.m_metadata = metadata;
-  return report_diagnostic (&diagnostic);
+
+  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
@@ -1541,6 +1677,13 @@ context::diagnostic_n_impl (rich_location *richloc,
 			    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;
 
@@ -1557,7 +1700,11 @@ context::diagnostic_n_impl (rich_location *richloc,
   if (kind == diagnostics::kind::warning)
     diagnostic.m_option_id = opt_id;
   diagnostic.m_metadata = metadata;
-  return report_diagnostic (&diagnostic);
+
+  bool ret = report_diagnostic (&diagnostic);
+  if (m_logger)
+    m_logger->log_bool_return ("diagnostics::context::diagnostic_n_impl", ret);
+  return ret;
 }
 
 
@@ -1659,8 +1806,13 @@ context::end_group ()
 	 If any diagnostics were emitted, give the context a chance
 	 to do something.  */
       if (m_diagnostic_groups.m_emission_count > 0)
-	for (auto sink_ : m_sinks)
-	  sink_->on_end_group ();
+	{
+	  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.  */
@@ -1682,9 +1834,15 @@ context::pop_nesting_level ()
 }
 
 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
 {
-  fprintf (out, "%*sprinter:\n", indent, "");
+  dumping::emit_heading (out, indent, "printer");
   m_printer->dump (out, indent + 2);
 }
 
@@ -1771,19 +1929,19 @@ counters::counters ()
 void
 counters::dump (FILE *out, int indent) const
 {
-  fprintf (out, "%*scounts:\n", indent, "");
+  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)
       {
-	fprintf (out, "%*s%s%i\n",
-		 indent + 2, "",
+	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)
-    fprintf (out, "%*s(none)\n", indent + 2, "");
+    dumping::emit_none (out, indent + 2);
 }
 
 void
@@ -2009,8 +2167,8 @@ assert_location_text (const char *expected_loc_text,
 			= DIAGNOSTICS_COLUMN_UNIT_BYTE)
 {
   diagnostics::selftest::test_context dc;
-  dc.m_column_unit = column_unit;
-  dc.m_column_origin = origin;
+  dc.get_column_options ().m_column_unit = column_unit;
+  dc.get_column_options ().m_column_origin = origin;
 
   expanded_location xloc;
   xloc.file = filename;
@@ -2046,8 +2204,8 @@ test_get_location_text ()
   assert_location_text ("foo.c:42:", "foo.c", 42, 10, false);
   assert_location_text ("foo.c:", "foo.c", 0, 10, false);
 
-  diagnostics::maybe_line_and_column (INT_MAX, INT_MAX);
-  diagnostics::maybe_line_and_column (INT_MIN, INT_MIN);
+  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
@@ -2130,10 +2288,11 @@ context_cc_tests ()
 }
 
 } // namespace diagnostics::selftest
-} // namespace diagnostics
 
 #endif /* #if CHECKING_P */
 
+} // namespace diagnostics
+
 #if __GNUC__ >= 10
 #  pragma GCC diagnostic pop
 #endif