[InstCombine] Fold PHIs with equal incoming pointers

[DaniilSuchkov]

Summary

In case when all incoming values of a PHI are equal pointers, this transformation inserts a definition of such a pointer right after definition of the base pointer and replaces with this value both PHI and all it's incoming pointers. Primary goal of this transformation is canonicalization of this pattern in order to enable optimizations that can't handle PHIs. Non-inbounds pointers aren't currently supported.

[lebedev.ri]

Please split baseline tests into a parent review and autogenerate them via utils/update_test_checks.py
It is not obvious what this actually does based just on those few sparse check-lines.
Should this go elsewhere, SimplifyCFG?

[RKSimon]

(style) auto should only be used when the type is obvious, this typically means the type is already present in the expression (cast/dyn_cast etc.)

[DaniilSuchkov]

Comments addressed: checks in tests are autogenerated, positive tests moved to a separate patch D68263, got rid of excessive use of auto keyword.

[DaniilSuchkov]

In D68128#1685720, @lebedev.ri wrote:

Should this go elsewhere, SimplifyCFG?

I don't see why it should, but if you think it does and others don't object, I won't mind moving it.

[lebedev.ri]

I see.
So we want to hoist identical gep+bitcast from 2 BB's into their closest dominating BB, more or less.
Do we have standalone hoisting pass?

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1157–1168

I'm not sure if this is correct.
I'd expect that we actually need to check to where we can move these geps.

[DaniilSuchkov]

In D68128#1689376, @lebedev.ri wrote:

I see.
So we want to hoist identical gep+bitcast from 2 BB's into their closest dominating BB, more or less.
Do we have standalone hoisting pass?

As stated in the "Summary", the main point is not to just hoist expressions, but to canonicalize them in order to open opportunities for further optimizations, so hoisting is more of a side-effect here (I chose it because sinking doesn't work). InstCombine sounds like the right place for canonicalization of specific simple patterns of instructions. GVN performs transformations of this kind but it takes number of uses into account (while for canonicalization it shouldn't matter) and also won't handle cases when the sequences of instructions producing equal pointers are different.

InstCombine already handles such patterns (is sinks instructions one by one) but with some serious limitations: only identical sequences of instructions are allowed and only for cases where PHI is the only user. If the latter restriction is lifted, the resulting code is then "optimized" back by GVN.

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1157–1168

Why do you think it's incorrect? Given the offset is constant, this code just looks for an insertion point right after base pointer definition and bails out in case when such point doesn't exist.

What restrictions did I miss?

[lebedev.ri]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1157–1168

Actually, i guess this might be ok,
we don't do anything with the users,
and gep inbounds at worst produces poison.

[DaniilSuchkov]

Test checks updated.

[lebedev.ri]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1144–1155

This still looks like a hoisting problem to me, honestly.

In particular, why do we want *all* the incoming values to be identical?
I.e. why can't we track *which* values are identical,
and if there are two-or-more of of particular value hoist+common them?

[lebedev.ri]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1144–1155

To be more specific

struct ZZZ {
  Value *Base;
  int64_t Offset;
  bool IsInBounds;
}

DenseMap<ZZZ, SmallVector<Value *, 4>> QQQ;

for (Use &Incoming : PN.incoming_values()) {
  QQQ[GetPointerBaseWithConstantOffset(Incoming)].append(Incoming);
}

for(??? I : QQQ) {
  if(I.second.size() < 2)
    continue;
  <hoist>
  replaceInstUsesWith()
}

[DaniilSuchkov]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1144–1155

This still looks like a hoisting problem to me, honestly.

In particular, why do we want *all* the incoming values to be identical?
I.e. why can't we track *which* values are identical,
and if there are two-or-more of of particular value hoist+common them?

Because the main idea here is to get rid of a redundant PHI, since it makes the code analyzable by optimizations that can't (and in general don't need to) walk through PHIs. Yes, it also makes a number of identical pointers trivially equal, but it is more of a side-effect.
What you propose is more complex, has broader scope (thus is more likely to have unwanted side-effects) but it doesn't improve the solution of the initial problem.

[DaniilSuchkov]

Gentle ping?

[spatel]

I didn't step through the entire patch/tests, but the first few examples are flattened/simplified by -simplifycfg. Would it be better to look there to add the missing functionality? Is there a test in this patch that shows a case that simplifycfg can't already flatten?

[lebedev.ri]

llvm/include/llvm/IR/Value.h

575–576

This could better out what happens when more than one GEP is stripped, and they had different inbound-ness.

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1144–1155

Okay.

[DaniilSuchkov]

In D68128#1709717, @spatel wrote:

I didn't step through the entire patch/tests, but the first few examples are flattened/simplified by -simplifycfg. Would it be better to look there to add the missing functionality? Is there a test in this patch that shows a case that simplifycfg can't already flatten?

SimplifyCFG happens to flatten most of these tests by a transformation that performs hoisting of the common code from the branches to their only immediate predecessor and does only very primitive matching, and, according to comments around it, this transformation is intentionally cheap and simple. So, such an extension of simplifycfg would perform worse on all cases other than primitive tests and it's not exactly in line with the intentions behind the transformation.

