[clang] 8fda9ee - Revert "[HLSL] Generate semantic signature metadata" (#215844)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Aug 12 09:47:41 PDT 2026
Author: Finn Plummer
Date: 2026-08-12T09:47:34-07:00
New Revision: 8fda9eee8956d4ac5a393689ccbde16a0d3a72b3
URL: https://github.com/llvm/llvm-project/commit/8fda9eee8956d4ac5a393689ccbde16a0d3a72b3
DIFF: https://github.com/llvm/llvm-project/commit/8fda9eee8956d4ac5a393689ccbde16a0d3a72b3.diff
LOG: Revert "[HLSL] Generate semantic signature metadata" (#215844)
Reverts llvm/llvm-project#212892
Build dependency for `DXILResource.h` was not updated. I will reland
with the corrected dependency.
Added:
Modified:
clang/lib/CodeGen/CGHLSLRuntime.cpp
clang/lib/CodeGen/CGHLSLRuntime.h
clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
clang/test/CodeGenHLSL/semantics/semantic.input.hlsl
clang/test/CodeGenHLSL/semantics/semantic.output.hlsl
llvm/include/llvm/Analysis/DXILResource.h
llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
llvm/lib/Analysis/DXILResource.cpp
llvm/unittests/Frontend/HLSLSemanticSignatureMetadataTest.cpp
Removed:
################################################################################
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index f67f50aff79b1..814894ea14da7 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -31,12 +31,10 @@
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetOptions.h"
#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Enum.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
-#include "llvm/Analysis/DXILResource.h"
#include "llvm/Frontend/HLSL/RootSignatureMetadata.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
@@ -104,33 +102,6 @@ void addRootSignatureMD(llvm::dxbc::RootSignatureVersion RootSigVer,
RootSignatureValMD->addOperand(MDVals);
}
-MDNode *buildSemanticSignatureMD(
- ArrayRef<llvm::hlsl::SemanticSignatureElement> Elements, LLVMContext &Ctx) {
- if (Elements.empty())
- return nullptr;
-
- SmallVector<Metadata *> ElementMD;
- for (const llvm::hlsl::SemanticSignatureElement &Element : Elements)
- ElementMD.push_back(Element.toMetadata(Ctx));
- return MDNode::get(Ctx, ElementMD);
-}
-
-void addSemanticSignatureMD(
- ArrayRef<llvm::hlsl::SemanticSignatureElement> InputElements,
- ArrayRef<llvm::hlsl::SemanticSignatureElement> OutputElements,
- llvm::Function *Fn, llvm::Module &M) {
- if (InputElements.empty() && OutputElements.empty())
- return;
-
- LLVMContext &Ctx = M.getContext();
- MDNode *InputSignature = buildSemanticSignatureMD(InputElements, Ctx);
- MDNode *OutputSignature = buildSemanticSignatureMD(OutputElements, Ctx);
- MDNode *MDVals = MDNode::get(
- Ctx, {ValueAsMetadata::get(Fn), InputSignature, OutputSignature});
-
- M.getOrInsertNamedMetadata("dx.semantic.signatures")->addOperand(MDVals);
-}
-
static void copyGlobalResource(CodeGenFunction &CGF, const VarDecl *ResourceVD,
AggValueSlot &DestSlot) {
GlobalVariable *ResGV =
@@ -1275,63 +1246,13 @@ static SemanticShape getSemanticShape(ASTContext &Ctx, QualType Ty) {
return Shape;
}
-static llvm::dxil::ElementType getSignatureComponentType(CodeGenModule &CGM,
- QualType Ty) {
- if (const auto *VT = Ty->getAs<clang::VectorType>())
- Ty = VT->getElementType();
- else if (const auto *MT = Ty->getAs<clang::ConstantMatrixType>())
- Ty = MT->getElementType();
-
- llvm::Type *IRTy = CGM.getTypes().ConvertTypeForMem(Ty);
- bool IsSigned = Ty->isSignedIntegerOrEnumerationType();
- return llvm::dxil::toDXILElementType(IRTy, IsSigned);
-}
-
-static llvm::dxbc::PSV::SemanticKind
-getSignatureSemanticKind(StringRef SemanticName) {
- if (!SemanticName.consume_front_insensitive("SV_"))
- return llvm::dxbc::PSV::SemanticKind::Arbitrary;
-
- for (const auto &Kind : llvm::dxbc::PSV::getSemanticKinds())
- if (SemanticName.equals_insensitive(Kind.name()))
- return Kind.value();
-
- return llvm::dxbc::PSV::SemanticKind::Invalid;
-}
-
-static llvm::hlsl::SemanticSignatureElement createSemanticSignatureElement(
- CodeGenModule &CGM, uint32_t SigId, HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index, const SemanticShape &Shape) {
- StringRef Name = Semantic->getAttrName()->getName();
-
- // One semantic index per row, starting from the declared index.
- SmallVector<uint32_t> SemanticIndices;
- uint32_t FirstSemanticIndex = Index.value_or(0);
- for (uint32_t I = 0, E = Shape.getNumRows(); I < E; ++I)
- SemanticIndices.push_back(FirstSemanticIndex + I);
-
- // The remaining members keep their default value and will be filled at a
- // later stage, either during packing or analysis of usage
- //
- // FIXME #189762: Element.InterpMode is to be set
- return llvm::hlsl::SemanticSignatureElement(
- SigId, Name, getSignatureComponentType(CGM, Shape.RowType),
- getSignatureSemanticKind(Name), SemanticIndices,
- static_cast<uint8_t>(Shape.Cols));
-}
-
llvm::Value *CGHLSLRuntime::emitDXILUserSemanticLoad(
llvm::IRBuilder<> &B, llvm::Type *Type, const clang::DeclaratorDecl *Decl,
- HLSLAppliedSemanticAttr *Semantic, std::optional<unsigned> Index,
- SemanticSignatures &Signature) {
+ HLSLAppliedSemanticAttr *Semantic, std::optional<unsigned> Index) {
StringRef Name = Semantic->getAttrName()->getName();
SemanticShape Shape =
getSemanticShape(CGM.getContext(), getSemanticLeafType(Decl));
- uint32_t SigId = Signature.size();
- Signature.push_back(
- createSemanticSignatureElement(CGM, SigId, Semantic, Index, Shape));
-
llvm::Type *RowTy = CGM.getTypes().ConvertTypeForMem(Shape.RowType);
llvm::Function *IntrFn = llvm::Intrinsic::getOrInsertDeclaration(
@@ -1343,6 +1264,8 @@ llvm::Value *CGHLSLRuntime::emitDXILUserSemanticLoad(
OB.emplace_back("convergencectrl", bundleArgs);
}
+ unsigned SigId = DXILInputSemanticIndex++;
+
llvm::Type *LeafTy = CGM.getTypes().ConvertType(Shape.RowType);
llvm::Value *Result = llvm::PoisonValue::get(Type);
@@ -1376,15 +1299,9 @@ void CGHLSLRuntime::emitDXILUserSemanticStore(llvm::IRBuilder<> &B,
llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature) {
+ std::optional<unsigned> Index) {
SemanticShape Shape =
getSemanticShape(CGM.getContext(), getSemanticLeafType(Decl));
-
- uint32_t SigId = Signature.size();
- Signature.push_back(
- createSemanticSignatureElement(CGM, SigId, Semantic, Index, Shape));
-
llvm::Type *RowTy = CGM.getTypes().ConvertTypeForMem(Shape.RowType);
llvm::Function *IntrFn = llvm::Intrinsic::getOrInsertDeclaration(
@@ -1397,6 +1314,8 @@ void CGHLSLRuntime::emitDXILUserSemanticStore(llvm::IRBuilder<> &B,
OB.emplace_back("convergencectrl", bundleArgs);
}
+ unsigned SigId = DXILOutputSemanticIndex++;
+
const unsigned NumRows = Shape.getNumRows();
for (unsigned Row = 0; Row < NumRows; ++Row) {
SmallVector<unsigned> Indices = Shape.getArrayIndicesForRow(Row);
@@ -1421,12 +1340,12 @@ void CGHLSLRuntime::emitDXILUserSemanticStore(llvm::IRBuilder<> &B,
llvm::Value *CGHLSLRuntime::emitUserSemanticLoad(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index, SemanticSignatures &Signature) {
+ std::optional<unsigned> Index) {
if (CGM.getTarget().getTriple().isSPIRV())
return emitSPIRVUserSemanticLoad(B, FD, Type, Decl, Semantic, Index);
if (CGM.getTarget().getTriple().isDXIL())
- return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index, Signature);
+ return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index);
llvm_unreachable("Unsupported target for user-semantic load.");
}
@@ -1434,14 +1353,12 @@ llvm::Value *CGHLSLRuntime::emitUserSemanticLoad(
void CGHLSLRuntime::emitUserSemanticStore(IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature) {
+ std::optional<unsigned> Index) {
if (CGM.getTarget().getTriple().isSPIRV())
return emitSPIRVUserSemanticStore(B, Source, Decl, Semantic, Index);
if (CGM.getTarget().getTriple().isDXIL())
- return emitDXILUserSemanticStore(B, Source, Decl, Semantic, Index,
- Signature);
+ return emitDXILUserSemanticStore(B, Source, Decl, Semantic, Index);
llvm_unreachable("Unsupported target for user-semantic load.");
}
@@ -1449,7 +1366,7 @@ void CGHLSLRuntime::emitUserSemanticStore(IRBuilder<> &B, llvm::Value *Source,
llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index, SemanticSignatures &Signature) {
+ std::optional<unsigned> Index) {
std::string SemanticName = Semantic->getAttrName()->getName().upper();
if (SemanticName == "SV_GROUPINDEX") {
@@ -1496,13 +1413,11 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
Semantic->getAttrName()->getName(),
/* BuiltIn::FragCoord */ 15);
if (CGM.getTarget().getTriple().isDXIL())
- return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index,
- Signature);
+ return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index);
}
if (ST == Triple::EnvironmentType::Vertex) {
- return emitUserSemanticLoad(B, FD, Type, Decl, Semantic, Index,
- Signature);
+ return emitUserSemanticLoad(B, FD, Type, Decl, Semantic, Index);
}
}
@@ -1513,8 +1428,7 @@ llvm::Value *CGHLSLRuntime::emitSystemSemanticLoad(
Semantic->getAttrName()->getName(),
/* BuiltIn::VertexIndex */ 42);
else
- return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index,
- Signature);
+ return emitDXILUserSemanticLoad(B, Type, Decl, Semantic, Index);
}
}
@@ -1539,13 +1453,12 @@ static void createSPIRVBuiltinStore(IRBuilder<> &B, llvm::Module &M,
void CGHLSLRuntime::emitSystemSemanticStore(IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature) {
+ std::optional<unsigned> Index) {
std::string SemanticName = Semantic->getAttrName()->getName().upper();
if (SemanticName == "SV_POSITION") {
if (CGM.getTarget().getTriple().isDXIL()) {
- emitDXILUserSemanticStore(B, Source, Decl, Semantic, Index, Signature);
+ emitDXILUserSemanticStore(B, Source, Decl, Semantic, Index);
return;
}
@@ -1558,7 +1471,7 @@ void CGHLSLRuntime::emitSystemSemanticStore(IRBuilder<> &B, llvm::Value *Source,
}
if (SemanticName == "SV_TARGET") {
- emitUserSemanticStore(B, Source, Decl, Semantic, Index, Signature);
+ emitUserSemanticStore(B, Source, Decl, Semantic, Index);
return;
}
@@ -1568,27 +1481,22 @@ void CGHLSLRuntime::emitSystemSemanticStore(IRBuilder<> &B, llvm::Value *Source,
llvm::Value *CGHLSLRuntime::handleScalarSemanticLoad(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
- const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic,
- SemanticSignatures &Signature) {
+ const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic) {
std::optional<unsigned> Index = Semantic->getSemanticIndex();
if (Semantic->getAttrName()->getName().starts_with_insensitive("SV_"))
- return emitSystemSemanticLoad(B, FD, Type, Decl, Semantic, Index,
- Signature);
- return emitUserSemanticLoad(B, FD, Type, Decl, Semantic, Index, Signature);
+ return emitSystemSemanticLoad(B, FD, Type, Decl, Semantic, Index);
+ return emitUserSemanticLoad(B, FD, Type, Decl, Semantic, Index);
}
-void CGHLSLRuntime::handleScalarSemanticStore(IRBuilder<> &B,
- const FunctionDecl *FD,
- llvm::Value *Source,
- const clang::DeclaratorDecl *Decl,
- HLSLAppliedSemanticAttr *Semantic,
- SemanticSignatures &Signature) {
+void CGHLSLRuntime::handleScalarSemanticStore(
+ IRBuilder<> &B, const FunctionDecl *FD, llvm::Value *Source,
+ const clang::DeclaratorDecl *Decl, HLSLAppliedSemanticAttr *Semantic) {
std::optional<unsigned> Index = Semantic->getSemanticIndex();
if (Semantic->getAttrName()->getName().starts_with_insensitive("SV_"))
- emitSystemSemanticStore(B, Source, Decl, Semantic, Index, Signature);
+ emitSystemSemanticStore(B, Source, Decl, Semantic, Index);
else
- emitUserSemanticStore(B, Source, Decl, Semantic, Index, Signature);
+ emitUserSemanticStore(B, Source, Decl, Semantic, Index);
}
std::pair<llvm::Value *, specific_attr_iterator<HLSLAppliedSemanticAttr>>
@@ -1596,8 +1504,7 @@ CGHLSLRuntime::handleStructSemanticLoad(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature) {
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd) {
const llvm::StructType *ST = cast<StructType>(Type);
const clang::RecordDecl *RD = Decl->getType()->getAsRecordDecl();
@@ -1606,9 +1513,8 @@ CGHLSLRuntime::handleStructSemanticLoad(
llvm::Value *Aggregate = llvm::PoisonValue::get(Type);
auto FieldDecl = RD->field_begin();
for (unsigned I = 0; I < ST->getNumElements(); ++I) {
- auto [ChildValue, NextAttr] =
- handleSemanticLoad(B, FD, ST->getElementType(I), *FieldDecl, AttrBegin,
- AttrEnd, Signature);
+ auto [ChildValue, NextAttr] = handleSemanticLoad(
+ B, FD, ST->getElementType(I), *FieldDecl, AttrBegin, AttrEnd);
AttrBegin = NextAttr;
assert(ChildValue);
Aggregate = B.CreateInsertValue(Aggregate, ChildValue, I);
@@ -1623,8 +1529,7 @@ CGHLSLRuntime::handleStructSemanticStore(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature) {
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd) {
const llvm::StructType *ST = cast<StructType>(Source->getType());
@@ -1640,8 +1545,8 @@ CGHLSLRuntime::handleStructSemanticStore(
auto FieldDecl = RD->field_begin();
for (unsigned I = 0; I < ST->getNumElements(); ++I, ++FieldDecl) {
llvm::Value *Extract = B.CreateExtractValue(Source, I);
- AttrBegin = handleSemanticStore(B, FD, Extract, *FieldDecl, AttrBegin,
- AttrEnd, Signature);
+ AttrBegin =
+ handleSemanticStore(B, FD, Extract, *FieldDecl, AttrBegin, AttrEnd);
}
return AttrBegin;
@@ -1652,17 +1557,15 @@ CGHLSLRuntime::handleSemanticLoad(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature) {
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd) {
assert(AttrBegin != AttrEnd);
if (Type->isStructTy())
- return handleStructSemanticLoad(B, FD, Type, Decl, AttrBegin, AttrEnd,
- Signature);
+ return handleStructSemanticLoad(B, FD, Type, Decl, AttrBegin, AttrEnd);
HLSLAppliedSemanticAttr *Attr = *AttrBegin;
++AttrBegin;
- return std::make_pair(
- handleScalarSemanticLoad(B, FD, Type, Decl, Attr, Signature), AttrBegin);
+ return std::make_pair(handleScalarSemanticLoad(B, FD, Type, Decl, Attr),
+ AttrBegin);
}
specific_attr_iterator<HLSLAppliedSemanticAttr>
@@ -1670,23 +1573,21 @@ CGHLSLRuntime::handleSemanticStore(
IRBuilder<> &B, const FunctionDecl *FD, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature) {
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd) {
assert(AttrBegin != AttrEnd);
if (Source->getType()->isStructTy())
- return handleStructSemanticStore(B, FD, Source, Decl, AttrBegin, AttrEnd,
- Signature);
+ return handleStructSemanticStore(B, FD, Source, Decl, AttrBegin, AttrEnd);
HLSLAppliedSemanticAttr *Attr = *AttrBegin;
++AttrBegin;
- handleScalarSemanticStore(B, FD, Source, Decl, Attr, Signature);
+ handleScalarSemanticStore(B, FD, Source, Decl, Attr);
return AttrBegin;
}
void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
llvm::Function *Fn) {
- SmallVector<llvm::hlsl::SemanticSignatureElement> InputSignature;
- SmallVector<llvm::hlsl::SemanticSignatureElement> OutputSignature;
+ DXILInputSemanticIndex = 0;
+ DXILOutputSemanticIndex = 0;
llvm::Module &M = CGM.getModule();
llvm::LLVMContext &Ctx = M.getContext();
@@ -1750,8 +1651,8 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
auto AttrBegin = PD->specific_attr_begin<HLSLAppliedSemanticAttr>();
auto AttrEnd = PD->specific_attr_end<HLSLAppliedSemanticAttr>();
- auto Result = handleSemanticLoad(B, FD, ParamType, PD, AttrBegin, AttrEnd,
- InputSignature);
+ auto Result =
+ handleSemanticLoad(B, FD, ParamType, PD, AttrBegin, AttrEnd);
SemanticValue = Result.first;
if (!SemanticValue)
return;
@@ -1784,8 +1685,7 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
auto AttrBegin = FD->specific_attr_begin<HLSLAppliedSemanticAttr>();
auto AttrEnd = FD->specific_attr_end<HLSLAppliedSemanticAttr>();
- handleSemanticStore(B, FD, SourceValue, FD, AttrBegin, AttrEnd,
- OutputSignature);
+ handleSemanticStore(B, FD, SourceValue, FD, AttrBegin, AttrEnd);
}
B.CreateRetVoid();
@@ -1798,8 +1698,6 @@ void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
EntryFn, M);
}
}
-
- addSemanticSignatureMD(InputSignature, OutputSignature, EntryFn, M);
}
static void gatherFunctions(SmallVectorImpl<Function *> &Fns, llvm::Module &M,
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.h b/clang/lib/CodeGen/CGHLSLRuntime.h
index ba8b2415a6275..f5674b64d0041 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.h
+++ b/clang/lib/CodeGen/CGHLSLRuntime.h
@@ -24,7 +24,6 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Frontend/HLSL/HLSLResource.h"
-#include "llvm/Frontend/HLSL/SemanticSignatures.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/IntrinsicsDirectX.h"
@@ -220,65 +219,54 @@ class CGHLSLRuntime {
//===----------------------------------------------------------------------===//
protected:
- using SemanticSignatures =
- llvm::SmallVectorImpl<llvm::hlsl::SemanticSignatureElement>;
-
CodeGenModule &CGM;
llvm::Value *emitSystemSemanticLoad(llvm::IRBuilder<> &B,
const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
void emitSystemSemanticStore(llvm::IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
llvm::Value *handleScalarSemanticLoad(llvm::IRBuilder<> &B,
const FunctionDecl *FD,
llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
- HLSLAppliedSemanticAttr *Semantic,
- SemanticSignatures &Signature);
+ HLSLAppliedSemanticAttr *Semantic);
void handleScalarSemanticStore(llvm::IRBuilder<> &B, const FunctionDecl *FD,
llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
- HLSLAppliedSemanticAttr *Semantic,
- SemanticSignatures &Signature);
+ HLSLAppliedSemanticAttr *Semantic);
std::pair<llvm::Value *, specific_attr_iterator<HLSLAppliedSemanticAttr>>
handleStructSemanticLoad(
llvm::IRBuilder<> &B, const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> begin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> end,
- SemanticSignatures &Signature);
+ specific_attr_iterator<HLSLAppliedSemanticAttr> end);
specific_attr_iterator<HLSLAppliedSemanticAttr> handleStructSemanticStore(
llvm::IRBuilder<> &B, const FunctionDecl *FD, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature);
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd);
std::pair<llvm::Value *, specific_attr_iterator<HLSLAppliedSemanticAttr>>
handleSemanticLoad(llvm::IRBuilder<> &B, const FunctionDecl *FD,
llvm::Type *Type, const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> begin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> end,
- SemanticSignatures &Signature);
+ specific_attr_iterator<HLSLAppliedSemanticAttr> end);
specific_attr_iterator<HLSLAppliedSemanticAttr>
handleSemanticStore(llvm::IRBuilder<> &B, const FunctionDecl *FD,
llvm::Value *Source, const clang::DeclaratorDecl *Decl,
specific_attr_iterator<HLSLAppliedSemanticAttr> AttrBegin,
- specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd,
- SemanticSignatures &Signature);
+ specific_attr_iterator<HLSLAppliedSemanticAttr> AttrEnd);
public:
CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
@@ -352,14 +340,12 @@ class CGHLSLRuntime {
llvm::Value *emitDXILUserSemanticLoad(llvm::IRBuilder<> &B, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
llvm::Value *emitUserSemanticLoad(llvm::IRBuilder<> &B,
const FunctionDecl *FD, llvm::Type *Type,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
void emitSPIRVUserSemanticStore(llvm::IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
@@ -368,13 +354,11 @@ class CGHLSLRuntime {
void emitDXILUserSemanticStore(llvm::IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
void emitUserSemanticStore(llvm::IRBuilder<> &B, llvm::Value *Source,
const clang::DeclaratorDecl *Decl,
HLSLAppliedSemanticAttr *Semantic,
- std::optional<unsigned> Index,
- SemanticSignatures &Signature);
+ std::optional<unsigned> Index);
bool initializeGlobalResourceArray(CodeGenFunction &CGF,
const VarDecl *ArrayDecl,
@@ -385,6 +369,12 @@ class CGHLSLRuntime {
llvm::DenseMap<const clang::RecordType *, llvm::StructType *> LayoutTypes;
unsigned SPIRVLastAssignedInputSemanticLocation = 0;
unsigned SPIRVLastAssignedOutputSemanticLocation = 0;
+
+ // FIXME: #57928, storing these here and reseting them in the entry is not
+ // very nice and is a temporary until we accumulate the signatures as part of
+ // the mentioned issue.
+ unsigned DXILInputSemanticIndex = 0;
+ unsigned DXILOutputSemanticIndex = 0;
};
} // namespace CodeGen
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
index 5427a569e5eee..8c8fe6443183e 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
@@ -34,11 +34,6 @@ S0 main1(float4 input : A) : B {
return output;
}
-// CHECK-DXIL: !dx.semantic.signatures = !{![[#ENTRY_SIG:]]}
-// CHECK-DXIL: ![[#ENTRY_SIG]] = !{ptr @main1, ![[#INPUT_SIG:]], ![[#OUTPUT_SIG:]]}
-// CHECK-DXIL: ![[#INPUT_SIG]] = !{![[#INPUT_ELEMENT:]]}
-// CHECK-DXIL: ![[#OUTPUT_SIG]] = !{![[#OUTPUT_ELEMENT_0:]], ![[#OUTPUT_ELEMENT_1:]]}
-
// CHECK-SPIRV-DAG: ![[#METADATA_0]] = !{![[#METADATA_1:]]}
// CHECK-SPIRV-DAG: ![[#METADATA_1]] = !{i32 30, i32 0}
// | `- Location index
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.input.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.input.hlsl
index 3bd77d783b435..3c46eace082ee 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.input.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.input.hlsl
@@ -51,14 +51,3 @@ void main(S s) {}
// CHECK: %[[E5:.*]] = call <4 x float> @llvm.dx.load.input.v4f32(i32 3, i32 5, i8 0, i32 poison)
// CHECK: %[[E_ARRAY5:.*]] = insertvalue [2 x [3 x <4 x float>]] %[[E_ARRAY4]], <4 x float> %[[E5]], 1, 2
// CHECK: %[[S3:.*]] = insertvalue %struct.S %[[S2]], [2 x [3 x <4 x float>]] %[[E_ARRAY5]], 3
-
-// CHECK: !dx.semantic.signatures = !{![[#ENTRY_SIG:]]}
-// CHECK: ![[#ENTRY_SIG]] = !{ptr @main, ![[#INPUT_SIG:]], null}
-// CHECK: ![[#INPUT_SIG]] = !{![[#A_SIG:]], ![[#B_SIG:]], ![[#D_SIG:]], ![[#E_SIG:]]}
-// CHECK: ![[#A_SIG]] = !{i32 0, !"A", i32 9, i32 0, ![[#ZERO_INDEX:]], i32 0, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#ZERO_INDEX]] = !{i32 0}
-// CHECK: ![[#B_SIG]] = !{i32 1, !"B", i32 9, i32 0, ![[#ZERO_INDEX]], i32 0, i32 1, i8 4, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#D_SIG]] = !{i32 2, !"D", i32 9, i32 0, ![[#D_INDICES:]], i32 0, i32 5, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#D_INDICES]] = !{i32 0, i32 1, i32 2, i32 3, i32 4}
-// CHECK: ![[#E_SIG]] = !{i32 3, !"E", i32 9, i32 0, ![[#E_INDICES:]], i32 0, i32 6, i8 4, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#E_INDICES]] = !{i32 0, i32 1, i32 2, i32 3, i32 4, i32 5}
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.output.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.output.hlsl
index 54e9aa83cda0b..fdb195899ca97 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.output.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.output.hlsl
@@ -54,14 +54,3 @@ S main() {
// CHECK: call void @llvm.dx.store.output.v4f32(i32 3, i32 4, i8 0, <4 x float> %[[E11]])
// CHECK: %[[E12:.*]] = extractvalue [2 x [3 x <4 x float>]] %[[E]], 1, 2
// CHECK: call void @llvm.dx.store.output.v4f32(i32 3, i32 5, i8 0, <4 x float> %[[E12]])
-
-// CHECK: !dx.semantic.signatures = !{![[#ENTRY_SIG:]]}
-// CHECK: ![[#ENTRY_SIG]] = !{ptr @main, null, ![[#OUTPUT_SIG:]]}
-// CHECK: ![[#OUTPUT_SIG]] = !{![[#A_SIG:]], ![[#B_SIG:]], ![[#D_SIG:]], ![[#E_SIG:]]}
-// CHECK: ![[#A_SIG]] = !{i32 0, !"A", i32 9, i32 0, ![[#ZERO_INDEX:]], i32 0, i32 1, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#ZERO_INDEX]] = !{i32 0}
-// CHECK: ![[#B_SIG]] = !{i32 1, !"B", i32 9, i32 0, ![[#ZERO_INDEX]], i32 0, i32 1, i8 4, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#D_SIG]] = !{i32 2, !"D", i32 9, i32 0, ![[#D_INDICES:]], i32 0, i32 5, i8 1, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#D_INDICES]] = !{i32 0, i32 1, i32 2, i32 3, i32 4}
-// CHECK: ![[#E_SIG]] = !{i32 3, !"E", i32 9, i32 0, ![[#E_INDICES:]], i32 0, i32 6, i8 4, i32 -1, i8 -1, i8 0, i8 0, i32 0}
-// CHECK: ![[#E_INDICES]] = !{i32 0, i32 1, i32 2, i32 3, i32 4, i32 5}
diff --git a/llvm/include/llvm/Analysis/DXILResource.h b/llvm/include/llvm/Analysis/DXILResource.h
index c996e79f2caee..1473a0f7d56c0 100644
--- a/llvm/include/llvm/Analysis/DXILResource.h
+++ b/llvm/include/llvm/Analysis/DXILResource.h
@@ -37,11 +37,6 @@ namespace dxil {
// dx_resource_handlefromimplicitbinding call
LLVM_ABI StringRef getResourceNameFromBindingCall(CallInst *CI);
-/// Converts a scalar or vector LLVM type to its DXIL element type. Integer
-/// signedness must be supplied separately because LLVM integer types are
-/// signless.
-LLVM_ABI ElementType toDXILElementType(Type *Ty, bool IsSigned);
-
/// The dx.RawBuffer target extension type
///
/// `target("dx.RawBuffer", Type, IsWriteable, IsROV)`
diff --git a/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h b/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
index 76518f75a70ec..c5be2516a7364 100644
--- a/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
+++ b/llvm/include/llvm/Frontend/HLSL/SemanticSignatures.h
@@ -14,7 +14,6 @@
#ifndef LLVM_FRONTEND_HLSL_SEMANTICSIGNATURES_H
#define LLVM_FRONTEND_HLSL_SEMANTICSIGNATURES_H
-#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/DXContainer.h"
@@ -54,15 +53,6 @@ struct SemanticSignatureElement {
uint8_t DynIndexMask = 0;
uint32_t GSStream = 0;
- SemanticSignatureElement() = default;
- SemanticSignatureElement(uint32_t SigId, StringRef SemanticName,
- dxil::ElementType CompType,
- dxbc::PSV::SemanticKind SemanticKind,
- ArrayRef<uint32_t> SemanticIndices, uint8_t Cols)
- : SigId(SigId), SemanticName(SemanticName), CompType(CompType),
- SemanticKind(SemanticKind), SemanticIndices(SemanticIndices),
- Rows(static_cast<uint32_t>(SemanticIndices.size())), Cols(Cols) {}
-
bool isAllocated() const {
return StartRow != UnallocatedRow && StartCol != UnallocatedCol;
}
diff --git a/llvm/lib/Analysis/DXILResource.cpp b/llvm/lib/Analysis/DXILResource.cpp
index 6ed66dad3d317..767c33684da60 100644
--- a/llvm/lib/Analysis/DXILResource.cpp
+++ b/llvm/lib/Analysis/DXILResource.cpp
@@ -180,7 +180,7 @@ static StringRef getSamplerFeedbackTypeName(SamplerFeedbackType SFT) {
llvm_unreachable("Unhandled SamplerFeedbackType");
}
-dxil::ElementType dxil::toDXILElementType(Type *Ty, bool IsSigned) {
+static dxil::ElementType toDXILElementType(Type *Ty, bool IsSigned) {
// TODO: Handle unorm, snorm, and packed.
Ty = Ty->getScalarType();
diff --git a/llvm/unittests/Frontend/HLSLSemanticSignatureMetadataTest.cpp b/llvm/unittests/Frontend/HLSLSemanticSignatureMetadataTest.cpp
index 9813264bf1f85..0638cf0f49692 100644
--- a/llvm/unittests/Frontend/HLSLSemanticSignatureMetadataTest.cpp
+++ b/llvm/unittests/Frontend/HLSLSemanticSignatureMetadataTest.cpp
@@ -71,12 +71,14 @@ class HLSLSemanticSignatureMetadataTest : public testing::Test {
//===----------------------------------------------------------------------===//
TEST_F(HLSLSemanticSignatureMetadataTest, StructHelpers) {
- SemanticSignatureElement Elem(/*SigId=*/0, "TEXCOORD", dxil::ElementType::F32,
- dxbc::PSV::SemanticKind::Arbitrary,
- /*SemanticIndices=*/{0}, /*Cols=*/4);
- EXPECT_EQ(Elem.Rows, 1u);
+ SemanticSignatureElement Elem;
+ Elem.SigId = 0;
+ Elem.CompType = dxil::ElementType::F32;
+ Elem.SemanticKind = dxbc::PSV::SemanticKind::Arbitrary;
+ Elem.Rows = 1;
EXPECT_FALSE(Elem.isAllocated());
+ Elem.Cols = 4;
Elem.StartRow = 0;
Elem.StartCol = 0;
EXPECT_TRUE(Elem.isAllocated());
@@ -387,11 +389,20 @@ TEST_F(HLSLSemanticSignatureMetadataTest, MetadataToElementIndicesRowMismatch) {
// A fully populated element emits all 13 operands in order
TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadata) {
- SemanticSignatureElement Elem(/*SigId=*/1, "TEXCOORD", dxil::ElementType::F32,
- dxbc::PSV::SemanticKind::Arbitrary,
- /*SemanticIndices=*/{0, 1}, /*Cols=*/4);
+ SemanticSignatureElement Elem;
+ Elem.SigId = 1;
+ Elem.SemanticName = "TEXCOORD";
+ Elem.CompType = dxil::ElementType::F32;
+ Elem.SemanticKind = dxbc::PSV::SemanticKind::Arbitrary;
+ Elem.SemanticIndices = {0, 1};
+ Elem.InterpMode = dxbc::PSV::InterpolationMode::Undefined;
+ Elem.Rows = 2;
+ Elem.Cols = 4;
Elem.StartRow = 1;
Elem.StartCol = 0;
+ Elem.UsageMask = 0;
+ Elem.DynIndexMask = 0;
+ Elem.GSStream = 0;
MDNode *Node = Elem.toMetadata(Ctx);
ASSERT_EQ(Node->getNumOperands(), 13u);
@@ -412,10 +423,14 @@ TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadata) {
// System value, non-zero masks and a non-zero stream index are emitted
TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadataSystemValue) {
- SemanticSignatureElement Elem(/*SigId=*/1, "SV_Target",
- dxil::ElementType::F32,
- dxbc::PSV::SemanticKind::Target,
- /*SemanticIndices=*/{1}, /*Cols=*/4);
+ SemanticSignatureElement Elem;
+ Elem.SigId = 1;
+ Elem.SemanticName = "SV_Target";
+ Elem.CompType = dxil::ElementType::F32;
+ Elem.SemanticKind = dxbc::PSV::SemanticKind::Target;
+ Elem.SemanticIndices = {1};
+ Elem.Rows = 1;
+ Elem.Cols = 4;
Elem.StartRow = 1;
Elem.StartCol = 0;
Elem.UsageMask = 0x7;
@@ -434,9 +449,14 @@ TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadataSystemValue) {
// An unallocated element emits the row/col sentinels
TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadataUnallocated) {
- SemanticSignatureElement Elem(/*SigId=*/0, "POSITION", dxil::ElementType::F32,
- dxbc::PSV::SemanticKind::Arbitrary,
- /*SemanticIndices=*/{0}, /*Cols=*/4);
+ SemanticSignatureElement Elem;
+ Elem.SigId = 0;
+ Elem.SemanticName = "POSITION";
+ Elem.CompType = dxil::ElementType::F32;
+ Elem.SemanticKind = dxbc::PSV::SemanticKind::Arbitrary;
+ Elem.SemanticIndices = {0};
+ Elem.Rows = 0;
+ Elem.Cols = 0;
MDNode *Node = Elem.toMetadata(Ctx);
ASSERT_EQ(Node->getNumOperands(), 13u);
@@ -446,13 +466,20 @@ TEST_F(HLSLSemanticSignatureMetadataTest, ElementToMetadataUnallocated) {
// Emitting then parsing yields an equivalent element
TEST_F(HLSLSemanticSignatureMetadataTest, ElementRoundTrip) {
- SemanticSignatureElement Elem(/*SigId=*/2, "TEXCOORD", dxil::ElementType::F32,
- dxbc::PSV::SemanticKind::Arbitrary,
- /*SemanticIndices=*/{1}, /*Cols=*/4);
+ SemanticSignatureElement Elem;
+ Elem.SigId = 2;
+ Elem.SemanticName = "TEXCOORD";
+ Elem.CompType = dxil::ElementType::F32;
+ Elem.SemanticKind = dxbc::PSV::SemanticKind::Arbitrary;
+ Elem.SemanticIndices = {1};
Elem.InterpMode = dxbc::PSV::InterpolationMode::LinearNoperspective;
+ Elem.Rows = 1;
+ Elem.Cols = 4;
Elem.StartRow = 2;
Elem.StartCol = 0;
Elem.UsageMask = 0x7;
+ Elem.DynIndexMask = 0;
+ Elem.GSStream = 0;
Expected<SemanticSignatureElement> Parsed =
SemanticSignatureElement::fromMetadata(Elem.toMetadata(Ctx));
More information about the cfe-commits
mailing list