diagnostics: support multithreaded diagnostic paths

This patch extends the existing diagnostic_path class so that as well
as list of events, there is a list of named threads, with each event
being associated with one of the threads.

No GCC diagnostics take advantage of this, but GCC plugins may find a
use for this; an example is provided in the testsuite.

Given that there is still a single list of events within a
diagnostic_path, the events in a diagnostic_path have a specific global
ordering even if they are in multiple threads.

Within the SARIF serialization, the patch adds the "executionOrder"
property to threadFlowLocation objects (SARIF v2.1.0 3.38.11).  This is
1-based in order to match the human-readable numbering of events shown
in messages emitted by pretty-printer.cc's "%@".

With -fdiagnostics-path-format=separate-events, the threads are not
shown.

With -fdiagnostics-path-format=inline-events, the threads and the
per-thread stack activity are tracked and visalized separately.  An
example can be seen in the testsuite.

gcc/analyzer/ChangeLog:
	* checker-event.h (checker_event::get_thread_id): New.
	* checker-path.h (class checker_path): Implement thread-related
	vfuncs via a single simple_diagnostic_thread instance named
	"main".

gcc/ChangeLog:
	* diagnostic-event-id.h (diagnostic_thread_id_t): New typedef.
	* diagnostic-format-sarif.cc (class sarif_thread_flow): New.
	(sarif_thread_flow::sarif_thread_flow): New.
	(sarif_builder::make_code_flow_object): Reimplement, creating
	per-thread threadFlow objects, populating them with the relevant
	events.
	(sarif_builder::make_thread_flow_object): Delete, moving the
	code into sarif_builder::make_code_flow_object.
	(sarif_builder::make_thread_flow_location_object): Add
	"path_event_idx" param.  Use it to set "executionOrder"
	property.
	* diagnostic-path.h (diagnostic_event::get_thread_id): New
	pure-virtual vfunc.
	(class diagnostic_thread): New.
	(diagnostic_path::num_threads): New pure-virtual vfunc.
	(diagnostic_path::get_thread):  New pure-virtual vfunc.
	(diagnostic_path::multithreaded_p): New decl.
	(simple_diagnostic_event::simple_diagnostic_event): Add optional
	thread_id param.
	(simple_diagnostic_event::get_thread_id): New accessor.
	(simple_diagnostic_event::m_thread_id): New.
	(class simple_diagnostic_thread): New.
	(simple_diagnostic_path::simple_diagnostic_path): Move definition
	to diagnostic.cc.
	(simple_diagnostic_path::num_threads): New.
	(simple_diagnostic_path::get_thread): New.
	(simple_diagnostic_path::add_thread): New.
	(simple_diagnostic_path::add_thread_event): New.
	(simple_diagnostic_path::m_threads): New.
	* diagnostic-show-locus.cc (layout::layout): Add pretty_printer
	param for overriding the context's printer.
	(diagnostic_show_locus): Likwise.
	* diagnostic.cc (simple_diagnostic_path::simple_diagnostic_path):
	Move here from diagnostic-path.h.  Add main thread.
	(simple_diagnostic_path::num_threads): New.
	(simple_diagnostic_path::get_thread): New.
	(simple_diagnostic_path::add_thread): New.
	(simple_diagnostic_path::add_thread_event): New.
	(simple_diagnostic_event::simple_diagnostic_event): Add thread_id
	param and use it to initialize m_thread_id.  Reformat.
	* diagnostic.h: Add pretty_printer param for overriding the
	context's printer.
	* tree-diagnostic-path.cc: Add #define INCLUDE_VECTOR.
	(can_consolidate_events): Compare thread ids.
	(class per_thread_summary): New.
	(event_range::event_range): Add per_thread_summary arg.
	(event_range::print): Add "pp" param and use it rather than dc's
	printer.
	(event_range::m_thread_id): New field.
	(event_range::m_per_thread_summary): New field.
	(path_summary::multithreaded_p): New.
	(path_summary::get_events_for_thread_id): New.
	(path_summary::m_per_thread_summary): New field.
	(path_summary::m_thread_id_to_events): New field.
	(path_summary::get_or_create_events_for_thread_id): New.
	(path_summary::path_summary): Create per_thread_summary instances
	as needed and associate the event_range instances with them.
	(base_indent): Move here from print_path_summary_as_text.
	(per_frame_indent): Likewise.
	(class thread_event_printer): New, adapted from parts of
	print_path_summary_as_text.
	(print_path_summary_as_text): Make static.  Reimplement to
	moving most of existing code to class thread_event_printer,
	capturing state as per-thread as appropriate.
	(default_tree_diagnostic_path_printer): Add missing 'break' on
	final case.

