1 //===-- CGBlocks.h - state for LLVM CodeGen for blocks ----------*- 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 is the internal state used for llvm translation for block literals. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_LIB_CODEGEN_CGBLOCKS_H 14 #define LLVM_CLANG_LIB_CODEGEN_CGBLOCKS_H 15 16 #include "CGBuilder.h" 17 #include "CGCall.h" 18 #include "CGValue.h" 19 #include "CodeGenFunction.h" 20 #include "CodeGenTypes.h" 21 #include "clang/AST/CharUnits.h" 22 #include "clang/AST/Expr.h" 23 #include "clang/AST/ExprCXX.h" 24 #include "clang/AST/ExprObjC.h" 25 #include "clang/AST/Type.h" 26 #include "clang/Basic/TargetInfo.h" 27 28 namespace llvm { 29 class Constant; 30 class Function; 31 class GlobalValue; 32 class DataLayout; 33 class FunctionType; 34 class PointerType; 35 class Value; 36 class LLVMContext; 37 } 38 39 namespace clang { 40 namespace CodeGen { 41 42 class CGBlockInfo; 43 44 // Flags stored in __block variables. 45 enum BlockByrefFlags { 46 BLOCK_BYREF_HAS_COPY_DISPOSE = (1 << 25), // compiler 47 BLOCK_BYREF_LAYOUT_MASK = (0xF << 28), // compiler 48 BLOCK_BYREF_LAYOUT_EXTENDED = (1 << 28), 49 BLOCK_BYREF_LAYOUT_NON_OBJECT = (2 << 28), 50 BLOCK_BYREF_LAYOUT_STRONG = (3 << 28), 51 BLOCK_BYREF_LAYOUT_WEAK = (4 << 28), 52 BLOCK_BYREF_LAYOUT_UNRETAINED = (5 << 28) 53 }; 54 55 enum BlockLiteralFlags { 56 BLOCK_IS_NOESCAPE = (1 << 23), 57 BLOCK_HAS_COPY_DISPOSE = (1 << 25), 58 BLOCK_HAS_CXX_OBJ = (1 << 26), 59 BLOCK_IS_GLOBAL = (1 << 28), 60 BLOCK_USE_STRET = (1 << 29), 61 BLOCK_HAS_SIGNATURE = (1 << 30), 62 BLOCK_HAS_EXTENDED_LAYOUT = (1u << 31) 63 }; 64 class BlockFlags { 65 uint32_t flags; 66 67 public: 68 BlockFlags(uint32_t flags) : flags(flags) {} 69 BlockFlags() : flags(0) {} 70 BlockFlags(BlockLiteralFlags flag) : flags(flag) {} 71 BlockFlags(BlockByrefFlags flag) : flags(flag) {} 72 73 uint32_t getBitMask() const { return flags; } 74 bool empty() const { return flags == 0; } 75 76 friend BlockFlags operator|(BlockFlags l, BlockFlags r) { 77 return BlockFlags(l.flags | r.flags); 78 } 79 friend BlockFlags &operator|=(BlockFlags &l, BlockFlags r) { 80 l.flags |= r.flags; 81 return l; 82 } 83 friend bool operator&(BlockFlags l, BlockFlags r) { 84 return (l.flags & r.flags); 85 } 86 bool operator==(BlockFlags r) { 87 return (flags == r.flags); 88 } 89 }; 90 inline BlockFlags operator|(BlockLiteralFlags l, BlockLiteralFlags r) { 91 return BlockFlags(l) | BlockFlags(r); 92 } 93 94 enum BlockFieldFlag_t { 95 BLOCK_FIELD_IS_OBJECT = 0x03, /* id, NSObject, __attribute__((NSObject)), 96 block, ... */ 97 BLOCK_FIELD_IS_BLOCK = 0x07, /* a block variable */ 98 99 BLOCK_FIELD_IS_BYREF = 0x08, /* the on stack structure holding the __block 100 variable */ 101 BLOCK_FIELD_IS_WEAK = 0x10, /* declared __weak, only used in byref copy 102 helpers */ 103 BLOCK_FIELD_IS_ARC = 0x40, /* field has ARC-specific semantics */ 104 BLOCK_BYREF_CALLER = 128, /* called from __block (byref) copy/dispose 105 support routines */ 106 BLOCK_BYREF_CURRENT_MAX = 256 107 }; 108 109 class BlockFieldFlags { 110 uint32_t flags; 111 112 BlockFieldFlags(uint32_t flags) : flags(flags) {} 113 public: 114 BlockFieldFlags() : flags(0) {} 115 BlockFieldFlags(BlockFieldFlag_t flag) : flags(flag) {} 116 117 uint32_t getBitMask() const { return flags; } 118 bool empty() const { return flags == 0; } 119 120 /// Answers whether the flags indicate that this field is an object 121 /// or block pointer that requires _Block_object_assign/dispose. 122 bool isSpecialPointer() const { return flags & BLOCK_FIELD_IS_OBJECT; } 123 124 friend BlockFieldFlags operator|(BlockFieldFlags l, BlockFieldFlags r) { 125 return BlockFieldFlags(l.flags | r.flags); 126 } 127 friend BlockFieldFlags &operator|=(BlockFieldFlags &l, BlockFieldFlags r) { 128 l.flags |= r.flags; 129 return l; 130 } 131 friend bool operator&(BlockFieldFlags l, BlockFieldFlags r) { 132 return (l.flags & r.flags); 133 } 134 bool operator==(BlockFieldFlags Other) const { 135 return flags == Other.flags; 136 } 137 }; 138 inline BlockFieldFlags operator|(BlockFieldFlag_t l, BlockFieldFlag_t r) { 139 return BlockFieldFlags(l) | BlockFieldFlags(r); 140 } 141 142 /// Information about the layout of a __block variable. 143 class BlockByrefInfo { 144 public: 145 llvm::StructType *Type; 146 unsigned FieldIndex; 147 CharUnits ByrefAlignment; 148 CharUnits FieldOffset; 149 }; 150 151 /// CGBlockInfo - Information to generate a block literal. 152 class CGBlockInfo { 153 public: 154 /// Name - The name of the block, kindof. 155 StringRef Name; 156 157 /// The field index of 'this' within the block, if there is one. 158 unsigned CXXThisIndex; 159 160 class Capture { 161 uintptr_t Data; 162 EHScopeStack::stable_iterator Cleanup; 163 CharUnits::QuantityType Offset; 164 165 /// Type of the capture field. Normally, this is identical to the type of 166 /// the capture's VarDecl, but can be different if there is an enclosing 167 /// lambda. 168 QualType FieldType; 169 170 public: 171 bool isIndex() const { return (Data & 1) != 0; } 172 bool isConstant() const { return !isIndex(); } 173 174 unsigned getIndex() const { 175 assert(isIndex()); 176 return Data >> 1; 177 } 178 CharUnits getOffset() const { 179 assert(isIndex()); 180 return CharUnits::fromQuantity(Offset); 181 } 182 EHScopeStack::stable_iterator getCleanup() const { 183 assert(isIndex()); 184 return Cleanup; 185 } 186 void setCleanup(EHScopeStack::stable_iterator cleanup) { 187 assert(isIndex()); 188 Cleanup = cleanup; 189 } 190 191 llvm::Value *getConstant() const { 192 assert(isConstant()); 193 return reinterpret_cast<llvm::Value*>(Data); 194 } 195 196 QualType fieldType() const { 197 return FieldType; 198 } 199 200 static Capture makeIndex(unsigned index, CharUnits offset, 201 QualType FieldType) { 202 Capture v; 203 v.Data = (index << 1) | 1; 204 v.Offset = offset.getQuantity(); 205 v.FieldType = FieldType; 206 return v; 207 } 208 209 static Capture makeConstant(llvm::Value *value) { 210 Capture v; 211 v.Data = reinterpret_cast<uintptr_t>(value); 212 return v; 213 } 214 }; 215 216 /// CanBeGlobal - True if the block can be global, i.e. it has 217 /// no non-constant captures. 218 bool CanBeGlobal : 1; 219 220 /// True if the block has captures that would necessitate custom copy or 221 /// dispose helper functions if the block were escaping. 222 bool NeedsCopyDispose : 1; 223 224 /// HasCXXObject - True if the block's custom copy/dispose functions 225 /// need to be run even in GC mode. 226 bool HasCXXObject : 1; 227 228 /// UsesStret : True if the block uses an stret return. Mutable 229 /// because it gets set later in the block-creation process. 230 mutable bool UsesStret : 1; 231 232 /// HasCapturedVariableLayout : True if block has captured variables 233 /// and their layout meta-data has been generated. 234 bool HasCapturedVariableLayout : 1; 235 236 /// Indicates whether an object of a non-external C++ class is captured. This 237 /// bit is used to determine the linkage of the block copy/destroy helper 238 /// functions. 239 bool CapturesNonExternalType : 1; 240 241 /// The mapping of allocated indexes within the block. 242 llvm::DenseMap<const VarDecl*, Capture> Captures; 243 244 Address LocalAddress; 245 llvm::StructType *StructureType; 246 const BlockDecl *Block; 247 const BlockExpr *BlockExpression; 248 CharUnits BlockSize; 249 CharUnits BlockAlign; 250 CharUnits CXXThisOffset; 251 252 // Offset of the gap caused by block header having a smaller 253 // alignment than the alignment of the block descriptor. This 254 // is the gap offset before the first capturued field. 255 CharUnits BlockHeaderForcedGapOffset; 256 // Gap size caused by aligning first field after block header. 257 // This could be zero if no forced alignment is required. 258 CharUnits BlockHeaderForcedGapSize; 259 260 /// The next block in the block-info chain. Invalid if this block 261 /// info is not part of the CGF's block-info chain, which is true 262 /// if it corresponds to a global block or a block whose expression 263 /// has been encountered. 264 CGBlockInfo *NextBlockInfo; 265 266 const Capture &getCapture(const VarDecl *var) const { 267 return const_cast<CGBlockInfo*>(this)->getCapture(var); 268 } 269 Capture &getCapture(const VarDecl *var) { 270 llvm::DenseMap<const VarDecl*, Capture>::iterator 271 it = Captures.find(var); 272 assert(it != Captures.end() && "no entry for variable!"); 273 return it->second; 274 } 275 276 const BlockDecl *getBlockDecl() const { return Block; } 277 const BlockExpr *getBlockExpr() const { 278 assert(BlockExpression); 279 assert(BlockExpression->getBlockDecl() == Block); 280 return BlockExpression; 281 } 282 283 CGBlockInfo(const BlockDecl *blockDecl, StringRef Name); 284 285 // Indicates whether the block needs a custom copy or dispose function. 286 bool needsCopyDisposeHelpers() const { 287 return NeedsCopyDispose && !Block->doesNotEscape(); 288 } 289 }; 290 291 } // end namespace CodeGen 292 } // end namespace clang 293 294 #endif 295