[DirectX] Adding missing descriptor table validations #153276

joaosaffran · 2025-08-12T20:22:59Z

This patch adds 2 small validation to DirectX backend. First, it checks if registers in descriptor tables are not overflowing, meaning they don't try to bind registers over the maximum allowed value; second, it checks if samplers are being mixed with other resource types.
Closes: #153057, #153058

llvmbot · 2025-08-12T20:23:29Z

@llvm/pr-subscribers-hlsl

@llvm/pr-subscribers-backend-directx

Author: None (joaosaffran)

Changes

This patch adds 2 small validation to DirectX backend. First, it checks if registers in descriptor tables are not overflowing, meaning they don't try to bind registers over the maximum allowed value; second, it checks if samplers are being mixed with other resource types.
Closes: #153057, #153058

Full diff: https://github.com/llvm/llvm-project/pull/153276.diff

4 Files Affected:

(modified) llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp (+96-7)
(added) llvm/test/CodeGen/DirectX/rootsignature-validation-fail-appending-overflow.ll (+18)
(added) llvm/test/CodeGen/DirectX/rootsignature-validation-fail-register-overflow.ll (+17)
(added) llvm/test/CodeGen/DirectX/rootsignature-validation-fail-sampler-mix.ll (+18)

diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp
index abcefe287d9bc..7067d6a2960e8 100644
--- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp
+++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp
@@ -155,6 +155,31 @@ reportRegNotBound(Module &M, ResourceClass Class,
   M.getContext().diagnose(DiagnosticInfoGeneric(Message));
 }
 
