[DIE] Remove DeadInstEliminationPass

[aeubanks]

Summary

This pass is like DeadCodeEliminationPass, but only does one pass
through a function instead of iterating on users of eliminated
instructions.

DeadCodeEliminationPass should be used in all cases.

[aeubanks]

Add back comment

[asbirlea]

This looks like a good cleanup. It's possible for DIE to be useful as a "light-weight" DCE, but that could also be achieved by adding a flag to DCE.
Unless there are folks that come forward that they need this for other reasons, I think it's good to clean the codebase.

[aeubanks]

http://lists.llvm.org/pipermail/llvm-dev/2020-September/145187.html for more agreement of this patch.

llvm/include/llvm/InitializePasses.h

 void initializeCorrelatedValuePropagationPass(PassRegistry&);
 void initializeCostModelAnalysisPass(PassRegistry&);
 void initializeCrossDSOCFIPass(PassRegistry&);
 void initializeDAEPass(PassRegistry&);
 void initializeDAHPass(PassRegistry&);
 void initializeDCELegacyPassPass(PassRegistry&);
 void initializeDSELegacyPassPass(PassRegistry&);
 void initializeDataFlowSanitizerLegacyPassPass(PassRegistry &);
-void initializeDeadInstEliminationPass(PassRegistry&);
 void initializeDeadMachineInstructionElimPass(PassRegistry&);
 void initializeDebugifyMachineModulePass(PassRegistry &);
 void initializeDelinearizationPass(PassRegistry&);
 void initializeDemandedBitsWrapperPassPass(PassRegistry&);
 void initializeDependenceAnalysisPass(PassRegistry&);
 void initializeDependenceAnalysisWrapperPassPass(PassRegistry&);
 void initializeDetectDeadLanesPass(PassRegistry&);
 void initializeDivRemPairsLegacyPassPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createStructurizeCFGPass();
       (void) llvm::createLibCallsShrinkWrapPass();
       (void) llvm::createCalledValuePropagationPass();
       (void) llvm::createConstantMergePass();
       (void) llvm::createControlHeightReductionLegacyPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();
       (void) llvm::createDeadCodeEliminationPass();
-      (void) llvm::createDeadInstEliminationPass();
       (void) llvm::createDeadStoreEliminationPass();
       (void) llvm::createDependenceAnalysisWrapperPass();
       (void) llvm::createDomOnlyPrinterPass();
       (void) llvm::createDomPrinterPass();
       (void) llvm::createDomOnlyViewerPass();
       (void) llvm::createDomViewerPass();
       (void) llvm::createGCOVProfilerPass();
       (void) llvm::createPGOInstrumentationGenLegacyPass();

llvm/include/llvm/Transforms/Scalar.h

 //===----------------------------------------------------------------------===//
 //
 // SCCP - Sparse conditional constant propagation.
 //
 FunctionPass *createSCCPPass();
 
 //===----------------------------------------------------------------------===//
 //
-// DeadInstElimination - This pass quickly removes trivially dead instructions
-// without modifying the CFG of the function.  It is a FunctionPass.
-//
-Pass *createDeadInstEliminationPass();
-
-//===----------------------------------------------------------------------===//
-//
 // RedundantDbgInstElimination - This pass removes redundant dbg intrinsics
 // without modifying the CFG of the function.  It is a FunctionPass.
 //
 Pass *createRedundantDbgInstEliminationPass();
 
 //===----------------------------------------------------------------------===//
 //
 // DeadCodeElimination - This pass is more powerful than DeadInstElimination,

llvm/lib/Transforms/Scalar/DCE.cpp

 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "dce"
 
-STATISTIC(DIEEliminated, "Number of insts removed by DIE pass");
 STATISTIC(DCEEliminated, "Number of insts removed");
 DEBUG_COUNTER(DCECounter, "dce-transform",
               "Controls which instructions are eliminated");
 
