[ObjC][ARC] Teach the OptimizeSequences step of ObjCARCOpts about WinEH funclet tokens

[sgraenitz]

Summary

When optimizing retain-release-sequences we insert (and delete) ObjC runtime calls. These calls need a funclet operand bundle that refers to the enclosing funclet pad whenever they are inserted in a WinEH funclet. WinEH funclets can contain multiple basic blocks. In order to find the enclosing funclet pad, we have to calculate the funclet coloring first.

[sgraenitz]

There was a similar effort for CleanupPads in the past: https://reviews.llvm.org/rG8b342680bf62722e5099074e8bd23491c71d92b3

[sgraenitz]

There doesn't seem to be a 1-to-1 relationship between deleted and inserted retain/release calls and thus we don't attempt to preserve bundle operands in general.

[rnk]

I can't say I'm familiar with ARC, but this seems right to me.

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

774

I don't think the verifier changes you made guarantee this. I would consider strengthening this to report_fatal_error, since valid IR transforms can probably reach this code.

2028–2029

I think this code snippet probably deserves a Function helper, F->hasScopedEHPersonality(). Another part of me thinks we should cache the personality enum similar to the way we cache intrinsic ids, but I wouldn't want to increase Function memory usage, so that seems premature. "No action required", I guess.

[sgraenitz]

Thanks for your feedback @rnk! I hope some of the ObjCARCOpts authors will share their opinions as well.

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

774

Right, I guess the Verifier change is correct and this should change to work for multi-color BBs?

assert(CV.size() > 0 && "Uncolored block");
for (BasicBlock *EHPadBB : CV)
  if (auto *EHPad = dyn_cast<FuncletPadInst>(ColorFirstBB->getFirstNonPHI())) {
    OpBundles.emplace_back("funclet", EHPad);
    break;
  }

There is no test that covers this case, but it appears that the unique color invariant only holds after WinEHPrepare. The assertion here seems to imply it:

assert(BBColors.size() == 1 && "multi-color BB not removed by preparation");

Since it would be equivalent to the Verifier check, I'd stick with the assertion and not report a fatal error.

2028–2029

It doesn't really fit the the scope of this patch but I am happy to add the helper function in a follow-up (for now without personality enum caching).

[sgraenitz]

Rebase and update check-lines after D137939

[sgraenitz]

Handle potential multi-color basic blocks in addOpBundleForFunclet()

[sgraenitz]

This is ready to land and I'd appreciate feedback from one of the authors. Anyone else I should add for review?

[ahatanak]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

774

Is the assertion assert(CV.size() == 1 && "non-unique color for block!"); in CloneCallInstForBB incorrect too?

2028–2029

OptimizeIndividualCall calls colorEHFunclets too. Is it possible to just call it once? Or we don't care because it's not expensive?

[sgraenitz]

Address feedback

[sgraenitz]

Thanks for taking a look. Yes, the coloring can be expensive and we shouldn't run it more than once. OptimizeIndividualCalls did it and actually even OptimizeSequences runs in a loop "until it either stops making changes or no retain+release pair nesting is detected". I completely missed that.

I moved funclet coloring into ObjCARCOpt::init() so that it runs once for the whole pass now. The results are cached in ObjCARCOpt::BlockEHColors. addOpBundleForFunclet() and cloneCallInstForBB became member functions that can directly use the cached results. We don't need to pass them as parameters from function to function anymore. I think it's not only more efficient now but also much cleaner. That was really useful feedback @ahatanak! Thanks

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

774

The code path disappears with the subsequent patch D137945. But yes, it's formally incorrect and I adjusted the assertion in the last iteration.

2028–2029

Good catch! Right, we shouldn't do it multiple times. Having moved funclet coloring into ObjCARCOpt::init() it now runs only once.

[sgraenitz]

Ping

[sgraenitz]

This review belongs to a series of patches. I am planning to land it towards the end of next week, so that it's ready for the next release branching in February. If you have any more remarks, please let me know soon.

[ahatanak]

