Changes in directory llvm/lib/Transforms/Scalar:

InstructionCombining.cpp updated: 1.566 -> 1.567
---
Log message:

Fix and/or/xor (cast A), (cast B) --> cast (and/or/xor A, B)
The cast patch introduced the possibility that the wrong cast opcode
could be used and that this transform could trigger on different kinds
of cast operations. This patch rectifies that.


---
Diffs of the changes:  (+40 -41)

 InstructionCombining.cpp |   81 +++++++++++++++++++++++------------------------
 1 files changed, 40 insertions(+), 41 deletions(-)


Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.566 
llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.567
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.566   Tue Dec 12 
17:36:14 2006
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Wed Dec 13 02:27:15 2006
@@ -3270,22 +3270,21 @@
   }
 
   // fold (and (cast A), (cast B)) -> (cast (and A, B))
-  if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) {
-    if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) {
-      const Type *SrcTy = Op0C->getOperand(0)->getType();
-      if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
-          // Only do this if the casts both really cause code to be generated.
-          ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
-          ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
-        Instruction *NewOp = BinaryOperator::createAnd(Op0C->getOperand(0),
-                                                       Op1C->getOperand(0),
-                                                       I.getName());
-        InsertNewInstBefore(NewOp, I);
-        return CastInst::createIntegerCast(NewOp, I.getType(), 
-                                           SrcTy->isSigned());
+  if (CastInst *Op0C = dyn_cast<CastInst>(Op0))
+    if (CastInst *Op1C = dyn_cast<CastInst>(Op1))
+      if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind ?
+        const Type *SrcTy = Op0C->getOperand(0)->getType();
+        if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
+            // Only do this if the casts both really cause code to be 
generated.
+            ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
+            ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
+          Instruction *NewOp = BinaryOperator::createAnd(Op0C->getOperand(0),
+                                                         Op1C->getOperand(0),
+                                                         I.getName());
+          InsertNewInstBefore(NewOp, I);
+          return CastInst::create(Op0C->getOpcode(), NewOp, I.getType());
+        }
       }
-    }
-  }
     
   // (X >> Z) & (Y >> Z)  -> (X&Y) >> Z  for all shifts.
   if (ShiftInst *SI1 = dyn_cast<ShiftInst>(Op1)) {
@@ -3675,21 +3674,21 @@
   }
     
   // fold (or (cast A), (cast B)) -> (cast (or A, B))
-  if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) {
-    const Type *SrcTy = Op0C->getOperand(0)->getType();
+  if (CastInst *Op0C = dyn_cast<CastInst>(Op0))
     if (CastInst *Op1C = dyn_cast<CastInst>(Op1))
-      if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
-          // Only do this if the casts both really cause code to be generated.
-          ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
-          ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
-        Instruction *NewOp = BinaryOperator::createOr(Op0C->getOperand(0),
-                                                      Op1C->getOperand(0),
-                                                      I.getName());
-        InsertNewInstBefore(NewOp, I);
-        return CastInst::createIntegerCast(NewOp, I.getType(),
-                                           SrcTy->isSigned());
+      if (Op0C->getOpcode() == Op1C->getOpcode()) {// same cast kind ?
+        const Type *SrcTy = Op0C->getOperand(0)->getType();
+        if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
+            // Only do this if the casts both really cause code to be 
generated.
+            ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
+            ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
+          Instruction *NewOp = BinaryOperator::createOr(Op0C->getOperand(0),
+                                                        Op1C->getOperand(0),
+                                                        I.getName());
+          InsertNewInstBefore(NewOp, I);
+          return CastInst::create(Op0C->getOpcode(), NewOp, I.getType());
+        }
       }
-  }
       
 
   return Changed ? &I : 0;
@@ -3857,21 +3856,21 @@
       return R;
 
   // fold (xor (cast A), (cast B)) -> (cast (xor A, B))
-  if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) {
-    const Type *SrcTy = Op0C->getOperand(0)->getType();
+  if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) 
     if (CastInst *Op1C = dyn_cast<CastInst>(Op1))
-      if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
-          // Only do this if the casts both really cause code to be generated.
-          ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
-          ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
-        Instruction *NewOp = BinaryOperator::createXor(Op0C->getOperand(0),
-                                                       Op1C->getOperand(0),
-                                                       I.getName());
-        InsertNewInstBefore(NewOp, I);
-        return CastInst::createIntegerCast(NewOp, I.getType(), 
-                                           SrcTy->isSigned());
+      if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind?
+        const Type *SrcTy = Op0C->getOperand(0)->getType();
+        if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegral() &&
+            // Only do this if the casts both really cause code to be 
generated.
+            ValueRequiresCast(Op0C->getOperand(0), I.getType(), TD) &&
+            ValueRequiresCast(Op1C->getOperand(0), I.getType(), TD)) {
+          Instruction *NewOp = BinaryOperator::createXor(Op0C->getOperand(0),
+                                                         Op1C->getOperand(0),
+                                                         I.getName());
+          InsertNewInstBefore(NewOp, I);
+          return CastInst::create(Op0C->getOpcode(), NewOp, I.getType());
+        }
       }
-  }
 
   // (X >> Z) ^ (Y >> Z)  -> (X^Y) >> Z  for all shifts.
   if (ShiftInst *SI1 = dyn_cast<ShiftInst>(Op1)) {



_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

Reply via email to