[CodeGen] Emit destructor calls to destruct compound literals

[ahatanak]

Summary

This patch fixes a bug in IRGen where it wasn't calling the destructors to destruct compound literals.

I've split out the changes needed to emit destructor calls for non-trivial C structs returned by function calls and loaded from volatile objects (https://reviews.llvm.org/D66094).

rdar://problem/51867864

[ahatanak]

lib/CodeGen/CGExprAgg.cpp

248

This change wasn't needed to fix the bugs, but I think isExternallyDestructed instead of isIgnored should be called to determine whether the returned value requires destruction.

[rjmccall]

lib/CodeGen/CGExpr.cpp

4158

Unfortunately, the lifetime of compound literals in C is not this simple; they're like blocks in that they're destroyed at the end of the enclosing scope rather than at the end of the current statement. (The cleanup here will be popped at the end of the full-expression if we've entered an ExprWithCleanups.) And the l-value case is exactly the case where this matters.

I think you need to do something like what we do with blocks, where we record all the blocks in the full-expression on the ExprWithCleanups so that we can push an inactive cleanup for them and then activate it when we emit the block.

lib/CodeGen/CGExprAgg.cpp

248

Agreed.

668

The cleanup shouldn't be pushed until after you've finished evaluating the initializer.

[ahatanak]

• Emit member access, compound literal, and call expressions as subexpressions of ExprWithCleanups if the expressions are of C struct types that require non-trivial destruction. This fixes the bug in IRGen where it was destructing the function return at the end of the enclosing scope rather than at the end of the full expression (see the changes made in test/CodeGenObjC/arc.m).
• Add compound literal expressions with automatic storage duration to the list of cleanup objects of ExprWithCleanups if the expressions have C struct types requiring non-trivial destruction. This enables IRGen to destruct the compound literals at the end of their enclosing scopes.

[rjmccall]

include/clang/AST/ExprCXX.h

3220

Might be worth spelling out and block-scoped compound literals here.

include/clang/Basic/DiagnosticSemaKinds.td

5171

Ah, good catch.

include/clang/Sema/Sema.h

587

I think the second sentence in this comment is no longer useful; you can just strike it.

lib/CodeGen/CGBlocks.cpp

863

This comment is no longer accurate. If you want to move the function, please do so in a separate commit, though.

lib/CodeGen/CGCleanup.cpp

1283

Please include in the comment here that this doesn't apply in C++, where the compound literal has temporary lifetime.

Can we clarify that we're talking about block-scope literals in all the new method names?

lib/CodeGen/CGDecl.cpp

555

It'd be nice to not shadow the enclosing variable.

lib/CodeGen/CGExpr.cpp

4158

Can we make the check here something like (1) this is a block-scope compound literal and (2) it has a non-trivially-destructed type (of any kind)? That way we're not conflating two potentially unrelated elements, the lifetime of the object and the kinds of types that can be constructed by the literal.

Oh, actually, there's a concrete reason to do this: C99 compound literals are not required to have struct type; they can have any object type, including arrays but also scalars. So we could, even without non-trivial C structs, have a block-scope compound of type __strong id[]; I guess we've always just gotten this wrong. Please add tests for this case. :)

4647

Does EmitCallExpr not enter a cleanup when it returns an aggregate that's not into an externally-destructed slot? That seems wrong and dangerous.

[ahatanak]

lib/CodeGen/CGExpr.cpp

4647

I'm going to split this patch into two parts, one for compound literals and the other for everything else. The patch is getting too large and I also found another bug: a cleanup isn't pushed for ObjC message send.

[martong]

test/Import/objc-arc/Inputs/cleanup-objects.m

6

Perhaps then this patch depends on another patch which implements the import of a BlockExpr?
Or maybe the branch if (auto *BD = From.dyn_cast<BlockDecl *>()) should be left out from the ASTImporter code, and this way BlockExpr and BlockDecl would be implemented later in another patch.

[ahatanak]

Address review comments:

• Destruct compound literals of ObjC array types too.
• Use pushLifetimeExtendedDestroy to extend the lifetime of compound literals to the end of the surrounding block. This simplifies the changes made in IRGen, but I was wondering whether we should do what we do to extend lifetime of block captures instead.

[ahatanak]

test/Import/objc-arc/Inputs/cleanup-objects.m

6

Yes, I removed it from ASTImporter::Import and left a FIXME comment there.

[ahatanak]

lib/CodeGen/CGExpr.cpp

4158

There is a check E->isFileScope() above this. Is that sufficient to check for block-scoped compound literals?

[martong]

clang/lib/AST/ASTImporter.cpp

7918 ↗