I'm not familiar with the WinEH stuff, but the other parts (the code that adds bundles, etc.) LGTM.

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

596

This piece of code does something similar to cloneCallInstForBB, but it's slightly different from it. It iterates over the entries in CV whereas the code above just looks at the first entry.

Is this a bug that is fixed in https://reviews.llvm.org/D137945?

[sgraenitz]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

596

Yes, D137945 unifies the behavior so that we will always iterate. The unique color invariant only holds after WinEHPrepare. So the old assertion in cloneCallInstForBB() was formally wrong, but I only ever observed cases of non-unique coloring in incorrect IR, i.e. dangling funclet tokens before D137939. Iteration is the safe solution, especially since we may not be able to bail out on dangling funclet tokens in the verifier (see https://reviews.llvm.org/D138123#4067201).

FYI: We discussed it this in a previous round of this review https://reviews.llvm.org/D137944?id=475132#inline-1334823

750

The old code here assumed all EH coloring to be unique.

clang/test/CodeGenObjCXX/arc-exceptions-seh.mm

-// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -emit-llvm -fobjc-arc -fexceptions -fobjc-exceptions -fobjc-arc-exceptions -fobjc-runtime=gnustep-2.0 -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-O0
-// RUN: %clang_cc1 -O2 -triple x86_64-pc-windows-msvc -emit-llvm -fobjc-arc -fexceptions -fobjc-exceptions -fobjc-arc-exceptions -fobjc-runtime=gnustep-2.0 -mllvm -enable-objc-arc-opts=false -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-O2
+// RUN: %clang_cc1 -O0 -triple x86_64-pc-windows-msvc -emit-llvm -fobjc-arc -fexceptions -fobjc-exceptions -fobjc-arc-exceptions -fobjc-runtime=gnustep-2.0 -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-O0
+// RUN: %clang_cc1 -O2 -triple x86_64-pc-windows-msvc -emit-llvm -fobjc-arc -fexceptions -fobjc-exceptions -fobjc-arc-exceptions -fobjc-runtime=gnustep-2.0 -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-O2
 
 // WinEH requires funclet tokens on nounwind intrinsics if they can lower to
 // regular function calls in the course of IR transformations.
 //
 // This is the case for ObjC ARC runtime intrinsics. Test that clang emits the
 // funclet tokens for llvm.objc.* calls inside catch- and cleanup-pads and that
 // they refer to their pad's SSA value.
 
 void do_something();
 void may_throw(id);
 
 void try_catch_with_objc_intrinsic() {
   id ex;
   @try {
     may_throw(ex);
   } @catch (id ex_caught) {
     do_something();
     may_throw(ex_caught);
   }
 }
 
 // CHECK-LABEL:   try_catch_with_objc_intrinsic
 //
 // CHECK:         catch.dispatch:
-// CHECK-NEXT:      [[CATCHSWITCH:%[0-9]+]] = catchswitch within none [label %catch] unwind label %[[CLEANUP1:.*]]
+// CHECK-NEXT:      [[CATCHSWITCH:%[0-9]+]] = catchswitch within none [label %catch]
+// CHECK-O0:          unwind label %[[CLEANUP1:.*]]
+// CHECK-O2:          unwind to caller
 //
 // All calls within a catchpad must have funclet tokens that refer to it:
 // CHECK:         catch:
 // CHECK-NEXT:      [[CATCHPAD:%[0-9]+]] = catchpad within [[CATCHSWITCH]]
 // CHECK:           call
 // CHECK:             @llvm.objc.retain
 // CHECK:             [ "funclet"(token [[CATCHPAD]]) ]
 // CHECK:           invoke

 //
 // CHECK:         [[CLEANUP2]]:
 // CHECK-NEXT:      [[CLEANUPPAD2:%[0-9]+]] = cleanuppad within [[CATCHPAD]]
 // CHECK:           call
 // CHECK-O0:          @llvm.objc.storeStrong
 // CHECK-O2:          @llvm.objc.release
 // CHECK:             [ "funclet"(token [[CLEANUPPAD2]]) ]
 // CHECK:           cleanupret from [[CLEANUPPAD2]]
-// CHECK:             unwind label %[[CLEANUP1]]
+// CHECK-O0:          unwind label %[[CLEANUP1]]
+// CHECK-O2:          unwind to caller
 //
-// CHECK:         [[CLEANUP1]]:
-// CHECK-NEXT:      [[CLEANUPPAD1:%[0-9]+]] = cleanuppad within none
-// CHECK:           call
+// CHECK-O0:      [[CLEANUP1]]:
+// CHECK-O0-NEXT:   [[CLEANUPPAD1:%[0-9]+]] = cleanuppad within none
+// CHECK-O0:        call
 // CHECK-O0:          @llvm.objc.storeStrong
-// CHECK-O2:          @llvm.objc.release
-// CHECK:             [ "funclet"(token [[CLEANUPPAD1]]) ]
-// CHECK:           cleanupret from [[CLEANUPPAD1]] unwind to caller
+// CHECK-O0:          [ "funclet"(token [[CLEANUPPAD1]]) ]
+// CHECK-O0:        cleanupret from [[CLEANUPPAD1]] unwind to caller

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

class ObjCARCOpt {
   /// A flag indicating whether the optimization that removes or moves
   /// retain/release pairs should be performed.
   bool DisableRetainReleasePairing = false;
 
   /// Flags which determine whether each of the interesting runtime functions
   /// is in fact used in the current function.
   unsigned UsedInThisFunction;
 
+  DenseMap<BasicBlock *, ColorVector> BlockEHColors;
+
   bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV);
   void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
                                  ARCInstKind &Class);
   void OptimizeIndividualCalls(Function &F);
 
   /// Optimize an individual call, optionally passing the
   /// GetArgRCIdentityRoot if it has already been computed.
