[PredicateInfo] Add a helper routine to remove SSA copies from a Function.

[mcrosier]

Summary

Also make it configurable so when PredicateInfo is destroyed the SSA copies are automatically removed if requested by the user.

While NewGVN takes care of these copies on the fly the expectation is that most passes will clean up after the fact. Doing this directly in PredicateInfo is much easier and faster.

Just looking for some feedback to see if I'm going in the right direction here..

Chad

[davide]

I'm not necessarily against this, and I think having PI garbage collecting the intrinsics is a good thing.
What I'm wondering here if you hit a case when this actually matters? I and Dan debugged several cases where PI intrinsics weren't reclaimed but those were all legitimate bugs in NewGVN.
In case we decide to use PI for some other pass (LVI is an obvious candidate) then having this logic handled in the utility may make things easier.

[mcrosier]

In D36591#838798, @davide wrote:

I'm not necessarily against this, and I think having PI garbage collecting the intrinsics is a good thing.
What I'm wondering here if you hit a case when this actually matters? I and Dan debugged several cases where PI intrinsics weren't reclaimed but those were all legitimate bugs in NewGVN.
In case we decide to use PI for some other pass (LVI is an obvious candidate) then having this logic handled in the utility may make things easier.

I have a patch in flight that uses PI along with this routine. The patch isn't yet in a state to be reviewed, but I figured I'd post this just to make sure I was on the right track w.r.t. cleaning up the ssa copies.. Approval for this can certainly be deferred until I have my WIP in a reviewable state.

[mcrosier]

We can revisit this once there's a use case.

include/llvm/Transforms/Utils/PredicateInfo.h

   iplist<PredicateBase> AllInfos;
 
 public:
-  PredicateInfo(Function &, DominatorTree &, AssumptionCache &);
+  PredicateInfo(Function &, DominatorTree &, AssumptionCache &, bool = false);
   ~PredicateInfo();
 
   void verifyPredicateInfo() const;

 
 private:
   void buildPredicateInfo();
+  void removeSSACopies();
   void processAssume(IntrinsicInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);
   void processBranch(BranchInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);
   void processSwitch(SwitchInst *, BasicBlock *, SmallPtrSetImpl<Value *> &);

   DominatorTree &DT;
   AssumptionCache &AC;
   OrderedInstructions OI;
+  bool RemoveSSACopies;
   // This maps from copy operands to Predicate Info. Note that it does not own
   // the Predicate Info, they belong to the ValueInfo structs in the ValueInfos
   // vector.

lib/Transforms/Utils/PredicateInfo.cpp

   renameUses(OpsToRename);
 }
 
+// Remove all SSA copies from function F.
+void PredicateInfo::removeSSACopies() {
+  for (DenseMap<const Value *, const PredicateBase *>::iterator
+           I = PredicateMap.begin(),
+           E = PredicateMap.end();
+       I != E; ++I) {
+    IntrinsicInst *Copy =
+        const_cast<IntrinsicInst *>(cast<IntrinsicInst>(I->first));
+    Copy->replaceAllUsesWith(Copy->getReturnedArgOperand());
+    Copy->eraseFromParent();
+  }
+}
+
 // Given the renaming stack, make all the operands currently on the stack real
 // by inserting them into the IR.  Return the last operation's value.
 Value *PredicateInfo::materializeStack(unsigned int &Counter,

 }
 
 PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT,
-                             AssumptionCache &AC)
+                             AssumptionCache &AC, bool RemoveCopies)
     : F(F), DT(DT), AC(AC), OI(&DT) {
   // Push an empty operand info so that we can detect 0 as not finding one
   ValueInfos.resize(1);
   buildPredicateInfo();
+  RemoveSSACopies = RemoveCopies;
 }
 
-PredicateInfo::~PredicateInfo() {}
+PredicateInfo::~PredicateInfo() {
+  if (RemoveSSACopies)
+    removeSSACopies();
+}
 
 void PredicateInfo::verifyPredicateInfo() const {}