[clang] [llvm] [HLSL] Add support for SV_PrimitiveID (PR #236260)
Finn Plummer via cfe-commits
cfe-commits at lists.llvm.org
Thu Oct 29 12:51:38 PDT 2026
https://github.com/inbelic updated https://github.com/llvm/llvm-project/pull/236260
>From 96bce6ef59dc8efb2220624aa82fa13c3f20e514 Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Tue, 27 Oct 2026 22:01:12 +0000
Subject: [PATCH 1/9] [HLSL] Add support for SV_SampleIndex
---
clang/lib/CodeGen/CGHLSLRuntime.cpp | 49 ++++++++++--
clang/lib/Sema/SemaHLSL.cpp | 8 +-
.../semantics/SV_SampleIndex.ps.hlsl | 51 ++++++++++++
.../SemaHLSL/Semantics/sampleindex.ps.hlsl | 57 ++++++++++++++
.../Semantics/sampleindex.stages.hlsl | 23 ++++++
.../llvm/Frontend/HLSL/SemanticSignatures.h | 2 +
llvm/include/llvm/IR/IntrinsicsDirectX.td | 3 +
llvm/lib/Frontend/HLSL/SemanticSignatures.cpp | 5 ++
llvm/lib/Target/DirectX/DXIL.td | 9 +++
llvm/lib/Target/DirectX/DXILShaderFlags.cpp | 8 +-
.../Target/DirectX/DXILSignatureAnalysis.cpp | 23 +++++-
.../SemanticSignatures-sample-index.ll | 62 +++++++++++++++
...semantic-signatures-sample-index-errors.ll | 78 +++++++++++++++++++
.../ShaderFlags/unpacked-low-precision.ll | 40 ++++++++++
llvm/test/CodeGen/DirectX/sample_index.ll | 28 +++++++
.../SPIRV/semantics/sample-index.ps.ll | 32 ++++++++
.../HLSLSemanticSignaturePackingTest.cpp | 15 ++++
.../Frontend/HLSLSemanticStagesTest.cpp | 13 +++-
18 files changed, 492 insertions(+), 14 deletions(-)
create mode 100644 clang/test/CodeGenHLSL/semantics/SV_SampleIndex.ps.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/sampleindex.ps.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/sampleindex.stages.hlsl
create mode 100644 llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-sample-index.ll
create mode 100644 llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-sample-index-errors.ll
create mode 100644 llvm/test/CodeGen/DirectX/ShaderFlags/unpacked-low-precision.ll
create mode 100644 llvm/test/CodeGen/DirectX/sample_index.ll
create mode 100644 llvm/test/CodeGen/SPIRV/semantics/sample-index.ps.ll
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 6dfec8cd934580..fac0f7b850f71a 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -1183,14 +1183,19 @@ static llvm::Value *createSPIRVInputLoad(
IRBuilder<> &B, llvm::Module &M, llvm::Type *Ty, const Twine &Name,
llvm::hlsl::SPIRVInterfaceDecoration Decoration, unsigned Operand,
llvm::hlsl::InterpolationMode InterpMode) {
+ llvm::Type *LoadTy = Ty;
+ if (Decoration == llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn &&
+ Ty->isIntegerTy() && Ty->getIntegerBitWidth() < 32)
+ LoadTy = B.getInt32Ty();
auto *GV = new llvm::GlobalVariable(
- M, Ty, /* isConstant= */ true, llvm::GlobalValue::ExternalLinkage,
+ M, LoadTy, /* isConstant= */ true, llvm::GlobalValue::ExternalLinkage,
/* Initializer= */ nullptr, Name, /* insertBefore= */ nullptr,
llvm::GlobalVariable::GeneralDynamicTLSModel,
/* AddressSpace */ 7, /* isExternallyInitialized= */ true);
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
addSPIRVInterfaceDecorations(GV, Decoration, Operand, InterpMode);
- return B.CreateLoad(Ty, GV);
+ llvm::Value *Value = B.CreateLoad(LoadTy, GV);
+ return LoadTy == Ty ? Value : B.CreateTrunc(Value, Ty);
}
llvm::Value *CGHLSLRuntime::emitSPIRVUserSemanticLoad(
@@ -1345,13 +1350,24 @@ static llvm::hlsl::SemanticSignatureElement createSemanticSignatureElement(
for (uint32_t I = 0, E = Shape.getNumRows(); I < E; ++I)
SemanticIndices.push_back(FirstSemanticIndex + I);
+ llvm::dxbc::PSV::SemanticKind Kind = llvm::hlsl::getSemanticKind(Name);
+ llvm::dxil::ElementType CompType =
+ getSignatureComponentType(CGM, Shape.RowType);
+ // These system values may be declared as int or uint, but DXIL signatures
+ // require an unsigned component type.
+ if (Kind == llvm::dxbc::PSV::SemanticKind::SampleIndex) {
+ if (CompType == llvm::dxil::ElementType::I16)
+ CompType = llvm::dxil::ElementType::U16;
+ else if (CompType == llvm::dxil::ElementType::I32)
+ CompType = llvm::dxil::ElementType::U32;
+ }
+
// The remaining members keep their default value and will be filled at a
// later stage, either during packing or analysis of usage. Interpolation
// is set by the load/store traversal after visiting each leaf.
- return llvm::hlsl::SemanticSignatureElement(
- SigId, Name, getSignatureComponentType(CGM, Shape.RowType),
- llvm::hlsl::getSemanticKind(Name), SemanticIndices,
- static_cast<uint8_t>(Shape.Cols));
+ return llvm::hlsl::SemanticSignatureElement(SigId, Name, CompType, Kind,
+ SemanticIndices,
+ static_cast<uint8_t>(Shape.Cols));
}
llvm::Value *CGHLSLRuntime::emitDXILUserSemanticLoad(
@@ -1687,6 +1703,27 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
return B.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::dx_start_vertex_location));
break;
+ case llvm::dxbc::PSV::SemanticKind::SampleIndex:
+ assert(Stage == llvm::Triple::Pixel &&
+ "SV_SampleIndex is in an unavailable stage and should have been "
+ "diagnosed by Sema");
+ if (CGM.getTarget().getTriple().isSPIRV())
+ return createSPIRVInputLoad(B, CGM.getModule(), Type,
+ Semantic->getAttrName()->getName(),
+ llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn,
+ /* SampleId */ 18, InterpMode);
+ if (CGM.getTarget().getTriple().isDXIL()) {
+ // The sample index is read with a dedicated operation, but an unpacked
+ // element is still added to the input signature for compatibility.
+ SemanticShape Shape =
+ getSemanticShape(CGM.getContext(), getSemanticLeafType(Decl));
+ Signature.push_back(createSemanticSignatureElement(
+ CGM, Signature.size(), Semantic, Index, Shape));
+ llvm::Value *SampleIndex =
+ B.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::dx_sample_index));
+ return B.CreateTrunc(SampleIndex, Type);
+ }
+ break;
case llvm::dxbc::PSV::SemanticKind::StartInstanceLocation:
assert(Stage == llvm::Triple::Vertex &&
"SV_StartInstanceLocation is in an unavailable stage and should "
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index e42f9bb21ff70f..2ce99418b2f8e1 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1015,6 +1015,7 @@ static bool isVkPipelineBuiltin(const ASTContext &AstContext, FunctionDecl *FD,
return (ST == llvm::Triple::Pixel && IsInput) ||
(ST == llvm::Triple::Vertex && !IsInput);
case SemanticKind::Barycentrics:
+ case SemanticKind::SampleIndex:
return ST == llvm::Triple::Pixel && IsInput;
case SemanticKind::StartVertexLocation:
case SemanticKind::StartInstanceLocation:
@@ -1436,6 +1437,12 @@ void SemaHLSL::diagnoseSemanticType(const Decl *D,
<< A->getAttrName() << /* scalar or vector of up to */ 1 << 4
<< /* 16 or 32 bit floating-point */ 2 << DeclaredTy;
return;
+ case SemanticKind::SampleIndex:
+ if (DeclaredTy != T || !T->isScalarType() || !isIntUpTo32Element(Ctx, T))
+ Diag(A->getLoc(), diag::err_hlsl_semantic_invalid_type)
+ << A->getAttrName() << /* scalar */ 0 << 1
+ << /* 16 or 32 bit integer */ 0 << DeclaredTy;
+ return;
case SemanticKind::InstanceID:
case SemanticKind::ShadingRate:
// DXIL permits U32 or U16. SPIR-V requires a 32-bit scalar per:
@@ -2253,7 +2260,6 @@ void SemaHLSL::handleSemanticAttr(Decl *D, const ParsedAttr &AL) {
case SemanticKind::DomainLocation:
case SemanticKind::PrimitiveID:
case SemanticKind::GSInstanceID:
- case SemanticKind::SampleIndex:
case SemanticKind::IsFrontFace:
case SemanticKind::Coverage:
case SemanticKind::InnerCoverage:
diff --git a/clang/test/CodeGenHLSL/semantics/SV_SampleIndex.ps.hlsl b/clang/test/CodeGenHLSL/semantics/SV_SampleIndex.ps.hlsl
new file mode 100644
index 00000000000000..ebbaf33f79e218
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/SV_SampleIndex.ps.hlsl
@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefixes=CHECK-DXIL,DXIL32 %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-pixel -x hlsl -emit-llvm -finclude-default-header -fnative-half-type -fnative-int16-type -disable-llvm-passes -DINT16 -o - %s | FileCheck --check-prefixes=CHECK-DXIL,DXIL16 %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefix=CHECK-SPIRV %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-pixel -x hlsl -emit-llvm -finclude-default-header -fnative-half-type -fnative-int16-type -disable-llvm-passes -DINT16 -o - %s | FileCheck --check-prefix=SPIRV16 %s
+
+#ifdef INT16
+#define TYPE int16_t
+#else
+#define TYPE int
+#endif
+
+// CHECK-SPIRV: @SV_SampleIndex = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations ![[#MD_0:]]
+
+// SV_SampleIndex is read with a dedicated operation. It still adds an unpacked
+// element to the input signature that does not consume a row, so the user
+// input that follows it is packed at row 0.
+
+// CHECK-DXIL-LABEL: define void @main()
+// CHECK-DXIL: %[[SI:.*]] = call i32 @llvm.dx.sample.index()
+// DXIL32-NOT: trunc
+// DXIL16: %[[SI16:.*]] = trunc i32 %[[SI]] to i16
+// CHECK-DXIL: %[[A:.*]] = call float @llvm.dx.load.input.f32(i32 1, i32 0, i8 0, i32 poison)
+// DXIL32: call float @_Z4mainif(i32 %[[SI]], float %[[A]])
+// DXIL16: call float @_Z4mainsf(i16 %[[SI16]], float %[[A]])
+
+// Signed declarations use an unsigned DXIL component type, with nointerpolation.
+// DXIL32-DAG: !{i32 0, !"SV_SampleIndex", i32 5, i32 12, ![[#ZERO:]], i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+// DXIL16-DAG: !{i32 0, !"SV_SampleIndex", i32 3, i32 12, ![[#ZERO:]], i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+// CHECK-DXIL-DAG: !{i32 1, !"A", i32 9, i32 0, ![[#ZERO]], i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+// CHECK-DXIL-DAG: ![[#ZERO]] = !{i32 0}
+
+// CHECK-SPIRV-LABEL: define void @main()
+// CHECK-SPIRV: %[[SI:.*]] = load i32, ptr addrspace(7) @SV_SampleIndex, align 4
+// CHECK-SPIRV: call spir_func float @_Z4mainif(i32 %[[SI]],
+float main(TYPE s : SV_SampleIndex, float a : A) : SV_Target {
+ return a * s;
+}
+
+// CHECK-SPIRV-DAG: ![[#MD_0]] = !{![[#BUILTIN:]], ![[#FLAT:]]}
+// The metadata below contains SPIR-V decoration 'BuiltIn' followed by
+// BuiltIn SampleId.
+// CHECK-SPIRV-DAG: ![[#BUILTIN]] = !{i32 11, i32 18}
+// CHECK-SPIRV-DAG: ![[#FLAT]] = !{i32 14}
+
+// The SPIR-V built-in is a 32-bit integer, so a 16-bit declaration is
+// truncated.
+// SPIRV16: @SV_SampleIndex = {{.*}} addrspace(7) externally_initialized constant i32,
+// SPIRV16-LABEL: define void @main()
+// SPIRV16: %[[V32:.*]] = load i32, ptr addrspace(7) @SV_SampleIndex
+// SPIRV16: %[[V16:.*]] = trunc i32 %[[V32]] to i16
+// SPIRV16: call spir_func float @_Z4mainsf(i16 %[[V16]],
diff --git a/clang/test/SemaHLSL/Semantics/sampleindex.ps.hlsl b/clang/test/SemaHLSL/Semantics/sampleindex.ps.hlsl
new file mode 100644
index 00000000000000..520893b5c4d9e1
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/sampleindex.ps.hlsl
@@ -0,0 +1,57 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+
+// Type, index and interpolation checks for SV_SampleIndex. These are
+// independent of the shader stage and IO direction, which are covered by
+// sampleindex.stages.hlsl.
+
+[shader("pixel")]
+void valid_uint(uint s : SV_SampleIndex) {}
+[shader("pixel")]
+void valid_int(int s : sv_sampleindex0) {}
+[shader("pixel")]
+void valid_flat(nointerpolation uint s : SV_SampleIndex) {}
+
+// 16-bit integers are allowed. SPIR-V converts them to and from the 32-bit
+// built-in.
+[shader("pixel")]
+void uint16(uint16_t s : SV_SampleIndex) {}
+[shader("pixel")]
+void int16(int16_t s : SV_SampleIndex) {}
+
+struct Input {
+ float4 p : SV_Position;
+ uint s : SV_SampleIndex;
+};
+[shader("pixel")]
+void valid_struct(Input i) {}
+
+[shader("pixel")]
+void bad_float(float s : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' must be a scalar of 16 or 32 bit integer type (was 'float')}}
+[shader("pixel")]
+void bad_bool(bool s : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' must be a scalar of 16 or 32 bit integer type (was 'bool')}}
+[shader("pixel")]
+void bad_int64(uint64_t s : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' must be a scalar of 16 or 32 bit integer type (was 'uint64_t' (aka 'unsigned long'))}}
+[shader("pixel")]
+void bad_vector(uint1 s : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' must be a scalar of 16 or 32 bit integer type (was 'uint1' (aka 'vector<uint, 1>'))}}
+[shader("pixel")]
+void bad_array(uint s[1] : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' must be a scalar of 16 or 32 bit integer type (was 'uint[1]'}}
+
+[shader("pixel")]
+void bad_index(uint s : SV_SampleIndex1) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' does not allow indexing}}
+
+[shader("pixel")]
+void same_index(uint s : SV_SampleIndex, // expected-note {{previous use is here}}
+ uint t : SV_SampleIndex0) {} // expected-note {{'t' declared here}}
+// expected-error at -1 {{semantic index overlap SV_SampleIndex0}}
+
+// Integer inputs can only use nointerpolation.
+[shader("pixel")]
+void bad_interpolation(sample uint s : SV_SampleIndex) {}
+// expected-error at -1 {{interpolation modifiers other than 'nointerpolation' cannot be used with type 'uint' (aka 'unsigned int')}}
diff --git a/clang/test/SemaHLSL/Semantics/sampleindex.stages.hlsl b/clang/test/SemaHLSL/Semantics/sampleindex.stages.hlsl
new file mode 100644
index 00000000000000..059328ccaf14ed
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/sampleindex.stages.hlsl
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -finclude-default-header -x hlsl -verify -o - %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -finclude-default-header -x hlsl -verify -o - %s
+
+// Stage and IO direction checks for SV_SampleIndex: only a pixel input.
+// Type, index and interpolation checks are covered by sampleindex.ps.hlsl.
+
+[shader("pixel")]
+float4 ok_ps_in(uint s : SV_SampleIndex) : SV_Target {
+ return float4((float)s, 0, 0, 1);
+}
+
+[shader("pixel")]
+uint bad_ps_out() : SV_SampleIndex { return 0; }
+// expected-error at -1 {{semantic 'SV_SampleIndex' is not supported in pixel shader outputs}}
+
+[shader("vertex")]
+float4 bad_vs_in(uint s : SV_SampleIndex) : SV_Position { return 0; }
+// expected-error at -1 {{semantic 'SV_SampleIndex' is not supported in vertex shader inputs}}
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void bad_cs_in(uint s : SV_SampleIndex) {}
+// expected-error at -1 {{semantic 'SV_SampleIndex' is not supported in compute shader inputs}}
diff --git a/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h b/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
index 90b7241d4d21d4..971b493ab7ee36 100644
--- a/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
+++ b/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
@@ -110,6 +110,8 @@ LLVM_ABI dxbc::PSV::InterpolationMode normalizeInterpolationMode(
enum class SemanticInterpretation {
Invalid,
NotAllocated,
+ // In the signature, but not packed. This includes DXC's Shadow
+ // interpretation, whose value is read with a dedicated intrinsic.
NotPacked,
Arbitrary,
SV,
diff --git a/llvm/include/llvm/IR/IntrinsicsDirectX.td b/llvm/include/llvm/IR/IntrinsicsDirectX.td
index b9b02aeb081916..6bde73d87f356a 100644
--- a/llvm/include/llvm/IR/IntrinsicsDirectX.td
+++ b/llvm/include/llvm/IR/IntrinsicsDirectX.td
@@ -607,4 +607,7 @@ let TargetPrefix = "dx" in {
def int_dx_start_instance_location
: DefaultAttrsIntrinsic<[llvm_i32_ty], [], [IntrNoMem]>;
+
+ def int_dx_sample_index
+ : DefaultAttrsIntrinsic<[llvm_i32_ty], [], [IntrNoMem]>;
}
diff --git a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
index 114d6309b12ddb..85c016b261ecd4 100644
--- a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
+++ b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
@@ -180,6 +180,11 @@ hlsl::getAvailableStages(dxbc::PSV::SemanticKind SemanticKind) {
{Triple::Vertex, IOType::In, SemanticInterpretation::NotAllocated}};
return Stages;
}
+ case dxbc::PSV::SemanticKind::SampleIndex: {
+ static constexpr SemanticStageInfo Stages[] = {
+ {Triple::Pixel, IOType::In, SemanticInterpretation::NotPacked}};
+ return Stages;
+ }
case dxbc::PSV::SemanticKind::Barycentrics: {
static constexpr SemanticStageInfo Stages[] = {
{Triple::Pixel, IOType::In, SemanticInterpretation::NotPacked}};
diff --git a/llvm/lib/Target/DirectX/DXIL.td b/llvm/lib/Target/DirectX/DXIL.td
index 3f81e83b01ecba..ca8dd5450bff6d 100644
--- a/llvm/lib/Target/DirectX/DXIL.td
+++ b/llvm/lib/Target/DirectX/DXIL.td
@@ -1153,6 +1153,15 @@ def DerivFineY : DXILOp<86, unary> {
let stages = [Stages<DXIL1_0, [library, pixel]>];
}
+def SampleIndex : DXILOp<90, sampleIndex> {
+ let Doc = "returns the sample index in a sample-frequency pixel shader";
+ let intrinsics = [IntrinSelect<int_dx_sample_index>];
+ let result = OverloadTy;
+ let overloads = [Overloads<DXIL1_0, [Int32Ty]>];
+ let stages = [Stages<DXIL1_0, [pixel]>];
+ let attributes = [Attributes<DXIL1_0, [ReadNone]>];
+}
+
def ThreadId : DXILOp<93, threadId> {
let Doc = "Reads the thread ID";
let intrinsics = [IntrinSelect<int_dx_thread_id>];
diff --git a/llvm/lib/Target/DirectX/DXILShaderFlags.cpp b/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
index 59953c191497be..b61f0aca42773b 100644
--- a/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
+++ b/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
@@ -456,11 +456,13 @@ void ModuleShaderFlags::initialize(Module &M, DXILResourceTypeMap &DRTM,
CSF.Barycentrics |= llvm::any_of(Sig->Inputs, [](const auto &E) {
return E.SemanticKind == dxbc::PSV::SemanticKind::Barycentrics;
});
+ // Unallocated elements do not occupy signature registers. Their type
+ // requirements come from the instructions that access them.
auto HasLowPrecision = [](const auto &Elements) {
return llvm::any_of(Elements, [](const auto &E) {
- return E.CompType == ElementType::F16 ||
- E.CompType == ElementType::I16 ||
- E.CompType == ElementType::U16;
+ return E.isAllocated() && (E.CompType == ElementType::F16 ||
+ E.CompType == ElementType::I16 ||
+ E.CompType == ElementType::U16);
});
};
if (HasLowPrecision(Sig->Inputs) || HasLowPrecision(Sig->Outputs)) {
diff --git a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
index d652ac24321fb7..7fa66a249ba8d5 100644
--- a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
+++ b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
@@ -96,6 +96,12 @@ static Error diagnoseSemanticType(const SemanticSignatureElement &E) {
return signatureError(
"SV_ShadingRate requires a scalar 16- or 32-bit unsigned integer");
break;
+ case dxbc::PSV::SemanticKind::SampleIndex:
+ if (E.Rows != 1 || E.Cols != 1 ||
+ (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
+ return signatureError(
+ "SV_SampleIndex requires a scalar 16- or 32-bit unsigned integer");
+ break;
case dxbc::PSV::SemanticKind::Barycentrics:
if (E.Rows != 1 || E.Cols != 3 ||
(E.CompType != ElementType::F16 && E.CompType != ElementType::F32))
@@ -123,6 +129,10 @@ static Error diagnoseSemanticIndex(const SemanticSignatureElement &E) {
if (E.SemanticIndices.front() != 0)
return signatureError("SV_Barycentrics requires semantic index 0");
break;
+ case dxbc::PSV::SemanticKind::SampleIndex:
+ if (E.SemanticIndices.front() != 0)
+ return signatureError("SV_SampleIndex requires semantic index 0");
+ break;
default:
break;
}
@@ -199,8 +209,8 @@ static Error parseSignature(Metadata *MD,
"point");
if (Interpretation == SemanticInterpretation::NotPacked) {
if (E.isAllocated())
- return signatureError(
- "SV_Barycentrics must not have an allocated location");
+ return signatureError(E.SemanticName +
+ " must not have an allocated location");
} else {
if (!E.isAllocated())
return signatureError("signature element " + Twine(E.SigId) + " ('" +
@@ -301,6 +311,8 @@ static Error analyzeAccess(const IntrinsicInst &I, EntrySignature &Sig) {
return signatureError(Category + " signature element " + Twine(E.SigId) +
" ('" + E.SemanticName + "'): " + Message);
};
+ if (E.SemanticKind == dxbc::PSV::SemanticKind::SampleIndex)
+ return AccessError("must not be read with dx.op.load/store");
Type *Ty = Input ? I.getType() : I.getArgOperand(3)->getType();
unsigned Width = 1;
if (auto *VT = dyn_cast<FixedVectorType>(Ty)) {
@@ -532,6 +544,8 @@ static dxbc::D3DSystemValue getSystemValue(dxbc::PSV::SemanticKind Kind) {
return dxbc::D3DSystemValue::ShadingRate;
case KindTy::Barycentrics:
return dxbc::D3DSystemValue::Barycentrics;
+ case KindTy::SampleIndex:
+ return dxbc::D3DSystemValue::SampleIndex;
default:
llvm_unreachable("validated vertex/pixel signature semantic");
}
@@ -564,6 +578,8 @@ static StringRef getContainerSemanticName(const SemanticSignatureElement &E) {
return "SV_ShadingRate";
case Kind::Barycentrics:
return "SV_Barycentrics";
+ case Kind::SampleIndex:
+ return "SV_SampleIndex";
default:
llvm_unreachable("validated vertex/pixel signature semantic");
}
@@ -643,7 +659,8 @@ void EntrySignature::updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
llvm::any_of(Inputs, [](const auto &E) {
return E.InterpMode == dxbc::PSV::InterpolationMode::LinearSample ||
E.InterpMode ==
- dxbc::PSV::InterpolationMode::LinearNoperspectiveSample;
+ dxbc::PSV::InterpolationMode::LinearNoperspectiveSample ||
+ E.SemanticKind == dxbc::PSV::SemanticKind::SampleIndex;
});
}
diff --git a/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-sample-index.ll b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-sample-index.ll
new file mode 100644
index 00000000000000..72a23895e039ff
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-sample-index.ll
@@ -0,0 +1,62 @@
+; RUN: opt -disable-output -passes='print<dxil-signature>' %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS
+; RUN: llc -filetype=obj %s -o %t.dxbc
+; RUN: obj2yaml %t.dxbc | FileCheck %s --check-prefix=PARTS
+; RUN: llvm-objcopy --dump-section=DXIL=%t.bc %t.dxbc
+; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefixes=MD,DXIL
+
+; SV_SampleIndex is an unpacked element: it keeps a signature ID, but is read with
+; dx.op.sampleIndex, does not consume a row and marks the pixel shader as
+; sample-frequency.
+target triple = "dxil-pc-shadermodel6.0-pixel"
+
+define void @main() #0 {
+ %p = call float @llvm.dx.load.input.f32(i32 0, i32 0, i8 0, i32 poison)
+ %si = call i32 @llvm.dx.sample.index()
+ %f = uitofp i32 %si to float
+ %result = fadd float %p, %f
+ call void @llvm.dx.store.output.f32(i32 0, i32 0, i8 0, float %result)
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!dx.valver = !{!10}
+!10 = !{i32 1, i32 8}
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, !2}
+!1 = !{!3, !4}
+!2 = !{!6}
+!3 = !{i32 0, !"A", i32 9, i32 0, !7, i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!4 = !{i32 1, !"SV_SampleIndex", i32 5, i32 12, !7, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!6 = !{i32 0, !"SV_Target", i32 9, i32 16, !7, i32 0, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!7 = !{i32 0}
+
+; ANALYSIS: Inputs: 2 elements, 1 vectors
+; ANALYSIS-NEXT: 0: A rows=1 cols=1 at 0:0 usage=1 dynamic=0
+; ANALYSIS-NEXT: 1: SV_SampleIndex rows=1 cols=1 at 4294967295:255 usage=0 dynamic=0
+; ANALYSIS-NEXT: Outputs: 1 elements, 1 vectors
+
+; DXIL: call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 {{.*}})
+; DXIL: call i32 @dx.op.sampleIndex.i32(i32 90)
+; MD-DAG: !{i32 1, !"SV_SampleIndex", i8 5, i8 12, !{{[0-9]+}}, i8 1, i32 1, i8 1, i32 -1, i8 -1, null}
+
+; PARTS: Name: ISG1
+; PARTS: Name: SV_SampleIndex
+; PARTS-NEXT: Index: 0
+; PARTS-NEXT: SystemValue: SampleIndex
+; PARTS-NEXT: CompType: UInt32
+; PARTS-NEXT: Register: 4294967295
+; PARTS-NEXT: Mask: 1
+; PARTS-NEXT: ExclusiveMask: 0
+; PARTS: Name: PSV0
+; PARTS: SampleFrequency: 1
+; PARTS: SigInputVectors: 1
+; PARTS: SigInputElements:
+; PARTS: Kind: Arbitrary
+; PARTS: Indices: [ 0 ]
+; PARTS-NEXT: StartRow: 0
+; PARTS-NEXT: Cols: 1
+; PARTS-NEXT: StartCol: 0
+; PARTS-NEXT: Allocated: false
+; PARTS-NEXT: Kind: SampleIndex
+; PARTS-NEXT: ComponentType: UInt32
+; PARTS-NEXT: Interpolation: Constant
diff --git a/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-sample-index-errors.ll b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-sample-index-errors.ll
new file mode 100644
index 00000000000000..9d4d63bbc97289
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-sample-index-errors.ll
@@ -0,0 +1,78 @@
+; RUN: split-file %s %t
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/signed.ll 2>&1 | FileCheck %s --check-prefix=CHECK-SIGNED
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/cols.ll 2>&1 | FileCheck %s --check-prefix=CHECK-COLS
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/index.ll 2>&1 | FileCheck %s --check-prefix=CHECK-INDEX
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/allocated.ll 2>&1 | FileCheck %s --check-prefix=CHECK-ALLOCATED
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/load.ll 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/vertex.ll 2>&1 | FileCheck %s --check-prefix=CHECK-VERTEX
+
+; Each case is a complete module with one invalid SV_SampleIndex declaration.
+
+;--- signed.ll
+; CHECK-SIGNED: SV_SampleIndex requires a scalar 16- or 32-bit unsigned integer
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 4, i32 12, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- cols.ll
+; CHECK-COLS: SV_SampleIndex requires a scalar 16- or 32-bit unsigned integer
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 5, i32 12, !3, i32 1, i32 1, i8 2, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- index.ll
+; CHECK-INDEX: SV_SampleIndex requires semantic index 0
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 5, i32 12, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 1}
+
+;--- allocated.ll
+; CHECK-ALLOCATED: SV_SampleIndex must not have an allocated location
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 5, i32 12, !3, i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- load.ll
+; CHECK-LOAD: input signature element 0 ('SV_SampleIndex'): must not be read with dx.op.load/store
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 {
+ %si = call i32 @llvm.dx.load.input.i32(i32 0, i32 0, i8 0, i32 poison)
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 5, i32 12, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- vertex.ll
+; CHECK-VERTEX: invalid or unsupported semantic for this stage and signature category
+target triple = "dxil-pc-shadermodel6.0-vertex"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="vertex" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 5, i32 12, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
diff --git a/llvm/test/CodeGen/DirectX/ShaderFlags/unpacked-low-precision.ll b/llvm/test/CodeGen/DirectX/ShaderFlags/unpacked-low-precision.ll
new file mode 100644
index 00000000000000..3e7eebefbb40bb
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/ShaderFlags/unpacked-low-precision.ll
@@ -0,0 +1,40 @@
+; RUN: opt -disable-output -passes=print-dx-shader-flags %s 2>&1 | FileCheck %s
+
+; Unallocated (NotPacked) elements do not occupy signature registers, so only
+; the instructions that read them contribute type requirements, as in DXC. A
+; 16-bit SV_SampleIndex is read with the 32-bit dx.op.sampleIndex, and an
+; unused 16-bit SV_Barycentrics has no loadInput. Allocated 16-bit signature
+; elements still require low-precision support.
+
+target triple = "dxil-pc-shadermodel6.2-library"
+
+; CHECK: ; Shader Flags Value: 0x00400020
+; CHECK: Function sample_index : 0x00000000
+; CHECK: Function barycentrics : 0x00400000
+; CHECK: Function arbitrary : 0x00000020
+define void @sample_index() #0 {
+entry:
+ %0 = call i32 @llvm.dx.sample.index()
+ ret void
+}
+define void @barycentrics() #0 {
+entry:
+ ret void
+}
+define void @arbitrary() #0 {
+entry:
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!dx.semantic.signatures = !{!0, !4, !7}
+!0 = !{ptr @sample_index, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_SampleIndex", i32 3, i32 12, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+!4 = !{ptr @barycentrics, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, !"SV_Barycentrics", i32 8, i32 28, !3, i32 2, i32 1, i8 3, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!7 = !{ptr @arbitrary, !8, null}
+!8 = !{!9}
+!9 = !{i32 0, !"A", i32 3, i32 0, !3, i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
diff --git a/llvm/test/CodeGen/DirectX/sample_index.ll b/llvm/test/CodeGen/DirectX/sample_index.ll
new file mode 100644
index 00000000000000..0119d427ff3878
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/sample_index.ll
@@ -0,0 +1,28 @@
+; RUN: split-file %s %t
+; RUN: opt -S -dxil-op-lower %t/pixel.ll | FileCheck %s
+; RUN: not opt -S -dxil-op-lower %t/vertex.ll 2>&1 | FileCheck %s --check-prefix=STAGE
+
+; CHECK-LABEL: define i32 @main(
+; CHECK: %[[SI:.*]] = call i32 @dx.op.sampleIndex.i32(i32 90)
+; CHECK: ret i32 %[[SI]]
+; CHECK: declare i32 @dx.op.sampleIndex.i32(i32) #[[#ATTR:]]
+; CHECK: attributes #[[#ATTR]] = { nounwind memory(none) }
+
+; SampleIndex is only available to pixel shaders.
+; STAGE: Cannot create SampleIndex operation: Invalid stage
+
+;--- pixel.ll
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.sample.index()
+ ret i32 %0
+}
+
+;--- vertex.ll
+target triple = "dxil-pc-shadermodel6.0-vertex"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.sample.index()
+ ret i32 %0
+}
diff --git a/llvm/test/CodeGen/SPIRV/semantics/sample-index.ps.ll b/llvm/test/CodeGen/SPIRV/semantics/sample-index.ps.ll
new file mode 100644
index 00000000000000..ecc6bbce22c0df
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/semantics/sample-index.ps.ll
@@ -0,0 +1,32 @@
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
+; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - -filetype=obj | spirv-val --target-env vulkan1.3 %}
+
+; SV_SampleIndex is lowered to a flat load of the SampleId built-in, which
+; requires SampleRateShading.
+
+; CHECK-DAG: OpCapability SampleRateShading
+; CHECK-DAG: OpDecorate %[[#SAMPLE:]] BuiltIn SampleId
+; CHECK-DAG: OpDecorate %[[#SAMPLE]] Flat
+; CHECK-DAG: %[[#INT:]] = OpTypeInt 32 0
+; CHECK-DAG: %[[#PTR:]] = OpTypePointer Input %[[#INT]]
+; CHECK-DAG: %[[#SAMPLE]] = OpVariable %[[#PTR]] Input
+
+ at SV_SampleIndex = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations !0
+ at SV_Target0 = external hidden thread_local addrspace(8) global float, !spirv.Decorations !3
+
+define void @main() #0 {
+entry:
+; CHECK: OpLoad %[[#INT]] %[[#SAMPLE]]
+ %0 = load i32, ptr addrspace(7) @SV_SampleIndex, align 4
+ %1 = uitofp i32 %0 to float
+ store float %1, ptr addrspace(8) @SV_Target0, align 4
+ ret void
+}
+
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!0 = !{!1, !2}
+!1 = !{i32 11, i32 18}
+!2 = !{i32 14}
+!3 = !{!4}
+!4 = !{i32 30, i32 0}
diff --git a/llvm/unittests/Frontend/HLSLSemanticSignaturePackingTest.cpp b/llvm/unittests/Frontend/HLSLSemanticSignaturePackingTest.cpp
index 080a675c6e763a..94af5531592c95 100644
--- a/llvm/unittests/Frontend/HLSLSemanticSignaturePackingTest.cpp
+++ b/llvm/unittests/Frontend/HLSLSemanticSignaturePackingTest.cpp
@@ -258,6 +258,21 @@ TEST_F(HLSLSemanticSignaturePackingTest, BarycentricsDoNotReserveRegisters) {
{Unallocated, {/*Row=*/0, /*Col=*/0}});
}
+TEST_F(HLSLSemanticSignaturePackingTest, SampleIndexDoesNotReserveRegisters) {
+ // SV_SampleIndex stays in the signature but is read with a dedicated
+ // intrinsic and never occupies a register.
+ TestConfig Config(
+ Triple::Pixel, IOType::In,
+ {{dxbc::PSV::SemanticKind::SampleIndex, /*Rows=*/1, /*Cols=*/1,
+ dxil::ElementType::U32, dxbc::PSV::InterpolationMode::Constant},
+ {dxbc::PSV::SemanticKind::Arbitrary, /*Rows=*/32, /*Cols=*/4,
+ dxil::ElementType::F32, dxbc::PSV::InterpolationMode::Linear}});
+ for (PackingMethod Method :
+ {PackingMethod::PrefixStable, PackingMethod::Optimized})
+ verifyPacking(Method, Config, /*ExpectedRows=*/32,
+ {Unallocated, {/*Row=*/0, /*Col=*/0}});
+}
+
TEST_F(HLSLSemanticSignaturePackingTest, StacksInDeclarationOrder) {
// Elements are assigned whole rows in declaration order, regardless of their
// semantic interpretation.
diff --git a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
index cd4a57abb68a6a..399e6630a189e1 100644
--- a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
+++ b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
@@ -76,7 +76,8 @@ constexpr SemanticKind SupportedKinds[] = {SemanticKind::Arbitrary,
SemanticKind::ShadingRate,
SemanticKind::Barycentrics,
SemanticKind::StartVertexLocation,
- SemanticKind::StartInstanceLocation};
+ SemanticKind::StartInstanceLocation,
+ SemanticKind::SampleIndex};
// Ensure all stages return a valid SemanticInterpretation
TEST(HLSLSemanticStagesTest, StagesAreValid) {
@@ -191,4 +192,14 @@ TEST(HLSLSemanticStagesTest, StartInstanceLocationSignaturePoints) {
expectOnlySignaturePoints(SemanticKind::StartInstanceLocation, Valid);
}
+// SV_SampleIndex is read with a dedicated operation, but is still added to the
+// pixel input signature for compatibility. Valid only on pixel inputs, where it
+// is in the signature but not packed.
+TEST(HLSLSemanticStagesTest, SampleIndexSignaturePoints) {
+ const SignaturePoint Valid[] = {
+ {Triple::Pixel, IOType::In, SemanticInterpretation::NotPacked},
+ };
+ expectOnlySignaturePoints(SemanticKind::SampleIndex, Valid);
+}
+
} // namespace
>From e0f9f2b6ed812f94c7e1d937687814e074e80b9f Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Tue, 20 Oct 2026 22:11:42 +0000
Subject: [PATCH 2/9] [HLSL] Add support for SV_ViewID
---
clang/lib/CodeGen/CGHLSLRuntime.cpp | 15 ++++++
clang/lib/Sema/SemaHLSL.cpp | 5 +-
.../test/CodeGenHLSL/semantics/SV_ViewID.hlsl | 36 ++++++++++++++
.../test/SemaHLSL/Semantics/viewid.model.hlsl | 14 ++++++
clang/test/SemaHLSL/Semantics/viewid.ps.hlsl | 49 +++++++++++++++++++
.../SemaHLSL/Semantics/viewid.stages.hlsl | 34 +++++++++++++
llvm/include/llvm/IR/IntrinsicsDirectX.td | 3 ++
llvm/lib/Frontend/HLSL/SemanticSignatures.cpp | 4 +-
.../lib/Target/DirectX/DXContainerGlobals.cpp | 10 +++-
llvm/lib/Target/DirectX/DXIL.td | 10 ++++
llvm/lib/Target/DirectX/DXILShaderFlags.cpp | 3 ++
.../Target/DirectX/DXILSignatureAnalysis.cpp | 29 ++++++++++-
.../Target/DirectX/DXILSignatureAnalysis.h | 23 ++++++---
.../Target/DirectX/DXILTranslateMetadata.cpp | 3 +-
llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp | 6 ++-
.../SemanticSignatures-view-id.ll | 47 ++++++++++++++++++
.../CodeGen/DirectX/ShaderFlags/view-id.ll | 23 +++++++++
llvm/test/CodeGen/DirectX/view_id.ll | 47 ++++++++++++++++++
.../CodeGen/SPIRV/semantics/view-index.ps.ll | 42 ++++++++++++++++
.../Frontend/HLSLSemanticStagesTest.cpp | 23 ++++++++-
20 files changed, 407 insertions(+), 19 deletions(-)
create mode 100644 clang/test/CodeGenHLSL/semantics/SV_ViewID.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/viewid.model.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/viewid.ps.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/viewid.stages.hlsl
create mode 100644 llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-view-id.ll
create mode 100644 llvm/test/CodeGen/DirectX/ShaderFlags/view-id.ll
create mode 100644 llvm/test/CodeGen/DirectX/view_id.ll
create mode 100644 llvm/test/CodeGen/SPIRV/semantics/view-index.ps.ll
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index fac0f7b850f71a..981ec3e9c790b3 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -1724,6 +1724,21 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
return B.CreateTrunc(SampleIndex, Type);
}
break;
+ case llvm::dxbc::PSV::SemanticKind::ViewID:
+ assert(llvm::is_contained({llvm::Triple::Vertex, llvm::Triple::Hull,
+ llvm::Triple::Domain, llvm::Triple::Geometry,
+ llvm::Triple::Pixel, llvm::Triple::Mesh},
+ Stage) &&
+ "SV_ViewID is in an unavailable stage and should have been "
+ "diagnosed by Sema");
+ if (CGM.getTarget().getTriple().isSPIRV())
+ return createSPIRVInputLoad(B, CGM.getModule(), Type,
+ Semantic->getAttrName()->getName(),
+ llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn,
+ /* ViewIndex */ 4440, InterpMode);
+ if (CGM.getTarget().getTriple().isDXIL())
+ return B.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::dx_view_id));
+ break;
case llvm::dxbc::PSV::SemanticKind::StartInstanceLocation:
assert(Stage == llvm::Triple::Vertex &&
"SV_StartInstanceLocation is in an unavailable stage and should "
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 2ce99418b2f8e1..708f74d71b0e3c 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1020,6 +1020,8 @@ static bool isVkPipelineBuiltin(const ASTContext &AstContext, FunctionDecl *FD,
case SemanticKind::StartVertexLocation:
case SemanticKind::StartInstanceLocation:
return ST == llvm::Triple::Vertex && IsInput;
+ case SemanticKind::ViewID:
+ return IsInput;
default:
return false;
}
@@ -1280,6 +1282,7 @@ void SemaHLSL::diagnoseSemanticShaderModel(const HLSLAppliedSemanticAttr *A,
switch (Kind) {
case SemanticKind::Barycentrics:
+ case SemanticKind::ViewID:
if (Triple.getOSVersion() < VersionTuple(6, 1))
Diag(A->getLoc(), diag::err_hlsl_semantic_in_wrong_shader_model)
<< A->getAttrName() << "6.1";
@@ -1412,6 +1415,7 @@ void SemaHLSL::diagnoseSemanticType(const Decl *D,
return;
case SemanticKind::StartVertexLocation:
case SemanticKind::StartInstanceLocation:
+ case SemanticKind::ViewID:
if (DeclaredTy != T || !T->isScalarType() ||
!isIntElementOfWidth(Ctx, T, 32))
Diag(A->getLoc(), diag::err_hlsl_semantic_invalid_type)
@@ -2269,7 +2273,6 @@ void SemaHLSL::handleSemanticAttr(Decl *D, const ParsedAttr &AL) {
case SemanticKind::StencilRef:
case SemanticKind::TessFactor:
case SemanticKind::InsideTessFactor:
- case SemanticKind::ViewID:
case SemanticKind::CullPrimitive:
Diag(AL.getLoc(), diag::err_hlsl_unknown_semantic) << AL;
return;
diff --git a/clang/test/CodeGenHLSL/semantics/SV_ViewID.hlsl b/clang/test/CodeGenHLSL/semantics/SV_ViewID.hlsl
new file mode 100644
index 00000000000000..71be4e2e6e00f4
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/SV_ViewID.hlsl
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.1-vertex -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefix=CHECK-DXIL %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.1-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefix=CHECK-DXIL %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-vertex -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefixes=CHECK-SPIRV,SPIRV-VS %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefixes=CHECK-SPIRV,SPIRV-PS %s
+
+#if __SHADER_TARGET_STAGE == __SHADER_STAGE_PIXEL
+#define OUTPUT SV_Target
+#else
+#define OUTPUT SV_Position
+#endif
+
+// CHECK-SPIRV: @SV_ViewID = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations ![[#MD_0:]]
+
+// The view ID is read with a dedicated operation and is not part of the input
+// signature, so the user input that follows keeps signature element 0.
+
+// CHECK-DXIL-LABEL: define void @main()
+// CHECK-DXIL: %[[VIEW:.*]] = call i32 @llvm.dx.view.id()
+// CHECK-DXIL: %[[A:.*]] = call <4 x float> @llvm.dx.load.input.v4f32(i32 0, i32 0, i8 0, i32 poison)
+// CHECK-DXIL: call <4 x float> @_Z4mainjDv4_f(i32 %[[VIEW]], <4 x float> %[[A]])
+// CHECK-DXIL-NOT: !"SV_ViewID"
+
+// CHECK-SPIRV-LABEL: define void @main()
+// CHECK-SPIRV: %[[VIEW:.*]] = load i32, ptr addrspace(7) @SV_ViewID, align 4
+// CHECK-SPIRV: call spir_func <4 x float> @_Z4mainjDv4_f(i32 %[[VIEW]],
+float4 main(uint view : SV_ViewID, float4 a : A) : OUTPUT {
+ return a * view;
+}
+
+// The pixel shader input is flat because it is an integer.
+// SPIRV-VS-DAG: ![[#MD_0]] = !{![[#BUILTIN:]]}
+// SPIRV-PS-DAG: ![[#MD_0]] = !{![[#BUILTIN:]], ![[#FLAT:]]}
+// SPIRV-PS-DAG: ![[#FLAT]] = !{i32 14}
+// The metadata below contains SPIR-V decoration 'BuiltIn' followed by
+// BuiltIn ViewIndex.
+// CHECK-SPIRV-DAG: ![[#BUILTIN]] = !{i32 11, i32 4440}
diff --git a/clang/test/SemaHLSL/Semantics/viewid.model.hlsl b/clang/test/SemaHLSL/Semantics/viewid.model.hlsl
new file mode 100644
index 00000000000000..e74f73c43086bd
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/viewid.model.hlsl
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-library -finclude-default-header -x hlsl -verify=dxil -o - %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.1-library -finclude-default-header -x hlsl -verify=ok -o - %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -finclude-default-header -x hlsl -verify=ok -o - %s
+
+// SV_ViewID requires shader model 6.1 for DXIL.
+// The shader model restriction does not apply to SPIR-V, which is only run to check that no error is emitted.
+
+[shader("pixel")]
+float4 ps_in(uint v : SV_ViewID) : SV_Target {
+// dxil-error at -1 {{semantic 'SV_ViewID' requires shader model 6.1 or greater}}
+ return float4((float)v, 0, 0, 1);
+}
+
+// ok-no-diagnostics
diff --git a/clang/test/SemaHLSL/Semantics/viewid.ps.hlsl b/clang/test/SemaHLSL/Semantics/viewid.ps.hlsl
new file mode 100644
index 00000000000000..2db5ee557495b5
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/viewid.ps.hlsl
@@ -0,0 +1,49 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+
+// Type, index and interpolation checks for SV_ViewID. These are independent of
+// the shader stage and IO direction, which are covered by viewid.stages.hlsl.
+
+[shader("pixel")]
+void valid_uint(uint v : SV_ViewID) {}
+[shader("pixel")]
+void valid_int(int v : sv_viewid0) {}
+[shader("pixel")]
+void valid_flat(nointerpolation uint v : SV_ViewID) {}
+
+struct Input {
+ float4 p : SV_Position;
+ uint v : SV_ViewID;
+};
+[shader("pixel")]
+void valid_struct(Input i) {}
+
+[shader("pixel")]
+void bad_float(float v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' must be a scalar of 32 bit integer type (was 'float')}}
+[shader("pixel")]
+void bad_bool(bool v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' must be a scalar of 32 bit integer type (was 'bool')}}
+[shader("pixel")]
+void bad_uint16(uint16_t v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' must be a scalar of 32 bit integer type (was 'uint16_t' (aka 'unsigned short'))}}
+[shader("pixel")]
+void bad_vector(uint2 v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' must be a scalar of 32 bit integer type (was 'uint2' (aka 'vector<uint, 2>'))}}
+[shader("pixel")]
+void bad_array(uint v[1] : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' must be a scalar of 32 bit integer type (was 'uint[1]'}}
+
+[shader("pixel")]
+void bad_index(uint v : SV_ViewID1) {}
+// expected-error at -1 {{semantic 'SV_ViewID' does not allow indexing}}
+
+[shader("pixel")]
+void same_index(uint v : SV_ViewID, // expected-note {{previous use is here}}
+ uint w : SV_ViewID0) {} // expected-note {{'w' declared here}}
+// expected-error at -1 {{semantic index overlap SV_ViewID0}}
+
+// Integer inputs can only use nointerpolation.
+[shader("pixel")]
+void bad_interpolation(linear uint v : SV_ViewID) {}
+// expected-error at -1 {{interpolation modifiers other than 'nointerpolation' cannot be used with type 'uint' (aka 'unsigned int')}}
diff --git a/clang/test/SemaHLSL/Semantics/viewid.stages.hlsl b/clang/test/SemaHLSL/Semantics/viewid.stages.hlsl
new file mode 100644
index 00000000000000..7b2aec15d14e64
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/viewid.stages.hlsl
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -finclude-default-header -x hlsl -verify -o - %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -finclude-default-header -x hlsl -verify -o - %s
+
+// Stage and IO direction checks for SV_ViewID: an input to every graphics
+// stage except amplification shaders. Type, index and interpolation checks are
+// covered by viewid.ps.hlsl.
+
+[shader("vertex")]
+float4 ok_vs_in(uint v : SV_ViewID) : SV_Position {
+ return float4((float)v, 0, 0, 1);
+}
+
+[shader("pixel")]
+float4 ok_ps_in(uint v : SV_ViewID) : SV_Target {
+ return float4((float)v, 0, 0, 1);
+}
+
+[shader("vertex")]
+uint bad_vs_out() : SV_ViewID { return 0; }
+// expected-error at -1 {{semantic 'SV_ViewID' is not supported in vertex shader outputs}}
+
+[shader("pixel")]
+uint bad_ps_out() : SV_ViewID { return 0; }
+// expected-error at -1 {{semantic 'SV_ViewID' is not supported in pixel shader outputs}}
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void bad_cs_in(uint v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' is not supported in compute shader inputs}}
+
+[shader("amplification")]
+[numthreads(1, 1, 1)]
+void bad_as_in(uint v : SV_ViewID) {}
+// expected-error at -1 {{semantic 'SV_ViewID' is not supported in amplification shader inputs}}
diff --git a/llvm/include/llvm/IR/IntrinsicsDirectX.td b/llvm/include/llvm/IR/IntrinsicsDirectX.td
index 6bde73d87f356a..b1cb80cd96f143 100644
--- a/llvm/include/llvm/IR/IntrinsicsDirectX.td
+++ b/llvm/include/llvm/IR/IntrinsicsDirectX.td
@@ -610,4 +610,7 @@ let TargetPrefix = "dx" in {
def int_dx_sample_index
: DefaultAttrsIntrinsic<[llvm_i32_ty], [], [IntrNoMem]>;
+
+ def int_dx_view_id
+ : DefaultAttrsIntrinsic<[llvm_i32_ty], [], [IntrNoMem]>;
}
diff --git a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
index 85c016b261ecd4..a079c78d952fb5 100644
--- a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
+++ b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
@@ -168,9 +168,7 @@ hlsl::getAvailableStages(dxbc::PSV::SemanticKind SemanticKind) {
SemanticInterpretation::NotAllocated},
{Triple::Geometry, IOType::In, SemanticInterpretation::NotAllocated},
{Triple::Pixel, IOType::In, SemanticInterpretation::NotAllocated},
- {Triple::Mesh, InOrPatchConstant, SemanticInterpretation::NotAllocated},
- {Triple::Amplification, IOType::In,
- SemanticInterpretation::NotAllocated},
+ {Triple::Mesh, IOType::In, SemanticInterpretation::NotAllocated},
};
return Stages;
}
diff --git a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
index 5a9a9ba9424c9a..f3cff5494f858d 100644
--- a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
+++ b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
@@ -370,10 +370,16 @@ void DXContainerGlobals::addPipelineStateValidationInfo(
unsigned PSVVersion = 3;
if (MMI.ShaderProfile != Triple::Library &&
MMI.EntryPropertyVec.size() == 1) {
+ const Function *Entry = MMI.EntryPropertyVec[0].Entry;
+ bool UsesViewID = getAnalysis<ShaderFlagsAnalysisWrapper>()
+ .getShaderFlags()
+ .getFunctionFlags(Entry)
+ .ViewID;
+ PSV.BaseData.UsesViewID = UsesViewID;
const auto &Signatures =
getAnalysis<SignatureAnalysisWrapper>().getSignatureInfo();
- if (const auto *Sig = Signatures.get(MMI.EntryPropertyVec[0].Entry)) {
- Sig->updatePSV(PSV, MMI.ValidatorVersion);
+ if (const auto *Sig = Signatures.get(Entry)) {
+ Sig->updatePSV(PSV, MMI.ValidatorVersion, UsesViewID);
// Preserve the existing empty-signature path, and select an ABI version
// compatible with the validator for graphics signature data.
VersionTuple V = MMI.ValidatorVersion;
diff --git a/llvm/lib/Target/DirectX/DXIL.td b/llvm/lib/Target/DirectX/DXIL.td
index ca8dd5450bff6d..403e9a5742db3e 100644
--- a/llvm/lib/Target/DirectX/DXIL.td
+++ b/llvm/lib/Target/DirectX/DXIL.td
@@ -1478,6 +1478,16 @@ def WaveAllBitCount : DXILOp<135, waveAllOp> {
let stages = [Stages<DXIL1_0, [all_stages]>];
}
+def ViewID : DXILOp<138, viewID> {
+ let Doc = "returns the view index";
+ let intrinsics = [IntrinSelect<int_dx_view_id>];
+ let result = OverloadTy;
+ let overloads = [Overloads<DXIL1_1, [Int32Ty]>];
+ let stages =
+ [Stages<DXIL1_1, [vertex, hull, domain, geometry, pixel, mesh]>];
+ let attributes = [Attributes<DXIL1_0, [ReadNone]>];
+}
+
def RawBufferLoad : DXILOp<139, rawBufferLoad> {
let Doc = "reads from a raw buffer and structured buffer";
// Handle, Coord0, Coord1, Mask, Alignment
diff --git a/llvm/lib/Target/DirectX/DXILShaderFlags.cpp b/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
index b61f0aca42773b..9c709cf5a1ca1c 100644
--- a/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
+++ b/llvm/lib/Target/DirectX/DXILShaderFlags.cpp
@@ -264,6 +264,9 @@ void ModuleShaderFlags::updateFunctionFlags(ComputedShaderFlags &CSF,
case Intrinsic::dx_start_instance_location:
CSF.ExtendedCommandInfo = true;
break;
+ case Intrinsic::dx_view_id:
+ CSF.ViewID = true;
+ break;
case Intrinsic::dx_resource_handlefrombinding: {
dxil::ResourceTypeInfo &RTI = DRTM[cast<TargetExtType>(II->getType())];
diff --git a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
index 7fa66a249ba8d5..1d6a8e4bc90e1f 100644
--- a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
+++ b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
@@ -639,8 +639,28 @@ void EntrySignature::buildSignatures(mcdxbc::Signature &Input,
buildSignature(Output, Outputs, false, UseNative16Bit, Legacy);
}
+SmallVector<uint32_t> EntrySignature::getViewIDOutputMask() const {
+ // Each output vector needs four component bits, so one 32-bit word holds
+ // eight vectors. Conservatively mark every written output component as
+ // dependent on the view ID, matching the conservative input/output map.
+ SmallVector<uint32_t> Mask((OutputVectors + 7) / 8, 0);
+ for (const auto &Output : Outputs) {
+ if (!Output.isAllocated())
+ continue;
+ for (unsigned R = 0; R != Output.Rows; ++R)
+ for (unsigned C = 0; C != 4; ++C) {
+ if (!(Output.UsageMask & (1U << C)))
+ continue;
+ unsigned Bit = (Output.StartRow + R) * 4 + C;
+ Mask[Bit / 32] |= 1U << (Bit % 32);
+ }
+ }
+ return Mask;
+}
+
void EntrySignature::updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
- VersionTuple ValidatorVersion) const {
+ VersionTuple ValidatorVersion,
+ bool UsesViewID) const {
bool Legacy = !ValidatorVersion.empty() &&
ValidatorVersion != VersionTuple(0, 0) &&
ValidatorVersion < VersionTuple(1, 5);
@@ -649,6 +669,8 @@ void EntrySignature::updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
PSV.BaseData.SigInputVectors = InputVectors;
PSV.BaseData.SigOutputVectors[0] = OutputVectors;
PSV.InputOutputMap[0] = InputOutputMap;
+ if (UsesViewID)
+ PSV.OutputVectorMasks[0] = getViewIDOutputMask();
if (Stage == Triple::Vertex)
PSV.BaseData.StageInfo.VS.OutputPositionPresent =
llvm::any_of(Outputs, [](const auto &E) {
@@ -664,8 +686,11 @@ void EntrySignature::updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
});
}
-SmallVector<uint32_t> EntrySignature::getDependencyState() const {
+SmallVector<uint32_t>
+EntrySignature::getDependencyState(bool UsesViewID) const {
SmallVector<uint32_t> State = {InputVectors * 4, OutputVectors * 4};
+ if (UsesViewID)
+ llvm::append_range(State, getViewIDOutputMask());
llvm::append_range(State, InputOutputMap);
return State;
}
diff --git a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.h b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.h
index 97e9d1df290615..ebab8ce870be38 100644
--- a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.h
+++ b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.h
@@ -45,16 +45,23 @@ struct EntrySignature {
VersionTuple ValidatorVersion) const;
/// Append PSV signature elements and set vector extents, the dependency map,
- /// and stage-specific signature flags. Does not finalize or serialize PSV.
- void updatePSV(mcdxbc::PSVRuntimeInfo &PSV,
- VersionTuple ValidatorVersion) const;
+ /// the view ID output mask if it is present, and stage-specific signature
+ /// flags. Does not finalize or serialize PSV.
+ void updatePSV(mcdxbc::PSVRuntimeInfo &PSV, VersionTuple ValidatorVersion,
+ bool UsesViewID) const;
/// Return the serialized dx.viewIdState words for this entry: input scalar
- /// count, output scalar count, then the input/output dependency table. Scalar
- /// counts include padding and equal four times the respective vector extent.
- /// Each input scalar has ceil(output scalar count / 32) consecutive words,
- /// where bit (4 * row + column) identifies an output scalar.
- SmallVector<uint32_t> getDependencyState() const;
+ /// count, output scalar count, the outputs that depend on the view ID if
+ /// it is present, then the input/output dependency table. Scalar counts
+ /// include padding and equal four times the respective vector extent. Each
+ /// output mask has ceil(output scalar count / 32) consecutive words, where
+ /// bit (4 * row + column) identifies an output scalar. There is one such
+ /// mask for each input scalar in the dependency table.
+ SmallVector<uint32_t> getDependencyState(bool UsesViewID) const;
+
+ /// Return the mask of output scalars that depend on the view ID.
+ SmallVector<uint32_t> getViewIDOutputMask() const;
+
void print(raw_ostream &OS) const;
};
diff --git a/llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp b/llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp
index f96107114b44a1..aa773abc26cf09 100644
--- a/llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp
+++ b/llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp
@@ -580,7 +580,8 @@ static void translateGlobalMetadata(Module &M, DXILResourceMap &DRM,
MMDI.ValidatorVersion == VersionTuple(0, 0) ||
MMDI.ValidatorVersion >= VersionTuple(1, 1)) &&
(Sig->InputVectors || Sig->OutputVectors)) {
- auto State = Sig->getDependencyState();
+ auto State = Sig->getDependencyState(
+ ShaderFlags.getFunctionFlags(EntryProp.Entry).ViewID);
auto *StateMD = M.getOrInsertNamedMetadata("dx.viewIdState");
StateMD->clearOperands();
StateMD->addOperand(MDNode::get(
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
index c3d84dd166ca3a..55b46cef36cf30 100644
--- a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -1099,7 +1099,7 @@ void RequirementHandler::initAvailableCapabilitiesForVulkan(
// Became core in Vulkan 1.1.
if (ST.isAtLeastSPIRVVer(VersionTuple(1, 3)))
- addAvailableCaps({Capability::DrawParameters});
+ addAvailableCaps({Capability::DrawParameters, Capability::MultiView});
// Became core in Vulkan 1.2
if (ST.isAtLeastSPIRVVer(VersionTuple(1, 5))) {
@@ -1176,6 +1176,10 @@ static void addOpDecorateReqs(const MachineInstr &MI, unsigned DecIndex,
Reqs, ST, SPIRV::Capability::DrawParameters,
SPIRV::Extension::SPV_KHR_shader_draw_parameters);
break;
+ case SPIRV::BuiltIn::ViewIndex:
+ addCoreInSPIRV13Capability(Reqs, ST, SPIRV::Capability::MultiView,
+ SPIRV::Extension::SPV_KHR_multiview);
+ break;
default:
Reqs.addRequirements(getSymbolicOperandRequirements(
SPIRV::OperandCategory::BuiltInOperand, BuiltIn, ST, Reqs));
diff --git a/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-view-id.ll b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-view-id.ll
new file mode 100644
index 00000000000000..5897d3a88b8b16
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-view-id.ll
@@ -0,0 +1,47 @@
+; RUN: llc -filetype=obj %s -o %t.dxbc
+; RUN: obj2yaml %t.dxbc | FileCheck %s --check-prefix=PARTS
+; RUN: llvm-objcopy --dump-section=DXIL=%t.bc %t.dxbc
+; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefixes=MD,DXIL
+
+; SV_ViewID is not part of the signature. Using it marks the shader as using
+; the view ID, and every written output component is conservatively treated as
+; depending on it, both in dx.viewIdState and in PSV0.
+target triple = "dxil-pc-shadermodel6.1-pixel"
+
+define void @main() #0 {
+ %a = call float @llvm.dx.load.input.f32(i32 0, i32 0, i8 0, i32 poison)
+ %view = call i32 @llvm.dx.view.id()
+ %f = uitofp i32 %view to float
+ %result = fadd float %a, %f
+ call void @llvm.dx.store.output.f32(i32 0, i32 0, i8 0, float %result)
+ call void @llvm.dx.store.output.f32(i32 0, i32 0, i8 2, float %result)
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!dx.valver = !{!10}
+!10 = !{i32 1, i32 8}
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, !2}
+!1 = !{!3}
+!2 = !{!6}
+!3 = !{i32 0, !"A", i32 9, i32 0, !7, i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!6 = !{i32 0, !"SV_Target", i32 9, i32 16, !7, i32 0, i32 1, i8 4, i32 0, i8 0, i8 0, i8 0, i32 0}
+!7 = !{i32 0}
+
+; DXIL: call i32 @dx.op.viewID.i32(i32 138)
+
+; The state is the input and output scalar counts, the outputs depending on
+; the view ID (components 0 and 2), then one output mask per input scalar.
+; MD-DAG: !dx.viewIdState = !{![[STATE:[0-9]+]]}
+; MD-DAG: ![[STATE]] = !{[7 x i32] [i32 4, i32 4, i32 5, i32 5, i32 0, i32 0, i32 0]}
+; MD-DAG: !{i32 0, i64 2097152}
+
+; PARTS: Name: SFI0
+; PARTS: ViewID: true
+; PARTS: Name: PSV0
+; PARTS: UsesViewID: 1
+; PARTS: OutputVectorMasks:
+; PARTS-NEXT: - [ 0x5 ]
+; PARTS: InputOutputMap:
+; PARTS-NEXT: - [ 0x5, 0x0, 0x0, 0x0 ]
diff --git a/llvm/test/CodeGen/DirectX/ShaderFlags/view-id.ll b/llvm/test/CodeGen/DirectX/ShaderFlags/view-id.ll
new file mode 100644
index 00000000000000..36234cd0f9226f
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/ShaderFlags/view-id.ll
@@ -0,0 +1,23 @@
+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+; Reading SV_ViewID requires the ViewID feature.
+
+; CHECK: ; Shader Flags Value: [[FLAG:0x00200000]]
+; CHECK: ; Note: shader requires additional functionality:
+; CHECK-NEXT: ; View Instancing
+; CHECK-NEXT: ; Note: extra DXIL module flags:
+
+target triple = "dxil-pc-shadermodel6.1-library"
+
+; CHECK: Function view_id : [[FLAG]]
+define i32 @view_id() {
+entry:
+ %0 = call i32 @llvm.dx.view.id()
+ ret i32 %0
+}
+
+; CHECK: Function no_view_id : 0x00000000
+define i32 @no_view_id() {
+entry:
+ ret i32 0
+}
diff --git a/llvm/test/CodeGen/DirectX/view_id.ll b/llvm/test/CodeGen/DirectX/view_id.ll
new file mode 100644
index 00000000000000..6c40e32d8632b0
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/view_id.ll
@@ -0,0 +1,47 @@
+; RUN: split-file %s %t
+; RUN: opt -S -dxil-op-lower %t/vertex.ll | FileCheck %s
+; RUN: opt -S -dxil-op-lower %t/pixel.ll | FileCheck %s
+; RUN: not opt -S -dxil-op-lower %t/compute.ll 2>&1 | FileCheck %s --check-prefix=STAGE
+; RUN: not opt -S -dxil-op-lower %t/sm60.ll 2>&1 | FileCheck %s --check-prefix=VERSION
+
+; CHECK-LABEL: define i32 @main(
+; CHECK: %[[VIEW:.*]] = call i32 @dx.op.viewID.i32(i32 138)
+; CHECK: ret i32 %[[VIEW]]
+; CHECK: declare i32 @dx.op.viewID.i32(i32) #[[#ATTR:]]
+; CHECK: attributes #[[#ATTR]] = { nounwind memory(none) }
+
+; ViewID is only available to graphics stages from shader model 6.1.
+; STAGE: Cannot create ViewID operation: Invalid stage
+; VERSION: Cannot create ViewID operation: No valid overloads for DXIL version 1.0
+
+;--- vertex.ll
+target triple = "dxil-pc-shadermodel6.1-vertex"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.view.id()
+ ret i32 %0
+}
+
+;--- pixel.ll
+target triple = "dxil-pc-shadermodel6.1-pixel"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.view.id()
+ ret i32 %0
+}
+
+;--- compute.ll
+target triple = "dxil-pc-shadermodel6.1-compute"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.view.id()
+ ret i32 %0
+}
+
+;--- sm60.ll
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define i32 @main() {
+entry:
+ %0 = call i32 @llvm.dx.view.id()
+ ret i32 %0
+}
diff --git a/llvm/test/CodeGen/SPIRV/semantics/view-index.ps.ll b/llvm/test/CodeGen/SPIRV/semantics/view-index.ps.ll
new file mode 100644
index 00000000000000..25d092775bdf08
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/semantics/view-index.ps.ll
@@ -0,0 +1,42 @@
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.2-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
+; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - -filetype=obj | spirv-val --target-env vulkan1.3 %}
+
+; Before SPIR-V 1.3, MultiView requires SPV_KHR_multiview.
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv32v1.2-unknown-vulkan1.0-pixel -spirv-ext=+SPV_KHR_multiview %s -o - | FileCheck %s --check-prefixes=CHECK,EXT
+; RUN: not llc -O0 -mtriple=spirv32v1.2-unknown-vulkan1.0-pixel %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERROR
+; RUN: not llc -O0 -mtriple=spirv32v1.2-unknown-vulkan1.0-pixel -spirv-ext=-SPV_KHR_multiview %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERROR
+
+; SV_ViewID is lowered to a flat load of the ViewIndex built-in, which requires
+; MultiView. The capability is core from SPIR-V 1.3, so no extension is needed
+; for Vulkan 1.2 or later.
+
+; ERROR: LLVM ERROR: capability MultiView requires SPIR-V 1.3 or the following SPIR-V extension: SPV_KHR_multiview
+
+; CHECK-DAG: OpCapability MultiView
+; EXT-DAG: OpExtension "SPV_KHR_multiview"
+; CHECK-DAG: OpDecorate %[[#VIEW:]] BuiltIn ViewIndex
+; CHECK-DAG: OpDecorate %[[#VIEW]] Flat
+; CHECK-DAG: %[[#INT:]] = OpTypeInt 32 0
+; CHECK-DAG: %[[#PTR:]] = OpTypePointer Input %[[#INT]]
+; CHECK-DAG: %[[#VIEW]] = OpVariable %[[#PTR]] Input
+
+ at SV_ViewID = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations !0
+ at SV_Target0 = external hidden thread_local addrspace(8) global float, !spirv.Decorations !3
+
+define void @main() #0 {
+entry:
+; CHECK: OpLoad %[[#INT]] %[[#VIEW]]
+ %0 = load i32, ptr addrspace(7) @SV_ViewID, align 4
+ %1 = uitofp i32 %0 to float
+ store float %1, ptr addrspace(8) @SV_Target0, align 4
+ ret void
+}
+
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!0 = !{!1, !2}
+!1 = !{i32 11, i32 4440}
+!2 = !{i32 14}
+!3 = !{!4}
+!4 = !{i32 30, i32 0}
diff --git a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
index 399e6630a189e1..f2ce49b898e61a 100644
--- a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
+++ b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
@@ -77,7 +77,8 @@ constexpr SemanticKind SupportedKinds[] = {SemanticKind::Arbitrary,
SemanticKind::Barycentrics,
SemanticKind::StartVertexLocation,
SemanticKind::StartInstanceLocation,
- SemanticKind::SampleIndex};
+ SemanticKind::SampleIndex,
+ SemanticKind::ViewID};
// Ensure all stages return a valid SemanticInterpretation
TEST(HLSLSemanticStagesTest, StagesAreValid) {
@@ -202,4 +203,24 @@ TEST(HLSLSemanticStagesTest, SampleIndexSignaturePoints) {
expectOnlySignaturePoints(SemanticKind::SampleIndex, Valid);
}
+// SV_ViewID is read with a dedicated operation and is never placed in a
+// signature. Valid on the inputs of every graphics stage that consumes it,
+// including hull and domain patch constants, but not on amplification shader
+// inputs, mesh shader primitive outputs, or any output.
+TEST(HLSLSemanticStagesTest, ViewIDSignaturePoints) {
+ constexpr SemanticInterpretation NotAllocated =
+ SemanticInterpretation::NotAllocated;
+ const SignaturePoint Valid[] = {
+ {Triple::Vertex, IOType::In, NotAllocated},
+ {Triple::Hull, IOType::In, NotAllocated},
+ {Triple::Hull, IOType::PatchConstantOrPrimitive, NotAllocated},
+ {Triple::Domain, IOType::In, NotAllocated},
+ {Triple::Domain, IOType::PatchConstantOrPrimitive, NotAllocated},
+ {Triple::Geometry, IOType::In, NotAllocated},
+ {Triple::Pixel, IOType::In, NotAllocated},
+ {Triple::Mesh, IOType::In, NotAllocated},
+ };
+ expectOnlySignaturePoints(SemanticKind::ViewID, Valid);
+}
+
} // namespace
>From eb5450b5eaa942b279b66fbac11462f86e9c2ed5 Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Wed, 21 Oct 2026 18:48:28 +0000
Subject: [PATCH 3/9] [HLSL] Add support for SV_PrimitiveID
---
clang/lib/CodeGen/CGHLSLRuntime.cpp | 18 ++++-
clang/lib/Sema/SemaHLSL.cpp | 5 +-
.../semantics/SV_PrimitiveID.ps.hlsl | 49 ++++++++++++
.../SemaHLSL/Semantics/primitiveid.ps.hlsl | 57 ++++++++++++++
.../Semantics/primitiveid.stages.hlsl | 23 ++++++
llvm/lib/Frontend/HLSL/SemanticSignatures.cpp | 5 ++
.../Target/DirectX/DXILSignatureAnalysis.cpp | 14 ++++
llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp | 1 +
.../SemanticSignatures-primitive-id.ll | 57 ++++++++++++++
...semantic-signatures-primitive-id-errors.ll | 75 +++++++++++++++++++
.../SPIRV/semantics/primitive-id.ps.ll | 32 ++++++++
.../Frontend/HLSLSemanticStagesTest.cpp | 12 ++-
12 files changed, 345 insertions(+), 3 deletions(-)
create mode 100644 clang/test/CodeGenHLSL/semantics/SV_PrimitiveID.ps.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
create mode 100644 llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
create mode 100644 llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
create mode 100644 llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 981ec3e9c790b3..4ca76df43fc7c9 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -1355,7 +1355,8 @@ static llvm::hlsl::SemanticSignatureElement createSemanticSignatureElement(
getSignatureComponentType(CGM, Shape.RowType);
// These system values may be declared as int or uint, but DXIL signatures
// require an unsigned component type.
- if (Kind == llvm::dxbc::PSV::SemanticKind::SampleIndex) {
+ if (Kind == llvm::dxbc::PSV::SemanticKind::SampleIndex ||
+ Kind == llvm::dxbc::PSV::SemanticKind::PrimitiveID) {
if (CompType == llvm::dxil::ElementType::I16)
CompType = llvm::dxil::ElementType::U16;
else if (CompType == llvm::dxil::ElementType::I32)
@@ -1703,6 +1704,21 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
return B.CreateCall(
CGM.getIntrinsic(llvm::Intrinsic::dx_start_vertex_location));
break;
+ case llvm::dxbc::PSV::SemanticKind::PrimitiveID:
+ assert(Stage == llvm::Triple::Pixel &&
+ "SV_PrimitiveID is in an unavailable stage and should have been "
+ "diagnosed by Sema");
+ if (CGM.getTarget().getTriple().isSPIRV())
+ return createSPIRVInputLoad(B, CGM.getModule(), Type,
+ Semantic->getAttrName()->getName(),
+ llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn,
+ /* PrimitiveId */ 7, InterpMode);
+ // Pixel shaders read the primitive ID from the input signature. The
+ // dx.op.primitiveID operation is only available to other stages.
+ if (CGM.getTarget().getTriple().isDXIL())
+ return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index,
+ Signature);
+ break;
case llvm::dxbc::PSV::SemanticKind::SampleIndex:
assert(Stage == llvm::Triple::Pixel &&
"SV_SampleIndex is in an unavailable stage and should have been "
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 708f74d71b0e3c..96f19144bb49be 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1016,6 +1016,7 @@ static bool isVkPipelineBuiltin(const ASTContext &AstContext, FunctionDecl *FD,
(ST == llvm::Triple::Vertex && !IsInput);
case SemanticKind::Barycentrics:
case SemanticKind::SampleIndex:
+ case SemanticKind::PrimitiveID:
return ST == llvm::Triple::Pixel && IsInput;
case SemanticKind::StartVertexLocation:
case SemanticKind::StartInstanceLocation:
@@ -1442,6 +1443,9 @@ void SemaHLSL::diagnoseSemanticType(const Decl *D,
<< /* 16 or 32 bit floating-point */ 2 << DeclaredTy;
return;
case SemanticKind::SampleIndex:
+ case SemanticKind::PrimitiveID:
+ // SPIR-V declares these built-ins as 32-bit integers and converts 16-bit
+ // declarations.
if (DeclaredTy != T || !T->isScalarType() || !isIntUpTo32Element(Ctx, T))
Diag(A->getLoc(), diag::err_hlsl_semantic_invalid_type)
<< A->getAttrName() << /* scalar */ 0 << 1
@@ -2262,7 +2266,6 @@ void SemaHLSL::handleSemanticAttr(Decl *D, const ParsedAttr &AL) {
case SemanticKind::CullDistance:
case SemanticKind::OutputControlPointID:
case SemanticKind::DomainLocation:
- case SemanticKind::PrimitiveID:
case SemanticKind::GSInstanceID:
case SemanticKind::IsFrontFace:
case SemanticKind::Coverage:
diff --git a/clang/test/CodeGenHLSL/semantics/SV_PrimitiveID.ps.hlsl b/clang/test/CodeGenHLSL/semantics/SV_PrimitiveID.ps.hlsl
new file mode 100644
index 00000000000000..7a083d8059f69c
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/SV_PrimitiveID.ps.hlsl
@@ -0,0 +1,49 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefixes=CHECK-DXIL,DXIL32 %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-pixel -x hlsl -emit-llvm -finclude-default-header -fnative-half-type -fnative-int16-type -disable-llvm-passes -DINT16 -o - %s | FileCheck --check-prefixes=CHECK-DXIL,DXIL16 %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-pixel -x hlsl -emit-llvm -finclude-default-header -disable-llvm-passes -o - %s | FileCheck --check-prefix=CHECK-SPIRV %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-pixel -x hlsl -emit-llvm -finclude-default-header -fnative-half-type -fnative-int16-type -disable-llvm-passes -DINT16 -o - %s | FileCheck --check-prefix=SPIRV16 %s
+
+#ifdef INT16
+#define TYPE int16_t
+#else
+#define TYPE int
+#endif
+
+// CHECK-SPIRV: @SV_PrimitiveID = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations ![[#MD_0:]]
+
+// Pixel shaders read SV_PrimitiveID from the input signature as a
+// system-generated value, allocated like the other inputs.
+
+// CHECK-DXIL-LABEL: define void @main()
+// DXIL32: %[[PID:.*]] = call i32 @llvm.dx.load.input.i32(i32 0, i32 0, i8 0, i32 poison)
+// DXIL16: %[[PID:.*]] = call i16 @llvm.dx.load.input.i16(i32 0, i32 0, i8 0, i32 poison)
+// CHECK-DXIL: %[[A:.*]] = call float @llvm.dx.load.input.f32(i32 1, i32 0, i8 0, i32 poison)
+// DXIL32: call float @_Z4mainif(i32 %[[PID]], float %[[A]])
+// DXIL16: call float @_Z4mainsf(i16 %[[PID]], float %[[A]])
+
+// Signed declarations use an unsigned DXIL component type, with nointerpolation.
+// DXIL32-DAG: !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, ![[#ZERO:]], i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+// DXIL16-DAG: !{i32 0, !"SV_PrimitiveID", i32 3, i32 10, ![[#ZERO:]], i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+// CHECK-DXIL-DAG: !{i32 1, !"A", i32 9, i32 0, ![[#ZERO]], i32 2, i32 1, i8 1, i32 1, i8 0, i8 0, i8 0, i32 0}
+// CHECK-DXIL-DAG: ![[#ZERO]] = !{i32 0}
+
+// CHECK-SPIRV-LABEL: define void @main()
+// CHECK-SPIRV: %[[PID:.*]] = load i32, ptr addrspace(7) @SV_PrimitiveID, align 4
+// CHECK-SPIRV: call spir_func float @_Z4mainif(i32 %[[PID]],
+float main(TYPE pid : SV_PrimitiveID, float a : A) : SV_Target {
+ return a * pid;
+}
+
+// CHECK-SPIRV-DAG: ![[#MD_0]] = !{![[#BUILTIN:]], ![[#FLAT:]]}
+// The metadata below contains SPIR-V decoration 'BuiltIn' followed by
+// BuiltIn PrimitiveId.
+// CHECK-SPIRV-DAG: ![[#BUILTIN]] = !{i32 11, i32 7}
+// CHECK-SPIRV-DAG: ![[#FLAT]] = !{i32 14}
+
+// The SPIR-V built-in is a 32-bit integer, so a 16-bit declaration is
+// truncated.
+// SPIRV16: @SV_PrimitiveID = {{.*}} addrspace(7) externally_initialized constant i32,
+// SPIRV16-LABEL: define void @main()
+// SPIRV16: %[[V32:.*]] = load i32, ptr addrspace(7) @SV_PrimitiveID
+// SPIRV16: %[[V16:.*]] = trunc i32 %[[V32]] to i16
+// SPIRV16: call spir_func float @_Z4mainsf(i16 %[[V16]],
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
new file mode 100644
index 00000000000000..48cdc4b035d992
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
@@ -0,0 +1,57 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+
+// Type, index and interpolation checks for SV_PrimitiveID. These are
+// independent of the shader stage and IO direction, which are covered by
+// primitiveid.stages.hlsl.
+
+[shader("pixel")]
+void valid_uint(uint s : SV_PrimitiveID) {}
+[shader("pixel")]
+void valid_int(int s : sv_primitiveid0) {}
+[shader("pixel")]
+void valid_flat(nointerpolation uint s : SV_PrimitiveID) {}
+
+// 16-bit integers are allowed. SPIR-V converts them to and from the 32-bit
+// built-in.
+[shader("pixel")]
+void uint16(uint16_t s : SV_PrimitiveID) {}
+[shader("pixel")]
+void int16(int16_t s : SV_PrimitiveID) {}
+
+struct Input {
+ float4 p : SV_Position;
+ uint s : SV_PrimitiveID;
+};
+[shader("pixel")]
+void valid_struct(Input i) {}
+
+[shader("pixel")]
+void bad_float(float s : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' must be a scalar of 16 or 32 bit integer type (was 'float')}}
+[shader("pixel")]
+void bad_bool(bool s : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' must be a scalar of 16 or 32 bit integer type (was 'bool')}}
+[shader("pixel")]
+void bad_int64(uint64_t s : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' must be a scalar of 16 or 32 bit integer type (was 'uint64_t' (aka 'unsigned long'))}}
+[shader("pixel")]
+void bad_vector(uint1 s : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' must be a scalar of 16 or 32 bit integer type (was 'uint1' (aka 'vector<uint, 1>'))}}
+[shader("pixel")]
+void bad_array(uint s[1] : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' must be a scalar of 16 or 32 bit integer type (was 'uint[1]'}}
+
+[shader("pixel")]
+void bad_index(uint s : SV_PrimitiveID1) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' does not allow indexing}}
+
+[shader("pixel")]
+void same_index(uint s : SV_PrimitiveID, // expected-note {{previous use is here}}
+ uint t : SV_PrimitiveID0) {} // expected-note {{'t' declared here}}
+// expected-error at -1 {{semantic index overlap SV_PrimitiveID0}}
+
+// Integer inputs can only use nointerpolation.
+[shader("pixel")]
+void bad_interpolation(sample uint s : SV_PrimitiveID) {}
+// expected-error at -1 {{interpolation modifiers other than 'nointerpolation' cannot be used with type 'uint' (aka 'unsigned int')}}
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
new file mode 100644
index 00000000000000..f80d0410eced0e
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -finclude-default-header -x hlsl -verify -o - %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -finclude-default-header -x hlsl -verify -o - %s
+
+// Stage and IO direction checks for SV_PrimitiveID: only a pixel input.
+// Type, index and interpolation checks are covered by primitiveid.ps.hlsl.
+
+[shader("pixel")]
+float4 ok_ps_in(uint s : SV_PrimitiveID) : SV_Target {
+ return float4((float)s, 0, 0, 1);
+}
+
+[shader("pixel")]
+uint bad_ps_out() : SV_PrimitiveID { return 0; }
+// expected-error at -1 {{semantic 'SV_PrimitiveID' is not supported in pixel shader outputs}}
+
+[shader("vertex")]
+float4 bad_vs_in(uint s : SV_PrimitiveID) : SV_Position { return 0; }
+// expected-error at -1 {{semantic 'SV_PrimitiveID' is not supported in vertex shader inputs}}
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void bad_cs_in(uint s : SV_PrimitiveID) {}
+// expected-error at -1 {{semantic 'SV_PrimitiveID' is not supported in compute shader inputs}}
diff --git a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
index a079c78d952fb5..2ec965d878d658 100644
--- a/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
+++ b/llvm/lib/Frontend/HLSL/SemanticSignatures.cpp
@@ -199,6 +199,11 @@ hlsl::getAvailableStages(dxbc::PSV::SemanticKind SemanticKind) {
{Triple::Vertex, IOType::In, SemanticInterpretation::SV}};
return Stages;
}
+ case dxbc::PSV::SemanticKind::PrimitiveID: {
+ static constexpr SemanticStageInfo Stages[] = {
+ {Triple::Pixel, IOType::In, SemanticInterpretation::SGV}};
+ return Stages;
+ }
case dxbc::PSV::SemanticKind::IsFrontFace: {
static constexpr SemanticStageInfo Stages[] = {
{Triple::Geometry, IOType::Out, SemanticInterpretation::SGV},
diff --git a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
index 1d6a8e4bc90e1f..a755c979eb4da8 100644
--- a/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
+++ b/llvm/lib/Target/DirectX/DXILSignatureAnalysis.cpp
@@ -102,6 +102,12 @@ static Error diagnoseSemanticType(const SemanticSignatureElement &E) {
return signatureError(
"SV_SampleIndex requires a scalar 16- or 32-bit unsigned integer");
break;
+ case dxbc::PSV::SemanticKind::PrimitiveID:
+ if (E.Rows != 1 || E.Cols != 1 ||
+ (E.CompType != ElementType::U16 && E.CompType != ElementType::U32))
+ return signatureError(
+ "SV_PrimitiveID requires a scalar 16- or 32-bit unsigned integer");
+ break;
case dxbc::PSV::SemanticKind::Barycentrics:
if (E.Rows != 1 || E.Cols != 3 ||
(E.CompType != ElementType::F16 && E.CompType != ElementType::F32))
@@ -133,6 +139,10 @@ static Error diagnoseSemanticIndex(const SemanticSignatureElement &E) {
if (E.SemanticIndices.front() != 0)
return signatureError("SV_SampleIndex requires semantic index 0");
break;
+ case dxbc::PSV::SemanticKind::PrimitiveID:
+ if (E.SemanticIndices.front() != 0)
+ return signatureError("SV_PrimitiveID requires semantic index 0");
+ break;
default:
break;
}
@@ -546,6 +556,8 @@ static dxbc::D3DSystemValue getSystemValue(dxbc::PSV::SemanticKind Kind) {
return dxbc::D3DSystemValue::Barycentrics;
case KindTy::SampleIndex:
return dxbc::D3DSystemValue::SampleIndex;
+ case KindTy::PrimitiveID:
+ return dxbc::D3DSystemValue::PrimitiveID;
default:
llvm_unreachable("validated vertex/pixel signature semantic");
}
@@ -580,6 +592,8 @@ static StringRef getContainerSemanticName(const SemanticSignatureElement &E) {
return "SV_Barycentrics";
case Kind::SampleIndex:
return "SV_SampleIndex";
+ case Kind::PrimitiveID:
+ return "SV_PrimitiveID";
default:
llvm_unreachable("validated vertex/pixel signature semantic");
}
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
index 55b46cef36cf30..c715e66db96825 100644
--- a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -1071,6 +1071,7 @@ void RequirementHandler::initAvailableCapabilitiesForVulkan(
// Core in Vulkan 1.1 and earlier.
addAvailableCaps({Capability::Int64,
+ Capability::Geometry,
Capability::Float16,
Capability::Float64,
Capability::GroupNonUniform,
diff --git a/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
new file mode 100644
index 00000000000000..37f6f1077bcd5d
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
@@ -0,0 +1,57 @@
+; RUN: opt -disable-output -passes='print<dxil-signature>' %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS
+; RUN: llc -filetype=obj %s -o %t.dxbc
+; RUN: obj2yaml %t.dxbc | FileCheck %s --check-prefix=PARTS
+; RUN: llvm-objcopy --dump-section=DXIL=%t.bc %t.dxbc
+; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefixes=MD,DXIL
+
+; SV_PrimitiveID is a system-generated pixel input, read with loadInput.
+target triple = "dxil-pc-shadermodel6.0-pixel"
+
+define void @main() #0 {
+ %a = call float @llvm.dx.load.input.f32(i32 0, i32 0, i8 0, i32 poison)
+ %pid = call i32 @llvm.dx.load.input.i32(i32 1, i32 0, i8 0, i32 poison)
+ %f = uitofp i32 %pid to float
+ %result = fadd float %a, %f
+ call void @llvm.dx.store.output.f32(i32 0, i32 0, i8 0, float %result)
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!dx.valver = !{!10}
+!10 = !{i32 1, i32 8}
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, !2}
+!1 = !{!3, !4}
+!2 = !{!6}
+!3 = !{i32 0, !"A", i32 9, i32 0, !7, i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!4 = !{i32 1, !"SV_PrimitiveID", i32 5, i32 10, !7, i32 1, i32 1, i8 1, i32 1, i8 0, i8 0, i8 0, i32 0}
+!6 = !{i32 0, !"SV_Target", i32 9, i32 16, !7, i32 0, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!7 = !{i32 0}
+
+; ANALYSIS: Inputs: 2 elements, 2 vectors
+; ANALYSIS-NEXT: 0: A rows=1 cols=1 at 0:0 usage=1 dynamic=0
+; ANALYSIS-NEXT: 1: SV_PrimitiveID rows=1 cols=1 at 1:0 usage=1 dynamic=0
+
+; DXIL: call i32 @dx.op.loadInput.i32(i32 4, i32 1, i32 0, i8 0, i32 {{.*}})
+; MD-DAG: !{i32 1, !"SV_PrimitiveID", i8 5, i8 10, !{{[0-9]+}}, i8 1, i32 1, i8 1, i32 1, i8 0, !{{[0-9]+}}}
+
+; PARTS: Name: ISG1
+; PARTS: Name: SV_PrimitiveID
+; PARTS-NEXT: Index: 0
+; PARTS-NEXT: SystemValue: PrimitiveID
+; PARTS-NEXT: CompType: UInt32
+; PARTS-NEXT: Register: 1
+; PARTS-NEXT: Mask: 1
+; PARTS-NEXT: ExclusiveMask: 1
+; PARTS: Name: PSV0
+; PARTS: SampleFrequency: 0
+; PARTS: SigInputElements:
+; PARTS: Kind: Arbitrary
+; PARTS: Indices: [ 0 ]
+; PARTS-NEXT: StartRow: 1
+; PARTS-NEXT: Cols: 1
+; PARTS-NEXT: StartCol: 0
+; PARTS-NEXT: Allocated: true
+; PARTS-NEXT: Kind: PrimitiveID
+; PARTS-NEXT: ComponentType: UInt32
+; PARTS-NEXT: Interpolation: Constant
diff --git a/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
new file mode 100644
index 00000000000000..ea99584890487b
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
@@ -0,0 +1,75 @@
+; RUN: split-file %s %t
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/signed.ll 2>&1 | FileCheck %s --check-prefix=CHECK-SIGNED
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/cols.ll 2>&1 | FileCheck %s --check-prefix=CHECK-COLS
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/index.ll 2>&1 | FileCheck %s --check-prefix=CHECK-INDEX
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/linear.ll 2>&1 | FileCheck %s --check-prefix=CHECK-LINEAR
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/unallocated.ll 2>&1 | FileCheck %s --check-prefix=CHECK-UNALLOCATED
+; RUN: not opt -disable-output -passes=dxil-translate-metadata %t/vertex.ll 2>&1 | FileCheck %s --check-prefix=CHECK-VERTEX
+
+; Each case is a complete module with one invalid SV_PrimitiveID declaration.
+
+;--- signed.ll
+; CHECK-SIGNED: SV_PrimitiveID requires a scalar 16- or 32-bit unsigned integer
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 4, i32 10, !3, i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- cols.ll
+; CHECK-COLS: SV_PrimitiveID requires a scalar 16- or 32-bit unsigned integer
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, !3, i32 1, i32 1, i8 2, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- index.ll
+; CHECK-INDEX: SV_PrimitiveID requires semantic index 0
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, !3, i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 1}
+
+;--- linear.ll
+; CHECK-LINEAR: integer pixel inputs require constant interpolation
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, !3, i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- unallocated.ll
+; CHECK-UNALLOCATED: signature element 0 ('SV_PrimitiveID') has no allocated location
+target triple = "dxil-pc-shadermodel6.0-pixel"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="pixel" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, !3, i32 1, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
+
+;--- vertex.ll
+; CHECK-VERTEX: invalid or unsupported semantic for this stage and signature category
+target triple = "dxil-pc-shadermodel6.0-vertex"
+define void @main() #0 { ret void }
+attributes #0 = { "hlsl.shader"="vertex" }
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, null}
+!1 = !{!2}
+!2 = !{i32 0, !"SV_PrimitiveID", i32 5, i32 10, !3, i32 1, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!3 = !{i32 0}
diff --git a/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll b/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
new file mode 100644
index 00000000000000..16545e81e8b1f9
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
@@ -0,0 +1,32 @@
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
+; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - -filetype=obj | spirv-val --target-env vulkan1.3 %}
+
+; SV_PrimitiveID is lowered to a flat load of the PrimitiveId built-in. In a
+; fragment shader it is enabled by the Geometry capability.
+
+; CHECK-DAG: OpCapability Geometry
+; CHECK-DAG: OpDecorate %[[#PRIM:]] BuiltIn PrimitiveId
+; CHECK-DAG: OpDecorate %[[#PRIM]] Flat
+; CHECK-DAG: %[[#INT:]] = OpTypeInt 32 0
+; CHECK-DAG: %[[#PTR:]] = OpTypePointer Input %[[#INT]]
+; CHECK-DAG: %[[#PRIM]] = OpVariable %[[#PTR]] Input
+
+ at SV_PrimitiveID = external hidden thread_local addrspace(7) externally_initialized constant i32, !spirv.Decorations !0
+ at SV_Target0 = external hidden thread_local addrspace(8) global float, !spirv.Decorations !3
+
+define void @main() #0 {
+entry:
+; CHECK: OpLoad %[[#INT]] %[[#PRIM]]
+ %0 = load i32, ptr addrspace(7) @SV_PrimitiveID, align 4
+ %1 = uitofp i32 %0 to float
+ store float %1, ptr addrspace(8) @SV_Target0, align 4
+ ret void
+}
+
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!0 = !{!1, !2}
+!1 = !{i32 11, i32 7}
+!2 = !{i32 14}
+!3 = !{!4}
+!4 = !{i32 30, i32 0}
diff --git a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
index f2ce49b898e61a..b3d2986d2c655b 100644
--- a/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
+++ b/llvm/unittests/Frontend/HLSLSemanticStagesTest.cpp
@@ -78,7 +78,8 @@ constexpr SemanticKind SupportedKinds[] = {SemanticKind::Arbitrary,
SemanticKind::StartVertexLocation,
SemanticKind::StartInstanceLocation,
SemanticKind::SampleIndex,
- SemanticKind::ViewID};
+ SemanticKind::ViewID,
+ SemanticKind::PrimitiveID};
// Ensure all stages return a valid SemanticInterpretation
TEST(HLSLSemanticStagesTest, StagesAreValid) {
@@ -223,4 +224,13 @@ TEST(HLSLSemanticStagesTest, ViewIDSignaturePoints) {
expectOnlySignaturePoints(SemanticKind::ViewID, Valid);
}
+// SV_PrimitiveID is generated by the rasterizer and read by the pixel shader.
+// Valid only on pixel inputs, where it is a system-generated value.
+TEST(HLSLSemanticStagesTest, PrimitiveIDSignaturePoints) {
+ const SignaturePoint Valid[] = {
+ {Triple::Pixel, IOType::In, SemanticInterpretation::SGV},
+ };
+ expectOnlySignaturePoints(SemanticKind::PrimitiveID, Valid);
+}
+
} // namespace
>From 79d8086ec863358178f5704b1fa4e9fd3f6c703e Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:49:58 +0000
Subject: [PATCH 4/9] review: explain how the SV_PrimitiveID error test covers
a signed integer
---
.../{primitiveid.ps.hlsl => primitiveid.ps.errors.hlsl} | 0
.../DirectX/Metadata/semantic-signatures-primitive-id-errors.ll | 2 ++
2 files changed, 2 insertions(+)
rename clang/test/SemaHLSL/Semantics/{primitiveid.ps.hlsl => primitiveid.ps.errors.hlsl} (100%)
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl
similarity index 100%
rename from clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
rename to clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl
diff --git a/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
index ea99584890487b..05d5a919e3c904 100644
--- a/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
+++ b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id-errors.ll
@@ -9,6 +9,8 @@
; Each case is a complete module with one invalid SV_PrimitiveID declaration.
;--- signed.ll
+; The component type is 4 (I32), a signed 32-bit integer. Clang always emits an
+; unsigned component type (U16 or U32) for SV_PrimitiveID, so I32 is rejected.
; CHECK-SIGNED: SV_PrimitiveID requires a scalar 16- or 32-bit unsigned integer
target triple = "dxil-pc-shadermodel6.0-pixel"
define void @main() #0 { ret void }
>From fc841c1a7eac345563c82adc290e8588784e9e47 Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:50:01 +0000
Subject: [PATCH 5/9] review: say pixel shader and test the minimum Vulkan
version for SV_PrimitiveID
---
llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll b/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
index 16545e81e8b1f9..f430b19ec63ecc 100644
--- a/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
+++ b/llvm/test/CodeGen/SPIRV/semantics/primitive-id.ps.ll
@@ -1,8 +1,11 @@
; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
+; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan1.2-pixel %s -o - | FileCheck %s --implicit-check-not=OpExtension
; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan1.3-pixel %s -o - -filetype=obj | spirv-val --target-env vulkan1.3 %}
; SV_PrimitiveID is lowered to a flat load of the PrimitiveId built-in. In a
-; fragment shader it is enabled by the Geometry capability.
+; pixel shader it is enabled by the Geometry capability. Geometry needs no
+; SPIR-V extension in any Vulkan version, so there is no minimum version beyond
+; Vulkan 1.2, the lowest version Clang accepts.
; CHECK-DAG: OpCapability Geometry
; CHECK-DAG: OpDecorate %[[#PRIM:]] BuiltIn PrimitiveId
>From b74397cbea689d492bbf2177fe887ac005fbe247 Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:50:02 +0000
Subject: [PATCH 6/9] review: explain why a signed SV_PrimitiveID declaration
is accepted
---
clang/lib/CodeGen/CGHLSLRuntime.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 4ca76df43fc7c9..5d380e7e8f5685 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -1353,8 +1353,10 @@ static llvm::hlsl::SemanticSignatureElement createSemanticSignatureElement(
llvm::dxbc::PSV::SemanticKind Kind = llvm::hlsl::getSemanticKind(Name);
llvm::dxil::ElementType CompType =
getSignatureComponentType(CGM, Shape.RowType);
- // These system values may be declared as int or uint, but DXIL signatures
- // require an unsigned component type.
+ // SV_SampleIndex and SV_PrimitiveID may be declared as int or uint, as in
+ // DXC. Both are indices generated by the system, so they are never negative
+ // and a signed declaration reads the same value. DXIL signatures require an
+ // unsigned component type.
if (Kind == llvm::dxbc::PSV::SemanticKind::SampleIndex ||
Kind == llvm::dxbc::PSV::SemanticKind::PrimitiveID) {
if (CompType == llvm::dxil::ElementType::I16)
>From f54fb35beb3819cbd63608fa5de2bbef0b08041e Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:50:02 +0000
Subject: [PATCH 7/9] review: simplify the SV_PrimitiveID scalar type check
---
clang/lib/Sema/SemaHLSL.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 96f19144bb49be..746c45662030a1 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1446,7 +1446,7 @@ void SemaHLSL::diagnoseSemanticType(const Decl *D,
case SemanticKind::PrimitiveID:
// SPIR-V declares these built-ins as 32-bit integers and converts 16-bit
// declarations.
- if (DeclaredTy != T || !T->isScalarType() || !isIntUpTo32Element(Ctx, T))
+ if (!DeclaredTy->isScalarType() || !isIntUpTo32Element(Ctx, DeclaredTy))
Diag(A->getLoc(), diag::err_hlsl_semantic_invalid_type)
<< A->getAttrName() << /* scalar */ 0 << 1
<< /* 16 or 32 bit integer */ 0 << DeclaredTy;
>From 83a8996159e3f905768e4e5996d034555cc76919 Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:50:02 +0000
Subject: [PATCH 8/9] review: split the SV_PrimitiveID container test into
packing and container part tests
---
.../SemanticSignatures-primitive-id.ll | 56 ++++++++-----------
.../semantic-signatures-primitive-id.ll | 35 ++++++++++++
2 files changed, 59 insertions(+), 32 deletions(-)
create mode 100644 llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id.ll
diff --git a/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
index 37f6f1077bcd5d..e97eef028f9058 100644
--- a/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
+++ b/llvm/test/CodeGen/DirectX/ContainerData/SemanticSignatures-primitive-id.ll
@@ -1,10 +1,9 @@
-; RUN: opt -disable-output -passes='print<dxil-signature>' %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS
; RUN: llc -filetype=obj %s -o %t.dxbc
-; RUN: obj2yaml %t.dxbc | FileCheck %s --check-prefix=PARTS
-; RUN: llvm-objcopy --dump-section=DXIL=%t.bc %t.dxbc
-; RUN: llvm-dis %t.bc -o - | FileCheck %s --check-prefixes=MD,DXIL
+; RUN: obj2yaml %t.dxbc | FileCheck %s
-; SV_PrimitiveID is a system-generated pixel input, read with loadInput.
+; SV_PrimitiveID is written to the ISG1 and PSV0 parts as an allocated input
+; element with the PrimitiveID system value. Packing is covered by
+; Metadata/semantic-signatures-primitive-id.ll.
target triple = "dxil-pc-shadermodel6.0-pixel"
define void @main() #0 {
@@ -28,30 +27,23 @@ attributes #0 = { "hlsl.shader"="pixel" }
!6 = !{i32 0, !"SV_Target", i32 9, i32 16, !7, i32 0, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
!7 = !{i32 0}
-; ANALYSIS: Inputs: 2 elements, 2 vectors
-; ANALYSIS-NEXT: 0: A rows=1 cols=1 at 0:0 usage=1 dynamic=0
-; ANALYSIS-NEXT: 1: SV_PrimitiveID rows=1 cols=1 at 1:0 usage=1 dynamic=0
-
-; DXIL: call i32 @dx.op.loadInput.i32(i32 4, i32 1, i32 0, i8 0, i32 {{.*}})
-; MD-DAG: !{i32 1, !"SV_PrimitiveID", i8 5, i8 10, !{{[0-9]+}}, i8 1, i32 1, i8 1, i32 1, i8 0, !{{[0-9]+}}}
-
-; PARTS: Name: ISG1
-; PARTS: Name: SV_PrimitiveID
-; PARTS-NEXT: Index: 0
-; PARTS-NEXT: SystemValue: PrimitiveID
-; PARTS-NEXT: CompType: UInt32
-; PARTS-NEXT: Register: 1
-; PARTS-NEXT: Mask: 1
-; PARTS-NEXT: ExclusiveMask: 1
-; PARTS: Name: PSV0
-; PARTS: SampleFrequency: 0
-; PARTS: SigInputElements:
-; PARTS: Kind: Arbitrary
-; PARTS: Indices: [ 0 ]
-; PARTS-NEXT: StartRow: 1
-; PARTS-NEXT: Cols: 1
-; PARTS-NEXT: StartCol: 0
-; PARTS-NEXT: Allocated: true
-; PARTS-NEXT: Kind: PrimitiveID
-; PARTS-NEXT: ComponentType: UInt32
-; PARTS-NEXT: Interpolation: Constant
+; CHECK: Name: ISG1
+; CHECK: Name: SV_PrimitiveID
+; CHECK-NEXT: Index: 0
+; CHECK-NEXT: SystemValue: PrimitiveID
+; CHECK-NEXT: CompType: UInt32
+; CHECK-NEXT: Register: 1
+; CHECK-NEXT: Mask: 1
+; CHECK-NEXT: ExclusiveMask: 1
+; CHECK: Name: PSV0
+; CHECK: SampleFrequency: 0
+; CHECK: SigInputElements:
+; CHECK: Kind: Arbitrary
+; CHECK: Indices: [ 0 ]
+; CHECK-NEXT: StartRow: 1
+; CHECK-NEXT: Cols: 1
+; CHECK-NEXT: StartCol: 0
+; CHECK-NEXT: Allocated: true
+; CHECK-NEXT: Kind: PrimitiveID
+; CHECK-NEXT: ComponentType: UInt32
+; CHECK-NEXT: Interpolation: Constant
diff --git a/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id.ll b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id.ll
new file mode 100644
index 00000000000000..98f939fa1f4e7f
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/Metadata/semantic-signatures-primitive-id.ll
@@ -0,0 +1,35 @@
+; RUN: opt -disable-output -passes='print<dxil-signature>' %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS
+; RUN: opt -S -dxil-translate-metadata %s | FileCheck %s --check-prefix=MD
+
+; SV_PrimitiveID is a system-generated pixel input. Unlike SV_SampleIndex, it is
+; allocated like an arbitrary input, so it is packed at row 1 after A. The
+; container parts are covered by ContainerData/SemanticSignatures-primitive-id.ll.
+target triple = "dxil-pc-shadermodel6.0-pixel"
+
+define void @main() #0 {
+ %a = call float @llvm.dx.load.input.f32(i32 0, i32 0, i8 0, i32 poison)
+ %pid = call i32 @llvm.dx.load.input.i32(i32 1, i32 0, i8 0, i32 poison)
+ %f = uitofp i32 %pid to float
+ %result = fadd float %a, %f
+ call void @llvm.dx.store.output.f32(i32 0, i32 0, i8 0, float %result)
+ ret void
+}
+attributes #0 = { "hlsl.shader"="pixel" }
+
+!dx.valver = !{!10}
+!10 = !{i32 1, i32 8}
+!dx.semantic.signatures = !{!0}
+!0 = !{ptr @main, !1, !2}
+!1 = !{!3, !4}
+!2 = !{!6}
+!3 = !{i32 0, !"A", i32 9, i32 0, !7, i32 2, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!4 = !{i32 1, !"SV_PrimitiveID", i32 5, i32 10, !7, i32 1, i32 1, i8 1, i32 1, i8 0, i8 0, i8 0, i32 0}
+!6 = !{i32 0, !"SV_Target", i32 9, i32 16, !7, i32 0, i32 1, i8 1, i32 0, i8 0, i8 0, i8 0, i32 0}
+!7 = !{i32 0}
+
+; ANALYSIS: Inputs: 2 elements, 2 vectors
+; ANALYSIS-NEXT: 0: A rows=1 cols=1 at 0:0 usage=1 dynamic=0
+; ANALYSIS-NEXT: 1: SV_PrimitiveID rows=1 cols=1 at 1:0 usage=1 dynamic=0
+
+; MD-DAG: !{i32 0, !"A", i8 9, i8 0, !{{[0-9]+}}, i8 2, i32 1, i8 1, i32 0, i8 0, !{{[0-9]+}}}
+; MD-DAG: !{i32 1, !"SV_PrimitiveID", i8 5, i8 10, !{{[0-9]+}}, i8 1, i32 1, i8 1, i32 1, i8 0, !{{[0-9]+}}}
>From 1a136faf3f375a2c38ebd965f746abc5d6d51c7e Mon Sep 17 00:00:00 2001
From: Finn Plummer <mail at inbelic.dev>
Date: Thu, 29 Oct 2026 19:50:02 +0000
Subject: [PATCH 9/9] review: split the SV_PrimitiveID Sema type checks into
valid and error tests
---
.../Semantics/primitiveid.ps.errors.hlsl | 27 ++----------------
.../SemaHLSL/Semantics/primitiveid.ps.hlsl | 28 +++++++++++++++++++
.../Semantics/primitiveid.stages.hlsl | 3 +-
3 files changed, 33 insertions(+), 25 deletions(-)
create mode 100644 clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl
index 48cdc4b035d992..6bee4f98367128 100644
--- a/clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl
+++ b/clang/test/SemaHLSL/Semantics/primitiveid.ps.errors.hlsl
@@ -1,30 +1,9 @@
// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
-// Type, index and interpolation checks for SV_PrimitiveID. These are
-// independent of the shader stage and IO direction, which are covered by
-// primitiveid.stages.hlsl.
-
-[shader("pixel")]
-void valid_uint(uint s : SV_PrimitiveID) {}
-[shader("pixel")]
-void valid_int(int s : sv_primitiveid0) {}
-[shader("pixel")]
-void valid_flat(nointerpolation uint s : SV_PrimitiveID) {}
-
-// 16-bit integers are allowed. SPIR-V converts them to and from the 32-bit
-// built-in.
-[shader("pixel")]
-void uint16(uint16_t s : SV_PrimitiveID) {}
-[shader("pixel")]
-void int16(int16_t s : SV_PrimitiveID) {}
-
-struct Input {
- float4 p : SV_Position;
- uint s : SV_PrimitiveID;
-};
-[shader("pixel")]
-void valid_struct(Input i) {}
+// Invalid type, index and interpolation uses of SV_PrimitiveID. The valid
+// cases are covered by primitiveid.ps.hlsl, and the shader stage and IO
+// direction by primitiveid.stages.hlsl.
[shader("pixel")]
void bad_float(float s : SV_PrimitiveID) {}
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
new file mode 100644
index 00000000000000..f6201e54e67881
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/primitiveid.ps.hlsl
@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.2-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -fnative-half-type -fnative-int16-type -finclude-default-header -fsyntax-only -verify %s
+
+// Valid type, index and interpolation uses of SV_PrimitiveID. The invalid
+// cases are covered by primitiveid.ps.errors.hlsl, and the shader stage and IO
+// direction by primitiveid.stages.hlsl.
+
+// expected-no-diagnostics
+
+[shader("pixel")]
+void valid_uint(uint s : SV_PrimitiveID) {}
+[shader("pixel")]
+void valid_int(int s : sv_primitiveid0) {}
+[shader("pixel")]
+void valid_flat(nointerpolation uint s : SV_PrimitiveID) {}
+
+// 16-bit integers are allowed. SPIR-V converts them to and from the 32-bit
+// built-in.
+[shader("pixel")]
+void uint16(uint16_t s : SV_PrimitiveID) {}
+[shader("pixel")]
+void int16(int16_t s : SV_PrimitiveID) {}
+
+struct Input {
+ uint s : SV_PrimitiveID;
+};
+[shader("pixel")]
+void valid_struct(Input i) {}
diff --git a/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl b/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
index f80d0410eced0e..6feffa29e01ec7 100644
--- a/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
+++ b/clang/test/SemaHLSL/Semantics/primitiveid.stages.hlsl
@@ -2,7 +2,8 @@
// RUN: %clang_cc1 -triple spirv-pc-vulkan1.3-library -finclude-default-header -x hlsl -verify -o - %s
// Stage and IO direction checks for SV_PrimitiveID: only a pixel input.
-// Type, index and interpolation checks are covered by primitiveid.ps.hlsl.
+// Type, index and interpolation checks are covered by primitiveid.ps.hlsl and
+// primitiveid.ps.errors.hlsl.
[shader("pixel")]
float4 ok_ps_in(uint s : SV_PrimitiveID) : SV_Target {
More information about the cfe-commits
mailing list