LLVM  6.0.0svn
AMDGPUOpenCLEnqueuedBlockLowering.cpp
Go to the documentation of this file.
1 //===- AMDGPUOpenCLEnqueuedBlockLowering.cpp - Lower enqueued block -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // \file
11 // \brief This post-linking pass replaces the function pointer of enqueued
12 // block kernel with a global variable (runtime handle) and adds
13 // "runtime-handle" attribute to the enqueued block kernel.
14 //
15 // In LLVM CodeGen the runtime-handle metadata will be translated to
16 // RuntimeHandle metadata in code object. Runtime allocates a global buffer
17 // for each kernel with RuntimeHandel metadata and saves the kernel address
18 // required for the AQL packet into the buffer. __enqueue_kernel function
19 // in device library knows that the invoke function pointer in the block
20 // literal is actually runtime handle and loads the kernel address from it
21 // and put it into AQL packet for dispatching.
22 //
23 // This cannot be done in FE since FE cannot create a unique global variable
24 // with external linkage across LLVM modules. The global variable with internal
25 // linkage does not work since optimization passes will try to replace loads
26 // of the global variable with its initialization value.
27 //
28 // It also identifies the kernels directly or indirectly enqueues kernels
29 // and adds "calls-enqueue-kernel" function attribute to them, which will
30 // be used to determine whether to emit runtime metadata for the kernel
31 // enqueue related hidden kernel arguments.
32 //
33 //===----------------------------------------------------------------------===//
34 
35 #include "AMDGPU.h"
36 #include "llvm/ADT/DenseSet.h"
37 #include "llvm/ADT/StringRef.h"
38 #include "llvm/IR/Constants.h"
39 #include "llvm/IR/Instructions.h"
40 #include "llvm/IR/Module.h"
41 #include "llvm/IR/User.h"
42 #include "llvm/Pass.h"
43 #include "llvm/Support/Debug.h"
45 
46 #define DEBUG_TYPE "amdgpu-lower-enqueued-block"
47 
48 using namespace llvm;
49 
50 namespace {
51 
52 /// \brief Lower enqueued blocks.
53 class AMDGPUOpenCLEnqueuedBlockLowering : public ModulePass {
54 public:
55  static char ID;
56 
57  explicit AMDGPUOpenCLEnqueuedBlockLowering() : ModulePass(ID) {}
58 
59 private:
60  bool runOnModule(Module &M) override;
61 };
62 
63 } // end anonymous namespace
64 
66 
69 
70 INITIALIZE_PASS(AMDGPUOpenCLEnqueuedBlockLowering, DEBUG_TYPE,
71  "Lower OpenCL enqueued blocks", false, false)
72 
74  return new AMDGPUOpenCLEnqueuedBlockLowering();
75 }
76 
77 /// Collect direct or indrect callers of \p F and save them
78 /// to \p Callers.
79 static void collectCallers(Function *F, DenseSet<Function *> &Callers) {
80  for (auto U : F->users()) {
81  if (auto *CI = dyn_cast<CallInst>(&*U)) {
82  auto *Caller = CI->getParent()->getParent();
83  if (Callers.count(Caller))
84  continue;
85  Callers.insert(Caller);
86  collectCallers(Caller, Callers);
87  }
88  }
89 }
90 
91 bool AMDGPUOpenCLEnqueuedBlockLowering::runOnModule(Module &M) {
92  DenseSet<Function *> Callers;
93  auto &C = M.getContext();
94  bool Changed = false;
95  for (auto &F : M.functions()) {
96  if (F.hasFnAttribute("enqueued-block")) {
97  if (!F.hasOneUse() || !F.user_begin()->hasOneUse() ||
98  !isa<ConstantExpr>(*F.user_begin()) ||
99  !isa<ConstantExpr>(*F.user_begin()->user_begin())) {
100  continue;
101  }
102  auto *BitCast = cast<ConstantExpr>(*F.user_begin());
103  auto *AddrCast = cast<ConstantExpr>(*BitCast->user_begin());
104  auto RuntimeHandle = (F.getName() + "_runtime_handle").str();
105  auto *GV = new GlobalVariable(
106  M, Type::getInt8Ty(C)->getPointerTo(AMDGPUAS::GLOBAL_ADDRESS),
107  /*IsConstant=*/true, GlobalValue::ExternalLinkage,
108  /*Initializer=*/nullptr, RuntimeHandle, /*InsertBefore=*/nullptr,
110  /*IsExternallyInitialized=*/true);
111  DEBUG(dbgs() << "runtime handle created: " << *GV << '\n');
112  auto *NewPtr = ConstantExpr::getPointerCast(GV, AddrCast->getType());
113  AddrCast->replaceAllUsesWith(NewPtr);
114  F.addFnAttr("runtime-handle", RuntimeHandle);
115  F.setLinkage(GlobalValue::ExternalLinkage);
116 
117  // Collect direct or indirect callers of enqueue_kernel.
118  for (auto U : NewPtr->users()) {
119  if (auto *I = dyn_cast<Instruction>(&*U)) {
120  auto *F = I->getParent()->getParent();
121  Callers.insert(F);
122  collectCallers(F, Callers);
123  }
124  }
125  Changed = true;
126  }
127  }
128 
129  for (auto F : Callers) {
130  if (F->getCallingConv() != CallingConv::AMDGPU_KERNEL)
131  continue;
132  F->addFnAttr("calls-enqueue-kernel");
133  }
134  return Changed;
135 }
static void collectCallers(Function *F, DenseSet< Function *> &Callers)
Collect direct or indrect callers of F and save them to Callers.
uint64_t CallInst * C
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
Externally visible function.
Definition: GlobalValue.h:49
char & AMDGPUOpenCLEnqueuedBlockLoweringID
F(f)
constexpr char RuntimeHandle[]
Key for Kernel::Attr::Metadata::mRuntimeHandle.
Address space for global memory (RAT0, VTX0).
Definition: AMDGPU.h:224
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:237
ModulePass * createAMDGPUOpenCLEnqueuedBlockLoweringPass()
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:430
iterator_range< iterator > functions()
Definition: Module.h:583
This file contains the declarations for the subclasses of Constant, which represent the different fla...
INITIALIZE_PASS(AMDGPUOpenCLEnqueuedBlockLowering, DEBUG_TYPE, "Lower OpenCL enqueued blocks", false, false) ModulePass *llvm
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:201
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:1492
Module.h This file contains the declarations for the Module class.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
iterator_range< user_iterator > users()
Definition: Value.h:401
#define I(x, y, z)
Definition: MD5.cpp:58
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:225
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
#define DEBUG(X)
Definition: Debug.h:118
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174