LLVM 18.0.0git
DirectXTargetMachine.cpp
Go to the documentation of this file.
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
16#include "DXILShaderFlags.h"
18#include "DirectX.h"
19#include "DirectXSubtarget.h"
23#include "llvm/CodeGen/Passes.h"
28#include "llvm/MC/SectionKind.h"
35#include <optional>
36
37using namespace llvm;
38
50}
51
53public:
55
57 const TargetMachine &TM) const override {
58 return getContext().getDXContainerSection(GO->getSection(), Kind);
59 }
60
61protected:
63 const TargetMachine &TM) const override {
64 llvm_unreachable("Not supported!");
65 }
66};
67
69public:
71 : TargetPassConfig(TM, PM) {}
72
74 return getTM<DirectXTargetMachine>();
75 }
76
77 FunctionPass *createTargetRegisterAllocator(bool) override { return nullptr; }
78 void addCodeGenPrepare() override {
82 }
83};
84
86 StringRef CPU, StringRef FS,
88 std::optional<Reloc::Model> RM,
89 std::optional<CodeModel::Model> CM,
90 CodeGenOptLevel OL, bool JIT)
92 "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
93 "f32:32-f64:64-n8:16:32:64",
94 TT, CPU, FS, Options, Reloc::Static, CodeModel::Small,
95 OL),
96 TLOF(std::make_unique<DXILTargetObjectFile>()),
97 Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {
99}
100
102
107 if (PassName == "print-dxil-resource") {
109 return true;
110 }
111 if (PassName == "print-dx-shader-flags") {
113 return true;
114 }
115 return false;
116 });
117
119 MAM.registerPass([&] { return DXILResourceAnalysis(); });
120 MAM.registerPass([&] { return dxil::ShaderFlagsAnalysis(); });
121 });
122}
123
126 CodeGenFileType FileType, bool DisableVerify,
128 TargetPassConfig *PassConfig = createPassConfig(PM);
129 PassConfig->addCodeGenPrepare();
130
131 switch (FileType) {
134 PM.add(createPrintModulePass(Out, "", true));
135 break;
139 // We embed the other DXContainer globals after embedding DXIL so that the
140 // globals don't pollute the DXIL.
142
143 if (!MMIWP)
144 MMIWP = new MachineModuleInfoWrapperPass(this);
145 PM.add(MMIWP);
146 if (addAsmPrinter(PM, Out, DwoOut, FileType,
147 MMIWP->getMMI().getContext()))
148 return true;
149 } else
150 PM.add(createDXILWriterPass(Out));
151 break;
153 break;
154 }
155 return false;
156}
157
159 MCContext *&Ctx,
161 bool DisableVerify) {
162 return true;
163}
164
166 return new DirectXPassConfig(*this, PM);
167}
168
169const DirectXSubtarget *
171 return Subtarget.get();
172}
173
176 return TargetTransformInfo(DirectXTTIImpl(this, F));
177}
178
180 const DirectXSubtarget &STI)
181 : TargetLowering(TM) {}
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
This file provides a bitcode writing pass.
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget()
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
This file contains an interface for creating legacy passes to print out IR in various granularities.
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
ModuleAnalysisManager MAM
const char LLVMTargetMachineRef TM
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
Target-Independent Code Generator Pass Configuration Options pass.
static const char PassName[]
DXILTargetObjectFile()=default
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
FunctionPass * createTargetRegisterAllocator(bool) override
createTargetRegisterAllocator - Create the register allocator pass for this target at the current opt...
void addCodeGenPrepare() override
Add pass to prepare the LLVM IR for code generation.
DirectXPassConfig(DirectXTargetMachine &TM, PassManagerBase &PM)
DirectXTargetMachine & getDirectXTargetMachine() const
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:836
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Analysis pass that exposes the DXILResource for a module.
Printer pass for the DXILResourceAnalysis results.
DirectXTargetLowering(const DirectXTargetMachine &TM, const DirectXSubtarget &STI)
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
DirectXTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT)
const DirectXSubtarget * getSubtargetImpl(const Function &) const override
Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...
bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, bool DisableVerify, MachineModuleInfoWrapperPass *MMIWP) override
Add passes to the specified pass manager to get the specified file emitted.
bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx, raw_pwrite_stream &Out, bool DisableVerify) override
Add passes to the specified pass manager to get machine code emitted with the MCJIT.
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:117
This class describes a target machine that is implemented with the LLVM target-independent code gener...
bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, MCContext &Context)
Adds an AsmPrinter pass to the pipeline that prints assembly or machine code from the MI representati...
Context object for machine code objects.
Definition: MCContext.h:76
MCSectionDXContainer * getDXContainerSection(StringRef Section, SectionKind K)
Get the section for the provided Section name.
Definition: MCContext.cpp:856
MCContext & getContext() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
const MCContext & getContext() const
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:103
void registerAnalysisRegistrationCallback(const std::function< void(CGSCCAnalysisManager &)> &C)
{{@ Register callbacks for analysis registration with this PassBuilder instance.
Definition: PassBuilder.h:508
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)
{{@ Register pipeline parsing callbacks with this pass builder instance.
Definition: PassBuilder.h:530
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:544
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
Target-Independent Code Generator Pass Configuration Options.
LLVMTargetMachine * TM
virtual void addCodeGenPrepare()
Add pass to prepare the LLVM IR for code generation.
AnalysisID addPass(AnalysisID PassID)
Utilities for targets to add passes to the pass manager.
static bool willCompleteCodeGenPipeline()
Returns true if none of the -stop-before and -stop-after options is set.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Printer pass for ShaderFlagsAnalysis results.
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
virtual void add(Pass *P)=0
Add a pass to the queue of passes to run.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:428
Interfaces for registering analysis passes, producing common pass manager configurations,...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void initializeShaderFlagsAnalysisWrapperPass(PassRegistry &)
Initializer for dxil::ShaderFlagsAnalysisWrapper pass.
ModulePass * createDXILWriterPass(raw_ostream &Str)
Create and return a pass that writes the module to the specified ostream.
ModulePass * createDXILPrepareModulePass()
Pass to convert modules into DXIL-compatable modules.
ModulePass * createDXContainerGlobalsPass()
Pass for generating DXContainer part globals.
Target & getTheDirectXTarget()
ModulePass * createDXILTranslateMetadataPass()
Pass to emit metadata for DXIL.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
Definition: CodeGen.h:83
ModulePass * createDXILPrettyPrinterPass(raw_ostream &OS)
Pass to pretty print DXIL metadata.
void initializeDXILPrepareModulePass(PassRegistry &)
Initializer for DXIL-prepare.
void initializeDXILResourceWrapperPass(PassRegistry &)
Initializer for DXILTranslateMetadata.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void initializeEmbedDXILPassPass(PassRegistry &)
Initializer for dxil embedder pass.
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
ModulePass * createDXILEmbedderPass()
Create and return a pass that writes the module to a global variable in the module for later emission...
ModulePass * createDXILOpLoweringLegacyPass()
Pass to lowering LLVM intrinsic call to DXIL op function call.
ModulePass * createPrintModulePass(raw_ostream &OS, const std::string &Banner="", bool ShouldPreserveUseListOrder=false)
Create and return a pass that writes the module to the specified raw_ostream.
void initializeDXILOpLoweringLegacyPass(PassRegistry &)
Initializer for DXILOpLowering.
void initializeWriteDXILPassPass(PassRegistry &)
Initializer for dxil writer pass.
void initializeDXILTranslateMetadataPass(PassRegistry &)
Initializer for DXILTranslateMetadata.
void initializeDXContainerGlobalsPass(PassRegistry &)
Initializer for DXContainerGlobals pass.
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
RegisterTargetMachine - Helper template for registering a target machine implementation,...