//===----- CGOpenCLRuntime.cpp - Interface to OpenCL Runtimes -------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This provides an abstract class for OpenCL code generation.  Concrete

// subclasses of this implement code generation for specific OpenCL

// runtime libraries.

//

//===----------------------------------------------------------------------===//

#include "CGOpenCLRuntime.h"

#include "CodeGenFunction.h"

#include "TargetInfo.h"

#include "clang/CodeGen/ConstantInitBuilder.h"

#include "llvm/IR/DerivedTypes.h"

#include "llvm/IR/GlobalValue.h"

#include <assert.h>

using namespace clang;

using namespace CodeGen;

CGOpenCLRuntime::~CGOpenCLRuntime() {}

void CGOpenCLRuntime::EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,

                                                const VarDecl &D) {

  return CGF.EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);

}

llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {

  assert(T->isOpenCLSpecificType() &&

         "Not an OpenCL specific type!");

  llvm::LLVMContext& Ctx = CGM.getLLVMContext();

  uint32_t AddrSpc = CGM.getContext().getTargetAddressSpace(

      CGM.getContext().getOpenCLTypeAddrSpace(T));

  switch (cast<BuiltinType>(T)->getKind()) {

  default:

    llvm_unreachable("Unexpected opencl builtin type!");

    return nullptr;

#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \

  case BuiltinType::Id: \

    return llvm::PointerType::get( \

        llvm::StructType::create(Ctx, "opencl." #ImgType "_" #Suffix "_t"), \

        AddrSpc);

#include "clang/Basic/OpenCLImageTypes.def"

  case BuiltinType::OCLSampler:

    return getSamplerType(T);

  case BuiltinType::OCLEvent:

    return llvm::PointerType::get(

        llvm::StructType::create(Ctx, "opencl.event_t"), AddrSpc);

  case BuiltinType::OCLClkEvent:

    return llvm::PointerType::get(

        llvm::StructType::create(Ctx, "opencl.clk_event_t"), AddrSpc);

  case BuiltinType::OCLQueue:

    return llvm::PointerType::get(

        llvm::StructType::create(Ctx, "opencl.queue_t"), AddrSpc);

  case BuiltinType::OCLReserveID:

    return llvm::PointerType::get(

        llvm::StructType::create(Ctx, "opencl.reserve_id_t"), AddrSpc);

#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \

  case BuiltinType::Id: \

    return llvm::PointerType::get( \

        llvm::StructType::create(Ctx, "opencl." #ExtType), AddrSpc);

#include "clang/Basic/OpenCLExtensionTypes.def"

  }

}

llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) {

  if (T->isReadOnly())

    return getPipeType(T, "opencl.pipe_ro_t", PipeROTy);

  else

    return getPipeType(T, "opencl.pipe_wo_t", PipeWOTy);

}

llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name,

                                         llvm::Type *&PipeTy) {

  if (!PipeTy)

    PipeTy = llvm::PointerType::get(llvm::StructType::create(

      CGM.getLLVMContext(), Name),

      CGM.getContext().getTargetAddressSpace(

          CGM.getContext().getOpenCLTypeAddrSpace(T)));

  return PipeTy;

}

llvm::PointerType *CGOpenCLRuntime::getSamplerType(const Type *T) {

  if (!SamplerTy)

    SamplerTy = llvm::PointerType::get(llvm::StructType::create(

      CGM.getLLVMContext(), "opencl.sampler_t"),

      CGM.getContext().getTargetAddressSpace(

          CGM.getContext().getOpenCLTypeAddrSpace(T)));

  return SamplerTy;

}

llvm::Value *CGOpenCLRuntime::getPipeElemSize(const Expr *PipeArg) {

  const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>();

  // The type of the last (implicit) argument to be passed.

  llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());

  unsigned TypeSize = CGM.getContext()

                          .getTypeSizeInChars(PipeTy->getElementType())

                          .getQuantity();

  return llvm::ConstantInt::get(Int32Ty, TypeSize, false);

}

llvm::Value *CGOpenCLRuntime::getPipeElemAlign(const Expr *PipeArg) {

  const PipeType *PipeTy = PipeArg->getType()->castAs<PipeType>();

  // The type of the last (implicit) argument to be passed.

  llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());

  unsigned TypeSize = CGM.getContext()

                          .getTypeAlignInChars(PipeTy->getElementType())

                          .getQuantity();

  return llvm::ConstantInt::get(Int32Ty, TypeSize, false);

}

llvm::PointerType *CGOpenCLRuntime::getGenericVoidPointerType() {

  assert(CGM.getLangOpts().OpenCL);

  return llvm::IntegerType::getInt8PtrTy(

      CGM.getLLVMContext(),

      CGM.getContext().getTargetAddressSpace(LangAS::opencl_generic));

}

// Get the block literal from an expression derived from the block expression.

// OpenCL v2.0 s6.12.5:

// Block variable declarations are implicitly qualified with const. Therefore

// all block variables must be initialized at declaration time and may not be

// reassigned.

static const BlockExpr *getBlockExpr(const Expr *E) {

  const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop.

  while(!isa<BlockExpr>(E) && 
E != Prev84
) {

    Prev = E;

    E = E->IgnoreCasts();

    if (auto DR = dyn_cast<DeclRefExpr>(E)) {

      E = cast<VarDecl>(DR->getDecl())->getInit();

    }

  }

  return cast<BlockExpr>(E);

}

/// Record emitted llvm invoke function and llvm block literal for the

/// corresponding block expression.

void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E,

                                      llvm::Function *InvokeF,

                                      llvm::Value *Block) {

  assert(EnqueuedBlockMap.find(E) == EnqueuedBlockMap.end() &&

         "Block expression emitted twice");

  assert(isa<llvm::Function>(InvokeF) && "Invalid invoke function");

  assert(Block->getType()->isPointerTy() && "Invalid block literal type");

  EnqueuedBlockMap[E].InvokeFunc = InvokeF;

  EnqueuedBlockMap[E].BlockArg = Block;

  EnqueuedBlockMap[E].Kernel = nullptr;

}

llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) {

  return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc;

}

CGOpenCLRuntime::EnqueuedBlockInfo

CGOpenCLRuntime::emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E) {

  CGF.EmitScalarExpr(E);

  // The block literal may be assigned to a const variable. Chasing down

  // to get the block literal.

  const BlockExpr *Block = getBlockExpr(E);

  assert(EnqueuedBlockMap.find(Block) != EnqueuedBlockMap.end() &&

         "Block expression not emitted");

  // Do not emit the block wrapper again if it has been emitted.

  if (EnqueuedBlockMap[Block].Kernel) {

    return EnqueuedBlockMap[Block];

  }

  auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel(

      CGF, EnqueuedBlockMap[Block].InvokeFunc,

      EnqueuedBlockMap[Block].BlockArg->stripPointerCasts());

  // The common part of the post-processing of the kernel goes here.

  F->addFnAttr(llvm::Attribute::NoUnwind);

  F->setCallingConv(

      CGF.getTypes().ClangCallConvToLLVMCallConv(CallingConv::CC_OpenCLKernel));

  EnqueuedBlockMap[Block].Kernel = F;

  return EnqueuedBlockMap[Block];

}