Commit 9e66c4ec authored by Alina Sbirlea's avatar Alina Sbirlea
Browse files

[Utils] Use WeakTrackingVH in vector used as scratch storage. 

The utility method RecursivelyDeleteTriviallyDeadInstructions receives
as input a vector of Instructions, where all inputs are valid
instructions. This same vector is used as a scratch storage (per the
header comment) to recursively delete instructions. If an instruction is
added as an operand of multiple other instructions, it may be added twice,
then deleted once, then the second reference in the vector is invalid.
Switch to using a Vector<WeakTrackingVH>.
This change facilitates a clean-up in LoopStrengthReduction.
parent 2af74e27

llvm/include/llvm/Transforms/Utils/Local.h

+1 −1
Original line number Diff line number Diff line
@@ -153,7 +153,7 @@ bool RecursivelyDeleteTriviallyDeadInstructions( 
/// `DeadInsts` will be used as scratch storage for this routine and will be

/// empty afterward.

void RecursivelyDeleteTriviallyDeadInstructions(

    SmallVectorImpl<Instruction *> &DeadInsts,

    SmallVectorImpl<WeakTrackingVH> &DeadInsts,

    const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr);



/// If the specified value is an effectively dead PHI node, due to being a

llvm/lib/Transforms/IPO/Attributor.cpp

+1 −1
Original line number Diff line number Diff line
@@ -6041,7 +6041,7 @@ ChangeStatus Attributor::run(Module &M) { 
                      << ToBeDeletedInsts.size() << " instructions and "

                      << ToBeChangedUses.size() << " uses\n");



    SmallVector<Instruction *, 32> DeadInsts;

    SmallVector<WeakTrackingVH, 32> DeadInsts;

    SmallVector<Instruction *, 32> TerminatorsToFold;



    for (auto &It : ToBeChangedUses) {

llvm/lib/Transforms/Scalar/InstSimplifyPass.cpp

+1 −1
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ static bool runImpl(Function &F, const SimplifyQuery &SQ, 
      if (!SQ.DT->isReachableFromEntry(&BB))

        continue;



      SmallVector<Instruction *, 8> DeadInstsInBB;

      SmallVector<WeakTrackingVH, 8> DeadInstsInBB;

      for (Instruction &I : BB) {

        // The first time through the loop, ToSimplify is empty and we try to

        // simplify all instructions. On later iterations, ToSimplify is not

llvm/lib/Transforms/Scalar/LoopInstSimplify.cpp

+1 −1
Original line number Diff line number Diff line
@@ -68,7 +68,7 @@ static bool simplifyLoopInst(Loop &L, DominatorTree &DT, LoopInfo &LI, 


  // While simplifying we may discover dead code or cause code to become dead.

  // Keep track of all such instructions and we will delete them at the end.

  SmallVector<Instruction *, 8> DeadInsts;

  SmallVector<WeakTrackingVH, 8> DeadInsts;



  // First we want to create an RPO traversal of the loop body. By processing in

  // RPO we can ensure that definitions are processed prior to uses (for non PHI

llvm/lib/Transforms/Utils/Local.cpp

+12 −9
Original line number Diff line number Diff line
@@ -443,7 +443,7 @@ bool llvm::RecursivelyDeleteTriviallyDeadInstructions( 
  if (!I || !isInstructionTriviallyDead(I, TLI))

    return false;



  SmallVector<Instruction*, 16> DeadInsts;

  SmallVector<WeakTrackingVH, 16> DeadInsts;

  DeadInsts.push_back(I);

  RecursivelyDeleteTriviallyDeadInstructions(DeadInsts, TLI, MSSAU);
@@ -451,21 +451,24 @@ bool llvm::RecursivelyDeleteTriviallyDeadInstructions( 
}



void llvm::RecursivelyDeleteTriviallyDeadInstructions(

    SmallVectorImpl<Instruction *> &DeadInsts, const TargetLibraryInfo *TLI,

    SmallVectorImpl<WeakTrackingVH> &DeadInsts, const TargetLibraryInfo *TLI,

    MemorySSAUpdater *MSSAU) {

  // Process the dead instruction list until empty.

  while (!DeadInsts.empty()) {

    Instruction &I = *DeadInsts.pop_back_val();

    assert(I.use_empty() && "Instructions with uses are not dead.");

    assert(isInstructionTriviallyDead(&I, TLI) &&

    Value *V = DeadInsts.pop_back_val();

    Instruction *I = cast_or_null<Instruction>(V);

    if (!I)

      continue;

    assert(isInstructionTriviallyDead(I, TLI) &&

           "Live instruction found in dead worklist!");

    assert(I->use_empty() && "Instructions with uses are not dead.");



    // Don't lose the debug info while deleting the instructions.

    salvageDebugInfo(I);

    salvageDebugInfo(*I);



    // Null out all of the instruction's operands to see if any operand becomes

    // dead as we go.

    for (Use &OpU : I.operands()) {

    for (Use &OpU : I->operands()) {

      Value *OpV = OpU.get();

      OpU.set(nullptr);
@@ -480,9 +483,9 @@ void llvm::RecursivelyDeleteTriviallyDeadInstructions( 
          DeadInsts.push_back(OpI);

    }

    if (MSSAU)

      MSSAU->removeMemoryAccess(&I);

      MSSAU->removeMemoryAccess(I);



    I.eraseFromParent();

    I->eraseFromParent();

  }

}