1//===- DirectXTargetMachine.h - DirectX Target Implementation ---*- C++ -*-===//
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//===----------------------------------------------------------------------===//
10
11#ifndef LLVM_LIB_TARGET_DIRECTX_DIRECTX_H
12#define LLVM_LIB_TARGET_DIRECTX_DIRECTX_H
13
14#include "llvm/IR/Analysis.h"
15#include "llvm/IR/PassManager.h"
16#include "llvm/Support/CommandLine.h"
17
18namespace llvm {
19namespace dxil {
20extern cl::opt<bool> PdbInPrivate;
21} // namespace dxil
22
23class AttributeMask;
24class Function;
25class FunctionPass;
26class Module;
27class ModulePass;
28class PassRegistry;
29class raw_ostream;
30
31/// Initializer for dxil writer pass
32void initializeDXILWriterLegacyPass(PassRegistry &);
33
34/// Initializer for dxil embedder pass
35void initializeDXILEmbedderLegacyPass(PassRegistry &);
36
37/// Initializer for DXIL-prepare
38void initializeDXILPrepareModuleLegacyPass(PassRegistry &);
39
40/// Pass to convert modules into DXIL-compatable modules
41class DXILPrepareModulePass
42 : public RequiredPassInfoMixin<DXILPrepareModulePass> {
43public:
44 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
45};
46
47ModulePass *createDXILPrepareModuleLegacyPass();
48
49/// Pass to downgrade debug information to forms supported by DXIL.
50class DXILDebugInfoPass : public OptionalPassInfoMixin<DXILDebugInfoPass> {
51public:
52 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
53};
54
55/// Initializer for DXIL debug info lowering.
56void initializeDXILDebugInfoLegacyPass(PassRegistry &);
57
58ModulePass *createDXILDebugInfoLegacyPass();
59
60/// Pass to expand intrinsic operations that lack DXIL opCodes
61class DXILIntrinsicExpansionPass
62 : public OptionalPassInfoMixin<DXILIntrinsicExpansionPass> {
63public:
64 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
65};
66
67/// Initializer for DXIL Intrinsic Expansion
68void initializeDXILIntrinsicExpansionLegacyPass(PassRegistry &);
69
70ModulePass *createDXILIntrinsicExpansionLegacyPass();
71
72/// Pass to translate loads in the cbuffer address space to cbuffer
73/// load intrinsic.
74class DXILCBufferAccessPass
75 : public OptionalPassInfoMixin<DXILCBufferAccessPass> {
76public:
77 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
78};
79
80/// Initializer for DXIL CBuffer Access Pass
81void initializeDXILCBufferAccessLegacyPass(PassRegistry &);
82
83ModulePass *createDXILCBufferAccessLegacyPass();
84
85/// Pass to prepare vector data for DXIL by converting vector storage to
86/// scalar arrays and lowering dynamically indexed vector accesses to
87/// array accesses.
88class DXILDataScalarizationPass
89 : public OptionalPassInfoMixin<DXILDataScalarizationPass> {
90public:
91 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
92};
93
94/// Initializer for DXIL Data Scalarization Pass
95void initializeDXILDataScalarizationLegacyPass(PassRegistry &);
96
97ModulePass *createDXILDataScalarizationLegacyPass();
98
99/// Pass to flatten arrays into a one dimensional DXIL legal form
100class DXILFlattenArraysPass
101 : public OptionalPassInfoMixin<DXILFlattenArraysPass> {
102public:
103 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
104};
105
106/// Initializer for DXIL Array Flatten Pass
107void initializeDXILFlattenArraysLegacyPass(PassRegistry &);
108
109ModulePass *createDXILFlattenArraysLegacyPass();
110
111/// Pass to eliminate redundant stores and loads from handle globals.
112class DXILForwardHandleAccessesPass
113 : public OptionalPassInfoMixin<DXILForwardHandleAccessesPass> {
114public:
115 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
116};
117
118/// Initializer for DXIL Forward Handle Accesses Pass
119void initializeDXILForwardHandleAccessesLegacyPass(PassRegistry &);
120
121FunctionPass *createDXILForwardHandleAccessesLegacyPass();
122
123/// Pass to rewrite LLVM IR constructs unsupported by DXIL into
124/// compatible forms.
125class DXILLegalizePass : public OptionalPassInfoMixin<DXILLegalizePass> {
126public:
127 PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
128};
129
130/// Initializer DXIL legalizationPass
131void initializeDXILLegalizeLegacyPass(PassRegistry &);
132
133FunctionPass *createDXILLegalizeLegacyPass();
134
135/// Pass to transform all llvm memory intrinsics to explicit loads and stores.
136class DXILMemIntrinsicsPass
137 : public OptionalPassInfoMixin<DXILMemIntrinsicsPass> {
138public:
139 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
140};
141
142/// Initializer for DXIL Mem Intrinsics.
143void initializeDXILMemIntrinsicsLegacyPass(PassRegistry &);
144
145ModulePass *createDXILMemIntrinsicsLegacyPass();
146
147/// Pass to lowering LLVM intrinsic call to DXIL op function call.
148class DXILOpLoweringPass : public OptionalPassInfoMixin<DXILOpLoweringPass> {
149public:
150 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
151};
152
153/// Initializer for DXILOpLowering
154void initializeDXILOpLoweringLegacyPass(PassRegistry &);
155
156ModulePass *createDXILOpLoweringLegacyPass();
157
158/// Pass to remove unused DXIL resources and associated
159/// global variables.
160class DXILRemoveUnusedResourcesPass
161 : public OptionalPassInfoMixin<DXILRemoveUnusedResourcesPass> {
162public:
163 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
164};
165
166/// Initializer for DXILRemoveUnusedResources
167void initializeDXILRemoveUnusedResourcesLegacyPass(PassRegistry &);
168
169FunctionPass *createDXILRemoveUnusedResourcesLegacyPass();
170
171/// Pass to replace pointers to DXIL resources with load and store
172/// operations.
173class DXILResourceAccessPass
174 : public OptionalPassInfoMixin<DXILResourceAccessPass> {
175public:
176 PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
177};
178
179/// Initializer for DXILResourceAccess
180void initializeDXILResourceAccessLegacyPass(PassRegistry &);
181
182FunctionPass *createDXILResourceAccessLegacyPass();
183
184/// Pass to assign register slots to resources without binding.
185class DXILResourceImplicitBindingPass
186 : public OptionalPassInfoMixin<DXILResourceImplicitBindingPass> {
187public:
188 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
189};
190
191/// Initializer for DXILResourceImplicitBindingLegacyPass
192void initializeDXILResourceImplicitBindingLegacyPass(PassRegistry &);
193
194ModulePass *createDXILResourceImplicitBindingLegacyPass();
195
196/// Pass to emit metadata for DXIL, and to transforms existing LLVM
197/// metadata to its DXIL equivalent.
198class DXILTranslateMetadataPass
199 : public OptionalPassInfoMixin<DXILTranslateMetadataPass> {
200public:
201 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
202};
203
204/// Initializer for DXILTranslateMetadata.
205void initializeDXILTranslateMetadataLegacyPass(PassRegistry &);
206
207ModulePass *createDXILTranslateMetadataLegacyPass();
208
209/// Pass to pretty print DXIL metadata into IR
210/// comments when printing assembly output.
211class DXILPrettyPrinterPass
212 : public OptionalPassInfoMixin<DXILPrettyPrinterPass> {
213 raw_ostream &OS;
214
215public:
216 explicit DXILPrettyPrinterPass(raw_ostream &OS) : OS(OS) {}
217
218 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
219};
220
221ModulePass *createDXILPrettyPrinterLegacyPass(raw_ostream &OS);
222
223/// Initializer for DXILPrettyPrinter.
224void initializeDXILPrettyPrinterLegacyPass(PassRegistry &);
225
226/// Pass for validating IR after optimizations are applied and before
227/// lowering to DXIL.
228class DXILPostOptimizationValidationPass
229 : public OptionalPassInfoMixin<DXILPostOptimizationValidationPass> {
230public:
231 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
232};
233
234/// Initializer for DXILPostOptimizationValidation.
235void initializeDXILPostOptimizationValidationLegacyPass(PassRegistry &);
236
237ModulePass *createDXILPostOptimizationValidationLegacyPass();
238
239/// Initializer for dxil::ShaderFlagsAnalysisWrapper pass.
240void initializeShaderFlagsAnalysisWrapperPass(PassRegistry &);
241
242/// Initializer for dxil::RootSignatureAnalysisWrapper pass.
243void initializeRootSignatureAnalysisWrapperPass(PassRegistry &);
244
245/// Initializer for dxil::SignatureAnalysisWrapper pass.
246void initializeSignatureAnalysisWrapperPass(PassRegistry &);
247
248/// Initializer for DXILContainerGlobals pass.
249void initializeDXILContainerGlobalsLegacyPass(PassRegistry &);
250
251/// Pass for generating DXContainer part globals.
252class DXILContainerGlobalsPass
253 : public RequiredPassInfoMixin<DXILContainerGlobalsPass> {
254public:
255 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
256};
257
258ModulePass *createDXILContainerGlobalsLegacyPass();
259
260/// Initializer for DXILContainerPDB pass.
261void initializeDXILContainerPDBLegacyPass(PassRegistry &);
262
263/// Pass for emitting DirectX PDB files.
264class DXILContainerPDBPass
265 : public RequiredPassInfoMixin<DXILContainerPDBPass> {
266public:
267 PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
268};
269
270ModulePass *createDXILContainerPDBLegacyPass();
271
272/// Pass to update the linkage of functions to make sure only
273/// shader entry points and exported functions are visible from
274/// the module (have program linkage). All other functions will
275/// be updated to have internal linkage.
276class DXILFinalizeLinkagePass
277 : public RequiredPassInfoMixin<DXILFinalizeLinkagePass> {
278public:
279 PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
280};
281
282/// Initializer for DXILFinalizeLinkage pass.
283void initializeDXILFinalizeLinkageLegacyPass(PassRegistry &);
284
285ModulePass *createDXILFinalizeLinkageLegacyPass();
286} // namespace llvm
287
288#endif // LLVM_LIB_TARGET_DIRECTX_DIRECTX_H
289