[os_log] Improve the way we extend the lifetime of objects passed to __builtin_os_log_format

[ahatanak]

Summary

This patch fixes several shortcomings of the way we currently extend the lifetime of objects passed to calls to __builtin_os_log_format:

• Sema doesn't diagnose code that jumps into or out of the scope of a lifetime-extended object.
• Lifetime of objects in comma operators or expressions for ObjC property access isn't extended.
• We extend the lifetime of an object by emitting an extra pair of retain and release calls instead of delaying the release call.
• Calls to clang.arc.use are emitted on exception paths even though they are needed only on normal paths.

rdar://problem/62610583

[rjmccall]

Why is the lifetime extended to the enclosing block scope anyway? I understand why we need a clang.arc.use — the optimizer can't reasonably understand that the object has to live within the buffer — but isn't the buffer only used for the duration of the call? Why is extension necessary?

clang/include/clang/Serialization/ASTBitCodes.h

1987

This seems like an excessively general name for what's happening here.

[ahatanak]

The use case for this is a macro in which the call to __builtin_os_log_format that writes to the buffer and the call that uses the buffer appear in two different statements. For example:

__builtin_os_log_format(buf, "%@", getObj());
...
use_buffer(buf);

The object returned by the call to getObj has to be kept alive until use_buffer is called, but currently it gets destructed at the end of the full expression. I think an alternate solution would be to provide users a means to tell ARC optimizer not to move the release call for a local variable past any calls, i.e., something that is stricter than NS_VALID_UNTIL_END_OF_SCOPE, but that places more burden on the users.

In the os_log macro, the result of the call to __builtin_os_log_format is passed directly to the call that uses the buffer, so it doesn't require any lifetime extension as you pointed out.

[martong]

clang/lib/AST/ASTImporter.cpp

8000

I am not sure how this hunk is related to os_log. Maybe you mistakenly mixed another unrelated change into this patch?

[rjmccall]

In D83997#2169745, @ahatanak wrote:

The use case for this is a macro in which the call to __builtin_os_log_format that writes to the buffer and the call that uses the buffer appear in two different statements. For example:

__builtin_os_log_format(buf, "%@", getObj());
...
use_buffer(buf);

The object returned by the call to getObj has to be kept alive until use_buffer is called, but currently it gets destructed at the end of the full expression. I think an alternate solution would be to provide users a means to tell ARC optimizer not to move the release call for a local variable past any calls, i.e., something that is stricter than NS_VALID_UNTIL_END_OF_SCOPE, but that places more burden on the users.

In the os_log macro, the result of the call to __builtin_os_log_format is passed directly to the call that uses the buffer, so it doesn't require any lifetime extension as you pointed out.

So are there actually any uses that take advantage of these semantics? Because as I understand it, this builtin exists entirely to support the os_log macro. If that macro doesn't need the extension semantics, let's just not do them.

clang/include/clang/AST/ExprCXX.h

 ///
 /// 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,
-          llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
+          llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *,
+                             ImplicitCastExpr *>> {
 public:
   /// The type of objects that are kept in the cleanup.
-  /// It's useful to remember the set of blocks and block-scoped compound
-  /// literals; we could also remember the set of temporaries, but there's
-  /// currently no need.
-  using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>;
+  /// It's useful to remember the set of blocks, block-scoped compound
+  /// literals, and objects whose lifetime is extended under ARC; we could also
+  /// remember the set of temporaries, but there's currently no need.
+  using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *,
+                                           ImplicitCastExpr *>;
 
 private:
   friend class ASTStmtReader;
   friend TrailingObjects;
 
   ExprWithCleanups(EmptyShell, unsigned NumObjects);
   ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
                    ArrayRef<CleanupObject> Objects);

clang/include/clang/Basic/DiagnosticSemaKinds.td

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_enters_lifetime_extended_arc_obj_scope : Note<
+  "jump enters lifetime of an object whose lifetime is extended under ARC">;
 
 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_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 note_exits_lifetime_extended_arc_obj_scope : Note<
+  "jump exits lifetime of an object whose lifetime is extended under ARC">;
 
 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_or_sizeless : Error<

clang/include/clang/Serialization/ASTBitCodes.h

#include "clang/Serialization/TypeBitCodes.def"
     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 };
+    enum CleanupObjectKind {
+      COK_Block,
+      COK_CompoundLiteral,
+      COK_ImplicitCastExpr
+    };
 
     /// 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;

clang/lib/AST/ASTImporter.cpp

void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
   MapImported(FromD, ToD);
 }
 
 llvm::Expected<ExprWithCleanups::CleanupObject>
 ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
   if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
     if (Expected<Expr *> R = Import(CLE))
       return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
+  } else if (auto *ICE = From.dyn_cast<ImplicitCastExpr *>()) {
+    if (Expected<Expr *> R = Import(ICE))
+      return ExprWithCleanups::CleanupObject(cast<ImplicitCastExpr>(*R));
   }
 
   // FIXME: Handle BlockDecl when we implement importing BlockExpr in
   //        ASTNodeImporter.
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
 Expected<QualType> ASTImporter::Import(QualType FromT) {

clang/lib/AST/JSONNodeDumper.cpp

JOS.attributeArray("cleanups", [this, EWC] {
       for (const ExprWithCleanups::CleanupObject &CO : EWC->getObjects())
         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 if (auto *ICE = CO.dyn_cast<ImplicitCastExpr *>()) {
+          llvm::json::Object Obj;
+          Obj["id"] = createPointerRepresentation(ICE);
+          Obj["kind"] = ICE->getStmtClassName();
+          JOS.value(std::move(Obj));
         } else {
           llvm_unreachable("unexpected cleanup object type");
         }
     });
   }
 }
 
 void JSONNodeDumper::VisitCXXBindTemporaryExpr(

clang/lib/AST/TextNodeDumper.cpp

else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
     AddChild([=] {
       OS << "cleanup ";
       {
         ColorScope Color(OS, ShowColors, StmtColor);
         OS << CLE->getStmtClassName();
       }
       dumpPointer(CLE);
     });
+  else if (auto *ICE = C.dyn_cast<ImplicitCastExpr *>())
+    AddChild([=] {
+      OS << "cleanup ";
+      {
+        ColorScope Color(OS, ShowColors, StmtColor);
+        OS << ICE->getStmtClassName();
+      }
+      dumpPointer(ICE);
+    });
   else
     llvm_unreachable("unexpected cleanup type");
 }
 
 void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
   if (!D)
     return;
 

clang/lib/CodeGen/CGBuiltin.cpp

case MSVCIntrin::__fastfail: {
     llvm::CallInst *CI = Builder.CreateCall(IA, EmitScalarExpr(E->getArg(0)));
     CI->setAttributes(NoReturnAttr);
     return CI;
   }
   }
   llvm_unreachable("Incorrect MSVC intrinsic!");
 }
 
