[CodeGen] Correct codegen for self-capturing __block var

[• ille]

Summary

This is based on my previous patch, https://reviews.llvm.org/D89903, but is an
attempt at a full fix rather than a minimal one, following rjmccall's
suggestion of initializing directly on the heap and emitting a trivial copy
helper.

This applies to situations where a __block variable's initializer references a
block that potentially captures the variable itself.

Clang special-cases these situations because the initializer might call
Block_copy and cause the variable to be moved to the heap while it's
still being initialized. For example, in this snippet:

int copyBlockAndReturnInt(void (^)(void));

__block int val = copyBlockAndReturnInt(^{
    printf("%p\n", val);
});

...if copyBlockAndReturnInt calls Block_copy, val will be moved to the
heap. When copyBlockAndReturnInt returns, the generated code needs to store
the value to the new location.

For scalar values like pointers, this is handled by deferring computation of
the variable's address until after the initializer has been evaluated (and just
before actually storing to that address).

But what about structs? This case would be hard:

struct Foo { int a, b; };
int copyBlockAndReturnInt(void (^)(void));

__block struct Foo foo = {42, copyBlockAndReturnInt(^{
    printf("%p\n", &foo);
})};

To support relocating this to the heap, Clang would have to recalculate
the location of foo before writing to each struct field, in case the
initializer of the current field moved the struct. Block_copy would
also end up copying a half-initialized struct, although that's no big
deal with C structs.

This C++ case, on the other hand, would be impossible:

struct Foo {
    void (^block_)(void);
    Foo(void (^block)(void)) {
        printf("I am at %p\n", this);
        block_ = Block_copy(block);
        printf("I am now at %p\n", this);
    }
};

__block Foo foo(^{
    printf("%p\n", &foo);
});

To support relocating Foo to the heap, Clang would have to magically
move it mid-construction. Normally, Clang uses the move or copy
constructor when moving C++ classes to the heap, but C++ classes
certainly don't expect a move constructor to be called in the middle of
another constructor. memcpy might work in some cases, but it violates
C++ classes' expectation that object addresses will remain stable. Thus
there's no real way to make this work, and ideally it would result in a
compile error (or, alternately, a runtime crash upon calling
Block_copy).

So how does Clang currently approach this situation? Well, there's just a
comment:

case TEK_Aggregate:
  [...]
    // TODO: how can we delay here if D is captured by its initializer?

Clang never calls drillIntoBlockVariable, and ends up writing the
variable to the beginning of the byref struct (not the corresponding
field in it), which is never the correct location. This leaves both the
variable and the byref struct corrupt - even if the block is never
actually copied.

This bug dates back to at least 2012, as I reproduced it on LLVM 3.1.

This patch addresses the issue by allocating the variable directly on
the heap and initializing it there. This ensures it never needs to
move.

For now, to avoid the need for an ABI update, this is done in a hacky
way. First, a byref struct is allocated on the stack as usual, but the
object data itself is left uninitialized, and the copy helper is set to
a no-op. Then _Block_object_assign is called to migrate it to the
heap, followed immediately by _Block_object_dispose to remove the
unnecessary extra reference. Only then is the object initialized in its
new location.

The implicit heap allocation introduced here may be unnecessary if the
block is never actually copied, which could be a problem in code that's
highly performance sensitive or wants to be resilient to allocation
failure. To defend against this, this patch adds a warning,
-Wimplicit-block-var-alloc, to diagnose every time the implicit allocation
is triggered. Since most codebases do not care, the warning is disabled
by default and is not included in any standard warning groups.

This patch also makes the is-captured-by-init analysis simpler yet more
precise (while moving it into Sema so that it can power the new
warning). As far as I can tell, the previous implementation was
overcomplicated for no good reason. In ancient days (2011), the
recursive function isCapturedBy only worked on Exprs, and it recursed on
the Expr's children, which it assumed would also be Exprs. This
assumption turned out to be false for statement expressions. The simple
fix would have been to change isCapturedBy to accept and recurse on
arbitrary Stmts instead, since children() is defined for all Stmts, not
just Exprs. I'm not sure if there was some reason that wasn't possible
at the time, but what happened instead is that a special case was added
for statement expressions, which over a series of patches got more and
more convoluted. This patch deletes all of that in favor of just
recursing on Stmts.

[• ille]

Satisfy clang-format bot, at the cost of formatting a few adjacent lines.

The other bot failures seem pretty clearly unrelated to this change.

[• ille]

Ping :)

[rjmccall]

This is great work, thank you.

clang/include/clang/Basic/DiagnosticSemaKinds.td

5347

This will read okay on the command line, but it'll be awkward in most IDEs that consume diagnostics. You should report the problem fairly completely in the main diagnostic and then just say something like "captured in block here" in the note.

clang/lib/AST/Decl.cpp

2491

You should check isEscapingByref() here rather than just hasAttr; if none of the capturing blocks are escaping, we don't need to worry about this. Or are you handling this implicitly in your pass during escape-marking? That seems subtle.

2498

You should use ->is<RecordType>() instead of isa, since the latter doesn't handle e.g. typedefs.

The reference to TEK_Aggregate is inappropriate here; it's okay to just talk about "aggregates" under the idea that anything else could validly just be zero-initialized prior to the capture.

clang/lib/CodeGen/CGBlocks.cpp

2754

I think there's some tooling that will be slightly happier if you release the value in out instead of addr. I believe we do emit a different function call to enable that in unoptimized builds.

You should add comments describing what you're doing here. The explanation from the commit description's pretty good.

clang/lib/Sema/Sema.cpp

1949

There is an EvaluatedExprVisitor class which might make this easier, and which will definitely eliminate some false positives.

[• ille]

clang/lib/AST/Decl.cpp

2491

