LLVM 19.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
51}
52
54public:
56
58 const TargetMachine &TM) const override {
59 return getContext().getDXContainerSection(GO->getSection(), Kind);
60 }
61
62protected:
64 const TargetMachine &TM) const override {
65 llvm_unreachable("Not supported!");
66 }
67};
68
70public:
72 : TargetPassConfig(TM, PM) {}
73
75 return getTM<DirectXTargetMachine>();
76 }
77
78 FunctionPass *createTargetRegisterAllocator(bool) override { return nullptr; }
79 void addCodeGenPrepare() override {
84 }
85};
86
88 StringRef CPU, StringRef FS,
90 std::optional<Reloc::Model> RM,
91 std::optional<CodeModel::Model> CM,
92 CodeGenOptLevel OL, bool JIT)
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
104
106#define GET_PASS_REGISTRY "DirectXPassRegistry.def"
108}
109
112 CodeGenFileType FileType, bool DisableVerify,
114 TargetPassConfig *PassConfig = createPassConfig(PM);
115 PassConfig->addCodeGenPrepare();
116
117 switch (FileType) {
120 PM.add(createPrintModulePass(Out, "", true));
121 break;
125 // We embed the other DXContainer globals after embedding DXIL so that the
126 // globals don't pollute the DXIL.
128
129 if (!MMIWP)
130 MMIWP = new MachineModuleInfoWrapperPass(this);
131 PM.add(MMIWP);
132 if (addAsmPrinter(PM, Out, DwoOut, FileType,
133 MMIWP->getMMI().getContext()))
134 return true;
135 } else
136 PM.add(createDXILWriterPass(Out));
137 break;
139 break;
140 }
141 return false;
142}
143
145 MCContext *&Ctx,
147 bool DisableVerify) {
148 return true;
149}
150
152 return new DirectXPassConfig(*this, PM);
153}
154
155const DirectXSubtarget *
157 return Subtarget.get();
158}
159
162 return TargetTransformInfo(DirectXTTIImpl(this, F));
163}
164
166 const DirectXSubtarget &STI)
167 : 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
const char LLVMTargetMachineRef TM
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
Target-Independent Code Generator Pass Configuration Options pass.
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
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:118
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:83
MCSectionDXContainer * getDXContainerSection(StringRef Section, SectionKind K)
Get the section for the provided Section name.
Definition: MCContext.cpp:869
MCContext & getContext() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
const MCContext & getContext() const
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:106
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:77
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
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:434
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.
void initializeEmbedDXILPassPass(PassRegistry &)
Initializer for dxil embedder pass.
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
ModulePass * createDXILIntrinsicExpansionLegacyPass()
Pass to expand intrinsic operations that lack DXIL opCodes.
void initializeDXILIntrinsicExpansionLegacyPass(PassRegistry &)
Initializer for DXIL Intrinsic Expansion.
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,...