The tests from D68263 are bad at showing when this transformation is more powerful than what SimplifyCFG can do because it wasn't the intention. Out of all the tests, following are out of scope of the SimplifyCFG transform and thus not simplified: test_extra_uses_multiple_geps, test_gep_and_bitcast_same_bb_and_extra_use, test_gep_and_bitcast_same_bb.

[DaniilSuchkov]

llvm/include/llvm/IR/Value.h

575–576

You're right, that is a tricky question, I will provide details on the behavior in this case.

[DaniilSuchkov]

Added a comment explaining how IsInBounds is set by stripAndAccumulateConstantOffsets.

[DaniilSuchkov]

ping?

[apilipenko]

Can we handle the case with inbounds offsets only first and extend with non-inbounds support in a follow up change? This way in the first change you'll not need to change IR interfaces at all.

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1163–1164

It's ok to insert at the end of BB.

Use IRBuilder::SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) for that. After this change there will be no situation when InsertPt is available, so the code can structured slightly differently:

if (auto *BaseInst = dyn_cast<Instruction>(Base)) {
  if (isa<PHINode>(BaseInst))
    Builder.SetInsertPoint(BaseInst->getParent(), BaseInst->getParent()->getFirstInsertionPt())
  else
    Builder.SetInsertPoint(BaseInst->getNextNode());
} else
  Builder.SetInsertPoint(...);

[DaniilSuchkov]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1163–1164

It's ok to insert at the end of BB.

It can result in broken IR by insertion of a regular instruction after terminator.

Take a look at "test_neg_gep_and_bitcast_phi_no_insert_pt", in that case there is no valid insertion point in bb at all:

catch:
  ; There is no insertion point in this basic block!
  %obj = phi i8* [ %obj1, %entry ], [ %obj2, %cont ]
  %cs = catchswitch within none [label %doit] unwind to caller

[DaniilSuchkov]

Removed support of non-inbounds pointers.

[lebedev.ri]

No further comments from me.
This seems correct, but still not sure where this should actually be performed.

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1171

Do you want to restore previous insertion point afterwards, i.e. use InsertPointGuard?

[DaniilSuchkov]

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

1171

I don't think so. In general it doesn't look like it is a common practice to restore insertion point in InstCombine (5 uses of InsertPointGuard vs 27 uses of SetInsertPoint). Moreover, in InstCombiner::run IP is being reset at every iteration, so it makes sense to reset IP only within helper functions that are to be called from other transformations, but this function isn't intended to be used this way.

llvm/include/llvm/Analysis/ValueTracking.h

class Value;
 
   /// Analyze the specified pointer to see if it can be expressed as a base
   /// pointer plus a constant offset. Return the base and offset to the caller.
   ///
   /// This is a wrapper around Value::stripAndAccumulateConstantOffsets that
   /// creates and later unpacks the required APInt.
   inline Value *GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset,
                                                  const DataLayout &DL,
-                                                 bool AllowNonInbounds = true) {
+                                                 bool AllowNonInbounds = true,
+                                                 bool *IsInBounds = nullptr) {
     APInt OffsetAPInt(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
     Value *Base =
-        Ptr->stripAndAccumulateConstantOffsets(DL, OffsetAPInt, AllowNonInbounds);
+        Ptr->stripAndAccumulateConstantOffsets(DL, OffsetAPInt,
+                                               AllowNonInbounds, IsInBounds);
 
     Offset = OffsetAPInt.getSExtValue();
     return Base;
   }
   inline const Value *
   GetPointerBaseWithConstantOffset(const Value *Ptr, int64_t &Offset,
                                    const DataLayout &DL,
-                                   bool AllowNonInbounds = true) {
+                                   bool AllowNonInbounds = true,
+                                   bool *IsInBounds = nullptr) {
     return GetPointerBaseWithConstantOffset(const_cast<Value *>(Ptr), Offset, DL,
-                                            AllowNonInbounds);
+                                            AllowNonInbounds, IsInBounds);
   }
 
   /// Returns true if the GEP is based on a pointer to a string (array of
   // \p CharSize integers) and is indexing into this string.
   bool isGEPBasedOnPointerToString(const GEPOperator *GEP,
                                    unsigned CharSize = 8);
 
   /// Represents offset+length into a ConstantDataArray.

llvm/include/llvm/IR/Value.h

#include "llvm/IR/Value.def"
   /// DataLayout::getIndexTypeSizeInBits(Ty).
   ///
   /// If \p AllowNonInbounds is true, constant offsets in GEPs are stripped and
   /// accumulated even if the GEP is not "inbounds".
   ///
   /// If this is called on a non-pointer value, it returns 'this' and the
   /// \p Offset is not modified.
   ///
+  /// If \p IsInBounds is not a nullptr and at least one GEP is stripped,
+  /// IsInBounds will reflect whether the accumulated offset is inbounds or not,
+  /// otherwise the value won't be modified.
+  ///
   /// Note that this function will never return a nullptr. It will also never
   /// manipulate the \p Offset in a way that would not match the difference
   /// between the underlying value and the returned one. Thus, if no constant
   /// offset was found, the returned value is the underlying one and \p Offset
   /// is unchanged.
