diagnostic-digraphs.h

Go to the documentation of this file.

/* Directed graphs associated with a diagnostic.
   Copyright (C) 2025 Free Software Foundation, Inc.
   Contributed by David Malcolm <dmalcolm@redhat.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/>.  */
 
#ifndef GCC_DIAGNOSTIC_DIGRAPHS_H
#define GCC_DIAGNOSTIC_DIGRAPHS_H
 
#include "json.h"
#include "logical-location.h"
 
class graphviz_out;
 
class sarif_graph;
class sarif_node;
class sarif_edge;
 
namespace dot { class graph; }
 
namespace diagnostics {
namespace digraphs {
 
/* A family of classes: digraph, node, and edge, closely related to
   SARIF's graph, node, and edge types (SARIF v2.1.0 sections 3.39-3.41).
 
   Nodes can have child nodes, allowing for arbitrarily deep nesting.
   Edges can be between any pair of nodes (potentially at different
   nesting levels).
 
   Digraphs, nodes, and edges also optionally have a JSON property bag,
   allowing round-tripping of arbitrary key/value pairs through SARIF.  */
 
class digraph;
class node;
class edge;
 
/* A base class for digraph, node, and edge to allow them to have
   an optional JSON property bag.  */
 
class object
{
public:
  const char *
  get_attr (const char *key_prefix,
            const char *key) const;
 
  void
  set_attr (const char *key_prefix,
            const char *key,
            const char *value);
 
  void
  set_json_attr (const char *key_prefix,
                 const char *key,
                 std::unique_ptr<json::value> value);
 
  json::object *
  get_property_bag () const { return m_property_bag.get (); }
 
  void
  set_property_bag (std::unique_ptr<json::object> property_bag)
  {
    m_property_bag = std::move (property_bag);
  }
  set_property_bag (std::unique_ptr<json::object> property_bag) {…}
 
private:
  std::unique_ptr<json::object> m_property_bag;
};
class object {…};
 
// A directed graph, corresponding to SARIF v2.1.0 section 3.39.
 
class digraph : public object
{
 public:
  friend class node;
  friend class edge;
 
  digraph () : m_next_edge_id_index (0) {}
  virtual ~digraph () {}
 
  const char *
  get_description () const
  {
    if (!m_description)
      return nullptr;
    return m_description->c_str ();
  }
  get_description () const {…}
 
  void
  set_description (const char *desc)
  {
    if (desc)
      m_description = std::make_unique<std::string> (desc);
    else
      m_description = nullptr;
  }
  set_description (const char *desc) {…}
  void
  set_description (std::string desc)
  {
    m_description = std::make_unique<std::string> (std::move (desc));
  }
  set_description (std::string desc) {…}
 
  node *
  get_node_by_id (const char *id) const
  {
    auto iter = m_id_to_node_map.find (id);
    if (iter == m_id_to_node_map.end ())
      return nullptr;
    return iter->second;
  }
  get_node_by_id (const char *id) const {…}
 
  edge *
  get_edge_by_id (const char *id) const
  {
    auto iter = m_id_to_edge_map.find (id);
    if (iter == m_id_to_edge_map.end ())
      return nullptr;
    return iter->second;
  }
  get_edge_by_id (const char *id) const {…}
 
  size_t
  get_num_nodes () const
  {
    return m_nodes.size ();
  }
  get_num_nodes () const {…}
 
  node &
  get_node (size_t idx) const
  {
    return *m_nodes[idx].get ();
  }
  get_node (size_t idx) const {…}
 
  size_t
  get_num_edges () const
  {
    return m_edges.size ();
  }
  get_num_edges () const {…}
 
  edge &
  get_edge (size_t idx) const
  {
    return *m_edges[idx].get ();
  }
  get_edge (size_t idx) const {…}
 
  void
  dump () const;
 
  std::unique_ptr<json::object>
  make_json_sarif_graph () const;
 
  std::unique_ptr<dot::graph>
  make_dot_graph () const;
 
  void
  add_node (std::unique_ptr<node> n)
  {
    gcc_assert (n);
    m_nodes.push_back (std::move (n));
  }
  add_node (std::unique_ptr<node> n) {…}
 
  void
  add_edge (std::unique_ptr<edge> e)
  {
    gcc_assert (e);
    m_edges.push_back (std::move (e));
  }
  add_edge (std::unique_ptr<edge> e) {…}
 
  void
  add_edge (const char *id,
            node &src_node,
            node &dst_node,
            const char *label = nullptr);
 
  std::unique_ptr<digraph> clone () const;
 
 private:
  void
  add_node_id (std::string node_id, node &new_node)
  {
    m_id_to_node_map.insert ({std::move (node_id), &new_node});
  }
  add_node_id (std::string node_id, node &new_node) {…}
  void
  add_edge_id (std::string edge_id, edge &new_edge)
  {
    m_id_to_edge_map.insert ({std::move (edge_id), &new_edge});
  }
  add_edge_id (std::string edge_id, edge &new_edge) {…}
 
  std::string
  make_edge_id (const char *edge_id);
 
  std::unique_ptr<std::string> m_description;
  std::map<std::string, node *> m_id_to_node_map;
  std::map<std::string, edge *> m_id_to_edge_map;
  std::vector<std::unique_ptr<node>> m_nodes;
  std::vector<std::unique_ptr<edge>> m_edges;
  size_t m_next_edge_id_index;
};
class digraph : public object {…};
 
// A node in a directed graph, corresponding to SARIF v2.1.0 section 3.40.
 
class node : public object
{
 public:
  virtual ~node () {}
 
