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