-  const Value *stripAndAccumulateConstantOffsets(const DataLayout &DL,
-                                                 APInt &Offset,
-                                                 bool AllowNonInbounds) const;
+  const Value *
+  stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
+                                    bool AllowNonInbounds,
+                                    bool *IsInBounds = nullptr) const;
   Value *stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
-                                           bool AllowNonInbounds) {
+                                           bool AllowNonInbounds,
+                                           bool *IsInBounds = nullptr) {
     return const_cast<Value *>(
         static_cast<const Value *>(this)->stripAndAccumulateConstantOffsets(
-            DL, Offset, AllowNonInbounds));
+            DL, Offset, AllowNonInbounds, IsInBounds));
   }
 
   /// This is a wrapper around stripAndAccumulateConstantOffsets with the
   /// in-bounds requirement set to false.
   const Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                          APInt &Offset) const {
     return stripAndAccumulateConstantOffsets(DL, Offset,
-                                             /* AllowNonInbounds */ false);
+                                             /* AllowNonInbounds */ false,
+                                             /* IsInBounds */ nullptr);
   }
   Value *stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL,
                                                    APInt &Offset) {
     return stripAndAccumulateConstantOffsets(DL, Offset,
-                                             /* AllowNonInbounds */ false);
+                                             /* AllowNonInbounds */ false,
+                                             /* IsInBounds */ nullptr);
   }
 
   /// Strip off pointer casts and inbounds GEPs.
   ///
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripInBoundsOffsets() const;
   Value *stripInBoundsOffsets() {

llvm/lib/IR/Value.cpp

 const Value *Value::stripInBoundsConstantOffsets() const {
   return stripPointerCastsAndOffsets<PSK_InBoundsConstantIndices>(this);
 }
 
 const Value *Value::stripPointerCastsAndInvariantGroups() const {
   return stripPointerCastsAndOffsets<PSK_ZeroIndicesAndInvariantGroups>(this);
 }
 
-const Value *
-Value::stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
-                                         bool AllowNonInbounds) const {
+const Value *Value::stripAndAccumulateConstantOffsets(const DataLayout &DL,
+                                                      APInt &Offset,
+                                                      bool AllowNonInbounds,
+                                                      bool *IsInBounds) const {
   if (!getType()->isPtrOrPtrVectorTy())
     return this;
 
   unsigned BitWidth = Offset.getBitWidth();
   assert(BitWidth == DL.getIndexTypeSizeInBits(getType()) &&
          "The offset bit width does not match the DL specification.");
 
   // Even though we don't look through PHI nodes, we could be called on an
   // instruction in an unreachable block, which may be on a cycle.
   SmallPtrSet<const Value *, 4> Visited;
   Visited.insert(this);
+  bool IsFirstStrippedGEP = true;
   const Value *V = this;
   do {
     if (auto *GEP = dyn_cast<GEPOperator>(V)) {
       // If in-bounds was requested, we do not strip non-in-bounds GEPs.
       if (!AllowNonInbounds && !GEP->isInBounds())
         return V;
 
       // If one of the values we have visited is an addrspacecast, then
       // the pointer type of this GEP may be different from the type
       // of the Ptr parameter which was passed to this function.  This
       // means when we construct GEPOffset, we need to use the size
       // of GEP's pointer type rather than the size of the original
       // pointer type.
       APInt GEPOffset(DL.getIndexTypeSizeInBits(V->getType()), 0);
       if (!GEP->accumulateConstantOffset(DL, GEPOffset))
         return V;
 
       // Stop traversal if the pointer offset wouldn't fit in the bit-width
       // provided by the Offset argument. This can happen due to AddrSpaceCast
       // stripping.
       if (GEPOffset.getMinSignedBits() > BitWidth)
         return V;
 
+      if (IsFirstStrippedGEP) {
+        if (IsInBounds)
+          *IsInBounds = GEP->isInBounds();
+        IsFirstStrippedGEP = false;
+      }
+
       Offset += GEPOffset.sextOrTrunc(BitWidth);
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast ||
                Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (auto *GA = dyn_cast<GlobalAlias>(V)) {
       if (!GA->isInterposable())
         V = GA->getAliasee();

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

private:
   Instruction *FoldPHIArgLoadIntoPHI(PHINode &PN);
   Instruction *FoldPHIArgZextsIntoPHI(PHINode &PN);
 
   /// If an integer typed PHI has only one use which is an IntToPtr operation,
   /// replace the PHI with an existing pointer typed PHI if it exists. Otherwise
   /// insert a new pointer typed PHI and replace the original one.
   Instruction *FoldIntegerTypedPHI(PHINode &PN);
 
+  /// If all incoming values of a pointer typed PHI are pointers with the same
+  /// base and offset, replace the PHI and all incoming values with one
+  /// definition of such pointer.
+  Instruction *FoldPHIWithEqualPointers(PHINode &PN);
+
   /// Helper function for FoldPHIArgXIntoPHI() to set debug location for the
   /// folded operation.
   void PHIArgMergedDebugLoc(Instruction *Inst, PHINode &PN);
 
   Instruction *foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
                            ICmpInst::Predicate Cond, Instruction &I);
   Instruction *foldAllocaCmp(ICmpInst &ICI, const AllocaInst *Alloca,
                              const Value *Other);

llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp

Instruction *InstCombiner::SliceUpIllegalIntegerPHI(PHINode &FirstPhi) {
   // Replace all the remaining uses of the PHI nodes (self uses and the lshrs)
   // with undefs.
   Value *Undef = UndefValue::get(FirstPhi.getType());
   for (unsigned i = 1, e = PHIsToSlice.size(); i != e; ++i)
     replaceInstUsesWith(*PHIsToSlice[i], Undef);
   return replaceInstUsesWith(FirstPhi, Undef);
 }
 
+Instruction *InstCombiner::FoldPHIWithEqualPointers(PHINode &PN) {
+  auto *PhiTy = dyn_cast<PointerType>(PN.getType());
+  if (!PhiTy)
+    return nullptr;
+
+  // Make sure all incoming pointers have the same base pointers, offsets and
+  // (if offset isn't 0) inbounds qualifiers. Also, make sure no addrspacecasts
+  // involved.
+  const DataLayout &DL = PN.getModule()->getDataLayout();
+  Value *FirstValue = PN.getIncomingValue(0);
+  int64_t Offset;
+  bool IsInBounds = true;
+  Value *Base = GetPointerBaseWithConstantOffset(
+      FirstValue, Offset, DL, /* AllowNonInbounds */ true, &IsInBounds);
+
+  auto *BaseTy = cast<PointerType>(Base->getType());
+  if (BaseTy->getAddressSpace() != PhiTy->getAddressSpace())
+    return nullptr;
+
+  for (Use &Incoming : PN.incoming_values()) {
+    if (!isa<Instruction>(Incoming))
+      return nullptr;
+    int64_t CurrentOffset;
+    bool IsCurrentInBounds = true;
+    Value *CurrentBase = GetPointerBaseWithConstantOffset(
+        Incoming, CurrentOffset, DL, /* AllowNonInbounds */ true,
+        &IsCurrentInBounds);
+    if (CurrentBase != Base || CurrentOffset != Offset ||
+        (Offset != 0 && IsCurrentInBounds != IsInBounds))
+      return nullptr;
+  }
+
+  Instruction *InsertPt = nullptr;
+  if (auto *BaseInst = dyn_cast<Instruction>(Base)) {
+    if (isa<PHINode>(BaseInst)) {
+      BasicBlock *InsertBB = BaseInst->getParent();
+      BasicBlock::iterator InsertPtIter = InsertBB->getFirstInsertionPt();
+      // Make sure the insertion point exists.
+      if (InsertPtIter != InsertBB->end())
+        InsertPt = &*InsertPtIter;
+    } else
+      InsertPt = BaseInst->getNextNode();
+  } else
+    InsertPt = &*PN.getFunction()->getEntryBlock().getFirstInsertionPt();
+
+  if (!InsertPt)
+    return nullptr;
+
+  Builder.SetInsertPoint(InsertPt);
+  Type *I8PtrTy = Builder.getInt8PtrTy(PhiTy->getAddressSpace());
+  Value *BaseI8Ptr = Builder.CreateBitCast(Base, I8PtrTy);
+  Value *GEP = IsInBounds
+                   ? Builder.CreateConstInBoundsGEP1_64(BaseI8Ptr, Offset)
+                   : Builder.CreateConstGEP1_64(BaseI8Ptr, Offset);
+  Value *GEPTyped = Builder.CreateBitCast(GEP, PhiTy);
+
+  for (Use &Incoming : PN.incoming_values())
+    replaceInstUsesWith(*cast<Instruction>(Incoming), GEPTyped);
+  return replaceInstUsesWith(PN, GEPTyped);
+}
+
 // PHINode simplification
 //
 Instruction *InstCombiner::visitPHINode(PHINode &PN) {
   if (Value *V = SimplifyInstruction(&PN, SQ.getWithInstruction(&PN)))
     return replaceInstUsesWith(PN, V);
 
   if (Instruction *Result = FoldPHIArgZextsIntoPHI(PN))
     return Result;
 
   // If all PHI operands are the same operation, pull them through the PHI,
   // reducing code size.
   if (isa<Instruction>(PN.getIncomingValue(0)) &&
       isa<Instruction>(PN.getIncomingValue(1)) &&
       cast<Instruction>(PN.getIncomingValue(0))->getOpcode() ==
       cast<Instruction>(PN.getIncomingValue(1))->getOpcode() &&
       // FIXME: The hasOneUse check will fail for PHIs that use the value more
       // than themselves more than once.
       PN.getIncomingValue(0)->hasOneUse())
     if (Instruction *Result = FoldPHIArgOpIntoPHI(PN))
       return Result;
 
+  if (Instruction *Result = FoldPHIWithEqualPointers(PN))
+    return Result;
+
   // If this is a trivial cycle in the PHI node graph, remove it.  Basically, if
   // this PHI only has a single use (a PHI), and if that PHI only has one use (a
   // PHI)... break the cycle.
   if (PN.hasOneUse()) {
     if (Instruction *Result = FoldIntegerTypedPHI(PN))
       return Result;
 
     Instruction *PHIUser = cast<Instruction>(PN.user_back());

llvm/test/Transforms/InstCombine/phi-equal-incoming-pointers.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine,verify -S < %s | FileCheck %s
 
 ; Make sure GVN won't undo the transformation:
 ; RUN: opt -passes=instcombine,gvn -S < %s | FileCheck --check-prefix=CHECK-AFTER-GVN %s
 
 declare i8* @get_ptr.i8()
 declare i32* @get_ptr.i32()
 declare void @foo.i8(i8*)
 declare void @foo.i32(i32*)
 
 define i32 @test_gep_and_bitcast(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_and_bitcast(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res.load = load i32, i32* %ptr.typed
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_gep_and_bitcast_arg(i8* %obj, i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_and_bitcast_arg(
 ; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ:%.*]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ:%.*]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast_arg(
 ; CHECK-AFTER-GVN-NEXT:  entry:
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ:%.*]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ:%.*]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
   %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16

 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    [[OBJ2_TYPED:%.*]] = call i32* @get_ptr.i32()
 ; CHECK-NEXT:    [[OBJ2:%.*]] = bitcast i32* [[OBJ2_TYPED]] to i8*
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; CHECK-NEXT:    [[OBJ:%.*]] = phi i8* [ [[OBJ1]], [[BB1]] ], [ [[OBJ2]], [[BB2]] ]
 ; CHECK-NEXT:    [[ANOTHER_PHI:%.*]] = phi i8* [ [[OBJ1]], [[BB1]] ], [ null, [[BB2]] ]
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    call void @foo.i8(i8* [[ANOTHER_PHI]])
 ; CHECK-NEXT:    br i1 [[COND2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK:       bb3:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb4:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB3]] ], [ [[PTR2_TYPED]], [[BB4]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB3]] ], [ [[PTR2_TYPED]], [[BB4]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND3:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast_phi(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ1:%.*]] = call i8* @get_ptr.i8()
 ; CHECK-AFTER-GVN-NEXT:    br label [[MERGE:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ2_TYPED:%.*]] = call i32* @get_ptr.i32()
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ2:%.*]] = bitcast i32* [[OBJ2_TYPED]] to i8*
 ; CHECK-AFTER-GVN-NEXT:    br label [[MERGE]]
 ; CHECK-AFTER-GVN:       merge:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = phi i8* [ [[OBJ1]], [[BB1]] ], [ [[OBJ2]], [[BB2]] ]
 ; CHECK-AFTER-GVN-NEXT:    [[ANOTHER_PHI:%.*]] = phi i8* [ [[OBJ1]], [[BB1]] ], [ null, [[BB2]] ]
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    call void @foo.i8(i8* [[ANOTHER_PHI]])
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND2:%.*]], label [[BB3:%.*]], label [[BB4:%.*]]
 ; CHECK-AFTER-GVN:       bb3:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb4:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB3]] ], [ [[PTR2_TYPED]], [[BB4]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB3]] ], [ [[PTR2_TYPED]], [[BB4]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND3:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
   %obj1 = call i8* @get_ptr.i8()
exit:
   %res = select i1 %cond3, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_gep_i32ptr(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_i32ptr(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i32* @get_ptr.i32()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP0]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_i32ptr(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i32* @get_ptr.i32()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = getelementptr inbounds i32, i32* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP0]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i32* @get_ptr.i32()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_gep_and_bitcast_gep_base_ptr(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_and_bitcast_gep_base_ptr(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ0:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast_gep_base_ptr(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ0:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ0]], i64 32
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj0 = call i8* @get_ptr.i8()
   %obj = getelementptr inbounds i8, i8* %obj0, i64 16
   br i1 %cond, label %bb1, label %bb2
 
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_gep_and_bitcast_same_bb(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_and_bitcast_same_bb(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[EXIT:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[ENTRY:%.*]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[ENTRY]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast_same_bb(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[EXIT:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR1_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
   %ptr1.typed = bitcast i8* %ptr1 to i32*
   %res1 = load i32, i32* %ptr1.typed
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_gep_and_bitcast_same_bb_and_extra_use(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_and_bitcast_same_bb_and_extra_use(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[EXIT:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[ENTRY:%.*]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[ENTRY]] ], [ [[PTR2_TYPED]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_and_bitcast_same_bb_and_extra_use(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[EXIT:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR1_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
   %ptr1.typed = bitcast i8* %ptr1 to i32*
   call void @foo.i32(i32* %ptr1.typed)
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i8 @test_gep(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
-; CHECK-NEXT:    [[RES_PHI:%.*]] = load i8, i8* [[RES_PHI_IN]], align 1
-; CHECK-NEXT:    store i8 1, i8* [[PTR_TYPED]], align 1
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT:    store i8 1, i8* [[TMP0]], align 1
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i8 [[RES_PHI]], i8 1
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI_IN:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i8, i8* [[RES_PHI_IN]], align 1
-; CHECK-AFTER-GVN-NEXT:    store i8 1, i8* [[PTR_TYPED]], align 1
+; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-AFTER-GVN-NEXT:    store i8 1, i8* [[TMP0]], align 1
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i8 [[RES_PHI]], i8 1
 ; CHECK-AFTER-GVN-NEXT:    ret i8 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res = select i1 %cond2, i8 %res.phi, i8 %res.load
   ret i8 %res
 }
 
 define i32 @test_extra_uses(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_extra_uses(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
-; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR2_TYPED]])
+; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_extra_uses(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[PTR2_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_extra_uses_non_inbounds(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_extra_uses_non_inbounds(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* [[PTR1_TYPED]])
+; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
-; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* [[PTR2_TYPED]])
+; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_extra_uses_non_inbounds(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* [[PTR1_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* [[PTR2_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i32 @test_extra_uses_multiple_geps(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_extra_uses_multiple_geps(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2_1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2_1]] to i32*
-; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR2_TYPED]])
+; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-NEXT:    ret i32 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_extra_uses_multiple_geps(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-AFTER-GVN-NEXT:    [[TMP1:%.*]] = bitcast i8* [[TMP0]] to i32*
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[PTR1_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2_1]] to i32*
-; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[PTR2_TYPED]])
+; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i32(i32* nonnull [[TMP1]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
 ; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-AFTER-GVN-NEXT:    store i32 1, i32* [[TMP1]], align 4
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
 ; CHECK-AFTER-GVN-NEXT:    ret i32 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:
exit:
   %res = select i1 %cond2, i32 %res.phi, i32 %res.load
   ret i32 %res
 }
 
 define i8 @test_gep_extra_uses(i1 %cond, i1 %cond2) {
 ; CHECK-LABEL: @test_gep_extra_uses(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK:       bb1:
-; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[RES1:%.*]] = load i8, i8* [[PTR1]], align 1
-; CHECK-NEXT:    call void @foo.i8(i8* nonnull [[PTR1]])
+; CHECK-NEXT:    [[RES1:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT:    call void @foo.i8(i8* nonnull [[TMP0]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-NEXT:    [[RES2:%.*]] = load i8, i8* [[PTR2]], align 1
-; CHECK-NEXT:    call void @foo.i8(i8* nonnull [[PTR2]])
+; CHECK-NEXT:    [[RES2:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT:    call void @foo.i8(i8* nonnull [[TMP0]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
-; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
 ; CHECK-NEXT:    [[RES_PHI:%.*]] = phi i8 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-NEXT:    store i8 1, i8* [[PTR_TYPED]], align 1
+; CHECK-NEXT:    store i8 1, i8* [[TMP0]], align 1
 ; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i8 [[RES_PHI]], i8 1
 ; CHECK-NEXT:    ret i8 [[RES]]
 ;
 ; CHECK-AFTER-GVN-LABEL: @test_gep_extra_uses(
 ; CHECK-AFTER-GVN-NEXT:  entry:
 ; CHECK-AFTER-GVN-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-AFTER-GVN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
 ; CHECK-AFTER-GVN-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
 ; CHECK-AFTER-GVN:       bb1:
-; CHECK-AFTER-GVN-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i8, i8* [[PTR1]], align 1
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i8(i8* nonnull [[PTR1]])
+; CHECK-AFTER-GVN-NEXT:    [[RES1:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i8(i8* nonnull [[TMP0]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT:%.*]]
 ; CHECK-AFTER-GVN:       bb2:
-; CHECK-AFTER-GVN-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
-; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i8, i8* [[PTR2]], align 1
-; CHECK-AFTER-GVN-NEXT:    call void @foo.i8(i8* nonnull [[PTR2]])
+; CHECK-AFTER-GVN-NEXT:    [[RES2:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-AFTER-GVN-NEXT:    call void @foo.i8(i8* nonnull [[TMP0]])
 ; CHECK-AFTER-GVN-NEXT:    br label [[EXIT]]
 ; CHECK-AFTER-GVN:       exit:
-; CHECK-AFTER-GVN-NEXT:    [[PTR_TYPED:%.*]] = phi i8* [ [[PTR1]], [[BB1]] ], [ [[PTR2]], [[BB2]] ]
 ; CHECK-AFTER-GVN-NEXT:    [[RES_PHI:%.*]] = phi i8 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
-; CHECK-AFTER-GVN-NEXT:    store i8 1, i8* [[PTR_TYPED]], align 1
+; CHECK-AFTER-GVN-NEXT:    store i8 1, i8* [[TMP0]], align 1
 ; CHECK-AFTER-GVN-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i8 [[RES_PHI]], i8 1
 ; CHECK-AFTER-GVN-NEXT:    ret i8 [[RES]]
 ;
 entry:
   %obj = call i8* @get_ptr.i8()
   br i1 %cond, label %bb1, label %bb2
 
 bb1:

 exit:
   %ptr.typed = phi i8* [ %ptr1, %bb1 ], [ %ptr2, %bb2 ]
   %res.phi = phi i8 [ %res1, %bb1 ], [ %res2, %bb2 ]
   store i8 1, i8* %ptr.typed
   %res.load = load i8, i8* %ptr.typed
   %res = select i1 %cond2, i8 %res.phi, i8 %res.load
   ret i8 %res
 }
+
+define i32 @test_neg_extra_uses_inbounds_mismatch(i1 %cond, i1 %cond2) {
+; CHECK-LABEL: @test_neg_extra_uses_inbounds_mismatch(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
+; CHECK-NEXT:    [[RES1:%.*]] = load i32, i32* [[PTR1_TYPED]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* [[PTR1_TYPED]])
+; CHECK-NEXT:    br label [[EXIT:%.*]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
+; CHECK-NEXT:    [[RES2:%.*]] = load i32, i32* [[PTR2_TYPED]], align 4
+; CHECK-NEXT:    call void @foo.i32(i32* nonnull [[PTR2_TYPED]])
+; CHECK-NEXT:    br label [[EXIT]]
+; CHECK:       exit:
+; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
+; CHECK-NEXT:    [[RES_PHI:%.*]] = phi i32 [ [[RES1]], [[BB1]] ], [ [[RES2]], [[BB2]] ]
+; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
+; CHECK-NEXT:    ret i32 [[RES]]
+;
+entry:
+  %obj = call i8* @get_ptr.i8()
+  br i1 %cond, label %bb1, label %bb2
+
+bb1:
+  %ptr1 = getelementptr i8, i8* %obj, i64 16
+  %ptr1.typed = bitcast i8* %ptr1 to i32*
+  %res1 = load i32, i32* %ptr1.typed
+  call void @foo.i32(i32* %ptr1.typed)
+  br label %exit
+
+bb2:
+  %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr2.typed = bitcast i8* %ptr2 to i32*
+  %res2 = load i32, i32* %ptr2.typed
+  call void @foo.i32(i32* %ptr2.typed)
+  br label %exit
+
+exit:
+  %ptr.typed = phi i32* [ %ptr1.typed, %bb1 ], [ %ptr2.typed, %bb2 ]
+  %res.phi = phi i32 [ %res1, %bb1 ], [ %res2, %bb2 ]
+  store i32 1, i32* %ptr.typed
+  %res.load = load i32, i32* %ptr.typed
+  %res = select i1 %cond2, i32 %res.phi, i32 %res.load
+  ret i32 %res
+}
+
+define i32 @test_neg_gep_and_bitcast_different_offset(i1 %cond, i1 %cond2) {
+; CHECK-LABEL: @test_neg_gep_and_bitcast_different_offset(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
+; CHECK-NEXT:    br label [[EXIT:%.*]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 20
+; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
+; CHECK-NEXT:    br label [[EXIT]]
+; CHECK:       exit:
+; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
+; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
+; CHECK-NEXT:    ret i32 [[RES]]
+;
+entry:
+  %obj = call i8* @get_ptr.i8()
+  br i1 %cond, label %bb1, label %bb2
+
+bb1:
+  %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr1.typed = bitcast i8* %ptr1 to i32*
+  %res1 = load i32, i32* %ptr1.typed
+  br label %exit
+
+bb2:
+  %ptr2 = getelementptr inbounds i8, i8* %obj, i64 20
+  %ptr2.typed = bitcast i8* %ptr2 to i32*
+  %res2 = load i32, i32* %ptr2.typed
+  br label %exit
+
+exit:
+  %ptr.typed = phi i32* [ %ptr1.typed, %bb1 ], [ %ptr2.typed, %bb2 ]
+  %res.phi = phi i32 [ %res1, %bb1 ], [ %res2, %bb2 ]
+  store i32 1, i32* %ptr.typed
+  %res.load = load i32, i32* %ptr.typed
+  %res = select i1 %cond2, i32 %res.phi, i32 %res.load
+  ret i32 %res
+}
+
+define i32 @test_neg_gep_and_bitcast_different_base_ptr(i1 %cond, i1 %cond2) {
+; CHECK-LABEL: @test_neg_gep_and_bitcast_different_base_ptr(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[OBJ:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    [[OBJ2:%.*]] = call i8* @get_ptr.i8()
+; CHECK-NEXT:    br i1 [[COND:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
+; CHECK:       bb1:
+; CHECK-NEXT:    [[PTR1:%.*]] = getelementptr inbounds i8, i8* [[OBJ]], i64 16
+; CHECK-NEXT:    [[PTR1_TYPED:%.*]] = bitcast i8* [[PTR1]] to i32*
+; CHECK-NEXT:    br label [[EXIT:%.*]]
+; CHECK:       bb2:
+; CHECK-NEXT:    [[PTR2:%.*]] = getelementptr inbounds i8, i8* [[OBJ2]], i64 16
+; CHECK-NEXT:    [[PTR2_TYPED:%.*]] = bitcast i8* [[PTR2]] to i32*
+; CHECK-NEXT:    br label [[EXIT]]
+; CHECK:       exit:
+; CHECK-NEXT:    [[PTR_TYPED:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
+; CHECK-NEXT:    [[RES_PHI_IN:%.*]] = phi i32* [ [[PTR1_TYPED]], [[BB1]] ], [ [[PTR2_TYPED]], [[BB2]] ]
+; CHECK-NEXT:    [[RES_PHI:%.*]] = load i32, i32* [[RES_PHI_IN]], align 4
+; CHECK-NEXT:    store i32 1, i32* [[PTR_TYPED]], align 4
+; CHECK-NEXT:    [[RES:%.*]] = select i1 [[COND2:%.*]], i32 [[RES_PHI]], i32 1
+; CHECK-NEXT:    ret i32 [[RES]]
+;
+entry:
+  %obj = call i8* @get_ptr.i8()
+  %obj2 = call i8* @get_ptr.i8()
+  br i1 %cond, label %bb1, label %bb2
+
+bb1:
+  %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr1.typed = bitcast i8* %ptr1 to i32*
+  %res1 = load i32, i32* %ptr1.typed
+  br label %exit
+
+bb2:
+  %ptr2 = getelementptr inbounds i8, i8* %obj2, i64 16
+  %ptr2.typed = bitcast i8* %ptr2 to i32*
+  %res2 = load i32, i32* %ptr2.typed
+  br label %exit
+
+exit:
+  %ptr.typed = phi i32* [ %ptr1.typed, %bb1 ], [ %ptr2.typed, %bb2 ]
+  %res.phi = phi i32 [ %res1, %bb1 ], [ %res2, %bb2 ]
+  store i32 1, i32* %ptr.typed
+  %res.load = load i32, i32* %ptr.typed
+  %res = select i1 %cond2, i32 %res.phi, i32 %res.load
+  ret i32 %res
+}
+
+; Just to make sure we don't generate invalid IR in this case.
+; There is no insertion point right after base pointer def here.
+define i32 @test_neg_gep_and_bitcast_invoke(i1 %cond, i1 %cond2) personality i8 0 {
+; CHECK-LABEL: @test_neg_gep_and_bitcast_invoke(
+entry:
+  %obj = invoke i8* @get_ptr.i8() to label %bb0 unwind label %lpad
+
+lpad:
+  %ll = landingpad { i8*, i32 }
+  cleanup
+  ret i32 0
+
+bb0:
+  br i1 %cond, label %bb1, label %bb2
+
+bb1:
+  %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr1.typed = bitcast i8* %ptr1 to i32*
+  %res1 = load i32, i32* %ptr1.typed
+  br label %exit
+
+bb2:
+  %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr2.typed = bitcast i8* %ptr2 to i32*
+  %res2 = load i32, i32* %ptr2.typed
+  br label %exit
+
+exit:
+  %ptr.typed = phi i32* [ %ptr1.typed, %bb1 ], [ %ptr2.typed, %bb2 ]
+  %res.phi = phi i32 [ %res1, %bb1 ], [ %res2, %bb2 ]
+  store i32 1, i32* %ptr.typed
+  %res.load = load i32, i32* %ptr.typed
+  %res = select i1 %cond2, i32 %res.phi, i32 %res.load
+  ret i32 %res
+}
+
+; Just to make sure we don't generate invalid IR in this case.
+define i32 @test_neg_gep_and_bitcast_phi_no_insert_pt(i1 %cond, i1 %cond2) personality i8 0 {
+; CHECK-LABEL: @test_neg_gep_and_bitcast_phi_no_insert_pt(
+entry:
+  %obj1 = call i8* @get_ptr.i8()
+  invoke void @foo.i8(i8* null) to label %cont unwind label %catch
+
+cont:
+  %obj2.typed = call i32* @get_ptr.i32()
+  %obj2 = bitcast i32* %obj2.typed to i8*
+  invoke void @foo.i8(i8* null) to label %unreachable unwind label %catch
+
+catch:
+  ; There is no insertion point in this basic block!
+  %obj = phi i8* [ %obj1, %entry ], [ %obj2, %cont ]
+  %cs = catchswitch within none [label %doit] unwind to caller
+
+doit:
+  %cl = catchpad within %cs []
+  br i1 %cond, label %bb1, label %bb2
+
+bb1:
+  %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr1.typed = bitcast i8* %ptr1 to i32*
+  %res1 = load i32, i32* %ptr1.typed
+  br label %exit
+
+bb2:
+  %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16
+  %ptr2.typed = bitcast i8* %ptr2 to i32*
+  %res2 = load i32, i32* %ptr2.typed
+  br label %exit
+
+exit:
+  %ptr.typed = phi i32* [ %ptr1.typed, %bb1 ], [ %ptr2.typed, %bb2 ]
+  %res.phi = phi i32 [ %res1, %bb1 ], [ %res2, %bb2 ]
+  store i32 1, i32* %ptr.typed
+  %res.load = load i32, i32* %ptr.typed
+  %res = select i1 %cond2, i32 %res.phi, i32 %res.load
+  ret i32 %res
+
+unreachable:
+  unreachable
+}