Skip to content

Commit ef12138

Browse files
author
joaosaffran
committed
moving root signature to it's own pass
1 parent 6043ffc commit ef12138

File tree

10 files changed

+271
-96
lines changed

10 files changed

+271
-96
lines changed

‎llvm/include/llvm/Analysis/DXILMetadataAnalysis.h‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111

1212
#include "llvm/ADT/SmallVector.h"
1313
#include "llvm/IR/PassManager.h"
14-
#include "llvm/MC/DXContainerRootSignature.h"
1514
#include "llvm/Pass.h"
1615
#include "llvm/Support/VersionTuple.h"
1716
#include "llvm/TargetParser/Triple.h"
@@ -39,7 +38,6 @@ struct ModuleMetadataInfo {
3938
Triple::EnvironmentType ShaderProfile{Triple::UnknownEnvironment};
4039
VersionTuple ValidatorVersion{};
4140
SmallVector<EntryProperties> EntryPropertyVec{};
42-
std::optional<mcdxbc::RootSignatureDesc> RootSignatureDesc;
4341
void print(raw_ostream &OS) const;
4442
};
4543

‎llvm/lib/Analysis/DXILMetadataAnalysis.cpp‎

Lines changed: 0 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,6 @@
1515
#include "llvm/IR/Metadata.h"
1616
#include "llvm/IR/Module.h"
1717
#include "llvm/InitializePasses.h"
18-
#include "llvm/MC/DXContainerRootSignature.h"
1918
#include "llvm/Support/Casting.h"
2019
#include "llvm/Support/ErrorHandling.h"
2120
#include <memory>
@@ -24,82 +23,8 @@
2423

2524
using namespace llvm;
2625
using namespace dxil;
27-
using namespace llvm::mcdxbc;
2826

29-
static bool parseRootFlags(MDNode *RootFlagNode, RootSignatureDesc *Desc) {
3027

31-
assert(RootFlagNode->getNumOperands() == 2 &&
32-
"Invalid format for RootFlag Element");
33-
auto *Flag = mdconst::extract<ConstantInt>(RootFlagNode->getOperand(1));
34-
auto Value = (RootSignatureFlags)Flag->getZExtValue();
35-
36-
if ((Value & ~RootSignatureFlags::ValidFlags) != RootSignatureFlags::None)
37-
return true;
38-
39-
Desc->Flags = Value;
40-
return false;
41-
}
42-
43-
static bool parseRootSignatureElement(MDNode *Element,
44-
RootSignatureDesc *Desc) {
45-
MDString *ElementText = cast<MDString>(Element->getOperand(0));
46-
47-
assert(ElementText != nullptr && "First preoperty of element is not ");
48-
49-
RootSignatureElementKind ElementKind =
50-
StringSwitch<RootSignatureElementKind>(ElementText->getString())
51-
.Case("RootFlags", RootSignatureElementKind::RootFlags)
52-
.Case("RootConstants", RootSignatureElementKind::RootConstants)
53-
.Case("RootCBV", RootSignatureElementKind::RootDescriptor)
54-
.Case("RootSRV", RootSignatureElementKind::RootDescriptor)
55-
.Case("RootUAV", RootSignatureElementKind::RootDescriptor)
56-
.Case("Sampler", RootSignatureElementKind::RootDescriptor)
57-
.Case("DescriptorTable", RootSignatureElementKind::DescriptorTable)
58-
.Case("StaticSampler", RootSignatureElementKind::StaticSampler)
59-
.Default(RootSignatureElementKind::None);
60-
61-
switch (ElementKind) {
62-
63-
case RootSignatureElementKind::RootFlags: {
64-
return parseRootFlags(Element, Desc);
65-
break;
66-
}
67-
68-
case RootSignatureElementKind::RootConstants:
69-
case RootSignatureElementKind::RootDescriptor:
70-
case RootSignatureElementKind::DescriptorTable:
71-
case RootSignatureElementKind::StaticSampler:
72-
case RootSignatureElementKind::None:
73-
llvm_unreachable("Not Implemented yet");
74-
break;
75-
}
76-
77-
return true;
78-
}
79-
80-
bool parseRootSignature(RootSignatureDesc *Desc, int32_t Version,
81-
NamedMDNode *Root) {
82-
Desc->Version = Version;
83-
bool HasError = false;
84-
85-
for (unsigned int Sid = 0; Sid < Root->getNumOperands(); Sid++) {
86-
// This should be an if, for error handling
87-
MDNode *Node = cast<MDNode>(Root->getOperand(Sid));
88-
89-
// Not sure what use this for...
90-
Metadata *Func = Node->getOperand(0).get();
91-
92-
// This should be an if, for error handling
93-
MDNode *Elements = cast<MDNode>(Node->getOperand(1).get());
94-
95-
for (unsigned int Eid = 0; Eid < Elements->getNumOperands(); Eid++) {
96-
MDNode *Element = cast<MDNode>(Elements->getOperand(Eid));
97-
98-
HasError = HasError || parseRootSignatureElement(Element, Desc);
99-
}
100-
}
101-
return HasError;
102-
}
10328

