[lld-macho] Add archive name and file modtime to STABS output

[int3]

Summary

We should also set the modtime when running LTO. That will be done in a
future diff, together with support for the -object_path_lto flag.

[int3]

update

[clayborg]

LTGM!

lld/MachO/Driver.h

 std::string createResponseFile(const llvm::opt::InputArgList &args);
 
 // Check for both libfoo.dylib and libfoo.tbd (in that order).
 llvm::Optional<std::string> resolveDylibPath(llvm::StringRef path);
 
 llvm::Optional<DylibFile *> makeDylibFromTAPI(llvm::MemoryBufferRef mbref,
                                               DylibFile *umbrella = nullptr);
 
+uint32_t getModTime(llvm::StringRef path);
+
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

 
 static std::vector<StringRef>
 getFrameworkSearchPaths(opt::InputArgList &args,
                         const std::vector<StringRef> &roots) {
   return getSearchPaths(OPT_F, args, roots,
                         {"/Library/Frameworks", "/System/Library/Frameworks"});
 }
 
+namespace {
+struct ArchiveMember {
+  MemoryBufferRef mbref;
+  uint32_t modTime;
+};
+} // namespace
+
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
-static std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef mb) {
+static std::vector<ArchiveMember> getArchiveMembers(MemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
       CHECK(Archive::create(mb),
             mb.getBufferIdentifier() + ": failed to parse archive");
 
-  std::vector<MemoryBufferRef> v;
+  std::vector<ArchiveMember> v;
   Error err = Error::success();
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               mb.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
-    v.push_back(mbref);
+    uint32_t modTime = toTimeT(
+        CHECK(c.getLastModified(), mb.getBufferIdentifier() +
+                                       ": could not get the modification "
+                                       "time for a child of the archive"));
+    v.push_back({mbref, modTime});
   }
   if (err)
     fatal(mb.getBufferIdentifier() +
           ": Archive::children failed: " + toString(std::move(err)));
 
   return v;
 }
 
