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