(On Diff #247919)

I think

return make_error<ImportError(ImportError::UnsupportedConstruct);

would be more appropriate here as this expresses that we do not support every aspect yet.

On the other hand a nullptr could be dereferenced later and thus could cause an unwanted crash.

[ahatanak]

Return make_error<ImportError> instead of a nullptr.

[rjmccall]

lib/CodeGen/CGExpr.cpp

4158

That plus the C/C++ difference; compound literals in C++ are just temporaries.

[rjmccall]

This patch looks good except for that C/C++ semantic difference. A compound literal temporary can be lifetime-extended in C++, but only in the standard way of binding a reference to it.

[ahatanak]

lib/CodeGen/CGExpr.cpp

4158

I haven't been able to come up with a piece of C++ code that executes EmitCompoundLiteralLValue. The following code gets rejected because you can't take the address of a temporary object in C++:

StrongSmall *p = &(StrongSmall){ 1, 0 };

If a bind a reference to it, AggExprEmitter::VisitCompoundLiteralExpr is called.

[rjmccall]

lib/CodeGen/CGExpr.cpp

4158

That makes sense; they're not gl-values in C++. It would be reasonable to assert that. But the C++ point does apply elsewhere.

[ahatanak]

Don't try to push a cleanup in C++.

[ahatanak]

lib/CodeGen/CGExpr.cpp

4158

It turns out this function is called in C++ when the compound literal is a vector type, so I've just added a check for C++ instead of an assert.

[rjmccall]

clang/lib/CodeGen/CGBlocks.cpp

869 ↗

(On Diff #248797)

I wonder if we could just switch blocks to the same thing.

clang/lib/Sema/SemaExpr.cpp

6271 ↗

(On Diff #248797)

This should all be conditional on C++ (but you should leave a comment explaining why).

clang/lib/Serialization/ASTWriterStmt.cpp

1729 ↗

(On Diff #248797)

Will this just serialize a second copy of the compound literal expression?

lib/CodeGen/CGExpr.cpp

4158

Really? Is the expression actually an l-value in this case somehow?

[martong]

Looks good from the ASTImporter's point of view. I don't have the competence to review the rest, so I am resigning.

[ahatanak]

Address review comments

[ahatanak]

clang/lib/CodeGen/CGBlocks.cpp

869 ↗

(On Diff #248797)

I think we can, but I haven't tried. We can fix it in a separate patch.

clang/lib/CodeGen/CGExprAgg.cpp

664 ↗

(On Diff #249173)

I fixed the way IsExternallyDestructed is used based on the comment in the other review.

clang/lib/Serialization/ASTWriterStmt.cpp

1729 ↗

(On Diff #248797)

This should emit a serialization::STMT_REF_PTR record, which is a reference to the previously serialized compound literal (see ASTWriter::WriteSubStmt).

lib/CodeGen/CGExpr.cpp

4158

I see this function being called when ScalarExprEmitter::VisitCompoundLiteralExpr calls EmitLoadOfLValue.

[rjmccall]

Minor comments; otherwise LGTM.

clang/lib/Sema/SemaExpr.cpp

6256 ↗

(On Diff #249173)

Probably add "in C; in C++, they're just temporaries".

lib/CodeGen/CGExpr.cpp

4158

Okay. As a general rule, nothing should be calling EmitLValue on an expression that isn't actually an l-value. It's a little more reasonable here because it's more like a helper routine. If this is the cleanest way to handle this in C++, it's okay, but please leave a comment explaining that here.

[ahatanak]

lib/CodeGen/CGExpr.cpp

4158

I added a comment in ScalarExprEmitter::VisitCompoundLiteralExpr.

include/clang/AST/ASTImporter.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_ASTIMPORTER_H
 #define LLVM_CLANG_AST_ASTIMPORTER_H
 
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclarationName.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
public:
     template <typename ImportT>
     LLVM_NODISCARD llvm::Error importInto(ImportT &To, const ImportT &From) {
       auto ToOrErr = Import(From);
       if (ToOrErr)
         To = *ToOrErr;
       return ToOrErr.takeError();
     }
 
+    /// Import cleanup objects owned by ExprWithCleanup.
+    llvm::Expected<ExprWithCleanups::CleanupObject>
+    Import(ExprWithCleanups::CleanupObject From);
+
     /// Import the given type from the "from" context into the "to"
     /// context. A null type is imported as a null type (no error).
     ///
     /// \returns The equivalent type in the "to" context, or the import error.
     llvm::Expected<QualType> Import(QualType FromT);
 
     /// Import the given type source information from the
     /// "from" context into the "to" context.

include/clang/AST/ExprCXX.h

 /// expressions can create cleanups, including basically every
 /// call in ARC that returns an Objective-C pointer.
 ///
 /// This expression also tracks whether the sub-expression contains a
 /// potentially-evaluated block literal.  The lifetime of a block
 /// literal is the extent of the enclosing scope.
 class ExprWithCleanups final
     : public FullExpr,
-      private llvm::TrailingObjects<ExprWithCleanups, BlockDecl *> {
+      private llvm::TrailingObjects<
+          ExprWithCleanups,
+          llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
 public:
   /// The type of objects that are kept in the cleanup.
-  /// It's useful to remember the set of blocks;  we could also
-  /// remember the set of temporaries, but there's currently
-  /// no need.
-  using CleanupObject = BlockDecl *;
+  /// It's useful to remember the set of blocks and compound literals; we could
+  /// also remember the set of temporaries, but there's currently no need.
+  using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>;
 
 private:
   friend class ASTStmtReader;
   friend TrailingObjects;
 
   ExprWithCleanups(EmptyShell, unsigned NumObjects);
   ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
                    ArrayRef<CleanupObject> Objects);

include/clang/AST/TextNodeDumper.h

public:
   void dumpPointer(const void *Ptr);
   void dumpLocation(SourceLocation Loc);
   void dumpSourceRange(SourceRange R);
   void dumpBareType(QualType T, bool Desugar = true);
   void dumpType(QualType T);
   void dumpBareDeclRef(const Decl *D);
   void dumpName(const NamedDecl *ND);
   void dumpAccessSpecifier(AccessSpecifier AS);
+  void dumpCleanupObject(const ExprWithCleanups::CleanupObject &C);
 
   void dumpDeclRef(const Decl *D, StringRef Label = {});
 
   void visitTextComment(const comments::TextComment *C,
                         const comments::FullComment *);
   void visitInlineCommandComment(const comments::InlineCommandComment *C,
                                  const comments::FullComment *);
   void visitHTMLStartTagComment(const comments::HTMLStartTagComment *C,

include/clang/Basic/DiagnosticSemaKinds.td

def note_enters_block_captures_cxx_obj : Note<
   "jump enters lifetime of block which captures a destructible C++ object">;
 def note_enters_block_captures_strong : Note<
   "jump enters lifetime of block which strongly captures a variable">;
 def note_enters_block_captures_weak : Note<
   "jump enters lifetime of block which weakly captures a variable">;
 def note_enters_block_captures_non_trivial_c_struct : Note<
   "jump enters lifetime of block which captures a C struct that is non-trivial "
   "to destroy">;
+def note_enters_compound_literal_scope : Note<
+  "jump enters lifetime of a compound literal that is non-trivial to destruct">;
 
 def note_exits_cleanup : Note<
   "jump exits scope of variable with __attribute__((cleanup))">;
 def note_exits_dtor : Note<
   "jump exits scope of variable with non-trivial destructor">;
 def note_exits_temporary_dtor : Note<
   "jump exits scope of lifetime-extended temporary with non-trivial "
   "destructor">;
def note_exits_block_captures_cxx_obj : Note<
   "jump exits lifetime of block which captures a destructible C++ object">;
 def note_exits_block_captures_strong : Note<
   "jump exits lifetime of block which strongly captures a variable">;
 def note_exits_block_captures_weak : Note<
   "jump exits lifetime of block which weakly captures a variable">;
 def note_exits_block_captures_non_trivial_c_struct : Note<
   "jump exits lifetime of block which captures a C struct that is non-trivial "
   "to destroy">;
+def note_exits_compound_literal_scope : Note<
+  "jump exits lifetime of a compound literal that is non-trivial to destruct">;
 
 def err_func_returning_qualified_void : ExtWarn<
   "function cannot return qualified void type %0">,
   InGroup<DiagGroup<"qualified-void-return-type">>;
 def err_func_returning_array_function : Error<
   "function cannot return %select{array|function}0 type %1">;
 def err_field_declared_as_function : Error<"field %0 declared as a function">;
 def err_field_incomplete : Error<"field has incomplete type %0">;

include/clang/Sema/Sema.h

public:
   /// if Sema is already doing so, which would cause infinite recursions.
   bool IsBuildingRecoveryCallExpr;
 
   /// Used to control the generation of ExprWithCleanups.
   CleanupInfo Cleanup;
 
   /// ExprCleanupObjects - This is the stack of objects requiring
   /// cleanup that are created by the current full expression.  The
   /// element type here is ExprWithCleanups::Object.
-  SmallVector<BlockDecl*, 8> ExprCleanupObjects;
+  SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
 
   /// Store a set of either DeclRefExprs or MemberExprs that contain a reference
   /// to a variable (constant) that may or may not be odr-used in this Expr, and
   /// we won't know until all lvalue-to-rvalue and discarded value conversions
   /// have been applied to all subexpressions of the enclosing full expression.
   /// This is cleared at the end of each full expression.
   using MaybeODRUseExprSet = llvm::SmallPtrSet<Expr *, 2>;
   MaybeODRUseExprSet MaybeODRUseExprs;

include/clang/Serialization/ASTBitCodes.h

#include "clang/Basic/OpenCLExtensionTypes.def"
     /// CtorInitializer.
     enum CtorInitializerType {
       CTOR_INITIALIZER_BASE,
       CTOR_INITIALIZER_DELEGATING,
       CTOR_INITIALIZER_MEMBER,
       CTOR_INITIALIZER_INDIRECT_MEMBER
     };
 
+    /// Kinds of cleanup objects owned by ExprWithCleanups.
+    enum CleanupObjectKind {
+      COK_Block,
+      COK_CompoundLiteral
+    };
+
     /// Describes the redeclarations of a declaration.
     struct LocalRedeclarationsInfo {
       // The ID of the first declaration
       DeclID FirstID;
 
       // Offset into the array of redeclaration chains.
       unsigned Offset;
 

lib/AST/ASTImporter.cpp

Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
   ASTNodeImporter Importer(*this);
   return Importer.Visit(FromD);
 }
 
 void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
   MapImported(FromD, ToD);
 }
 
+llvm::Expected<ExprWithCleanups::CleanupObject>
+ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
+  if (auto *BD = From.dyn_cast<BlockDecl *>()) {
+    if (Expected<Decl *> R = Import(BD))
+      return ExprWithCleanups::CleanupObject(cast<BlockDecl>(*R));
+  } else if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
+    if (Expected<Expr *> R = Import(CLE))
+      return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
+  }
+
+  return nullptr;
+}
+
 Expected<QualType> ASTImporter::Import(QualType FromT) {
   if (FromT.isNull())
     return QualType{};
 
   const Type *FromTy = FromT.getTypePtr();
 
   // Check whether we've already imported this type.
   llvm::DenseMap<const Type *, const Type *>::iterator Pos

lib/AST/JSONNodeDumper.cpp

 }
 
 void JSONNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *EWC) {
   attributeOnlyIfTrue("cleanupsHaveSideEffects",
                       EWC->cleanupsHaveSideEffects());
   if (EWC->getNumObjects()) {
     JOS.attributeArray("cleanups", [this, EWC] {
       for (const ExprWithCleanups::CleanupObject &CO : EWC->getObjects())
-        JOS.value(createBareDeclRef(CO));
+        if (auto *BD = CO.dyn_cast<BlockDecl *>()) {
+          JOS.value(createBareDeclRef(BD));
+        } else if (auto *CLE = CO.dyn_cast<CompoundLiteralExpr *>()) {
+          llvm::json::Object Obj;
+          Obj["id"] = createPointerRepresentation(CLE);
+          Obj["kind"] = CLE->getStmtClassName();
+          JOS.value(std::move(Obj));
+        } else {
+          llvm_unreachable("unexpected cleanup object type");
+        }
     });
   }
 }
 
 void JSONNodeDumper::VisitCXXBindTemporaryExpr(
     const CXXBindTemporaryExpr *BTE) {
   const CXXTemporary *Temp = BTE->getTemporary();
   JOS.attribute("temp", createPointerRepresentation(Temp));

lib/AST/TextNodeDumper.cpp

case AS_protected:
     OS << "protected";
     break;
   case AS_private:
     OS << "private";
     break;
   }
 }
 
+void TextNodeDumper::dumpCleanupObject(
+    const ExprWithCleanups::CleanupObject &C) {
+  if (auto *BD = C.dyn_cast<BlockDecl *>())
+    dumpDeclRef(BD, "cleanup");
+  else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
+    AddChild([=] {
+      OS << "cleanup ";
+      {
+        ColorScope Color(OS, ShowColors, StmtColor);
+        OS << CLE->getStmtClassName();
+      }
+      dumpPointer(CLE);
+    });
+  else
+    llvm_unreachable("unexpected cleanup type");
+}
+
 void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
   if (!D)
     return;
 
   AddChild([=] {
     if (!Label.empty())
       OS << Label << ' ';
     dumpBareDeclRef(D);
void TextNodeDumper::VisitMaterializeTemporaryExpr(
   if (const ValueDecl *VD = Node->getExtendingDecl()) {
     OS << " extended by ";
     dumpBareDeclRef(VD);
   }
 }
 
 void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
   for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
-    dumpDeclRef(Node->getObject(i), "cleanup");
+    dumpCleanupObject(Node->getObject(i));
 }
 
 void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
   dumpPointer(Node->getPack());
   dumpName(Node->getPack());
 }
 
 void TextNodeDumper::VisitCXXDependentScopeMemberExpr(

lib/CodeGen/CGBlocks.cpp

for (const auto &CI : block->captures()) {
 
     // 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 FullExpr *E) {
   if (const auto EWC = dyn_cast<ExprWithCleanups>(E)) {
+    auto *DomInst = Builder.CreateAlignedLoad(
+        Int8Ty, llvm::Constant::getNullValue(Int8PtrTy),
+        CharUnits::One());
+    DominatingIPs.push_back(DomInst);
+
     assert(EWC->getNumObjects() != 0);
     for (const ExprWithCleanups::CleanupObject &C : EWC->getObjects())
-      enterBlockScope(*this, C);
+      if (auto *BD = C.dyn_cast<BlockDecl *>())
+        enterBlockScope(*this, BD);
+      else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
+        enterCompoundLiteralScope(CLE, DomInst);
+      else
+        llvm_unreachable("unexpected cleanup object type");
   }
 }
 
 /// 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);

lib/CodeGen/CGCleanup.cpp

 
 /// Emits all the code to cause the given temporary to be cleaned up.
 void CodeGenFunction::EmitCXXTemporary(const CXXTemporary *Temporary,
                                        QualType TempType,
                                        Address Ptr) {
   pushDestroy(NormalAndEHCleanup, Ptr, TempType, destroyCXXObject,
               /*useEHCleanup*/ true);
 }
+
+void CodeGenFunction::enterCompoundLiteralScope(const CompoundLiteralExpr *CLE,
+                                                llvm::Instruction *DomInst) {
+  // The lifetime of a compound literal with automatic storage duration ends at
+  // the end of its enclosing block. Push an inactive cleanup here so that its
+  // destructor is called when the lifetime ends.
+  QualType Ty = CLE->getType();
+  QualType::DestructionKind DtorKind = Ty.isDestructedType();
+  assert(DtorKind == QualType::DK_nontrivial_c_struct &&
+         "non-trivial C struct type expected here");
+  bool UseArrayEHCleanup = needsEHCleanup(DtorKind);
+  CleanupKind CK = UseArrayEHCleanup ?
+      InactiveNormalAndEHCleanup : InactiveNormalCleanup;
+  pushCompoundLiteralCleanup(CK, CLE, getDestroyer(DtorKind),
+                             UseArrayEHCleanup);
+  CompoundLiteralCleanupInfoMap[CLE].setCleanup(
+      EHStack.stable_begin(), DomInst);
+}

lib/CodeGen/CGDecl.cpp

struct DestroyNRVOVariableC final
     DestroyNRVOVariableC(Address addr, llvm::Value *NRVOFlag, QualType Ty)
         : DestroyNRVOVariable<DestroyNRVOVariableC>(addr, Ty, NRVOFlag) {}
 
     void emitDestructorCall(CodeGenFunction &CGF) {
       CGF.destroyNonTrivialCStruct(CGF, Loc, Ty);
     }
   };
 
+  /// A cleanup for destructing compound literals that have automatic storage
+  /// duration and are of C struct types that are non-trivial to destruct.
+  struct DestroyCompoundLiteral final : EHScopeStack::Cleanup {
+    DestroyCompoundLiteral(const CompoundLiteralExpr *CLE,
+                           CodeGenFunction::Destroyer *destroyer,
+                           bool useEHCleanupForArray)
+      : CLE(CLE), destroyer(destroyer),
+        useEHCleanupForArray(useEHCleanupForArray) {}
+
+    const CompoundLiteralExpr *CLE;
+    CodeGenFunction::Destroyer *destroyer;
+    bool useEHCleanupForArray;
+
+    void Emit(CodeGenFunction &CGF, Flags flags) override {
+      // Don't use an EH cleanup recursively from an EH cleanup.
+      bool useEHCleanupForArray =
+          flags.isForNormalCleanup() && this->useEHCleanupForArray;
+      CGF.emitDestroy(CGF.CompoundLiteralCleanupInfoMap[CLE].getAddr(),
+                      CLE->getType(), destroyer, useEHCleanupForArray);
+    }
+  };
+
   struct CallStackRestore final : EHScopeStack::Cleanup {
     Address Stack;
     CallStackRestore(Address Stack) : Stack(Stack) {}
     void Emit(CodeGenFunction &CGF, Flags flags) override {
       llvm::Value *V = CGF.Builder.CreateLoad(Stack);
       llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
       CGF.Builder.CreateCall(F, V);
     }

 
 void CodeGenFunction::pushDestroy(CleanupKind cleanupKind, Address addr,
                                   QualType type, Destroyer *destroyer,
                                   bool useEHCleanupForArray) {
   pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
                                      destroyer, useEHCleanupForArray);
 }
 
+void CodeGenFunction::pushCompoundLiteralCleanup(CleanupKind cleanupKind,
+                                                 const CompoundLiteralExpr *CLE,
+                                                 Destroyer *destroyer,
+                                                 bool useEHCleanupForArray) {
+  pushFullExprCleanup<DestroyCompoundLiteral>(cleanupKind, CLE, destroyer,
+                                              useEHCleanupForArray);
+}
+
 void CodeGenFunction::pushStackRestore(CleanupKind Kind, Address SPMem) {
   EHStack.pushCleanup<CallStackRestore>(Kind, SPMem);
 }
 
 void CodeGenFunction::pushLifetimeExtendedDestroy(
     CleanupKind cleanupKind, Address addr, QualType type,
     Destroyer *destroyer, bool useEHCleanupForArray) {
   // Push an EH-only cleanup for the object now.

lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
 
   Address DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
   const Expr *InitExpr = E->getInitializer();
   LValue Result = MakeAddrLValue(DeclPtr, E->getType(), AlignmentSource::Decl);
 
   EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
                    /*Init*/ true);
 
+  // If the compound literal has a non-trivial C struct type, activate the
+  // cleanup that was pushed at the entry of the full expression and record the
+  // address of the aggregate.
+  if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) {
+    CompoundLiteralCleanupInfo &Info = CompoundLiteralCleanupInfoMap[E];
+    ActivateCleanupBlock(Info.Cleanup, Info.DominatingIP);
+    Info.setAddr(DeclPtr);
+  }
+
   return Result;
 }
 
 LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
   if (!E->isGLValue())
     // Initializing an aggregate temporary in C++11: T{...}.
     return EmitAggExprToLValue(E);
 
case TEK_Aggregate:
     return EmitAggExprToLValue(E);
   }
   llvm_unreachable("bad evaluation kind");
 }
 
 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
   RValue RV = EmitCallExpr(E);
 
