[llvm] [BinaryFormat][NFC] Use compact enums (PR #206074)

[via llvm-commits]

llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-hlsl

Author: Alexis Engelke (aengelke)

<details>
<summary>Changes</summary>

Straight-forward replacement.


---

Patch is 36.56 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/206074.diff


7 Files Affected:

- (modified) llvm/include/llvm/BinaryFormat/DXContainer.h (+21-21) 
- (modified) llvm/include/llvm/BinaryFormat/SFrame.h (+9-9) 
- (modified) llvm/lib/BinaryFormat/DXContainer.cpp (+143-137) 
- (modified) llvm/lib/BinaryFormat/SFrame.cpp (+43-35) 
- (modified) llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp (+7-7) 
- (modified) llvm/lib/ObjectYAML/DXContainerYAML.cpp (+24-23) 
- (modified) llvm/tools/llvm-objdump/DXContainerDump.cpp (+8-11) 


``````````diff
diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h
index 4d832368ae888..ab09afc589340 100644
--- a/llvm/include/llvm/BinaryFormat/DXContainer.h
+++ b/llvm/include/llvm/BinaryFormat/DXContainer.h
@@ -24,7 +24,7 @@
 #include <stdint.h>
 
 namespace llvm {
-template <typename T> struct EnumEntry;
+template <typename, unsigned> class EnumStrings;
 
 // The DXContainer file format is arranged as a header and "parts". Semantically
 // parts are similar to sections in other object file formats. The File format
@@ -167,7 +167,7 @@ enum class RootFlags : uint32_t {
   LLVM_MARK_AS_BITMASK_ENUM(SamplerHeapDirectlyIndexed)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<RootFlags>> getRootFlags();
+LLVM_ABI EnumStrings<RootFlags, 1> getRootFlags();
 
 #define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) Enum = Num,
 enum class RootDescriptorFlags : uint32_t {
@@ -176,7 +176,7 @@ enum class RootDescriptorFlags : uint32_t {
   LLVM_MARK_AS_BITMASK_ENUM(DataStatic)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<RootDescriptorFlags>> getRootDescriptorFlags();
+LLVM_ABI EnumStrings<RootDescriptorFlags, 1> getRootDescriptorFlags();
 
 #define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) Enum = Num,
 enum class DescriptorRangeFlags : uint32_t {
@@ -185,7 +185,7 @@ enum class DescriptorRangeFlags : uint32_t {
   LLVM_MARK_AS_BITMASK_ENUM(DescriptorsStaticKeepingBufferBoundsChecks)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<DescriptorRangeFlags>> getDescriptorRangeFlags();
+LLVM_ABI EnumStrings<DescriptorRangeFlags, 1> getDescriptorRangeFlags();
 
 #define STATIC_SAMPLER_FLAG(Num, Enum, Flag) Enum = Num,
 enum class StaticSamplerFlags : uint32_t {
@@ -194,14 +194,14 @@ enum class StaticSamplerFlags : uint32_t {
   LLVM_MARK_AS_BITMASK_ENUM(NonNormalizedCoordinates)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<StaticSamplerFlags>> getStaticSamplerFlags();
+LLVM_ABI EnumStrings<StaticSamplerFlags, 1> getStaticSamplerFlags();
 
 #define ROOT_PARAMETER(Val, Enum) Enum = Val,
 enum class RootParameterType : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
+LLVM_ABI EnumStrings<RootParameterType, 1> getRootParameterTypes();
 
 LLVM_ABI bool isValidParameterType(uint32_t V);
 
@@ -212,7 +212,7 @@ enum class ShaderVisibility : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<ShaderVisibility>> getShaderVisibility();
+LLVM_ABI EnumStrings<ShaderVisibility, 1> getShaderVisibility();
 
 LLVM_ABI bool isValidShaderVisibility(uint32_t V);
 
@@ -223,14 +223,14 @@ enum class SamplerFilter : uint32_t {
 
 LLVM_ABI bool isValidSamplerFilter(uint32_t V);
 
-LLVM_ABI ArrayRef<EnumEntry<SamplerFilter>> getSamplerFilters();
+LLVM_ABI EnumStrings<SamplerFilter, 1> getSamplerFilters();
 
 #define TEXTURE_ADDRESS_MODE(Val, Enum) Enum = Val,
 enum class TextureAddressMode : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<TextureAddressMode>> getTextureAddressModes();
+LLVM_ABI EnumStrings<TextureAddressMode, 1> getTextureAddressModes();
 
 LLVM_ABI bool isValidAddress(uint32_t V);
 
@@ -239,7 +239,7 @@ enum class ComparisonFunc : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<ComparisonFunc>> getComparisonFuncs();
+LLVM_ABI EnumStrings<ComparisonFunc, 1> getComparisonFuncs();
 
 LLVM_ABI bool isValidComparisonFunc(uint32_t V);
 
@@ -256,7 +256,7 @@ LLVM_ABI bool isValidDescriptorRangeFlags(uint32_t V);
 
 LLVM_ABI bool isValidStaticSamplerFlags(uint32_t V);
 
-LLVM_ABI ArrayRef<EnumEntry<StaticBorderColor>> getStaticBorderColors();
+LLVM_ABI EnumStrings<StaticBorderColor, 1> getStaticBorderColors();
 
 LLVM_ABI PartType parsePartType(StringRef S);
 
@@ -394,35 +394,35 @@ enum class SemanticKind : uint8_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<SemanticKind>> getSemanticKinds();
+LLVM_ABI EnumStrings<SemanticKind, 1> getSemanticKinds();
 
 #define COMPONENT_TYPE(Val, Enum) Enum = Val,
 enum class ComponentType : uint8_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<ComponentType>> getComponentTypes();
+LLVM_ABI EnumStrings<ComponentType, 1> getComponentTypes();
 
 #define INTERPOLATION_MODE(Val, Enum) Enum = Val,
 enum class InterpolationMode : uint8_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<InterpolationMode>> getInterpolationModes();
+LLVM_ABI EnumStrings<InterpolationMode, 1> getInterpolationModes();
 
 #define RESOURCE_TYPE(Val, Enum) Enum = Val,
 enum class ResourceType : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<ResourceType>> getResourceTypes();
+LLVM_ABI EnumStrings<ResourceType, 1> getResourceTypes();
 
 #define RESOURCE_KIND(Val, Enum) Enum = Val,
 enum class ResourceKind : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<ResourceKind>> getResourceKinds();
+LLVM_ABI EnumStrings<ResourceKind, 1> getResourceKinds();
 
 #define RESOURCE_FLAG(Index, Enum) bool Enum = false;
 struct ResourceFlags {
@@ -591,21 +591,21 @@ enum class SigMinPrecision : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<SigMinPrecision>> getSigMinPrecisions();
+LLVM_ABI EnumStrings<SigMinPrecision, 1> getSigMinPrecisions();
 
 #define D3D_SYSTEM_VALUE(Val, Enum) Enum = Val,
 enum class D3DSystemValue : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<D3DSystemValue>> getD3DSystemValues();
+LLVM_ABI EnumStrings<D3DSystemValue, 1> getD3DSystemValues();
 
 #define COMPONENT_TYPE(Val, Enum) Enum = Val,
 enum class SigComponentType : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-LLVM_ABI ArrayRef<EnumEntry<SigComponentType>> getSigComponentTypes();
+LLVM_ABI EnumStrings<SigComponentType, 1> getSigComponentTypes();
 
 struct ProgramSignatureHeader {
   uint32_t ParamCount;
@@ -881,7 +881,7 @@ enum class SectionType : uint16_t {
   LLVM_MARK_AS_BITMASK_ENUM(Args)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<SectionType>> getSectionTypes();
+LLVM_ABI EnumStrings<SectionType, 1> getSectionTypes();
 LLVM_ABI bool isValidSectionType(uint16_t V);
 LLVM_ABI StringRef getSectionName(SectionType Type);
 
@@ -950,7 +950,7 @@ enum class CompressionType : uint16_t {
   LLVM_MARK_AS_BITMASK_ENUM(Zlib)
 };
 
-LLVM_ABI ArrayRef<EnumEntry<CompressionType>> getCompressionTypes();
+LLVM_ABI EnumStrings<CompressionType, 1> getCompressionTypes();
 LLVM_ABI bool isValidCompressionType(uint16_t V);
 
 struct Header {
diff --git a/llvm/include/llvm/BinaryFormat/SFrame.h b/llvm/include/llvm/BinaryFormat/SFrame.h
index 7b58043c60363..4f750c1bb9833 100644
--- a/llvm/include/llvm/BinaryFormat/SFrame.h
+++ b/llvm/include/llvm/BinaryFormat/SFrame.h
@@ -23,7 +23,7 @@
 
 namespace llvm {
 
-template <typename T> struct EnumEntry;
+template <typename, unsigned> class EnumStrings;
 
 namespace sframe {
 
@@ -168,14 +168,14 @@ template <endianness E> using FrameRowEntryAddr1 = FrameRowEntry<uint8_t, E>;
 template <endianness E> using FrameRowEntryAddr2 = FrameRowEntry<uint16_t, E>;
 template <endianness E> using FrameRowEntryAddr4 = FrameRowEntry<uint32_t, E>;
 
-LLVM_ABI ArrayRef<EnumEntry<Version>> getVersions();
-LLVM_ABI ArrayRef<EnumEntry<Flags>> getFlags();
-LLVM_ABI ArrayRef<EnumEntry<ABI>> getABIs();
-LLVM_ABI ArrayRef<EnumEntry<FREType>> getFRETypes();
-LLVM_ABI ArrayRef<EnumEntry<FDEType>> getFDETypes();
-LLVM_ABI ArrayRef<EnumEntry<AArch64PAuthKey>> getAArch64PAuthKeys();
-LLVM_ABI ArrayRef<EnumEntry<FREOffset>> getFREOffsets();
-LLVM_ABI ArrayRef<EnumEntry<BaseReg>> getBaseRegisters();
+LLVM_ABI EnumStrings<Version, 1> getVersions();
+LLVM_ABI EnumStrings<Flags, 1> getFlags();
+LLVM_ABI EnumStrings<ABI, 1> getABIs();
+LLVM_ABI EnumStrings<FREType, 1> getFRETypes();
+LLVM_ABI EnumStrings<FDEType, 1> getFDETypes();
+LLVM_ABI EnumStrings<AArch64PAuthKey, 1> getAArch64PAuthKeys();
+LLVM_ABI EnumStrings<FREOffset, 1> getFREOffsets();
+LLVM_ABI EnumStrings<BaseReg, 1> getBaseRegisters();
 
 } // namespace sframe
 } // namespace llvm
diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp
index 46d91347742b2..9eaf75cd256c4 100644
--- a/llvm/lib/BinaryFormat/DXContainer.cpp
+++ b/llvm/lib/BinaryFormat/DXContainer.cpp
@@ -142,208 +142,214 @@ bool ShaderHash::isPopulated() {
   return Flags > 0 || 0 != memcmp(&Digest, &Zeros, 16);
 }
 
-#define COMPONENT_PRECISION(Val, Enum) {#Enum, SigMinPrecision::Enum},
-
-static const EnumEntry<SigMinPrecision> SigMinPrecisionNames[] = {
+EnumStrings<SigMinPrecision> dxbc::getSigMinPrecisions() {
+  constexpr EnumStringDef<SigMinPrecision> SigMinPrecisionNameDefs[] = {
+#define COMPONENT_PRECISION(Val, Enum) {{#Enum}, SigMinPrecision::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<SigMinPrecision>> dxbc::getSigMinPrecisions() {
-  return ArrayRef(SigMinPrecisionNames);
+  };
+  static constexpr auto SigMinPrecisionNames =
+      BUILD_ENUM_STRINGS(SigMinPrecisionNameDefs);
+  return EnumStrings(SigMinPrecisionNames);
 }
 
-#define D3D_SYSTEM_VALUE(Val, Enum) {#Enum, D3DSystemValue::Enum},
-
-static const EnumEntry<D3DSystemValue> D3DSystemValueNames[] = {
+EnumStrings<D3DSystemValue> dxbc::getD3DSystemValues() {
+  constexpr EnumStringDef<D3DSystemValue> D3DSystemValueNameDefs[] = {
+#define D3D_SYSTEM_VALUE(Val, Enum) {{#Enum}, D3DSystemValue::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<D3DSystemValue>> dxbc::getD3DSystemValues() {
-  return ArrayRef(D3DSystemValueNames);
+  };
+  static constexpr auto D3DSystemValueNames =
+      BUILD_ENUM_STRINGS(D3DSystemValueNameDefs);
+  return EnumStrings(D3DSystemValueNames);
 }
 
-#define COMPONENT_TYPE(Val, Enum) {#Enum, SigComponentType::Enum},
-
-static const EnumEntry<SigComponentType> SigComponentTypes[] = {
+EnumStrings<SigComponentType> dxbc::getSigComponentTypes() {
+  constexpr EnumStringDef<SigComponentType> SigComponentTypeDefs[] = {
+#define COMPONENT_TYPE(Val, Enum) {{#Enum}, SigComponentType::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<SigComponentType>> dxbc::getSigComponentTypes() {
-  return ArrayRef(SigComponentTypes);
+  };
+  static constexpr auto SigComponentTypes =
+      BUILD_ENUM_STRINGS(SigComponentTypeDefs);
+  return EnumStrings(SigComponentTypes);
 }
 
-static const EnumEntry<RootFlags> RootFlagNames[] = {
-#define ROOT_SIGNATURE_FLAG(Val, Enum) {#Enum, RootFlags::Enum},
+EnumStrings<RootFlags> dxbc::getRootFlags() {
+  constexpr EnumStringDef<RootFlags> RootFlagNameDefs[] = {
+#define ROOT_SIGNATURE_FLAG(Val, Enum) {{#Enum}, RootFlags::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<RootFlags>> dxbc::getRootFlags() {
-  return ArrayRef(RootFlagNames);
+  };
+  static constexpr auto RootFlagNames = BUILD_ENUM_STRINGS(RootFlagNameDefs);
+  return EnumStrings(RootFlagNames);
 }
 
-static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = {
+EnumStrings<RootDescriptorFlags> dxbc::getRootDescriptorFlags() {
+  constexpr EnumStringDef<RootDescriptorFlags> RootDescriptorFlagNameDefs[] = {
 #define ROOT_DESCRIPTOR_FLAG(Val, Enum, Flag)                                  \
-  {#Enum, RootDescriptorFlags::Enum},
+  {{#Enum}, RootDescriptorFlags::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<RootDescriptorFlags>> dxbc::getRootDescriptorFlags() {
-  return ArrayRef(RootDescriptorFlagNames);
+  };
+  static constexpr auto RootDescriptorFlagNames =
+      BUILD_ENUM_STRINGS(RootDescriptorFlagNameDefs);
+  return EnumStrings(RootDescriptorFlagNames);
 }
 
-static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
+EnumStrings<DescriptorRangeFlags> dxbc::getDescriptorRangeFlags() {
+  constexpr EnumStringDef<DescriptorRangeFlags> DescriptorRangeFlagNameDefs[] =
+      {
 #define DESCRIPTOR_RANGE_FLAG(Val, Enum, Flag)                                 \
-  {#Enum, DescriptorRangeFlags::Enum},
+  {{#Enum}, DescriptorRangeFlags::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<DescriptorRangeFlags>> dxbc::getDescriptorRangeFlags() {
-  return ArrayRef(DescriptorRangeFlagNames);
+      };
+  static constexpr auto DescriptorRangeFlagNames =
+      BUILD_ENUM_STRINGS(DescriptorRangeFlagNameDefs);
+  return EnumStrings(DescriptorRangeFlagNames);
 }
 
-static const EnumEntry<StaticSamplerFlags> StaticSamplerFlagNames[] = {
-#define STATIC_SAMPLER_FLAG(Val, Enum, Flag) {#Enum, StaticSamplerFlags::Enum},
+EnumStrings<StaticSamplerFlags> dxbc::getStaticSamplerFlags() {
+  constexpr EnumStringDef<StaticSamplerFlags> StaticSamplerFlagNameDefs[] = {
+#define STATIC_SAMPLER_FLAG(Val, Enum, Flag)                                   \
+  {{#Enum}, StaticSamplerFlags::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<StaticSamplerFlags>> dxbc::getStaticSamplerFlags() {
-  return ArrayRef(StaticSamplerFlagNames);
+  };
+  static constexpr auto StaticSamplerFlagNames =
+      BUILD_ENUM_STRINGS(StaticSamplerFlagNameDefs);
+  return EnumStrings(StaticSamplerFlagNames);
 }
 
-#define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibility::Enum},
-
-static const EnumEntry<ShaderVisibility> ShaderVisibilityValues[] = {
+EnumStrings<ShaderVisibility> dxbc::getShaderVisibility() {
+  constexpr EnumStringDef<ShaderVisibility> ShaderVisibilityValueDefs[] = {
+#define SHADER_VISIBILITY(Val, Enum) {{#Enum}, ShaderVisibility::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<ShaderVisibility>> dxbc::getShaderVisibility() {
-  return ArrayRef(ShaderVisibilityValues);
+  };
+  static constexpr auto ShaderVisibilityValues =
+      BUILD_ENUM_STRINGS(ShaderVisibilityValueDefs);
+  return EnumStrings(ShaderVisibilityValues);
 }
 
-#define FILTER(Val, Enum) {#Enum, SamplerFilter::Enum},
-
-static const EnumEntry<SamplerFilter> SamplerFilterNames[] = {
+EnumStrings<SamplerFilter> dxbc::getSamplerFilters() {
+  constexpr EnumStringDef<SamplerFilter> SamplerFilterNameDefs[] = {
+#define FILTER(Val, Enum) {{#Enum}, SamplerFilter::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<SamplerFilter>> dxbc::getSamplerFilters() {
-  return ArrayRef(SamplerFilterNames);
+  };
+  static constexpr auto SamplerFilterNames =
+      BUILD_ENUM_STRINGS(SamplerFilterNameDefs);
+  return EnumStrings(SamplerFilterNames);
 }
 
-#define TEXTURE_ADDRESS_MODE(Val, Enum) {#Enum, TextureAddressMode::Enum},
-
-static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = {
+EnumStrings<TextureAddressMode> dxbc::getTextureAddressModes() {
+  constexpr EnumStringDef<TextureAddressMode> TextureAddressModeNameDefs[] = {
+#define TEXTURE_ADDRESS_MODE(Val, Enum) {{#Enum}, TextureAddressMode::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<TextureAddressMode>> dxbc::getTextureAddressModes() {
-  return ArrayRef(TextureAddressModeNames);
+  };
+  static constexpr auto TextureAddressModeNames =
+      BUILD_ENUM_STRINGS(TextureAddressModeNameDefs);
+  return EnumStrings(TextureAddressModeNames);
 }
 
-#define COMPARISON_FUNC(Val, Enum) {#Enum, ComparisonFunc::Enum},
-
-static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = {
+EnumStrings<ComparisonFunc> dxbc::getComparisonFuncs() {
+  constexpr EnumStringDef<ComparisonFunc> ComparisonFuncNameDefs[] = {
+#define COMPARISON_FUNC(Val, Enum) {{#Enum}, ComparisonFunc::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<ComparisonFunc>> dxbc::getComparisonFuncs() {
-  return ArrayRef(ComparisonFuncNames);
+  };
+  static constexpr auto ComparisonFuncNames =
+      BUILD_ENUM_STRINGS(ComparisonFuncNameDefs);
+  return EnumStrings(ComparisonFuncNames);
 }
 
-#define STATIC_BORDER_COLOR(Val, Enum) {#Enum, StaticBorderColor::Enum},
-
-static const EnumEntry<StaticBorderColor> StaticBorderColorValues[] = {
+EnumStrings<StaticBorderColor> dxbc::getStaticBorderColors() {
+  constexpr EnumStringDef<StaticBorderColor> StaticBorderColorValueDefs[] = {
+#define STATIC_BORDER_COLOR(Val, Enum) {{#Enum}, StaticBorderColor::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<StaticBorderColor>> dxbc::getStaticBorderColors() {
-  return ArrayRef(StaticBorderColorValues);
+  };
+  static constexpr auto StaticBorderColorValues =
+      BUILD_ENUM_STRINGS(StaticBorderColorValueDefs);
+  return EnumStrings(StaticBorderColorValues);
 }
 
-#define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum},
-
-static const EnumEntry<RootParameterType> RootParameterTypes[] = {
+EnumStrings<RootParameterType> dxbc::getRootParameterTypes() {
+  constexpr EnumStringDef<RootParameterType> RootParameterTypeDefs[] = {
+#define ROOT_PARAMETER(Val, Enum) {{#Enum}, RootParameterType::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<RootParameterType>> dxbc::getRootParameterTypes() {
-  return ArrayRef(RootParameterTypes);
+  };
+  static constexpr auto RootParameterTypes =
+      BUILD_ENUM_STRINGS(RootParameterTypeDefs);
+  return EnumStrings(RootParameterTypes);
 }
 
-#define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum},
-
-static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = {
+EnumStrings<PSV::SemanticKind> PSV::getSemanticKinds() {
+  constexpr EnumStringDef<PSV::SemanticKind> SemanticKindNameDefs[] = {
+#define SEMANTIC_KIND(Val, Enum) {{#Enum}, PSV::SemanticKind::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<PSV::SemanticKind>> PSV::getSemanticKinds() {
-  return ArrayRef(SemanticKindNames);
+  };
+  static constexpr auto SemanticKindNames =
+      BUILD_ENUM_STRINGS(SemanticKindNameDefs);
+  return EnumStrings(SemanticKindNames);
 }
 
-#define COMPONENT_TYPE(Val, Enum) {#Enum, PSV::ComponentType::Enum},
-
-static const EnumEntry<PSV::ComponentType> ComponentTypeNames[] = {
+EnumStrings<PSV::ComponentType> PSV::getComponentTypes() {
+  constexpr EnumStringDef<PSV::ComponentType> ComponentTypeNameDefs[] = {
+#define COMPONENT_TYPE(Val, Enum) {{#Enum}, PSV::ComponentType::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<PSV::ComponentType>> PSV::getComponentTypes() {
-  return ArrayRef(ComponentTypeNames);
+  };
+  static constexpr auto ComponentTypeNames =
+      BUILD_ENUM_STRINGS(ComponentTypeNameDefs);
+  return EnumStrings(ComponentTypeNames);
 }
 
-#define INTERPOLATION_MODE(Val, Enum) {#Enum, PSV::InterpolationMode::Enum},
-
-static const EnumEntry<PSV::InterpolationMode> InterpolationModeNames[] = {
+EnumStrings<PSV::InterpolationMode> PSV::getInterpolationModes() {
+  constexpr EnumStringDef<PSV::InterpolationMode> InterpolationModeNameDefs[] =
+      {
+#define INTERPOLATION_MODE(Val, Enum) {{#Enum}, PSV::InterpolationMode::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<PSV::InterpolationMode>> PSV::getInterpolationModes() {
-  return ArrayRef(InterpolationModeNames);
+      };
+  static constexpr auto InterpolationModeNames =
+      BUILD_ENUM_STRINGS(InterpolationModeNameDefs);
+  return EnumStrings(InterpolationModeNames);
 }
 
-#define RESOURCE_TYPE(Val, Enum) {#Enum, PSV::ResourceType::Enum},
-
-static const EnumEntry<PSV::ResourceType> ResourceTypeNames[] = {
+EnumStrings<PSV::ResourceType> PSV::getResourceTypes() {
+  constexpr EnumStringDef<PSV::ResourceType> ResourceTypeNameDefs[] = {
+#define RESOURCE_TYPE(Val, Enum) {{#Enum}, PSV::ResourceType::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<PSV::ResourceType>> PSV::getResourceTypes() {
-  return ArrayRef(ResourceTypeNames);
+  };
+  static constexpr auto ResourceTypeNames =
+      BUILD_ENUM_STRINGS(ResourceTypeNameDefs);
+  return EnumStrings(ResourceTypeNames);
 }
 
-#define RESOURCE_KIND(Val, Enum) {#Enum, PSV::ResourceKind::Enum},
-
-static const EnumEntry<PSV::ResourceKind> ResourceKindNames[] = {
+EnumStrings<PSV::ResourceKind> PSV::getResourceKinds() {
+  constexpr EnumStringDef<PSV::ResourceKind> ResourceKindNameDefs[] = {
+#define RESOURCE_KIND(Val, Enum) {{#Enum}, PSV::ResourceKind::Enum},
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<PSV::ResourceKind>> PS...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/206074