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
|
///===- DroppedVariableStatsIR.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
///
///===---------------------------------------------------------------------===//
/// \file
/// Dropped Variable Statistics for Debug Information. Reports any number
/// of #dbg_value that get dropped due to an optimization pass.
///
///===---------------------------------------------------------------------===//
#include "llvm/IR/DroppedVariableStatsIR.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassInstrumentation.h"
using namespace llvm;
template <typename IRUnitT>
const IRUnitT *DroppedVariableStatsIR::unwrapIR(Any IR) {
const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&IR);
return IRPtr ? *IRPtr : nullptr;
}
void DroppedVariableStatsIR::runBeforePass(StringRef P, Any IR) {
setup();
if (const auto *M = unwrapIR<Module>(IR))
return this->runOnModule(P, M, true);
if (const auto *F = unwrapIR<Function>(IR))
return this->runOnFunction(P, F, true);
}
void DroppedVariableStatsIR::runAfterPass(StringRef P, Any IR) {
if (const auto *M = unwrapIR<Module>(IR))
runAfterPassModule(P, M);
else if (const auto *F = unwrapIR<Function>(IR))
runAfterPassFunction(P, F);
cleanup();
}
void DroppedVariableStatsIR::runAfterPassFunction(StringRef PassID,
const Function *F) {
runOnFunction(PassID, F, false);
calculateDroppedVarStatsOnFunction(F, PassID, F->getName().str(), "Function");
}
void DroppedVariableStatsIR::runAfterPassModule(StringRef PassID,
const Module *M) {
runOnModule(PassID, M, false);
calculateDroppedVarStatsOnModule(M, PassID, M->getName().str(), "Module");
}
void DroppedVariableStatsIR::runOnFunction(StringRef PassID, const Function *F,
bool Before) {
auto &DebugVariables = DebugVariablesStack.back()[F];
auto FuncName = F->getName();
Func = F;
run(DebugVariables, FuncName, Before);
}
void DroppedVariableStatsIR::calculateDroppedVarStatsOnFunction(
const Function *F, StringRef PassID, StringRef FuncOrModName,
StringRef PassLevel) {
Func = F;
StringRef FuncName = F->getName();
DebugVariables &DbgVariables = DebugVariablesStack.back()[F];
calculateDroppedStatsAndPrint(DbgVariables, FuncName, PassID, FuncOrModName,
PassLevel, Func);
}
void DroppedVariableStatsIR::runOnModule(StringRef PassID, const Module *M,
bool Before) {
for (auto &F : *M) {
runOnFunction(PassID, &F, Before);
}
}
void DroppedVariableStatsIR::calculateDroppedVarStatsOnModule(
const Module *M, StringRef PassID, StringRef FuncOrModName,
StringRef PassLevel) {
for (auto &F : *M) {
calculateDroppedVarStatsOnFunction(&F, PassID, FuncOrModName, PassLevel);
}
}
void DroppedVariableStatsIR::registerCallbacks(
PassInstrumentationCallbacks &PIC) {
if (!DroppedVariableStatsEnabled)
return;
PIC.registerBeforeNonSkippedPassCallback(
[this](StringRef P, Any IR) { return runBeforePass(P, IR); });
PIC.registerAfterPassCallback(
[this](StringRef P, Any IR, const PreservedAnalyses &PA) {
return runAfterPass(P, IR);
});
PIC.registerAfterPassInvalidatedCallback(
[this](StringRef P, const PreservedAnalyses &PA) { return cleanup(); });
}
void DroppedVariableStatsIR::visitEveryInstruction(
unsigned &DroppedCount, DenseMap<VarID, DILocation *> &InlinedAtsMap,
VarID Var) {
const DIScope *DbgValScope = std::get<0>(Var);
for (const auto &I : instructions(Func)) {
auto *DbgLoc = I.getDebugLoc().get();
if (!DbgLoc)
continue;
if (updateDroppedCount(DbgLoc, DbgLoc->getScope(), DbgValScope,
InlinedAtsMap, Var, DroppedCount))
break;
}
}
void DroppedVariableStatsIR::visitEveryDebugRecord(
DenseSet<VarID> &VarIDSet,
DenseMap<StringRef, DenseMap<VarID, DILocation *>> &InlinedAtsMap,
StringRef FuncName, bool Before) {
for (const auto &I : instructions(Func)) {
for (DbgRecord &DR : I.getDbgRecordRange()) {
if (auto *Dbg = dyn_cast<DbgVariableRecord>(&DR)) {
auto *DbgVar = Dbg->getVariable();
auto DbgLoc = DR.getDebugLoc();
populateVarIDSetAndInlinedMap(DbgVar, DbgLoc, VarIDSet, InlinedAtsMap,
FuncName, Before);
}
}
}
}
|
