analyzer: make checker_event::m_kind private

No functional change intended.

gcc/analyzer/ChangeLog:
	* checker-event.h (checker_event::get_kind): New accessor.
	(checker_event::m_kind): Make private.
	* checker-path.cc (checker_path::maybe_log): Use accessor for
	checker_event::m_kind.
	(checker_path::add_event): Likewise.
	(checker_path::debug): Likewise.
	(checker_path::cfg_edge_pair_at_p): Likewise.
	(checker_path::inject_any_inlined_call_events): Likewise.
	* diagnostic-manager.cc
	(diagnostic_manager::prune_for_sm_diagnostic): Likewise.
	(diagnostic_manager::prune_for_sm_diagnostic): Likewise.
	(diagnostic_manager::consolidate_conditions): Likewise.
	(diagnostic_manager::consolidate_unwind_events): Likewise.
	(diagnostic_manager::finish_pruning): Likewise.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>

diff --git a/gcc/analyzer/checker-event.h b/gcc/analyzer/checker-event.h
index 2f26b8daaa6a518c27f999da0deaebbb74deda47..e29173a439d188fc505cef88b0fcd463bc84282c 100644 (file)
--- a/gcc/analyzer/checker-event.h
+++ b/gcc/analyzer/checker-event.h
@@ -116,6 +116,7 @@ public:
                              sarif_object &thread_flow_loc_obj) const override;
 
   /* Additional functionality.  */
+  enum event_kind get_kind () const { return m_kind; }
   tree get_fndecl () const { return m_effective_fndecl; }
 
   int get_original_stack_depth () const { return m_original_depth; }
@@ -142,7 +143,7 @@ protected:
   checker_event (enum event_kind kind,
                 const event_loc_info &loc_info);
 
- public:
+ private:
   const enum event_kind m_kind;
  protected:
   location_t m_loc;

diff --git a/gcc/analyzer/checker-path.cc b/gcc/analyzer/checker-path.cc
index 9bde6f2f8351c26b5fcd867817c236517acff7af..45593e0abe37573593adb324965e6708223a5c95 100644 (file)
--- a/gcc/analyzer/checker-path.cc
+++ b/gcc/analyzer/checker-path.cc
@@ -89,7 +89,7 @@ checker_path::maybe_log (logger *logger, const char *desc) const
     {
       logger->start_log_line ();
       logger->log_partial ("%s[%i]: %s ", desc, i,
-                          event_kind_to_string (m_events[i]->m_kind));
+                          event_kind_to_string (m_events[i]->get_kind ()));
       m_events[i]->dump (logger->get_printer ());
       logger->end_log_line ();
     }
@@ -103,7 +103,7 @@ checker_path::add_event (std::unique_ptr<checker_event> event)
       m_logger->start_log_line ();
       m_logger->log_partial ("added event[%i]: %s ",
                             m_events.length (),
-                            event_kind_to_string (event.get ()->m_kind));
+                            event_kind_to_string (event.get ()->get_kind ()));
       event.get ()->dump (m_logger->get_printer ());
       m_logger->end_log_line ();
     }
@@ -123,7 +123,7 @@ checker_path::debug () const
       fprintf (stderr,
               "[%i]: %s \"%s\"\n",
               i,
-              event_kind_to_string (m_events[i]->m_kind),
+              event_kind_to_string (m_events[i]->get_kind ()),
               event_desc.get ());
     }
 }