-namespace {
-  //===--------------------------------------------------------------------===//
-  // DeadInstElimination pass implementation
-  //
-struct DeadInstElimination : public FunctionPass {
-  static char ID; // Pass identification, replacement for typeid
-  DeadInstElimination() : FunctionPass(ID) {
-    initializeDeadInstEliminationPass(*PassRegistry::getPassRegistry());
-  }
-  bool runOnFunction(Function &F) override {
-    if (skipFunction(F))
-      return false;
-    auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
-    TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(F) : nullptr;
-
-    bool Changed = false;
-    for (auto &BB : F) {
-      for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) {
-        Instruction *Inst = &*DI++;
-        if (isInstructionTriviallyDead(Inst, TLI)) {
-          if (!DebugCounter::shouldExecute(DCECounter))
-            continue;
-          salvageDebugInfo(*Inst);
-          Inst->eraseFromParent();
-          Changed = true;
-          ++DIEEliminated;
-        }
-      }
-    }
-    return Changed;
-  }
-
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.setPreservesCFG();
-    }
-};
-}
-
-char DeadInstElimination::ID = 0;
-INITIALIZE_PASS(DeadInstElimination, "die",
-                "Dead Instruction Elimination", false, false)
-
-Pass *llvm::createDeadInstEliminationPass() {
-  return new DeadInstElimination();
-}
-
 //===--------------------------------------------------------------------===//
 // RedundantDbgInstElimination pass implementation
 //
 
 namespace {
 struct RedundantDbgInstElimination : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
   RedundantDbgInstElimination() : FunctionPass(ID) {

llvm/lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeADCELegacyPassPass(Registry);
   initializeBDCELegacyPassPass(Registry);
   initializeAlignmentFromAssumptionsPass(Registry);
   initializeCallSiteSplittingLegacyPassPass(Registry);
   initializeConstantHoistingLegacyPassPass(Registry);
   initializeConstraintEliminationPass(Registry);
   initializeCorrelatedValuePropagationPass(Registry);
   initializeDCELegacyPassPass(Registry);
-  initializeDeadInstEliminationPass(Registry);
   initializeDivRemPairsLegacyPassPass(Registry);
   initializeScalarizerLegacyPassPass(Registry);
   initializeDSELegacyPassPass(Registry);
   initializeGuardWideningLegacyPassPass(Registry);
   initializeLoopGuardWideningLegacyPassPass(Registry);
   initializeGVNLegacyPassPass(Registry);
   initializeNewGVNLegacyPassPass(Registry);
   initializeEarlyCSELegacyPassPass(Registry);

llvm/test/Feature/optnone-opt.ll

 ; RUN: opt     -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=O0
 ; RUN: opt -O1 -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=O1
 ; RUN: opt -O2 -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=O1 --check-prefix=O2O3
 ; RUN: opt -O3 -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=O1 --check-prefix=O2O3
-; RUN: opt -dce -die -gvn-hoist -loweratomic -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=MORE
+; RUN: opt -dce -gvn-hoist -loweratomic -S -debug -enable-new-pm=0 %s 2>&1 | FileCheck %s --check-prefix=MORE
 ; RUN: opt -indvars -licm -loop-deletion -loop-extract -loop-idiom -loop-instsimplify -loop-reduce -loop-reroll -loop-rotate -loop-unroll -loop-unswitch -enable-new-pm=0 -S -debug %s 2>&1 | FileCheck %s --check-prefix=LOOP
 ; RUN: opt -enable-npm-optnone     -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-O0
 ; RUN: opt -enable-npm-optnone -O1 -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-O1
 ; RUN: opt -enable-npm-optnone -O2 -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-O1 --check-prefix=NPM-O2O3
 ; RUN: opt -enable-npm-optnone -O3 -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-O1 --check-prefix=NPM-O2O3
 ; RUN: opt -enable-npm-optnone -dce -gvn-hoist -loweratomic -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-MORE
 ; RUN: opt -enable-npm-optnone -indvars -licm -loop-deletion -loop-idiom -loop-instsimplify -loop-reduce -loop-unroll -simple-loop-unswitch -S -debug-pass-manager -enable-new-pm %s 2>&1 | FileCheck %s --check-prefix=NPM-LOOP
 

 ; Additional IR passes run at -O2 and higher.
 ; O2O3-DAG: Skipping pass 'Global Value Numbering'
 ; O2O3-DAG: Skipping pass 'SLP Vectorizer'
 ; NPM-O2O3-DAG: Skipping pass: GVN
 ; NPM-O2O3-DAG: Skipping pass: SLPVectorizerPass
 
 ; Additional IR passes that opt doesn't turn on by default.
 ; MORE-DAG: Skipping pass 'Dead Code Elimination'
-; MORE-DAG: Skipping pass 'Dead Instruction Elimination'
 ; NPM-MORE-DAG: Skipping pass: DCEPass
 ; NPM-MORE-DAG: Skipping pass: GVNHoistPass
 
 ; Loop IR passes that opt doesn't turn on by default.
 ; LOOP-DAG: Skipping pass 'Delete dead loops'
 ; LOOP-DAG: Skipping pass 'Induction Variable Simplification'
 ; LOOP-DAG: Skipping pass 'Loop Invariant Code Motion'
 ; LOOP-DAG: Skipping pass 'Loop Strength Reduction'

llvm/test/Transforms/DeadArgElim/2008-06-23-DeadAfterLive.ll

-; RUN: opt < %s -deadargelim -die -S > %t
+; RUN: opt < %s -deadargelim -dce -S > %t
 ; RUN: cat %t | grep 123
 
 ; This test tries to catch wrongful removal of return values for a specific case
 ; that was breaking llvm-gcc builds.
 
 ; This function has a live return value, it is used by @alive.
 define internal i32 @test5() {
   ret i32 123 

llvm/test/Transforms/DeadArgElim/deadretval2.ll

-; RUN: opt < %s -deadargelim -die -S > %t
+; RUN: opt < %s -deadargelim -dce -S > %t
 ; RUN: cat %t | not grep DEAD
 ; RUN: cat %t | grep LIVE | count 4
 
 @P = external global i32                ; <i32*> [#uses=1]
 
 ; Dead arg only used by dead retval
 define internal i32 @test(i32 %DEADARG) {
         ret i32 %DEADARG

llvm/test/Transforms/GVN/PRE/rle-addrspace-cast.ll

-; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -die | FileCheck %s
+; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -dce | FileCheck %s
 
 define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) {
   store i32 %V, i32* %P
 
   %P2 = addrspacecast i32* %P to i8 addrspace(1)*
   %P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2
 
   %A = load i8, i8 addrspace(1)* %P3
   ret i8 %A
 ; CHECK-LABEL: @coerce_offset0_addrspacecast(
 ; CHECK-NOT: load
 ; CHECK: ret i8
 }

llvm/test/Transforms/GVN/PRE/rle.ll

-; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -die | FileCheck %s
-; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32"      -basic-aa -gvn -S -die | FileCheck %s
+; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -dce | FileCheck %s
+; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32"      -basic-aa -gvn -S -dce | FileCheck %s
 
 ;; Trivial RLE test.
 define i32 @test0(i32 %V, i32* %P) {
   store i32 %V, i32* %P
 
   %A = load i32, i32* %P
   ret i32 %A
 ; CHECK-LABEL: @test0(
entry:
   %add = add nsw i32 %conv, %conv2
 
   %tmp2 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 3), align 2
   %conv3 = zext i8 %tmp2 to i32
   %add2 = add nsw i32 %add, %conv3
 
   %tmp3 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 4), align 1
   %conv4 = zext i8 %tmp3 to i32
-  %add3 = add nsw i32 %add2, %conv3
+  %add3 = add nsw i32 %add2, %conv4
 
   ret i32 %add3
 ; CHECK-LABEL: @test_widening2(
 ; CHECK-NOT: load
 ; CHECK: load i8, i8*
 ; CHECK: load i8, i8*
 ; CHECK: load i8, i8*
 ; CHECK: load i8, i8*

llvm/test/Transforms/InstCombine/deadcode.ll

 ; RUN: opt < %s -instcombine -S | grep "ret i32 %A"
-; RUN: opt < %s -die -S | not grep call.*llvm
+; RUN: opt < %s -dce -S | not grep call.*llvm
 
 define i32 @test(i32 %A) {
   %X = or i1 false, false   
   br i1 %X, label %T, label %C
 
 T:    ; preds = %0
   %B = add i32 %A, 1  
   br label %C

llvm/test/Transforms/InstSimplify/ConstProp/2002-09-03-SetCC-Bools.ll

 ; SetCC on boolean values was not implemented!
 
-; RUN: opt < %s -instsimplify -die -S | \
+; RUN: opt < %s -instsimplify -dce -S | \
 ; RUN:   not grep set
 
 define i1 @test1() {
         %A = icmp ule i1 true, false            ; <i1> [#uses=1]
         %B = icmp uge i1 true, false            ; <i1> [#uses=1]
         %C = icmp ult i1 false, true            ; <i1> [#uses=1]
         %D = icmp ugt i1 true, false            ; <i1> [#uses=1]
         %E = icmp eq i1 false, false            ; <i1> [#uses=1]

llvm/test/Transforms/InstSimplify/ConstProp/basictest.ll

-; RUN: opt < %s -instsimplify -die -S | FileCheck %s
+; RUN: opt < %s -instsimplify -dce -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.7.2"
 
 ; This is a basic sanity check for constant propagation.  The add instruction
 ; should be eliminated.
 define i32 @test1(i1 %B) {
         br i1 %B, label %BB1, label %BB2

llvm/test/Transforms/InstSimplify/ConstProp/logicaltest.ll

 ; Ensure constant propagation of logical instructions is working correctly.
 
-; RUN: opt < %s -instsimplify -die -S | FileCheck %s
+; RUN: opt < %s -instsimplify -dce -S | FileCheck %s
 ; CHECK-NOT:     {{and|or|xor}}
 
 define i32 @test1() {
         %R = and i32 4, 1234            ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i1 @test1.upgrd.1() {

llvm/test/Transforms/InstSimplify/ConstProp/phi.ll

 ; This is a basic sanity check for constant propagation.  The add instruction
 ; should be eliminated.
 
-; RUN: opt < %s -instsimplify -die -S | not grep phi
+; RUN: opt < %s -instsimplify -dce -S | not grep phi
 
 define i32 @test(i1 %B) {
 BB0:
         br i1 %B, label %BB1, label %BB3
 
 BB1:            ; preds = %BB0
         br label %BB3
 
 BB3:            ; preds = %BB1, %BB0
         %Ret = phi i32 [ 1, %BB0 ], [ 1, %BB1 ]         ; <i32> [#uses=1]
         ret i32 %Ret
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/remtest.ll

 ; Ensure constant propagation of remainder instructions is working correctly.
 
-; RUN: opt < %s -instsimplify -die -S | not grep rem
+; RUN: opt < %s -instsimplify -dce -S | not grep rem
 
 define i32 @test1() {
         %R = srem i32 4, 3              ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i32 @test2() {
         %R = srem i32 123, -23          ; <i32> [#uses=1]

llvm/test/Transforms/NewGVN/rle.ll

-; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -newgvn -S -die | FileCheck %s
-; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32"      -basic-aa -newgvn -S -die | FileCheck %s
+; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -newgvn -S -dce | FileCheck %s
+; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32"      -basic-aa -newgvn -S -dce | FileCheck %s
 ; memset -> i16 forwarding.
 define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp {
 entry:
   %conv = bitcast i16* %A to i8*
   tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false)
   %arrayidx = getelementptr inbounds i16, i16* %A, i64 42
   %tmp2 = load i16, i16* %arrayidx
   ret i16 %tmp2

llvm/test/Transforms/Reassociate/inverses.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -reassociate -die -S | FileCheck %s
+; RUN: opt < %s -reassociate -dce -S | FileCheck %s
 
 ; (A&B)&~A == 0
 define i32 @test1(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret i32 0
 ;
   %t2 = and i32 %b, %a
   %t4 = xor i32 %a, -1

llvm/test/Transforms/Reassociate/otherops.ll

 ; Reassociation should apply to Add, Mul, And, Or, & Xor
 ;
-; RUN: opt < %s -reassociate -instcombine -die -S | FileCheck %s
+; RUN: opt < %s -reassociate -instcombine -dce -S | FileCheck %s
 
 define i32 @test_mul(i32 %arg) {
 ; CHECK-LABEL: test_mul
 ; CHECK-NEXT: %tmp2 = mul i32 %arg, 144
 ; CHECK-NEXT: ret i32 %tmp2
 
   %tmp1 = mul i32 12, %arg
   %tmp2 = mul i32 %tmp1, 12

llvm/test/Transforms/Reassociate/vaarg_movable.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -reassociate -die < %s | FileCheck %s
+; RUN: opt -S -reassociate -dce < %s | FileCheck %s
 
 ; The two va_arg instructions depend on the memory/context, are therfore not
 ; identical and the sub should not be optimized to 0 by reassociate.
 ;
 ; ...
 ; ...
 define i32 @func(i32 %dummy, ...) {
 ;