llvm/clang/lib/CodeGen/CGOpenCLRuntime.cpp

//===----- 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>

usingnamespaceclang;
usingnamespaceCodeGen;

CGOpenCLRuntime::~CGOpenCLRuntime() { … }

void CGOpenCLRuntime::EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,
                                                const VarDecl &D) { … }

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

llvm::PointerType *CGOpenCLRuntime::getPointerType(const Type *T) { … }

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

llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name,
                                         llvm::Type *&PipeTy) { … }

llvm::Type *CGOpenCLRuntime::getSamplerType(const Type *T) { … }

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

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

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

// 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) { … }

/// 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, llvm::Type *BlockTy) { … }

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

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