https://gcc.gnu.org/g:2a2f878d01fe45f7b2163cee2aed6fd2e5850719

commit r17-6299-g2a2f878d01fe45f7b2163cee2aed6fd2e5850719
Author: David Malcolm <[email protected]>
Date:   Sun Nov 15 14:32:20 2026 -0500

    analyzer: convert enum memory_space to enum class
    
    Modernization; no functional change intended.
    
    gcc/analyzer/ChangeLog:
            * bounds-checking.cc (enum memory_space): Convert to "enum class
            memory_space" throughout, renaming values accordingly.
            * checker-event.cc: Likewise.
            * checker-event.h: Likewise.
            * diagnostic-manager.cc: Likewise.
            * kf.cc: Likewise.
            * region-model.cc: Likewise.
            * region-model.h: Likewise.
            * region.cc: Likewise.
            * region.h: Likewise.
            * sm-malloc.cc: Likewise.
            * sm-taint.cc: Likewise.
            * store.cc: Likewise.
    
    Signed-off-by: David Malcolm <[email protected]>

Diff:
---
 gcc/analyzer/bounds-checking.cc    | 27 ++++++++++++++-------------
 gcc/analyzer/checker-event.cc      |  4 ++--
 gcc/analyzer/checker-event.h       |  4 ++--
 gcc/analyzer/diagnostic-manager.cc |  6 +++---
 gcc/analyzer/kf.cc                 | 14 +++++++-------
 gcc/analyzer/region-model.cc       | 25 ++++++++++++++-----------
 gcc/analyzer/region-model.h        |  2 +-
 gcc/analyzer/region.cc             | 32 ++++++++++++++++----------------
 gcc/analyzer/region.h              | 20 ++++++++++----------
 gcc/analyzer/sm-malloc.cc          | 25 +++++++++++++------------
 gcc/analyzer/sm-taint.cc           | 10 +++++-----
 gcc/analyzer/store.cc              |  8 ++++----
 12 files changed, 91 insertions(+), 86 deletions(-)

diff --git a/gcc/analyzer/bounds-checking.cc b/gcc/analyzer/bounds-checking.cc
index 83ed9d172c11..0d6f1dca918a 100644
--- a/gcc/analyzer/bounds-checking.cc
+++ b/gcc/analyzer/bounds-checking.cc
@@ -125,7 +125,8 @@ public:
   virtual enum access_direction get_dir () const = 0;
 
 protected:
-  enum memory_space get_memory_space () const
+  memory_space
+  get_memory_space () const
   {
     return m_access_range.get_base_region ().get_memory_space ();
   }
@@ -349,11 +350,11 @@ public:
        ctxt.add_cwe (787);
        warned = ctxt.warn ("buffer overflow");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        ctxt.add_cwe (121);
        warned = ctxt.warn ("stack-based buffer overflow");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        ctxt.add_cwe (122);
        warned = ctxt.warn ("heap-based buffer overflow");
        break;
@@ -532,10 +533,10 @@ public:
       default:
        warned = ctxt.warn ("buffer over-read");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        warned = ctxt.warn ("stack-based buffer over-read");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        warned = ctxt.warn ("heap-based buffer over-read");
        break;
       }
@@ -715,10 +716,10 @@ public:
       default:
        warned = ctxt.warn ("buffer underwrite");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        warned = ctxt.warn ("stack-based buffer underwrite");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        warned = ctxt.warn ("heap-based buffer underwrite");
        break;
       }
@@ -841,10 +842,10 @@ public:
       default:
        warned = ctxt.warn ("buffer under-read");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        warned = ctxt.warn ("stack-based buffer under-read");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        warned = ctxt.warn ("heap-based buffer under-read");
        break;
       }
@@ -1024,11 +1025,11 @@ public:
        ctxt.add_cwe (787);
        warned = ctxt.warn ("buffer overflow");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        ctxt.add_cwe (121);
        warned = ctxt.warn ("stack-based buffer overflow");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        ctxt.add_cwe (122);
        warned =  ctxt.warn ("heap-based buffer overflow");
        break;
