blob: 71664817bf4662be36eea44b7fb5ee9c62706978 (
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
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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===-- llvm/CodeGen/AssignmentTrackingAnalysis.h --------------*- C++ -*--===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
#define LLVM_CODEGEN_ASSIGNMENTTRACKINGANALYSIS_H
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Pass.h"
namespace llvm {
class Instruction;
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;
RawLocationWrapper Values = RawLocationWrapper();
};
/// 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 DebugAssignmentTrackingAnalysis
: public AnalysisInfoMixin<DebugAssignmentTrackingAnalysis> {
friend AnalysisInfoMixin<DebugAssignmentTrackingAnalysis>;
static AnalysisKey Key;
public:
using Result = FunctionVarLocs;
Result run(Function &F, FunctionAnalysisManager &FAM);
};
class DebugAssignmentTrackingPrinterPass
: public PassInfoMixin<DebugAssignmentTrackingPrinterPass> {
raw_ostream &OS;
public:
DebugAssignmentTrackingPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
};
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
|
