comparison llvm/unittests/Analysis/ScalarEvolutionTest.cpp @ 236:c4bab56944e8 llvm-original

LLVM 16
author kono
date Wed, 09 Nov 2022 17:45:10 +0900
parents 5f17cb93ff66
children 1f2b6ac9f198
comparison
equal deleted inserted replaced
232:70dce7da266c 236:c4bab56944e8
940 // exit: 940 // exit:
941 ReturnInst::Create(Context, nullptr, ExitBB); 941 ReturnInst::Create(Context, nullptr, ExitBB);
942 942
943 // Make sure that SCEV doesn't blow up 943 // Make sure that SCEV doesn't blow up
944 ScalarEvolution SE = buildSE(*F); 944 ScalarEvolution SE = buildSE(*F);
945 SCEVUnionPredicate Preds;
946 const SCEV *Expr = SE.getSCEV(Phi); 945 const SCEV *Expr = SE.getSCEV(Phi);
947 EXPECT_NE(nullptr, Expr); 946 EXPECT_NE(nullptr, Expr);
948 EXPECT_TRUE(isa<SCEVUnknown>(Expr)); 947 EXPECT_TRUE(isa<SCEVUnknown>(Expr));
949 auto Result = SE.createAddRecFromPHIWithCasts(cast<SCEVUnknown>(Expr)); 948 auto Result = SE.createAddRecFromPHIWithCasts(cast<SCEVUnknown>(Expr));
950 } 949 }
998 // exit: 997 // exit:
999 ReturnInst::Create(Context, nullptr, ExitBB); 998 ReturnInst::Create(Context, nullptr, ExitBB);
1000 999
1001 // Make sure that SCEV doesn't blow up 1000 // Make sure that SCEV doesn't blow up
1002 ScalarEvolution SE = buildSE(*F); 1001 ScalarEvolution SE = buildSE(*F);
1003 SCEVUnionPredicate Preds;
1004 const SCEV *Expr = SE.getSCEV(Phi); 1002 const SCEV *Expr = SE.getSCEV(Phi);
1005 EXPECT_NE(nullptr, Expr); 1003 EXPECT_NE(nullptr, Expr);
1006 EXPECT_TRUE(isa<SCEVUnknown>(Expr)); 1004 EXPECT_TRUE(isa<SCEVUnknown>(Expr));
1007 auto Result = SE.createAddRecFromPHIWithCasts(cast<SCEVUnknown>(Expr)); 1005 auto Result = SE.createAddRecFromPHIWithCasts(cast<SCEVUnknown>(Expr));
1008 } 1006 }
1536 ASSERT_TRUE(CeilingS->getAPInt() == CeilingInt); 1534 ASSERT_TRUE(CeilingS->getAPInt() == CeilingInt);
1537 } 1535 }
1538 }); 1536 });
1539 } 1537 }
1540 1538
1539 TEST_F(ScalarEvolutionsTest, ComputeMaxTripCountFromArrayNormal) {
1540 LLVMContext C;
1541 SMDiagnostic Err;
1542 std::unique_ptr<Module> M = parseAssemblyString(
1543 "define void @foo(i32 signext %len) { "
1544 "entry: "
1545 " %a = alloca [7 x i32], align 4 "
1546 " %cmp4 = icmp sgt i32 %len, 0 "
1547 " br i1 %cmp4, label %for.body.preheader, label %for.cond.cleanup "
1548 "for.body.preheader: "
1549 " br label %for.body "
1550 "for.cond.cleanup.loopexit: "
1551 " br label %for.cond.cleanup "
1552 "for.cond.cleanup: "
1553 " ret void "
1554 "for.body: "
1555 " %iv = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] "
1556 " %idxprom = zext i32 %iv to i64 "
1557 " %arrayidx = getelementptr inbounds [7 x i32], [7 x i32]* %a, i64 0, \
1558 i64 %idxprom "
1559 " store i32 0, i32* %arrayidx, align 4 "
1560 " %inc = add nuw nsw i32 %iv, 1 "
1561 " %cmp = icmp slt i32 %inc, %len "
1562 " br i1 %cmp, label %for.body, label %for.cond.cleanup.loopexit "
1563 "} ",
1564 Err, C);
1565
1566 ASSERT_TRUE(M && "Could not parse module?");
1567 ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
1568
1569 runWithSE(*M, "foo", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
1570 auto *ScevIV = SE.getSCEV(getInstructionByName(F, "iv"));
1571 const Loop *L = cast<SCEVAddRecExpr>(ScevIV)->getLoop();
1572
1573 const SCEV *ITC = SE.getConstantMaxTripCountFromArray(L);
1574 EXPECT_FALSE(isa<SCEVCouldNotCompute>(ITC));
1575 EXPECT_TRUE(isa<SCEVConstant>(ITC));
1576 EXPECT_EQ(cast<SCEVConstant>(ITC)->getAPInt().getSExtValue(), 8);
1577 });
1578 }
1579
1580 TEST_F(ScalarEvolutionsTest, ComputeMaxTripCountFromZeroArray) {
1581 LLVMContext C;
1582 SMDiagnostic Err;
1583 std::unique_ptr<Module> M = parseAssemblyString(
1584 "define void @foo(i32 signext %len) { "
1585 "entry: "
1586 " %a = alloca [0 x i32], align 4 "
1587 " %cmp4 = icmp sgt i32 %len, 0 "
1588 " br i1 %cmp4, label %for.body.preheader, label %for.cond.cleanup "
1589 "for.body.preheader: "
1590 " br label %for.body "
1591 "for.cond.cleanup.loopexit: "
1592 " br label %for.cond.cleanup "
1593 "for.cond.cleanup: "
1594 " ret void "
1595 "for.body: "
1596 " %iv = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] "
1597 " %idxprom = zext i32 %iv to i64 "
1598 " %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* %a, i64 0, \
1599 i64 %idxprom "
1600 " store i32 0, i32* %arrayidx, align 4 "
1601 " %inc = add nuw nsw i32 %iv, 1 "
1602 " %cmp = icmp slt i32 %inc, %len "
1603 " br i1 %cmp, label %for.body, label %for.cond.cleanup.loopexit "
1604 "} ",
1605 Err, C);
1606
1607 ASSERT_TRUE(M && "Could not parse module?");
1608 ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
1609
1610 runWithSE(*M, "foo", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
1611 auto *ScevIV = SE.getSCEV(getInstructionByName(F, "iv"));
1612 const Loop *L = cast<SCEVAddRecExpr>(ScevIV)->getLoop();
1613
1614 const SCEV *ITC = SE.getConstantMaxTripCountFromArray(L);
1615 EXPECT_FALSE(isa<SCEVCouldNotCompute>(ITC));
1616 EXPECT_TRUE(isa<SCEVConstant>(ITC));
1617 EXPECT_EQ(cast<SCEVConstant>(ITC)->getAPInt().getSExtValue(), 1);
1618 });
1619 }
1620
1621 TEST_F(ScalarEvolutionsTest, ComputeMaxTripCountFromExtremArray) {
1622 LLVMContext C;
1623 SMDiagnostic Err;
1624 std::unique_ptr<Module> M = parseAssemblyString(
1625 "define void @foo(i32 signext %len) { "
1626 "entry: "
1627 " %a = alloca [4294967295 x i1], align 4 "
1628 " %cmp4 = icmp sgt i32 %len, 0 "
1629 " br i1 %cmp4, label %for.body.preheader, label %for.cond.cleanup "
1630 "for.body.preheader: "
1631 " br label %for.body "
1632 "for.cond.cleanup.loopexit: "
1633 " br label %for.cond.cleanup "
1634 "for.cond.cleanup: "
1635 " ret void "
1636 "for.body: "
1637 " %iv = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] "
1638 " %idxprom = zext i32 %iv to i64 "
1639 " %arrayidx = getelementptr inbounds [4294967295 x i1], \
1640 [4294967295 x i1]* %a, i64 0, i64 %idxprom "
1641 " store i1 0, i1* %arrayidx, align 4 "
1642 " %inc = add nuw nsw i32 %iv, 1 "
1643 " %cmp = icmp slt i32 %inc, %len "
1644 " br i1 %cmp, label %for.body, label %for.cond.cleanup.loopexit "
1645 "} ",
1646 Err, C);
1647
1648 ASSERT_TRUE(M && "Could not parse module?");
1649 ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
1650
1651 runWithSE(*M, "foo", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
1652 auto *ScevIV = SE.getSCEV(getInstructionByName(F, "iv"));
1653 const Loop *L = cast<SCEVAddRecExpr>(ScevIV)->getLoop();
1654
1655 const SCEV *ITC = SE.getConstantMaxTripCountFromArray(L);
1656 EXPECT_TRUE(isa<SCEVCouldNotCompute>(ITC));
1657 });
1658 }
1659
1660 TEST_F(ScalarEvolutionsTest, ComputeMaxTripCountFromArrayInBranch) {
1661 LLVMContext C;
1662 SMDiagnostic Err;
1663 std::unique_ptr<Module> M = parseAssemblyString(
1664 "define void @foo(i32 signext %len) { "
1665 "entry: "
1666 " %a = alloca [8 x i32], align 4 "
1667 " br label %for.cond "
1668 "for.cond: "
1669 " %iv = phi i32 [ %inc, %for.inc ], [ 0, %entry ] "
1670 " %cmp = icmp slt i32 %iv, %len "
1671 " br i1 %cmp, label %for.body, label %for.cond.cleanup "
1672 "for.cond.cleanup: "
1673 " br label %for.end "
1674 "for.body: "
1675 " %cmp1 = icmp slt i32 %iv, 8 "
1676 " br i1 %cmp1, label %if.then, label %if.end "
1677 "if.then: "
1678 " %idxprom = sext i32 %iv to i64 "
1679 " %arrayidx = getelementptr inbounds [8 x i32], [8 x i32]* %a, i64 0, \
1680 i64 %idxprom "
1681 " store i32 0, i32* %arrayidx, align 4 "
1682 " br label %if.end "
1683 "if.end: "
1684 " br label %for.inc "
1685 "for.inc: "
1686 " %inc = add nsw i32 %iv, 1 "
1687 " br label %for.cond "
1688 "for.end: "
1689 " ret void "
1690 "} ",
1691 Err, C);
1692
1693 ASSERT_TRUE(M && "Could not parse module?");
1694 ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
1695
1696 runWithSE(*M, "foo", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
1697 auto *ScevIV = SE.getSCEV(getInstructionByName(F, "iv"));
1698 const Loop *L = cast<SCEVAddRecExpr>(ScevIV)->getLoop();
1699
1700 const SCEV *ITC = SE.getConstantMaxTripCountFromArray(L);
1701 EXPECT_TRUE(isa<SCEVCouldNotCompute>(ITC));
1702 });
1703 }
1704
1705 TEST_F(ScalarEvolutionsTest, ComputeMaxTripCountFromMultiDemArray) {
1706 LLVMContext C;
1707 SMDiagnostic Err;
1708 std::unique_ptr<Module> M = parseAssemblyString(
1709 "define void @foo(i32 signext %len) { "
1710 "entry: "
1711 " %a = alloca [3 x [5 x i32]], align 4 "
1712 " br label %for.cond "
1713 "for.cond: "
1714 " %iv = phi i32 [ %inc, %for.inc ], [ 0, %entry ] "
1715 " %cmp = icmp slt i32 %iv, %len "
1716 " br i1 %cmp, label %for.body, label %for.cond.cleanup "
1717 "for.cond.cleanup: "
1718 " br label %for.end "
1719 "for.body: "
1720 " %arrayidx = getelementptr inbounds [3 x [5 x i32]], \
1721 [3 x [5 x i32]]* %a, i64 0, i64 3 "
1722 " %idxprom = sext i32 %iv to i64 "
1723 " %arrayidx1 = getelementptr inbounds [5 x i32], [5 x i32]* %arrayidx, \
1724 i64 0, i64 %idxprom "
1725 " store i32 0, i32* %arrayidx1, align 4"
1726 " br label %for.inc "
1727 "for.inc: "
1728 " %inc = add nsw i32 %iv, 1 "
1729 " br label %for.cond "
1730 "for.end: "
1731 " ret void "
1732 "} ",
1733 Err, C);
1734
1735 ASSERT_TRUE(M && "Could not parse module?");
1736 ASSERT_TRUE(!verifyModule(*M) && "Must have been well formed!");
1737
1738 runWithSE(*M, "foo", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
1739 auto *ScevIV = SE.getSCEV(getInstructionByName(F, "iv"));
1740 const Loop *L = cast<SCEVAddRecExpr>(ScevIV)->getLoop();
1741
1742 const SCEV *ITC = SE.getConstantMaxTripCountFromArray(L);
1743 EXPECT_TRUE(isa<SCEVCouldNotCompute>(ITC));
1744 });
1745 }
1746
1541 } // end namespace llvm 1747 } // end namespace llvm