1 //===-- PDBContext.cpp ------------------------------------------*- 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 #include "llvm/DebugInfo/PDB/PDBContext.h"
10 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
11 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
12 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
13 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
14 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
15 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
16 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
17 #include "llvm/Object/COFF.h"
18
19 using namespace llvm;
20 using namespace llvm::object;
21 using namespace llvm::pdb;
22
PDBContext(const COFFObjectFile & Object,std::unique_ptr<IPDBSession> PDBSession)23 PDBContext::PDBContext(const COFFObjectFile &Object,
24 std::unique_ptr<IPDBSession> PDBSession)
25 : DIContext(CK_PDB), Session(std::move(PDBSession)) {
26 ErrorOr<uint64_t> ImageBase = Object.getImageBase();
27 if (ImageBase)
28 Session->setLoadAddress(ImageBase.get());
29 }
30
dump(raw_ostream & OS,DIDumpOptions DumpOpts)31 void PDBContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts){}
32
getLineInfoForAddress(object::SectionedAddress Address,DILineInfoSpecifier Specifier)33 DILineInfo PDBContext::getLineInfoForAddress(object::SectionedAddress Address,
34 DILineInfoSpecifier Specifier) {
35 DILineInfo Result;
36 Result.FunctionName = getFunctionName(Address.Address, Specifier.FNKind);
37
38 uint32_t Length = 1;
39 std::unique_ptr<PDBSymbol> Symbol =
40 Session->findSymbolByAddress(Address.Address, PDB_SymType::None);
41 if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(Symbol.get())) {
42 Length = Func->getLength();
43 } else if (auto Data = dyn_cast_or_null<PDBSymbolData>(Symbol.get())) {
44 Length = Data->getLength();
45 }
46
47 // If we couldn't find a symbol, then just assume 1 byte, so that we get
48 // only the line number of the first instruction.
49 auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Length);
50 if (!LineNumbers || LineNumbers->getChildCount() == 0)
51 return Result;
52
53 auto LineInfo = LineNumbers->getNext();
54 assert(LineInfo);
55 auto SourceFile = Session->getSourceFileById(LineInfo->getSourceFileId());
56
57 if (SourceFile &&
58 Specifier.FLIKind != DILineInfoSpecifier::FileLineInfoKind::None)
59 Result.FileName = SourceFile->getFileName();
60 Result.Column = LineInfo->getColumnNumber();
61 Result.Line = LineInfo->getLineNumber();
62 return Result;
63 }
64
65 DILineInfoTable
getLineInfoForAddressRange(object::SectionedAddress Address,uint64_t Size,DILineInfoSpecifier Specifier)66 PDBContext::getLineInfoForAddressRange(object::SectionedAddress Address,
67 uint64_t Size,
68 DILineInfoSpecifier Specifier) {
69 if (Size == 0)
70 return DILineInfoTable();
71
72 DILineInfoTable Table;
73 auto LineNumbers = Session->findLineNumbersByAddress(Address.Address, Size);
74 if (!LineNumbers || LineNumbers->getChildCount() == 0)
75 return Table;
76
77 while (auto LineInfo = LineNumbers->getNext()) {
78 DILineInfo LineEntry = getLineInfoForAddress(
79 {LineInfo->getVirtualAddress(), Address.SectionIndex}, Specifier);
80 Table.push_back(std::make_pair(LineInfo->getVirtualAddress(), LineEntry));
81 }
82 return Table;
83 }
84
85 DIInliningInfo
getInliningInfoForAddress(object::SectionedAddress Address,DILineInfoSpecifier Specifier)86 PDBContext::getInliningInfoForAddress(object::SectionedAddress Address,
87 DILineInfoSpecifier Specifier) {
88 DIInliningInfo InlineInfo;
89 DILineInfo CurrentLine = getLineInfoForAddress(Address, Specifier);
90
91 // Find the function at this address.
92 std::unique_ptr<PDBSymbol> ParentFunc =
93 Session->findSymbolByAddress(Address.Address, PDB_SymType::Function);
94 if (!ParentFunc) {
95 InlineInfo.addFrame(CurrentLine);
96 return InlineInfo;
97 }
98
99 auto Frames = ParentFunc->findInlineFramesByVA(Address.Address);
100 if (!Frames || Frames->getChildCount() == 0) {
101 InlineInfo.addFrame(CurrentLine);
102 return InlineInfo;
103 }
104
105 while (auto Frame = Frames->getNext()) {
106 uint32_t Length = 1;
107 auto LineNumbers = Frame->findInlineeLinesByVA(Address.Address, Length);
108 if (!LineNumbers || LineNumbers->getChildCount() == 0)
109 break;
110
111 std::unique_ptr<IPDBLineNumber> Line = LineNumbers->getNext();
112 assert(Line);
113
114 DILineInfo LineInfo;
115 LineInfo.FunctionName = Frame->getName();
116 auto SourceFile = Session->getSourceFileById(Line->getSourceFileId());
117 if (SourceFile &&
118 Specifier.FLIKind != DILineInfoSpecifier::FileLineInfoKind::None)
119 LineInfo.FileName = SourceFile->getFileName();
120 LineInfo.Line = Line->getLineNumber();
121 LineInfo.Column = Line->getColumnNumber();
122 InlineInfo.addFrame(LineInfo);
123 }
124
125 InlineInfo.addFrame(CurrentLine);
126 return InlineInfo;
127 }
128
129 std::vector<DILocal>
getLocalsForAddress(object::SectionedAddress Address)130 PDBContext::getLocalsForAddress(object::SectionedAddress Address) {
131 return std::vector<DILocal>();
132 }
133
getFunctionName(uint64_t Address,DINameKind NameKind) const134 std::string PDBContext::getFunctionName(uint64_t Address,
135 DINameKind NameKind) const {
136 if (NameKind == DINameKind::None)
137 return std::string();
138
139 std::unique_ptr<PDBSymbol> FuncSymbol =
140 Session->findSymbolByAddress(Address, PDB_SymType::Function);
141 auto *Func = dyn_cast_or_null<PDBSymbolFunc>(FuncSymbol.get());
142
143 if (NameKind == DINameKind::LinkageName) {
144 // It is not possible to get the mangled linkage name through a
145 // PDBSymbolFunc. For that we have to specifically request a
146 // PDBSymbolPublicSymbol.
147 auto PublicSym =
148 Session->findSymbolByAddress(Address, PDB_SymType::PublicSymbol);
149 if (auto *PS = dyn_cast_or_null<PDBSymbolPublicSymbol>(PublicSym.get())) {
150 // If we also have a function symbol, prefer the use of public symbol name
151 // only if it refers to the same address. The public symbol uses the
152 // linkage name while the function does not.
153 if (!Func || Func->getVirtualAddress() == PS->getVirtualAddress())
154 return PS->getName();
155 }
156 }
157
158 return Func ? Func->getName() : std::string();
159 }
160