+  if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
+    pushDestroy(QualType::DK_nontrivial_c_struct, RV.getAggregateAddress(),
+                E->getType());
+
   if (!RV.isScalar())
     return MakeAddrLValue(RV.getAggregateAddress(), E->getType(),
                           AlignmentSource::Decl);
 
   assert(E->getCallReturnType(getContext())->isReferenceType() &&
          "Can't have a scalar return unless the return type is a "
          "reference type!");
 

lib/CodeGen/CGExprAgg.cpp

bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
   // Check whether the type has an object member.
   return Record->hasObjectMember();
 }
 
 void AggExprEmitter::withReturnValueSlot(
     const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
   QualType RetTy = E->getType();
   bool RequiresDestruction =
-      Dest.isIgnored() &&
+      !Dest.isExternallyDestructed() &&
       RetTy.isDestructedType() == QualType::DK_nontrivial_c_struct;
 
   // If it makes no observable difference, save a memcpy + temporary.
   //
   // We need to always provide our own temporary if destruction is required.
   // Otherwise, EmitCall will emit its own, notice that it's "unused", and end
   // its lifetime before we have the chance to emit a proper destructor call.
   bool UseTemp = Dest.isPotentiallyAliased() || Dest.requiresGCollection() ||
if (Dest.isPotentiallyAliased() &&
     // For a POD type, just emit a load of the lvalue + a copy, because our
     // compound literal might alias the destination.
     EmitAggLoadOfLValue(E);
     return;
   }
 
   AggValueSlot Slot = EnsureSlot(E->getType());
   CGF.EmitAggExpr(E->getInitializer(), Slot);
+
+  // If the compound literal has a non-trivial C struct type, activate the
+  // cleanup that was pushed at the entry of the full expression and record the
+  // address of the aggregate.
+  if (!Slot.isExternallyDestructed() &&
+      E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) {
+    CodeGenFunction::CompoundLiteralCleanupInfo &Info =
+        CGF.CompoundLiteralCleanupInfoMap[E];
+    CGF.ActivateCleanupBlock(Info.Cleanup, Info.DominatingIP);
+    Info.setAddr(Slot.getAddress());
+    Slot.setExternallyDestructed();
+  }
 }
 
 /// Attempt to look through various unimportant expressions to find a
 /// cast of the given kind.
 static Expr *findPeephole(Expr *op, CastKind kind) {
   while (true) {
     op = op->IgnoreParens();
     if (CastExpr *castE = dyn_cast<CastExpr>(op)) {
void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   case CK_AddressSpaceConversion:
      return Visit(E->getSubExpr());
 
   case CK_LValueToRValue:
     // If we're loading from a volatile type, force the destination
     // into existence.
     if (E->getSubExpr()->getType().isVolatileQualified()) {
       EnsureDest(E->getType());
-      return Visit(E->getSubExpr());
+      Visit(E->getSubExpr());
+
+      if (!Dest.isExternallyDestructed() &&
+          E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) {
+        CGF.pushDestroy(QualType::DK_nontrivial_c_struct, Dest.getAddress(),
+                        E->getType());
+        Dest.setExternallyDestructed();
+      }
+
+      return;
     }
 
     LLVM_FALLTHROUGH;
 
 
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_ConstructorConversion:

lib/CodeGen/CodeGenFunction.h

if (CurLexicalScope)
       return CurLexicalScope->hasLabels();
     return !LabelMap.empty();
   }
 
   /// AllocaInsertPoint - This is an instruction in the entry block before which
   /// we prefer to insert allocas.
   llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
 
+  /// List of dominating IPs. These instructions are deleted after IR generation
+  /// of a function is completed.
+  SmallVector<llvm::Instruction *, 1> DominatingIPs;
+
   /// API for captured statement code generation.
   class CGCapturedStmtInfo {
   public:
     explicit CGCapturedStmtInfo(CapturedRegionKind K = CR_Default)
         : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {}
     explicit CGCapturedStmtInfo(const CapturedStmt &S,
                                 CapturedRegionKind K = CR_Default)
       : Kind(K), ThisValue(nullptr), CXXThisFieldDecl(nullptr) {
public:
   /// Value returned by __exception_info intrinsic.
   llvm::Value *SEHInfo = nullptr;
 
   /// Emits a landing pad for the current EH stack.
   llvm::BasicBlock *EmitLandingPad();
 
   llvm::BasicBlock *getInvokeDestImpl();
 
+  /// This struct has the information that is needed to destruct a compound
+  /// literal with automatic storage duration that has a C struct type that is
+  /// non-trivial to destruct.
+  struct CompoundLiteralCleanupInfo {
+    EHScopeStack::stable_iterator Cleanup;
+    llvm::Instruction *DominatingIP;
+    llvm::Value *AddrPtr;
+    CharUnits AddrAlignment;
+
+    void setCleanup(EHScopeStack::stable_iterator C, llvm::Instruction *D) {
+      Cleanup = C;
+      DominatingIP = D;
+    }
+    void setAddr(Address Addr) {
+      AddrPtr = Addr.getPointer();
+      AddrAlignment = Addr.getAlignment();
+    }
+    Address getAddr() const {
+      return Address(AddrPtr, AddrAlignment);
+    }
+  };
+
+  llvm::DenseMap<const CompoundLiteralExpr *, CompoundLiteralCleanupInfo>
+      CompoundLiteralCleanupInfoMap;
+
   template <class T>
   typename DominatingValue<T>::saved_type saveValueInCond(T value) {
     return DominatingValue<T>::save(*this, value);
   }
 
 public:
   /// ObjCEHValueStack - Stack of Objective-C exception values, used for
   /// rethrows.
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
                                       Destroyer *destroyer);
 
   void pushDestroy(QualType::DestructionKind dtorKind,
                    Address addr, QualType type);
   void pushEHDestroy(QualType::DestructionKind dtorKind,
                      Address addr, QualType type);
   void pushDestroy(CleanupKind kind, Address addr, QualType type,
                    Destroyer *destroyer, bool useEHCleanupForArray);
+  void pushCompoundLiteralCleanup(CleanupKind kind,
+                                  const CompoundLiteralExpr *CLE,
+                                  Destroyer *destroyer,
+                                  bool useEHCleanupForArray);
   void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr,
                                    QualType type, Destroyer *destroyer,
                                    bool useEHCleanupForArray);
   void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
                                    llvm::Value *CompletePtr,
                                    QualType ElementType);
   void pushStackRestore(CleanupKind kind, Address SPMem);
   void emitDestroy(Address addr, QualType type, Destroyer *destroyer,
public:
   void enterFullExpression(const FullExpr *E) {
     if (const auto *EWC = dyn_cast<ExprWithCleanups>(E))
       if (EWC->getNumObjects() == 0)
         return;
     enterNonTrivialFullExpression(E);
   }
   void enterNonTrivialFullExpression(const FullExpr *E);
 
+  void enterCompoundLiteralScope(const CompoundLiteralExpr *CLE,
+                                 llvm::Instruction *DomInst);
+
   void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
 
   RValue EmitAtomicExpr(AtomicExpr *E);
 
   //===--------------------------------------------------------------------===//
   //                         Annotations Emission
   //===--------------------------------------------------------------------===//
 

lib/CodeGen/CodeGenFunction.cpp

if (!EscapedLocals.empty()) {
     CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
   }
 
   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
   llvm::Instruction *Ptr = AllocaInsertPt;
   AllocaInsertPt = nullptr;
   Ptr->eraseFromParent();
 
+  for (auto I : DominatingIPs)
+    I->eraseFromParent();
+
   // If someone took the address of a label but never did an indirect goto, we
   // made a zero entry PHI node, which is illegal, zap it now.
   if (IndirectBranch) {
     llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
     if (PN->getNumIncomingValues() == 0) {
       PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
       PN->eraseFromParent();
     }

lib/Sema/JumpDiagnostics.cpp

class JumpScopeChecker {
   SmallVector<LabelDecl*, 4> IndirectJumpTargets;
   SmallVector<LabelDecl*, 4> AsmJumpTargets;
 public:
   JumpScopeChecker(Stmt *Body, Sema &S);
 private:
   void BuildScopeInformation(Decl *D, unsigned &ParentScope);
   void BuildScopeInformation(VarDecl *D, const BlockDecl *BDecl,
                              unsigned &ParentScope);
+  void BuildScopeInformation(CompoundLiteralExpr *CLE, unsigned &ParentScope);
   void BuildScopeInformation(Stmt *S, unsigned &origParentScope);
 
   void VerifyJumps();
   void VerifyIndirectOrAsmJumps(bool IsAsmGoto);
   void NoteJumpIntoScopes(ArrayRef<unsigned> ToScopes);
   void DiagnoseIndirectOrAsmJump(Stmt *IG, unsigned IGScope, LabelDecl *Target,
                                  unsigned TargetScope);
   void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
if (destructKind != QualType::DK_none) {
     if (Loc.isInvalid())
       Loc = BDecl->getLocation();
     Scopes.push_back(GotoScope(ParentScope,
                                Diags.first, Diags.second, Loc));
     ParentScope = Scopes.size()-1;
   }
 }
 
+/// Build scope information for compound literals of C struct types that are
+/// non-trivial to destruct.
+void JumpScopeChecker::BuildScopeInformation(CompoundLiteralExpr *CLE,
+                                             unsigned &ParentScope) {
+  unsigned InDiag = diag::note_enters_compound_literal_scope;
+  unsigned OutDiag = diag::note_exits_compound_literal_scope;
+  Scopes.push_back(GotoScope(ParentScope, InDiag, OutDiag, CLE->getExprLoc()));
+  ParentScope = Scopes.size() - 1;
+}
+
 /// BuildScopeInformation - The statements from CI to CE are known to form a
 /// coherent VLA scope with a specified parent node.  Walk through the
 /// statements, adding any labels or gotos to LabelAndGotoScopes and recursively
 /// walking the AST as needed.
 void JumpScopeChecker::BuildScopeInformation(Stmt *S,
                                              unsigned &origParentScope) {
   // If this is a statement, rather than an expression, scopes within it don't
   // propagate out into the enclosing scope.  Otherwise we have to worry
void JumpScopeChecker::BuildScopeInformation(Stmt *S,
   }
 
   case Stmt::ExprWithCleanupsClass: {
     // Disallow jumps past full-expressions that use blocks with
     // non-trivial cleanups of their captures.  This is theoretically
     // implementable but a lot of work which we haven't felt up to doing.
     ExprWithCleanups *EWC = cast<ExprWithCleanups>(S);
     for (unsigned i = 0, e = EWC->getNumObjects(); i != e; ++i) {
-      const BlockDecl *BDecl = EWC->getObject(i);
+      if (auto *BDecl = EWC->getObject(i).dyn_cast<BlockDecl *>())
         for (const auto &CI : BDecl->captures()) {
           VarDecl *variable = CI.getVariable();
           BuildScopeInformation(variable, BDecl, origParentScope);
         }
+      else if (auto *CLE = EWC->getObject(i).dyn_cast<CompoundLiteralExpr *>())
+        BuildScopeInformation(CLE, origParentScope);
+      else
+        llvm_unreachable("unexpected cleanup object type");
     }
     break;
   }
 
   case Stmt::MaterializeTemporaryExprClass: {
     // Disallow jumps out of scopes containing temporaries lifetime-extended to
     // automatic storage duration.
     MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(S);

lib/Sema/SemaExpr.cpp

if (Res.isInvalid())
     return Res;
   E = Res.get();
 
   // Loading a __weak object implicitly retains the value, so we need a cleanup to
   // balance that.
   if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
     Cleanup.setExprNeedsCleanups(true);
 
+  if (E->getType().isVolatileQualified() &&
+      E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
+    Cleanup.setExprNeedsCleanups(true);
+
   // C++ [conv.lval]p3:
   //   If T is cv std::nullptr_t, the result is a null pointer constant.
   CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;
   Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_RValue);
 
   // C11 6.3.2.1p2:
   //   ... if the lvalue has atomic type, the value has the non-atomic version
   //   of the type of the lvalue ...
if (ULE->hasExplicitTemplateArgs() &&
         ULE->decls_begin() == ULE->decls_end()) {
       Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus2a
                                  ? diag::warn_cxx17_compat_adl_only_template_id
                                  : diag::ext_adl_only_template_id)
           << ULE->getName();
     }
   }
 
+  if (Call.get()->getType().isDestructedType() ==
+      QualType::DK_nontrivial_c_struct)
+    Cleanup.setExprNeedsCleanups(true);
+
   return Call;
 }
 
 /// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
 /// This provides the location of the left/right parens and a list of comma
 /// locations.
 ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
 
   if (isFileScope)
     if (auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
       for (unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
         Expr *Init = ILE->getInit(i);
         ILE->setInit(i, ConstantExpr::Create(Context, Init));
       }
 
-  Expr *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
+  auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
                                               VK, LiteralExpr, isFileScope);
   if (isFileScope) {
     if (!LiteralExpr->isTypeDependent() &&
         !LiteralExpr->isValueDependent() &&
         !literalType->isDependentType()) // C99 6.5.2.5p3
       if (CheckForConstantInitializer(LiteralExpr, literalType))
         return ExprError();
   } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
              literalType.getAddressSpace() != LangAS::Default) {
     // Embedded-C extensions to C99 6.5.2.5:
     //   "If the compound literal occurs inside the body of a function, the
     //   type name shall not be qualified by an address-space qualifier."
     Diag(LParenLoc, diag::err_compound_literal_with_address_space)
       << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
     return ExprError();
   }
 
+  if (!isFileScope &&
+      literalType.isDestructedType() == QualType::DK_nontrivial_c_struct) {
+    Cleanup.setExprNeedsCleanups(true);
+    ExprCleanupObjects.push_back(E);
+    getCurFunction()->setHasBranchProtectedScope();
+  }
+
   return MaybeBindToTemporary(E);
 }
 
 ExprResult
 Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
                     SourceLocation RBraceLoc) {
   // Immediately handle non-overload placeholders.  Overloads can be
   // resolved contextually, but everything else here can't.

lib/Serialization/ASTReaderStmt.cpp

else
     E->setDestroyedType(GetTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
   VisitExpr(E);
 
   unsigned NumObjects = Record.readInt();
   assert(NumObjects == E->getNumObjects());
-  for (unsigned i = 0; i != NumObjects; ++i)
-    E->getTrailingObjects<BlockDecl *>()[i] =
-        ReadDeclAs<BlockDecl>();
+  for (unsigned i = 0; i != NumObjects; ++i) {
+    unsigned CleanupKind = Record.readInt();
+    ExprWithCleanups::CleanupObject Obj;
+    if (CleanupKind == COK_Block)
+      Obj = ReadDeclAs<BlockDecl>();
+    else if (CleanupKind == COK_CompoundLiteral)
+      Obj = cast<CompoundLiteralExpr>(Record.readSubExpr());
+    else
+      llvm_unreachable("unexpected cleanup object type");
+    E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
+  }
 
   E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
   E->SubExpr = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
     CXXDependentScopeMemberExpr *E) {
   VisitExpr(E);

lib/Serialization/ASTWriterStmt.cpp

else
     Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
 
   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
 }
 
 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
   VisitExpr(E);
   Record.push_back(E->getNumObjects());
-  for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
-    Record.AddDeclRef(E->getObject(i));
+  for (auto &Obj : E->getObjects()) {
+    if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {
+      Record.push_back(serialization::COK_Block);
+      Record.AddDeclRef(BD);
+    } else if (auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
+      Record.push_back(serialization::COK_CompoundLiteral);
+      Record.AddStmt(CLE);
+    }
+  }
 
   Record.push_back(E->cleanupsHaveSideEffects());
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
 }
 
 void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
     CXXDependentScopeMemberExpr *E) {

test/AST/ast-dump-objc-arc-json.m

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x objective-c -fobjc-arc -ast-dump=json -ast-dump-filter Test %s | FileCheck %s
+
+typedef struct {
+  id f;
+} S;
+
+id TestCompoundLiteral(id a) {
+  return ((S){ .f = a }).f;
+}
+
+// CHECK:  "kind": "ExprWithCleanups",
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {
+// CHECK-NEXT:    "col": 10,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "end": {
+// CHECK-NEXT:    "col": 26,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "type": {
+// CHECK-NEXT:   "desugaredQualType": "id",
+// CHECK-NEXT:   "qualType": "id",
+// CHECK-NEXT:   "typeAliasDeclId":
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "valueCategory": "rvalue",
+// CHECK-NEXT:  "cleanupsHaveSideEffects": true,
+// CHECK-NEXT:  "cleanups": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundLiteralExpr"
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ],

test/AST/ast-dump-stmt.m

-// RUN: %clang_cc1 -Wno-unused -fblocks -fobjc-exceptions -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
+// RUN: %clang_cc1 -Wno-unused -fobjc-arc -fblocks -fobjc-exceptions -ast-dump -ast-dump-filter Test %s | FileCheck -strict-whitespace %s
 
 void TestBlockExpr(int x) {
   ^{ x; };
 }
 // CHECK:      FunctionDecl{{.*}}TestBlockExpr
 // CHECK:      BlockExpr{{.*}} 'void (^)(void)'
 // CHECK-NEXT:   BlockDecl
 

 // CHECK:      ObjCAtTryStmt
 // CHECK-NEXT:   CompoundStmt
 // CHECK-NEXT:   ObjCAtCatchStmt{{.*}}
 // CHECK-NEXT:     VarDecl{{.*}}a
 // CHECK-NEXT:     CompoundStmt
 // CHECK-NEXT:   ObjCAtCatchStmt{{.*}} catch all
 // CHECK-NEXT:     CompoundStmt
 // CHECK-NEXT:   ObjCAtFinallyStmt
+
+typedef struct {
+  id f;
+} S;
+
+id TestCompoundLiteral(id a) {
+  return ((S){ .f = a }).f;
+}
+
+// CHECK:     FunctionDecl{{.*}}TestCompoundLiteral
+// CHECK:       ExprWithCleanups
+// CHECK-NEXT:    cleanup CompoundLiteralExpr
+// CHECK:           CompoundLiteralExpr{{.*}}'S':'S' lvalue

test/CodeGenObjC/arc.m

struct AggDtor {
   char cs[40];
   id x;
 };
 
 struct AggDtor getAggDtor(void);
 
 // CHECK-LABEL: define void @test71
 void test71(void) {
-  // FIXME: It would be nice if the __destructor_8_s40 for the first call (and
-  // the following lifetime.end) came before the second call.
-  //
   // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP1:[^ ]+]] to i8*
   // CHECK: call void @llvm.lifetime.start.p0i8({{[^,]+}}, i8* %[[T]])
   // CHECK: call void @getAggDtor(%struct.AggDtor* sret %[[TMP1]])
+  // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP1]] to i8**
+  // CHECK: call void @__destructor_8_s40(i8** %[[T]])
+  // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP1:[^ ]+]] to i8*
+  // CHECK: call void @llvm.lifetime.end.p0i8({{[^,]+}}, i8* %[[T]])
   // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP2:[^ ]+]] to i8*
   // CHECK: call void @llvm.lifetime.start.p0i8({{[^,]+}}, i8* %[[T]])
   // CHECK: call void @getAggDtor(%struct.AggDtor* sret %[[TMP2]])
   // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP2]] to i8**
   // CHECK: call void @__destructor_8_s40(i8** %[[T]])
   // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP2:[^ ]+]] to i8*
   // CHECK: call void @llvm.lifetime.end.p0i8({{[^,]+}}, i8* %[[T]])
-  // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP1]] to i8**
-  // CHECK: call void @__destructor_8_s40(i8** %[[T]])
-  // CHECK: %[[T:[^ ]+]] = bitcast %struct.AggDtor* %[[TMP1:[^ ]+]] to i8*
-  // CHECK: call void @llvm.lifetime.end.p0i8({{[^,]+}}, i8* %[[T]])
   getAggDtor();
   getAggDtor();
 }
 
 // ARC-ALIEN: attributes [[NLB]] = { nonlazybind }
 // ARC-NATIVE: attributes [[NLB]] = { nonlazybind }
 // CHECK: attributes [[NUW]] = { nounwind }

test/CodeGenObjC/strong-in-c-struct.m

 // CHECK: ret void
 
 void test_copy_assignment_StrongBlock(StrongBlock *d, StrongBlock *s) {
   *d = *s;
 }
 
 // CHECK: define void @test_copy_constructor_StrongVolatile0(
 // CHECK: call void @__copy_constructor_8_8_t0w4_sv8(
+// CHECK-NOT: call
 // CHECK: call void @__destructor_8_sv8(
+// CHECK-NOT: call
 
 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w4_sv8(
 // CHECK: %[[V8:.*]] = load volatile i8*, i8** %{{.*}}, align 8
 // CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]])
 // CHECK: store volatile i8* %[[V9]], i8** %{{.*}}, align 8
 
 void test_copy_constructor_StrongVolatile0(StrongVolatile *s) {
   StrongVolatile t = *s;

 // CHECK: %[[V13:.*]] = bitcast i8** %[[ADDR_CUR1]] to i32*
 // CHECK: %[[V14:.*]] = load volatile i32, i32* %[[V13]], align 4
 // CHECK: store volatile i32 %[[V14]], i32* %[[V12]], align 4
 
 void test_copy_constructor_VolatileArray(VolatileArray *a) {
   VolatileArray t = *a;
 }
 
+// CHECK: define void @test_member_access(
+// CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[TMP]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V3]])
+// CHECK: call void @func(
+
+void test_member_access(void) {
+  id t = getStrongSmall().f1;
+  func(0);
+}
+
+// CHECK: define void @test_compound_literal(
+// CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[CLEANUP_ISACTIVE:.*]] = alloca i1,
+// CHECK: %[[_COMPOUNDLITERAL1:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[CLEANUP_ISACTIVE4:.*]] = alloca i1,
+// CHECK: store i1 false, i1* %[[CLEANUP_ISACTIVE]],
+// CHECK: store i1 false, i1* %[[CLEANUP_ISACTIVE4]],
+
+// CHECK: store i1 true, i1* %[[CLEANUP_ISACTIVE]],
+
+// CHECK: store i1 true, i1* %[[CLEANUP_ISACTIVE4]],
+
+// CHECK: call void @func(
+// CHECK: %[[IS_ACTIVE4:.*]] = load i1, i1* %[[CLEANUP_ISACTIVE4]],
+// CHECK: br i1 %[[IS_ACTIVE4]],
+
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[_COMPOUNDLITERAL1]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V1]])
+
+// CHECK: %[[IS_ACTIVE:.*]] = load i1, i1* %[[CLEANUP_ISACTIVE]],
+// CHECK: br i1 %[[IS_ACTIVE]],
+
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[_COMPOUNDLITERAL]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V2]])
+
+void test_compound_literal(int c) {
+  StrongSmall *p = c ? &(StrongSmall){ 1, 0 } : &(StrongSmall){ 2, 0 };
+  func(0);
+}
+
+// CHECK: define void @test_compound_literal2(
+// CHECK: %[[AGG_TMP_ENSURED:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[CLEANUP_ISACTIVE:.*]] = alloca i1,
+// CHECK: %[[AGG_TMP_ENSURED1:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[CLEANUP_ISACTIVE4:.*]] = alloca i1,
+// CHECK: store i1 false, i1* %[[CLEANUP_ISACTIVE]],
+// CHECK: store i1 false, i1* %[[CLEANUP_ISACTIVE4]],
+
+// CHECK: store i1 true, i1* %[[CLEANUP_ISACTIVE]],
+
+// CHECK: store i1 true, i1* %[[CLEANUP_ISACTIVE4]],
+
+// CHECK: call void @func(
+// CHECK: %[[IS_ACTIVE4:.*]] = load i1, i1* %[[CLEANUP_ISACTIVE4]],
+// CHECK: br i1 %[[IS_ACTIVE4]],
+
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[AGG_TMP_ENSURED1]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V1]])
+
+// CHECK: %[[IS_ACTIVE:.*]] = load i1, i1* %[[CLEANUP_ISACTIVE]],
+// CHECK: br i1 %[[IS_ACTIVE]],
+
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[AGG_TMP_ENSURED]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V2]])
+
+void test_compound_literal2(int c) {
+  c ? (StrongSmall){ 1, 0 } : (StrongSmall){ 2, 0 };
+  func(0);
+}
+
+// CHECK: define void @test_volatile_variable_reference(
+// CHECK: %[[AGG_TMP_ENSURED:.*]] = alloca %[[STRUCT_STRONGSMALL]],
+// CHECK: %[[V1:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[AGG_TMP_ENSURED]] to i8**
+// CHECK: %[[V2:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %{{.*}} to i8**
+// CHECK: call void @__copy_constructor_8_8_tv0w32_sv8(i8** %[[V1]], i8** %[[V2]])
+// CHECK: %[[V3:.*]] = bitcast %[[STRUCT_STRONGSMALL]]* %[[AGG_TMP_ENSURED]] to i8**
+// CHECK: call void @__destructor_8_s8(i8** %[[V3]])
+// CHECK: call void @func(
+
+void test_volatile_variable_reference(volatile StrongSmall *a) {
+  (void)*a;
+  func(0);
+}
+
 #endif /* USESTRUCT */

