[TableGen] Add a backend to help with target enums

[frasercrmck]

Summary

This patch adds a TableGen backend which aims to help keep enums and
their values in sync between TableGen and C++. Previously enums would be
defined separately, usually with a comment to the effect of "must be
kept in sync with XXX".

Enumerators can be individually defined with or without values. Enums
can be given underling types and be optionally declared as enum classes.
Support is also present for automatically converting enums to/from
string values, using custom string values if desired.

The backend operates on two new basic classes: Enum and EnumMember,
which are fairly self-explanatory.

Although almost every (if not all) backends could likely stand to
benefit from this enum support to some extent, only a handful of RISC-V
enums have been converted to use this new support, both as a proof of
concept and to avoid bloating the patch.

[frasercrmck]

create enums based on derived definitions of Enum (not classes)

[frasercrmck]

add copyright header & docs; fix Target.td comment

[Paul-C-Anagnostopoulos]

Sorry, I'm just quickly passing through for now. How does this new feature relate to the existing GenericEnum class?

https://llvm.org/docs/TableGen/BackEnds.html#generic-enumerated-types

[frasercrmck]

In D122832#3422031, @Paul-C-Anagnostopoulos wrote:

Sorry, I'm just quickly passing through for now. How does this new feature relate to the existing GenericEnum class?

https://llvm.org/docs/TableGen/BackEnds.html#generic-enumerated-types

Good question! If I'm honest, I originally wrote this patch back in 2017 before that class was added and didn't fully grok GenericEnum when rebasing the patch. I thought it was purely internal to the searchable-table backend for some reason.

The way I see it, these two enum classes overlap more than is ideal. Personally I feel that GenericEnum's implicit use of alphabetical enumerator order isn't as flexible for use in C++ as using an ordered list is. When explicitly instantiating values that's less of a problem, though. Having to/from string support is quite useful, too.

Now whether or not those features can/should go into GenericEnum is a question I don't really have the answer to. If there's no appetite to really use TableGen enums in backends then it's probably not worth the hassle.

[Paul-C-Anagnostopoulos]

So one possibility is to deprecate GenericEnum, replace all uses of it with your Enum, and document Enum as the standard solution.

What do others think? @RKSimon @craig.topper

[RKSimon]

In D122832#3436351, @Paul-C-Anagnostopoulos wrote:

So one possibility is to deprecate GenericEnum, replace all uses of it with your Enum, and document Enum as the standard solution.

What do others think? @RKSimon @craig.topper

Obviously we shouldn't be duplicating functionality, but other than this code is very unfamiliar to me.

[Paul-C-Anagnostopoulos]

Why don't you take an inventory of the number of uses of GenericEnum? Then we can see if it's practical to replace those uses.

Also, please review your Enum against GenericEnum to be sure you've covered all the features.

I don't think we can eliminate GenericEnum, because there may be users outside of the LLVM project. But we could deprecate it in favor of Enum.

And, of course, you will have to write documentation similar to that for GenericEnum.

[craig.topper]

llvm/include/llvm/Target/Target.td

1776

This set unset but you're using empty string instead of '?'

1803

MuEnum -> MyEnum?

1823

Would StringRef be better?

llvm/utils/TableGen/EnumEmitter.cpp

26

MuEnum -> MyEnum?

64

EnumClass is unused in release builds

68

Doesn't getAllDerivedDefinitions return a std::vector? Can we just assign it to Enums instead of copying every value.

78

Why getValueAsOptionalString and not getValueAsString? Are you intending to allow Unset as well as empty?

109

command after "names" I think.

121

Maybe just a regular if statement for UnderlyingType being set instead of the conditional operator and an empty string.

156

Why do we need a Twine in the middle here?

180

Same question about the Twine here

[myhsu]

llvm/utils/TableGen/EnumEmitter.cpp

118

I wonder if it will be better to use Twine here?

142

can we simplify this using Record::getValueAsOptionalString?

166

ditto

[frasercrmck]

address feedback

llvm/include/llvm/Target/Target.td

1776

As in a comment below I think <string name = NAME> and field string Name = name is what I want here.

1823

Yeah, I'll do that. Ta

llvm/utils/TableGen/EnumEmitter.cpp

64

Ah yes, thanks! I'll just assert(Records.getClass("Enum")) then

68

Yep, thanks.

78

I was kind of hoping EnumMember could have both a default of NAME and a template parameter for a common situation where it might need renaming, without relying on an extra derived class. I think class EnumMember<string name = NAME> is the right way to do that? In which case, no, this should never be unset - or empty, really? Should I assert that it isn't empty, then?

118

Done

121

Yeah, that's better. Ta

142

Much better, thank you!

156

We don't! Not sure what was happening there.

[frasercrmck]

