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 if (T->isSamplerT()) 41 return getSamplerType(T); 42 43 return getPointerType(T); 44 } 45 46 llvm::PointerType *CGOpenCLRuntime::getPointerType(const Type *T) { 47 uint32_t AddrSpc = CGM.getContext().getTargetAddressSpace( 48 CGM.getContext().getOpenCLTypeAddrSpace(T)); 49 return llvm::PointerType::get(CGM.getLLVMContext(), AddrSpc); 50 } 51 52 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) { 53 if (llvm::Type *PipeTy = CGM.getTargetCodeGenInfo().getOpenCLType(CGM, T)) 54 return PipeTy; 55 56 if (T->isReadOnly()) 57 return getPipeType(T, "opencl.pipe_ro_t", PipeROTy); 58 else 59 return getPipeType(T, "opencl.pipe_wo_t", PipeWOTy); 60 } 61 62 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name, 63 llvm::Type *&PipeTy) { 64 if (!PipeTy) 65 PipeTy = getPointerType(T); 66 return PipeTy; 67 } 68 69 llvm::Type *CGOpenCLRuntime::getSamplerType(const Type *T) { 70 if (SamplerTy) 71 return SamplerTy; 72 73 if (llvm::Type *TransTy = CGM.getTargetCodeGenInfo().getOpenCLType( 74 CGM, CGM.getContext().OCLSamplerTy.getTypePtr())) 75 SamplerTy = TransTy; 76 else 77 SamplerTy = getPointerType(T); 78 return SamplerTy; 79 } 80 81 llvm::Value *CGOpenCLRuntime::getPipeElemSize(const Expr *PipeArg) { 82 const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>(); 83 // The type of the last (implicit) argument to be passed. 84 llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext()); 85 unsigned TypeSize = CGM.getContext() 86 .getTypeSizeInChars(PipeTy->getElementType()) 87 .getQuantity(); 88 return llvm::ConstantInt::get(Int32Ty, TypeSize, false); 89 } 90 91 llvm::Value *CGOpenCLRuntime::getPipeElemAlign(const Expr *PipeArg) { 92 const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>(); 93 // The type of the last (implicit) argument to be passed. 94 llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext()); 95 unsigned TypeSize = CGM.getContext() 96 .getTypeAlignInChars(PipeTy->getElementType()) 97 .getQuantity(); 98 return llvm::ConstantInt::get(Int32Ty, TypeSize, false); 99 } 100 101 llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() { 102 assert(CGM.getLangOpts().OpenCL); 103 return llvm::PointerType::get( 104 CGM.getLLVMContext(), 105 CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic)); 106 } 107 108 // Get the block literal from an expression derived from the block expression. 109 // OpenCL v2.0 s6.12.5: 110 // Block variable declarations are implicitly qualified with const. Therefore 111 // all block variables must be initialized at declaration time and may not be 112 // reassigned. 113 static const BlockExpr *getBlockExpr(const Expr *E) { 114 const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop. 115 while(!isa<BlockExpr>(E) && E != Prev) { 116 Prev = E; 117 E = E->IgnoreCasts(); 118 if (auto DR = dyn_cast<DeclRefExpr>(E)) { 119 E = cast<VarDecl>(DR->getDecl())->getInit(); 120 } 121 } 122 return cast<BlockExpr>(E); 123 } 124 125 /// Record emitted llvm invoke function and llvm block literal for the 126 /// corresponding block expression. 127 void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E, 128 llvm::Function *InvokeF, 129 llvm::Value *Block, llvm::Type *BlockTy) { 130 assert(!EnqueuedBlockMap.contains(E) && "Block expression emitted twice"); 131 assert(isa<llvm::Function>(InvokeF) && "Invalid invoke function"); 132 assert(Block->getType()->isPointerTy() && "Invalid block literal type"); 133 EnqueuedBlockMap[E].InvokeFunc = InvokeF; 134 EnqueuedBlockMap[E].BlockArg = Block; 135 EnqueuedBlockMap[E].BlockTy = BlockTy; 136 EnqueuedBlockMap[E].KernelHandle = nullptr; 137 } 138 139 llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) { 140 return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc; 141 } 142 143 CGOpenCLRuntime::EnqueuedBlockInfo 144 CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) { 145 CGF.EmitScalarExpr(E); 146 147 // The block literal may be assigned to a const variable. Chasing down 148 // to get the block literal. 149 const BlockExpr *Block = getBlockExpr(E); 150 151 assert(EnqueuedBlockMap.contains(Block) && "Block expression not emitted"); 152 153 // Do not emit the block wrapper again if it has been emitted. 154 if (EnqueuedBlockMap[Block].KernelHandle) { 155 return EnqueuedBlockMap[Block]; 156 } 157 158 auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel( 159 CGF, EnqueuedBlockMap[Block].InvokeFunc, EnqueuedBlockMap[Block].BlockTy); 160 161 // The common part of the post-processing of the kernel goes here. 162 EnqueuedBlockMap[Block].KernelHandle = F; 163 return EnqueuedBlockMap[Block]; 164 } 165