[ADCE] Refactor anticipating new functionality (NFC)

[david2050]

Summary

This is the first refactoring before adding new functionality.
Add a class wrapper for the functions and container for
state associated with the transformation.

No functional change

[david2050]

Undo a clang-format include reordering

[nadav]

LGTM.

[mehdi_amini]

lib/Transforms/Scalar/ADCE.cpp

43

Can you document these fields?

[david2050]

Comments for state variables

[mehdi_amini]

Thanks, LGTM for me as well.

[david2050]

I have a process question.
Will we commit the incremental diffs? in which case would one of you "accept" this on.
Or do I continue to update this diff with more changes until we are code complete?

[mehdi_amini]

Sorry I meant to mark it accepted, please commit.

lib/Transforms/Scalar/ADCE.cpp

 // This file implements the Aggressive Dead Code Elimination pass.  This pass
 // optimistically assumes that all instructions are dead until proven otherwise,
 // allowing it to eliminate dead computations that other DCE passes do not
 // catch, particularly involving loop computations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/ADCE.h"
+
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Pass.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Transforms/Scalar.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "adce"
 
 STATISTIC(NumRemoved, "Number of instructions removed");
 
-static void collectLiveScopes(const DILocalScope &LS,
-                              SmallPtrSetImpl<const Metadata *> &AliveScopes) {
+namespace {
+class AgggressiveDeadCodeElimination {
+  Function &F;
+  // Instructions known to be live
+  SmallPtrSet<Instruction *, 32> Alive;
+  // Instructions known to be live where we need to mark
+  // reaching definitions as live
+  SmallVector<Instruction *, 128> Worklist;
+  // Debug info scopes around a live instruction
+  SmallPtrSet<const Metadata *, 32> AliveScopes;
+  
+  void collectLiveScopes(const DILocalScope &LS);
+  void collectLiveScopes(const DILocation &DL);
+  bool isInstrumentsConstant(Instruction &I);
+public:
+  AgggressiveDeadCodeElimination(Function &F) : F(F) {}
+  bool aggressiveDCE();
+};
+}
+
+void AgggressiveDeadCodeElimination::collectLiveScopes(
+    const DILocalScope &LS) {
   if (!AliveScopes.insert(&LS).second)
     return;
 
   if (isa<DISubprogram>(LS))
     return;
 
   // Tail-recurse through the scope chain.
-  collectLiveScopes(cast<DILocalScope>(*LS.getScope()), AliveScopes);
+  collectLiveScopes(cast<DILocalScope>(*LS.getScope()));
 }
 
-static void collectLiveScopes(const DILocation &DL,
-                              SmallPtrSetImpl<const Metadata *> &AliveScopes) {
+void AgggressiveDeadCodeElimination::collectLiveScopes(const DILocation &DL) {
   // Even though DILocations are not scopes, shove them into AliveScopes so we
   // don't revisit them.
   if (!AliveScopes.insert(&DL).second)
     return;
 
   // Collect live scopes from the scope chain.
-  collectLiveScopes(*DL.getScope(), AliveScopes);
+  collectLiveScopes(*DL.getScope());
 
   // Tail-recurse through the inlined-at chain.
   if (const DILocation *IA = DL.getInlinedAt())
-    collectLiveScopes(*IA, AliveScopes);
+    collectLiveScopes(*IA);
 }
 
 // Check if this instruction is a runtime call for value profiling and
 // if it's instrumenting a constant.
-static bool isInstrumentsConstant(Instruction &I) {
+bool AgggressiveDeadCodeElimination::isInstrumentsConstant(Instruction &I) {
   if (CallInst *CI = dyn_cast<CallInst>(&I))
     if (Function *Callee = CI->getCalledFunction())
       if (Callee->getName().equals(getInstrProfValueProfFuncName()))
         if (isa<Constant>(CI->getArgOperand(0)))
           return true;
   return false;
 }
 
-static bool aggressiveDCE(Function& F) {
-  SmallPtrSet<Instruction*, 32> Alive;
-  SmallVector<Instruction*, 128> Worklist;
+bool AgggressiveDeadCodeElimination::aggressiveDCE() {
 
   // Collect the set of "root" instructions that are known live.
   for (Instruction &I : instructions(F)) {
     if (isa<TerminatorInst>(I) || I.isEHPad() || I.mayHaveSideEffects()) {
       // Skip any value profile instrumentation calls if they are
       // instrumenting constants.
       if (isInstrumentsConstant(I))
         continue;
       Alive.insert(&I);
       Worklist.push_back(&I);
     }
   }
 
   // Propagate liveness backwards to operands.  Keep track of live debug info
   // scopes.
-  SmallPtrSet<const Metadata *, 32> AliveScopes;
   while (!Worklist.empty()) {
     Instruction *Curr = Worklist.pop_back_val();
 
     // Collect the live debug info scopes attached to this instruction.
     if (const DILocation *DL = Curr->getDebugLoc())
-      collectLiveScopes(*DL, AliveScopes);
+      collectLiveScopes(*DL);
 
     for (Use &OI : Curr->operands()) {
       if (Instruction *Inst = dyn_cast<Instruction>(OI))
         if (Alive.insert(Inst).second)
           Worklist.push_back(Inst);
     }
   }
 
for (Instruction *&I : Worklist) {
     ++NumRemoved;
     I->eraseFromParent();
   }
 
   return !Worklist.empty();
 }
 
 PreservedAnalyses ADCEPass::run(Function &F, FunctionAnalysisManager &) {
-  if (!aggressiveDCE(F))
+  if (!AgggressiveDeadCodeElimination(F).aggressiveDCE())
     return PreservedAnalyses::all();
 
   // FIXME: This should also 'preserve the CFG'.
   auto PA = PreservedAnalyses();
   PA.preserve<GlobalsAA>();
   return PA;
 }
 
 namespace {
 struct ADCELegacyPass : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid
   ADCELegacyPass() : FunctionPass(ID) {
     initializeADCELegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
-  bool runOnFunction(Function& F) override {
+  bool runOnFunction(Function &F) override {
     if (skipFunction(F))
       return false;
-    return aggressiveDCE(F);
+    return AgggressiveDeadCodeElimination(F).aggressiveDCE();
   }
 
-  void getAnalysisUsage(AnalysisUsage& AU) const override {
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesCFG();
     AU.addPreserved<GlobalsAAWrapperPass>();
   }
 };
 }
 
 char ADCELegacyPass::ID = 0;
 INITIALIZE_PASS(ADCELegacyPass, "adce", "Aggressive Dead Code Elimination",
                 false, false)
 
 FunctionPass *llvm::createAggressiveDCEPass() { return new ADCELegacyPass(); }