[Attributor] Use the delete API for liveness

[uenoku]

llvm/lib/Transforms/IPO/Attributor.cpp

3573 ↗

(On Diff #217505)

This may be off topic, but I think this is invalid, isn't it?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

3573 ↗

(On Diff #217505)

Probably true. I'll get rid of it in a separate commit. (We do not preserve anything for now but are placed such that it doesn't matter (for now)).

[uenoku]

LGTM

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

struct AAIsDeadImpl : public AAIsDead {
   ChangeStatus manifest(Attributor &A) override {
     assert(getState().isValidState() &&
            "Attempted to manifest an invalid state!");
 
     ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
     Function &F = *getAssociatedFunction();
 
     if (AssumedLiveBlocks.empty()) {
-      F.replaceAllUsesWith(UndefValue::get(F.getType()));
+      A.deleteAfterManifest(F);
       return ChangeStatus::CHANGED;
     }
 
     // Flag to determine if we can change an invoke to a call assuming the
     // callee is nounwind. This is not possible if the personality of the
     // function allows to catch asynchronous exceptions.
     bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);
 
for (const Instruction *NRC : NoReturnCalls) {
               CallInst *CI = createCallMatchingInvoke(II);
               CI->insertBefore(II);
               CI->takeName(II);
               II->replaceAllUsesWith(CI);
               SplitPos = CI->getNextNode();
             }
           }
         }
+
+        if (SplitPos == &NormalDestBB->front())
+          AssumedLiveBlocks.insert(NormalDestBB);
       }
 
       BB = SplitPos->getParent();
       SplitBlock(BB, SplitPos);
       changeToUnreachable(BB->getTerminator(), /* UseLLVMTrap */ false);
       HasChanged = ChangeStatus::CHANGED;
     }
 
+    for (BasicBlock &BB : F)
+      if (!AssumedLiveBlocks.count(&BB))
+        A.deleteAfterManifest(BB);
+
     return HasChanged;
   }
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A) override;
 
   /// See AAIsDead::isAssumedDead(BasicBlock *).
   bool isAssumedDead(const BasicBlock *BB) const override {
assert(
       "Expected the final number of abstract attributes to remain unchanged!");
 
   // Delete stuff at the end to avoid invalid references and a nice order.
   LLVM_DEBUG(dbgs() << "\n[Attributor] Delete " << ToBeDeletedFunctions.size()
                     << " functions and " << ToBeDeletedBlocks.size()
                     << " blocks and " << ToBeDeletedInsts.size()
                     << " instructions\n");
   for (Instruction *I : ToBeDeletedInsts) {
-    if (I->hasNUsesOrMore(1))
+    if (!I->use_empty())
       I->replaceAllUsesWith(UndefValue::get(I->getType()));
     I->eraseFromParent();
   }
-  for (BasicBlock *BB : ToBeDeletedBlocks) {
-    // TODO: Check if we need to replace users (PHIs, indirect branches?)
-    BB->eraseFromParent();
+
+  if (unsigned NumDeadBlocks = ToBeDeletedBlocks.size()) {
+    SmallVector<BasicBlock *, 8> ToBeDeletedBBs;
+    ToBeDeletedBBs.reserve(NumDeadBlocks);
+    ToBeDeletedBBs.append(ToBeDeletedBlocks.begin(), ToBeDeletedBlocks.end());
+    DeleteDeadBlocks(ToBeDeletedBBs);
   }
+
   for (Function *Fn : ToBeDeletedFunctions) {
     Fn->replaceAllUsesWith(UndefValue::get(Fn->getType()));
     Fn->eraseFromParent();
   }
 
   if (VerifyMaxFixpointIterations &&
       IterationCounter != MaxFixpointIterations) {
     errs() << "\n[Attributor] Fixpoint iteration done after: "

llvm/trunk/test/Transforms/FunctionAttrs/arg_returned.ll

 
 attributes #0 = { noinline nounwind uwtable }
 
 ; BOTH-NOT: attributes #
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline nosync nounwind readnone uwtable }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline noreturn nosync nounwind readonly uwtable }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { noinline nounwind uwtable }
-; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline nosync nounwind readnone uwtable willreturn }
-; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline nosync nounwind uwtable willreturn }
+; BOTH-DAG: attributes #{{[0-9]*}} = { noreturn }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree nosync willreturn }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree nosync }
 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noreturn nosync }
