llvm/tools/dsymutil/BinaryHolder.cpp

   1 //===-- BinaryHolder.cpp --------------------------------------------------===//
   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 // This program is a utility that aims to be a dropin replacement for
  10 // Darwin's dsymutil.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "BinaryHolder.h"
  15 #include "llvm/Object/MachO.h"
  16 #include "llvm/Support/WithColor.h"
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 namespace llvm {
  20 namespace dsymutil {
  21
  22 static std::pair<StringRef, StringRef>
  23 getArchiveAndObjectName(StringRef Filename) {
  24   StringRef Archive = Filename.substr(0, Filename.rfind('('));
  25   StringRef Object = Filename.substr(Archive.size() + 1).drop_back();
  26   return {Archive, Object};
  27 }
  28
  29 static bool isArchive(StringRef Filename) { return Filename.endswith(")"); }
  30
  31 static std::vector<MemoryBufferRef>
  32 getMachOFatMemoryBuffers(StringRef Filename, MemoryBuffer &Mem,
  33                          object::MachOUniversalBinary &Fat) {
  34   std::vector<MemoryBufferRef> Buffers;
  35   StringRef FatData = Fat.getData();
  36   for (auto It = Fat.begin_objects(), End = Fat.end_objects(); It != End;
  37        ++It) {
  38     StringRef ObjData = FatData.substr(It->getOffset(), It->getSize());
  39     Buffers.emplace_back(ObjData, Filename);
  40   }
  41   return Buffers;
  42 }
  43
  44 Error BinaryHolder::ArchiveEntry::load(IntrusiveRefCntPtr<vfs::FileSystem> VFS,
  45                                        StringRef Filename,
  46                                        TimestampTy Timestamp, bool Verbose) {
  47   StringRef ArchiveFilename = getArchiveAndObjectName(Filename).first;
  48
  49   // Try to load archive and force it to be memory mapped.
  50   auto ErrOrBuff = (ArchiveFilename == "-")
  51                        ? MemoryBuffer::getSTDIN()
  52                        : VFS->getBufferForFile(ArchiveFilename, -1, false);
  53   if (auto Err = ErrOrBuff.getError())
  54     return errorCodeToError(Err);
  55
  56   MemBuffer = std::move(*ErrOrBuff);
  57
  58   if (Verbose)
  59     WithColor::note() << "loaded archive '" << ArchiveFilename << "'\n";
  60
  61   // Load one or more archive buffers, depending on whether we're dealing with
  62   // a fat binary.
  63   std::vector<MemoryBufferRef> ArchiveBuffers;
  64
  65   auto ErrOrFat =
  66       object::MachOUniversalBinary::create(MemBuffer->getMemBufferRef());
  67   if (!ErrOrFat) {
  68     consumeError(ErrOrFat.takeError());
  69     ArchiveBuffers.push_back(MemBuffer->getMemBufferRef());
  70   } else {
  71     FatBinary = std::move(*ErrOrFat);
  72     FatBinaryName = std::string(ArchiveFilename);
  73     ArchiveBuffers =
  74         getMachOFatMemoryBuffers(FatBinaryName, *MemBuffer, *FatBinary);
  75   }
  76
  77   // Finally, try to load the archives.
  78   Archives.reserve(ArchiveBuffers.size());
  79   for (auto MemRef : ArchiveBuffers) {
  80     auto ErrOrArchive = object::Archive::create(MemRef);
  81     if (!ErrOrArchive)
  82       return ErrOrArchive.takeError();
  83     Archives.push_back(std::move(*ErrOrArchive));
  84   }
  85
  86   return Error::success();
  87 }
  88
  89 Error BinaryHolder::ObjectEntry::load(IntrusiveRefCntPtr<vfs::FileSystem> VFS,
  90                                       StringRef Filename, TimestampTy Timestamp,
  91                                       bool Verbose) {
  92   // Try to load regular binary and force it to be memory mapped.
  93   auto ErrOrBuff = (Filename == "-")
  94                        ? MemoryBuffer::getSTDIN()
  95                        : VFS->getBufferForFile(Filename, -1, false);
  96   if (auto Err = ErrOrBuff.getError())
  97     return errorCodeToError(Err);
  98
  99   if (Filename != "-" && Timestamp != sys::TimePoint<>()) {
 100     llvm::ErrorOr<vfs::Status> Stat = VFS->status(Filename);
 101     if (!Stat)
 102       return errorCodeToError(Stat.getError());
 103     if (Timestamp != std::chrono::time_point_cast<std::chrono::seconds>(
 104                          Stat->getLastModificationTime()))
 105       WithColor::warning() << Filename
 106                            << ": timestamp mismatch between object file ("
 107                            << Stat->getLastModificationTime()
 108                            << ") and debug map (" << Timestamp << ")\n";
 109   }
 110
 111   MemBuffer = std::move(*ErrOrBuff);
 112
 113   if (Verbose)
 114     WithColor::note() << "loaded object.\n";
 115
 116   // Load one or more object buffers, depending on whether we're dealing with a
 117   // fat binary.
 118   std::vector<MemoryBufferRef> ObjectBuffers;
 119
 120   auto ErrOrFat =
 121       object::MachOUniversalBinary::create(MemBuffer->getMemBufferRef());
 122   if (!ErrOrFat) {
 123     consumeError(ErrOrFat.takeError());
 124     ObjectBuffers.push_back(MemBuffer->getMemBufferRef());
 125   } else {
 126     FatBinary = std::move(*ErrOrFat);
 127     FatBinaryName = std::string(Filename);
 128     ObjectBuffers =
 129         getMachOFatMemoryBuffers(FatBinaryName, *MemBuffer, *FatBinary);
 130   }
 131
 132   Objects.reserve(ObjectBuffers.size());
 133   for (auto MemRef : ObjectBuffers) {
 134     auto ErrOrObjectFile = object::ObjectFile::createObjectFile(MemRef);
 135     if (!ErrOrObjectFile)
 136       return ErrOrObjectFile.takeError();
 137     Objects.push_back(std::move(*ErrOrObjectFile));
 138   }
 139
 140   return Error::success();
 141 }
 142
 143 std::vector<const object::ObjectFile *>
 144 BinaryHolder::ObjectEntry::getObjects() const {
 145   std::vector<const object::ObjectFile *> Result;
 146   Result.reserve(Objects.size());
 147   for (auto &Object : Objects) {
 148     Result.push_back(Object.get());
 149   }
 150   return Result;
 151 }
 152 Expected<const object::ObjectFile &>
 153 BinaryHolder::ObjectEntry::getObject(const Triple &T) const {
 154   for (const auto &Obj : Objects) {
 155     if (const auto *MachO = dyn_cast<object::MachOObjectFile>(Obj.get())) {
 156       if (MachO->getArchTriple().str() == T.str())
 157         return *MachO;
 158     } else if (Obj->getArch() == T.getArch())
 159       return *Obj;
 160   }
 161   return errorCodeToError(object::object_error::arch_not_found);
 162 }
 163
 164 Expected<const BinaryHolder::ObjectEntry &>
 165 BinaryHolder::ArchiveEntry::getObjectEntry(StringRef Filename,
 166                                            TimestampTy Timestamp,
 167                                            bool Verbose) {
 168   StringRef ArchiveFilename;
 169   StringRef ObjectFilename;
 170   std::tie(ArchiveFilename, ObjectFilename) = getArchiveAndObjectName(Filename);
 171   KeyTy Key = {ObjectFilename, Timestamp};
 172
 173   // Try the cache first.
 174   std::lock_guard<std::mutex> Lock(MemberCacheMutex);
 175   if (MemberCache.count(Key))
 176     return *MemberCache[Key];
 177
 178   // Create a new ObjectEntry, but don't add it to the cache yet. Loading of
 179   // the archive members might fail and we don't want to lock the whole archive
 180   // during this operation.
 181   auto OE = std::make_unique<ObjectEntry>();
 182
 183   for (const auto &Archive : Archives) {
 184     Error Err = Error::success();
 185     for (const auto &Child : Archive->children(Err)) {
 186       if (auto NameOrErr = Child.getName()) {
 187         if (*NameOrErr == ObjectFilename) {
 188           auto ModTimeOrErr = Child.getLastModified();
 189           if (!ModTimeOrErr)
 190             return ModTimeOrErr.takeError();
 191
 192           if (Timestamp != sys::TimePoint<>() &&
 193               Timestamp != std::chrono::time_point_cast<std::chrono::seconds>(
 194                                ModTimeOrErr.get())) {
 195             if (Verbose)
 196               WithColor::warning()
 197                   << *NameOrErr
 198                   << ": timestamp mismatch between archive member ("
 199                   << ModTimeOrErr.get() << ") and debug map (" << Timestamp
 200                   << ")\n";
 201             continue;
 202           }
 203
 204           if (Verbose)
 205             WithColor::note() << "found member in archive.\n";
 206
 207           auto ErrOrMem = Child.getMemoryBufferRef();
 208           if (!ErrOrMem)
 209             return ErrOrMem.takeError();
 210
 211           auto ErrOrObjectFile =
 212               object::ObjectFile::createObjectFile(*ErrOrMem);
 213           if (!ErrOrObjectFile)
 214             return ErrOrObjectFile.takeError();
 215
 216           OE->Objects.push_back(std::move(*ErrOrObjectFile));
 217         }
 218       }
 219     }
 220     if (Err)
 221       return std::move(Err);
 222   }
 223
 224   if (OE->Objects.empty())
 225     return errorCodeToError(errc::no_such_file_or_directory);
 226
 227   MemberCache[Key] = std::move(OE);
 228   return *MemberCache[Key];
 229 }
 230
 231 Expected<const BinaryHolder::ObjectEntry &>
 232 BinaryHolder::getObjectEntry(StringRef Filename, TimestampTy Timestamp) {
 233   if (Verbose)
 234     WithColor::note() << "trying to open '" << Filename << "'\n";
 235
 236   // If this is an archive, we might have either the object or the archive
 237   // cached. In this case we can load it without accessing the file system.
 238   if (isArchive(Filename)) {
 239     StringRef ArchiveFilename = getArchiveAndObjectName(Filename).first;
 240     std::lock_guard<std::mutex> Lock(ArchiveCacheMutex);
 241     ArchiveRefCounter[ArchiveFilename]++;
 242     if (ArchiveCache.count(ArchiveFilename)) {
 243       return ArchiveCache[ArchiveFilename]->getObjectEntry(Filename, Timestamp,
 244                                                            Verbose);
 245     } else {
 246       auto AE = std::make_unique<ArchiveEntry>();
 247       auto Err = AE->load(VFS, Filename, Timestamp, Verbose);
 248       if (Err) {
 249         // Don't return the error here: maybe the file wasn't an archive.
 250         llvm::consumeError(std::move(Err));
 251       } else {
 252         ArchiveCache[ArchiveFilename] = std::move(AE);
 253         return ArchiveCache[ArchiveFilename]->getObjectEntry(
 254             Filename, Timestamp, Verbose);
 255       }
 256     }
 257   }
 258
 259   // If this is an object, we might have it cached. If not we'll have to load
 260   // it from the file system and cache it now.
 261   std::lock_guard<std::mutex> Lock(ObjectCacheMutex);
 262   ObjectRefCounter[Filename]++;
 263   if (!ObjectCache.count(Filename)) {
 264     auto OE = std::make_unique<ObjectEntry>();
 265     auto Err = OE->load(VFS, Filename, Timestamp, Verbose);
 266     if (Err)
 267       return std::move(Err);
 268     ObjectCache[Filename] = std::move(OE);
 269   }
 270
 271   return *ObjectCache[Filename];
 272 }
 273
 274 void BinaryHolder::clear() {
 275   std::lock_guard<std::mutex> ArchiveLock(ArchiveCacheMutex);
 276   std::lock_guard<std::mutex> ObjectLock(ObjectCacheMutex);
 277   ArchiveCache.clear();
 278   ObjectCache.clear();
 279 }
 280
 281 void BinaryHolder::eraseObjectEntry(StringRef Filename) {
 282   if (Verbose)
 283     WithColor::note() << "erasing '" << Filename << "' from cache\n";
 284
 285   if (isArchive(Filename)) {
 286     StringRef ArchiveFilename = getArchiveAndObjectName(Filename).first;
 287     std::lock_guard<std::mutex> Lock(ArchiveCacheMutex);
 288     ArchiveRefCounter[ArchiveFilename]--;
 289     if (ArchiveRefCounter[ArchiveFilename] == 0)
 290       ArchiveCache.erase(ArchiveFilename);
 291     return;
 292   }
 293
 294   std::lock_guard<std::mutex> Lock(ObjectCacheMutex);
 295   ObjectRefCounter[Filename]--;
 296   if (ObjectRefCounter[Filename] == 0)
 297     ObjectCache.erase(Filename);
 298 }
 299
 300 } // namespace dsymutil
 301 } // namespace llvm