+static void
+reportDescriptorTableMixingTypes(Module &M, uint32_t Location,
+                                 dxbc::DescriptorRangeType RangeType) {
+  SmallString<128> Message;
+  raw_svector_ostream OS(Message);
+  OS << "Samplers cannot be mixed with other "
+     << "resource types in a descriptor table, "
+     << getResourceClassName(toResourceClass(RangeType))
+     << "(location=" << Location << ")";
+
+  M.getContext().diagnose(DiagnosticInfoGeneric(Message));
+}
+
+static void reportOverlowingRange(Module &M, const dxbc::RTS0::v2::DescriptorRange &Range) {
+  SmallString<128> Message;
+  raw_svector_ostream OS(Message);
+  OS << "Cannot append range with implicit lower " 
+      << "bound after an unbounded range "
+      << getResourceClassName(toResourceClass(static_cast<dxbc::DescriptorRangeType>(Range.RangeType)))
+      << "(register=" << Range.BaseShaderRegister << ", space=" << 
+      Range.RegisterSpace
+      << ") exceeds maximum allowed value.";
+  M.getContext().diagnose(DiagnosticInfoGeneric(Message));
+}
+
 static void reportInvalidHandleTy(
     Module &M, const llvm::ArrayRef<dxil::ResourceInfo::ResourceBinding> &RDs,
     const iterator_range<SmallVectorImpl<dxil::ResourceInfo>::iterator>
@@ -236,10 +261,73 @@ getRootDescriptorsBindingInfo(const mcdxbc::RootSignatureDesc &RSD,
   return RDs;
 }
 
-static void validateRootSignature(Module &M,
-                                  const mcdxbc::RootSignatureDesc &RSD,
-                                  dxil::ModuleMetadataInfo &MMI,
-                                  DXILResourceMap &DRM) {
+
+
+static void validateDescriptorTables(Module &M,
+                                     const mcdxbc::RootSignatureDesc &RSD,
+                                     dxil::ModuleMetadataInfo &MMI,
+                                     DXILResourceMap &DRM) {
+  for (const mcdxbc::RootParameterInfo &ParamInfo : RSD.ParametersContainer) {
+    if (static_cast<dxbc::RootParameterType>(ParamInfo.Header.ParameterType) !=
+        dxbc::RootParameterType::DescriptorTable)
+      continue;
+
+    mcdxbc::DescriptorTable Table =
+        RSD.ParametersContainer.getDescriptorTable(ParamInfo.Location);
+
+    bool HasSampler = false;
+    bool HasOtherRangeType = false;
+    dxbc::DescriptorRangeType OtherRangeType;
+    uint32_t OtherRangeTypeLocation = 0;
+
+    uint64_t AppendingOffset = 0;
+
+
+    for (const dxbc::RTS0::v2::DescriptorRange &Range : Table.Ranges) {
+      dxbc::DescriptorRangeType RangeType =
+          static_cast<dxbc::DescriptorRangeType>(Range.RangeType);
+      
+      uint64_t Offset = AppendingOffset;
+      if(Range.OffsetInDescriptorsFromTableStart != ~0U)
+        Offset = Range.OffsetInDescriptorsFromTableStart;
+      
+      if(Offset > ~0U)
+        reportOverlowingRange(M, Range);
+      if(Range.NumDescriptors == ~0U) {
+        AppendingOffset = (uint64_t)~0U + (uint64_t)1ULL;
+      } else { 
+        uint64_t UpperBound = (uint64_t)Range.BaseShaderRegister + (uint64_t)Range.NumDescriptors - (uint64_t)1U;
+        if(UpperBound > ~0U)
+          reportOverlowingRange(M, Range);
+
+        uint64_t AppendingUpperBound = (uint64_t)Offset + (uint64_t)Range.NumDescriptors - (uint64_t)1U;
+        if(AppendingUpperBound > ~0U)
+          reportOverlowingRange(M, Range);
+        AppendingOffset = Offset + Range.NumDescriptors;
+      }
+      
+      if (RangeType == dxbc::DescriptorRangeType::Sampler) {
+        HasSampler = true;
+      } else {
+        HasOtherRangeType = true;
+        OtherRangeType = RangeType;
+        OtherRangeTypeLocation = ParamInfo.Location;
+      }
+    }
+
+    // Samplers cannot be mixed with other resources in a descriptor table.
+    if (HasSampler && HasOtherRangeType) {
+      reportDescriptorTableMixingTypes(M, OtherRangeTypeLocation,
+                                       OtherRangeType);
+      continue;
+    }
+  }
+}
+
+static void validateRootSignatureBindings(Module &M,
+                                          const mcdxbc::RootSignatureDesc &RSD,
+                                          dxil::ModuleMetadataInfo &MMI,
+                                          DXILResourceMap &DRM) {
 
   hlsl::BindingInfoBuilder Builder;
   dxbc::ShaderVisibility Visibility = tripleToVisibility(MMI.ShaderProfile);
@@ -309,7 +397,6 @@ static void validateRootSignature(Module &M,
         reportOverlappingRegisters(M, ReportedBinding, Overlaping);
       });
   // Next checks require that the root signature definition is valid.
-  // Next checks require that the root signature definition is valid.
   if (!HasOverlap) {
     SmallVector<ResourceInfo::ResourceBinding> RDs =
         getRootDescriptorsBindingInfo(RSD, Visibility);
@@ -351,8 +438,10 @@ static void reportErrors(Module &M, DXILResourceMap &DRM,
   assert(!DRBI.hasImplicitBinding() && "implicit bindings should be handled in "
                                        "DXILResourceImplicitBinding pass");
 
-  if (mcdxbc::RootSignatureDesc *RSD = getRootSignature(RSBI, MMI))
-    validateRootSignature(M, *RSD, MMI, DRM);
+  if (mcdxbc::RootSignatureDesc *RSD = getRootSignature(RSBI, MMI)) {
+    validateRootSignatureBindings(M, *RSD, MMI, DRM);
+    validateDescriptorTables(M, *RSD, MMI, DRM);
+  }
 }
 
 PreservedAnalyses
diff --git a/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-appending-overflow.ll b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-appending-overflow.ll
new file mode 100644
index 0000000000000..865312a43b5a8
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-appending-overflow.ll
@@ -0,0 +1,18 @@
+; RUN: not opt -S -passes='dxil-post-optimization-validation' -mtriple=dxil-pc-shadermodel6.6-compute %s 2>&1 | FileCheck %s
+; CHECK: error: Cannot append range with implicit lower bound after an unbounded range UAV(register=3, space=4) exceeds maximum allowed value.
+
+@TB.str = private unnamed_addr constant [3 x i8] c"TB\00", align 1
+
+define void @CSMain() "hlsl.shader"="compute" {
+entry:
+  ret void
+}
+
+!dx.rootsignatures = !{!0}
+
+!0 = !{ptr @CSMain, !1, i32 2}
+!1 = !{!3}
+!3 = !{!"DescriptorTable", i32 0, !4, !5}
+!4 = !{!"UAV", i32 -1, i32 1, i32 2, i32 -1, i32 0}
+!5 = !{!"UAV", i32 1, i32 3, i32 4, i32 -1, i32 0}
+
diff --git a/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-register-overflow.ll b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-register-overflow.ll
new file mode 100644
index 0000000000000..ef887baf80728
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-register-overflow.ll
@@ -0,0 +1,17 @@
+; RUN: not opt -S -passes='dxil-post-optimization-validation' -mtriple=dxil-pc-shadermodel6.6-compute %s 2>&1 | FileCheck %s
+; CHECK: error: Cannot append range with implicit lower bound after an unbounded range UAV(register=4294967295, space=0) exceeds maximum allowed value. 
+
+@TB.str = private unnamed_addr constant [3 x i8] c"TB\00", align 1
+
+define void @CSMain() "hlsl.shader"="compute" {
+entry:
+  ret void
+}
+
+!dx.rootsignatures = !{!0}
+
+!0 = !{ptr @CSMain, !1, i32 2}
+!1 = !{!3}
+!3 = !{!"DescriptorTable", i32 0, !4}
+!4 = !{!"UAV", i32 100, i32 4294967295, i32 0, i32 -1, i32 0}
+
diff --git a/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-sampler-mix.ll b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-sampler-mix.ll
new file mode 100644
index 0000000000000..d4caeb2675d82
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/rootsignature-validation-fail-sampler-mix.ll
@@ -0,0 +1,18 @@
+; RUN: not opt -S -passes='dxil-post-optimization-validation' -mtriple=dxil-pc-shadermodel6.6-compute %s 2>&1 | FileCheck %s
+; CHECK: error: Samplers cannot be mixed with other resource types in a descriptor table, UAV(location=0)
+
+@TB.str = private unnamed_addr constant [3 x i8] c"TB\00", align 1
+
+define void @CSMain() "hlsl.shader"="compute" {
+entry:
+  ret void
+}
+
+!dx.rootsignatures = !{!0}
+
+!0 = !{ptr @CSMain, !1, i32 2}
+!1 = !{!3}
+!3 = !{!"DescriptorTable", i32 0, !4, !5}
+!4 = !{!"UAV", i32 1, i32 0, i32 0, i32 -1, i32 0}
+!5 = !{!"Sampler", i32 2, i32 0, i32 0, i32 -1, i32 0}
+

github-actions · 2025-08-12T20:24:41Z

⚠️ We detected that you are using a GitHub private e-mail address to contribute to the repo.
Please turn off Keep my email addresses private setting in your account.
See LLVM Developer Policy and LLVM Discourse for more information.

github-actions · 2025-08-12T20:26:15Z

✅ With the latest revision this PR passed the C/C++ code formatter.

inbelic · 2025-08-12T21:20:03Z

llvm/test/CodeGen/DirectX/rootsignature-validation-fail-register-overflow.ll

@@ -0,0 +1,17 @@
+; RUN: not opt -S -passes='dxil-post-optimization-validation' -mtriple=dxil-pc-shadermodel6.6-compute %s 2>&1 | FileCheck %s
+; CHECK: error: Cannot append range with implicit lower bound after an unbounded range UAV(register=4294967295, space=0) exceeds maximum allowed value. 


This error message is incorrect, this case does have an explicit binding

That is the same error message as DXC. It has nothing to do with implicit binding. It means that you cannot bind if the lower bound is, implicit, exceeding the maximum allowed value. This happens when you append a range after an unbounded range.

Thant being said, I change the error message to fix this confusion.

inbelic · 2025-08-12T21:25:11Z

llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp

+static void validateDescriptorTables(Module &M,
+                                     const mcdxbc::RootSignatureDesc &RSD) {


Suggested change

static void validateDescriptorTables(Module &M,

const mcdxbc::RootSignatureDesc &RSD) {

static void validateDescriptorTable(Module &M,

const mcdxbc::DescriptorTable &Table) {

Does it make more sense to call validateDescriptorTable when we encounter a descriptor table while iterating in validateRootSignature?

inbelic · 2025-08-12T21:27:27Z

llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp

+    // Samplers cannot be mixed with other resources in a descriptor table.
+    if (HasSampler && HasOtherRangeType) {
+      reportDescriptorTableMixingTypes(M, OtherRangeTypeLocation,
+                                       OtherRangeType);
+      continue;
+    }


Suggested change

// Samplers cannot be mixed with other resources in a descriptor table.

if (HasSampler && HasOtherRangeType) {

reportDescriptorTableMixingTypes(M, OtherRangeTypeLocation,

OtherRangeType);

continue;

}

// Samplers cannot be mixed with other resources in a descriptor table.

if (HasSampler && HasOtherRangeType)

reportDescriptorTableMixingTypes(M, OtherRangeTypeLocation,

OtherRangeType);

inbelic · 2025-08-12T21:39:26Z

llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp

+      dxbc::DescriptorRangeType RangeType =
+          static_cast<dxbc::DescriptorRangeType>(Range.RangeType);
+
+      uint64_t Offset = AppendingOffset;


I am having a really hard time trying to figure what it happening here to validate it is correct. Can you add some comments to describe how this checks for an overflow

…osaffran/llvm-project into validation/descriptor-tables

inbelic · 2025-08-18T15:23:46Z

Given we want to use these for the frontend as well. Would it be possible to do these validations with an HLSLBinding instead? Both the front and backend will create the bindings I believe and could be a common interface?

inbelic · 2025-08-25T15:35:32Z

llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp

+    if (verifyOffsetOverflowing(AppendingRegister,
+                                Range.OffsetInDescriptorsFromTableStart,
+                                Range.BaseShaderRegister, Range.RegisterSpace,
+                                Range.NumDescriptors))
+      return make_error<TableRegisterOverflowError>(
+          RangeType, Range.BaseShaderRegister, Range.RegisterSpace);


I don't think it makes sense to group all these verifications into the same function and same error message. DXC provided a unique error message for each scenario.

I also think if we split this into 3 validation checks, the functions would be much easier to follow:

if Offset == append && AppendingRegister == unbound -> implict bound error

if NumDescriptors != unbound && BaseRegister + NumDescriptors - 1 >= ~0u -> overflow for shader range error

Let Offset = (Offset == append) ? AppendingRegister : Offset. Then if Offset + NumDescriptors - 1 >= ~0u -> overflow for descriptor range error

I would also personally return a std::optional<uint64_t> rather than updating AppendingRegister as a reference.

inbelic · 2025-08-25T22:22:36Z

llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp

+          RangeType, Range.BaseShaderRegister, Range.RegisterSpace);
+
+    if (verifyRegisterOverflow(AppendingRegister, Range.NumDescriptors))
+      return make_error<TableRegisterOverflowError>(


These provide the same error message for the different cases. I think we should be at least on par, if not better than DXC here. DXC for reference.

inbelic · 2025-08-25T22:23:51Z

llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp

+                                 uint32_t NumDescriptors) {
+  if (NumDescriptors == ~0U)
+    return (uint64_t)~0U + (uint64_t)1ULL;
+  return AppendingRegisterRegister + NumDescriptors;


This is also dependent on the current offset.

Suggested change

return AppendingRegisterRegister + NumDescriptors;

return Offset == append ? AppendingRegisterRegister + NumDescriptors : Offset + NumDescriptors;

inbelic

LGTM assuming the toResourceClass stuff will be removed when we rebase onto main

inbelic · 2025-08-26T16:43:10Z

llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp

  if (NumDescriptors == ~0U)
    return (uint64_t)~0U + (uint64_t)1ULL;


nit: I don't think this is required anymore

inbelic · 2025-08-26T16:47:24Z

llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp

-    if (verifyOffsetOverflow(Range.OffsetInDescriptorsFromTableStart,
-                             AppendingRegister))
-      return make_error<TableRegisterOverflowError>(
+    uint64_t StartSlot = AppendingRegister;


nit: StartSlot can just be replaced in all uses by AppendingRegister. Or if you think StartSlot is a better name then we can just use that.

...test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll

…dation/descriptor-tables

joaosaffran · 2025-08-30T01:59:46Z

llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h

@@ -40,6 +41,12 @@ LLVM_ABI bool verifyMaxAnisotropy(uint32_t MaxAnisotropy);
 LLVM_ABI bool verifyComparisonFunc(uint32_t ComparisonFunc);
 LLVM_ABI bool verifyBorderColor(uint32_t BorderColor);
 LLVM_ABI bool verifyLOD(float LOD);
+LLVM_ABI bool verifyRegisterOverflow(uint64_t Register,
+                                     uint32_t NumDescriptors);
+LLVM_ABI uint64_t updateAppendingRegister(uint64_t AppendingRegisterRegister,


This function contain important logic to make sure the previous 2 validations work properly, so I added it in here, so it can be reused in the frontend.

joaosaffran · 2025-08-30T02:54:48Z

llvm/include/llvm/BinaryFormat/DXContainer.h

+inline dxil::ResourceClass
+toResourceClass(dxbc::DescriptorRangeType RangeType) {
+  using namespace dxbc;
+  switch (RangeType) {
+  case DescriptorRangeType::SRV:
+    return dxil::ResourceClass::SRV;
+  case DescriptorRangeType::UAV:
+    return dxil::ResourceClass::UAV;
+  case DescriptorRangeType::CBV:
+    return dxil::ResourceClass::CBuffer;
+  case DescriptorRangeType::Sampler:
+    return dxil::ResourceClass::Sampler;
+  }
+  llvm_unreachable("Unknown DescriptorRangeType");
+}
+
+inline dxil::ResourceClass toResourceClass(dxbc::RootParameterType Type) {
+  using namespace dxbc;
+  switch (Type) {
+  case RootParameterType::Constants32Bit:
+    return dxil::ResourceClass::CBuffer;
+  case RootParameterType::SRV:
+    return dxil::ResourceClass::SRV;
+  case RootParameterType::UAV:
+    return dxil::ResourceClass::UAV;
+  case RootParameterType::CBV:
+    return dxil::ResourceClass::CBuffer;
+  case dxbc::RootParameterType::DescriptorTable:
+    llvm_unreachable("DescriptorTable is not convertible to ResourceClass");
+  }
+  llvm_unreachable("Unknown RootParameterType");
+}


Those are being moved to here, to be used in Frontend/HLSL/RootSignatureMetadata.h and DirectX/DxilPostOptimizationValidation.cpp

joaosaffran · 2025-08-30T03:39:01Z

llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp

+    if (RangeType == dxbc::DescriptorRangeType::Sampler) {
+      HasSampler = true;
+    } else {
+      HasOtherRangeType = true;
+      OtherRangeType = RangeType;
+    }


Using curly brackets so it follows llvm coding style recommendations.

joaosaffran · 2025-08-30T03:42:46Z

...test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll

-!5 = !{ !"DescriptorTable", i32 0, !6, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20 }
+!3 = !{ !5, !21 } ; list of root signature elements
+!5 = !{ !"DescriptorTable", i32 0, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20 }
+!21 = !{ !"DescriptorTable", i32 0,!6, !8, !9 }


This refactor is necessary, because this test was mixing samplers and non samplers in a single descriptor table, which is not allowed

joaosaffran · 2025-08-30T03:47:51Z

...test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll

-;DXC-NEXT:              - RangeType:       3
-;DXC-NEXT:                NumDescriptors:  1
-;DXC-NEXT:                BaseShaderRegister: 0
-;DXC-NEXT:                RegisterSpace:   1
-;DXC-NEXT:                OffsetInDescriptorsFromTableStart: 4294967295
-;DXC-NEXT:              - RangeType:       3
-;DXC-NEXT:                NumDescriptors:  1
-;DXC-NEXT:                BaseShaderRegister: 0
-;DXC-NEXT:                RegisterSpace:   3
-;DXC-NEXT:                OffsetInDescriptorsFromTableStart: 4294967295
-;DXC-NEXT:                DESCRIPTORS_VOLATILE: true
-;DXC-NEXT:              - RangeType:       3
-;DXC-NEXT:                NumDescriptors:  1
-;DXC-NEXT:                BaseShaderRegister: 0
-;DXC-NEXT:                RegisterSpace:   4
-;DXC-NEXT:                OffsetInDescriptorsFromTableStart: 4294967295
-;DXC-NEXT:                DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true


Those are all samplers, they are being moved to bellow

Joao Saffran added 3 commits August 12, 2025 11:21

check if table mix samplers with others

50e78d2

validating register not overflow in table

aee4c56

clean

7d1c13e

llvmbot added the backend:DirectX label Aug 12, 2025

format

85719af

Joao Saffran added 3 commits August 12, 2025 13:30

format

cc304fd

fix typo

3c28142

clean

81261ff

inbelic reviewed Aug 12, 2025

View reviewed changes

address comments

e5e73fe

llvmbot added the HLSL HLSL Language Support label Aug 12, 2025

Joao Saffran added 7 commits August 12, 2025 17:04

address comments

ad0e1f3

Merge branch 'validation/descriptor-tables' of https://github.com/joa…

d97eb7c

…osaffran/llvm-project into validation/descriptor-tables

fix comment

8a4ee3c

addressing comment

23537b5

Merge

def929f

clean up

d3349ce

moving code to where I think make sense

bf5714d

This was linked to issues Aug 18, 2025

[DirectX] Descriptor table registers can only allocate up to MAX_UINT register #153058

Open

[DirectX] validate Samples are not being mixed with other resources types in descriptor table #153057

Open

moving offset logic into shared validations

34619da

inbelic reviewed Aug 25, 2025

View reviewed changes

refactoring suggested by inbelic

84d4579

joaosaffran requested a review from inbelic August 25, 2025 21:57

inbelic reviewed Aug 25, 2025

View reviewed changes

adding multiple error messages

d2b4aea

joaosaffran requested a review from inbelic August 26, 2025 02:43

inbelic reviewed Aug 26, 2025

View reviewed changes

joaosaffran added 3 commits August 26, 2025 11:10

removing StartSlot

e2ba167

removing unecessary code

b395a47

Merge branch 'validation/textures-not-bind-root-signatures' into vali…

567bd15

…dation/descriptor-tables

joaosaffran commented Aug 30, 2025

View reviewed changes

clean up

42518b2

joaosaffran commented Aug 30, 2025

View reviewed changes

joaosaffran added 4 commits August 29, 2025 20:26

clean up

f6abbf7

clean up

2971f5f

clean up: self review

f0ed242

clean up self review

a6a9fe9

joaosaffran commented Aug 30, 2025

View reviewed changes

		@@ -0,0 +1,17 @@
		; RUN: not opt -S -passes='dxil-post-optimization-validation' -mtriple=dxil-pc-shadermodel6.6-compute %s 2>&1 \| FileCheck %s
		; CHECK: error: Cannot append range with implicit lower bound after an unbounded range UAV(register=4294967295, space=0) exceeds maximum allowed value.

		static void validateDescriptorTables(Module &M,
		const mcdxbc::RootSignatureDesc &RSD) {

	return AppendingRegisterRegister + NumDescriptors;
	return Offset == append ? AppendingRegisterRegister + NumDescriptors : Offset + NumDescriptors;

		if (NumDescriptors == ~0U)
		return (uint64_t)~0U + (uint64_t)1ULL;

[DirectX] Adding missing descriptor table validations #153276

Are you sure you want to change the base?

[DirectX] Adding missing descriptor table validations #153276

Conversation

joaosaffran commented Aug 12, 2025

Uh oh!

llvmbot commented Aug 12, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Aug 12, 2025

Uh oh!

github-actions bot commented Aug 12, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

inbelic Aug 12, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

inbelic commented Aug 18, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

inbelic left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

joaosaffran Aug 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

llvmbot commented Aug 12, 2025 •

edited

Loading

github-actions bot commented Aug 12, 2025 •

edited

Loading

inbelic Aug 12, 2025 •

edited

Loading

joaosaffran Aug 30, 2025 •

edited

Loading