-; BOTH-DAG: attributes #{{[0-9]*}} = { noreturn }
 ; BOTH-NOT: attributes #

llvm/trunk/test/Transforms/FunctionAttrs/liveness.ll

 
 declare i32 @foo_noreturn() noreturn
 
 declare i32 @bar() nosync readnone
 
 ; This internal function has no live call sites, so all its BBs are considered dead,
 ; and nothing should be deduced for it.
 
-; CHECK: define internal i32 @dead_internal_func(i32 %0)
+; CHECK-NOT: define internal i32 @dead_internal_func(i32 %0)
 define internal i32 @dead_internal_func(i32 %0) {
   %2 = icmp slt i32 %0, 1
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %5, %1
   %4 = phi i32 [ 1, %1 ], [ %8, %5 ]
   ret i32 %4
 

 ; CHECK-NEXT: define i32 @first_block_no_return(i32 %a, i32* nocapture nonnull %ptr1, i32* nocapture %ptr2)
 define i32 @first_block_no_return(i32 %a, i32* nonnull %ptr1, i32* %ptr2) #0 {
 entry:
   call i32 @internal_load(i32* %ptr1)
   ; CHECK: call i32 @internal_load(i32* nocapture nonnull %ptr1)
   call void @no_return_call()
   ; CHECK: call void @no_return_call()
   ; CHECK-NEXT: unreachable
+  ; CHECK-NEXT: }
   call i32 @dead_internal_func(i32 10)
-  ; CHECK call i32 undef(i32 10)
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %cond.true, label %cond.false
 
 cond.true:                                        ; preds = %entry
   call i32 @internal_load(i32* %ptr2)
-  ; CHECK: call i32 @internal_load(i32* %ptr2)
   %load = call i32 @volatile_load(i32* %ptr1)
   call void @normal_call()
   %call = call i32 @foo()
   br label %cond.end
 
 cond.false:                                       ; preds = %entry
   call void @normal_call()
   %call1 = call i32 @bar()
cond.true:                                        ; preds = %entry
   br label %cond.end
 
 cond.false:                                       ; preds = %entry
   call void @normal_call()
   %call1 = call i32 @bar()
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.false, %cond.true
+; CHECK:      cond.end:
+; CHECK-NEXT:   ret i32 %call1
   %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
   ret i32 %cond
 }
 
 ; TEST 3: both cond.true and cond.false are dead, therfore cond.end is dead as well.
 
 define i32 @all_dead(i32 %a) #0 {
 entry:
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %cond.true, label %cond.false
 
 cond.true:                                        ; preds = %entry
   call void @no_return_call()
   ; CHECK: call void @no_return_call()
   ; CHECK-NEXT: unreachable
   call i32 @dead_internal_func(i32 10)
-  ; CHECK call i32 undef(i32 10)
+  ; CHECK-NOT: call
   %call = call i32 @foo()
   br label %cond.end
 
 cond.false:                                       ; preds = %entry
   call void @no_return_call()
   ; CHECK: call void @no_return_call()
   ; CHECK-NEXT: unreachable
   call i32 @dead_internal_func(i32 10)
-  ; CHECK call i32 undef(i32 10)
+  ; CHECK-NEXT: }
   %call1 = call i32 @bar()
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.false, %cond.true
   %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
   ret i32 %cond
 }
 

 cond.true:                                        ; preds = %entry
   call void @normal_call()
   %call = invoke i32 @foo_noreturn_nounwind() to label %continue
             unwind label %cleanup
   ; CHECK:      call void @normal_call()
   ; CHECK-NEXT: call i32 @foo_noreturn_nounwind()
   ; CHECK-NEXT: unreachable
 
-  ; We keep the invoke around as other attributes might have references to it.
-  ; CHECK:       cond.true.split:                                  ; No predecessors!
-  ; CHECK-NEXT:      invoke i32 @foo_noreturn_nounwind()
+  ; CHECK-NOT:      @foo_noreturn_nounwind()
 
 cond.false:                                       ; preds = %entry
   call void @normal_call()
   %call1 = call i32 @bar()
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.false, %continue
   %cond = phi i32 [ %call, %continue ], [ %call1, %cond.false ]