Home | History | Annotate | Line # | Download | only in dsymutil 
      1 //===- tools/dsymutil/DebugMap.cpp - Generic debug map representation -----===//
      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 "DebugMap.h"
     10 #include "BinaryHolder.h"
     11 #include "llvm/ADT/Optional.h"
     12 #include "llvm/ADT/SmallString.h"
     13 #include "llvm/ADT/StringMap.h"
     14 #include "llvm/ADT/StringRef.h"
     15 #include "llvm/ADT/Triple.h"
     16 #include "llvm/ADT/iterator_range.h"
     17 #include "llvm/BinaryFormat/MachO.h"
     18 #include "llvm/Object/ObjectFile.h"
     19 #include "llvm/Support/Chrono.h"
     20 #include "llvm/Support/Error.h"
     21 #include "llvm/Support/Format.h"
     22 #include "llvm/Support/MemoryBuffer.h"
     23 #include "llvm/Support/Path.h"
     24 #include "llvm/Support/WithColor.h"
     25 #include "llvm/Support/YAMLTraits.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 #include <algorithm>
     28 #include <cinttypes>
     29 #include <cstdint>
     30 #include <memory>
     31 #include <string>
     32 #include <utility>
     33 #include <vector>
     34 
     35 namespace llvm {
     36 
     37 namespace dsymutil {
     38 
     39 using namespace llvm::object;
     40 
     41 DebugMapObject::DebugMapObject(StringRef ObjectFilename,
     42                                sys::TimePoint<std::chrono::seconds> Timestamp,
     43                                uint8_t Type)
     44     : Filename(std::string(ObjectFilename)), Timestamp(Timestamp), Type(Type) {}
     45 
     46 bool DebugMapObject::addSymbol(StringRef Name, Optional<uint64_t> ObjectAddress,
     47                                uint64_t LinkedAddress, uint32_t Size) {
     48   auto InsertResult = Symbols.insert(
     49       std::make_pair(Name, SymbolMapping(ObjectAddress, LinkedAddress, Size)));
     50 
     51   if (ObjectAddress && InsertResult.second)
     52     AddressToMapping[*ObjectAddress] = &*InsertResult.first;
     53   return InsertResult.second;
     54 }
     55 
     56 void DebugMapObject::print(raw_ostream &OS) const {
     57   OS << getObjectFilename() << ":\n";
     58   // Sort the symbols in alphabetical order, like llvm-nm (and to get
     59   // deterministic output for testing).
     60   using Entry = std::pair<StringRef, SymbolMapping>;
     61   std::vector<Entry> Entries;
     62   Entries.reserve(Symbols.getNumItems());
     63   for (const auto &Sym : Symbols)
     64     Entries.push_back(std::make_pair(Sym.getKey(), Sym.getValue()));
     65   llvm::sort(Entries, [](const Entry &LHS, const Entry &RHS) {
     66     return LHS.first < RHS.first;
     67   });
     68   for (const auto &Sym : Entries) {
     69     if (Sym.second.ObjectAddress)
     70       OS << format("\t%016" PRIx64, uint64_t(*Sym.second.ObjectAddress));
     71     else
     72       OS << "\t????????????????";
     73     OS << format(" => %016" PRIx64 "+0x%x\t%s\n",
     74                  uint64_t(Sym.second.BinaryAddress), uint32_t(Sym.second.Size),
     75                  Sym.first.data());
     76   }
     77   OS << '\n';
     78 }
     79 
     80 #ifndef NDEBUG
     81 void DebugMapObject::dump() const { print(errs()); }
     82 #endif
     83 
     84 DebugMapObject &
     85 DebugMap::addDebugMapObject(StringRef ObjectFilePath,
     86                             sys::TimePoint<std::chrono::seconds> Timestamp,
     87                             uint8_t Type) {
     88   Objects.emplace_back(new DebugMapObject(ObjectFilePath, Timestamp, Type));
     89   return *Objects.back();
     90 }
     91 
     92 const DebugMapObject::DebugMapEntry *
     93 DebugMapObject::lookupSymbol(StringRef SymbolName) const {
     94   StringMap<SymbolMapping>::const_iterator Sym = Symbols.find(SymbolName);
     95   if (Sym == Symbols.end())
     96     return nullptr;
     97   return &*Sym;
     98 }
     99 
    100 const DebugMapObject::DebugMapEntry *
    101 DebugMapObject::lookupObjectAddress(uint64_t Address) const {
    102   auto Mapping = AddressToMapping.find(Address);
    103   if (Mapping == AddressToMapping.end())
    104     return nullptr;
    105   return Mapping->getSecond();
    106 }
    107 
    108 void DebugMap::print(raw_ostream &OS) const {
    109   yaml::Output yout(OS, /* Ctxt = */ nullptr, /* WrapColumn = */ 0);
    110   yout << const_cast<DebugMap &>(*this);
    111 }
    112 
    113 #ifndef NDEBUG
    114 void DebugMap::dump() const { print(errs()); }
    115 #endif
    116 
    117 namespace {
    118 
    119 struct YAMLContext {
    120   StringRef PrependPath;
    121   Triple BinaryTriple;
    122 };
    123 
    124 } // end anonymous namespace
    125 
    126 ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
    127 DebugMap::parseYAMLDebugMap(StringRef InputFile, StringRef PrependPath,
    128                             bool Verbose) {
    129   auto ErrOrFile = MemoryBuffer::getFileOrSTDIN(InputFile);
    130   if (auto Err = ErrOrFile.getError())
    131     return Err;
    132 
    133   YAMLContext Ctxt;
    134 
    135   Ctxt.PrependPath = PrependPath;
    136 
    137   std::unique_ptr<DebugMap> Res;
    138   yaml::Input yin((*ErrOrFile)->getBuffer(), &Ctxt);
    139   yin >> Res;
    140 
    141   if (auto EC = yin.error())
    142     return EC;
    143   std::vector<std::unique_ptr<DebugMap>> Result;
    144   Result.push_back(std::move(Res));
    145   return std::move(Result);
    146 }
    147 
    148 } // end namespace dsymutil
    149 
    150 namespace yaml {
    151 
    152 // Normalize/Denormalize between YAML and a DebugMapObject.
    153 struct MappingTraits<dsymutil::DebugMapObject>::YamlDMO {
    154   YamlDMO(IO &io) { Timestamp = 0; }
    155   YamlDMO(IO &io, dsymutil::DebugMapObject &Obj);
    156   dsymutil::DebugMapObject denormalize(IO &IO);
    157 
    158   std::string Filename;
    159   int64_t Timestamp;
    160   std::vector<dsymutil::DebugMapObject::YAMLSymbolMapping> Entries;
    161 };
    162 
    163 void MappingTraits<std::pair<std::string, DebugMapObject::SymbolMapping>>::
    164     mapping(IO &io, std::pair<std::string, DebugMapObject::SymbolMapping> &s) {
    165   io.mapRequired("sym", s.first);
    166   io.mapOptional("objAddr", s.second.ObjectAddress);
    167   io.mapRequired("binAddr", s.second.BinaryAddress);
    168   io.mapOptional("size", s.second.Size);
    169 }
    170 
    171 void MappingTraits<dsymutil::DebugMapObject>::mapping(
    172     IO &io, dsymutil::DebugMapObject &DMO) {
    173   MappingNormalization<YamlDMO, dsymutil::DebugMapObject> Norm(io, DMO);
    174   io.mapRequired("filename", Norm->Filename);
    175   io.mapOptional("timestamp", Norm->Timestamp);
    176   io.mapRequired("symbols", Norm->Entries);
    177 }
    178 
    179 void ScalarTraits<Triple>::output(const Triple &val, void *, raw_ostream &out) {
    180   out << val.str();
    181 }
    182 
    183 StringRef ScalarTraits<Triple>::input(StringRef scalar, void *, Triple &value) {
    184   value = Triple(scalar);
    185   return StringRef();
    186 }
    187 
    188 size_t
    189 SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::size(
    190     IO &io, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq) {
    191   return seq.size();
    192 }
    193 
    194 dsymutil::DebugMapObject &
    195 SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::element(
    196     IO &, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq,
    197     size_t index) {
    198   if (index >= seq.size()) {
    199     seq.resize(index + 1);
    200     seq[index].reset(new dsymutil::DebugMapObject);
    201   }
    202   return *seq[index];
    203 }
    204 
    205 void MappingTraits<dsymutil::DebugMap>::mapping(IO &io,
    206                                                 dsymutil::DebugMap &DM) {
    207   io.mapRequired("triple", DM.BinaryTriple);
    208   io.mapOptional("binary-path", DM.BinaryPath);
    209   if (void *Ctxt = io.getContext())
    210     reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM.BinaryTriple;
    211   io.mapOptional("objects", DM.Objects);
    212 }
    213 
    214 void MappingTraits<std::unique_ptr<dsymutil::DebugMap>>::mapping(
    215     IO &io, std::unique_ptr<dsymutil::DebugMap> &DM) {
    216   if (!DM)
    217     DM.reset(new DebugMap());
    218   io.mapRequired("triple", DM->BinaryTriple);
    219   io.mapOptional("binary-path", DM->BinaryPath);
    220   if (void *Ctxt = io.getContext())
    221     reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM->BinaryTriple;
    222   io.mapOptional("objects", DM->Objects);
    223 }
    224 
    225 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::YamlDMO(
    226     IO &io, dsymutil::DebugMapObject &Obj) {
    227   Filename = Obj.Filename;
    228   Timestamp = sys::toTimeT(Obj.getTimestamp());
    229   Entries.reserve(Obj.Symbols.size());
    230   for (auto &Entry : Obj.Symbols)
    231     Entries.push_back(
    232         std::make_pair(std::string(Entry.getKey()), Entry.getValue()));
    233 }
    234 
    235 dsymutil::DebugMapObject
    236 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::denormalize(IO &IO) {
    237   BinaryHolder BinHolder(vfs::getRealFileSystem(), /* Verbose =*/false);
    238   const auto &Ctxt = *reinterpret_cast<YAMLContext *>(IO.getContext());
    239   SmallString<80> Path(Ctxt.PrependPath);
    240   StringMap<uint64_t> SymbolAddresses;
    241 
    242   sys::path::append(Path, Filename);
    243 
    244   auto ObjectEntry = BinHolder.getObjectEntry(Path);
    245   if (!ObjectEntry) {
    246     auto Err = ObjectEntry.takeError();
    247     WithColor::warning() << "Unable to open " << Path << " "
    248                          << toString(std::move(Err)) << '\n';
    249   } else {
    250     auto Object = ObjectEntry->getObject(Ctxt.BinaryTriple);
    251     if (!Object) {
    252       auto Err = Object.takeError();
    253       WithColor::warning() << "Unable to open " << Path << " "
    254                            << toString(std::move(Err)) << '\n';
    255     } else {
    256       for (const auto &Sym : Object->symbols()) {
    257         Expected<uint64_t> AddressOrErr = Sym.getValue();
    258         if (!AddressOrErr) {
    259           // TODO: Actually report errors helpfully.
    260           consumeError(AddressOrErr.takeError());
    261           continue;
    262         }
    263         Expected<StringRef> Name = Sym.getName();
    264         Expected<uint32_t> FlagsOrErr = Sym.getFlags();
    265         if (!Name || !FlagsOrErr ||
    266             (*FlagsOrErr & (SymbolRef::SF_Absolute | SymbolRef::SF_Common))) {
    267           // TODO: Actually report errors helpfully.
    268           if (!FlagsOrErr)
    269             consumeError(FlagsOrErr.takeError());
    270           if (!Name)
    271             consumeError(Name.takeError());
    272           continue;
    273         }
    274         SymbolAddresses[*Name] = *AddressOrErr;
    275       }
    276     }
    277   }
    278 
    279   dsymutil::DebugMapObject Res(Path, sys::toTimePoint(Timestamp), MachO::N_OSO);
    280   for (auto &Entry : Entries) {
    281     auto &Mapping = Entry.second;
    282     Optional<uint64_t> ObjAddress;
    283     if (Mapping.ObjectAddress)
    284       ObjAddress = *Mapping.ObjectAddress;
    285     auto AddressIt = SymbolAddresses.find(Entry.first);
    286     if (AddressIt != SymbolAddresses.end())
    287       ObjAddress = AddressIt->getValue();
    288     Res.addSymbol(Entry.first, ObjAddress, Mapping.BinaryAddress, Mapping.Size);
    289   }
    290   return Res;
    291 }
    292 
    293 } // end namespace yaml
    294 } // end namespace llvm
    295