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
28namespace llvm {
29class Value;
30}
31
32namespace clang {
33namespace CodeGen {
34
35class CGBlockInfo;
36
37// Flags stored in __block variables.
38enum 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
48enum 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};
57class BlockFlags {
58 uint32_t flags;
59
60public:
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};
83inline BlockFlags operator|(BlockLiteralFlags l, BlockLiteralFlags r) {
84 return BlockFlags(l) | BlockFlags(r);
85}
86
87enum 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
102class BlockFieldFlags {
103 uint32_t flags;
104
105 BlockFieldFlags(uint32_t flags) : flags(flags) {}
106public:
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};
131inline 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.
136class BlockByrefInfo {
137public:
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.
146enum class BlockCaptureEntityKind {
147 None,
148 CXXRecord, // Copy or destroy
149 AddressDiscriminatedPointerAuth,
150 ARCWeak,
151 ARCStrong,
152 NonTrivialCStruct,
153 BlockObject, // Assign or release
154};
155
156/// CGBlockInfo - Information to generate a block literal.
157class CGBlockInfo {
158public:
159 /// Name - The name of the block, kindof.
160 StringRef Name;
161
162 /// The field index of 'this' within the block, if there is one.
163 unsigned CXXThisIndex;
164
165 class Capture {
166 uintptr_t Data;
167 EHScopeStack::stable_iterator Cleanup;
168 CharUnits::QuantityType Offset;
169
170 /// Type of the capture field. Normally, this is identical to the type of
171 /// the capture's VarDecl, but can be different if there is an enclosing
172 /// lambda.
173 QualType FieldType;
174
175 public:
176 bool isIndex() const { return (Data & 1) != 0; }
177 bool isConstant() const { return !isIndex(); }
178
179 unsigned getIndex() const {
180 assert(isIndex());
181 return Data >> 1;
182 }
183 CharUnits getOffset() const {
184 assert(isIndex());
185 return CharUnits::fromQuantity(Quantity: Offset);
186 }
187 EHScopeStack::stable_iterator getCleanup() const {
188 assert(isIndex());
189 return Cleanup;
190 }
191 void setCleanup(EHScopeStack::stable_iterator cleanup) {
192 assert(isIndex());
193 Cleanup = cleanup;
194 }
195
196 llvm::Value *getConstant() const {
197 assert(isConstant());
198 return reinterpret_cast<llvm::Value*>(Data);
199 }
200
201 QualType fieldType() const {
202 return FieldType;
203 }
204
205 static Capture
206 makeIndex(unsigned index, CharUnits offset, QualType FieldType,
207 BlockCaptureEntityKind CopyKind, BlockFieldFlags CopyFlags,
208 BlockCaptureEntityKind DisposeKind, BlockFieldFlags DisposeFlags,
209 const BlockDecl::Capture *Cap) {
210 Capture v;
211 v.Data = (index << 1) | 1;
212 v.Offset = offset.getQuantity();
213 v.FieldType = FieldType;
214 v.CopyKind = CopyKind;
215 v.CopyFlags = CopyFlags;
216 v.DisposeKind = DisposeKind;
217 v.DisposeFlags = DisposeFlags;
218 v.Cap = Cap;
219 return v;
220 }
221
222 static Capture makeConstant(llvm::Value *value,
223 const BlockDecl::Capture *Cap) {
224 Capture v;
225 v.Data = reinterpret_cast<uintptr_t>(value);
226 v.Cap = Cap;
227 return v;
228 }
229
230 bool isConstantOrTrivial() const {
231 return CopyKind == BlockCaptureEntityKind::None &&
232 DisposeKind == BlockCaptureEntityKind::None;
233 }
234
235 BlockCaptureEntityKind CopyKind = BlockCaptureEntityKind::None,
236 DisposeKind = BlockCaptureEntityKind::None;
237 BlockFieldFlags CopyFlags, DisposeFlags;
238 const BlockDecl::Capture *Cap;
239 };
240
241 /// CanBeGlobal - True if the block can be global, i.e. it has
242 /// no non-constant captures.
243 bool CanBeGlobal : 1;
244
245 /// True if the block has captures that would necessitate custom copy or
246 /// dispose helper functions if the block were escaping.
247 bool NeedsCopyDispose : 1;
248
249 /// Indicates whether the block is non-escaping.
250 bool NoEscape : 1;
251
252 /// HasCXXObject - True if the block's custom copy/dispose functions
253 /// need to be run even in GC mode.
254 bool HasCXXObject : 1;
255
256 /// UsesStret : True if the block uses an stret return. Mutable
257 /// because it gets set later in the block-creation process.
258 mutable bool UsesStret : 1;
259
260 /// HasCapturedVariableLayout : True if block has captured variables
261 /// and their layout meta-data has been generated.
262 bool HasCapturedVariableLayout : 1;
263
264 /// Indicates whether an object of a non-external C++ class is captured. This
265 /// bit is used to determine the linkage of the block copy/destroy helper
266 /// functions.
267 bool CapturesNonExternalType : 1;
268
269 /// Mapping from variables to pointers to captures in SortedCaptures.
270 llvm::DenseMap<const VarDecl *, Capture *> Captures;
271
272 /// The block's captures. Non-constant captures are sorted by their offsets.
273 llvm::SmallVector<Capture, 4> SortedCaptures;
274
275 // Currently we assume that block-pointer types are never signed.
276 RawAddress LocalAddress;
277 llvm::StructType *StructureType;
278 const BlockDecl *Block;
279 const BlockExpr *BlockExpression;
280 CharUnits BlockSize;
281 CharUnits BlockAlign;
282 CharUnits CXXThisOffset;
283
284 // Offset of the gap caused by block header having a smaller
285 // alignment than the alignment of the block descriptor. This
286 // is the gap offset before the first capturued field.
287 CharUnits BlockHeaderForcedGapOffset;
288 // Gap size caused by aligning first field after block header.
289 // This could be zero if no forced alignment is required.
290 CharUnits BlockHeaderForcedGapSize;
291
292 void buildCaptureMap() {
293 for (auto &C : SortedCaptures)
294 Captures[C.Cap->getVariable()] = &C;
295 }
296
297 const Capture &getCapture(const VarDecl *var) const {
298 return const_cast<CGBlockInfo*>(this)->getCapture(var);
299 }
300 Capture &getCapture(const VarDecl *var) {
301 auto it = Captures.find(Val: var);
302 assert(it != Captures.end() && "no entry for variable!");
303 return *it->second;
304 }
305
306 const BlockDecl *getBlockDecl() const { return Block; }
307 const BlockExpr *getBlockExpr() const {
308 assert(BlockExpression);
309 assert(BlockExpression->getBlockDecl() == Block);
310 return BlockExpression;
311 }
312
313 CGBlockInfo(const BlockDecl *blockDecl, StringRef Name);
314};
315
316} // end namespace CodeGen
317} // end namespace clang
318
319#endif
320