gcc/testsuite/ChangeLog:
	* gcc.dg/plugin/diagnostic-test-paths-multithreaded-inline-events.c:
	New test.
	* gcc.dg/plugin/diagnostic-test-paths-multithreaded-sarif.c: New
	test.
	* gcc.dg/plugin/diagnostic-test-paths-multithreaded-separate-events.c:
	New test.
	* gcc.dg/plugin/diagnostic_plugin_test_paths.c: Add support for
	generating multithreaded paths.
	* gcc.dg/plugin/plugin.exp: Add the new tests.

Signed-off-by: David Malcolm <[email protected]>

Author: davidmalcolm

gcc/analyzer/checker-event.h

@@ -113,6 +113,10 @@ class checker_event : public diagnostic_event
       return NULL;
   }
   meaning get_meaning () const override;
+  diagnostic_thread_id_t get_thread_id () const final override
+  {
+    return 0;
+  }
 
   /* Additional functionality.  */
 

gcc/analyzer/checker-path.h

@@ -30,7 +30,11 @@ namespace ana {
 class checker_path : public diagnostic_path
 {
 public:
-  checker_path (logger *logger) : diagnostic_path (), m_logger (logger) {}
+  checker_path (logger *logger)
+  : diagnostic_path (),
+    m_thread ("main"),
+    m_logger (logger)
+  {}
 
   /* Implementation of diagnostic_path vfuncs.  */
 
@@ -43,6 +47,15 @@ class checker_path : public diagnostic_path
   {
     return *m_events[idx];
   }
+  unsigned num_threads () const final override
+  {
+    return 1;
+  }
+  const diagnostic_thread &
+  get_thread (diagnostic_thread_id_t) const final override
+  {
+    return m_thread;
+  }
 
   checker_event *get_checker_event (int idx)
   {
@@ -120,6 +133,8 @@ class checker_path : public diagnostic_path
 private:
   DISABLE_COPY_AND_ASSIGN(checker_path);
 
+  simple_diagnostic_thread m_thread;
+
   /* The events that have occurred along this path.  */
   auto_delete_vec<checker_event> m_events;
 

gcc/diagnostic-event-id.h

@@ -58,4 +58,9 @@ class diagnostic_event_id_t
    The %@ format code requires that known_p be true for the event ID. */
 typedef diagnostic_event_id_t *diagnostic_event_id_ptr;
 
+/* A type for compactly referring to a particular thread within a
+   diagnostic_path.  Typically there is just one thread per path,
+   with id 0.  */
+typedef unsigned diagnostic_thread_id_t;
+
 #endif /* ! GCC_DIAGNOSTIC_EVENT_ID_H */

gcc/diagnostic-format-sarif.cc

@@ -94,6 +94,23 @@ class sarif_ice_notification : public sarif_object
 			  sarif_builder *builder);
 };
 
+/* Subclass of sarif_object for SARIF threadFlow objects
+   (SARIF v2.1.0 section 3.37) for PATH.  */
+
+class sarif_thread_flow : public sarif_object
+{
+public:
+  sarif_thread_flow (const diagnostic_thread &thread);
+
+  void add_location (json::object *thread_flow_loc_obj)
+  {
+    m_locations_arr->append (thread_flow_loc_obj);
+  }
+
+private:
+  json::array *m_locations_arr;
+};
+
 /* A class for managing SARIF output (for -fdiagnostics-format=sarif-stderr
    and -fdiagnostics-format=sarif-file).
 
@@ -168,9 +185,9 @@ class sarif_builder
   json::object *
   make_logical_location_object (const logical_location &logical_loc) const;
   json::object *make_code_flow_object (const diagnostic_path &path);
-  json::object *make_thread_flow_object (const diagnostic_path &path);
   json::object *
-  make_thread_flow_location_object (const diagnostic_event &event);
+  make_thread_flow_location_object (const diagnostic_event &event,
+				    int path_event_idx);
   json::array *maybe_make_kinds_array (diagnostic_event::meaning m) const;
   json::object *maybe_make_physical_location_object (location_t loc);
   json::object *make_artifact_location_object (location_t loc);
@@ -365,6 +382,19 @@ sarif_ice_notification::sarif_ice_notification (diagnostic_context *context,
   set ("level", new json::string ("error"));
 }
 
+/* class sarif_thread_flow : public sarif_object.  */
+
+sarif_thread_flow::sarif_thread_flow (const diagnostic_thread &thread)
+{
+  /* "id" property (SARIF v2.1.0 section 3.37.2).  */
+  label_text name (thread.get_name (false));
+  set ("id", new json::string (name.get ()));
+
+  /* "locations" property (SARIF v2.1.0 section 3.37.6).  */
+  m_locations_arr = new json::array ();
+  set ("locations", m_locations_arr);
+}
+
 /* class sarif_builder.  */
 
 /* sarif_builder's ctor.  */
@@ -1091,41 +1121,44 @@ sarif_builder::make_code_flow_object (const diagnostic_path &path)
 {
   json::object *code_flow_obj = new json::object ();
 
-  /* "threadFlows" property (SARIF v2.1.0 section 3.36.3).
-     Currently we only support one thread per result.  */
+  /* "threadFlows" property (SARIF v2.1.0 section 3.36.3).  */
   json::array *thread_flows_arr = new json::array ();
-  json::object *thread_flow_obj = make_thread_flow_object (path);
-  thread_flows_arr->append (thread_flow_obj);
-  code_flow_obj->set ("threadFlows", thread_flows_arr);
 
-  return code_flow_obj;
-}
-
-/* Make a threadFlow object (SARIF v2.1.0 section 3.37) for PATH.  */
-
-json::object *
-sarif_builder::make_thread_flow_object (const diagnostic_path &path)
-{
-  json::object *thread_flow_obj = new json::object ();
-
-  /* "locations" property (SARIF v2.1.0 section 3.37.6).  */
-  json::array *locations_arr = new json::array ();
+  /* Walk the events, consolidating into per-thread threadFlow objects,
+     using the index with PATH as the overall executionOrder.  */
+  hash_map<int_hash<diagnostic_thread_id_t, -1, -2>,
+	   sarif_thread_flow *> thread_id_map;
   for (unsigned i = 0; i < path.num_events (); i++)
     {
       const diagnostic_event &event = path.get_event (i);
+      const diagnostic_thread_id_t thread_id = event.get_thread_id ();
+      sarif_thread_flow *thread_flow_obj;
+
+      if (sarif_thread_flow **slot = thread_id_map.get (thread_id))
+	thread_flow_obj = *slot;
+      else
+	{
+	  const diagnostic_thread &thread = path.get_thread (thread_id);
+	  thread_flow_obj = new sarif_thread_flow (thread);
+	  thread_flows_arr->append (thread_flow_obj);
+	  thread_id_map.put (thread_id, thread_flow_obj);
+	}
+
+      /* Add event to thread's threadFlow object.  */
       json::object *thread_flow_loc_obj
-	= make_thread_flow_location_object (event);
-      locations_arr->append (thread_flow_loc_obj);
+	= make_thread_flow_location_object (event, i);
+      thread_flow_obj->add_location (thread_flow_loc_obj);
     }
-  thread_flow_obj->set ("locations", locations_arr);
+  code_flow_obj->set ("threadFlows", thread_flows_arr);
 
-  return thread_flow_obj;
+  return code_flow_obj;
 }
 
 /* Make a threadFlowLocation object (SARIF v2.1.0 section 3.38) for EVENT.  */
 
 json::object *
-sarif_builder::make_thread_flow_location_object (const diagnostic_event &ev)
+sarif_builder::make_thread_flow_location_object (const diagnostic_event &ev,
+						 int path_event_idx)
 {
   json::object *thread_flow_loc_obj = new json::object ();
 
@@ -1142,6 +1175,11 @@ sarif_builder::make_thread_flow_location_object (const diagnostic_event &ev)
   thread_flow_loc_obj->set ("nestingLevel",
 			    new json::integer_number (ev.get_stack_depth ()));
 
+  /* "executionOrder" property (SARIF v2.1.0 3.38.11).
+     Offset by 1 to match the human-readable values emitted by %@.  */
+  thread_flow_loc_obj->set ("executionOrder",
+			    new json::integer_number (path_event_idx + 1));
+
   /* It might be nice to eventually implement the following for -fanalyzer:
      - the "stack" property (SARIF v2.1.0 section 3.38.5)
      - the "state" property (SARIF v2.1.0 section 3.38.9)

gcc/diagnostic-path.h

@@ -155,6 +155,20 @@ class diagnostic_event
   virtual const logical_location *get_logical_location () const = 0;
 
   virtual meaning get_meaning () const = 0;
+
+  virtual diagnostic_thread_id_t get_thread_id () const = 0;
+};
+
+/* Abstract base class representing a thread of execution within
+   a diagnostic_path.
+   Each diagnostic_event is associated with one thread.
+   Typically there is just one thread per diagnostic_path. */
+
+class diagnostic_thread
+{
+public:
+  virtual ~diagnostic_thread () {}
+  virtual label_text get_name (bool can_colorize) const = 0;
 };
 
 /* Abstract base class for getting at a sequence of events.  */
@@ -165,8 +179,12 @@ class diagnostic_path
   virtual ~diagnostic_path () {}
   virtual unsigned num_events () const = 0;
   virtual const diagnostic_event & get_event (int idx) const = 0;
+  virtual unsigned num_threads () const = 0;
+  virtual const diagnostic_thread &
+  get_thread (diagnostic_thread_id_t) const = 0;
 
   bool interprocedural_p () const;
+  bool multithreaded_p () const;
 
 private:
   bool get_first_event_in_a_function (unsigned *out_idx) const;
@@ -180,7 +198,8 @@ class simple_diagnostic_event : public diagnostic_event
 {
  public:
   simple_diagnostic_event (location_t loc, tree fndecl, int depth,
-			   const char *desc);
+			   const char *desc,
+			   diagnostic_thread_id_t thread_id = 0);
   ~simple_diagnostic_event ();
 
   location_t get_location () const final override { return m_loc; }
@@ -198,12 +217,32 @@ class simple_diagnostic_event : public diagnostic_event
   {
     return meaning ();
   }
+  diagnostic_thread_id_t get_thread_id () const final override
+  {
+    return m_thread_id;
+  }
 
  private:
   location_t m_loc;
   tree m_fndecl;
   int m_depth;
   char *m_desc; // has been i18n-ed and formatted
+  diagnostic_thread_id_t m_thread_id;
+};
+
+/* A simple implementation of diagnostic_thread.  */
+
+class simple_diagnostic_thread : public diagnostic_thread
+{
+public:
+  simple_diagnostic_thread (const char *name) : m_name (name) {}
+  label_text get_name (bool) const final override
+  {
+    return label_text::borrow (m_name);
+  }
+
+private:
+  const char *m_name; // has been i18n-ed and formatted
 };
 
 /* A simple implementation of diagnostic_path, as a vector of
@@ -212,17 +251,27 @@ class simple_diagnostic_event : public diagnostic_event
 class simple_diagnostic_path : public diagnostic_path
 {
  public:
-  simple_diagnostic_path (pretty_printer *event_pp)
-  : m_event_pp (event_pp) {}
+  simple_diagnostic_path (pretty_printer *event_pp);
 
   unsigned num_events () const final override;
   const diagnostic_event & get_event (int idx) const final override;
+  unsigned num_threads () const final override;
+  const diagnostic_thread &
+  get_thread (diagnostic_thread_id_t) const final override;
+
+  diagnostic_thread_id_t add_thread (const char *name);
 
   diagnostic_event_id_t add_event (location_t loc, tree fndecl, int depth,
 				   const char *fmt, ...)
     ATTRIBUTE_GCC_DIAG(5,6);
+  diagnostic_event_id_t
+  add_thread_event (diagnostic_thread_id_t thread_id,
+		    location_t loc, tree fndecl, int depth,
+		    const char *fmt, ...)
+    ATTRIBUTE_GCC_DIAG(6,7);
 
  private:
+  auto_delete_vec<simple_diagnostic_thread> m_threads;
   auto_delete_vec<simple_diagnostic_event> m_events;
 
   /* (for use by add_event).  */

gcc/diagnostic-show-locus.cc

@@ -367,7 +367,8 @@ class layout
  public:
   layout (diagnostic_context *context,
 	  rich_location *richloc,
-	  diagnostic_t diagnostic_kind);
+	  diagnostic_t diagnostic_kind,
+	  pretty_printer *pp = nullptr);
 
   bool maybe_add_location_range (const location_range *loc_range,
 				 unsigned original_idx,
@@ -1183,9 +1184,10 @@ make_policy (const diagnostic_context &dc,
 
 layout::layout (diagnostic_context * context,
 		rich_location *richloc,
-		diagnostic_t diagnostic_kind)
+		diagnostic_t diagnostic_kind,
+		pretty_printer *pp)
 : m_context (context),
-  m_pp (context->printer),
+  m_pp (pp ? pp : context->printer),
   m_policy (make_policy (*context, *richloc)),
   m_primary_loc (richloc->get_range (0)->m_loc),
   m_exploc (richloc->get_expanded_location (0), m_policy,
@@ -2825,12 +2827,14 @@ gcc_rich_location::add_location_if_nearby (location_t loc,
 }
 
 /* Print the physical source code corresponding to the location of
-   this diagnostic, with additional annotations.  */
+   this diagnostic, with additional annotations.
+   If PP is non-null, then use it rather than CONTEXT's printer.  */
 
 void
 diagnostic_show_locus (diagnostic_context * context,
 		       rich_location *richloc,
-		       diagnostic_t diagnostic_kind)
+		       diagnostic_t diagnostic_kind,
+		       pretty_printer *pp)
 {
   location_t loc = richloc->get_loc ();
   /* Do nothing if source-printing has been disabled.  */
@@ -2851,7 +2855,7 @@ diagnostic_show_locus (diagnostic_context * context,
 
   context->last_location = loc;
 
-  layout layout (context, richloc, diagnostic_kind);
+  layout layout (context, richloc, diagnostic_kind, pp);
   for (int line_span_idx = 0; line_span_idx < layout.get_num_line_spans ();
        line_span_idx++)
     {