  node (digraph &g, std::string id)
  : m_id (id),
    m_physical_loc (UNKNOWN_LOCATION)
  {
    g.add_node_id (std::move (id), *this);
  }
  node (digraph &g, std::string id) {…}
  node (const node &) = delete;
 
  std::string
  get_id () const { return m_id; }
 
  const char *
  get_label () const
  {
    if (!m_label)
      return nullptr;
    return m_label->c_str ();
  }
  get_label () const {…}
 
  void
  set_label (const char *label)
  {
    if (label)
      m_label = std::make_unique<std::string> (label);
    else
      m_label = nullptr;
  }
  set_label (const char *label) {…}
  void
  set_label (std::string label)
  {
    m_label = std::make_unique<std::string> (std::move (label));
  }
  set_label (std::string label) {…}
 
  size_t
  get_num_children () const { return m_children.size (); }
 
  node &
  get_child (size_t idx) const { return *m_children[idx].get (); }
 
  void
  add_child (std::unique_ptr<node> child)
  {
    gcc_assert (child);
    m_children.push_back (std::move (child));
  }
  add_child (std::unique_ptr<node> child) {…}
 
  location_t
  get_physical_loc () const
  {
    return m_physical_loc;
  }
  get_physical_loc () const {…}
 
  void
  set_physical_loc (location_t physical_loc)
  {
    m_physical_loc = physical_loc;
  }
  set_physical_loc (location_t physical_loc) {…}
 
  logical_location
  get_logical_loc () const
  {
    return m_logical_loc;
  }
  get_logical_loc () const {…}
 
  void
  set_logical_loc (logical_location logical_loc)
  {
    m_logical_loc = logical_loc;
  }
  set_logical_loc (logical_location logical_loc) {…}
 
  void print (graphviz_out &gv) const;
 
  void
  dump () const;
 
  std::unique_ptr<json::object>
  to_json_sarif_node () const;
 
  std::unique_ptr<node>
  clone (digraph &new_graph,
         std::map<node *, node *> &node_mapping) const;
 
 private:
  std::string m_id;
  std::unique_ptr<std::string> m_label;
  std::vector<std::unique_ptr<node>> m_children;
  location_t m_physical_loc;
  logical_location m_logical_loc;
};
class node : public object {…};
 
// An edge in a directed graph, corresponding to SARIF v2.1.0 section 3.41.
 
class edge : public object
{
 public:
  virtual ~edge () {}
 
  /* SARIF requires us to provide unique edge IDs within a graph,
     but otherwise we don't need them.
     Pass in nullptr for the id to get the graph to generate a unique
     edge id for us.  */
  edge (digraph &g,
        const char *id,
        node &src_node,
        node &dst_node)
  : m_id (g.make_edge_id (id)),
    m_src_node (src_node),
    m_dst_node (dst_node)
  {
    g.add_edge_id (m_id, *this);
  }
  edge (digraph &g, {…}
 
  std::string
  get_id () const { return m_id; }
 
  const char *
  get_label () const
  {
    if (!m_label)
      return nullptr;
    return m_label->c_str ();
  }
  get_label () const {…}
 
  void
  set_label (const char *label)
  {
    if (label)
      m_label = std::make_unique<std::string> (label);
    else
      m_label = nullptr;
  }
  set_label (const char *label) {…}
 
  node &
  get_src_node () const { return m_src_node; }
 
  node &
  get_dst_node () const { return m_dst_node; }
 
  void
  dump () const;
 
  std::unique_ptr<json::object>
  to_json_sarif_edge () const;
 
  std::unique_ptr<edge>
  clone (digraph &new_graph,
         const std::map<diagnostics::digraphs::node *, diagnostics::digraphs::node *> &node_mapping) const;
 
private:
  std::string m_id;
  std::unique_ptr<std::string> m_label;
  node &m_src_node;
  node &m_dst_node;
};
class edge : public object {…};
 
/* Abstract base class for lazily creating
   a digraph on demand.
 
   This allows us to avoid the work of creating the digraph for
   the common case where we just have a text sink.  */
 
class lazy_digraph
{
public:
  virtual ~lazy_digraph () {}
 
  const digraph &
  get_or_create_digraph () const;
 
private:
  virtual std::unique_ptr<digraph>
  create_digraph () const = 0;
 
  mutable std::unique_ptr<digraph> m_digraph;
};
class lazy_digraph {…};
 
/* Abstract base class for lazily creating a collection of
   digraphs on demand.
 
   This allows us to avoid the work of creating the digraphs for
   the common case where we just have a text sink.  */
 
class lazy_digraphs
{
public:
  virtual ~lazy_digraphs () {}
 
  const std::vector<std::unique_ptr<digraph>> &
  get_or_create_digraphs () const;
 
private:
  virtual std::unique_ptr<std::vector<std::unique_ptr<digraph>>>
  create_digraphs () const = 0;
 
  mutable std::unique_ptr<std::vector<std::unique_ptr<digraph>>> m_digraphs;
};
class lazy_digraphs {…};
 
} // namespace digraphs
namespace digraphs {…}
} // namespace diagnostics
namespace diagnostics {…}
 
#endif /* ! GCC_DIAGNOSTIC_DIGRAPHS_H */