LLVM  9.0.0svn
NVPTXTargetMachine.cpp
Go to the documentation of this file.
1 //===-- NVPTXTargetMachine.cpp - Define TargetMachine for NVPTX -----------===//
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 // Top-level implementation for the NVPTX target.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "NVPTXTargetMachine.h"
14 #include "NVPTX.h"
15 #include "NVPTXAllocaHoisting.h"
16 #include "NVPTXLowerAggrCopies.h"
17 #include "NVPTXTargetObjectFile.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Triple.h"
22 #include "llvm/CodeGen/Passes.h"
25 #include "llvm/Pass.h"
31 #include "llvm/Transforms/Scalar.h"
34 #include <cassert>
35 #include <string>
36 
37 using namespace llvm;
38 
39 // LSV is still relatively new; this switch lets us turn it off in case we
40 // encounter (or suspect) a bug.
41 static cl::opt<bool>
42  DisableLoadStoreVectorizer("disable-nvptx-load-store-vectorizer",
43  cl::desc("Disable load/store vectorizer"),
44  cl::init(false), cl::Hidden);
45 
46 // TODO: Remove this flag when we are confident with no regressions.
48  "disable-nvptx-require-structured-cfg",
49  cl::desc("Transitional flag to turn off NVPTX's requirement on preserving "
50  "structured CFG. The requirement should be disabled only when "
51  "unexpected regressions happen."),
52  cl::init(false), cl::Hidden);
53 
55  "nvptx-short-ptr",
56  cl::desc(
57  "Use 32-bit pointers for accessing const/local/shared address spaces."),
58  cl::init(false), cl::Hidden);
59 
60 namespace llvm {
61 
71 
72 } // end namespace llvm
73 
74 extern "C" void LLVMInitializeNVPTXTarget() {
75  // Register the target.
78 
79  // FIXME: This pass is really intended to be invoked during IR optimization,
80  // but it's very NVPTX-specific.
91 }
92 
93 static std::string computeDataLayout(bool is64Bit, bool UseShortPointers) {
94  std::string Ret = "e";
95 
96  if (!is64Bit)
97  Ret += "-p:32:32";
98  else if (UseShortPointers)
99  Ret += "-p3:32:32-p4:32:32-p5:32:32";
100 
101  Ret += "-i64:64-i128:128-v16:16-v32:32-n16:32:64";
102 
103  return Ret;
104 }
105 
107  StringRef CPU, StringRef FS,
108  const TargetOptions &Options,
111  CodeGenOpt::Level OL, bool is64bit)
112  // The pic relocation model is used regardless of what the client has
113  // specified, as it is the only relocation model currently supported.
115  CPU, FS, Options, Reloc::PIC_,
116  getEffectiveCodeModel(CM, CodeModel::Small), OL),
117  is64bit(is64bit), UseShortPointers(UseShortPointersOpt),
119  Subtarget(TT, CPU, FS, *this) {
120  if (TT.getOS() == Triple::NVCL)
121  drvInterface = NVPTX::NVCL;
122  else
123  drvInterface = NVPTX::CUDA;
126  initAsmInfo();
127 }
128 
130 
131 void NVPTXTargetMachine32::anchor() {}
132 
134  StringRef CPU, StringRef FS,
135  const TargetOptions &Options,
138  CodeGenOpt::Level OL, bool JIT)
139  : NVPTXTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, false) {}
140 
141 void NVPTXTargetMachine64::anchor() {}
142 
144  StringRef CPU, StringRef FS,
145  const TargetOptions &Options,
148  CodeGenOpt::Level OL, bool JIT)
149  : NVPTXTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
150 
151 namespace {
152 
153 class NVPTXPassConfig : public TargetPassConfig {
154 public:
155  NVPTXPassConfig(NVPTXTargetMachine &TM, PassManagerBase &PM)
156  : TargetPassConfig(TM, PM) {}
157 
158  NVPTXTargetMachine &getNVPTXTargetMachine() const {
159  return getTM<NVPTXTargetMachine>();
160  }
161 
162  void addIRPasses() override;
163  bool addInstSelector() override;
164  void addPreRegAlloc() override;
165  void addPostRegAlloc() override;
166  void addMachineSSAOptimization() override;
167 
168  FunctionPass *createTargetRegisterAllocator(bool) override;
169  void addFastRegAlloc() override;
170  void addOptimizedRegAlloc() override;
171 
172  bool addRegAssignmentFast() override {
173  llvm_unreachable("should not be used");
174  }
175 
176  bool addRegAssignmentOptimized() override {
177  llvm_unreachable("should not be used");
178  }
179 
180 private:
181  // If the opt level is aggressive, add GVN; otherwise, add EarlyCSE. This
182  // function is only called in opt mode.
183  void addEarlyCSEOrGVNPass();
184 
185  // Add passes that propagate special memory spaces.
186  void addAddressSpaceInferencePasses();
187 
188  // Add passes that perform straight-line scalar optimizations.
189  void addStraightLineScalarOptimizationPasses();
190 };
191 
192 } // end anonymous namespace
193 
195  return new NVPTXPassConfig(*this, PM);
196 }
197 
199  Builder.addExtension(
201  [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
202  PM.add(createNVVMReflectPass(Subtarget.getSmVersion()));
203  PM.add(createNVVMIntrRangePass(Subtarget.getSmVersion()));
204  });
205 }
206 
209  return TargetTransformInfo(NVPTXTTIImpl(this, F));
210 }
211 
212 void NVPTXPassConfig::addEarlyCSEOrGVNPass() {
214  addPass(createGVNPass());
215  else
216  addPass(createEarlyCSEPass());
217 }
218 
219 void NVPTXPassConfig::addAddressSpaceInferencePasses() {
220  // NVPTXLowerArgs emits alloca for byval parameters which can often
221  // be eliminated by SROA.
222  addPass(createSROAPass());
223  addPass(createNVPTXLowerAllocaPass());
224  addPass(createInferAddressSpacesPass());
225 }
226 
227 void NVPTXPassConfig::addStraightLineScalarOptimizationPasses() {
230  // ReassociateGEPs exposes more opportunites for SLSR. See
231  // the example in reassociate-geps-and-slsr.ll.
233  // SeparateConstOffsetFromGEP and SLSR creates common expressions which GVN or
234  // EarlyCSE can reuse. GVN generates significantly better code than EarlyCSE
235  // for some of our benchmarks.
236  addEarlyCSEOrGVNPass();
237  // Run NaryReassociate after EarlyCSE/GVN to be more effective.
238  addPass(createNaryReassociatePass());
239  // NaryReassociate on GEPs creates redundant common expressions, so run
240  // EarlyCSE after it.
241  addPass(createEarlyCSEPass());
242 }
243 
244 void NVPTXPassConfig::addIRPasses() {
245  // The following passes are known to not play well with virtual regs hanging
246  // around after register allocation (which in our case, is *all* registers).
247  // We explicitly disable them here. We do, however, need some functionality
248  // of the PrologEpilogCodeInserter pass, so we emulate that behavior in the
249  // NVPTXPrologEpilog pass (see NVPTXPrologEpilogPass.cpp).
250  disablePass(&PrologEpilogCodeInserterID);
251  disablePass(&MachineCopyPropagationID);
252  disablePass(&TailDuplicateID);
253  disablePass(&StackMapLivenessID);
254  disablePass(&LiveDebugValuesID);
255  disablePass(&PostRAMachineSinkingID);
256  disablePass(&PostRASchedulerID);
257  disablePass(&FuncletLayoutID);
258  disablePass(&PatchableFunctionID);
259  disablePass(&ShrinkWrapID);
260 
261  // NVVMReflectPass is added in addEarlyAsPossiblePasses, so hopefully running
262  // it here does nothing. But since we need it for correctness when lowering
263  // to NVPTX, run it here too, in case whoever built our pass pipeline didn't
264  // call addEarlyAsPossiblePasses.
265  const NVPTXSubtarget &ST = *getTM<NVPTXTargetMachine>().getSubtargetImpl();
266  addPass(createNVVMReflectPass(ST.getSmVersion()));
267 
268  if (getOptLevel() != CodeGenOpt::None)
271  addPass(createGenericToNVVMPass());
272 
273  // NVPTXLowerArgs is required for correctness and should be run right
274  // before the address space inference passes.
275  addPass(createNVPTXLowerArgsPass(&getNVPTXTargetMachine()));
276  if (getOptLevel() != CodeGenOpt::None) {
277  addAddressSpaceInferencePasses();
280  addStraightLineScalarOptimizationPasses();
281  }
282 
283  // === LSR and other generic IR passes ===
285  // EarlyCSE is not always strong enough to clean up what LSR produces. For
286  // example, GVN can combine
287  //
288  // %0 = add %a, %b
289  // %1 = add %b, %a
290  //
291  // and
292  //
293  // %0 = shl nsw %a, 2
294  // %1 = shl %a, 2
295  //
296  // but EarlyCSE can do neither of them.
297  if (getOptLevel() != CodeGenOpt::None)
298  addEarlyCSEOrGVNPass();
299 }
300 
301 bool NVPTXPassConfig::addInstSelector() {
302  const NVPTXSubtarget &ST = *getTM<NVPTXTargetMachine>().getSubtargetImpl();
303 
304  addPass(createLowerAggrCopies());
305  addPass(createAllocaHoisting());
306  addPass(createNVPTXISelDag(getNVPTXTargetMachine(), getOptLevel()));
307 
308  if (!ST.hasImageHandles())
310 
311  return false;
312 }
313 
314 void NVPTXPassConfig::addPreRegAlloc() {
315  // Remove Proxy Register pseudo instructions used to keep `callseq_end` alive.
317 }
318 
319 void NVPTXPassConfig::addPostRegAlloc() {
320  addPass(createNVPTXPrologEpilogPass(), false);
321  if (getOptLevel() != CodeGenOpt::None) {
322  // NVPTXPrologEpilogPass calculates frame object offset and replace frame
323  // index with VRFrame register. NVPTXPeephole need to be run after that and
324  // will replace VRFrame with VRFrameLocal when possible.
325  addPass(createNVPTXPeephole());
326  }
327 }
328 
329 FunctionPass *NVPTXPassConfig::createTargetRegisterAllocator(bool) {
330  return nullptr; // No reg alloc
331 }
332 
333 void NVPTXPassConfig::addFastRegAlloc() {
334  addPass(&PHIEliminationID);
335  addPass(&TwoAddressInstructionPassID);
336 }
337 
338 void NVPTXPassConfig::addOptimizedRegAlloc() {
339  addPass(&ProcessImplicitDefsID);
340  addPass(&LiveVariablesID);
341  addPass(&MachineLoopInfoID);
342  addPass(&PHIEliminationID);
343 
344  addPass(&TwoAddressInstructionPassID);
345  addPass(&RegisterCoalescerID);
346 
347  // PreRA instruction scheduling.
348  if (addPass(&MachineSchedulerID))
349  printAndVerify("After Machine Scheduling");
350 
351 
352  addPass(&StackSlotColoringID);
353 
354  // FIXME: Needs physical registers
355  //addPass(&MachineLICMID);
356 
357  printAndVerify("After StackSlotColoring");
358 }
359 
360 void NVPTXPassConfig::addMachineSSAOptimization() {
361  // Pre-ra tail duplication.
362  if (addPass(&EarlyTailDuplicateID))
363  printAndVerify("After Pre-RegAlloc TailDuplicate");
364 
365  // Optimize PHIs before DCE: removing dead PHI cycles may make more
366  // instructions dead.
367  addPass(&OptimizePHIsID);
368 
369  // This pass merges large allocas. StackSlotColoring is a different pass
370  // which merges spill slots.
371  addPass(&StackColoringID);
372 
373  // If the target requests it, assign local variables to stack slots relative
374  // to one another and simplify frame index references where possible.
375  addPass(&LocalStackSlotAllocationID);
376 
377  // With optimization, dead code should already be eliminated. However
378  // there is one known exception: lowered code for arguments that are only
379  // used by tail calls, where the tail calls reuse the incoming stack
380  // arguments directly (see t11 in test/CodeGen/X86/sibcall.ll).
382  printAndVerify("After codegen DCE pass");
383 
384  // Allow targets to insert passes that improve instruction level parallelism,
385  // like if-conversion. Such passes will typically need dominator trees and
386  // loop info, just like LICM and CSE below.
387  if (addILPOpts())
388  printAndVerify("After ILP optimizations");
389 
390  addPass(&EarlyMachineLICMID);
391  addPass(&MachineCSEID);
392 
393  addPass(&MachineSinkingID);
394  printAndVerify("After Machine LICM, CSE and Sinking passes");
395 
396  addPass(&PeepholeOptimizerID);
397  printAndVerify("After codegen peephole optimization pass");
398 }
FunctionPass * createSpeculativeExecutionPass()
FunctionPass * createStraightLineStrengthReducePass()
FunctionPass * createGVNPass(bool NoLoads=false)
Create a legacy GVN pass.
Definition: GVN.cpp:2590
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
void initializeNVPTXLowerArgsPass(PassRegistry &)
CodeModel::Model getEffectiveCodeModel(Optional< CodeModel::Model > CM, CodeModel::Model Default)
Helper method for getting the code model, returning Default if CM does not have a value...
MachineFunctionPass * createNVPTXProxyRegErasurePass()
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void LLVMInitializeNVPTXTarget()
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:300
ModulePass * createNVPTXAssignValidGlobalNamesPass()
char & FuncletLayoutID
This pass lays out funclets contiguously.
FunctionPass * createAllocaHoisting()
static cl::opt< bool > DisableRequireStructuredCFG("disable-nvptx-require-structured-cfg", cl::desc("Transitional flag to turn off NVPTX's requirement on preserving " "structured CFG. The requirement should be disabled only when " "unexpected regressions happen."), cl::init(false), cl::Hidden)
char & RegisterCoalescerID
RegisterCoalescer - This pass merges live ranges to eliminate copies.
virtual void add(Pass *P)=0
Add a pass to the queue of passes to run.
MachineFunctionPass * createNVPTXPrologEpilogPass()
F(f)
char & MachineSchedulerID
MachineScheduler - This pass schedules machine instructions.
block Block Frequency true
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:1393
ModulePass * createGenericToNVVMPass()
char & ProcessImplicitDefsID
ProcessImpicitDefs pass - This pass removes IMPLICIT_DEFs.
void initializeNVPTXAssignValidGlobalNamesPass(PassRegistry &)
FunctionPass * createNVVMReflectPass(unsigned int SmVersion)
Definition: NVVMReflect.cpp:62
NVPTXTargetMachine64(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
bool hasImageHandles() const
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
char & MachineLoopInfoID
MachineLoopInfo - This pass is a loop analysis pass.
char & StackColoringID
StackSlotColoring - This pass performs stack coloring and merging.
Target-Independent Code Generator Pass Configuration Options.
Target & getTheNVPTXTarget64()
static cl::opt< bool > UseShortPointersOpt("nvptx-short-ptr", cl::desc("Use 32-bit pointers for accessing const/local/shared address spaces."), cl::init(false), cl::Hidden)
char & EarlyTailDuplicateID
Duplicate blocks with unconditional branches into tails of their predecessors.
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
char & MachineCSEID
MachineCSE - This pass performs global CSE on machine instructions.
Definition: MachineCSE.cpp:132
char & StackSlotColoringID
StackSlotColoring - This pass performs stack slot coloring.
char & DeadMachineInstructionElimID
DeadMachineInstructionElim - This pass removes dead machine instructions.
Pass * createLoadStoreVectorizerPass()
Create a legacy pass manager instance of the LoadStoreVectorizer pass.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
FunctionPass * createNVPTXImageOptimizerPass()
void initializeNVVMIntrRangePass(PassRegistry &)
TargetTransformInfo getTargetTransformInfo(const Function &F) override
Get a TargetTransformInfo implementation for the target.
char & PHIEliminationID
PHIElimination - This pass eliminates machine instruction PHI nodes by inserting copy instructions...
Target & getTheNVPTXTarget32()
char & LiveVariablesID
LiveVariables pass - This pass computes the set of blocks in which each variable is life and sets mac...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:427
This file a TargetTransformInfo::Concept conforming object specific to the NVPTX target machine...
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
static std::string computeDataLayout(bool is64Bit, bool UseShortPointers)
void initializeNVPTXLowerAggrCopiesPass(PassRegistry &)
void initializeNVVMReflectPass(PassRegistry &)
NVPTXTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OP, bool is64bit)
This file provides the interface for LLVM&#39;s Global Value Numbering pass which eliminates fully redund...
static bool is64Bit(const char *name)
MachineFunctionPass * createNVPTXReplaceImageHandlesPass()
char & PostRAMachineSinkingID
This pass perform post-ra machine sink for COPY instructions.
char & LiveDebugValuesID
LiveDebugValues pass.
This class describes a target machine that is implemented with the LLVM target-independent code gener...
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
void initializeNVPTXAllocaHoistingPass(PassRegistry &)
char & MachineCopyPropagationID
MachineCopyPropagation - This pass performs copy propagation on machine instructions.
char & TwoAddressInstructionPassID
TwoAddressInstruction - This pass reduces two-address instructions to use two operands.
void initializeGenericToNVVMPass(PassRegistry &)
EP_EarlyAsPossible - This extension point allows adding passes before any other transformations, allowing them to see the code as it is coming out of the frontend.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
char & PostRASchedulerID
createPostRAScheduler - This pass performs post register allocation scheduling.
void initializeNVPTXLowerAllocaPass(PassRegistry &)
NVPTXTargetMachine32(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
BasicBlockPass * createNVPTXLowerAllocaPass()
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
char & StackMapLivenessID
StackMapLiveness - This pass analyses the register live-out set of stackmap/patchpoint intrinsics and...
char & TailDuplicateID
TailDuplicate - Duplicate blocks with unconditional branches into tails of their predecessors.
char & MachineSinkingID
MachineSinking - This pass performs sinking on machine instructions.
void setRequiresStructuredCFG(bool Value)
char & EarlyMachineLICMID
This pass performs loop invariant code motion on machine instructions.
char & OptimizePHIsID
OptimizePHIs - This pass optimizes machine instruction PHIs to take advantage of opportunities create...
FunctionPass * createSeparateConstOffsetFromGEPPass(bool LowerGEP=false)
Target - Wrapper for Target specific information.
char & PeepholeOptimizerID
PeepholeOptimizer - This pass performs peephole optimizations - like extension and comparison elimina...
void initializeNVPTXProxyRegErasurePass(PassRegistry &)
char & PrologEpilogCodeInserterID
PrologEpilogCodeInserter - This pass inserts prolog and epilog code, and eliminates abstract frame re...
char & PatchableFunctionID
This pass implements the "patchable-function" attribute.
FunctionPass * createInferAddressSpacesPass()
NVPTXTargetMachine.
MachineFunctionPass * createNVPTXPeephole()
FunctionPass * createNVPTXISelDag(NVPTXTargetMachine &TM, llvm::CodeGenOpt::Level OptLevel)
createNVPTXISelDag - This pass converts a legalized DAG into a NVPTX-specific DAG, ready for instruction scheduling.
~NVPTXTargetMachine() override
FunctionPass * createNVVMIntrRangePass(unsigned int SmVersion)
FunctionPass * createNVPTXLowerArgsPass(const NVPTXTargetMachine *TM)
FunctionPass * createLowerAggrCopies()
TargetOptions Options
void adjustPassManager(PassManagerBuilder &) override
Allow the target to modify the pass manager, e.g.
FunctionPass * createSROAPass()
Definition: SROA.cpp:4596
const NVPTXSubtarget * getSubtargetImpl() const
unsigned int getSmVersion() const
FunctionPass * createEarlyCSEPass(bool UseMemorySSA=false)
Definition: EarlyCSE.cpp:1358
static cl::opt< bool > DisableLoadStoreVectorizer("disable-nvptx-load-store-vectorizer", cl::desc("Disable load/store vectorizer"), cl::init(false), cl::Hidden)
char & ShrinkWrapID
ShrinkWrap pass. Look for the best place to insert save and restore.
Definition: ShrinkWrap.cpp:249
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
This pass exposes codegen information to IR-level passes.
void addExtension(ExtensionPointTy Ty, ExtensionFn Fn)
char & LocalStackSlotAllocationID
LocalStackSlotAllocation - This pass assigns local frame indices to stack slots relative to one anoth...
FunctionPass * createNaryReassociatePass()