@@ -167,8 +167,8 @@ checker_path::cfg_edge_pair_at_p (unsigned idx) const
 {
   if (m_events.length () < idx + 1)
     return false;
-  return (m_events[idx]->m_kind == event_kind::start_cfg_edge
-         && m_events[idx + 1]->m_kind == event_kind::end_cfg_edge);
+  return (m_events[idx]->get_kind () == event_kind::start_cfg_edge
+         && m_events[idx + 1]->get_kind () == event_kind::end_cfg_edge);
 }
 
 /* Consider a call from "outer" to "middle" which calls "inner",
@@ -254,7 +254,7 @@ checker_path::inject_any_inlined_call_events (logger *logger)
        {
          logger->start_log_line ();
          logger->log_partial ("event[%i]: %s ", ev_idx,
-                              event_kind_to_string (curr_event->m_kind));
+                              event_kind_to_string (curr_event->get_kind ()));
          curr_event->dump (logger->get_printer ());
          logger->end_log_line ();
          for (inlining_iterator iter (curr_event->get_location ());

diff --git a/gcc/analyzer/diagnostic-manager.cc b/gcc/analyzer/diagnostic-manager.cc
index e5d1a2571a0464a556b03d4d7c7764b9f66bea23..6867dd267e6af2bd900eb6bb67fa10440e793f83 100644 (file)
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -2599,19 +2599,19 @@ diagnostic_manager::prune_for_sm_diagnostic (checker_path *path,
                {
                  label_text sval_desc = sval->get_desc ();
                  log ("considering event %i (%s), with sval: %qs, state: %qs",
-                      idx, event_kind_to_string (base_event->m_kind),
+                      idx, event_kind_to_string (base_event->get_kind ()),
                       sval_desc.get (), state->get_name ());
                }
              else
                log ("considering event %i (%s), with global state: %qs",
-                    idx, event_kind_to_string (base_event->m_kind),
+                    idx, event_kind_to_string (base_event->get_kind ()),
                     state->get_name ());
            }
          else
            log ("considering event %i", idx);
        }
 
-      switch (base_event->m_kind)
+      switch (base_event->get_kind ())
        {
        default:
          gcc_unreachable ();
@@ -2718,7 +2718,7 @@ diagnostic_manager::prune_for_sm_diagnostic (checker_path *path,
                log ("filtering events %i and %i: CFG edge", idx, idx + 1);
                path->delete_event (idx);
                /* Also delete the corresponding event_kind::end_cfg_edge.  */
-               gcc_assert (path->get_checker_event (idx)->m_kind
+               gcc_assert (path->get_checker_event (idx)->get_kind ()
                            == event_kind::end_cfg_edge);
                path->delete_event (idx);
              }
@@ -3109,7 +3109,7 @@ diagnostic_manager::consolidate_conditions (checker_path *path) const
            continue;
 
          /* Are we looking for a run of all TRUE edges, or all FALSE edges?  */
-         gcc_assert (old_start_ev->m_kind == event_kind::start_cfg_edge);
+         gcc_assert (old_start_ev->get_kind () == event_kind::start_cfg_edge);
          const start_cfg_edge_event *old_start_cfg_ev
            = (const start_cfg_edge_event *)old_start_ev;
          const cfg_superedge& first_cfg_sedge
@@ -3132,7 +3132,7 @@ diagnostic_manager::consolidate_conditions (checker_path *path) const
            {
              const checker_event *iter_ev
                = path->get_checker_event (next_idx);
-             gcc_assert (iter_ev->m_kind == event_kind::start_cfg_edge);
+             gcc_assert (iter_ev->get_kind () == event_kind::start_cfg_edge);
              const start_cfg_edge_event *iter_cfg_ev
                = (const start_cfg_edge_event *)iter_ev;
              const cfg_superedge& iter_cfg_sedge
@@ -3190,11 +3190,13 @@ diagnostic_manager::consolidate_unwind_events (checker_path *path) const
        start_idx++)
     {
       /* Find a run of consecutive unwind_event instances.  */
-      if (path->get_checker_event (start_idx)->m_kind != event_kind::unwind)
+      if (path->get_checker_event (start_idx)->get_kind ()
+         != event_kind::unwind)
        continue;
       int iter_idx = start_idx + 1;
       while (iter_idx < (int)path->num_events ())
-       if (path->get_checker_event (iter_idx)->m_kind == event_kind::unwind)
+       if (path->get_checker_event (iter_idx)->get_kind ()
+           == event_kind::unwind)
          ++iter_idx;
        else
          break;
@@ -3232,7 +3234,7 @@ diagnostic_manager::finish_pruning (checker_path *path) const
       while (idx >= 0 && idx < (signed)path->num_events ())
        {
          checker_event *base_event = path->get_checker_event (idx);
-         if (base_event->m_kind == event_kind::function_entry)
+         if (base_event->get_kind () == event_kind::function_entry)
            {
              log ("filtering event %i:"
                   " function entry for purely intraprocedural path", idx);