RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-26 04:32:44 +01:00
Code Issues Projects Releases Wiki Activity
4d9d8789ad
llvm-mirror/unittests/Transforms/Vectorize/VPlanSlpTest.cpp
Max Kazantsev c38d6febb5 [BasicAA] Drop dependency on Loop Info. PR43276 
BasicAA stores a reference to LoopInfo inside. This imposes an implicit
requirement of keeping it up to date whenever we modify the IR (in particular,
whenever we modify terminators of blocks that belong to loops). Failing
to do so leads to incorrect state of the LoopInfo.

Because general AA does not require loop info updates and provides to API to
update it properly, the users of AA reasonably assume that there is no need to
update the loop info. It may be a reason of bugs, as example in PR43276 shows.

This patch drops dependence of BasicAA on LoopInfo to avoid this problem.

This may potentially pessimize the result of queries to BasicAA.

Differential Revision: https://reviews.llvm.org/D98627
Reviewed By: nikic
2021-03-17 11:43:44 +07:00

922 lines
40 KiB
C++
Raw Blame History

//===- llvm/unittest/Transforms/Vectorize/VPlanSlpTest.cpp ---------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "../lib/Transforms/Vectorize/VPlan.h"
#include "../lib/Transforms/Vectorize/VPlanHCFGBuilder.h"
#include "VPlanTestBase.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/VectorUtils.h"
#include "gtest/gtest.h"
namespace llvm {
namespace {
class VPlanSlpTest : public VPlanTestBase {
protected:
TargetLibraryInfoImpl TLII;
TargetLibraryInfo TLI;
DataLayout DL;
std::unique_ptr<AssumptionCache> AC;
std::unique_ptr<ScalarEvolution> SE;
std::unique_ptr<AAResults> AARes;
std::unique_ptr<BasicAAResult> BasicAA;
std::unique_ptr<LoopAccessInfo> LAI;
std::unique_ptr<PredicatedScalarEvolution> PSE;
std::unique_ptr<InterleavedAccessInfo> IAI;
VPlanSlpTest()
: TLII(), TLI(TLII),
DL("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-"
"f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:"
"16:32:64-S128") {}
VPInterleavedAccessInfo getInterleavedAccessInfo(Function &F, Loop *L,
VPlan &Plan) {
AC.reset(new AssumptionCache(F));
SE.reset(new ScalarEvolution(F, TLI, *AC, *DT, *LI));
BasicAA.reset(new BasicAAResult(DL, F, TLI, *AC, &*DT));
AARes.reset(new AAResults(TLI));
AARes->addAAResult(*BasicAA);
PSE.reset(new PredicatedScalarEvolution(*SE, *L));
LAI.reset(new LoopAccessInfo(L, &*SE, &TLI, &*AARes, &*DT, &*LI));
IAI.reset(new InterleavedAccessInfo(*PSE, L, &*DT, &*LI, &*LAI));
IAI->analyzeInterleaving(false);
return {Plan, *IAI};
}
};
TEST_F(VPlanSlpTest, testSlpSimple_2) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
VPInstruction *CombinedStore = Slp.buildGraph(StoreRoot);
EXPECT_EQ(64u, Slp.getWidestBundleBits());
EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
auto *CombinedAdd = cast<VPInstruction>(CombinedStore->getOperand(0));
EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
auto *CombinedLoadA = cast<VPInstruction>(CombinedAdd->getOperand(0));
auto *CombinedLoadB = cast<VPInstruction>(CombinedAdd->getOperand(1));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
delete CombinedStore;
delete CombinedAdd;
delete CombinedLoadA;
delete CombinedLoadB;
}
TEST_F(VPlanSlpTest, testSlpSimple_3) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr %struct.Test, %struct.Test* %A, i64 "
" %indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
" %indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
" %indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
" %indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
" %indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
" %indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
VPInstruction *CombinedStore = Slp.buildGraph(StoreRoot);
EXPECT_EQ(64u, Slp.getWidestBundleBits());
EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
auto *CombinedAdd = cast<VPInstruction>(CombinedStore->getOperand(0));
EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
auto *CombinedLoadA = cast<VPInstruction>(CombinedAdd->getOperand(0));
auto *CombinedLoadB = cast<VPInstruction>(CombinedAdd->getOperand(1));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
VPInstruction *GetA = cast<VPInstruction>(&*std::next(Body->begin(), 1));
VPInstruction *GetB = cast<VPInstruction>(&*std::next(Body->begin(), 3));
EXPECT_EQ(GetA, CombinedLoadA->getOperand(0));
EXPECT_EQ(GetB, CombinedLoadB->getOperand(0));
delete CombinedStore;
delete CombinedAdd;
delete CombinedLoadA;
delete CombinedLoadB;
}
TEST_F(VPlanSlpTest, testSlpReuse_1) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %add0 = add nsw i32 %vA0, %vA0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %add1 = add nsw i32 %vA1, %vA1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 8));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 10));
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
VPInstruction *CombinedStore = Slp.buildGraph(StoreRoot);
EXPECT_EQ(64u, Slp.getWidestBundleBits());
EXPECT_EQ(VPInstruction::SLPStore, CombinedStore->getOpcode());
auto *CombinedAdd = cast<VPInstruction>(CombinedStore->getOperand(0));
EXPECT_EQ(Instruction::Add, CombinedAdd->getOpcode());
auto *CombinedLoadA = cast<VPInstruction>(CombinedAdd->getOperand(0));
EXPECT_EQ(CombinedLoadA, CombinedAdd->getOperand(1));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
delete CombinedStore;
delete CombinedAdd;
delete CombinedLoadA;
}
TEST_F(VPlanSlpTest, testSlpReuse_2) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define i32 @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %add0 = add nsw i32 %vA0, %vA0\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %add1 = add nsw i32 %vA1, %vA1\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret i32 %vA1\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 5));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 10));
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
Slp.buildGraph(StoreRoot);
EXPECT_FALSE(Slp.isCompletelySLP());
}
static void checkReorderExample(VPInstruction *Store1, VPInstruction *Store2,
VPBasicBlock *Body,
VPInterleavedAccessInfo &&IAI) {
VPlanSlp Slp(IAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
VPInstruction *CombinedStore = Slp.buildGraph(StoreRoot);
EXPECT_TRUE(Slp.isCompletelySLP());
EXPECT_EQ(CombinedStore->getOpcode(), VPInstruction::SLPStore);
VPInstruction *CombinedAdd =
cast<VPInstruction>(CombinedStore->getOperand(0));
EXPECT_EQ(CombinedAdd->getOpcode(), Instruction::Add);
VPInstruction *CombinedMulAB =
cast<VPInstruction>(CombinedAdd->getOperand(0));
VPInstruction *CombinedMulCD =
cast<VPInstruction>(CombinedAdd->getOperand(1));
EXPECT_EQ(CombinedMulAB->getOpcode(), Instruction::Mul);
VPInstruction *CombinedLoadA =
cast<VPInstruction>(CombinedMulAB->getOperand(0));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadA->getOpcode());
VPInstruction *LoadvA0 = cast<VPInstruction>(&*std::next(Body->begin(), 2));
VPInstruction *LoadvA1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
EXPECT_EQ(LoadvA0->getOperand(0), CombinedLoadA->getOperand(0));
EXPECT_EQ(LoadvA1->getOperand(0), CombinedLoadA->getOperand(1));
VPInstruction *CombinedLoadB =
cast<VPInstruction>(CombinedMulAB->getOperand(1));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadB->getOpcode());
VPInstruction *LoadvB0 = cast<VPInstruction>(&*std::next(Body->begin(), 4));
VPInstruction *LoadvB1 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
EXPECT_EQ(LoadvB0->getOperand(0), CombinedLoadB->getOperand(0));
EXPECT_EQ(LoadvB1->getOperand(0), CombinedLoadB->getOperand(1));
EXPECT_EQ(CombinedMulCD->getOpcode(), Instruction::Mul);
VPInstruction *CombinedLoadC =
cast<VPInstruction>(CombinedMulCD->getOperand(0));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadC->getOpcode());
VPInstruction *LoadvC0 = cast<VPInstruction>(&*std::next(Body->begin(), 7));
VPInstruction *LoadvC1 = cast<VPInstruction>(&*std::next(Body->begin(), 17));
EXPECT_EQ(LoadvC0->getOperand(0), CombinedLoadC->getOperand(0));
EXPECT_EQ(LoadvC1->getOperand(0), CombinedLoadC->getOperand(1));
VPInstruction *CombinedLoadD =
cast<VPInstruction>(CombinedMulCD->getOperand(1));
EXPECT_EQ(VPInstruction::SLPLoad, CombinedLoadD->getOpcode());
VPInstruction *LoadvD0 = cast<VPInstruction>(&*std::next(Body->begin(), 9));
VPInstruction *LoadvD1 = cast<VPInstruction>(&*std::next(Body->begin(), 19));
EXPECT_EQ(LoadvD0->getOperand(0), CombinedLoadD->getOperand(0));
EXPECT_EQ(LoadvD1->getOperand(0), CombinedLoadD->getOperand(1));
delete CombinedStore;
delete CombinedAdd;
delete CombinedMulAB;
delete CombinedMulCD;
delete CombinedLoadA;
delete CombinedLoadB;
delete CombinedLoadC;
delete CombinedLoadD;
}
TEST_F(VPlanSlpTest, testSlpReorder_1) {
LLVMContext Ctx;
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define void @add_x3(%struct.Test* %A, %struct.Test* %B, %struct.Test* "
"%C, %struct.Test* %D, %struct.Test* %E) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %mul11 = mul nsw i32 %vA0, %vB0\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" %vC0 = load i32, i32* %C0, align 4\n"
" %D0 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 0\n"
" %vD0 = load i32, i32* %D0, align 4\n"
" %mul12 = mul nsw i32 %vC0, %vD0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %mul21 = mul nsw i32 %vA1, %vB1\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" %vC1 = load i32, i32* %C1, align 4\n"
" %D1 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 1\n"
" %vD1 = load i32, i32* %D1, align 4\n"
" %mul22 = mul nsw i32 %vC1, %vD1\n"
" %add1 = add nsw i32 %mul11, %mul12\n"
" %add2 = add nsw i32 %mul22, %mul21\n"
" %E0 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add1, i32* %E0, align 4\n"
" %E1 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add2, i32* %E1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x3");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
checkReorderExample(
Store1, Store2, Body,
getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan));
}
TEST_F(VPlanSlpTest, testSlpReorder_2) {
LLVMContext Ctx;
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define void @add_x3(%struct.Test* %A, %struct.Test* %B, %struct.Test* "
"%C, %struct.Test* %D, %struct.Test* %E) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %mul11 = mul nsw i32 %vA0, %vB0\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" %vC0 = load i32, i32* %C0, align 4\n"
" %D0 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 0\n"
" %vD0 = load i32, i32* %D0, align 4\n"
" %mul12 = mul nsw i32 %vC0, %vD0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %mul21 = mul nsw i32 %vB1, %vA1\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" %vC1 = load i32, i32* %C1, align 4\n"
" %D1 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 1\n"
" %vD1 = load i32, i32* %D1, align 4\n"
" %mul22 = mul nsw i32 %vD1, %vC1\n"
" %add1 = add nsw i32 %mul11, %mul12\n"
" %add2 = add nsw i32 %mul22, %mul21\n"
" %E0 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add1, i32* %E0, align 4\n"
" %E1 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add2, i32* %E1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x3");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
checkReorderExample(
Store1, Store2, Body,
getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan));
}
TEST_F(VPlanSlpTest, testSlpReorder_3) {
LLVMContext Ctx;
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define void @add_x3(%struct.Test* %A, %struct.Test* %B, %struct.Test* "
"%C, %struct.Test* %D, %struct.Test* %E) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %mul11 = mul nsw i32 %vA1, %vB0\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" %vC0 = load i32, i32* %C0, align 4\n"
" %D0 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 0\n"
" %vD0 = load i32, i32* %D0, align 4\n"
" %mul12 = mul nsw i32 %vC0, %vD0\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %mul21 = mul nsw i32 %vB1, %vA0\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" %vC1 = load i32, i32* %C1, align 4\n"
" %D1 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 1\n"
" %vD1 = load i32, i32* %D1, align 4\n"
" %mul22 = mul nsw i32 %vD1, %vC1\n"
" %add1 = add nsw i32 %mul11, %mul12\n"
" %add2 = add nsw i32 %mul22, %mul21\n"
" %E0 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add1, i32* %E0, align 4\n"
" %E1 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add2, i32* %E1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x3");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
// FIXME Need to select better first value for lane0.
EXPECT_FALSE(Slp.isCompletelySLP());
}
TEST_F(VPlanSlpTest, testSlpReorder_4) {
LLVMContext Ctx;
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"define void @add_x3(%struct.Test* %A, %struct.Test* %B, %struct.Test* "
"%C, %struct.Test* %D, %struct.Test* %E) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %mul11 = mul nsw i32 %vA0, %vB0\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" %vC0 = load i32, i32* %C0, align 4\n"
" %D0 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 0\n"
" %vD0 = load i32, i32* %D0, align 4\n"
" %mul12 = mul nsw i32 %vC0, %vD0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %mul21 = mul nsw i32 %vA1, %vB1\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" %vC1 = load i32, i32* %C1, align 4\n"
" %D1 = getelementptr inbounds %struct.Test, %struct.Test* %D, i64 "
"%indvars.iv, i32 1\n"
" %vD1 = load i32, i32* %D1, align 4\n"
" %mul22 = mul nsw i32 %vC1, %vD1\n"
" %add1 = add nsw i32 %mul11, %mul12\n"
" %add2 = add nsw i32 %mul22, %mul21\n"
" %E0 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add1, i32* %E0, align 4\n"
" %E1 = getelementptr inbounds %struct.Test, %struct.Test* %E, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add2, i32* %E1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x3");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 24));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 26));
checkReorderExample(
Store1, Store2, Body,
getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan));
}
// Make sure we do not combine instructions with operands in different BBs.
TEST_F(VPlanSlpTest, testInstrsInDifferentBBs) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" br label %bb2\n"
"bb2:\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPBasicBlock *BB2 = Body->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(BB2->begin(), 3));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(BB2->begin(), 5));
VPlanSlp Slp(VPIAI, *BB2);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
EXPECT_EQ(0u, Slp.getWidestBundleBits());
}
// Make sure we do not combine instructions with operands in different BBs.
TEST_F(VPlanSlpTest, testInstrsInDifferentBBs2) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" br label %bb2\n"
"bb2:\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPBasicBlock *BB2 = Body->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(BB2->begin(), 1));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(BB2->begin(), 3));
VPlanSlp Slp(VPIAI, *BB2);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
EXPECT_EQ(0u, Slp.getWidestBundleBits());
}
TEST_F(VPlanSlpTest, testSlpAtomicLoad) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load atomic i32, i32* %A0 monotonic, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store i32 %add0, i32* %C0, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
EXPECT_EQ(nullptr, Slp.buildGraph(StoreRoot));
EXPECT_FALSE(Slp.isCompletelySLP());
}
TEST_F(VPlanSlpTest, testSlpAtomicStore) {
const char *ModuleString =
"%struct.Test = type { i32, i32 }\n"
"%struct.Test3 = type { i32, i32, i32 }\n"
"%struct.Test4xi8 = type { i8, i8, i8 }\n"
"define void @add_x2(%struct.Test* nocapture readonly %A, %struct.Test* "
"nocapture readonly %B, %struct.Test* nocapture %C) {\n"
"entry:\n"
" br label %for.body\n"
"for.body: ; preds = %for.body, "
"%entry\n"
" %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]\n"
" %A0 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 0\n"
" %vA0 = load i32, i32* %A0, align 4\n"
" %B0 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 0\n"
" %vB0 = load i32, i32* %B0, align 4\n"
" %add0 = add nsw i32 %vA0, %vB0\n"
" %A1 = getelementptr inbounds %struct.Test, %struct.Test* %A, i64 "
"%indvars.iv, i32 1\n"
" %vA1 = load i32, i32* %A1, align 4\n"
" %B1 = getelementptr inbounds %struct.Test, %struct.Test* %B, i64 "
"%indvars.iv, i32 1\n"
" %vB1 = load i32, i32* %B1, align 4\n"
" %add1 = add nsw i32 %vA1, %vB1\n"
" %C0 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 0\n"
" store atomic i32 %add0, i32* %C0 monotonic, align 4\n"
" %C1 = getelementptr inbounds %struct.Test, %struct.Test* %C, i64 "
"%indvars.iv, i32 1\n"
" store i32 %add1, i32* %C1, align 4\n"
" %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1\n"
" %exitcond = icmp eq i64 %indvars.iv.next, 1024\n"
" br i1 %exitcond, label %for.cond.cleanup, label %for.body\n"
"for.cond.cleanup: ; preds = %for.body\n"
" ret void\n"
"}\n";
Module &M = parseModule(ModuleString);
Function *F = M.getFunction("add_x2");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
auto Plan = buildHCFG(LoopHeader);
auto VPIAI = getInterleavedAccessInfo(*F, LI->getLoopFor(LoopHeader), *Plan);
VPBlockBase *Entry = Plan->getEntry()->getEntryBasicBlock();
EXPECT_NE(nullptr, Entry->getSingleSuccessor());
VPBasicBlock *Body = Entry->getSingleSuccessor()->getEntryBasicBlock();
VPInstruction *Store1 = cast<VPInstruction>(&*std::next(Body->begin(), 12));
VPInstruction *Store2 = cast<VPInstruction>(&*std::next(Body->begin(), 14));
VPlanSlp Slp(VPIAI, *Body);
SmallVector<VPValue *, 4> StoreRoot = {Store1, Store2};
Slp.buildGraph(StoreRoot);
EXPECT_FALSE(Slp.isCompletelySLP());
}
} // namespace
} // namespace llvm
Reference in New Issue View Git Blame Copy Permalink