test/Import/objc-arc/Inputs/cleanup-objects.m

+typedef struct {
+  id x;
+} S;
+
+id getObj(int c, id a) {
+  // Commenting out the following line because AST importer crashes when trying
+  // to import a BlockExpr.
+  // return c ? ^{ return a; }() : ((S){ .x = a }).x;
+  return ((S){ .x = a }).x;
+}

test/Import/objc-arc/test-cleanup-object.m

+// RUN: clang-import-test -x objective-c -objc-arc -import %S/Inputs/cleanup-objects.m -dump-ast -expression %s | FileCheck %s
+
+// CHECK: FunctionDecl {{.*}} getObj '
+// CHECK: ExprWithCleanups
+// CHECK-NEXT: cleanup CompoundLiteralExpr
+
+void test(int c, id a) {
+  (void)getObj(c, a);
+}
+

test/PCH/non-trivial-c-compound-literal.m

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x objective-c -fobjc-arc -emit-pch -o %t %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x objective-c -fobjc-arc -include-pch %t -emit-llvm -o - %s | FileCheck %s
+
+#ifndef HEADER
+#define HEADER
+
+typedef struct {
+  id f;
+} S;
+
+static inline id getObj(id a) {
+  S *p = &(S){ .f = a };
+  return p->f;
+}
+
+#else
+
+// CHECK: %[[STRUCT_S:.*]] = type { i8* }
+
+// CHECK: define internal i8* @getObj(
+// CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca %[[STRUCT_S]],
+// CHECK: %[[V5:.*]] = bitcast %[[STRUCT_S]]* %[[_COMPOUNDLITERAL]] to i8**
+// CHECK: call void @__destructor_8_s0(i8** %[[V5]])
+
+id test(id a) {
+  return getObj(a);
+}
+
+#endif