-  void OptimizeIndividualCallImpl(
-      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
-      Instruction *Inst, ARCInstKind Class, const Value *Arg);
+  void OptimizeIndividualCallImpl(Function &F, Instruction *Inst,
+                                  ARCInstKind Class, const Value *Arg);
 
   /// Try to optimize an AutoreleaseRV with a RetainRV or UnsafeClaimRV.  If the
   /// optimization occurs, returns true to indicate that the caller should
   /// assume the instructions are dead.
-  bool OptimizeInlinedAutoreleaseRVCall(
-      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
-      Instruction *Inst, const Value *&Arg, ARCInstKind Class,
-      Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg);
+  bool OptimizeInlinedAutoreleaseRVCall(Function &F, Instruction *Inst,
+                                        const Value *&Arg, ARCInstKind Class,
+                                        Instruction *AutoreleaseRV,
+                                        const Value *&AutoreleaseRVArg);
 
   void CheckForCFGHazards(const BasicBlock *BB,
                           DenseMap<const BasicBlock *, BBState> &BBStates,
                           BBState &MyStates) const;
   bool VisitInstructionBottomUp(Instruction *Inst, BasicBlock *BB,
                                 BlotMapVector<Value *, RRInfo> &Retains,
                                 BBState &MyStates);
   bool VisitBottomUp(BasicBlock *BB,
bool PerformCodePlacement(DenseMap<const BasicBlock *, BBState> &BBStates,
                             DenseMap<Value *, RRInfo> &Releases, Module *M);
 
   void OptimizeWeakCalls(Function &F);
 
   bool OptimizeSequences(Function &F);
 
   void OptimizeReturns(Function &F);
 
+  Instruction *cloneCallInstForBB(CallInst &CI, BasicBlock &BB) {
+    SmallVector<OperandBundleDef, 1> OpBundles;
+    for (unsigned I = 0, E = CI.getNumOperandBundles(); I != E; ++I) {
+      auto Bundle = CI.getOperandBundleAt(I);
+      // Funclets will be reassociated in the future.
+      if (Bundle.getTagID() == LLVMContext::OB_funclet)
+        continue;
+      OpBundles.emplace_back(Bundle);
+    }
+
+    if (!BlockEHColors.empty()) {
+      const ColorVector &CV = BlockEHColors.find(&BB)->second;
+      assert(CV.size() > 0 && "non-unique color for block!");
+      Instruction *EHPad = CV.front()->getFirstNonPHI();
+      if (EHPad->isEHPad())
+        OpBundles.emplace_back("funclet", EHPad);
+    }
+
+    return CallInst::Create(&CI, OpBundles);
+  }
+
+  void addOpBundleForFunclet(BasicBlock *BB,
+                             SmallVectorImpl<OperandBundleDef> &OpBundles) {
+    if (!BlockEHColors.empty()) {
+      const ColorVector &CV = BlockEHColors.find(BB)->second;
+      assert(CV.size() > 0 && "Uncolored block");
+      for (BasicBlock *EHPadBB : CV)
+        if (auto *EHPad = dyn_cast<FuncletPadInst>(EHPadBB->getFirstNonPHI())) {
+          OpBundles.emplace_back("funclet", EHPad);
+          return;
+        }
+    }
+  }
+
 #ifndef NDEBUG
   void GatherStatistics(Function &F, bool AfterOptimization = false);
 #endif
 
   public:
-    void init(Module &M);
+    void init(Function &F);
     bool run(Function &F, AAResults &AA);
     bool hasCFGChanged() const { return CFGChanged; }
 };
 } // end anonymous namespace
 
 /// Turn objc_retainAutoreleasedReturnValue into objc_retain if the operand is
 /// not a return value.
 bool
ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
   cast<CallInst>(RetainRV)->setCalledFunction(NewDecl);
 
   LLVM_DEBUG(dbgs() << "New = " << *RetainRV << "\n");
 
   return false;
 }
 
 bool ObjCARCOpt::OptimizeInlinedAutoreleaseRVCall(
-    Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
-    Instruction *Inst, const Value *&Arg, ARCInstKind Class,
+    Function &F, Instruction *Inst, const Value *&Arg, ARCInstKind Class,
     Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg) {
   if (BundledInsts->contains(Inst))
     return false;
 
   // Must be in the same basic block.
   assert(Inst->getParent() == AutoreleaseRV->getParent());
 
   // Must operate on the same root.
CallInst *Release = CallInst::Create(
       EP.get(ARCRuntimeEntryPointKind::Release), CallArg, "", Inst);
   assert(IsAlwaysTail(ARCInstKind::UnsafeClaimRV) &&
          "Expected UnsafeClaimRV to be safe to tail call");
   Release->setTailCall();
   Inst->replaceAllUsesWith(CallArg);
   EraseInstruction(Inst);
 
   // Run the normal optimizations on Release.
-  OptimizeIndividualCallImpl(F, BlockColors, Release, ARCInstKind::Release,
-                             Arg);
+  OptimizeIndividualCallImpl(F, Release, ARCInstKind::Release, Arg);
   return true;
 }
 
 /// Turn objc_autoreleaseReturnValue into objc_autorelease if the result is not
 /// used as a return value.
 void ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F,
                                            Instruction *AutoreleaseRV,
                                            ARCInstKind &Class) {
void ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F,
   Function *NewDecl = EP.get(ARCRuntimeEntryPointKind::Autorelease);
   AutoreleaseRVCI->setCalledFunction(NewDecl);
   AutoreleaseRVCI->setTailCall(false); // Never tail call objc_autorelease.
   Class = ARCInstKind::Autorelease;
 
   LLVM_DEBUG(dbgs() << "New: " << *AutoreleaseRV << "\n");
 }
 
