C++11: Use sized enums (+4% performance).

include/verilated.h

@@ -94,7 +94,7 @@ class VerilatedVcdSc;
 class VerilatedFst;
 class VerilatedFstC;
 
-enum VerilatedVarType {
+enum VerilatedVarType : vluint8_t {
     VLVT_UNKNOWN = 0,
     VLVT_PTR,  // Pointer to something
     VLVT_UINT8,  // AKA CData
@@ -313,7 +313,7 @@ public:  // But for internal use only
 
 class VerilatedScope {
 public:
-    typedef enum {
+    typedef enum : vluint8_t {
         SCOPE_MODULE,
         SCOPE_OTHER
     } Type;  // Type of a scope, currently module is only interesting

include/verilated_trace.h

@@ -87,7 +87,7 @@ class VerilatedTraceCommand {
 public:
     // These must all fit in 4 bit at the moment, as the tracing routines
     // pack parameters in the top bits.
-    enum {
+    enum : vluint8_t {
         CHG_BIT_0 = 0x0,
         CHG_BIT_1 = 0x1,
         CHG_CDATA = 0x2,

include/verilated_vpi.cpp

@@ -965,10 +965,10 @@ const char* VerilatedVpiError::strFromVpiProp(PLI_INT32 vpiVal) VL_MT_SAFE {
         VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); \
     }
 
-#define SELF_CHECK_ENUM_STR(fn, enum) \
+#define SELF_CHECK_ENUM_STR(fn, enumn) \
     do { \
-        const char* strVal = VerilatedVpiError::fn(enum); \
-        SELF_CHECK_RESULT_CSTR(strVal, #enum); \
+        const char* strVal = VerilatedVpiError::fn(enumn); \
+        SELF_CHECK_RESULT_CSTR(strVal, #enumn); \
     } while (0)
 
 void VerilatedVpi::selfTest() VL_MT_UNSAFE_ONE { VerilatedVpiError::selfTest(); }

src/V3Active.cpp

@@ -141,7 +141,7 @@ public:
 
 class ActiveDlyVisitor : public ActiveBaseVisitor {
 public:
-    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
+    enum CheckType : uint8_t { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 
 private:
     CheckType m_check;  // Combo logic or other

src/V3Ast.h

@@ -96,7 +96,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstType& rhs) { return o
 
 class VLifetime {
 public:
-    enum en { NONE, AUTOMATIC, STATIC };
+    enum en : uint8_t { NONE, AUTOMATIC, STATIC };
     enum en m_e;
     const char* ascii() const {
         static const char* const names[] = {"NONE", "VAUTOM", "VSTATIC"};
@@ -125,7 +125,7 @@ inline std::ostream& operator<<(std::ostream& os, const VLifetime& rhs) {
 
 class VSigning {
 public:
-    enum en {
+    enum en : uint8_t {
         UNSIGNED,
         SIGNED,
         NOSIGN,
@@ -162,7 +162,7 @@ inline std::ostream& operator<<(std::ostream& os, const VSigning& rhs) {
 
 class AstPragmaType {
 public:
-    enum en {
+    enum en : uint8_t {
         ILLEGAL,
         COVERAGE_BLOCK_OFF,
         HIER_BLOCK,
@@ -195,7 +195,7 @@ inline bool operator==(AstPragmaType::en lhs, const AstPragmaType& rhs) { return
 
 class AstCFuncType {
 public:
-    enum en {
+    enum en : uint8_t {
         FT_NORMAL,
         TRACE_REGISTER,
         TRACE_INIT,
@@ -229,7 +229,7 @@ inline bool operator==(AstCFuncType::en lhs, const AstCFuncType& rhs) { return l
 class VEdgeType {
 public:
     // REMEMBER to edit the strings below too
-    enum en {
+    enum en : uint8_t {
         // These must be in general -> most specific order, as we sort by it
         // in V3Const::visit AstSenTree
         ET_ILLEGAL,
@@ -315,7 +315,7 @@ inline bool operator==(VEdgeType::en lhs, const VEdgeType& rhs) { return lhs ==
 class AstAttrType {
 public:
     // clang-format off
-    enum en {
+    enum en: uint8_t  {
         ILLEGAL,
         //
         DIM_BITS,                       // V3Const converts to constant
@@ -396,7 +396,7 @@ inline bool operator==(AstAttrType::en lhs, const AstAttrType& rhs) { return lhs
 
 class AstBasicDTypeKwd {
 public:
-    enum en {
+    enum en : uint8_t {
         UNKNOWN,
         BIT,
         BYTE,
@@ -532,7 +532,7 @@ inline bool operator==(AstBasicDTypeKwd::en lhs, const AstBasicDTypeKwd& rhs) {
 
 class VDirection {
 public:
-    enum en { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF };
+    enum en : uint8_t { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF };
     enum en m_e;
     inline VDirection()
         : m_e{NONE} {}
@@ -577,7 +577,7 @@ inline std::ostream& operator<<(std::ostream& os, const VDirection& rhs) {
 /// Boolean or unknown
 class VBoolOrUnknown {
 public:
-    enum en { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END };
+    enum en : uint8_t { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
     inline VBoolOrUnknown()
@@ -616,7 +616,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBoolOrUnknown& rhs) {
 /// Join type
 class VJoinType {
 public:
-    enum en { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 };
+    enum en : uint8_t { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
     inline VJoinType()
@@ -649,7 +649,7 @@ inline std::ostream& operator<<(std::ostream& os, const VJoinType& rhs) {
 
 class AstVarType {
 public:
-    enum en {
+    enum en : uint8_t {
         UNKNOWN,
         GPARAM,
         LPARAM,
@@ -717,7 +717,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstVarType& rhs) {
 
 class VBranchPred {
 public:
-    enum en { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END };
+    enum en : uint8_t { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
     inline VBranchPred()
@@ -758,7 +758,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBranchPred& rhs) {
 
 class VVarAttrClocker {
 public:
-    enum en { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END };
+    enum en : uint8_t { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
     inline VVarAttrClocker()
@@ -801,7 +801,7 @@ inline std::ostream& operator<<(std::ostream& os, const VVarAttrClocker& rhs) {
 
 class VAlwaysKwd {
 public:
-    enum en { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB };
+    enum en : uint8_t { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB };
     enum en m_e;
     inline VAlwaysKwd()
         : m_e{ALWAYS} {}
@@ -824,7 +824,7 @@ inline bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lhs =
 
 class VCaseType {
 public:
-    enum en { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
+    enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
     enum en m_e;
     inline VCaseType()
         : m_e{CT_CASE} {}
@@ -843,7 +843,7 @@ inline bool operator==(VCaseType::en lhs, const VCaseType& rhs) { return lhs ==
 
 class AstDisplayType {
 public:
-    enum en { DT_DISPLAY, DT_WRITE, DT_INFO, DT_ERROR, DT_WARNING, DT_FATAL };
+    enum en : uint8_t { DT_DISPLAY, DT_WRITE, DT_INFO, DT_ERROR, DT_WARNING, DT_FATAL };
     enum en m_e;
     inline AstDisplayType()
         : m_e{DT_DISPLAY} {}
@@ -875,7 +875,7 @@ inline bool operator==(AstDisplayType::en lhs, const AstDisplayType& rhs) {
 
 class VDumpCtlType {
 public:
-    enum en { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON };
+    enum en : uint8_t { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON };
     enum en m_e;
     inline VDumpCtlType()
         : m_e{ON} {}
@@ -901,7 +901,7 @@ inline bool operator==(VDumpCtlType::en lhs, const VDumpCtlType& rhs) { return l
 
 class VParseRefExp {
 public:
-    enum en {
+    enum en : uint8_t {
         PX_NONE,  // Used in V3LinkParse only
         PX_ROOT,
         PX_TEXT  // Unknown ID component
@@ -1014,7 +1014,7 @@ inline std::ostream& operator<<(std::ostream& os, const VNumRange& rhs) {
 
 class VUseType {
 public:
-    enum en {
+    enum en : uint8_t {
         IMP_INCLUDE,  // Implementation (.cpp) needs an include
         INT_INCLUDE,  // Interface (.h) needs an include
         IMP_FWD_CLASS,  // Implementation (.cpp) needs a forward class declaration
@@ -1262,7 +1262,14 @@ public:
 class AstNRelinker {
 protected:
     friend class AstNode;
-    enum RelinkWhatEn { RELINK_BAD, RELINK_NEXT, RELINK_OP1, RELINK_OP2, RELINK_OP3, RELINK_OP4 };
+    enum RelinkWhatEn : uint8_t {
+        RELINK_BAD,
+        RELINK_NEXT,
+        RELINK_OP1,
+        RELINK_OP2,
+        RELINK_OP3,
+        RELINK_OP4
+    };
     AstNode* m_oldp = nullptr;  // The old node that was linked to this point in the tree
     AstNode* m_backp = nullptr;
     RelinkWhatEn m_chg = RELINK_BAD;

src/V3Clean.cpp

@@ -47,7 +47,7 @@ private:
     AstUser3InUse m_inuser3;
 
     // TYPES
-    enum CleanState { CS_UNKNOWN, CS_CLEAN, CS_DIRTY };
+    enum CleanState : uint8_t { CS_UNKNOWN, CS_CLEAN, CS_DIRTY };
 
     // STATE
     AstNodeModule* m_modp = nullptr;

src/V3Combine.cpp

@@ -171,7 +171,7 @@ private:
     // AstUser4InUse     part of V3Hashed
 
     // STATE
-    typedef enum { STATE_IDLE, STATE_HASH, STATE_DUP } CombineState;
+    typedef enum : uint8_t { STATE_IDLE, STATE_HASH, STATE_DUP } CombineState;
     VDouble0 m_statCombs;  // Statistic tracking
     CombineState m_state = STATE_IDLE;  // Major state
     AstNodeModule* m_modp = nullptr;  // Current module

src/V3Const.cpp

@@ -2528,7 +2528,7 @@ private:
 
 public:
     // Processing Mode Enum
-    enum ProcMode {
+    enum ProcMode : uint8_t {
         PROC_PARAMS,
         PROC_GENERATE,
         PROC_LIVE,

src/V3Delayed.cpp

@@ -86,7 +86,7 @@ private:
     AstUser4InUse m_inuser4;
     AstUser5InUse m_inuser5;
 
-    enum VarUsage { VU_NONE = 0, VU_DLY = 1, VU_NONDLY = 2 };
+    enum VarUsage : uint8_t { VU_NONE = 0, VU_DLY = 1, VU_NONDLY = 2 };
 
     // STATE
     AstActive* m_activep = nullptr;  // Current activate

src/V3EmitC.cpp

@@ -75,7 +75,7 @@ public:
                     char fmtLetter);
 
     void emitVarDecl(const AstVar* nodep, const string& prefixIfImp);
-    typedef enum {
+    typedef enum : uint8_t {
         EVL_CLASS_IO,
         EVL_CLASS_SIG,
         EVL_CLASS_TEMP,

src/V3Error.h

@@ -35,7 +35,7 @@
 class V3ErrorCode {
 public:
     // clang-format off
-    enum en {
+    enum en: uint8_t  {
         EC_MIN=0,       // Keep first
         //
         EC_INFO,        // General information out

src/V3File.h

@@ -103,8 +103,8 @@ class V3OutFormatter {
     // TYPES
     enum MiscConsts { MAXSPACE = 80 };  // After this indent, stop indenting more
 public:
-    enum AlignClass { AL_AUTO = 0, AL_STATIC = 1 };
-    enum Language {
+    enum AlignClass : uint8_t { AL_AUTO = 0, AL_STATIC = 1 };
+    enum Language : uint8_t {
         LA_C = 0,
         LA_VERILOG = 1,
         LA_MK = 2,

src/V3Global.h

@@ -43,7 +43,7 @@ class V3HierBlockPlan;
 
 class VWidthMinUsage {
 public:
-    enum en { LINT_WIDTH, MATCHES_WIDTH, VERILOG_WIDTH };
+    enum en : uint8_t { LINT_WIDTH, MATCHES_WIDTH, VERILOG_WIDTH };
     enum en m_e;
     inline VWidthMinUsage()
         : m_e{LINT_WIDTH} {}

src/V3Graph.h

@@ -47,7 +47,7 @@ typedef bool (*V3EdgeFuncP)(const V3GraphEdge* edgep);
 
 class GraphWay {
 public:
-    enum en {
+    enum en : uint8_t {
         FORWARD = 0,
         REVERSE = 1,
         NUM_WAYS = 2  // NUM_WAYS is not an actual way, it's typically
@@ -277,7 +277,7 @@ class V3GraphEdge {
     // Wires/variables aren't edges.  Edges have only a single to/from vertex
 public:
     // ENUMS
-    enum Cutable { NOT_CUTABLE = false, CUTABLE = true };  // For passing to V3GraphEdge
+    enum Cutable : uint8_t { NOT_CUTABLE = false, CUTABLE = true };  // For passing to V3GraphEdge
 protected:
     friend class V3Graph;
     friend class V3GraphVertex;

src/V3Inline.cpp

@@ -58,7 +58,7 @@ private:
     AstUser4InUse m_inuser4;
 
     // For the user2 field:
-    enum {
+    enum : uint8_t {
         CIL_NOTHARD = 0,  // Inline not supported
         CIL_NOTSOFT,  // Don't inline unless user overrides
         CIL_MAYBE,  // Might inline

src/V3LangCode.h

@@ -30,7 +30,7 @@
 //! file).
 class V3LangCode {
 public:
-    enum en {
+    enum en : uint8_t {
         L_ERROR,  // Must be first.
         L1364_1995,
         L1364_2001,

src/V3LinkDot.cpp

@@ -134,7 +134,7 @@ private:
 public:
     // ENUMS
     // In order of priority, compute first ... compute last
-    enum SAMNum { SAMN_MODPORT, SAMN_IFTOP, SAMN__MAX };  // Values for m_scopeAliasMap
+    enum SAMNum : uint8_t { SAMN_MODPORT, SAMN_IFTOP, SAMN__MAX };  // Values for m_scopeAliasMap
 
 private:
     // TYPES
@@ -1687,7 +1687,7 @@ private:
     AstUser5InUse m_inuser5;
 
     // TYPES
-    enum DotPosition {
+    enum DotPosition : uint8_t {
         DP_NONE = 0,  // Not under a DOT
         DP_PACKAGE,  // {package}:: DOT
         DP_SCOPE,  // [DOT...] {scope-or-var} DOT

src/V3LinkDot.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-enum VLinkDotStep { LDS_PRIMARY, LDS_PARAMED, LDS_ARRAYED, LDS_SCOPED };
+enum VLinkDotStep : uint8_t { LDS_PRIMARY, LDS_PARAMED, LDS_ARRAYED, LDS_SCOPED };
 
 class V3LinkDot {
 private:

src/V3LinkInc.cpp

@@ -50,7 +50,7 @@
 class LinkIncVisitor : public AstNVisitor {
 private:
     // TYPES
-    enum InsertMode {
+    enum InsertMode : uint8_t {
         IM_BEFORE,  // Pointing at statement ref is in, insert before this
         IM_AFTER,  // Pointing at last inserted stmt, insert after
         IM_WHILE_PRECOND  // Pointing to for loop, add to body end

src/V3Options.cpp

@@ -1625,7 +1625,12 @@ void V3Options::parseOptsFile(FileLine* fl, const string& filename, bool rel) {
     std::vector<string> args;
 
     // Parse file using a state machine, taking into account quoted strings and escaped chars
-    enum state { ST_IN_OPTION, ST_ESCAPED_CHAR, ST_IN_QUOTED_STR, ST_IN_DOUBLE_QUOTED_STR };
+    enum state : uint8_t {
+        ST_IN_OPTION,
+        ST_ESCAPED_CHAR,
+        ST_IN_QUOTED_STR,
+        ST_IN_DOUBLE_QUOTED_STR
+    };
 
     state st = ST_IN_OPTION;
     state last_st = ST_IN_OPTION;

src/V3Options.h

@@ -37,7 +37,7 @@ class VOptionBool {
     // Class to track options that are either not specified (and default
     // true/false), versus user setting the option to true or false
 public:
-    enum en { OPT_DEFAULT_FALSE = 0, OPT_DEFAULT_TRUE, OPT_TRUE, OPT_FALSE, _ENUM_END };
+    enum en : uint8_t { OPT_DEFAULT_FALSE = 0, OPT_DEFAULT_TRUE, OPT_TRUE, OPT_FALSE, _ENUM_END };
     enum en m_e;
     inline VOptionBool()
         : m_e{OPT_DEFAULT_FALSE} {}
@@ -71,7 +71,7 @@ inline std::ostream& operator<<(std::ostream& os, const VOptionBool& rhs) {
 
 class VTimescale {
 public:
-    enum en {
+    enum en : uint8_t {
         // clang-format off
         TS_100S = 0, TS_10S = 1, TS_1S = 2,
         TS_100MS = 3, TS_10MS = 4, TS_1MS = 5,
@@ -83,7 +83,7 @@ public:
         NONE = 18,
         _ENUM_END
     };
-    enum { TS_DEFAULT = TS_1PS };
+    enum : uint8_t { TS_DEFAULT = TS_1PS };
     enum en m_e;
     // CONSTRUCTOR
     inline VTimescale()
@@ -169,7 +169,7 @@ inline std::ostream& operator<<(std::ostream& os, const VTimescale& rhs) {
 
 class TraceFormat {
 public:
-    enum en { VCD = 0, FST } m_e;
+    enum en : uint8_t { VCD = 0, FST } m_e;
     // cppcheck-suppress noExplicitConstructor
     inline TraceFormat(en _e = VCD)
         : m_e{_e} {}

src/V3Order.cpp

@@ -182,7 +182,7 @@ inline std::ostream& operator<<(std::ostream& lhs, const OrderMoveDomScope& rhs)
 // Order information stored under each AstNode::user1p()...
 
 // Types of vertex we can create
-enum WhichVertex { WV_STD, WV_PRE, WV_PORD, WV_POST, WV_SETL, WV_MAX };
+enum WhichVertex : uint8_t { WV_STD, WV_PRE, WV_PORD, WV_POST, WV_SETL, WV_MAX };
 
 class OrderUser {
     // Stored in AstVarScope::user1p, a list of all the various vertices
@@ -683,7 +683,7 @@ private:
     VDouble0 m_statCut[OrderVEdgeType::_ENUM_END];  // Count of each edge type cut
 
     // TYPES
-    enum VarUsage { VU_NONE = 0, VU_CON = 1, VU_GEN = 2 };
+    enum VarUsage : uint8_t { VU_NONE = 0, VU_CON = 1, VU_GEN = 2 };
 
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()
@@ -752,7 +752,7 @@ private:
         MTaskState() {}
     };
     void processMTasks();
-    typedef enum { LOGIC_INITIAL, LOGIC_SETTLE } InitialLogicE;
+    typedef enum : uint8_t { LOGIC_INITIAL, LOGIC_SETTLE } InitialLogicE;
     void processMTasksInitial(InitialLogicE logic_type);
 
     string cfuncName(AstNodeModule* modp, AstSenTree* domainp, AstScope* scopep,

src/V3OrderGraph.h

@@ -53,7 +53,7 @@ class OrderMoveDomScope;
 
 //######################################################################
 
-enum OrderWeights {
+enum OrderWeights : uint8_t {
     WEIGHT_INPUT = 1,  // Low weight just so dot graph looks nice
     WEIGHT_COMBO = 1,  // Breakable combo logic
     WEIGHT_POST = 2,  // Post-delayed used var
@@ -63,7 +63,7 @@ enum OrderWeights {
 };  // High weight just so dot graph looks nice
 
 struct OrderVEdgeType {
-    enum en {
+    enum en : uint8_t {
         VERTEX_UNKNOWN = 0,
         VERTEX_INPUTS,
         VERTEX_LOGIC,
@@ -322,7 +322,7 @@ public:
 //--- Following only under the move graph, not the main graph
 
 class OrderMoveVertex : public V3GraphVertex {
-    typedef enum { POM_WAIT, POM_READY, POM_MOVED } OrderMState;
+    typedef enum : uint8_t { POM_WAIT, POM_READY, POM_MOVED } OrderMState;
 
     OrderLogicVertex* m_logicp;
     OrderMState m_state;  // Movement state

src/V3Os.cpp

@@ -137,7 +137,7 @@ string V3Os::filenameNonExt(const string& filename) {
 
 string V3Os::filenameSubstitute(const string& filename) {
     string out;
-    enum { NONE, PAREN, CURLY } brackets = NONE;
+    enum : uint8_t { NONE, PAREN, CURLY } brackets = NONE;
     for (string::size_type pos = 0; pos < filename.length(); ++pos) {
         if ((filename[pos] == '$') && (pos + 1 < filename.length())) {
             switch (filename[pos + 1]) {

src/V3ParseImp.h

@@ -37,9 +37,9 @@ class V3Lexer;
 //======================================================================
 // Types (between parser & lexer)
 
-typedef enum { uniq_NONE, uniq_UNIQUE, uniq_UNIQUE0, uniq_PRIORITY } V3UniqState;
+typedef enum : uint8_t { uniq_NONE, uniq_UNIQUE, uniq_UNIQUE0, uniq_PRIORITY } V3UniqState;
 
-typedef enum { iprop_NONE, iprop_CONTEXT, iprop_PURE } V3ImportProperty;
+typedef enum : uint8_t { iprop_NONE, iprop_CONTEXT, iprop_PURE } V3ImportProperty;
 
 //============================================================================
 // Member qualifiers

src/V3PreProc.cpp

@@ -122,7 +122,7 @@ public:
     int m_lastLineno = 0;  // Last line number (stall detection)
     int m_tokensOnLine = 0;  // Number of tokens on line (stall detection)
 
-    enum ProcState {
+    enum ProcState : uint8_t {
         ps_TOP,
         ps_DEFNAME_UNDEF,
         ps_DEFNAME_DEFINE,

src/V3Simulate.h

@@ -85,7 +85,7 @@ private:
     //    (and output for non-delayed assignments)
     //  AstVar(Scope)::user2()  -> AstCont*. Output value of variable (delayed assignments)
 
-    enum VarUsage { VU_NONE = 0, VU_LV = 1, VU_RV = 2, VU_LVDLY = 4 };
+    enum VarUsage : uint8_t { VU_NONE = 0, VU_LV = 1, VU_RV = 2, VU_LVDLY = 4 };
 
     // STATE
     // Major mode

src/V3Task.cpp

@@ -321,7 +321,7 @@ private:
     AstUser2InUse m_inuser2;
 
     // TYPES
-    enum InsertMode {
+    enum InsertMode : uint8_t {
         IM_BEFORE,  // Pointing at statement ref is in, insert before this
         IM_AFTER,  // Pointing at last inserted stmt, insert after
         IM_WHILE_PRECOND  // Pointing to for loop, add to body end

src/V3Tristate.cpp

@@ -329,7 +329,7 @@ class TristateVisitor : public TristateBaseVisitor {
     // TYPES
     typedef std::vector<AstVarRef*> RefVec;
     typedef std::map<AstVar*, RefVec*> VarMap;
-    enum {
+    enum : uint8_t {
         U2_GRAPHING = 1,  // bit[0] if did m_graphing visit
         U2_NONGRAPH = 2,  // bit[1] if did !m_graphing visit
         U2_BOTH = 3

src/V3Undriven.cpp

@@ -43,7 +43,7 @@ class UndrivenVarEntry {
     std::vector<bool> m_wholeFlags;  // Used/Driven on whole vector
     std::vector<bool> m_bitFlags;  // Used/Driven on each subbit
 
-    enum { FLAG_USED = 0, FLAG_DRIVEN = 1, FLAGS_PER_BIT = 2 };
+    enum : uint8_t { FLAG_USED = 0, FLAG_DRIVEN = 1, FLAGS_PER_BIT = 2 };
 
     VL_DEBUG_FUNC;  // Declare debug()
 
@@ -70,7 +70,7 @@ private:
     bool drivenFlag(int bit) const {
         return m_wholeFlags[FLAG_DRIVEN] || m_bitFlags[bit * FLAGS_PER_BIT + FLAG_DRIVEN];
     }
-    enum BitNamesWhich { BN_UNUSED, BN_UNDRIVEN, BN_BOTH };
+    enum BitNamesWhich : uint8_t { BN_UNUSED, BN_UNDRIVEN, BN_BOTH };
     string bitNames(BitNamesWhich which) {
         string bits;
         bool prev = false;

src/V3Width.cpp

@@ -81,12 +81,16 @@
 
 //######################################################################
 
-enum Stage { PRELIM = 1, FINAL = 2, BOTH = 3 };  // Numbers are a bitmask <0>=prelim, <1>=final
+enum Stage : uint8_t {
+    PRELIM = 1,
+    FINAL = 2,
+    BOTH = 3
+};  // Numbers are a bitmask <0>=prelim, <1>=final
 std::ostream& operator<<(std::ostream& str, const Stage& rhs) {
     return str << ("-PFB"[static_cast<int>(rhs)]);
 }
 
-enum Determ {
+enum Determ : uint8_t {
     SELF,  // Self-determined
     CONTEXT,  // Context-determined
     ASSIGN  // Assignment-like where sign comes from RHS only
@@ -197,7 +201,7 @@ private:
     TableMap m_tableMap;  // Created tables so can remove duplicates
 
     // ENUMS
-    enum ExtendRule {
+    enum ExtendRule : uint8_t {
         EXTEND_EXP,  // Extend if expect sign and node signed, e.g. node=y in ADD(x,y), "x + y"
         EXTEND_ZERO,  // Extend with zeros. e.g. node=y in EQ(x,y), "x == y"
         EXTEND_LHS,  // Extend with sign if node signed. e.g. node=y in ASSIGN(y,x), "x = y"
@@ -2526,7 +2530,14 @@ private:
         nodep->dtypeSetSigned32();  // Guess on error
     }
     void methodCallUnpack(AstMethodCall* nodep, AstUnpackArrayDType* adtypep) {
-        enum { UNKNOWN = 0, ARRAY_OR, ARRAY_AND, ARRAY_XOR, ARRAY_SUM, ARRAY_PRODUCT } methodId;
+        enum : uint8_t {
+            UNKNOWN = 0,
+            ARRAY_OR,
+            ARRAY_AND,
+            ARRAY_XOR,
+            ARRAY_SUM,
+            ARRAY_PRODUCT
+        } methodId;
 
         methodId = UNKNOWN;
         if (nodep->name() == "or") {

src/astgen

@@ -340,12 +340,12 @@ sub write_type_enum {
 sub write_types {
     my $fh = open_file(@_);
 
-    printf $fh "    enum en {\n";
+    printf $fh "    enum en : uint16_t {\n";
     (my $final, undef) = write_type_enum($fh, "Node", 0, {}, "concrete-enum", 2);
     printf $fh "        _ENUM_END = $final\n";
     printf $fh "    };\n";
 
-    printf $fh "    enum bounds {\n";
+    printf $fh "    enum bounds : uint16_t {\n";
     write_type_enum($fh, "Node", 0, {}, "abstract-enum", 2);
     printf $fh "        _BOUNDS_END\n";
     printf $fh "    };\n";