oh, also, renamed PrintMethod to ToStringMethod (as "print" is an overloaded term) and MatchMethod to FromStringMethod (to better serve as the compliment to ToString)

[frasercrmck]

• remove stale comments

[frasercrmck]

finish print/match renaming effort

[frasercrmck]

Thanks for the input! Since it's not a clear "no" I've ploughed on.

One thing that probably needs a bit of feedback is whether this should continue to be a separate backend as I've got it in this patch. The searchable tables backend currently gathers GenericEnums for use in tables and emits the decls, which I see as cross-purposes, but obviously another backend is adding extra compile time to targets. My inclination is to support Enum in the searchable tables backend but not emit them as enum decls anywhere but the enum backend. Then it's (arguably) cleaner that targets can choose the enum backend if they just want enums.

Also, if the searchable tables backend now uses Enum then Enum should live somewhere that include/llvm/TableGen/SearchableTable.td can include. So, include/llvm/TableGen/Enum.td?

Lastly, what's the deprecation/removal path for GenericEnum if this does go ahead? We only have one example of it in tree which is AMDGPU. I'm currently experimenting whether I can move everything there to Enum. I presume that this sort of TableGen infrastructure isn't part of a stable API, but I don't want to bother downstream targets if it can be helped. Apart from straight-up removal, one thought would be to drop GenericEnum enum generation but keep it for tables, and encourage people to move to Enum. Then remove it later?

[frasercrmck]

Looking again, the way AMDGPU use GenericEnum (in particular the FilterClass) is different to how I'd envisaged enums. For example,MIMGDim : GenericEnum { let FilterClass = "AMDGPUDimProps"; } allows the creation of an enum from a completely different complex class without having to manually enumerate them, since it just pulls in all defs of the AMDGPUDimProps class. I'd originally done something similar but found that relying on alphabetical order can be restrictive in its own sense, so I used list<EnumMember> Members. I feel there's a valid use case for both behaviours.

Is there a way we can support both in the same class? A toggling of behaviour between FilterClass or Members? Or something like if FilterClass is a subclass of EnumMembers it could pull in members in a different way. Might be a little convoluted.

[Paul-C-Anagnostopoulos]

Sorry, I'm pretty busy now and don't have time right away to work on this. Would it make sense to document it now? Then we can determine whether the two schemes can be merged in a reasonable way.

Again, sorry for being scarce.

[craig.topper]

llvm/utils/TableGen/EnumEmitter.cpp

65

Is this assert important? It looks like the code will just work even if there are no enums. If you're really concerned, it might be better to check !Enums.empty after the getAllDerivedDefinitions?

77

Should these asserts be fatal errors since they are under the control of the input file?

107

Only duplicate names would be caught by the compiler right? It's not an error to have duplicate values.

151

Looking at other uses of OS.ident, I don't think we typically use it for small constant indentations. The spaces are just included in the strings. That would make the formatting more obvious from the tablegen source.

[frasercrmck]

llvm/utils/TableGen/EnumEmitter.cpp

65

I don't think it's important, no. From what I can tell, getAllDerivedDefinitions reports a fatal error if the class isn't defined. That's better than an assert.

77

Done.

107

It's only a error when requesting a ToString method, due to the way we use a switch over the enum. So it's an "opt-in" error, in that sense. Maybe the comment isn't making that clear?

151

Ah yeah, you're right. Thanks!

[frasercrmck]

address feedback

[craig.topper]

LGTM

[Paul-C-Anagnostopoulos]

Sorry I've been scarce for this patch. Doesn't it need documentation?

llvm/include/llvm/Target/Target.td

class InstrMapping {
   //
   // Ex: let ValueCols = [['true'],['false']] -- It adds two columns in the
   // table. First column requires all the instructions to have predSense
   // set to 'true' and second column requires it to be 'false'.
   list<list<string> > ValueCols = [];
 }
 
 //===----------------------------------------------------------------------===//