On second thought, the hasAttr<BlocksAttr>() shouldn't be there; it's unnecessary. (I based it on isEscapingByref, where it's also unnecessary - but it's needed in isNonEscapingByref, so I suppose isEscapingByref has it for symmetry.). I should replace it with just !isa<ParmVarDecl>(this) to ensure that NonParmVarDeclBits is valid. And the name isCapturedByOwnInit is also a misnomer; I should change it to something like isByRefCapturedByOwnInit.

I want the substantive conditions for isCapturedByOwnInit to be handled during escape marking, for two reasons. One, that's where the warning is emitted, and I want to ensure it doesn't ever disagree with codegen about whether init-on-heap needs to be applied. Two, it can't mean "is captured by own initializer regardless of __block", because that would imply unnecessarily running the capture check on all variables.

2498

You mean isRecordType()? Good catch, I'll add a test for that.

clang/lib/Sema/Sema.cpp

1949

Hmm… In an earlier revision by jfb to this same check, you were concerned about using RecursiveASTVisitor because 'RecursiveASTVisitor instantiations are huge'. EvaluatedExprVisitor inherits from a different class from RecursiveASTVisitor, but they look pretty similar, so doesn't the same concern about template bloat apply? Perhaps I'm misunderstanding that earlier comment.

[rjmccall]

clang/lib/AST/Decl.cpp

2491

Okay. In that case, this can just go in the header, and it's worth documenting in comments (on either the accessor or the underlying bit) that it's only set on __block variables.

clang/lib/Sema/Sema.cpp

1949

StmtVisitor instantiations don't come with the same code-size impact as RecursiveASTVisitor, mostly because they primarily depend on the same recursive children() walk rather than the explicit repeated logic and careful tracking of the latter, but also because they don't make an effort to recurse into various syntactic but unevaluated expressions, and because the main "heavyweight" thing in their instantiation (the switch in Visit) is pretty easily optimized by the compiler if you actually end up only caring about particular cases. But also, EvaluatedExprVisitor is the right tool for this job because you only care about evaluated references to the variable.

[ahatanak]

@ille, are you still working on this patch?

clang/docs/DiagnosticsReference.rst

 |:warning:`warning:` |nbsp| :diagtext:`property is assumed atomic when auto-synthesizing the property`|
 +-----------------------------------------------------------------------------------------------------+
 
 +----------------------------------------------------------------------------+
 |:warning:`warning:` |nbsp| :diagtext:`property is assumed atomic by default`|
 +----------------------------------------------------------------------------+
 
 
+-Wimplicit-block-var-alloc
+--------------------------
+**Diagnostic text:**
+
++-----------------------------------------------------------------------------------------------------------------------------------+
+|:warning:`warning:` |nbsp| :diagtext:`variable` |nbsp| :placeholder:`A` |nbsp| :diagtext:`will be initialized in a heap allocation`|
++-----------------------------------------------------------------------------------------------------------------------------------+
+
+
 -Wimplicit-const-int-float-conversion
 -------------------------------------
 This diagnostic is enabled by default.
 
 **Diagnostic text:**
 
 +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 |:warning:`warning:` |nbsp| :diagtext:`implicit conversion from` |nbsp| :placeholder:`C` |nbsp| :diagtext:`to` |nbsp| :placeholder:`D` |nbsp| :diagtext:`changes value from` |nbsp| :placeholder:`A` |nbsp| :diagtext:`to` |nbsp| :placeholder:`B`|

clang/include/clang/AST/Decl.h

class NonParmVarDeclBitfields {
     /// the type of this declaration with its previous declaration.
     unsigned PreviousDeclInSameBlockScope : 1;
 
     /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
     /// something else.
     unsigned ImplicitParamKind : 3;
 
     unsigned EscapingByref : 1;
+
+    /// Whether this is a __block variable that is captured by a block
+    /// referenced in its own initializer.
+    unsigned CapturedByOwnInit : 1;
   };
 
   union {
     unsigned AllBits;
     VarDeclBitfields VarDeclBits;
     ParmVarDeclBitfields ParmVarDeclBits;
     NonParmVarDeclBitfields NonParmVarDeclBits;
   };
public:
   /// that can potentially escape (a block for which BlockDecl::doesNotEscape
   /// returns false).
   bool isEscapingByref() const;
 
   /// Indicates the capture is a __block variable that is never captured by an
   /// escaping block.
   bool isNonEscapingByref() const;
 
+  /// Indicates this is a __block variable that is captured by a block
+  /// referenced in its own initializer.
+  bool isCapturedByOwnInit() const;
+
   void setEscapingByref() {
     NonParmVarDeclBits.EscapingByref = true;
   }
 
+  void setCapturedByOwnInit() {
+    NonParmVarDeclBits.CapturedByOwnInit = true;
+  }
+
+  /// Check if this is a __block variable which needs to be initialized
+  /// directly on the heap.
+  bool needsInitOnHeap() const;
+
   /// Retrieve the variable declaration from which this variable could
   /// be instantiated, if it is an instantiation (rather than a non-template).
   VarDecl *getTemplateInstantiationPattern() const;
 
   /// If this variable is an instantiated static data member of a
   /// class template specialization, returns the templated static data member
   /// from which it was instantiated.
   VarDecl *getInstantiatedFromStaticDataMember() const;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_undefined_internal_type : Extension<
   "ISO C++ requires a definition in this translation unit for "
   "%select{function|variable}0 %q1 because its type does not have linkage">,
   InGroup<DiagGroup<"undefined-internal-type">>;
 def warn_undefined_inline : Warning<"inline function %q0 is not defined">,
   InGroup<DiagGroup<"undefined-inline">>;
 def err_undefined_inline_var : Error<"inline variable %q0 is not defined">;
 def note_used_here : Note<"used here">;
 
