lib/CodeGen/CGBlocks.h

   1 //===-- CGBlocks.h - state for LLVM CodeGen for blocks ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This is the internal state used for llvm translation for block literals.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef CLANG_CODEGEN_CGBLOCKS_H
  15 #define CLANG_CODEGEN_CGBLOCKS_H
  16
  17 #include "CodeGenTypes.h"
  18 #include "clang/AST/Type.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/ADT/DenseMap.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "clang/Basic/TargetInfo.h"
  23 #include "clang/AST/Expr.h"
  24 #include "clang/AST/ExprCXX.h"
  25 #include "clang/AST/ExprObjC.h"
  26
  27 #include <vector>
  28 #include <map>
  29
  30 #include "CGBuilder.h"
  31 #include "CGCall.h"
  32 #include "CGValue.h"
  33
  34 namespace llvm {
  35   class Module;
  36   class Constant;
  37   class Function;
  38   class GlobalValue;
  39   class TargetData;
  40   class FunctionType;
  41   class Value;
  42   class LLVMContext;
  43 }
  44
  45 namespace clang {
  46
  47 namespace CodeGen {
  48 class CodeGenModule;
  49
  50 class BlockBase {
  51 public:
  52     enum {
  53         BLOCK_NEEDS_FREE =        (1 << 24),
  54         BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
  55         BLOCK_HAS_CXX_OBJ =       (1 << 26),
  56         BLOCK_IS_GC =             (1 << 27),
  57         BLOCK_IS_GLOBAL =         (1 << 28),
  58         BLOCK_HAS_DESCRIPTOR =    (1 << 29)
  59     };
  60 };
  61
  62 class BlockModule : public BlockBase {
  63   ASTContext &Context;
  64   llvm::Module &TheModule;
  65   const llvm::TargetData &TheTargetData;
  66   CodeGenTypes &Types;
  67   CodeGenModule &CGM;
  68   llvm::LLVMContext &VMContext;
  69
  70   ASTContext &getContext() const { return Context; }
  71   llvm::Module &getModule() const { return TheModule; }
  72   CodeGenTypes &getTypes() { return Types; }
  73   const llvm::TargetData &getTargetData() const { return TheTargetData; }
  74 public:
  75   llvm::Constant *getNSConcreteGlobalBlock();
  76   llvm::Constant *getNSConcreteStackBlock();
  77   int getGlobalUniqueCount() { return ++Block.GlobalUniqueCount; }
  78   const llvm::Type *getBlockDescriptorType();
  79
  80   const llvm::Type *getGenericBlockLiteralType();
  81   const llvm::Type *getGenericExtendedBlockLiteralType();
  82
  83   llvm::Constant *GetAddrOfGlobalBlock(const BlockExpr *BE, const char *);
  84
  85   /// NSConcreteGlobalBlock - Cached reference to the class pointer for global
  86   /// blocks.
  87   llvm::Constant *NSConcreteGlobalBlock;
  88
  89   /// NSConcreteStackBlock - Cached reference to the class poinnter for stack
  90   /// blocks.
  91   llvm::Constant *NSConcreteStackBlock;
  92
  93   const llvm::Type *BlockDescriptorType;
  94   const llvm::Type *GenericBlockLiteralType;
  95   const llvm::Type *GenericExtendedBlockLiteralType;
  96   struct {
  97     int GlobalUniqueCount;
  98   } Block;
  99
 100   llvm::Value *BlockObjectAssign;
 101   llvm::Value *BlockObjectDispose;
 102   const llvm::Type *PtrToInt8Ty;
 103
 104   std::map<uint64_t, llvm::Constant *> AssignCache;
 105   std::map<uint64_t, llvm::Constant *> DestroyCache;
 106
 107   BlockModule(ASTContext &C, llvm::Module &M, const llvm::TargetData &TD,
 108               CodeGenTypes &T, CodeGenModule &CodeGen)
 109     : Context(C), TheModule(M), TheTargetData(TD), Types(T),
 110       CGM(CodeGen), VMContext(M.getContext()),
 111       NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), BlockDescriptorType(0),
 112       GenericBlockLiteralType(0), GenericExtendedBlockLiteralType(0),
 113       BlockObjectAssign(0), BlockObjectDispose(0) {
 114     Block.GlobalUniqueCount = 0;
 115     PtrToInt8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
 116   }
 117 };
 118
 119 class BlockFunction : public BlockBase {
 120   CodeGenModule &CGM;
 121   CodeGenFunction &CGF;
 122   ASTContext &getContext() const;
 123
 124 protected:
 125   llvm::LLVMContext &VMContext;
 126
 127 public:
 128   const llvm::Type *PtrToInt8Ty;
 129   struct HelperInfo {
 130     int index;
 131     int flag;
 132     bool RequiresCopying;
 133   };
 134
 135   enum {
 136     BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)),
 137                                       block, ... */
 138     BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */
 139     BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the __block
 140                                       variable */
 141     BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy
 142                                       helpers */
 143     BLOCK_BYREF_CALLER      = 128,  /* called from __block (byref) copy/dispose
 144                                       support routines */
 145     BLOCK_BYREF_CURRENT_MAX = 256
 146   };
 147
 148   /// BlockInfo - Information to generate a block literal.
 149   struct BlockInfo {
 150     /// BlockLiteralTy - The type of the block literal.
 151     const llvm::Type *BlockLiteralTy;
 152
 153     /// Name - the name of the function this block was created for, if any.
 154     const char *Name;
 155
 156     /// ByCopyDeclRefs - Variables from parent scopes that have been imported
 157     /// into this block.
 158     llvm::SmallVector<const BlockDeclRefExpr *, 8> ByCopyDeclRefs;
 159
 160     // ByRefDeclRefs - __block variables from parent scopes that have been
 161     // imported into this block.
 162     llvm::SmallVector<const BlockDeclRefExpr *, 8> ByRefDeclRefs;
 163
 164     BlockInfo(const llvm::Type *blt, const char *n)
 165       : BlockLiteralTy(blt), Name(n) {
 166       // Skip asm prefix, if any.
 167       if (Name && Name[0] == '\01')
 168         ++Name;
 169     }
 170   };
 171
 172   CGBuilderTy &Builder;
 173
 174   BlockFunction(CodeGenModule &cgm, CodeGenFunction &cgf, CGBuilderTy &B);
 175
 176   /// BlockOffset - The offset in bytes for the next allocation of an
 177   /// imported block variable.
 178   uint64_t BlockOffset;
 179   /// BlockAlign - Maximal alignment needed for the Block expressed in bytes.
 180   uint64_t BlockAlign;
 181
 182   /// getBlockOffset - Allocate an offset for the ValueDecl from a
 183   /// BlockDeclRefExpr in a block literal (BlockExpr).
 184   uint64_t getBlockOffset(const BlockDeclRefExpr *E);
 185
 186   /// BlockHasCopyDispose - True iff the block uses copy/dispose.
 187   bool BlockHasCopyDispose;
 188
 189   /// BlockDeclRefDecls - Decls from BlockDeclRefExprs in apperance order
 190   /// in a block literal.  Decls without names are used for padding.
 191   llvm::SmallVector<const Expr *, 8> BlockDeclRefDecls;
 192
 193   /// BlockDecls - Offsets for all Decls in BlockDeclRefExprs.
 194   std::map<const Decl*, uint64_t> BlockDecls;
 195
 196   ImplicitParamDecl *BlockStructDecl;
 197   ImplicitParamDecl *getBlockStructDecl() { return BlockStructDecl; }
 198
 199   llvm::Constant *GenerateCopyHelperFunction(bool, const llvm::StructType *,
 200                                              std::vector<HelperInfo> *);
 201   llvm::Constant *GenerateDestroyHelperFunction(bool, const llvm::StructType *,
 202                                                 std::vector<HelperInfo> *);
 203
 204   llvm::Constant *BuildCopyHelper(const llvm::StructType *,
 205                                   std::vector<HelperInfo> *);
 206   llvm::Constant *BuildDestroyHelper(const llvm::StructType *,
 207                                      std::vector<HelperInfo> *);
 208
 209   llvm::Constant *GeneratebyrefCopyHelperFunction(const llvm::Type *, int flag);
 210   llvm::Constant *GeneratebyrefDestroyHelperFunction(const llvm::Type *T, int);
 211
 212   llvm::Constant *BuildbyrefCopyHelper(const llvm::Type *T, int flag,
 213                                        unsigned Align);
 214   llvm::Constant *BuildbyrefDestroyHelper(const llvm::Type *T, int flag,
 215                                           unsigned Align);
 216
 217   llvm::Value *getBlockObjectAssign();
 218   llvm::Value *getBlockObjectDispose();
 219   void BuildBlockRelease(llvm::Value *DeclPtr, int flag = BLOCK_FIELD_IS_BYREF);
 220
 221   bool BlockRequiresCopying(QualType Ty) {
 222     if (Ty->isBlockPointerType())
 223       return true;
 224     if (getContext().isObjCNSObjectType(Ty))
 225       return true;
 226     if (Ty->isObjCObjectPointerType())
 227       return true;
 228     return false;
 229   }
 230 };
 231
 232 }  // end namespace CodeGen
 233 }  // end namespace clang
 234
 235 #endif