1 //===----- CGOpenCLRuntime.h - Interface to OpenCL Runtimes -----*- C++ -*-===// 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 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENCLRUNTIME_H 16 #define LLVM_CLANG_LIB_CODEGEN_CGOPENCLRUNTIME_H 17 18 #include "clang/AST/Expr.h" 19 #include "clang/AST/Type.h" 20 #include "llvm/ADT/DenseMap.h" 21 #include "llvm/ADT/StringMap.h" 22 #include "llvm/IR/Type.h" 23 #include "llvm/IR/Value.h" 24 25 namespace clang { 26 27 class BlockExpr; 28 class Expr; 29 class VarDecl; 30 31 namespace CodeGen { 32 33 class CodeGenFunction; 34 class CodeGenModule; 35 36 class CGOpenCLRuntime { 37 protected: 38 CodeGenModule &CGM; 39 llvm::Type *PipeROTy; 40 llvm::Type *PipeWOTy; 41 llvm::Type *SamplerTy; 42 43 /// Structure for enqueued block information. 44 struct EnqueuedBlockInfo { 45 llvm::Function *InvokeFunc; /// Block invoke function. 46 llvm::Value *KernelHandle; /// Enqueued block kernel reference. 47 llvm::Value *BlockArg; /// The first argument to enqueued block kernel. 48 llvm::Type *BlockTy; /// Type of the block argument. 49 }; 50 /// Maps block expression to block information. 51 llvm::DenseMap<const Expr *, EnqueuedBlockInfo> EnqueuedBlockMap; 52 53 virtual llvm::Type *getPipeType(const PipeType *T, StringRef Name, 54 llvm::Type *&PipeTy); 55 llvm::PointerType *getPointerType(const Type *T); 56 57 public: 58 CGOpenCLRuntime(CodeGenModule &CGM) : CGM(CGM), 59 PipeROTy(nullptr), PipeWOTy(nullptr), SamplerTy(nullptr) {} 60 virtual ~CGOpenCLRuntime(); 61 62 /// Emit the IR required for a work-group-local variable declaration, and add 63 /// an entry to CGF's LocalDeclMap for D. The base class does this using 64 /// CodeGenFunction::EmitStaticVarDecl to emit an internal global for D. 65 virtual void EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF, 66 const VarDecl &D); 67 68 virtual llvm::Type *convertOpenCLSpecificType(const Type *T); 69 70 virtual llvm::Type *getPipeType(const PipeType *T); 71 72 llvm::Type *getSamplerType(const Type *T); 73 74 // Returns a value which indicates the size in bytes of the pipe 75 // element. 76 virtual llvm::Value *getPipeElemSize(const Expr *PipeArg); 77 78 // Returns a value which indicates the alignment in bytes of the pipe 79 // element. 80 virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg); 81 82 /// \return __generic void* type. 83 llvm::PointerType *getGenericVoidPointerType(); 84 85 /// \return enqueued block information for enqueued block. 86 EnqueuedBlockInfo emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, 87 const Expr *E); 88 89 /// Record invoke function and block literal emitted during normal 90 /// codegen for a block expression. The information is used by 91 /// emitOpenCLEnqueuedBlock to emit wrapper kernel. 92 /// 93 /// \param InvokeF invoke function emitted for the block expression. 94 /// \param Block block literal emitted for the block expression. 95 void recordBlockInfo(const BlockExpr *E, llvm::Function *InvokeF, 96 llvm::Value *Block, llvm::Type *BlockTy); 97 98 /// \return LLVM block invoke function emitted for an expression derived from 99 /// the block expression. 100 llvm::Function *getInvokeFunction(const Expr *E); 101 }; 102 103 } 104 } 105 106 #endif 107