150
|
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) {
|
252
|
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;
|
150
|
39
|
|
40 switch (cast<BuiltinType>(T)->getKind()) {
|
|
41 default:
|
|
42 llvm_unreachable("Unexpected opencl builtin type!");
|
|
43 return nullptr;
|
236
|
44 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
|
|
45 case BuiltinType::Id: \
|
|
46 return getPointerType(T, "opencl." #ImgType "_" #Suffix "_t");
|
150
|
47 #include "clang/Basic/OpenCLImageTypes.def"
|
|
48 case BuiltinType::OCLSampler:
|
|
49 return getSamplerType(T);
|
|
50 case BuiltinType::OCLEvent:
|
236
|
51 return getPointerType(T, "opencl.event_t");
|
150
|
52 case BuiltinType::OCLClkEvent:
|
236
|
53 return getPointerType(T, "opencl.clk_event_t");
|
150
|
54 case BuiltinType::OCLQueue:
|
236
|
55 return getPointerType(T, "opencl.queue_t");
|
150
|
56 case BuiltinType::OCLReserveID:
|
236
|
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);
|
150
|
61 #include "clang/Basic/OpenCLExtensionTypes.def"
|
|
62 }
|
|
63 }
|
|
64
|
236
|
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
|
150
|
80 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) {
|
252
|
81 if (llvm::Type *PipeTy = CGM.getTargetCodeGenInfo().getOpenCLType(CGM, T))
|
|
82 return PipeTy;
|
|
83
|
150
|
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
|
252
|
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)));
|
150
|
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);
|
252
|
137 return llvm::PointerType::get(
|
150
|
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,
|
236
|
163 llvm::Value *Block, llvm::Type *BlockTy) {
|
252
|
164 assert(!EnqueuedBlockMap.contains(E) && "Block expression emitted twice");
|
150
|
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;
|
236
|
169 EnqueuedBlockMap[E].BlockTy = BlockTy;
|
252
|
170 EnqueuedBlockMap[E].KernelHandle = nullptr;
|
150
|
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
|
252
|
185 assert(EnqueuedBlockMap.contains(Block) && "Block expression not emitted");
|
150
|
186
|
|
187 // Do not emit the block wrapper again if it has been emitted.
|
252
|
188 if (EnqueuedBlockMap[Block].KernelHandle) {
|
150
|
189 return EnqueuedBlockMap[Block];
|
|
190 }
|
|
191
|
|
192 auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel(
|
236
|
193 CGF, EnqueuedBlockMap[Block].InvokeFunc, EnqueuedBlockMap[Block].BlockTy);
|
150
|
194
|
|
195 // The common part of the post-processing of the kernel goes here.
|
252
|
196 EnqueuedBlockMap[Block].KernelHandle = F;
|
150
|
197 return EnqueuedBlockMap[Block];
|
|
198 }
|