Commit 1c49553c authored by Bjorn Pettersson's avatar Bjorn Pettersson
Browse files

[BasicBlockUtils] Add utility to remove redundant dbg.value instrs 

Summary:
Add a RemoveRedundantDbgInstrs to BasicBlockUtils with the
goal to remove redundant dbg intrinsics from a basic block.

This can be useful after various transforms, as it might
be simpler to do a filtering of dbg intrinsics after the
transform than during the transform.
One primary use case would be to replace a too aggressive
removal done by MergeBlockIntoPredecessor, seen at loop
rotate (not done in this patch).

The elimination algorithm currently focuses on dbg.value
intrinsics and is doing two iterations over the BB.

First we iterate backward starting at the last instruction
in the BB. Whenever a consecutive sequence of dbg.value
instructions are found we keep the last dbg.value for
each variable found (variable fragments are identified
using the  {DILocalVariable, FragmentInfo, inlinedAt}
triple as given by the DebugVariable helper class).

Next we iterate forward starting at the first instruction
in the BB. Whenever we find a dbg.value describing a
DebugVariable (identified by {DILocalVariable, inlinedAt})
we save the {DIValue, DIExpression} that describes that
variables value. But if the variable already was mapped
to the same {DIValue, DIExpression} pair we instead drop
the second dbg.value.

To ease the process of making lit tests for this utility a
new pass is introduced called RedundantDbgInstElimination.
It can be executed by opt using -redundant-dbg-inst-elim.

Reviewers: aprantl, jmorse, vsk

Subscribers: hiraditya, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D71478
parent 4f17b178

llvm/include/llvm/InitializePasses.h

+1 −0
Original line number Diff line number Diff line
@@ -346,6 +346,7 @@ void initializeRABasicPass(PassRegistry&); 
void initializeRAGreedyPass(PassRegistry&);

void initializeReachingDefAnalysisPass(PassRegistry&);

void initializeReassociateLegacyPassPass(PassRegistry&);

void initializeRedundantDbgInstEliminationPass(PassRegistry&);

void initializeRegAllocFastPass(PassRegistry&);

void initializeRegBankSelectPass(PassRegistry&);

void initializeRegToMemPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

+1 −0
Original line number Diff line number Diff line
@@ -159,6 +159,7 @@ namespace { 
      (void) llvm::createPostDomOnlyViewerPass();

      (void) llvm::createPostDomViewerPass();

      (void) llvm::createReassociatePass();

      (void) llvm::createRedundantDbgInstEliminationPass();

      (void) llvm::createRegionInfoPass();

      (void) llvm::createRegionOnlyPrinterPass();

      (void) llvm::createRegionOnlyViewerPass();

llvm/include/llvm/Transforms/Scalar.h

+7 −0
Original line number Diff line number Diff line
@@ -53,6 +53,13 @@ FunctionPass *createSCCPPass(); 
//

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/include/llvm/Transforms/Utils/BasicBlockUtils.h

+4 −0
Original line number Diff line number Diff line
@@ -94,6 +94,10 @@ bool MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU = nullptr, 
                               MemoryDependenceResults *MemDep = nullptr,

                               bool PredecessorWithTwoSuccessors = false);



/// Try to remove redundant dbg.value instructions from given basic block.

/// Returns true if at least one instruction was removed.

bool RemoveRedundantDbgInstrs(BasicBlock *BB);



/// Replace all uses of an instruction (specified by BI) with a value, then

/// remove and delete the original instruction.

void ReplaceInstWithValue(BasicBlock::InstListType &BIL,

llvm/lib/Transforms/Scalar/DCE.cpp

+38 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include "llvm/Pass.h"

#include "llvm/Support/DebugCounter.h"

#include "llvm/Transforms/Scalar.h"

#include "llvm/Transforms/Utils/BasicBlockUtils.h"

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

using namespace llvm;
@@ -81,6 +82,43 @@ 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) {

    initializeRedundantDbgInstEliminationPass(*PassRegistry::getPassRegistry());

  }

  bool runOnFunction(Function &F) override {

    if (skipFunction(F))

      return false;

    bool Changed = false;

    for (auto &BB : F)

      Changed |= RemoveRedundantDbgInstrs(&BB);

    return Changed;

  }



  void getAnalysisUsage(AnalysisUsage &AU) const override {

    AU.setPreservesCFG();

  }

};

}



char RedundantDbgInstElimination::ID = 0;

INITIALIZE_PASS(RedundantDbgInstElimination, "redundant-dbg-inst-elim",

                "Redundant Dbg Instruction Elimination", false, false)



Pass *llvm::createRedundantDbgInstEliminationPass() {

  return new RedundantDbgInstElimination();

}



//===--------------------------------------------------------------------===//

// DeadCodeElimination pass implementation

//



static bool DCEInstruction(Instruction *I,

                           SmallSetVector<Instruction *, 16> &WorkList,

                           const TargetLibraryInfo *TLI) {