OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 2
Code Issues Packages Projects Releases Wiki Activity
llvm-project/llvm/unittests/Analysis/FunctionPropertiesAnalysisT...

749 lines
20 KiB
C++
Raw Blame History

//===- FunctionPropertiesAnalysisTest.cpp - Function Properties 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/Analysis/FunctionPropertiesAnalysis.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/StandardInstrumentations.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "gtest/gtest.h"
#include <cstring>
using namespace llvm;
namespace {
class FunctionPropertiesAnalysisTest : public testing::Test {
public:
FunctionPropertiesAnalysisTest() {
FAM.registerPass([&] { return DominatorTreeAnalysis(); });
FAM.registerPass([&] { return LoopAnalysis(); });
FAM.registerPass([&] { return PassInstrumentationAnalysis(); });
}
protected:
std::unique_ptr<DominatorTree> DT;
std::unique_ptr<LoopInfo> LI;
FunctionAnalysisManager FAM;
FunctionPropertiesInfo buildFPI(Function &F) {
return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, FAM);
}
void invalidate(Function &F) {
PreservedAnalyses PA = PreservedAnalyses::none();
FAM.invalidate(F, PA);
}
std::unique_ptr<Module> makeLLVMModule(LLVMContext &C, const char *IR) {
SMDiagnostic Err;
std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
if (!Mod)
Err.print("MLAnalysisTests", errs());
return Mod;
}
CallBase* findCall(Function& F, const char* Name = nullptr) {
for (auto &BB : F)
for (auto &I : BB )
if (auto *CB = dyn_cast<CallBase>(&I))
if (!Name || CB->getName() == Name)
return CB;
return nullptr;
}
};
TEST_F(FunctionPropertiesAnalysisTest, BasicTest) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
declare i32 @f1(i32)
declare i32 @f2(i32)
define i32 @branches(i32) {
%cond = icmp slt i32 %0, 3
br i1 %cond, label %then, label %else
then:
%ret.1 = call i32 @f1(i32 %0)
br label %last.block
else:
%ret.2 = call i32 @f2(i32 %0)
br label %last.block
last.block:
%ret = phi i32 [%ret.1, %then], [%ret.2, %else]
ret i32 %ret
}
define internal i32 @top() {
%1 = call i32 @branches(i32 2)
%2 = call i32 @f1(i32 %1)
ret i32 %2
}
)IR");
Function *BranchesFunction = M->getFunction("branches");
FunctionPropertiesInfo BranchesFeatures = buildFPI(*BranchesFunction);
EXPECT_EQ(BranchesFeatures.BasicBlockCount, 4);
EXPECT_EQ(BranchesFeatures.BlocksReachedFromConditionalInstruction, 2);
// 2 Users: top is one. The other is added because @branches is not internal,
// so it may have external callers.
EXPECT_EQ(BranchesFeatures.Uses, 2);
EXPECT_EQ(BranchesFeatures.DirectCallsToDefinedFunctions, 0);
EXPECT_EQ(BranchesFeatures.LoadInstCount, 0);
EXPECT_EQ(BranchesFeatures.StoreInstCount, 0);
EXPECT_EQ(BranchesFeatures.MaxLoopDepth, 0);
EXPECT_EQ(BranchesFeatures.TopLevelLoopCount, 0);
Function *TopFunction = M->getFunction("top");
FunctionPropertiesInfo TopFeatures = buildFPI(*TopFunction);
EXPECT_EQ(TopFeatures.BasicBlockCount, 1);
EXPECT_EQ(TopFeatures.BlocksReachedFromConditionalInstruction, 0);
EXPECT_EQ(TopFeatures.Uses, 0);
EXPECT_EQ(TopFeatures.DirectCallsToDefinedFunctions, 1);
EXPECT_EQ(BranchesFeatures.LoadInstCount, 0);
EXPECT_EQ(BranchesFeatures.StoreInstCount, 0);
EXPECT_EQ(BranchesFeatures.MaxLoopDepth, 0);
EXPECT_EQ(BranchesFeatures.TopLevelLoopCount, 0);
}
TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBSimple) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
define i32 @f1(i32 %a) {
%b = call i32 @f2(i32 %a)
%c = add i32 %b, 2
ret i32 %c
}
define i32 @f2(i32 %a) {
%b = add i32 %a, 1
ret i32 %b
}
)IR");
Function *F1 = M->getFunction("f1");
CallBase* CB = findCall(*F1, "b");
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 1;
ExpectedInitial.TotalInstructionCount = 3;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
ExpectedFinal.DirectCallsToDefinedFunctions = 0;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBLargerCFG) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
define i32 @f1(i32 %a) {
entry:
%i = icmp slt i32 %a, 0
br i1 %i, label %if.then, label %if.else
if.then:
%b = call i32 @f2(i32 %a)
%c1 = add i32 %b, 2
br label %end
if.else:
%c2 = add i32 %a, 1
br label %end
end:
%ret = phi i32 [%c1, %if.then],[%c2, %if.else]
ret i32 %ret
}
define i32 @f2(i32 %a) {
%b = add i32 %a, 1
ret i32 %b
}
)IR");
Function *F1 = M->getFunction("f1");
CallBase* CB = findCall(*F1, "b");
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 4;
ExpectedInitial.BlocksReachedFromConditionalInstruction = 2;
ExpectedInitial.TotalInstructionCount = 9;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
ExpectedFinal.DirectCallsToDefinedFunctions = 0;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBLoops) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
define i32 @f1(i32 %a) {
entry:
%i = icmp slt i32 %a, 0
br i1 %i, label %if.then, label %if.else
if.then:
%b = call i32 @f2(i32 %a)
%c1 = add i32 %b, 2
br label %end
if.else:
%c2 = add i32 %a, 1
br label %end
end:
%ret = phi i32 [%c1, %if.then],[%c2, %if.else]
ret i32 %ret
}
define i32 @f2(i32 %a) {
entry:
br label %loop
loop:
%indvar = phi i32 [%indvar.next, %loop], [0, %entry]
%b = add i32 %a, %indvar
%indvar.next = add i32 %indvar, 1
%cond = icmp slt i32 %indvar.next, %a
br i1 %cond, label %loop, label %exit
exit:
ret i32 %b
}
)IR");
Function *F1 = M->getFunction("f1");
CallBase* CB = findCall(*F1, "b");
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 4;
ExpectedInitial.BlocksReachedFromConditionalInstruction = 2;
ExpectedInitial.TotalInstructionCount = 9;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
FunctionPropertiesInfo ExpectedFinal;
ExpectedFinal.BasicBlockCount = 6;
ExpectedFinal.BlocksReachedFromConditionalInstruction = 4;
ExpectedFinal.Uses = 1;
ExpectedFinal.MaxLoopDepth = 1;
ExpectedFinal.TopLevelLoopCount = 1;
ExpectedFinal.TotalInstructionCount = 14;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
TEST_F(FunctionPropertiesAnalysisTest, InvokeSimple) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
declare void @might_throw()
define internal void @callee() {
entry:
call void @might_throw()
ret void
}
define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
entry:
invoke void @callee()
to label %cont unwind label %exc
cont:
ret i32 0
exc:
%exn = landingpad {i8*, i32}
cleanup
ret i32 1
}
declare i32 @__gxx_personality_v0(...)
)IR");
Function *F1 = M->getFunction("caller");
CallBase* CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
auto FPI = buildFPI(*F1);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
F1->getBasicBlockList().size());
EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
F1->getInstructionCount());
}
TEST_F(FunctionPropertiesAnalysisTest, InvokeUnreachableHandler) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
declare void @might_throw()
define internal i32 @callee() personality i32 (...)* @__gxx_personality_v0 {
entry:
invoke void @might_throw()
to label %cont unwind label %exc
cont:
ret i32 0
exc:
%exn = landingpad {i8*, i32}
cleanup
resume { i8*, i32 } %exn
}
define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
entry:
%X = invoke i32 @callee()
to label %cont unwind label %Handler
cont:
ret i32 %X
Handler:
%exn = landingpad {i8*, i32}
cleanup
ret i32 1
}
declare i32 @__gxx_personality_v0(...)
)IR");
Function *F1 = M->getFunction("caller");
CallBase* CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
auto FPI = buildFPI(*F1);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
F1->getBasicBlockList().size() - 1);
EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
F1->getInstructionCount() - 2);
EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
}
TEST_F(FunctionPropertiesAnalysisTest, Rethrow) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
declare void @might_throw()
define internal i32 @callee() personality i32 (...)* @__gxx_personality_v0 {
entry:
invoke void @might_throw()
to label %cont unwind label %exc
cont:
ret i32 0
exc:
%exn = landingpad {i8*, i32}
cleanup
resume { i8*, i32 } %exn
}
define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
entry:
%X = invoke i32 @callee()
to label %cont unwind label %Handler
cont:
ret i32 %X
Handler:
%exn = landingpad {i8*, i32}
cleanup
ret i32 1
}
declare i32 @__gxx_personality_v0(...)
)IR");
Function *F1 = M->getFunction("caller");
CallBase* CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
auto FPI = buildFPI(*F1);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
F1->getBasicBlockList().size() - 1);
EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
F1->getInstructionCount() - 2);
EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
}
TEST_F(FunctionPropertiesAnalysisTest, LPadChanges) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
declare void @external_func()
@exception_type1 = external global i8
@exception_type2 = external global i8
define internal void @inner() personality i8* null {
invoke void @external_func()
to label %cont unwind label %lpad
cont:
ret void
lpad:
%lp = landingpad i32
catch i8* @exception_type1
resume i32 %lp
}
define void @outer() personality i8* null {
invoke void @inner()
to label %cont unwind label %lpad
cont:
ret void
lpad:
%lp = landingpad i32
cleanup
catch i8* @exception_type2
resume i32 %lp
}
)IR");
Function *F1 = M->getFunction("outer");
CallBase* CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
auto FPI = buildFPI(*F1);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
F1->getBasicBlockList().size() - 1);
EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
F1->getInstructionCount() - 2);
EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
}
TEST_F(FunctionPropertiesAnalysisTest, LPadChangesConditional) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
declare void @external_func()
@exception_type1 = external global i8
@exception_type2 = external global i8
define internal void @inner() personality i8* null {
invoke void @external_func()
to label %cont unwind label %lpad
cont:
ret void
lpad:
%lp = landingpad i32
catch i8* @exception_type1
resume i32 %lp
}
define void @outer(i32 %a) personality i8* null {
entry:
%i = icmp slt i32 %a, 0
br i1 %i, label %if.then, label %cont
if.then:
invoke void @inner()
to label %cont unwind label %lpad
cont:
ret void
lpad:
%lp = landingpad i32
cleanup
catch i8* @exception_type2
resume i32 %lp
}
)IR");
Function *F1 = M->getFunction("outer");
CallBase* CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
auto FPI = buildFPI(*F1);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
F1->getBasicBlockList().size() - 1);
EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
F1->getInstructionCount() - 2);
EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
}
TEST_F(FunctionPropertiesAnalysisTest, InlineSameLoopBB) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
declare i32 @a()
declare i32 @b()
define i32 @f1(i32 %a) {
entry:
br label %loop
loop:
%i = call i32 @f2(i32 %a)
%c = icmp slt i32 %i, %a
br i1 %c, label %loop, label %end
end:
%r = phi i32 [%i, %loop], [%a, %entry]
ret i32 %r
}
define i32 @f2(i32 %a) {
%cnd = icmp slt i32 %a, 0
br i1 %cnd, label %then, label %else
then:
%r1 = call i32 @a()
br label %end
else:
%r2 = call i32 @b()
br label %end
end:
%r = phi i32 [%r1, %then], [%r2, %else]
ret i32 %r
}
)IR");
Function *F1 = M->getFunction("f1");
CallBase *CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 3;
ExpectedInitial.TotalInstructionCount = 6;
ExpectedInitial.BlocksReachedFromConditionalInstruction = 2;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
ExpectedInitial.MaxLoopDepth = 1;
ExpectedInitial.TopLevelLoopCount = 1;
FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
ExpectedFinal.BasicBlockCount = 6;
ExpectedFinal.DirectCallsToDefinedFunctions = 0;
ExpectedFinal.BlocksReachedFromConditionalInstruction = 4;
ExpectedFinal.TotalInstructionCount = 12;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
TEST_F(FunctionPropertiesAnalysisTest, Unreachable) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
define i64 @f1(i32 noundef %value) {
entry:
br i1 true, label %cond.true, label %cond.false
cond.true: ; preds = %entry
%conv2 = sext i32 %value to i64
br label %cond.end
cond.false: ; preds = %entry
%call3 = call noundef i64 @f2()
br label %extra
extra:
br label %extra2
extra2:
br label %cond.end
cond.end: ; preds = %cond.false, %cond.true
%cond = phi i64 [ %conv2, %cond.true ], [ %call3, %extra ]
ret i64 %cond
}
define i64 @f2() {
entry:
tail call void @llvm.trap()
unreachable
}
declare void @llvm.trap()
)IR");
Function *F1 = M->getFunction("f1");
CallBase *CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 6;
ExpectedInitial.TotalInstructionCount = 9;
ExpectedInitial.BlocksReachedFromConditionalInstruction = 2;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
ExpectedFinal.BasicBlockCount = 4;
ExpectedFinal.DirectCallsToDefinedFunctions = 0;
ExpectedFinal.TotalInstructionCount = 7;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
TEST_F(FunctionPropertiesAnalysisTest, InvokeSkipLP) {
LLVMContext C;
std::unique_ptr<Module> M = makeLLVMModule(C,
R"IR(
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
define i64 @f1(i32 noundef %value) {
entry:
invoke fastcc void @f2() to label %cont unwind label %lpad
cont:
ret i64 1
lpad:
%lp = landingpad i32 cleanup
br label %ehcleanup
ehcleanup:
resume i32 0
}
define void @f2() {
invoke noundef void @f3() to label %exit unwind label %lpad
exit:
ret void
lpad:
%lp = landingpad i32 cleanup
resume i32 %lp
}
declare void @f3()
)IR");
// The outcome of inlining will be that lpad becomes unreachable. The landing
// pad of the invoke inherited from f2 will land on a new bb which will branch
// to a bb containing the body of lpad.
Function *F1 = M->getFunction("f1");
CallBase *CB = findCall(*F1);
EXPECT_NE(CB, nullptr);
FunctionPropertiesInfo ExpectedInitial;
ExpectedInitial.BasicBlockCount = 4;
ExpectedInitial.TotalInstructionCount = 5;
ExpectedInitial.BlocksReachedFromConditionalInstruction = 0;
ExpectedInitial.Uses = 1;
ExpectedInitial.DirectCallsToDefinedFunctions = 1;
FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
ExpectedFinal.BasicBlockCount = 6;
ExpectedFinal.DirectCallsToDefinedFunctions = 0;
ExpectedFinal.TotalInstructionCount = 8;
auto FPI = buildFPI(*F1);
EXPECT_EQ(FPI, ExpectedInitial);
FunctionPropertiesUpdater FPU(FPI, *CB);
InlineFunctionInfo IFI;
auto IR = llvm::InlineFunction(*CB, IFI);
EXPECT_TRUE(IR.isSuccess());
invalidate(*F1);
FPU.finish(FAM);
EXPECT_EQ(FPI, ExpectedFinal);
}
} // end anonymous namespace
Reference in New Issue View Git Blame Copy Permalink