Index: llvm/include/llvm/Analysis/ValueTracking.h =================================================================== --- llvm/include/llvm/Analysis/ValueTracking.h +++ llvm/include/llvm/Analysis/ValueTracking.h @@ -243,10 +243,12 @@ /// 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; @@ -254,9 +256,10 @@ 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(Ptr), Offset, DL, - AllowNonInbounds); + AllowNonInbounds, IsInBounds); } /// Returns true if the GEP is based on a pointer to a string (array of Index: llvm/include/llvm/IR/Value.h =================================================================== --- llvm/include/llvm/IR/Value.h +++ llvm/include/llvm/IR/Value.h @@ -571,19 +571,25 @@ /// 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( static_cast(this)->stripAndAccumulateConstantOffsets( - DL, Offset, AllowNonInbounds)); + DL, Offset, AllowNonInbounds, IsInBounds)); } /// This is a wrapper around stripAndAccumulateConstantOffsets with the @@ -591,12 +597,14 @@ 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. Index: llvm/lib/IR/Value.cpp =================================================================== --- llvm/lib/IR/Value.cpp +++ llvm/lib/IR/Value.cpp @@ -538,9 +538,10 @@ return stripPointerCastsAndOffsets(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; @@ -552,6 +553,7 @@ // instruction in an unreachable block, which may be on a cycle. SmallPtrSet Visited; Visited.insert(this); + bool IsFirstStrippedGEP = true; const Value *V = this; do { if (auto *GEP = dyn_cast(V)) { @@ -575,6 +577,12 @@ 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 || Index: llvm/lib/Transforms/InstCombine/InstCombineInternal.h =================================================================== --- llvm/lib/Transforms/InstCombine/InstCombineInternal.h +++ llvm/lib/Transforms/InstCombine/InstCombineInternal.h @@ -846,6 +846,11 @@ /// 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); Index: llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp =================================================================== --- llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp +++ llvm/lib/Transforms/InstCombine/InstCombinePHI.cpp @@ -1122,6 +1122,66 @@ return replaceInstUsesWith(FirstPhi, Undef); } +Instruction *InstCombiner::FoldPHIWithEqualPointers(PHINode &PN) { + auto *PhiTy = dyn_cast(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. + auto &DL = PN.getModule()->getDataLayout(); + auto *FirstValue = PN.getIncomingValue(0); + int64_t Offset; + bool IsInBounds = true; + auto *Base = GetPointerBaseWithConstantOffset( + FirstValue, Offset, DL, /* AllowNonInbounds */ true, &IsInBounds); + + auto *BaseTy = cast(Base->getType()); + if (BaseTy->getAddressSpace() != PhiTy->getAddressSpace()) + return nullptr; + + for (auto &Incoming : PN.incoming_values()) { + if (!isa(Incoming)) + return nullptr; + int64_t CurrentOffset; + bool IsCurrentInBounds = true; + auto *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(Base)) { + if (isa(BaseInst)) { + auto *InsertBB = BaseInst->getParent(); + auto 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); + auto *I8PtrTy = Builder.getInt8PtrTy(PhiTy->getAddressSpace()); + auto *BaseI8Ptr = Builder.CreateBitCast(Base, I8PtrTy); + auto *GEP = IsInBounds ? Builder.CreateConstInBoundsGEP1_64(BaseI8Ptr, Offset) + : Builder.CreateConstGEP1_64(BaseI8Ptr, Offset); + auto *GEPTyped = Builder.CreateBitCast(GEP, PhiTy); + + for (auto &Incoming : PN.incoming_values()) + replaceInstUsesWith(*cast(Incoming), GEPTyped); + return replaceInstUsesWith(PN, GEPTyped); +} + // PHINode simplification // Instruction *InstCombiner::visitPHINode(PHINode &PN) { @@ -1143,6 +1203,9 @@ 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. Index: llvm/test/Transforms/InstCombine/phi-equal-incoming-pointers.ll =================================================================== --- /dev/null +++ llvm/test/Transforms/InstCombine/phi-equal-incoming-pointers.ll @@ -0,0 +1,639 @@ +; RUN: opt -passes=instcombine,verify -S %s | FileCheck %s + +; Now make sure GVN won't undo the transformation: +; RUN: opt -passes=instcombine,gvn -S %s | FileCheck %s + +declare i8* @get_ptr.i8() +declare i32* @get_ptr.i32() +declare i64 @get_i64() +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 +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 16 + %ptr2.typed = bitcast i8* %ptr2 to i32* + %res2 = load i32, i32* %ptr2.typed + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.gep_and_bitcast_arg(i8* %obj, i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep_and_bitcast_arg +entry: + 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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.gep_and_bitcast_phi(i1 %cond, i1 %cond2, i1 %cond3) { +; CHECK-LABEL: test.gep_and_bitcast_phi +entry: + br i1 %cond, label %bb1, label %bb2 + +bb1: + %obj1 = call i8* @get_ptr.i8() + br label %merge + +bb2: + %obj2.typed = call i32* @get_ptr.i32() + %obj2 = bitcast i32* %obj2.typed to i8* + br label %merge + +merge: + %obj = phi i8* [ %obj1, %bb1 ], [ %obj2, %bb2 ] + %another_phi = phi i8* [ %obj1, %bb1 ], [ null, %bb2 ] + call void @foo.i8(i8* %another_phi) + br i1 %cond2, label %bb3, label %bb4 + +bb3: + %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16 + %ptr1.typed = bitcast i8* %ptr1 to i32* + %res1 = load i32, i32* %ptr1.typed + br label %exit + +bb4: + %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, %bb3 ], [ %ptr2.typed, %bb4 ] + %res.phi = phi i32 [ %res1, %bb3 ], [ %res2, %bb4 ] + store i32 1, i32* %ptr.typed + %res.load = load i32, i32* %ptr.typed + %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 +entry: + %obj = call i32* @get_ptr.i32() + br i1 %cond, label %bb1, label %bb2 + +bb1: + %ptr1.typed = getelementptr inbounds i32, i32* %obj, i64 16 + %res1 = load i32, i32* %ptr1.typed + br label %exit + +bb2: + %ptr2.typed = getelementptr inbounds i32, i32* %obj, i64 16 + %res2 = load i32, i32* %ptr2.typed + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.gep_and_bitcast.gep_base_ptr(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep_and_bitcast.gep_base_ptr +entry: + %obj0 = call i8* @get_ptr.i8() + %obj = getelementptr inbounds i8, i8* %obj0, i64 16 + 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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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 +entry: + %obj = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: +; CHECK: bb1: +; CHECK: = getelementptr +; CHECK: = bitcast + %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: +; CHECK: bb2: +; CHECK: = getelementptr +; CHECK: = bitcast + %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: +; CHECK: exit: +; CHECK: phi i32* + %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 +entry: + %obj = call i8* @get_ptr.i8() + %obj2 = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: +; CHECK: bb1: +; CHECK: = getelementptr +; CHECK: = bitcast + %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: +; CHECK: bb2: +; CHECK: = getelementptr +; CHECK: = bitcast + %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: +; CHECK: exit: +; CHECK: phi i32* + %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.gep_and_bitcast.same_bb(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep_and_bitcast.same_bb +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 + br i1 %cond, label %exit, label %bb2 + +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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %ptr.typed = phi i32* [ %ptr1.typed, %entry ], [ %ptr2.typed, %bb2 ] + %res.phi = phi i32 [ %res1, %entry ], [ %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.gep_and_bitcast.same_bb_and_extra_use(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep_and_bitcast.same_bb_and_extra_use +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) + %res1 = load i32, i32* %ptr1.typed + br i1 %cond, label %exit, label %bb2 + +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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %ptr.typed = phi i32* [ %ptr1.typed, %entry ], [ %ptr2.typed, %bb2 ] + %res.phi = phi i32 [ %res1, %entry ], [ %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 i8 @test.gep(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep +entry: + %obj = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: + %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16 + %res1 = load i8, i8* %ptr1 + br label %exit + +bb2: + %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16 + %res2 = load i8, i8* %ptr2 + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i8* + %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 i8 @test.redundant_phi(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.redundant_phi +entry: + %obj = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: + %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16 + %res1 = load i8, i8* %ptr1 + br label %exit + +bb2: + %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16 + %res2 = load i8, i8* %ptr2 + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i8* + %ptr.typed = phi i8* [ %obj, %bb1 ], [ %obj, %bb2 ] + %res.phi = phi i8 [ %res1, %bb1 ], [ %res2, %bb2 ] + call void @foo.i8(i8* %ptr.typed) + 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.extra_uses(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.extra_uses +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 + 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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.extra_uses.non_inbounds(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.extra_uses +; CHECK-NOT: = getelementptr inbounds +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 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: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.extra_uses.multiple_geps(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.extra_uses.multiple_geps +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 + call void @foo.i32(i32* %ptr1.typed) + br label %exit + +bb2: + %ptr2.0 = getelementptr i8, i8* %obj, i64 8 + %ptr2.1 = getelementptr inbounds i8, i8* %ptr2.0, i64 8 + %ptr2.typed = bitcast i8* %ptr2.1 to i32* + %res2 = load i32, i32* %ptr2.typed + call void @foo.i32(i32* %ptr2.typed) + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i32* + %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.extra_uses.inbounds_mismatch(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.neg.extra_uses.inbounds_mismatch +entry: + %obj = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: +; CHECK: bb1: +; CHECK: = getelementptr i8 + %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: +; CHECK: bb2: +; CHECK: = getelementptr inbounds i8 + %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 i8 @test.gep.extra_uses(i1 %cond, i1 %cond2) { +; CHECK-LABEL: test.gep.extra_uses +entry: + %obj = call i8* @get_ptr.i8() + br i1 %cond, label %bb1, label %bb2 + +bb1: + %ptr1 = getelementptr inbounds i8, i8* %obj, i64 16 + %res1 = load i8, i8* %ptr1 + call void @foo.i8(i8* %ptr1) + br label %exit + +bb2: + %ptr2 = getelementptr inbounds i8, i8* %obj, i64 16 + %res2 = load i8, i8* %ptr2 + call void @foo.i8(i8* %ptr2) + br label %exit + +exit: +; CHECK: exit: +; CHECK-NOT: phi i8* + %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 +} + +; 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.gep_and_bitcast_phi.no_insert_pt(i1 %cond, i1 %cond2) personality i8 0 { +; CHECK-LABEL: test.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: + %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 +} + +; Simply check we don't crash in this case. +define i32 @test.gep_and_bitcast.unreachable_bb(i1 %cond) { +; CHECK-LABEL: test.gep_and_bitcast.unreachable_bb +entry: + %obj = call i8* @get_ptr.i8() + br 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 %cond, i32 %res.phi, i32 %res.load + ret i32 %res +} + +; Simply check we don't crash in this case. +define i32 @test.gep_and_bitcast.extra_uses.unreachable_bb(i1 %cond) { +; CHECK-LABEL: test.gep_and_bitcast.extra_uses.unreachable_bb +entry: + %obj = call i8* @get_ptr.i8() + br label %bb2 + +bb1: + %ptr1 = getelementptr inbounds 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 %cond, i32 %res.phi, i32 %res.load + ret i32 %res +}