1 //===-- PDBContext.cpp ------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===/
9
10 #include "llvm/DebugInfo/PDB/PDBContext.h"
11 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
12 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
13 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
14 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
15 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
16 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
17 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
18 #include "llvm/Object/COFF.h"
19
20 using namespace llvm;
21 using namespace llvm::object;
22
PDBContext(const COFFObjectFile & Object,std::unique_ptr<IPDBSession> PDBSession,bool RelativeAddress)23 PDBContext::PDBContext(const COFFObjectFile &Object,
24 std::unique_ptr<IPDBSession> PDBSession,
25 bool RelativeAddress)
26 : DIContext(CK_PDB), Session(std::move(PDBSession)) {
27 if (!RelativeAddress) {
28 uint64_t ImageBase = 0;
29 if (Object.is64()) {
30 const pe32plus_header *Header = nullptr;
31 Object.getPE32PlusHeader(Header);
32 if (Header)
33 ImageBase = Header->ImageBase;
34 } else {
35 const pe32_header *Header = nullptr;
36 Object.getPE32Header(Header);
37 if (Header)
38 ImageBase = static_cast<uint64_t>(Header->ImageBase);
39 }
40 Session->setLoadAddress(ImageBase);
41 }
42 }
43
dump(raw_ostream & OS,DIDumpType DumpType)44 void PDBContext::dump(raw_ostream &OS, DIDumpType DumpType) {}
45
getLineInfoForAddress(uint64_t Address,DILineInfoSpecifier Specifier)46 DILineInfo PDBContext::getLineInfoForAddress(uint64_t Address,
47 DILineInfoSpecifier Specifier) {
48 DILineInfo Result;
49 Result.FunctionName = getFunctionName(Address, Specifier.FNKind);
50
51 uint32_t Length = 1;
52 std::unique_ptr<PDBSymbol> Symbol =
53 Session->findSymbolByAddress(Address, PDB_SymType::None);
54 if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(Symbol.get())) {
55 Length = Func->getLength();
56 } else if (auto Data = dyn_cast_or_null<PDBSymbolData>(Symbol.get())) {
57 Length = Data->getLength();
58 }
59
60 // If we couldn't find a symbol, then just assume 1 byte, so that we get
61 // only the line number of the first instruction.
62 auto LineNumbers = Session->findLineNumbersByAddress(Address, Length);
63 if (!LineNumbers || LineNumbers->getChildCount() == 0)
64 return Result;
65
66 auto LineInfo = LineNumbers->getNext();
67 assert(LineInfo);
68 auto SourceFile = Session->getSourceFileById(LineInfo->getSourceFileId());
69
70 if (SourceFile &&
71 Specifier.FLIKind != DILineInfoSpecifier::FileLineInfoKind::None)
72 Result.FileName = SourceFile->getFileName();
73 Result.Column = LineInfo->getColumnNumber();
74 Result.Line = LineInfo->getLineNumber();
75 return Result;
76 }
77
78 DILineInfoTable
getLineInfoForAddressRange(uint64_t Address,uint64_t Size,DILineInfoSpecifier Specifier)79 PDBContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
80 DILineInfoSpecifier Specifier) {
81 if (Size == 0)
82 return DILineInfoTable();
83
84 DILineInfoTable Table;
85 auto LineNumbers = Session->findLineNumbersByAddress(Address, Size);
86 if (!LineNumbers || LineNumbers->getChildCount() == 0)
87 return Table;
88
89 while (auto LineInfo = LineNumbers->getNext()) {
90 DILineInfo LineEntry =
91 getLineInfoForAddress(LineInfo->getVirtualAddress(), Specifier);
92 Table.push_back(std::make_pair(LineInfo->getVirtualAddress(), LineEntry));
93 }
94 return Table;
95 }
96
97 DIInliningInfo
getInliningInfoForAddress(uint64_t Address,DILineInfoSpecifier Specifier)98 PDBContext::getInliningInfoForAddress(uint64_t Address,
99 DILineInfoSpecifier Specifier) {
100 DIInliningInfo InlineInfo;
101 DILineInfo Frame = getLineInfoForAddress(Address, Specifier);
102 InlineInfo.addFrame(Frame);
103 return InlineInfo;
104 }
105
getFunctionName(uint64_t Address,DINameKind NameKind) const106 std::string PDBContext::getFunctionName(uint64_t Address,
107 DINameKind NameKind) const {
108 if (NameKind == DINameKind::None)
109 return std::string();
110
111 if (NameKind == DINameKind::LinkageName) {
112 // It is not possible to get the mangled linkage name through a
113 // PDBSymbolFunc. For that we have to specifically request a
114 // PDBSymbolPublicSymbol.
115 auto PublicSym =
116 Session->findSymbolByAddress(Address, PDB_SymType::PublicSymbol);
117 if (auto PS = dyn_cast_or_null<PDBSymbolPublicSymbol>(PublicSym.get()))
118 return PS->getName();
119 }
120
121 auto FuncSymbol =
122 Session->findSymbolByAddress(Address, PDB_SymType::Function);
123
124 // This could happen either if there was no public symbol (e.g. not
125 // external) or the user requested the short name. In the former case,
126 // although they technically requested the linkage name, if the linkage
127 // name is not available we fallback to at least returning a non-empty
128 // string.
129 if (auto Func = dyn_cast_or_null<PDBSymbolFunc>(FuncSymbol.get()))
130 return Func->getName();
131
132 return std::string();
133 }
134