+// EnumMember - Used in conjunction with an Enum to specify members of an
+// enumeration. Can optionally have a specific integer value.
+//
+class EnumMember<string name = NAME> {
+  // If set, this is the explicit value given to the enumeration member. If
+  // unset, the value is implied by the member's order in the Enum.
+  field int Value = ?;
+
+  // If given, this is the name given to the enumeration member. If unset,
+  // the name of the Record definition is used.
+  field string Name = name;
+
+  // The field used by the enumeration 'Print' and 'Match' methods when
+  // printing or matching enumeration members. See below.
+  field string String = NAME;
+}
+
+//===----------------------------------------------------------------------===//
+// EnumMemberVal - Convenience class that can be used in the common case that
+// an enum member has a specific value.
+//
+class EnumMemberVal<int v, string name = NAME> : EnumMember {
+  let Value = v;
+  let Name = name;
+}
+
+//===----------------------------------------------------------------------===//
+// Enum - This class is used to automatically defined and link enumerations
+// between TableGen and C++. An enum is generated for each def of Enum with a
+// non-empty list of EnumMember instances:
+//     def A : EnumMember;
+//     def B : EnumMember;
+//     def C : EnumMemberVal<3, "third">;
+//     def MyEnum : Enum<[A, B, C]>;
+// Generates:
+//     enum MyEnum {
+//       A,
+//       B,
+//       third = 3,
+//     };
+//
+class Enum<list<EnumMember> members> {
+  // If set, the name of the enum. If unset, the name of the class is used.
+  field string Name = NAME;
+
+  // If set, the underlying type of the enumeration.
+  field string UnderlyingTy = ?;
+
+  // When this bit is set, the enum will be emitted as a C++ enum class.
+  field bit IsClass = false;
+
+  // The (ordered) list of enumeration members.
+  field list<EnumMember> Members = members;
+
+  // The name of the method used to get the String value of enumeration
+  // values. The generated method returns StringRef, and switches over all
+  // enum members with an llvm_unreachable on the default case.
+  field string ToStringMethod = ?;
+
+  // The name of the method used to match from the String value back to the
+  // enum value. If set, the String field of each enum member must be unique.
+  // The method returns an Optional<>, where None is returned if there is no
+  // match.
+  field string FromStringMethod = ?;
+}
+
+//===----------------------------------------------------------------------===//
 // Pull in the common support for calling conventions.
 //
 include "llvm/Target/TargetCallingConv.td"
 
 //===----------------------------------------------------------------------===//
 // Pull in the common support for DAG isel generation.
 //
 include "llvm/Target/TargetSelectionDAG.td"

llvm/lib/Target/RISCV/CMakeLists.txt

 tablegen(LLVM RISCVGenGlobalISel.inc -gen-global-isel)
 tablegen(LLVM RISCVGenInstrInfo.inc -gen-instr-info)
 tablegen(LLVM RISCVGenMCCodeEmitter.inc -gen-emitter)
 tablegen(LLVM RISCVGenMCPseudoLowering.inc -gen-pseudo-lowering)
 tablegen(LLVM RISCVGenRegisterBank.inc -gen-register-bank)
 tablegen(LLVM RISCVGenRegisterInfo.inc -gen-register-info)
 tablegen(LLVM RISCVGenSearchableTables.inc -gen-searchable-tables)
 tablegen(LLVM RISCVGenSubtargetInfo.inc -gen-subtarget)