-namespace {
-// ARC cleanup for __builtin_os_log_format
-struct CallObjCArcUse final : EHScopeStack::Cleanup {
-  CallObjCArcUse(llvm::Value *object) : object(object) {}
-  llvm::Value *object;
-
-  void Emit(CodeGenFunction &CGF, Flags flags) override {
-    CGF.EmitARCIntrinsicUse(object);
-  }
-};
-}
-
 Value *CodeGenFunction::EmitCheckedArgForBuiltin(const Expr *E,
                                                  BuiltinCheckKind Kind) {
   assert((Kind == BCK_CLZPassedZero || Kind == BCK_CTZPassedZero)
           && "Unsupported builtin check kind");
 
   Value *ArgValue = EmitScalarExpr(E);
   if (!SanOpts.has(SanitizerKind::Builtin) || !getTarget().isCLZForZeroUndef())
     return ArgValue;
for (const auto &Item : Layout.Items) {
 
     if (Item.getKind() == analyze_os_log::OSLogBufferItem::MaskKind) {
       uint64_t Val = 0;
       for (unsigned I = 0, E = Item.getMaskType().size(); I < E; ++I)
         Val |= ((uint64_t)Item.getMaskType()[I]) << I * 8;
       ArgVal = llvm::Constant::getIntegerValue(Int64Ty, llvm::APInt(64, Val));
     } else if (const Expr *TheExpr = Item.getExpr()) {
       ArgVal = EmitScalarExpr(TheExpr, /*Ignore*/ false);
-
-      // If a temporary object that requires destruction after the full
-      // expression is passed, push a lifetime-extended cleanup to extend its
-      // lifetime to the end of the enclosing block scope.
-      auto LifetimeExtendObject = [&](const Expr *E) {
-        E = E->IgnoreParenCasts();
-        // Extend lifetimes of objects returned by function calls and message
-        // sends.
-
-        // FIXME: We should do this in other cases in which temporaries are
-        //        created including arguments of non-ARC types (e.g., C++
-        //        temporaries).
-        if (isa<CallExpr>(E) || isa<ObjCMessageExpr>(E))
-          return true;
-        return false;
-      };
-
-      if (TheExpr->getType()->isObjCRetainableType() &&
-          getLangOpts().ObjCAutoRefCount && LifetimeExtendObject(TheExpr)) {
-        assert(getEvaluationKind(TheExpr->getType()) == TEK_Scalar &&
-               "Only scalar can be a ObjC retainable type");
-        if (!isa<Constant>(ArgVal)) {
-          CleanupKind Cleanup = getARCCleanupKind();
-          QualType Ty = TheExpr->getType();
-          Address Alloca = Address::invalid();
-          Address Addr = CreateMemTemp(Ty, "os.log.arg", &Alloca);
-          ArgVal = EmitARCRetain(Ty, ArgVal);
-          Builder.CreateStore(ArgVal, Addr);
-          pushLifetimeExtendedDestroy(Cleanup, Alloca, Ty,
-                                      CodeGenFunction::destroyARCStrongPrecise,
-                                      Cleanup & EHCleanup);
-
-          // Push a clang.arc.use call to ensure ARC optimizer knows that the
-          // argument has to be alive.
-          if (CGM.getCodeGenOpts().OptimizationLevel != 0)
-            pushCleanupAfterFullExpr<CallObjCArcUse>(Cleanup, ArgVal);
-        }
-      }
     } else {
       ArgVal = Builder.getInt32(Item.getConstValue().getQuantity());
     }
 
     unsigned ArgValSize =
         CGM.getDataLayout().getTypeSizeInBits(ArgVal->getType());
     llvm::IntegerType *IntTy = llvm::Type::getIntNTy(getLLVMContext(),
                                                      ArgValSize);

clang/lib/CodeGen/CGExprAgg.cpp

for (unsigned i = Cleanups.size(); i != 0; --i)
     CGF.DeactivateCleanupBlock(Cleanups[i-1], CleanupDominator);
 
   // Destroy the placeholder if we made one.
   if (CleanupDominator)
     CleanupDominator->eraseFromParent();
 }
 
 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
+  CodeGenFunction::SaveExprWithCleanupsRAII SaveExprWithCleanups(E, CGF);
   CodeGenFunction::RunCleanupsScope cleanups(CGF);
   Visit(E->getSubExpr());
 }
 
 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   QualType T = E->getType();
   AggValueSlot Slot = EnsureSlot(T);
   EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));

clang/lib/CodeGen/CGExprComplex.cpp

ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
     CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
     return Visit(DAE->getExpr());
   }
   ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
     CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
     return Visit(DIE->getExpr());
   }
   ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
+    CodeGenFunction::SaveExprWithCleanupsRAII SaveExprWithCleanups(E, CGF);
     CodeGenFunction::RunCleanupsScope Scope(CGF);
     ComplexPairTy Vals = Visit(E->getSubExpr());
     // Defend against dominance problems caused by jumps out of expression
     // evaluation through the shared cleanup block.
     Scope.ForceCleanup({&Vals.first, &Vals.second});
     return Vals;
   }
   ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {

clang/lib/CodeGen/CGExprScalar.cpp

case CK_DerivedToBaseMemberPointer: {
     // check, which it is for data member pointers (but not member
     // function pointers on Itanium and ARM).
     return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
   }
 
   case CK_ARCProduceObject:
     return CGF.EmitARCRetainScalarExpr(E);
   case CK_ARCConsumeObject:
-    return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
+    return CGF.EmitObjCConsumeObject(E->getType(), Visit(E),
+                                     CGF.isLifetimeExtendedARCObject(CE));
   case CK_ARCReclaimReturnedObject:
-    return CGF.EmitARCReclaimReturnedObject(E, /*allowUnsafe*/ Ignored);
+    return CGF.EmitARCReclaimReturnedObject(
+        E, /*allowUnsafe*/ Ignored, CGF.isLifetimeExtendedARCObject(CE));
   case CK_ARCExtendBlockObject:
     return CGF.EmitARCExtendBlockObject(E);
 
   case CK_CopyAndAutoreleaseBlockObject:
     return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
 
   case CK_FloatingRealToComplex:
   case CK_FloatingComplexCast:
Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
                                            !E->getType()->isVoidType());
   if (!RetAlloca.isValid())
     return nullptr;
   return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->getType()),
                               E->getExprLoc());
 }
 
 Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
+  CodeGenFunction::SaveExprWithCleanupsRAII SaveExprWithCleanups(E, CGF);
   CodeGenFunction::RunCleanupsScope Scope(CGF);
   Value *V = Visit(E->getSubExpr());
   // Defend against dominance problems caused by jumps out of expression
   // evaluation through the shared cleanup block.
   Scope.ForceCleanup({&V});
   return V;
 }
 

clang/lib/CodeGen/CGObjC.cpp

struct CallObjCRelease final : EHScopeStack::Cleanup {
 
     void Emit(CodeGenFunction &CGF, Flags flags) override {
       // Releases at the end of the full-expression are imprecise.
       CGF.EmitARCRelease(object, ARCImpreciseLifetime);
     }
   };
 }
 
+namespace {
+// ARC cleanup for __builtin_os_log_format
+struct CallObjCArcUse final : EHScopeStack::Cleanup {
+  CallObjCArcUse(llvm::Value *object) : object(object) {}
+  llvm::Value *object;
+
+  void Emit(CodeGenFunction &CGF, Flags flags) override {
+    CGF.EmitARCIntrinsicUse(object);
+  }
+};
+} // namespace
+
 /// Produce the code for a CK_ARCConsumeObject.  Does a primitive
 /// release at the end of the full-expression.
 llvm::Value *CodeGenFunction::EmitObjCConsumeObject(QualType type,
-                                                    llvm::Value *object) {
+                                                    llvm::Value *object,
+                                                    bool extendLifetime) {
   // If we're in a conditional branch, we need to make the cleanup
   // conditional.
-  pushFullExprCleanup<CallObjCRelease>(getARCCleanupKind(), object);
+  CleanupKind cleanupKind = getARCCleanupKind();
+  if (extendLifetime) {
+    if (cleanupKind & EHCleanup)
+      pushFullExprCleanup<CallObjCRelease>(EHCleanup, object);
+    pushCleanupAfterFullExpr<CallObjCRelease>(cleanupKind, object);
+    // Push a clang.arc.use call to prevent ARC optimizer from moving the
+    // release call upward on normal paths.
+    if (CGM.getCodeGenOpts().OptimizationLevel != 0)
+      pushCleanupAfterFullExpr<CallObjCArcUse>(NormalCleanup, object);
+  } else
+    pushFullExprCleanup<CallObjCRelease>(cleanupKind, object);
   return object;
 }
 
 llvm::Value *CodeGenFunction::EmitObjCExtendObjectLifetime(QualType type,
                                                            llvm::Value *value) {
   return EmitARCRetainAutorelease(type, value);
 }
 
