lib/DebugInfo/PDB/PDBContext.cpp

   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
  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
  44 void PDBContext::dump(raw_ostream &OS, DIDumpType DumpType) {}
  45
  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
  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
  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
 106 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 }