Fixes following the CR by Chris and Duncan:

Optimize chained bitcasts of the form A->B->A.
Undo r138722 and change isEliminableCastPair to allow this case.

llvm-svn: 138756

llvm/lib/Analysis/ConstantFolding.cpp

@@ -51,12 +51,6 @@ static Constant *FoldBitCast(Constant *C, Type *DestTy,
   if (C->isAllOnesValue() && !DestTy->isX86_MMXTy())
     return Constant::getAllOnesValue(DestTy);
 
-  // Bitcast of Bitcast can be done using a single cast.
-  ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
-  if (CE && CE->getOpcode() == Instruction::BitCast) {
-    return ConstantExpr::getBitCast(CE->getOperand(0), DestTy);
-  }
-
   // The code below only handles casts to vectors currently.
   VectorType *DestVTy = dyn_cast<VectorType>(DestTy);
   if (DestVTy == 0)

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

@@ -1659,11 +1659,6 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
   if (DestTy == Src->getType())
     return ReplaceInstUsesWith(CI, Src);
 
-  // Bitcasts are transitive.
-  if (BitCastInst* BSrc = dyn_cast<BitCastInst>(Src)) {
-    return CastInst::Create(Instruction::BitCast, BSrc->getOperand(0), DestTy);
-  }
-
   if (PointerType *DstPTy = dyn_cast<PointerType>(DestTy)) {
     PointerType *SrcPTy = cast<PointerType>(SrcTy);
     Type *DstElTy = DstPTy->getElementType();

llvm/lib/VMCore/Instructions.cpp

@@ -2059,8 +2059,7 @@ bool CastInst::isNoopCast(Type *IntPtrTy) const {
 /// If no such cast is permited, the function returns 0.
 unsigned CastInst::isEliminableCastPair(
   Instruction::CastOps firstOp, Instruction::CastOps secondOp,
-  Type *SrcTy, Type *MidTy, Type *DstTy, Type *IntPtrTy)
+  Type *SrcTy, Type *MidTy, Type *DstTy, Type *IntPtrTy) {
-{
   // Define the 144 possibilities for these two cast instructions. The values
   // in this matrix determine what to do in a given situation and select the
   // case in the switch below.  The rows correspond to firstOp, the columns 
@@ -2113,12 +2112,16 @@ unsigned CastInst::isEliminableCastPair(
   };
   
   // If either of the casts are a bitcast from scalar to vector, disallow the
-  // merging.
+  // merging. However, bitcast of A->B->A are allowed.
-  if ((firstOp == Instruction::BitCast &&
+  bool isFirstBitcast  = (firstOp == Instruction::BitCast);
-       isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) ||
+  bool isSecondBitcast = (secondOp == Instruction::BitCast);
-      (secondOp == Instruction::BitCast &&
+  bool chainedBitcast  = (SrcTy == DstTy && isFirstBitcast && isSecondBitcast);
-       isa<VectorType>(MidTy) != isa<VectorType>(DstTy)))
+
-    return 0; // Disallowed
+  // Check if any of the bitcasts convert scalars<->vectors.
+  if ((isFirstBitcast  && isa<VectorType>(SrcTy) != isa<VectorType>(MidTy)) ||
+      (isSecondBitcast && isa<VectorType>(MidTy) != isa<VectorType>(DstTy)))
+    // Unless we are bitcasing to the original type, disallow optimizations.
+    if (!chainedBitcast) return 0;
 
   int ElimCase = CastResults[firstOp-Instruction::CastOpsBegin]
                             [secondOp-Instruction::CastOpsBegin];

llvm/test/Transforms/InstCombine/cast.ll

@@ -632,15 +632,48 @@ entry:
 
 define <4 x float> @test64(<4 x float> %c) nounwind {
   %t0 = bitcast <4 x float> %c to <4 x i32>
-  %t1 = bitcast <4 x i32> %t0 to <2 x double>
+  %t1 = bitcast <4 x i32> %t0 to <4 x float>
-  %t2 = bitcast <2 x double> %t1 to <4 x float>
+  ret <4 x float> %t1
-  ret <4 x float> %t2
 ; CHECK: @test64
 ; CHECK-NEXT: ret <4 x float> %c
 }
 
+define <4 x float> @test65(<4 x float> %c) nounwind {
+  %t0 = bitcast <4 x float> %c to <2 x double>
+  %t1 = bitcast <2 x double> %t0 to <4 x float>
+  ret <4 x float> %t1
+; CHECK: @test65
+; CHECK-NEXT: ret <4 x float> %c
+}
+
+define <2 x float> @test66(<2 x float> %c) nounwind {
+  %t0 = bitcast <2 x float> %c to double
+  %t1 = bitcast double %t0 to <2 x float>
+  ret <2 x float> %t1
+; CHECK: @test66
+; CHECK-NEXT: ret <2 x float> %c
+}
+
 define float @test2c() {
   ret float extractelement (<2 x float> bitcast (double bitcast (<2 x float> <float -1.000000e+00, float -1.000000e+00> to double) to <2 x float>), i32 0)
 ; CHECK: @test2c
 ; CHECK-NOT: extractelement
 }
+
+define i64 @test_mmx(<2 x i32> %c) nounwind {
+  %A = bitcast <2 x i32> %c to x86_mmx
+  %B = bitcast x86_mmx %A to <2 x i32>
+  %C = bitcast <2 x i32> %B to i64
+  ret i64 %C
+; CHECK: @test_mmx
+; CHECK-NOT: x86_mmx
+}
+
+define i64 @test_mmx_const(<2 x i32> %c) nounwind {
+  %A = bitcast <2 x i32> zeroinitializer to x86_mmx
+  %B = bitcast x86_mmx %A to <2 x i32>
+  %C = bitcast <2 x i32> %B to i64
+  ret i64 %C
+; CHECK: @test_mmx_const
+; CHECK-NOT: x86_mmx
+}