/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 | 330 | CGOpenCLRuntime::~CGOpenCLRuntime() {} |
27 | | |
28 | | void CGOpenCLRuntime::EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF, |
29 | 122 | const VarDecl &D) { |
30 | 122 | return CGF.EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage); |
31 | 122 | } |
32 | | |
33 | 75 | llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) { |
34 | 75 | assert(T->isOpenCLSpecificType() && |
35 | 75 | "Not an OpenCL specific type!"); |
36 | | |
37 | 75 | llvm::LLVMContext& Ctx = CGM.getLLVMContext(); |
38 | 75 | uint32_t AddrSpc = CGM.getContext().getTargetAddressSpace( |
39 | 75 | CGM.getContext().getOpenCLTypeAddrSpace(T)); |
40 | 75 | 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 | 34 | case BuiltinType::Id: \ |
46 | 34 | return llvm::PointerType::get( \ |
47 | 34 | llvm::StructType::create(Ctx, "opencl." #ImgType "_" #Suffix "_t"), \ |
48 | 34 | AddrSpc); |
49 | 0 | #include "clang/Basic/OpenCLImageTypes.def" |
50 | 5 | case BuiltinType::OCLSampler: |
51 | 5 | return getSamplerType(T); |
52 | 3 | case BuiltinType::OCLEvent: |
53 | 3 | return llvm::PointerType::get( |
54 | 3 | llvm::StructType::create(Ctx, "opencl.event_t"), AddrSpc); |
55 | 5 | case BuiltinType::OCLClkEvent: |
56 | 5 | return llvm::PointerType::get( |
57 | 5 | llvm::StructType::create(Ctx, "opencl.clk_event_t"), AddrSpc); |
58 | 12 | case BuiltinType::OCLQueue: |
59 | 12 | return llvm::PointerType::get( |
60 | 12 | llvm::StructType::create(Ctx, "opencl.queue_t"), AddrSpc); |
61 | 4 | case BuiltinType::OCLReserveID: |
62 | 4 | return llvm::PointerType::get( |
63 | 4 | llvm::StructType::create(Ctx, "opencl.reserve_id_t"), AddrSpc); |
64 | 0 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ |
65 | 12 | case BuiltinType::Id: \ |
66 | 12 | return llvm::PointerType::get( \ |
67 | 12 | llvm::StructType::create(Ctx, "opencl." #ExtType), AddrSpc); |
68 | 0 | #include "clang/Basic/OpenCLExtensionTypes.def" |
69 | 75 | } |
70 | 75 | } |
71 | | |
72 | 42 | llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) { |
73 | 42 | if (T->isReadOnly()) |
74 | 33 | return getPipeType(T, "opencl.pipe_ro_t", PipeROTy); |
75 | 9 | else |
76 | 9 | return getPipeType(T, "opencl.pipe_wo_t", PipeWOTy); |
77 | 42 | } |
78 | | |
79 | | llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name, |
80 | 42 | llvm::Type *&PipeTy) { |
81 | 42 | if (!PipeTy) |
82 | 22 | PipeTy = llvm::PointerType::get(llvm::StructType::create( |
83 | 22 | CGM.getLLVMContext(), Name), |
84 | 22 | CGM.getContext().getTargetAddressSpace( |
85 | 22 | CGM.getContext().getOpenCLTypeAddrSpace(T))); |
86 | 42 | return PipeTy; |
87 | 42 | } |
88 | | |
89 | 27 | llvm::PointerType *CGOpenCLRuntime::getSamplerType(const Type *T) { |
90 | 27 | if (!SamplerTy) |
91 | 5 | SamplerTy = llvm::PointerType::get(llvm::StructType::create( |
92 | 5 | CGM.getLLVMContext(), "opencl.sampler_t"), |
93 | 5 | CGM.getContext().getTargetAddressSpace( |
94 | 5 | CGM.getContext().getOpenCLTypeAddrSpace(T))); |
95 | 27 | return SamplerTy; |
96 | 27 | } |
97 | | |
98 | 28 | llvm::Value *CGOpenCLRuntime::getPipeElemSize(const Expr *PipeArg) { |
99 | 28 | const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>(); |
100 | | // The type of the last (implicit) argument to be passed. |
101 | 28 | llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext()); |
102 | 28 | unsigned TypeSize = CGM.getContext() |
103 | 28 | .getTypeSizeInChars(PipeTy->getElementType()) |
104 | 28 | .getQuantity(); |
105 | 28 | return llvm::ConstantInt::get(Int32Ty, TypeSize, false); |
106 | 28 | } |
107 | | |
108 | 28 | llvm::Value *CGOpenCLRuntime::getPipeElemAlign(const Expr *PipeArg) { |
109 | 28 | const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>(); |
110 | | // The type of the last (implicit) argument to be passed. |
111 | 28 | llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext()); |
112 | 28 | unsigned TypeSize = CGM.getContext() |
113 | 28 | .getTypeAlignInChars(PipeTy->getElementType()) |
114 | 28 | .getQuantity(); |
115 | 28 | return llvm::ConstantInt::get(Int32Ty, TypeSize, false); |
116 | 28 | } |
117 | | |
118 | 223 | llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() { |
119 | 223 | assert(CGM.getLangOpts().OpenCL); |
120 | 223 | return llvm::IntegerType::getInt8PtrTy( |
121 | 223 | CGM.getLLVMContext(), |
122 | 223 | CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic)); |
123 | 223 | } |
124 | | |
125 | | // Get the block literal from an expression derived from the block expression. |
126 | | // OpenCL v2.0 s6.12.5: |
127 | | // Block variable declarations are implicitly qualified with const. Therefore |
128 | | // all block variables must be initialized at declaration time and may not be |
129 | | // reassigned. |
130 | 86 | static const BlockExpr *getBlockExpr(const Expr *E) { |
131 | 86 | const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop. |
132 | 170 | while(!isa<BlockExpr>(E) && E != Prev84 ) { |
133 | 84 | Prev = E; |
134 | 84 | E = E->IgnoreCasts(); |
135 | 84 | if (auto DR = dyn_cast<DeclRefExpr>(E)) { |
136 | 48 | E = cast<VarDecl>(DR->getDecl())->getInit(); |
137 | 48 | } |
138 | 84 | } |
139 | 86 | return cast<BlockExpr>(E); |
140 | 86 | } |
141 | | |
142 | | /// Record emitted llvm invoke function and llvm block literal for the |
143 | | /// corresponding block expression. |
144 | | void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E, |
145 | | llvm::Function *InvokeF, |
146 | 72 | llvm::Value *Block) { |
147 | 72 | assert(EnqueuedBlockMap.find(E) == EnqueuedBlockMap.end() && |
148 | 72 | "Block expression emitted twice"); |
149 | 72 | assert(isa<llvm::Function>(InvokeF) && "Invalid invoke function"); |
150 | 72 | assert(Block->getType()->isPointerTy() && "Invalid block literal type"); |
151 | 72 | EnqueuedBlockMap[E].InvokeFunc = InvokeF; |
152 | 72 | EnqueuedBlockMap[E].BlockArg = Block; |
153 | 72 | EnqueuedBlockMap[E].Kernel = nullptr; |
154 | 72 | } |
155 | | |
156 | 18 | llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) { |
157 | 18 | return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc; |
158 | 18 | } |
159 | | |
160 | | CGOpenCLRuntime::EnqueuedBlockInfo |
161 | 68 | CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) { |
162 | 68 | CGF.EmitScalarExpr(E); |
163 | | |
164 | | // The block literal may be assigned to a const variable. Chasing down |
165 | | // to get the block literal. |
166 | 68 | const BlockExpr *Block = getBlockExpr(E); |
167 | | |
168 | 68 | assert(EnqueuedBlockMap.find(Block) != EnqueuedBlockMap.end() && |
169 | 68 | "Block expression not emitted"); |
170 | | |
171 | | // Do not emit the block wrapper again if it has been emitted. |
172 | 68 | if (EnqueuedBlockMap[Block].Kernel) { |
173 | 9 | return EnqueuedBlockMap[Block]; |
174 | 9 | } |
175 | | |
176 | 59 | auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel( |
177 | 59 | CGF, EnqueuedBlockMap[Block].InvokeFunc, |
178 | 59 | EnqueuedBlockMap[Block].BlockArg->stripPointerCasts()); |
179 | | |
180 | | // The common part of the post-processing of the kernel goes here. |
181 | 59 | F->addFnAttr(llvm::Attribute::NoUnwind); |
182 | 59 | F->setCallingConv( |
183 | 59 | CGF.getTypes().ClangCallConvToLLVMCallConv(CallingConv::CC_OpenCLKernel)); |
184 | 59 | EnqueuedBlockMap[Block].Kernel = F; |
185 | 59 | return EnqueuedBlockMap[Block]; |
186 | 59 | } |