return emitARCOperationAfterCall(CGF, value,
            [](CodeGenFunction &CGF, llvm::Value *value) {
              return CGF.EmitARCUnsafeClaimAutoreleasedReturnValue(value);
            },
            [](CodeGenFunction &CGF, llvm::Value *value) {
              return value;
            });
 }
 
-llvm::Value *CodeGenFunction::EmitARCReclaimReturnedObject(const Expr *E,
-                                                      bool allowUnsafeClaim) {
+llvm::Value *CodeGenFunction::EmitARCReclaimReturnedObject(
+    const Expr *E, bool allowUnsafeClaim, bool extendLifetime) {
   if (allowUnsafeClaim &&
       CGM.getLangOpts().ObjCRuntime.hasARCUnsafeClaimAutoreleasedReturnValue()) {
     return emitARCUnsafeClaimCallResult(*this, E);
   } else {
     llvm::Value *value = emitARCRetainCallResult(*this, E);
-    return EmitObjCConsumeObject(E->getType(), value);
+    return EmitObjCConsumeObject(E->getType(), value, extendLifetime);
   }
 }
 
 /// Determine whether it might be important to emit a separate
 /// objc_retain_block on the result of the given expression, or
 /// whether it's okay to just emit it in a +1 context.
 static bool shouldEmitSeparateBlockRetain(const Expr *e) {
   assert(e->getType()->isBlockPointerType());

clang/lib/CodeGen/CodeGenFunction.h

public:
   typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
   LoopInfoStack LoopStack;
   CGBuilderTy Builder;
 
   // Stores variables for which we can't generate correct lifetime markers
   // because of jumps.
   VarBypassDetector Bypasses;
 
+  // The current ExprWithCleanups expression being visited.
+  const ExprWithCleanups *CurExprWithCleanups = nullptr;
+
+  // RAII for saving the current CurExprWithCleanups and restoring it later.
+  struct SaveExprWithCleanupsRAII {
+    SaveExprWithCleanupsRAII(const ExprWithCleanups *E, CodeGenFunction &CGF)
+        : OldExprWithCleanups(CGF.CurExprWithCleanups), CGF(CGF) {
+      CGF.CurExprWithCleanups = E;
+    }
+    ~SaveExprWithCleanupsRAII() {
+      CGF.CurExprWithCleanups = OldExprWithCleanups;
+    }
+    const ExprWithCleanups *OldExprWithCleanups;
+    CodeGenFunction &CGF;
+  };
+
+  // Indicates whether the expression is in the cleanup list of
+  // CurExprWithCleanups and represents an object whose lifetime is extended
+  // under ARC.
+  bool isLifetimeExtendedARCObject(const Expr *E) const;
+
   // CodeGen lambda for loops and support for ordered clause
   typedef llvm::function_ref<void(CodeGenFunction &, const OMPLoopDirective &,
                                   JumpDest)>
       CodeGenLoopTy;
   typedef llvm::function_ref<void(CodeGenFunction &, SourceLocation,
                                   const unsigned, const bool)>
       CodeGenOrderedTy;
 
public:
 
   llvm::Value *EmitObjCAlloc(llvm::Value *value,
                              llvm::Type *returnType);
   llvm::Value *EmitObjCAllocWithZone(llvm::Value *value,
                                      llvm::Type *returnType);
   llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
 
   llvm::Value *EmitObjCThrowOperand(const Expr *expr);
-  llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
+  llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr,
+                                     bool extendLifetime = false);
   llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
 
   llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
   llvm::Value *EmitARCReclaimReturnedObject(const Expr *e,
-                                            bool allowUnsafeClaim);
+                                            bool allowUnsafeClaim,
+                                            bool extendLifetime = false);
   llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
   llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
   llvm::Value *EmitARCUnsafeUnretainedScalarExpr(const Expr *expr);
 
   void EmitARCIntrinsicUse(ArrayRef<llvm::Value*> values);
 
   static Destroyer destroyARCStrongImprecise;
   static Destroyer destroyARCStrongPrecise;

clang/lib/CodeGen/CodeGenFunction.cpp

CodeGenFunction::SanitizerScope::SanitizerScope(CodeGenFunction *CGF)
   assert(!CGF->IsSanitizerScope);
   CGF->IsSanitizerScope = true;
 }
 
 CodeGenFunction::SanitizerScope::~SanitizerScope() {
   CGF->IsSanitizerScope = false;
 }
 
+bool CodeGenFunction::isLifetimeExtendedARCObject(const Expr *E) const {
+  return CurExprWithCleanups &&
+         llvm::any_of(CurExprWithCleanups->getObjects(),
+                      [&](const ExprWithCleanups::CleanupObject &C) {
+                        return C.dyn_cast<ImplicitCastExpr *>() == E;
+                      });
+}
+
 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
                                    const llvm::Twine &Name,
                                    llvm::BasicBlock *BB,
                                    llvm::BasicBlock::iterator InsertPt) const {
   LoopStack.InsertHelper(I);
   if (IsSanitizerScope)
     CGM.getSanitizerMetadata()->disableSanitizerForInstruction(I);
 }

clang/lib/Sema/JumpDiagnostics.cpp