10429
static ModuleMetadataInfo collectMetadataInfo(Module &M) {
10530
ModuleMetadataInfo MMDAI;
@@ -117,15 +42,6 @@ static ModuleMetadataInfo collectMetadataInfo(Module &M) {
11742
VersionTuple(MajorMD->getZExtValue(), MinorMD->getZExtValue());
11843
}
11944

120-
NamedMDNode *RootSignatureNode = M.getNamedMetadata("dx.rootsignatures");
121-
if (RootSignatureNode) {
122-
mcdxbc::RootSignatureDesc Desc;
123-
124-
parseRootSignature(&Desc, 1, RootSignatureNode);
125-
126-
MMDAI.RootSignatureDesc = Desc;
127-
}
128-
12945
// For all HLSL Shader functions
13046
for (auto &F : M.functions()) {
13147
if (!F.hasFnAttribute("hlsl.shader"))

‎llvm/lib/MC/CMakeLists.txt‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
add_llvm_component_library(LLVMMC
22
ConstantPools.cpp
33
DXContainerPSVInfo.cpp
4-
DXContainerRootSignature.cpp
54
ELFObjectWriter.cpp
65
GOFFObjectWriter.cpp
76
MCAsmBackend.cpp

‎llvm/lib/Target/DirectX/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ add_llvm_target(DirectXCodeGen
3333
DXILResourceAccess.cpp
3434
DXILShaderFlags.cpp
3535
DXILTranslateMetadata.cpp
36-
36+
DXILRootSignature.cpp
3737
LINK_COMPONENTS
3838
Analysis
3939
AsmPrinter

‎llvm/lib/Target/DirectX/DXContainerGlobals.cpp‎

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
//===----------------------------------------------------------------------===//
1212

1313
#include "DXILShaderFlags.h"
14+
#include "DXILRootSignature.h"
1415
#include "DirectX.h"
1516
#include "llvm/ADT/SmallVector.h"
1617
#include "llvm/ADT/StringExtras.h"
@@ -23,7 +24,6 @@
2324
#include "llvm/IR/Module.h"
2425
#include "llvm/InitializePasses.h"
2526
#include "llvm/MC/DXContainerPSVInfo.h"
26-
#include "llvm/MC/DXContainerRootSignature.h"
2727
#include "llvm/Pass.h"
2828
#include "llvm/Support/MD5.h"
2929
#include "llvm/Transforms/Utils/ModuleUtils.h"
@@ -63,6 +63,7 @@ class DXContainerGlobals : public llvm::ModulePass {
6363
void getAnalysisUsage(AnalysisUsage &AU) const override {
6464
AU.setPreservesAll();
6565
AU.addRequired<ShaderFlagsAnalysisWrapper>();
66+
AU.addRequired<RootSignatureAnalysisWrapper>();
6667
AU.addRequired<DXILMetadataAnalysisWrapperPass>();
6768
AU.addRequired<DXILResourceTypeWrapperPass>();
6869
AU.addRequired<DXILResourceBindingWrapperPass>();
@@ -151,17 +152,15 @@ void DXContainerGlobals::addSignature(Module &M,
151152
void DXContainerGlobals::addRootSignature(Module &M,
152153
SmallVector<GlobalValue *> &Globals) {
153154

154-
std::optional<RootSignatureDesc> Desc =
155-
getAnalysis<DXILMetadataAnalysisWrapperPass>()
156-
.getModuleMetadata()
157-
.RootSignatureDesc;
158-
if (!Desc.has_value())
155+
std::optional<ModuleRootSignature> MRS =
156+
getAnalysis<RootSignatureAnalysisWrapper>()
157+
.getRootSignature();
158+
if (!MRS.has_value())
159159
return;
160160

161161
SmallString<256> Data;
162162
raw_svector_ostream OS(Data);
163-
RootSignatureDescWriter writer(&Desc.value());
164-
writer.write(OS);
163+
MRS->write(OS);
165164

166165
Constant *Constant =
167166
ConstantDataArray::getString(M.getContext(), Data, /*AddNull*/ false);

‎llvm/lib/Target/DirectX/DXILRootSignature.cpp‎

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
//===- DXILRootSignature.cpp - DXIL Root Signature helper objects ---------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
///
9+
/// \file This file contains helper objects and APIs for working with DXIL
10+
/// Root Signatures.
11+
///
12+
//===----------------------------------------------------------------------===//
13+
#include "DXILRootSignature.h"
14+
#include "DirectX.h"
15+
#include "llvm/ADT/StringSwitch.h"
16+
#include "llvm/BinaryFormat/DXContainer.h"
17+
#include "llvm/IR/Constants.h"
18+
#include "llvm/IR/Metadata.h"
19+
#include "llvm/IR/Module.h"
20+
21+
using namespace llvm;
22+
using namespace llvm::dxil;
23+
24+
static bool parseRootFlags(ModuleRootSignature *MRS, MDNode *RootFlagNode) {
25+
26+
assert(RootFlagNode->getNumOperands() == 2 &&
27+
"Invalid format for RootFlag Element");
28+
auto *Flag = mdconst::extract<ConstantInt>(RootFlagNode->getOperand(1));
29+
auto Value = Flag->getZExtValue();
30+
31+
// Root Element validation, as specified: https://github.com/llvm/wg-hlsl/blob/main/proposals/0002-root-signature-in-clang.md#validations-during-dxil-generation
32+
if ((Value & ~0x80000fff) != 0)
33+
return true;
34+
35+
MRS->Flags = Value;
36+
return false;
37+
}
38+
39+
static bool parseRootSignatureElement(ModuleRootSignature *MRS, MDNode *Element) {
40+
MDString *ElementText = cast<MDString>(Element->getOperand(0));
41+
42+
assert(ElementText != nullptr && "First preoperty of element is not ");
43+
44+
RootSignatureElementKind ElementKind =
45+
StringSwitch<RootSignatureElementKind>(ElementText->getString())
46+
.Case("RootFlags", RootSignatureElementKind::RootFlags)
47+
.Case("RootConstants", RootSignatureElementKind::RootConstants)
48+
.Case("RootCBV", RootSignatureElementKind::RootDescriptor)
49+
.Case("RootSRV", RootSignatureElementKind::RootDescriptor)
50+
.Case("RootUAV", RootSignatureElementKind::RootDescriptor)
51+
.Case("Sampler", RootSignatureElementKind::RootDescriptor)
52+
.Case("DescriptorTable", RootSignatureElementKind::DescriptorTable)
53+
.Case("StaticSampler", RootSignatureElementKind::StaticSampler)
54+
.Default(RootSignatureElementKind::None);
55+
56+
switch (ElementKind) {
57+
58+
case RootSignatureElementKind::RootFlags: {
59+
return parseRootFlags(MRS, Element);
60+
break;
61+
}
62+
63+
case RootSignatureElementKind::RootConstants:
64+
case RootSignatureElementKind::RootDescriptor:
65+
case RootSignatureElementKind::DescriptorTable:
66+
case RootSignatureElementKind::StaticSampler:
67+
case RootSignatureElementKind::None:
68+
llvm_unreachable("Not Implemented yet");
69+
break;
70+
}
71+
72+
return true;
73+
}
74+
75+
bool ModuleRootSignature::parse( int32_t Version,
76+
NamedMDNode *Root) {
77+
this->Version = Version;
78+
bool HasError = false;
79+
80+
for (unsigned int Sid = 0; Sid < Root->getNumOperands(); Sid++) {
81+
// This should be an if, for error handling
82+
MDNode *Node = cast<MDNode>(Root->getOperand(Sid));
83+
84+
// Not sure what use this for...
85+
Metadata *Func = Node->getOperand(0).get();
86+
87+
// This should be an if, for error handling
88+
MDNode *Elements = cast<MDNode>(Node->getOperand(1).get());
89+
90+
for (unsigned int Eid = 0; Eid < Elements->getNumOperands(); Eid++) {
91+
MDNode *Element = cast<MDNode>(Elements->getOperand(Eid));
92+
93+
HasError = HasError || parseRootSignatureElement(this, Element);
94+
}
95+
}
96+
return HasError;
97+
}
98+
99+
void ModuleRootSignature::write(raw_ostream &OS) {
100+
dxbc::RootSignatureDesc Out{this->Version, this->Flags};
101+
102+
if (sys::IsBigEndianHost) {
103+
Out.swapBytes();
104+
}
105+
106+
OS.write(reinterpret_cast<const char *>(&Out), sizeof(dxbc::RootSignatureDesc));
107+
}
108+
109+
AnalysisKey RootSignatureAnalysis::Key;
110+
111+
ModuleRootSignature RootSignatureAnalysis::run(Module &M,
112+
ModuleAnalysisManager &AM) {
113+
ModuleRootSignature MRSI;
114+
115+
NamedMDNode *RootSignatureNode = M.getNamedMetadata("dx.rootsignatures");
116+
if (RootSignatureNode) {
117+
MRSI.parse(1, RootSignatureNode);
118+
}
119+
120+
return MRSI;
121+
122+
}
123+
124+
125+
//===----------------------------------------------------------------------===//
126+
bool RootSignatureAnalysisWrapper::runOnModule(Module &M) {
127+
ModuleRootSignature MRS;
128+
129+
NamedMDNode *RootSignatureNode = M.getNamedMetadata("dx.rootsignatures");
130+
if (RootSignatureNode) {
131+
MRS.parse(1, RootSignatureNode);
132+
this->MRS = MRS;
133+
}
134+
135+
136+
return false;
137+
}
138+
139+
void RootSignatureAnalysisWrapper::getAnalysisUsage(AnalysisUsage &AU) const {
140+
AU.setPreservesAll();
141+
}
142+
143+
char RootSignatureAnalysisWrapper::ID = 0;
144+
145+
INITIALIZE_PASS(RootSignatureAnalysisWrapper, "dx-root-signature-analysis",
146+
"DXIL Root Signature Analysis", true, true)

0 commit comments

Comments
 (0)