+static void forceLoadArchive(StringRef path) {
+  if (Optional<MemoryBufferRef> buffer = readFile(path)) {
+    for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
+      auto file = make<ObjFile>(member.mbref, member.modTime);
+      file->archiveName = buffer->getBufferIdentifier();
+      inputFiles.push_back(file);
+    }
+  }
+}
+
 static InputFile *addFile(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return nullptr;
   MemoryBufferRef mbref = *buffer;
   InputFile *newFile = nullptr;
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::archive: {
     std::unique_ptr<object::Archive> file = CHECK(
         object::Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable())
       error(path + ": archive has no index; run ranlib to add one");
 
     if (config->allLoad) {
-      if (Optional<MemoryBufferRef> buffer = readFile(path))
-        for (MemoryBufferRef member : getArchiveMembers(*buffer))
-          inputFiles.push_back(make<ObjFile>(member));
+      forceLoadArchive(path);
     } else if (config->forceLoadObjC) {
       for (const object::Archive::Symbol &sym : file->symbols())
         if (sym.getName().startswith(objc::klass))
           symtab->addUndefined(sym.getName());
 
       // TODO: no need to look for ObjC sections for a given archive member if
       // we already found that it contains an ObjC symbol. We should also
       // consider creating a LazyObjFile class in order to avoid double-loading
       // these files here and below (as part of the ArchiveFile).
       if (Optional<MemoryBufferRef> buffer = readFile(path))
-        for (MemoryBufferRef member : getArchiveMembers(*buffer))
-          if (hasObjCSection(member))
-            inputFiles.push_back(make<ObjFile>(member));
+        for (const ArchiveMember &member : getArchiveMembers(*buffer))
+          if (hasObjCSection(member.mbref))
+            inputFiles.push_back(make<ObjFile>(member.mbref, member.modTime));
     }
 
     newFile = make<ArchiveFile>(std::move(file));
     break;
   }
   case file_magic::macho_object:
-    newFile = make<ObjFile>(mbref);
+    newFile = make<ObjFile>(mbref, getModTime(path));
     break;
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
     newFile = make<DylibFile>(mbref);
     break;
   case file_magic::tapi_file: {
     if (Optional<DylibFile *> dylibFile = makeDylibFromTAPI(mbref))
       newFile = *dylibFile;
static void addFileList(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
   for (StringRef path : args::getLines(mbref))
     addFile(path);
 }
 
-static void forceLoadArchive(StringRef path) {
-  if (Optional<MemoryBufferRef> buffer = readFile(path))
-    for (MemoryBufferRef member : getArchiveMembers(*buffer))
-      inputFiles.push_back(make<ObjFile>(member));
-}
-
 static std::array<StringRef, 6> archNames{"arm",    "arm64", "i386",
                                           "x86_64", "ppc",   "ppc64"};
 static bool isArchString(StringRef s) {
   static DenseSet<StringRef> archNamesSet(archNames.begin(), archNames.end());
   return archNamesSet.find(s) != archNamesSet.end();
 }
 
 // An order file has one entry per line, in the following format:

lld/MachO/DriverUtils.cpp

Optional<DylibFile *> macho::makeDylibFromTAPI(MemoryBufferRef mbref,
   Expected<std::unique_ptr<InterfaceFile>> result = TextAPIReader::get(mbref);
   if (!result) {
     error("could not load TAPI file at " + mbref.getBufferIdentifier() + ": " +
           toString(result.takeError()));
     return {};
   }
   return make<DylibFile>(**result, umbrella);
 }
+
+uint32_t macho::getModTime(StringRef path) {
+  fs::file_status stat;
+  if (!fs::status(path, stat))
+    if (fs::exists(stat))
+      return toTimeT(stat.getLastModificationTime());
+
+  warn("failed to get modification time of " + path);
+  return 0;
+}

lld/MachO/InputFiles.h

 private:
   const Kind fileKind;
   const StringRef name;
 };
 
 // .o file
 class ObjFile : public InputFile {
 public:
-  explicit ObjFile(MemoryBufferRef mb);
+  explicit ObjFile(MemoryBufferRef mb, uint32_t modTime);
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
+  StringRef archiveName = "";
+  const uint32_t modTime;
 
 private:
   void parseDebugInfo();
 };
 
 // command-line -sectcreate file
 class OpaqueFile : public InputFile {
 public:

lld/MachO/InputFiles.cpp

OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
   isec->file = this;
   isec->name = sectName.take_front(16);
   isec->segname = segName.take_front(16);
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   isec->data = {buf, mb.getBufferSize()};
   subsections.push_back({{0, isec}});
 }
 
-ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
+ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime)
+    : InputFile(ObjKind, mb), modTime(modTime) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
 
   if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
     auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
     sectionHeaders = ArrayRef<section_64>{
         reinterpret_cast<const section_64 *>(c + 1), c->nsects};
     parseSections(sectionHeaders);
void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
   MemoryBufferRef mb =
       CHECK(c.getMemoryBufferRef(),
             toString(this) +
                 ": could not get the buffer for the member defining symbol " +
                 sym.getName());
-  auto file = make<ObjFile>(mb);
+
+  uint32_t modTime = toTimeT(
+      CHECK(c.getLastModified(), toString(this) +
+                                     ": could not get the modification time "
+                                     "for the member defining symbol " +
+                                     sym.getName()));
+
+  auto file = make<ObjFile>(mb, modTime);
+  file->archiveName = getName();
+
   symbols.insert(symbols.end(), file->symbols.begin(), file->symbols.end());
   subsections.insert(subsections.end(), file->subsections.begin(),
                      file->subsections.end());
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
     : InputFile(BitcodeKind, mbref) {
   obj = check(lto::InputFile::create(mbref));
 }
 
 // Returns "<internal>" or "baz.o".
 std::string lld::toString(const InputFile *file) {
   return file ? std::string(file->getName()) : "<internal>";
 }

lld/MachO/LTO.cpp

std::vector<ObjFile *> BitcodeCompiler::compile() {
 
   if (config->saveTemps) {
     if (!buf[0].empty())
       saveBuffer(buf[0], config->outputFile + ".lto.o");
     for (unsigned i = 1; i != maxTasks; ++i)
       saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
   }
 
+  // TODO: set modTime properly
   std::vector<ObjFile *> ret;
   for (unsigned i = 0; i != maxTasks; ++i)
     if (!buf[i].empty())
-      ret.push_back(make<ObjFile>(MemoryBufferRef(buf[i], "lto.tmp")));
+      ret.push_back(
+          make<ObjFile>(MemoryBufferRef(buf[i], "lto.tmp"), /*modTime=*/0));
 
   return ret;
 }

