[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