[llvm-commits] [llvm] r169025 - /llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

[Pedro Artigas]

Author: partigas
Date: Fri Nov 30 13:09:41 2012
New Revision: 169025

URL: http://llvm.org/viewvc/llvm-project?rev=169025&view=rev
Log:
Add fast math inst combine X*log2(Y*0.5)-->X*log2(Y)-X

reviewed by Michael Ilseman <milseman at apple.com>


Modified:
    llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=169025&r1=169024&r2=169025&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (original)
+++ llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp Fri Nov 30 13:09:41 2012
@@ -284,6 +284,83 @@
     if (Value *Op1v = dyn_castFNegVal(Op1))
       return BinaryOperator::CreateFMul(Op0v, Op1v);
 
+  // Under unsafe algebra do:
+  // X * log2(0.5*Y) = X*log2(Y) - X
+  if (I.hasUnsafeAlgebra()) {
+    Value *OpX = NULL;
+    Value *OpY = NULL;
+    IntrinsicInst *Log2;
+    if (Op0->hasOneUse()) {
+      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op0)) {
+        if (II->getIntrinsicID() == Intrinsic::log2 && 
+            II->hasUnsafeAlgebra())
+        {
+          Log2 = II;
+          Value *OpLog2Of = II->getArgOperand(0);
+          if (OpLog2Of->hasOneUse()) {
+            if (Instruction *I = dyn_cast<Instruction>(OpLog2Of)) {
+              if (I->getOpcode() == Instruction::FMul &&
+                  I->hasUnsafeAlgebra())
+              {
+                ConstantFP *CFP = dyn_cast<ConstantFP>(I->getOperand(0));
+                if (CFP && CFP->isExactlyValue(0.5)) {
+                  OpY = I->getOperand(1);
+                  OpX = Op1;
+                } else {
+                  CFP = dyn_cast<ConstantFP>(I->getOperand(1));
+                  if (CFP && CFP->isExactlyValue(0.5)) {
+                    OpY = I->getOperand(0);
+                    OpX = Op1;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (Op1->hasOneUse()) {
+      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op1)) {
+        if (II->getIntrinsicID() == Intrinsic::log2 &&
+            II->hasUnsafeAlgebra()) 
+        {
+          Log2 = II;
+          Value *OpLog2Of = II->getArgOperand(0);
+          if (OpLog2Of->hasOneUse()) {
+            if (Instruction *I = dyn_cast<Instruction>(OpLog2Of)) {
+              if (I->getOpcode() == Instruction::FMul &&
+                  I->hasUnsafeAlgebra()) 
+              {
+                ConstantFP *CFP = dyn_cast<ConstantFP>(I->getOperand(0));
+                if (CFP && CFP->isExactlyValue(0.5)) {
+                  OpY = I->getOperand(1);
+                  OpX = Op0;
+                } else {
+                  CFP = dyn_cast<ConstantFP>(I->getOperand(1));
+                  if (CFP && CFP->isExactlyValue(0.5)) {
+                    OpY = I->getOperand(0);
+                    OpX = Op0;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    // if pattern detected emit alternate sequence
+    if (OpX && OpY) {
+      Log2->setArgOperand(0, OpY);
+      Value *FMulVal = Builder->CreateFMul(OpX, Log2);
+      Instruction *FMul = dyn_cast<Instruction>(FMulVal);
+      assert(FMul && "Must be instruction as Log2 is instruction");
+      FMul->copyFastMathFlags(Log2);
+      Instruction *FSub = BinaryOperator::CreateFSub(FMulVal, OpX);
+      FSub->copyFastMathFlags(Log2);
+      return FSub;
+    }
+  }
+
   return Changed ? &I : 0;
 }