class JumpScopeChecker {
   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 BuildLifetimeExtendedARCObjScopeInformation(ImplicitCastExpr *ICE,
+                                                   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,

 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;
 }
 
+void JumpScopeChecker::BuildLifetimeExtendedARCObjScopeInformation(
+    ImplicitCastExpr *ICE, unsigned &ParentScope) {
+  unsigned InDiag = diag::note_enters_lifetime_extended_arc_obj_scope;
+  unsigned OutDiag = diag::note_exits_lifetime_extended_arc_obj_scope;
+  Scopes.push_back(GotoScope(ParentScope, InDiag, OutDiag, ICE->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
case Stmt::ExprWithCleanupsClass: {
     for (unsigned i = 0, e = EWC->getNumObjects(); i != e; ++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 if (auto *ICE = EWC->getObject(i).dyn_cast<ImplicitCastExpr *>())
+        BuildLifetimeExtendedARCObjScopeInformation(ICE, origParentScope);
       else
         llvm_unreachable("unexpected cleanup object type");
     }
     break;
   }
 
   case Stmt::MaterializeTemporaryExprClass: {
     // Disallow jumps out of scopes containing temporaries lifetime-extended to

clang/lib/Sema/SemaChecking.cpp

if (NumArgs > 2) {
     Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
     if (Arg.isInvalid()) return true;
     TheCall->setArg(2, Arg.get());
   }
 
   return false;
 }
 
+/// Extend the lifetime of ObjC temporary objects under ARC that are passed to
+/// __builtin_os_log_format to the end of the enclosing scope.
+///
+/// For example, the lifetime of the object returned by the call to getObj is
+/// extended and doesn't end at the end of the full expression in the code
+/// below:
+///
+///  id getObj(void);
+///  // the pointer to the object is stored to 'buf' and must be kept alive
+///  // until 'os_log_pack_send' is called.
+///  __builtin_os_log_format(buf, "%@", getObj());
+///  os_log_pack_send(buf);
+
+static void lifetimeExtendOSLogFormatArg(Expr *E, Sema &S) {
+  while (true) {
+    E = E->IgnoreParens();
+
+    switch (E->getStmtClass()) {
+    case Expr::ConditionalOperatorClass:
+    case Expr::BinaryConditionalOperatorClass: {
+      auto *ACO = cast<AbstractConditionalOperator>(E);
+      lifetimeExtendOSLogFormatArg(ACO->getTrueExpr(), S);
+      lifetimeExtendOSLogFormatArg(ACO->getFalseExpr(), S);
+      return;
+    }
+    case Expr::BinaryOperatorClass: {
+      auto *BO = cast<BinaryOperator>(E);
+      // Only the RHS of a comma operator needs lifetime-extension.
+      if (BO->getOpcode() == BO_Comma) {
+        E = BO->getRHS();
+        continue;
+      }
+      return;
+    }
+    case Expr::PseudoObjectExprClass: {
+      // Visit the result expression of expressions for ObjC property accesses.
+      E = cast<PseudoObjectExpr>(E)->getResultExpr();
+      continue;
+    }
+    default: {
+      if (auto *CE = dyn_cast<CastExpr>(E)) {
+        switch (CE->getCastKind()) {
+        case CK_ARCConsumeObject:
+        case CK_ARCReclaimReturnedObject: {
+          S.Cleanup.setExprNeedsCleanups(true);
+          S.ExprCleanupObjects.push_back(cast<ImplicitCastExpr>(E));
+          S.getCurFunction()->setHasBranchProtectedScope();
+          return;
+        }
+        default: {
+          // Ignore any other cast expressions.
+          E = CE->getSubExpr();
+          continue;
+        }
+        }
+      }
+      return;
+    }
+    }
+  }
+}
+
 bool Sema::SemaBuiltinOSLogFormat(CallExpr *TheCall) {
   unsigned BuiltinID =
       cast<FunctionDecl>(TheCall->getCalleeDecl())->getBuiltinID();
   bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
 
   unsigned NumArgs = TheCall->getNumArgs();
   unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
   if (NumArgs < NumRequiredArgs) {
bool Sema::SemaBuiltinOSLogFormat(CallExpr *TheCall) {
 
   // Make sure variadic args are scalar.
   unsigned FirstDataArg = i;
   while (i < NumArgs) {
     ExprResult Arg = DefaultVariadicArgumentPromotion(
         TheCall->getArg(i), VariadicFunction, nullptr);
     if (Arg.isInvalid())
       return true;
+    if (getLangOpts().ObjCAutoRefCount &&
+        Arg.get()->getType()->isObjCRetainableType())
+      lifetimeExtendOSLogFormatArg(Arg.get(), *this);
     CharUnits ArgSize = Context.getTypeSizeInChars(Arg.get()->getType());
     if (ArgSize.getQuantity() >= 0x100) {
       return Diag(Arg.get()->getEndLoc(), diag::err_os_log_argument_too_big)
              << i << (int)ArgSize.getQuantity() << 0xff
              << TheCall->getSourceRange();
     }
     TheCall->setArg(i, Arg.get());
     i++;

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
   assert(NumObjects == E->getNumObjects());
   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 if (CleanupKind == COK_ImplicitCastExpr)
+      Obj = cast<ImplicitCastExpr>(Record.readSubExpr());
     else
       llvm_unreachable("unexpected cleanup object type");
     E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
   }
 
   E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
   E->SubExpr = Record.readSubExpr();
 }

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
   Record.push_back(E->getNumObjects());
   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);
+    } else if (auto *ICE = Obj.dyn_cast<ImplicitCastExpr *>()) {
+      Record.push_back(serialization::COK_ImplicitCastExpr);
+      Record.AddStmt(ICE);
+    } else {
+      llvm_unreachable("unexpected cleanup object type");
     }
   }
 
   Record.push_back(E->cleanupsHaveSideEffects());
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
 }
 

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

 // 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:  ],
+
+id GetObj(void);
+
+// CHECK:       "cleanups": [
+// CHECK-NEXT:    {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "ImplicitCastExpr"
+// CHECK-NEXT:    }
+// CHECK-NEXT:  ],
+
+void TestBuiltinOSLogFormat(void *buf) {
+  __builtin_os_log_format(buf, "%@", GetObj());
+}

clang/test/AST/ast-dump-stmt.m

 id TestCompoundLiteral(id a) {
   return ((S){ .f = a }).f;
 }
 
 // CHECK:     FunctionDecl{{.*}}TestCompoundLiteral
 // CHECK:       ExprWithCleanups
 // CHECK-NEXT:    cleanup CompoundLiteralExpr
 // CHECK:           CompoundLiteralExpr{{.*}}'S':'S' lvalue
+
+void TestBuiltinOSLog(void *buf) {
+  extern id getObj(void);
+  __builtin_os_log_format(buf, "%@", getObj());
+}
+
+// CHECK:       FunctionDecl{{.*}}TestBuiltinOSLog
+// CHECK:         ExprWithCleanups
+// CHECK-NEXT:      cleanup ImplicitCastExpr [[EXPR_ADDR:.*]]
+// CHECK:             ImplicitCastExpr [[EXPR_ADDR]]
+// CHECK-NEXT:          CallExpr
+// CHECK-NEXT:            ImplicitCastExpr
+// CHECK-NEXT:              DeclRefExpr{{.*}}'getObj' 'id (void)'

clang/test/CodeGenObjC/os_log.m

 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple -fobjc-arc -O2 -disable-llvm-passes | FileCheck %s --check-prefixes=CHECK,CHECK-O2
 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple -fobjc-arc -O0 | FileCheck %s --check-prefixes=CHECK,CHECK-O0
 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple -O2 -disable-llvm-passes | FileCheck %s --check-prefix=CHECK-MRR
 
 // Make sure we emit clang.arc.use before calling objc_release as part of the
 // cleanup. This way we make sure the object will not be released until the
 // end of the full expression.
 
 // rdar://problem/24528966
 
 @interface C
 - (id)m0;
 + (id)m1;
+@property id prop0;
 @end
 
 C *c;
+id g0, g1;
 
 @class NSString;
 extern __attribute__((visibility("default"))) NSString *GenString();
 void os_log_pack_send(void *);
 
 // CHECK-LABEL: define void @test_builtin_os_log1(
 // CHECK: alloca i8*, align 8
 // CHECK: %[[A_ADDR:.*]] = alloca i8*, align 8
-// CHECK: %[[OS_LOG_ARG:.*]] = alloca %{{.*}}*, align 8
 // CHECK-O2: %[[V0:.*]] = call i8* @llvm.objc.retain(
 // CHECK-O2: store i8* %[[V0]], i8** %[[A_ADDR]], align 8,
 // CHECK-O0: call void @llvm.objc.storeStrong(i8** %[[A_ADDR]], i8* %{{.*}})
 // CHECK: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
 // CHECK: %[[V2:.*]] = bitcast %{{.*}}* %[[CALL]] to i8*
 // CHECK: %[[V3:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V2]])
 // CHECK: %[[V4:.*]] = bitcast i8* %[[V3]] to %{{.*}}*
-// CHECK: %[[V5:.*]] = bitcast %{{.*}}* %[[V4]] to i8*
-// CHECK: %[[V6:.*]] = call i8* @llvm.objc.retain(i8* %[[V5]])
-// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to %{{.*}}*
-// CHECK: store %{{.*}}* %[[V7]], %{{.*}}** %[[OS_LOG_ARG]],
-// CHECK: %[[V8:.*]] = ptrtoint %{{.*}}* %[[V7]] to i64
-// CHECK: %[[V9:.*]] = load i8*, i8** %[[A_ADDR]], align 8
-// CHECK: %[[V10:.*]] = ptrtoint i8* %[[V9]] to i64
-// CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(i8* %{{.*}}, i64 %[[V8]], i64 %[[V10]])
-// CHECK: %[[V11:.*]] = bitcast %{{.*}}* %[[V4]] to i8*
-// CHECK: call void @llvm.objc.release(i8* %[[V11]])
-// CHECK: call void @os_log_pack_send(i8* %{{.*}})
-// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V7]])
-// CHECK-O2: %[[V13:.*]] = load %{{.*}}*, %{{.*}}** %[[OS_LOG_ARG]], align 8
-// CHECK-O2: %[[V14:.*]] = bitcast %{{.*}}* %[[V13]] to i8*
-// CHECK-O2: call void @llvm.objc.release(i8* %[[V14]])
-// CHECK-O2: %[[V15:.*]] = load i8*, i8** %[[A_ADDR]], align 8
-// CHECK-O2: call void @llvm.objc.release(i8* %[[V15]])
-// CHECK-O0: %[[V12:.*]] = bitcast %{{.*}}** %[[OS_LOG_ARG]] to i8**
-// CHECK-O0: call void @llvm.objc.storeStrong(i8** %[[V12]], i8* null)
+// CHECK: %[[V5:.*]] = ptrtoint %{{.*}}* %[[V4]] to i64
+// CHECK: %[[V6:.*]] = load i8*, i8** %[[A_ADDR]], align 8
+// CHECK: %[[V7:.*]] = ptrtoint i8* %[[V6]] to i64
+// CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(i8* %{{.*}}, i64 %[[V5]], i64 %[[V7]])
+// CHECK: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V4]])
+// CHECK: %[[V9:.*]] = bitcast %{{.*}}* %[[V4]] to i8*
+// CHECK: call void @llvm.objc.release(i8* %[[V9]])
+// CHECK-O2: %[[V10:.*]] = load i8*, i8** %[[A_ADDR]], align 8
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V10]])
 // CHECK-O0: call void @llvm.objc.storeStrong(i8** %[[A_ADDR]], i8* null)
 
 // CHECK-MRR-LABEL: define void @test_builtin_os_log1(
 // CHECK-MRR-NOT: call {{.*}} @llvm.objc
 // CHECK-MRR: ret void
 
 void test_builtin_os_log1(void *buf, id a) {
   __builtin_os_log_format(buf, "capabilities: %@ %@", GenString(), a);
   os_log_pack_send(buf);
 }
 
 // CHECK: define void @test_builtin_os_log2(
 // CHECK-NOT: @llvm.objc.retain(
 
 void test_builtin_os_log2(void *buf, id __unsafe_unretained a) {
   __builtin_os_log_format(buf, "capabilities: %@", a);
   os_log_pack_send(buf);
 }
 
 // CHECK-LABEL: define void @test_builtin_os_log3(