-namespace {
-Instruction *
-CloneCallInstForBB(CallInst &CI, BasicBlock &BB,
-                   const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
-  SmallVector<OperandBundleDef, 1> OpBundles;
-  for (unsigned I = 0, E = CI.getNumOperandBundles(); I != E; ++I) {
-    auto Bundle = CI.getOperandBundleAt(I);
-    // Funclets will be reassociated in the future.
-    if (Bundle.getTagID() == LLVMContext::OB_funclet)
-      continue;
-    OpBundles.emplace_back(Bundle);
-  }
-
-  if (!BlockColors.empty()) {
-    const ColorVector &CV = BlockColors.find(&BB)->second;
-    assert(CV.size() == 1 && "non-unique color for block!");
-    Instruction *EHPad = CV.front()->getFirstNonPHI();
-    if (EHPad->isEHPad())
-      OpBundles.emplace_back("funclet", EHPad);
-  }
-
-  return CallInst::Create(&CI, OpBundles);
-}
-}
-
 /// Visit each call, one at a time, and make simplifications without doing any
 /// additional analysis.
 void ObjCARCOpt::OptimizeIndividualCalls(Function &F) {
   LLVM_DEBUG(dbgs() << "\n== ObjCARCOpt::OptimizeIndividualCalls ==\n");
   // Reset all the flags in preparation for recomputing them.
   UsedInThisFunction = 0;
 
-  DenseMap<BasicBlock *, ColorVector> BlockColors;
-  if (F.hasPersonalityFn() &&
-      isScopedEHPersonality(classifyEHPersonality(F.getPersonalityFn())))
-    BlockColors = colorEHFunclets(F);
-
   // Store any delayed AutoreleaseRV intrinsics, so they can be easily paired
   // with RetainRV and UnsafeClaimRV.
   Instruction *DelayedAutoreleaseRV = nullptr;
   const Value *DelayedAutoreleaseRVArg = nullptr;
   auto setDelayedAutoreleaseRV = [&](Instruction *AutoreleaseRV) {
     assert(!DelayedAutoreleaseRV || !AutoreleaseRV);
     DelayedAutoreleaseRV = AutoreleaseRV;
     DelayedAutoreleaseRVArg = nullptr;
   };
   auto optimizeDelayedAutoreleaseRV = [&]() {
     if (!DelayedAutoreleaseRV)
       return;
-    OptimizeIndividualCallImpl(F, BlockColors, DelayedAutoreleaseRV,
+    OptimizeIndividualCallImpl(F, DelayedAutoreleaseRV,
                                ARCInstKind::AutoreleaseRV,
                                DelayedAutoreleaseRVArg);
     setDelayedAutoreleaseRV(nullptr);
   };
   auto shouldDelayAutoreleaseRV = [&](Instruction *NonARCInst) {
     // Nothing to delay, but we may as well skip the logic below.
     if (!DelayedAutoreleaseRV)
       return true;
for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
     case ARCInstKind::AutoreleaseRV:
       optimizeDelayedAutoreleaseRV();
       setDelayedAutoreleaseRV(Inst);
       continue;
     case ARCInstKind::RetainRV:
     case ARCInstKind::UnsafeClaimRV:
       if (DelayedAutoreleaseRV) {
         // We have a potential RV pair.  Check if they cancel out.
-        if (OptimizeInlinedAutoreleaseRVCall(F, BlockColors, Inst, Arg, Class,
+        if (OptimizeInlinedAutoreleaseRVCall(F, Inst, Arg, Class,
                                              DelayedAutoreleaseRV,
                                              DelayedAutoreleaseRVArg)) {
           setDelayedAutoreleaseRV(nullptr);
           continue;
         }
         optimizeDelayedAutoreleaseRV();
       }
       break;
     }
 
-    OptimizeIndividualCallImpl(F, BlockColors, Inst, Class, Arg);
+    OptimizeIndividualCallImpl(F, Inst, Class, Arg);
   }
 
   // Catch the final delayed AutoreleaseRV.
   optimizeDelayedAutoreleaseRV();
 }
 
 /// This function returns true if the value is inert. An ObjC ARC runtime call
 /// taking an inert operand can be safely deleted.
for (Value *Opnd : PN->incoming_values())
       if (!isInertARCValue(Opnd, VisitedPhis))
         return false;
     return true;
   }
 
   return false;
 }
 
