lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

   1 //===- SymbolizableObjectFile.cpp -----------------------------------------===//
   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 // Implementation of SymbolizableObjectFile class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "SymbolizableObjectFile.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/Triple.h"
  18 #include "llvm/BinaryFormat/COFF.h"
  19 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
  20 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
  21 #include "llvm/Object/COFF.h"
  22 #include "llvm/Object/ObjectFile.h"
  23 #include "llvm/Object/SymbolSize.h"
  24 #include "llvm/Support/Casting.h"
  25 #include "llvm/Support/DataExtractor.h"
  26 #include "llvm/Support/Error.h"
  27 #include <algorithm>
  28 #include <cstdint>
  29 #include <memory>
  30 #include <string>
  31 #include <system_error>
  32 #include <utility>
  33 #include <vector>
  34
  35 using namespace llvm;
  36 using namespace object;
  37 using namespace symbolize;
  38
  39 static DILineInfoSpecifier
  40 getDILineInfoSpecifier(FunctionNameKind FNKind) {
  41   return DILineInfoSpecifier(
  42       DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FNKind);
  43 }
  44
  45 ErrorOr<std::unique_ptr<SymbolizableObjectFile>>
  46 SymbolizableObjectFile::create(object::ObjectFile *Obj,
  47                                std::unique_ptr<DIContext> DICtx) {
  48   std::unique_ptr<SymbolizableObjectFile> res(
  49       new SymbolizableObjectFile(Obj, std::move(DICtx)));
  50   std::unique_ptr<DataExtractor> OpdExtractor;
  51   uint64_t OpdAddress = 0;
  52   // Find the .opd (function descriptor) section if any, for big-endian
  53   // PowerPC64 ELF.
  54   if (Obj->getArch() == Triple::ppc64) {
  55     for (section_iterator Section : Obj->sections()) {
  56       StringRef Name;
  57       StringRef Data;
  58       if (auto EC = Section->getName(Name))
  59         return EC;
  60       if (Name == ".opd") {
  61         if (auto EC = Section->getContents(Data))
  62           return EC;
  63         OpdExtractor.reset(new DataExtractor(Data, Obj->isLittleEndian(),
  64                                              Obj->getBytesInAddress()));
  65         OpdAddress = Section->getAddress();
  66         break;
  67       }
  68     }
  69   }
  70   std::vector<std::pair<SymbolRef, uint64_t>> Symbols =
  71       computeSymbolSizes(*Obj);
  72   for (auto &P : Symbols)
  73     res->addSymbol(P.first, P.second, OpdExtractor.get(), OpdAddress);
  74
  75   // If this is a COFF object and we didn't find any symbols, try the export
  76   // table.
  77   if (Symbols.empty()) {
  78     if (auto *CoffObj = dyn_cast<COFFObjectFile>(Obj))
  79       if (auto EC = res->addCoffExportSymbols(CoffObj))
  80         return EC;
  81   }
  82   return std::move(res);
  83 }
  84
  85 SymbolizableObjectFile::SymbolizableObjectFile(ObjectFile *Obj,
  86                                                std::unique_ptr<DIContext> DICtx)
  87     : Module(Obj), DebugInfoContext(std::move(DICtx)) {}
  88
  89 namespace {
  90
  91 struct OffsetNamePair {
  92   uint32_t Offset;
  93   StringRef Name;
  94
  95   bool operator<(const OffsetNamePair &R) const {
  96     return Offset < R.Offset;
  97   }
  98 };
  99
 100 } // end anonymous namespace
 101
 102 std::error_code SymbolizableObjectFile::addCoffExportSymbols(
 103     const COFFObjectFile *CoffObj) {
 104   // Get all export names and offsets.
 105   std::vector<OffsetNamePair> ExportSyms;
 106   for (const ExportDirectoryEntryRef &Ref : CoffObj->export_directories()) {
 107     StringRef Name;
 108     uint32_t Offset;
 109     if (auto EC = Ref.getSymbolName(Name))
 110       return EC;
 111     if (auto EC = Ref.getExportRVA(Offset))
 112       return EC;
 113     ExportSyms.push_back(OffsetNamePair{Offset, Name});
 114   }
 115   if (ExportSyms.empty())
 116     return std::error_code();
 117
 118   // Sort by ascending offset.
 119   array_pod_sort(ExportSyms.begin(), ExportSyms.end());
 120
 121   // Approximate the symbol sizes by assuming they run to the next symbol.
 122   // FIXME: This assumes all exports are functions.
 123   uint64_t ImageBase = CoffObj->getImageBase();
 124   for (auto I = ExportSyms.begin(), E = ExportSyms.end(); I != E; ++I) {
 125     OffsetNamePair &Export = *I;
 126     // FIXME: The last export has a one byte size now.
 127     uint32_t NextOffset = I != E ? I->Offset : Export.Offset + 1;
 128     uint64_t SymbolStart = ImageBase + Export.Offset;
 129     uint64_t SymbolSize = NextOffset - Export.Offset;
 130     SymbolDesc SD = {SymbolStart, SymbolSize};
 131     Functions.insert(std::make_pair(SD, Export.Name));
 132   }
 133   return std::error_code();
 134 }
 135
 136 std::error_code SymbolizableObjectFile::addSymbol(const SymbolRef &Symbol,
 137                                                   uint64_t SymbolSize,
 138                                                   DataExtractor *OpdExtractor,
 139                                                   uint64_t OpdAddress) {
 140   Expected<SymbolRef::Type> SymbolTypeOrErr = Symbol.getType();
 141   if (!SymbolTypeOrErr)
 142     return errorToErrorCode(SymbolTypeOrErr.takeError());
 143   SymbolRef::Type SymbolType = *SymbolTypeOrErr;
 144   if (SymbolType != SymbolRef::ST_Function && SymbolType != SymbolRef::ST_Data)
 145     return std::error_code();
 146   Expected<uint64_t> SymbolAddressOrErr = Symbol.getAddress();
 147   if (!SymbolAddressOrErr)
 148     return errorToErrorCode(SymbolAddressOrErr.takeError());
 149   uint64_t SymbolAddress = *SymbolAddressOrErr;
 150   if (OpdExtractor) {
 151     // For big-endian PowerPC64 ELF, symbols in the .opd section refer to
 152     // function descriptors. The first word of the descriptor is a pointer to
 153     // the function's code.
 154     // For the purposes of symbolization, pretend the symbol's address is that
 155     // of the function's code, not the descriptor.
 156     uint64_t OpdOffset = SymbolAddress - OpdAddress;
 157     uint32_t OpdOffset32 = OpdOffset;
 158     if (OpdOffset == OpdOffset32 &&
 159         OpdExtractor->isValidOffsetForAddress(OpdOffset32))
 160       SymbolAddress = OpdExtractor->getAddress(&OpdOffset32);
 161   }
 162   Expected<StringRef> SymbolNameOrErr = Symbol.getName();
 163   if (!SymbolNameOrErr)
 164     return errorToErrorCode(SymbolNameOrErr.takeError());
 165   StringRef SymbolName = *SymbolNameOrErr;
 166   // Mach-O symbol table names have leading underscore, skip it.
 167   if (Module->isMachO() && !SymbolName.empty() && SymbolName[0] == '_')
 168     SymbolName = SymbolName.drop_front();
 169   // FIXME: If a function has alias, there are two entries in symbol table
 170   // with same address size. Make sure we choose the correct one.
 171   auto &M = SymbolType == SymbolRef::ST_Function ? Functions : Objects;
 172   SymbolDesc SD = { SymbolAddress, SymbolSize };
 173   M.insert(std::make_pair(SD, SymbolName));
 174   return std::error_code();
 175 }
 176
 177 // Return true if this is a 32-bit x86 PE COFF module.
 178 bool SymbolizableObjectFile::isWin32Module() const {
 179   auto *CoffObject = dyn_cast<COFFObjectFile>(Module);
 180   return CoffObject && CoffObject->getMachine() == COFF::IMAGE_FILE_MACHINE_I386;
 181 }
 182
 183 uint64_t SymbolizableObjectFile::getModulePreferredBase() const {
 184   if (auto *CoffObject = dyn_cast<COFFObjectFile>(Module))
 185     return CoffObject->getImageBase();
 186   return 0;
 187 }
 188
 189 bool SymbolizableObjectFile::getNameFromSymbolTable(SymbolRef::Type Type,
 190                                                     uint64_t Address,
 191                                                     std::string &Name,
 192                                                     uint64_t &Addr,
 193                                                     uint64_t &Size) const {
 194   const auto &SymbolMap = Type == SymbolRef::ST_Function ? Functions : Objects;
 195   if (SymbolMap.empty())
 196     return false;
 197   SymbolDesc SD = { Address, Address };
 198   auto SymbolIterator = SymbolMap.upper_bound(SD);
 199   if (SymbolIterator == SymbolMap.begin())
 200     return false;
 201   --SymbolIterator;
 202   if (SymbolIterator->first.Size != 0 &&
 203       SymbolIterator->first.Addr + SymbolIterator->first.Size <= Address)
 204     return false;
 205   Name = SymbolIterator->second.str();
 206   Addr = SymbolIterator->first.Addr;
 207   Size = SymbolIterator->first.Size;
 208   return true;
 209 }
 210
 211 bool SymbolizableObjectFile::shouldOverrideWithSymbolTable(
 212     FunctionNameKind FNKind, bool UseSymbolTable) const {
 213   // When DWARF is used with -gline-tables-only / -gmlt, the symbol table gives
 214   // better answers for linkage names than the DIContext. Otherwise, we are
 215   // probably using PEs and PDBs, and we shouldn't do the override. PE files
 216   // generally only contain the names of exported symbols.
 217   return FNKind == FunctionNameKind::LinkageName && UseSymbolTable &&
 218          isa<DWARFContext>(DebugInfoContext.get());
 219 }
 220
 221 DILineInfo SymbolizableObjectFile::symbolizeCode(uint64_t ModuleOffset,
 222                                                  FunctionNameKind FNKind,
 223                                                  bool UseSymbolTable) const {
 224   DILineInfo LineInfo;
 225   if (DebugInfoContext) {
 226     LineInfo = DebugInfoContext->getLineInfoForAddress(
 227         ModuleOffset, getDILineInfoSpecifier(FNKind));
 228   }
 229   // Override function name from symbol table if necessary.
 230   if (shouldOverrideWithSymbolTable(FNKind, UseSymbolTable)) {
 231     std::string FunctionName;
 232     uint64_t Start, Size;
 233     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset,
 234                                FunctionName, Start, Size)) {
 235       LineInfo.FunctionName = FunctionName;
 236     }
 237   }
 238   return LineInfo;
 239 }
 240
 241 DIInliningInfo SymbolizableObjectFile::symbolizeInlinedCode(
 242     uint64_t ModuleOffset, FunctionNameKind FNKind, bool UseSymbolTable) const {
 243   DIInliningInfo InlinedContext;
 244
 245   if (DebugInfoContext)
 246     InlinedContext = DebugInfoContext->getInliningInfoForAddress(
 247         ModuleOffset, getDILineInfoSpecifier(FNKind));
 248   // Make sure there is at least one frame in context.
 249   if (InlinedContext.getNumberOfFrames() == 0)
 250     InlinedContext.addFrame(DILineInfo());
 251
 252   // Override the function name in lower frame with name from symbol table.
 253   if (shouldOverrideWithSymbolTable(FNKind, UseSymbolTable)) {
 254     std::string FunctionName;
 255     uint64_t Start, Size;
 256     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset,
 257                                FunctionName, Start, Size)) {
 258       InlinedContext.getMutableFrame(InlinedContext.getNumberOfFrames() - 1)
 259           ->FunctionName = FunctionName;
 260     }
 261   }
 262
 263   return InlinedContext;
 264 }
 265
 266 DIGlobal SymbolizableObjectFile::symbolizeData(uint64_t ModuleOffset) const {
 267   DIGlobal Res;
 268   getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset, Res.Name, Res.Start,
 269                          Res.Size);
 270   return Res;
 271 }