-// CHECK: alloca i8*, align 8
-// CHECK: %[[OS_LOG_ARG:.*]] = alloca i8*, align 8
 // CHECK: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
 // CHECK: %[[V1:.*]] = bitcast %{{.*}}* %[[CALL]] to i8*
 // CHECK: %[[V2:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
 // CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to %{{.*}}*
-// CHECK: %[[V4:.*]] = bitcast %{{.*}}* %[[V3]] to i8*
-// CHECK: %[[V5:.*]] = call i8* @llvm.objc.retain(i8* %[[V4]])
-// CHECK: store i8* %[[V5]], i8** %[[OS_LOG_ARG]], align 8
-// CHECK: %[[V6:.*]] = ptrtoint i8* %[[V5]] to i64
-// CHECK: call void @__os_log_helper_1_2_1_8_64(i8* %{{.*}}, i64 %[[V6]])
+// CHECK: call void @__os_log_helper_1_2_1_8_64(
+// CHECK: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%[[V1]]* %[[V3]])
 // CHECK: %[[V7:.*]] = bitcast %{{.*}}* %[[V3]] to i8*
 // CHECK: call void @llvm.objc.release(i8* %[[V7]])
-// CHECK: call void @os_log_pack_send(i8* %{{.*}})
-// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V5]])
-// CHECK-O2: %[[V9:.*]] = load i8*, i8** %[[OS_LOG_ARG]], align 8
-// CHECK-O2: call void @llvm.objc.release(i8* %[[V9]])
-// CHECK-O0: call void @llvm.objc.storeStrong(i8** %[[OS_LOG_ARG]], i8* null)
 
 void test_builtin_os_log3(void *buf) {
   __builtin_os_log_format(buf, "capabilities: %@", (id)GenString());
   os_log_pack_send(buf);
 }
 
 // CHECK-LABEL: define void @test_builtin_os_log4(
-// CHECK: alloca i8*, align 8
-// CHECK: %[[OS_LOG_ARG:.*]] = alloca i8*, align 8
-// CHECK: %[[OS_LOG_ARG2:.*]] = alloca i8*, align 8
-// CHECK: %[[CALL:.*]] = call {{.*}} @objc_msgSend
+// CHECK: %[[CALL:.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(
 // CHECK: %[[V4:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL]])
-// CHECK: %[[V5:.*]] = call i8* @llvm.objc.retain(i8* %[[V4]])
-// CHECK: store i8* %[[V5]], i8** %[[OS_LOG_ARG]], align 8
-// CHECK: %[[V6:.*]] = ptrtoint i8* %[[V5]] to i64
-// CHECK: %[[CALL1:.*]] = call {{.*}} @objc_msgSend
-// CHECK: %[[V10:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL1]])
-// CHECK: %[[V11:.*]] = call i8* @llvm.objc.retain(i8* %[[V10]])
-// CHECK: store i8* %[[V11]], i8** %[[OS_LOG_ARG2]], align 8
-// CHECK: %[[V12:.*]] = ptrtoint i8* %[[V11]] to i64
-// CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(i8* %{{.*}}, i64 %[[V6]], i64 %[[V12]])
-// CHECK: call void @llvm.objc.release(i8* %[[V10]])
+// CHECK: %[[CALL1:.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (
+// CHECK: %[[V9:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL1]])
+// CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(
+// CHECK: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V9]])
+// CHECK: call void @llvm.objc.release(i8* %[[V9]])
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V4]])
 // CHECK: call void @llvm.objc.release(i8* %[[V4]])
-// CHECK: call void @os_log_pack_send(i8* %{{.*}})
-// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V11]])
-// CHECK-O2: %[[V14:.*]] = load i8*, i8** %[[OS_LOG_ARG2]], align 8
-// CHECK-O2: call void @llvm.objc.release(i8* %[[V14]])
-// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V5]])
-// CHECK-O2: %[[V15:.*]] = load i8*, i8** %[[OS_LOG_ARG]], align 8
-// CHECK-O2: call void @llvm.objc.release(i8* %[[V15]])
 
 void test_builtin_os_log4(void *buf) {
   __builtin_os_log_format(buf, "capabilities: %@ %@", [c m0], [C m1]);
   os_log_pack_send(buf);
 }
 
-// FIXME: Lifetime of GenString's return should be extended in this case too.
 // CHECK-LABEL: define void @test_builtin_os_log5(
+// CHECK: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK: %[[V1:.*]] = bitcast %{{.}}* %[[CALL]] to i8*
+// CHECK: %[[V2:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to %{{.*}}*
+// CHECK: call void @__os_log_helper_1_2_1_8_64(
 // CHECK: call void @os_log_pack_send(
-// CHECK-NOT: call void @llvm.objc.release(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V3]])
+// CHECK: %[[V6:.*]] = bitcast %{{.*}}* %[[V3]] to i8*
+// CHECK: call void @llvm.objc.release(i8* %[[V6]])
 
 void test_builtin_os_log5(void *buf) {
   __builtin_os_log_format(buf, "capabilities: %@", (0, GenString()));
   os_log_pack_send(buf);
 }
