https://github.com/Keenuts updated
https://github.com/llvm/llvm-project/pull/159047
From 445bdafaa7b32b6154f3e7a414463818d90ee20a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nathan=20Gau=C3=ABr?= <brio...@google.com>
Date: Tue, 12 Aug 2025 18:06:17 +0200
Subject: [PATCH 1/4] [HLSL] Add support for input semantics in structs
This commit adds the support for semantics annotations on structs, but
only for inputs. Due to the current semantics implemented, we cannot
test much more than nesting/shadowing.
Once user semantics are implemented, we'll be able to test arrays in
structs and more complex cases.
As-is, this commit has one weakness vs DXC: semantics type validation is
not looking at the inner-most type, but the outermost type:
```hlsl
struct Inner {
uint tid;
};
Inner inner : SV_GroupID
```
This sample would fail today because `SV_GroupID` require the type to be
an integer. This works in DXC as the inner type is a integer.
Because GroupIndex is not correctly validated, I uses this semantic to
test the inheritance/shadowing. But this will need to be fixed in a
later commit.
Requires #152537
---
.../clang/Basic/DiagnosticFrontendKinds.td | 2 +
clang/lib/CodeGen/CGHLSLRuntime.cpp | 63 ++++++++++++++++++-
clang/lib/CodeGen/CGHLSLRuntime.h | 4 ++
.../semantics/semantic-struct-1.hlsl | 23 +++++++
.../semantics/semantic-struct-2.hlsl | 25 ++++++++
.../semantic-struct-nested-inherit.hlsl | 30 +++++++++
.../semantic-struct-nested-shadow.hlsl | 30 +++++++++
.../semantics/semantic-struct-nested.hlsl | 30 +++++++++
8 files changed, 204 insertions(+), 3 deletions(-)
create mode 100644 clang/test/CodeGenHLSL/semantics/semantic-struct-1.hlsl
create mode 100644 clang/test/CodeGenHLSL/semantics/semantic-struct-2.hlsl
create mode 100644
clang/test/CodeGenHLSL/semantics/semantic-struct-nested-inherit.hlsl
create mode 100644
clang/test/CodeGenHLSL/semantics/semantic-struct-nested-shadow.hlsl
create mode 100644 clang/test/CodeGenHLSL/semantics/semantic-struct-nested.hlsl
diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index 2fd2ae434d7c5..6c5a92c63d25a 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -404,6 +404,8 @@ def err_hlsl_semantic_missing : Error<"semantic annotations
must be present "
"for all input and outputs of an entry "
"function or patch constant function">;
+def note_hlsl_semantic_used_here : Note<"%0 used here">;
+
// ClangIR frontend errors
def err_cir_to_cir_transform_failed : Error<
"CIR-to-CIR transformation failed">, DefaultFatal;
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp
b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index afee1198e0988..7994ff83b2c21 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -632,11 +632,51 @@ CGHLSLRuntime::handleScalarSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
return emitSystemSemanticLoad(B, Type, Decl, ActiveSemantic);
}
+llvm::Value *
+CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
+ const clang::DeclaratorDecl *Decl,
+ SemanticInfo &ActiveSemantic) {
+ const llvm::StructType *ST = cast<StructType>(Type);
+ const clang::RecordDecl *RD = Decl->getType()->getAsRecordDecl();
+
+ assert(std::distance(RD->field_begin(), RD->field_end()) ==
+ ST->getNumElements());
+
+ if (!ActiveSemantic.Semantic) {
+ ActiveSemantic.Semantic = Decl->getAttr<HLSLSemanticAttr>();
+ ActiveSemantic.Index = ActiveSemantic.Semantic
+ ? ActiveSemantic.Semantic->getSemanticIndex()
+ : 0;
+ }
+
+ llvm::Value *Aggregate = llvm::PoisonValue::get(Type);
+ auto FieldDecl = RD->field_begin();
+ for (unsigned I = 0; I < ST->getNumElements(); ++I) {
+ SemanticInfo Info = ActiveSemantic;
+ llvm::Value *ChildValue =
+ handleSemanticLoad(B, ST->getElementType(I), *FieldDecl, Info);
+ if (!ChildValue) {
+ CGM.getDiags().Report(Decl->getInnerLocStart(),
+ diag::note_hlsl_semantic_used_here)
+ << Decl;
+ return nullptr;
+ }
+ if (ActiveSemantic.Semantic)
+ ActiveSemantic = Info;
+
+ Aggregate = B.CreateInsertValue(Aggregate, ChildValue, I);
+ ++FieldDecl;
+ }
+
+ return Aggregate;
+}
+
llvm::Value *
CGHLSLRuntime::handleSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
SemanticInfo &ActiveSemantic) {
- assert(!Type->isStructTy());
+ if (Type->isStructTy())
+ return handleStructSemanticLoad(B, Type, Decl, ActiveSemantic);
return handleScalarSemanticLoad(B, Type, Decl, ActiveSemantic);
}
@@ -684,8 +724,25 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl
*FD,
}
const ParmVarDecl *PD = FD->getParamDecl(Param.getArgNo() - SRetOffset);
- SemanticInfo ActiveSemantic = {nullptr, 0};
- Args.push_back(handleSemanticLoad(B, Param.getType(), PD, ActiveSemantic));
+ llvm::Value *SemanticValue = nullptr;
+ if (HLSLParamModifierAttr *MA = PD->getAttr<HLSLParamModifierAttr>()) {
+ llvm_unreachable("Not handled yet");
+ } else {
+ llvm::Type *ParamType =
+ Param.hasByValAttr() ? Param.getParamByValType() : Param.getType();
+ SemanticInfo ActiveSemantic = {nullptr, 0};
+ SemanticValue = handleSemanticLoad(B, ParamType, PD, ActiveSemantic);
+ if (!SemanticValue)
+ return;
+ if (Param.hasByValAttr()) {
+ llvm::Value *Var = B.CreateAlloca(Param.getParamByValType());
+ B.CreateStore(SemanticValue, Var);
+ SemanticValue = Var;
+ }
+ }
+
+ assert(SemanticValue);
+ Args.push_back(SemanticValue);
}
CallInst *CI = B.CreateCall(FunctionCallee(Fn), Args, OB);
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.h
b/clang/lib/CodeGen/CGHLSLRuntime.h
index 370f3d5c5d30d..a22b1c7d2031b 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.h
+++ b/clang/lib/CodeGen/CGHLSLRuntime.h
@@ -157,6 +157,10 @@ class CGHLSLRuntime {
const clang::DeclaratorDecl *Decl,
SemanticInfo &ActiveSemantic);
+ llvm::Value *handleStructSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
+ const clang::DeclaratorDecl *Decl,
+ SemanticInfo &ActiveSemantic);
+
llvm::Value *handleSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
SemanticInfo &ActiveSemantic);
diff --git a/clang/test/CodeGenHLSL/semantics/semantic-struct-1.hlsl
b/clang/test/CodeGenHLSL/semantics/semantic-struct-1.hlsl
new file mode 100644
index 0000000000000..ddd0baed41f37
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/semantic-struct-1.hlsl
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-DXIL -DTARGET=dx
+// RUN: %clang_cc1 -triple spirv-linux-vulkan-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-SPIRV -DTARGET=spv
+
+
+struct Input {
+ uint Idx : SV_DispatchThreadID;
+
+};
+
+// Make sure SV_DispatchThreadID translated into dx.thread.id.
+
+// CHECK: define void @foo()
+// CHECK-DXIL: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id(i32 0)
+// CHECK-SPIRV: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id.i32(i32 0)
+// CHECK: %[[#TMP:]] = insertvalue %struct.Input poison, i32 %[[#ID]], 0
+// CHECK: %[[#VAR:]] = alloca %struct.Input, align 8
+// CHECK: store %struct.Input %[[#TMP]], ptr %[[#VAR]],
align 4
+// CHECK-DXIL: call void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+// CHECK-SPIRV: call spir_func void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+[shader("compute")]
+[numthreads(8,8,1)]
+void foo(Input input) {}
+
diff --git a/clang/test/CodeGenHLSL/semantics/semantic-struct-2.hlsl
b/clang/test/CodeGenHLSL/semantics/semantic-struct-2.hlsl
new file mode 100644
index 0000000000000..0d9c91e746454
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/semantic-struct-2.hlsl
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-DXIL -DTARGET=dx
+// RUN: %clang_cc1 -triple spirv-linux-vulkan-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-SPIRV -DTARGET=spv
+
+
+struct Input {
+ uint Idx : SV_DispatchThreadID;
+ uint Gid : SV_GroupID;
+};
+
+// Make sure SV_DispatchThreadID translated into dx.thread.id.
+
+// CHECK: define void @foo()
+// CHECK-DXIL: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id(i32 0)
+// CHECK-SPIRV: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id.i32(i32 0)
+// CHECK: %[[#TMP1:]] = insertvalue %struct.Input poison, i32 %[[#ID]], 0
+// CHECK-DXIL: %[[#GID:]] = call i32 @llvm.[[TARGET]].group.id(i32 0)
+// CHECK-SPIRV:%[[#GID:]] = call i32 @llvm.[[TARGET]].group.id.i32(i32 0)
+// CHECK: %[[#TMP2:]] = insertvalue %struct.Input %[[#TMP1]], i32
%[[#GID]], 1
+// CHECK: %[[#VAR:]] = alloca %struct.Input, align 8
+// CHECK: store %struct.Input %[[#TMP2]], ptr %[[#VAR]],
align 4
+// CHECK-DXIL: call void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+// CHECK-SPIRV: call spir_func void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+[shader("compute")]
+[numthreads(8,8,1)]
+void foo(Input input) {}
diff --git
a/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-inherit.hlsl
b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-inherit.hlsl
new file mode 100644
index 0000000000000..f4c4d86933ca1
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-inherit.hlsl
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-DXIL -DTARGET=dx
+// RUN: %clang_cc1 -triple spirv-linux-vulkan-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-SPIRV -DTARGET=spv
+
+
+struct Inner {
+ uint Gid;
+};
+
+struct Input {
+ uint Idx : SV_DispatchThreadID;
+ Inner inner : SV_GroupIndex;
+};
+
+// Make sure SV_DispatchThreadID translated into dx.thread.id.
+
+// CHECK: define void @foo()
+// CHECK-DXIL: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id(i32 0)
+// CHECK-SPIRV: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id.i32(i32 0)
+// CHECK: %[[#TMP1:]] = insertvalue %struct.Input poison, i32 %[[#ID]], 0
+// CHECK-DXIL: %[[#GID:]] = call i32 @llvm.dx.flattened.thread.id.in.group()
+// CHECK-SPIRV:%[[#GID:]] = call i32 @llvm.spv.flattened.thread.id.in.group()
+// CHECK: %[[#TMP2:]] = insertvalue %struct.Inner poison, i32 %[[#GID]], 0
+// CHECK: %[[#TMP3:]] = insertvalue %struct.Input %[[#TMP1]],
%struct.Inner %[[#TMP2]], 1
+// CHECK: %[[#VAR:]] = alloca %struct.Input, align 8
+// CHECK: store %struct.Input %[[#TMP3]], ptr %[[#VAR]],
align 4
+// CHECK-DXIL: call void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+// CHECK-SPIRV: call spir_func void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+[shader("compute")]
+[numthreads(8,8,1)]
+void foo(Input input) {}
diff --git
a/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-shadow.hlsl
b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-shadow.hlsl
new file mode 100644
index 0000000000000..e1344dd87a6ed
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested-shadow.hlsl
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-DXIL -DTARGET=dx
+// RUN: %clang_cc1 -triple spirv-linux-vulkan-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-SPIRV -DTARGET=spv
+
+
+struct Inner {
+ uint Gid : SV_GroupID;
+};
+
+struct Input {
+ uint Idx : SV_DispatchThreadID;
+ Inner inner : SV_GroupIndex;
+};
+
+// Make sure SV_DispatchThreadID translated into dx.thread.id.
+
+// CHECK: define void @foo()
+// CHECK-DXIL: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id(i32 0)
+// CHECK-SPIRV: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id.i32(i32 0)
+// CHECK: %[[#TMP1:]] = insertvalue %struct.Input poison, i32 %[[#ID]], 0
+// CHECK-DXIL: %[[#GID:]] = call i32 @llvm.dx.flattened.thread.id.in.group()
+// CHECK-SPIRV:%[[#GID:]] = call i32 @llvm.spv.flattened.thread.id.in.group()
+// CHECK: %[[#TMP2:]] = insertvalue %struct.Inner poison, i32 %[[#GID]], 0
+// CHECK: %[[#TMP3:]] = insertvalue %struct.Input %[[#TMP1]],
%struct.Inner %[[#TMP2]], 1
+// CHECK: %[[#VAR:]] = alloca %struct.Input, align 8
+// CHECK: store %struct.Input %[[#TMP3]], ptr %[[#VAR]],
align 4
+// CHECK-DXIL: call void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+// CHECK-SPIRV: call spir_func void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+[shader("compute")]
+[numthreads(8,8,1)]
+void foo(Input input) {}
diff --git a/clang/test/CodeGenHLSL/semantics/semantic-struct-nested.hlsl
b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested.hlsl
new file mode 100644
index 0000000000000..cd6f9460bc617
--- /dev/null
+++ b/clang/test/CodeGenHLSL/semantics/semantic-struct-nested.hlsl
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-DXIL -DTARGET=dx
+// RUN: %clang_cc1 -triple spirv-linux-vulkan-library -x hlsl -emit-llvm
-finclude-default-header -disable-llvm-passes -o - %s | FileCheck %s
--check-prefixes=CHECK,CHECK-SPIRV -DTARGET=spv
+
+
+struct Inner {
+ uint Gid : SV_GroupID;
+};
+
+struct Input {
+ uint Idx : SV_DispatchThreadID;
+ Inner inner;
+};
+
+// Make sure SV_DispatchThreadID translated into dx.thread.id.
+
+// CHECK: define void @foo()
+// CHECK-DXIL: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id(i32 0)
+// CHECK-SPIRV: %[[#ID:]] = call i32 @llvm.[[TARGET]].thread.id.i32(i32 0)
+// CHECK: %[[#TMP1:]] = insertvalue %struct.Input poison, i32 %[[#ID]], 0
+// CHECK-DXIL: %[[#GID:]] = call i32 @llvm.[[TARGET]].group.id(i32 0)
+// CHECK-SPIRV:%[[#GID:]] = call i32 @llvm.[[TARGET]].group.id.i32(i32 0)
+// CHECK: %[[#TMP2:]] = insertvalue %struct.Inner poison, i32 %[[#GID]], 0
+// CHECK: %[[#TMP3:]] = insertvalue %struct.Input %[[#TMP1]],
%struct.Inner %[[#TMP2]], 1
+// CHECK: %[[#VAR:]] = alloca %struct.Input, align 8
+// CHECK: store %struct.Input %[[#TMP3]], ptr %[[#VAR]],
align 4
+// CHECK-DXIL: call void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+// CHECK-SPIRV: call spir_func void @{{.*}}foo{{.*}}(ptr %[[#VAR]])
+[shader("compute")]
+[numthreads(8,8,1)]
+void foo(Input input) {}
From 6b55b1ef0ed256dd072db78964bef25a7beca8c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nathan=20Gau=C3=ABr?= <brio...@google.com>
Date: Tue, 9 Sep 2025 16:11:13 +0200
Subject: [PATCH 2/4] add maybe_unused on fixme location
---
clang/lib/CodeGen/CGHLSLRuntime.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp
b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 7994ff83b2c21..69d903bb6d5b7 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -725,7 +725,8 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl
*FD,
const ParmVarDecl *PD = FD->getParamDecl(Param.getArgNo() - SRetOffset);
llvm::Value *SemanticValue = nullptr;
- if (HLSLParamModifierAttr *MA = PD->getAttr<HLSLParamModifierAttr>()) {
+ if ([[maybe_unused]] HLSLParamModifierAttr *MA =
+ PD->getAttr<HLSLParamModifierAttr>()) {
llvm_unreachable("Not handled yet");
} else {
llvm::Type *ParamType =
From 29ea2a48a91b40a19f8ed210bb3f0bca8e0769b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nathan=20Gau=C3=ABr?= <brio...@google.com>
Date: Mon, 15 Sep 2025 17:57:16 +0200
Subject: [PATCH 3/4] move all diagnostics to sema
---
clang/include/clang/AST/Attr.h | 2 +
.../clang/Basic/DiagnosticFrontendKinds.td | 6 --
.../clang/Basic/DiagnosticSemaKinds.td | 1 +
clang/include/clang/Sema/SemaHLSL.h | 21 +++--
clang/lib/CodeGen/CGHLSLRuntime.cpp | 74 +++++----------
clang/lib/CodeGen/CGHLSLRuntime.h | 17 ++--
clang/lib/Sema/SemaHLSL.cpp | 90 +++++++++++++++----
7 files changed, 122 insertions(+), 89 deletions(-)
diff --git a/clang/include/clang/AST/Attr.h b/clang/include/clang/AST/Attr.h
index fe388b9fa045e..00d4a0035fccf 100644
--- a/clang/include/clang/AST/Attr.h
+++ b/clang/include/clang/AST/Attr.h
@@ -259,6 +259,8 @@ class HLSLSemanticAttr : public HLSLAnnotationAttr {
unsigned getSemanticIndex() const { return SemanticIndex; }
+ bool isSemanticIndexExplicit() const { return SemanticExplicitIndex; }
+
// Implement isa/cast/dyncast/etc.
static bool classof(const Attr *A) {
return A->getKind() >= attr::FirstHLSLSemanticAttr &&
diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index 6c5a92c63d25a..15447558cf952 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -400,12 +400,6 @@ def warn_hlsl_langstd_minimal :
"recommend using %1 instead">,
InGroup<HLSLDXCCompat>;
-def err_hlsl_semantic_missing : Error<"semantic annotations must be present "
- "for all input and outputs of an entry "
- "function or patch constant function">;
-
-def note_hlsl_semantic_used_here : Note<"%0 used here">;
-
// ClangIR frontend errors
def err_cir_to_cir_transform_failed : Error<
"CIR-to-CIR transformation failed">, DefaultFatal;
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td
b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 757404a3f5eac..6950fdd994b3d 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -13123,6 +13123,7 @@ def err_hlsl_duplicate_parameter_modifier :
Error<"duplicate parameter modifier
def err_hlsl_missing_semantic_annotation : Error<
"semantic annotations must be present for all parameters of an entry "
"function or patch constant function">;
+def note_hlsl_semantic_used_here : Note<"%0 used here">;
def err_hlsl_unknown_semantic : Error<"unknown HLSL semantic %0">;
def err_hlsl_semantic_output_not_supported
: Error<"semantic %0 does not support output">;
diff --git a/clang/include/clang/Sema/SemaHLSL.h
b/clang/include/clang/Sema/SemaHLSL.h
index b5ddca0fe2ca5..f0a940353515c 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -130,9 +130,6 @@ class SemaHLSL : public SemaBase {
bool ActOnUninitializedVarDecl(VarDecl *D);
void ActOnEndOfTranslationUnit(TranslationUnitDecl *TU);
void CheckEntryPoint(FunctionDecl *FD);
- bool isSemanticValid(FunctionDecl *FD, DeclaratorDecl *D);
- void CheckSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param,
- const HLSLAnnotationAttr *AnnotationAttr);
void DiagnoseAttrStageMismatch(
const Attr *A, llvm::Triple::EnvironmentType Stage,
std::initializer_list<llvm::Triple::EnvironmentType> AllowedStages);
@@ -177,9 +174,9 @@ class SemaHLSL : public SemaBase {
bool handleResourceTypeAttr(QualType T, const ParsedAttr &AL);
template <typename T>
- T *createSemanticAttr(const ParsedAttr &AL,
+ T *createSemanticAttr(const AttributeCommonInfo &ACI,
std::optional<unsigned> Location) {
- T *Attr = ::new (getASTContext()) T(getASTContext(), AL);
+ T *Attr = ::new (getASTContext()) T(getASTContext(), ACI);
if (Attr->isSemanticIndexable())
Attr->setSemanticIndex(Location ? *Location : 0);
else if (Location.has_value()) {
@@ -246,10 +243,24 @@ class SemaHLSL : public SemaBase {
IdentifierInfo *RootSigOverrideIdent = nullptr;
+ struct SemanticInfo {
+ HLSLSemanticAttr *Semantic;
+ std::optional<uint32_t> Index;
+ };
+
private:
void collectResourceBindingsOnVarDecl(VarDecl *D);
void collectResourceBindingsOnUserRecordDecl(const VarDecl *VD,
const RecordType *RT);
+
+ void checkSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param,
+ const HLSLSemanticAttr *SemanticAttr);
+ HLSLSemanticAttr *createSemantic(const SemanticInfo &Semantic);
+ bool isSemanticOnScalarValid(FunctionDecl *FD, DeclaratorDecl *D,
+ SemanticInfo &ActiveSemantic);
+ bool isSemanticValid(FunctionDecl *FD, DeclaratorDecl *D,
+ SemanticInfo &ActiveSemantic);
+
void processExplicitBindingsOnDecl(VarDecl *D);
void diagnoseAvailabilityViolations(TranslationUnitDecl *TU);
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp
b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 69d903bb6d5b7..c68d85ac837f3 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -566,17 +566,16 @@ static llvm::Value *createSPIRVBuiltinLoad(IRBuilder<>
&B, llvm::Module &M,
return B.CreateLoad(Ty, GV);
}
-llvm::Value *
-CGHLSLRuntime::emitSystemSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic) {
- if (isa<HLSLSV_GroupIndexAttr>(ActiveSemantic.Semantic)) {
+llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
+ IRBuilder<> &B, llvm::Type *Type, const clang::DeclaratorDecl *Decl,
+ Attr *Semantic, std::optional<unsigned> Index) {
+ if (isa<HLSLSV_GroupIndexAttr>(Semantic)) {
llvm::Function *GroupIndex =
CGM.getIntrinsic(getFlattenedThreadIdInGroupIntrinsic());
return B.CreateCall(FunctionCallee(GroupIndex));
}
- if (isa<HLSLSV_DispatchThreadIDAttr>(ActiveSemantic.Semantic)) {
+ if (isa<HLSLSV_DispatchThreadIDAttr>(Semantic)) {
llvm::Intrinsic::ID IntrinID = getThreadIdIntrinsic();
llvm::Function *ThreadIDIntrinsic =
llvm::Intrinsic::isOverloaded(IntrinID)
@@ -585,7 +584,7 @@ CGHLSLRuntime::emitSystemSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
return buildVectorInput(B, ThreadIDIntrinsic, Type);
}
- if (isa<HLSLSV_GroupThreadIDAttr>(ActiveSemantic.Semantic)) {
+ if (isa<HLSLSV_GroupThreadIDAttr>(Semantic)) {
llvm::Intrinsic::ID IntrinID = getGroupThreadIdIntrinsic();
llvm::Function *GroupThreadIDIntrinsic =
llvm::Intrinsic::isOverloaded(IntrinID)
@@ -594,7 +593,7 @@ CGHLSLRuntime::emitSystemSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
return buildVectorInput(B, GroupThreadIDIntrinsic, Type);
}
- if (isa<HLSLSV_GroupIDAttr>(ActiveSemantic.Semantic)) {
+ if (isa<HLSLSV_GroupIDAttr>(Semantic)) {
llvm::Intrinsic::ID IntrinID = getGroupIdIntrinsic();
llvm::Function *GroupIDIntrinsic =
llvm::Intrinsic::isOverloaded(IntrinID)
@@ -603,8 +602,7 @@ CGHLSLRuntime::emitSystemSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
return buildVectorInput(B, GroupIDIntrinsic, Type);
}
- if (HLSLSV_PositionAttr *S =
- dyn_cast<HLSLSV_PositionAttr>(ActiveSemantic.Semantic)) {
+ if (HLSLSV_PositionAttr *S = dyn_cast<HLSLSV_PositionAttr>(Semantic)) {
if (CGM.getTriple().getEnvironment() == Triple::EnvironmentType::Pixel)
return createSPIRVBuiltinLoad(B, CGM.getModule(), Type,
S->getAttrName()->getName(),
@@ -616,54 +614,32 @@ CGHLSLRuntime::emitSystemSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
llvm::Value *
CGHLSLRuntime::handleScalarSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic) {
-
- if (!ActiveSemantic.Semantic) {
- ActiveSemantic.Semantic = Decl->getAttr<HLSLSemanticAttr>();
- if (!ActiveSemantic.Semantic) {
- CGM.getDiags().Report(Decl->getInnerLocStart(),
- diag::err_hlsl_semantic_missing);
- return nullptr;
- }
- ActiveSemantic.Index = ActiveSemantic.Semantic->getSemanticIndex();
- }
-
- return emitSystemSemanticLoad(B, Type, Decl, ActiveSemantic);
+ const clang::DeclaratorDecl *Decl) {
+ HLSLSemanticAttr *Semantic = Decl->getAttr<HLSLSemanticAttr>();
+ // Sema either attached a semantic to each field/param, or raised an error.
+ assert(Semantic);
+
+ std::optional<unsigned> Index = std::nullopt;
+ if (Semantic->isSemanticIndexExplicit())
+ Index = Semantic->getSemanticIndex();
+ return emitSystemSemanticLoad(B, Type, Decl, Semantic, Index);
}
llvm::Value *
CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic) {
+ const clang::DeclaratorDecl *Decl) {
const llvm::StructType *ST = cast<StructType>(Type);
const clang::RecordDecl *RD = Decl->getType()->getAsRecordDecl();
assert(std::distance(RD->field_begin(), RD->field_end()) ==
ST->getNumElements());
- if (!ActiveSemantic.Semantic) {
- ActiveSemantic.Semantic = Decl->getAttr<HLSLSemanticAttr>();
- ActiveSemantic.Index = ActiveSemantic.Semantic
- ? ActiveSemantic.Semantic->getSemanticIndex()
- : 0;
- }
-
llvm::Value *Aggregate = llvm::PoisonValue::get(Type);
auto FieldDecl = RD->field_begin();
for (unsigned I = 0; I < ST->getNumElements(); ++I) {
- SemanticInfo Info = ActiveSemantic;
llvm::Value *ChildValue =
- handleSemanticLoad(B, ST->getElementType(I), *FieldDecl, Info);
- if (!ChildValue) {
- CGM.getDiags().Report(Decl->getInnerLocStart(),
- diag::note_hlsl_semantic_used_here)
- << Decl;
- return nullptr;
- }
- if (ActiveSemantic.Semantic)
- ActiveSemantic = Info;
-
+ handleSemanticLoad(B, ST->getElementType(I), *FieldDecl);
+ assert(ChildValue);
Aggregate = B.CreateInsertValue(Aggregate, ChildValue, I);
++FieldDecl;
}
@@ -673,11 +649,10 @@ CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
llvm::Value *
CGHLSLRuntime::handleSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic) {
+ const clang::DeclaratorDecl *Decl) {
if (Type->isStructTy())
- return handleStructSemanticLoad(B, Type, Decl, ActiveSemantic);
- return handleScalarSemanticLoad(B, Type, Decl, ActiveSemantic);
+ return handleStructSemanticLoad(B, Type, Decl);
+ return handleScalarSemanticLoad(B, Type, Decl);
}
void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
@@ -731,8 +706,7 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl
*FD,
} else {
llvm::Type *ParamType =
Param.hasByValAttr() ? Param.getParamByValType() : Param.getType();
- SemanticInfo ActiveSemantic = {nullptr, 0};
- SemanticValue = handleSemanticLoad(B, ParamType, PD, ActiveSemantic);
+ SemanticValue = handleSemanticLoad(B, ParamType, PD);
if (!SemanticValue)
return;
if (Param.hasByValAttr()) {
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.h
b/clang/lib/CodeGen/CGHLSLRuntime.h
index a22b1c7d2031b..039b881d2c9ee 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.h
+++ b/clang/lib/CodeGen/CGHLSLRuntime.h
@@ -144,26 +144,19 @@ class CGHLSLRuntime {
llvm::Type *Type,
SmallVectorImpl<llvm::Value *> &Inputs);
- struct SemanticInfo {
- clang::HLSLSemanticAttr *Semantic;
- uint32_t Index;
- };
-
llvm::Value *emitSystemSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic);
+ Attr *Semantic,
+ std::optional<unsigned> Index);
llvm::Value *handleScalarSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic);
+ const clang::DeclaratorDecl *Decl);
llvm::Value *handleStructSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic);
+ const clang::DeclaratorDecl *Decl);
llvm::Value *handleSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl,
- SemanticInfo &ActiveSemantic);
+ const clang::DeclaratorDecl *Decl);
public:
CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index 0af38472b0fec..ee4088d528c98 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -769,23 +769,78 @@ void SemaHLSL::ActOnTopLevelFunction(FunctionDecl *FD) {
}
}
-bool SemaHLSL::isSemanticValid(FunctionDecl *FD, DeclaratorDecl *D) {
- const auto *AnnotationAttr = D->getAttr<HLSLAnnotationAttr>();
- if (AnnotationAttr) {
- CheckSemanticAnnotation(FD, D, AnnotationAttr);
- return true;
+HLSLSemanticAttr *SemaHLSL::createSemantic(const SemanticInfo &Info) {
+ std::string SemanticName = Info.Semantic->getAttrName()->getName().upper();
+
+ if (SemanticName == "SV_DISPATCHTHREADID") {
+ return createSemanticAttr<HLSLSV_DispatchThreadIDAttr>(*Info.Semantic,
+ Info.Index);
+ } else if (SemanticName == "SV_GROUPINDEX") {
+ return createSemanticAttr<HLSLSV_GroupIndexAttr>(*Info.Semantic,
+ Info.Index);
+ } else if (SemanticName == "SV_GROUPTHREADID") {
+ return createSemanticAttr<HLSLSV_GroupThreadIDAttr>(*Info.Semantic,
+ Info.Index);
+ } else if (SemanticName == "SV_GROUPID") {
+ return createSemanticAttr<HLSLSV_GroupIDAttr>(*Info.Semantic, Info.Index);
+ } else if (SemanticName == "SV_POSITION") {
+ return createSemanticAttr<HLSLSV_PositionAttr>(*Info.Semantic, Info.Index);
+ } else
+ Diag(Info.Semantic->getLoc(), diag::err_hlsl_unknown_semantic)
+ << *Info.Semantic;
+
+ return nullptr;
+}
+
+bool SemaHLSL::isSemanticOnScalarValid(FunctionDecl *FD, DeclaratorDecl *D,
+ SemanticInfo &ActiveSemantic) {
+ if (ActiveSemantic.Semantic == nullptr) {
+ ActiveSemantic.Semantic = D->getAttr<HLSLSemanticAttr>();
+ if (ActiveSemantic.Semantic &&
+ ActiveSemantic.Semantic->isSemanticIndexExplicit())
+ ActiveSemantic.Index = ActiveSemantic.Semantic->getSemanticIndex();
+ }
+
+ if (!ActiveSemantic.Semantic) {
+ Diag(D->getLocation(), diag::err_hlsl_missing_semantic_annotation);
+ return false;
+ }
+
+ auto *A = createSemantic(ActiveSemantic);
+ if (!A)
+ return false;
+
+ checkSemanticAnnotation(FD, D, A);
+ D->dropAttrs<HLSLSemanticAttr>();
+ D->addAttr(A);
+ return true;
+}
+
+bool SemaHLSL::isSemanticValid(FunctionDecl *FD, DeclaratorDecl *D,
+ SemanticInfo &ActiveSemantic) {
+ if (ActiveSemantic.Semantic == nullptr) {
+ ActiveSemantic.Semantic = D->getAttr<HLSLSemanticAttr>();
+ if (ActiveSemantic.Semantic &&
+ ActiveSemantic.Semantic->isSemanticIndexExplicit())
+ ActiveSemantic.Index = ActiveSemantic.Semantic->getSemanticIndex();
}
const Type *T = D->getType()->getUnqualifiedDesugaredType();
const RecordType *RT = dyn_cast<RecordType>(T);
if (!RT)
- return false;
+ return isSemanticOnScalarValid(FD, D, ActiveSemantic);
const RecordDecl *RD = RT->getOriginalDecl();
for (FieldDecl *Field : RD->fields()) {
- if (!isSemanticValid(FD, Field))
+ SemanticInfo Info = ActiveSemantic;
+ if (!isSemanticValid(FD, Field, Info)) {
+ Diag(Field->getLocation(), diag::note_hlsl_semantic_used_here) << Field;
return false;
+ }
+ if (ActiveSemantic.Semantic)
+ ActiveSemantic = Info;
}
+
return true;
}
@@ -852,8 +907,11 @@ void SemaHLSL::CheckEntryPoint(FunctionDecl *FD) {
}
for (ParmVarDecl *Param : FD->parameters()) {
- if (!isSemanticValid(FD, Param)) {
- Diag(FD->getLocation(), diag::err_hlsl_missing_semantic_annotation);
+ SemanticInfo ActiveSemantic;
+ ActiveSemantic.Semantic = nullptr;
+ ActiveSemantic.Index = std::nullopt;
+
+ if (!isSemanticValid(FD, Param, ActiveSemantic)) {
Diag(Param->getLocation(), diag::note_previous_decl) << Param;
FD->setInvalidDecl();
}
@@ -861,31 +919,31 @@ void SemaHLSL::CheckEntryPoint(FunctionDecl *FD) {
// FIXME: Verify return type semantic annotation.
}
-void SemaHLSL::CheckSemanticAnnotation(
- FunctionDecl *EntryPoint, const Decl *Param,
- const HLSLAnnotationAttr *AnnotationAttr) {
+void SemaHLSL::checkSemanticAnnotation(FunctionDecl *EntryPoint,
+ const Decl *Param,
+ const HLSLSemanticAttr *SemanticAttr) {
auto *ShaderAttr = EntryPoint->getAttr<HLSLShaderAttr>();
assert(ShaderAttr && "Entry point has no shader attribute");
llvm::Triple::EnvironmentType ST = ShaderAttr->getType();
- switch (AnnotationAttr->getKind()) {
+ switch (SemanticAttr->getKind()) {
case attr::HLSLSV_DispatchThreadID:
case attr::HLSLSV_GroupIndex:
case attr::HLSLSV_GroupThreadID:
case attr::HLSLSV_GroupID:
if (ST == llvm::Triple::Compute)
return;
- DiagnoseAttrStageMismatch(AnnotationAttr, ST, {llvm::Triple::Compute});
+ DiagnoseAttrStageMismatch(SemanticAttr, ST, {llvm::Triple::Compute});
break;
case attr::HLSLSV_Position:
// TODO(#143523): allow use on other shader types & output once the overall
// semantic logic is implemented.
if (ST == llvm::Triple::Pixel)
return;
- DiagnoseAttrStageMismatch(AnnotationAttr, ST, {llvm::Triple::Pixel});
+ DiagnoseAttrStageMismatch(SemanticAttr, ST, {llvm::Triple::Pixel});
break;
default:
- llvm_unreachable("Unknown HLSLAnnotationAttr");
+ llvm_unreachable("Unknown SemanticAttr");
}
}
From 5f5c43a1ca208c4780d12d9404e2074f693b1fa5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nathan=20Gau=C3=ABr?= <brio...@google.com>
Date: Fri, 19 Sep 2025 11:52:46 +0200
Subject: [PATCH 4/4] sema: move to a flat attribute list per entrypoint
The previous solution had a major drawback: if a stuct was used
by multiple entrypoints, we had conflicting attribute.
This commit moves the attribute to the function declaration:
- each field with an active semantic will have a related attribute
attached to the corresponding entrypoint.
This means the semantic list is per-entrypoint.
---
clang/include/clang/AST/Attr.h | 5 +++++
clang/include/clang/Sema/SemaHLSL.h | 7 ++++--
clang/lib/CodeGen/CGHLSLRuntime.cpp | 28 ++++++++++++++++--------
clang/lib/CodeGen/CGHLSLRuntime.h | 15 +++++++------
clang/lib/Sema/SemaHLSL.cpp | 34 ++++++++++++++++-------------
5 files changed, 56 insertions(+), 33 deletions(-)
diff --git a/clang/include/clang/AST/Attr.h b/clang/include/clang/AST/Attr.h
index 00d4a0035fccf..ce273c167aa22 100644
--- a/clang/include/clang/AST/Attr.h
+++ b/clang/include/clang/AST/Attr.h
@@ -239,6 +239,8 @@ class HLSLSemanticAttr : public HLSLAnnotationAttr {
LLVM_PREFERRED_TYPE(bool)
unsigned SemanticExplicitIndex : 1;
+ Decl *TargetDecl = nullptr;
+
protected:
HLSLSemanticAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
attr::Kind AK, bool IsLateParsed,
@@ -261,6 +263,9 @@ class HLSLSemanticAttr : public HLSLAnnotationAttr {
bool isSemanticIndexExplicit() const { return SemanticExplicitIndex; }
+ void setTargetDecl(Decl *D) { TargetDecl = D; }
+ Decl *getTargetDecl() const { return TargetDecl; }
+
// Implement isa/cast/dyncast/etc.
static bool classof(const Attr *A) {
return A->getKind() >= attr::FirstHLSLSemanticAttr &&
diff --git a/clang/include/clang/Sema/SemaHLSL.h
b/clang/include/clang/Sema/SemaHLSL.h
index f0a940353515c..4d57cb0e7f734 100644
--- a/clang/include/clang/Sema/SemaHLSL.h
+++ b/clang/include/clang/Sema/SemaHLSL.h
@@ -174,9 +174,10 @@ class SemaHLSL : public SemaBase {
bool handleResourceTypeAttr(QualType T, const ParsedAttr &AL);
template <typename T>
- T *createSemanticAttr(const AttributeCommonInfo &ACI,
+ T *createSemanticAttr(const AttributeCommonInfo &ACI, Decl *TargetDecl,
std::optional<unsigned> Location) {
T *Attr = ::new (getASTContext()) T(getASTContext(), ACI);
+
if (Attr->isSemanticIndexable())
Attr->setSemanticIndex(Location ? *Location : 0);
else if (Location.has_value()) {
@@ -185,6 +186,7 @@ class SemaHLSL : public SemaBase {
return nullptr;
}
+ Attr->setTargetDecl(TargetDecl);
return Attr;
}
@@ -255,7 +257,8 @@ class SemaHLSL : public SemaBase {
void checkSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param,
const HLSLSemanticAttr *SemanticAttr);
- HLSLSemanticAttr *createSemantic(const SemanticInfo &Semantic);
+ HLSLSemanticAttr *createSemantic(const SemanticInfo &Semantic,
+ Decl *TargetDecl);
bool isSemanticOnScalarValid(FunctionDecl *FD, DeclaratorDecl *D,
SemanticInfo &ActiveSemantic);
bool isSemanticValid(FunctionDecl *FD, DeclaratorDecl *D,
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp
b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index c68d85ac837f3..e937456a87be0 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -613,10 +613,18 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
}
llvm::Value *
-CGHLSLRuntime::handleScalarSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
+CGHLSLRuntime::handleScalarSemanticLoad(IRBuilder<> &B, const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl) {
- HLSLSemanticAttr *Semantic = Decl->getAttr<HLSLSemanticAttr>();
- // Sema either attached a semantic to each field/param, or raised an error.
+
+ HLSLSemanticAttr *Semantic = nullptr;
+ for (HLSLSemanticAttr *Item : FD->specific_attrs<HLSLSemanticAttr>()) {
+ if (Item->getTargetDecl() == Decl) {
+ Semantic = Item;
+ break;
+ }
+ }
+ // Sema must create one attribute per scalar field.
assert(Semantic);
std::optional<unsigned> Index = std::nullopt;
@@ -626,7 +634,8 @@ CGHLSLRuntime::handleScalarSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
}
llvm::Value *
-CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
+CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B, const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl) {
const llvm::StructType *ST = cast<StructType>(Type);
const clang::RecordDecl *RD = Decl->getType()->getAsRecordDecl();
@@ -638,7 +647,7 @@ CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
auto FieldDecl = RD->field_begin();
for (unsigned I = 0; I < ST->getNumElements(); ++I) {
llvm::Value *ChildValue =
- handleSemanticLoad(B, ST->getElementType(I), *FieldDecl);
+ handleSemanticLoad(B, FD, ST->getElementType(I), *FieldDecl);
assert(ChildValue);
Aggregate = B.CreateInsertValue(Aggregate, ChildValue, I);
++FieldDecl;
@@ -648,11 +657,12 @@ CGHLSLRuntime::handleStructSemanticLoad(IRBuilder<> &B,
llvm::Type *Type,
}
llvm::Value *
-CGHLSLRuntime::handleSemanticLoad(IRBuilder<> &B, llvm::Type *Type,
+CGHLSLRuntime::handleSemanticLoad(IRBuilder<> &B, const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl) {
if (Type->isStructTy())
- return handleStructSemanticLoad(B, Type, Decl);
- return handleScalarSemanticLoad(B, Type, Decl);
+ return handleStructSemanticLoad(B, FD, Type, Decl);
+ return handleScalarSemanticLoad(B, FD, Type, Decl);
}
void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
@@ -706,7 +716,7 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl
*FD,
} else {
llvm::Type *ParamType =
Param.hasByValAttr() ? Param.getParamByValType() : Param.getType();
- SemanticValue = handleSemanticLoad(B, ParamType, PD);
+ SemanticValue = handleSemanticLoad(B, FD, ParamType, PD);
if (!SemanticValue)
return;
if (Param.hasByValAttr()) {
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.h
b/clang/lib/CodeGen/CGHLSLRuntime.h
index 039b881d2c9ee..ea11525f103d7 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.h
+++ b/clang/lib/CodeGen/CGHLSLRuntime.h
@@ -140,22 +140,23 @@ class CGHLSLRuntime {
protected:
CodeGenModule &CGM;
- void collectInputSemantic(llvm::IRBuilder<> &B, const DeclaratorDecl *D,
- llvm::Type *Type,
- SmallVectorImpl<llvm::Value *> &Inputs);
-
llvm::Value *emitSystemSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
Attr *Semantic,
std::optional<unsigned> Index);
- llvm::Value *handleScalarSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
+ llvm::Value *handleScalarSemanticLoad(llvm::IRBuilder<> &B,
+ const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl);
- llvm::Value *handleStructSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
+ llvm::Value *handleStructSemanticLoad(llvm::IRBuilder<> &B,
+ const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl);
- llvm::Value *handleSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
+ llvm::Value *handleSemanticLoad(llvm::IRBuilder<> &B, const FunctionDecl *FD,
+ llvm::Type *Type,
const clang::DeclaratorDecl *Decl);
public:
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index ee4088d528c98..cf270ff952695 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -769,22 +769,25 @@ void SemaHLSL::ActOnTopLevelFunction(FunctionDecl *FD) {
}
}
-HLSLSemanticAttr *SemaHLSL::createSemantic(const SemanticInfo &Info) {
+HLSLSemanticAttr *SemaHLSL::createSemantic(const SemanticInfo &Info,
+ Decl *TargetDecl) {
std::string SemanticName = Info.Semantic->getAttrName()->getName().upper();
if (SemanticName == "SV_DISPATCHTHREADID") {
- return createSemanticAttr<HLSLSV_DispatchThreadIDAttr>(*Info.Semantic,
- Info.Index);
+ return createSemanticAttr<HLSLSV_DispatchThreadIDAttr>(
+ *Info.Semantic, TargetDecl, Info.Index);
} else if (SemanticName == "SV_GROUPINDEX") {
- return createSemanticAttr<HLSLSV_GroupIndexAttr>(*Info.Semantic,
+ return createSemanticAttr<HLSLSV_GroupIndexAttr>(*Info.Semantic,
TargetDecl,
Info.Index);
} else if (SemanticName == "SV_GROUPTHREADID") {
return createSemanticAttr<HLSLSV_GroupThreadIDAttr>(*Info.Semantic,
- Info.Index);
+ TargetDecl,
Info.Index);
} else if (SemanticName == "SV_GROUPID") {
- return createSemanticAttr<HLSLSV_GroupIDAttr>(*Info.Semantic, Info.Index);
+ return createSemanticAttr<HLSLSV_GroupIDAttr>(*Info.Semantic, TargetDecl,
+ Info.Index);
} else if (SemanticName == "SV_POSITION") {
- return createSemanticAttr<HLSLSV_PositionAttr>(*Info.Semantic, Info.Index);
+ return createSemanticAttr<HLSLSV_PositionAttr>(*Info.Semantic, TargetDecl,
+ Info.Index);
} else
Diag(Info.Semantic->getLoc(), diag::err_hlsl_unknown_semantic)
<< *Info.Semantic;
@@ -806,13 +809,12 @@ bool SemaHLSL::isSemanticOnScalarValid(FunctionDecl *FD,
DeclaratorDecl *D,
return false;
}
- auto *A = createSemantic(ActiveSemantic);
+ auto *A = createSemantic(ActiveSemantic, D);
if (!A)
return false;
checkSemanticAnnotation(FD, D, A);
- D->dropAttrs<HLSLSemanticAttr>();
- D->addAttr(A);
+ FD->addAttr(A);
return true;
}
@@ -1702,28 +1704,30 @@ void SemaHLSL::diagnoseSystemSemanticAttr(Decl *D,
const ParsedAttr &AL,
diagnoseInputIDType(ValueType, AL);
if (IsOutput)
Diag(AL.getLoc(), diag::err_hlsl_semantic_output_not_supported) << AL;
- Attribute = createSemanticAttr<HLSLSV_DispatchThreadIDAttr>(AL, Index);
+ Attribute =
+ createSemanticAttr<HLSLSV_DispatchThreadIDAttr>(AL, nullptr, Index);
} else if (SemanticName == "SV_GROUPINDEX") {
if (IsOutput)
Diag(AL.getLoc(), diag::err_hlsl_semantic_output_not_supported) << AL;
- Attribute = createSemanticAttr<HLSLSV_GroupIndexAttr>(AL, Index);
+ Attribute = createSemanticAttr<HLSLSV_GroupIndexAttr>(AL, nullptr, Index);
} else if (SemanticName == "SV_GROUPTHREADID") {
diagnoseInputIDType(ValueType, AL);
if (IsOutput)
Diag(AL.getLoc(), diag::err_hlsl_semantic_output_not_supported) << AL;
- Attribute = createSemanticAttr<HLSLSV_GroupThreadIDAttr>(AL, Index);
+ Attribute =
+ createSemanticAttr<HLSLSV_GroupThreadIDAttr>(AL, nullptr, Index);
} else if (SemanticName == "SV_GROUPID") {
diagnoseInputIDType(ValueType, AL);
if (IsOutput)
Diag(AL.getLoc(), diag::err_hlsl_semantic_output_not_supported) << AL;
- Attribute = createSemanticAttr<HLSLSV_GroupIDAttr>(AL, Index);
+ Attribute = createSemanticAttr<HLSLSV_GroupIDAttr>(AL, nullptr, Index);
} else if (SemanticName == "SV_POSITION") {
const auto *VT = ValueType->getAs<VectorType>();
if (!ValueType->hasFloatingRepresentation() ||
(VT && VT->getNumElements() > 4))
Diag(AL.getLoc(), diag::err_hlsl_attr_invalid_type)
<< AL << "float/float1/float2/float3/float4";
- Attribute = createSemanticAttr<HLSLSV_PositionAttr>(AL, Index);
+ Attribute = createSemanticAttr<HLSLSV_PositionAttr>(AL, nullptr, Index);
} else
Diag(AL.getLoc(), diag::err_hlsl_unknown_semantic) << AL;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