test/SemaObjC/strong-in-c-struct.m

 void test_block_scope1(void) {
   static void *ips[] = { &&L0 };
 L0:  // expected-note {{possible target of indirect goto}}
   ;
   Strong x; // expected-note {{jump exits scope of variable with non-trivial destructor}} expected-note {{jump exits lifetime of block which captures a C struct that is non-trivial to destroy}}
   func(^{ func2(x); });
   goto *ips; // expected-error {{cannot jump}}
 }
+
+void test_compound_literal0(int cond, id x) {
+  switch (cond) {
+  case 0:
+    (void)(Strong){ .a = x }; // expected-note {{jump enters lifetime of a compound literal that is non-trivial to destruct}}
+    break;
+  default: // expected-error {{cannot jump from switch statement to this case label}}
+    break;
+  }
+}
+
+void test_compound_literal1(id x) {
+  static void *ips[] = { &&L0 };
+L0:  // expected-note {{possible target of indirect goto}}
+  ;
+  (void)(Strong){ .a = x }; // expected-note {{jump exits lifetime of a compound literal that is non-trivial to destruct}}
+  goto *ips; // expected-error {{cannot jump}}
+}

tools/clang-import-test/clang-import-test.cpp

ClangArgs("Xcc", llvm::cl::ZeroOrMore,
               llvm::cl::desc("Argument to pass to the CompilerInvocation"),
               llvm::cl::CommaSeparated);
 
 static llvm::cl::opt<std::string>
     Input("x", llvm::cl::Optional,
           llvm::cl::desc("The language to parse (default: c++)"),
           llvm::cl::init("c++"));
 