+
+// CHECK-LABEL: define void @test_builtin_os_log6(
+// CHECK: call void @os_log_pack_send(
+// CHECK-NOT: call
+
+void test_builtin_os_log6(void *buf) {
+  __builtin_os_log_format(buf, "%@", (GenString(), g0));
+  os_log_pack_send(buf);
+}
+
+// CHECK-LABEL: define void @test_builtin_os_log7(
+// CHECK: alloca i8*, align 8
+// CHECK: %[[TMP:.*]] = alloca %{{.*}}*, align 8
+// CHECK: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK: %[[V1:.*]] = bitcast %{{.}}* %[[CALL]] to i8*
+// CHECK: %[[V2:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to %{{.*}}*
+// CHECK: %[[V4:.*]] = bitcast %{{.*}}* %[[V3]] to i8*
+// CHECK: call void @llvm.objc.release(i8* %[[V4]])
+// CHECK: %[[CALL1:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK: %[[V5:.*]] = bitcast %{{.}}* %[[CALL1]] to i8*
+// CHECK: %[[V6:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V5]])
+// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to %{{.*}}*
+// CHECK: store %{{.}}* %[[V7]], %{{.}}** %[[TMP]], align 8
+// CHECK: %[[V8:.*]] = load %{{.}}*, %{{.}}** %[[TMP]], align 8
+// CHECK: call void @__os_log_helper_1_2_1_8_64(
+// CHECK: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V8]])
+// CHECK: %[[V11:.*]] = bitcast %{{.*}}* %[[V8]] to i8*
+// CHECK: call void @llvm.objc.release(i8* %[[V11]])
+
+void test_builtin_os_log7(void *buf) {
+  __builtin_os_log_format(buf, "%@", ({ GenString(); GenString(); }));
+  os_log_pack_send(buf);
+}
+
+// CHECK-LABEL: define void @test_builtin_os_log8(
+// CHECK: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK: %[[V1:.*]] = bitcast %{{.}}* %[[CALL]] to i8*
+// CHECK: %[[V2:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
+// CHECK: %[[V3:.*]] = bitcast i8* %[[V2]] to %{{.*}}*
+// CHECK: call void @__os_log_helper_1_2_1_8_64(
+// CHECK: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V3]])
+// CHECK: %[[V6:.*]] = bitcast %{{.*}}* %[[V3]] to i8*
+// CHECK: call void @llvm.objc.release(i8* %[[V6]])
+
+void test_builtin_os_log8(void *buf) {
+  __builtin_os_log_format(buf, "%@", (g0, (g0, GenString())));
+  os_log_pack_send(buf);
+}
+
+// CHECK-O2-LABEL: define void @test_builtin_os_log9(
+// CHECK-O2: %[[CLEANUP_COND:.*]] = alloca i1, align 1
+// CHECK-O2: %[[COND_CLEANUP_SAVE:.*]] = alloca %{{.*}}*, align 8
+// CHECK-O2: %[[CLEANUP_COND3:.*]] = alloca i1, align 1
+// CHECK-O2: %[[COND_CLEANUP_SAVE4:.*]] = alloca %{{.*}}*, align 8
+// CHECK-O2: %[[CLEANUP_COND10:.*]] = alloca i1, align 1
+// CHECK-O2: %[[COND_CLEANUP_SAVE11:.*]] = alloca %{{.*}}*, align 8
+// CHECK-O2: %[[CLEANUP_COND12:.*]] = alloca i1, align 1
+// CHECK-O2: %[[COND_CLEANUP_SAVE13:.*]] = alloca %{{.*}}*, align 8
+// CHECK-O2: store i1 false, i1* %[[CLEANUP_COND]], align 1
+// CHECK-O2: store i1 false, i1* %[[CLEANUP_COND3]], align 1
+// CHECK-O2: store i1 false, i1* %[[CLEANUP_COND10]], align 1
+// CHECK-O2: store i1 false, i1* %[[CLEANUP_COND12]], align 1
+
+// CHECK-O2: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK-O2: %[[V3:.*]] = bitcast %{{.*}}* %[[CALL]] to i8*
+// CHECK-O2: %[[V4:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V3]])
+// CHECK-O2: %[[V5:.*]] = bitcast i8* %[[V4]] to %{{.*}}*
+// CHECK-O2: store i1 true, i1* %[[CLEANUP_COND]], align 1
+// CHECK-O2: store %{{.*}}* %[[V5]], %{{.*}}** %[[COND_CLEANUP_SAVE]], align 8
+// CHECK-O2: store i1 true, i1* %[[CLEANUP_COND3]], align 1
+// CHECK-O2: store %{{.*}}* %[[V5]], %{{.*}}** %[[COND_CLEANUP_SAVE4]], align 8
+// CHECK-O2: %[[V6:.*]] = bitcast %{{.*}}* %[[V5]] to i8*
+
+// CHECK-O2: %[[V7:.*]] = load i8*, i8** @g1, align 8
+
+// CHECK-O2: %[[COND:.*]] = phi i8* [ %[[V6]], %{{.*}} ], [ %[[V7]], %{{.*}} ]
+
+// CHECK-O2: %[[V9:.*]] = load i8*, i8** @g0, align 8
+
+// CHECK-O2: %[[CALL9:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK-O2: %[[V10:.*]] = bitcast %{{.*}}* %[[CALL9]] to i8*
+// CHECK-O2: %[[V11:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V10]])
+// CHECK-O2: %[[V12:.*]] = bitcast i8* %[[V11]] to %{{.*}}*
+// CHECK-O2: store i1 true, i1* %[[CLEANUP_COND10]], align 1
+// CHECK-O2: store %{{.*}}* %[[V12]], %{{.*}}** %[[COND_CLEANUP_SAVE11]], align 8
+// CHECK-O2: store i1 true, i1* %[[CLEANUP_COND12]], align 1
+// CHECK-O2: store %{{.*}}* %[[V12]], %{{.*}}** %[[COND_CLEANUP_SAVE13]], align 8
+// CHECK-O2: %[[V13:.*]] = bitcast %{{.*}}* %[[V12]] to i8*
+
+// CHECK-O2: %[[COND15:.*]] = phi i8* [ %[[V9]], %{{.*}} ], [ %[[V13]], %{{.*}} ]
+
+// CHECK-O2: %[[COND17:.*]] = phi i8* [ %[[COND]], %{{.*}} ], [ %[[COND15]], %{{.*}} ]
+// CHECK-O2: %[[V14:.*]] = ptrtoint i8* %[[COND17]] to i64
+// CHECK-O2: call void @__os_log_helper_1_2_1_8_64(i8* %{{.*}}, i64 %[[V14]])
+// CHECK-O2: call void @os_log_pack_send(
+// CHECK-O2: %[[CLEANUP_IS_ACTIVE:.*]] = load i1, i1* %[[CLEANUP_COND12]], align 1
+// CHECK-O2: br i1 %[[CLEANUP_IS_ACTIVE]],
+
+// CHECK-O2: %[[V16:.*]] = load %{{.*}}*, %{{.*}}** %[[COND_CLEANUP_SAVE13]], align 8
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V16]])
+
+// CHECK-O2: %[[CLEANUP_IS_ACTIVE18:.*]] = load i1, i1* %[[CLEANUP_COND10]], align 1
+// CHECK-O2: br i1 %[[CLEANUP_IS_ACTIVE18]],
+
+// CHECK-O2: %[[V17:.*]] = load %{{.*}}*, %{{.*}}** %[[COND_CLEANUP_SAVE11]], align 8
+// CHECK-O2: %[[V18:.*]] = bitcast %{{.*}}* %[[V17]] to i8*
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V18]])
+
+// CHECK-O2: %[[CLEANUP_IS_ACTIVE21:.*]] = load i1, i1* %[[CLEANUP_COND3]], align 1
+// CHECK-O2: br i1 %[[CLEANUP_IS_ACTIVE21]],
+
+// CHECK-O2: %[[V19:.*]] = load %{{.*}}*, %{{.*}}** %[[COND_CLEANUP_SAVE4]], align 8
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V19]])
+
+// CHECK-O2: %[[CLEANUP_IS_ACTIVE24:.*]] = load i1, i1* %[[CLEANUP_COND]], align 1
+// CHECK-O2: br i1 %[[CLEANUP_IS_ACTIVE24]],
+
+// CHECK-O2: %[[V20:.*]] = load %{{.*}}*, %{{.*}}** %[[COND_CLEANUP_SAVE]], align 8
+// CHECK-O2: %[[V21:.*]] = bitcast %{{.*}}* %[[V20]] to i8*
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V21]])
+
+void test_builtin_os_log9(void *buf, int c) {
+  __builtin_os_log_format(buf, "%@", c > 11 ? (c > 20 ? GenString() : g1) : (0, (c < 0 ? g0 : GenString())));
+  os_log_pack_send(buf);
+}
+
+// CHECK-O2-LABEL: define void @test_builtin_os_log10(
+// CHECK-O2: %[[CALL:.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(
+// CHECK-O2: %[[V7:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL]])
+// CHECK-O2: call void @__os_log_helper_1_2_1_8_64(
+// CHECK-O2: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V7]])
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V7]])
+
+void test_builtin_os_log10(void *buf, C *c) {
+  __builtin_os_log_format(buf, "%@", c.prop0);
+  os_log_pack_send(buf);
+}
+
+// CHECK-O2-LABEL: define void @test_builtin_os_log11(
+// CHECK-O2: alloca i8*, align 8
+// CHECK-O2: %[[TMP:.*]] = alloca i8*, align 8
+// CHECK-O2: %[[CALL:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK-O2: %[[V2:.*]] = bitcast %{{.*}}* %[[CALL]] to i8*
+// CHECK-O2: %[[V3:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V2]])
+// CHECK-O2: %[[V4:.*]] = bitcast i8* %[[V3]] to %{{.*}}*
+// CHECK-O2: call void @__os_log_helper_1_2_1_8_64(
+// CHECK-O2: call void @os_log_pack_send(
+// CHECK-O2: %[[V7:.*]] = load i8*, i8** @g0, align 8
+// CHECK-O2: %[[V8:.*]] = call i8* @llvm.objc.retain(i8* %[[V7]])
+// CHECK-O2: store i8* %[[V8]], i8** %[[TMP]], align 8
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V4]])
+// CHECK-O2: %[[V9:.*]] = bitcast %{{.*}}* %[[V4]] to i8*
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V9]])
+// CHECK-O2: %[[V10:.*]] = load i8*, i8** %[[TMP]], align 8
+// CHECK-O2: %[[CALL1:.*]] = call %{{.*}}* (...) @GenString()
+// CHECK-O2: %[[V12:.*]] = bitcast %{{.*}}* %[[CALL1]] to i8*
+// CHECK-O2: %[[V13:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V12]])
+// CHECK-O2: %[[V14:.*]] = bitcast i8* %[[V13]] to %{{.*}}*
+// CHECK-O2: call void @__os_log_helper_1_2_2_8_64_8_64(
+// CHECK-O2: call void @os_log_pack_send(
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(%{{.*}}* %[[V14]])
+// CHECK-O2: %[[V17:.*]] = bitcast %{{.*}}* %[[V14]] to i8*
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V17]])
+// CHECK-O2: call void (...) @llvm.objc.clang.arc.use(i8* %[[V10]])
+// CHECK-O2: call void @llvm.objc.release(i8* %[[V10]])
+
+void test_builtin_os_log11(void *buf) {
+  __builtin_os_log_format(buf, "%@ %@",
+                          ({
+                            __builtin_os_log_format(buf, "%@", GenString());
+                            os_log_pack_send(buf);
+                            g0;
+                          }),
+                          GenString());
+  os_log_pack_send(buf);
+}

