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
|
//===-- CGProfile.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 "llvm/Transforms/Instrumentation/CGProfile.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/IR/PassManager.h"
#include "llvm/InitializePasses.h"
#include "llvm/ProfileData/InstrProf.h"
#include "llvm/Transforms/Instrumentation.h"
#include <array>
using namespace llvm;
static bool
addModuleFlags(Module &M,
MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) {
if (Counts.empty())
return false;
LLVMContext &Context = M.getContext();
MDBuilder MDB(Context);
std::vector<Metadata *> Nodes;
for (auto E : Counts) {
Metadata *Vals[] = {ValueAsMetadata::get(E.first.first),
ValueAsMetadata::get(E.first.second),
MDB.createConstant(ConstantInt::get(
Type::getInt64Ty(Context), E.second))};
Nodes.push_back(MDNode::get(Context, Vals));
}
M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes));
return true;
}
static bool runCGProfilePass(
Module &M, function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
function_ref<TargetTransformInfo &(Function &)> GetTTI, bool LazyBFI) {
MapVector<std::pair<Function *, Function *>, uint64_t> Counts;
InstrProfSymtab Symtab;
auto UpdateCounts = [&](TargetTransformInfo &TTI, Function *F,
Function *CalledF, uint64_t NewCount) {
if (!CalledF || !TTI.isLoweredToCall(CalledF) ||
CalledF->hasDLLImportStorageClass())
return;
uint64_t &Count = Counts[std::make_pair(F, CalledF)];
Count = SaturatingAdd(Count, NewCount);
};
// Ignore error here. Indirect calls are ignored if this fails.
(void)(bool) Symtab.create(M);
for (auto &F : M) {
// Avoid extra cost of running passes for BFI when the function doesn't have
// entry count. Since LazyBlockFrequencyInfoPass only exists in LPM, check
// if using LazyBlockFrequencyInfoPass.
// TODO: Remove LazyBFI when LazyBlockFrequencyInfoPass is available in NPM.
if (F.isDeclaration() || (LazyBFI && !F.getEntryCount()))
continue;
auto &BFI = GetBFI(F);
if (BFI.getEntryFreq() == 0)
continue;
TargetTransformInfo &TTI = GetTTI(F);
for (auto &BB : F) {
Optional<uint64_t> BBCount = BFI.getBlockProfileCount(&BB);
if (!BBCount)
continue;
for (auto &I : BB) {
CallBase *CB = dyn_cast<CallBase>(&I);
if (!CB)
continue;
if (CB->isIndirectCall()) {
InstrProfValueData ValueData[8];
uint32_t ActualNumValueData;
uint64_t TotalC;
if (!getValueProfDataFromInst(*CB, IPVK_IndirectCallTarget, 8,
ValueData, ActualNumValueData, TotalC))
continue;
for (const auto &VD :
ArrayRef<InstrProfValueData>(ValueData, ActualNumValueData)) {
UpdateCounts(TTI, &F, Symtab.getFunction(VD.Value), VD.Count);
}
continue;
}
UpdateCounts(TTI, &F, CB->getCalledFunction(), *BBCount);
}
}
}
return addModuleFlags(M, Counts);
}
namespace {
struct CGProfileLegacyPass final : public ModulePass {
static char ID;
CGProfileLegacyPass() : ModulePass(ID) {
initializeCGProfileLegacyPassPass(*PassRegistry::getPassRegistry());
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG();
AU.addRequired<LazyBlockFrequencyInfoPass>();
AU.addRequired<TargetTransformInfoWrapperPass>();
}
bool runOnModule(Module &M) override {
auto GetBFI = [this](Function &F) -> BlockFrequencyInfo & {
return this->getAnalysis<LazyBlockFrequencyInfoPass>(F).getBFI();
};
auto GetTTI = [this](Function &F) -> TargetTransformInfo & {
return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
};
return runCGProfilePass(M, GetBFI, GetTTI, true);
}
};
} // namespace
char CGProfileLegacyPass::ID = 0;
INITIALIZE_PASS(CGProfileLegacyPass, "cg-profile", "Call Graph Profile", false,
false)
ModulePass *llvm::createCGProfileLegacyPass() {
return new CGProfileLegacyPass();
}
PreservedAnalyses CGProfilePass::run(Module &M, ModuleAnalysisManager &MAM) {
FunctionAnalysisManager &FAM =
MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & {
return FAM.getResult<BlockFrequencyAnalysis>(F);
};
auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & {
return FAM.getResult<TargetIRAnalysis>(F);
};
runCGProfilePass(M, GetBFI, GetTTI, false);
return PreservedAnalyses::all();
}
|
