mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
846be29e5e
Recommit r352791 after tweaking DerivedTypes.h slightly, so that gcc
doesn't choke on it, hopefully.
Original Message:
The FunctionCallee type is effectively a {FunctionType*,Value*} pair,
and is a useful convenience to enable code to continue passing the
result of getOrInsertFunction() through to EmitCall, even once pointer
types lose their pointee-type.
Then:
- update the CallInst/InvokeInst instruction creation functions to
take a Callee,
- modify getOrInsertFunction to return FunctionCallee, and
- update all callers appropriately.
One area of particular note is the change to the sanitizer
code. Previously, they had been casting the result of
`getOrInsertFunction` to a `Function*` via
`checkSanitizerInterfaceFunction`, and storing that. That would report
an error if someone had already inserted a function declaraction with
a mismatching signature.
However, in general, LLVM allows for such mismatches, as
`getOrInsertFunction` will automatically insert a bitcast if
needed. As part of this cleanup, cause the sanitizer code to do the
same. (It will call its functions using the expected signature,
however they may have been declared.)
Finally, in a small number of locations, callers of
`getOrInsertFunction` actually were expecting/requiring that a brand
new function was being created. In such cases, I've switched them to
Function::Create instead.
Differential Revision: https://reviews.llvm.org/D57315
llvm-svn: 352827
431 lines
12 KiB
C++
431 lines
12 KiB
C++
//===- DivergenceAnalysisTest.cpp - DivergenceAnalysis unit tests ---------===//
|
|
//
|
|
// 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 "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
|
#include "llvm/Analysis/DivergenceAnalysis.h"
|
|
#include "llvm/Analysis/LoopInfo.h"
|
|
#include "llvm/Analysis/PostDominators.h"
|
|
#include "llvm/Analysis/SyncDependenceAnalysis.h"
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
|
#include "llvm/AsmParser/Parser.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/Dominators.h"
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
#include "llvm/IR/IRBuilder.h"
|
|
#include "llvm/IR/InstIterator.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/LegacyPassManager.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/Verifier.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
namespace llvm {
|
|
namespace {
|
|
|
|
BasicBlock *GetBlockByName(StringRef BlockName, Function &F) {
|
|
for (auto &BB : F) {
|
|
if (BB.getName() != BlockName)
|
|
continue;
|
|
return &BB;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// We use this fixture to ensure that we clean up DivergenceAnalysis before
|
|
// deleting the PassManager.
|
|
class DivergenceAnalysisTest : public testing::Test {
|
|
protected:
|
|
LLVMContext Context;
|
|
Module M;
|
|
TargetLibraryInfoImpl TLII;
|
|
TargetLibraryInfo TLI;
|
|
|
|
std::unique_ptr<DominatorTree> DT;
|
|
std::unique_ptr<PostDominatorTree> PDT;
|
|
std::unique_ptr<LoopInfo> LI;
|
|
std::unique_ptr<SyncDependenceAnalysis> SDA;
|
|
|
|
DivergenceAnalysisTest() : M("", Context), TLII(), TLI(TLII) {}
|
|
|
|
DivergenceAnalysis buildDA(Function &F, bool IsLCSSA) {
|
|
DT.reset(new DominatorTree(F));
|
|
PDT.reset(new PostDominatorTree(F));
|
|
LI.reset(new LoopInfo(*DT));
|
|
SDA.reset(new SyncDependenceAnalysis(*DT, *PDT, *LI));
|
|
return DivergenceAnalysis(F, nullptr, *DT, *LI, *SDA, IsLCSSA);
|
|
}
|
|
|
|
void runWithDA(
|
|
Module &M, StringRef FuncName, bool IsLCSSA,
|
|
function_ref<void(Function &F, LoopInfo &LI, DivergenceAnalysis &DA)>
|
|
Test) {
|
|
auto *F = M.getFunction(FuncName);
|
|
ASSERT_NE(F, nullptr) << "Could not find " << FuncName;
|
|
DivergenceAnalysis DA = buildDA(*F, IsLCSSA);
|
|
Test(*F, *LI, DA);
|
|
}
|
|
};
|
|
|
|
// Simple initial state test
|
|
TEST_F(DivergenceAnalysisTest, DAInitialState) {
|
|
IntegerType *IntTy = IntegerType::getInt32Ty(Context);
|
|
FunctionType *FTy =
|
|
FunctionType::get(Type::getVoidTy(Context), {IntTy}, false);
|
|
Function *F = Function::Create(FTy, Function::ExternalLinkage, "f", M);
|
|
BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
|
|
ReturnInst::Create(Context, nullptr, BB);
|
|
|
|
DivergenceAnalysis DA = buildDA(*F, false);
|
|
|
|
// Whole function region
|
|
EXPECT_EQ(DA.getRegionLoop(), nullptr);
|
|
|
|
// No divergence in initial state
|
|
EXPECT_FALSE(DA.hasDetectedDivergence());
|
|
|
|
// No spurious divergence
|
|
DA.compute();
|
|
EXPECT_FALSE(DA.hasDetectedDivergence());
|
|
|
|
// Detected divergence after marking
|
|
Argument &arg = *F->arg_begin();
|
|
DA.markDivergent(arg);
|
|
|
|
EXPECT_TRUE(DA.hasDetectedDivergence());
|
|
EXPECT_TRUE(DA.isDivergent(arg));
|
|
|
|
DA.compute();
|
|
EXPECT_TRUE(DA.hasDetectedDivergence());
|
|
EXPECT_TRUE(DA.isDivergent(arg));
|
|
}
|
|
|
|
TEST_F(DivergenceAnalysisTest, DANoLCSSA) {
|
|
LLVMContext C;
|
|
SMDiagnostic Err;
|
|
|
|
std::unique_ptr<Module> M = parseAssemblyString(
|
|
"target datalayout = \"e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128\" "
|
|
" "
|
|
"define i32 @f_1(i8* nocapture %arr, i32 %n, i32* %A, i32* %B) "
|
|
" local_unnamed_addr { "
|
|
"entry: "
|
|
" br label %loop.ph "
|
|
" "
|
|
"loop.ph: "
|
|
" br label %loop "
|
|
" "
|
|
"loop: "
|
|
" %iv0 = phi i32 [ %iv0.inc, %loop ], [ 0, %loop.ph ] "
|
|
" %iv1 = phi i32 [ %iv1.inc, %loop ], [ -2147483648, %loop.ph ] "
|
|
" %iv0.inc = add i32 %iv0, 1 "
|
|
" %iv1.inc = add i32 %iv1, 3 "
|
|
" %cond.cont = icmp slt i32 %iv0, %n "
|
|
" br i1 %cond.cont, label %loop, label %for.end.loopexit "
|
|
" "
|
|
"for.end.loopexit: "
|
|
" ret i32 %iv0 "
|
|
"} ",
|
|
Err, C);
|
|
|
|
Function *F = M->getFunction("f_1");
|
|
DivergenceAnalysis DA = buildDA(*F, false);
|
|
EXPECT_FALSE(DA.hasDetectedDivergence());
|
|
|
|
auto ItArg = F->arg_begin();
|
|
ItArg++;
|
|
auto &NArg = *ItArg;
|
|
|
|
// Seed divergence in argument %n
|
|
DA.markDivergent(NArg);
|
|
|
|
DA.compute();
|
|
EXPECT_TRUE(DA.hasDetectedDivergence());
|
|
|
|
// Verify that "ret %iv.0" is divergent
|
|
auto ItBlock = F->begin();
|
|
std::advance(ItBlock, 3);
|
|
auto &ExitBlock = *GetBlockByName("for.end.loopexit", *F);
|
|
auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());
|
|
EXPECT_TRUE(DA.isDivergent(RetInst));
|
|
}
|
|
|
|
TEST_F(DivergenceAnalysisTest, DALCSSA) {
|
|
LLVMContext C;
|
|
SMDiagnostic Err;
|
|
|
|
std::unique_ptr<Module> M = parseAssemblyString(
|
|
"target datalayout = \"e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128\" "
|
|
" "
|
|
"define i32 @f_lcssa(i8* nocapture %arr, i32 %n, i32* %A, i32* %B) "
|
|
" local_unnamed_addr { "
|
|
"entry: "
|
|
" br label %loop.ph "
|
|
" "
|
|
"loop.ph: "
|
|
" br label %loop "
|
|
" "
|
|
"loop: "
|
|
" %iv0 = phi i32 [ %iv0.inc, %loop ], [ 0, %loop.ph ] "
|
|
" %iv1 = phi i32 [ %iv1.inc, %loop ], [ -2147483648, %loop.ph ] "
|
|
" %iv0.inc = add i32 %iv0, 1 "
|
|
" %iv1.inc = add i32 %iv1, 3 "
|
|
" %cond.cont = icmp slt i32 %iv0, %n "
|
|
" br i1 %cond.cont, label %loop, label %for.end.loopexit "
|
|
" "
|
|
"for.end.loopexit: "
|
|
" %val.ret = phi i32 [ %iv0, %loop ] "
|
|
" br label %detached.return "
|
|
" "
|
|
"detached.return: "
|
|
" ret i32 %val.ret "
|
|
"} ",
|
|
Err, C);
|
|
|
|
Function *F = M->getFunction("f_lcssa");
|
|
DivergenceAnalysis DA = buildDA(*F, true);
|
|
EXPECT_FALSE(DA.hasDetectedDivergence());
|
|
|
|
auto ItArg = F->arg_begin();
|
|
ItArg++;
|
|
auto &NArg = *ItArg;
|
|
|
|
// Seed divergence in argument %n
|
|
DA.markDivergent(NArg);
|
|
|
|
DA.compute();
|
|
EXPECT_TRUE(DA.hasDetectedDivergence());
|
|
|
|
// Verify that "ret %iv.0" is divergent
|
|
auto ItBlock = F->begin();
|
|
std::advance(ItBlock, 4);
|
|
auto &ExitBlock = *GetBlockByName("detached.return", *F);
|
|
auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());
|
|
EXPECT_TRUE(DA.isDivergent(RetInst));
|
|
}
|
|
|
|
TEST_F(DivergenceAnalysisTest, DAJoinDivergence) {
|
|
LLVMContext C;
|
|
SMDiagnostic Err;
|
|
|
|
std::unique_ptr<Module> M = parseAssemblyString(
|
|
"target datalayout = \"e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128\" "
|
|
" "
|
|
"define void @f_1(i1 %a, i1 %b, i1 %c) "
|
|
" local_unnamed_addr { "
|
|
"A: "
|
|
" br i1 %a, label %B, label %C "
|
|
" "
|
|
"B: "
|
|
" br i1 %b, label %C, label %D "
|
|
" "
|
|
"C: "
|
|
" %c.join = phi i32 [ 0, %A ], [ 1, %B ] "
|
|
" br i1 %c, label %D, label %E "
|
|
" "
|
|
"D: "
|
|
" %d.join = phi i32 [ 0, %B ], [ 1, %C ] "
|
|
" br label %E "
|
|
" "
|
|
"E: "
|
|
" %e.join = phi i32 [ 0, %C ], [ 1, %D ] "
|
|
" ret void "
|
|
"} "
|
|
" "
|
|
"define void @f_2(i1 %a, i1 %b, i1 %c) "
|
|
" local_unnamed_addr { "
|
|
"A: "
|
|
" br i1 %a, label %B, label %E "
|
|
" "
|
|
"B: "
|
|
" br i1 %b, label %C, label %D "
|
|
" "
|
|
"C: "
|
|
" br label %D "
|
|
" "
|
|
"D: "
|
|
" %d.join = phi i32 [ 0, %B ], [ 1, %C ] "
|
|
" br label %E "
|
|
" "
|
|
"E: "
|
|
" %e.join = phi i32 [ 0, %A ], [ 1, %D ] "
|
|
" ret void "
|
|
"} "
|
|
" "
|
|
"define void @f_3(i1 %a, i1 %b, i1 %c)"
|
|
" local_unnamed_addr { "
|
|
"A: "
|
|
" br i1 %a, label %B, label %C "
|
|
" "
|
|
"B: "
|
|
" br label %C "
|
|
" "
|
|
"C: "
|
|
" %c.join = phi i32 [ 0, %A ], [ 1, %B ] "
|
|
" br i1 %c, label %D, label %E "
|
|
" "
|
|
"D: "
|
|
" br label %E "
|
|
" "
|
|
"E: "
|
|
" %e.join = phi i32 [ 0, %C ], [ 1, %D ] "
|
|
" ret void "
|
|
"} ",
|
|
Err, C);
|
|
|
|
// Maps divergent conditions to the basic blocks whose Phi nodes become
|
|
// divergent. Blocks need to be listed in IR order.
|
|
using SmallBlockVec = SmallVector<const BasicBlock *, 4>;
|
|
using InducedDivJoinMap = std::map<const Value *, SmallBlockVec>;
|
|
|
|
// Actual function performing the checks.
|
|
auto CheckDivergenceFunc = [this](Function &F,
|
|
InducedDivJoinMap &ExpectedDivJoins) {
|
|
for (auto &ItCase : ExpectedDivJoins) {
|
|
auto *DivVal = ItCase.first;
|
|
auto DA = buildDA(F, false);
|
|
DA.markDivergent(*DivVal);
|
|
DA.compute();
|
|
|
|
// List of basic blocks that shall host divergent Phi nodes.
|
|
auto ItDivJoins = ItCase.second.begin();
|
|
|
|
for (auto &BB : F) {
|
|
auto *Phi = dyn_cast<PHINode>(BB.begin());
|
|
if (!Phi)
|
|
continue;
|
|
|
|
if (ItDivJoins != ItCase.second.end() && &BB == *ItDivJoins) {
|
|
EXPECT_TRUE(DA.isDivergent(*Phi));
|
|
// Advance to next block with expected divergent PHI node.
|
|
++ItDivJoins;
|
|
} else {
|
|
EXPECT_FALSE(DA.isDivergent(*Phi));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
{
|
|
auto *F = M->getFunction("f_1");
|
|
auto ItBlocks = F->begin();
|
|
ItBlocks++; // Skip A
|
|
ItBlocks++; // Skip B
|
|
auto *C = &*ItBlocks++;
|
|
auto *D = &*ItBlocks++;
|
|
auto *E = &*ItBlocks;
|
|
|
|
auto ItArg = F->arg_begin();
|
|
auto *AArg = &*ItArg++;
|
|
auto *BArg = &*ItArg++;
|
|
auto *CArg = &*ItArg;
|
|
|
|
InducedDivJoinMap DivJoins;
|
|
DivJoins.emplace(AArg, SmallBlockVec({C, D, E}));
|
|
DivJoins.emplace(BArg, SmallBlockVec({D, E}));
|
|
DivJoins.emplace(CArg, SmallBlockVec({E}));
|
|
|
|
CheckDivergenceFunc(*F, DivJoins);
|
|
}
|
|
|
|
{
|
|
auto *F = M->getFunction("f_2");
|
|
auto ItBlocks = F->begin();
|
|
ItBlocks++; // Skip A
|
|
ItBlocks++; // Skip B
|
|
ItBlocks++; // Skip C
|
|
auto *D = &*ItBlocks++;
|
|
auto *E = &*ItBlocks;
|
|
|
|
auto ItArg = F->arg_begin();
|
|
auto *AArg = &*ItArg++;
|
|
auto *BArg = &*ItArg++;
|
|
auto *CArg = &*ItArg;
|
|
|
|
InducedDivJoinMap DivJoins;
|
|
DivJoins.emplace(AArg, SmallBlockVec({E}));
|
|
DivJoins.emplace(BArg, SmallBlockVec({D}));
|
|
DivJoins.emplace(CArg, SmallBlockVec({}));
|
|
|
|
CheckDivergenceFunc(*F, DivJoins);
|
|
}
|
|
|
|
{
|
|
auto *F = M->getFunction("f_3");
|
|
auto ItBlocks = F->begin();
|
|
ItBlocks++; // Skip A
|
|
ItBlocks++; // Skip B
|
|
auto *C = &*ItBlocks++;
|
|
ItBlocks++; // Skip D
|
|
auto *E = &*ItBlocks;
|
|
|
|
auto ItArg = F->arg_begin();
|
|
auto *AArg = &*ItArg++;
|
|
auto *BArg = &*ItArg++;
|
|
auto *CArg = &*ItArg;
|
|
|
|
InducedDivJoinMap DivJoins;
|
|
DivJoins.emplace(AArg, SmallBlockVec({C}));
|
|
DivJoins.emplace(BArg, SmallBlockVec({}));
|
|
DivJoins.emplace(CArg, SmallBlockVec({E}));
|
|
|
|
CheckDivergenceFunc(*F, DivJoins);
|
|
}
|
|
}
|
|
|
|
TEST_F(DivergenceAnalysisTest, DASwitchUnreachableDefault) {
|
|
LLVMContext C;
|
|
SMDiagnostic Err;
|
|
|
|
std::unique_ptr<Module> M = parseAssemblyString(
|
|
"target datalayout = \"e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128\" "
|
|
" "
|
|
"define void @switch_unreachable_default(i32 %cond) local_unnamed_addr { "
|
|
"entry: "
|
|
" switch i32 %cond, label %sw.default [ "
|
|
" i32 0, label %sw.bb0 "
|
|
" i32 1, label %sw.bb1 "
|
|
" ] "
|
|
" "
|
|
"sw.bb0: "
|
|
" br label %sw.epilog "
|
|
" "
|
|
"sw.bb1: "
|
|
" br label %sw.epilog "
|
|
" "
|
|
"sw.default: "
|
|
" unreachable "
|
|
" "
|
|
"sw.epilog: "
|
|
" %div.dbl = phi double [ 0.0, %sw.bb0], [ -1.0, %sw.bb1 ] "
|
|
" ret void "
|
|
"}",
|
|
Err, C);
|
|
|
|
auto *F = M->getFunction("switch_unreachable_default");
|
|
auto &CondArg = *F->arg_begin();
|
|
auto DA = buildDA(*F, false);
|
|
|
|
EXPECT_FALSE(DA.hasDetectedDivergence());
|
|
|
|
DA.markDivergent(CondArg);
|
|
DA.compute();
|
|
|
|
// Still %CondArg is divergent.
|
|
EXPECT_TRUE(DA.hasDetectedDivergence());
|
|
|
|
// The join uni.dbl is not divergent (see D52221)
|
|
auto &ExitBlock = *GetBlockByName("sw.epilog", *F);
|
|
auto &DivDblPhi = *cast<PHINode>(ExitBlock.begin());
|
|
EXPECT_TRUE(DA.isDivergent(DivDblPhi));
|
|
}
|
|
|
|
} // end anonymous namespace
|
|
} // end namespace llvm
|