1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
//===- InlineCostTest.cpp - test for InlineCost ---------------------------===//
//
// 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/InlineCost.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/InlineModelFeatureMaps.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassInstrumentation.h"
#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"
namespace {
using namespace llvm;
CallBase *getCallInFunction(Function *F) {
for (auto &I : instructions(F)) {
if (auto *CB = dyn_cast<llvm::CallBase>(&I))
return CB;
}
return nullptr;
}
std::optional<InlineCostFeatures> getInliningCostFeaturesForCall(CallBase &CB) {
ModuleAnalysisManager MAM;
FunctionAnalysisManager FAM;
FAM.registerPass([&] { return TargetIRAnalysis(); });
FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
FAM.registerPass([&] { return AssumptionAnalysis(); });
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
MAM.registerPass([&] { return PassInstrumentationAnalysis(); });
FAM.registerPass([&] { return PassInstrumentationAnalysis(); });
ModulePassManager MPM;
MPM.run(*CB.getModule(), MAM);
auto GetAssumptionCache = [&](Function &F) -> AssumptionCache & {
return FAM.getResult<AssumptionAnalysis>(F);
};
auto &TIR = FAM.getResult<TargetIRAnalysis>(*CB.getFunction());
return getInliningCostFeatures(CB, TIR, GetAssumptionCache);
}
// Tests that we can retrieve the CostFeatures without an error
TEST(InlineCostTest, CostFeatures) {
const auto *const IR = R"IR(
define i32 @f(i32) {
ret i32 4
}
define i32 @g(i32) {
%2 = call i32 @f(i32 0)
ret i32 %2
}
)IR";
LLVMContext C;
SMDiagnostic Err;
std::unique_ptr<Module> M = parseAssemblyString(IR, Err, C);
ASSERT_TRUE(M);
auto *G = M->getFunction("g");
ASSERT_TRUE(G);
// find the call to f in g
CallBase *CB = getCallInFunction(G);
ASSERT_TRUE(CB);
const auto Features = getInliningCostFeaturesForCall(*CB);
// Check that the optional is not empty
ASSERT_TRUE(Features);
}
// Tests the calculated SROA cost
TEST(InlineCostTest, SROACost) {
using namespace llvm;
const auto *const IR = R"IR(
define void @f_savings(ptr %var) {
%load = load i32, ptr %var
%inc = add i32 %load, 1
store i32 %inc, ptr %var
ret void
}
define void @g_savings(i32) {
%var = alloca i32
call void @f_savings(ptr %var)
ret void
}
define void @f_losses(ptr %var) {
%load = load i32, ptr %var
%inc = add i32 %load, 1
store i32 %inc, ptr %var
call void @prevent_sroa(ptr %var)
ret void
}
define void @g_losses(i32) {
%var = alloca i32
call void @f_losses(ptr %var)
ret void
}
declare void @prevent_sroa(ptr)
)IR";
LLVMContext C;
SMDiagnostic Err;
std::unique_ptr<Module> M = parseAssemblyString(IR, Err, C);
ASSERT_TRUE(M);
const int DefaultInstCost = 5;
const int DefaultAllocaCost = 0;
const char *GName[] = {"g_savings", "g_losses", nullptr};
const int Savings[] = {2 * DefaultInstCost + DefaultAllocaCost, 0};
const int Losses[] = {0, 2 * DefaultInstCost + DefaultAllocaCost};
for (unsigned i = 0; GName[i]; ++i) {
auto *G = M->getFunction(GName[i]);
ASSERT_TRUE(G);
// find the call to f in g
CallBase *CB = getCallInFunction(G);
ASSERT_TRUE(CB);
const auto Features = getInliningCostFeaturesForCall(*CB);
ASSERT_TRUE(Features);
// Check the predicted SROA cost
auto GetFeature = [&](InlineCostFeatureIndex I) {
return (*Features)[static_cast<size_t>(I)];
};
ASSERT_EQ(GetFeature(InlineCostFeatureIndex::sroa_savings), Savings[i]);
ASSERT_EQ(GetFeature(InlineCostFeatureIndex::sroa_losses), Losses[i]);
}
}
} // namespace
|