+static llvm::cl::opt<bool>
+    ObjCARC("objc-arc", llvm::cl::init(false),
+            llvm::cl::desc("Emable ObjC ARC"));
+
 static llvm::cl::opt<bool> DumpAST("dump-ast", llvm::cl::init(false),
                                    llvm::cl::desc("Dump combined AST"));
 
 static llvm::cl::opt<bool> DumpIR("dump-ir", llvm::cl::init(false),
                                   llvm::cl::desc("Dump IR from final parse"));
 
 namespace init_convenience {
 class TestDiagnosticConsumer : public DiagnosticConsumer {
if (isCXX(Id)) {
       Inv->getLangOpts()->CPlusPlus = true;
       Inv->getLangOpts()->CPlusPlus11 = true;
       Inv->getHeaderSearchOpts().UseLibcxx = true;
     }
     if (isObjC(Id)) {
       Inv->getLangOpts()->ObjC = 1;
     }
   }
+  Inv->getLangOpts()->ObjCAutoRefCount = ObjCARC;
+
   Inv->getLangOpts()->Bool = true;
   Inv->getLangOpts()->WChar = true;
   Inv->getLangOpts()->Blocks = true;
   Inv->getLangOpts()->DebuggerSupport = true;
   Inv->getLangOpts()->SpellChecking = false;
   Inv->getLangOpts()->ThreadsafeStatics = false;
   Inv->getLangOpts()->AccessControl = false;
   Inv->getLangOpts()->DollarIdents = true;