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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
//===-- llvm/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "DbgValueHistoryCalculator.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/Support/Debug.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include <algorithm>
#include <map>
#define DEBUG_TYPE "dwarfdebug"
namespace llvm {
namespace {
// Maps physreg numbers to the variables they describe.
typedef std::map<unsigned, SmallVector<const MDNode *, 1>> RegDescribedVarsMap;
}
// \brief If @MI is a DBG_VALUE with debug value described by a
// defined register, returns the number of this register.
// In the other case, returns 0.
static unsigned isDescribedByReg(const MachineInstr &MI) {
assert(MI.isDebugValue());
assert(MI.getNumOperands() == 3);
// If location of variable is described using a register (directly or
// indirecltly), this register is always a first operand.
return MI.getOperand(0).isReg() ? MI.getOperand(0).getReg() : 0;
}
// \brief Claim that @Var is not described by @RegNo anymore.
static void dropRegDescribedVar(RegDescribedVarsMap &RegVars,
unsigned RegNo, const MDNode *Var) {
const auto &I = RegVars.find(RegNo);
assert(RegNo != 0U && I != RegVars.end());
auto &VarSet = I->second;
const auto &VarPos = std::find(VarSet.begin(), VarSet.end(), Var);
assert(VarPos != VarSet.end());
VarSet.erase(VarPos);
// Don't keep empty sets in a map to keep it as small as possible.
if (VarSet.empty())
RegVars.erase(I);
}
// \brief Claim that @Var is now described by @RegNo.
static void addRegDescribedVar(RegDescribedVarsMap &RegVars,
unsigned RegNo, const MDNode *Var) {
assert(RegNo != 0U);
RegVars[RegNo].push_back(Var);
}
static void clobberVariableLocation(SmallVectorImpl<const MachineInstr *> &VarHistory,
const MachineInstr &ClobberingInstr) {
assert(!VarHistory.empty());
// DBG_VALUE we're clobbering should belong to the same MBB.
assert(VarHistory.back()->isDebugValue());
assert(VarHistory.back()->getParent() == ClobberingInstr.getParent());
VarHistory.push_back(&ClobberingInstr);
}
// \brief Terminate the location range for variables described by register
// @RegNo by inserting @ClobberingInstr to their history.
static void clobberRegisterUses(RegDescribedVarsMap &RegVars, unsigned RegNo,
DbgValueHistoryMap &HistMap,
const MachineInstr &ClobberingInstr) {
const auto &I = RegVars.find(RegNo);
if (I == RegVars.end())
return;
// Iterate over all variables described by this register and add this
// instruction to their history, clobbering it.
for (const auto &Var : I->second)
clobberVariableLocation(HistMap[Var], ClobberingInstr);
RegVars.erase(I);
}
// \brief Terminate the location range for all variables, described by registers
// clobbered by @MI.
static void clobberRegisterUses(RegDescribedVarsMap &RegVars,
const MachineInstr &MI,
const TargetRegisterInfo *TRI,
DbgValueHistoryMap &HistMap) {
for (const MachineOperand &MO : MI.operands()) {
if (!MO.isReg() || !MO.isDef() || !MO.getReg())
continue;
for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
++AI) {
unsigned RegNo = *AI;
clobberRegisterUses(RegVars, RegNo, HistMap, MI);
}
}
}
// \brief Terminate the location range for all register-described variables
// by inserting @ClobberingInstr to their history.
static void clobberAllRegistersUses(RegDescribedVarsMap &RegVars,
DbgValueHistoryMap &HistMap,
const MachineInstr &ClobberingInstr) {
for (const auto &I : RegVars)
for (const auto &Var : I.second)
clobberVariableLocation(HistMap[Var], ClobberingInstr);
RegVars.clear();
}
// \brief Update the register that describes location of @Var in @RegVars map.
static void
updateRegForVariable(RegDescribedVarsMap &RegVars, const MDNode *Var,
const SmallVectorImpl<const MachineInstr *> &VarHistory,
const MachineInstr &MI) {
if (!VarHistory.empty()) {
const MachineInstr &Prev = *VarHistory.back();
// Check if Var is currently described by a register by instruction in the
// same basic block.
if (Prev.isDebugValue() && Prev.getDebugVariable() == Var &&
Prev.getParent() == MI.getParent()) {
if (unsigned PrevReg = isDescribedByReg(Prev))
dropRegDescribedVar(RegVars, PrevReg, Var);
}
}
assert(MI.getDebugVariable() == Var);
if (unsigned MIReg = isDescribedByReg(MI))
addRegDescribedVar(RegVars, MIReg, Var);
}
void calculateDbgValueHistory(const MachineFunction *MF,
const TargetRegisterInfo *TRI,
DbgValueHistoryMap &Result) {
RegDescribedVarsMap RegVars;
for (const auto &MBB : *MF) {
for (const auto &MI : MBB) {
if (!MI.isDebugValue()) {
// Not a DBG_VALUE instruction. It may clobber registers which describe
// some variables.
clobberRegisterUses(RegVars, MI, TRI, Result);
continue;
}
assert(MI.getNumOperands() > 1 && "Invalid DBG_VALUE instruction!");
const MDNode *Var = MI.getDebugVariable();
auto &History = Result[Var];
if (!History.empty() && History.back()->isIdenticalTo(&MI)) {
DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
<< "\t" << History.back() << "\t" << MI << "\n");
continue;
}
updateRegForVariable(RegVars, Var, History, MI);
History.push_back(&MI);
}
// Make sure locations for register-described variables are valid only
// until the end of the basic block (unless it's the last basic block, in
// which case let their liveness run off to the end of the function).
if (!MBB.empty() && &MBB != &MF->back())
clobberAllRegistersUses(RegVars, Result, MBB.back());
}
}
}
|