@@ -1156,11 +1157,11 @@ public:
        ctxt.add_cwe (787);
        warned = ctxt.warn ("buffer over-read");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        ctxt.add_cwe (121);
        warned = ctxt.warn ("stack-based buffer over-read");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        ctxt.add_cwe (122);
        warned = ctxt.warn ("heap-based buffer over-read");
        break;
diff --git a/gcc/analyzer/checker-event.cc b/gcc/analyzer/checker-event.cc
index 6ded235a2874..a44db6b57e3a 100644
--- a/gcc/analyzer/checker-event.cc
+++ b/gcc/analyzer/checker-event.cc
@@ -412,10 +412,10 @@ region_creation_event_memory_space::print_desc 
(pretty_printer &pp) const
     default:
       pp_string (&pp, "region created here");
       return;
-    case MEMSPACE_STACK:
+    case memory_space::stack:
       pp_string (&pp, "region created on stack here");
       return;
-    case MEMSPACE_HEAP:
+    case memory_space::heap:
       pp_string (&pp, "region created on heap here");
       return;
     }
diff --git a/gcc/analyzer/checker-event.h b/gcc/analyzer/checker-event.h
index edf81e907ebe..e1c36333cdbb 100644
--- a/gcc/analyzer/checker-event.h
+++ b/gcc/analyzer/checker-event.h
@@ -300,7 +300,7 @@ protected:
 class region_creation_event_memory_space : public region_creation_event
 {
 public:
-  region_creation_event_memory_space (enum memory_space mem_space,
+  region_creation_event_memory_space (memory_space mem_space,
                                      const event_loc_info &loc_info)
   : region_creation_event (loc_info),
     m_mem_space (mem_space)
@@ -310,7 +310,7 @@ public:
   void print_desc (pretty_printer &pp) const final override;
 
 private:
-  enum memory_space m_mem_space;
+  memory_space m_mem_space;
 };
 
 /* Concrete subclass of region_creation_event.
diff --git a/gcc/analyzer/diagnostic-manager.cc 
b/gcc/analyzer/diagnostic-manager.cc
index 94e23c7ad761..f117fee4e217 100644
--- a/gcc/analyzer/diagnostic-manager.cc
+++ b/gcc/analyzer/diagnostic-manager.cc
@@ -2024,9 +2024,9 @@ diagnostic_manager::build_emission_path (const 
path_builder &pb,
        {
        default:
          continue;
-       case MEMSPACE_CODE:
-       case MEMSPACE_GLOBALS:
-       case MEMSPACE_READONLY_DATA:
+       case memory_space::code:
+       case memory_space::globals:
+       case memory_space::read_only_data:
          {
            const region *base_reg = reg->get_base_region ();
            if (tree decl = base_reg->maybe_get_decl ())
diff --git a/gcc/analyzer/kf.cc b/gcc/analyzer/kf.cc
index 6ba997af472a..b0c3e5647cc3 100644
--- a/gcc/analyzer/kf.cc
+++ b/gcc/analyzer/kf.cc
@@ -1613,18 +1613,18 @@ public:
       = model->deref_rvalue (ptr_sval, cd.get_arg_tree (0), ctxt);
     model->get_store ()->mark_as_escaped (reg->get_base_region (),
                                          model->get_baseline_state ());
-    enum memory_space mem_space = reg->get_memory_space ();
+    memory_space mem_space = reg->get_memory_space ();
     switch (mem_space)
       {
       default:
        gcc_unreachable ();
-      case MEMSPACE_UNKNOWN:
-      case MEMSPACE_CODE:
-      case MEMSPACE_GLOBALS:
-      case MEMSPACE_HEAP:
-      case MEMSPACE_READONLY_DATA:
+      case memory_space::unknown:
+      case memory_space::code:
+      case memory_space::globals:
+      case memory_space::heap:
+      case memory_space::read_only_data:
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        if (ctxt)
          ctxt->warn (std::make_unique<putenv_of_auto_var> (fndecl, reg));
        break;
diff --git a/gcc/analyzer/region-model.cc b/gcc/analyzer/region-model.cc
index e80574d52c7a..24101bbf6190 100644
--- a/gcc/analyzer/region-model.cc
+++ b/gcc/analyzer/region-model.cc
@@ -1500,8 +1500,8 @@ region_model::on_assignment (const gassign *assign, 
region_model_context *ctxt)
      as externally visible.  */
   if (ctxt)
     {
-      enum memory_space memspace = lhs_reg->get_memory_space ();
-      if (memspace != MEMSPACE_STACK)
+      memory_space memspace = lhs_reg->get_memory_space ();
+      if (memspace != memory_space::stack)
        ctxt->maybe_did_work ();
     }
 
@@ -6930,7 +6930,7 @@ public:
   {
     /* CWE-200: Exposure of Sensitive Information to an Unauthorized Actor.  */
     ctxt.add_cwe (200);
-    enum memory_space mem_space = get_src_memory_space ();
+    memory_space mem_space = get_src_memory_space ();
     bool warned;
     switch (mem_space)
       {
@@ -6939,12 +6939,12 @@ public:
                            " by copying uninitialized data"
                            " across trust boundary");
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        warned = ctxt.warn ("potential exposure of sensitive information"
                            " by copying uninitialized data from stack"
                            " across trust boundary");
        break;
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        warned = ctxt.warn ("potential exposure of sensitive information"
                            " by copying uninitialized data from heap"
                            " across trust boundary");
@@ -6956,7 +6956,7 @@ public:
        inform_number_of_uninit_bits (loc);
        complain_about_uninit_ranges (loc);
 
-       if (mem_space == MEMSPACE_STACK)
+       if (mem_space == memory_space::stack)
          maybe_emit_fixit_hint ();
       }
     return warned;
@@ -6966,18 +6966,18 @@ public:
   describe_final_event (pretty_printer &pp,
                        const evdesc::final_event &) final override
   {
-    enum memory_space mem_space = get_src_memory_space ();
+    memory_space mem_space = get_src_memory_space ();
     switch (mem_space)
       {
       default:
        pp_string (&pp, "uninitialized data copied here");
        return true;
 
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        pp_string (&pp, "uninitialized data copied from stack here");
        return true;
 
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        pp_string (&pp, "uninitialized data copied from heap here");
        return true;
       }
@@ -7002,9 +7002,12 @@ public:
   }
 
 private:
-  enum memory_space get_src_memory_space () const
+  memory_space
+  get_src_memory_space () const
   {
-    return m_src_region ? m_src_region->get_memory_space () : MEMSPACE_UNKNOWN;
+    return (m_src_region
+           ? m_src_region->get_memory_space ()
+           : memory_space::unknown);
   }
 
   const symbolic_bit_size &
diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h
index fc1691954c38..0fc4729056ba 100644
--- a/gcc/analyzer/region-model.h
+++ b/gcc/analyzer/region-model.h
@@ -730,7 +730,7 @@ private:
                         region_model_context *ctxt,
                         enum poison_kind pkind) const;
 
