From 60c5ae542c1d56923e6141802c2af7eb04ef2c04 Mon Sep 17 00:00:00 2001 From: Xinliang David Li Date: Tue, 10 Oct 2017 05:07:54 +0000 Subject: [PATCH] Renable r314928 Eliminate inttype phi with inttoptr/ptrtoint. This version fixed a bug in finding the matching phi -- the order of the incoming blocks may be different (triggered in self build on Windows). A new test case is added. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@315272 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/InstCombine/InstCombineInternal.h | 4 + lib/Transforms/InstCombine/InstCombinePHI.cpp | 235 +++++++++++++++++++++++ test/Transforms/InstCombine/intptr1.ll | 193 +++++++++++++++++++ test/Transforms/InstCombine/intptr2.ll | 39 ++++ test/Transforms/InstCombine/intptr3.ll | 39 ++++ test/Transforms/InstCombine/intptr4.ll | 53 +++++ test/Transforms/InstCombine/intptr5.ll | 56 ++++++ test/Transforms/InstCombine/intptr6.ll | 90 +++++++++ test/Transforms/InstCombine/intptr7.ll | 58 ++++++ 9 files changed, 767 insertions(+) create mode 100644 test/Transforms/InstCombine/intptr1.ll create mode 100644 test/Transforms/InstCombine/intptr2.ll create mode 100644 test/Transforms/InstCombine/intptr3.ll create mode 100644 test/Transforms/InstCombine/intptr4.ll create mode 100644 test/Transforms/InstCombine/intptr5.ll create mode 100644 test/Transforms/InstCombine/intptr6.ll create mode 100644 test/Transforms/InstCombine/intptr7.ll diff --git a/lib/Transforms/InstCombine/InstCombineInternal.h b/lib/Transforms/InstCombine/InstCombineInternal.h index 46f86114718..f1404facaf3 100644 --- a/lib/Transforms/InstCombine/InstCombineInternal.h +++ b/lib/Transforms/InstCombine/InstCombineInternal.h @@ -670,6 +670,10 @@ private: Instruction *FoldPHIArgGEPIntoPHI(PHINode &PN); 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); /// Helper function for FoldPHIArgXIntoPHI() to set debug location for the /// folded operation. diff --git a/lib/Transforms/InstCombine/InstCombinePHI.cpp b/lib/Transforms/InstCombine/InstCombinePHI.cpp index 2f31ede32ac..45d448075d6 100644 --- a/lib/Transforms/InstCombine/InstCombinePHI.cpp +++ b/lib/Transforms/InstCombine/InstCombinePHI.cpp @@ -40,6 +40,238 @@ void InstCombiner::PHIArgMergedDebugLoc(Instruction *Inst, PHINode &PN) { } } +// Replace Integer typed PHI PN if the PHI's value is used as a pointer value. +// If there is an existing pointer typed PHI that produces the same value as PN, +// replace PN and the IntToPtr operation with it. Otherwise, synthesize a new +// PHI node: +// +// Case-1: +// bb1: +// int_init = PtrToInt(ptr_init) +// br label %bb2 +// bb2: +// int_val = PHI([int_init, %bb1], [int_val_inc, %bb2] +// ptr_val = PHI([ptr_init, %bb1], [ptr_val_inc, %bb2] +// ptr_val2 = IntToPtr(int_val) +// ... +// use(ptr_val2) +// ptr_val_inc = ... +// inc_val_inc = PtrToInt(ptr_val_inc) +// +// ==> +// bb1: +// br label %bb2 +// bb2: +// ptr_val = PHI([ptr_init, %bb1], [ptr_val_inc, %bb2] +// ... +// use(ptr_val) +// ptr_val_inc = ... +// +// Case-2: +// bb1: +// int_ptr = BitCast(ptr_ptr) +// int_init = Load(int_ptr) +// br label %bb2 +// bb2: +// int_val = PHI([int_init, %bb1], [int_val_inc, %bb2] +// ptr_val2 = IntToPtr(int_val) +// ... +// use(ptr_val2) +// ptr_val_inc = ... +// inc_val_inc = PtrToInt(ptr_val_inc) +// ==> +// bb1: +// ptr_init = Load(ptr_ptr) +// br label %bb2 +// bb2: +// ptr_val = PHI([ptr_init, %bb1], [ptr_val_inc, %bb2] +// ... +// use(ptr_val) +// ptr_val_inc = ... +// ... +// +Instruction *InstCombiner::FoldIntegerTypedPHI(PHINode &PN) { + if (!PN.getType()->isIntegerTy()) + return nullptr; + if (!PN.hasOneUse()) + return nullptr; + + auto *IntToPtr = dyn_cast(PN.user_back()); + if (!IntToPtr) + return nullptr; + + // Check if the pointer is actually used as pointer: + auto HasPointerUse = [](Instruction *IIP) { + for (User *U : IIP->users()) { + Value *Ptr = nullptr; + if (LoadInst *LoadI = dyn_cast(U)) { + Ptr = LoadI->getPointerOperand(); + } else if (StoreInst *SI = dyn_cast(U)) { + Ptr = SI->getPointerOperand(); + } else if (GetElementPtrInst *GI = dyn_cast(U)) { + Ptr = GI->getPointerOperand(); + } + + if (Ptr && Ptr == IIP) + return true; + } + return false; + }; + + if (!HasPointerUse(IntToPtr)) + return nullptr; + + if (DL.getPointerSizeInBits(IntToPtr->getAddressSpace()) != + DL.getTypeSizeInBits(IntToPtr->getOperand(0)->getType())) + return nullptr; + + SmallVector AvailablePtrVals; + for (unsigned i = 0; i != PN.getNumIncomingValues(); ++i) { + Value *Arg = PN.getIncomingValue(i); + + // First look backward: + if (auto *PI = dyn_cast(Arg)) { + AvailablePtrVals.emplace_back(PI->getOperand(0)); + continue; + } + + // Next look forward: + Value *ArgIntToPtr = nullptr; + for (User *U : Arg->users()) { + if (isa(U) && U->getType() == IntToPtr->getType() && + (DT.dominates(cast(U), PN.getIncomingBlock(i)) || + cast(U)->getParent() == PN.getIncomingBlock(i))) { + ArgIntToPtr = U; + break; + } + } + + if (ArgIntToPtr) { + AvailablePtrVals.emplace_back(ArgIntToPtr); + continue; + } + + // If Arg is defined by a PHI, allow it. This will also create + // more opportunities iteratively. + if (isa(Arg)) { + AvailablePtrVals.emplace_back(Arg); + continue; + } + + // For a single use integer load: + auto *LoadI = dyn_cast(Arg); + if (!LoadI) + return nullptr; + + if (!LoadI->hasOneUse()) + return nullptr; + + // Push the integer typed Load instruction into the available + // value set, and fix it up later when the pointer typed PHI + // is synthesized. + AvailablePtrVals.emplace_back(LoadI); + } + + // Now search for a matching PHI + auto *BB = PN.getParent(); + assert(AvailablePtrVals.size() == PN.getNumIncomingValues() && + "Not enough available ptr typed incoming values"); + PHINode *MatchingPtrPHI = nullptr; + for (auto II = BB->begin(), EI = BasicBlock::iterator(BB->getFirstNonPHI()); + II != EI; II++) { + PHINode *PtrPHI = dyn_cast(II); + if (!PtrPHI || PtrPHI == &PN || PtrPHI->getType() != IntToPtr->getType()) + continue; + MatchingPtrPHI = PtrPHI; + for (unsigned i = 0; i != PtrPHI->getNumIncomingValues(); ++i) { + if (AvailablePtrVals[i] != + PtrPHI->getIncomingValueForBlock(PN.getIncomingBlock(i))) { + MatchingPtrPHI = nullptr; + break; + } + } + + if (MatchingPtrPHI) + break; + } + + if (MatchingPtrPHI) { + assert(MatchingPtrPHI->getType() == IntToPtr->getType() && + "Phi's Type does not match with IntToPtr"); + // The PtrToCast + IntToPtr will be simplified later + return CastInst::CreateBitOrPointerCast(MatchingPtrPHI, + IntToPtr->getOperand(0)->getType()); + } + + // If it requires a conversion for every PHI operand, do not do it. + if (std::all_of(AvailablePtrVals.begin(), AvailablePtrVals.end(), + [&](Value *V) { + return (V->getType() != IntToPtr->getType()) || + isa(V); + })) + return nullptr; + + // If any of the operand that requires casting is a terminator + // instruction, do not do it. + if (std::any_of(AvailablePtrVals.begin(), AvailablePtrVals.end(), + [&](Value *V) { + return (V->getType() != IntToPtr->getType()) && + isa(V); + })) + return nullptr; + + PHINode *NewPtrPHI = PHINode::Create( + IntToPtr->getType(), PN.getNumIncomingValues(), PN.getName() + ".ptr"); + + InsertNewInstBefore(NewPtrPHI, PN); + SmallDenseMap Casts; + for (unsigned i = 0; i != PN.getNumIncomingValues(); ++i) { + auto *IncomingBB = PN.getIncomingBlock(i); + auto *IncomingVal = AvailablePtrVals[i]; + + if (IncomingVal->getType() == IntToPtr->getType()) { + NewPtrPHI->addIncoming(IncomingVal, IncomingBB); + continue; + } + +#ifndef NDEBUG + LoadInst *LoadI = dyn_cast(IncomingVal); + assert((isa(IncomingVal) || + IncomingVal->getType()->isPointerTy() || + (LoadI && LoadI->hasOneUse())) && + "Can not replace LoadInst with multiple uses"); +#endif + // Need to insert a BitCast. + // For an integer Load instruction with a single use, the load + IntToPtr + // cast will be simplified into a pointer load: + // %v = load i64, i64* %a.ip, align 8 + // %v.cast = inttoptr i64 %v to float ** + // ==> + // %v.ptrp = bitcast i64 * %a.ip to float ** + // %v.cast = load float *, float ** %v.ptrp, align 8 + Instruction *&CI = Casts[IncomingVal]; + if (!CI) { + CI = CastInst::CreateBitOrPointerCast(IncomingVal, IntToPtr->getType(), + IncomingVal->getName() + ".ptr"); + if (auto *IncomingI = dyn_cast(IncomingVal)) { + BasicBlock::iterator InsertPos(IncomingI); + InsertPos++; + if (isa(IncomingI)) + InsertPos = IncomingI->getParent()->getFirstInsertionPt(); + InsertNewInstBefore(CI, *InsertPos); + } else { + auto *InsertBB = &IncomingBB->getParent()->getEntryBlock(); + InsertNewInstBefore(CI, *InsertBB->getFirstInsertionPt()); + } + } + NewPtrPHI->addIncoming(CI, IncomingBB); + } + + // The PtrToCast + IntToPtr will be simplified later + return CastInst::CreateBitOrPointerCast(NewPtrPHI, + IntToPtr->getOperand(0)->getType()); +} + /// If we have something like phi [add (a,b), add(a,c)] and if a/b/c and the /// adds all have a single use, turn this into a phi and a single binop. Instruction *InstCombiner::FoldPHIArgBinOpIntoPHI(PHINode &PN) { @@ -903,6 +1135,9 @@ Instruction *InstCombiner::visitPHINode(PHINode &PN) { // 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(PN.user_back()); if (PHINode *PU = dyn_cast(PHIUser)) { SmallPtrSet PotentiallyDeadPHIs; diff --git a/test/Transforms/InstCombine/intptr1.ll b/test/Transforms/InstCombine/intptr1.ll new file mode 100644 index 00000000000..3d8f915eb43 --- /dev/null +++ b/test/Transforms/InstCombine/intptr1.ll @@ -0,0 +1,193 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @test1(float* %a, float* readnone %a_end, i64* %b.i64) { +; CHECK-LABEL: @test1 +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b = load i64, i64* %b.i64, align 8 +; CHECK: load float*, float** + br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %for.body ], [ %b, %for.body.preheader ] + +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK: %b.addr.02.ptr = phi float* [ %add, %for.body ], +; CHECK-NOT: %b.addr.02 = phi i64 + + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK-NOT: inttoptr i64 + %tmp1 = load float, float* %tmp, align 4 +; CHECK: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %tmp, i64 1 + %add.int = ptrtoint float* %add to i64 +; CHECK %add = getelementptr +; CHECK-NOT: ptrtoint float* + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + +define void @test1_neg(float* %a, float* readnone %a_end, i64* %b.i64) { +; CHECK-LABEL: @test1_neg +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b = load i64, i64* %b.i64, align 8 + br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %bb ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %bb ], [ %b, %for.body.preheader ] + +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %bb ], [ %a, %for.body.preheader ] +; CHECK: %b.addr.02 = phi i64 + + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK: inttoptr i64 + %ptrcmp = icmp ult float* %tmp, %a_end + br i1 %ptrcmp, label %for.end, label %bb + +bb: + %tmp1 = load float, float* %a, align 4 + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %a, i64 1 + %add.int = ptrtoint float* %add to i64 +; CHECK: ptrtoint float* + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + +define void @test2(float* %a, float* readnone %a_end, float** %b.float) { +; CHECK-LABEL: @test2 +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b.i64 = bitcast float** %b.float to i64* + %b = load i64, i64* %b.i64, align 8 +; CHECK: load float*, float** + br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %for.body ], [ %b, %for.body.preheader ] + +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK: %b.addr.02.ptr = phi float* [ %add, %for.body ], +; CHECK-NOT: %b.addr.02 = phi i64 + + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK-NOT: inttoptr i64 + %tmp1 = load float, float* %tmp, align 4 +; CHECK: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %tmp, i64 1 +; CHECK: %add = + %add.int = ptrtoint float* %add to i64 +; CHECK-NOT: ptrtoint float* + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + +define void @test3(float* %a, float* readnone %a_end, i8** %b.i8p) { +; CHECK-LABEL: @test3 +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b.i64 = bitcast i8** %b.i8p to i64* + %b = load i64, i64* %b.i64, align 8 +; CHECK: load float*, float** + br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %for.body ], [ %b, %for.body.preheader ] + +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK: %b.addr.02.ptr = phi float* [ %add, %for.body ], +; CHECK-NOT: %b.addr.02 = phi i64 + + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK-NOT: inttoptr i64 + %tmp1 = load float, float* %tmp, align 4 +; CHECK: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %tmp, i64 1 +; CHECK: %add = getelementptr + %add.int = ptrtoint float* %add to i64 +; CHECK-NOT: ptrtoint float* + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + +define void @test4(float* %a, float* readnone %a_end, float** %b.float) { +entry: +; CHECK-LABEL: @test4 + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b.f = load float*, float** %b.float, align 8 + %b = ptrtoint float* %b.f to i64 +; CHECK: load float*, float** +; CHECK-NOT: ptrtoint float* + br label %for.body +; CHECK: br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %for.body ], [ %b, %for.body.preheader ] + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK-NOT: inttoptr i64 + %tmp1 = load float, float* %tmp, align 4 +; CHECK: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %tmp, i64 1 +; CHECK: %add = + %add.int = ptrtoint float* %add to i64 +; CHECK-NOT: ptrtoint float* + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} diff --git a/test/Transforms/InstCombine/intptr2.ll b/test/Transforms/InstCombine/intptr2.ll new file mode 100644 index 00000000000..b105a722749 --- /dev/null +++ b/test/Transforms/InstCombine/intptr2.ll @@ -0,0 +1,39 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @test1(float* %a, float* readnone %a_end, i32* %b.i) { +; CHECK-LABEL: @test1 +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b = ptrtoint i32 * %b.i to i64 +; CHECK: bitcast +; CHECK-NOT: ptrtoint + br label %for.body +; CHECK: br label %for.body + +for.body: ; preds = %for.body, %for.body.preheader + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.02 = phi i64 [ %add.int, %for.body ], [ %b, %for.body.preheader ] +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK-NOT: phi i64 + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK-NOT: inttoptr + %tmp1 = load float, float* %tmp, align 4 +; CHECK: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %add = getelementptr inbounds float, float* %tmp, i64 1 +; CHECK: %add = + %add.int = ptrtoint float* %add to i64 +; CHECK-NOT: ptrtoint + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + diff --git a/test/Transforms/InstCombine/intptr3.ll b/test/Transforms/InstCombine/intptr3.ll new file mode 100644 index 00000000000..72b81ce350f --- /dev/null +++ b/test/Transforms/InstCombine/intptr3.ll @@ -0,0 +1,39 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @test(float* %a, float* readnone %a_end, i64 %b) unnamed_addr { +entry: + %cmp1 = icmp ult float* %a, %a_end + br i1 %cmp1, label %for.body.preheader, label %for.end + +for.body.preheader: ; preds = %entry + %b.float = inttoptr i64 %b to float* + br label %for.body + +for.body: ; preds = %for.body.preheader, %for.body + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ] + %b.addr.i64 = phi i64 [ %b.addr.i64.inc, %for.body ], [ %b, %for.body.preheader ] +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK-NEXT: %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ] +; CHECK-NEXT: = load float + %l = load float, float* %b.addr.float, align 4 + %mul.i = fmul float %l, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 +; CHECK: store float + %b.addr.float.2 = inttoptr i64 %b.addr.i64 to float* +; CHECK-NOT: inttoptr + %b.addr.float.inc = getelementptr inbounds float, float* %b.addr.float.2, i64 1 +; CHECK: %b.addr.float.inc = + %b.addr.i64.inc = ptrtoint float* %b.addr.float.inc to i64 +; CHECK-NOT: ptrtoint + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + + diff --git a/test/Transforms/InstCombine/intptr4.ll b/test/Transforms/InstCombine/intptr4.ll new file mode 100644 index 00000000000..663090f06e8 --- /dev/null +++ b/test/Transforms/InstCombine/intptr4.ll @@ -0,0 +1,53 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @test(float* %a, float* readnone %a_end, i64 %b, float* %bf) unnamed_addr { +entry: + %cmp1 = icmp ult float* %a, %a_end + %b.float = inttoptr i64 %b to float* + br i1 %cmp1, label %bb1, label %bb2 + +bb1: + br label %for.body.preheader +bb2: + %bfi = ptrtoint float* %bf to i64 + br label %for.body.preheader + +for.body.preheader: ; preds = %entry + %b.phi = phi i64 [%b, %bb1], [%bfi, %bb2] + br label %for.body +; CHECK: for.body.preheader +; CHECK: %b.phi = phi +; CHECK: %b.phi.ptr = +; CHECK: br label %for.body + +for.body: ; preds = %for.body.preheader, %for.body +; CHECK: for.body + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] + %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ] + %b.addr.i64 = phi i64 [ %b.addr.i64.inc, %for.body ], [ %b.phi, %for.body.preheader ] +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK-NEXT: %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ] +; CHECK-NEXT: %b.addr.i64.ptr = phi +; CHECK-NOT: = phi i64 +; CHECK: = load + %l = load float, float* %b.addr.float, align 4 + %mul.i = fmul float %l, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %b.addr.float.2 = inttoptr i64 %b.addr.i64 to float* + %b.addr.float.inc = getelementptr inbounds float, float* %b.addr.float.2, i64 1 +; CHECK: store float %mul.i +; CHECK-NOT: inttoptr +; CHECK: %b.addr.float.inc = + %b.addr.i64.inc = ptrtoint float* %b.addr.float.inc to i64 +; CHECK-NOT: ptrtoint + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + + diff --git a/test/Transforms/InstCombine/intptr5.ll b/test/Transforms/InstCombine/intptr5.ll new file mode 100644 index 00000000000..c5e728f1441 --- /dev/null +++ b/test/Transforms/InstCombine/intptr5.ll @@ -0,0 +1,56 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @test(float* %a, float* readnone %a_end, i64 %b, float* %bf) unnamed_addr { +entry: + %cmp1 = icmp ult float* %a, %a_end + %b.float = inttoptr i64 %b to float* + br i1 %cmp1, label %bb1, label %bb2 + +bb1: + br label %for.body.preheader +bb2: + %bfi = ptrtoint float* %bf to i64 + br label %for.body.preheader + +for.body.preheader: ; preds = %entry + %b.phi = phi i64 [%b, %bb1], [%bfi, %bb2] + switch i64 %b, label %for.body [ + i64 1, label %for.body + ] +; CHECK: for.body.preheader +; CHECK: %b.phi = phi +; CHECK: %b.phi.ptr = +; CHECK-NOT: %b.phi.ptr2 = +; CHECK: switch + +for.body: ; preds = %for.body.preheader, %for.body +; CHECK: for.body + %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ], [%a, %for.body.preheader] + %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ], [%b.float, %for.body.preheader] + %b.addr.i64 = phi i64 [ %b.addr.i64.inc, %for.body ], [ %b.phi, %for.body.preheader ], [ %b.phi, %for.body.preheader] +; CHECK: %a.addr.03 = phi float* [ %incdec.ptr, %for.body ], [ %a, %for.body.preheader ] +; CHECK-NEXT: %b.addr.float = phi float* [ %b.addr.float.inc, %for.body ], [ %b.float, %for.body.preheader ] +; CHECK-NEXT: %b.addr.i64.ptr = phi +; CHECK-NOT: = %b.addr.i64 +; CHECK: = load + %l = load float, float* %b.addr.float, align 4 + %mul.i = fmul float %l, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + %b.addr.float.2 = inttoptr i64 %b.addr.i64 to float* + %b.addr.float.inc = getelementptr inbounds float, float* %b.addr.float.2, i64 1 +; CHECK: store float %mul.i +; CHECK-NOT: inttoptr +; CHECK: %b.addr.float.inc = + %b.addr.i64.inc = ptrtoint float* %b.addr.float.inc to i64 +; CHECK-NOT: ptrtoint + %incdec.ptr = getelementptr inbounds float, float* %a.addr.03, i64 1 +; CHECK: %incdec.ptr = + %cmp = icmp ult float* %incdec.ptr, %a_end + br i1 %cmp, label %for.body, label %for.end + +for.end: ; preds = %for.body, %entry + ret void +} + + + diff --git a/test/Transforms/InstCombine/intptr6.ll b/test/Transforms/InstCombine/intptr6.ll new file mode 100644 index 00000000000..9c29145ab16 --- /dev/null +++ b/test/Transforms/InstCombine/intptr6.ll @@ -0,0 +1,90 @@ +; RUN: opt < %s -instcombine -S +; no crash + +%A = type { %B } +%B = type { %C *} +%C = type <{ i32 (...)**, i32, [4 x i8] }> + +$foo = comdat any + +@bar= external thread_local global %A, align 8 + +declare i32 @__gxx_personality_v0(...) + +; Function Attrs: inlinehint sanitize_memory uwtable +define void @foo() local_unnamed_addr #0 comdat align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { +entry: + %0 = load %C*, %C** getelementptr inbounds (%A, %A* @bar, i64 0, i32 0, i32 0), align 8 + %1 = ptrtoint %C* %0 to i64 + %count.i.i.i23 = getelementptr inbounds %C, %C* %0, i64 0, i32 1 + store i32 0, i32* %count.i.i.i23, align 8 + %2 = invoke i8* @_Znwm() #3 + to label %invoke.cont unwind label %lpad + +invoke.cont: ; preds = %entry + %call.i25 = invoke i8* @_Znwm() #3 + to label %call.i.noexc unwind label %lpad4 + +call.i.noexc: ; preds = %invoke.cont + invoke void @lazy() + to label %invoke.cont5 unwind label %lpad.i + +lpad.i: ; preds = %call.i.noexc + %3 = landingpad { i8*, i32 } + cleanup + br label %ehcleanup + +invoke.cont5: ; preds = %call.i.noexc + %4 = ptrtoint i8* %call.i25 to i64 + invoke void @scale() + to label %invoke.cont16 unwind label %lpad15 + +invoke.cont16: ; preds = %invoke.cont5 + ret void + +lpad: ; preds = %entry + %5 = landingpad { i8*, i32 } + cleanup + unreachable + +lpad4: ; preds = %invoke.cont + %6 = landingpad { i8*, i32 } + cleanup + unreachable + +ehcleanup: ; preds = %lpad.i + br label %ehcleanup21 + +lpad15: ; preds = %invoke.cont5 + %7 = landingpad { i8*, i32 } + cleanup + br label %ehcleanup21 + +ehcleanup21: ; preds = %lpad15, %ehcleanup + %actual_other.sroa.0.0 = phi i64 [ %1, %ehcleanup ], [ %4, %lpad15 ] + %8 = inttoptr i64 %actual_other.sroa.0.0 to %C* + br i1 undef, label %_ZN4CGAL6HandleD2Ev.exit, label %land.lhs.true.i + +land.lhs.true.i: ; preds = %ehcleanup21 + %count.i = getelementptr inbounds %C, %C* %8, i64 0, i32 1 + %9 = load i32, i32* %count.i, align 8 + unreachable + +_ZN4CGAL6HandleD2Ev.exit: ; preds = %ehcleanup21 + resume { i8*, i32 } undef +} + +; Function Attrs: nobuiltin +declare noalias nonnull i8* @_Znwm() local_unnamed_addr #1 + +; Function Attrs: sanitize_memory uwtable +declare void @scale() local_unnamed_addr #2 align 2 + +; Function Attrs: sanitize_memory uwtable +declare void @lazy() unnamed_addr #2 align 2 + +attributes #0 = { inlinehint sanitize_memory uwtable} +attributes #1 = { nobuiltin } +attributes #2 = { sanitize_memory uwtable } +attributes #3 = { builtin } + diff --git a/test/Transforms/InstCombine/intptr7.ll b/test/Transforms/InstCombine/intptr7.ll new file mode 100644 index 00000000000..1e83bacd65b --- /dev/null +++ b/test/Transforms/InstCombine/intptr7.ll @@ -0,0 +1,58 @@ +; RUN: opt < %s -instcombine -S | FileCheck %s + +define void @matching_phi(i64 %a, float* %b, i1 %cond) { +; CHECK-LABEL: @matching_phi +entry: + %cmp1 = icmp eq i1 %cond, 0 + %add.int = add i64 %a, 1 + %add = inttoptr i64 %add.int to float * + + %addb = getelementptr inbounds float, float* %b, i64 2 + %addb.int = ptrtoint float* %addb to i64 + br i1 %cmp1, label %A, label %B +A: + br label %C +B: + store float 1.0e+01, float* %add, align 4 + br label %C + +C: + %a.addr.03 = phi float* [ %addb, %A ], [ %add, %B ] + %b.addr.02 = phi i64 [ %addb.int, %A ], [ %add.int, %B ] + %tmp = inttoptr i64 %b.addr.02 to float* +; CHECK: %a.addr.03 = phi +; CHECK-NEXT: = load + %tmp1 = load float, float* %tmp, align 4 + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + ret void +} + +define void @no_matching_phi(i64 %a, float* %b, i1 %cond) { +; CHECK-LABEL: @no_matching_phi +entry: + %cmp1 = icmp eq i1 %cond, 0 + %add.int = add i64 %a, 1 + %add = inttoptr i64 %add.int to float * + + %addb = getelementptr inbounds float, float* %b, i64 2 + %addb.int = ptrtoint float* %addb to i64 + br i1 %cmp1, label %A, label %B +A: + br label %C +B: + store float 1.0e+01, float* %add, align 4 + br label %C + +C: + %a.addr.03 = phi float* [ %addb, %A ], [ %add, %B ] + %b.addr.02 = phi i64 [ %addb.int, %B ], [ %add.int, %A ] + %tmp = inttoptr i64 %b.addr.02 to float* + %tmp1 = load float, float* %tmp, align 4 +; CHECK: %a.addr.03 = phi +; CHECK-NEXT: %b.addr.02.ptr = phi +; CHECK-NEXT: = load + %mul.i = fmul float %tmp1, 4.200000e+01 + store float %mul.i, float* %a.addr.03, align 4 + ret void +} -- 2.11.0