From 22ccfc44845f29e850c52d4b3850f9ac8a82922c Mon Sep 17 00:00:00 2001
From: David Majnemer <david.majnemer@gmail.com>
Date: Wed, 27 Aug 2014 20:08:37 +0000
Subject: [PATCH] InstCombine: Combine gep X, (Y-X) to Y

We try to perform this transform in InstSimplify but we aren't always
able to.  Sometimes, we need to insert a bitcast if X and Y don't have
the same time.

llvm-svn: 216598
---
 .../InstCombine/InstructionCombining.cpp      | 39 ++++++++++++-------
 .../Transforms/InstCombine/getelementptr.ll   | 13 +++++++
 2 files changed, 38 insertions(+), 14 deletions(-)

diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
index 46789711bc8c..2f80e8389d98 100644
--- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -1516,28 +1516,39 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
       Type *Ty = PtrTy->getPointerElementType();
       uint64_t TyAllocSize = DL->getTypeAllocSize(Ty);
 
-      // Canonicalize (gep i8* X, -(ptrtoint Y)) to (sub (ptrtoint X), (ptrtoint Y))
-      // The GEP pattern is emitted by the SCEV expander for certain kinds of
-      // pointer arithmetic.
       uint64_t C;
-      Value *NegPtrToInt = nullptr;
+      Value *V = nullptr;
       if (TyAllocSize == 1) {
-          NegPtrToInt = GEP.getOperand(1);
+          V = GEP.getOperand(1);
       } else if (match(GEP.getOperand(1),
-                       m_AShr(m_Value(NegPtrToInt), m_ConstantInt(C)))) {
+                       m_AShr(m_Value(V), m_ConstantInt(C)))) {
         if (TyAllocSize != 1ULL << C)
-          NegPtrToInt = nullptr;
+          V = nullptr;
       } else if (match(GEP.getOperand(1),
-                       m_SDiv(m_Value(NegPtrToInt), m_ConstantInt(C)))) {
+                       m_SDiv(m_Value(V), m_ConstantInt(C)))) {
         if (TyAllocSize != C)
-          NegPtrToInt = nullptr;
+          V = nullptr;
       }
 
-      if (NegPtrToInt && match(NegPtrToInt, m_Neg(m_PtrToInt(m_Value())))) {
-        Operator *Index = cast<Operator>(NegPtrToInt);
-        Value *PtrToInt = Builder->CreatePtrToInt(PtrOp, Index->getType());
-        Value *NewSub = Builder->CreateSub(PtrToInt, Index->getOperand(1));
-        return CastInst::Create(Instruction::IntToPtr, NewSub, GEP.getType());
+      if (V) {
+        // Canonicalize (gep i8* X, -(ptrtoint Y))
+        // to (inttoptr (sub (ptrtoint X), (ptrtoint Y)))
+        // The GEP pattern is emitted by the SCEV expander for certain kinds of
+        // pointer arithmetic.
+        if (match(V, m_Neg(m_PtrToInt(m_Value())))) {
+          Operator *Index = cast<Operator>(V);
+          Value *PtrToInt = Builder->CreatePtrToInt(PtrOp, Index->getType());
+          Value *NewSub = Builder->CreateSub(PtrToInt, Index->getOperand(1));
+          return CastInst::Create(Instruction::IntToPtr, NewSub, GEP.getType());
+        }
+        // Canonicalize (gep i8* X, (ptrtoint Y)-(ptrtoint X))
+        // to (bitcast Y)
+        Value *Y;
+        if (match(V, m_Sub(m_PtrToInt(m_Value(Y)),
+                           m_PtrToInt(m_Specific(GEP.getOperand(0)))))) {
+          return CastInst::CreatePointerBitCastOrAddrSpaceCast(Y,
+                                                               GEP.getType());
+        }
       }
     }
   }
diff --git a/llvm/test/Transforms/InstCombine/getelementptr.ll b/llvm/test/Transforms/InstCombine/getelementptr.ll
index 71546ae3328f..684d94471290 100644
--- a/llvm/test/Transforms/InstCombine/getelementptr.ll
+++ b/llvm/test/Transforms/InstCombine/getelementptr.ll
@@ -858,6 +858,19 @@ define %struct.C* @test44(%struct.C* %c1, %struct.C* %c2) {
 ; CHECK-NEXT:  ret %struct.C* [[INTTOPTR]]
 }
 
+define %struct.C* @test45(%struct.C* %c1, %struct.C** %c2) {
+  %ptrtoint1 = ptrtoint %struct.C* %c1 to i64
+  %ptrtoint2 = ptrtoint %struct.C** %c2 to i64
+  %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1
+  %shr = sdiv i64 %sub, 7
+  %gep = getelementptr inbounds %struct.C* %c1, i64 %shr ; C1 + (C2 - C1)
+  ret %struct.C* %gep
+
+; CHECK-LABEL: @test45(
+; CHECK-NEXT:  [[BITCAST:%.*]] = bitcast %struct.C** %c2 to %struct.C*
+; CHECK-NEXT:  ret %struct.C* [[BITCAST]]
+}
+
 define i32 addrspace(1)* @ascast_0_gep(i32* %p) nounwind {
 ; CHECK-LABEL: @ascast_0_gep(
 ; CHECK-NOT: getelementptr