+def warn_implicit_block_var_alloc : Warning<"variable %q0 will be initialized in a heap allocation">,
+  InGroup<DiagGroup<"implicit-block-var-alloc">>, DefaultIgnore;
+def note_because_captured_by_block : Note<
+  "because it is captured by a block used in its own initializer">;
+
 def err_internal_linkage_redeclaration : Error<
   "'internal_linkage' attribute does not appear on the first declaration of %0">;
 def warn_internal_linkage_local_storage : Warning<
   "'internal_linkage' attribute on a non-static local variable is ignored">,
   InGroup<IgnoredAttributes>;
 
 def ext_internal_in_extern_inline : ExtWarn<
   "static %select{function|variable}0 %1 is used in an inline function with "

clang/lib/AST/Decl.cpp

 bool VarDecl::isEscapingByref() const {
   return hasAttr<BlocksAttr>() && NonParmVarDeclBits.EscapingByref;
 }
 
 bool VarDecl::isNonEscapingByref() const {
   return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
 }
 
+bool VarDecl::isCapturedByOwnInit() const {
+  return hasAttr<BlocksAttr>() && NonParmVarDeclBits.CapturedByOwnInit;
+}
+
+bool VarDecl::needsInitOnHeap() const {
+  // Record types are the only TEK_Aggregate types that can legally be the type
+  // of a __block variable.
+  return isCapturedByOwnInit() &&
+         isa<RecordType>(getType().getAtomicUnqualifiedType());
+}
+
 VarDecl *VarDecl::getTemplateInstantiationPattern() const {
   const VarDecl *VD = this;
 
   // If this is an instantiated member, walk back to the template from which
   // it was instantiated.
   if (MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo()) {
     if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
       VD = VD->getInstantiatedFromStaticDataMember();

clang/lib/CodeGen/CGBlocks.h

 
 /// Information about the layout of a __block variable.
 class BlockByrefInfo {
 public:
   llvm::StructType *Type;
   unsigned FieldIndex;
   CharUnits ByrefAlignment;
   CharUnits FieldOffset;
+  bool ForceNoopCopy;
 };
 
 /// CGBlockInfo - Information to generate a block literal.
 class CGBlockInfo {
 public:
   /// Name - The name of the block, kindof.
   StringRef Name;
 

clang/lib/CodeGen/CGBlocks.cpp

: Name(name), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false),
     StructureType(nullptr), Block(block) {
 
   // 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);
 }
 
+BlockByrefHelpers::BlockByrefHelpers(const BlockByrefInfo &info)
+    : CopyHelper(nullptr), DisposeHelper(nullptr),
+      // The alignment we care about for the purposes of uniquing byref
+      // helpers is the alignment of the actual byref value field.
+      Alignment(info.ByrefAlignment.alignmentAtOffset(info.FieldOffset)),
+      ForceNoopCopy(info.ForceNoopCopy) {}
+
 // Anchor the vtable to this translation unit.
 BlockByrefHelpers::~BlockByrefHelpers() {}
 
 /// Build the given block as a global block.
 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
                                         const CGBlockInfo &blockInfo,
                                         llvm::Constant *blockFn);
 

 
 namespace {
 
 /// Emits the copy/dispose helper functions for a __block object of id type.
 class ObjectByrefHelpers final : public BlockByrefHelpers {
   BlockFieldFlags Flags;
 
 public:
-  ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags)
-    : BlockByrefHelpers(alignment), Flags(flags) {}
-
+  ObjectByrefHelpers(const BlockByrefInfo &info, BlockFieldFlags flags)
+      : BlockByrefHelpers(info), Flags(flags) {}
   void emitCopy(CodeGenFunction &CGF, Address destField,
                 Address 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();
public:
   void profileImpl(llvm::FoldingSetNodeID &id) const override {
     id.AddInteger(Flags.getBitMask());
   }
 };
 
 /// Emits the copy/dispose helpers for an ARC __block __weak variable.
 class ARCWeakByrefHelpers final : public BlockByrefHelpers {
 public:
-  ARCWeakByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}
+  ARCWeakByrefHelpers(const BlockByrefInfo &info) : BlockByrefHelpers(info) {}
 
   void emitCopy(CodeGenFunction &CGF, Address destField,
                 Address srcField) override {
     CGF.EmitARCMoveWeak(destField, srcField);
   }
 
   void emitDispose(CodeGenFunction &CGF, Address 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 final : public BlockByrefHelpers {
 public:
-  ARCStrongByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}
+  ARCStrongByrefHelpers(const BlockByrefInfo &info) : BlockByrefHelpers(info) {}
 
   void emitCopy(CodeGenFunction &CGF, Address destField,
                 Address srcField) override {
     // Do a "move" by copying the value and then zeroing out the old
     // variable.
 
     llvm::Value *value = CGF.Builder.CreateLoad(srcField);
 
void profileImpl(llvm::FoldingSetNodeID &id) const override {
     id.AddInteger(1);
   }
 };
 
 /// Emits the copy/dispose helpers for an ARC __block __strong
 /// variable that's of block-pointer type.
 class ARCStrongBlockByrefHelpers final : public BlockByrefHelpers {
 public:
-  ARCStrongBlockByrefHelpers(CharUnits alignment)
-    : BlockByrefHelpers(alignment) {}
+  ARCStrongBlockByrefHelpers(const BlockByrefInfo &info)
+      : BlockByrefHelpers(info) {}
 
   void emitCopy(CodeGenFunction &CGF, Address destField,
                 Address 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::Value *oldValue = CGF.Builder.CreateLoad(srcField);
     llvm::Value *copy = CGF.EmitARCRetainBlock(oldValue, /*mandatory*/ true);

 
 /// Emits the copy/dispose helpers for a __block variable with a
 /// nontrivial copy constructor or destructor.
 class CXXByrefHelpers final : public BlockByrefHelpers {
   QualType VarType;
   const Expr *CopyExpr;
 
 public:
-  CXXByrefHelpers(CharUnits alignment, QualType type,
+  CXXByrefHelpers(const BlockByrefInfo &info, QualType type,
                   const Expr *copyExpr)
-    : BlockByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {}
+      : BlockByrefHelpers(info), VarType(type), CopyExpr(copyExpr) {}
 
   bool needsCopy() const override { return CopyExpr != nullptr; }
   void emitCopy(CodeGenFunction &CGF, Address destField,
                 Address srcField) override {
     if (!CopyExpr) return;
     CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr);
   }
 

 };
 
 /// 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) {}
+  NonTrivialCStructByrefHelpers(const BlockByrefInfo &info, QualType type)
+      : BlockByrefHelpers(info), 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 {
generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo,
   FunctionDecl *FD = FunctionDecl::Create(
       Context, Context.getTranslationUnitDecl(), SourceLocation(),
       SourceLocation(), II, FunctionTy, nullptr, SC_Static, false, false);
 
   CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   CGF.StartFunction(FD, ReturnTy, Fn, FI, args);
 
-  if (generator.needsCopy()) {
+  if (generator.needsCopy() && !generator.ForceNoopCopy) {
     llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0);
 
     // dst->x
     Address destField = CGF.GetAddrOfLocalVar(&Dst);
     destField = Address(CGF.Builder.CreateLoad(destField),
                         byrefInfo.ByrefAlignment);
     destField = CGF.Builder.CreateBitCast(destField, byrefPtrType);
     destField = CGF.emitBlockByrefAddress(destField, byrefInfo, false,
CodeGenFunction::buildByrefHelpers(llvm::StructType &byrefType,
   const VarDecl &var = *emission.Variable;
   assert(var.isEscapingByref() &&
          "only escaping __block variables need byref helpers");
 
   QualType type = var.getType();
 
   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);
-
   if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) {
     const Expr *copyExpr =
         CGM.getContext().getBlockVarCopyInit(&var).getCopyExpr();
     if (!copyExpr && record->hasTrivialDestructor()) return nullptr;
 
-    return ::buildByrefHelpers(
-        CGM, byrefInfo, CXXByrefHelpers(valueAlignment, type, copyExpr));
+    return ::buildByrefHelpers(CGM, byrefInfo,
+                               CXXByrefHelpers(byrefInfo, type, copyExpr));
   }
 
   // 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));
+    return ::buildByrefHelpers(CGM, byrefInfo,
+                               NonTrivialCStructByrefHelpers(byrefInfo, type));
 
   // 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()) {
     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:
       return ::buildByrefHelpers(CGM, byrefInfo,
-                                 ARCWeakByrefHelpers(valueAlignment));
+                                 ARCWeakByrefHelpers(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()) {
         return ::buildByrefHelpers(CGM, byrefInfo,
-                                   ARCStrongBlockByrefHelpers(valueAlignment));
+                                   ARCStrongBlockByrefHelpers(byrefInfo));
 
       // Otherwise, we transfer ownership of the retain from the stack
       // to the heap.
       } else {
         return ::buildByrefHelpers(CGM, byrefInfo,
-                                   ARCStrongByrefHelpers(valueAlignment));
+                                   ARCStrongByrefHelpers(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;
 
   return ::buildByrefHelpers(CGM, byrefInfo,
-                             ObjectByrefHelpers(valueAlignment, flags));
+                             ObjectByrefHelpers(byrefInfo, flags));
 }
 
 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
                                                const VarDecl *var,
                                                bool followForward) {
   auto &info = getBlockByrefInfo(var);
   return emitBlockByrefAddress(baseAddr, info, followForward, var->getName());
 }
const BlockByrefInfo &CodeGenFunction::getBlockByrefInfo(const VarDecl *D) {
 
   byrefType->setBody(types, packed);
 
   BlockByrefInfo info;
   info.Type = byrefType;
   info.FieldIndex = types.size() - 1;
   info.FieldOffset = varOffset;
   info.ByrefAlignment = std::max(varAlign, getPointerAlign());
+  info.ForceNoopCopy = D->needsInitOnHeap();
 
   auto pair = BlockByrefInfos.insert({D, info});
   assert(pair.second && "info was inserted recursively?");
   return pair.first->second;
 }
 
+void CodeGenFunction::emitByrefInitOnHeap(Address addr) {
+  Address out = CreateDefaultAlignTempAlloca(addr.getType(), "initOnHeap.out");
+  BlockFieldFlags flags = BLOCK_FIELD_IS_BYREF;
+  llvm::Value *args[] = {Builder.CreateBitCast(out.getPointer(), VoidPtrTy),
+                         Builder.CreateBitCast(addr.getPointer(), VoidPtrTy),
+                         llvm::ConstantInt::get(Int32Ty, flags.getBitMask())};
+
+  EmitNounwindRuntimeCall(CGM.getBlockObjectAssign(), args);
+
+  BuildBlockRelease(addr.getPointer(), flags, false);
+}
+
 /// 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.
   Address addr = emission.Addr;
 
   // That's an alloca of the byref structure type.
   llvm::StructType *byrefType = cast<llvm::StructType>(
if (helpers) {
     storeHeaderField(helpers->DisposeHelper, getPointerSize(),
                      "byref.disposeHelper");
   }
 
   if (ByRefHasLifetime && HasByrefExtendedLayout) {
     auto layoutInfo = CGM.getObjCRuntime().BuildByrefLayout(CGM, type);
     storeHeaderField(layoutInfo, getPointerSize(), "byref.layout");
   }
+
+  if (emission.NeedsInitOnHeap)
+    emitByrefInitOnHeap(addr);
 }
 
 void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags,
                                         bool CanThrow) {
   llvm::FunctionCallee F = CGM.getBlockObjectDispose();
   llvm::Value *args[] = {
     Builder.CreateBitCast(V, Int8PtrTy),
     llvm::ConstantInt::get(Int32Ty, flags.getBitMask())

clang/lib/CodeGen/CGDecl.cpp

CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
   assert(
       Ty.getAddressSpace() == LangAS::Default ||
       (Ty.getAddressSpace() == LangAS::opencl_private && getLangOpts().OpenCL));
 
   AutoVarEmission emission(D);
 
   bool isEscapingByRef = D.isEscapingByref();
   emission.IsEscapingByRef = isEscapingByRef;
+  emission.IsCapturedByOwnInit = D.isCapturedByOwnInit();
+  emission.NeedsInitOnHeap = D.needsInitOnHeap();
 
   CharUnits alignment = getContext().getDeclAlign(&D);
 
   // If the type is variably-modified, emit all the VLA sizes for it.
   if (Ty->isVariablyModifiedType())
     EmitVariablyModifiedType(Ty);
 
   auto *DI = getDebugInfo();
CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
   if (emission.useLifetimeMarkers())
     EHStack.pushCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker,
                                          emission.getOriginalAllocatedAddress(),
                                          emission.getSizeForLifetimeMarkers());
 
   return emission;
 }
 
-static bool isCapturedBy(const VarDecl &, const Expr *);
-
-/// Determines whether the given __block variable is potentially
-/// captured by the given statement.
-static bool isCapturedBy(const VarDecl &Var, const Stmt *S) {
-  if (const Expr *E = dyn_cast<Expr>(S))
-    return isCapturedBy(Var, E);
-  for (const Stmt *SubStmt : S->children())
-    if (isCapturedBy(Var, SubStmt))
-      return true;
-  return false;
-}
-
-/// Determines whether the given __block variable is potentially
-/// captured by the given expression.
-static bool isCapturedBy(const VarDecl &Var, const Expr *E) {
-  // Skip the most common kinds of expressions that make
-  // hierarchy-walking expensive.
-  E = E->IgnoreParenCasts();
-
-  if (const BlockExpr *BE = dyn_cast<BlockExpr>(E)) {
-    const BlockDecl *Block = BE->getBlockDecl();
-    for (const auto &I : Block->captures()) {
-      if (I.getVariable() == &Var)
-        return true;
-    }
-
-    // No need to walk into the subexpressions.
-    return false;
-  }
-
-  if (const StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
-    const CompoundStmt *CS = SE->getSubStmt();
-    for (const auto *BI : CS->body())
-      if (const auto *BIE = dyn_cast<Expr>(BI)) {
-        if (isCapturedBy(Var, BIE))
-          return true;
-      }
-      else if (const auto *DS = dyn_cast<DeclStmt>(BI)) {
-          // special case declarations
-          for (const auto *I : DS->decls()) {
-              if (const auto *VD = dyn_cast<VarDecl>((I))) {
-                const Expr *Init = VD->getInit();
-                if (Init && isCapturedBy(Var, Init))
-                  return true;
-              }
-          }
-      }
-      else
-        // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
-        // Later, provide code to poke into statements for capture analysis.
-        return true;
-    return false;
-  }
-
-  for (const Stmt *SubStmt : E->children())
-    if (isCapturedBy(Var, SubStmt))
-      return true;
-
-  return false;
-}
-
 /// Determine whether the given initializer is trivial in the sense
 /// that it requires no code to be generated.
 bool CodeGenFunction::isTrivialInitializer(const Expr *Init) {
   if (!Init)
     return true;
 
   if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
     if (CXXConstructorDecl *Constructor = Construct->getConstructor())
if (emission.IsEscapingByRef)
       drillIntoBlockVariable(*this, Dst, &D);
     defaultInitNonTrivialCStructVar(Dst);
     return;
   }
 
   // Check whether this is a byref variable that's potentially
   // captured and moved by its own initializer.  If so, we'll need to
   // emit the initializer first, then copy into the variable.
-  bool capturedByInit =
-      Init && emission.IsEscapingByRef && isCapturedBy(D, Init);
+  bool capturedByInit = emission.IsCapturedByOwnInit;
 
   bool locIsByrefHeader = !capturedByInit;
   const Address Loc =
       locIsByrefHeader ? emission.getObjectAddress(*this) : emission.Addr;
 
   // Note: constexpr already initializes everything correctly.
   LangOptions::TrivialAutoVarInitKind trivialAutoVarInit =
       (D.isConstexpr()
if (constant && !constant->isZeroValue() &&
                                   replaceUndef(CGM, isPattern, constant));
     }
   }
 
   if (!constant) {
     initializeWhatIsTechnicallyUninitialized(Loc);
     LValue lv = MakeAddrLValue(Loc, type);
     lv.setNonGC(true);
+    if (emission.NeedsInitOnHeap) {
+      drillIntoBlockVariable(*this, lv, &D);
+      capturedByInit = false; // We don't need to drill again.
+    }
     return EmitExprAsInit(Init, &D, lv, capturedByInit);
   }
 
   if (!emission.IsConstantAggregate) {
     // For simple scalar/complex initialization, store the value directly.
     LValue lv = MakeAddrLValue(Loc, type);
     lv.setNonGC(true);
     return EmitStoreThroughLValue(RValue::get(constant), lv, true);
void CodeGenFunction::EmitExprAsInit(const Expr *init, const ValueDecl *D,
   case TEK_Complex: {
     ComplexPairTy complex = EmitComplexExpr(init);
     if (capturedByInit)
       drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
     EmitStoreOfComplex(complex, lvalue, /*init*/ true);
     return;
   }
   case TEK_Aggregate:
+    assert(
+        !capturedByInit &&
+        "Capture-by-initializer should have been handled by NeedsInitOnHeap!");
     if (type->isAtomicType()) {
       EmitAtomicInit(const_cast<Expr*>(init), lvalue);
     } else {
       AggValueSlot::Overlap_t Overlap = AggValueSlot::MayOverlap;
       if (isa<VarDecl>(D))
         Overlap = AggValueSlot::DoesNotOverlap;
       else if (auto *FD = dyn_cast<FieldDecl>(D))
         Overlap = getOverlapForFieldInit(FD);
-      // TODO: how can we delay here if D is captured by its initializer?
       EmitAggExpr(init, AggValueSlot::forLValue(
                             lvalue, *this, AggValueSlot::IsDestructed,
                             AggValueSlot::DoesNotNeedGCBarriers,
                             AggValueSlot::IsNotAliased, Overlap));
     }
     return;
   }
   llvm_unreachable("bad evaluation kind");
void CodeGenFunction::EmitAutoVarCleanups(const AutoVarEmission &emission) {
 
   // If this was emitted as a global constant, we're done.
   if (emission.wasEmittedAsGlobal()) return;
 
   // If we don't have an insertion point, we're done.  Sema prevents
   // us from jumping into any of these scopes anyway.
   if (!HaveInsertPoint()) return;
 
+  // If we're pre-copying, _Block_object_destroy will handle destruction so we
+  // don't need to directly destroy the variable.
+  if (!emission.NeedsInitOnHeap) {
     const VarDecl &D = *emission.Variable;
 
     // Check the type for a cleanup.
     if (QualType::DestructionKind dtorKind = D.needsDestruction(getContext()))
       emitAutoVarTypeCleanup(emission, dtorKind);
 
     // In GC mode, honor objc_precise_lifetime.
     if (getLangOpts().getGC() != LangOptions::NonGC &&
         D.hasAttr<ObjCPreciseLifetimeAttr>()) {
       EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
     }
 
     // Handle the cleanup attribute.
     if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
       const FunctionDecl *FD = CA->getFunctionDecl();
 
       llvm::Constant *F = CGM.GetAddrOfFunction(FD);
       assert(F && "Could not find function!");
 
-    const CGFunctionInfo &Info = CGM.getTypes().arrangeFunctionDeclaration(FD);
-    EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
+      const CGFunctionInfo &Info =
+          CGM.getTypes().arrangeFunctionDeclaration(FD);
+      EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info,
+                                               &D);
+    }
   }
 
   // If this is a block variable, call _Block_object_destroy
   // (on the unforwarded address). Don't enter this cleanup if we're in pure-GC
   // mode.
   if (emission.IsEscapingByRef &&
       CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
     BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF;

clang/lib/CodeGen/CodeGenFunction.h

llvm::Constant *GenerateObjCAtomicGetterCopyHelperFunction(
                                              const ObjCPropertyImplDecl *PID);
   llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
 
   void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags,
                          bool CanThrow);
 
   class AutoVarEmission;
 
+  void emitByrefInitOnHeap(Address addr);
   void emitByrefStructureInit(const AutoVarEmission &emission);
 
   /// 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.
   ///
   /// \param Kind Cleanup kind.
class AutoVarEmission {
     Address Addr;
 
     llvm::Value *NRVOFlag;
 
     /// True if the variable is a __block variable that is captured by an
     /// escaping block.
     bool IsEscapingByRef;
 
+    /// True if the variable is a __block variable that is captured by a block
+    // referenced in its own initializer.
+    bool IsCapturedByOwnInit;
+
+    /// True if the variable is a __block variable that needs to be initialized
+    /// directly on the heap.
+    bool NeedsInitOnHeap;
+
     /// True if the variable is of aggregate type and has a constant
     /// initializer.
     bool IsConstantAggregate;
 
     /// Non-null if we should use lifetime annotations.
     llvm::Value *SizeForLifetimeMarkers;
 
     /// Address with original alloca instruction. Invalid if the variable was

clang/lib/CodeGen/CodeGenModule.h

public:
   /// Record that a function we've visited has mismatched profile data.
   void addMismatched(bool MainFile) { ++Mismatched; }
   /// Whether or not the stats we've gathered indicate any potential problems.
   bool hasDiagnostics() { return Missing || Mismatched; }
   /// Report potential problems we've found to \c Diags.
   void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile);
 };
 
+class BlockByrefInfo;
+
 /// A pair of helper functions for a __block variable.
 class BlockByrefHelpers : public llvm::FoldingSetNode {
   // MSVC requires this type to be complete in order to process this
   // header.
 public:
   llvm::Constant *CopyHelper;
   llvm::Constant *DisposeHelper;
 
   /// The alignment of the field.  This is important because
   /// different offsets to the field within the byref struct need to
   /// have different helper functions.
   CharUnits Alignment;
 
-  BlockByrefHelpers(CharUnits alignment)
-      : CopyHelper(nullptr), DisposeHelper(nullptr), Alignment(alignment) {}
+  /// Emit a trivial copy helper; true if the variable is NeedsInitOnHeap.
+  bool ForceNoopCopy;
+
+  BlockByrefHelpers(const BlockByrefInfo &byrefInfo);
   BlockByrefHelpers(const BlockByrefHelpers &) = default;
   virtual ~BlockByrefHelpers();
 
   void Profile(llvm::FoldingSetNodeID &id) const {
     id.AddInteger(Alignment.getQuantity());
+    id.AddInteger(ForceNoopCopy);
     profileImpl(id);
   }
   virtual void profileImpl(llvm::FoldingSetNodeID &id) const = 0;
 
   virtual bool needsCopy() const { return true; }
   virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = 0;
 
   virtual bool needsDispose() const { return true; }

clang/lib/Sema/Sema.cpp

 // resolve its destructor's exception specification.
 static void checkEscapingByref(VarDecl *VD, Sema &S) {
   QualType T = VD->getType();
   EnterExpressionEvaluationContext scope(
       S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
   SourceLocation Loc = VD->getLocation();
   Expr *VarRef =
       new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
+  // Note: If needsInitOnHeap is true, the move/copy constructor will not
+  // actually be called, so in theory we don't have to require that it exists.
+  // But needsInitOnHeap is based on a conservative estimate of __block
+  // variables that might be retained in their own initializers; it could be
+  // refined in the future, which could cause variables to suddenly start
+  // requiring move constructors again.  To avoid the backwards compatibility
+  // hazard, require it regardless of needsInitOnHeap.
   ExprResult Result = S.PerformMoveOrCopyInitialization(
       InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
       VarRef, /*AllowNRVO=*/true);
   if (!Result.isInvalid()) {
     Result = S.MaybeCreateExprWithCleanups(Result);
     Expr *Init = Result.getAs<Expr>();
     S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
   }
 
   // The destructor's exception specification is needed when IRGen generates
   // block copy/destroy functions. Resolve it here.
   if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
     if (CXXDestructorDecl *DD = RD->getDestructor()) {
       auto *FPT = DD->getType()->getAs<FunctionProtoType>();
       S.ResolveExceptionSpec(Loc, FPT);
     }
 }
 
+/// Determines whether the given __block variable is potentially
+/// captured by a block within the given statement.
+static const BlockExpr *blockThatCaptures(const VarDecl &Var, const Stmt *S) {
+  if (const Expr *E = dyn_cast<Expr>(S)) {
+    // Skip the most common kinds of expressions that make
+    // hierarchy-walking expensive.
+    S = E->IgnoreParenCasts();
+  }
+
+  if (const BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
+    const BlockDecl *Block = BE->getBlockDecl();
+    for (const auto &I : Block->captures()) {
+      if (I.getVariable() == &Var)
+        return BE;
+    }
+
+    // No need to walk into the subexpressions.
+    return nullptr;
+  }
+
+  for (const Stmt *SubStmt : S->children())
+    if (const BlockExpr *BE = blockThatCaptures(Var, SubStmt))
+      return BE;
+  return nullptr;
+}
+
 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
   // Set the EscapingByref flag of __block variables captured by
   // escaping blocks.
   for (const BlockDecl *BD : FSI.Blocks) {
     for (const BlockDecl::Capture &BC : BD->captures()) {
       VarDecl *VD = BC.getVariable();
       if (VD->hasAttr<BlocksAttr>()) {
         // Nothing to do if this is a __block variable captured by a
         // non-escaping block.
         if (BD->doesNotEscape())
           continue;
         VD->setEscapingByref();
+
+        // Possibly set CapturedByOwnInit, which implies needsInitOnHeap (which
+        // we warn about) if the variable is a record.
+        // But only once per variable:
+        if (VD->isCapturedByOwnInit())
+          continue;
+
+        if (Expr *I = VD->getInit())
+          if (const BlockExpr *BE = blockThatCaptures(*VD, I)) {
+            VD->setCapturedByOwnInit();
+
+            if (VD->needsInitOnHeap()) {
+              S.Diag(VD->getLocation(), diag::warn_implicit_block_var_alloc)
+                  << VD;
+              S.Diag(BE->getCaretLocation(),
+                     diag::note_because_captured_by_block);
+            }
+          }
+
+        // __block variables might require us to capture a copy-initializer.
+        // It's currently invalid to ever have a __block variable with an
+        // array type; should we diagnose that here?
+        // Regardless, we don't want to ignore array nesting when
+        // constructing this copy.
+        if (VD->getType()->isStructureOrClassType())
+          checkEscapingByref(VD, S);
       }
       // Check whether the captured variable is or contains an object of
       // non-trivial C union type.
       QualType CapType = BC.getVariable()->getType();
       if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||
           CapType.hasNonTrivialToPrimitiveCopyCUnion())
         S.checkNonTrivialCUnion(BC.getVariable()->getType(),
                                 BD->getCaretLocation(),
                                 Sema::NTCUC_BlockCapture,
                                 Sema::NTCUK_Destruct|Sema::NTCUK_Copy);
     }
   }
-
-  for (VarDecl *VD : FSI.ByrefBlockVars) {
-    // __block variables might require us to capture a copy-initializer.
-    if (!VD->isEscapingByref())
-      continue;
-    // It's currently invalid to ever have a __block variable with an
-    // array type; should we diagnose that here?
-    // Regardless, we don't want to ignore array nesting when
-    // constructing this copy.
-    if (VD->getType()->isStructureOrClassType())
-      checkEscapingByref(VD, S);
-  }
 }
 
 /// Pop a function (or block or lambda or captured region) scope from the stack.
 ///
 /// \param WP The warning policy to use for CFG-based warnings, or null if such
 ///        warnings should not be produced.
 /// \param D The declaration corresponding to this function scope, if producing
 ///        CFG-based warnings.

clang/lib/Serialization/ASTReaderDecl.cpp

if (!isa<ParmVarDecl>(VD)) {
     VD->NonParmVarDeclBits.ObjCForDecl = Record.readInt();
     VD->NonParmVarDeclBits.IsInline = Record.readInt();
     VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
     VD->NonParmVarDeclBits.IsConstexpr = Record.readInt();
     VD->NonParmVarDeclBits.IsInitCapture = Record.readInt();
     VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record.readInt();
     VD->NonParmVarDeclBits.ImplicitParamKind = Record.readInt();
     VD->NonParmVarDeclBits.EscapingByref = Record.readInt();
+    VD->NonParmVarDeclBits.CapturedByOwnInit = Record.readInt();
   }
   auto VarLinkage = Linkage(Record.readInt());
   VD->setCachedLinkage(VarLinkage);
 
   // Reconstruct the one piece of the IdentifierNamespace that we need.
   if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
       VD->getLexicalDeclContext()->isFunctionOrMethod())
     VD->setLocalExternDecl();

clang/lib/Serialization/ASTWriterDecl.cpp

if (!isa<ParmVarDecl>(D)) {
     Record.push_back(D->isConstexpr());
     Record.push_back(D->isInitCapture());
     Record.push_back(D->isPreviousDeclInSameBlockScope());
     if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
       Record.push_back(static_cast<unsigned>(IPD->getParameterKind()));
     else
       Record.push_back(0);
     Record.push_back(D->isEscapingByref());
+    Record.push_back(D->isCapturedByOwnInit());
   }
   Record.push_back(D->getLinkageInternal());
 
   Record.AddVarDeclInit(D);
 
   if (D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) {
     BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D);
     Record.AddStmt(Init.getCopyExpr());
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl
-  Abv->Add(BitCodeAbbrevOp(0));                         // isInline
-  Abv->Add(BitCodeAbbrevOp(0));                         // isInlineSpecified
-  Abv->Add(BitCodeAbbrevOp(0));                         // isConstexpr
-  Abv->Add(BitCodeAbbrevOp(0));                         // isInitCapture
-  Abv->Add(BitCodeAbbrevOp(0));                         // isPrevDeclInSameScope
-  Abv->Add(BitCodeAbbrevOp(0));                         // ImplicitParamKind
-  Abv->Add(BitCodeAbbrevOp(0));                         // EscapingByref
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isInline
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isInlineSpecified
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isConstexpr
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isInitCapture
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isPrevDeclInSameScope
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ImplicitParamKind
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EscapingByref
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CapturedByOwnInit
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // HasConstant*
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
   // Type Source Info
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
   DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
 

clang/test/CodeGenCXX/block-capture.cpp

-// RUN: %clang_cc1 -x c++ -std=c++11 -fblocks -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -x c++ -std=c++11 -fblocks -Wimplicit-block-var-alloc -verify -emit-llvm %s -o - | \
+// RUN:    FileCheck --implicit-check-not "call{{.*}}_ZN3Big" %s
 
 // CHECK: %struct.__block_byref_baz = type { i8*, %struct.__block_byref_baz*, i32, i32, i32 }
 // CHECK: [[baz:%[0-9a-z_]*]] = alloca %struct.__block_byref_baz
 // CHECK: [[bazref:%[0-9a-z_\.]*]] = getelementptr inbounds %struct.__block_byref_baz, %struct.__block_byref_baz* [[baz]], i32 0, i32 1
 // CHECK: store %struct.__block_byref_baz* [[baz]], %struct.__block_byref_baz** [[bazref]]
 // CHECK: bitcast %struct.__block_byref_baz* [[baz]] to i8*
 // CHECK: [[disposable:%[0-9a-z_]*]] = bitcast %struct.__block_byref_baz* [[baz]] to i8*
 // CHECK: call void @_Block_object_dispose(i8* [[disposable]]
 
-int main() {
+int a() {
   __block int baz = [&]() { return 0; }();
-  ^{ (void)baz; };
+  (void)^{ (void)baz; };
   return 0;
 }
+
+class Big {
+public:
+  Big(const Big &);
+  ~Big();
+private:
+  Big();
+  int s[100];
+};
+Big get_Big(Big *(^)());
+
+// CHECK: define void @_Z17implicit_copy_bigv
+// CHECK: call void @_Block_object_assign(i8* {{.*}}, i8* {{.*}}, i32 8)
+// CHECK: call void @_Block_object_dispose(i8* {{.*}}, i32 8)
+// CHECK: %bar1 = getelementptr inbounds %struct.__block_byref_bar, %struct.__block_byref_bar* %{{.*}}, i32 0, i32 6
+// CHECK: call void @_Z7get_BigU13block_pointerFP3BigvE(%class.Big* sret(%class.Big) align 4 %bar1
+// CHECK: call void @_Block_object_dispose
+
+// CHECK: define internal void @__Block_byref_object_copy_
+// (no call to copy constructor)
+
+// CHECK: define internal void @__Block_byref_object_dispose_
+// CHECK: call void @_ZN3BigD1Ev
+
+void implicit_copy_big() {
+  // expected-warning@+1{{variable 'bar' will be initialized in a heap allocation}}
+  __block Big bar =
+    ({ // Make sure this works with statement expressions.
+      get_Big(
+        // expected-note@+1{{because it is captured by a block used in its own initializer}}
+        ^{
+          return &bar;
+        }
+      );
+    });
+}
+
+struct Small { int s[2]; };
+extern Small get_Small(_Atomic(Small) *(^)());
+
+
+// CHECK: %bay1 = getelementptr inbounds %struct.__block_byref_bay, %struct.__block_byref_bay* %{{.*}}, i32 0, i32 4
+// CHECK: [[call:%[0-9a-z_\.]*]] = call i64 @_Z9get_SmallU13block_pointerFPU7_Atomic5SmallvE(%struct.Small* ()* %{{.*}})
+// CHECK: [[dive:%[0-9a-z_\.]*]] = getelementptr inbounds %struct.Small, %struct.Small* %bay1, i32 0, i32 0
+// CHECK: [[cast:%[0-9]*]] = bitcast [2 x i32]* [[dive]] to i64*
+// CHECK: store i64 [[call]], i64* [[cast]], align 8
+
+void implicit_copy_small_atomic() {
+  // expected-warning@+1{{variable 'bay' will be initialized in a heap allocation}}
+  __block _Atomic(Small) bay = get_Small(
+  // expected-note@+1{{because it is captured by a block used in its own initializer}}
+    ^{ return &bay; });
+}