[llvm] 1da59d8 - [BinaryFormat][NFC] Use compact enums (#206074)
via llvm-commits
llvm-commits at lists.llvm.org
Sat Jun 27 22:14:30 PDT 2026
Author: Alexis Engelke
Date: 2026-06-28T07:14:26+02:00
New Revision: 1da59d8713add10b00f5c2c4c8bc2f2149c10c0d
URL: https://github.com/llvm/llvm-project/commit/1da59d8713add10b00f5c2c4c8bc2f2149c10c0d
DIFF: https://github.com/llvm/llvm-project/commit/1da59d8713add10b00f5c2c4c8bc2f2149c10c0d.diff
LOG: [BinaryFormat][NFC] Use compact enums (#206074)
Straight-forward replacement.
Added:
Modified:
llvm/include/llvm/BinaryFormat/DXContainer.h
llvm/include/llvm/BinaryFormat/SFrame.h
llvm/lib/BinaryFormat/DXContainer.cpp
llvm/lib/BinaryFormat/SFrame.cpp
llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
llvm/lib/ObjectYAML/DXContainerYAML.cpp
llvm/tools/llvm-objdump/DXContainerDump.cpp
Removed:
################################################################################
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>> PSV::getResourceKinds() {
- return ArrayRef(ResourceKindNames);
+ };
+ static constexpr auto ResourceKindNames =
+ BUILD_ENUM_STRINGS(ResourceKindNameDefs);
+ return EnumStrings(ResourceKindNames);
}
-static const EnumEntry<SourceInfo::SectionType> SectionNames[] = {
-#define SOURCE_INFO_TYPE(Num, Val) {#Val, SourceInfo::SectionType::Val},
+EnumStrings<SourceInfo::SectionType> SourceInfo::getSectionTypes() {
+ constexpr EnumStringDef<SectionType> SectionNameDefs[] = {
+#define SOURCE_INFO_TYPE(Num, Val) {{#Val}, SourceInfo::SectionType::Val},
#include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<SourceInfo::SectionType>> SourceInfo::getSectionTypes() {
- return ArrayRef(SectionNames);
+ };
+ static constexpr auto SectionNames = BUILD_ENUM_STRINGS(SectionNameDefs);
+ return EnumStrings(SectionNames);
}
StringRef SourceInfo::getSectionName(SourceInfo::SectionType Type) {
auto V = to_underlying(Type);
if (!isValidSectionType(V))
return StringRef();
- return getSectionTypes()[V].Name;
+ return getSectionTypes()[V].name();
}
-static const EnumEntry<SourceInfo::Contents::CompressionType>
- CompressionTypes[] = {
+EnumStrings<SourceInfo::Contents::CompressionType>
+SourceInfo::Contents::getCompressionTypes() {
+ constexpr EnumStringDef<CompressionType> CompressionTypeDefs[] = {
#define COMPRESSION_TYPE(Num, Val) \
- {#Val, SourceInfo::Contents::CompressionType::Val},
+ {{#Val}, SourceInfo::Contents::CompressionType::Val},
#include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<SourceInfo::Contents::CompressionType>>
-SourceInfo::Contents::getCompressionTypes() {
- return ArrayRef(CompressionTypes);
+ };
+ static constexpr auto CompressionTypes =
+ BUILD_ENUM_STRINGS(CompressionTypeDefs);
+ return EnumStrings(CompressionTypes);
}
diff --git a/llvm/lib/BinaryFormat/SFrame.cpp b/llvm/lib/BinaryFormat/SFrame.cpp
index 8076a26f27f32..eed7a3c650bc8 100644
--- a/llvm/lib/BinaryFormat/SFrame.cpp
+++ b/llvm/lib/BinaryFormat/SFrame.cpp
@@ -7,72 +7,80 @@
//===----------------------------------------------------------------------===//
#include "llvm/BinaryFormat/SFrame.h"
-#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/ADT/Enum.h"
using namespace llvm;
-ArrayRef<EnumEntry<sframe::Version>> sframe::getVersions() {
- static constexpr EnumEntry<Version> Versions[] = {
-#define HANDLE_SFRAME_VERSION(CODE, NAME) {#NAME, sframe::Version::NAME},
+EnumStrings<sframe::Version> sframe::getVersions() {
+ constexpr EnumStringDef<Version> VersionDefs[] = {
+#define HANDLE_SFRAME_VERSION(CODE, NAME) {{#NAME}, sframe::Version::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
-
- return ArrayRef(Versions);
+ static constexpr auto Versions = BUILD_ENUM_STRINGS(VersionDefs);
+ return EnumStrings(Versions);
}
-ArrayRef<EnumEntry<sframe::Flags>> sframe::getFlags() {
- static constexpr EnumEntry<sframe::Flags> Flags[] = {
-#define HANDLE_SFRAME_FLAG(CODE, NAME) {#NAME, sframe::Flags::NAME},
+EnumStrings<sframe::Flags> sframe::getFlags() {
+ constexpr EnumStringDef<sframe::Flags> FlagDefs[] = {
+#define HANDLE_SFRAME_FLAG(CODE, NAME) {{#NAME}, sframe::Flags::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(Flags);
+ static constexpr auto Flags = BUILD_ENUM_STRINGS(FlagDefs);
+ return EnumStrings(Flags);
}
-ArrayRef<EnumEntry<sframe::ABI>> sframe::getABIs() {
- static constexpr EnumEntry<sframe::ABI> ABIs[] = {
-#define HANDLE_SFRAME_ABI(CODE, NAME) {#NAME, sframe::ABI::NAME},
+EnumStrings<sframe::ABI> sframe::getABIs() {
+ constexpr EnumStringDef<sframe::ABI> ABIDefs[] = {
+#define HANDLE_SFRAME_ABI(CODE, NAME) {{#NAME}, sframe::ABI::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(ABIs);
+ static constexpr auto ABIs = BUILD_ENUM_STRINGS(ABIDefs);
+ return EnumStrings(ABIs);
}
-ArrayRef<EnumEntry<sframe::FREType>> sframe::getFRETypes() {
- static constexpr EnumEntry<sframe::FREType> FRETypes[] = {
-#define HANDLE_SFRAME_FRE_TYPE(CODE, NAME) {#NAME, sframe::FREType::NAME},
+EnumStrings<sframe::FREType> sframe::getFRETypes() {
+ constexpr EnumStringDef<sframe::FREType> FRETypeDefs[] = {
+#define HANDLE_SFRAME_FRE_TYPE(CODE, NAME) {{#NAME}, sframe::FREType::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(FRETypes);
+ static constexpr auto FRETypes = BUILD_ENUM_STRINGS(FRETypeDefs);
+ return EnumStrings(FRETypes);
}
-ArrayRef<EnumEntry<sframe::FDEType>> sframe::getFDETypes() {
- static constexpr EnumEntry<sframe::FDEType> FDETypes[] = {
-#define HANDLE_SFRAME_FDE_TYPE(CODE, NAME) {#NAME, sframe::FDEType::NAME},
+EnumStrings<sframe::FDEType> sframe::getFDETypes() {
+ constexpr EnumStringDef<sframe::FDEType> FDETypeDefs[] = {
+#define HANDLE_SFRAME_FDE_TYPE(CODE, NAME) {{#NAME}, sframe::FDEType::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(FDETypes);
+ static constexpr auto FDETypes = BUILD_ENUM_STRINGS(FDETypeDefs);
+ return EnumStrings(FDETypes);
}
-ArrayRef<EnumEntry<sframe::AArch64PAuthKey>> sframe::getAArch64PAuthKeys() {
- static constexpr EnumEntry<sframe::AArch64PAuthKey> AArch64PAuthKeys[] = {
+EnumStrings<sframe::AArch64PAuthKey> sframe::getAArch64PAuthKeys() {
+ constexpr EnumStringDef<sframe::AArch64PAuthKey> AArch64PAuthKeyDefs[] = {
#define HANDLE_SFRAME_AARCH64_PAUTH_KEY(CODE, NAME) \
- {#NAME, sframe::AArch64PAuthKey::NAME},
+ {{#NAME}, sframe::AArch64PAuthKey::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(AArch64PAuthKeys);
+ static constexpr auto AArch64PAuthKeys =
+ BUILD_ENUM_STRINGS(AArch64PAuthKeyDefs);
+ return EnumStrings(AArch64PAuthKeys);
}
-ArrayRef<EnumEntry<sframe::FREOffset>> sframe::getFREOffsets() {
- static constexpr EnumEntry<sframe::FREOffset> FREOffsets[] = {
-#define HANDLE_SFRAME_FRE_OFFSET(CODE, NAME) {#NAME, sframe::FREOffset::NAME},
+EnumStrings<sframe::FREOffset> sframe::getFREOffsets() {
+ constexpr EnumStringDef<sframe::FREOffset> FREOffsetDefs[] = {
+#define HANDLE_SFRAME_FRE_OFFSET(CODE, NAME) {{#NAME}, sframe::FREOffset::NAME},
#include "llvm/BinaryFormat/SFrameConstants.def"
};
- return ArrayRef(FREOffsets);
+ static constexpr auto FREOffsets = BUILD_ENUM_STRINGS(FREOffsetDefs);
+ return EnumStrings(FREOffsets);
}
-ArrayRef<EnumEntry<sframe::BaseReg>> sframe::getBaseRegisters() {
- static constexpr EnumEntry<sframe::BaseReg> BaseRegs[] = {
- {"FP", sframe::BaseReg::FP},
- {"SP", sframe::BaseReg::SP},
+EnumStrings<sframe::BaseReg> sframe::getBaseRegisters() {
+ constexpr EnumStringDef<sframe::BaseReg> BaseRegDefs[] = {
+ {{"FP"}, sframe::BaseReg::FP},
+ {{"SP"}, sframe::BaseReg::SP},
};
- return ArrayRef(BaseRegs);
+ static constexpr auto BaseRegs = BUILD_ENUM_STRINGS(BaseRegDefs);
+ return EnumStrings(BaseRegs);
}
diff --git a/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp b/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
index 67b9e7d5001fd..7f12db8404600 100644
--- a/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
+++ b/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
@@ -21,7 +21,7 @@ namespace rootsig {
template <typename T>
static raw_ostream &printFlags(raw_ostream &OS, const T Value,
- ArrayRef<EnumEntry<T>> Flags) {
+ EnumStrings<T> Flags) {
bool FlagSet = false;
unsigned Remaining = llvm::to_underlying(Value);
while (Remaining) {
@@ -30,7 +30,7 @@ static raw_ostream &printFlags(raw_ostream &OS, const T Value,
if (FlagSet)
OS << " | ";
- StringRef MaybeFlag = enumToStringRef(T(Bit), Flags);
+ StringRef MaybeFlag = Flags.toString(T(Bit));
if (!MaybeFlag.empty())
OS << MaybeFlag;
else
@@ -61,35 +61,35 @@ static raw_ostream &operator<<(raw_ostream &OS, const Register &Reg) {
static raw_ostream &operator<<(raw_ostream &OS,
const llvm::dxbc::ShaderVisibility &Visibility) {
- OS << enumToStringRef(Visibility, dxbc::getShaderVisibility());
+ OS << dxbc::getShaderVisibility().toString(Visibility);
return OS;
}
static raw_ostream &operator<<(raw_ostream &OS,
const llvm::dxbc::SamplerFilter &Filter) {
- OS << enumToStringRef(Filter, dxbc::getSamplerFilters());
+ OS << dxbc::getSamplerFilters().toString(Filter);
return OS;
}
static raw_ostream &operator<<(raw_ostream &OS,
const dxbc::TextureAddressMode &Address) {
- OS << enumToStringRef(Address, dxbc::getTextureAddressModes());
+ OS << dxbc::getTextureAddressModes().toString(Address);
return OS;
}
static raw_ostream &operator<<(raw_ostream &OS,
const dxbc::ComparisonFunc &CompFunc) {
- OS << enumToStringRef(CompFunc, dxbc::getComparisonFuncs());
+ OS << dxbc::getComparisonFuncs().toString(CompFunc);
return OS;
}
static raw_ostream &operator<<(raw_ostream &OS,
const dxbc::StaticBorderColor &BorderColor) {
- OS << enumToStringRef(BorderColor, dxbc::getStaticBorderColors());
+ OS << dxbc::getStaticBorderColors().toString(BorderColor);
return OS;
}
diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
index 1671ec2afed9b..aaf9820c2d668 100644
--- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp
+++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
@@ -622,104 +622,105 @@ void MappingTraits<DXContainerYAML::StringTableEntry>::mapping(
void ScalarEnumerationTraits<dxbc::PSV::SemanticKind>::enumeration(
IO &IO, dxbc::PSV::SemanticKind &Value) {
for (const auto &E : dxbc::PSV::getSemanticKinds())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::PSV::ComponentType>::enumeration(
IO &IO, dxbc::PSV::ComponentType &Value) {
for (const auto &E : dxbc::PSV::getComponentTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::PSV::InterpolationMode>::enumeration(
IO &IO, dxbc::PSV::InterpolationMode &Value) {
for (const auto &E : dxbc::PSV::getInterpolationModes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::PSV::ResourceType>::enumeration(
IO &IO, dxbc::PSV::ResourceType &Value) {
for (const auto &E : dxbc::PSV::getResourceTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::PSV::ResourceKind>::enumeration(
IO &IO, dxbc::PSV::ResourceKind &Value) {
for (const auto &E : dxbc::PSV::getResourceKinds())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::D3DSystemValue>::enumeration(
IO &IO, dxbc::D3DSystemValue &Value) {
for (const auto &E : dxbc::getD3DSystemValues())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::SigMinPrecision>::enumeration(
IO &IO, dxbc::SigMinPrecision &Value) {
for (const auto &E : dxbc::getSigMinPrecisions())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::SigComponentType>::enumeration(
IO &IO, dxbc::SigComponentType &Value) {
for (const auto &E : dxbc::getSigComponentTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::RootParameterType>::enumeration(
IO &IO, dxbc::RootParameterType &Value) {
for (const auto &E : dxbc::getRootParameterTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxil::ResourceClass>::enumeration(
IO &IO, dxil::ResourceClass &Value) {
- const EnumEntry<dxil::ResourceClass> ResourceClasses[] = {
- {"CBuffer", dxil::ResourceClass::CBuffer},
- {"SRV", dxil::ResourceClass::SRV},
- {"UAV", dxil::ResourceClass::UAV},
- {"Sampler", dxil::ResourceClass::Sampler},
+ constexpr EnumStringDef<dxil::ResourceClass> ResourceClassDefs[] = {
+ {{"CBuffer"}, dxil::ResourceClass::CBuffer},
+ {{"SRV"}, dxil::ResourceClass::SRV},
+ {{"UAV"}, dxil::ResourceClass::UAV},
+ {{"Sampler"}, dxil::ResourceClass::Sampler},
};
+ static constexpr auto ResourceClasses = BUILD_ENUM_STRINGS(ResourceClassDefs);
- for (const auto &E : ResourceClasses)
- IO.enumCase(Value, E.Name, E.Value);
+ for (const auto &E : EnumStrings(ResourceClasses))
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::SamplerFilter>::enumeration(
IO &IO, dxbc::SamplerFilter &Value) {
for (const auto &E : dxbc::getSamplerFilters())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::StaticBorderColor>::enumeration(
IO &IO, dxbc::StaticBorderColor &Value) {
for (const auto &E : dxbc::getStaticBorderColors())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::TextureAddressMode>::enumeration(
IO &IO, dxbc::TextureAddressMode &Value) {
for (const auto &E : dxbc::getTextureAddressModes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::ShaderVisibility>::enumeration(
IO &IO, dxbc::ShaderVisibility &Value) {
for (const auto &E : dxbc::getShaderVisibility())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<dxbc::ComparisonFunc>::enumeration(
IO &IO, dxbc::ComparisonFunc &Value) {
for (const auto &E : dxbc::getComparisonFuncs())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<llvm::dxbc::SourceInfo::SectionType>::enumeration(
IO &IO, llvm::dxbc::SourceInfo::SectionType &Value) {
for (const auto &E : dxbc::SourceInfo::getSectionTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void ScalarEnumerationTraits<
@@ -727,7 +728,7 @@ void ScalarEnumerationTraits<
enumeration(IO &IO,
llvm::dxbc::SourceInfo::Contents::CompressionType &Value) {
for (const auto &E : dxbc::SourceInfo::Contents::getCompressionTypes())
- IO.enumCase(Value, E.Name, E.Value);
+ IO.enumCase(Value, E.name(), E.value());
}
void MappingTraits<llvm::DXContainerYAML::SourceInfo::Header>::mapping(
diff --git a/llvm/tools/llvm-objdump/DXContainerDump.cpp b/llvm/tools/llvm-objdump/DXContainerDump.cpp
index 52963e0f7d1b6..28b4702f33f12 100644
--- a/llvm/tools/llvm-objdump/DXContainerDump.cpp
+++ b/llvm/tools/llvm-objdump/DXContainerDump.cpp
@@ -96,13 +96,12 @@ void DXContainerDumper::printSignature(const DirectX::Signature &S) {
for (auto El : S) {
LongestName = std::max(LongestName, S.getName(El.NameOffset).size());
LongestSV = std::max(
- LongestSV,
- enumToStringRef(El.SystemValue, dxbc::getD3DSystemValues()).size());
+ LongestSV, dxbc::getD3DSystemValues().toString(El.SystemValue).size());
LongestIndex = std::max(LongestIndex, digitsForNumber(El.Index));
LongestRegister = std::max(LongestRegister, digitsForNumber(El.Register));
- LongestFormat = std::max(
- LongestFormat,
- enumToStringRef(El.CompType, dxbc::getSigComponentTypes()).size());
+ LongestFormat =
+ std::max(LongestFormat,
+ dxbc::getSigComponentTypes().toString(El.CompType).size());
}
// Print Column headers.
@@ -123,13 +122,11 @@ void DXContainerDumper::printSignature(const DirectX::Signature &S) {
OS << right_justify(std::to_string(El.Index), LongestIndex) << " ";
OS << right_justify(maskToString(El.Mask), MaskWidth) << " ";
OS << right_justify(std::to_string(El.Register), LongestRegister) << " ";
- OS << right_justify(
- enumToStringRef(El.SystemValue, dxbc::getD3DSystemValues()),
- LongestSV)
+ OS << right_justify(dxbc::getD3DSystemValues().toString(El.SystemValue),
+ LongestSV)
<< " ";
- OS << right_justify(
- enumToStringRef(El.CompType, dxbc::getSigComponentTypes()),
- LongestFormat);
+ OS << right_justify(dxbc::getSigComponentTypes().toString(El.CompType),
+ LongestFormat);
if (El.ExclusiveMask)
OS << " " << maskToString(El.ExclusiveMask, true);
OS << "\n";
More information about the llvm-commits
mailing list