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; }
