[ObjCARC] Add funclet token to ARC marker

[smeenai]

Summary

The inline assembly generated for the ARC autorelease elision marker
must have a funclet token if it's emitted inside a funclet, otherwise
the inline assembly (and all subsequent code in the funclet) will be
marked unreachable by WinEHPrepare.

Note that this only applies for the non-O0 case, since at O0, clang
emits the autorelease elision marker itself rather than deferring to the
backend. The fix for clang is handled in a separate change.

[compnerd]

LGTM, I'd give @majnemer a day or so before committing.

[majnemer]

LGTM

llvm/trunk/lib/Transforms/ObjCARC/ObjCARCContract.cpp

 // TODO: ObjCARCContract could insert PHI nodes when uses aren't
 // dominated by single calls.
 
 #include "ARCRuntimeEntryPoints.h"
 #include "DependencyAnalysis.h"
 #include "ObjCARC.h"
 #include "ProvenanceAnalysis.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;
class ObjCARCContract : public FunctionPass {
     const MDString *RVInstMarker;
 
     /// The set of inserted objc_storeStrong calls. If at the end of walking the
     /// function we have found no alloca instructions, these calls can be marked
     /// "tail".
     SmallPtrSet<CallInst *, 8> StoreStrongCalls;
 
     /// Returns true if we eliminated Inst.
-    bool tryToPeepholeInstruction(Function &F, Instruction *Inst,
-                                  inst_iterator &Iter,
-                                  SmallPtrSetImpl<Instruction *> &DepInsts,
-                                  SmallPtrSetImpl<const BasicBlock *> &Visited,
-                                  bool &TailOkForStoreStrong);
+    bool
+    tryToPeepholeInstruction(Function &F, Instruction *Inst,
+                             bool &TailOkForStoreStrong,
+                             DenseMap<BasicBlock *, ColorVector> &BlockColors);
 
     bool optimizeRetainCall(Function &F, Instruction *Retain);
 
     bool
     contractAutorelease(Function &F, Instruction *Autorelease,
                         ARCInstKind Class,
                         SmallPtrSetImpl<Instruction *> &DependingInstructions,
                         SmallPtrSetImpl<const BasicBlock *> &Visited);
void ObjCARCContract::tryToContractReleaseIntoStoreStrong(Instruction *Release,
   if (Load->use_empty())
     Load->eraseFromParent();
 }
 