-void ObjCARCOpt::OptimizeIndividualCallImpl(
-    Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
-    Instruction *Inst, ARCInstKind Class, const Value *Arg) {
+void ObjCARCOpt::OptimizeIndividualCallImpl(Function &F, Instruction *Inst,
+                                            ARCInstKind Class,
+                                            const Value *Arg) {
   LLVM_DEBUG(dbgs() << "Visiting: Class: " << Class << "; " << *Inst << "\n");
 
   // We can delete this call if it takes an inert value.
   SmallPtrSet<Value *, 1> VisitedPhis;
 
   if (BundledInsts->contains(Inst)) {
     UsedInThisFunction |= 1 << unsigned(Class);
     return;
do {
     CallInst *CInst = cast<CallInst>(Inst);
     Type *ParamTy = CInst->getArgOperand(0)->getType();
     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
       Value *Incoming = GetRCIdentityRoot(PN->getIncomingValue(i));
       if (IsNullOrUndef(Incoming))
         continue;
       Value *Op = PN->getIncomingValue(i);
       Instruction *InsertPos = &PN->getIncomingBlock(i)->back();
-      CallInst *Clone = cast<CallInst>(
-          CloneCallInstForBB(*CInst, *InsertPos->getParent(), BlockColors));
+      CallInst *Clone =
+          cast<CallInst>(cloneCallInstForBB(*CInst, *InsertPos->getParent()));
       if (Op->getType() != ParamTy)
         Op = new BitCastInst(Op, ParamTy, "", InsertPos);
       Clone->setArgOperand(0, Op);
       Clone->insertBefore(InsertPos);
 
       LLVM_DEBUG(dbgs() << "Cloning " << *CInst << "\n"
                                                    "And inserting clone at "
                         << *InsertPos << "\n");
void ObjCARCOpt::MoveCalls(Value *Arg, RRInfo &RetainsToMove,
 
   LLVM_DEBUG(dbgs() << "== ObjCARCOpt::MoveCalls ==\n");
 
   // Insert the new retain and release calls.
   for (Instruction *InsertPt : ReleasesToMove.ReverseInsertPts) {
     Value *MyArg = ArgTy == ParamTy ? Arg :
                    new BitCastInst(Arg, ParamTy, "", InsertPt);
     Function *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
-    CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
+    SmallVector<OperandBundleDef, 1> BundleList;
+    addOpBundleForFunclet(InsertPt->getParent(), BundleList);
+    CallInst *Call = CallInst::Create(Decl, MyArg, BundleList, "", InsertPt);
     Call->setDoesNotThrow();
     Call->setTailCall();
 
     LLVM_DEBUG(dbgs() << "Inserting new Retain: " << *Call
                       << "\n"
                          "At insertion point: "
                       << *InsertPt << "\n");
   }
   for (Instruction *InsertPt : RetainsToMove.ReverseInsertPts) {
     Value *MyArg = ArgTy == ParamTy ? Arg :
                    new BitCastInst(Arg, ParamTy, "", InsertPt);
     Function *Decl = EP.get(ARCRuntimeEntryPointKind::Release);
-    CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
+    SmallVector<OperandBundleDef, 1> BundleList;
+    addOpBundleForFunclet(InsertPt->getParent(), BundleList);
+    CallInst *Call = CallInst::Create(Decl, MyArg, BundleList, "", InsertPt);
     // Attach a clang.imprecise_release metadata tag, if appropriate.
     if (MDNode *M = ReleasesToMove.ReleaseMetadata)
       Call->setMetadata(MDKindCache.get(ARCMDKindID::ImpreciseRelease), M);
     Call->setDoesNotThrow();
     if (ReleasesToMove.IsTailCallRelease)
       Call->setTailCall();
 
     LLVM_DEBUG(dbgs() << "Inserting new Release: " << *Call

 /// them.
 bool ObjCARCOpt::PerformCodePlacement(
     DenseMap<const BasicBlock *, BBState> &BBStates,
     BlotMapVector<Value *, RRInfo> &Retains,
     DenseMap<Value *, RRInfo> &Releases, Module *M) {
   LLVM_DEBUG(dbgs() << "\n== ObjCARCOpt::PerformCodePlacement ==\n");
 
   bool AnyPairsCompletelyEliminated = false;
   SmallVector<Instruction *, 8> DeadInsts;
 
   // Visit each retain.
   for (BlotMapVector<Value *, RRInfo>::const_iterator I = Retains.begin(),
                                                       E = Retains.end();
        I != E; ++I) {
     Value *V = I->first;
     if (!V) continue; // blotted
 
     Instruction *Retain = cast<Instruction>(V);
for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
     case ARCInstKind::Release:
       ++NumReleases;
       break;
     }
   }
 }
 #endif
 
-void ObjCARCOpt::init(Module &M) {
+void ObjCARCOpt::init(Function &F) {
   if (!EnableARCOpts)
     return;
 
   // Intuitively, objc_retain and others are nocapture, however in practice
   // they are not, because they return their argument value. And objc_release
   // calls finalizers which can have arbitrary side effects.
-  MDKindCache.init(&M);
+  MDKindCache.init(F.getParent());
 
   // Initialize our runtime entry point cache.
-  EP.init(&M);
+  EP.init(F.getParent());
+
+  // Compute which blocks are in which funclet.
+  if (F.hasPersonalityFn() &&
+      isScopedEHPersonality(classifyEHPersonality(F.getPersonalityFn())))
+    BlockEHColors = colorEHFunclets(F);
 }
 
 bool ObjCARCOpt::run(Function &F, AAResults &AA) {
   if (!EnableARCOpts)
     return false;
 
   Changed = CFGChanged = false;
   BundledRetainClaimRVs BRV(/*ContractPass=*/false);

 }
 
 /// @}
 ///
 
 PreservedAnalyses ObjCARCOptPass::run(Function &F,
                                       FunctionAnalysisManager &AM) {
   ObjCARCOpt OCAO;
-  OCAO.init(*F.getParent());
+  OCAO.init(F);
 
   bool Changed = OCAO.run(F, AM.getResult<AAManager>(F));
   bool CFGChanged = OCAO.hasCFGChanged();
   if (Changed) {
     PreservedAnalyses PA;
     if (!CFGChanged)
       PA.preserveSet<CFGAnalyses>();
     return PA;
   }
   return PreservedAnalyses::all();
 }

llvm/test/Transforms/ObjCARC/funclet-catchpad.ll

+; RUN: opt -mtriple=x86_64-windows-msvc -passes=objc-arc -S < %s | FileCheck %s
+
+; Check that funclet tokens are preserved
+;
+; CHECK-LABEL:  catch:
+; CHECK:          %1 = catchpad within %0
+; CHECK:          %2 = tail call ptr @llvm.objc.retain(ptr %exn) #0 [ "funclet"(token %1) ]
+; CHECK:          call void @llvm.objc.release(ptr %exn) #0 [ "funclet"(token %1) ]
+; CHECK:          catchret from %1 to label %eh.cont
+
+define void @try_catch_with_objc_intrinsic() personality ptr @__CxxFrameHandler3 {
+entry:
+  %exn.slot = alloca ptr, align 8
+  invoke void @may_throw(ptr null) to label %eh.cont unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch] unwind to caller
+
+eh.cont:                                          ; preds = %catch, %entry
+  ret void
+
+catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %0 [ptr null, i32 0, ptr %exn.slot]
+  br label %if.then
+
+if.then:                                          ; preds = %catch
+  %exn = load ptr, ptr null, align 8
+  %2 = call ptr @llvm.objc.retain(ptr %exn) [ "funclet"(token %1) ]
+  call void @may_throw(ptr %exn)
+  call void @llvm.objc.release(ptr %exn) [ "funclet"(token %1) ]
+  catchret from %1 to label %eh.cont
+}
+
+declare void @may_throw(ptr)
+declare i32 @__CxxFrameHandler3(...)
+
+declare ptr @llvm.objc.retain(ptr) #0
+declare void @llvm.objc.release(ptr) #0
+
+attributes #0 = { nounwind }