blob: d7f15023d30b5481c78fda6ab70e62b029165b8b (
plain) (
blame)
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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
#ifndef LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
#define LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/Pass.h"
namespace llvm {
class Function;
class Instruction;
class Value;
class raw_ostream;
} // namespace llvm
class FunctionVarLocsBuilder;
namespace llvm {
/// Type wrapper for integer ID for Variables. 0 is reserved.
enum class VariableID : unsigned { Reserved = 0 };
/// Variable location definition used by FunctionVarLocs.
struct VarLocInfo {
llvm::VariableID VariableID;
DIExpression *Expr = nullptr;
DebugLoc DL;
Value *V = nullptr; // TODO: Needs to be value_s_ for variadic expressions.
};
/// Data structure describing the variable locations in a function. Used as the
/// result of the AssignmentTrackingAnalysis pass. Essentially read-only
/// outside of AssignmentTrackingAnalysis where it is built.
class FunctionVarLocs {
/// Maps VarLocInfo.VariableID to a DebugVariable for VarLocRecords.
SmallVector<DebugVariable> Variables;
/// List of variable location changes grouped by the instruction the
/// change occurs before (see VarLocsBeforeInst). The elements from
/// zero to SingleVarLocEnd represent variables with a single location.
SmallVector<VarLocInfo> VarLocRecords;
/// End of range of VarLocRecords that represent variables with a single
/// location that is valid for the entire scope. Range starts at 0.
unsigned SingleVarLocEnd = 0;
/// Maps an instruction to a range of VarLocs that start just before it.
DenseMap<const Instruction *, std::pair<unsigned, unsigned>>
VarLocsBeforeInst;
public:
/// Return the DILocalVariable for the location definition represented by \p
/// ID.
DILocalVariable *getDILocalVariable(const VarLocInfo *Loc) const {
VariableID VarID = Loc->VariableID;
return getDILocalVariable(VarID);
}
/// Return the DILocalVariable of the variable represented by \p ID.
DILocalVariable *getDILocalVariable(VariableID ID) const {
return const_cast<DILocalVariable *>(getVariable(ID).getVariable());
}
/// Return the DebugVariable represented by \p ID.
const DebugVariable &getVariable(VariableID ID) const {
return Variables[static_cast<unsigned>(ID)];
}
///@name iterators
///@{
/// First single-location variable location definition.
const VarLocInfo *single_locs_begin() const { return VarLocRecords.begin(); }
/// One past the last single-location variable location definition.
const VarLocInfo *single_locs_end() const {
const auto *It = VarLocRecords.begin();
std::advance(It, SingleVarLocEnd);
return It;
}
/// First variable location definition that comes before \p Before.
const VarLocInfo *locs_begin(const Instruction *Before) const {
auto Span = VarLocsBeforeInst.lookup(Before);
const auto *It = VarLocRecords.begin();
std::advance(It, Span.first);
return It;
}
/// One past the last variable location definition that comes before \p
/// Before.
const VarLocInfo *locs_end(const Instruction *Before) const {
auto Span = VarLocsBeforeInst.lookup(Before);
const auto *It = VarLocRecords.begin();
std::advance(It, Span.second);
return It;
}
///@}
void print(raw_ostream &OS, const Function &Fn) const;
///@{
/// Non-const methods used by AssignmentTrackingAnalysis (which invalidate
/// analysis results if called incorrectly).
void init(FunctionVarLocsBuilder &Builder);
void clear();
///@}
};
class AssignmentTrackingAnalysis : public FunctionPass {
std::unique_ptr<FunctionVarLocs> Results;
public:
static char ID;
AssignmentTrackingAnalysis();
bool runOnFunction(Function &F) override;
static bool isRequired() { return true; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesAll();
}
const FunctionVarLocs *getResults() { return Results.get(); }
};
} // end namespace llvm
#endif // LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
