head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.04; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.02.14.20.07.10; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.05.30.18.14.40; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.33.36; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.35.25; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.30.58; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.02.14.20.07.10; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.36; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.17; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.31; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGBlocks.cpp - Emit LLVM Code for declarations -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit blocks. // //===----------------------------------------------------------------------===// #include "CGBlocks.h" #include "CGDebugInfo.h" #include "CGObjCRuntime.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "clang/AST/DeclObjC.h" #include "llvm/ADT/SmallSet.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Module.h" #include "llvm/Support/CallSite.h" #include #include using namespace clang; using namespace CodeGen; CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name) : Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false), HasCXXObject(false), UsesStret(false), HasCapturedVariableLayout(false), StructureType(0), Block(block), DominatingIP(0) { // Skip asm prefix, if any. 'name' is usually taken directly from // the mangled name of the enclosing function. if (!name.empty() && name[0] == '\01') name = name.substr(1); } // Anchor the vtable to this translation unit. CodeGenModule::ByrefHelpers::~ByrefHelpers() {} /// Build the given block as a global block. static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn); /// Build the helper function to copy a block. static llvm::Constant *buildCopyHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo); } /// Build the helper function to dipose of a block. static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo); } /// buildBlockDescriptor - Build the block descriptor meta-data for a block. /// buildBlockDescriptor is accessed from 5th field of the Block_literal /// meta-data and contains stationary information about the block literal. /// Its definition will have 4 (or optinally 6) words. /// \code /// struct Block_descriptor { /// unsigned long reserved; /// unsigned long size; // size of Block_literal metadata in bytes. /// void *copy_func_helper_decl; // optional copy helper. /// void *destroy_func_decl; // optioanl destructor helper. /// void *block_method_encoding_address; // @@encode for block literal signature. /// void *block_layout_info; // encoding of captured block variables. /// }; /// \endcode static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { ASTContext &C = CGM.getContext(); llvm::Type *ulong = CGM.getTypes().ConvertType(C.UnsignedLongTy); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); SmallVector elements; // reserved elements.push_back(llvm::ConstantInt::get(ulong, 0)); // Size // FIXME: What is the right way to say this doesn't fit? We should give // a user diagnostic in that case. Better fix would be to change the // API to size_t. elements.push_back(llvm::ConstantInt::get(ulong, blockInfo.BlockSize.getQuantity())); // Optional copy/dispose helpers. if (blockInfo.NeedsCopyDispose) { // copy_func_helper_decl elements.push_back(buildCopyHelper(CGM, blockInfo)); // destroy_func_decl elements.push_back(buildDisposeHelper(CGM, blockInfo)); } // Signature. Mandatory ObjC-style method descriptor @@encode sequence. std::string typeAtEncoding = CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr()); elements.push_back(llvm::ConstantExpr::getBitCast( CGM.GetAddrOfConstantCString(typeAtEncoding), i8p)); // GC layout. if (C.getLangOpts().ObjC1) { if (CGM.getLangOpts().getGC() != LangOptions::NonGC) elements.push_back(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo)); else elements.push_back(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo)); } else elements.push_back(llvm::Constant::getNullValue(i8p)); llvm::Constant *init = llvm::ConstantStruct::getAnon(elements); llvm::GlobalVariable *global = new llvm::GlobalVariable(CGM.getModule(), init->getType(), true, llvm::GlobalValue::InternalLinkage, init, "__block_descriptor_tmp"); return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType()); } /* Purely notional variadic template describing the layout of a block. template struct Block_literal { /// Initialized to one of: /// extern void *_NSConcreteStackBlock[]; /// extern void *_NSConcreteGlobalBlock[]; /// /// In theory, we could start one off malloc'ed by setting /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using /// this isa: /// extern void *_NSConcreteMallocBlock[]; struct objc_class *isa; /// These are the flags (with corresponding bit number) that the /// compiler is actually supposed to know about. /// 25. BLOCK_HAS_COPY_DISPOSE - indicates that the block /// descriptor provides copy and dispose helper functions /// 26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured /// object with a nontrivial destructor or copy constructor /// 28. BLOCK_IS_GLOBAL - indicates that the block is allocated /// as global memory /// 29. BLOCK_USE_STRET - indicates that the block function /// uses stret, which objc_msgSend needs to know about /// 30. BLOCK_HAS_SIGNATURE - indicates that the block has an /// @@encoded signature string /// And we're not supposed to manipulate these: /// 24. BLOCK_NEEDS_FREE - indicates that the block has been moved /// to malloc'ed memory /// 27. BLOCK_IS_GC - indicates that the block has been moved to /// to GC-allocated memory /// Additionally, the bottom 16 bits are a reference count which /// should be zero on the stack. int flags; /// Reserved; should be zero-initialized. int reserved; /// Function pointer generated from block literal. _ResultType (*invoke)(Block_literal *, _ParamTypes...); /// Block description metadata generated from block literal. struct Block_descriptor *block_descriptor; /// Captured values follow. _CapturesTypes captures...; }; */ /// The number of fields in a block header. const unsigned BlockHeaderSize = 5; namespace { /// A chunk of data that we actually have to capture in the block. struct BlockLayoutChunk { CharUnits Alignment; CharUnits Size; Qualifiers::ObjCLifetime Lifetime; const BlockDecl::Capture *Capture; // null for 'this' llvm::Type *Type; BlockLayoutChunk(CharUnits align, CharUnits size, Qualifiers::ObjCLifetime lifetime, const BlockDecl::Capture *capture, llvm::Type *type) : Alignment(align), Size(size), Lifetime(lifetime), Capture(capture), Type(type) {} /// Tell the block info that this chunk has the given field index. void setIndex(CGBlockInfo &info, unsigned index) { if (!Capture) info.CXXThisIndex = index; else info.Captures[Capture->getVariable()] = CGBlockInfo::Capture::makeIndex(index); } }; /// Order by 1) all __strong together 2) next, all byfref together 3) next, /// all __weak together. Preserve descending alignment in all situations. bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) { CharUnits LeftValue, RightValue; bool LeftByref = left.Capture ? left.Capture->isByRef() : false; bool RightByref = right.Capture ? right.Capture->isByRef() : false; if (left.Lifetime == Qualifiers::OCL_Strong && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(64); else if (LeftByref && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(32); else if (left.Lifetime == Qualifiers::OCL_Weak && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(16); else LeftValue = left.Alignment; if (right.Lifetime == Qualifiers::OCL_Strong && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(64); else if (RightByref && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(32); else if (right.Lifetime == Qualifiers::OCL_Weak && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(16); else RightValue = right.Alignment; return LeftValue > RightValue; } } /// Determines if the given type is safe for constant capture in C++. static bool isSafeForCXXConstantCapture(QualType type) { const RecordType *recordType = type->getBaseElementTypeUnsafe()->getAs(); // Only records can be unsafe. if (!recordType) return true; const CXXRecordDecl *record = cast(recordType->getDecl()); // Maintain semantics for classes with non-trivial dtors or copy ctors. if (!record->hasTrivialDestructor()) return false; if (record->hasNonTrivialCopyConstructor()) return false; // Otherwise, we just have to make sure there aren't any mutable // fields that might have changed since initialization. return !record->hasMutableFields(); } /// It is illegal to modify a const object after initialization. /// Therefore, if a const object has a constant initializer, we don't /// actually need to keep storage for it in the block; we'll just /// rematerialize it at the start of the block function. This is /// acceptable because we make no promises about address stability of /// captured variables. static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM, CodeGenFunction *CGF, const VarDecl *var) { QualType type = var->getType(); // We can only do this if the variable is const. if (!type.isConstQualified()) return 0; // Furthermore, in C++ we have to worry about mutable fields: // C++ [dcl.type.cv]p4: // Except that any class member declared mutable can be // modified, any attempt to modify a const object during its // lifetime results in undefined behavior. if (CGM.getLangOpts().CPlusPlus && !isSafeForCXXConstantCapture(type)) return 0; // If the variable doesn't have any initializer (shouldn't this be // invalid?), it's not clear what we should do. Maybe capture as // zero? const Expr *init = var->getInit(); if (!init) return 0; return CGM.EmitConstantInit(*var, CGF); } /// Get the low bit of a nonzero character count. This is the /// alignment of the nth byte if the 0th byte is universally aligned. static CharUnits getLowBit(CharUnits v) { return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1)); } static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info, SmallVectorImpl &elementTypes) { ASTContext &C = CGM.getContext(); // The header is basically a 'struct { void *; int; int; void *; void *; }'. CharUnits ptrSize, ptrAlign, intSize, intAlign; llvm::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy); llvm::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy); // Are there crazy embedded platforms where this isn't true? assert(intSize <= ptrSize && "layout assumptions horribly violated"); CharUnits headerSize = ptrSize; if (2 * intSize < ptrAlign) headerSize += ptrSize; else headerSize += 2 * intSize; headerSize += 2 * ptrSize; info.BlockAlign = ptrAlign; info.BlockSize = headerSize; assert(elementTypes.empty()); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); llvm::Type *intTy = CGM.getTypes().ConvertType(C.IntTy); elementTypes.push_back(i8p); elementTypes.push_back(intTy); elementTypes.push_back(intTy); elementTypes.push_back(i8p); elementTypes.push_back(CGM.getBlockDescriptorType()); assert(elementTypes.size() == BlockHeaderSize); } /// Compute the layout of the given block. Attempts to lay the block /// out with minimal space requirements. static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF, CGBlockInfo &info) { ASTContext &C = CGM.getContext(); const BlockDecl *block = info.getBlockDecl(); SmallVector elementTypes; initializeForBlockHeader(CGM, info, elementTypes); if (!block->hasCaptures()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } else if (C.getLangOpts().ObjC1 && CGM.getLangOpts().getGC() == LangOptions::NonGC) info.HasCapturedVariableLayout = true; // Collect the layout chunks. SmallVector layout; layout.reserve(block->capturesCXXThis() + (block->capture_end() - block->capture_begin())); CharUnits maxFieldAlign; // First, 'this'. if (block->capturesCXXThis()) { assert(CGF && CGF->CurFuncDecl && isa(CGF->CurFuncDecl) && "Can't capture 'this' outside a method"); QualType thisType = cast(CGF->CurFuncDecl)->getThisType(C); llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType); std::pair tinfo = CGM.getContext().getTypeInfoInChars(thisType); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, 0, llvmType)); } // Next, all the block captures. for (BlockDecl::capture_const_iterator ci = block->capture_begin(), ce = block->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); if (ci->isByRef()) { // We have to copy/dispose of the __block reference. info.NeedsCopyDispose = true; // Just use void* instead of a pointer to the byref type. QualType byRefPtrTy = C.VoidPtrTy; llvm::Type *llvmType = CGM.getTypes().ConvertType(byRefPtrTy); std::pair tinfo = CGM.getContext().getTypeInfoInChars(byRefPtrTy); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, &*ci, llvmType)); continue; } // Otherwise, build a layout chunk with the size and alignment of // the declaration. if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) { info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant); continue; } // If we have a lifetime qualifier, honor it for capture purposes. // That includes *not* copying it if it's __unsafe_unretained. Qualifiers::ObjCLifetime lifetime = variable->getType().getObjCLifetime(); if (lifetime) { switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: break; case Qualifiers::OCL_Strong: case Qualifiers::OCL_Weak: info.NeedsCopyDispose = true; } // Block pointers require copy/dispose. So do Objective-C pointers. } else if (variable->getType()->isObjCRetainableType()) { info.NeedsCopyDispose = true; // used for mrr below. lifetime = Qualifiers::OCL_Strong; // So do types that require non-trivial copy construction. } else if (ci->hasCopyExpr()) { info.NeedsCopyDispose = true; info.HasCXXObject = true; // And so do types with destructors. } else if (CGM.getLangOpts().CPlusPlus) { if (const CXXRecordDecl *record = variable->getType()->getAsCXXRecordDecl()) { if (!record->hasTrivialDestructor()) { info.HasCXXObject = true; info.NeedsCopyDispose = true; } } } QualType VT = variable->getType(); CharUnits size = C.getTypeSizeInChars(VT); CharUnits align = C.getDeclAlign(variable); maxFieldAlign = std::max(maxFieldAlign, align); llvm::Type *llvmType = CGM.getTypes().ConvertTypeForMem(VT); layout.push_back(BlockLayoutChunk(align, size, lifetime, &*ci, llvmType)); } // If that was everything, we're done here. if (layout.empty()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } // Sort the layout by alignment. We have to use a stable sort here // to get reproducible results. There should probably be an // llvm::array_pod_stable_sort. std::stable_sort(layout.begin(), layout.end()); // Needed for blocks layout info. info.BlockHeaderForcedGapOffset = info.BlockSize; info.BlockHeaderForcedGapSize = CharUnits::Zero(); CharUnits &blockSize = info.BlockSize; info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign); // Assuming that the first byte in the header is maximally aligned, // get the alignment of the first byte following the header. CharUnits endAlign = getLowBit(blockSize); // If the end of the header isn't satisfactorily aligned for the // maximum thing, look for things that are okay with the header-end // alignment, and keep appending them until we get something that's // aligned right. This algorithm is only guaranteed optimal if // that condition is satisfied at some point; otherwise we can get // things like: // header // next byte has alignment 4 // something_with_size_5; // next byte has alignment 1 // something_with_alignment_8; // which has 7 bytes of padding, as opposed to the naive solution // which might have less (?). if (endAlign < maxFieldAlign) { SmallVectorImpl::iterator li = layout.begin() + 1, le = layout.end(); // Look for something that the header end is already // satisfactorily aligned for. for (; li != le && endAlign < li->Alignment; ++li) ; // If we found something that's naturally aligned for the end of // the header, keep adding things... if (li != le) { SmallVectorImpl::iterator first = li; for (; li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); // ...until we get to the alignment of the maximum field. if (endAlign >= maxFieldAlign) { if (li == first) { // No user field was appended. So, a gap was added. // Save total gap size for use in block layout bit map. info.BlockHeaderForcedGapSize = li->Size; } break; } } // Don't re-append everything we just appended. layout.erase(first, li); } } assert(endAlign == getLowBit(blockSize)); // At this point, we just have to add padding if the end align still // isn't aligned right. if (endAlign < maxFieldAlign) { CharUnits newBlockSize = blockSize.RoundUpToAlignment(maxFieldAlign); CharUnits padding = newBlockSize - blockSize; elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, padding.getQuantity())); blockSize = newBlockSize; endAlign = getLowBit(blockSize); // might be > maxFieldAlign } assert(endAlign >= maxFieldAlign); assert(endAlign == getLowBit(blockSize)); // Slam everything else on now. This works because they have // strictly decreasing alignment and we expect that size is always a // multiple of alignment. for (SmallVectorImpl::iterator li = layout.begin(), le = layout.end(); li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); } info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); } /// Enter the scope of a block. This should be run at the entrance to /// a full-expression so that the block's cleanups are pushed at the /// right place in the stack. static void enterBlockScope(CodeGenFunction &CGF, BlockDecl *block) { assert(CGF.HaveInsertPoint()); // Allocate the block info and place it at the head of the list. CGBlockInfo &blockInfo = *new CGBlockInfo(block, CGF.CurFn->getName()); blockInfo.NextBlockInfo = CGF.FirstBlockInfo; CGF.FirstBlockInfo = &blockInfo; // Compute information about the layout, etc., of this block, // pushing cleanups as necessary. computeBlockInfo(CGF.CGM, &CGF, blockInfo); // Nothing else to do if it can be global. if (blockInfo.CanBeGlobal) return; // Make the allocation for the block. blockInfo.Address = CGF.CreateTempAlloca(blockInfo.StructureType, "block"); blockInfo.Address->setAlignment(blockInfo.BlockAlign.getQuantity()); // If there are cleanups to emit, enter them (but inactive). if (!blockInfo.NeedsCopyDispose) return; // Walk through the captures (in order) and find the ones not // captured by constant. for (BlockDecl::capture_const_iterator ci = block->capture_begin(), ce = block->capture_end(); ci != ce; ++ci) { // Ignore __block captures; there's nothing special in the // on-stack block that we need to do for them. if (ci->isByRef()) continue; // Ignore variables that are constant-captured. const VarDecl *variable = ci->getVariable(); CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; // Ignore objects that aren't destructed. QualType::DestructionKind dtorKind = variable->getType().isDestructedType(); if (dtorKind == QualType::DK_none) continue; CodeGenFunction::Destroyer *destroyer; // Block captures count as local values and have imprecise semantics. // They also can't be arrays, so need to worry about that. if (dtorKind == QualType::DK_objc_strong_lifetime) { destroyer = CodeGenFunction::destroyARCStrongImprecise; } else { destroyer = CGF.getDestroyer(dtorKind); } // GEP down to the address. llvm::Value *addr = CGF.Builder.CreateStructGEP(blockInfo.Address, capture.getIndex()); // We can use that GEP as the dominating IP. if (!blockInfo.DominatingIP) blockInfo.DominatingIP = cast(addr); CleanupKind cleanupKind = InactiveNormalCleanup; bool useArrayEHCleanup = CGF.needsEHCleanup(dtorKind); if (useArrayEHCleanup) cleanupKind = InactiveNormalAndEHCleanup; CGF.pushDestroy(cleanupKind, addr, variable->getType(), destroyer, useArrayEHCleanup); // Remember where that cleanup was. capture.setCleanup(CGF.EHStack.stable_begin()); } } /// Enter a full-expression with a non-trivial number of objects to /// clean up. This is in this file because, at the moment, the only /// kind of cleanup object is a BlockDecl*. void CodeGenFunction::enterNonTrivialFullExpression(const ExprWithCleanups *E) { assert(E->getNumObjects() != 0); ArrayRef cleanups = E->getObjects(); for (ArrayRef::iterator i = cleanups.begin(), e = cleanups.end(); i != e; ++i) { enterBlockScope(*this, *i); } } /// Find the layout for the given block in a linked list and remove it. static CGBlockInfo *findAndRemoveBlockInfo(CGBlockInfo **head, const BlockDecl *block) { while (true) { assert(head && *head); CGBlockInfo *cur = *head; // If this is the block we're looking for, splice it out of the list. if (cur->getBlockDecl() == block) { *head = cur->NextBlockInfo; return cur; } head = &cur->NextBlockInfo; } } /// Destroy a chain of block layouts. void CodeGenFunction::destroyBlockInfos(CGBlockInfo *head) { assert(head && "destroying an empty chain"); do { CGBlockInfo *cur = head; head = cur->NextBlockInfo; delete cur; } while (head != 0); } /// Emit a block literal expression in the current function. llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) { // If the block has no captures, we won't have a pre-computed // layout for it. if (!blockExpr->getBlockDecl()->hasCaptures()) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName()); computeBlockInfo(CGM, this, blockInfo); blockInfo.BlockExpression = blockExpr; return EmitBlockLiteral(blockInfo); } // Find the block info for this block and take ownership of it. OwningPtr blockInfo; blockInfo.reset(findAndRemoveBlockInfo(&FirstBlockInfo, blockExpr->getBlockDecl())); blockInfo->BlockExpression = blockExpr; return EmitBlockLiteral(*blockInfo); } llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) { // Using the computed layout, generate the actual block function. bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda(); llvm::Constant *blockFn = CodeGenFunction(CGM, true).GenerateBlockFunction(CurGD, blockInfo, LocalDeclMap, isLambdaConv); blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); // If there is nothing to capture, we can emit this as a global block. if (blockInfo.CanBeGlobal) return buildGlobalBlock(CGM, blockInfo, blockFn); // Otherwise, we have to emit this as a local block. llvm::Constant *isa = CGM.getNSConcreteStackBlock(); isa = llvm::ConstantExpr::getBitCast(isa, VoidPtrTy); // Build the block descriptor. llvm::Constant *descriptor = buildBlockDescriptor(CGM, blockInfo); llvm::AllocaInst *blockAddr = blockInfo.Address; assert(blockAddr && "block has no address!"); // Compute the initial on-stack block flags. BlockFlags flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; // Initialize the block literal. Builder.CreateStore(isa, Builder.CreateStructGEP(blockAddr, 0, "block.isa")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(blockAddr, 1, "block.flags")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, 0), Builder.CreateStructGEP(blockAddr, 2, "block.reserved")); Builder.CreateStore(blockFn, Builder.CreateStructGEP(blockAddr, 3, "block.invoke")); Builder.CreateStore(descriptor, Builder.CreateStructGEP(blockAddr, 4, "block.descriptor")); // Finally, capture all the values into the block. const BlockDecl *blockDecl = blockInfo.getBlockDecl(); // First, 'this'. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(blockAddr, blockInfo.CXXThisIndex, "block.captured-this.addr"); Builder.CreateStore(LoadCXXThis(), addr); } // Next, captured variables. for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); // Ignore constant captures. if (capture.isConstant()) continue; QualType type = variable->getType(); CharUnits align = getContext().getDeclAlign(variable); // This will be a [[type]]*, except that a byref entry will just be // an i8**. llvm::Value *blockField = Builder.CreateStructGEP(blockAddr, capture.getIndex(), "block.captured"); // Compute the address of the thing we're going to move into the // block literal. llvm::Value *src; if (BlockInfo && ci->isNested()) { // We need to use the capture from the enclosing block. const CGBlockInfo::Capture &enclosingCapture = BlockInfo->getCapture(variable); // This is a [[type]]*, except that a byref entry wil just be an i8**. src = Builder.CreateStructGEP(LoadBlockStruct(), enclosingCapture.getIndex(), "block.capture.addr"); } else if (blockDecl->isConversionFromLambda()) { // The lambda capture in a lambda's conversion-to-block-pointer is // special; we'll simply emit it directly. src = 0; } else { // Just look it up in the locals map, which will give us back a // [[type]]*. If that doesn't work, do the more elaborate DRE // emission. src = LocalDeclMap.lookup(variable); if (!src) { DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ ci->isNested(), type, VK_LValue, SourceLocation()); src = EmitDeclRefLValue(&declRef).getAddress(); } } // For byrefs, we just write the pointer to the byref struct into // the block field. There's no need to chase the forwarding // pointer at this point, since we're building something that will // live a shorter life than the stack byref anyway. if (ci->isByRef()) { // Get a void* that points to the byref struct. if (ci->isNested()) src = Builder.CreateAlignedLoad(src, align.getQuantity(), "byref.capture"); else src = Builder.CreateBitCast(src, VoidPtrTy); // Write that void* into the capture field. Builder.CreateAlignedStore(src, blockField, align.getQuantity()); // If we have a copy constructor, evaluate that into the block field. } else if (const Expr *copyExpr = ci->getCopyExpr()) { if (blockDecl->isConversionFromLambda()) { // If we have a lambda conversion, emit the expression // directly into the block instead. AggValueSlot Slot = AggValueSlot::forAddr(blockField, align, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); EmitAggExpr(copyExpr, Slot); } else { EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr); } // If it's a reference variable, copy the reference into the block field. } else if (type->isReferenceType()) { llvm::Value *ref = Builder.CreateAlignedLoad(src, align.getQuantity(), "ref.val"); Builder.CreateAlignedStore(ref, blockField, align.getQuantity()); // If this is an ARC __strong block-pointer variable, don't do a // block copy. // // TODO: this can be generalized into the normal initialization logic: // we should never need to do a block-copy when initializing a local // variable, because the local variable's lifetime should be strictly // contained within the stack block's. } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong && type->isBlockPointerType()) { // Load the block and do a simple retain. LValue srcLV = MakeAddrLValue(src, type, align); llvm::Value *value = EmitLoadOfScalar(srcLV, SourceLocation()); value = EmitARCRetainNonBlock(value); // Do a primitive store to the block field. LValue destLV = MakeAddrLValue(blockField, type, align); EmitStoreOfScalar(value, destLV, /*init*/ true); // Otherwise, fake up a POD copy into the block field. } else { // Fake up a new variable so that EmitScalarInit doesn't think // we're referring to the variable in its own initializer. ImplicitParamDecl blockFieldPseudoVar(/*DC*/ 0, SourceLocation(), /*name*/ 0, type); // We use one of these or the other depending on whether the // reference is nested. DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ ci->isNested(), type, VK_LValue, SourceLocation()); ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue, &declRef, VK_RValue); EmitExprAsInit(&l2r, &blockFieldPseudoVar, MakeAddrLValue(blockField, type, align), /*captured by init*/ false); } // Activate the cleanup if layout pushed one. if (!ci->isByRef()) { EHScopeStack::stable_iterator cleanup = capture.getCleanup(); if (cleanup.isValid()) ActivateCleanupBlock(cleanup, blockInfo.DominatingIP); } } // Cast to the converted block-pointer type, which happens (somewhat // unfortunately) to be a pointer to function type. llvm::Value *result = Builder.CreateBitCast(blockAddr, ConvertType(blockInfo.getBlockExpr()->getType())); return result; } llvm::Type *CodeGenModule::getBlockDescriptorType() { if (BlockDescriptorType) return BlockDescriptorType; llvm::Type *UnsignedLongTy = getTypes().ConvertType(getContext().UnsignedLongTy); // struct __block_descriptor { // unsigned long reserved; // unsigned long block_size; // // // later, the following will be added // // struct { // void (*copyHelper)(); // void (*copyHelper)(); // } helpers; // !!! optional // // const char *signature; // the block signature // const char *layout; // reserved // }; BlockDescriptorType = llvm::StructType::create("struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy, NULL); // Now form a pointer to that. BlockDescriptorType = llvm::PointerType::getUnqual(BlockDescriptorType); return BlockDescriptorType; } llvm::Type *CodeGenModule::getGenericBlockLiteralType() { if (GenericBlockLiteralType) return GenericBlockLiteralType; llvm::Type *BlockDescPtrTy = getBlockDescriptorType(); // struct __block_literal_generic { // void *__isa; // int __flags; // int __reserved; // void (*__invoke)(void *); // struct __block_descriptor *__descriptor; // }; GenericBlockLiteralType = llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy, IntTy, IntTy, VoidPtrTy, BlockDescPtrTy, NULL); return GenericBlockLiteralType; } RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue) { const BlockPointerType *BPT = E->getCallee()->getType()->getAs(); llvm::Value *Callee = EmitScalarExpr(E->getCallee()); // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::getUnqual(CGM.getGenericBlockLiteralType()); // Bitcast the callee to a block literal. llvm::Value *BlockLiteral = Builder.CreateBitCast(Callee, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. llvm::Value *FuncPtr = Builder.CreateStructGEP(BlockLiteral, 3); BlockLiteral = Builder.CreateBitCast(BlockLiteral, VoidPtrTy); // Add the block literal. CallArgList Args; Args.add(RValue::get(BlockLiteral), getContext().VoidPtrTy); QualType FnType = BPT->getPointeeType(); // And the rest of the arguments. EmitCallArgs(Args, FnType->getAs(), E->arg_begin(), E->arg_end()); // Load the function. llvm::Value *Func = Builder.CreateLoad(FuncPtr); const FunctionType *FuncTy = FnType->castAs(); const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy); // Cast the function pointer to the right type. llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo); llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy); Func = Builder.CreateBitCast(Func, BlockFTyPtr); // And call the block. return EmitCall(FnInfo, Func, ReturnValue, Args); } llvm::Value *CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable, bool isByRef) { assert(BlockInfo && "evaluating block ref without block information?"); const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable); // Handle constant captures. if (capture.isConstant()) return LocalDeclMap[variable]; llvm::Value *addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(), "block.capture.addr"); if (isByRef) { // addr should be a void** right now. Load, then cast the result // to byref*. addr = Builder.CreateLoad(addr); llvm::PointerType *byrefPointerType = llvm::PointerType::get(BuildByRefType(variable), 0); addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr"); // Follow the forwarding pointer. addr = Builder.CreateStructGEP(addr, 1, "byref.forwarding"); addr = Builder.CreateLoad(addr, "byref.addr.forwarded"); // Cast back to byref* and GEP over to the actual object. addr = Builder.CreateBitCast(addr, byrefPointerType); addr = Builder.CreateStructGEP(addr, getByRefValueLLVMField(variable), variable->getNameAsString()); } if (variable->getType()->isReferenceType()) addr = Builder.CreateLoad(addr, "ref.tmp"); return addr; } llvm::Constant * CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *blockExpr, const char *name) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), name); blockInfo.BlockExpression = blockExpr; // Compute information about the layout, etc., of this block. computeBlockInfo(*this, 0, blockInfo); // Using that metadata, generate the actual block function. llvm::Constant *blockFn; { llvm::DenseMap LocalDeclMap; blockFn = CodeGenFunction(*this).GenerateBlockFunction(GlobalDecl(), blockInfo, LocalDeclMap, false); } blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); return buildGlobalBlock(*this, blockInfo, blockFn); } static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn) { assert(blockInfo.CanBeGlobal); // Generate the constants for the block literal initializer. llvm::Constant *fields[BlockHeaderSize]; // isa fields[0] = CGM.getNSConcreteGlobalBlock(); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields[1] = llvm::ConstantInt::get(CGM.IntTy, flags.getBitMask()); // Reserved fields[2] = llvm::Constant::getNullValue(CGM.IntTy); // Function fields[3] = blockFn; // Descriptor fields[4] = buildBlockDescriptor(CGM, blockInfo); llvm::Constant *init = llvm::ConstantStruct::getAnon(fields); llvm::GlobalVariable *literal = new llvm::GlobalVariable(CGM.getModule(), init->getType(), /*constant*/ true, llvm::GlobalVariable::InternalLinkage, init, "__block_literal_global"); literal->setAlignment(blockInfo.BlockAlign.getQuantity()); // Return a constant of the appropriately-casted type. llvm::Type *requiredType = CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType()); return llvm::ConstantExpr::getBitCast(literal, requiredType); } llvm::Function * CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &blockInfo, const DeclMapTy &ldm, bool IsLambdaConversionToBlock) { const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CurGD = GD; BlockInfo = &blockInfo; // Arrange for local static and local extern declarations to appear // to be local to this function as well, in case they're directly // referenced in a block. for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) { const VarDecl *var = dyn_cast(i->first); if (var && !var->hasLocalStorage()) LocalDeclMap[var] = i->second; } // Begin building the function declaration. // Build the argument list. FunctionArgList args; // The first argument is the block pointer. Just take it as a void* // and cast it later. QualType selfTy = getContext().VoidPtrTy; IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor"); ImplicitParamDecl selfDecl(const_cast(blockDecl), SourceLocation(), II, selfTy); args.push_back(&selfDecl); // Now add the rest of the parameters. for (BlockDecl::param_const_iterator i = blockDecl->param_begin(), e = blockDecl->param_end(); i != e; ++i) args.push_back(*i); // Create the function declaration. const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType(); const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeFunctionDeclaration(fnType->getResultType(), args, fnType->getExtInfo(), fnType->isVariadic()); if (CGM.ReturnTypeUsesSRet(fnInfo)) blockInfo.UsesStret = true; llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo); MangleBuffer name; CGM.getBlockMangledName(GD, name, blockDecl); llvm::Function *fn = llvm::Function::Create(fnLLVMType, llvm::GlobalValue::InternalLinkage, name.getString(), &CGM.getModule()); CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo); // Begin generating the function. StartFunction(blockDecl, fnType->getResultType(), fn, fnInfo, args, blockInfo.getBlockExpr()->getBody()->getLocStart()); // Okay. Undo some of what StartFunction did. // Pull the 'self' reference out of the local decl map. llvm::Value *blockAddr = LocalDeclMap[&selfDecl]; LocalDeclMap.erase(&selfDecl); BlockPointer = Builder.CreateBitCast(blockAddr, blockInfo.StructureType->getPointerTo(), "block"); // At -O0 we generate an explicit alloca for the BlockPointer, so the RA // won't delete the dbg.declare intrinsics for captured variables. llvm::Value *BlockPointerDbgLoc = BlockPointer; if (CGM.getCodeGenOpts().OptimizationLevel == 0) { // Allocate a stack slot for it, so we can point the debugger to it llvm::AllocaInst *Alloca = CreateTempAlloca(BlockPointer->getType(), "block.addr"); unsigned Align = getContext().getDeclAlign(&selfDecl).getQuantity(); Alloca->setAlignment(Align); // Set the DebugLocation to empty, so the store is recognized as a // frame setup instruction by llvm::DwarfDebug::beginFunction(). NoLocation NL(*this, Builder); Builder.CreateAlignedStore(BlockPointer, Alloca, Align); BlockPointerDbgLoc = Alloca; } // If we have a C++ 'this' reference, go ahead and force it into // existence now. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(BlockPointer, blockInfo.CXXThisIndex, "block.captured-this"); CXXThisValue = Builder.CreateLoad(addr, "this"); } // Also force all the constant captures. for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (!capture.isConstant()) continue; unsigned align = getContext().getDeclAlign(variable).getQuantity(); llvm::AllocaInst *alloca = CreateMemTemp(variable->getType(), "block.captured-const"); alloca->setAlignment(align); Builder.CreateAlignedStore(capture.getConstant(), alloca, align); LocalDeclMap[variable] = alloca; } // Save a spot to insert the debug information for all the DeclRefExprs. llvm::BasicBlock *entry = Builder.GetInsertBlock(); llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint(); --entry_ptr; if (IsLambdaConversionToBlock) EmitLambdaBlockInvokeBody(); else EmitStmt(blockDecl->getBody()); // Remember where we were... llvm::BasicBlock *resume = Builder.GetInsertBlock(); // Go back to the entry. ++entry_ptr; Builder.SetInsertPoint(entry, entry_ptr); // Emit debug information for all the DeclRefExprs. // FIXME: also for 'this' if (CGDebugInfo *DI = getDebugInfo()) { for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); DI->EmitLocation(Builder, variable->getLocation()); if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) { DI->EmitDeclareOfAutoVariable(variable, LocalDeclMap[variable], Builder); continue; } DI->EmitDeclareOfBlockDeclRefVariable(variable, BlockPointerDbgLoc, Builder, blockInfo); } } // Recover location if it was changed in the above loop. DI->EmitLocation(Builder, cast(blockDecl->getBody())->getRBracLoc()); } // And resume where we left off. if (resume == 0) Builder.ClearInsertionPoint(); else Builder.SetInsertPoint(resume); FinishFunction(cast(blockDecl->getBody())->getRBracLoc()); return fn; } /* notes.push_back(HelperInfo()); HelperInfo ¬e = notes.back(); note.index = capture.getIndex(); note.RequiresCopying = (ci->hasCopyExpr() || BlockRequiresCopying(type)); note.cxxbar_import = ci->getCopyExpr(); if (ci->isByRef()) { note.flag = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) note.flag |= BLOCK_FIELD_IS_WEAK; } else if (type->isBlockPointerType()) { note.flag = BLOCK_FIELD_IS_BLOCK; } else { note.flag = BLOCK_FIELD_IS_OBJECT; } */ /// Generate the copy-helper function for a block closure object: /// static void block_copy_helper(block_t *dst, block_t *src); /// The runtime will have previously initialized 'dst' by doing a /// bit-copy of 'src'. /// /// Note that this copies an entire block closure object to the heap; /// it should not be confused with a 'byref copy helper', which moves /// the contents of an individual __block variable to the heap. llvm::Constant * CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl dstDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&dstDecl); ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFunctionDeclaration(C.VoidTy, args, FunctionType::ExtInfo(), /*variadic*/ false); // FIXME: it would be nice if these were mergeable with things with // identical semantics. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__copy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__copy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, 0, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation()); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block.source"); llvm::Value *dst = GetAddrOfLocalVar(&dstDecl); dst = Builder.CreateLoad(dst); dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; const Expr *copyExpr = ci->getCopyExpr(); BlockFieldFlags flags; bool useARCWeakCopy = false; bool useARCStrongCopy = false; if (copyExpr) { assert(!ci->isByRef()); // don't bother computing flags } else if (ci->isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; bool isBlockPointer = type->isBlockPointerType(); if (isBlockPointer) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures: if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // We need to register __weak direct captures with the runtime. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) { useARCWeakCopy = true; // We need to retain the copied value for __strong direct captures. } else if (qs.getObjCLifetime() == Qualifiers::OCL_Strong) { // If it's a block pointer, we have to copy the block and // assign that to the destination pointer, so we might as // well use _Block_object_assign. Otherwise we can avoid that. if (!isBlockPointer) useARCStrongCopy = true; // Otherwise the memcpy is fine. } else { continue; } // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. } else { // fall through } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); llvm::Value *dstField = Builder.CreateStructGEP(dst, index); // If there's an explicit copy expression, we do that. if (copyExpr) { EmitSynthesizedCXXCopyCtor(dstField, srcField, copyExpr); } else if (useARCWeakCopy) { EmitARCCopyWeak(dstField, srcField); } else { llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src"); if (useARCStrongCopy) { // At -O0, store null into the destination field (so that the // storeStrong doesn't over-release) and then call storeStrong. // This is a workaround to not having an initStrong call. if (CGM.getCodeGenOpts().OptimizationLevel == 0) { llvm::PointerType *ty = cast(srcValue->getType()); llvm::Value *null = llvm::ConstantPointerNull::get(ty); Builder.CreateStore(null, dstField); EmitARCStoreStrongCall(dstField, srcValue, true); // With optimization enabled, take advantage of the fact that // the blocks runtime guarantees a memcpy of the block data, and // just emit a retain of the src field. } else { EmitARCRetainNonBlock(srcValue); // We don't need this anymore, so kill it. It's not quite // worth the annoyance to avoid creating it in the first place. cast(dstField)->eraseFromParent(); } } else { srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy); llvm::Value *dstAddr = Builder.CreateBitCast(dstField, VoidPtrTy); llvm::Value *args[] = { dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; bool copyCanThrow = false; if (ci->isByRef() && variable->getType()->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(variable); if (copyExpr) { copyCanThrow = true; // FIXME: reuse the noexcept logic } } if (copyCanThrow) { EmitRuntimeCallOrInvoke(CGM.getBlockObjectAssign(), args); } else { EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args); } } } } FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } /// Generate the destroy-helper function for a block closure object: /// static void block_destroy_helper(block_t *theBlock); /// /// Note that this destroys a heap-allocated block closure object; /// it should not be confused with a 'byref destroy helper', which /// destroys the heap-allocated contents of an individual __block /// variable. llvm::Constant * CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFunctionDeclaration(C.VoidTy, args, FunctionType::ExtInfo(), /*variadic*/ false); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__destroy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__destroy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, 0, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation()); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CodeGenFunction::RunCleanupsScope cleanups(*this); for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; BlockFieldFlags flags; const CXXDestructorDecl *dtor = 0; bool useARCWeakDestroy = false; bool useARCStrongDestroy = false; if (ci->isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { if (record->hasTrivialDestructor()) continue; dtor = record->getDestructor(); } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; if (type->isBlockPointerType()) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures. if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // Don't generate special dispose logic for a captured object // unless it's __strong or __weak. if (!qs.hasStrongOrWeakObjCLifetime()) continue; // Support __weak direct captures. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) useARCWeakDestroy = true; // Tools really want us to use objc_storeStrong here. else useARCStrongDestroy = true; } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); // If there's an explicit copy expression, we do that. if (dtor) { PushDestructorCleanup(dtor, srcField); // If this is a __weak capture, emit the release directly. } else if (useARCWeakDestroy) { EmitARCDestroyWeak(srcField); // Destroy strong objects with a call if requested. } else if (useARCStrongDestroy) { EmitARCDestroyStrong(srcField, ARCImpreciseLifetime); // Otherwise we call _Block_object_dispose. It wouldn't be too // hard to just emit this as a cleanup if we wanted to make sure // that things were done in reverse. } else { llvm::Value *value = Builder.CreateLoad(srcField); value = Builder.CreateBitCast(value, VoidPtrTy); BuildBlockRelease(value, flags); } } cleanups.ForceCleanup(); FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } namespace { /// Emits the copy/dispose helper functions for a __block object of id type. class ObjectByrefHelpers : public CodeGenModule::ByrefHelpers { BlockFieldFlags Flags; public: ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags) : ByrefHelpers(alignment), Flags(flags) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy); srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy); llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField); unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask(); llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags); llvm::Value *fn = CGF.CGM.getBlockObjectAssign(); llvm::Value *args[] = { destField, srcValue, flagsVal }; CGF.EmitNounwindRuntimeCall(fn, args); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0)); llvm::Value *value = CGF.Builder.CreateLoad(field); CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER); } void profileImpl(llvm::FoldingSetNodeID &id) const { id.AddInteger(Flags.getBitMask()); } }; /// Emits the copy/dispose helpers for an ARC __block __weak variable. class ARCWeakByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCWeakByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { CGF.EmitARCMoveWeak(destField, srcField); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyWeak(field); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 0 is distinguishable from all pointers and byref flags id.AddInteger(0); } }; /// Emits the copy/dispose helpers for an ARC __block __strong variable /// that's not of block-pointer type. class ARCStrongByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { // Do a "move" by copying the value and then zeroing out the old // variable. llvm::LoadInst *value = CGF.Builder.CreateLoad(srcField); value->setAlignment(Alignment.getQuantity()); llvm::Value *null = llvm::ConstantPointerNull::get(cast(value->getType())); if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) { llvm::StoreInst *store = CGF.Builder.CreateStore(null, destField); store->setAlignment(Alignment.getQuantity()); CGF.EmitARCStoreStrongCall(destField, value, /*ignored*/ true); CGF.EmitARCStoreStrongCall(srcField, null, /*ignored*/ true); return; } llvm::StoreInst *store = CGF.Builder.CreateStore(value, destField); store->setAlignment(Alignment.getQuantity()); store = CGF.Builder.CreateStore(null, srcField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 1 is distinguishable from all pointers and byref flags id.AddInteger(1); } }; /// Emits the copy/dispose helpers for an ARC __block __strong /// variable that's of block-pointer type. class ARCStrongBlockByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongBlockByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { // Do the copy with objc_retainBlock; that's all that // _Block_object_assign would do anyway, and we'd have to pass the // right arguments to make sure it doesn't get no-op'ed. llvm::LoadInst *oldValue = CGF.Builder.CreateLoad(srcField); oldValue->setAlignment(Alignment.getQuantity()); llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true); llvm::StoreInst *store = CGF.Builder.CreateStore(copy, destField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 2 is distinguishable from all pointers and byref flags id.AddInteger(2); } }; /// Emits the copy/dispose helpers for a __block variable with a /// nontrivial copy constructor or destructor. class CXXByrefHelpers : public CodeGenModule::ByrefHelpers { QualType VarType; const Expr *CopyExpr; public: CXXByrefHelpers(CharUnits alignment, QualType type, const Expr *copyExpr) : ByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} bool needsCopy() const { return CopyExpr != 0; } void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { if (!CopyExpr) return; CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.PushDestructorCleanup(VarType, field); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; } // end anonymous namespace static llvm::Constant * generateByrefCopyHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned valueFieldIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl dst(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&dst); ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFunctionDeclaration(R, args, FunctionType::ExtInfo(), /*variadic*/ false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_copy_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_copy_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, 0, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation()); if (byrefInfo.needsCopy()) { llvm::Type *byrefPtrType = byrefType.getPointerTo(0); // dst->x llvm::Value *destField = CGF.GetAddrOfLocalVar(&dst); destField = CGF.Builder.CreateLoad(destField); destField = CGF.Builder.CreateBitCast(destField, byrefPtrType); destField = CGF.Builder.CreateStructGEP(destField, valueFieldIndex, "x"); // src->x llvm::Value *srcField = CGF.GetAddrOfLocalVar(&src); srcField = CGF.Builder.CreateLoad(srcField); srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType); srcField = CGF.Builder.CreateStructGEP(srcField, valueFieldIndex, "x"); byrefInfo.emitCopy(CGF, destField, srcField); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the copy helper for a __block variable. static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefCopyHelper(CGF, byrefType, byrefValueIndex, info); } /// Generate code for a __block variable's dispose helper. static llvm::Constant * generateByrefDisposeHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFunctionDeclaration(R, args, FunctionType::ExtInfo(), /*variadic*/ false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_dispose_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_dispose_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, 0, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation()); if (byrefInfo.needsDispose()) { llvm::Value *V = CGF.GetAddrOfLocalVar(&src); V = CGF.Builder.CreateLoad(V); V = CGF.Builder.CreateBitCast(V, byrefType.getPointerTo(0)); V = CGF.Builder.CreateStructGEP(V, byrefValueIndex, "x"); byrefInfo.emitDispose(CGF, V); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the dispose helper for a __block variable. static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefDisposeHelper(CGF, byrefType, byrefValueIndex, info); } /// Lazily build the copy and dispose helpers for a __block variable /// with the given information. template static T *buildByrefHelpers(CodeGenModule &CGM, llvm::StructType &byrefTy, unsigned byrefValueIndex, T &byrefInfo) { // Increase the field's alignment to be at least pointer alignment, // since the layout of the byref struct will guarantee at least that. byrefInfo.Alignment = std::max(byrefInfo.Alignment, CharUnits::fromQuantity(CGM.PointerAlignInBytes)); llvm::FoldingSetNodeID id; byrefInfo.Profile(id); void *insertPos; CodeGenModule::ByrefHelpers *node = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos); if (node) return static_cast(node); byrefInfo.CopyHelper = buildByrefCopyHelper(CGM, byrefTy, byrefValueIndex, byrefInfo); byrefInfo.DisposeHelper = buildByrefDisposeHelper(CGM, byrefTy, byrefValueIndex,byrefInfo); T *copy = new (CGM.getContext()) T(byrefInfo); CGM.ByrefHelpersCache.InsertNode(copy, insertPos); return copy; } /// Build the copy and dispose helpers for the given __block variable /// emission. Places the helpers in the global cache. Returns null /// if no helpers are required. CodeGenModule::ByrefHelpers * CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType, const AutoVarEmission &emission) { const VarDecl &var = *emission.Variable; QualType type = var.getType(); unsigned byrefValueIndex = getByRefValueLLVMField(&var); if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(&var); if (!copyExpr && record->hasTrivialDestructor()) return 0; CXXByrefHelpers byrefInfo(emission.Alignment, type, copyExpr); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // Otherwise, if we don't have a retainable type, there's nothing to do. // that the runtime does extra copies. if (!type->isObjCRetainableType()) return 0; Qualifiers qs = type.getQualifiers(); // If we have lifetime, that dominates. if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) { assert(getLangOpts().ObjCAutoRefCount); switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); // These are just bits as far as the runtime is concerned. case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: return 0; // Tell the runtime that this is ARC __weak, called by the // byref routines. case Qualifiers::OCL_Weak: { ARCWeakByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // ARC __strong __block variables need to be retained. case Qualifiers::OCL_Strong: // Block pointers need to be copied, and there's no direct // transfer possible. if (type->isBlockPointerType()) { ARCStrongBlockByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); // Otherwise, we transfer ownership of the retain from the stack // to the heap. } else { ARCStrongByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } } llvm_unreachable("fell out of lifetime switch!"); } BlockFieldFlags flags; if (type->isBlockPointerType()) { flags |= BLOCK_FIELD_IS_BLOCK; } else if (CGM.getContext().isObjCNSObjectType(type) || type->isObjCObjectPointerType()) { flags |= BLOCK_FIELD_IS_OBJECT; } else { return 0; } if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; ObjectByrefHelpers byrefInfo(emission.Alignment, flags); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } unsigned CodeGenFunction::getByRefValueLLVMField(const ValueDecl *VD) const { assert(ByRefValueInfo.count(VD) && "Did not find value!"); return ByRefValueInfo.find(VD)->second.second; } llvm::Value *CodeGenFunction::BuildBlockByrefAddress(llvm::Value *BaseAddr, const VarDecl *V) { llvm::Value *Loc = Builder.CreateStructGEP(BaseAddr, 1, "forwarding"); Loc = Builder.CreateLoad(Loc); Loc = Builder.CreateStructGEP(Loc, getByRefValueLLVMField(V), V->getNameAsString()); return Loc; } /// BuildByRefType - This routine changes a __block variable declared as T x /// into: /// /// struct { /// void *__isa; /// void *__forwarding; /// int32_t __flags; /// int32_t __size; /// void *__copy_helper; // only if needed /// void *__destroy_helper; // only if needed /// void *__byref_variable_layout;// only if needed /// char padding[X]; // only if needed /// T x; /// } x /// llvm::Type *CodeGenFunction::BuildByRefType(const VarDecl *D) { std::pair &Info = ByRefValueInfo[D]; if (Info.first) return Info.first; QualType Ty = D->getType(); SmallVector types; llvm::StructType *ByRefType = llvm::StructType::create(getLLVMContext(), "struct.__block_byref_" + D->getNameAsString()); // void *__isa; types.push_back(Int8PtrTy); // void *__forwarding; types.push_back(llvm::PointerType::getUnqual(ByRefType)); // int32_t __flags; types.push_back(Int32Ty); // int32_t __size; types.push_back(Int32Ty); // Note that this must match *exactly* the logic in buildByrefHelpers. bool HasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D); if (HasCopyAndDispose) { /// void *__copy_helper; types.push_back(Int8PtrTy); /// void *__destroy_helper; types.push_back(Int8PtrTy); } bool HasByrefExtendedLayout = false; Qualifiers::ObjCLifetime Lifetime; if (getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) && HasByrefExtendedLayout) /// void *__byref_variable_layout; types.push_back(Int8PtrTy); bool Packed = false; CharUnits Align = getContext().getDeclAlign(D); if (Align > getContext().toCharUnitsFromBits(getTarget().getPointerAlign(0))) { // We have to insert padding. // The struct above has 2 32-bit integers. unsigned CurrentOffsetInBytes = 4 * 2; // And either 2, 3, 4 or 5 pointers. unsigned noPointers = 2; if (HasCopyAndDispose) noPointers += 2; if (HasByrefExtendedLayout) noPointers += 1; CurrentOffsetInBytes += noPointers * CGM.getDataLayout().getTypeAllocSize(Int8PtrTy); // Align the offset. unsigned AlignedOffsetInBytes = llvm::RoundUpToAlignment(CurrentOffsetInBytes, Align.getQuantity()); unsigned NumPaddingBytes = AlignedOffsetInBytes - CurrentOffsetInBytes; if (NumPaddingBytes > 0) { llvm::Type *Ty = Int8Ty; // FIXME: We need a sema error for alignment larger than the minimum of // the maximal stack alignment and the alignment of malloc on the system. if (NumPaddingBytes > 1) Ty = llvm::ArrayType::get(Ty, NumPaddingBytes); types.push_back(Ty); // We want a packed struct. Packed = true; } } // T x; types.push_back(ConvertTypeForMem(Ty)); ByRefType->setBody(types, Packed); Info.first = ByRefType; Info.second = types.size() - 1; return Info.first; } /// Initialize the structural components of a __block variable, i.e. /// everything but the actual object. void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) { // Find the address of the local. llvm::Value *addr = emission.Address; // That's an alloca of the byref structure type. llvm::StructType *byrefType = cast( cast(addr->getType())->getElementType()); // Build the byref helpers if necessary. This is null if we don't need any. CodeGenModule::ByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission); const VarDecl &D = *emission.Variable; QualType type = D.getType(); bool HasByrefExtendedLayout; Qualifiers::ObjCLifetime ByrefLifetime; bool ByRefHasLifetime = getContext().getByrefLifetime(type, ByrefLifetime, HasByrefExtendedLayout); llvm::Value *V; // Initialize the 'isa', which is just 0 or 1. int isa = 0; if (type.isObjCGCWeak()) isa = 1; V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa"); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 0, "byref.isa")); // Store the address of the variable into its own forwarding pointer. Builder.CreateStore(addr, Builder.CreateStructGEP(addr, 1, "byref.forwarding")); // Blocks ABI: // c) the flags field is set to either 0 if no helper functions are // needed or BLOCK_BYREF_HAS_COPY_DISPOSE if they are, BlockFlags flags; if (helpers) flags |= BLOCK_BYREF_HAS_COPY_DISPOSE; if (ByRefHasLifetime) { if (HasByrefExtendedLayout) flags |= BLOCK_BYREF_LAYOUT_EXTENDED; else switch (ByrefLifetime) { case Qualifiers::OCL_Strong: flags |= BLOCK_BYREF_LAYOUT_STRONG; break; case Qualifiers::OCL_Weak: flags |= BLOCK_BYREF_LAYOUT_WEAK; break; case Qualifiers::OCL_ExplicitNone: flags |= BLOCK_BYREF_LAYOUT_UNRETAINED; break; case Qualifiers::OCL_None: if (!type->isObjCObjectPointerType() && !type->isBlockPointerType()) flags |= BLOCK_BYREF_LAYOUT_NON_OBJECT; break; default: break; } if (CGM.getLangOpts().ObjCGCBitmapPrint) { printf("\n Inline flag for BYREF variable layout (%d):", flags.getBitMask()); if (flags & BLOCK_BYREF_HAS_COPY_DISPOSE) printf(" BLOCK_BYREF_HAS_COPY_DISPOSE"); if (flags & BLOCK_BYREF_LAYOUT_MASK) { BlockFlags ThisFlag(flags.getBitMask() & BLOCK_BYREF_LAYOUT_MASK); if (ThisFlag == BLOCK_BYREF_LAYOUT_EXTENDED) printf(" BLOCK_BYREF_LAYOUT_EXTENDED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_STRONG) printf(" BLOCK_BYREF_LAYOUT_STRONG"); if (ThisFlag == BLOCK_BYREF_LAYOUT_WEAK) printf(" BLOCK_BYREF_LAYOUT_WEAK"); if (ThisFlag == BLOCK_BYREF_LAYOUT_UNRETAINED) printf(" BLOCK_BYREF_LAYOUT_UNRETAINED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_NON_OBJECT) printf(" BLOCK_BYREF_LAYOUT_NON_OBJECT"); } printf("\n"); } } Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(addr, 2, "byref.flags")); CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType); V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity()); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 3, "byref.size")); if (helpers) { llvm::Value *copy_helper = Builder.CreateStructGEP(addr, 4); Builder.CreateStore(helpers->CopyHelper, copy_helper); llvm::Value *destroy_helper = Builder.CreateStructGEP(addr, 5); Builder.CreateStore(helpers->DisposeHelper, destroy_helper); } if (ByRefHasLifetime && HasByrefExtendedLayout) { llvm::Constant* ByrefLayoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type); llvm::Value *ByrefInfoAddr = Builder.CreateStructGEP(addr, helpers ? 6 : 4, "byref.layout"); // cast destination to pointer to source type. llvm::Type *DesTy = ByrefLayoutInfo->getType(); DesTy = DesTy->getPointerTo(); llvm::Value *BC = Builder.CreatePointerCast(ByrefInfoAddr, DesTy); Builder.CreateStore(ByrefLayoutInfo, BC); } } void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags) { llvm::Value *F = CGM.getBlockObjectDispose(); llvm::Value *args[] = { Builder.CreateBitCast(V, Int8PtrTy), llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; EmitNounwindRuntimeCall(F, args); // FIXME: throwing destructors? } namespace { struct CallBlockRelease : EHScopeStack::Cleanup { llvm::Value *Addr; CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {} void Emit(CodeGenFunction &CGF, Flags flags) { // Should we be passing FIELD_IS_WEAK here? CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF); } }; } /// Enter a cleanup to destroy a __block variable. Note that this /// cleanup should be a no-op if the variable hasn't left the stack /// yet; if a cleanup is required for the variable itself, that needs /// to be done externally. void CodeGenFunction::enterByrefCleanup(const AutoVarEmission &emission) { // We don't enter this cleanup if we're in pure-GC mode. if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) return; EHStack.pushCleanup(NormalAndEHCleanup, emission.Address); } /// Adjust the declaration of something from the blocks API. static void configureBlocksRuntimeObject(CodeGenModule &CGM, llvm::Constant *C) { if (!CGM.getLangOpts().BlocksRuntimeOptional) return; llvm::GlobalValue *GV = cast(C->stripPointerCasts()); if (GV->isDeclaration() && GV->getLinkage() == llvm::GlobalValue::ExternalLinkage) GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); } llvm::Constant *CodeGenModule::getBlockObjectDispose() { if (BlockObjectDispose) return BlockObjectDispose; llvm::Type *args[] = { Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectDispose = CreateRuntimeFunction(fty, "_Block_object_dispose"); configureBlocksRuntimeObject(*this, BlockObjectDispose); return BlockObjectDispose; } llvm::Constant *CodeGenModule::getBlockObjectAssign() { if (BlockObjectAssign) return BlockObjectAssign; llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectAssign = CreateRuntimeFunction(fty, "_Block_object_assign"); configureBlocksRuntimeObject(*this, BlockObjectAssign); return BlockObjectAssign; } llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() { if (NSConcreteGlobalBlock) return NSConcreteGlobalBlock; NSConcreteGlobalBlock = GetOrCreateLLVMGlobal("_NSConcreteGlobalBlock", Int8PtrTy->getPointerTo(), 0); configureBlocksRuntimeObject(*this, NSConcreteGlobalBlock); return NSConcreteGlobalBlock; } llvm::Constant *CodeGenModule::getNSConcreteStackBlock() { if (NSConcreteStackBlock) return NSConcreteStackBlock; NSConcreteStackBlock = GetOrCreateLLVMGlobal("_NSConcreteStackBlock", Int8PtrTy->getPointerTo(), 0); configureBlocksRuntimeObject(*this, NSConcreteStackBlock); return NSConcreteStackBlock; } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d56 1 a56 1 /// Build the helper function to dispose of a block. @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @d1126 4 a1129 3 const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeFreeFunctionDeclaration( fnType->getReturnType(), args, fnType->getExtInfo(), fnType->isVariadic()); d1143 1 a1143 1 StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args, d1288 4 a1291 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); d1463 4 a1466 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); d1754 4 a1757 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); d1825 4 a1828 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); @ 1.1.1.3.2.1 log @Rebase. @ text @a20 1 #include "llvm/IR/CallSite.h" d23 1 d33 3 a35 3 StructureType(nullptr), Block(block), DominatingIP(nullptr) { d249 1 a249 1 const auto *record = cast(recordType->getDecl()); d272 1 a272 1 if (!type.isConstQualified()) return nullptr; d280 1 a280 1 return nullptr; d286 1 a286 1 if (!init) return nullptr; d303 2 a304 2 std::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy); std::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy); d369 1 a369 1 nullptr, llvmType)); d373 3 a375 2 for (const auto &CI : block->captures()) { const VarDecl *variable = CI.getVariable(); d377 1 a377 1 if (CI.isByRef()) { d390 2 a391 1 Qualifiers::OCL_None, &CI, llvmType)); d425 1 a425 1 } else if (CI.hasCopyExpr()) { d449 1 a449 1 layout.push_back(BlockLayoutChunk(align, size, lifetime, &CI, llvmType)); d584 2 a585 1 for (const auto &CI : block->captures()) { d588 1 a588 1 if (CI.isByRef()) continue; d591 1 a591 1 const VarDecl *variable = CI.getVariable(); d667 1 a667 1 } while (head != nullptr); d682 1 a682 1 std::unique_ptr blockInfo; d744 3 a746 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d764 1 a764 1 if (BlockInfo && CI.isNested()) { d776 1 a776 1 src = nullptr; d783 2 a784 2 DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ CI.isNested(), type, d794 1 a794 1 if (CI.isByRef()) { d796 1 a796 1 if (CI.isNested()) d806 1 a806 1 } else if (const Expr *copyExpr = CI.getCopyExpr()) { d848 2 a849 3 ImplicitParamDecl blockFieldPseudoVar(getContext(), /*DC*/ nullptr, SourceLocation(), /*name*/ nullptr, type); d854 1 a854 1 /*refersToEnclosing*/ CI.isNested(), type, d865 1 a865 1 if (!CI.isByRef()) { d1026 1 a1026 1 computeBlockInfo(*this, nullptr, blockInfo); d1100 1 a1100 1 const auto *var = dyn_cast(i->first); d1115 1 a1115 1 ImplicitParamDecl selfDecl(getContext(), const_cast(blockDecl), d1120 3 a1122 2 for (auto i : blockDecl->params()) args.push_back(i); d1129 1 a1129 1 if (CGM.ReturnSlotInterferesWithArgs(fnInfo)) a1142 1 blockDecl->getLocation(), d1179 3 a1181 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1203 1 a1203 4 else { PGO.assignRegionCounters(blockDecl, fn); RegionCounter Cnt = getPGORegionCounter(blockDecl->getBody()); Cnt.beginRegion(Builder); a1204 3 PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); } d1216 3 a1218 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1240 1 a1240 1 if (resume == nullptr) d1282 1 a1282 2 ImplicitParamDecl dstDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1284 1 a1284 2 ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1304 2 a1305 2 SourceLocation(), II, C.VoidTy, nullptr, SC_Static, d1310 1 a1310 1 StartFunction(FD, C.VoidTy, Fn, FI, args); d1325 3 a1327 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1333 1 a1333 1 const Expr *copyExpr = CI.getCopyExpr(); d1340 1 a1340 1 assert(!CI.isByRef()); d1343 1 a1343 1 } else if (CI.isByRef()) { d1400 1 a1400 1 auto *ty = cast(srcValue->getType()); d1423 1 a1423 1 if (CI.isByRef() && variable->getType()->getAsCXXRecordDecl()) { d1457 1 a1457 2 ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1476 2 a1477 2 SourceLocation(), II, C.VoidTy, nullptr, SC_Static, d1481 1 a1481 1 StartFunction(FD, C.VoidTy, Fn, FI, args); d1494 3 a1496 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1503 1 a1503 1 const CXXDestructorDecl *dtor = nullptr; d1508 1 a1508 1 if (CI.isByRef()) { d1585 1 a1585 1 llvm::Value *srcField) override { d1600 1 a1600 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1607 1 a1607 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1618 1 a1618 1 llvm::Value *srcField) override { d1622 1 a1622 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1626 1 a1626 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1639 1 a1639 1 llvm::Value *srcField) override { d1663 1 a1663 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1667 1 a1667 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1680 1 a1680 1 llvm::Value *srcField) override { d1693 1 a1693 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1697 1 a1697 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1714 1 a1714 1 bool needsCopy() const override { return CopyExpr != nullptr; } d1716 1 a1716 1 llvm::Value *srcField) override { d1721 1 a1721 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1727 1 a1727 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1743 1 a1743 2 ImplicitParamDecl dst(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1746 1 a1746 2 ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1767 1 a1767 1 SourceLocation(), II, R, nullptr, d1771 1 a1771 1 CGF.StartFunction(FD, R, Fn, FI, args); d1815 1 a1815 2 ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1837 1 a1837 1 SourceLocation(), II, R, nullptr, d1840 1 a1840 1 CGF.StartFunction(FD, R, Fn, FI, args); d1907 1 a1907 1 if (!copyExpr && record->hasTrivialDestructor()) return nullptr; d1915 1 a1915 1 if (!type->isObjCRetainableType()) return nullptr; d1929 1 a1929 1 return nullptr; d1963 1 a1963 1 return nullptr; d2212 1 a2212 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d2236 3 a2238 2 auto *GV = cast(C->stripPointerCasts()); if (GV->isDeclaration() && GV->hasExternalLinkage()) d2271 1 a2271 2 Int8PtrTy->getPointerTo(), nullptr); d2281 1 a2281 2 Int8PtrTy->getPointerTo(), nullptr); @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @a20 1 #include "llvm/IR/CallSite.h" d23 1 d33 3 a35 3 StructureType(nullptr), Block(block), DominatingIP(nullptr) { d249 1 a249 1 const auto *record = cast(recordType->getDecl()); d272 1 a272 1 if (!type.isConstQualified()) return nullptr; d280 1 a280 1 return nullptr; d286 1 a286 1 if (!init) return nullptr; d303 2 a304 2 std::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy); std::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy); d369 1 a369 1 nullptr, llvmType)); d373 3 a375 2 for (const auto &CI : block->captures()) { const VarDecl *variable = CI.getVariable(); d377 1 a377 1 if (CI.isByRef()) { d390 2 a391 1 Qualifiers::OCL_None, &CI, llvmType)); d425 1 a425 1 } else if (CI.hasCopyExpr()) { d449 1 a449 1 layout.push_back(BlockLayoutChunk(align, size, lifetime, &CI, llvmType)); d584 2 a585 1 for (const auto &CI : block->captures()) { d588 1 a588 1 if (CI.isByRef()) continue; d591 1 a591 1 const VarDecl *variable = CI.getVariable(); d667 1 a667 1 } while (head != nullptr); d682 1 a682 1 std::unique_ptr blockInfo; d744 3 a746 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d764 1 a764 1 if (BlockInfo && CI.isNested()) { d776 1 a776 1 src = nullptr; d783 2 a784 2 DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ CI.isNested(), type, d794 1 a794 1 if (CI.isByRef()) { d796 1 a796 1 if (CI.isNested()) d806 1 a806 1 } else if (const Expr *copyExpr = CI.getCopyExpr()) { d848 2 a849 3 ImplicitParamDecl blockFieldPseudoVar(getContext(), /*DC*/ nullptr, SourceLocation(), /*name*/ nullptr, type); d854 1 a854 1 /*refersToEnclosing*/ CI.isNested(), type, d865 1 a865 1 if (!CI.isByRef()) { d1026 1 a1026 1 computeBlockInfo(*this, nullptr, blockInfo); d1100 1 a1100 1 const auto *var = dyn_cast(i->first); d1115 1 a1115 1 ImplicitParamDecl selfDecl(getContext(), const_cast(blockDecl), d1120 3 a1122 2 for (auto i : blockDecl->params()) args.push_back(i); d1129 1 a1129 1 if (CGM.ReturnSlotInterferesWithArgs(fnInfo)) a1142 1 blockDecl->getLocation(), d1179 3 a1181 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1203 1 a1203 4 else { PGO.assignRegionCounters(blockDecl, fn); RegionCounter Cnt = getPGORegionCounter(blockDecl->getBody()); Cnt.beginRegion(Builder); a1204 3 PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); } d1216 3 a1218 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1240 1 a1240 1 if (resume == nullptr) d1282 1 a1282 2 ImplicitParamDecl dstDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1284 1 a1284 2 ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1304 2 a1305 2 SourceLocation(), II, C.VoidTy, nullptr, SC_Static, d1310 1 a1310 1 StartFunction(FD, C.VoidTy, Fn, FI, args); d1325 3 a1327 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1333 1 a1333 1 const Expr *copyExpr = CI.getCopyExpr(); d1340 1 a1340 1 assert(!CI.isByRef()); d1343 1 a1343 1 } else if (CI.isByRef()) { d1400 1 a1400 1 auto *ty = cast(srcValue->getType()); d1423 1 a1423 1 if (CI.isByRef() && variable->getType()->getAsCXXRecordDecl()) { d1457 1 a1457 2 ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); d1476 2 a1477 2 SourceLocation(), II, C.VoidTy, nullptr, SC_Static, d1481 1 a1481 1 StartFunction(FD, C.VoidTy, Fn, FI, args); d1494 3 a1496 2 for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); d1503 1 a1503 1 const CXXDestructorDecl *dtor = nullptr; d1508 1 a1508 1 if (CI.isByRef()) { d1585 1 a1585 1 llvm::Value *srcField) override { d1600 1 a1600 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1607 1 a1607 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1618 1 a1618 1 llvm::Value *srcField) override { d1622 1 a1622 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1626 1 a1626 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1639 1 a1639 1 llvm::Value *srcField) override { d1663 1 a1663 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1667 1 a1667 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1680 1 a1680 1 llvm::Value *srcField) override { d1693 1 a1693 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1697 1 a1697 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1714 1 a1714 1 bool needsCopy() const override { return CopyExpr != nullptr; } d1716 1 a1716 1 llvm::Value *srcField) override { d1721 1 a1721 1 void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { d1727 1 a1727 1 void profileImpl(llvm::FoldingSetNodeID &id) const override { d1743 1 a1743 2 ImplicitParamDecl dst(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1746 1 a1746 2 ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1767 1 a1767 1 SourceLocation(), II, R, nullptr, d1771 1 a1771 1 CGF.StartFunction(FD, R, Fn, FI, args); d1815 1 a1815 2 ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); d1837 1 a1837 1 SourceLocation(), II, R, nullptr, d1840 1 a1840 1 CGF.StartFunction(FD, R, Fn, FI, args); d1907 1 a1907 1 if (!copyExpr && record->hasTrivialDestructor()) return nullptr; d1915 1 a1915 1 if (!type->isObjCRetainableType()) return nullptr; d1929 1 a1929 1 return nullptr; d1963 1 a1963 1 return nullptr; d2212 1 a2212 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d2236 3 a2238 2 auto *GV = cast(C->stripPointerCasts()); if (GV->isDeclaration() && GV->hasExternalLinkage()) d2271 1 a2271 2 Int8PtrTy->getPointerTo(), nullptr); d2281 1 a2281 2 Int8PtrTy->getPointerTo(), nullptr); @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d1130 5 a1134 3 StringRef name = CGM.getBlockMangledName(GD, blockDecl); llvm::Function *fn = llvm::Function::Create( fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &CGM.getModule()); @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d81 1 a81 7 llvm::Type *i8p = NULL; if (CGM.getLangOpts().OpenCL) i8p = llvm::Type::getInt8PtrTy( CGM.getLLVMContext(), C.getTargetAddressSpace(LangAS::opencl_constant)); else i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); a541 10 if (endAlign < li->Alignment) { // size may not be multiple of alignment. This can only happen with // an over-aligned variable. We will be adding a padding field to // make the size be multiple of alignment. CharUnits padding = li->Alignment - endAlign; elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, padding.getQuantity())); blockSize += padding; endAlign = getLowBit(blockSize); } d779 3 a781 4 DeclRefExpr declRef( const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type, VK_LValue, SourceLocation()); d850 3 a852 3 DeclRefExpr declRef(const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type, VK_LValue, SourceLocation()); a855 3 // FIXME: Pass a specific location for the expr init so that the store is // attributed to a reasonable location - otherwise it may be attributed to // locations of subexpressions in the initialization. d902 1 a902 1 UnsignedLongTy, UnsignedLongTy, nullptr); d925 1 a925 1 BlockDescPtrTy, nullptr); a1089 2 CurEHLocation = blockInfo.getBlockExpr()->getLocEnd(); d1159 1 a1159 1 ApplyDebugLocation NL(*this); d1202 2 d1230 1 a1230 3 Builder, blockInfo, entry_ptr == entry->end() ? nullptr : entry_ptr); d1310 1 a1310 1 ApplyDebugLocation NL(*this); d1312 1 a1312 1 ArtificialLocation AL(*this); d1481 1 a1481 1 ApplyDebugLocation NL(*this); d1483 1 a1483 1 ArtificialLocation AL(*this); @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d81 1 a81 7 llvm::Type *i8p = NULL; if (CGM.getLangOpts().OpenCL) i8p = llvm::Type::getInt8PtrTy( CGM.getLLVMContext(), C.getTargetAddressSpace(LangAS::opencl_constant)); else i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); a541 10 if (endAlign < li->Alignment) { // size may not be multiple of alignment. This can only happen with // an over-aligned variable. We will be adding a padding field to // make the size be multiple of alignment. CharUnits padding = li->Alignment - endAlign; elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, padding.getQuantity())); blockSize += padding; endAlign = getLowBit(blockSize); } d779 3 a781 4 DeclRefExpr declRef( const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type, VK_LValue, SourceLocation()); d850 3 a852 3 DeclRefExpr declRef(const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type, VK_LValue, SourceLocation()); a855 3 // FIXME: Pass a specific location for the expr init so that the store is // attributed to a reasonable location - otherwise it may be attributed to // locations of subexpressions in the initialization. d902 1 a902 1 UnsignedLongTy, UnsignedLongTy, nullptr); d925 1 a925 1 BlockDescPtrTy, nullptr); a1089 2 CurEHLocation = blockInfo.getBlockExpr()->getLocEnd(); d1159 1 a1159 1 ApplyDebugLocation NL(*this); d1202 2 d1230 1 a1230 3 Builder, blockInfo, entry_ptr == entry->end() ? nullptr : entry_ptr); d1310 1 a1310 1 ApplyDebugLocation NL(*this); d1312 1 a1312 1 ArtificialLocation AL(*this); d1481 1 a1481 1 ApplyDebugLocation NL(*this); d1483 1 a1483 1 ArtificialLocation AL(*this); @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d1 1 a1 1 //===--- CGBlocks.cpp - Emit LLVM Code for declarations ---------*- C++ -*-===// d33 1 a33 1 LocalAddress(Address::invalid()), StructureType(nullptr), Block(block), d43 1 a43 1 BlockByrefHelpers::~BlockByrefHelpers() {} d81 1 a81 1 llvm::Type *i8p = nullptr; d114 1 a114 1 CGM.GetAddrOfConstantCString(typeAtEncoding).getPointer(), i8p)); d206 2 a207 2 void setIndex(CGBlockInfo &info, unsigned index, CharUnits offset) { if (!Capture) { d209 3 a211 5 info.CXXThisOffset = offset; } else { info.Captures.insert({Capture->getVariable(), CGBlockInfo::Capture::makeIndex(index, offset)}); } d218 26 a243 14 if (left.Alignment != right.Alignment) return left.Alignment > right.Alignment; auto getPrefOrder = [](const BlockLayoutChunk &chunk) { if (chunk.Capture && chunk.Capture->isByRef()) return 1; if (chunk.Lifetime == Qualifiers::OCL_Strong) return 0; if (chunk.Lifetime == Qualifiers::OCL_Weak) return 2; return 3; }; return getPrefOrder(left) < getPrefOrder(right); d245 1 a245 1 } // end anonymous namespace d305 1 a305 5 // The header is basically 'struct { void *; int; int; void *; void *; }'. // Assert that that struct is packed. assert(CGM.getIntSize() <= CGM.getPointerSize()); assert(CGM.getIntAlign() <= CGM.getPointerAlign()); assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())); d307 15 a321 2 info.BlockAlign = CGM.getPointerAlign(); info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize(); d324 6 a329 4 elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.VoidPtrTy); a367 2 // Theoretically, this could be in a different address space, so // don't assume standard pointer size/align. d387 6 a392 2 CharUnits align = CGM.getPointerAlign(); maxFieldAlign = std::max(maxFieldAlign, align); d394 2 a395 3 layout.push_back(BlockLayoutChunk(align, CGM.getPointerSize(), Qualifiers::OCL_None, &CI, CGM.VoidPtrTy)); d424 3 a426 9 // But honor the inert __unsafe_unretained qualifier, which doesn't // actually make it into the type system. if (variable->getType()->isObjCInertUnsafeUnretainedType()) { lifetime = Qualifiers::OCL_ExplicitNone; } else { info.NeedsCopyDispose = true; // used for mrr below. lifetime = Qualifiers::OCL_Strong; } d507 1 a507 1 li->setIndex(info, elementTypes.size(), blockSize); d514 5 a534 6 // If we haven't yet added any fields, remember that there was an // initial gap; this need to go into the block layout bit map. if (blockSize == info.BlockHeaderForcedGapOffset) { info.BlockHeaderForcedGapSize = padding; } d559 1 a559 1 li->setIndex(info, elementTypes.size(), blockSize); d589 3 a591 2 blockInfo.LocalAddress = CGF.CreateTempAlloca(blockInfo.StructureType, blockInfo.BlockAlign, "block"); d624 2 a625 3 Address addr = CGF.Builder.CreateStructGEP(blockInfo.LocalAddress, capture.getIndex(), capture.getOffset()); d629 1 a629 1 blockInfo.DominatingIP = cast(addr.getPointer()); d724 2 a725 2 Address blockAddr = blockInfo.LocalAddress; assert(blockAddr.isValid() && "block has no address!"); d734 10 a743 30 auto projectField = [&](unsigned index, CharUnits offset, const Twine &name) -> Address { return Builder.CreateStructGEP(blockAddr, index, offset, name); }; auto storeField = [&](llvm::Value *value, unsigned index, CharUnits offset, const Twine &name) { Builder.CreateStore(value, projectField(index, offset, name)); }; // Initialize the block header. { // We assume all the header fields are densely packed. unsigned index = 0; CharUnits offset; auto addHeaderField = [&](llvm::Value *value, CharUnits size, const Twine &name) { storeField(value, index, offset, name); offset += size; index++; }; addHeaderField(isa, getPointerSize(), "block.isa"); addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), getIntSize(), "block.flags"); addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(), "block.reserved"); addHeaderField(blockFn, getPointerSize(), "block.invoke"); addHeaderField(descriptor, getPointerSize(), "block.descriptor"); } d750 3 a752 2 Address addr = projectField(blockInfo.CXXThisIndex, blockInfo.CXXThisOffset, "block.captured-this.addr"); d765 1 d769 3 a771 2 Address blockField = projectField(capture.getIndex(), capture.getOffset(), "block.captured"); d775 1 a775 1 Address src = Address::invalid(); a783 1 enclosingCapture.getOffset(), d788 1 a788 1 src = Address::invalid(); d793 2 a794 4 auto it = LocalDeclMap.find(variable); if (it != LocalDeclMap.end()) { src = it->second; } else { a808 1 llvm::Value *byrefPointer; d810 2 a811 1 byrefPointer = Builder.CreateLoad(src, "byref.capture"); d813 1 a813 1 byrefPointer = Builder.CreateBitCast(src.getPointer(), VoidPtrTy); d816 1 a816 1 Builder.CreateStore(byrefPointer, blockField); d824 1 a824 1 AggValueSlot::forAddr(blockField, Qualifiers(), d835 3 a837 2 llvm::Value *ref = Builder.CreateLoad(src, "ref.val"); Builder.CreateStore(ref, blockField); d849 2 a850 1 llvm::Value *value = Builder.CreateLoad(src, "block.captured_block"); d854 2 a855 1 Builder.CreateStore(value, blockField); d877 1 a877 1 MakeAddrLValue(blockField, type, AlignmentSource::Decl), d892 1 a892 1 Builder.CreateBitCast(blockAddr.getPointer(), d950 1 d967 1 a967 2 llvm::Value *FuncPtr = Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockLiteral, 3); d978 2 a979 1 EmitCallArgs(Args, FnType->getAs(), E->arguments()); d982 1 a982 1 llvm::Value *Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); d998 2 a999 2 Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable, bool isByRef) { d1004 1 a1004 1 if (capture.isConstant()) return LocalDeclMap.find(variable)->second; d1006 1 a1006 1 Address addr = d1008 1 a1008 1 capture.getOffset(), "block.capture.addr"); d1014 14 a1027 8 auto &byrefInfo = getBlockByrefInfo(variable); addr = Address(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment); auto byrefPointerType = llvm::PointerType::get(byrefInfo.Type, 0); addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr"); addr = emitBlockByrefAddress(addr, byrefInfo, /*follow*/ true, variable->getName()); d1030 2 a1031 3 if (auto refType = variable->getType()->getAs()) { addr = EmitLoadOfReference(addr, refType); } d1048 1 a1048 1 CodeGenFunction::DeclMapTy LocalDeclMap; a1101 38 void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *arg) { assert(BlockInfo && "not emitting prologue of block invocation function?!"); llvm::Value *localAddr = nullptr; if (CGM.getCodeGenOpts().OptimizationLevel == 0) { // Allocate a stack slot to let the debug info survive the RA. Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr"); Builder.CreateStore(arg, alloc); localAddr = Builder.CreateLoad(alloc); } if (CGDebugInfo *DI = getDebugInfo()) { if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { DI->setLocation(D->getLocation()); DI->EmitDeclareOfBlockLiteralArgVariable(*BlockInfo, arg, argNum, localAddr, Builder); } } SourceLocation StartLoc = BlockInfo->getBlockExpr()->getBody()->getLocStart(); ApplyDebugLocation Scope(*this, StartLoc); // Instead of messing around with LocalDeclMap, just set the value // directly as BlockPointer. BlockPointer = Builder.CreateBitCast(arg, BlockInfo->StructureType->getPointerTo(), "block"); } Address CodeGenFunction::LoadBlockStruct() { assert(BlockInfo && "not in a block invocation function!"); assert(BlockPointer && "no block pointer set!"); return Address(BlockPointer, BlockInfo->BlockAlign); } d1121 1 a1121 1 setAddrOfLocalVar(var, i->second); d1139 2 a1140 1 args.append(blockDecl->param_begin(), blockDecl->param_end()); d1163 7 a1169 1 d1175 4 a1178 3 Address Alloca = CreateTempAlloca(BlockPointer->getType(), getPointerAlign(), "block.addr"); d1181 3 a1183 3 auto NL = ApplyDebugLocation::CreateEmpty(*this); Builder.CreateStore(BlockPointer, Alloca); BlockPointerDbgLoc = Alloca.getPointer(); d1189 3 a1191 3 Address addr = Builder.CreateStructGEP(LoadBlockStruct(), blockInfo.CXXThisIndex, blockInfo.CXXThisOffset, "block.captured-this"); d1201 5 a1205 3 CharUnits align = getContext().getDeclAlign(variable); Address alloca = CreateMemTemp(variable->getType(), align, "block.captured-const"); d1207 1 a1207 1 Builder.CreateStore(capture.getConstant(), alloca); d1209 1 a1209 1 setAddrOfLocalVar(variable, alloca); d1220 3 a1222 2 PGO.assignRegionCounters(GlobalDecl(blockDecl), fn); incrementProfileCounter(blockDecl->getBody()); d1244 1 a1244 2 auto addr = LocalDeclMap.find(variable)->second; DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(), d1249 4 a1252 3 DI->EmitDeclareOfBlockDeclRefVariable( variable, BlockPointerDbgLoc, Builder, blockInfo, entry_ptr == entry->end() ? nullptr : &*entry_ptr); d1289 1 d1331 4 a1335 6 CGM.SetInternalFunctionAttributes(nullptr, Fn, FI); auto NL = ApplyDebugLocation::CreateEmpty(*this); StartFunction(FD, C.VoidTy, Fn, FI, args); // Create a scope with an artificial location for the body of this function. auto AL = ApplyDebugLocation::CreateArtificial(*this); d1338 2 a1339 2 Address src = GetAddrOfLocalVar(&srcDecl); src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign); d1342 2 a1343 2 Address dst = GetAddrOfLocalVar(&dstDecl); dst = Address(Builder.CreateLoad(dst), blockInfo.BlockAlign); d1377 14 a1390 1 Qualifiers qs = type.getQualifiers(); d1392 4 a1395 11 // We need to register __weak direct captures with the runtime. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) { useARCWeakCopy = true; // We need to retain the copied value for __strong direct captures. } else if (qs.getObjCLifetime() == Qualifiers::OCL_Strong) { // If it's a block pointer, we have to copy the block and // assign that to the destination pointer, so we might as // well use _Block_object_assign. Otherwise we can avoid that. if (!isBlockPointer) useARCStrongCopy = true; d1399 1 a1399 1 } else if (!qs.getObjCLifetime() && !getLangOpts().ObjCAutoRefCount) { a1400 4 // Otherwise the memcpy is fine. } else { continue; a1401 2 // For all other types, the memcpy is fine. d1407 2 a1408 2 Address srcField = Builder.CreateStructGEP(src, index, capture.getOffset()); Address dstField = Builder.CreateStructGEP(dst, index, capture.getOffset()); d1435 1 a1435 1 cast(dstField.getPointer())->eraseFromParent(); d1439 1 a1439 2 llvm::Value *dstAddr = Builder.CreateBitCast(dstField.getPointer(), VoidPtrTy); a1501 3 CGM.SetInternalFunctionAttributes(nullptr, Fn, FI); d1503 1 a1503 1 auto NL = ApplyDebugLocation::CreateEmpty(*this); d1505 1 a1505 1 auto AL = ApplyDebugLocation::CreateArtificial(*this); d1509 2 a1510 2 Address src = GetAddrOfLocalVar(&srcDecl); src = Address(Builder.CreateLoad(src), blockInfo.BlockAlign); d1544 2 a1545 1 Qualifiers qs = type.getQualifiers(); d1547 4 a1550 8 // Use objc_storeStrong for __strong direct captures; the // dynamic tools really like it when we do this. if (qs.getObjCLifetime() == Qualifiers::OCL_Strong) { useARCStrongDestroy = true; // Support __weak direct captures. } else if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) { useARCWeakDestroy = true; d1552 7 a1558 7 // Non-ARC captures are strong, and we need to use _Block_object_dispose. } else if (!qs.hasObjCLifetime() && !getLangOpts().ObjCAutoRefCount) { // fall through // Otherwise, we have nothing to do. } else { continue; d1564 2 a1565 2 Address srcField = Builder.CreateStructGEP(src, capture.getIndex(), capture.getOffset()); d1599 1 a1599 1 class ObjectByrefHelpers final : public BlockByrefHelpers { d1604 1 a1604 1 : BlockByrefHelpers(alignment), Flags(flags) {} d1606 2 a1607 2 void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { d1618 1 a1618 1 llvm::Value *args[] = { destField.getPointer(), srcValue, flagsVal }; d1622 1 a1622 1 void emitDispose(CodeGenFunction &CGF, Address field) override { d1635 1 a1635 1 class ARCWeakByrefHelpers final : public BlockByrefHelpers { d1637 1 a1637 1 ARCWeakByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {} d1639 2 a1640 2 void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { d1644 1 a1644 1 void emitDispose(CodeGenFunction &CGF, Address field) override { d1656 1 a1656 1 class ARCStrongByrefHelpers final : public BlockByrefHelpers { d1658 1 a1658 1 ARCStrongByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {} d1660 2 a1661 2 void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { d1665 2 a1666 1 llvm::Value *value = CGF.Builder.CreateLoad(srcField); d1672 2 a1673 1 CGF.Builder.CreateStore(null, destField); d1678 5 a1682 2 CGF.Builder.CreateStore(value, destField); CGF.Builder.CreateStore(null, srcField); d1685 1 a1685 1 void emitDispose(CodeGenFunction &CGF, Address field) override { d1697 1 a1697 1 class ARCStrongBlockByrefHelpers final : public BlockByrefHelpers { d1699 1 a1699 2 ARCStrongBlockByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {} d1701 2 a1702 2 void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { d1706 3 a1708 1 llvm::Value *oldValue = CGF.Builder.CreateLoad(srcField); d1710 3 a1712 1 CGF.Builder.CreateStore(copy, destField); d1715 1 a1715 1 void emitDispose(CodeGenFunction &CGF, Address field) override { d1727 1 a1727 1 class CXXByrefHelpers final : public BlockByrefHelpers { d1734 1 a1734 1 : BlockByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} d1737 2 a1738 2 void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { d1743 1 a1743 1 void emitDispose(CodeGenFunction &CGF, Address field) override { d1756 4 a1759 2 generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator) { d1776 2 a1777 1 llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI); a1794 2 CGF.CGM.SetInternalFunctionAttributes(nullptr, Fn, FI); d1797 2 a1798 2 if (generator.needsCopy()) { llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0); d1801 2 a1802 3 Address destField = CGF.GetAddrOfLocalVar(&dst); destField = Address(CGF.Builder.CreateLoad(destField), byrefInfo.ByrefAlignment); d1804 1 a1804 2 destField = CGF.emitBlockByrefAddress(destField, byrefInfo, false, "dest-object"); d1807 2 a1808 3 Address srcField = CGF.GetAddrOfLocalVar(&src); srcField = Address(CGF.Builder.CreateLoad(srcField), byrefInfo.ByrefAlignment); d1810 1 a1810 2 srcField = CGF.emitBlockByrefAddress(srcField, byrefInfo, false, "src-object"); d1812 1 a1812 1 generator.emitCopy(CGF, destField, srcField); d1822 3 a1824 2 const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator) { d1826 1 a1826 1 return generateByrefCopyHelper(CGF, byrefInfo, generator); d1832 3 a1834 2 const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator) { d1846 2 a1847 1 llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI); a1864 3 CGF.CGM.SetInternalFunctionAttributes(nullptr, Fn, FI); d1867 5 a1871 6 if (generator.needsDispose()) { Address addr = CGF.GetAddrOfLocalVar(&src); addr = Address(CGF.Builder.CreateLoad(addr), byrefInfo.ByrefAlignment); auto byrefPtrType = byrefInfo.Type->getPointerTo(0); addr = CGF.Builder.CreateBitCast(addr, byrefPtrType); addr = CGF.emitBlockByrefAddress(addr, byrefInfo, false, "object"); d1873 1 a1873 1 generator.emitDispose(CGF, addr); d1883 3 a1885 2 const BlockByrefInfo &byrefInfo, BlockByrefHelpers &generator) { d1887 1 a1887 1 return generateByrefDisposeHelper(CGF, byrefInfo, generator); d1892 9 a1900 3 template static T *buildByrefHelpers(CodeGenModule &CGM, const BlockByrefInfo &byrefInfo, T &&generator) { d1902 1 a1902 1 generator.Profile(id); d1905 1 a1905 1 BlockByrefHelpers *node d1909 4 a1912 2 generator.CopyHelper = buildByrefCopyHelper(CGM, byrefInfo, generator); generator.DisposeHelper = buildByrefDisposeHelper(CGM, byrefInfo, generator); d1914 1 a1914 1 T *copy = new (CGM.getContext()) T(std::move(generator)); d1922 1 a1922 1 BlockByrefHelpers * d1928 1 a1928 6 auto &byrefInfo = getBlockByrefInfo(&var); // The alignment we care about for the purposes of uniquing byref // helpers is the alignment of the actual byref value field. CharUnits valueAlignment = byrefInfo.ByrefAlignment.alignmentAtOffset(byrefInfo.FieldOffset); d1934 2 a1935 2 return ::buildByrefHelpers( CGM, byrefInfo, CXXByrefHelpers(valueAlignment, type, copyExpr)); d1946 2 d1958 4 a1961 3 case Qualifiers::OCL_Weak: return ::buildByrefHelpers(CGM, byrefInfo, ARCWeakByrefHelpers(valueAlignment)); d1968 2 a1969 2 return ::buildByrefHelpers(CGM, byrefInfo, ARCStrongBlockByrefHelpers(valueAlignment)); d1974 2 a1975 2 return ::buildByrefHelpers(CGM, byrefInfo, ARCStrongByrefHelpers(valueAlignment)); d1994 2 a1995 2 return ::buildByrefHelpers(CGM, byrefInfo, ObjectByrefHelpers(valueAlignment, flags)); d1998 4 a2001 5 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr, const VarDecl *var, bool followForward) { auto &info = getBlockByrefInfo(var); return emitBlockByrefAddress(baseAddr, info, followForward, var->getName()); d2004 7 a2010 13 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr, const BlockByrefInfo &info, bool followForward, const llvm::Twine &name) { // Chase the forwarding address if requested. if (followForward) { Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, getPointerSize(), "forwarding"); baseAddr = Address(Builder.CreateLoad(forwardingAddr), info.ByrefAlignment); } return Builder.CreateStructGEP(baseAddr, info.FieldIndex, info.FieldOffset, name); d2013 1 a2013 1 /// BuildByrefInfo - This routine changes a __block variable declared as T x d2028 4 a2031 8 const BlockByrefInfo &CodeGenFunction::getBlockByrefInfo(const VarDecl *D) { auto it = BlockByrefInfos.find(D); if (it != BlockByrefInfos.end()) return it->second; llvm::StructType *byrefType = llvm::StructType::create(getLLVMContext(), "struct.__block_byref_" + D->getNameAsString()); a2034 1 CharUnits size; d2037 4 a2042 1 size += getPointerSize(); d2045 1 a2045 2 types.push_back(llvm::PointerType::getUnqual(byrefType)); size += getPointerSize(); a2048 1 size += CharUnits::fromQuantity(4); a2051 2 size += CharUnits::fromQuantity(4); d2053 2 a2054 2 bool hasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D); if (hasCopyAndDispose) { a2056 1 size += getPointerSize(); a2059 1 size += getPointerSize(); a2060 1 d2064 1 a2064 1 HasByrefExtendedLayout) { d2067 36 a2102 1 size += CharUnits::fromQuantity(PointerSizeInBytes); d2106 9 a2114 32 llvm::Type *varTy = ConvertTypeForMem(Ty); bool packed = false; CharUnits varAlign = getContext().getDeclAlign(D); CharUnits varOffset = size.RoundUpToAlignment(varAlign); // We may have to insert padding. if (varOffset != size) { llvm::Type *paddingTy = llvm::ArrayType::get(Int8Ty, (varOffset - size).getQuantity()); types.push_back(paddingTy); size = varOffset; // Conversely, we might have to prevent LLVM from inserting padding. } else if (CGM.getDataLayout().getABITypeAlignment(varTy) > varAlign.getQuantity()) { packed = true; } types.push_back(varTy); byrefType->setBody(types, packed); BlockByrefInfo info; info.Type = byrefType; info.FieldIndex = types.size() - 1; info.FieldOffset = varOffset; info.ByrefAlignment = std::max(varAlign, getPointerAlign()); auto pair = BlockByrefInfos.insert({D, info}); assert(pair.second && "info was inserted recursively?"); return pair.first->second; d2121 1 a2121 1 Address addr = emission.Addr; d2125 1 a2125 13 cast(addr.getPointer()->getType())->getElementType()); unsigned nextHeaderIndex = 0; CharUnits nextHeaderOffset; auto storeHeaderField = [&](llvm::Value *value, CharUnits fieldSize, const Twine &name) { auto fieldAddr = Builder.CreateStructGEP(addr, nextHeaderIndex, nextHeaderOffset, name); Builder.CreateStore(value, fieldAddr); nextHeaderIndex++; nextHeaderOffset += fieldSize; }; d2128 2 a2129 1 BlockByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission); d2138 1 a2138 1 d2146 1 a2146 1 storeHeaderField(V, getPointerSize(), "byref.isa"); d2149 2 a2150 1 storeHeaderField(addr.getPointer(), getPointerSize(), "byref.forwarding"); d2196 3 a2198 2 storeHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), getIntSize(), "byref.flags"); d2202 1 a2202 1 storeHeaderField(V, getIntSize(), "byref.size"); d2205 5 a2209 4 storeHeaderField(helpers->CopyHelper, getPointerSize(), "byref.copyHelper"); storeHeaderField(helpers->DisposeHelper, getPointerSize(), "byref.disposeHelper"); a2210 1 d2212 8 a2219 2 auto layoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type); storeHeaderField(layoutInfo, getPointerSize(), "byref.layout"); d2233 1 a2233 2 /// Release a __block variable. struct CallBlockRelease final : EHScopeStack::Cleanup { d2242 1 a2242 1 } // end anonymous namespace d2253 1 a2253 2 EHStack.pushCleanup(NormalAndEHCleanup, emission.Addr.getPointer()); @ 1.1.1.7.2.1 log @Sync with HEAD @ text @a18 1 #include "ConstantBuilder.h" d80 2 a81 3 llvm::IntegerType *ulong = cast(CGM.getTypes().ConvertType(C.UnsignedLongTy)); llvm::PointerType *i8p = nullptr; d87 1 a87 1 i8p = CGM.VoidPtrTy; d89 1 a89 2 ConstantInitBuilder builder(CGM); auto elements = builder.beginStruct(); d92 1 a92 1 elements.addInt(ulong, 0); d98 2 a99 1 elements.addInt(ulong, blockInfo.BlockSize.getQuantity()); d104 1 a104 1 elements.add(buildCopyHelper(CGM, blockInfo)); d107 1 a107 1 elements.add(buildDisposeHelper(CGM, blockInfo)); d113 1 a113 1 elements.add(llvm::ConstantExpr::getBitCast( d119 1 a119 1 elements.add(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo)); d121 1 a121 1 elements.add(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo)); d124 1 a124 1 elements.addNullPointer(i8p); d126 1 a126 3 unsigned AddrSpace = 0; if (C.getLangOpts().OpenCL) AddrSpace = C.getTargetAddressSpace(LangAS::opencl_constant); d129 3 a131 5 elements.finishAndCreateGlobal("__block_descriptor_tmp", CGM.getPointerAlign(), /*constant*/ true, llvm::GlobalValue::InternalLinkage, AddrSpace); d186 3 a196 1 QualType FieldType; d201 1 a201 1 llvm::Type *type, QualType fieldType) d203 1 a203 1 Capture(capture), Type(type), FieldType(fieldType) {} d211 2 a212 2 auto C = CGBlockInfo::Capture::makeIndex(index, offset, FieldType); info.Captures.insert({Capture->getVariable(), C}); a264 5 // Return if this is a function paramter. We shouldn't try to // rematerialize default arguments of function parameters. if (isa(var)) return nullptr; d310 2 d356 1 a356 1 nullptr, llvmType, thisType)); d373 1 a373 1 CGM.VoidPtrTy, variable->getType())); a428 8 // If the variable is captured by an enclosing block or lambda expression, // use the type of the capture field. if (CGF->BlockInfo && CI.isNested()) VT = CGF->BlockInfo->getCapture(variable).fieldType(); else if (auto *FD = CGF->LambdaCaptureFields.lookup(variable)) VT = FD->getType(); d437 1 a437 2 layout.push_back( BlockLayoutChunk(align, size, lifetime, &CI, llvmType, VT)); d511 1 a511 1 CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign); a672 2 if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) return Block; d768 1 a768 1 QualType type = capture.fieldType(); d778 11 a788 2 if (blockDecl->isConversionFromLambda()) { d792 7 a798 11 } else if (CI.isByRef()) { if (BlockInfo && CI.isNested()) { // We need to use the capture from the enclosing block. const CGBlockInfo::Capture &enclosingCapture = BlockInfo->getCapture(variable); // This is a [[type]]*, except that a byref entry wil just be an i8**. src = Builder.CreateStructGEP(LoadBlockStruct(), enclosingCapture.getIndex(), enclosingCapture.getOffset(), "block.capture.addr"); d800 5 a804 3 auto I = LocalDeclMap.find(variable); assert(I != LocalDeclMap.end()); src = I->second; d806 1 a806 7 } else { DeclRefExpr declRef(const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type.getNonReferenceType(), VK_LValue, SourceLocation()); src = EmitDeclRefLValue(&declRef).getAddress(); }; d840 2 a841 1 Builder.CreateStore(src.getPointer(), blockField); d927 1 a927 4 unsigned AddrSpace = 0; if (getLangOpts().OpenCL) AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_constant); BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace); d957 1 a957 1 llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee()); d964 2 a965 1 BlockPtr = Builder.CreateBitCast(BlockPtr, BlockLiteralTy, "block.literal"); d969 1 a969 1 Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr, 3); d971 1 a971 1 BlockPtr = Builder.CreateBitCast(BlockPtr, VoidPtrTy); d975 1 a975 1 Args.add(RValue::get(BlockPtr), getContext().VoidPtrTy); a994 3 // Prepare the callee. CGCallee Callee(CGCalleeInfo(), Func); d996 1 a996 1 return EmitCall(FnInfo, Callee, ReturnValue, Args); d1025 1 a1025 1 if (auto refType = capture.fieldType()->getAs()) d1027 1 a1031 7 void CodeGenModule::setAddrOfGlobalBlock(const BlockExpr *BE, llvm::Constant *Addr) { bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second; (void)Ok; assert(Ok && "Trying to replace an already-existing global block!"); } d1033 4 a1036 7 CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name) { if (llvm::Constant *Block = getAddrOfGlobalBlockIfEmitted(BE)) return Block; CGBlockInfo blockInfo(BE->getBlockDecl(), Name); blockInfo.BlockExpression = BE; a1058 5 // Callers should detect this case on their own: calling this function // generally requires computing layout information, which is a waste of time // if we've already emitted this block. assert(!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) && "Refusing to re-emit a global block."); d1061 1 a1061 2 ConstantInitBuilder builder(CGM); auto fields = builder.beginStruct(); d1064 1 a1064 1 fields.add(CGM.getNSConcreteGlobalBlock()); d1070 1 a1070 1 fields.addInt(CGM.IntTy, flags.getBitMask()); d1073 1 a1073 1 fields.addInt(CGM.IntTy, 0); d1076 1 a1076 1 fields.add(blockFn); d1079 1 a1079 1 fields.add(buildBlockDescriptor(CGM, blockInfo)); d1081 10 a1090 4 llvm::Constant *literal = fields.finishAndCreateGlobal("__block_literal_global", blockInfo.BlockAlign, /*constant*/ true); d1093 1 a1093 1 llvm::Type *RequiredType = d1095 1 a1095 4 llvm::Constant *Result = llvm::ConstantExpr::getBitCast(literal, RequiredType); CGM.setAddrOfGlobalBlock(blockInfo.BlockExpression, Result); return Result; d1112 2 a1113 2 if (CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) { d1177 3 a1179 2 const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args); d1263 2 a1264 2 if (CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) { d1332 2 a1333 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args); d1508 2 a1509 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args); d1794 2 a1795 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args); d1867 2 a1868 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args); d1932 1 a1932 1 T *copy = new (CGM.getContext()) T(std::forward(generator)); d2111 1 a2111 1 CharUnits varOffset = size.alignTo(varAlign); d2288 2 a2290 29 if (CGM.getTarget().getTriple().isOSBinFormatCOFF()) { IdentifierInfo &II = CGM.getContext().Idents.get(C->getName()); TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); assert((isa(C->stripPointerCasts()) || isa(C->stripPointerCasts())) && "expected Function or GlobalVariable"); const NamedDecl *ND = nullptr; for (const auto &Result : DC->lookup(&II)) if ((ND = dyn_cast(Result)) || (ND = dyn_cast(Result))) break; // TODO: support static blocks runtime if (GV->isDeclaration() && (!ND || !ND->hasAttr())) { GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); GV->setLinkage(llvm::GlobalValue::ExternalLinkage); } else { GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); GV->setLinkage(llvm::GlobalValue::ExternalLinkage); } } if (!CGM.getLangOpts().BlocksRuntimeOptional) return; d2338 1 a2338 1 return NSConcreteStackBlock; @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @a18 1 #include "ConstantBuilder.h" d80 2 a81 3 llvm::IntegerType *ulong = cast(CGM.getTypes().ConvertType(C.UnsignedLongTy)); llvm::PointerType *i8p = nullptr; d87 1 a87 1 i8p = CGM.VoidPtrTy; d89 1 a89 2 ConstantInitBuilder builder(CGM); auto elements = builder.beginStruct(); d92 1 a92 1 elements.addInt(ulong, 0); d98 2 a99 1 elements.addInt(ulong, blockInfo.BlockSize.getQuantity()); d104 1 a104 1 elements.add(buildCopyHelper(CGM, blockInfo)); d107 1 a107 1 elements.add(buildDisposeHelper(CGM, blockInfo)); d113 1 a113 1 elements.add(llvm::ConstantExpr::getBitCast( d119 1 a119 1 elements.add(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo)); d121 1 a121 1 elements.add(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo)); d124 1 a124 1 elements.addNullPointer(i8p); d126 1 a126 3 unsigned AddrSpace = 0; if (C.getLangOpts().OpenCL) AddrSpace = C.getTargetAddressSpace(LangAS::opencl_constant); d129 3 a131 5 elements.finishAndCreateGlobal("__block_descriptor_tmp", CGM.getPointerAlign(), /*constant*/ true, llvm::GlobalValue::InternalLinkage, AddrSpace); d186 3 a196 1 QualType FieldType; d201 1 a201 1 llvm::Type *type, QualType fieldType) d203 1 a203 1 Capture(capture), Type(type), FieldType(fieldType) {} d211 2 a212 2 auto C = CGBlockInfo::Capture::makeIndex(index, offset, FieldType); info.Captures.insert({Capture->getVariable(), C}); a264 5 // Return if this is a function paramter. We shouldn't try to // rematerialize default arguments of function parameters. if (isa(var)) return nullptr; d310 2 d356 1 a356 1 nullptr, llvmType, thisType)); d373 1 a373 1 CGM.VoidPtrTy, variable->getType())); a428 8 // If the variable is captured by an enclosing block or lambda expression, // use the type of the capture field. if (CGF->BlockInfo && CI.isNested()) VT = CGF->BlockInfo->getCapture(variable).fieldType(); else if (auto *FD = CGF->LambdaCaptureFields.lookup(variable)) VT = FD->getType(); d437 1 a437 2 layout.push_back( BlockLayoutChunk(align, size, lifetime, &CI, llvmType, VT)); d511 1 a511 1 CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign); a672 2 if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) return Block; d768 1 a768 1 QualType type = capture.fieldType(); d778 11 a788 2 if (blockDecl->isConversionFromLambda()) { d792 7 a798 11 } else if (CI.isByRef()) { if (BlockInfo && CI.isNested()) { // We need to use the capture from the enclosing block. const CGBlockInfo::Capture &enclosingCapture = BlockInfo->getCapture(variable); // This is a [[type]]*, except that a byref entry wil just be an i8**. src = Builder.CreateStructGEP(LoadBlockStruct(), enclosingCapture.getIndex(), enclosingCapture.getOffset(), "block.capture.addr"); d800 5 a804 3 auto I = LocalDeclMap.find(variable); assert(I != LocalDeclMap.end()); src = I->second; d806 1 a806 7 } else { DeclRefExpr declRef(const_cast(variable), /*RefersToEnclosingVariableOrCapture*/ CI.isNested(), type.getNonReferenceType(), VK_LValue, SourceLocation()); src = EmitDeclRefLValue(&declRef).getAddress(); }; d840 2 a841 1 Builder.CreateStore(src.getPointer(), blockField); d927 1 a927 4 unsigned AddrSpace = 0; if (getLangOpts().OpenCL) AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_constant); BlockDescriptorType = llvm::PointerType::get(BlockDescriptorType, AddrSpace); d957 1 a957 1 llvm::Value *BlockPtr = EmitScalarExpr(E->getCallee()); d964 2 a965 1 BlockPtr = Builder.CreateBitCast(BlockPtr, BlockLiteralTy, "block.literal"); d969 1 a969 1 Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr, 3); d971 1 a971 1 BlockPtr = Builder.CreateBitCast(BlockPtr, VoidPtrTy); d975 1 a975 1 Args.add(RValue::get(BlockPtr), getContext().VoidPtrTy); a994 3 // Prepare the callee. CGCallee Callee(CGCalleeInfo(), Func); d996 1 a996 1 return EmitCall(FnInfo, Callee, ReturnValue, Args); d1025 1 a1025 1 if (auto refType = capture.fieldType()->getAs()) d1027 1 a1031 7 void CodeGenModule::setAddrOfGlobalBlock(const BlockExpr *BE, llvm::Constant *Addr) { bool Ok = EmittedGlobalBlocks.insert(std::make_pair(BE, Addr)).second; (void)Ok; assert(Ok && "Trying to replace an already-existing global block!"); } d1033 4 a1036 7 CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name) { if (llvm::Constant *Block = getAddrOfGlobalBlockIfEmitted(BE)) return Block; CGBlockInfo blockInfo(BE->getBlockDecl(), Name); blockInfo.BlockExpression = BE; a1058 5 // Callers should detect this case on their own: calling this function // generally requires computing layout information, which is a waste of time // if we've already emitted this block. assert(!CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression) && "Refusing to re-emit a global block."); d1061 1 a1061 2 ConstantInitBuilder builder(CGM); auto fields = builder.beginStruct(); d1064 1 a1064 1 fields.add(CGM.getNSConcreteGlobalBlock()); d1070 1 a1070 1 fields.addInt(CGM.IntTy, flags.getBitMask()); d1073 1 a1073 1 fields.addInt(CGM.IntTy, 0); d1076 1 a1076 1 fields.add(blockFn); d1079 1 a1079 1 fields.add(buildBlockDescriptor(CGM, blockInfo)); d1081 10 a1090 4 llvm::Constant *literal = fields.finishAndCreateGlobal("__block_literal_global", blockInfo.BlockAlign, /*constant*/ true); d1093 1 a1093 1 llvm::Type *RequiredType = d1095 1 a1095 4 llvm::Constant *Result = llvm::ConstantExpr::getBitCast(literal, RequiredType); CGM.setAddrOfGlobalBlock(blockInfo.BlockExpression, Result); return Result; d1112 2 a1113 2 if (CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) { d1177 3 a1179 2 const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeBlockFunctionDeclaration(fnType, args); d1263 2 a1264 2 if (CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) { d1332 2 a1333 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args); d1508 2 a1509 2 const CGFunctionInfo &FI = CGM.getTypes().arrangeBuiltinFunctionDeclaration(C.VoidTy, args); d1794 2 a1795 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args); d1867 2 a1868 2 const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeBuiltinFunctionDeclaration(R, args); d1932 1 a1932 1 T *copy = new (CGM.getContext()) T(std::forward(generator)); d2111 1 a2111 1 CharUnits varOffset = size.alignTo(varAlign); d2288 2 a2290 29 if (CGM.getTarget().getTriple().isOSBinFormatCOFF()) { IdentifierInfo &II = CGM.getContext().Idents.get(C->getName()); TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); assert((isa(C->stripPointerCasts()) || isa(C->stripPointerCasts())) && "expected Function or GlobalVariable"); const NamedDecl *ND = nullptr; for (const auto &Result : DC->lookup(&II)) if ((ND = dyn_cast(Result)) || (ND = dyn_cast(Result))) break; // TODO: support static blocks runtime if (GV->isDeclaration() && (!ND || !ND->hasAttr())) { GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); GV->setLinkage(llvm::GlobalValue::ExternalLinkage); } else { GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass); GV->setLinkage(llvm::GlobalValue::ExternalLinkage); } } if (!CGM.getLangOpts().BlocksRuntimeOptional) return; d2338 1 a2338 1 return NSConcreteStackBlock; @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @d19 1 a19 1 #include "clang/CodeGen/ConstantInitBuilder.h" d269 1 a269 1 // Return if this is a function parameter. We shouldn't try to a320 13 static QualType getCaptureFieldType(const CodeGenFunction &CGF, const BlockDecl::Capture &CI) { const VarDecl *VD = CI.getVariable(); // If the variable is captured by an enclosing block or lambda expression, // use the type of the capture field. if (CGF.BlockInfo && CI.isNested()) return CGF.BlockInfo->getCapture(VD).fieldType(); if (auto *FD = CGF.LambdaCaptureFields.lookup(VD)) return FD->getType(); return VD->getType(); } d435 9 a443 1 QualType VT = getCaptureFieldType(*CGF, CI); d609 2 a610 2 QualType VT = getCaptureFieldType(CGF, CI); QualType::DestructionKind dtorKind = VT.isDestructedType(); d617 1 a617 11 // // For const-qualified captures, emit clang.arc.use to ensure the captured // object doesn't get released while we are still depending on its validity // within the block. if (VT.isConstQualified() && VT.getObjCLifetime() == Qualifiers::OCL_Strong && CGF.CGM.getCodeGenOpts().OptimizationLevel != 0) { assert(CGF.CGM.getLangOpts().ObjCAutoRefCount && "expected ObjC ARC to be enabled"); destroyer = CodeGenFunction::emitARCIntrinsicUse; } else if (dtorKind == QualType::DK_objc_strong_lifetime) { d637 1 a637 1 CGF.pushDestroy(cleanupKind, addr, VT, d721 1 a721 6 llvm::Constant *isa = (!CGM.getContext().getLangOpts().OpenCL) ? CGM.getNSConcreteStackBlock() : CGM.getNullPointer(VoidPtrPtrTy, CGM.getContext().getPointerType( QualType(CGM.getContext().VoidPtrTy))); a858 7 // If type is const-qualified, copy the value into the block field. } else if (type.isConstQualified() && type.getObjCLifetime() == Qualifiers::OCL_Strong && CGM.getCodeGenOpts().OptimizationLevel != 0) { llvm::Value *value = Builder.CreateLoad(src, "captured"); Builder.CreateStore(value, blockField); d879 3 a881 2 ImplicitParamDecl BlockFieldPseudoVar(getContext(), type, ImplicitParamDecl::Other); d894 2 a895 3 LValueBaseInfo BaseInfo(AlignmentSource::Decl, false); EmitExprAsInit(&l2r, &BlockFieldPseudoVar, MakeAddrLValue(blockField, type, BaseInfo), d909 3 a911 2 llvm::Value *result = Builder.CreatePointerCast( blockAddr.getPointer(), ConvertType(blockInfo.getBlockExpr()->getType())); d938 3 a940 2 BlockDescriptorType = llvm::StructType::create( "struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy); d964 3 a966 2 llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy, IntTy, IntTy, VoidPtrTy, BlockDescPtrTy); a978 8 // For OpenCL we generate generic AS void ptr to be able to reuse the same // block definition for blocks with captures generated as private AS local // variables and without captures generated as global AS program scope // variables. unsigned AddrSpace = 0; if (getLangOpts().OpenCL) AddrSpace = getContext().getTargetAddressSpace(LangAS::opencl_generic); d980 1 a980 1 llvm::PointerType::get(CGM.getGenericBlockLiteralType(), AddrSpace); d983 1 a983 2 BlockPtr = Builder.CreatePointerCast(BlockPtr, BlockLiteralTy, "block.literal"); d989 1 d993 1 a993 13 QualType VoidPtrQualTy = getContext().VoidPtrTy; llvm::Type *GenericVoidPtrTy = VoidPtrTy; if (getLangOpts().OpenCL) { GenericVoidPtrTy = Builder.getInt8PtrTy( getContext().getTargetAddressSpace(LangAS::opencl_generic)); VoidPtrQualTy = getContext().getPointerType(getContext().getAddrSpaceQualType( getContext().VoidTy, LangAS::opencl_generic)); } BlockPtr = Builder.CreatePointerCast(BlockPtr, GenericVoidPtrTy); Args.add(RValue::get(BlockPtr), VoidPtrQualTy); d1100 1 a1100 5 fields.add((!CGM.getContext().getLangOpts().OpenCL) ? CGM.getNSConcreteGlobalBlock() : CGM.getNullPointer(CGM.VoidPtrPtrTy, CGM.getContext().getPointerType(QualType( CGM.getContext().VoidPtrTy)))); d1117 4 a1120 7 unsigned AddrSpace = 0; if (CGM.getContext().getLangOpts().OpenCL) AddrSpace = CGM.getContext().getTargetAddressSpace(LangAS::opencl_global); llvm::Constant *literal = fields.finishAndCreateGlobal( "__block_literal_global", blockInfo.BlockAlign, /*constant*/ true, llvm::GlobalVariable::InternalLinkage, AddrSpace); d1126 1 a1126 1 llvm::ConstantExpr::getPointerCast(literal, RequiredType); d1158 3 a1160 7 BlockPointer = Builder.CreatePointerCast( arg, BlockInfo->StructureType->getPointerTo( getContext().getLangOpts().OpenCL ? getContext().getTargetAddressSpace(LangAS::opencl_generic) : 0), "block"); a1198 9 // For OpenCL passed block pointer can be private AS local variable or // global AS program scope variable (for the case with and without captures). // Generic AS is used therefore to be able to accommodate both private and // generic AS in one implementation. if (getLangOpts().OpenCL) selfTy = getContext().getPointerType(getContext().getAddrSpaceQualType( getContext().VoidTy, LangAS::opencl_generic)); d1201 3 a1203 4 ImplicitParamDecl SelfDecl(getContext(), const_cast(blockDecl), SourceLocation(), II, selfTy, ImplicitParamDecl::ObjCSelf); args.push_back(&SelfDecl); d1326 17 a1342 96 namespace { /// Represents a type of copy/destroy operation that should be performed for an /// entity that's captured by a block. enum class BlockCaptureEntityKind { CXXRecord, // Copy or destroy ARCWeak, ARCStrong, BlockObject, // Assign or release None }; /// Represents a captured entity that requires extra operations in order for /// this entity to be copied or destroyed correctly. struct BlockCaptureManagedEntity { BlockCaptureEntityKind Kind; BlockFieldFlags Flags; const BlockDecl::Capture &CI; const CGBlockInfo::Capture &Capture; BlockCaptureManagedEntity(BlockCaptureEntityKind Type, BlockFieldFlags Flags, const BlockDecl::Capture &CI, const CGBlockInfo::Capture &Capture) : Kind(Type), Flags(Flags), CI(CI), Capture(Capture) {} }; } // end anonymous namespace static std::pair computeCopyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, const LangOptions &LangOpts) { if (CI.getCopyExpr()) { assert(!CI.isByRef()); // don't bother computing flags return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags()); } BlockFieldFlags Flags; if (CI.isByRef()) { Flags = BLOCK_FIELD_IS_BYREF; if (T.isObjCGCWeak()) Flags |= BLOCK_FIELD_IS_WEAK; return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); } if (!T->isObjCRetainableType()) // For all other types, the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, Flags); Flags = BLOCK_FIELD_IS_OBJECT; bool isBlockPointer = T->isBlockPointerType(); if (isBlockPointer) Flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures: Qualifiers QS = T.getQualifiers(); // We need to register __weak direct captures with the runtime. if (QS.getObjCLifetime() == Qualifiers::OCL_Weak) return std::make_pair(BlockCaptureEntityKind::ARCWeak, Flags); // We need to retain the copied value for __strong direct captures. if (QS.getObjCLifetime() == Qualifiers::OCL_Strong) { // If it's a block pointer, we have to copy the block and // assign that to the destination pointer, so we might as // well use _Block_object_assign. Otherwise we can avoid that. return std::make_pair(!isBlockPointer ? BlockCaptureEntityKind::ARCStrong : BlockCaptureEntityKind::BlockObject, Flags); } // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); // Otherwise the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, Flags); } /// Find the set of block captures that need to be explicitly copied or destroy. static void findBlockCapturedManagedEntities( const CGBlockInfo &BlockInfo, const LangOptions &LangOpts, SmallVectorImpl &ManagedCaptures, llvm::function_ref( const BlockDecl::Capture &, QualType, const LangOptions &)> Predicate) { for (const auto &CI : BlockInfo.getBlockDecl()->captures()) { const VarDecl *Variable = CI.getVariable(); const CGBlockInfo::Capture &Capture = BlockInfo.getCapture(Variable); if (Capture.isConstant()) continue; auto Info = Predicate(CI, Variable->getType(), LangOpts); if (Info.first != BlockCaptureEntityKind::None) ManagedCaptures.emplace_back(Info.first, Info.second, CI, Capture); } } d1357 6 a1362 6 ImplicitParamDecl DstDecl(getContext(), C.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&DstDecl); ImplicitParamDecl SrcDecl(getContext(), C.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&SrcDecl); d1394 1 a1394 1 Address src = GetAddrOfLocalVar(&SrcDecl); d1398 1 a1398 1 Address dst = GetAddrOfLocalVar(&DstDecl); d1402 59 a1460 8 SmallVector CopiedCaptures; findBlockCapturedManagedEntities(blockInfo, getLangOpts(), CopiedCaptures, computeCopyInfoForBlockCapture); for (const auto &CopiedCapture : CopiedCaptures) { const BlockDecl::Capture &CI = CopiedCapture.CI; const CGBlockInfo::Capture &capture = CopiedCapture.Capture; BlockFieldFlags flags = CopiedCapture.Flags; d1467 3 a1469 4 if (CI.getCopyExpr()) { assert(CopiedCapture.Kind == BlockCaptureEntityKind::CXXRecord); EmitSynthesizedCXXCopyCtor(dstField, srcField, CI.getCopyExpr()); } else if (CopiedCapture.Kind == BlockCaptureEntityKind::ARCWeak) { d1473 1 a1473 1 if (CopiedCapture.Kind == BlockCaptureEntityKind::ARCStrong) { a1493 1 assert(CopiedCapture.Kind == BlockCaptureEntityKind::BlockObject); a1500 1 const VarDecl *variable = CI.getVariable(); a1523 46 static std::pair computeDestroyInfoForBlockCapture(const BlockDecl::Capture &CI, QualType T, const LangOptions &LangOpts) { BlockFieldFlags Flags; if (CI.isByRef()) { Flags = BLOCK_FIELD_IS_BYREF; if (T.isObjCGCWeak()) Flags |= BLOCK_FIELD_IS_WEAK; return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); } if (const CXXRecordDecl *Record = T->getAsCXXRecordDecl()) { if (Record->hasTrivialDestructor()) return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); return std::make_pair(BlockCaptureEntityKind::CXXRecord, BlockFieldFlags()); } // Other types don't need to be destroy explicitly. if (!T->isObjCRetainableType()) return std::make_pair(BlockCaptureEntityKind::None, Flags); Flags = BLOCK_FIELD_IS_OBJECT; if (T->isBlockPointerType()) Flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures. Qualifiers QS = T.getQualifiers(); // Use objc_storeStrong for __strong direct captures; the // dynamic tools really like it when we do this. if (QS.getObjCLifetime() == Qualifiers::OCL_Strong) return std::make_pair(BlockCaptureEntityKind::ARCStrong, Flags); // Support __weak direct captures. if (QS.getObjCLifetime() == Qualifiers::OCL_Weak) return std::make_pair(BlockCaptureEntityKind::ARCWeak, Flags); // Non-ARC captures are strong, and we need to use // _Block_object_dispose. if (!QS.hasObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); // Otherwise, we have nothing to do. return std::make_pair(BlockCaptureEntityKind::None, Flags); } d1536 3 a1538 3 ImplicitParamDecl SrcDecl(getContext(), C.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&SrcDecl); d1569 1 a1569 1 Address src = GetAddrOfLocalVar(&SrcDecl); d1573 2 d1577 49 a1625 8 SmallVector DestroyedCaptures; findBlockCapturedManagedEntities(blockInfo, getLangOpts(), DestroyedCaptures, computeDestroyInfoForBlockCapture); for (const auto &DestroyedCapture : DestroyedCaptures) { const BlockDecl::Capture &CI = DestroyedCapture.CI; const CGBlockInfo::Capture &capture = DestroyedCapture.Capture; BlockFieldFlags flags = DestroyedCapture.Flags; d1630 3 a1632 5 // If the captured record has a destructor then call it. if (DestroyedCapture.Kind == BlockCaptureEntityKind::CXXRecord) { const auto *Dtor = CI.getVariable()->getType()->getAsCXXRecordDecl()->getDestructor(); PushDestructorCleanup(Dtor, srcField); d1634 2 a1635 2 // If this is a __weak capture, emit the release directly. } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::ARCWeak) { d1639 1 a1639 1 } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::ARCStrong) { a1645 1 assert(DestroyedCapture.Kind == BlockCaptureEntityKind::BlockObject); d1818 7 a1824 7 ImplicitParamDecl Dst(CGF.getContext(), Context.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&Dst); ImplicitParamDecl Src(CGF.getContext(), Context.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&Src); d1855 1 a1855 1 Address destField = CGF.GetAddrOfLocalVar(&Dst); d1863 1 a1863 1 Address srcField = CGF.GetAddrOfLocalVar(&Src); d1895 3 a1897 3 ImplicitParamDecl Src(CGF.getContext(), Context.VoidPtrTy, ImplicitParamDecl::Other); args.push_back(&Src); d1926 1 a1926 1 Address addr = CGF.GetAddrOfLocalVar(&Src); @ 1.1.1.9.4.1 log @Sync with HEAD @ text @a16 1 #include "CGOpenCLRuntime.h" d19 1 a19 2 #include "ConstantEmitter.h" #include "TargetInfo.h" a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" d66 1 a66 1 /// Its definition will have 4 (or optionally 6) words. d293 1 a293 1 return ConstantEmitter(CGM, CGF).tryEmitAbstractForInitializer(*var); d304 8 d314 5 a318 36 if (CGM.getLangOpts().OpenCL) { // The header is basically 'struct { int; int; // custom_fields; }'. Assert that struct is packed. elementTypes.push_back(CGM.IntTy); /* total size */ elementTypes.push_back(CGM.IntTy); /* align */ unsigned Offset = 2 * CGM.getIntSize().getQuantity(); unsigned BlockAlign = CGM.getIntAlign().getQuantity(); if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldTypes()) /* custom fields */ { // TargetOpenCLBlockHelp needs to make sure the struct is packed. // If necessary, add padding fields to the custom fields. unsigned Align = CGM.getDataLayout().getABITypeAlignment(I); if (BlockAlign < Align) BlockAlign = Align; assert(Offset % Align == 0); Offset += CGM.getDataLayout().getTypeAllocSize(I); elementTypes.push_back(I); } } info.BlockAlign = CharUnits::fromQuantity(BlockAlign); info.BlockSize = CharUnits::fromQuantity(Offset); } else { // The header is basically 'struct { void *; int; int; void *; void *; }'. // Assert that the struct is packed. assert(CGM.getIntSize() <= CGM.getPointerSize()); assert(CGM.getIntAlign() <= CGM.getPointerAlign()); assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())); info.BlockAlign = CGM.getPointerAlign(); info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize(); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.getBlockDescriptorType()); } d343 2 a344 6 bool hasNonConstantCustomFields = false; if (auto *OpenCLHelper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) hasNonConstantCustomFields = !OpenCLHelper->areAllCustomFieldValuesConstant(info); if (!block->hasCaptures() && !hasNonConstantCustomFields) { a436 8 // So do C structs that require non-trivial copy construction or // destruction. } else if (variable->getType().isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct || variable->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) { info.NeedsCopyDispose = true; d665 5 a669 2 for (const ExprWithCleanups::CleanupObject &C : E->getObjects()) enterBlockScope(*this, C); d704 1 a704 3 // The block literal is emitted as a global variable, and the block invoke // function has to be extracted from its initializer. if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) { a705 1 } a721 1 bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL; d724 5 a728 4 CodeGenFunction BlockCGF{CGM, true}; BlockCGF.SanOpts = SanOpts; auto *InvokeFn = BlockCGF.GenerateBlockFunction( CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal); d732 1 a732 1 return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression); d736 11 d750 6 a755 21 llvm::Constant *isa; llvm::Constant *descriptor; BlockFlags flags; if (!IsOpenCL) { isa = llvm::ConstantExpr::getBitCast(CGM.getNSConcreteStackBlock(), VoidPtrTy); // Build the block descriptor. descriptor = buildBlockDescriptor(CGM, blockInfo); // Compute the initial on-stack block flags. flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; } d779 7 a785 28 if (!IsOpenCL) { addHeaderField(isa, getPointerSize(), "block.isa"); addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), getIntSize(), "block.flags"); addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(), "block.reserved"); } else { addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()), getIntSize(), "block.size"); addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()), getIntSize(), "block.align"); } if (!IsOpenCL) { addHeaderField(llvm::ConstantExpr::getBitCast(InvokeFn, VoidPtrTy), getPointerSize(), "block.invoke"); addHeaderField(descriptor, getPointerSize(), "block.descriptor"); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) { addHeaderField( I.first, CharUnits::fromQuantity( CGM.getDataLayout().getTypeAllocSize(I.first->getType())), I.second); } } d827 1 a827 1 // This is a [[type]]*, except that a byref entry will just be an i8**. d869 1 a869 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); d920 1 d922 1 a922 1 MakeAddrLValue(blockField, type, AlignmentSource::Decl), a938 5 if (IsOpenCL) { CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn, result); } a975 2 assert(!getLangOpts().OpenCL && "OpenCL does not need this"); d995 1 a995 1 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, a1000 1 llvm::Value *FuncPtr; d1002 20 a1021 13 if (!CGM.getLangOpts().OpenCL) { // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::get(CGM.getGenericBlockLiteralType(), 0); // Bitcast the callee to a block literal. BlockPtr = Builder.CreatePointerCast(BlockPtr, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. FuncPtr = Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr, 3); } d1029 2 a1030 1 GenericVoidPtrTy = CGM.getOpenCLRuntime().getGenericVoidPointerType(); d1045 1 a1045 5 llvm::Value *Func; if (CGM.getLangOpts().OpenCL) Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee()); else Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); d1055 1 a1055 1 Func = Builder.CreatePointerCast(Func, BlockFTyPtr); d1090 2 a1091 2 if (capture.fieldType()->isReferenceType()) addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType())); d1116 1 d1119 4 a1122 3 CodeGenFunction(*this).GenerateBlockFunction( GlobalDecl(), blockInfo, LocalDeclMap, /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true); d1124 1 d1126 1 a1126 1 return getAddrOfGlobalBlockIfEmitted(BE); d1143 12 a1154 11 bool IsOpenCL = CGM.getLangOpts().OpenCL; if (!IsOpenCL) { // isa fields.add(CGM.getNSConcreteGlobalBlock()); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields.addInt(CGM.IntTy, flags.getBitMask()); d1156 2 a1157 2 // Reserved fields.addInt(CGM.IntTy, 0); d1159 2 a1160 6 // Function fields.add(blockFn); } else { fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity()); fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity()); } d1162 2 a1163 9 if (!IsOpenCL) { // Descriptor fields.add(buildBlockDescriptor(CGM, blockInfo)); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) { fields.add(I); } } a1178 4 if (CGM.getContext().getLangOpts().OpenCL) CGM.getOpenCLRuntime().recordBlockInfo( blockInfo.BlockExpression, cast(blockFn->stripPointerCasts()), Result); d1187 8 a1194 4 // Allocate a stack slot like for any local variable to guarantee optimal // debug info at -O0. The mem2reg pass will eliminate it when optimizing. Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr"); Builder.CreateStore(arg, alloc); d1199 2 a1200 3 DI->EmitDeclareOfBlockLiteralArgVariable( *BlockInfo, D->getName(), argNum, cast(alloc.getPointer()), Builder); d1228 1 a1228 2 bool IsLambdaConversionToBlock, bool BuildGlobalBlock) { a1286 8 if (BuildGlobalBlock) { auto GenVoidPtrTy = getContext().getLangOpts().OpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy; buildGlobalBlock(CGM, blockInfo, llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy)); } d1365 2 a1366 2 (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(), Builder); a1398 1 NonTrivialCStruct, d1434 3 d1443 5 a1447 6 switch (T.isNonTrivialToPrimitiveCopy()) { case QualType::PCK_Struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::PCK_ARCWeak: // We need to register __weak direct captures with the runtime. d1449 6 a1454 5 case QualType::PCK_ARCStrong: // We need to retain the copied value for __strong direct captures. // If it's a block pointer, we have to copy the block and assign that to // the destination pointer, so we might as well use _Block_object_assign. // Otherwise we can avoid that. d1458 1 a1458 5 case QualType::PCK_Trivial: case QualType::PCK_VolatileTrivial: { if (!T->isObjCRetainableType()) // For all other types, the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1460 4 a1463 7 // Special rules for ARC captures: Qualifiers QS = T.getQualifiers(); // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); d1465 2 a1466 5 // Otherwise the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); } } llvm_unreachable("after exhaustive PrimitiveCopyKind switch"); d1530 1 a1530 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1532 1 d1534 2 a1535 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1564 7 // If this is a C struct that requires non-trivial copy construction, emit a // call to its copy constructor. } else if (CopiedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); callCStructCopyConstructor(MakeAddrLValue(dstField, varType), MakeAddrLValue(srcField, varType)); a1619 9 static BlockFieldFlags getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI, QualType T) { BlockFieldFlags Flags = BLOCK_FIELD_IS_OBJECT; if (T->isBlockPointerType()) Flags = BLOCK_FIELD_IS_BLOCK; return Flags; } d1623 1 d1625 1 a1625 1 BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF; d1631 3 a1633 2 switch (T.isDestructedType()) { case QualType::DK_cxx_destructor: a1634 20 case QualType::DK_objc_strong_lifetime: // Use objc_storeStrong for __strong direct captures; the // dynamic tools really like it when we do this. return std::make_pair(BlockCaptureEntityKind::ARCStrong, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_objc_weak_lifetime: // Support __weak direct captures. return std::make_pair(BlockCaptureEntityKind::ARCWeak, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_nontrivial_c_struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::DK_none: { // Non-ARC captures are strong, and we need to use _Block_object_dispose. if (T->isObjCRetainableType() && !T.getQualifiers().hasObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, getBlockFieldFlagsForObjCObjectPointer(CI, T)); // Otherwise, we have nothing to do. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1636 28 a1663 2 } llvm_unreachable("after exhaustive DestructionKind switch"); d1702 1 a1702 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1704 2 d1707 1 a1707 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1742 7 // If this is a C struct that requires non-trivial destruction, emit a call // to its destructor. } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); pushDestroy(varType.isDestructedType(), srcField, varType); a1909 30 /// Emits the copy/dispose helpers for a __block variable that is a non-trivial /// C struct. class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers { QualType VarType; public: NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type) : BlockByrefHelpers(alignment), VarType(type) {} void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { CGF.callCStructMoveConstructor(CGF.MakeAddrLValue(destField, VarType), CGF.MakeAddrLValue(srcField, VarType)); } bool needsDispose() const override { return VarType.isDestructedType(); } void emitDispose(CodeGenFunction &CGF, Address field) override { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.pushDestroy(VarType.isDestructedType(), field, VarType); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; d1949 1 a1949 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d2023 1 a2023 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); a2094 7 // If type is a non-trivial C struct type that is non-trivial to // destructly move or destroy, build the copy and dispose helpers. if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct || type.isDestructedType() == QualType::DK_nontrivial_c_struct) return ::buildByrefHelpers( CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type)); d2449 4 a2452 2 if (CGM.getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() && GV->hasExternalLinkage()) a2453 2 CGM.setDSOLocal(GV); @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @a16 1 #include "CGOpenCLRuntime.h" d19 1 a19 2 #include "ConstantEmitter.h" #include "TargetInfo.h" a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" d66 1 a66 1 /// Its definition will have 4 (or optionally 6) words. d293 1 a293 1 return ConstantEmitter(CGM, CGF).tryEmitAbstractForInitializer(*var); d304 8 d314 5 a318 36 if (CGM.getLangOpts().OpenCL) { // The header is basically 'struct { int; int; // custom_fields; }'. Assert that struct is packed. elementTypes.push_back(CGM.IntTy); /* total size */ elementTypes.push_back(CGM.IntTy); /* align */ unsigned Offset = 2 * CGM.getIntSize().getQuantity(); unsigned BlockAlign = CGM.getIntAlign().getQuantity(); if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldTypes()) /* custom fields */ { // TargetOpenCLBlockHelp needs to make sure the struct is packed. // If necessary, add padding fields to the custom fields. unsigned Align = CGM.getDataLayout().getABITypeAlignment(I); if (BlockAlign < Align) BlockAlign = Align; assert(Offset % Align == 0); Offset += CGM.getDataLayout().getTypeAllocSize(I); elementTypes.push_back(I); } } info.BlockAlign = CharUnits::fromQuantity(BlockAlign); info.BlockSize = CharUnits::fromQuantity(Offset); } else { // The header is basically 'struct { void *; int; int; void *; void *; }'. // Assert that the struct is packed. assert(CGM.getIntSize() <= CGM.getPointerSize()); assert(CGM.getIntAlign() <= CGM.getPointerAlign()); assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())); info.BlockAlign = CGM.getPointerAlign(); info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize(); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.getBlockDescriptorType()); } d343 2 a344 6 bool hasNonConstantCustomFields = false; if (auto *OpenCLHelper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) hasNonConstantCustomFields = !OpenCLHelper->areAllCustomFieldValuesConstant(info); if (!block->hasCaptures() && !hasNonConstantCustomFields) { a436 8 // So do C structs that require non-trivial copy construction or // destruction. } else if (variable->getType().isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct || variable->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) { info.NeedsCopyDispose = true; d665 5 a669 2 for (const ExprWithCleanups::CleanupObject &C : E->getObjects()) enterBlockScope(*this, C); d704 1 a704 3 // The block literal is emitted as a global variable, and the block invoke // function has to be extracted from its initializer. if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) { a705 1 } a721 1 bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL; d724 5 a728 4 CodeGenFunction BlockCGF{CGM, true}; BlockCGF.SanOpts = SanOpts; auto *InvokeFn = BlockCGF.GenerateBlockFunction( CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal); d732 1 a732 1 return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression); d736 11 d750 6 a755 21 llvm::Constant *isa; llvm::Constant *descriptor; BlockFlags flags; if (!IsOpenCL) { isa = llvm::ConstantExpr::getBitCast(CGM.getNSConcreteStackBlock(), VoidPtrTy); // Build the block descriptor. descriptor = buildBlockDescriptor(CGM, blockInfo); // Compute the initial on-stack block flags. flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; } d779 7 a785 28 if (!IsOpenCL) { addHeaderField(isa, getPointerSize(), "block.isa"); addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), getIntSize(), "block.flags"); addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(), "block.reserved"); } else { addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()), getIntSize(), "block.size"); addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()), getIntSize(), "block.align"); } if (!IsOpenCL) { addHeaderField(llvm::ConstantExpr::getBitCast(InvokeFn, VoidPtrTy), getPointerSize(), "block.invoke"); addHeaderField(descriptor, getPointerSize(), "block.descriptor"); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) { addHeaderField( I.first, CharUnits::fromQuantity( CGM.getDataLayout().getTypeAllocSize(I.first->getType())), I.second); } } d827 1 a827 1 // This is a [[type]]*, except that a byref entry will just be an i8**. d869 1 a869 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); d920 1 d922 1 a922 1 MakeAddrLValue(blockField, type, AlignmentSource::Decl), a938 5 if (IsOpenCL) { CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn, result); } a975 2 assert(!getLangOpts().OpenCL && "OpenCL does not need this"); d995 1 a995 1 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, a1000 1 llvm::Value *FuncPtr; d1002 20 a1021 13 if (!CGM.getLangOpts().OpenCL) { // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::get(CGM.getGenericBlockLiteralType(), 0); // Bitcast the callee to a block literal. BlockPtr = Builder.CreatePointerCast(BlockPtr, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. FuncPtr = Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr, 3); } d1029 2 a1030 1 GenericVoidPtrTy = CGM.getOpenCLRuntime().getGenericVoidPointerType(); d1045 1 a1045 5 llvm::Value *Func; if (CGM.getLangOpts().OpenCL) Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee()); else Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); d1055 1 a1055 1 Func = Builder.CreatePointerCast(Func, BlockFTyPtr); d1090 2 a1091 2 if (capture.fieldType()->isReferenceType()) addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType())); d1116 1 d1119 4 a1122 3 CodeGenFunction(*this).GenerateBlockFunction( GlobalDecl(), blockInfo, LocalDeclMap, /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true); d1124 1 d1126 1 a1126 1 return getAddrOfGlobalBlockIfEmitted(BE); d1143 12 a1154 11 bool IsOpenCL = CGM.getLangOpts().OpenCL; if (!IsOpenCL) { // isa fields.add(CGM.getNSConcreteGlobalBlock()); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields.addInt(CGM.IntTy, flags.getBitMask()); d1156 2 a1157 2 // Reserved fields.addInt(CGM.IntTy, 0); d1159 2 a1160 6 // Function fields.add(blockFn); } else { fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity()); fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity()); } d1162 2 a1163 9 if (!IsOpenCL) { // Descriptor fields.add(buildBlockDescriptor(CGM, blockInfo)); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) { fields.add(I); } } a1178 4 if (CGM.getContext().getLangOpts().OpenCL) CGM.getOpenCLRuntime().recordBlockInfo( blockInfo.BlockExpression, cast(blockFn->stripPointerCasts()), Result); d1187 8 a1194 4 // Allocate a stack slot like for any local variable to guarantee optimal // debug info at -O0. The mem2reg pass will eliminate it when optimizing. Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr"); Builder.CreateStore(arg, alloc); d1199 2 a1200 3 DI->EmitDeclareOfBlockLiteralArgVariable( *BlockInfo, D->getName(), argNum, cast(alloc.getPointer()), Builder); d1228 1 a1228 2 bool IsLambdaConversionToBlock, bool BuildGlobalBlock) { a1286 8 if (BuildGlobalBlock) { auto GenVoidPtrTy = getContext().getLangOpts().OpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy; buildGlobalBlock(CGM, blockInfo, llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy)); } d1365 2 a1366 2 (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(), Builder); a1398 1 NonTrivialCStruct, d1434 3 d1443 5 a1447 6 switch (T.isNonTrivialToPrimitiveCopy()) { case QualType::PCK_Struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::PCK_ARCWeak: // We need to register __weak direct captures with the runtime. d1449 6 a1454 5 case QualType::PCK_ARCStrong: // We need to retain the copied value for __strong direct captures. // If it's a block pointer, we have to copy the block and assign that to // the destination pointer, so we might as well use _Block_object_assign. // Otherwise we can avoid that. d1458 1 a1458 5 case QualType::PCK_Trivial: case QualType::PCK_VolatileTrivial: { if (!T->isObjCRetainableType()) // For all other types, the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1460 4 a1463 7 // Special rules for ARC captures: Qualifiers QS = T.getQualifiers(); // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); d1465 2 a1466 5 // Otherwise the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); } } llvm_unreachable("after exhaustive PrimitiveCopyKind switch"); d1530 1 a1530 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1532 1 d1534 2 a1535 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1564 7 // If this is a C struct that requires non-trivial copy construction, emit a // call to its copy constructor. } else if (CopiedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); callCStructCopyConstructor(MakeAddrLValue(dstField, varType), MakeAddrLValue(srcField, varType)); a1619 9 static BlockFieldFlags getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI, QualType T) { BlockFieldFlags Flags = BLOCK_FIELD_IS_OBJECT; if (T->isBlockPointerType()) Flags = BLOCK_FIELD_IS_BLOCK; return Flags; } d1623 1 d1625 1 a1625 1 BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF; d1631 3 a1633 2 switch (T.isDestructedType()) { case QualType::DK_cxx_destructor: a1634 20 case QualType::DK_objc_strong_lifetime: // Use objc_storeStrong for __strong direct captures; the // dynamic tools really like it when we do this. return std::make_pair(BlockCaptureEntityKind::ARCStrong, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_objc_weak_lifetime: // Support __weak direct captures. return std::make_pair(BlockCaptureEntityKind::ARCWeak, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_nontrivial_c_struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::DK_none: { // Non-ARC captures are strong, and we need to use _Block_object_dispose. if (T->isObjCRetainableType() && !T.getQualifiers().hasObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, getBlockFieldFlagsForObjCObjectPointer(CI, T)); // Otherwise, we have nothing to do. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1636 28 a1663 2 } llvm_unreachable("after exhaustive DestructionKind switch"); d1702 1 a1702 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1704 2 d1707 1 a1707 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1742 7 // If this is a C struct that requires non-trivial destruction, emit a call // to its destructor. } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); pushDestroy(varType.isDestructedType(), srcField, varType); a1909 30 /// Emits the copy/dispose helpers for a __block variable that is a non-trivial /// C struct. class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers { QualType VarType; public: NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type) : BlockByrefHelpers(alignment), VarType(type) {} void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { CGF.callCStructMoveConstructor(CGF.MakeAddrLValue(destField, VarType), CGF.MakeAddrLValue(srcField, VarType)); } bool needsDispose() const override { return VarType.isDestructedType(); } void emitDispose(CodeGenFunction &CGF, Address field) override { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.pushDestroy(VarType.isDestructedType(), field, VarType); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; d1949 1 a1949 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d2023 1 a2023 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); a2094 7 // If type is a non-trivial C struct type that is non-trivial to // destructly move or destroy, build the copy and dispose helpers. if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct || type.isDestructedType() == QualType::DK_nontrivial_c_struct) return ::buildByrefHelpers( CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type)); d2449 4 a2452 2 if (CGM.getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() && GV->hasExternalLinkage()) a2453 2 CGM.setDSOLocal(GV); @ 1.1.1.10 log @Import clang r337282 from trunk @ text @a16 1 #include "CGOpenCLRuntime.h" d19 1 a19 2 #include "ConstantEmitter.h" #include "TargetInfo.h" a20 1 #include "clang/CodeGen/ConstantInitBuilder.h" d66 1 a66 1 /// Its definition will have 4 (or optionally 6) words. d293 1 a293 1 return ConstantEmitter(CGM, CGF).tryEmitAbstractForInitializer(*var); d304 8 d314 5 a318 36 if (CGM.getLangOpts().OpenCL) { // The header is basically 'struct { int; int; // custom_fields; }'. Assert that struct is packed. elementTypes.push_back(CGM.IntTy); /* total size */ elementTypes.push_back(CGM.IntTy); /* align */ unsigned Offset = 2 * CGM.getIntSize().getQuantity(); unsigned BlockAlign = CGM.getIntAlign().getQuantity(); if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldTypes()) /* custom fields */ { // TargetOpenCLBlockHelp needs to make sure the struct is packed. // If necessary, add padding fields to the custom fields. unsigned Align = CGM.getDataLayout().getABITypeAlignment(I); if (BlockAlign < Align) BlockAlign = Align; assert(Offset % Align == 0); Offset += CGM.getDataLayout().getTypeAllocSize(I); elementTypes.push_back(I); } } info.BlockAlign = CharUnits::fromQuantity(BlockAlign); info.BlockSize = CharUnits::fromQuantity(Offset); } else { // The header is basically 'struct { void *; int; int; void *; void *; }'. // Assert that the struct is packed. assert(CGM.getIntSize() <= CGM.getPointerSize()); assert(CGM.getIntAlign() <= CGM.getPointerAlign()); assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())); info.BlockAlign = CGM.getPointerAlign(); info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize(); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.getBlockDescriptorType()); } d343 2 a344 6 bool hasNonConstantCustomFields = false; if (auto *OpenCLHelper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) hasNonConstantCustomFields = !OpenCLHelper->areAllCustomFieldValuesConstant(info); if (!block->hasCaptures() && !hasNonConstantCustomFields) { a436 8 // So do C structs that require non-trivial copy construction or // destruction. } else if (variable->getType().isNonTrivialToPrimitiveCopy() == QualType::PCK_Struct || variable->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) { info.NeedsCopyDispose = true; d665 5 a669 2 for (const ExprWithCleanups::CleanupObject &C : E->getObjects()) enterBlockScope(*this, C); d704 1 a704 3 // The block literal is emitted as a global variable, and the block invoke // function has to be extracted from its initializer. if (llvm::Constant *Block = CGM.getAddrOfGlobalBlockIfEmitted(blockExpr)) { a705 1 } a721 1 bool IsOpenCL = CGM.getContext().getLangOpts().OpenCL; d724 5 a728 4 CodeGenFunction BlockCGF{CGM, true}; BlockCGF.SanOpts = SanOpts; auto *InvokeFn = BlockCGF.GenerateBlockFunction( CurGD, blockInfo, LocalDeclMap, isLambdaConv, blockInfo.CanBeGlobal); d732 1 a732 1 return CGM.getAddrOfGlobalBlockIfEmitted(blockInfo.BlockExpression); d736 11 d750 6 a755 21 llvm::Constant *isa; llvm::Constant *descriptor; BlockFlags flags; if (!IsOpenCL) { isa = llvm::ConstantExpr::getBitCast(CGM.getNSConcreteStackBlock(), VoidPtrTy); // Build the block descriptor. descriptor = buildBlockDescriptor(CGM, blockInfo); // Compute the initial on-stack block flags. flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; } d779 7 a785 28 if (!IsOpenCL) { addHeaderField(isa, getPointerSize(), "block.isa"); addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()), getIntSize(), "block.flags"); addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(), "block.reserved"); } else { addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()), getIntSize(), "block.size"); addHeaderField( llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()), getIntSize(), "block.align"); } if (!IsOpenCL) { addHeaderField(llvm::ConstantExpr::getBitCast(InvokeFn, VoidPtrTy), getPointerSize(), "block.invoke"); addHeaderField(descriptor, getPointerSize(), "block.descriptor"); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(*this, blockInfo)) { addHeaderField( I.first, CharUnits::fromQuantity( CGM.getDataLayout().getTypeAllocSize(I.first->getType())), I.second); } } d827 1 a827 1 // This is a [[type]]*, except that a byref entry will just be an i8**. d869 1 a869 2 AggValueSlot::IsNotAliased, AggValueSlot::DoesNotOverlap); d920 1 d922 1 a922 1 MakeAddrLValue(blockField, type, AlignmentSource::Decl), a938 5 if (IsOpenCL) { CGM.getOpenCLRuntime().recordBlockInfo(blockInfo.BlockExpression, InvokeFn, result); } a975 2 assert(!getLangOpts().OpenCL && "OpenCL does not need this"); d995 1 a995 1 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, a1000 1 llvm::Value *FuncPtr; d1002 20 a1021 13 if (!CGM.getLangOpts().OpenCL) { // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::get(CGM.getGenericBlockLiteralType(), 0); // Bitcast the callee to a block literal. BlockPtr = Builder.CreatePointerCast(BlockPtr, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. FuncPtr = Builder.CreateStructGEP(CGM.getGenericBlockLiteralType(), BlockPtr, 3); } d1029 2 a1030 1 GenericVoidPtrTy = CGM.getOpenCLRuntime().getGenericVoidPointerType(); d1045 1 a1045 5 llvm::Value *Func; if (CGM.getLangOpts().OpenCL) Func = CGM.getOpenCLRuntime().getInvokeFunction(E->getCallee()); else Func = Builder.CreateAlignedLoad(FuncPtr, getPointerAlign()); d1055 1 a1055 1 Func = Builder.CreatePointerCast(Func, BlockFTyPtr); d1090 2 a1091 2 if (capture.fieldType()->isReferenceType()) addr = EmitLoadOfReference(MakeAddrLValue(addr, capture.fieldType())); d1116 1 d1119 4 a1122 3 CodeGenFunction(*this).GenerateBlockFunction( GlobalDecl(), blockInfo, LocalDeclMap, /*IsLambdaConversionToBlock*/ false, /*BuildGlobalBlock*/ true); d1124 1 d1126 1 a1126 1 return getAddrOfGlobalBlockIfEmitted(BE); d1143 12 a1154 11 bool IsOpenCL = CGM.getLangOpts().OpenCL; if (!IsOpenCL) { // isa fields.add(CGM.getNSConcreteGlobalBlock()); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields.addInt(CGM.IntTy, flags.getBitMask()); d1156 2 a1157 2 // Reserved fields.addInt(CGM.IntTy, 0); d1159 2 a1160 6 // Function fields.add(blockFn); } else { fields.addInt(CGM.IntTy, blockInfo.BlockSize.getQuantity()); fields.addInt(CGM.IntTy, blockInfo.BlockAlign.getQuantity()); } d1162 2 a1163 9 if (!IsOpenCL) { // Descriptor fields.add(buildBlockDescriptor(CGM, blockInfo)); } else if (auto *Helper = CGM.getTargetCodeGenInfo().getTargetOpenCLBlockHelper()) { for (auto I : Helper->getCustomFieldValues(CGM, blockInfo)) { fields.add(I); } } a1178 4 if (CGM.getContext().getLangOpts().OpenCL) CGM.getOpenCLRuntime().recordBlockInfo( blockInfo.BlockExpression, cast(blockFn->stripPointerCasts()), Result); d1187 8 a1194 4 // Allocate a stack slot like for any local variable to guarantee optimal // debug info at -O0. The mem2reg pass will eliminate it when optimizing. Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr"); Builder.CreateStore(arg, alloc); d1199 2 a1200 3 DI->EmitDeclareOfBlockLiteralArgVariable( *BlockInfo, D->getName(), argNum, cast(alloc.getPointer()), Builder); d1228 1 a1228 2 bool IsLambdaConversionToBlock, bool BuildGlobalBlock) { a1286 8 if (BuildGlobalBlock) { auto GenVoidPtrTy = getContext().getLangOpts().OpenCL ? CGM.getOpenCLRuntime().getGenericVoidPointerType() : VoidPtrTy; buildGlobalBlock(CGM, blockInfo, llvm::ConstantExpr::getPointerCast(fn, GenVoidPtrTy)); } d1365 2 a1366 2 (void)DI->EmitDeclareOfAutoVariable(variable, addr.getPointer(), Builder); a1398 1 NonTrivialCStruct, d1434 3 d1443 5 a1447 6 switch (T.isNonTrivialToPrimitiveCopy()) { case QualType::PCK_Struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::PCK_ARCWeak: // We need to register __weak direct captures with the runtime. d1449 6 a1454 5 case QualType::PCK_ARCStrong: // We need to retain the copied value for __strong direct captures. // If it's a block pointer, we have to copy the block and assign that to // the destination pointer, so we might as well use _Block_object_assign. // Otherwise we can avoid that. d1458 1 a1458 5 case QualType::PCK_Trivial: case QualType::PCK_VolatileTrivial: { if (!T->isObjCRetainableType()) // For all other types, the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1460 4 a1463 7 // Special rules for ARC captures: Qualifiers QS = T.getQualifiers(); // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. if (!QS.getObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, Flags); d1465 2 a1466 5 // Otherwise the memcpy is fine. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); } } llvm_unreachable("after exhaustive PrimitiveCopyKind switch"); d1530 1 a1530 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1532 1 d1534 2 a1535 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1564 7 // If this is a C struct that requires non-trivial copy construction, emit a // call to its copy constructor. } else if (CopiedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); callCStructCopyConstructor(MakeAddrLValue(dstField, varType), MakeAddrLValue(srcField, varType)); a1619 9 static BlockFieldFlags getBlockFieldFlagsForObjCObjectPointer(const BlockDecl::Capture &CI, QualType T) { BlockFieldFlags Flags = BLOCK_FIELD_IS_OBJECT; if (T->isBlockPointerType()) Flags = BLOCK_FIELD_IS_BLOCK; return Flags; } d1623 1 d1625 1 a1625 1 BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF; d1631 3 a1633 2 switch (T.isDestructedType()) { case QualType::DK_cxx_destructor: a1634 20 case QualType::DK_objc_strong_lifetime: // Use objc_storeStrong for __strong direct captures; the // dynamic tools really like it when we do this. return std::make_pair(BlockCaptureEntityKind::ARCStrong, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_objc_weak_lifetime: // Support __weak direct captures. return std::make_pair(BlockCaptureEntityKind::ARCWeak, getBlockFieldFlagsForObjCObjectPointer(CI, T)); case QualType::DK_nontrivial_c_struct: return std::make_pair(BlockCaptureEntityKind::NonTrivialCStruct, BlockFieldFlags()); case QualType::DK_none: { // Non-ARC captures are strong, and we need to use _Block_object_dispose. if (T->isObjCRetainableType() && !T.getQualifiers().hasObjCLifetime() && !LangOpts.ObjCAutoRefCount) return std::make_pair(BlockCaptureEntityKind::BlockObject, getBlockFieldFlagsForObjCObjectPointer(CI, T)); // Otherwise, we have nothing to do. return std::make_pair(BlockCaptureEntityKind::None, BlockFieldFlags()); d1636 28 a1663 2 } llvm_unreachable("after exhaustive DestructionKind switch"); d1702 1 a1702 1 CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d1704 2 d1707 1 a1707 1 ApplyDebugLocation NL{*this, blockInfo.getBlockExpr()->getLocStart()}; a1742 7 // If this is a C struct that requires non-trivial destruction, emit a call // to its destructor. } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::NonTrivialCStruct) { QualType varType = CI.getVariable()->getType(); pushDestroy(varType.isDestructedType(), srcField, varType); a1909 30 /// Emits the copy/dispose helpers for a __block variable that is a non-trivial /// C struct. class NonTrivialCStructByrefHelpers final : public BlockByrefHelpers { QualType VarType; public: NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type) : BlockByrefHelpers(alignment), VarType(type) {} void emitCopy(CodeGenFunction &CGF, Address destField, Address srcField) override { CGF.callCStructMoveConstructor(CGF.MakeAddrLValue(destField, VarType), CGF.MakeAddrLValue(srcField, VarType)); } bool needsDispose() const override { return VarType.isDestructedType(); } void emitDispose(CodeGenFunction &CGF, Address field) override { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.pushDestroy(VarType.isDestructedType(), field, VarType); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; d1949 1 a1949 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); d2023 1 a2023 1 CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI); a2094 7 // If type is a non-trivial C struct type that is non-trivial to // destructly move or destroy, build the copy and dispose helpers. if (type.isNonTrivialToPrimitiveDestructiveMove() == QualType::PCK_Struct || type.isDestructedType() == QualType::DK_nontrivial_c_struct) return ::buildByrefHelpers( CGM, byrefInfo, NonTrivialCStructByrefHelpers(valueAlignment, type)); d2449 4 a2452 2 if (CGM.getLangOpts().BlocksRuntimeOptional && GV->isDeclaration() && GV->hasExternalLinkage()) a2453 2 CGM.setDSOLocal(GV); @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file CGBlocks.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 2288 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2288 //===--- CGBlocks.cpp - Emit LLVM Code for declarations -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit blocks. // //===----------------------------------------------------------------------===// #include "CGBlocks.h" #include "CGDebugInfo.h" #include "CGObjCRuntime.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "clang/AST/DeclObjC.h" #include "llvm/ADT/SmallSet.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Module.h" #include #include using namespace clang; using namespace CodeGen; CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name) : Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false), HasCXXObject(false), UsesStret(false), HasCapturedVariableLayout(false), StructureType(nullptr), Block(block), DominatingIP(nullptr) { // Skip asm prefix, if any. 'name' is usually taken directly from // the mangled name of the enclosing function. if (!name.empty() && name[0] == '\01') name = name.substr(1); } // Anchor the vtable to this translation unit. CodeGenModule::ByrefHelpers::~ByrefHelpers() {} /// Build the given block as a global block. static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn); /// Build the helper function to copy a block. static llvm::Constant *buildCopyHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo); } /// Build the helper function to dispose of a block. static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo); } /// buildBlockDescriptor - Build the block descriptor meta-data for a block. /// buildBlockDescriptor is accessed from 5th field of the Block_literal /// meta-data and contains stationary information about the block literal. /// Its definition will have 4 (or optinally 6) words. /// \code /// struct Block_descriptor { /// unsigned long reserved; /// unsigned long size; // size of Block_literal metadata in bytes. /// void *copy_func_helper_decl; // optional copy helper. /// void *destroy_func_decl; // optioanl destructor helper. /// void *block_method_encoding_address; // @@encode for block literal signature. /// void *block_layout_info; // encoding of captured block variables. /// }; /// \endcode static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { ASTContext &C = CGM.getContext(); llvm::Type *ulong = CGM.getTypes().ConvertType(C.UnsignedLongTy); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); SmallVector elements; // reserved elements.push_back(llvm::ConstantInt::get(ulong, 0)); // Size // FIXME: What is the right way to say this doesn't fit? We should give // a user diagnostic in that case. Better fix would be to change the // API to size_t. elements.push_back(llvm::ConstantInt::get(ulong, blockInfo.BlockSize.getQuantity())); // Optional copy/dispose helpers. if (blockInfo.NeedsCopyDispose) { // copy_func_helper_decl elements.push_back(buildCopyHelper(CGM, blockInfo)); // destroy_func_decl elements.push_back(buildDisposeHelper(CGM, blockInfo)); } // Signature. Mandatory ObjC-style method descriptor @@encode sequence. std::string typeAtEncoding = CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr()); elements.push_back(llvm::ConstantExpr::getBitCast( CGM.GetAddrOfConstantCString(typeAtEncoding), i8p)); // GC layout. if (C.getLangOpts().ObjC1) { if (CGM.getLangOpts().getGC() != LangOptions::NonGC) elements.push_back(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo)); else elements.push_back(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo)); } else elements.push_back(llvm::Constant::getNullValue(i8p)); llvm::Constant *init = llvm::ConstantStruct::getAnon(elements); llvm::GlobalVariable *global = new llvm::GlobalVariable(CGM.getModule(), init->getType(), true, llvm::GlobalValue::InternalLinkage, init, "__block_descriptor_tmp"); return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType()); } /* Purely notional variadic template describing the layout of a block. template struct Block_literal { /// Initialized to one of: /// extern void *_NSConcreteStackBlock[]; /// extern void *_NSConcreteGlobalBlock[]; /// /// In theory, we could start one off malloc'ed by setting /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using /// this isa: /// extern void *_NSConcreteMallocBlock[]; struct objc_class *isa; /// These are the flags (with corresponding bit number) that the /// compiler is actually supposed to know about. /// 25. BLOCK_HAS_COPY_DISPOSE - indicates that the block /// descriptor provides copy and dispose helper functions /// 26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured /// object with a nontrivial destructor or copy constructor /// 28. BLOCK_IS_GLOBAL - indicates that the block is allocated /// as global memory /// 29. BLOCK_USE_STRET - indicates that the block function /// uses stret, which objc_msgSend needs to know about /// 30. BLOCK_HAS_SIGNATURE - indicates that the block has an /// @@encoded signature string /// And we're not supposed to manipulate these: /// 24. BLOCK_NEEDS_FREE - indicates that the block has been moved /// to malloc'ed memory /// 27. BLOCK_IS_GC - indicates that the block has been moved to /// to GC-allocated memory /// Additionally, the bottom 16 bits are a reference count which /// should be zero on the stack. int flags; /// Reserved; should be zero-initialized. int reserved; /// Function pointer generated from block literal. _ResultType (*invoke)(Block_literal *, _ParamTypes...); /// Block description metadata generated from block literal. struct Block_descriptor *block_descriptor; /// Captured values follow. _CapturesTypes captures...; }; */ /// The number of fields in a block header. const unsigned BlockHeaderSize = 5; namespace { /// A chunk of data that we actually have to capture in the block. struct BlockLayoutChunk { CharUnits Alignment; CharUnits Size; Qualifiers::ObjCLifetime Lifetime; const BlockDecl::Capture *Capture; // null for 'this' llvm::Type *Type; BlockLayoutChunk(CharUnits align, CharUnits size, Qualifiers::ObjCLifetime lifetime, const BlockDecl::Capture *capture, llvm::Type *type) : Alignment(align), Size(size), Lifetime(lifetime), Capture(capture), Type(type) {} /// Tell the block info that this chunk has the given field index. void setIndex(CGBlockInfo &info, unsigned index) { if (!Capture) info.CXXThisIndex = index; else info.Captures[Capture->getVariable()] = CGBlockInfo::Capture::makeIndex(index); } }; /// Order by 1) all __strong together 2) next, all byfref together 3) next, /// all __weak together. Preserve descending alignment in all situations. bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) { CharUnits LeftValue, RightValue; bool LeftByref = left.Capture ? left.Capture->isByRef() : false; bool RightByref = right.Capture ? right.Capture->isByRef() : false; if (left.Lifetime == Qualifiers::OCL_Strong && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(64); else if (LeftByref && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(32); else if (left.Lifetime == Qualifiers::OCL_Weak && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(16); else LeftValue = left.Alignment; if (right.Lifetime == Qualifiers::OCL_Strong && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(64); else if (RightByref && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(32); else if (right.Lifetime == Qualifiers::OCL_Weak && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(16); else RightValue = right.Alignment; return LeftValue > RightValue; } } /// Determines if the given type is safe for constant capture in C++. static bool isSafeForCXXConstantCapture(QualType type) { const RecordType *recordType = type->getBaseElementTypeUnsafe()->getAs(); // Only records can be unsafe. if (!recordType) return true; const auto *record = cast(recordType->getDecl()); // Maintain semantics for classes with non-trivial dtors or copy ctors. if (!record->hasTrivialDestructor()) return false; if (record->hasNonTrivialCopyConstructor()) return false; // Otherwise, we just have to make sure there aren't any mutable // fields that might have changed since initialization. return !record->hasMutableFields(); } /// It is illegal to modify a const object after initialization. /// Therefore, if a const object has a constant initializer, we don't /// actually need to keep storage for it in the block; we'll just /// rematerialize it at the start of the block function. This is /// acceptable because we make no promises about address stability of /// captured variables. static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM, CodeGenFunction *CGF, const VarDecl *var) { QualType type = var->getType(); // We can only do this if the variable is const. if (!type.isConstQualified()) return nullptr; // Furthermore, in C++ we have to worry about mutable fields: // C++ [dcl.type.cv]p4: // Except that any class member declared mutable can be // modified, any attempt to modify a const object during its // lifetime results in undefined behavior. if (CGM.getLangOpts().CPlusPlus && !isSafeForCXXConstantCapture(type)) return nullptr; // If the variable doesn't have any initializer (shouldn't this be // invalid?), it's not clear what we should do. Maybe capture as // zero? const Expr *init = var->getInit(); if (!init) return nullptr; return CGM.EmitConstantInit(*var, CGF); } /// Get the low bit of a nonzero character count. This is the /// alignment of the nth byte if the 0th byte is universally aligned. static CharUnits getLowBit(CharUnits v) { return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1)); } static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info, SmallVectorImpl &elementTypes) { ASTContext &C = CGM.getContext(); // The header is basically a 'struct { void *; int; int; void *; void *; }'. CharUnits ptrSize, ptrAlign, intSize, intAlign; std::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy); std::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy); // Are there crazy embedded platforms where this isn't true? assert(intSize <= ptrSize && "layout assumptions horribly violated"); CharUnits headerSize = ptrSize; if (2 * intSize < ptrAlign) headerSize += ptrSize; else headerSize += 2 * intSize; headerSize += 2 * ptrSize; info.BlockAlign = ptrAlign; info.BlockSize = headerSize; assert(elementTypes.empty()); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); llvm::Type *intTy = CGM.getTypes().ConvertType(C.IntTy); elementTypes.push_back(i8p); elementTypes.push_back(intTy); elementTypes.push_back(intTy); elementTypes.push_back(i8p); elementTypes.push_back(CGM.getBlockDescriptorType()); assert(elementTypes.size() == BlockHeaderSize); } /// Compute the layout of the given block. Attempts to lay the block /// out with minimal space requirements. static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF, CGBlockInfo &info) { ASTContext &C = CGM.getContext(); const BlockDecl *block = info.getBlockDecl(); SmallVector elementTypes; initializeForBlockHeader(CGM, info, elementTypes); if (!block->hasCaptures()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } else if (C.getLangOpts().ObjC1 && CGM.getLangOpts().getGC() == LangOptions::NonGC) info.HasCapturedVariableLayout = true; // Collect the layout chunks. SmallVector layout; layout.reserve(block->capturesCXXThis() + (block->capture_end() - block->capture_begin())); CharUnits maxFieldAlign; // First, 'this'. if (block->capturesCXXThis()) { assert(CGF && CGF->CurFuncDecl && isa(CGF->CurFuncDecl) && "Can't capture 'this' outside a method"); QualType thisType = cast(CGF->CurFuncDecl)->getThisType(C); llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType); std::pair tinfo = CGM.getContext().getTypeInfoInChars(thisType); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, nullptr, llvmType)); } // Next, all the block captures. for (const auto &CI : block->captures()) { const VarDecl *variable = CI.getVariable(); if (CI.isByRef()) { // We have to copy/dispose of the __block reference. info.NeedsCopyDispose = true; // Just use void* instead of a pointer to the byref type. QualType byRefPtrTy = C.VoidPtrTy; llvm::Type *llvmType = CGM.getTypes().ConvertType(byRefPtrTy); std::pair tinfo = CGM.getContext().getTypeInfoInChars(byRefPtrTy); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, &CI, llvmType)); continue; } // Otherwise, build a layout chunk with the size and alignment of // the declaration. if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) { info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant); continue; } // If we have a lifetime qualifier, honor it for capture purposes. // That includes *not* copying it if it's __unsafe_unretained. Qualifiers::ObjCLifetime lifetime = variable->getType().getObjCLifetime(); if (lifetime) { switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: break; case Qualifiers::OCL_Strong: case Qualifiers::OCL_Weak: info.NeedsCopyDispose = true; } // Block pointers require copy/dispose. So do Objective-C pointers. } else if (variable->getType()->isObjCRetainableType()) { info.NeedsCopyDispose = true; // used for mrr below. lifetime = Qualifiers::OCL_Strong; // So do types that require non-trivial copy construction. } else if (CI.hasCopyExpr()) { info.NeedsCopyDispose = true; info.HasCXXObject = true; // And so do types with destructors. } else if (CGM.getLangOpts().CPlusPlus) { if (const CXXRecordDecl *record = variable->getType()->getAsCXXRecordDecl()) { if (!record->hasTrivialDestructor()) { info.HasCXXObject = true; info.NeedsCopyDispose = true; } } } QualType VT = variable->getType(); CharUnits size = C.getTypeSizeInChars(VT); CharUnits align = C.getDeclAlign(variable); maxFieldAlign = std::max(maxFieldAlign, align); llvm::Type *llvmType = CGM.getTypes().ConvertTypeForMem(VT); layout.push_back(BlockLayoutChunk(align, size, lifetime, &CI, llvmType)); } // If that was everything, we're done here. if (layout.empty()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } // Sort the layout by alignment. We have to use a stable sort here // to get reproducible results. There should probably be an // llvm::array_pod_stable_sort. std::stable_sort(layout.begin(), layout.end()); // Needed for blocks layout info. info.BlockHeaderForcedGapOffset = info.BlockSize; info.BlockHeaderForcedGapSize = CharUnits::Zero(); CharUnits &blockSize = info.BlockSize; info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign); // Assuming that the first byte in the header is maximally aligned, // get the alignment of the first byte following the header. CharUnits endAlign = getLowBit(blockSize); // If the end of the header isn't satisfactorily aligned for the // maximum thing, look for things that are okay with the header-end // alignment, and keep appending them until we get something that's // aligned right. This algorithm is only guaranteed optimal if // that condition is satisfied at some point; otherwise we can get // things like: // header // next byte has alignment 4 // something_with_size_5; // next byte has alignment 1 // something_with_alignment_8; // which has 7 bytes of padding, as opposed to the naive solution // which might have less (?). if (endAlign < maxFieldAlign) { SmallVectorImpl::iterator li = layout.begin() + 1, le = layout.end(); // Look for something that the header end is already // satisfactorily aligned for. for (; li != le && endAlign < li->Alignment; ++li) ; // If we found something that's naturally aligned for the end of // the header, keep adding things... if (li != le) { SmallVectorImpl::iterator first = li; for (; li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); // ...until we get to the alignment of the maximum field. if (endAlign >= maxFieldAlign) { if (li == first) { // No user field was appended. So, a gap was added. // Save total gap size for use in block layout bit map. info.BlockHeaderForcedGapSize = li->Size; } break; } } // Don't re-append everything we just appended. layout.erase(first, li); } } assert(endAlign == getLowBit(blockSize)); // At this point, we just have to add padding if the end align still // isn't aligned right. if (endAlign < maxFieldAlign) { CharUnits newBlockSize = blockSize.RoundUpToAlignment(maxFieldAlign); CharUnits padding = newBlockSize - blockSize; elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, padding.getQuantity())); blockSize = newBlockSize; endAlign = getLowBit(blockSize); // might be > maxFieldAlign } assert(endAlign >= maxFieldAlign); assert(endAlign == getLowBit(blockSize)); // Slam everything else on now. This works because they have // strictly decreasing alignment and we expect that size is always a // multiple of alignment. for (SmallVectorImpl::iterator li = layout.begin(), le = layout.end(); li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); } info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); } /// Enter the scope of a block. This should be run at the entrance to /// a full-expression so that the block's cleanups are pushed at the /// right place in the stack. static void enterBlockScope(CodeGenFunction &CGF, BlockDecl *block) { assert(CGF.HaveInsertPoint()); // Allocate the block info and place it at the head of the list. CGBlockInfo &blockInfo = *new CGBlockInfo(block, CGF.CurFn->getName()); blockInfo.NextBlockInfo = CGF.FirstBlockInfo; CGF.FirstBlockInfo = &blockInfo; // Compute information about the layout, etc., of this block, // pushing cleanups as necessary. computeBlockInfo(CGF.CGM, &CGF, blockInfo); // Nothing else to do if it can be global. if (blockInfo.CanBeGlobal) return; // Make the allocation for the block. blockInfo.Address = CGF.CreateTempAlloca(blockInfo.StructureType, "block"); blockInfo.Address->setAlignment(blockInfo.BlockAlign.getQuantity()); // If there are cleanups to emit, enter them (but inactive). if (!blockInfo.NeedsCopyDispose) return; // Walk through the captures (in order) and find the ones not // captured by constant. for (const auto &CI : block->captures()) { // Ignore __block captures; there's nothing special in the // on-stack block that we need to do for them. if (CI.isByRef()) continue; // Ignore variables that are constant-captured. const VarDecl *variable = CI.getVariable(); CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; // Ignore objects that aren't destructed. QualType::DestructionKind dtorKind = variable->getType().isDestructedType(); if (dtorKind == QualType::DK_none) continue; CodeGenFunction::Destroyer *destroyer; // Block captures count as local values and have imprecise semantics. // They also can't be arrays, so need to worry about that. if (dtorKind == QualType::DK_objc_strong_lifetime) { destroyer = CodeGenFunction::destroyARCStrongImprecise; } else { destroyer = CGF.getDestroyer(dtorKind); } // GEP down to the address. llvm::Value *addr = CGF.Builder.CreateStructGEP(blockInfo.Address, capture.getIndex()); // We can use that GEP as the dominating IP. if (!blockInfo.DominatingIP) blockInfo.DominatingIP = cast(addr); CleanupKind cleanupKind = InactiveNormalCleanup; bool useArrayEHCleanup = CGF.needsEHCleanup(dtorKind); if (useArrayEHCleanup) cleanupKind = InactiveNormalAndEHCleanup; CGF.pushDestroy(cleanupKind, addr, variable->getType(), destroyer, useArrayEHCleanup); // Remember where that cleanup was. capture.setCleanup(CGF.EHStack.stable_begin()); } } /// Enter a full-expression with a non-trivial number of objects to /// clean up. This is in this file because, at the moment, the only /// kind of cleanup object is a BlockDecl*. void CodeGenFunction::enterNonTrivialFullExpression(const ExprWithCleanups *E) { assert(E->getNumObjects() != 0); ArrayRef cleanups = E->getObjects(); for (ArrayRef::iterator i = cleanups.begin(), e = cleanups.end(); i != e; ++i) { enterBlockScope(*this, *i); } } /// Find the layout for the given block in a linked list and remove it. static CGBlockInfo *findAndRemoveBlockInfo(CGBlockInfo **head, const BlockDecl *block) { while (true) { assert(head && *head); CGBlockInfo *cur = *head; // If this is the block we're looking for, splice it out of the list. if (cur->getBlockDecl() == block) { *head = cur->NextBlockInfo; return cur; } head = &cur->NextBlockInfo; } } /// Destroy a chain of block layouts. void CodeGenFunction::destroyBlockInfos(CGBlockInfo *head) { assert(head && "destroying an empty chain"); do { CGBlockInfo *cur = head; head = cur->NextBlockInfo; delete cur; } while (head != nullptr); } /// Emit a block literal expression in the current function. llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) { // If the block has no captures, we won't have a pre-computed // layout for it. if (!blockExpr->getBlockDecl()->hasCaptures()) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName()); computeBlockInfo(CGM, this, blockInfo); blockInfo.BlockExpression = blockExpr; return EmitBlockLiteral(blockInfo); } // Find the block info for this block and take ownership of it. std::unique_ptr blockInfo; blockInfo.reset(findAndRemoveBlockInfo(&FirstBlockInfo, blockExpr->getBlockDecl())); blockInfo->BlockExpression = blockExpr; return EmitBlockLiteral(*blockInfo); } llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) { // Using the computed layout, generate the actual block function. bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda(); llvm::Constant *blockFn = CodeGenFunction(CGM, true).GenerateBlockFunction(CurGD, blockInfo, LocalDeclMap, isLambdaConv); blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); // If there is nothing to capture, we can emit this as a global block. if (blockInfo.CanBeGlobal) return buildGlobalBlock(CGM, blockInfo, blockFn); // Otherwise, we have to emit this as a local block. llvm::Constant *isa = CGM.getNSConcreteStackBlock(); isa = llvm::ConstantExpr::getBitCast(isa, VoidPtrTy); // Build the block descriptor. llvm::Constant *descriptor = buildBlockDescriptor(CGM, blockInfo); llvm::AllocaInst *blockAddr = blockInfo.Address; assert(blockAddr && "block has no address!"); // Compute the initial on-stack block flags. BlockFlags flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; // Initialize the block literal. Builder.CreateStore(isa, Builder.CreateStructGEP(blockAddr, 0, "block.isa")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(blockAddr, 1, "block.flags")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, 0), Builder.CreateStructGEP(blockAddr, 2, "block.reserved")); Builder.CreateStore(blockFn, Builder.CreateStructGEP(blockAddr, 3, "block.invoke")); Builder.CreateStore(descriptor, Builder.CreateStructGEP(blockAddr, 4, "block.descriptor")); // Finally, capture all the values into the block. const BlockDecl *blockDecl = blockInfo.getBlockDecl(); // First, 'this'. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(blockAddr, blockInfo.CXXThisIndex, "block.captured-this.addr"); Builder.CreateStore(LoadCXXThis(), addr); } // Next, captured variables. for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); // Ignore constant captures. if (capture.isConstant()) continue; QualType type = variable->getType(); CharUnits align = getContext().getDeclAlign(variable); // This will be a [[type]]*, except that a byref entry will just be // an i8**. llvm::Value *blockField = Builder.CreateStructGEP(blockAddr, capture.getIndex(), "block.captured"); // Compute the address of the thing we're going to move into the // block literal. llvm::Value *src; if (BlockInfo && CI.isNested()) { // We need to use the capture from the enclosing block. const CGBlockInfo::Capture &enclosingCapture = BlockInfo->getCapture(variable); // This is a [[type]]*, except that a byref entry wil just be an i8**. src = Builder.CreateStructGEP(LoadBlockStruct(), enclosingCapture.getIndex(), "block.capture.addr"); } else if (blockDecl->isConversionFromLambda()) { // The lambda capture in a lambda's conversion-to-block-pointer is // special; we'll simply emit it directly. src = nullptr; } else { // Just look it up in the locals map, which will give us back a // [[type]]*. If that doesn't work, do the more elaborate DRE // emission. src = LocalDeclMap.lookup(variable); if (!src) { DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ CI.isNested(), type, VK_LValue, SourceLocation()); src = EmitDeclRefLValue(&declRef).getAddress(); } } // For byrefs, we just write the pointer to the byref struct into // the block field. There's no need to chase the forwarding // pointer at this point, since we're building something that will // live a shorter life than the stack byref anyway. if (CI.isByRef()) { // Get a void* that points to the byref struct. if (CI.isNested()) src = Builder.CreateAlignedLoad(src, align.getQuantity(), "byref.capture"); else src = Builder.CreateBitCast(src, VoidPtrTy); // Write that void* into the capture field. Builder.CreateAlignedStore(src, blockField, align.getQuantity()); // If we have a copy constructor, evaluate that into the block field. } else if (const Expr *copyExpr = CI.getCopyExpr()) { if (blockDecl->isConversionFromLambda()) { // If we have a lambda conversion, emit the expression // directly into the block instead. AggValueSlot Slot = AggValueSlot::forAddr(blockField, align, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); EmitAggExpr(copyExpr, Slot); } else { EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr); } // If it's a reference variable, copy the reference into the block field. } else if (type->isReferenceType()) { llvm::Value *ref = Builder.CreateAlignedLoad(src, align.getQuantity(), "ref.val"); Builder.CreateAlignedStore(ref, blockField, align.getQuantity()); // If this is an ARC __strong block-pointer variable, don't do a // block copy. // // TODO: this can be generalized into the normal initialization logic: // we should never need to do a block-copy when initializing a local // variable, because the local variable's lifetime should be strictly // contained within the stack block's. } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong && type->isBlockPointerType()) { // Load the block and do a simple retain. LValue srcLV = MakeAddrLValue(src, type, align); llvm::Value *value = EmitLoadOfScalar(srcLV, SourceLocation()); value = EmitARCRetainNonBlock(value); // Do a primitive store to the block field. LValue destLV = MakeAddrLValue(blockField, type, align); EmitStoreOfScalar(value, destLV, /*init*/ true); // Otherwise, fake up a POD copy into the block field. } else { // Fake up a new variable so that EmitScalarInit doesn't think // we're referring to the variable in its own initializer. ImplicitParamDecl blockFieldPseudoVar(getContext(), /*DC*/ nullptr, SourceLocation(), /*name*/ nullptr, type); // We use one of these or the other depending on whether the // reference is nested. DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ CI.isNested(), type, VK_LValue, SourceLocation()); ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue, &declRef, VK_RValue); EmitExprAsInit(&l2r, &blockFieldPseudoVar, MakeAddrLValue(blockField, type, align), /*captured by init*/ false); } // Activate the cleanup if layout pushed one. if (!CI.isByRef()) { EHScopeStack::stable_iterator cleanup = capture.getCleanup(); if (cleanup.isValid()) ActivateCleanupBlock(cleanup, blockInfo.DominatingIP); } } // Cast to the converted block-pointer type, which happens (somewhat // unfortunately) to be a pointer to function type. llvm::Value *result = Builder.CreateBitCast(blockAddr, ConvertType(blockInfo.getBlockExpr()->getType())); return result; } llvm::Type *CodeGenModule::getBlockDescriptorType() { if (BlockDescriptorType) return BlockDescriptorType; llvm::Type *UnsignedLongTy = getTypes().ConvertType(getContext().UnsignedLongTy); // struct __block_descriptor { // unsigned long reserved; // unsigned long block_size; // // // later, the following will be added // // struct { // void (*copyHelper)(); // void (*copyHelper)(); // } helpers; // !!! optional // // const char *signature; // the block signature // const char *layout; // reserved // }; BlockDescriptorType = llvm::StructType::create("struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy, NULL); // Now form a pointer to that. BlockDescriptorType = llvm::PointerType::getUnqual(BlockDescriptorType); return BlockDescriptorType; } llvm::Type *CodeGenModule::getGenericBlockLiteralType() { if (GenericBlockLiteralType) return GenericBlockLiteralType; llvm::Type *BlockDescPtrTy = getBlockDescriptorType(); // struct __block_literal_generic { // void *__isa; // int __flags; // int __reserved; // void (*__invoke)(void *); // struct __block_descriptor *__descriptor; // }; GenericBlockLiteralType = llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy, IntTy, IntTy, VoidPtrTy, BlockDescPtrTy, NULL); return GenericBlockLiteralType; } RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue) { const BlockPointerType *BPT = E->getCallee()->getType()->getAs(); llvm::Value *Callee = EmitScalarExpr(E->getCallee()); // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::getUnqual(CGM.getGenericBlockLiteralType()); // Bitcast the callee to a block literal. llvm::Value *BlockLiteral = Builder.CreateBitCast(Callee, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. llvm::Value *FuncPtr = Builder.CreateStructGEP(BlockLiteral, 3); BlockLiteral = Builder.CreateBitCast(BlockLiteral, VoidPtrTy); // Add the block literal. CallArgList Args; Args.add(RValue::get(BlockLiteral), getContext().VoidPtrTy); QualType FnType = BPT->getPointeeType(); // And the rest of the arguments. EmitCallArgs(Args, FnType->getAs(), E->arg_begin(), E->arg_end()); // Load the function. llvm::Value *Func = Builder.CreateLoad(FuncPtr); const FunctionType *FuncTy = FnType->castAs(); const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy); // Cast the function pointer to the right type. llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo); llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy); Func = Builder.CreateBitCast(Func, BlockFTyPtr); // And call the block. return EmitCall(FnInfo, Func, ReturnValue, Args); } llvm::Value *CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable, bool isByRef) { assert(BlockInfo && "evaluating block ref without block information?"); const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable); // Handle constant captures. if (capture.isConstant()) return LocalDeclMap[variable]; llvm::Value *addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(), "block.capture.addr"); if (isByRef) { // addr should be a void** right now. Load, then cast the result // to byref*. addr = Builder.CreateLoad(addr); llvm::PointerType *byrefPointerType = llvm::PointerType::get(BuildByRefType(variable), 0); addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr"); // Follow the forwarding pointer. addr = Builder.CreateStructGEP(addr, 1, "byref.forwarding"); addr = Builder.CreateLoad(addr, "byref.addr.forwarded"); // Cast back to byref* and GEP over to the actual object. addr = Builder.CreateBitCast(addr, byrefPointerType); addr = Builder.CreateStructGEP(addr, getByRefValueLLVMField(variable), variable->getNameAsString()); } if (variable->getType()->isReferenceType()) addr = Builder.CreateLoad(addr, "ref.tmp"); return addr; } llvm::Constant * CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *blockExpr, const char *name) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), name); blockInfo.BlockExpression = blockExpr; // Compute information about the layout, etc., of this block. computeBlockInfo(*this, nullptr, blockInfo); // Using that metadata, generate the actual block function. llvm::Constant *blockFn; { llvm::DenseMap LocalDeclMap; blockFn = CodeGenFunction(*this).GenerateBlockFunction(GlobalDecl(), blockInfo, LocalDeclMap, false); } blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); return buildGlobalBlock(*this, blockInfo, blockFn); } static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn) { assert(blockInfo.CanBeGlobal); // Generate the constants for the block literal initializer. llvm::Constant *fields[BlockHeaderSize]; // isa fields[0] = CGM.getNSConcreteGlobalBlock(); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields[1] = llvm::ConstantInt::get(CGM.IntTy, flags.getBitMask()); // Reserved fields[2] = llvm::Constant::getNullValue(CGM.IntTy); // Function fields[3] = blockFn; // Descriptor fields[4] = buildBlockDescriptor(CGM, blockInfo); llvm::Constant *init = llvm::ConstantStruct::getAnon(fields); llvm::GlobalVariable *literal = new llvm::GlobalVariable(CGM.getModule(), init->getType(), /*constant*/ true, llvm::GlobalVariable::InternalLinkage, init, "__block_literal_global"); literal->setAlignment(blockInfo.BlockAlign.getQuantity()); // Return a constant of the appropriately-casted type. llvm::Type *requiredType = CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType()); return llvm::ConstantExpr::getBitCast(literal, requiredType); } llvm::Function * CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &blockInfo, const DeclMapTy &ldm, bool IsLambdaConversionToBlock) { const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CurGD = GD; BlockInfo = &blockInfo; // Arrange for local static and local extern declarations to appear // to be local to this function as well, in case they're directly // referenced in a block. for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) { const auto *var = dyn_cast(i->first); if (var && !var->hasLocalStorage()) LocalDeclMap[var] = i->second; } // Begin building the function declaration. // Build the argument list. FunctionArgList args; // The first argument is the block pointer. Just take it as a void* // and cast it later. QualType selfTy = getContext().VoidPtrTy; IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor"); ImplicitParamDecl selfDecl(getContext(), const_cast(blockDecl), SourceLocation(), II, selfTy); args.push_back(&selfDecl); // Now add the rest of the parameters. for (auto i : blockDecl->params()) args.push_back(i); // Create the function declaration. const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType(); const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeFreeFunctionDeclaration( fnType->getReturnType(), args, fnType->getExtInfo(), fnType->isVariadic()); if (CGM.ReturnSlotInterferesWithArgs(fnInfo)) blockInfo.UsesStret = true; llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo); StringRef name = CGM.getBlockMangledName(GD, blockDecl); llvm::Function *fn = llvm::Function::Create( fnLLVMType, llvm::GlobalValue::InternalLinkage, name, &CGM.getModule()); CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo); // Begin generating the function. StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args, blockDecl->getLocation(), blockInfo.getBlockExpr()->getBody()->getLocStart()); // Okay. Undo some of what StartFunction did. // Pull the 'self' reference out of the local decl map. llvm::Value *blockAddr = LocalDeclMap[&selfDecl]; LocalDeclMap.erase(&selfDecl); BlockPointer = Builder.CreateBitCast(blockAddr, blockInfo.StructureType->getPointerTo(), "block"); // At -O0 we generate an explicit alloca for the BlockPointer, so the RA // won't delete the dbg.declare intrinsics for captured variables. llvm::Value *BlockPointerDbgLoc = BlockPointer; if (CGM.getCodeGenOpts().OptimizationLevel == 0) { // Allocate a stack slot for it, so we can point the debugger to it llvm::AllocaInst *Alloca = CreateTempAlloca(BlockPointer->getType(), "block.addr"); unsigned Align = getContext().getDeclAlign(&selfDecl).getQuantity(); Alloca->setAlignment(Align); // Set the DebugLocation to empty, so the store is recognized as a // frame setup instruction by llvm::DwarfDebug::beginFunction(). NoLocation NL(*this, Builder); Builder.CreateAlignedStore(BlockPointer, Alloca, Align); BlockPointerDbgLoc = Alloca; } // If we have a C++ 'this' reference, go ahead and force it into // existence now. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(BlockPointer, blockInfo.CXXThisIndex, "block.captured-this"); CXXThisValue = Builder.CreateLoad(addr, "this"); } // Also force all the constant captures. for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (!capture.isConstant()) continue; unsigned align = getContext().getDeclAlign(variable).getQuantity(); llvm::AllocaInst *alloca = CreateMemTemp(variable->getType(), "block.captured-const"); alloca->setAlignment(align); Builder.CreateAlignedStore(capture.getConstant(), alloca, align); LocalDeclMap[variable] = alloca; } // Save a spot to insert the debug information for all the DeclRefExprs. llvm::BasicBlock *entry = Builder.GetInsertBlock(); llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint(); --entry_ptr; if (IsLambdaConversionToBlock) EmitLambdaBlockInvokeBody(); else { PGO.assignRegionCounters(blockDecl, fn); RegionCounter Cnt = getPGORegionCounter(blockDecl->getBody()); Cnt.beginRegion(Builder); EmitStmt(blockDecl->getBody()); PGO.emitInstrumentationData(); PGO.destroyRegionCounters(); } // Remember where we were... llvm::BasicBlock *resume = Builder.GetInsertBlock(); // Go back to the entry. ++entry_ptr; Builder.SetInsertPoint(entry, entry_ptr); // Emit debug information for all the DeclRefExprs. // FIXME: also for 'this' if (CGDebugInfo *DI = getDebugInfo()) { for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); DI->EmitLocation(Builder, variable->getLocation()); if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) { DI->EmitDeclareOfAutoVariable(variable, LocalDeclMap[variable], Builder); continue; } DI->EmitDeclareOfBlockDeclRefVariable(variable, BlockPointerDbgLoc, Builder, blockInfo); } } // Recover location if it was changed in the above loop. DI->EmitLocation(Builder, cast(blockDecl->getBody())->getRBracLoc()); } // And resume where we left off. if (resume == nullptr) Builder.ClearInsertionPoint(); else Builder.SetInsertPoint(resume); FinishFunction(cast(blockDecl->getBody())->getRBracLoc()); return fn; } /* notes.push_back(HelperInfo()); HelperInfo ¬e = notes.back(); note.index = capture.getIndex(); note.RequiresCopying = (ci->hasCopyExpr() || BlockRequiresCopying(type)); note.cxxbar_import = ci->getCopyExpr(); if (ci->isByRef()) { note.flag = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) note.flag |= BLOCK_FIELD_IS_WEAK; } else if (type->isBlockPointerType()) { note.flag = BLOCK_FIELD_IS_BLOCK; } else { note.flag = BLOCK_FIELD_IS_OBJECT; } */ /// Generate the copy-helper function for a block closure object: /// static void block_copy_helper(block_t *dst, block_t *src); /// The runtime will have previously initialized 'dst' by doing a /// bit-copy of 'src'. /// /// Note that this copies an entire block closure object to the heap; /// it should not be confused with a 'byref copy helper', which moves /// the contents of an individual __block variable to the heap. llvm::Constant * CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl dstDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); args.push_back(&dstDecl); ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); // FIXME: it would be nice if these were mergeable with things with // identical semantics. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__copy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__copy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, nullptr, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block.source"); llvm::Value *dst = GetAddrOfLocalVar(&dstDecl); dst = Builder.CreateLoad(dst); dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; const Expr *copyExpr = CI.getCopyExpr(); BlockFieldFlags flags; bool useARCWeakCopy = false; bool useARCStrongCopy = false; if (copyExpr) { assert(!CI.isByRef()); // don't bother computing flags } else if (CI.isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; bool isBlockPointer = type->isBlockPointerType(); if (isBlockPointer) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures: if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // We need to register __weak direct captures with the runtime. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) { useARCWeakCopy = true; // We need to retain the copied value for __strong direct captures. } else if (qs.getObjCLifetime() == Qualifiers::OCL_Strong) { // If it's a block pointer, we have to copy the block and // assign that to the destination pointer, so we might as // well use _Block_object_assign. Otherwise we can avoid that. if (!isBlockPointer) useARCStrongCopy = true; // Otherwise the memcpy is fine. } else { continue; } // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. } else { // fall through } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); llvm::Value *dstField = Builder.CreateStructGEP(dst, index); // If there's an explicit copy expression, we do that. if (copyExpr) { EmitSynthesizedCXXCopyCtor(dstField, srcField, copyExpr); } else if (useARCWeakCopy) { EmitARCCopyWeak(dstField, srcField); } else { llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src"); if (useARCStrongCopy) { // At -O0, store null into the destination field (so that the // storeStrong doesn't over-release) and then call storeStrong. // This is a workaround to not having an initStrong call. if (CGM.getCodeGenOpts().OptimizationLevel == 0) { auto *ty = cast(srcValue->getType()); llvm::Value *null = llvm::ConstantPointerNull::get(ty); Builder.CreateStore(null, dstField); EmitARCStoreStrongCall(dstField, srcValue, true); // With optimization enabled, take advantage of the fact that // the blocks runtime guarantees a memcpy of the block data, and // just emit a retain of the src field. } else { EmitARCRetainNonBlock(srcValue); // We don't need this anymore, so kill it. It's not quite // worth the annoyance to avoid creating it in the first place. cast(dstField)->eraseFromParent(); } } else { srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy); llvm::Value *dstAddr = Builder.CreateBitCast(dstField, VoidPtrTy); llvm::Value *args[] = { dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; bool copyCanThrow = false; if (CI.isByRef() && variable->getType()->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(variable); if (copyExpr) { copyCanThrow = true; // FIXME: reuse the noexcept logic } } if (copyCanThrow) { EmitRuntimeCallOrInvoke(CGM.getBlockObjectAssign(), args); } else { EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args); } } } } FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } /// Generate the destroy-helper function for a block closure object: /// static void block_destroy_helper(block_t *theBlock); /// /// Note that this destroys a heap-allocated block closure object; /// it should not be confused with a 'byref destroy helper', which /// destroys the heap-allocated contents of an individual __block /// variable. llvm::Constant * CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl srcDecl(getContext(), nullptr, SourceLocation(), nullptr, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__destroy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__destroy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, nullptr, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CodeGenFunction::RunCleanupsScope cleanups(*this); for (const auto &CI : blockDecl->captures()) { const VarDecl *variable = CI.getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; BlockFieldFlags flags; const CXXDestructorDecl *dtor = nullptr; bool useARCWeakDestroy = false; bool useARCStrongDestroy = false; if (CI.isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { if (record->hasTrivialDestructor()) continue; dtor = record->getDestructor(); } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; if (type->isBlockPointerType()) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures. if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // Don't generate special dispose logic for a captured object // unless it's __strong or __weak. if (!qs.hasStrongOrWeakObjCLifetime()) continue; // Support __weak direct captures. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) useARCWeakDestroy = true; // Tools really want us to use objc_storeStrong here. else useARCStrongDestroy = true; } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); // If there's an explicit copy expression, we do that. if (dtor) { PushDestructorCleanup(dtor, srcField); // If this is a __weak capture, emit the release directly. } else if (useARCWeakDestroy) { EmitARCDestroyWeak(srcField); // Destroy strong objects with a call if requested. } else if (useARCStrongDestroy) { EmitARCDestroyStrong(srcField, ARCImpreciseLifetime); // Otherwise we call _Block_object_dispose. It wouldn't be too // hard to just emit this as a cleanup if we wanted to make sure // that things were done in reverse. } else { llvm::Value *value = Builder.CreateLoad(srcField); value = Builder.CreateBitCast(value, VoidPtrTy); BuildBlockRelease(value, flags); } } cleanups.ForceCleanup(); FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } namespace { /// Emits the copy/dispose helper functions for a __block object of id type. class ObjectByrefHelpers : public CodeGenModule::ByrefHelpers { BlockFieldFlags Flags; public: ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags) : ByrefHelpers(alignment), Flags(flags) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) override { destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy); srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy); llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField); unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask(); llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags); llvm::Value *fn = CGF.CGM.getBlockObjectAssign(); llvm::Value *args[] = { destField, srcValue, flagsVal }; CGF.EmitNounwindRuntimeCall(fn, args); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0)); llvm::Value *value = CGF.Builder.CreateLoad(field); CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER); } void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddInteger(Flags.getBitMask()); } }; /// Emits the copy/dispose helpers for an ARC __block __weak variable. class ARCWeakByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCWeakByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) override { CGF.EmitARCMoveWeak(destField, srcField); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyWeak(field); } void profileImpl(llvm::FoldingSetNodeID &id) const override { // 0 is distinguishable from all pointers and byref flags id.AddInteger(0); } }; /// Emits the copy/dispose helpers for an ARC __block __strong variable /// that's not of block-pointer type. class ARCStrongByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) override { // Do a "move" by copying the value and then zeroing out the old // variable. llvm::LoadInst *value = CGF.Builder.CreateLoad(srcField); value->setAlignment(Alignment.getQuantity()); llvm::Value *null = llvm::ConstantPointerNull::get(cast(value->getType())); if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) { llvm::StoreInst *store = CGF.Builder.CreateStore(null, destField); store->setAlignment(Alignment.getQuantity()); CGF.EmitARCStoreStrongCall(destField, value, /*ignored*/ true); CGF.EmitARCStoreStrongCall(srcField, null, /*ignored*/ true); return; } llvm::StoreInst *store = CGF.Builder.CreateStore(value, destField); store->setAlignment(Alignment.getQuantity()); store = CGF.Builder.CreateStore(null, srcField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const override { // 1 is distinguishable from all pointers and byref flags id.AddInteger(1); } }; /// Emits the copy/dispose helpers for an ARC __block __strong /// variable that's of block-pointer type. class ARCStrongBlockByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongBlockByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) override { // Do the copy with objc_retainBlock; that's all that // _Block_object_assign would do anyway, and we'd have to pass the // right arguments to make sure it doesn't get no-op'ed. llvm::LoadInst *oldValue = CGF.Builder.CreateLoad(srcField); oldValue->setAlignment(Alignment.getQuantity()); llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true); llvm::StoreInst *store = CGF.Builder.CreateStore(copy, destField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const override { // 2 is distinguishable from all pointers and byref flags id.AddInteger(2); } }; /// Emits the copy/dispose helpers for a __block variable with a /// nontrivial copy constructor or destructor. class CXXByrefHelpers : public CodeGenModule::ByrefHelpers { QualType VarType; const Expr *CopyExpr; public: CXXByrefHelpers(CharUnits alignment, QualType type, const Expr *copyExpr) : ByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} bool needsCopy() const override { return CopyExpr != nullptr; } void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) override { if (!CopyExpr) return; CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) override { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.PushDestructorCleanup(VarType, field); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const override { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; } // end anonymous namespace static llvm::Constant * generateByrefCopyHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned valueFieldIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl dst(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); args.push_back(&dst); ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_copy_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_copy_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, nullptr, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args); if (byrefInfo.needsCopy()) { llvm::Type *byrefPtrType = byrefType.getPointerTo(0); // dst->x llvm::Value *destField = CGF.GetAddrOfLocalVar(&dst); destField = CGF.Builder.CreateLoad(destField); destField = CGF.Builder.CreateBitCast(destField, byrefPtrType); destField = CGF.Builder.CreateStructGEP(destField, valueFieldIndex, "x"); // src->x llvm::Value *srcField = CGF.GetAddrOfLocalVar(&src); srcField = CGF.Builder.CreateLoad(srcField); srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType); srcField = CGF.Builder.CreateStructGEP(srcField, valueFieldIndex, "x"); byrefInfo.emitCopy(CGF, destField, srcField); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the copy helper for a __block variable. static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefCopyHelper(CGF, byrefType, byrefValueIndex, info); } /// Generate code for a __block variable's dispose helper. static llvm::Constant * generateByrefDisposeHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl src(CGF.getContext(), nullptr, SourceLocation(), nullptr, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_dispose_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_dispose_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, nullptr, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args); if (byrefInfo.needsDispose()) { llvm::Value *V = CGF.GetAddrOfLocalVar(&src); V = CGF.Builder.CreateLoad(V); V = CGF.Builder.CreateBitCast(V, byrefType.getPointerTo(0)); V = CGF.Builder.CreateStructGEP(V, byrefValueIndex, "x"); byrefInfo.emitDispose(CGF, V); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the dispose helper for a __block variable. static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefDisposeHelper(CGF, byrefType, byrefValueIndex, info); } /// Lazily build the copy and dispose helpers for a __block variable /// with the given information. template static T *buildByrefHelpers(CodeGenModule &CGM, llvm::StructType &byrefTy, unsigned byrefValueIndex, T &byrefInfo) { // Increase the field's alignment to be at least pointer alignment, // since the layout of the byref struct will guarantee at least that. byrefInfo.Alignment = std::max(byrefInfo.Alignment, CharUnits::fromQuantity(CGM.PointerAlignInBytes)); llvm::FoldingSetNodeID id; byrefInfo.Profile(id); void *insertPos; CodeGenModule::ByrefHelpers *node = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos); if (node) return static_cast(node); byrefInfo.CopyHelper = buildByrefCopyHelper(CGM, byrefTy, byrefValueIndex, byrefInfo); byrefInfo.DisposeHelper = buildByrefDisposeHelper(CGM, byrefTy, byrefValueIndex,byrefInfo); T *copy = new (CGM.getContext()) T(byrefInfo); CGM.ByrefHelpersCache.InsertNode(copy, insertPos); return copy; } /// Build the copy and dispose helpers for the given __block variable /// emission. Places the helpers in the global cache. Returns null /// if no helpers are required. CodeGenModule::ByrefHelpers * CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType, const AutoVarEmission &emission) { const VarDecl &var = *emission.Variable; QualType type = var.getType(); unsigned byrefValueIndex = getByRefValueLLVMField(&var); if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(&var); if (!copyExpr && record->hasTrivialDestructor()) return nullptr; CXXByrefHelpers byrefInfo(emission.Alignment, type, copyExpr); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // Otherwise, if we don't have a retainable type, there's nothing to do. // that the runtime does extra copies. if (!type->isObjCRetainableType()) return nullptr; Qualifiers qs = type.getQualifiers(); // If we have lifetime, that dominates. if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) { assert(getLangOpts().ObjCAutoRefCount); switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); // These are just bits as far as the runtime is concerned. case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: return nullptr; // Tell the runtime that this is ARC __weak, called by the // byref routines. case Qualifiers::OCL_Weak: { ARCWeakByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // ARC __strong __block variables need to be retained. case Qualifiers::OCL_Strong: // Block pointers need to be copied, and there's no direct // transfer possible. if (type->isBlockPointerType()) { ARCStrongBlockByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); // Otherwise, we transfer ownership of the retain from the stack // to the heap. } else { ARCStrongByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } } llvm_unreachable("fell out of lifetime switch!"); } BlockFieldFlags flags; if (type->isBlockPointerType()) { flags |= BLOCK_FIELD_IS_BLOCK; } else if (CGM.getContext().isObjCNSObjectType(type) || type->isObjCObjectPointerType()) { flags |= BLOCK_FIELD_IS_OBJECT; } else { return nullptr; } if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; ObjectByrefHelpers byrefInfo(emission.Alignment, flags); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } unsigned CodeGenFunction::getByRefValueLLVMField(const ValueDecl *VD) const { assert(ByRefValueInfo.count(VD) && "Did not find value!"); return ByRefValueInfo.find(VD)->second.second; } llvm::Value *CodeGenFunction::BuildBlockByrefAddress(llvm::Value *BaseAddr, const VarDecl *V) { llvm::Value *Loc = Builder.CreateStructGEP(BaseAddr, 1, "forwarding"); Loc = Builder.CreateLoad(Loc); Loc = Builder.CreateStructGEP(Loc, getByRefValueLLVMField(V), V->getNameAsString()); return Loc; } /// BuildByRefType - This routine changes a __block variable declared as T x /// into: /// /// struct { /// void *__isa; /// void *__forwarding; /// int32_t __flags; /// int32_t __size; /// void *__copy_helper; // only if needed /// void *__destroy_helper; // only if needed /// void *__byref_variable_layout;// only if needed /// char padding[X]; // only if needed /// T x; /// } x /// llvm::Type *CodeGenFunction::BuildByRefType(const VarDecl *D) { std::pair &Info = ByRefValueInfo[D]; if (Info.first) return Info.first; QualType Ty = D->getType(); SmallVector types; llvm::StructType *ByRefType = llvm::StructType::create(getLLVMContext(), "struct.__block_byref_" + D->getNameAsString()); // void *__isa; types.push_back(Int8PtrTy); // void *__forwarding; types.push_back(llvm::PointerType::getUnqual(ByRefType)); // int32_t __flags; types.push_back(Int32Ty); // int32_t __size; types.push_back(Int32Ty); // Note that this must match *exactly* the logic in buildByrefHelpers. bool HasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D); if (HasCopyAndDispose) { /// void *__copy_helper; types.push_back(Int8PtrTy); /// void *__destroy_helper; types.push_back(Int8PtrTy); } bool HasByrefExtendedLayout = false; Qualifiers::ObjCLifetime Lifetime; if (getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) && HasByrefExtendedLayout) /// void *__byref_variable_layout; types.push_back(Int8PtrTy); bool Packed = false; CharUnits Align = getContext().getDeclAlign(D); if (Align > getContext().toCharUnitsFromBits(getTarget().getPointerAlign(0))) { // We have to insert padding. // The struct above has 2 32-bit integers. unsigned CurrentOffsetInBytes = 4 * 2; // And either 2, 3, 4 or 5 pointers. unsigned noPointers = 2; if (HasCopyAndDispose) noPointers += 2; if (HasByrefExtendedLayout) noPointers += 1; CurrentOffsetInBytes += noPointers * CGM.getDataLayout().getTypeAllocSize(Int8PtrTy); // Align the offset. unsigned AlignedOffsetInBytes = llvm::RoundUpToAlignment(CurrentOffsetInBytes, Align.getQuantity()); unsigned NumPaddingBytes = AlignedOffsetInBytes - CurrentOffsetInBytes; if (NumPaddingBytes > 0) { llvm::Type *Ty = Int8Ty; // FIXME: We need a sema error for alignment larger than the minimum of // the maximal stack alignment and the alignment of malloc on the system. if (NumPaddingBytes > 1) Ty = llvm::ArrayType::get(Ty, NumPaddingBytes); types.push_back(Ty); // We want a packed struct. Packed = true; } } // T x; types.push_back(ConvertTypeForMem(Ty)); ByRefType->setBody(types, Packed); Info.first = ByRefType; Info.second = types.size() - 1; return Info.first; } /// Initialize the structural components of a __block variable, i.e. /// everything but the actual object. void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) { // Find the address of the local. llvm::Value *addr = emission.Address; // That's an alloca of the byref structure type. llvm::StructType *byrefType = cast( cast(addr->getType())->getElementType()); // Build the byref helpers if necessary. This is null if we don't need any. CodeGenModule::ByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission); const VarDecl &D = *emission.Variable; QualType type = D.getType(); bool HasByrefExtendedLayout; Qualifiers::ObjCLifetime ByrefLifetime; bool ByRefHasLifetime = getContext().getByrefLifetime(type, ByrefLifetime, HasByrefExtendedLayout); llvm::Value *V; // Initialize the 'isa', which is just 0 or 1. int isa = 0; if (type.isObjCGCWeak()) isa = 1; V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa"); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 0, "byref.isa")); // Store the address of the variable into its own forwarding pointer. Builder.CreateStore(addr, Builder.CreateStructGEP(addr, 1, "byref.forwarding")); // Blocks ABI: // c) the flags field is set to either 0 if no helper functions are // needed or BLOCK_BYREF_HAS_COPY_DISPOSE if they are, BlockFlags flags; if (helpers) flags |= BLOCK_BYREF_HAS_COPY_DISPOSE; if (ByRefHasLifetime) { if (HasByrefExtendedLayout) flags |= BLOCK_BYREF_LAYOUT_EXTENDED; else switch (ByrefLifetime) { case Qualifiers::OCL_Strong: flags |= BLOCK_BYREF_LAYOUT_STRONG; break; case Qualifiers::OCL_Weak: flags |= BLOCK_BYREF_LAYOUT_WEAK; break; case Qualifiers::OCL_ExplicitNone: flags |= BLOCK_BYREF_LAYOUT_UNRETAINED; break; case Qualifiers::OCL_None: if (!type->isObjCObjectPointerType() && !type->isBlockPointerType()) flags |= BLOCK_BYREF_LAYOUT_NON_OBJECT; break; default: break; } if (CGM.getLangOpts().ObjCGCBitmapPrint) { printf("\n Inline flag for BYREF variable layout (%d):", flags.getBitMask()); if (flags & BLOCK_BYREF_HAS_COPY_DISPOSE) printf(" BLOCK_BYREF_HAS_COPY_DISPOSE"); if (flags & BLOCK_BYREF_LAYOUT_MASK) { BlockFlags ThisFlag(flags.getBitMask() & BLOCK_BYREF_LAYOUT_MASK); if (ThisFlag == BLOCK_BYREF_LAYOUT_EXTENDED) printf(" BLOCK_BYREF_LAYOUT_EXTENDED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_STRONG) printf(" BLOCK_BYREF_LAYOUT_STRONG"); if (ThisFlag == BLOCK_BYREF_LAYOUT_WEAK) printf(" BLOCK_BYREF_LAYOUT_WEAK"); if (ThisFlag == BLOCK_BYREF_LAYOUT_UNRETAINED) printf(" BLOCK_BYREF_LAYOUT_UNRETAINED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_NON_OBJECT) printf(" BLOCK_BYREF_LAYOUT_NON_OBJECT"); } printf("\n"); } } Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(addr, 2, "byref.flags")); CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType); V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity()); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 3, "byref.size")); if (helpers) { llvm::Value *copy_helper = Builder.CreateStructGEP(addr, 4); Builder.CreateStore(helpers->CopyHelper, copy_helper); llvm::Value *destroy_helper = Builder.CreateStructGEP(addr, 5); Builder.CreateStore(helpers->DisposeHelper, destroy_helper); } if (ByRefHasLifetime && HasByrefExtendedLayout) { llvm::Constant* ByrefLayoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type); llvm::Value *ByrefInfoAddr = Builder.CreateStructGEP(addr, helpers ? 6 : 4, "byref.layout"); // cast destination to pointer to source type. llvm::Type *DesTy = ByrefLayoutInfo->getType(); DesTy = DesTy->getPointerTo(); llvm::Value *BC = Builder.CreatePointerCast(ByrefInfoAddr, DesTy); Builder.CreateStore(ByrefLayoutInfo, BC); } } void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags) { llvm::Value *F = CGM.getBlockObjectDispose(); llvm::Value *args[] = { Builder.CreateBitCast(V, Int8PtrTy), llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; EmitNounwindRuntimeCall(F, args); // FIXME: throwing destructors? } namespace { struct CallBlockRelease : EHScopeStack::Cleanup { llvm::Value *Addr; CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {} void Emit(CodeGenFunction &CGF, Flags flags) override { // Should we be passing FIELD_IS_WEAK here? CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF); } }; } /// Enter a cleanup to destroy a __block variable. Note that this /// cleanup should be a no-op if the variable hasn't left the stack /// yet; if a cleanup is required for the variable itself, that needs /// to be done externally. void CodeGenFunction::enterByrefCleanup(const AutoVarEmission &emission) { // We don't enter this cleanup if we're in pure-GC mode. if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) return; EHStack.pushCleanup(NormalAndEHCleanup, emission.Address); } /// Adjust the declaration of something from the blocks API. static void configureBlocksRuntimeObject(CodeGenModule &CGM, llvm::Constant *C) { if (!CGM.getLangOpts().BlocksRuntimeOptional) return; auto *GV = cast(C->stripPointerCasts()); if (GV->isDeclaration() && GV->hasExternalLinkage()) GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); } llvm::Constant *CodeGenModule::getBlockObjectDispose() { if (BlockObjectDispose) return BlockObjectDispose; llvm::Type *args[] = { Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectDispose = CreateRuntimeFunction(fty, "_Block_object_dispose"); configureBlocksRuntimeObject(*this, BlockObjectDispose); return BlockObjectDispose; } llvm::Constant *CodeGenModule::getBlockObjectAssign() { if (BlockObjectAssign) return BlockObjectAssign; llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectAssign = CreateRuntimeFunction(fty, "_Block_object_assign"); configureBlocksRuntimeObject(*this, BlockObjectAssign); return BlockObjectAssign; } llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() { if (NSConcreteGlobalBlock) return NSConcreteGlobalBlock; NSConcreteGlobalBlock = GetOrCreateLLVMGlobal("_NSConcreteGlobalBlock", Int8PtrTy->getPointerTo(), nullptr); configureBlocksRuntimeObject(*this, NSConcreteGlobalBlock); return NSConcreteGlobalBlock; } llvm::Constant *CodeGenModule::getNSConcreteStackBlock() { if (NSConcreteStackBlock) return NSConcreteStackBlock; NSConcreteStackBlock = GetOrCreateLLVMGlobal("_NSConcreteStackBlock", Int8PtrTy->getPointerTo(), nullptr); configureBlocksRuntimeObject(*this, NSConcreteStackBlock); return NSConcreteStackBlock; } @ 1.1.1.3.4.1 log @file CGBlocks.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 2284 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 2284 //===--- CGBlocks.cpp - Emit LLVM Code for declarations -------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code to emit blocks. // //===----------------------------------------------------------------------===// #include "CGBlocks.h" #include "CGDebugInfo.h" #include "CGObjCRuntime.h" #include "CodeGenFunction.h" #include "CodeGenModule.h" #include "clang/AST/DeclObjC.h" #include "llvm/ADT/SmallSet.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Module.h" #include "llvm/Support/CallSite.h" #include #include using namespace clang; using namespace CodeGen; CGBlockInfo::CGBlockInfo(const BlockDecl *block, StringRef name) : Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false), HasCXXObject(false), UsesStret(false), HasCapturedVariableLayout(false), StructureType(0), Block(block), DominatingIP(0) { // Skip asm prefix, if any. 'name' is usually taken directly from // the mangled name of the enclosing function. if (!name.empty() && name[0] == '\01') name = name.substr(1); } // Anchor the vtable to this translation unit. CodeGenModule::ByrefHelpers::~ByrefHelpers() {} /// Build the given block as a global block. static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn); /// Build the helper function to copy a block. static llvm::Constant *buildCopyHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo); } /// Build the helper function to dispose of a block. static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo); } /// buildBlockDescriptor - Build the block descriptor meta-data for a block. /// buildBlockDescriptor is accessed from 5th field of the Block_literal /// meta-data and contains stationary information about the block literal. /// Its definition will have 4 (or optinally 6) words. /// \code /// struct Block_descriptor { /// unsigned long reserved; /// unsigned long size; // size of Block_literal metadata in bytes. /// void *copy_func_helper_decl; // optional copy helper. /// void *destroy_func_decl; // optioanl destructor helper. /// void *block_method_encoding_address; // @@encode for block literal signature. /// void *block_layout_info; // encoding of captured block variables. /// }; /// \endcode static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM, const CGBlockInfo &blockInfo) { ASTContext &C = CGM.getContext(); llvm::Type *ulong = CGM.getTypes().ConvertType(C.UnsignedLongTy); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); SmallVector elements; // reserved elements.push_back(llvm::ConstantInt::get(ulong, 0)); // Size // FIXME: What is the right way to say this doesn't fit? We should give // a user diagnostic in that case. Better fix would be to change the // API to size_t. elements.push_back(llvm::ConstantInt::get(ulong, blockInfo.BlockSize.getQuantity())); // Optional copy/dispose helpers. if (blockInfo.NeedsCopyDispose) { // copy_func_helper_decl elements.push_back(buildCopyHelper(CGM, blockInfo)); // destroy_func_decl elements.push_back(buildDisposeHelper(CGM, blockInfo)); } // Signature. Mandatory ObjC-style method descriptor @@encode sequence. std::string typeAtEncoding = CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr()); elements.push_back(llvm::ConstantExpr::getBitCast( CGM.GetAddrOfConstantCString(typeAtEncoding), i8p)); // GC layout. if (C.getLangOpts().ObjC1) { if (CGM.getLangOpts().getGC() != LangOptions::NonGC) elements.push_back(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo)); else elements.push_back(CGM.getObjCRuntime().BuildRCBlockLayout(CGM, blockInfo)); } else elements.push_back(llvm::Constant::getNullValue(i8p)); llvm::Constant *init = llvm::ConstantStruct::getAnon(elements); llvm::GlobalVariable *global = new llvm::GlobalVariable(CGM.getModule(), init->getType(), true, llvm::GlobalValue::InternalLinkage, init, "__block_descriptor_tmp"); return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType()); } /* Purely notional variadic template describing the layout of a block. template struct Block_literal { /// Initialized to one of: /// extern void *_NSConcreteStackBlock[]; /// extern void *_NSConcreteGlobalBlock[]; /// /// In theory, we could start one off malloc'ed by setting /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using /// this isa: /// extern void *_NSConcreteMallocBlock[]; struct objc_class *isa; /// These are the flags (with corresponding bit number) that the /// compiler is actually supposed to know about. /// 25. BLOCK_HAS_COPY_DISPOSE - indicates that the block /// descriptor provides copy and dispose helper functions /// 26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured /// object with a nontrivial destructor or copy constructor /// 28. BLOCK_IS_GLOBAL - indicates that the block is allocated /// as global memory /// 29. BLOCK_USE_STRET - indicates that the block function /// uses stret, which objc_msgSend needs to know about /// 30. BLOCK_HAS_SIGNATURE - indicates that the block has an /// @@encoded signature string /// And we're not supposed to manipulate these: /// 24. BLOCK_NEEDS_FREE - indicates that the block has been moved /// to malloc'ed memory /// 27. BLOCK_IS_GC - indicates that the block has been moved to /// to GC-allocated memory /// Additionally, the bottom 16 bits are a reference count which /// should be zero on the stack. int flags; /// Reserved; should be zero-initialized. int reserved; /// Function pointer generated from block literal. _ResultType (*invoke)(Block_literal *, _ParamTypes...); /// Block description metadata generated from block literal. struct Block_descriptor *block_descriptor; /// Captured values follow. _CapturesTypes captures...; }; */ /// The number of fields in a block header. const unsigned BlockHeaderSize = 5; namespace { /// A chunk of data that we actually have to capture in the block. struct BlockLayoutChunk { CharUnits Alignment; CharUnits Size; Qualifiers::ObjCLifetime Lifetime; const BlockDecl::Capture *Capture; // null for 'this' llvm::Type *Type; BlockLayoutChunk(CharUnits align, CharUnits size, Qualifiers::ObjCLifetime lifetime, const BlockDecl::Capture *capture, llvm::Type *type) : Alignment(align), Size(size), Lifetime(lifetime), Capture(capture), Type(type) {} /// Tell the block info that this chunk has the given field index. void setIndex(CGBlockInfo &info, unsigned index) { if (!Capture) info.CXXThisIndex = index; else info.Captures[Capture->getVariable()] = CGBlockInfo::Capture::makeIndex(index); } }; /// Order by 1) all __strong together 2) next, all byfref together 3) next, /// all __weak together. Preserve descending alignment in all situations. bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) { CharUnits LeftValue, RightValue; bool LeftByref = left.Capture ? left.Capture->isByRef() : false; bool RightByref = right.Capture ? right.Capture->isByRef() : false; if (left.Lifetime == Qualifiers::OCL_Strong && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(64); else if (LeftByref && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(32); else if (left.Lifetime == Qualifiers::OCL_Weak && left.Alignment >= right.Alignment) LeftValue = CharUnits::fromQuantity(16); else LeftValue = left.Alignment; if (right.Lifetime == Qualifiers::OCL_Strong && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(64); else if (RightByref && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(32); else if (right.Lifetime == Qualifiers::OCL_Weak && right.Alignment >= left.Alignment) RightValue = CharUnits::fromQuantity(16); else RightValue = right.Alignment; return LeftValue > RightValue; } } /// Determines if the given type is safe for constant capture in C++. static bool isSafeForCXXConstantCapture(QualType type) { const RecordType *recordType = type->getBaseElementTypeUnsafe()->getAs(); // Only records can be unsafe. if (!recordType) return true; const CXXRecordDecl *record = cast(recordType->getDecl()); // Maintain semantics for classes with non-trivial dtors or copy ctors. if (!record->hasTrivialDestructor()) return false; if (record->hasNonTrivialCopyConstructor()) return false; // Otherwise, we just have to make sure there aren't any mutable // fields that might have changed since initialization. return !record->hasMutableFields(); } /// It is illegal to modify a const object after initialization. /// Therefore, if a const object has a constant initializer, we don't /// actually need to keep storage for it in the block; we'll just /// rematerialize it at the start of the block function. This is /// acceptable because we make no promises about address stability of /// captured variables. static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM, CodeGenFunction *CGF, const VarDecl *var) { QualType type = var->getType(); // We can only do this if the variable is const. if (!type.isConstQualified()) return 0; // Furthermore, in C++ we have to worry about mutable fields: // C++ [dcl.type.cv]p4: // Except that any class member declared mutable can be // modified, any attempt to modify a const object during its // lifetime results in undefined behavior. if (CGM.getLangOpts().CPlusPlus && !isSafeForCXXConstantCapture(type)) return 0; // If the variable doesn't have any initializer (shouldn't this be // invalid?), it's not clear what we should do. Maybe capture as // zero? const Expr *init = var->getInit(); if (!init) return 0; return CGM.EmitConstantInit(*var, CGF); } /// Get the low bit of a nonzero character count. This is the /// alignment of the nth byte if the 0th byte is universally aligned. static CharUnits getLowBit(CharUnits v) { return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1)); } static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info, SmallVectorImpl &elementTypes) { ASTContext &C = CGM.getContext(); // The header is basically a 'struct { void *; int; int; void *; void *; }'. CharUnits ptrSize, ptrAlign, intSize, intAlign; llvm::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy); llvm::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy); // Are there crazy embedded platforms where this isn't true? assert(intSize <= ptrSize && "layout assumptions horribly violated"); CharUnits headerSize = ptrSize; if (2 * intSize < ptrAlign) headerSize += ptrSize; else headerSize += 2 * intSize; headerSize += 2 * ptrSize; info.BlockAlign = ptrAlign; info.BlockSize = headerSize; assert(elementTypes.empty()); llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy); llvm::Type *intTy = CGM.getTypes().ConvertType(C.IntTy); elementTypes.push_back(i8p); elementTypes.push_back(intTy); elementTypes.push_back(intTy); elementTypes.push_back(i8p); elementTypes.push_back(CGM.getBlockDescriptorType()); assert(elementTypes.size() == BlockHeaderSize); } /// Compute the layout of the given block. Attempts to lay the block /// out with minimal space requirements. static void computeBlockInfo(CodeGenModule &CGM, CodeGenFunction *CGF, CGBlockInfo &info) { ASTContext &C = CGM.getContext(); const BlockDecl *block = info.getBlockDecl(); SmallVector elementTypes; initializeForBlockHeader(CGM, info, elementTypes); if (!block->hasCaptures()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } else if (C.getLangOpts().ObjC1 && CGM.getLangOpts().getGC() == LangOptions::NonGC) info.HasCapturedVariableLayout = true; // Collect the layout chunks. SmallVector layout; layout.reserve(block->capturesCXXThis() + (block->capture_end() - block->capture_begin())); CharUnits maxFieldAlign; // First, 'this'. if (block->capturesCXXThis()) { assert(CGF && CGF->CurFuncDecl && isa(CGF->CurFuncDecl) && "Can't capture 'this' outside a method"); QualType thisType = cast(CGF->CurFuncDecl)->getThisType(C); llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType); std::pair tinfo = CGM.getContext().getTypeInfoInChars(thisType); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, 0, llvmType)); } // Next, all the block captures. for (BlockDecl::capture_const_iterator ci = block->capture_begin(), ce = block->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); if (ci->isByRef()) { // We have to copy/dispose of the __block reference. info.NeedsCopyDispose = true; // Just use void* instead of a pointer to the byref type. QualType byRefPtrTy = C.VoidPtrTy; llvm::Type *llvmType = CGM.getTypes().ConvertType(byRefPtrTy); std::pair tinfo = CGM.getContext().getTypeInfoInChars(byRefPtrTy); maxFieldAlign = std::max(maxFieldAlign, tinfo.second); layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, Qualifiers::OCL_None, &*ci, llvmType)); continue; } // Otherwise, build a layout chunk with the size and alignment of // the declaration. if (llvm::Constant *constant = tryCaptureAsConstant(CGM, CGF, variable)) { info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant); continue; } // If we have a lifetime qualifier, honor it for capture purposes. // That includes *not* copying it if it's __unsafe_unretained. Qualifiers::ObjCLifetime lifetime = variable->getType().getObjCLifetime(); if (lifetime) { switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: break; case Qualifiers::OCL_Strong: case Qualifiers::OCL_Weak: info.NeedsCopyDispose = true; } // Block pointers require copy/dispose. So do Objective-C pointers. } else if (variable->getType()->isObjCRetainableType()) { info.NeedsCopyDispose = true; // used for mrr below. lifetime = Qualifiers::OCL_Strong; // So do types that require non-trivial copy construction. } else if (ci->hasCopyExpr()) { info.NeedsCopyDispose = true; info.HasCXXObject = true; // And so do types with destructors. } else if (CGM.getLangOpts().CPlusPlus) { if (const CXXRecordDecl *record = variable->getType()->getAsCXXRecordDecl()) { if (!record->hasTrivialDestructor()) { info.HasCXXObject = true; info.NeedsCopyDispose = true; } } } QualType VT = variable->getType(); CharUnits size = C.getTypeSizeInChars(VT); CharUnits align = C.getDeclAlign(variable); maxFieldAlign = std::max(maxFieldAlign, align); llvm::Type *llvmType = CGM.getTypes().ConvertTypeForMem(VT); layout.push_back(BlockLayoutChunk(align, size, lifetime, &*ci, llvmType)); } // If that was everything, we're done here. if (layout.empty()) { info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); info.CanBeGlobal = true; return; } // Sort the layout by alignment. We have to use a stable sort here // to get reproducible results. There should probably be an // llvm::array_pod_stable_sort. std::stable_sort(layout.begin(), layout.end()); // Needed for blocks layout info. info.BlockHeaderForcedGapOffset = info.BlockSize; info.BlockHeaderForcedGapSize = CharUnits::Zero(); CharUnits &blockSize = info.BlockSize; info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign); // Assuming that the first byte in the header is maximally aligned, // get the alignment of the first byte following the header. CharUnits endAlign = getLowBit(blockSize); // If the end of the header isn't satisfactorily aligned for the // maximum thing, look for things that are okay with the header-end // alignment, and keep appending them until we get something that's // aligned right. This algorithm is only guaranteed optimal if // that condition is satisfied at some point; otherwise we can get // things like: // header // next byte has alignment 4 // something_with_size_5; // next byte has alignment 1 // something_with_alignment_8; // which has 7 bytes of padding, as opposed to the naive solution // which might have less (?). if (endAlign < maxFieldAlign) { SmallVectorImpl::iterator li = layout.begin() + 1, le = layout.end(); // Look for something that the header end is already // satisfactorily aligned for. for (; li != le && endAlign < li->Alignment; ++li) ; // If we found something that's naturally aligned for the end of // the header, keep adding things... if (li != le) { SmallVectorImpl::iterator first = li; for (; li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); // ...until we get to the alignment of the maximum field. if (endAlign >= maxFieldAlign) { if (li == first) { // No user field was appended. So, a gap was added. // Save total gap size for use in block layout bit map. info.BlockHeaderForcedGapSize = li->Size; } break; } } // Don't re-append everything we just appended. layout.erase(first, li); } } assert(endAlign == getLowBit(blockSize)); // At this point, we just have to add padding if the end align still // isn't aligned right. if (endAlign < maxFieldAlign) { CharUnits newBlockSize = blockSize.RoundUpToAlignment(maxFieldAlign); CharUnits padding = newBlockSize - blockSize; elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty, padding.getQuantity())); blockSize = newBlockSize; endAlign = getLowBit(blockSize); // might be > maxFieldAlign } assert(endAlign >= maxFieldAlign); assert(endAlign == getLowBit(blockSize)); // Slam everything else on now. This works because they have // strictly decreasing alignment and we expect that size is always a // multiple of alignment. for (SmallVectorImpl::iterator li = layout.begin(), le = layout.end(); li != le; ++li) { assert(endAlign >= li->Alignment); li->setIndex(info, elementTypes.size()); elementTypes.push_back(li->Type); blockSize += li->Size; endAlign = getLowBit(blockSize); } info.StructureType = llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true); } /// Enter the scope of a block. This should be run at the entrance to /// a full-expression so that the block's cleanups are pushed at the /// right place in the stack. static void enterBlockScope(CodeGenFunction &CGF, BlockDecl *block) { assert(CGF.HaveInsertPoint()); // Allocate the block info and place it at the head of the list. CGBlockInfo &blockInfo = *new CGBlockInfo(block, CGF.CurFn->getName()); blockInfo.NextBlockInfo = CGF.FirstBlockInfo; CGF.FirstBlockInfo = &blockInfo; // Compute information about the layout, etc., of this block, // pushing cleanups as necessary. computeBlockInfo(CGF.CGM, &CGF, blockInfo); // Nothing else to do if it can be global. if (blockInfo.CanBeGlobal) return; // Make the allocation for the block. blockInfo.Address = CGF.CreateTempAlloca(blockInfo.StructureType, "block"); blockInfo.Address->setAlignment(blockInfo.BlockAlign.getQuantity()); // If there are cleanups to emit, enter them (but inactive). if (!blockInfo.NeedsCopyDispose) return; // Walk through the captures (in order) and find the ones not // captured by constant. for (BlockDecl::capture_const_iterator ci = block->capture_begin(), ce = block->capture_end(); ci != ce; ++ci) { // Ignore __block captures; there's nothing special in the // on-stack block that we need to do for them. if (ci->isByRef()) continue; // Ignore variables that are constant-captured. const VarDecl *variable = ci->getVariable(); CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; // Ignore objects that aren't destructed. QualType::DestructionKind dtorKind = variable->getType().isDestructedType(); if (dtorKind == QualType::DK_none) continue; CodeGenFunction::Destroyer *destroyer; // Block captures count as local values and have imprecise semantics. // They also can't be arrays, so need to worry about that. if (dtorKind == QualType::DK_objc_strong_lifetime) { destroyer = CodeGenFunction::destroyARCStrongImprecise; } else { destroyer = CGF.getDestroyer(dtorKind); } // GEP down to the address. llvm::Value *addr = CGF.Builder.CreateStructGEP(blockInfo.Address, capture.getIndex()); // We can use that GEP as the dominating IP. if (!blockInfo.DominatingIP) blockInfo.DominatingIP = cast(addr); CleanupKind cleanupKind = InactiveNormalCleanup; bool useArrayEHCleanup = CGF.needsEHCleanup(dtorKind); if (useArrayEHCleanup) cleanupKind = InactiveNormalAndEHCleanup; CGF.pushDestroy(cleanupKind, addr, variable->getType(), destroyer, useArrayEHCleanup); // Remember where that cleanup was. capture.setCleanup(CGF.EHStack.stable_begin()); } } /// Enter a full-expression with a non-trivial number of objects to /// clean up. This is in this file because, at the moment, the only /// kind of cleanup object is a BlockDecl*. void CodeGenFunction::enterNonTrivialFullExpression(const ExprWithCleanups *E) { assert(E->getNumObjects() != 0); ArrayRef cleanups = E->getObjects(); for (ArrayRef::iterator i = cleanups.begin(), e = cleanups.end(); i != e; ++i) { enterBlockScope(*this, *i); } } /// Find the layout for the given block in a linked list and remove it. static CGBlockInfo *findAndRemoveBlockInfo(CGBlockInfo **head, const BlockDecl *block) { while (true) { assert(head && *head); CGBlockInfo *cur = *head; // If this is the block we're looking for, splice it out of the list. if (cur->getBlockDecl() == block) { *head = cur->NextBlockInfo; return cur; } head = &cur->NextBlockInfo; } } /// Destroy a chain of block layouts. void CodeGenFunction::destroyBlockInfos(CGBlockInfo *head) { assert(head && "destroying an empty chain"); do { CGBlockInfo *cur = head; head = cur->NextBlockInfo; delete cur; } while (head != 0); } /// Emit a block literal expression in the current function. llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) { // If the block has no captures, we won't have a pre-computed // layout for it. if (!blockExpr->getBlockDecl()->hasCaptures()) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), CurFn->getName()); computeBlockInfo(CGM, this, blockInfo); blockInfo.BlockExpression = blockExpr; return EmitBlockLiteral(blockInfo); } // Find the block info for this block and take ownership of it. OwningPtr blockInfo; blockInfo.reset(findAndRemoveBlockInfo(&FirstBlockInfo, blockExpr->getBlockDecl())); blockInfo->BlockExpression = blockExpr; return EmitBlockLiteral(*blockInfo); } llvm::Value *CodeGenFunction::EmitBlockLiteral(const CGBlockInfo &blockInfo) { // Using the computed layout, generate the actual block function. bool isLambdaConv = blockInfo.getBlockDecl()->isConversionFromLambda(); llvm::Constant *blockFn = CodeGenFunction(CGM, true).GenerateBlockFunction(CurGD, blockInfo, LocalDeclMap, isLambdaConv); blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); // If there is nothing to capture, we can emit this as a global block. if (blockInfo.CanBeGlobal) return buildGlobalBlock(CGM, blockInfo, blockFn); // Otherwise, we have to emit this as a local block. llvm::Constant *isa = CGM.getNSConcreteStackBlock(); isa = llvm::ConstantExpr::getBitCast(isa, VoidPtrTy); // Build the block descriptor. llvm::Constant *descriptor = buildBlockDescriptor(CGM, blockInfo); llvm::AllocaInst *blockAddr = blockInfo.Address; assert(blockAddr && "block has no address!"); // Compute the initial on-stack block flags. BlockFlags flags = BLOCK_HAS_SIGNATURE; if (blockInfo.HasCapturedVariableLayout) flags |= BLOCK_HAS_EXTENDED_LAYOUT; if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE; if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; // Initialize the block literal. Builder.CreateStore(isa, Builder.CreateStructGEP(blockAddr, 0, "block.isa")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(blockAddr, 1, "block.flags")); Builder.CreateStore(llvm::ConstantInt::get(IntTy, 0), Builder.CreateStructGEP(blockAddr, 2, "block.reserved")); Builder.CreateStore(blockFn, Builder.CreateStructGEP(blockAddr, 3, "block.invoke")); Builder.CreateStore(descriptor, Builder.CreateStructGEP(blockAddr, 4, "block.descriptor")); // Finally, capture all the values into the block. const BlockDecl *blockDecl = blockInfo.getBlockDecl(); // First, 'this'. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(blockAddr, blockInfo.CXXThisIndex, "block.captured-this.addr"); Builder.CreateStore(LoadCXXThis(), addr); } // Next, captured variables. for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); // Ignore constant captures. if (capture.isConstant()) continue; QualType type = variable->getType(); CharUnits align = getContext().getDeclAlign(variable); // This will be a [[type]]*, except that a byref entry will just be // an i8**. llvm::Value *blockField = Builder.CreateStructGEP(blockAddr, capture.getIndex(), "block.captured"); // Compute the address of the thing we're going to move into the // block literal. llvm::Value *src; if (BlockInfo && ci->isNested()) { // We need to use the capture from the enclosing block. const CGBlockInfo::Capture &enclosingCapture = BlockInfo->getCapture(variable); // This is a [[type]]*, except that a byref entry wil just be an i8**. src = Builder.CreateStructGEP(LoadBlockStruct(), enclosingCapture.getIndex(), "block.capture.addr"); } else if (blockDecl->isConversionFromLambda()) { // The lambda capture in a lambda's conversion-to-block-pointer is // special; we'll simply emit it directly. src = 0; } else { // Just look it up in the locals map, which will give us back a // [[type]]*. If that doesn't work, do the more elaborate DRE // emission. src = LocalDeclMap.lookup(variable); if (!src) { DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ ci->isNested(), type, VK_LValue, SourceLocation()); src = EmitDeclRefLValue(&declRef).getAddress(); } } // For byrefs, we just write the pointer to the byref struct into // the block field. There's no need to chase the forwarding // pointer at this point, since we're building something that will // live a shorter life than the stack byref anyway. if (ci->isByRef()) { // Get a void* that points to the byref struct. if (ci->isNested()) src = Builder.CreateAlignedLoad(src, align.getQuantity(), "byref.capture"); else src = Builder.CreateBitCast(src, VoidPtrTy); // Write that void* into the capture field. Builder.CreateAlignedStore(src, blockField, align.getQuantity()); // If we have a copy constructor, evaluate that into the block field. } else if (const Expr *copyExpr = ci->getCopyExpr()) { if (blockDecl->isConversionFromLambda()) { // If we have a lambda conversion, emit the expression // directly into the block instead. AggValueSlot Slot = AggValueSlot::forAddr(blockField, align, Qualifiers(), AggValueSlot::IsDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); EmitAggExpr(copyExpr, Slot); } else { EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr); } // If it's a reference variable, copy the reference into the block field. } else if (type->isReferenceType()) { llvm::Value *ref = Builder.CreateAlignedLoad(src, align.getQuantity(), "ref.val"); Builder.CreateAlignedStore(ref, blockField, align.getQuantity()); // If this is an ARC __strong block-pointer variable, don't do a // block copy. // // TODO: this can be generalized into the normal initialization logic: // we should never need to do a block-copy when initializing a local // variable, because the local variable's lifetime should be strictly // contained within the stack block's. } else if (type.getObjCLifetime() == Qualifiers::OCL_Strong && type->isBlockPointerType()) { // Load the block and do a simple retain. LValue srcLV = MakeAddrLValue(src, type, align); llvm::Value *value = EmitLoadOfScalar(srcLV, SourceLocation()); value = EmitARCRetainNonBlock(value); // Do a primitive store to the block field. LValue destLV = MakeAddrLValue(blockField, type, align); EmitStoreOfScalar(value, destLV, /*init*/ true); // Otherwise, fake up a POD copy into the block field. } else { // Fake up a new variable so that EmitScalarInit doesn't think // we're referring to the variable in its own initializer. ImplicitParamDecl blockFieldPseudoVar(/*DC*/ 0, SourceLocation(), /*name*/ 0, type); // We use one of these or the other depending on whether the // reference is nested. DeclRefExpr declRef(const_cast(variable), /*refersToEnclosing*/ ci->isNested(), type, VK_LValue, SourceLocation()); ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue, &declRef, VK_RValue); EmitExprAsInit(&l2r, &blockFieldPseudoVar, MakeAddrLValue(blockField, type, align), /*captured by init*/ false); } // Activate the cleanup if layout pushed one. if (!ci->isByRef()) { EHScopeStack::stable_iterator cleanup = capture.getCleanup(); if (cleanup.isValid()) ActivateCleanupBlock(cleanup, blockInfo.DominatingIP); } } // Cast to the converted block-pointer type, which happens (somewhat // unfortunately) to be a pointer to function type. llvm::Value *result = Builder.CreateBitCast(blockAddr, ConvertType(blockInfo.getBlockExpr()->getType())); return result; } llvm::Type *CodeGenModule::getBlockDescriptorType() { if (BlockDescriptorType) return BlockDescriptorType; llvm::Type *UnsignedLongTy = getTypes().ConvertType(getContext().UnsignedLongTy); // struct __block_descriptor { // unsigned long reserved; // unsigned long block_size; // // // later, the following will be added // // struct { // void (*copyHelper)(); // void (*copyHelper)(); // } helpers; // !!! optional // // const char *signature; // the block signature // const char *layout; // reserved // }; BlockDescriptorType = llvm::StructType::create("struct.__block_descriptor", UnsignedLongTy, UnsignedLongTy, NULL); // Now form a pointer to that. BlockDescriptorType = llvm::PointerType::getUnqual(BlockDescriptorType); return BlockDescriptorType; } llvm::Type *CodeGenModule::getGenericBlockLiteralType() { if (GenericBlockLiteralType) return GenericBlockLiteralType; llvm::Type *BlockDescPtrTy = getBlockDescriptorType(); // struct __block_literal_generic { // void *__isa; // int __flags; // int __reserved; // void (*__invoke)(void *); // struct __block_descriptor *__descriptor; // }; GenericBlockLiteralType = llvm::StructType::create("struct.__block_literal_generic", VoidPtrTy, IntTy, IntTy, VoidPtrTy, BlockDescPtrTy, NULL); return GenericBlockLiteralType; } RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue) { const BlockPointerType *BPT = E->getCallee()->getType()->getAs(); llvm::Value *Callee = EmitScalarExpr(E->getCallee()); // Get a pointer to the generic block literal. llvm::Type *BlockLiteralTy = llvm::PointerType::getUnqual(CGM.getGenericBlockLiteralType()); // Bitcast the callee to a block literal. llvm::Value *BlockLiteral = Builder.CreateBitCast(Callee, BlockLiteralTy, "block.literal"); // Get the function pointer from the literal. llvm::Value *FuncPtr = Builder.CreateStructGEP(BlockLiteral, 3); BlockLiteral = Builder.CreateBitCast(BlockLiteral, VoidPtrTy); // Add the block literal. CallArgList Args; Args.add(RValue::get(BlockLiteral), getContext().VoidPtrTy); QualType FnType = BPT->getPointeeType(); // And the rest of the arguments. EmitCallArgs(Args, FnType->getAs(), E->arg_begin(), E->arg_end()); // Load the function. llvm::Value *Func = Builder.CreateLoad(FuncPtr); const FunctionType *FuncTy = FnType->castAs(); const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeBlockFunctionCall(Args, FuncTy); // Cast the function pointer to the right type. llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo); llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy); Func = Builder.CreateBitCast(Func, BlockFTyPtr); // And call the block. return EmitCall(FnInfo, Func, ReturnValue, Args); } llvm::Value *CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable, bool isByRef) { assert(BlockInfo && "evaluating block ref without block information?"); const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable); // Handle constant captures. if (capture.isConstant()) return LocalDeclMap[variable]; llvm::Value *addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(), "block.capture.addr"); if (isByRef) { // addr should be a void** right now. Load, then cast the result // to byref*. addr = Builder.CreateLoad(addr); llvm::PointerType *byrefPointerType = llvm::PointerType::get(BuildByRefType(variable), 0); addr = Builder.CreateBitCast(addr, byrefPointerType, "byref.addr"); // Follow the forwarding pointer. addr = Builder.CreateStructGEP(addr, 1, "byref.forwarding"); addr = Builder.CreateLoad(addr, "byref.addr.forwarded"); // Cast back to byref* and GEP over to the actual object. addr = Builder.CreateBitCast(addr, byrefPointerType); addr = Builder.CreateStructGEP(addr, getByRefValueLLVMField(variable), variable->getNameAsString()); } if (variable->getType()->isReferenceType()) addr = Builder.CreateLoad(addr, "ref.tmp"); return addr; } llvm::Constant * CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *blockExpr, const char *name) { CGBlockInfo blockInfo(blockExpr->getBlockDecl(), name); blockInfo.BlockExpression = blockExpr; // Compute information about the layout, etc., of this block. computeBlockInfo(*this, 0, blockInfo); // Using that metadata, generate the actual block function. llvm::Constant *blockFn; { llvm::DenseMap LocalDeclMap; blockFn = CodeGenFunction(*this).GenerateBlockFunction(GlobalDecl(), blockInfo, LocalDeclMap, false); } blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy); return buildGlobalBlock(*this, blockInfo, blockFn); } static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM, const CGBlockInfo &blockInfo, llvm::Constant *blockFn) { assert(blockInfo.CanBeGlobal); // Generate the constants for the block literal initializer. llvm::Constant *fields[BlockHeaderSize]; // isa fields[0] = CGM.getNSConcreteGlobalBlock(); // __flags BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE; if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET; fields[1] = llvm::ConstantInt::get(CGM.IntTy, flags.getBitMask()); // Reserved fields[2] = llvm::Constant::getNullValue(CGM.IntTy); // Function fields[3] = blockFn; // Descriptor fields[4] = buildBlockDescriptor(CGM, blockInfo); llvm::Constant *init = llvm::ConstantStruct::getAnon(fields); llvm::GlobalVariable *literal = new llvm::GlobalVariable(CGM.getModule(), init->getType(), /*constant*/ true, llvm::GlobalVariable::InternalLinkage, init, "__block_literal_global"); literal->setAlignment(blockInfo.BlockAlign.getQuantity()); // Return a constant of the appropriately-casted type. llvm::Type *requiredType = CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType()); return llvm::ConstantExpr::getBitCast(literal, requiredType); } llvm::Function * CodeGenFunction::GenerateBlockFunction(GlobalDecl GD, const CGBlockInfo &blockInfo, const DeclMapTy &ldm, bool IsLambdaConversionToBlock) { const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CurGD = GD; BlockInfo = &blockInfo; // Arrange for local static and local extern declarations to appear // to be local to this function as well, in case they're directly // referenced in a block. for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) { const VarDecl *var = dyn_cast(i->first); if (var && !var->hasLocalStorage()) LocalDeclMap[var] = i->second; } // Begin building the function declaration. // Build the argument list. FunctionArgList args; // The first argument is the block pointer. Just take it as a void* // and cast it later. QualType selfTy = getContext().VoidPtrTy; IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor"); ImplicitParamDecl selfDecl(const_cast(blockDecl), SourceLocation(), II, selfTy); args.push_back(&selfDecl); // Now add the rest of the parameters. for (BlockDecl::param_const_iterator i = blockDecl->param_begin(), e = blockDecl->param_end(); i != e; ++i) args.push_back(*i); // Create the function declaration. const FunctionProtoType *fnType = blockInfo.getBlockExpr()->getFunctionType(); const CGFunctionInfo &fnInfo = CGM.getTypes().arrangeFreeFunctionDeclaration( fnType->getReturnType(), args, fnType->getExtInfo(), fnType->isVariadic()); if (CGM.ReturnTypeUsesSRet(fnInfo)) blockInfo.UsesStret = true; llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo); MangleBuffer name; CGM.getBlockMangledName(GD, name, blockDecl); llvm::Function *fn = llvm::Function::Create(fnLLVMType, llvm::GlobalValue::InternalLinkage, name.getString(), &CGM.getModule()); CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo); // Begin generating the function. StartFunction(blockDecl, fnType->getReturnType(), fn, fnInfo, args, blockInfo.getBlockExpr()->getBody()->getLocStart()); // Okay. Undo some of what StartFunction did. // Pull the 'self' reference out of the local decl map. llvm::Value *blockAddr = LocalDeclMap[&selfDecl]; LocalDeclMap.erase(&selfDecl); BlockPointer = Builder.CreateBitCast(blockAddr, blockInfo.StructureType->getPointerTo(), "block"); // At -O0 we generate an explicit alloca for the BlockPointer, so the RA // won't delete the dbg.declare intrinsics for captured variables. llvm::Value *BlockPointerDbgLoc = BlockPointer; if (CGM.getCodeGenOpts().OptimizationLevel == 0) { // Allocate a stack slot for it, so we can point the debugger to it llvm::AllocaInst *Alloca = CreateTempAlloca(BlockPointer->getType(), "block.addr"); unsigned Align = getContext().getDeclAlign(&selfDecl).getQuantity(); Alloca->setAlignment(Align); // Set the DebugLocation to empty, so the store is recognized as a // frame setup instruction by llvm::DwarfDebug::beginFunction(). NoLocation NL(*this, Builder); Builder.CreateAlignedStore(BlockPointer, Alloca, Align); BlockPointerDbgLoc = Alloca; } // If we have a C++ 'this' reference, go ahead and force it into // existence now. if (blockDecl->capturesCXXThis()) { llvm::Value *addr = Builder.CreateStructGEP(BlockPointer, blockInfo.CXXThisIndex, "block.captured-this"); CXXThisValue = Builder.CreateLoad(addr, "this"); } // Also force all the constant captures. for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (!capture.isConstant()) continue; unsigned align = getContext().getDeclAlign(variable).getQuantity(); llvm::AllocaInst *alloca = CreateMemTemp(variable->getType(), "block.captured-const"); alloca->setAlignment(align); Builder.CreateAlignedStore(capture.getConstant(), alloca, align); LocalDeclMap[variable] = alloca; } // Save a spot to insert the debug information for all the DeclRefExprs. llvm::BasicBlock *entry = Builder.GetInsertBlock(); llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint(); --entry_ptr; if (IsLambdaConversionToBlock) EmitLambdaBlockInvokeBody(); else EmitStmt(blockDecl->getBody()); // Remember where we were... llvm::BasicBlock *resume = Builder.GetInsertBlock(); // Go back to the entry. ++entry_ptr; Builder.SetInsertPoint(entry, entry_ptr); // Emit debug information for all the DeclRefExprs. // FIXME: also for 'this' if (CGDebugInfo *DI = getDebugInfo()) { for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); DI->EmitLocation(Builder, variable->getLocation()); if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) { const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) { DI->EmitDeclareOfAutoVariable(variable, LocalDeclMap[variable], Builder); continue; } DI->EmitDeclareOfBlockDeclRefVariable(variable, BlockPointerDbgLoc, Builder, blockInfo); } } // Recover location if it was changed in the above loop. DI->EmitLocation(Builder, cast(blockDecl->getBody())->getRBracLoc()); } // And resume where we left off. if (resume == 0) Builder.ClearInsertionPoint(); else Builder.SetInsertPoint(resume); FinishFunction(cast(blockDecl->getBody())->getRBracLoc()); return fn; } /* notes.push_back(HelperInfo()); HelperInfo ¬e = notes.back(); note.index = capture.getIndex(); note.RequiresCopying = (ci->hasCopyExpr() || BlockRequiresCopying(type)); note.cxxbar_import = ci->getCopyExpr(); if (ci->isByRef()) { note.flag = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) note.flag |= BLOCK_FIELD_IS_WEAK; } else if (type->isBlockPointerType()) { note.flag = BLOCK_FIELD_IS_BLOCK; } else { note.flag = BLOCK_FIELD_IS_OBJECT; } */ /// Generate the copy-helper function for a block closure object: /// static void block_copy_helper(block_t *dst, block_t *src); /// The runtime will have previously initialized 'dst' by doing a /// bit-copy of 'src'. /// /// Note that this copies an entire block closure object to the heap; /// it should not be confused with a 'byref copy helper', which moves /// the contents of an individual __block variable to the heap. llvm::Constant * CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl dstDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&dstDecl); ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); // FIXME: it would be nice if these were mergeable with things with // identical semantics. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__copy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__copy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, 0, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation()); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block.source"); llvm::Value *dst = GetAddrOfLocalVar(&dstDecl); dst = Builder.CreateLoad(dst); dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; const Expr *copyExpr = ci->getCopyExpr(); BlockFieldFlags flags; bool useARCWeakCopy = false; bool useARCStrongCopy = false; if (copyExpr) { assert(!ci->isByRef()); // don't bother computing flags } else if (ci->isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; bool isBlockPointer = type->isBlockPointerType(); if (isBlockPointer) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures: if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // We need to register __weak direct captures with the runtime. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) { useARCWeakCopy = true; // We need to retain the copied value for __strong direct captures. } else if (qs.getObjCLifetime() == Qualifiers::OCL_Strong) { // If it's a block pointer, we have to copy the block and // assign that to the destination pointer, so we might as // well use _Block_object_assign. Otherwise we can avoid that. if (!isBlockPointer) useARCStrongCopy = true; // Otherwise the memcpy is fine. } else { continue; } // Non-ARC captures of retainable pointers are strong and // therefore require a call to _Block_object_assign. } else { // fall through } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); llvm::Value *dstField = Builder.CreateStructGEP(dst, index); // If there's an explicit copy expression, we do that. if (copyExpr) { EmitSynthesizedCXXCopyCtor(dstField, srcField, copyExpr); } else if (useARCWeakCopy) { EmitARCCopyWeak(dstField, srcField); } else { llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src"); if (useARCStrongCopy) { // At -O0, store null into the destination field (so that the // storeStrong doesn't over-release) and then call storeStrong. // This is a workaround to not having an initStrong call. if (CGM.getCodeGenOpts().OptimizationLevel == 0) { llvm::PointerType *ty = cast(srcValue->getType()); llvm::Value *null = llvm::ConstantPointerNull::get(ty); Builder.CreateStore(null, dstField); EmitARCStoreStrongCall(dstField, srcValue, true); // With optimization enabled, take advantage of the fact that // the blocks runtime guarantees a memcpy of the block data, and // just emit a retain of the src field. } else { EmitARCRetainNonBlock(srcValue); // We don't need this anymore, so kill it. It's not quite // worth the annoyance to avoid creating it in the first place. cast(dstField)->eraseFromParent(); } } else { srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy); llvm::Value *dstAddr = Builder.CreateBitCast(dstField, VoidPtrTy); llvm::Value *args[] = { dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; bool copyCanThrow = false; if (ci->isByRef() && variable->getType()->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(variable); if (copyExpr) { copyCanThrow = true; // FIXME: reuse the noexcept logic } } if (copyCanThrow) { EmitRuntimeCallOrInvoke(CGM.getBlockObjectAssign(), args); } else { EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args); } } } } FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } /// Generate the destroy-helper function for a block closure object: /// static void block_destroy_helper(block_t *theBlock); /// /// Note that this destroys a heap-allocated block closure object; /// it should not be confused with a 'byref destroy helper', which /// destroys the heap-allocated contents of an individual __block /// variable. llvm::Constant * CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) { ASTContext &C = getContext(); FunctionArgList args; ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy); args.push_back(&srcDecl); const CGFunctionInfo &FI = CGM.getTypes().arrangeFreeFunctionDeclaration( C.VoidTy, args, FunctionType::ExtInfo(), /*variadic=*/false); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI); llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__destroy_helper_block_", &CGM.getModule()); IdentifierInfo *II = &CGM.getContext().Idents.get("__destroy_helper_block_"); FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, C.VoidTy, 0, SC_Static, false, false); // Create a scope with an artificial location for the body of this function. ArtificialLocation AL(*this, Builder); StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation()); AL.Emit(); llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo(); llvm::Value *src = GetAddrOfLocalVar(&srcDecl); src = Builder.CreateLoad(src); src = Builder.CreateBitCast(src, structPtrTy, "block"); const BlockDecl *blockDecl = blockInfo.getBlockDecl(); CodeGenFunction::RunCleanupsScope cleanups(*this); for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(), ce = blockDecl->capture_end(); ci != ce; ++ci) { const VarDecl *variable = ci->getVariable(); QualType type = variable->getType(); const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); if (capture.isConstant()) continue; BlockFieldFlags flags; const CXXDestructorDecl *dtor = 0; bool useARCWeakDestroy = false; bool useARCStrongDestroy = false; if (ci->isByRef()) { flags = BLOCK_FIELD_IS_BYREF; if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; } else if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { if (record->hasTrivialDestructor()) continue; dtor = record->getDestructor(); } else if (type->isObjCRetainableType()) { flags = BLOCK_FIELD_IS_OBJECT; if (type->isBlockPointerType()) flags = BLOCK_FIELD_IS_BLOCK; // Special rules for ARC captures. if (getLangOpts().ObjCAutoRefCount) { Qualifiers qs = type.getQualifiers(); // Don't generate special dispose logic for a captured object // unless it's __strong or __weak. if (!qs.hasStrongOrWeakObjCLifetime()) continue; // Support __weak direct captures. if (qs.getObjCLifetime() == Qualifiers::OCL_Weak) useARCWeakDestroy = true; // Tools really want us to use objc_storeStrong here. else useARCStrongDestroy = true; } } else { continue; } unsigned index = capture.getIndex(); llvm::Value *srcField = Builder.CreateStructGEP(src, index); // If there's an explicit copy expression, we do that. if (dtor) { PushDestructorCleanup(dtor, srcField); // If this is a __weak capture, emit the release directly. } else if (useARCWeakDestroy) { EmitARCDestroyWeak(srcField); // Destroy strong objects with a call if requested. } else if (useARCStrongDestroy) { EmitARCDestroyStrong(srcField, ARCImpreciseLifetime); // Otherwise we call _Block_object_dispose. It wouldn't be too // hard to just emit this as a cleanup if we wanted to make sure // that things were done in reverse. } else { llvm::Value *value = Builder.CreateLoad(srcField); value = Builder.CreateBitCast(value, VoidPtrTy); BuildBlockRelease(value, flags); } } cleanups.ForceCleanup(); FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy); } namespace { /// Emits the copy/dispose helper functions for a __block object of id type. class ObjectByrefHelpers : public CodeGenModule::ByrefHelpers { BlockFieldFlags Flags; public: ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags) : ByrefHelpers(alignment), Flags(flags) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy); srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy); llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField); unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask(); llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags); llvm::Value *fn = CGF.CGM.getBlockObjectAssign(); llvm::Value *args[] = { destField, srcValue, flagsVal }; CGF.EmitNounwindRuntimeCall(fn, args); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0)); llvm::Value *value = CGF.Builder.CreateLoad(field); CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER); } void profileImpl(llvm::FoldingSetNodeID &id) const { id.AddInteger(Flags.getBitMask()); } }; /// Emits the copy/dispose helpers for an ARC __block __weak variable. class ARCWeakByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCWeakByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { CGF.EmitARCMoveWeak(destField, srcField); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyWeak(field); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 0 is distinguishable from all pointers and byref flags id.AddInteger(0); } }; /// Emits the copy/dispose helpers for an ARC __block __strong variable /// that's not of block-pointer type. class ARCStrongByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { // Do a "move" by copying the value and then zeroing out the old // variable. llvm::LoadInst *value = CGF.Builder.CreateLoad(srcField); value->setAlignment(Alignment.getQuantity()); llvm::Value *null = llvm::ConstantPointerNull::get(cast(value->getType())); if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0) { llvm::StoreInst *store = CGF.Builder.CreateStore(null, destField); store->setAlignment(Alignment.getQuantity()); CGF.EmitARCStoreStrongCall(destField, value, /*ignored*/ true); CGF.EmitARCStoreStrongCall(srcField, null, /*ignored*/ true); return; } llvm::StoreInst *store = CGF.Builder.CreateStore(value, destField); store->setAlignment(Alignment.getQuantity()); store = CGF.Builder.CreateStore(null, srcField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 1 is distinguishable from all pointers and byref flags id.AddInteger(1); } }; /// Emits the copy/dispose helpers for an ARC __block __strong /// variable that's of block-pointer type. class ARCStrongBlockByrefHelpers : public CodeGenModule::ByrefHelpers { public: ARCStrongBlockByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {} void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { // Do the copy with objc_retainBlock; that's all that // _Block_object_assign would do anyway, and we'd have to pass the // right arguments to make sure it doesn't get no-op'ed. llvm::LoadInst *oldValue = CGF.Builder.CreateLoad(srcField); oldValue->setAlignment(Alignment.getQuantity()); llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true); llvm::StoreInst *store = CGF.Builder.CreateStore(copy, destField); store->setAlignment(Alignment.getQuantity()); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { CGF.EmitARCDestroyStrong(field, ARCImpreciseLifetime); } void profileImpl(llvm::FoldingSetNodeID &id) const { // 2 is distinguishable from all pointers and byref flags id.AddInteger(2); } }; /// Emits the copy/dispose helpers for a __block variable with a /// nontrivial copy constructor or destructor. class CXXByrefHelpers : public CodeGenModule::ByrefHelpers { QualType VarType; const Expr *CopyExpr; public: CXXByrefHelpers(CharUnits alignment, QualType type, const Expr *copyExpr) : ByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {} bool needsCopy() const { return CopyExpr != 0; } void emitCopy(CodeGenFunction &CGF, llvm::Value *destField, llvm::Value *srcField) { if (!CopyExpr) return; CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr); } void emitDispose(CodeGenFunction &CGF, llvm::Value *field) { EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin(); CGF.PushDestructorCleanup(VarType, field); CGF.PopCleanupBlocks(cleanupDepth); } void profileImpl(llvm::FoldingSetNodeID &id) const { id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr()); } }; } // end anonymous namespace static llvm::Constant * generateByrefCopyHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned valueFieldIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl dst(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&dst); ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_copy_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_copy_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, 0, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation()); if (byrefInfo.needsCopy()) { llvm::Type *byrefPtrType = byrefType.getPointerTo(0); // dst->x llvm::Value *destField = CGF.GetAddrOfLocalVar(&dst); destField = CGF.Builder.CreateLoad(destField); destField = CGF.Builder.CreateBitCast(destField, byrefPtrType); destField = CGF.Builder.CreateStructGEP(destField, valueFieldIndex, "x"); // src->x llvm::Value *srcField = CGF.GetAddrOfLocalVar(&src); srcField = CGF.Builder.CreateLoad(srcField); srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType); srcField = CGF.Builder.CreateStructGEP(srcField, valueFieldIndex, "x"); byrefInfo.emitCopy(CGF, destField, srcField); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the copy helper for a __block variable. static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefCopyHelper(CGF, byrefType, byrefValueIndex, info); } /// Generate code for a __block variable's dispose helper. static llvm::Constant * generateByrefDisposeHelper(CodeGenFunction &CGF, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &byrefInfo) { ASTContext &Context = CGF.getContext(); QualType R = Context.VoidTy; FunctionArgList args; ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy); args.push_back(&src); const CGFunctionInfo &FI = CGF.CGM.getTypes().arrangeFreeFunctionDeclaration( R, args, FunctionType::ExtInfo(), /*variadic=*/false); CodeGenTypes &Types = CGF.CGM.getTypes(); llvm::FunctionType *LTy = Types.GetFunctionType(FI); // FIXME: We'd like to put these into a mergable by content, with // internal linkage. llvm::Function *Fn = llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage, "__Block_byref_object_dispose_", &CGF.CGM.getModule()); IdentifierInfo *II = &Context.Idents.get("__Block_byref_object_dispose_"); FunctionDecl *FD = FunctionDecl::Create(Context, Context.getTranslationUnitDecl(), SourceLocation(), SourceLocation(), II, R, 0, SC_Static, false, false); CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation()); if (byrefInfo.needsDispose()) { llvm::Value *V = CGF.GetAddrOfLocalVar(&src); V = CGF.Builder.CreateLoad(V); V = CGF.Builder.CreateBitCast(V, byrefType.getPointerTo(0)); V = CGF.Builder.CreateStructGEP(V, byrefValueIndex, "x"); byrefInfo.emitDispose(CGF, V); } CGF.FinishFunction(); return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy); } /// Build the dispose helper for a __block variable. static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM, llvm::StructType &byrefType, unsigned byrefValueIndex, CodeGenModule::ByrefHelpers &info) { CodeGenFunction CGF(CGM); return generateByrefDisposeHelper(CGF, byrefType, byrefValueIndex, info); } /// Lazily build the copy and dispose helpers for a __block variable /// with the given information. template static T *buildByrefHelpers(CodeGenModule &CGM, llvm::StructType &byrefTy, unsigned byrefValueIndex, T &byrefInfo) { // Increase the field's alignment to be at least pointer alignment, // since the layout of the byref struct will guarantee at least that. byrefInfo.Alignment = std::max(byrefInfo.Alignment, CharUnits::fromQuantity(CGM.PointerAlignInBytes)); llvm::FoldingSetNodeID id; byrefInfo.Profile(id); void *insertPos; CodeGenModule::ByrefHelpers *node = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos); if (node) return static_cast(node); byrefInfo.CopyHelper = buildByrefCopyHelper(CGM, byrefTy, byrefValueIndex, byrefInfo); byrefInfo.DisposeHelper = buildByrefDisposeHelper(CGM, byrefTy, byrefValueIndex,byrefInfo); T *copy = new (CGM.getContext()) T(byrefInfo); CGM.ByrefHelpersCache.InsertNode(copy, insertPos); return copy; } /// Build the copy and dispose helpers for the given __block variable /// emission. Places the helpers in the global cache. Returns null /// if no helpers are required. CodeGenModule::ByrefHelpers * CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType, const AutoVarEmission &emission) { const VarDecl &var = *emission.Variable; QualType type = var.getType(); unsigned byrefValueIndex = getByRefValueLLVMField(&var); if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) { const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(&var); if (!copyExpr && record->hasTrivialDestructor()) return 0; CXXByrefHelpers byrefInfo(emission.Alignment, type, copyExpr); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // Otherwise, if we don't have a retainable type, there's nothing to do. // that the runtime does extra copies. if (!type->isObjCRetainableType()) return 0; Qualifiers qs = type.getQualifiers(); // If we have lifetime, that dominates. if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) { assert(getLangOpts().ObjCAutoRefCount); switch (lifetime) { case Qualifiers::OCL_None: llvm_unreachable("impossible"); // These are just bits as far as the runtime is concerned. case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: return 0; // Tell the runtime that this is ARC __weak, called by the // byref routines. case Qualifiers::OCL_Weak: { ARCWeakByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } // ARC __strong __block variables need to be retained. case Qualifiers::OCL_Strong: // Block pointers need to be copied, and there's no direct // transfer possible. if (type->isBlockPointerType()) { ARCStrongBlockByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); // Otherwise, we transfer ownership of the retain from the stack // to the heap. } else { ARCStrongByrefHelpers byrefInfo(emission.Alignment); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } } llvm_unreachable("fell out of lifetime switch!"); } BlockFieldFlags flags; if (type->isBlockPointerType()) { flags |= BLOCK_FIELD_IS_BLOCK; } else if (CGM.getContext().isObjCNSObjectType(type) || type->isObjCObjectPointerType()) { flags |= BLOCK_FIELD_IS_OBJECT; } else { return 0; } if (type.isObjCGCWeak()) flags |= BLOCK_FIELD_IS_WEAK; ObjectByrefHelpers byrefInfo(emission.Alignment, flags); return ::buildByrefHelpers(CGM, byrefType, byrefValueIndex, byrefInfo); } unsigned CodeGenFunction::getByRefValueLLVMField(const ValueDecl *VD) const { assert(ByRefValueInfo.count(VD) && "Did not find value!"); return ByRefValueInfo.find(VD)->second.second; } llvm::Value *CodeGenFunction::BuildBlockByrefAddress(llvm::Value *BaseAddr, const VarDecl *V) { llvm::Value *Loc = Builder.CreateStructGEP(BaseAddr, 1, "forwarding"); Loc = Builder.CreateLoad(Loc); Loc = Builder.CreateStructGEP(Loc, getByRefValueLLVMField(V), V->getNameAsString()); return Loc; } /// BuildByRefType - This routine changes a __block variable declared as T x /// into: /// /// struct { /// void *__isa; /// void *__forwarding; /// int32_t __flags; /// int32_t __size; /// void *__copy_helper; // only if needed /// void *__destroy_helper; // only if needed /// void *__byref_variable_layout;// only if needed /// char padding[X]; // only if needed /// T x; /// } x /// llvm::Type *CodeGenFunction::BuildByRefType(const VarDecl *D) { std::pair &Info = ByRefValueInfo[D]; if (Info.first) return Info.first; QualType Ty = D->getType(); SmallVector types; llvm::StructType *ByRefType = llvm::StructType::create(getLLVMContext(), "struct.__block_byref_" + D->getNameAsString()); // void *__isa; types.push_back(Int8PtrTy); // void *__forwarding; types.push_back(llvm::PointerType::getUnqual(ByRefType)); // int32_t __flags; types.push_back(Int32Ty); // int32_t __size; types.push_back(Int32Ty); // Note that this must match *exactly* the logic in buildByrefHelpers. bool HasCopyAndDispose = getContext().BlockRequiresCopying(Ty, D); if (HasCopyAndDispose) { /// void *__copy_helper; types.push_back(Int8PtrTy); /// void *__destroy_helper; types.push_back(Int8PtrTy); } bool HasByrefExtendedLayout = false; Qualifiers::ObjCLifetime Lifetime; if (getContext().getByrefLifetime(Ty, Lifetime, HasByrefExtendedLayout) && HasByrefExtendedLayout) /// void *__byref_variable_layout; types.push_back(Int8PtrTy); bool Packed = false; CharUnits Align = getContext().getDeclAlign(D); if (Align > getContext().toCharUnitsFromBits(getTarget().getPointerAlign(0))) { // We have to insert padding. // The struct above has 2 32-bit integers. unsigned CurrentOffsetInBytes = 4 * 2; // And either 2, 3, 4 or 5 pointers. unsigned noPointers = 2; if (HasCopyAndDispose) noPointers += 2; if (HasByrefExtendedLayout) noPointers += 1; CurrentOffsetInBytes += noPointers * CGM.getDataLayout().getTypeAllocSize(Int8PtrTy); // Align the offset. unsigned AlignedOffsetInBytes = llvm::RoundUpToAlignment(CurrentOffsetInBytes, Align.getQuantity()); unsigned NumPaddingBytes = AlignedOffsetInBytes - CurrentOffsetInBytes; if (NumPaddingBytes > 0) { llvm::Type *Ty = Int8Ty; // FIXME: We need a sema error for alignment larger than the minimum of // the maximal stack alignment and the alignment of malloc on the system. if (NumPaddingBytes > 1) Ty = llvm::ArrayType::get(Ty, NumPaddingBytes); types.push_back(Ty); // We want a packed struct. Packed = true; } } // T x; types.push_back(ConvertTypeForMem(Ty)); ByRefType->setBody(types, Packed); Info.first = ByRefType; Info.second = types.size() - 1; return Info.first; } /// Initialize the structural components of a __block variable, i.e. /// everything but the actual object. void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) { // Find the address of the local. llvm::Value *addr = emission.Address; // That's an alloca of the byref structure type. llvm::StructType *byrefType = cast( cast(addr->getType())->getElementType()); // Build the byref helpers if necessary. This is null if we don't need any. CodeGenModule::ByrefHelpers *helpers = buildByrefHelpers(*byrefType, emission); const VarDecl &D = *emission.Variable; QualType type = D.getType(); bool HasByrefExtendedLayout; Qualifiers::ObjCLifetime ByrefLifetime; bool ByRefHasLifetime = getContext().getByrefLifetime(type, ByrefLifetime, HasByrefExtendedLayout); llvm::Value *V; // Initialize the 'isa', which is just 0 or 1. int isa = 0; if (type.isObjCGCWeak()) isa = 1; V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa"); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 0, "byref.isa")); // Store the address of the variable into its own forwarding pointer. Builder.CreateStore(addr, Builder.CreateStructGEP(addr, 1, "byref.forwarding")); // Blocks ABI: // c) the flags field is set to either 0 if no helper functions are // needed or BLOCK_BYREF_HAS_COPY_DISPOSE if they are, BlockFlags flags; if (helpers) flags |= BLOCK_BYREF_HAS_COPY_DISPOSE; if (ByRefHasLifetime) { if (HasByrefExtendedLayout) flags |= BLOCK_BYREF_LAYOUT_EXTENDED; else switch (ByrefLifetime) { case Qualifiers::OCL_Strong: flags |= BLOCK_BYREF_LAYOUT_STRONG; break; case Qualifiers::OCL_Weak: flags |= BLOCK_BYREF_LAYOUT_WEAK; break; case Qualifiers::OCL_ExplicitNone: flags |= BLOCK_BYREF_LAYOUT_UNRETAINED; break; case Qualifiers::OCL_None: if (!type->isObjCObjectPointerType() && !type->isBlockPointerType()) flags |= BLOCK_BYREF_LAYOUT_NON_OBJECT; break; default: break; } if (CGM.getLangOpts().ObjCGCBitmapPrint) { printf("\n Inline flag for BYREF variable layout (%d):", flags.getBitMask()); if (flags & BLOCK_BYREF_HAS_COPY_DISPOSE) printf(" BLOCK_BYREF_HAS_COPY_DISPOSE"); if (flags & BLOCK_BYREF_LAYOUT_MASK) { BlockFlags ThisFlag(flags.getBitMask() & BLOCK_BYREF_LAYOUT_MASK); if (ThisFlag == BLOCK_BYREF_LAYOUT_EXTENDED) printf(" BLOCK_BYREF_LAYOUT_EXTENDED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_STRONG) printf(" BLOCK_BYREF_LAYOUT_STRONG"); if (ThisFlag == BLOCK_BYREF_LAYOUT_WEAK) printf(" BLOCK_BYREF_LAYOUT_WEAK"); if (ThisFlag == BLOCK_BYREF_LAYOUT_UNRETAINED) printf(" BLOCK_BYREF_LAYOUT_UNRETAINED"); if (ThisFlag == BLOCK_BYREF_LAYOUT_NON_OBJECT) printf(" BLOCK_BYREF_LAYOUT_NON_OBJECT"); } printf("\n"); } } Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()), Builder.CreateStructGEP(addr, 2, "byref.flags")); CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType); V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity()); Builder.CreateStore(V, Builder.CreateStructGEP(addr, 3, "byref.size")); if (helpers) { llvm::Value *copy_helper = Builder.CreateStructGEP(addr, 4); Builder.CreateStore(helpers->CopyHelper, copy_helper); llvm::Value *destroy_helper = Builder.CreateStructGEP(addr, 5); Builder.CreateStore(helpers->DisposeHelper, destroy_helper); } if (ByRefHasLifetime && HasByrefExtendedLayout) { llvm::Constant* ByrefLayoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type); llvm::Value *ByrefInfoAddr = Builder.CreateStructGEP(addr, helpers ? 6 : 4, "byref.layout"); // cast destination to pointer to source type. llvm::Type *DesTy = ByrefLayoutInfo->getType(); DesTy = DesTy->getPointerTo(); llvm::Value *BC = Builder.CreatePointerCast(ByrefInfoAddr, DesTy); Builder.CreateStore(ByrefLayoutInfo, BC); } } void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags) { llvm::Value *F = CGM.getBlockObjectDispose(); llvm::Value *args[] = { Builder.CreateBitCast(V, Int8PtrTy), llvm::ConstantInt::get(Int32Ty, flags.getBitMask()) }; EmitNounwindRuntimeCall(F, args); // FIXME: throwing destructors? } namespace { struct CallBlockRelease : EHScopeStack::Cleanup { llvm::Value *Addr; CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {} void Emit(CodeGenFunction &CGF, Flags flags) { // Should we be passing FIELD_IS_WEAK here? CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF); } }; } /// Enter a cleanup to destroy a __block variable. Note that this /// cleanup should be a no-op if the variable hasn't left the stack /// yet; if a cleanup is required for the variable itself, that needs /// to be done externally. void CodeGenFunction::enterByrefCleanup(const AutoVarEmission &emission) { // We don't enter this cleanup if we're in pure-GC mode. if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) return; EHStack.pushCleanup(NormalAndEHCleanup, emission.Address); } /// Adjust the declaration of something from the blocks API. static void configureBlocksRuntimeObject(CodeGenModule &CGM, llvm::Constant *C) { if (!CGM.getLangOpts().BlocksRuntimeOptional) return; llvm::GlobalValue *GV = cast(C->stripPointerCasts()); if (GV->isDeclaration() && GV->getLinkage() == llvm::GlobalValue::ExternalLinkage) GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); } llvm::Constant *CodeGenModule::getBlockObjectDispose() { if (BlockObjectDispose) return BlockObjectDispose; llvm::Type *args[] = { Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectDispose = CreateRuntimeFunction(fty, "_Block_object_dispose"); configureBlocksRuntimeObject(*this, BlockObjectDispose); return BlockObjectDispose; } llvm::Constant *CodeGenModule::getBlockObjectAssign() { if (BlockObjectAssign) return BlockObjectAssign; llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty }; llvm::FunctionType *fty = llvm::FunctionType::get(VoidTy, args, false); BlockObjectAssign = CreateRuntimeFunction(fty, "_Block_object_assign"); configureBlocksRuntimeObject(*this, BlockObjectAssign); return BlockObjectAssign; } llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() { if (NSConcreteGlobalBlock) return NSConcreteGlobalBlock; NSConcreteGlobalBlock = GetOrCreateLLVMGlobal("_NSConcreteGlobalBlock", Int8PtrTy->getPointerTo(), 0); configureBlocksRuntimeObject(*this, NSConcreteGlobalBlock); return NSConcreteGlobalBlock; } llvm::Constant *CodeGenModule::getNSConcreteStackBlock() { if (NSConcreteStackBlock) return NSConcreteStackBlock; NSConcreteStackBlock = GetOrCreateLLVMGlobal("_NSConcreteStackBlock", Int8PtrTy->getPointerTo(), 0); configureBlocksRuntimeObject(*this, NSConcreteStackBlock); return NSConcreteStackBlock; } @