[clang] [VK][HLSL][SPIRV] Implement vk::builtin("PointSize") (PR #231275)
Jonathan Zakharov via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 5 11:52:35 PST 2026
https://github.com/jzakharovnv updated https://github.com/llvm/llvm-project/pull/231275
>From b107b696b11d3213a9bc0e14e97dde755d1cd70d Mon Sep 17 00:00:00 2001
From: Jonathan Zakharov <jzakharov at nvidia.com>
Date: Wed, 4 Nov 2026 09:07:28 -0800
Subject: [PATCH 1/2] [HLSL][SPIRV] Implement vk::builtin attribute
---
clang/include/clang/Basic/Attr.td | 8 +++
clang/include/clang/Basic/AttrDocs.td | 20 +++++++
.../clang/Basic/DiagnosticSemaKinds.td | 3 ++
clang/include/clang/Sema/SemaHLSL.h | 1 +
clang/lib/Sema/SemaDeclAttr.cpp | 3 ++
clang/lib/Sema/SemaHLSL.cpp | 29 +++++++++++
...a-attribute-supported-attributes-list.test | 1 +
.../SemaHLSL/vk-builtin-attr-non-spirv.hlsl | 16 ++++++
clang/test/SemaHLSL/vk-builtin-attr.hlsl | 52 +++++++++++++++++++
9 files changed, 133 insertions(+)
create mode 100644 clang/test/SemaHLSL/vk-builtin-attr-non-spirv.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-attr.hlsl
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index 5de5059cc18c0e..0a9224bc8a790a 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -5462,6 +5462,14 @@ def HLSLVkLocation : HLSLAnnotationAttr {
let Documentation = [HLSLVkLocationDocs];
}
+def HLSLVkBuiltIn : HLSLAnnotationAttr, TargetSpecificAttr<TargetSPIRV> {
+ let Spellings = [CXX11<"vk", "builtin">];
+ let Args = [StringArgument<"BuiltIn">];
+ let Subjects = SubjectList<[ParmVar, Field, Function], ErrorDiag>;
+ let LangOpts = [HLSL];
+ let Documentation = [HLSLVkBuiltInDocs];
+}
+
// `row_major` / `column_major` are HLSL keywords that select the in-memory
// layout of a matrix-typed declaration.
def HLSLRowMajor : TypeAttr {
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index 2300c8456ef164..e04196b26765f8 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -9755,6 +9755,26 @@ This attribute maps to the `Location` SPIR-V decoration.
}];
}
+def HLSLVkBuiltInDocs : Documentation {
+ let Category = DocCatVariable;
+ let Content = [{
+Some Vulkan built-in variables have no equivalent in native HLSL, so no
+system-value semantic can express them. The `[[vk::builtin]]` attribute marks a
+stage input/output variable as a SPIR-V built-in variable, identified by name.
+Allowed on function parameters, function returns, and struct fields. This
+attribute has no effect when used outside of an entrypoint parameter/parameter
+field/return value.
+
+The attribute is only available when targeting SPIR-V. For any other target it
+is ignored with an "unknown attribute ignored" warning.
+
+The attribute takes a single string literal argument naming the built-in.
+No built-in names are supported yet: every name is currently rejected with an
+error. Supported built-in names are added incrementally, each landing together
+with its own type/stage validation and CodeGen support.
+ }];
+}
+
def HLSLMatrixLayoutDocs : Documentation {
let Category = DocCatVariable;
let Heading = "row_major, column_major";
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 941a58ae54a05e..5655e0071eb232 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -13842,6 +13842,9 @@ def err_hlsl_semantic_in_wrong_shader_model
def err_hlsl_semantic_partial_explicit_indexing
: Error<"partial explicit stage input location assignment via "
"vk::location(X) unsupported">;
+def err_hlsl_vk_builtin_unsupported_value
+ : Error<"'%0' is not a supported value for the 'vk::builtin' attribute; "
+ "supported values are: %1">;
def warn_hlsl_user_defined_type_missing_member: Warning<"binding type '%select{t|u|b|s|c}0' only applies to types containing %select{SRV resources|UAV resources|constant buffer resources|sampler state|numeric types}0">, InGroup<LegacyConstantRegisterBinding>;
def err_hlsl_binding_type_mismatch: Error<"binding type '%select{t|u|b|s|c}0' only applies to %select{SRV resources|UAV resources|constant buffer resources|sampler state|numeric variables in the global scope}0">;
diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h
index 6a4709ed06d119..20b52737fd5d3d 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -186,6 +186,7 @@ class SemaHLSL : public SemaBase {
void handleWaveSizeAttr(Decl *D, const ParsedAttr &AL);
void handleVkConstantIdAttr(Decl *D, const ParsedAttr &AL);
void handleVkBindingAttr(Decl *D, const ParsedAttr &AL);
+ void handleVkBuiltInAttr(Decl *D, const ParsedAttr &AL);
void handleVkLocationAttr(Decl *D, const ParsedAttr &AL);
void handlePackOffsetAttr(Decl *D, const ParsedAttr &AL);
void handleShaderAttr(Decl *D, const ParsedAttr &AL);
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index e57f1de9c11007..0392c5067a1184 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -8304,6 +8304,9 @@ ProcessDeclAttribute(Sema &S, Decl *D, const ParsedAttr &AL,
case ParsedAttr::AT_HLSLVkExtBuiltinOutput:
S.HLSL().handleVkExtBuiltinOutputAttr(D, AL);
break;
+ case ParsedAttr::AT_HLSLVkBuiltIn:
+ S.HLSL().handleVkBuiltInAttr(D, AL);
+ break;
case ParsedAttr::AT_HLSLVkPushConstant:
S.HLSL().handleVkPushConstantAttr(D, AL);
break;
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 746c45662030a1..e1966e974f4fcb 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -47,6 +47,7 @@
#include "llvm/Support/DXILABI.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
#include <cmath>
@@ -2244,6 +2245,34 @@ void SemaHLSL::handleVkLocationAttr(Decl *D, const ParsedAttr &AL) {
HLSLVkLocationAttr(getASTContext(), AL, Location));
}
+void SemaHLSL::handleVkBuiltInAttr(Decl *D, const ParsedAttr &AL) {
+ StringRef BuiltIn;
+ SourceLocation ArgLoc;
+ if (!SemaRef.checkStringLiteralArgumentAttr(AL, 0, BuiltIn, &ArgLoc))
+ return;
+
+ // No built-ins are implemented yet. A name is added here together with its
+ // validation and CodeGen support, so Sema never accepts a built-in that the
+ // rest of the compiler ignores. Candidates: "PointSize", "HelperInvocation",
+ // "BaseVertex", "BaseInstance", "DrawIndex", "DeviceIndex", "ViewportMaskNV".
+ constexpr ArrayRef<StringRef> SupportedBuiltIns;
+ if (!llvm::is_contained(SupportedBuiltIns, BuiltIn)) {
+ std::string Quoted;
+ llvm::raw_string_ostream OS(Quoted);
+ if (SupportedBuiltIns.empty())
+ OS << "none";
+ else
+ llvm::interleaveComma(SupportedBuiltIns, OS,
+ [&](StringRef S) { OS << "'" << S << "'"; });
+ Diag(ArgLoc, diag::err_hlsl_vk_builtin_unsupported_value)
+ << BuiltIn << Quoted;
+ return;
+ }
+
+ D->addAttr(::new (getASTContext())
+ HLSLVkBuiltInAttr(getASTContext(), AL, BuiltIn));
+}
+
void SemaHLSL::handleSemanticAttr(Decl *D, const ParsedAttr &AL) {
uint32_t IndexValue(0), ExplicitIndex(0);
if (!SemaRef.checkUInt32Argument(AL, AL.getArgAsExpr(0), IndexValue) ||
diff --git a/clang/test/Misc/pragma-attribute-supported-attributes-list.test b/clang/test/Misc/pragma-attribute-supported-attributes-list.test
index 8f8c1aa3d3f9cd..05e4e86f22f9d9 100644
--- a/clang/test/Misc/pragma-attribute-supported-attributes-list.test
+++ b/clang/test/Misc/pragma-attribute-supported-attributes-list.test
@@ -90,6 +90,7 @@
// CHECK-NEXT: GCCStruct (SubjectMatchRule_record)
// CHECK-NEXT: GNUInline (SubjectMatchRule_function)
// CHECK-NEXT: HIPManaged (SubjectMatchRule_variable)
+// CHECK-NEXT: HLSLVkBuiltIn (SubjectMatchRule_variable_is_parameter, SubjectMatchRule_field, SubjectMatchRule_function)
// CHECK-NEXT: HLSLVkLocation (SubjectMatchRule_variable_is_parameter, SubjectMatchRule_field, SubjectMatchRule_function)
// CHECK-NEXT: HLSLVkPushConstant (SubjectMatchRule_variable_is_global)
// CHECK-NEXT: Hot (SubjectMatchRule_function)
diff --git a/clang/test/SemaHLSL/vk-builtin-attr-non-spirv.hlsl b/clang/test/SemaHLSL/vk-builtin-attr-non-spirv.hlsl
new file mode 100644
index 00000000000000..51a35368914016
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-attr-non-spirv.hlsl
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.8-library -verify %s
+
+// vk::builtin only exists when targeting SPIR-V; elsewhere it is unknown.
+
+struct S {
+ // expected-warning at +1 {{unknown attribute 'vk::builtin' ignored}}
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+
+// expected-warning at +1 {{unknown attribute 'vk::builtin' ignored}}
+float param([[vk::builtin("PointSize")]] float size : PSIZE) : A {
+ return size;
+}
+
+// expected-warning at +1 {{unknown attribute 'vk::builtin' ignored}}
+[[vk::builtin("PointSize")]] float func() : PSIZE { return 1.0f; }
diff --git a/clang/test/SemaHLSL/vk-builtin-attr.hlsl b/clang/test/SemaHLSL/vk-builtin-attr.hlsl
new file mode 100644
index 00000000000000..da1089e00f4877
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-attr.hlsl
@@ -0,0 +1,52 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-compute -verify %s
+
+// No built-in names are supported yet, so every name is rejected. Only the
+// paths that reject the attribute are exercised here.
+
+// Invalid subjects.
+// expected-error at +1 {{'vk::builtin' attribute only applies to parameters, non-static data members, and functions}}
+[[vk::builtin("Bogus")]] static float global_var;
+
+// expected-error at +1 {{'vk::builtin' attribute only applies to parameters, non-static data members, and functions}}
+[[vk::builtin("Bogus")]] cbuffer InvalidCBuffer {
+ float cb;
+}
+
+// Unsupported built-in name on each valid subject kind.
+struct BadName {
+ // expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ [[vk::builtin("Bogus")]] float a : A;
+ // The name is case sensitive.
+ // expected-error-re at +1 {{'pointsize' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ [[vk::builtin("pointsize")]] float b : B;
+ // expected-error-re at +1 {{'' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ [[vk::builtin("")]] float c : C;
+};
+
+// expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+float param([[vk::builtin("Bogus")]] float size : S) : A { return size; }
+
+// expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+[[vk::builtin("Bogus")]] float func() : F { return 1.0f; }
+
+// Wrong argument count and type.
+struct BadArgs {
+ // expected-error at +1 {{'vk::builtin' attribute takes one argument}}
+ [[vk::builtin()]] float a : A;
+ // expected-error at +1 {{'vk::builtin' attribute takes one argument}}
+ [[vk::builtin("Bogus", "Bogus")]] float b : B;
+ // expected-error at +1 {{expected string literal as argument of 'builtin' attribute}}
+ [[vk::builtin(5)]] float c : C;
+};
+
+// Templates: the argument is a string literal, so it is validated when the
+// template is declared, not when it is instantiated.
+template <typename T> struct Templated {
+ // expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ [[vk::builtin("Bogus")]] T a : A;
+};
+Templated<float> TemplatedInstance;
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void main() {}
>From a6eed69e4d1dcd540b95f1c941e0dab214d5e1d4 Mon Sep 17 00:00:00 2001
From: Jonathan Zakharov <jzakharov at nvidia.com>
Date: Thu, 5 Nov 2026 09:31:02 -0800
Subject: [PATCH 2/2] [HLSL][SPIRV] Implement vk::builtin(PointSize) validation
and CodeGen
---
clang/include/clang/Basic/AttrDocs.td | 19 +++-
.../clang/Basic/DiagnosticSemaKinds.td | 4 +
clang/lib/CodeGen/CGHLSLRuntime.cpp | 31 ++++++
clang/lib/Sema/SemaHLSL.cpp | 96 ++++++++++++++++---
clang/test/AST/HLSL/vk-builtin-attr.hlsl | 29 ++++++
.../vk-builtin-point-size-return.hlsl | 18 ++++
.../CodeGenHLSL/vk-builtin-point-size.hlsl | 36 +++++++
...antic.explicit-mix-vk-builtin-control.hlsl | 15 +++
...emantic.explicit-mix-vk-builtin-field.hlsl | 22 +++++
...emantic.explicit-mix-vk-builtin-param.hlsl | 14 +++
...mantic.explicit-mix-vk-builtin-return.hlsl | 17 ++++
clang/test/SemaHLSL/vk-builtin-attr.hlsl | 47 +++++----
.../vk-builtin-point-size-inout-pixel.hlsl | 14 +++
.../vk-builtin-point-size-inout-vertex.hlsl | 17 ++++
.../vk-builtin-point-size-invalid.hlsl | 12 +++
.../vk-builtin-point-size-stages.hlsl | 50 ++++++++++
.../SemaHLSL/vk-builtin-point-size-types.hlsl | 63 ++++++++++++
.../test/SemaHLSL/vk-builtin-point-size.hlsl | 18 ++++
18 files changed, 491 insertions(+), 31 deletions(-)
create mode 100644 clang/test/AST/HLSL/vk-builtin-attr.hlsl
create mode 100644 clang/test/CodeGenHLSL/vk-builtin-point-size-return.hlsl
create mode 100644 clang/test/CodeGenHLSL/vk-builtin-point-size.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-control.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-field.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-param.hlsl
create mode 100644 clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-return.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size-inout-pixel.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size-inout-vertex.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size-invalid.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size-stages.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size-types.hlsl
create mode 100644 clang/test/SemaHLSL/vk-builtin-point-size.hlsl
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index e04196b26765f8..fff2230713d273 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -9769,9 +9769,22 @@ The attribute is only available when targeting SPIR-V. For any other target it
is ignored with an "unknown attribute ignored" warning.
The attribute takes a single string literal argument naming the built-in.
-No built-in names are supported yet: every name is currently rejected with an
-error. Supported built-in names are added incrementally, each landing together
-with its own type/stage validation and CodeGen support.
+Currently supported built-ins:
+
+* `PointSize`: the GLSL equivalent is `gl_PointSize`. Must be of floating-point
+ type. Can be used as a vertex shader output, a hull or domain shader control
+ point input or output, a geometry shader input or output, a pixel shader
+ input, or a mesh shader output.
+
+A declaration annotated with `[[vk::builtin]]` does not take part in
+`vk::location` assignment, and cannot also be annotated with `[[vk::location]]`.
+
+```c++
+struct VSOutput {
+ [[vk::location(0)]] float4 color : COLOR;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+```
}];
}
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 5655e0071eb232..2fa83da4e47450 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -13845,6 +13845,10 @@ def err_hlsl_semantic_partial_explicit_indexing
def err_hlsl_vk_builtin_unsupported_value
: Error<"'%0' is not a supported value for the 'vk::builtin' attribute; "
"supported values are: %1">;
+def err_hlsl_vk_builtin_wrong_type
+ : Error<"'%0' builtin must be of type %1">;
+def err_hlsl_vk_builtin_wrong_stage
+ : Error<"'%0' builtin cannot be used as %1 shader %2">;
def warn_hlsl_user_defined_type_missing_member: Warning<"binding type '%select{t|u|b|s|c}0' only applies to types containing %select{SRV resources|UAV resources|constant buffer resources|sampler state|numeric types}0">, InGroup<LegacyConstantRegisterBinding>;
def err_hlsl_binding_type_mismatch: Error<"binding type '%select{t|u|b|s|c}0' only applies to %select{SRV resources|UAV resources|constant buffer resources|sampler state|numeric variables in the global scope}0">;
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index e65ada1ee8100e..e9a105f2cadc66 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -37,6 +37,7 @@
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringSwitch.h"
#include "llvm/Frontend/HLSL/HLSLResource.h"
#include "llvm/Frontend/HLSL/RootSignatureMetadata.h"
#include "llvm/Frontend/HLSL/SemanticSignaturePacking.h"
@@ -1786,6 +1787,18 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
"Load hasn't been implemented yet for this system semantic. FIXME");
}
+// Maps a [[vk::builtin(...)]] name to its SPIR-V spec `BuiltIn` decoration.
+// Deliberately not creating dependency on llvm::SPIRV::BuiltIn in front end.
+// Sema's handleVkBuiltInAttr only allows names handled here to reach CodeGen.
+static unsigned getSPIRVVkBuiltinID(StringRef BuiltIn) {
+ unsigned ID = llvm::StringSwitch<unsigned>(BuiltIn)
+ .Case("PointSize", /* BuiltIn::PointSize */ 1)
+ .Default(-1);
+ assert(ID != static_cast<unsigned>(-1) &&
+ "Sema should only allow builtin names implemented here");
+ return ID;
+}
+
void CGHLSLRuntime::emitSystemSemanticStore(
IRBuilder<> &B, llvm::Value *Source, const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
@@ -1862,6 +1875,15 @@ llvm::Value *CGHLSLRuntime::handleScalarSemanticLoad(
const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic,
SemanticSignatures &Signature, llvm::hlsl::InterpolationMode InterpMode) {
+ // [[vk::builtin(...)]] takes precedence over the recognized-semantic
+ // dispatch, so without this check they'd always be treated as an arbitrary
+ // user semantic. The attribute is only ever attached when targeting SPIR-V.
+ if (const auto *BuiltInAttr = Decl->getAttr<HLSLVkBuiltInAttr>())
+ return createSPIRVInputLoad(
+ B, CGM.getModule(), Type, Semantic->getAttrName()->getName(),
+ llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn,
+ getSPIRVVkBuiltinID(BuiltInAttr->getBuiltIn()), InterpMode);
+
std::optional<unsigned> Index = Semantic->getSemanticIndex();
llvm::dxbc::PSV::SemanticKind SemanticKind =
llvm::hlsl::getSemanticKind(Semantic->getAttrName()->getName());
@@ -1887,6 +1909,15 @@ void CGHLSLRuntime::handleScalarSemanticStore(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Value *Source,
const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic,
SemanticSignatures &Signature, llvm::hlsl::InterpolationMode InterpMode) {
+ // See the matching comment in `handleScalarSemanticLoad`
+ if (const auto *BuiltInAttr = Decl->getAttr<HLSLVkBuiltInAttr>()) {
+ createSPIRVOutputStore(
+ B, CGM.getModule(), Source, Semantic->getAttrName()->getName(),
+ llvm::hlsl::SPIRVInterfaceDecoration::BuiltIn,
+ getSPIRVVkBuiltinID(BuiltInAttr->getBuiltIn()), InterpMode);
+ return;
+ }
+
std::optional<unsigned> Index = Semantic->getSemanticIndex();
llvm::dxbc::PSV::SemanticKind SemanticKind =
llvm::hlsl::getSemanticKind(Semantic->getAttrName()->getName());
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index e1966e974f4fcb..bfb698faf5d73d 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -987,8 +987,13 @@ void SemaHLSL::ActOnTopLevelFunction(FunctionDecl *FD) {
}
static bool isVkPipelineBuiltin(const ASTContext &AstContext, FunctionDecl *FD,
+ const DeclaratorDecl *D,
HLSLAppliedSemanticAttr *Semantic,
bool IsInput) {
+ // Explicitly annotated built-ins skip location assignment
+ if (D->hasAttr<HLSLVkBuiltInAttr>())
+ return true;
+
if (AstContext.getTargetInfo().getTriple().getOS() != llvm::Triple::Vulkan)
return false;
@@ -1029,6 +1034,52 @@ static bool isVkPipelineBuiltin(const ASTContext &AstContext, FunctionDecl *FD,
}
}
+static void validateVkBuiltinUsage(Sema &S, FunctionDecl *FD,
+ const DeclaratorDecl *D,
+ const HLSLVkBuiltInAttr *Attr,
+ IOType CurrentIOType) {
+ const ASTContext &AstContext = S.getASTContext();
+ if (AstContext.getTargetInfo().getTriple().getOS() != llvm::Triple::Vulkan)
+ return;
+
+ StringRef BuiltIn = Attr->getBuiltIn();
+
+ QualType T =
+ (D == FD ? FD->getReturnType() : D->getType()).getNonReferenceType();
+ const auto *ShaderAttr = FD->getAttr<HLSLShaderAttr>();
+ assert(ShaderAttr && "Entry point has no shader attribute");
+ llvm::Triple::EnvironmentType Stage = ShaderAttr->getType();
+ bool IsIn = any(CurrentIOType & IOType::In);
+ bool IsOut = any(CurrentIOType & IOType::Out);
+
+ if (BuiltIn == "PointSize") {
+ if (!T->isFloatingType())
+ S.Diag(Attr->getLocation(), diag::err_hlsl_vk_builtin_wrong_type)
+ << BuiltIn << S.getASTContext().FloatTy;
+
+ // PointSize is a per-vertex value, so patch-constant (hull/domain)
+ // and per-primitive (mesh) data never carries it.
+ // Note: Sema does not set this bit yet.
+ bool IsPatchConstantOrPrimitive =
+ any(CurrentIOType & IOType::PatchConstantOrPrimitive);
+ bool LegalStage =
+ !IsPatchConstantOrPrimitive &&
+ ((Stage == llvm::Triple::Vertex && IsOut) ||
+ Stage == llvm::Triple::Hull || Stage == llvm::Triple::Domain ||
+ Stage == llvm::Triple::Geometry ||
+ (Stage == llvm::Triple::Pixel && IsIn) ||
+ (Stage == llvm::Triple::Mesh && IsOut));
+ if (!LegalStage) {
+ StringRef IOTypeName = (IsIn && IsOut) ? "inputs and outputs"
+ : IsIn ? "inputs"
+ : "outputs";
+ S.Diag(Attr->getLocation(), diag::err_hlsl_vk_builtin_wrong_stage)
+ << BuiltIn << llvm::Triple::getEnvironmentTypeName(Stage)
+ << IOTypeName;
+ }
+ }
+}
+
bool SemaHLSL::determineActiveSemanticOnScalar(FunctionDecl *FD,
DeclaratorDecl *OutputDecl,
DeclaratorDecl *D,
@@ -1076,8 +1127,14 @@ bool SemaHLSL::determineActiveSemanticOnScalar(FunctionDecl *FD,
unsigned Location = ActiveSemantic.Index.value_or(0);
- if (!isVkPipelineBuiltin(getASTContext(), FD, A,
- any(SC.CurrentIOType & IOType::In))) {
+ bool IsBuiltin = isVkPipelineBuiltin(getASTContext(), FD, D, A,
+ any(SC.CurrentIOType & IOType::In));
+ if (IsBuiltin) {
+ if (const auto *BuiltInAttr = D->getAttr<HLSLVkBuiltInAttr>())
+ validateVkBuiltinUsage(SemaRef, FD, D, BuiltInAttr, SC.CurrentIOType);
+ }
+
+ if (!IsBuiltin) {
bool HasVkLocation = false;
if (auto *A = D->getAttr<HLSLVkLocationAttr>()) {
HasVkLocation = true;
@@ -2241,6 +2298,15 @@ void SemaHLSL::handleVkLocationAttr(Decl *D, const ParsedAttr &AL) {
if (!SemaRef.checkUInt32Argument(AL, AL.getArgAsExpr(0), Location))
return;
+ // vk::builtin and vk::location mutually exclusive
+ if (const auto *BuiltIn = D->getAttr<HLSLVkBuiltInAttr>()) {
+ Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
+ << AL << BuiltIn
+ << (AL.isRegularKeywordAttribute() ||
+ BuiltIn->isRegularKeywordAttribute());
+ Diag(BuiltIn->getLocation(), diag::note_conflicting_attribute);
+ }
+
D->addAttr(::new (getASTContext())
HLSLVkLocationAttr(getASTContext(), AL, Location));
}
@@ -2251,24 +2317,30 @@ void SemaHLSL::handleVkBuiltInAttr(Decl *D, const ParsedAttr &AL) {
if (!SemaRef.checkStringLiteralArgumentAttr(AL, 0, BuiltIn, &ArgLoc))
return;
- // No built-ins are implemented yet. A name is added here together with its
- // validation and CodeGen support, so Sema never accepts a built-in that the
- // rest of the compiler ignores. Candidates: "PointSize", "HelperInvocation",
- // "BaseVertex", "BaseInstance", "DrawIndex", "DeviceIndex", "ViewportMaskNV".
- constexpr ArrayRef<StringRef> SupportedBuiltIns;
+ static constexpr StringRef SupportedBuiltIns[] = {
+ "PointSize", // TODO: uncomment build-ins as they're fully implemented
+ // "HelperInvocation", "BaseVertex", "BaseInstance",
+ // "DrawIndex", "DeviceIndex", "ViewportMaskNV",
+ };
if (!llvm::is_contained(SupportedBuiltIns, BuiltIn)) {
std::string Quoted;
llvm::raw_string_ostream OS(Quoted);
- if (SupportedBuiltIns.empty())
- OS << "none";
- else
- llvm::interleaveComma(SupportedBuiltIns, OS,
- [&](StringRef S) { OS << "'" << S << "'"; });
+ llvm::interleaveComma(SupportedBuiltIns, OS,
+ [&](StringRef S) { OS << "'" << S << "'"; });
Diag(ArgLoc, diag::err_hlsl_vk_builtin_unsupported_value)
<< BuiltIn << Quoted;
return;
}
+ // vk::builtin and vk::location mutually exclusive.
+ if (const auto *Location = D->getAttr<HLSLVkLocationAttr>()) {
+ Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
+ << AL << Location
+ << (AL.isRegularKeywordAttribute() ||
+ Location->isRegularKeywordAttribute());
+ Diag(Location->getLoc(), diag::note_conflicting_attribute);
+ }
+
D->addAttr(::new (getASTContext())
HLSLVkBuiltInAttr(getASTContext(), AL, BuiltIn));
}
diff --git a/clang/test/AST/HLSL/vk-builtin-attr.hlsl b/clang/test/AST/HLSL/vk-builtin-attr.hlsl
new file mode 100644
index 00000000000000..16d42a0b136374
--- /dev/null
+++ b/clang/test/AST/HLSL/vk-builtin-attr.hlsl
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -triple spirv-unknown-vulkan1.3-library -finclude-default-header -ast-dump -o - %s | FileCheck %s -check-prefixes=CHECK,SPV
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.8-library -finclude-default-header -ast-dump -o - %s | FileCheck %s -check-prefixes=CHECK,DXIL
+
+// vk::builtin only exists when targeting SPIR-V.
+
+// CHECK: CXXRecordDecl {{.*}} struct S definition
+// CHECK: FieldDecl {{.*}} a 'float'
+// SPV-NEXT: HLSLVkBuiltInAttr {{.*}} "PointSize"
+// DXIL-NOT: HLSLVkBuiltInAttr
+// CHECK: HLSLParsedSemanticAttr {{.*}} "PSIZE"
+// CHECK: FieldDecl {{.*}} b 'float'
+// CHECK-NEXT: HLSLVkLocationAttr {{.*}} 1
+// CHECK-NEXT: HLSLParsedSemanticAttr {{.*}} "B"
+struct S {
+ [[vk::builtin("PointSize")]] float a : PSIZE;
+ [[vk::location(1)]] float b : B;
+};
+
+// CHECK: FunctionDecl {{.*}} param 'float (float)'
+// CHECK-NEXT: ParmVarDecl {{.*}} p 'float'
+// SPV-NEXT: HLSLVkBuiltInAttr {{.*}} "PointSize"
+// DXIL-NOT: HLSLVkBuiltInAttr
+// CHECK: HLSLParsedSemanticAttr {{.*}} "PSIZE"
+float param([[vk::builtin("PointSize")]] float p : PSIZE) : A { return p; }
+
+// CHECK: FunctionDecl {{.*}} func 'float ()'
+// SPV: HLSLVkBuiltInAttr {{.*}} "PointSize"
+// DXIL-NOT: HLSLVkBuiltInAttr
+[[vk::builtin("PointSize")]] float func() : PSIZE { return 1.0f; }
diff --git a/clang/test/CodeGenHLSL/vk-builtin-point-size-return.hlsl b/clang/test/CodeGenHLSL/vk-builtin-point-size-return.hlsl
new file mode 100644
index 00000000000000..2e999f3226b311
--- /dev/null
+++ b/clang/test/CodeGenHLSL/vk-builtin-point-size-return.hlsl
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry main -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s
+
+// Same as vk-builtin-point-size.hlsl, but [[vk::builtin("PointSize")]]
+// annotates the entry point's return value (the Function subject) rather
+// than a struct field.
+
+[[vk::builtin("PointSize")]]
+[shader("vertex")]
+float main([[vk::location(0)]] float4 a : A) : PSIZE {
+ return a.x;
+}
+
+// CHECK: @PSIZE = {{.*}} addrspace(8) global float, !spirv.Decorations [[PSIZE_DECO:![0-9]+]]
+// CHECK: define void @main()
+// CHECK: [[PT_SIZE:%[0-9]+]] = call spir_func float @{{.*}}main{{.*}}
+// CHECK-NEXT: store float [[PT_SIZE]], ptr addrspace(8) @PSIZE
+// CHECK-DAG: [[PSIZE_DECO]] = !{[[PSIZE_OP:![0-9]+]]}
+// CHECK-DAG: [[PSIZE_OP]] = !{i32 11, i32 1}
diff --git a/clang/test/CodeGenHLSL/vk-builtin-point-size.hlsl b/clang/test/CodeGenHLSL/vk-builtin-point-size.hlsl
new file mode 100644
index 00000000000000..800662b698db73
--- /dev/null
+++ b/clang/test/CodeGenHLSL/vk-builtin-point-size.hlsl
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry main -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s
+// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.8-vertex -hlsl-entry main -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s --check-prefix=DXIL
+
+// On SPIR-V, [[vk::builtin("PointSize")]] lowers to a BuiltIn PointSize
+// decoration instead of an ordinary Location-based user semantic. The
+// attribute doesn't exist on DXIL, so there PSIZE is an ordinary semantic.
+
+struct VSOutput {
+ float4 pos : SV_Position;
+ float4 color : COLOR;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+
+[shader("vertex")]
+VSOutput main() {
+ VSOutput output;
+ output.pos = float4(0, 0, 0, 1);
+ output.color = float4(1, 1, 1, 1);
+ output.size = 1.0;
+ return output;
+}
+
+// CHECK: @COLOR0 = {{.*}}!spirv.Decorations ![[COLOR_MD:[0-9]+]]
+// CHECK: @PSIZE = {{.*}}addrspace(8){{.*}}!spirv.Decorations ![[PSIZE_MD:[0-9]+]]
+// CHECK: define void @main()
+// CHECK: store float %{{.*}}, ptr addrspace(8) @PSIZE
+
+// BuiltIn decoration (11) with value 1 (PointSize), vs. COLOR0's Location (30).
+// CHECK: ![[COLOR_MD]] = !{![[COLOR_DEC:[0-9]+]]}
+// CHECK: ![[COLOR_DEC]] = !{i32 30,
+// CHECK: ![[PSIZE_MD]] = !{![[PSIZE_DEC:[0-9]+]]}
+// CHECK: ![[PSIZE_DEC]] = !{i32 11, i32 1}
+
+// DXIL: define void @main()
+// DXIL-NOT: PointSize
+// DXIL: !{{[0-9]+}} = !{i32 {{[0-9]+}}, !"PSIZE",
diff --git a/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-control.hlsl b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-control.hlsl
new file mode 100644
index 00000000000000..77079ae318970b
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-control.hlsl
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-unknown-vulkan1.3-vertex -hlsl-entry main1 -fsyntax-only -verify -verify-ignore-unexpected=note %s
+
+// Control for semantic.explicit-mix-vk-builtin-field.hlsl: without the
+// vk::builtin attribute, the same struct shape is still rejected.
+struct VSOutput {
+ [[vk::location(0)]] float4 color : COLOR;
+ float size : PSIZE;
+ // expected-error at -1 {{partial explicit stage input location assignment via vk::location(X) unsupported}}
+};
+
+[shader("vertex")]
+VSOutput main1() {
+ VSOutput output = (VSOutput)0;
+ return output;
+}
diff --git a/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-field.hlsl b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-field.hlsl
new file mode 100644
index 00000000000000..7b872a7bca662d
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-field.hlsl
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-unknown-vulkan1.3-vertex -hlsl-entry main1 -fsyntax-only -verify %s
+
+// vk::builtin fields are exempt from the "all or nothing" explicit-location
+// check, so they can be mixed with vk::location annotated fields.
+struct VSOutput {
+ [[vk::location(0)]] float4 color : COLOR;
+ [[vk::location(1)]] float2 uv : TEXCOORD0;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+ [[vk::location(2)]] float other : TEXCOORD1;
+};
+
+[shader("vertex")]
+VSOutput main1() {
+ VSOutput output;
+ output.color = float4(1, 1, 1, 1);
+ output.uv = float2(0, 0);
+ output.size = 1.0;
+ output.other = 0.0;
+ return output;
+}
+
+// expected-no-diagnostics
diff --git a/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-param.hlsl b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-param.hlsl
new file mode 100644
index 00000000000000..3330d9e447924f
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-param.hlsl
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-unknown-vulkan1.3-pixel -hlsl-entry main1 -fsyntax-only -verify %s
+
+// Same as semantic.explicit-mix-vk-builtin-field.hlsl, but for a vk::builtin
+// annotated entry-point parameter instead of a struct field.
+// SPIRV-VAL-SKIP: PointSize as a pixel shader input is accepted by Sema, but
+// Vulkan (VUID-PointSize-PointSize-04314) only allows BuiltIn PointSize in
+// vertex, tessellation and geometry stages, so spirv-val rejects the module.
+[shader("pixel")]
+float4 main1([[vk::location(0)]] float4 a : A,
+ [[vk::builtin("PointSize")]] float size : PSIZE) : SV_Target {
+ return a * size;
+}
+
+// expected-no-diagnostics
diff --git a/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-return.hlsl b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-return.hlsl
new file mode 100644
index 00000000000000..476f70829a3af0
--- /dev/null
+++ b/clang/test/SemaHLSL/Semantics/semantic.explicit-mix-vk-builtin-return.hlsl
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-unknown-vulkan1.3-vertex -hlsl-entry main1 -fsyntax-only -verify %s
+
+// Same as semantic.explicit-mix-vk-builtin-field.hlsl, but vk::builtin
+// annotates the entry point's return value (the Function subject), mixed
+// with an explicit output location on an `out` parameter.
+// SPIRV-VAL-SKIP: the out entry parameter is not supported by clang's SPIR-V
+// CodeGen yet (llvm_unreachable "Not handled yet" in CGHLSLRuntime.cpp for
+// parameters with HLSLParamModifierAttr). This test only covers Sema.
+[[vk::builtin("PointSize")]]
+[shader("vertex")]
+float main1(
+ [[vk::location(0)]] float4 a : A, [[vk::location(1)]] out float4 b : B) : PSIZE {
+ b = a;
+ return a.x;
+}
+
+// expected-no-diagnostics
diff --git a/clang/test/SemaHLSL/vk-builtin-attr.hlsl b/clang/test/SemaHLSL/vk-builtin-attr.hlsl
index da1089e00f4877..a330bf19e7a716 100644
--- a/clang/test/SemaHLSL/vk-builtin-attr.hlsl
+++ b/clang/test/SemaHLSL/vk-builtin-attr.hlsl
@@ -1,40 +1,40 @@
// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-compute -verify %s
-// No built-in names are supported yet, so every name is rejected. Only the
-// paths that reject the attribute are exercised here.
+// Valid subjects: field, parameter, function.
+struct Valid {
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+
+float param([[vk::builtin("PointSize")]] float size : PSIZE) : A { return size; }
+
+[[vk::builtin("PointSize")]] float func() : PSIZE { return 1.0f; }
// Invalid subjects.
// expected-error at +1 {{'vk::builtin' attribute only applies to parameters, non-static data members, and functions}}
-[[vk::builtin("Bogus")]] static float global_var;
+[[vk::builtin("PointSize")]] static float global_var;
// expected-error at +1 {{'vk::builtin' attribute only applies to parameters, non-static data members, and functions}}
-[[vk::builtin("Bogus")]] cbuffer InvalidCBuffer {
+[[vk::builtin("PointSize")]] cbuffer InvalidCBuffer {
float cb;
}
-// Unsupported built-in name on each valid subject kind.
+// Unsupported built-in name.
struct BadName {
- // expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ // expected-error at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: 'PointSize'}}
[[vk::builtin("Bogus")]] float a : A;
// The name is case sensitive.
- // expected-error-re at +1 {{'pointsize' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ // expected-error at +1 {{'pointsize' is not a supported value for the 'vk::builtin' attribute; supported values are: 'PointSize'}}
[[vk::builtin("pointsize")]] float b : B;
- // expected-error-re at +1 {{'' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ // expected-error at +1 {{'' is not a supported value for the 'vk::builtin' attribute; supported values are: 'PointSize'}}
[[vk::builtin("")]] float c : C;
};
-// expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
-float param([[vk::builtin("Bogus")]] float size : S) : A { return size; }
-
-// expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
-[[vk::builtin("Bogus")]] float func() : F { return 1.0f; }
-
// Wrong argument count and type.
struct BadArgs {
// expected-error at +1 {{'vk::builtin' attribute takes one argument}}
[[vk::builtin()]] float a : A;
// expected-error at +1 {{'vk::builtin' attribute takes one argument}}
- [[vk::builtin("Bogus", "Bogus")]] float b : B;
+ [[vk::builtin("PointSize", "PointSize")]] float b : B;
// expected-error at +1 {{expected string literal as argument of 'builtin' attribute}}
[[vk::builtin(5)]] float c : C;
};
@@ -42,11 +42,26 @@ struct BadArgs {
// Templates: the argument is a string literal, so it is validated when the
// template is declared, not when it is instantiated.
template <typename T> struct Templated {
- // expected-error-re at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: {{.*}}}}
+ // expected-error at +1 {{'Bogus' is not a supported value for the 'vk::builtin' attribute; supported values are: 'PointSize'}}
[[vk::builtin("Bogus")]] T a : A;
+ [[vk::builtin("PointSize")]] T b : PSIZE;
};
Templated<float> TemplatedInstance;
+// Combining `vk::builtin` and `vk::location` is rejected, whatever the order.
+struct Combined {
+ // expected-error at +2 {{'vk::location' and 'vk::builtin' attributes are not compatible}}
+ // expected-note at +1 {{conflicting attribute is here}}
+ [[vk::builtin("PointSize")]] [[vk::location(1)]] float a : A;
+ // expected-error at +2 {{'vk::builtin' and 'vk::location' attributes are not compatible}}
+ // expected-note at +1 {{conflicting attribute is here}}
+ [[vk::location(2)]] [[vk::builtin("PointSize")]] float b : B;
+};
+
+// expected-error at +2 {{'vk::location' and 'vk::builtin' attributes are not compatible}}
+// expected-note at +1 {{conflicting attribute is here}}
+[[vk::builtin("PointSize")]] [[vk::location(0)]] float func_combined() : A;
+
[shader("compute")]
[numthreads(1, 1, 1)]
void main() {}
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size-inout-pixel.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size-inout-pixel.hlsl
new file mode 100644
index 00000000000000..3fc454105e90d3
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size-inout-pixel.hlsl
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-pixel -hlsl-entry ps -fsyntax-only -verify %s
+
+// PointSize is only legal as a pixel shader input, never an output. An
+// `inout` parameter is currently treated as output-only here, so this is
+// rejected (see the sibling vk-builtin-point-size-inout-vertex.hlsl, where
+// `inout` on a stage where PointSize is a legal output is accepted).
+
+[shader("pixel")]
+float4 ps([[vk::builtin("PointSize")]] inout float size : PSIZE) : SV_Target {
+ // expected-error at -1 {{semantic 'PSIZE' is not supported in pixel shader outputs}}
+ // expected-error at -2 {{'PointSize' builtin cannot be used as pixel shader outputs}}
+ size *= 2.0;
+ return float4(size, 0, 0, 1);
+}
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size-inout-vertex.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size-inout-vertex.hlsl
new file mode 100644
index 00000000000000..05d3dd1b2448d1
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size-inout-vertex.hlsl
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs -fsyntax-only -verify %s
+
+// An `inout` PointSize parameter on a vertex shader is accepted, same as
+// plain `out` (see the sibling vk-builtin-point-size-inout-pixel.hlsl for a
+// stage where `inout`'s current treatment as output-only changes the
+// outcome).
+
+// SPIRV-VAL-SKIP: inout entry parameters are not supported by clang's SPIR-V
+// CodeGen yet (llvm_unreachable "Not handled yet" in CGHLSLRuntime.cpp). This
+// test only covers Sema.
+[shader("vertex")]
+float4 vs([[vk::builtin("PointSize")]] inout float size : PSIZE) : SV_Position {
+ size *= 2.0;
+ return float4(0, 0, 0, 1);
+}
+
+// expected-no-diagnostics
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size-invalid.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size-invalid.hlsl
new file mode 100644
index 00000000000000..cc7d5cbd1b4858
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size-invalid.hlsl
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry main -fsyntax-only -verify %s
+
+// A single decl can violate multiple PointSize rules at once -- combined
+// with vk::location, wrong type, and wrong stage -- and all diagnostics
+// fire together rather than short-circuiting on the first.
+float main([[vk::location(5), vk::builtin("PointSize")]] int input : A) : B {
+ // expected-error at -1 {{'vk::builtin' and 'vk::location' attributes are not compatible}}
+ // expected-note at -2 {{conflicting attribute is here}}
+ // expected-error at -3 {{'PointSize' builtin must be of type 'float'}}
+ // expected-error at -4 {{'PointSize' builtin cannot be used as vertex shader inputs}}
+ return (float)input;
+}
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size-stages.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size-stages.hlsl
new file mode 100644
index 00000000000000..c17e96b0dd42f5
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size-stages.hlsl
@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_ok -fsyntax-only -verify -DCASE_VS_OUT_OK %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_err -fsyntax-only -verify -DCASE_VS_IN_ERR %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-pixel -hlsl-entry ps_in -fsyntax-only -verify -DCASE_PS_IN %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-pixel -hlsl-entry ps_out -fsyntax-only -verify -DCASE_PS_OUT %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-compute -hlsl-entry cs -fsyntax-only -verify -DCASE_CS %s
+
+// PointSize is legal as a vertex shader output and a pixel shader input;
+// vertex shader input, pixel shader output and compute are not.
+
+#ifdef CASE_VS_OUT_OK
+// expected-no-diagnostics
+// Vertex output is the only legal vertex position.
+struct Out {
+ float4 pos : SV_Position;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+[shader("vertex")] Out vs_ok() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_VS_IN_ERR
+// expected-error at +1 {{'PointSize' builtin cannot be used as vertex shader inputs}}
+float4 vs_err([[vk::builtin("PointSize")]] float size : PSIZE) : SV_Position {
+ return size;
+}
+#endif
+
+#ifdef CASE_PS_IN
+// expected-no-diagnostics
+float4 ps_in([[vk::builtin("PointSize")]] float size : PSIZE) : SV_Target {
+ return size;
+}
+#endif
+
+#ifdef CASE_PS_OUT
+struct Out {
+ float4 c : SV_Target;
+ // PSIZE is also not a valid pixel shader output semantic.
+ // expected-error at +2 {{semantic 'PSIZE' is not supported in pixel shader outputs}}
+ // expected-error at +1 {{'PointSize' builtin cannot be used as pixel shader outputs}}
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+[shader("pixel")] Out ps_out() { Out o; o.c = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_CS
+[numthreads(1, 1, 1)]
+// expected-error at +2 {{semantic 'PSIZE' is not supported in compute shader inputs}}
+// expected-error at +1 {{'PointSize' builtin cannot be used as compute shader inputs}}
+void cs([[vk::builtin("PointSize")]] float size : PSIZE) {}
+#endif
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size-types.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size-types.hlsl
new file mode 100644
index 00000000000000..3a5b53762e8f1b
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size-types.hlsl
@@ -0,0 +1,63 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_float -fsyntax-only -verify -DCASE_FLOAT %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_half -fsyntax-only -verify -DCASE_HALF %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_double -fsyntax-only -verify -DCASE_DOUBLE %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_vector -fsyntax-only -verify -DCASE_VECTOR %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_int -fsyntax-only -verify -DCASE_INT %s
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry vs_bool -fsyntax-only -verify -DCASE_BOOL %s
+
+// PointSize accepts any scalar floating-point type, and rejects everything
+// else (vectors, integers, bool).
+
+#ifdef CASE_FLOAT
+// expected-no-diagnostics
+struct Out {
+ float4 pos : SV_Position;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+[shader("vertex")] Out vs_float() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_HALF
+// expected-no-diagnostics
+struct Out {
+ float4 pos : SV_Position;
+ [[vk::builtin("PointSize")]] half size : PSIZE;
+};
+[shader("vertex")] Out vs_half() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_DOUBLE
+// expected-no-diagnostics
+struct Out {
+ float4 pos : SV_Position;
+ [[vk::builtin("PointSize")]] double size : PSIZE;
+};
+[shader("vertex")] Out vs_double() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_VECTOR
+struct Out {
+ float4 pos : SV_Position;
+ // expected-error at +1 {{'PointSize' builtin must be of type 'float'}}
+ [[vk::builtin("PointSize")]] float2 size : PSIZE;
+};
+[shader("vertex")] Out vs_vector() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_INT
+struct Out {
+ float4 pos : SV_Position;
+ // expected-error at +1 {{'PointSize' builtin must be of type 'float'}}
+ [[vk::builtin("PointSize")]] int size : PSIZE;
+};
+[shader("vertex")] Out vs_int() { Out o; o.pos = 0; o.size = 1; return o; }
+#endif
+
+#ifdef CASE_BOOL
+struct Out {
+ float4 pos : SV_Position;
+ // expected-error at +1 {{'PointSize' builtin must be of type 'float'}}
+ [[vk::builtin("PointSize")]] bool size : PSIZE;
+};
+[shader("vertex")] Out vs_bool() { Out o; o.pos = 0; o.size = true; return o; }
+#endif
diff --git a/clang/test/SemaHLSL/vk-builtin-point-size.hlsl b/clang/test/SemaHLSL/vk-builtin-point-size.hlsl
new file mode 100644
index 00000000000000..bdb6a9a7e1cf79
--- /dev/null
+++ b/clang/test/SemaHLSL/vk-builtin-point-size.hlsl
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -finclude-default-header -triple spirv-pc-vulkan1.3-vertex -hlsl-entry legal -fsyntax-only -verify %s
+
+// PointSize must be a float, and is only legal as a vertex shader output
+// (plus other stages not exercised here).
+struct Out {
+ float4 pos : SV_Position;
+ [[vk::builtin("PointSize")]] float size : PSIZE;
+};
+
+[shader("vertex")]
+Out legal([[vk::location(0)]] float4 a : A) {
+ Out o;
+ o.pos = a;
+ o.size = a.x;
+ return o;
+}
+
+// expected-no-diagnostics
More information about the cfe-commits
mailing list