maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "Reland "[SCEV] Model ptrtoint(SCEVUnknown) cast not as unknown, but as zext/trunc/self of SCEVUnknown"" and it's follow-ups 

While we haven't encountered an earth-shattering problem with this yet,
by now it is pretty evident that trying to model the ptr->int cast
implicitly leads to having to update every single place that assumed
no such cast could be needed. That is of course the wrong approach.

Let's back this out, and re-attempt with some another approach,
possibly one originally suggested by Eli Friedman in
https://bugs.llvm.org/show_bug.cgi?id=46786#c20
which should hopefully spare us this pain and more.

This reverts commits 1fb6104293,
7324616660,
aaafe350bb,
e92a8e0c74.

I've kept&improved the tests though.
This commit is contained in:
Roman Lebedev 2020-10-14 14:56:58 +03:00
parent 2c4226f8ac
commit 7ee6c40247
No known key found for this signature in database
GPG Key ID: 083C3EBB4A1689E0
11 changed files with 296 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
llvm/lib/Analysis/ScalarEvolution.cpp
View File

@ -3505,15 +3505,15 @@ const SCEV *ScalarEvolution::getUMinExpr(SmallVectorImpl<const SCEV *> &Ops) {
} }
const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) { const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
// We can bypass creating a target-independent
// constant expression and then folding it back into a ConstantInt.
// This is just a compile-time optimization.
if (isa<ScalableVectorType>(AllocTy)) { if (isa<ScalableVectorType>(AllocTy)) {
Constant *NullPtr = Constant::getNullValue(AllocTy->getPointerTo()); Constant *NullPtr = Constant::getNullValue(AllocTy->getPointerTo());
Constant *One = ConstantInt::get(IntTy, 1); Constant *One = ConstantInt::get(IntTy, 1);
Constant *GEP = ConstantExpr::getGetElementPtr(AllocTy, NullPtr, One); Constant *GEP = ConstantExpr::getGetElementPtr(AllocTy, NullPtr, One);
return getUnknown(ConstantExpr::getPtrToInt(GEP, IntTy)); return getSCEV(ConstantExpr::getPtrToInt(GEP, IntTy));
} }
// We can bypass creating a target-independent
// constant expression and then folding it back into a ConstantInt.
// This is just a compile-time optimization.
return getConstant(IntTy, getDataLayout().getTypeAllocSize(AllocTy)); return getConstant(IntTy, getDataLayout().getTypeAllocSize(AllocTy));
} }
@ -6301,36 +6301,6 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
return getSCEV(U->getOperand(0)); return getSCEV(U->getOperand(0));
break; break;
case Instruction::PtrToInt: {
// It's tempting to handle inttoptr and ptrtoint as no-ops,
// however this can lead to pointer expressions which cannot safely be
// expanded to GEPs because ScalarEvolution doesn't respect
// the GEP aliasing rules when simplifying integer expressions.
//
// However, given
// %x = ???
// %y = ptrtoint %x
// %z = ptrtoint %x
// it is safe to say that %y and %z are the same thing.
//
// So instead of modelling the cast itself as unknown,
// since the casts are transparent within SCEV,
// we can at least model the casts original value as unknow instead.
// BUT, there's caveat. If we simply model %x as unknown, unrelated uses
// of %x will also see it as unknown, which is obviously bad.
// So we can only do this iff %x would be modelled as unknown anyways.
auto *OpSCEV = getSCEV(U->getOperand(0));
if (isa<SCEVUnknown>(OpSCEV))
return getTruncateOrZeroExtend(OpSCEV, U->getType());
// If we can model the operand, however, we must fallback to modelling
// the whole cast as unknown instead.
LLVM_FALLTHROUGH;
}
case Instruction::IntToPtr:
// We can't do this for inttoptr at all, however.
return getUnknown(V);
case Instruction::SDiv: case Instruction::SDiv:
// If both operands are non-negative, this is just an udiv. // If both operands are non-negative, this is just an udiv.
if (isKnownNonNegative(getSCEV(U->getOperand(0))) && if (isKnownNonNegative(getSCEV(U->getOperand(0))) &&
@ -6345,6 +6315,11 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
return getURemExpr(getSCEV(U->getOperand(0)), getSCEV(U->getOperand(1))); return getURemExpr(getSCEV(U->getOperand(0)), getSCEV(U->getOperand(1)));
break; break;
// It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
// lead to pointer expressions which cannot safely be expanded to GEPs,
// because ScalarEvolution doesn't respect the GEP aliasing rules when
// simplifying integer expressions.
case Instruction::GetElementPtr: case Instruction::GetElementPtr:
return createNodeForGEP(cast<GEPOperator>(U)); return createNodeForGEP(cast<GEPOperator>(U));
@ -7976,7 +7951,7 @@ const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
/// will return Constants for objects which aren't represented by a /// will return Constants for objects which aren't represented by a
/// SCEVConstant, because SCEVConstant is restricted to ConstantInt. /// SCEVConstant, because SCEVConstant is restricted to ConstantInt.
/// Returns NULL if the SCEV isn't representable as a Constant. /// Returns NULL if the SCEV isn't representable as a Constant.
static Constant *BuildConstantFromSCEV(const SCEV *V, const DataLayout &DL) { static Constant *BuildConstantFromSCEV(const SCEV *V) {
switch (static_cast<SCEVTypes>(V->getSCEVType())) { switch (static_cast<SCEVTypes>(V->getSCEVType())) {
case scCouldNotCompute: case scCouldNotCompute:
case scAddRecExpr: case scAddRecExpr:
@ -7987,47 +7962,32 @@ static Constant *BuildConstantFromSCEV(const SCEV *V, const DataLayout &DL) {
return dyn_cast<Constant>(cast<SCEVUnknown>(V)->getValue()); return dyn_cast<Constant>(cast<SCEVUnknown>(V)->getValue());
case scSignExtend: { case scSignExtend: {
const SCEVSignExtendExpr *SS = cast<SCEVSignExtendExpr>(V); const SCEVSignExtendExpr *SS = cast<SCEVSignExtendExpr>(V);
if (Constant *CastOp = BuildConstantFromSCEV(SS->getOperand(), DL)) { if (Constant *CastOp = BuildConstantFromSCEV(SS->getOperand()))
if (CastOp->getType()->isPointerTy())
// Note that for SExt, unlike ZExt/Trunc, it is incorrect to just call
// ConstantExpr::getPtrToInt() and be done with it, because PtrToInt
// will zero-extend (otherwise ZExt case wouldn't work). So we need to
// first cast to the same-bitwidth integer, and then SExt it.
CastOp = ConstantExpr::getPtrToInt(
CastOp, DL.getIntPtrType(CastOp->getType()));
// And now, we can actually perform the sign-extension.
return ConstantExpr::getSExt(CastOp, SS->getType()); return ConstantExpr::getSExt(CastOp, SS->getType());
}
break; break;
} }
case scZeroExtend: { case scZeroExtend: {
const SCEVZeroExtendExpr *SZ = cast<SCEVZeroExtendExpr>(V); const SCEVZeroExtendExpr *SZ = cast<SCEVZeroExtendExpr>(V);
if (Constant *CastOp = BuildConstantFromSCEV(SZ->getOperand(), DL)) { if (Constant *CastOp = BuildConstantFromSCEV(SZ->getOperand()))
if (!CastOp->getType()->isPointerTy()) return ConstantExpr::getZExt(CastOp, SZ->getType());
return ConstantExpr::getZExt(CastOp, SZ->getType());
return ConstantExpr::getPtrToInt(CastOp, SZ->getType());
}
break; break;
} }
case scTruncate: { case scTruncate: {
const SCEVTruncateExpr *ST = cast<SCEVTruncateExpr>(V); const SCEVTruncateExpr *ST = cast<SCEVTruncateExpr>(V);
if (Constant *CastOp = BuildConstantFromSCEV(ST->getOperand(), DL)) { if (Constant *CastOp = BuildConstantFromSCEV(ST->getOperand()))
if (!CastOp->getType()->isPointerTy()) return ConstantExpr::getTrunc(CastOp, ST->getType());
return ConstantExpr::getTrunc(CastOp, ST->getType());
return ConstantExpr::getPtrToInt(CastOp, ST->getType());
}
break; break;
} }
case scAddExpr: { case scAddExpr: {
const SCEVAddExpr *SA = cast<SCEVAddExpr>(V); const SCEVAddExpr *SA = cast<SCEVAddExpr>(V);
if (Constant *C = BuildConstantFromSCEV(SA->getOperand(0), DL)) { if (Constant *C = BuildConstantFromSCEV(SA->getOperand(0))) {
if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) { if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
unsigned AS = PTy->getAddressSpace(); unsigned AS = PTy->getAddressSpace();
Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS); Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
C = ConstantExpr::getBitCast(C, DestPtrTy); C = ConstantExpr::getBitCast(C, DestPtrTy);
} }
for (unsigned i = 1, e = SA->getNumOperands(); i != e; ++i) { for (unsigned i = 1, e = SA->getNumOperands(); i != e; ++i) {
Constant *C2 = BuildConstantFromSCEV(SA->getOperand(i), DL); Constant *C2 = BuildConstantFromSCEV(SA->getOperand(i));
if (!C2) return nullptr; if (!C2) return nullptr;
// First pointer! // First pointer!
@ -8059,11 +8019,11 @@ static Constant *BuildConstantFromSCEV(const SCEV *V, const DataLayout &DL) {
} }
case scMulExpr: { case scMulExpr: {
const SCEVMulExpr *SM = cast<SCEVMulExpr>(V); const SCEVMulExpr *SM = cast<SCEVMulExpr>(V);
if (Constant *C = BuildConstantFromSCEV(SM->getOperand(0), DL)) { if (Constant *C = BuildConstantFromSCEV(SM->getOperand(0))) {
// Don't bother with pointers at all. // Don't bother with pointers at all.
if (C->getType()->isPointerTy()) return nullptr; if (C->getType()->isPointerTy()) return nullptr;
for (unsigned i = 1, e = SM->getNumOperands(); i != e; ++i) { for (unsigned i = 1, e = SM->getNumOperands(); i != e; ++i) {
Constant *C2 = BuildConstantFromSCEV(SM->getOperand(i), DL); Constant *C2 = BuildConstantFromSCEV(SM->getOperand(i));
if (!C2 || C2->getType()->isPointerTy()) return nullptr; if (!C2 || C2->getType()->isPointerTy()) return nullptr;
C = ConstantExpr::getMul(C, C2); C = ConstantExpr::getMul(C, C2);
} }
@ -8073,8 +8033,8 @@ static Constant *BuildConstantFromSCEV(const SCEV *V, const DataLayout &DL) {
} }
case scUDivExpr: { case scUDivExpr: {
const SCEVUDivExpr *SU = cast<SCEVUDivExpr>(V); const SCEVUDivExpr *SU = cast<SCEVUDivExpr>(V);
if (Constant *LHS = BuildConstantFromSCEV(SU->getLHS(), DL)) if (Constant *LHS = BuildConstantFromSCEV(SU->getLHS()))
if (Constant *RHS = BuildConstantFromSCEV(SU->getRHS(), DL)) if (Constant *RHS = BuildConstantFromSCEV(SU->getRHS()))
if (LHS->getType() == RHS->getType()) if (LHS->getType() == RHS->getType())
return ConstantExpr::getUDiv(LHS, RHS); return ConstantExpr::getUDiv(LHS, RHS);
break; break;
@ -8179,7 +8139,7 @@ const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
const SCEV *OpV = getSCEVAtScope(OrigV, L); const SCEV *OpV = getSCEVAtScope(OrigV, L);
MadeImprovement |= OrigV != OpV; MadeImprovement |= OrigV != OpV;
Constant *C = BuildConstantFromSCEV(OpV, getDataLayout()); Constant *C = BuildConstantFromSCEV(OpV);
if (!C) return V; if (!C) return V;
if (C->getType() != Op->getType()) if (C->getType() != Op->getType())
C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false, C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,

2
llvm/lib/Transforms/Utils/SimplifyIndVar.cpp
View File

@ -427,7 +427,7 @@ static bool willNotOverflow(ScalarEvolution *SE, Instruction::BinaryOps BinOp,
: &ScalarEvolution::getZeroExtendExpr; : &ScalarEvolution::getZeroExtendExpr;
// Check ext(LHS op RHS) == ext(LHS) op ext(RHS) // Check ext(LHS op RHS) == ext(LHS) op ext(RHS)
auto *NarrowTy = cast<IntegerType>(SE->getEffectiveSCEVType(LHS->getType())); auto *NarrowTy = cast<IntegerType>(LHS->getType());
auto *WideTy = auto *WideTy =
IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2); IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2);

4
llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
View File

@ -33,9 +33,9 @@ define i32 @d(i32 %base) {
; CHECK-NEXT: %1 = load i32*, i32** @c, align 8 ; CHECK-NEXT: %1 = load i32*, i32** @c, align 8
; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint i32* %1 to i64 ; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint i32* %1 to i64
; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: --> %sub.ptr.lhs.cast U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint ([1 x i32]* @b to i64) ; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint ([1 x i32]* @b to i64)
; CHECK-NEXT: --> ((-1 * @b) + %1) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: --> ((-1 * ptrtoint ([1 x i32]* @b to i64)) + %sub.ptr.lhs.cast) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4 ; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4
; CHECK-NEXT: --> %sub.ptr.div U: full-set S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: --> %sub.ptr.div U: full-set S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], [1 x i8]* %arrayidx, i64 0, i64 %sub.ptr.div ; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], [1 x i8]* %arrayidx, i64 0, i64 %sub.ptr.div

4
llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
View File

@ -170,14 +170,14 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) {
%int5 = add i32 %int0, 5 %int5 = add i32 %int0, 5
%int.zext = zext i32 %int5 to i64 %int.zext = zext i32 %int5 to i64
; CHECK: %int.zext = zext i32 %int5 to i64 ; CHECK: %int.zext = zext i32 %int5 to i64
; CHECK-NEXT: --> (1 + (zext i32 (4 + (trunc [16 x i8]* @z_addr to i32)) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297) ; CHECK-NEXT: --> (1 + (zext i32 (4 + %int0) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
%ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8* %ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8*
%int0_na = ptrtoint i8* %ptr_noalign to i32 %int0_na = ptrtoint i8* %ptr_noalign to i32
%int5_na = add i32 %int0_na, 5 %int5_na = add i32 %int0_na, 5
%int.zext_na = zext i32 %int5_na to i64 %int.zext_na = zext i32 %int5_na to i64
; CHECK: %int.zext_na = zext i32 %int5_na to i64 ; CHECK: %int.zext_na = zext i32 %int5_na to i64
; CHECK-NEXT: --> (zext i32 (5 + (trunc [16 x i8]* @z_addr_noalign to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; CHECK-NEXT: --> (zext i32 (5 + %int0_na) to i64) U: [0,4294967296) S: [0,4294967296)
%tmp = load i32, i32* %tmp_addr %tmp = load i32, i32* %tmp_addr
%mul = and i32 %tmp, -4 %mul = and i32 %tmp, -4

286
llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
View File

@ -13,31 +13,48 @@
declare void @use16(i16) declare void @use16(i16)
define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) { define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; X64-LABEL: 'trunc_ptr_to_i64' ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i64'
; X64-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR64_IDX64-NEXT: Classifying expressions for: @trunc_ptr_to_i64
; X64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; X64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; X64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
; X64-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; X64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; X64-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; X64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; X64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; X64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
; X64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; X64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64 ; PTR64_IDX64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; X64-NEXT: Loop %bb11: Unpredictable backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; X64-NEXT: Loop %bb11: Unpredictable max backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable max backedge-taken count.
; X64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'trunc_ptr_to_i64'
; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i64
; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR64_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
; ;
; PTR16_IDX16-LABEL: 'trunc_ptr_to_i64' ; PTR16_IDX16-LABEL: 'trunc_ptr_to_i64'
; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i64 ; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i64
; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
@ -52,9 +69,9 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64) ; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
@ -88,9 +105,9 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
; PTR64_IDX64-NEXT: --> ((sext i32 (trunc [0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc [0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR64_IDX64-NEXT: --> ((sext i32 (trunc [0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc [0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
@ -105,9 +122,9 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) ; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
; PTR64_IDX32-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR64_IDX32-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
@ -122,9 +139,9 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
@ -139,9 +156,9 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32) ; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
@ -170,31 +187,48 @@ bb17: ; preds = %bb11
br label %bb11 br label %bb11
} }
define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) { define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; X64-LABEL: 'trunc_ptr_to_i128' ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i128'
; X64-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR64_IDX64-NEXT: Classifying expressions for: @trunc_ptr_to_i128
; X64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; X64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; X64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
; X64-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; X64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR64_IDX64-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; X64-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
; X64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR64_IDX64-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; X64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; X64-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2
; X64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; X64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128 ; PTR64_IDX64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; X64-NEXT: Loop %bb11: Unpredictable backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; X64-NEXT: Loop %bb11: Unpredictable max backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable max backedge-taken count.
; X64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count. ; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'trunc_ptr_to_i128'
; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i128
; PTR64_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR64_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR64_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR64_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR64_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR64_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
; PTR64_IDX32-NEXT: --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
; ;
; PTR16_IDX16-LABEL: 'trunc_ptr_to_i128' ; PTR16_IDX16-LABEL: 'trunc_ptr_to_i128'
; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i128 ; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i128
; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX16-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX16-NEXT: --> (@global + %arg) U: full-set S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX16-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2
@ -209,9 +243,9 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX32-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable } ; PTR16_IDX32-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128) ; PTR16_IDX32-NEXT: %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32* ; PTR16_IDX32-NEXT: %tmp13 = bitcast i8* %tmp12 to i32*
; PTR16_IDX32-NEXT: --> (@global + %arg) U: [0,131071) S: full-set Exits: (@global + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX32-NEXT: --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4 ; PTR16_IDX32-NEXT: %tmp14 = load i32, i32* %tmp13, align 4
; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant } ; PTR16_IDX32-NEXT: --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2 ; PTR16_IDX32-NEXT: %tmp18 = add i32 %tmp, 2
@ -241,49 +275,27 @@ bb17: ; preds = %bb11
} }
define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; PTR64_IDX64-LABEL: 'zext_ptr_to_i32' ; X64-LABEL: 'zext_ptr_to_i32'
; PTR64_IDX64-NEXT: Classifying expressions for: @zext_ptr_to_i32 ; X64-NEXT: Classifying expressions for: @zext_ptr_to_i32
; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) ; X64-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
; PTR64_IDX64-NEXT: --> ((-1 * (trunc [0 x i8]* @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc [0 x i8]* @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; X64-NEXT: --> ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant }
; PTR64_IDX64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; X64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR64_IDX64-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant } ; X64-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR64_IDX64-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 ; X64-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable backedge-taken count. ; X64-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable max backedge-taken count. ; X64-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count. ; X64-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
; ;
; PTR64_IDX32-LABEL: 'zext_ptr_to_i32' ; X32-LABEL: 'zext_ptr_to_i32'
; PTR64_IDX32-NEXT: Classifying expressions for: @zext_ptr_to_i32 ; X32-NEXT: Classifying expressions for: @zext_ptr_to_i32
; PTR64_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32) ; X32-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
; PTR64_IDX32-NEXT: --> ((-1 * @global) + %arg) U: full-set S: full-set Exits: ((-1 * @global) + %arg) LoopDispositions: { %bb7: Invariant } ; X32-NEXT: --> ((-1 * ptrtoint ([0 x i8]* @global to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint ([0 x i8]* @global to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
; PTR64_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; X32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR64_IDX32-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant } ; X32-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR64_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 ; X32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count. ; X32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable max backedge-taken count. ; X32-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count. ; X32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'zext_ptr_to_i32'
; PTR16_IDX16-NEXT: Classifying expressions for: @zext_ptr_to_i32
; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
; PTR16_IDX16-NEXT: --> ((-1 * (zext [0 x i8]* @global to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext [0 x i8]* @global to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR16_IDX16-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'zext_ptr_to_i32'
; PTR16_IDX32-NEXT: Classifying expressions for: @zext_ptr_to_i32
; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, ptrtoint ([0 x i8]* @global to i32)
; PTR16_IDX32-NEXT: --> ((-1 * @global) + %arg) U: full-set S: full-set Exits: ((-1 * @global) + %arg) LoopDispositions: { %bb7: Invariant }
; PTR16_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR16_IDX32-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR16_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
; ;
bb: bb:
br label %bb7 br label %bb7
@ -300,38 +312,16 @@ bb10: ; preds = %bb7
} }
define void @sext_to_i32(i32 %arg, i32 %arg6) { define void @sext_to_i32(i32 %arg, i32 %arg6) {
; X64-LABEL: 'sext_to_i32' ; ALL-LABEL: 'sext_to_i32'
; X64-NEXT: Classifying expressions for: @sext_to_i32 ; ALL-NEXT: Classifying expressions for: @sext_to_i32
; X64-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32) ; ALL-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
; X64-NEXT: --> ((-1 * (sext i16 (trunc [0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc [0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant } ; ALL-NEXT: --> ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint ([0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
; X64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; ALL-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; X64-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant } ; ALL-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; X64-NEXT: Determining loop execution counts for: @sext_to_i32 ; ALL-NEXT: Determining loop execution counts for: @sext_to_i32
; X64-NEXT: Loop %bb7: Unpredictable backedge-taken count. ; ALL-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; X64-NEXT: Loop %bb7: Unpredictable max backedge-taken count. ; ALL-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; X64-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count. ; ALL-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'sext_to_i32'
; PTR16_IDX16-NEXT: Classifying expressions for: @sext_to_i32
; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
; PTR16_IDX16-NEXT: --> ((-1 * (sext [0 x i8]* @global to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext [0 x i8]* @global to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'sext_to_i32'
; PTR16_IDX32-NEXT: Classifying expressions for: @sext_to_i32
; PTR16_IDX32-NEXT: %tmp = sub i32 %arg, sext (i16 ptrtoint ([0 x i8]* @global to i16) to i32)
; PTR16_IDX32-NEXT: --> ((-1 * (sext i16 (trunc [0 x i8]* @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc [0 x i8]* @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
; PTR16_IDX32-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1
; PTR16_IDX32-NEXT: --> %tmp9 U: [0,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
; PTR16_IDX32-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
; ;
bb: bb:
br label %bb7 br label %bb7
@ -346,3 +336,55 @@ bb7: ; preds = %bb7, %bb
bb10: ; preds = %bb7 bb10: ; preds = %bb7
ret void ret void
} }
define i64 @sext_like_noop(i32 %n) {
; X64-LABEL: 'sext_like_noop'
; X64-NEXT: Classifying expressions for: @sext_like_noop
; X64-NEXT: %ii = sext i32 %i to i64
; X64-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
; X64-NEXT: %div = sdiv i64 55555, %ii
; X64-NEXT: --> %div U: full-set S: full-set --> sdiv (i64 55555, i64 sext (i32 add (i32 ptrtoint (i64 (i32)* @sext_like_noop to i32), i32 -1) to i64)) U: full-set S: full-set
; X64-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
; X64-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable }
; X64-NEXT: %inc = add nuw i32 %i, 1
; X64-NEXT: --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (i64 (i32)* @sext_like_noop to i32) LoopDispositions: { %for.body: Computable }
; X64-NEXT: Determining loop execution counts for: @sext_like_noop
; X64-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))
; X64-NEXT: Loop %for.body: max backedge-taken count is -1
; X64-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))
; X64-NEXT: Predicates:
; X64: Loop %for.body: Trip multiple is 1
;
; X32-LABEL: 'sext_like_noop'
; X32-NEXT: Classifying expressions for: @sext_like_noop
; X32-NEXT: %ii = sext i32 %i to i64
; X32-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32)) to i64) U: [-1,65535) S: [-65537,65535)
; X32-NEXT: %div = sdiv i64 55555, %ii
; X32-NEXT: --> %div U: full-set S: full-set --> sdiv (i64 55555, i64 sext (i32 add (i32 ptrtoint (i64 (i32)* @sext_like_noop to i32), i32 -1) to i64)) U: full-set S: full-set
; X32-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
; X32-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw> LoopDispositions: { %for.body: Computable }
; X32-NEXT: %inc = add nuw i32 %i, 1
; X32-NEXT: --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (i64 (i32)* @sext_like_noop to i32) LoopDispositions: { %for.body: Computable }
; X32-NEXT: Determining loop execution counts for: @sext_like_noop
; X32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
; X32-NEXT: Loop %for.body: max backedge-taken count is -1
; X32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
; X32-NEXT: Predicates:
; X32: Loop %for.body: Trip multiple is 1
;
entry:
%cmp6 = icmp sgt i32 %n, 1
br label %for.body
for.cond.cleanup:
%ii = sext i32 %i to i64
%div = sdiv i64 55555, %ii
ret i64 %div
for.body:
%i = phi i32 [ %inc, %for.body ], [ 1, %entry ]
%inc = add nuw i32 %i, 1
%exitcond = icmp eq i32 %inc, ptrtoint (i64 (i32)* @sext_like_noop to i32)
br i1 %exitcond, label %for.cond.cleanup, label %for.body
}
declare void @f(i64)

60
llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
View File

@ -16,25 +16,25 @@ define void @ptrtoint(i8* %in, i64* %out0, i32* %out1, i16* %out2, i128* %out3)
; X64-LABEL: 'ptrtoint' ; X64-LABEL: 'ptrtoint'
; X64-NEXT: Classifying expressions for: @ptrtoint ; X64-NEXT: Classifying expressions for: @ptrtoint
; X64-NEXT: %p0 = ptrtoint i8* %in to i64 ; X64-NEXT: %p0 = ptrtoint i8* %in to i64
; X64-NEXT: --> %in U: full-set S: full-set ; X64-NEXT: --> %p0 U: full-set S: full-set
; X64-NEXT: %p1 = ptrtoint i8* %in to i32 ; X64-NEXT: %p1 = ptrtoint i8* %in to i32
; X64-NEXT: --> (trunc i8* %in to i32) U: full-set S: full-set ; X64-NEXT: --> %p1 U: full-set S: full-set
; X64-NEXT: %p2 = ptrtoint i8* %in to i16 ; X64-NEXT: %p2 = ptrtoint i8* %in to i16
; X64-NEXT: --> (trunc i8* %in to i16) U: full-set S: full-set ; X64-NEXT: --> %p2 U: full-set S: full-set
; X64-NEXT: %p3 = ptrtoint i8* %in to i128 ; X64-NEXT: %p3 = ptrtoint i8* %in to i128
; X64-NEXT: --> (zext i8* %in to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: --> %p3 U: [0,18446744073709551616) S: [-18446744073709551616,18446744073709551616)
; X64-NEXT: Determining loop execution counts for: @ptrtoint ; X64-NEXT: Determining loop execution counts for: @ptrtoint
; ;
; X32-LABEL: 'ptrtoint' ; X32-LABEL: 'ptrtoint'
; X32-NEXT: Classifying expressions for: @ptrtoint ; X32-NEXT: Classifying expressions for: @ptrtoint
; X32-NEXT: %p0 = ptrtoint i8* %in to i64 ; X32-NEXT: %p0 = ptrtoint i8* %in to i64
; X32-NEXT: --> (zext i8* %in to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p0 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: %p1 = ptrtoint i8* %in to i32 ; X32-NEXT: %p1 = ptrtoint i8* %in to i32
; X32-NEXT: --> %in U: full-set S: full-set ; X32-NEXT: --> %p1 U: full-set S: full-set
; X32-NEXT: %p2 = ptrtoint i8* %in to i16 ; X32-NEXT: %p2 = ptrtoint i8* %in to i16
; X32-NEXT: --> (trunc i8* %in to i16) U: full-set S: full-set ; X32-NEXT: --> %p2 U: full-set S: full-set
; X32-NEXT: %p3 = ptrtoint i8* %in to i128 ; X32-NEXT: %p3 = ptrtoint i8* %in to i128
; X32-NEXT: --> (zext i8* %in to i128) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p3 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint ; X32-NEXT: Determining loop execution counts for: @ptrtoint
; ;
%p0 = ptrtoint i8* %in to i64 %p0 = ptrtoint i8* %in to i64
@ -53,25 +53,25 @@ define void @ptrtoint_as1(i8 addrspace(1)* %in, i64* %out0, i32* %out1, i16* %ou
; X64-LABEL: 'ptrtoint_as1' ; X64-LABEL: 'ptrtoint_as1'
; X64-NEXT: Classifying expressions for: @ptrtoint_as1 ; X64-NEXT: Classifying expressions for: @ptrtoint_as1
; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64 ; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64
; X64-NEXT: --> %in U: full-set S: full-set ; X64-NEXT: --> %p0 U: full-set S: full-set
; X64-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32 ; X64-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32
; X64-NEXT: --> (trunc i8 addrspace(1)* %in to i32) U: full-set S: full-set ; X64-NEXT: --> %p1 U: full-set S: full-set
; X64-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16 ; X64-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16
; X64-NEXT: --> (trunc i8 addrspace(1)* %in to i16) U: full-set S: full-set ; X64-NEXT: --> %p2 U: full-set S: full-set
; X64-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128 ; X64-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128
; X64-NEXT: --> (zext i8 addrspace(1)* %in to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: --> %p3 U: [0,18446744073709551616) S: [-18446744073709551616,18446744073709551616)
; X64-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; X64-NEXT: Determining loop execution counts for: @ptrtoint_as1
; ;
; X32-LABEL: 'ptrtoint_as1' ; X32-LABEL: 'ptrtoint_as1'
; X32-NEXT: Classifying expressions for: @ptrtoint_as1 ; X32-NEXT: Classifying expressions for: @ptrtoint_as1
; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64 ; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in to i64
; X32-NEXT: --> (zext i8 addrspace(1)* %in to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p0 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32 ; X32-NEXT: %p1 = ptrtoint i8 addrspace(1)* %in to i32
; X32-NEXT: --> %in U: full-set S: full-set ; X32-NEXT: --> %p1 U: full-set S: full-set
; X32-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16 ; X32-NEXT: %p2 = ptrtoint i8 addrspace(1)* %in to i16
; X32-NEXT: --> (trunc i8 addrspace(1)* %in to i16) U: full-set S: full-set ; X32-NEXT: --> %p2 U: full-set S: full-set
; X32-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128 ; X32-NEXT: %p3 = ptrtoint i8 addrspace(1)* %in to i128
; X32-NEXT: --> (zext i8 addrspace(1)* %in to i128) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p3 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; X32-NEXT: Determining loop execution counts for: @ptrtoint_as1
; ;
%p0 = ptrtoint i8 addrspace(1)* %in to i64 %p0 = ptrtoint i8 addrspace(1)* %in to i64
@ -92,7 +92,7 @@ define void @ptrtoint_of_bitcast(i8* %in, i64* %out0) {
; X64-NEXT: %in_casted = bitcast i8* %in to float* ; X64-NEXT: %in_casted = bitcast i8* %in to float*
; X64-NEXT: --> %in U: full-set S: full-set ; X64-NEXT: --> %in U: full-set S: full-set
; X64-NEXT: %p0 = ptrtoint float* %in_casted to i64 ; X64-NEXT: %p0 = ptrtoint float* %in_casted to i64
; X64-NEXT: --> %in U: full-set S: full-set ; X64-NEXT: --> %p0 U: full-set S: full-set
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast
; ;
; X32-LABEL: 'ptrtoint_of_bitcast' ; X32-LABEL: 'ptrtoint_of_bitcast'
@ -100,7 +100,7 @@ define void @ptrtoint_of_bitcast(i8* %in, i64* %out0) {
; X32-NEXT: %in_casted = bitcast i8* %in to float* ; X32-NEXT: %in_casted = bitcast i8* %in to float*
; X32-NEXT: --> %in U: full-set S: full-set ; X32-NEXT: --> %in U: full-set S: full-set
; X32-NEXT: %p0 = ptrtoint float* %in_casted to i64 ; X32-NEXT: %p0 = ptrtoint float* %in_casted to i64
; X32-NEXT: --> (zext i8* %in to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p0 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast
; ;
%in_casted = bitcast i8* %in to float* %in_casted = bitcast i8* %in to float*
@ -116,7 +116,7 @@ define void @ptrtoint_of_addrspacecast(i8* %in, i64* %out0) {
; X64-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)* ; X64-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: --> %in_casted U: full-set S: full-set
; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64 ; X64-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64
; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: --> %p0 U: full-set S: full-set
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast
; ;
; X32-LABEL: 'ptrtoint_of_addrspacecast' ; X32-LABEL: 'ptrtoint_of_addrspacecast'
@ -124,7 +124,7 @@ define void @ptrtoint_of_addrspacecast(i8* %in, i64* %out0) {
; X32-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)* ; X32-NEXT: %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
; X32-NEXT: --> %in_casted U: full-set S: full-set ; X32-NEXT: --> %in_casted U: full-set S: full-set
; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64 ; X32-NEXT: %p0 = ptrtoint i8 addrspace(1)* %in_casted to i64
; X32-NEXT: --> (zext i8 addrspace(1)* %in_casted to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p0 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast
; ;
%in_casted = addrspacecast i8* %in to i8 addrspace(1)* %in_casted = addrspacecast i8* %in to i8 addrspace(1)*
@ -140,7 +140,7 @@ define void @ptrtoint_of_inttoptr(i64 %in, i64* %out0) {
; X64-NEXT: %in_casted = inttoptr i64 %in to i8* ; X64-NEXT: %in_casted = inttoptr i64 %in to i8*
; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: --> %in_casted U: full-set S: full-set
; X64-NEXT: %p0 = ptrtoint i8* %in_casted to i64 ; X64-NEXT: %p0 = ptrtoint i8* %in_casted to i64
; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: --> %p0 U: full-set S: full-set
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr
; ;
; X32-LABEL: 'ptrtoint_of_inttoptr' ; X32-LABEL: 'ptrtoint_of_inttoptr'
@ -148,7 +148,7 @@ define void @ptrtoint_of_inttoptr(i64 %in, i64* %out0) {
; X32-NEXT: %in_casted = inttoptr i64 %in to i8* ; X32-NEXT: %in_casted = inttoptr i64 %in to i8*
; X32-NEXT: --> %in_casted U: full-set S: full-set ; X32-NEXT: --> %in_casted U: full-set S: full-set
; X32-NEXT: %p0 = ptrtoint i8* %in_casted to i64 ; X32-NEXT: %p0 = ptrtoint i8* %in_casted to i64
; X32-NEXT: --> (zext i8* %in_casted to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: --> %p0 U: [0,4294967296) S: [-4294967296,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr
; ;
%in_casted = inttoptr i64 %in to i8* %in_casted = inttoptr i64 %in to i8*
@ -197,17 +197,11 @@ define void @ptrtoint_of_nullptr(i64* %out0) {
; A constant inttoptr argument of an ptrtoint is still bad. ; A constant inttoptr argument of an ptrtoint is still bad.
define void @ptrtoint_of_constantexpr_inttoptr(i64* %out0) { define void @ptrtoint_of_constantexpr_inttoptr(i64* %out0) {
; X64-LABEL: 'ptrtoint_of_constantexpr_inttoptr' ; ALL-LABEL: 'ptrtoint_of_constantexpr_inttoptr'
; X64-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr ; ALL-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr
; X64-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64 ; ALL-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
; X64-NEXT: --> inttoptr (i64 42 to i8*) U: [42,43) S: [-64,64) ; ALL-NEXT: --> %p0 U: [42,43) S: [-64,64)
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr ; ALL-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr
;
; X32-LABEL: 'ptrtoint_of_constantexpr_inttoptr'
; X32-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr
; X32-NEXT: %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
; X32-NEXT: --> (zext i8* inttoptr (i64 42 to i8*) to i64) U: [42,43) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr
; ;
%p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64 %p0 = ptrtoint i8* inttoptr (i64 42 to i8*) to i64
store i64 %p0, i64* %out0 store i64 %p0, i64* %out0

4
llvm/test/CodeGen/ARM/lsr-undef-in-binop.ll
View File

@ -186,9 +186,7 @@ define linkonce_odr i32 @vector_insert(%"class.std::__1::vector.182"*, [1 x i32]
br i1 %114, label %124, label %115 br i1 %114, label %124, label %115
; CHECK-LABEL: .preheader: ; CHECK-LABEL: .preheader:
; CHECK-NEXT: [[NEG_NEW:%[0-9]+]] = sub i32 0, [[NEW_CAST]] ; CHECK-NEXT: sub i32 [[OLD_CAST]], [[NEW_CAST]]
; CHECK-NEXT: getelementptr i8, i8* %97, i32 [[NEG_NEW]]
; <label>:115: ; preds = %111, %115 ; <label>:115: ; preds = %111, %115
%116 = phi i8* [ %118, %115 ], [ %97, %111 ] %116 = phi i8* [ %118, %115 ], [ %97, %111 ]
%117 = phi i8* [ %119, %115 ], [ %11, %111 ] %117 = phi i8* [ %119, %115 ], [ %11, %111 ]

4
llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
View File

@ -268,9 +268,9 @@ define i8* @SyFgets(i8* %line, i64 %length, i64 %fid) {
; CHECK-NEXT: LBB0_48: ## %if.then1477 ; CHECK-NEXT: LBB0_48: ## %if.then1477
; CHECK-NEXT: movl $1, %edx ; CHECK-NEXT: movl $1, %edx
; CHECK-NEXT: callq _write ; CHECK-NEXT: callq _write
; CHECK-NEXT: subq %rbx, %r14
; CHECK-NEXT: movq _syHistory@{{.*}}(%rip), %rax ; CHECK-NEXT: movq _syHistory@{{.*}}(%rip), %rax
; CHECK-NEXT: subq %rbx, %rax ; CHECK-NEXT: leaq 8189(%r14,%rax), %rax
; CHECK-NEXT: leaq 8189(%rax,%r14), %rax
; CHECK-NEXT: .p2align 4, 0x90 ; CHECK-NEXT: .p2align 4, 0x90
; CHECK-NEXT: LBB0_49: ## %for.body1723 ; CHECK-NEXT: LBB0_49: ## %for.body1723
; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1 ; CHECK-NEXT: ## =>This Inner Loop Header: Depth=1

16
llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
View File

@ -166,23 +166,21 @@ define i8 @testnullptrint(i8* %buf, i8* %end) nounwind {
; PTR64-NEXT: ret i8 [[RET]] ; PTR64-NEXT: ret i8 [[RET]]
; ;
; PTR32-LABEL: @testnullptrint( ; PTR32-LABEL: @testnullptrint(
; PTR32-NEXT: [[BUF1:%.*]] = ptrtoint i8* [[BUF:%.*]] to i32
; PTR32-NEXT: br label [[LOOPGUARD:%.*]] ; PTR32-NEXT: br label [[LOOPGUARD:%.*]]
; PTR32: loopguard: ; PTR32: loopguard:
; PTR32-NEXT: [[BI:%.*]] = ptrtoint i8* [[BUF]] to i32 ; PTR32-NEXT: [[BI:%.*]] = ptrtoint i8* [[BUF:%.*]] to i32
; PTR32-NEXT: [[EI:%.*]] = ptrtoint i8* [[END:%.*]] to i32 ; PTR32-NEXT: [[EI:%.*]] = ptrtoint i8* [[END:%.*]] to i32
; PTR32-NEXT: [[CNT:%.*]] = sub i32 [[EI]], [[BI]] ; PTR32-NEXT: [[CNT:%.*]] = sub i32 [[EI]], [[BI]]
; PTR32-NEXT: [[CNT1:%.*]] = inttoptr i32 [[CNT]] to i8*
; PTR32-NEXT: [[GUARD:%.*]] = icmp ult i32 0, [[CNT]] ; PTR32-NEXT: [[GUARD:%.*]] = icmp ult i32 0, [[CNT]]
; PTR32-NEXT: br i1 [[GUARD]], label [[PREHEADER:%.*]], label [[EXIT:%.*]] ; PTR32-NEXT: br i1 [[GUARD]], label [[PREHEADER:%.*]], label [[EXIT:%.*]]
; PTR32: preheader: ; PTR32: preheader:
; PTR32-NEXT: [[TMP1:%.*]] = sub i32 0, [[BUF1]]
; PTR32-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, i8* [[END]], i32 [[TMP1]]
; PTR32-NEXT: br label [[LOOP:%.*]] ; PTR32-NEXT: br label [[LOOP:%.*]]
; PTR32: loop: ; PTR32: loop:
; PTR32-NEXT: [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ] ; PTR32-NEXT: [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
; PTR32-NEXT: [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1 ; PTR32-NEXT: [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
; PTR32-NEXT: [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1 ; PTR32-NEXT: [[SNEXT:%.*]] = load i8, i8* [[GEP]]
; PTR32-NEXT: [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[SCEVGEP]] ; PTR32-NEXT: [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[CNT1]]
; PTR32-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] ; PTR32-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
; PTR32: exit.loopexit: ; PTR32: exit.loopexit:
; PTR32-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ] ; PTR32-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ]
@ -258,10 +256,10 @@ define i8 @testptrint(i8* %buf, i8* %end) nounwind {
; PTR32-NEXT: [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ] ; PTR32-NEXT: [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
; PTR32-NEXT: [[IV:%.*]] = phi i32 [ [[BI]], [[PREHEADER]] ], [ [[IVNEXT:%.*]], [[LOOP]] ] ; PTR32-NEXT: [[IV:%.*]] = phi i32 [ [[BI]], [[PREHEADER]] ], [ [[IVNEXT:%.*]], [[LOOP]] ]
; PTR32-NEXT: [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1 ; PTR32-NEXT: [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
; PTR32-NEXT: [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1 ; PTR32-NEXT: [[SNEXT:%.*]] = load i8, i8* [[GEP]]
; PTR32-NEXT: [[IVNEXT]] = add nuw i32 [[IV]], 1 ; PTR32-NEXT: [[IVNEXT]] = add nuw i32 [[IV]], 1
; PTR32-NEXT: [[CMP:%.*]] = icmp ult i32 [[IVNEXT]], [[CNT]] ; PTR32-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[IVNEXT]], [[CNT]]
; PTR32-NEXT: br i1 [[CMP]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] ; PTR32-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
; PTR32: exit.loopexit: ; PTR32: exit.loopexit:
; PTR32-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ] ; PTR32-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ]
; PTR32-NEXT: br label [[EXIT]] ; PTR32-NEXT: br label [[EXIT]]

66
llvm/unittests/Analysis/IVDescriptorsTest.cpp
View File

@ -98,3 +98,69 @@ for.end:
EXPECT_EQ(IndDesc.getUnsafeAlgebraInst(), nullptr); EXPECT_EQ(IndDesc.getUnsafeAlgebraInst(), nullptr);
}); });
} }
// Depending on how SCEV deals with ptrtoint cast, the step of a phi could be
// a pointer, and InductionDescriptor used to fail with an assertion.
// So just check that it doesn't assert.
TEST(IVDescriptorsTest, LoopWithPtrToInt) {
// Parse the module.
LLVMContext Context;
std::unique_ptr<Module> M = parseIR(Context, R"(
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv6m-arm-none-eabi"
declare void @widget()
declare void @wobble(i32)
define void @barney(i8* %arg, i8* %arg18, i32 %arg19) {
bb:
%tmp = ptrtoint i8* %arg to i32
%tmp20 = ptrtoint i8* %arg18 to i32
%tmp21 = or i32 %tmp20, %tmp
%tmp22 = and i32 %tmp21, 3
%tmp23 = icmp eq i32 %tmp22, 0
br i1 %tmp23, label %bb24, label %bb25
bb24:
tail call void @widget()
br label %bb34
bb25:
%tmp26 = sub i32 %tmp, %tmp20
%tmp27 = icmp ult i32 %tmp26, %arg19
br i1 %tmp27, label %bb28, label %bb34
bb28:
br label %bb29
bb29:
%tmp30 = phi i32 [ %tmp31, %bb29 ], [ %arg19, %bb28 ]
tail call void @wobble(i32 %tmp26)
%tmp31 = sub i32 %tmp30, %tmp26
%tmp32 = icmp ugt i32 %tmp31, %tmp26
br i1 %tmp32, label %bb29, label %bb33
bb33:
br label %bb34
bb34:
ret void
})");
runWithLoopInfoAndSE(
*M, "barney", [&](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
Function::iterator FI = F.begin();
// First basic block is entry - skip it.
BasicBlock *Header = &*(++(++(++(++FI))));
assert(Header->getName() == "bb29");
Loop *L = LI.getLoopFor(Header);
EXPECT_NE(L, nullptr);
PHINode *Inst_i = dyn_cast<PHINode>(&Header->front());
assert(Inst_i->getName() == "tmp30");
InductionDescriptor IndDesc;
bool IsInductionPHI =
InductionDescriptor::isInductionPHI(Inst_i, L, &SE, IndDesc);
EXPECT_TRUE(IsInductionPHI);
});
}

3
polly/test/Isl/CodeGen/scev_looking_through_bitcasts.ll
View File

@ -32,5 +32,6 @@ bitmap_element_allocate.exit:
; CHECK: polly.stmt.cond.end73.i: ; CHECK: polly.stmt.cond.end73.i:
; CHECK-NEXT: store %structty* undef, %structty** %b.s2a ; CHECK-NEXT: %0 = bitcast %structty** %b.s2a to i8**
; CHECK-NEXT: store i8* undef, i8** %0
; CHECK-NEXT: br label %polly.exiting ; CHECK-NEXT: br label %polly.exiting