clang/test/CodeGenObjCXX/os_log.mm

 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple -fobjc-arc \
-// RUN:   -fexceptions -fcxx-exceptions | FileCheck %s
+// RUN:   -fexceptions -fcxx-exceptions -fobjc-arc-exceptions -O2 \
+// RUN:   -disable-llvm-passes | FileCheck %s
+
+@class Class0;
 
 // Check that no EH cleanup is emitted around the call to __os_log_helper.
 namespace no_eh_cleanup {
   void release(int *lock);
 
   // CHECK-LABEL: define {{.*}} @_ZN13no_eh_cleanup3logERiPcS1_(
   // CHECK: call void @__os_log_helper_1_2_2_4_0_8_34(
 
   void log(int &i, char *data, char *buf) {
       int lock __attribute__((cleanup(release)));
       __builtin_os_log_format(buf, "%d %{public}s", i, data);
   }
 
   // Check that the os_log_helper is marked `nounwind`.
   // CHECK: define {{.*}} @__os_log_helper_1_2_2_4_0_8_34({{.*}} [[NUW:#[0-9]+]]
 }
 
+namespace extend_lifetime {
+void os_log_pack_send(void *);
+id getObj(int);
+id g0, g1;
+
+// CHECK-LABEL: define void @_ZN15extend_lifetime5test0EPvb(
+// CHECK: alloca i8*, align 8
+// CHECK: alloca i8, align 1
+// CHECK: %[[COND_CLEANUP_SAVE:.*]] = alloca i8*, align 8
+// CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1
+// CHECK: %[[CLEANUP_COND1:.*]] = alloca i1, align 1
+// CHECK: %[[COND_CLEANUP_SAVE2:.*]] = alloca i8*, align 8
+// CHECK: %[[CLEANUP_COND3:.*]] = alloca i1, align 1
+// CHECK: %[[COND_CLEANUP_SAVE4:.*]] = alloca i8*, align 8
+// CHECK: alloca i8*, align 8
+// CHECK: %[[COND_CLEANUP_SAVE6:.*]] = alloca i8*, align 8
+// CHECK: %[[CLEANUP_COND7:.*]] = alloca i1, align 1
+// CHECK: %[[CLEANUP_COND8:.*]] = alloca i1, align 1
+// CHECK: %[[COND_CLEANUP_SAVE9:.*]] = alloca i8*, align 8
+// CHECK: %[[CLEANUP_COND10:.*]] = alloca i1, align 1
+// CHECK: %[[COND_CLEANUP_SAVE11:.*]] = alloca i8*, align 8
+// CHECK: store i1 false, i1* %[[CLEANUP_COND]], align 1
+// CHECK: store i1 false, i1* %[[CLEANUP_COND1]], align 1
+// CHECK: store i1 false, i1* %[[CLEANUP_COND3]], align 1
+// CHECK: store i1 false, i1* %[[CLEANUP_COND7]], align 1
+// CHECK: store i1 false, i1* %[[CLEANUP_COND8]], align 1
+// CHECK: store i1 false, i1* %[[CLEANUP_COND10]], align 1
+
+// CHECK: %[[CALL:.*]] = call i8* @_ZN15extend_lifetime6getObjEi(i32 0)
+// CHECK: %[[V2:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL]])
+// CHECK: store i8* %[[V2]], i8** %[[COND_CLEANUP_SAVE]], align 8
+// CHECK: store i1 true, i1* %[[CLEANUP_COND]], align 1
+// CHECK: store i1 true, i1* %[[CLEANUP_COND1]], align 1
+// CHECK: store i8* %[[V2]], i8** %[[COND_CLEANUP_SAVE2]], align 8
+// CHECK: store i1 true, i1* %[[CLEANUP_COND3]], align 1
+// CHECK: store i8* %[[V2]], i8** %[[COND_CLEANUP_SAVE4]], align 8
+
+// CHECK: %[[CALL5:.*]] = invoke i8* @_ZN15extend_lifetime6getObjEi(i32 1)
+
+// CHECK: %[[V3:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL5]])
+// CHECK: store i8* %[[V3]], i8** %[[COND_CLEANUP_SAVE6]], align 8
+// CHECK: store i1 true, i1* %[[CLEANUP_COND7]], align 1
+// CHECK: store i1 true, i1* %[[CLEANUP_COND8]], align 1
+// CHECK: store i8* %[[V3]], i8** %[[COND_CLEANUP_SAVE9]], align 8
+// CHECK: store i1 true, i1* %[[CLEANUP_COND10]], align 1
+// CHECK: store i8* %[[V3]], i8** %[[COND_CLEANUP_SAVE11]], align 8
+
+// CHECK: %[[COND:.*]] = phi i8* [ %[[V2]], %{{.*}} ], [ %[[V3]], %{{.*}} ]
+// CHECK: %[[V4:.*]] = ptrtoint i8* %[[COND]] to i64
+// CHECK: %[[CALL14:.*]] = invoke i8* @_ZN15extend_lifetime6getObjEi(i32 2)
+
+// CHECK: %[[V5:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL14]])
+// CHECK: %[[V6:.*]] = ptrtoint i8* %[[V5]] to i64
+// CHECK: call void @__os_log_helper_1_2_2_8_64_8_64(i8* %{{.*}}, i64 %[[V4]], i64 %[[V6]])
+// CHECK: invoke void @_ZN15extend_lifetime16os_log_pack_sendEPv(
+
+// CHECK: call void (...) @llvm.objc.clang.arc.use(i8* %[[V5]]) #4
+// CHECK: call void @llvm.objc.release(i8* %[[V5]])
+// CHECK: %[[CLEANUP_IS_ACTIVE21:.*]] = load i1, i1* %[[CLEANUP_COND10]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE21]],
+
+// CHECK: %[[V8:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE11]], align 8
+// CHECK: call void (...) @llvm.objc.clang.arc.use(i8* %[[V8]])
+
+// CHECK: %[[CLEANUP_IS_ACTIVE24:.*]] = load i1, i1* %[[CLEANUP_COND8]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE24]],
+
+// CHECK: %[[V9:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE9]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V9]])
+
+// CHECK: %[[CLEANUP_IS_ACTIVE31:.*]] = load i1, i1* %[[CLEANUP_COND3]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE31]],
+
+// CHECK: %[[V10:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE4]], align 8
+// CHECK: call void (...) @llvm.objc.clang.arc.use(i8* %[[V10]])
+
+// CHECK: %[[CLEANUP_IS_ACTIVE34:.*]] = load i1, i1* %[[CLEANUP_COND1]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE34]],
+
+// CHECK: %[[V11:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE2]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V11]])
+
+// CHECK: ret void
+
+// CHECK: landingpad { i8*, i32 }
+
+// CHECK: landingpad { i8*, i32 }
+// CHECK: %[[CLEANUP_IS_ACTIVE:.*]] = load i1, i1* %[[CLEANUP_COND7]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE]],
+
+// CHECK: %[[V18:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE6]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V18]])
+
+// CHECK: %[[CLEANUP_IS_ACTIVE15:.*]] = load i1, i1* %[[CLEANUP_COND]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE15]],
+
+// CHECK: %[[V19:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V19]])
+
+// CHECK: landingpad { i8*, i32 }
+// CHECK: call void @llvm.objc.release(i8* %[[V5]])
+// CHECK: %[[CLEANUP_IS_ACTIVE28:.*]] = load i1, i1* %[[CLEANUP_COND8]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE28]],
+
+// CHECK: %[[V23:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE9]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V23]])
+
+// CHECK: %[[CLEANUP_IS_ACTIVE38:.*]] = load i1, i1* %[[CLEANUP_COND1]], align 1
+// CHECK: br i1 %[[CLEANUP_IS_ACTIVE38]],
+
+// CHECK: %[[V24:.*]] = load i8*, i8** %[[COND_CLEANUP_SAVE2]], align 8
+// CHECK: call void @llvm.objc.release(i8* %[[V24]])
+
+void test0(void *buf, bool c) {
+  __builtin_os_log_format(buf, "%@ %@", c ? getObj(0) : getObj(1), getObj(2));
+  os_log_pack_send(buf);
+}
+
+}
+
 // CHECK: attributes [[NUW]] = { {{.*}}nounwind

