llvm · joaosaffran · May 29, 2025 · Apr 24, 2025 · Apr 24, 2025 · Apr 25, 2025
diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h
@@ -153,6 +153,50 @@ enum class FeatureFlags : uint64_t {
 static_assert((uint64_t)FeatureFlags::NextUnusedBit <= 1ull << 63,
              "Shader flag bits exceed enum size.");

+#define ROOT_ELEMENT_FLAG(Num, Val) Val = 1ull << Num,
+enum class RootElementFlag : uint32_t {
+#include "DXContainerConstants.def"
+};
+
+#define ROOT_DESCRIPTOR_FLAG(Num, Val) Val = 1ull << Num,
+enum class RootDescriptorFlag : uint32_t {
+#include "DXContainerConstants.def"
+};
+
+#define ROOT_PARAMETER(Val, Enum) Enum = Val,
+enum class RootParameterType : uint32_t {
+#include "DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
+
+#define ROOT_PARAMETER(Val, Enum)                                              \
+  case Val:                                                                    \
+    return true;
+inline bool isValidParameterType(uint32_t V) {
+  switch (V) {
+#include "DXContainerConstants.def"
+  }
+  return false;
+}
+
+#define SHADER_VISIBILITY(Val, Enum) Enum = Val,
+enum class ShaderVisibility : uint32_t {
+#include "DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<ShaderVisibility>> getShaderVisibility();
+
+#define SHADER_VISIBILITY(Val, Enum)                                           \
+  case Val:                                                                    \
+    return true;
+inline bool isValidShaderVisibility(uint32_t V) {
+  switch (V) {
+#include "DXContainerConstants.def"
+  }
+  return false;
+}
+
 PartType parsePartType(StringRef S);

 struct VertexPSVInfo {
@@ -553,146 +597,16 @@ struct RootDescriptor {
 };
 } // namespace v1

-namespace RTS0 {
-
-#define ROOT_ELEMENT_FLAG(Num, Val) Val = 1ull << Num,
-enum class RootElementFlag : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) Val = 1ull << Num,
-enum class RootDescriptorFlag : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) Val = 1ull << Num,
-enum class DescriptorRangeFlag : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-#define ROOT_PARAMETER(Val, Enum) Enum = Val,
-enum class RootParameterType : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
-
-#define DESCRIPTOR_RANGE(Val, Enum) Enum = Val,
-enum class DescriptorRangeType : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<DescriptorRangeType>> getDescriptorRangeTypes();
-
-#define ROOT_PARAMETER(Val, Enum)                                              \
-  case Val:                                                                    \
-    return true;
-inline bool isValidParameterType(uint32_t V) {
-  switch (V) {
-#include "DXContainerConstants.def"
-  }
-  return false;
-}
-
-#define SHADER_VISIBILITY(Val, Enum) Enum = Val,
-enum class ShaderVisibility : uint32_t {
-#include "DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<ShaderVisibility>> getShaderVisibility();
-
-#define SHADER_VISIBILITY(Val, Enum)                                           \
-  case Val:                                                                    \
-    return true;
-inline bool isValidShaderVisibility(uint32_t V) {
-  switch (V) {
-#include "DXContainerConstants.def"
-  }
-  return false;
-}
-
-namespace v1 {
-
-struct RootSignatureHeader {
-  uint32_t Version;
-  uint32_t NumParameters;
-  uint32_t ParametersOffset;
-  uint32_t NumStaticSamplers;
-  uint32_t StaticSamplerOffset;
-  uint32_t Flags;
-
-  void swapBytes() {
-    sys::swapByteOrder(Version);
-    sys::swapByteOrder(NumParameters);
-    sys::swapByteOrder(ParametersOffset);
-    sys::swapByteOrder(NumStaticSamplers);
-    sys::swapByteOrder(StaticSamplerOffset);
-    sys::swapByteOrder(Flags);
-  }
-};
-
-struct RootParameterHeader {
-  uint32_t ParameterType;
-  uint32_t ShaderVisibility;
-  uint32_t ParameterOffset;
-
-  void swapBytes() {
-    sys::swapByteOrder(ParameterType);
-    sys::swapByteOrder(ShaderVisibility);
-    sys::swapByteOrder(ParameterOffset);
-  }
-};
-
-struct RootConstants {
-  uint32_t ShaderRegister;
-  uint32_t RegisterSpace;
-  uint32_t Num32BitValues;
-
-  void swapBytes() {
-    sys::swapByteOrder(ShaderRegister);
-    sys::swapByteOrder(RegisterSpace);
-    sys::swapByteOrder(Num32BitValues);
-  }
-};
-
-struct RootDescriptor {
-  uint32_t ShaderRegister;
-  uint32_t RegisterSpace;
-  void swapBytes() {
-    sys::swapByteOrder(ShaderRegister);
-    sys::swapByteOrder(RegisterSpace);
-  }
-};
-
-struct DescriptorRange {
-  uint32_t RangeType;
-  uint32_t NumDescriptors;
-  uint32_t BaseShaderRegister;
-  uint32_t RegisterSpace;
-  int32_t OffsetInDescriptorsFromTableStart;
-  void swapBytes() {
-    sys::swapByteOrder(RangeType);
-    sys::swapByteOrder(NumDescriptors);
-    sys::swapByteOrder(BaseShaderRegister);
-    sys::swapByteOrder(RegisterSpace);
-    sys::swapByteOrder(OffsetInDescriptorsFromTableStart);
-  }
-};
-} // namespace v1
-
 namespace v2 {
 struct RootDescriptor : public v1::RootDescriptor {
  uint32_t Flags;
-  void swapBytes() {
-    v1::RootDescriptor::swapBytes();
-    sys::swapByteOrder(Flags);
-  }
-};

-struct DescriptorRange : public v1::DescriptorRange {
-  uint32_t Flags;
+  RootDescriptor() = default;
+  explicit RootDescriptor(v1::RootDescriptor &Base)
+      : v1::RootDescriptor(Base), Flags(0u) {}
+
  void swapBytes() {
-    v1::DescriptorRange::swapBytes();
+    v1::RootDescriptor::swapBytes();
    sys::swapByteOrder(Flags);
  }
 };

diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
@@ -86,38 +86,15 @@ ROOT_DESCRIPTOR_FLAG(3, DATA_STATIC)
 #endif // ROOT_DESCRIPTOR_FLAG


-// DESCRIPTOR_RANGE_FLAG(bit offset for the flag, name).
-#ifdef DESCRIPTOR_RANGE_FLAG
-
-DESCRIPTOR_RANGE_FLAG(0, NONE)
-DESCRIPTOR_RANGE_FLAG(1, DESCRIPTORS_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(2, DATA_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(3, DATA_STATIC_WHILE_SET_AT_EXECUTE)
-DESCRIPTOR_RANGE_FLAG(4, DATA_STATIC)
-DESCRIPTOR_RANGE_FLAG(16, DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
-#undef DESCRIPTOR_RANGE_FLAG
-#endif // DESCRIPTOR_RANGE_FLAG
-
 #ifdef ROOT_PARAMETER

-ROOT_PARAMETER(0, DescriptorTable)
 ROOT_PARAMETER(1, Constants32Bit)
 ROOT_PARAMETER(2, CBV)
 ROOT_PARAMETER(3, SRV)
 ROOT_PARAMETER(4, UAV)
 #undef ROOT_PARAMETER
 #endif // ROOT_PARAMETER

-
-#ifdef DESCRIPTOR_RANGE
-
-DESCRIPTOR_RANGE(0, SRV)
-DESCRIPTOR_RANGE(1, UAV)
-DESCRIPTOR_RANGE(2, CBV)
-DESCRIPTOR_RANGE(3, Sampler)
-#undef DESCRIPTOR_RANGE
-#endif // DESCRIPTOR_RANGE
-
 #ifdef SHADER_VISIBILITY

 SHADER_VISIBILITY(0, All)

diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h
@@ -6,14 +6,9 @@
 //
 //===----------------------------------------------------------------------===//

-#include "llvm/ADT/STLForwardCompat.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/DXContainer.h"
-#include <cstddef>
 #include <cstdint>
-#include <optional>
-#include <utility>
-#include <variant>
+#include <limits>

 namespace llvm {

@@ -26,81 +21,53 @@ struct RootParameterInfo {

  RootParameterInfo() = default;

-  RootParameterInfo(dxbc::RTS0::v1::RootParameterHeader H, size_t L)
-      : Header(H), Location(L) {}
+  RootParameterInfo(dxbc::RootParameterHeader Header, size_t Location)
+      : Header(Header), Location(Location) {}
 };
-using DescriptorRanges = std::variant<dxbc::RTS0::v1::DescriptorRange,
-                                      dxbc::RTS0::v2::DescriptorRange>;
-struct DescriptorTable {
-  SmallVector<DescriptorRanges> Ranges;

-  SmallVector<DescriptorRanges>::const_iterator begin() const {
-    return Ranges.begin();
-  }
-  SmallVector<DescriptorRanges>::const_iterator end() const {
-    return Ranges.end();
-  }
-};
-
-using RootDescriptor = std::variant<dxbc::RTS0::v1::RootDescriptor,
-                                    dxbc::RTS0::v2::RootDescriptor>;
-
-using ParametersView = std::variant<const dxbc::RTS0::v1::RootConstants *,
-                                    const dxbc::RTS0::v1::RootDescriptor *,
-                                    const dxbc::RTS0::v2::RootDescriptor *,
-                                    const DescriptorTable *>;
 struct RootParametersContainer {
  SmallVector<RootParameterInfo> ParametersInfo;
-  SmallVector<dxbc::RTS0::v1::RootConstants> Constants;
-  SmallVector<RootDescriptor> Descriptors;
-  SmallVector<DescriptorTable> Tables;

-  void addInfo(dxbc::RTS0::v1::RootParameterHeader H, size_t L) {
-    ParametersInfo.push_back(RootParameterInfo(H, L));
+  SmallVector<dxbc::RootConstants> Constants;
+  SmallVector<dxbc::RTS0::v2::RootDescriptor> Descriptors;
+
+  void addInfo(dxbc::RootParameterHeader Header, size_t Location) {
+    ParametersInfo.push_back(RootParameterInfo(Header, Location));
+  }
+
+  void addParameter(dxbc::RootParameterHeader Header,
+                    dxbc::RootConstants Constant) {
+    addInfo(Header, Constants.size());
+    Constants.push_back(Constant);
+  }
+
+  void addInvalidParameter(dxbc::RootParameterHeader Header) {
+    addInfo(Header, -1);
  }

-  void addParameter(dxbc::RTS0::v1::RootParameterHeader H,
-                    dxbc::RTS0::v1::RootConstants C) {
-    addInfo(H, Constants.size());
-    Constants.push_back(C);
+  void addParameter(dxbc::RootParameterHeader Header,
+                    dxbc::RTS0::v2::RootDescriptor Descriptor) {
+    addInfo(Header, Descriptors.size());
+    Descriptors.push_back(Descriptor);
  }

-  void addParameter(dxbc::RTS0::v1::RootParameterHeader H,
-                    dxbc::RTS0::v1::RootDescriptor D) {
-    addInfo(H, Descriptors.size());
-    Descriptors.push_back(D);
+  const std::pair<uint32_t, uint32_t>
+  getTypeAndLocForParameter(uint32_t Location) const {
+    const RootParameterInfo &Info = ParametersInfo[Location];
+    return {Info.Header.ParameterType, Info.Location};
  }

-  void addParameter(dxbc::RTS0::v1::RootParameterHeader H,
-                    dxbc::RTS0::v2::RootDescriptor D) {
-    addInfo(H, Descriptors.size());
-    Descriptors.push_back(D);
+  const dxbc::RootParameterHeader &getHeader(size_t Location) const {
+    const RootParameterInfo &Info = ParametersInfo[Location];
+    return Info.Header;
  }

-  void addParameter(dxbc::RTS0::v1::RootParameterHeader H, DescriptorTable D) {
-    addInfo(H, Tables.size());
-    Tables.push_back(D);
+  const dxbc::RootConstants &getConstant(size_t Index) const {
+    return Constants[Index];
  }

-  std::optional<ParametersView> getParameter(const RootParameterInfo *H) const {
-    switch (H->Header.ParameterType) {
-    case llvm::to_underlying(dxbc::RTS0::RootParameterType::Constants32Bit):
-      return &Constants[H->Location];
-    case llvm::to_underlying(dxbc::RTS0::RootParameterType::CBV):
-    case llvm::to_underlying(dxbc::RTS0::RootParameterType::SRV):
-    case llvm::to_underlying(dxbc::RTS0::RootParameterType::UAV): {
-      const RootDescriptor &VersionedParam = Descriptors[H->Location];
-      if (std::holds_alternative<dxbc::RTS0::v1::RootDescriptor>(
-              VersionedParam)) {
-        return &std::get<dxbc::RTS0::v1::RootDescriptor>(VersionedParam);
-      }
-      return &std::get<dxbc::RTS0::v2::RootDescriptor>(VersionedParam);
-    }
-    case llvm::to_underlying(dxbc::RTS0::RootParameterType::DescriptorTable):
-      return &Tables[H->Location];
-    }
-
-    return std::nullopt;
+  const dxbc::RTS0::v2::RootDescriptor &getRootDescriptor(size_t Index) const {
+    return Descriptors[Index];
  }

  size_t size() const { return ParametersInfo.size(); }