If dom tree information is available, make it possible to pass

it to get better phi node simplification.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119055 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/InstructionSimplify.h b/include/llvm/Analysis/InstructionSimplify.h
index 9825caff8f0e56de6a32aa3ab0ee6c50fce0708b..d1ad061d5cd0e2d0e471103de4bf62729f932a6a 100644 (file)
--- a/include/llvm/Analysis/InstructionSimplify.h
+++ b/include/llvm/Analysis/InstructionSimplify.h
@@ -17,6 +17,7 @@
 #define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
 
 namespace llvm {
+  class DominatorTree;
   class Instruction;
   class Value;
   class TargetData;
@@ -73,7 +74,8 @@ namespace llvm {
   /// instruction.  If not, this returns null.
   /// WARNING: If called on unreachable code, an instruction may be reported
   /// to simplify to itself.
-  Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0);
+  Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0,
+                             const DominatorTree *DT = 0);
 
 
   /// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then
@@ -83,7 +85,8 @@ namespace llvm {
   /// simplifies and deletes scalar operations, it does not change the CFG.
   ///
   void ReplaceAndSimplifyAllUses(Instruction *From, Value *To,
-                                 const TargetData *TD = 0);
+                                 const TargetData *TD = 0,
+                                 const DominatorTree *DT = 0);
 } // end namespace llvm
 
 #endif

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index fd300ea47a382074cc3fafe16c356ceb7a115e80..91f7729a11d9a67fb7c0f68b6e3da59888a13471 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -1952,7 +1952,7 @@ public:
   /// value dominates the PHI. If DT is null, use a conservative check,
   /// otherwise use DT to test for dominance.
   ///
-  Value *hasConstantValue(DominatorTree *DT = 0) const;
+  Value *hasConstantValue(const DominatorTree *DT = 0) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const PHINode *) { return true; }

diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp
index 210399d7291ebb1b3b592eac1d9e3cc9e75c2ec6..282e0d31bed77a9b190708bc6650f202464e9274 100644 (file)
--- a/lib/Analysis/InstructionSimplify.cpp
+++ b/lib/Analysis/InstructionSimplify.cpp
@@ -674,7 +674,8 @@ Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
 
 /// SimplifyInstruction - See if we can compute a simplified version of this
 /// instruction.  If not, this returns null.
-Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) {
+Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD,
+                                 const DominatorTree *DT) {
   switch (I->getOpcode()) {
   default:
     return ConstantFoldInstruction(I, TD);
@@ -700,7 +701,7 @@ Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) {
     return SimplifyGEPInst(&Ops[0], Ops.size(), TD);
   }
   case Instruction::PHI:
-    return cast<PHINode>(I)->hasConstantValue();
+    return cast<PHINode>(I)->hasConstantValue(DT);
   }
 }
 
@@ -711,7 +712,8 @@ Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) {
 /// simplifies and deletes scalar operations, it does not change the CFG.
 ///
 void llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To,
-                                     const TargetData *TD) {
+                                     const TargetData *TD,
+                                     const DominatorTree *DT) {
   assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!");
 
   // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that
@@ -735,12 +737,12 @@ void llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To,
       // SimplifyInstruction.
       AssertingVH<> UserHandle(User);
 
-      SimplifiedVal = SimplifyInstruction(User, TD);
+      SimplifiedVal = SimplifyInstruction(User, TD, DT);
       if (SimplifiedVal == 0) continue;
     }
 
     // Recursively simplify this user to the new value.
-    ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD);
+    ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, DT);
     From = dyn_cast_or_null<Instruction>((Value*)FromHandle);
     To = ToHandle;
 

diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
index db3cd803645322285fc2eb32f9a0c4ca236f4806..732f6c823cc1742161c4aeb8812877d57e6845c2 100644 (file)
--- a/lib/Transforms/Scalar/GVN.cpp
+++ b/lib/Transforms/Scalar/GVN.cpp
@@ -1903,7 +1903,7 @@ bool GVN::processInstruction(Instruction *I,
   // to value numbering it.  Value numbering often exposes redundancies, for
   // example if it determines that %y is equal to %x then the instruction
   // "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify.
-  if (Value *V = SimplifyInstruction(I, TD)) {
+  if (Value *V = SimplifyInstruction(I, TD, DT)) {
     I->replaceAllUsesWith(V);
     if (MD && V->getType()->isPointerTy())
       MD->invalidateCachedPointerInfo(V);

diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp
index eb05f995c781dd8abc355ddc85e71d2d9a2fe696..009ee7b95eaba6dfca1aeabc78cc82be7e7e0f83 100644 (file)
--- a/lib/Transforms/Scalar/LoopUnswitch.cpp
+++ b/lib/Transforms/Scalar/LoopUnswitch.cpp
@@ -994,7 +994,7 @@ void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
     // See if instruction simplification can hack this up.  This is common for
     // things like "select false, X, Y" after unswitching made the condition be
     // 'false'.
-    if (Value *V = SimplifyInstruction(I)) {
+    if (Value *V = SimplifyInstruction(I, 0, DT)) {
       ReplaceUsesOfWith(I, V, Worklist, L, LPM);
       continue;
     }

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 57181e32e1f3e00e4b3bbf5a3ba29b4193234f21..7306d86877cebb9bc71b03c83065c91ec09a3d22 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -170,7 +170,7 @@ void PHINode::resizeOperands(unsigned NumOps) {
 /// value dominates the PHI. If DT is null, use a conservative check,
 /// otherwise use DT to test for dominance.
 ///
-Value *PHINode::hasConstantValue(DominatorTree *DT) const {
+Value *PHINode::hasConstantValue(const DominatorTree *DT) const {
   // If the PHI node only has one incoming value, eliminate the PHI node.
   if (getNumIncomingValues() == 1) {
     if (getIncomingValue(0) != this)   // not  X = phi X