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