clang/test/PCH/Inputs/arc.h

 #define BRIDGE __bridge
 #else
 #define BRIDGE
 #endif
 
 typedef int array0[sizeof((BRIDGE id)CFCreateSomething())];
 typedef int array1[sizeof((BRIDGE CFTypeRef)CreateSomething())];
 
-
+static inline void callBuiltinOSLogFormat(void *buf) {
+  extern id getObj(void);
+  extern void os_log_pack_send(void *);
+  __builtin_os_log_format(buf, "%@", getObj());
+  os_log_pack_send(buf);
+}

clang/test/PCH/arc.m

 // REQUIRES: x86-registered-target
 // Test this without pch.
 // RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fobjc-arc -include %S/Inputs/arc.h -fsyntax-only -emit-llvm-only %s
 
 // Test with pch.
 // RUN: %clang_cc1 -emit-pch -fblocks -triple x86_64-apple-darwin11 -fobjc-arc -x objective-c-header -o %t %S/Inputs/arc.h
-// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fobjc-arc -include-pch %t -fsyntax-only -emit-llvm-only %s 
+// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fobjc-arc -include-pch %t -emit-llvm -o - %s | FileCheck %s
 
 // Test error when pch's -fobjc-arc state is different.
 // RUN: not %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -include-pch %t -fsyntax-only -emit-llvm-only %s 2>&1 | FileCheck -check-prefix=CHECK-ERR1 %s 
 // RUN: %clang_cc1 -emit-pch -fblocks -triple x86_64-apple-darwin11 -x objective-c-header -o %t %S/Inputs/arc.h
 // RUN: not %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fobjc-arc -include-pch %t -fsyntax-only -emit-llvm-only %s 2>&1 | FileCheck -check-prefix=CHECK-ERR2 %s
 
 array0 a0;
 array1 a1;
 
 // CHECK-ERR1: Objective-C automated reference counting was enabled in PCH file but is currently disabled
 // CHECK-ERR2: Objective-C automated reference counting was disabled in PCH file but is currently enabled
+
+// CHECK: define internal void @callBuiltinOSLogFormat(
+// CHECK: %[[CALL:.*]] = call i8* @getObj()
+// CHECK: %[[V1:.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[CALL]])
+// CHECK: %[[V2:.*]] = ptrtoint i8* %[[V1]] to i64
+// CHECK: call void @__os_log_helper_1_2_1_8_64(i8* %{{.*}}, i64 %[[V2]])
+// CHECK: call void @os_log_pack_send(
+// CHECK: call void @llvm.objc.release(i8* %[[V1]])
+
+void testBuiltinOSLogFormat(void) {
+  callBuiltinOSLogFormat(0);
+}

clang/test/SemaObjC/format-strings-oslog.m

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -verify %s
 
 #include <stdarg.h>
 #include <stddef.h>
 #define __need_wint_t
 #include <stddef.h> // For wint_t and wchar_t
 
 int printf(const char *restrict, ...);
+id getObj(void);
 
 @interface NSString
 @end
 
 void test_os_log_format(const char *pc, int i, void *p, void *buf) {
   __builtin_os_log_format(buf, "");
   __builtin_os_log_format(buf, "%d"); // expected-warning {{more '%' conversions than data arguments}}
   __builtin_os_log_format(buf, "%d", i);

 
 // Test the os_log format attribute.
 void MyOSLog(const char *format, ...) __attribute__((format(os_log, 1, 2)));
 void test_attribute(void *p) {
   MyOSLog("%s\n", "Hello");
   MyOSLog("%d");    // expected-warning {{more '%' conversions than data arguments}}
   MyOSLog("%P", p); // expected-warning {{using '%P' format specifier without precision}}
 }
+
+void test_arc_extended_lifetime0(int cond, void *buf) {
+  switch (cond) {
+  case 0:
+    __builtin_os_log_format(buf, @"%@", getObj()); // expected-note {{jump enters lifetime of an object}}
+    break;
+  default: // expected-error {{cannot jump from switch statement to this case label}}
+    break;
+  }
+}
+
+void test_arc_extended_lifetime1(int cond, void *buf, id a) {
+  switch (cond) {
+  case 0:
+    __builtin_os_log_format(buf, @"%@", a);
+    break;
+  default:
+    break;
+  }
+}
+
+void test_arc_extended_lifetime2(int cond, void *buf) {
+  static void *ips[] = {&&L0};
+L0: // expected-note {{possible target of indirect goto}}
+    ;
+  __builtin_os_log_format(buf, @"%@", getObj()); // expected-note {{jump exits lifetime of an object}}
+  goto *ips;                                     // expected-error {{cannot jump}}
+}
+
+void test_arc_extended_lifetime3(int cond, void *buf, id a) {
+  static void *ips[] = {&&L0};
+L0:;
+  __builtin_os_log_format(buf, @"%@", a);
+  goto *ips;
+}