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
|
//===- CVSymbolVisitor.cpp --------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
#include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
#include "llvm/Support/BinaryStreamArray.h"
#include "llvm/Support/ErrorHandling.h"
using namespace llvm;
using namespace llvm::codeview;
CVSymbolVisitor::CVSymbolVisitor(SymbolVisitorCallbacks &Callbacks)
: Callbacks(Callbacks) {}
template <typename T>
static Error visitKnownRecord(CVSymbol &Record,
SymbolVisitorCallbacks &Callbacks) {
SymbolRecordKind RK = static_cast<SymbolRecordKind>(Record.kind());
T KnownRecord(RK);
if (auto EC = Callbacks.visitKnownRecord(Record, KnownRecord))
return EC;
return Error::success();
}
static Error finishVisitation(CVSymbol &Record,
SymbolVisitorCallbacks &Callbacks) {
switch (Record.kind()) {
default:
if (auto EC = Callbacks.visitUnknownSymbol(Record))
return EC;
break;
#define SYMBOL_RECORD(EnumName, EnumVal, Name) \
case EnumName: { \
if (auto EC = visitKnownRecord<Name>(Record, Callbacks)) \
return EC; \
break; \
}
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName) \
SYMBOL_RECORD(EnumVal, EnumVal, AliasName)
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
}
if (auto EC = Callbacks.visitSymbolEnd(Record))
return EC;
return Error::success();
}
Error CVSymbolVisitor::visitSymbolRecord(CVSymbol &Record) {
if (auto EC = Callbacks.visitSymbolBegin(Record))
return EC;
return finishVisitation(Record, Callbacks);
}
Error CVSymbolVisitor::visitSymbolRecord(CVSymbol &Record, uint32_t Offset) {
if (auto EC = Callbacks.visitSymbolBegin(Record, Offset))
return EC;
return finishVisitation(Record, Callbacks);
}
Error CVSymbolVisitor::visitSymbolStream(const CVSymbolArray &Symbols) {
for (auto I : Symbols) {
if (auto EC = visitSymbolRecord(I))
return EC;
}
return Error::success();
}
Error CVSymbolVisitor::visitSymbolStream(const CVSymbolArray &Symbols,
uint32_t InitialOffset) {
for (auto I : Symbols) {
if (auto EC = visitSymbolRecord(I, InitialOffset + Symbols.skew()))
return EC;
InitialOffset += I.length();
}
return Error::success();
}
Error CVSymbolVisitor::visitSymbolStreamFiltered(const CVSymbolArray &Symbols,
const FilterOptions &Filter) {
if (!Filter.SymbolOffset)
return visitSymbolStream(Symbols);
uint32_t SymbolOffset = *Filter.SymbolOffset;
uint32_t ParentRecurseDepth = Filter.ParentRecursiveDepth.value_or(0);
uint32_t ChildrenRecurseDepth = Filter.ChildRecursiveDepth.value_or(0);
if (!Symbols.isOffsetValid(SymbolOffset))
return createStringError(inconvertibleErrorCode(), "Invalid symbol offset");
CVSymbol Sym = *Symbols.at(SymbolOffset);
uint32_t SymEndOffset =
symbolOpensScope(Sym.kind()) ? getScopeEndOffset(Sym) : 0;
std::vector<uint32_t> ParentOffsets;
std::vector<uint32_t> ParentEndOffsets;
uint32_t ChildrenDepth = 0;
for (auto Begin = Symbols.begin(), End = Symbols.end(); Begin != End;
++Begin) {
uint32_t BeginOffset = Begin.offset();
CVSymbol BeginSym = *Begin;
if (BeginOffset < SymbolOffset) {
if (symbolOpensScope(Begin->kind())) {
uint32_t EndOffset = getScopeEndOffset(BeginSym);
if (SymbolOffset < EndOffset) {
ParentOffsets.push_back(BeginOffset);
ParentEndOffsets.push_back(EndOffset);
}
}
} else if (BeginOffset == SymbolOffset) {
// Found symbol at offset. Visit its parent up to ParentRecurseDepth.
if (ParentRecurseDepth >= ParentOffsets.size())
ParentRecurseDepth = ParentOffsets.size();
uint32_t StartIndex = ParentOffsets.size() - ParentRecurseDepth;
while (StartIndex < ParentOffsets.size()) {
if (!Symbols.isOffsetValid(ParentOffsets[StartIndex]))
break;
CVSymbol Parent = *Symbols.at(ParentOffsets[StartIndex]);
if (auto EC = visitSymbolRecord(Parent, ParentOffsets[StartIndex]))
return EC;
++StartIndex;
}
if (auto EC = visitSymbolRecord(Sym, SymbolOffset))
return EC;
} else if (BeginOffset <= SymEndOffset) {
if (ChildrenRecurseDepth) {
// Visit children.
if (symbolEndsScope(Begin->kind()))
--ChildrenDepth;
if (ChildrenDepth < ChildrenRecurseDepth ||
BeginOffset == SymEndOffset) {
if (auto EC = visitSymbolRecord(BeginSym, BeginOffset))
return EC;
}
if (symbolOpensScope(Begin->kind()))
++ChildrenDepth;
}
} else {
// Visit parents' ends.
if (ParentRecurseDepth && BeginOffset == ParentEndOffsets.back()) {
if (auto EC = visitSymbolRecord(BeginSym, BeginOffset))
return EC;
ParentEndOffsets.pop_back();
--ParentRecurseDepth;
}
}
}
return Error::success();
}
|
