xref: /llvm-project/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp (revision de1a97db3948608822a6d099cc3460690132e1cb)
1 //===- DirectXTargetMachine.cpp - 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 /// \file
10 /// This file contains DirectX target initializer.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "DirectXTargetMachine.h"
15 #include "DXILResourceAnalysis.h"
16 #include "DXILShaderFlags.h"
17 #include "DXILWriter/DXILWriterPass.h"
18 #include "DirectX.h"
19 #include "DirectXSubtarget.h"
20 #include "DirectXTargetTransformInfo.h"
21 #include "TargetInfo/DirectXTargetInfo.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/CodeGen/Passes.h"
24 #include "llvm/CodeGen/TargetPassConfig.h"
25 #include "llvm/IR/IRPrintingPasses.h"
26 #include "llvm/IR/LegacyPassManager.h"
27 #include "llvm/MC/MCSectionDXContainer.h"
28 #include "llvm/MC/SectionKind.h"
29 #include "llvm/MC/TargetRegistry.h"
30 #include "llvm/Passes/PassBuilder.h"
31 #include "llvm/Support/CodeGen.h"
32 #include "llvm/Support/Compiler.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Target/TargetLoweringObjectFile.h"
35 #include <optional>
36 
37 using namespace llvm;
38 
39 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
40   RegisterTargetMachine<DirectXTargetMachine> X(getTheDirectXTarget());
41   auto *PR = PassRegistry::getPassRegistry();
42   initializeDXILIntrinsicExpansionLegacyPass(*PR);
43   initializeDXILPrepareModulePass(*PR);
44   initializeEmbedDXILPassPass(*PR);
45   initializeWriteDXILPassPass(*PR);
46   initializeDXContainerGlobalsPass(*PR);
47   initializeDXILOpLoweringLegacyPass(*PR);
48   initializeDXILTranslateMetadataPass(*PR);
49   initializeDXILResourceWrapperPass(*PR);
50   initializeShaderFlagsAnalysisWrapperPass(*PR);
51 }
52 
53 class DXILTargetObjectFile : public TargetLoweringObjectFile {
54 public:
55   DXILTargetObjectFile() = default;
56 
57   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
58                                       const TargetMachine &TM) const override {
59     return getContext().getDXContainerSection(GO->getSection(), Kind);
60   }
61 
62 protected:
63   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
64                                     const TargetMachine &TM) const override {
65     llvm_unreachable("Not supported!");
66   }
67 };
68 
69 class DirectXPassConfig : public TargetPassConfig {
70 public:
71   DirectXPassConfig(DirectXTargetMachine &TM, PassManagerBase &PM)
72       : TargetPassConfig(TM, PM) {}
73 
74   DirectXTargetMachine &getDirectXTargetMachine() const {
75     return getTM<DirectXTargetMachine>();
76   }
77 
78   FunctionPass *createTargetRegisterAllocator(bool) override { return nullptr; }
79   void addCodeGenPrepare() override {
80     addPass(createDXILIntrinsicExpansionLegacyPass());
81     addPass(createDXILOpLoweringLegacyPass());
82     addPass(createDXILPrepareModulePass());
83     addPass(createDXILTranslateMetadataPass());
84   }
85 };
86 
87 DirectXTargetMachine::DirectXTargetMachine(const Target &T, const Triple &TT,
88                                            StringRef CPU, StringRef FS,
89                                            const TargetOptions &Options,
90                                            std::optional<Reloc::Model> RM,
91                                            std::optional<CodeModel::Model> CM,
92                                            CodeGenOptLevel OL, bool JIT)
93     : LLVMTargetMachine(T,
94                         "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
95                         "f32:32-f64:64-n8:16:32:64",
96                         TT, CPU, FS, Options, Reloc::Static, CodeModel::Small,
97                         OL),
98       TLOF(std::make_unique<DXILTargetObjectFile>()),
99       Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {
100   initAsmInfo();
101 }
102 
103 DirectXTargetMachine::~DirectXTargetMachine() {}
104 
105 void DirectXTargetMachine::registerPassBuilderCallbacks(
106     PassBuilder &PB, bool PopulateClassToPassNames) {
107   PB.registerPipelineParsingCallback(
108       [](StringRef PassName, ModulePassManager &PM,
109          ArrayRef<PassBuilder::PipelineElement>) {
110         if (PassName == "print-dxil-resource") {
111           PM.addPass(DXILResourcePrinterPass(dbgs()));
112           return true;
113         }
114         if (PassName == "print-dx-shader-flags") {
115           PM.addPass(dxil::ShaderFlagsAnalysisPrinter(dbgs()));
116           return true;
117         }
118         return false;
119       });
120 
121   PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &MAM) {
122     MAM.registerPass([&] { return DXILResourceAnalysis(); });
123     MAM.registerPass([&] { return dxil::ShaderFlagsAnalysis(); });
124   });
125 }
126 
127 bool DirectXTargetMachine::addPassesToEmitFile(
128     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
129     CodeGenFileType FileType, bool DisableVerify,
130     MachineModuleInfoWrapperPass *MMIWP) {
131   TargetPassConfig *PassConfig = createPassConfig(PM);
132   PassConfig->addCodeGenPrepare();
133 
134   switch (FileType) {
135   case CodeGenFileType::AssemblyFile:
136     PM.add(createDXILPrettyPrinterPass(Out));
137     PM.add(createPrintModulePass(Out, "", true));
138     break;
139   case CodeGenFileType::ObjectFile:
140     if (TargetPassConfig::willCompleteCodeGenPipeline()) {
141       PM.add(createDXILEmbedderPass());
142       // We embed the other DXContainer globals after embedding DXIL so that the
143       // globals don't pollute the DXIL.
144       PM.add(createDXContainerGlobalsPass());
145 
146       if (!MMIWP)
147         MMIWP = new MachineModuleInfoWrapperPass(this);
148       PM.add(MMIWP);
149       if (addAsmPrinter(PM, Out, DwoOut, FileType,
150                         MMIWP->getMMI().getContext()))
151         return true;
152     } else
153       PM.add(createDXILWriterPass(Out));
154     break;
155   case CodeGenFileType::Null:
156     break;
157   }
158   return false;
159 }
160 
161 bool DirectXTargetMachine::addPassesToEmitMC(PassManagerBase &PM,
162                                              MCContext *&Ctx,
163                                              raw_pwrite_stream &Out,
164                                              bool DisableVerify) {
165   return true;
166 }
167 
168 TargetPassConfig *DirectXTargetMachine::createPassConfig(PassManagerBase &PM) {
169   return new DirectXPassConfig(*this, PM);
170 }
171 
172 const DirectXSubtarget *
173 DirectXTargetMachine::getSubtargetImpl(const Function &) const {
174   return Subtarget.get();
175 }
176 
177 TargetTransformInfo
178 DirectXTargetMachine::getTargetTransformInfo(const Function &F) const {
179   return TargetTransformInfo(DirectXTTIImpl(this, F));
180 }
181 
182 DirectXTargetLowering::DirectXTargetLowering(const DirectXTargetMachine &TM,
183                                              const DirectXSubtarget &STI)
184     : TargetLowering(TM) {}
185