lld/MachO/SyntheticSections.cpp

void SymtabSection::emitEndSourceStab() {
   StabsEntry stab(MachO::N_SO);
   stab.sect = 1;
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitObjectFileStab(ObjFile *file) {
   StabsEntry stab(MachO::N_OSO);
   stab.sect = target->cpuSubtype;
-  SmallString<261> path(file->getName());
+  SmallString<261> path(!file->archiveName.empty() ? file->archiveName
+                                                   : file->getName());
   std::error_code ec = sys::fs::make_absolute(path);
   if (ec)
-    fatal("failed to get absolute path for " + file->getName());
+    fatal("failed to get absolute path for " + path);
+
+  if (!file->archiveName.empty())
+    path.append({"(", file->getName(), ")"});
 
   stab.strx = stringTableSection.addString(saver.save(path.str()));
   stab.desc = 1;
+  stab.value = file->modTime;
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitFunStabs(Defined *defined) {
   {
     StabsEntry stab(MachO::N_FUN);
     stab.sect = 1;
     stab.strx = stringTableSection.addString(defined->getName());

lld/test/MachO/stabs.s

 # REQUIRES: x86
 # UNSUPPORTED: system-windows
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/foo.s -o %t/foo.o
+## Set modtimes of the files for deterministic test output.
+# RUN: env TZ=UTC touch -t "197001010000.16" %t/test.o
+# RUN: env TZ=UTC touch -t "197001010000.32" %t/foo.o
+# RUN: rm -f %t/foo.a
+# RUN: llvm-ar rcsU %t/foo.a %t/foo.o
 
 # RUN: %lld -lSystem %t/test.o %t/foo.o -o %t/test
-# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t
+# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t -DFOO_PATH=%t/foo.o
+
+## Check that we emit the right modtime even when the object file is in an
+## archive.
+# RUN: %lld -lSystem %t/test.o %t/foo.a -o %t/test
+# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t -DFOO_PATH=%t/foo.a\(foo.o\)
 
 ## Check that we emit absolute paths to the object files in our OSO entries
 ## even if our inputs are relative paths.
 # RUN: cd %t && %lld -lSystem test.o foo.o -o test
-# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t
+# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t -DFOO_PATH=%t/foo.o
+
+# RUN: cd %t && %lld -lSystem %t/test.o %t/foo.a -o %t/test
+# RUN: llvm-nm -pa %t/test | FileCheck %s -DDIR=%t -DFOO_PATH=%t/foo.a\(foo.o\)
 
 # CHECK:      0000000000000000 - 00 0000    SO /tmp/test.cpp
-# CHECK-NEXT: 0000000000000000 - 03 0001   OSO [[DIR]]/test.o
+# CHECK-NEXT: 0000000000000010 - 03 0001   OSO [[DIR]]/test.o
 # CHECK-NEXT: [[#%x, MAIN:]]   - 01 0000   FUN _main
-# CHECK-NEXT: 0000000000000001 - 00 0000   FUN
+# CHECK-NEXT: 0000000000000006 - 00 0000   FUN
 # CHECK-NEXT: 0000000000000000 - 01 0000    SO
 # CHECK-NEXT: 0000000000000000 - 00 0000    SO /foo.cpp
-# CHECK-NEXT: 0000000000000000 - 03 0001   OSO [[DIR]]/foo.o
+# CHECK-NEXT: 0000000000000020 - 03 0001   OSO [[FOO_PATH]]
 # CHECK-NEXT: [[#%x, FOO:]]    - 01 0000   FUN _foo
 # CHECK-NEXT: 0000000000000001 - 00 0000   FUN
 # CHECK-NEXT: 0000000000000000 - 01 0000    SO
 # CHECK-NEXT: [[#MAIN]]        T _main
 # CHECK-NEXT: [[#FOO]]         T _foo
 
 #--- test.s
 .text
 .globl  _main
 _main:
 Lfunc_begin0:
+  callq _foo
   retq
 Lfunc_end0:
 
 .section  __DWARF,__debug_str,regular,debug
   .asciz  "test.cpp"             ## string offset=0
   .asciz  "/tmp"                 ## string offset=9
 .section  __DWARF,__debug_abbrev,regular,debug
 Lsection_abbrev: