1 //===----- CGOpenCLRuntime.cpp - Interface to OpenCL Runtimes -------------===//
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 // This provides an abstract class for OpenCL code generation.  Concrete
10 // subclasses of this implement code generation for specific OpenCL
11 // runtime libraries.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "CGOpenCLRuntime.h"
16 #include "CodeGenFunction.h"
17 #include "TargetInfo.h"
18 #include "clang/CodeGen/ConstantInitBuilder.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/GlobalValue.h"
21 #include <assert.h>
22 
23 using namespace clang;
24 using namespace CodeGen;
25 
26 CGOpenCLRuntime::~CGOpenCLRuntime() {}
27 
28 void CGOpenCLRuntime::EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,
29                                                 const VarDecl &D) {
30   return CGF.EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
31 }
32 
33 llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {
34   assert(T->isOpenCLSpecificType() && "Not an OpenCL specific type!");
35 
36   // Check if the target has a specific translation for this type first.
37   if (llvm::Type *TransTy = CGM.getTargetCodeGenInfo().getOpenCLType(CGM, T))
38     return TransTy;
39 
40   switch (cast<BuiltinType>(T)->getKind()) {
41   default:
42     llvm_unreachable("Unexpected opencl builtin type!");
43     return nullptr;
44 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
45   case BuiltinType::Id:                                                        \
46     return getPointerType(T, "opencl." #ImgType "_" #Suffix "_t");
47 #include "clang/Basic/OpenCLImageTypes.def"
48   case BuiltinType::OCLSampler:
49     return getSamplerType(T);
50   case BuiltinType::OCLEvent:
51     return getPointerType(T, "opencl.event_t");
52   case BuiltinType::OCLClkEvent:
53     return getPointerType(T, "opencl.clk_event_t");
54   case BuiltinType::OCLQueue:
55     return getPointerType(T, "opencl.queue_t");
56   case BuiltinType::OCLReserveID:
57     return getPointerType(T, "opencl.reserve_id_t");
58 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
59   case BuiltinType::Id:                                                        \
60     return getPointerType(T, "opencl." #ExtType);
61 #include "clang/Basic/OpenCLExtensionTypes.def"
62   }
63 }
64 
65 llvm::PointerType *CGOpenCLRuntime::getPointerType(const Type *T,
66                                                    StringRef Name) {
67   auto I = CachedTys.find(Name);
68   if (I != CachedTys.end())
69     return I->second;
70 
71   llvm::LLVMContext &Ctx = CGM.getLLVMContext();
72   uint32_t AddrSpc = CGM.getContext().getTargetAddressSpace(
73       CGM.getContext().getOpenCLTypeAddrSpace(T));
74   auto *PTy =
75       llvm::PointerType::get(llvm::StructType::create(Ctx, Name), AddrSpc);
76   CachedTys[Name] = PTy;
77   return PTy;
78 }
79 
80 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) {
81   if (llvm::Type *PipeTy = CGM.getTargetCodeGenInfo().getOpenCLType(CGM, T))
82     return PipeTy;
83 
84   if (T->isReadOnly())
85     return getPipeType(T, "opencl.pipe_ro_t", PipeROTy);
86   else
87     return getPipeType(T, "opencl.pipe_wo_t", PipeWOTy);
88 }
89 
90 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name,
91                                          llvm::Type *&PipeTy) {
92   if (!PipeTy)
93     PipeTy = llvm::PointerType::get(llvm::StructType::create(
94       CGM.getLLVMContext(), Name),
95       CGM.getContext().getTargetAddressSpace(
96           CGM.getContext().getOpenCLTypeAddrSpace(T)));
97   return PipeTy;
98 }
99 
100 llvm::Type *CGOpenCLRuntime::getSamplerType(const Type *T) {
101   if (SamplerTy)
102     return SamplerTy;
103 
104   if (llvm::Type *TransTy = CGM.getTargetCodeGenInfo().getOpenCLType(
105           CGM, CGM.getContext().OCLSamplerTy.getTypePtr()))
106     SamplerTy = TransTy;
107   else
108     SamplerTy = llvm::PointerType::get(
109         llvm::StructType::create(CGM.getLLVMContext(), "opencl.sampler_t"),
110         CGM.getContext().getTargetAddressSpace(
111             CGM.getContext().getOpenCLTypeAddrSpace(T)));
112   return SamplerTy;
113 }
114 
115 llvm::Value *CGOpenCLRuntime::getPipeElemSize(const Expr *PipeArg) {
116   const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>();
117   // The type of the last (implicit) argument to be passed.
118   llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());
119   unsigned TypeSize = CGM.getContext()
120                           .getTypeSizeInChars(PipeTy->getElementType())
121                           .getQuantity();
122   return llvm::ConstantInt::get(Int32Ty, TypeSize, false);
123 }
124 
125 llvm::Value *CGOpenCLRuntime::getPipeElemAlign(const Expr *PipeArg) {
126   const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>();
127   // The type of the last (implicit) argument to be passed.
128   llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());
129   unsigned TypeSize = CGM.getContext()
130                           .getTypeAlignInChars(PipeTy->getElementType())
131                           .getQuantity();
132   return llvm::ConstantInt::get(Int32Ty, TypeSize, false);
133 }
134 
135 llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() {
136   assert(CGM.getLangOpts().OpenCL);
137   return llvm::IntegerType::getInt8PtrTy(
138       CGM.getLLVMContext(),
139       CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));
140 }
141 
142 // Get the block literal from an expression derived from the block expression.
143 // OpenCL v2.0 s6.12.5:
144 // Block variable declarations are implicitly qualified with const. Therefore
145 // all block variables must be initialized at declaration time and may not be
146 // reassigned.
147 static const BlockExpr *getBlockExpr(const Expr *E) {
148   const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop.
149   while(!isa<BlockExpr>(E) && E != Prev) {
150     Prev = E;
151     E = E->IgnoreCasts();
152     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
153       E = cast<VarDecl>(DR->getDecl())->getInit();
154     }
155   }
156   return cast<BlockExpr>(E);
157 }
158 
159 /// Record emitted llvm invoke function and llvm block literal for the
160 /// corresponding block expression.
161 void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E,
162                                       llvm::Function *InvokeF,
163                                       llvm::Value *Block, llvm::Type *BlockTy) {
164   assert(!EnqueuedBlockMap.contains(E) && "Block expression emitted twice");
165   assert(isa<llvm::Function>(InvokeF) && "Invalid invoke function");
166   assert(Block->getType()->isPointerTy() && "Invalid block literal type");
167   EnqueuedBlockMap[E].InvokeFunc = InvokeF;
168   EnqueuedBlockMap[E].BlockArg = Block;
169   EnqueuedBlockMap[E].BlockTy = BlockTy;
170   EnqueuedBlockMap[E].KernelHandle = nullptr;
171 }
172 
173 llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) {
174   return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc;
175 }
176 
177 CGOpenCLRuntime::EnqueuedBlockInfo
178 CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) {
179   CGF.EmitScalarExpr(E);
180 
181   // The block literal may be assigned to a const variable. Chasing down
182   // to get the block literal.
183   const BlockExpr *Block = getBlockExpr(E);
184 
185   assert(EnqueuedBlockMap.contains(Block) && "Block expression not emitted");
186 
187   // Do not emit the block wrapper again if it has been emitted.
188   if (EnqueuedBlockMap[Block].KernelHandle) {
189     return EnqueuedBlockMap[Block];
190   }
191 
192   auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel(
193       CGF, EnqueuedBlockMap[Block].InvokeFunc, EnqueuedBlockMap[Block].BlockTy);
194 
195   // The common part of the post-processing of the kernel goes here.
196   EnqueuedBlockMap[Block].KernelHandle = F;
197   return EnqueuedBlockMap[Block];
198 }
199