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