 bool ObjCARCContract::tryToPeepholeInstruction(
   Function &F, Instruction *Inst, inst_iterator &Iter,
   SmallPtrSetImpl<Instruction *> &DependingInsts,
   SmallPtrSetImpl<const BasicBlock *> &Visited,
-  bool &TailOkForStoreStrongs) {
+  bool &TailOkForStoreStrongs,
+  DenseMap<BasicBlock *, ColorVector> &BlockColors) {
     // Only these library routines return their argument. In particular,
     // objc_retainBlock does not necessarily return its argument.
   ARCInstKind Class = GetBasicARCInstKind(Inst);
     switch (Class) {
     case ARCInstKind::FusedRetainAutorelease:
     case ARCInstKind::FusedRetainAutoreleaseRV:
       return false;
     case ARCInstKind::Autorelease:
case ARCInstKind::ClaimRV: {
         DEBUG(dbgs() << "Adding inline asm marker for the return value "
                         "optimization.\n");
         Changed = true;
         InlineAsm *IA = InlineAsm::get(
             FunctionType::get(Type::getVoidTy(Inst->getContext()),
                               /*isVarArg=*/false),
             RVInstMarker->getString(),
             /*Constraints=*/"", /*hasSideEffects=*/true);
-        CallInst::Create(IA, "", Inst);
+
+        SmallVector<OperandBundleDef, 1> OpBundles;
+        if (!BlockColors.empty()) {
+          const ColorVector &CV = BlockColors.find(Inst->getParent())->second;
+          assert(CV.size() == 1 && "non-unique color for block!");
+          Instruction *EHPad = CV.front()->getFirstNonPHI();
+          if (EHPad->isEHPad())
+            OpBundles.emplace_back("funclet", EHPad);
+        }
+
+        CallInst::Create(IA, None, OpBundles, "", Inst);
       }
     decline_rv_optimization:
       return false;
     }
     case ARCInstKind::InitWeak: {
       // objc_initWeak(p, null) => *p = null
       CallInst *CI = cast<CallInst>(Inst);
       if (IsNullOrUndef(CI->getArgOperand(1))) {
if (!Run)
     return false;
 
   Changed = false;
   AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 
   PA.setAA(&getAnalysis<AAResultsWrapperPass>().getAAResults());
 
+  DenseMap<BasicBlock *, ColorVector> BlockColors;
+  if (F.hasPersonalityFn() &&
+      isFuncletEHPersonality(classifyEHPersonality(F.getPersonalityFn())))
+    BlockColors = colorEHFunclets(F);
+
   DEBUG(llvm::dbgs() << "**** ObjCARC Contract ****\n");
 
   // Track whether it's ok to mark objc_storeStrong calls with the "tail"
   // keyword. Be conservative if the function has variadic arguments.
   // It seems that functions which "return twice" are also unsafe for the
   // "tail" argument, because they are setjmp, which could need to
   // return to an earlier stack state.
   bool TailOkForStoreStrongs =
       !F.isVarArg() && !F.callsFunctionThatReturnsTwice();
 
   // For ObjC library calls which return their argument, replace uses of the
   // argument with uses of the call return value, if it dominates the use. This
   // reduces register pressure.
   SmallPtrSet<Instruction *, 4> DependingInstructions;
   SmallPtrSet<const BasicBlock *, 4> Visited;
   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E;) {
     Instruction *Inst = &*I++;
 
     DEBUG(dbgs() << "Visiting: " << *Inst << "\n");
 
     // First try to peephole Inst. If there is nothing further we can do in
     // terms of undoing objc-arc-expand, process the next inst.
     if (tryToPeepholeInstruction(F, Inst, I, DependingInstructions, Visited,
-                                 TailOkForStoreStrongs))
+                                 TailOkForStoreStrongs, BlockColors))
       continue;
 
     // Otherwise, try to undo objc-arc-expand.
 
     // Don't use GetArgRCIdentityRoot because we don't want to look through bitcasts
     // and such; to do the replacement, the argument must have type i8*.
 
     // Function for replacing uses of Arg dominated by Inst.

llvm/trunk/test/Transforms/ObjCARC/contract-marker-funclet.ll

+; RUN: opt -mtriple=i686-unknown-windows-msvc -objc-arc-contract -S -o - %s | FileCheck %s
+
+; Generated (and lightly modified and cleaned up) from the following source:
+; id f();
+; void g() {
+;   try {
+;     f();
+;   } catch (...) {
+;     f();
+;   }
+; }
+
+define void @"\01?g@@YAXXZ"() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  %call = invoke i8* @"\01?f@@YAPAUobjc_object@@XZ"()
+          to label %invoke.cont unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %entry
+  %0 = catchswitch within none [label %catch] unwind to caller
+
+catch:                                            ; preds = %catch.dispatch
+  %1 = catchpad within %0 [i8* null, i32 64, i8* null]
+  %call1 = call i8* @"\01?f@@YAPAUobjc_object@@XZ"() [ "funclet"(token %1) ]
+  %2 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call1) [ "funclet"(token %1) ]
+  call void @objc_release(i8* %2) [ "funclet"(token %1) ]
+  br label %catch.1
+
+catch.1:                                          ; preds = %catch
+  %call2 = call i8* @"\01?f@@YAPAUobjc_object@@XZ"() [ "funclet"(token %1) ]
+  %3 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call2) [ "funclet"(token %1) ]
+  call void @objc_release(i8* %3) [ "funclet"(token %1) ]
+  catchret from %1 to label %catchret.dest
+
+catchret.dest:                                    ; preds = %catch.1
+  ret void
+
+invoke.cont:                                      ; preds = %entry
+  %4 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call)
+  call void @objc_release(i8* %4)
+  ret void
+}
+
+declare i8* @"\01?f@@YAPAUobjc_object@@XZ"()
+
+declare i32 @__CxxFrameHandler3(...)
+
+declare dllimport i8* @objc_retainAutoreleasedReturnValue(i8*)
+
+declare dllimport void @objc_release(i8*)
+
+!clang.arc.retainAutoreleasedReturnValueMarker = !{!0}
+!0 = !{!"movl\09%ebp, %ebp\09\09// marker for objc_retainAutoreleaseReturnValue"}
+
+; CHECK-LABEL: catch
+; CHECK: call void asm sideeffect "movl{{.*}}%ebp, %ebp{{.*}}", ""() [ "funclet"(token %1) ]
+
+; CHECK-LABEL: catch.1
+; CHECK: call void asm sideeffect "movl{{.*}}%ebp, %ebp{{.*}}", ""() [ "funclet"(token %1) ]
+
+; CHECK-LABEL: invoke.cont
+; CHECK: call void asm sideeffect "movl{{.*}}%ebp, %ebp{{.*}}", ""(){{$}}