LLVM 19.0.0git
LVCodeViewVisitor.h
Go to the documentation of this file.
1//===-- LVCodeViewVisitor.h -------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the LVCodeViewVisitor class, which is used to describe a
10// debug information (CodeView) visitor.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_CODEVIEWVISITOR_H
15#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_CODEVIEWVISITOR_H
16
17#include "llvm/ADT/iterator.h"
24#include "llvm/Object/Binary.h"
26#include "llvm/Support/Error.h"
27#include <stack>
28#include <utility>
29
30namespace llvm {
31namespace logicalview {
32
33using namespace llvm::codeview;
34
35class LVCodeViewReader;
36class LVLogicalVisitor;
37struct LVShared;
38
39class LVTypeVisitor final : public TypeVisitorCallbacks {
41 LVLogicalVisitor *LogicalVisitor;
44 uint32_t StreamIdx;
45 LVShared *Shared = nullptr;
46
47 // In a PDB, a type index may refer to a type (TPI) or an item ID (IPI).
48 // In a COFF or PDB (/Z7), the type index always refer to a type (TPI).
49 // When creating logical elements, we must access the correct element
50 // table, while searching for a type index.
51 bool HasIds = false;
52
53 // Current type index during the types traversal.
54 TypeIndex CurrentTypeIndex = TypeIndex::None();
55
56 void printTypeIndex(StringRef FieldName, TypeIndex TI,
57 uint32_t StreamIdx) const;
58
59public:
62 uint32_t StreamIdx, LVShared *Shared)
63 : TypeVisitorCallbacks(), W(W), LogicalVisitor(LogicalVisitor),
64 Types(Types), Ids(Ids), StreamIdx(StreamIdx), Shared(Shared) {
65 HasIds = &Types != &Ids;
66 }
67
73
83};
84
86 LVCodeViewReader *Reader;
87 const llvm::object::coff_section *CoffSection;
88 StringRef SectionContents;
89
90public:
92 const llvm::object::SectionRef &Section,
94 StringRef SectionContents)
95 : Reader(Reader), SectionContents(SectionContents) {
96 CoffSection = Obj->getCOFFSection(Section);
97 }
98
101 if (Error Err = Reader.readLongestContiguousChunk(Data)) {
102 llvm::consumeError(std::move(Err));
103 return 0;
104 }
105 return Data.data() - SectionContents.bytes_begin();
106 }
107
108 void printRelocatedField(StringRef Label, uint32_t RelocOffset,
109 uint32_t Offset, StringRef *RelocSym = nullptr);
110
111 void getLinkageName(uint32_t RelocOffset, uint32_t Offset,
112 StringRef *RelocSym = nullptr);
113
114 StringRef getFileNameForFileOffset(uint32_t FileOffset) override;
116};
117
118class LVElement;
119class LVScope;
120class LVSymbol;
121class LVType;
122
123// Visitor for CodeView symbol streams found in COFF object files and PDB files.
125 LVCodeViewReader *Reader;
126 ScopedPrinter &W;
127 LVLogicalVisitor *LogicalVisitor;
130 LVSymbolVisitorDelegate *ObjDelegate;
131 LVShared *Shared;
132
133 // Symbol offset when processing PDB streams.
134 uint32_t CurrentOffset = 0;
135 // Current object name collected from S_OBJNAME.
136 StringRef CurrentObjectName;
137 // Last symbol processed by S_LOCAL.
138 LVSymbol *LocalSymbol = nullptr;
139
140 bool HasIds;
141 bool InFunctionScope = false;
142 bool IsCompileUnit = false;
143
144 // Register for the locals and parameters symbols in the current frame.
145 RegisterId LocalFrameRegister = RegisterId::NONE;
146 RegisterId ParamFrameRegister = RegisterId::NONE;
147
148 void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
149 uint32_t RelocationOffset);
150 void printLocalVariableAddrGap(ArrayRef<LocalVariableAddrGap> Gaps);
151 void printTypeIndex(StringRef FieldName, TypeIndex TI) const;
152
153 // Return true if this symbol is a Compile Unit.
154 bool symbolIsCompileUnit(SymbolKind Kind) {
155 switch (Kind) {
156 case SymbolKind::S_COMPILE2:
157 case SymbolKind::S_COMPILE3:
158 return true;
159 default:
160 return false;
161 }
162 }
163
164 // Determine symbol kind (local or parameter).
165 void determineSymbolKind(LVSymbol *Symbol, RegisterId Register) {
166 if (Register == LocalFrameRegister) {
167 Symbol->setIsVariable();
168 return;
169 }
170 if (Register == ParamFrameRegister) {
171 Symbol->setIsParameter();
172 return;
173 }
174 // Assume is a variable.
175 Symbol->setIsVariable();
176 }
177
178public:
180 LVLogicalVisitor *LogicalVisitor,
183 LVSymbolVisitorDelegate *ObjDelegate, LVShared *Shared)
184 : Reader(Reader), W(W), LogicalVisitor(LogicalVisitor), Types(Types),
185 Ids(Ids), ObjDelegate(ObjDelegate), Shared(Shared) {
186 HasIds = &Types != &Ids;
187 }
188
193
196 Error visitKnownRecord(CVSymbol &Record, BuildInfoSym &BuildInfo) override;
197 Error visitKnownRecord(CVSymbol &Record, Compile2Sym &Compile2) override;
198 Error visitKnownRecord(CVSymbol &Record, Compile3Sym &Compile3) override;
203 &DefRangeFramePointerRelFullScope) override;
206 DefRangeFramePointerRelSym &DefRangeFramePointerRel) override;
208 DefRangeRegisterRelSym &DefRangeRegisterRel) override;
210 DefRangeRegisterSym &DefRangeRegister) override;
213 DefRangeSubfieldRegisterSym &DefRangeSubfieldRegister) override;
215 DefRangeSubfieldSym &DefRangeSubfield) override;
216 Error visitKnownRecord(CVSymbol &Record, DefRangeSym &DefRange) override;
217 Error visitKnownRecord(CVSymbol &Record, FrameProcSym &FrameProc) override;
220 Error visitKnownRecord(CVSymbol &Record, ObjNameSym &ObjName) override;
221 Error visitKnownRecord(CVSymbol &Record, ProcSym &Proc) override;
223 Error visitKnownRecord(CVSymbol &Record, ScopeEndSym &ScopeEnd) override;
227 Error visitKnownRecord(CVSymbol &Record, JumpTableSym &JumpTable) override;
228 Error visitKnownRecord(CVSymbol &Record, CallerSym &Caller) override;
229};
230
231// Visitor for CodeView types and symbols to populate elements.
232class LVLogicalVisitor final {
233 LVCodeViewReader *Reader;
234 ScopedPrinter &W;
235
236 // Encapsulates access to the input file and any dependent type server,
237 // including any precompiled header object.
239 std::shared_ptr<llvm::pdb::InputFile> TypeServer = nullptr;
240 std::shared_ptr<LazyRandomTypeCollection> PrecompHeader = nullptr;
241
242 std::shared_ptr<LVShared> Shared;
243
244 // Object files have only one type stream that contains both types and ids.
245 // Precompiled header objects don't contain an IPI stream. Use the TPI.
246 LazyRandomTypeCollection &types() {
247 return TypeServer ? TypeServer->types()
248 : (PrecompHeader ? *PrecompHeader : Input.types());
249 }
251 return TypeServer ? TypeServer->ids()
252 : (PrecompHeader ? *PrecompHeader : Input.ids());
253 }
254
255 using LVScopeStack = std::stack<LVScope *>;
256 LVScopeStack ScopeStack;
257 LVScope *ReaderParent = nullptr;
258 LVScope *ReaderScope = nullptr;
259 bool InCompileUnitScope = false;
260
261 // Allow processing of argument list.
262 bool ProcessArgumentList = false;
263 StringRef OverloadedMethodName;
264 std::string CompileUnitName;
265
266 // Inlined functions source information.
267 using LVInlineeEntry = std::pair<uint32_t, StringRef>;
268 using LVInlineeInfo = std::map<TypeIndex, LVInlineeEntry>;
269 LVInlineeInfo InlineeInfo;
270
271 Error visitFieldListMemberStream(TypeIndex TI, LVElement *Element,
273
274 LVType *createBaseType(TypeIndex TI, StringRef TypeName);
275 LVType *createPointerType(TypeIndex TI, StringRef TypeName);
276 LVSymbol *createParameter(TypeIndex TI, StringRef Name, LVScope *Parent);
277 LVSymbol *createParameter(LVElement *Element, StringRef Name,
278 LVScope *Parent);
279 void createDataMember(CVMemberRecord &Record, LVScope *Parent, StringRef Name,
280 TypeIndex Type, MemberAccess Access);
281 void createParents(StringRef ScopedName, LVElement *Element);
282
283public:
285 llvm::pdb::InputFile &Input);
286
287 // Current elements during the processing of a RecordType or RecordSymbol.
288 // They are shared with the SymbolVisitor.
292 LVType *CurrentType = nullptr;
293
294 // Input source in the case of type server or precompiled header.
295 void setInput(std::shared_ptr<llvm::pdb::InputFile> TypeServer) {
296 this->TypeServer = TypeServer;
297 }
298 void setInput(std::shared_ptr<LazyRandomTypeCollection> PrecompHeader) {
299 this->PrecompHeader = PrecompHeader;
300 }
301
303 InlineeInfo.emplace(std::piecewise_construct, std::forward_as_tuple(TI),
304 std::forward_as_tuple(LineNumber, Filename));
305 }
306
307 void printTypeIndex(StringRef FieldName, TypeIndex TI, uint32_t StreamIdx);
311
315
316 // Break down the annotation byte code and calculate code and line offsets.
317 Error inlineSiteAnnotation(LVScope *AbstractFunction,
318 LVScope *InlinedFunction,
320
321 void pushScope(LVScope *Scope) {
322 ScopeStack.push(ReaderParent);
323 ReaderParent = ReaderScope;
324 ReaderScope = Scope;
325 }
326 void popScope() {
327 ReaderScope = ReaderParent;
328 ReaderParent = ScopeStack.top();
329 ScopeStack.pop();
330 }
331 void closeScope() {
332 if (InCompileUnitScope) {
333 InCompileUnitScope = false;
334 popScope();
335 }
336 }
337 void setRoot(LVScope *Root) { ReaderScope = Root; }
338
339 void addElement(LVScope *Scope, bool IsCompileUnit);
340 void addElement(LVSymbol *Symbol);
341 void addElement(LVType *Type);
342
343 std::string getCompileUnitName() { return CompileUnitName; }
344 void setCompileUnitName(std::string Name) {
345 CompileUnitName = std::move(Name);
346 }
347
348 LVElement *getElement(uint32_t StreamIdx, TypeIndex TI,
349 LVScope *Parent = nullptr);
350 LVShared *getShared() { return Shared.get(); }
351
352 LVScope *getReaderScope() const { return ReaderScope; }
353
354 void printTypeBegin(CVType &Record, TypeIndex TI, LVElement *Element,
355 uint32_t StreamIdx);
358 LVElement *Element, uint32_t StreamIdx);
360
361 void startProcessArgumentList() { ProcessArgumentList = true; }
362 void stopProcessArgumentList() { ProcessArgumentList = false; }
363
364 void processFiles();
365 void processLines();
366 void processNamespaces();
367
368 void printRecords(raw_ostream &OS) const;
369
372 LVElement *Element);
374 LVElement *Element);
376 LVElement *Element);
378 LVElement *Element);
380 LVElement *Element);
382 LVElement *Element);
384 TypeIndex TI, LVElement *Element);
386 LVElement *Element);
388 LVElement *Element);
390 LVElement *Element);
392 LVElement *Element);
394 LVElement *Element);
396 TypeIndex TI, LVElement *Element);
398 LVElement *Element);
400 LVElement *Element);
402 LVElement *Element);
404 LVElement *Element);
406 LVElement *Element);
408 TypeIndex TI, LVElement *Element);
410 TypeIndex TI, LVElement *Element);
412 LVElement *Element);
414 TypeIndex TI, LVElement *Element);
416 TypeIndex TI, LVElement *Element);
418 LVElement *Element);
420 TypeIndex TI, LVElement *Element);
421
424 TypeIndex TI, LVElement *Element);
426 TypeIndex TI, LVElement *Element);
428 TypeIndex TI, LVElement *Element);
430 TypeIndex TI, LVElement *Element);
432 TypeIndex TI, LVElement *Element);
434 TypeIndex TI, LVElement *Element);
436 TypeIndex TI, LVElement *Element);
438 TypeIndex TI, LVElement *Element);
440 TypeIndex TI, LVElement *Element);
442 TypeIndex TI, LVElement *Element);
443
444 template <typename T>
446 TypeVisitorCallbacks &Callbacks, TypeIndex TI,
447 LVElement *Element) {
448 TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Kind);
449 T KnownRecord(RK);
450 if (Error Err = Callbacks.visitKnownMember(Record, KnownRecord))
451 return Err;
452 if (Error Err = visitKnownMember(Record, KnownRecord, TI, Element))
453 return Err;
454 return Error::success();
455 }
456
457 template <typename T>
459 TypeRecordKind RK = static_cast<TypeRecordKind>(Record.kind());
460 T KnownRecord(RK);
462 const_cast<CVType &>(Record), KnownRecord))
463 return Err;
464 if (Error Err = visitKnownRecord(Record, KnownRecord, TI, Element))
465 return Err;
466 return Error::success();
467 }
468
470 TypeVisitorCallbacks &Callbacks, TypeIndex TI,
471 LVElement *Element);
473};
474
475} // namespace logicalview
476} // namespace llvm
477
478#endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_CODEVIEWVISITOR_H
static LVOptions Options
Definition: LVOptions.cpp:25
raw_pwrite_stream & OS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Provides read only access to a subclass of BinaryStream.
Error readLongestContiguousChunk(ArrayRef< uint8_t > &Buffer)
Read as much as possible from the underlying string at the current offset without invoking a copy,...
This is an important base class in LLVM.
Definition: Constant.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
const unsigned char * bytes_begin() const
Definition: StringRef.h:115
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Represents a read-only view of a CodeView string table.
Provides amortized O(1) random access to a CodeView type stream.
LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records together.
Definition: TypeRecord.h:915
For method overload sets. LF_METHOD.
Definition: TypeRecord.h:765
static Error deserializeAs(CVType &CVT, T &Record)
A 32-bit type reference.
Definition: TypeIndex.h:96
static TypeIndex None()
Definition: TypeIndex.h:148
void addInlineeInfo(TypeIndex TI, uint32_t LineNumber, StringRef Filename)
Error visitKnownRecord(CVType &Record, ArgListRecord &Args, TypeIndex TI, LVElement *Element)
void printRecords(raw_ostream &OS) const
Error visitMemberRecord(CVMemberRecord &Record, TypeVisitorCallbacks &Callbacks, TypeIndex TI, LVElement *Element)
Error visitKnownMember(CVMemberRecord &Record, BaseClassRecord &Base, TypeIndex TI, LVElement *Element)
void printMemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Options)
void printMemberEnd(CVMemberRecord &Record)
void setCompileUnitName(std::string Name)
void printMemberAttributes(MemberAttributes Attrs)
Error inlineSiteAnnotation(LVScope *AbstractFunction, LVScope *InlinedFunction, InlineSiteSym &InlineSite)
void printTypeIndex(StringRef FieldName, TypeIndex TI, uint32_t StreamIdx)
Error visitUnknownMember(CVMemberRecord &Record, TypeIndex TI)
void setInput(std::shared_ptr< LazyRandomTypeCollection > PrecompHeader)
Error visitKnownMember(CVMemberRecord &Record, TypeVisitorCallbacks &Callbacks, TypeIndex TI, LVElement *Element)
Error visitUnknownType(CVType &Record, TypeIndex TI)
void setInput(std::shared_ptr< llvm::pdb::InputFile > TypeServer)
void addElement(LVScope *Scope, bool IsCompileUnit)
void printTypeBegin(CVType &Record, TypeIndex TI, LVElement *Element, uint32_t StreamIdx)
LVElement * getElement(uint32_t StreamIdx, TypeIndex TI, LVScope *Parent=nullptr)
void printMemberBegin(CVMemberRecord &Record, TypeIndex TI, LVElement *Element, uint32_t StreamIdx)
Error finishVisitation(CVType &Record, TypeIndex TI, LVElement *Element)
Error visitKnownRecord(CVType &Record, TypeIndex TI, LVElement *Element)
LVElement * createElement(TypeLeafKind Kind)
LVSymbolVisitorDelegate(LVCodeViewReader *Reader, const llvm::object::SectionRef &Section, const llvm::object::COFFObjectFile *Obj, StringRef SectionContents)
void getLinkageName(uint32_t RelocOffset, uint32_t Offset, StringRef *RelocSym=nullptr)
uint32_t getRecordOffset(BinaryStreamReader Reader) override
void printRelocatedField(StringRef Label, uint32_t RelocOffset, uint32_t Offset, StringRef *RelocSym=nullptr)
DebugStringTableSubsectionRef getStringTable() override
StringRef getFileNameForFileOffset(uint32_t FileOffset) override
Error visitSymbolEnd(CVSymbol &Record) override
LVSymbolVisitor(LVCodeViewReader *Reader, ScopedPrinter &W, LVLogicalVisitor *LogicalVisitor, LazyRandomTypeCollection &Types, LazyRandomTypeCollection &Ids, LVSymbolVisitorDelegate *ObjDelegate, LVShared *Shared)
Error visitKnownRecord(CVSymbol &Record, BlockSym &Block) override
Error visitSymbolBegin(CVSymbol &Record) override
Error visitUnknownSymbol(CVSymbol &Record) override
Action to take on unknown symbols. By default, they are ignored.
Error visitMemberEnd(CVMemberRecord &Record) override
LVTypeVisitor(ScopedPrinter &W, LVLogicalVisitor *LogicalVisitor, LazyRandomTypeCollection &Types, LazyRandomTypeCollection &Ids, uint32_t StreamIdx, LVShared *Shared)
Error visitUnknownMember(CVMemberRecord &Record) override
Error visitTypeBegin(CVType &Record) override
Paired begin/end actions for all types.
Error visitMemberBegin(CVMemberRecord &Record) override
Error visitKnownRecord(CVType &Record, BuildInfoRecord &Args) override
Error visitUnknownType(CVType &Record) override
Action to take on unknown types. By default, they are ignored.
const coff_section * getCOFFSection(const SectionRef &Section) const
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
codeview::LazyRandomTypeCollection & types()
Definition: InputFile.cpp:457
codeview::LazyRandomTypeCollection & ids()
Definition: InputFile.cpp:461
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
MethodKind
Part of member attribute flags. (CV_methodprop_e)
Definition: CodeView.h:280
MethodOptions
Equivalent to CV_fldattr_t bitfield.
Definition: CodeView.h:291
MemberAccess
Source-level access specifier. (CV_access_e)
Definition: CodeView.h:272
TypeLeafKind
Duplicate copy of the above enum, but using the official CV names.
Definition: CodeView.h:34
TypeRecordKind
Distinguishes individual records in .debug$T or .debug$P section or PDB type stream.
Definition: CodeView.h:27
SymbolKind
Duplicate copy of the above enum, but using the official CV names.
Definition: CodeView.h:48
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::tuple< uint64_t, uint32_t > InlineSite
Definition: MCPseudoProbe.h:99
@ Mod
The access may modify the value stored in memory.
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
Equvalent to CV_fldattr_t in cvinfo.h.
Definition: TypeRecord.h:40