clang/lib/CodeGen/CGOpenCLRuntime.cpp

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