-  void check_dynamic_size_for_taint (enum memory_space mem_space,
+  void check_dynamic_size_for_taint (memory_space mem_space,
                                     const svalue *size_in_bytes,
                                     region_model_context *ctxt) const;
   void check_dynamic_size_for_floats (const svalue *size_in_bytes,
diff --git a/gcc/analyzer/region.cc b/gcc/analyzer/region.cc
index 3a4ee52cd513..6a933dd25abe 100644
--- a/gcc/analyzer/region.cc
+++ b/gcc/analyzer/region.cc
@@ -159,7 +159,7 @@ region::maybe_get_frame_region () const
 
 /* Get the memory space of this region.  */
 
-enum memory_space
+memory_space
 region::get_memory_space () const
 {
   const region *iter = this;
@@ -170,22 +170,22 @@ region::get_memory_space () const
        default:
          break;
        case RK_GLOBALS:
-         return MEMSPACE_GLOBALS;
+         return memory_space::globals;
        case RK_CODE:
        case RK_FUNCTION:
        case RK_LABEL:
-         return MEMSPACE_CODE;
+         return memory_space::code;
        case RK_FRAME:
        case RK_STACK:
        case RK_ALLOCA:
-         return MEMSPACE_STACK;
+         return memory_space::stack;
        case RK_HEAP:
        case RK_HEAP_ALLOCATED:
-         return MEMSPACE_HEAP;
+         return memory_space::heap;
        case RK_STRING:
-         return MEMSPACE_READONLY_DATA;
+         return memory_space::read_only_data;
        case RK_PRIVATE:
-         return MEMSPACE_PRIVATE;
+         return memory_space::private_;
        case RK_SYMBOLIC:
          {
            auto *sym_reg = as_a<const symbolic_region *> (iter);
@@ -197,7 +197,7 @@ region::get_memory_space () const
        }
       iter = iter->get_parent_region ();
     }
-  return MEMSPACE_UNKNOWN;
+  return memory_space::unknown;
 }
 
 /* Subroutine for use by region_model_manager::get_or_create_initial_value.
@@ -211,24 +211,24 @@ region::can_have_initial_svalue_p () const
   const region *base_reg = get_base_region ();
 
   /* Check for memory spaces that are uninitialized by default.  */
-  enum memory_space mem_space = base_reg->get_memory_space ();
+  memory_space mem_space = base_reg->get_memory_space ();
   switch (mem_space)
     {
     default:
       gcc_unreachable ();
-    case MEMSPACE_UNKNOWN:
-    case MEMSPACE_CODE:
-    case MEMSPACE_GLOBALS:
-    case MEMSPACE_READONLY_DATA:
-    case MEMSPACE_PRIVATE:
+    case memory_space::unknown:
+    case memory_space::code:
+    case memory_space::globals:
+    case memory_space::read_only_data:
+    case memory_space::private_:
       /* Such regions have initial_svalues.  */
       return true;
 
-    case MEMSPACE_HEAP:
+    case memory_space::heap:
       /* Heap allocations are uninitialized by default.  */
       return false;
 
-    case MEMSPACE_STACK:
+    case memory_space::stack:
       if (tree decl = base_reg->maybe_get_decl ())
        {
          /* See the assertion in frame_region::get_region_for_local for the
diff --git a/gcc/analyzer/region.h b/gcc/analyzer/region.h
index 2e19cdeb8166..20434e96f082 100644
--- a/gcc/analyzer/region.h
+++ b/gcc/analyzer/region.h
@@ -32,16 +32,16 @@ namespace ana {
 
 /* An enum for identifying different spaces within memory.  */
 
-enum memory_space
+enum class memory_space
 {
-  MEMSPACE_UNKNOWN,
-  MEMSPACE_CODE,
-  MEMSPACE_GLOBALS,
-  MEMSPACE_STACK,
-  MEMSPACE_HEAP,
-  MEMSPACE_READONLY_DATA,
-  MEMSPACE_THREAD_LOCAL,
-  MEMSPACE_PRIVATE
+  unknown,
+  code,
+  globals,
+  stack,
+  heap,
+  read_only_data,
+  thread_local_,
+  private_
 };
 
 /* An enum for discriminating between the different concrete subclasses
@@ -175,7 +175,7 @@ public:
   bool base_region_p () const;
   bool descendent_of_p (const region *elder) const;
   const frame_region *maybe_get_frame_region () const;
-  enum memory_space get_memory_space () const;
+  memory_space get_memory_space () const;
   bool can_have_initial_svalue_p () const;
   const svalue *get_initial_value_at_main (region_model_manager *mgr) const;
 
diff --git a/gcc/analyzer/sm-malloc.cc b/gcc/analyzer/sm-malloc.cc
index ad51dddcda03..54343caf0545 100644
--- a/gcc/analyzer/sm-malloc.cc
+++ b/gcc/analyzer/sm-malloc.cc
@@ -373,10 +373,10 @@ public:
          {
          default:
            break;
-         case MEMSPACE_CODE:
-         case MEMSPACE_GLOBALS:
-         case MEMSPACE_STACK:
-         case MEMSPACE_READONLY_DATA:
+         case memory_space::code:
+         case memory_space::globals:
+         case memory_space::stack:
+         case memory_space::read_only_data:
            return m_non_heap;
          }
       }
@@ -1525,17 +1525,17 @@ public:
     switch (get_memory_space ())
       {
       default:
-      case MEMSPACE_HEAP:
+      case memory_space::heap:
        gcc_unreachable ();
-      case MEMSPACE_UNKNOWN:
-      case MEMSPACE_CODE:
-      case MEMSPACE_GLOBALS:
-      case MEMSPACE_READONLY_DATA:
+      case memory_space::unknown:
+      case memory_space::code:
+      case memory_space::globals:
+      case memory_space::read_only_data:
        return ctxt.warn ("%qs of %qE which points to memory"
                          " not on the heap",
                          m_funcname, m_arg);
        break;
-      case MEMSPACE_STACK:
+      case memory_space::stack:
        return ctxt.warn ("%qs of %qE which points to memory"
                          " on the stack",
                          m_funcname, m_arg);
@@ -1566,12 +1566,13 @@ public:
   }
 
 private:
-  enum memory_space get_memory_space () const
+  memory_space
+  get_memory_space () const
   {
     if (m_freed_reg)
       return m_freed_reg->get_memory_space ();
     else
-      return MEMSPACE_UNKNOWN;
+      return memory_space::unknown;
   }
 
   const region *m_freed_reg;
diff --git a/gcc/analyzer/sm-taint.cc b/gcc/analyzer/sm-taint.cc
index 6165d504b727..36d1dfa4d880 100644
--- a/gcc/analyzer/sm-taint.cc
+++ b/gcc/analyzer/sm-taint.cc
@@ -717,7 +717,7 @@ class tainted_allocation_size : public taint_diagnostic
 public:
   tainted_allocation_size (const taint_state_machine &sm, tree arg,
                           const svalue *size_in_bytes,
-                          enum bounds has_bounds, enum memory_space mem_space)
+                          enum bounds has_bounds, memory_space mem_space)
   : taint_diagnostic (sm, arg, has_bounds),
     m_size_in_bytes (size_in_bytes),
     m_mem_space (mem_space)
@@ -800,10 +800,10 @@ public:
          {
          default:
            break;
-         case MEMSPACE_STACK:
+         case memory_space::stack:
            inform (loc, "stack-based allocation");
            break;
-         case MEMSPACE_HEAP:
+         case memory_space::heap:
            inform (loc, "heap-based allocation");
            break;
          }
@@ -875,7 +875,7 @@ public:
 
 private:
   const svalue *m_size_in_bytes;
-  enum memory_space m_mem_space;
+  memory_space m_mem_space;
 };
 
 /* Concrete taint_diagnostic subclass for reporting attacker-controlled
@@ -1805,7 +1805,7 @@ region_model::check_region_for_taint (const region *reg,
    is happening within MEM_SPACE.  */
 
 void
-region_model::check_dynamic_size_for_taint (enum memory_space mem_space,
+region_model::check_dynamic_size_for_taint (memory_space mem_space,
                                            const svalue *size_in_bytes,
                                            region_model_context *ctxt) const
 {
diff --git a/gcc/analyzer/store.cc b/gcc/analyzer/store.cc
index b4357e942ee0..8ccc2a7b34fe 100644
--- a/gcc/analyzer/store.cc
+++ b/gcc/analyzer/store.cc
@@ -1612,11 +1612,11 @@ store::eval_alias_1 (const region *base_reg_a,
 
   /* If they're in different memory spaces, they can't alias.  */
   {
-    enum memory_space memspace_a = base_reg_a->get_memory_space ();
-    if (memspace_a != MEMSPACE_UNKNOWN)
+    memory_space memspace_a = base_reg_a->get_memory_space ();
+    if (memspace_a != memory_space::unknown)
       {
-       enum memory_space memspace_b = base_reg_b->get_memory_space ();
-       if (memspace_b != MEMSPACE_UNKNOWN
+       memory_space memspace_b = base_reg_b->get_memory_space ();
+       if (memspace_b != memory_space::unknown
            && memspace_a != memspace_b)
          return tristate::TS_FALSE;
       }

Reply via email to