Add comment.

[oota-llvm.git] / lib / Transforms / Scalar / Reassociate.cpp

diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp
index 2193777e250ff8a1d852ee92c5d2017b28cd21d9..47c767feb63921f90a408badbda9b847f707bfc3 100644 (file)
--- a/lib/Transforms/Scalar/Reassociate.cpp
+++ b/lib/Transforms/Scalar/Reassociate.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -69,6 +69,9 @@ namespace {
     std::map<Value*, unsigned> ValueRankMap;
     bool MadeChange;
   public:
+    static char ID; // Pass identification, replacement for typeid
+    Reassociate() : FunctionPass((intptr_t)&ID) {}
+
     bool runOnFunction(Function &F);
 
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
@@ -89,6 +92,7 @@ namespace {
     void RemoveDeadBinaryOp(Value *V);
   };
 
+  char Reassociate::ID = 0;
   RegisterPass<Reassociate> X("reassociate", "Reassociate expressions");
 }
 
@@ -387,17 +391,33 @@ static Value *NegateValue(Value *V, Instruction *BI) {
   return BinaryOperator::createNeg(V, V->getName() + ".neg", BI);
 }
 
+/// ShouldBreakUpSubtract - Return true if we should break up this subtract of
+/// X-Y into (X + -Y).
+static bool ShouldBreakUpSubtract(Instruction *Sub) {
+  // If this is a negation, we can't split it up!
+  if (BinaryOperator::isNeg(Sub))
+    return false;
+  
+  // Don't bother to break this up unless either the LHS is an associable add or
+  // subtract or if this is only used by one.
+  if (isReassociableOp(Sub->getOperand(0), Instruction::Add) ||
+      isReassociableOp(Sub->getOperand(0), Instruction::Sub))
+    return true;
+  if (isReassociableOp(Sub->getOperand(1), Instruction::Add) ||
+      isReassociableOp(Sub->getOperand(1), Instruction::Sub))
+    return true;
+  if (Sub->hasOneUse() && 
+      (isReassociableOp(Sub->use_back(), Instruction::Add) ||
+       isReassociableOp(Sub->use_back(), Instruction::Sub)))
+    return true;
+    
+  return false;
+}
+
 /// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is
 /// only used by an add, transform this into (X+(0-Y)) to promote better
 /// reassociation.
 static Instruction *BreakUpSubtract(Instruction *Sub) {
-  // Don't bother to break this up unless either the LHS is an associable add or
-  // if this is only used by one.
-  if (!isReassociableOp(Sub->getOperand(0), Instruction::Add) &&
-      !isReassociableOp(Sub->getOperand(1), Instruction::Add) &&
-      !(Sub->hasOneUse() &&isReassociableOp(Sub->use_back(), Instruction::Add)))
-    return 0;
-
   // Convert a subtract into an add and a neg instruction... so that sub
   // instructions can be commuted with other add instructions...
   //
@@ -536,7 +556,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
     switch (Opcode) {
     default: break;
     case Instruction::And:
-      if (CstVal->isNullValue()) {           // ... & 0 -> 0
+      if (CstVal->isZero()) {                // ... & 0 -> 0
         ++NumAnnihil;
         return CstVal;
       } else if (CstVal->isAllOnesValue()) { // ... & -1 -> ...
@@ -544,10 +564,10 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
       }
       break;
     case Instruction::Mul:
-      if (CstVal->isNullValue()) {           // ... * 0 -> 0
+      if (CstVal->isZero()) {                // ... * 0 -> 0
         ++NumAnnihil;
         return CstVal;
-      } else if (cast<ConstantInt>(CstVal)->getZExtValue() == 1) {
+      } else if (cast<ConstantInt>(CstVal)->isOne()) {
         Ops.pop_back();                      // ... * 1 -> ...
       }
       break;
@@ -559,7 +579,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
       // FALLTHROUGH!
     case Instruction::Add:
     case Instruction::Xor:
-      if (CstVal->isNullValue())             // ... [|^+] 0 -> ...
+      if (CstVal->isZero())                  // ... [|^+] 0 -> ...
         Ops.pop_back();
       break;
     }
@@ -718,7 +738,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
       
       ++NumFactor;
       
-      if (Ops.size() == 0)
+      if (Ops.empty())
         return V2;
 
       // Add the new value to the list of things being added.
@@ -752,18 +772,16 @@ void Reassociate::ReassociateBB(BasicBlock *BB) {
 
     // Reject cases where it is pointless to do this.
     if (!isa<BinaryOperator>(BI) || BI->getType()->isFloatingPoint() || 
-        isa<PackedType>(BI->getType()))
+        isa<VectorType>(BI->getType()))
       continue;  // Floating point ops are not associative.
 
     // If this is a subtract instruction which is not already in negate form,
     // see if we can convert it to X+-Y.
     if (BI->getOpcode() == Instruction::Sub) {
-      if (!BinaryOperator::isNeg(BI)) {
-        if (Instruction *NI = BreakUpSubtract(BI)) {
-          MadeChange = true;
-          BI = NI;
-        }
-      } else {
+      if (ShouldBreakUpSubtract(BI)) {
+        BI = BreakUpSubtract(BI);
+        MadeChange = true;
+      } else if (BinaryOperator::isNeg(BI)) {
         // Otherwise, this is a negation.  See if the operand is a multiply tree
         // and if this is not an inner node of a multiply tree.
         if (isReassociableOp(BI->getOperand(1), Instruction::Mul) &&