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
|
//===-- 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/MDBuilder.h"
#include "llvm/IR/PassManager.h"
#include "llvm/InitializePasses.h"
#include "llvm/ProfileData/InstrProf.h"
#include "llvm/Transforms/Instrumentation.h"
#include <optional>
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",
MDTuple::getDistinct(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 (NewCount == 0)
return;
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) {
std::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);
}
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();
}
|
