320 lines · c
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-exception6//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_H14#define LLVM_CLANG_LIB_CODEGEN_CGBLOCKS_H15 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), // compiler40 BLOCK_BYREF_LAYOUT_MASK = (0xF << 28), // compiler41 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 __block93 variable */94 BLOCK_FIELD_IS_WEAK = 0x10, /* declared __weak, only used in byref copy95 helpers */96 BLOCK_FIELD_IS_ARC = 0x40, /* field has ARC-specific semantics */97 BLOCK_BYREF_CALLER = 128, /* called from __block (byref) copy/dispose98 support routines */99 BLOCK_BYREF_CURRENT_MAX = 256100};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 object114 /// 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 an145/// entity that's captured by a block.146enum class BlockCaptureEntityKind {147 None,148 CXXRecord, // Copy or destroy149 AddressDiscriminatedPointerAuth,150 ARCWeak,151 ARCStrong,152 NonTrivialCStruct,153 BlockObject, // Assign or release154};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 of171 /// the capture's VarDecl, but can be different if there is an enclosing172 /// 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(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 Capture206 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 has242 /// no non-constant captures.243 bool CanBeGlobal : 1;244 245 /// True if the block has captures that would necessitate custom copy or246 /// 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 functions253 /// need to be run even in GC mode.254 bool HasCXXObject : 1;255 256 /// UsesStret : True if the block uses an stret return. Mutable257 /// because it gets set later in the block-creation process.258 mutable bool UsesStret : 1;259 260 /// HasCapturedVariableLayout : True if block has captured variables261 /// 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. This265 /// bit is used to determine the linkage of the block copy/destroy helper266 /// 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 smaller285 // alignment than the alignment of the block descriptor. This286 // 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(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 CodeGen317} // end namespace clang318 319#endif320