+tablegen(LLVM RISCVGenEnums.inc -gen-enums)
 
 add_public_tablegen_target(RISCVCommonTableGen)
 
 add_llvm_target(RISCVCodeGen
   RISCVAsmPrinter.cpp
   RISCVCallLowering.cpp
   RISCVExpandAtomicPseudoInsts.cpp
   RISCVExpandPseudoInsts.cpp

llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h

enum {
   // Does this instruction care about mask policy. If it is not, the mask policy
   // could be either agnostic or undisturbed. For example, unmasked, store, and
   // reduction operations result would not be affected by mask policy, so
   // compiler has free to select either one.
   UsesMaskPolicyShift = IsRVVWideningReductionShift + 1,
   UsesMaskPolicyMask = 1 << UsesMaskPolicyShift,
 };
 
-// Match with the definitions in RISCVInstrFormats.td
-enum VConstraintType {
-  NoConstraint = 0,
-  VS2Constraint = 0b001,
-  VS1Constraint = 0b010,
-  VMConstraint = 0b100,
-};
-
-enum VLMUL : uint8_t {
-  LMUL_1 = 0,
-  LMUL_2,
-  LMUL_4,
-  LMUL_8,
-  LMUL_RESERVED,
-  LMUL_F8,
-  LMUL_F4,
-  LMUL_F2
-};
-
-enum {
-  TAIL_AGNOSTIC = 1,
-  MASK_AGNOSTIC = 2,
-};
+// Include enumerations from TableGen
+#define GET_VConstraintType_ENUM
+#define GET_VLMUL_ENUM
+#define GET_RVVPolicy_ENUM
+#include "RISCVGenEnums.inc"
 
 // Helper functions to read TSFlags.
 /// \returns the format of the instruction.
 static inline unsigned getFormat(uint64_t TSFlags) {
   return (TSFlags & InstFormatMask) >> InstFormatShift;
 }
 /// \returns the constraint for the instruction.
 static inline VConstraintType getConstraint(uint64_t TSFlags) {

llvm/lib/Target/RISCV/RISCVInstrFormats.td

 def InstFormatCIW    : InstFormat<11>;
 def InstFormatCL     : InstFormat<12>;
 def InstFormatCS     : InstFormat<13>;
 def InstFormatCA     : InstFormat<14>;
 def InstFormatCB     : InstFormat<15>;
 def InstFormatCJ     : InstFormat<16>;
 def InstFormatOther  : InstFormat<17>;
 
-class RISCVVConstraint<bits<3> val> {
-  bits<3> Value = val;
-}
+class RISCVVConstraint<bits<3> val> : EnumMemberVal<val>;
+
 def NoConstraint  : RISCVVConstraint<0b000>;
 def VS2Constraint : RISCVVConstraint<0b001>;
 def VS1Constraint : RISCVVConstraint<0b010>;
 def VMConstraint  : RISCVVConstraint<0b100>;
 
+def VConstraintType : Enum<[NoConstraint, VS2Constraint,
+                            VS1Constraint, VMConstraint]>;
+
 // Illegal instructions:
 //
 // * The destination vector register group for a masked vector instruction
 // cannot overlap the source mask register (v0), unless the destination vector
 // register is being written with a mask value (e.g., comparisons) or the
 // scalar result of a reduction.
 //
 // * Widening: The destination EEW is greater than the source EEW, the source

llvm/lib/Target/RISCV/RISCVInstrInfoVPseudos.td

 
 def DecImm : SDNodeXForm<imm, [{
   return CurDAG->getTargetConstant(N->getSExtValue() - 1, SDLoc(N),
                                    N->getValueType(0));
 }]>;
 
 defvar TAIL_UNDISTURBED = 0;
 defvar TAIL_AGNOSTIC = 1;
+defvar MASK_AGNOSTIC = 2;
+
+def RVVPolicy : Enum<[
+  EnumMemberVal<TAIL_UNDISTURBED, "TAIL_UNDISTURBED">,
+  EnumMemberVal<TAIL_AGNOSTIC,    "TAIL_AGNOSTIC">,
+  EnumMemberVal<MASK_AGNOSTIC,    "MASK_AGNOSTIC">]>;
 
 //===----------------------------------------------------------------------===//
 // Utilities.
 //===----------------------------------------------------------------------===//
 
+class LMUL<bits<3> v> : EnumMemberVal<v>;
+
+def LMUL_1        : LMUL<0b000>;
+def LMUL_2        : LMUL<0b001>;
+def LMUL_4        : LMUL<0b010>;
+def LMUL_8        : LMUL<0b011>;
+def LMUL_RESERVED : LMUL<0b100>;
+def LMUL_F8       : LMUL<0b101>;
+def LMUL_F4       : LMUL<0b110>;
+def LMUL_F2       : LMUL<0b111>;
+
+def VLMULNum : Enum<[LMUL_1, LMUL_2, LMUL_4, LMUL_8,
+                     LMUL_RESERVED, LMUL_F8, LMUL_F4, LMUL_F2]> {
+  let Name = "VLMUL";
+  let UnderlyingTy = "uint8_t";
+}
+
 // This class describes information associated to the LMUL.
-class LMULInfo<int lmul, int oct, VReg regclass, VReg wregclass,
+class LMULInfo<LMUL lmul, int oct, VReg regclass, VReg wregclass,
                VReg f2regclass, VReg f4regclass, VReg f8regclass, string mx> {
-  bits<3> value = lmul; // This is encoded as the vlmul field of vtype.
+  bits<3> value = lmul.Value; // This is encoded as the vlmul field of vtype.
   VReg vrclass = regclass;
   VReg wvrclass = wregclass;
   VReg f8vrclass = f8regclass;
   VReg f4vrclass = f4regclass;
   VReg f2vrclass = f2regclass;
   string MX = mx;
   int octuple = oct;
 }
 
 // Associate LMUL with tablegen records of register classes.
-def V_M1  : LMULInfo<0b000,  8,   VR,        VRM2,   VR,   VR, VR, "M1">;
-def V_M2  : LMULInfo<0b001, 16, VRM2,        VRM4,   VR,   VR, VR, "M2">;
-def V_M4  : LMULInfo<0b010, 32, VRM4,        VRM8, VRM2,   VR, VR, "M4">;
-def V_M8  : LMULInfo<0b011, 64, VRM8,/*NoVReg*/VR, VRM4, VRM2, VR, "M8">;
-
-def V_MF8 : LMULInfo<0b101, 1, VR, VR,/*NoVReg*/VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF8">;
-def V_MF4 : LMULInfo<0b110, 2, VR, VR,          VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF4">;
-def V_MF2 : LMULInfo<0b111, 4, VR, VR,          VR,          VR,/*NoVReg*/VR, "MF2">;
+def V_M1  : LMULInfo<LMUL_1,  8,   VR,        VRM2,   VR,   VR, VR, "M1">;
+def V_M2  : LMULInfo<LMUL_2, 16, VRM2,        VRM4,   VR,   VR, VR, "M2">;
+def V_M4  : LMULInfo<LMUL_4, 32, VRM4,        VRM8, VRM2,   VR, VR, "M4">;
+def V_M8  : LMULInfo<LMUL_8, 64, VRM8,/*NoVReg*/VR, VRM4, VRM2, VR, "M8">;
+
+def V_MF8 : LMULInfo<LMUL_F8, 1, VR, VR,/*NoVReg*/VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF8">;
+def V_MF4 : LMULInfo<LMUL_F4, 2, VR, VR,          VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF4">;
+def V_MF2 : LMULInfo<LMUL_F2, 4, VR, VR,          VR,          VR,/*NoVReg*/VR, "MF2">;
 
 // Used to iterate over all possible LMULs.
 defvar MxList = [V_MF8, V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8];
 // For floating point which don't need MF8.
 defvar MxListF = [V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8];
 
 // Used for widening and narrowing instructions as it doesn't contain M8.
 defvar MxListW = [V_MF8, V_MF4, V_MF2, V_M1, V_M2, V_M4];

llvm/test/TableGen/EnumEmitter.td

+// RUN: llvm-tblgen -gen-enums -I %p/../../include %s 2>&1 | FileCheck %s
+
+include "llvm/Target/Target.td"
+
+def One : EnumMember;
+def Two : EnumMember;
+
+def MyEnum : Enum<[One, Two]>;
+
+// CHECK-LABEL: #ifdef GET_MyEnum_ENUM
+// CHECK-LABEL: enum MyEnum {
+// CHECK-NEXT: One,
+// CHECK-NEXT: Two,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnum_ENUM
+
+def MyEnumEnumName : Enum<[One, Two]> {
+  let Name = "SomethingElse";
+}
+
+// CHECK-LABEL: #ifdef GET_SomethingElse_ENUM
+// CHECK-LABEL: enum SomethingElse {
+// CHECK-NEXT: One,
+// CHECK-NEXT: Two,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_SomethingElse_ENUM
+
+def MyEnumMemberName : Enum<[EnumMember<"one">, EnumMember<"two">]>;
+
+// CHECK-LABEL: #ifdef GET_MyEnumMemberName_ENUM
+// CHECK-LABEL: enum MyEnumMemberName {
+// CHECK-NEXT: one,
+// CHECK-NEXT: two,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnumMemberName_ENUM
+
+def OneV : EnumMemberVal<1>;
+def TwoV : EnumMemberVal<2>;
+
+def MyEnumV : Enum<[OneV, TwoV]>;
+
+// CHECK-LABEL: #ifdef GET_MyEnumV_ENUM
+// CHECK-LABEL: enum MyEnumV {
+// CHECK-NEXT: OneV = 1,
+// CHECK-NEXT: TwoV = 2,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnumV_ENUM
+
+def MyEnumVClass : Enum<[OneV, TwoV]> {
+  let IsClass = true;
+}
+
+// CHECK-LABEL: #ifdef GET_MyEnumVClass_ENUM
+// CHECK-LABEL: enum class MyEnumVClass {
+// CHECK-NEXT: OneV = 1,
+// CHECK-NEXT: TwoV = 2,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnumVClass_ENUM
+
+def MyEnumVClassUnsignedShort : Enum<[OneV, TwoV]> {
+  let IsClass = true;
+  let UnderlyingTy = "unsigned short";
+}
+
+// CHECK-LABEL: #ifdef GET_MyEnumVClassUnsignedShort_ENUM
+// CHECK-LABEL: enum class MyEnumVClassUnsignedShort : unsigned short {
+// CHECK-NEXT: OneV = 1,
+// CHECK-NEXT: TwoV = 2,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnumVClassUnsignedShort_ENUM
+
+def MyEnumVMixed : Enum<[One, TwoV]>;
+
+// CHECK-LABEL: #ifdef GET_MyEnumVMixed_ENUM
+// CHECK-LABEL: enum MyEnumVMixed {
+// CHECK-NEXT: One,
+// CHECK-NEXT: TwoV = 2,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_MyEnumVMixed_ENUM
+
+def THREE : EnumMember {
+  let String = "three";
+}
+def FOUR : EnumMember {
+  let Name = "Four";
+  let String = "four";
+}
+
+def PrintEnum : Enum<[One, Two, THREE, FOUR]> {
+  let ToStringMethod = "getPrintEnumAsStr";
+  let FromStringMethod = "getPrintEnumFromStr";
+}
+
+// CHECK-LABEL: #ifdef GET_PrintEnum_ENUM
+// CHECK-LABEL: enum PrintEnum {
+// CHECK-NEXT: One,
+// CHECK-NEXT: Two,
+// CHECK-NEXT: THREE,
+// CHECK-NEXT: Four,
+// CHECK-NEXT: };
+// CHECK-LABEL: #endif // GET_PrintEnum_ENUM
+
+// CHECK-LABEL: #ifdef GET_PrintEnum_TOSTRING_IMPL
+// CHECK-LABEL: static inline StringRef getPrintEnumAsStr(const PrintEnum E) {
+// CHECK-NEXT:   switch (E) {
+// CHECK-NEXT:   default:
+// CHECK-NEXT:     llvm_unreachable("Invalid PrintEnum");
+// CHECK-NEXT:   case PrintEnum::One:
+// CHECK-NEXT:     return "One";
+// CHECK-NEXT:   case PrintEnum::Two:
+// CHECK-NEXT:     return "Two";
+// CHECK-NEXT:   case PrintEnum::THREE:
+// CHECK-NEXT:     return "three";
+// CHECK-NEXT:   case PrintEnum::Four:
+// CHECK-NEXT:     return "four";
+// CHECK-NEXT:   }
+// CHECK-NEXT: }
+// CHECK-LABEL: #endif // GET_PrintEnum_TOSTRING_IMPL
+
+// CHECK-LABEL: #ifdef GET_PrintEnum_FROMSTRING_IMPL
+// CHECK-LABEL: static inline Optional<PrintEnum> getPrintEnumFromStr(StringRef Str) {
+// CHECK-NEXT:   return StringSwitch<Optional<PrintEnum>>(Str)
+// CHECK-NEXT:       .Case("One", PrintEnum::One)
+// CHECK-NEXT:       .Case("Two", PrintEnum::Two)
+// CHECK-NEXT:       .Case("three", PrintEnum::THREE)
+// CHECK-NEXT:       .Case("four", PrintEnum::Four)
+// CHECK-NEXT:       .Default(None);
+// CHECK-NEXT: }
+// CHECK-LABEL: #endif // GET_PrintEnum_FROMSTRING_IMPL

llvm/test/TableGen/EnumEmitterInvalid.td

+// RUN: not llvm-tblgen -gen-enums -DERROR1 -I %p/../../include %s 2>&1 | FileCheck %s --check-prefix ERROR1
+// RUN: not llvm-tblgen -gen-enums -DERROR2 -I %p/../../include %s 2>&1 | FileCheck %s --check-prefix ERROR2
+// RUN: not llvm-tblgen -gen-enums -DERROR3 -I %p/../../include %s 2>&1 | FileCheck %s --check-prefix ERROR3
+
+include "llvm/Target/Target.td"
+
+#ifdef ERROR1
+
+def Zero : EnumMember;
+def One  : EnumMember;
+def Null : EnumMemberVal<0>;
+
+def MyEnum : Enum<[Zero, One, Null]> {
+  let ToStringMethod = "AsStr1";
+}
+
+#endif // ERROR1
+
+// ERROR1: Enum has duplicate values so no ToStringMethod is possible!
+
+#ifdef ERROR2
+
+def Zero : EnumMember;
+def One  : EnumMember;
+def Null : EnumMember<"Zero">;
+
+def MyEnum : Enum<[Zero, One, Null]> {
+  let FromStringMethod = "AsStr1";
+}
+
+// ERROR2: Enum has duplicate enumerator named 'Zero'!
+
+#endif // ERROR2
+
+#ifdef ERROR3
+
+def Zero : EnumMember;
+def One  : EnumMember;
+def Null : EnumMember {
+  let String = "Zero";
+}
+
+def MyEnum : Enum<[Zero, One, Null]> {
+  let FromStringMethod = "AsStr1";
+}
+
+// ERROR3: Enum has duplicate enumerator string 'Zero'!
+
+#endif // ERROR3

llvm/utils/TableGen/CMakeLists.txt

add_tablegen(llvm-tblgen LLVM
   DAGISelMatcherEmitter.cpp
   DAGISelMatcherGen.cpp
   DAGISelMatcherOpt.cpp
   DAGISelMatcher.cpp
   DFAEmitter.cpp
   DFAPacketizerEmitter.cpp
   DirectiveEmitter.cpp
   DisassemblerEmitter.cpp
+  EnumEmitter.cpp
   ExegesisEmitter.cpp
   FastISelEmitter.cpp
   FixedLenDecoderEmitter.cpp
   GICombinerEmitter.cpp
   GlobalISelEmitter.cpp
   InfoByHwMode.cpp
   InstrInfoEmitter.cpp
   InstrDocsEmitter.cpp

llvm/utils/TableGen/EnumEmitter.cpp

+//===- EnumEmitter.cpp - Generate enums -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file This tablegen backend emits enum definitions which can be used across
+/// tablegen and C++. See include/llvm/Target/Target.td for the Enum and
+/// EnumMember classes.
+///
+/// An enum is created for each definition that derives from the Enum class.
+/// At a minimum, the Enum class is given a non-empty list of EnumMember
+/// definitions serving as its constituent members/enumerators. It can
+/// additionally be given optional underlying types, be defined as a C++ enum
+/// class, and have auto-generated to-string and from-string methods:
+///
+///     def A : EnumMember;
+///     def B : EnumMember;
+///     def C : EnumMemberVal<3>;
+///     def MyEnum : Enum<[A, B, C]>;
+///
+/// Generates:
+///     enum MyEnum {
+///       A,
+///       B,
+///       C = 3,
+///     };
+///
+/// To- and from-string methods are generated by defining ToStringMethod and
+/// FromStringMethod string variables which generate the following methods:
+///     static inline StringRef ToStringMethod(const Enum);
+///     static inline Optional<Enum> FromStringMethod(StringRef Str);
+/// The ToStringMethod is implemented as a switch over all enumerators
+/// returning the enumerator as a StringRef, hitting llvm_unreachable if not
+/// found.
+/// The FromStringMethod is implemented as a StringSwitch over all enumerators,
+/// returning None if not found.
+//===----------------------------------------------------------------------===//
+
+#include "TableGenBackends.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace llvm;
+
+namespace {
+class EnumEmitter {
+  RecordKeeper &Records;
+
+public:
+  EnumEmitter(RecordKeeper &R) : Records(R) {}
+
+  void run(raw_ostream &OS) const;
+  void emitEnum(const Record *Enum, raw_ostream &OS) const;
+};
+} // End anonymous namespace
+
+void EnumEmitter::run(raw_ostream &OS) const {
+  auto Enums = Records.getAllDerivedDefinitions("Enum");
+
+  llvm::sort(Enums, LessRecord());
+
+  for (const auto *R : Enums)
+    emitEnum(R, OS);
+}
+
+static StringRef getEnumMemberName(const Record *EM) {
+  auto Name = EM->getValueAsString("Name");
+  if (Name.empty())
+    PrintFatalError(EM->getLoc(), "EnumMember has empty Name!");
+  return Name;
+}
+
+static StringRef getEnumMemberStr(const Record *EM) {
+  auto Str = EM->getValueAsString("String");
+  if (Str.empty())
+    PrintFatalError(EM->getLoc(), "EnumMember has empty String!");
+  return Str;
+}
+
+static Optional<int> getEnumMemberVal(const Record *EM) {
+  if (EM->isValueUnset("Value"))
+    return None;
+  return EM->getValueAsInt("Value");
+}
+
+void EnumEmitter::emitEnum(const Record *Enum, raw_ostream &OS) const {
+  auto EnumName = Enum->getValueAsString("Name");
+  if (EnumName.empty())
+    PrintFatalError(Enum->getLoc(), "Enum has empty Name!");
+
+  const auto &Members = Enum->getValueAsListOfDefs("Members");
+
+  if (Members.empty())
+    return;
+
+  Optional<StringRef> UnderlyingTy =
+      Enum->getValueAsOptionalString("UnderlyingTy");
+
+  bool HasDuplicateVals = false;
+  // Keep track of enumerator values and names, as duplicates would cause C++
+  // miscompilations. These would be caught later by the C++ compiler, but it's
+  // better to flag this as early as possible.
+  SmallSet<int, 8> EnumValues;
+  SmallSet<StringRef, 8> EnumMemberNames;
+
+  bool IsClass = Enum->getValueAsBit("IsClass");
+
+  // Emit the enum definition itself
+  std::string EnumGuard = ("GET_" + Twine(EnumName) + "_ENUM").str();
+  OS << "#ifdef " << EnumGuard << "\n";
+  OS << "enum " << (IsClass ? "class " : "") << EnumName;
+  if (UnderlyingTy)
+    OS << " : " + *UnderlyingTy;
+  OS << " {\n";
+  for (const auto &P : enumerate(Members)) {
+    auto EnumMemberName = getEnumMemberName(P.value());
+    if (!EnumMemberNames.insert(EnumMemberName).second)
+      PrintFatalError(Enum->getLoc(), "Enum has duplicate enumerator named '" +
+                                          EnumMemberName + "'!");
+    OS << "  " << EnumMemberName;
+    if (auto Val = getEnumMemberVal(P.value())) {
+      OS << " = " << *Val;
+      HasDuplicateVals |= !EnumValues.insert(*Val).second;
+    } else {
+      // Else the value is implied by its ordering.
+      HasDuplicateVals |= !EnumValues.insert(P.index()).second;
+    }
+    OS << ",\n";
+  }
+
+  OS << "};\n";
+  OS << "#endif // " << EnumGuard << "\n\n";
+
+  if (auto ToStringMethod = Enum->getValueAsOptionalString("ToStringMethod")) {
+    if (HasDuplicateVals)
+      PrintFatalError(
+          Enum->getLoc(),
+          "Enum has duplicate values so no ToStringMethod is possible!");
+    const char *Param = "E";
+    std::string ToStringGuard = ("GET_" + EnumName + "_TOSTRING_IMPL").str();
+    // ToString method definition
+    OS << "#ifdef " << ToStringGuard << "\n";
+    OS << "static inline StringRef " << *ToStringMethod << "(const " << EnumName
+       << " " << Param << ") {\n";
+    OS << "  switch (" << Param << ") {\n";
+    OS << "  default:\n";
+    OS << "    llvm_unreachable(\"Invalid " << EnumName << "\");\n";
+    for (const auto *M : Members) {
+      OS << "  case " << EnumName + "::" + getEnumMemberName(M) << ":\n";
+      OS << "    return \"" << getEnumMemberStr(M) << "\";\n";
+    }
+    OS << "  }\n";
+    OS << "}\n";
+    OS << "#endif // " << ToStringGuard << "\n\n";
+  }
+
+  if (auto FromStringMethod =
+          Enum->getValueAsOptionalString("FromStringMethod")) {
+    SmallSet<StringRef, 8> SeenStrings;
+    std::string RetTy = ("Optional<" + EnumName + ">").str();
+    std::string FromStringGuard =
+        ("GET_" + EnumName + "_FROMSTRING_IMPL").str();
+    // FromString method definition
+    OS << "#ifdef " << FromStringGuard << "\n";
+    OS << "static inline " << RetTy << " " << *FromStringMethod
+       << "(StringRef Str) {\n";
+    OS << "  return StringSwitch<" << RetTy << ">(Str)\n";
+    for (const auto *M : Members) {
+      if (!SeenStrings.insert(getEnumMemberStr(M)).second)
+        PrintFatalError(M->getLoc(), "Enum has duplicate enumerator string '" +
+                                         getEnumMemberStr(M) + "'!");
+      OS << "      .Case(\"" << getEnumMemberStr(M) << "\", "
+         << EnumName + "::" + getEnumMemberName(M) << ")\n";
+    }
+    OS << "      .Default(None);\n";
+    OS << "}\n";
+    OS << "#endif // " << FromStringGuard << "\n\n";
+  }
+}
+
+void llvm::EmitEnums(RecordKeeper &RK, raw_ostream &OS) {
+  EnumEmitter(RK).run(OS);
+}

llvm/utils/TableGen/TableGen.cpp

enum ActionType {
   GenX86EVEX2VEXTables,
   GenX86FoldTables,
   GenX86MnemonicTables,
   GenRegisterBank,
   GenExegesis,
   GenAutomata,
   GenDirectivesEnumDecl,
   GenDirectivesEnumImpl,
+  GenEnums,
 };
 
 namespace llvm {
 cl::opt<bool> EmitLongStrLiterals(
     "long-string-literals",
     cl::desc("when emitting large string tables, prefer string literals over "
              "comma-separated char literals. This can be a readability and "
              "compile-time performance win, but upsets some compilers"),
cl::values(
         clEnumValN(GenRegisterBank, "gen-register-bank",
                    "Generate registers bank descriptions"),
         clEnumValN(GenExegesis, "gen-exegesis",
                    "Generate llvm-exegesis tables"),
         clEnumValN(GenAutomata, "gen-automata", "Generate generic automata"),
         clEnumValN(GenDirectivesEnumDecl, "gen-directive-decl",
                    "Generate directive related declaration code (header file)"),
         clEnumValN(GenDirectivesEnumImpl, "gen-directive-impl",
-                   "Generate directive related implementation code")));
+                   "Generate directive related implementation code"),
+        clEnumValN(GenEnums, "gen-enums", "Generate enumerations")));
 
 cl::OptionCategory PrintEnumsCat("Options for -print-enums");
 cl::opt<std::string> Class("class", cl::desc("Print Enum list for this class"),
                            cl::value_desc("class name"),
                            cl::cat(PrintEnumsCat));
 
 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   switch (Action) {
case GenAutomata:
     EmitAutomata(Records, OS);
     break;
   case GenDirectivesEnumDecl:
     EmitDirectivesDecl(Records, OS);
     break;
   case GenDirectivesEnumImpl:
     EmitDirectivesImpl(Records, OS);
     break;
+  case GenEnums:
+    EmitEnums(Records, OS);
+    break;
   }
 
   return false;
 }
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);

llvm/utils/TableGen/TableGenBackends.h

 void EmitX86EVEX2VEXTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86FoldTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86MnemonicTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterBank(RecordKeeper &RK, raw_ostream &OS);
 void EmitExegesis(RecordKeeper &RK, raw_ostream &OS);
 void EmitAutomata(RecordKeeper &RK, raw_ostream &OS);
 void EmitDirectivesDecl(RecordKeeper &RK, raw_ostream &OS);
 void EmitDirectivesImpl(RecordKeeper &RK, raw_ostream &OS);
+void EmitEnums(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif