Go back to previous more contained thin archive bitcode members scheme

Author: bd1976bris

lld/ELF/Config.h

@@ -166,8 +166,7 @@ class LinkerDriver {
   template <class ELFT> void link(llvm::opt::InputArgList &args);
   template <class ELFT> void compileBitcodeFiles(bool skipLinkedOutput);
   bool tryAddFatLTOFile(MemoryBufferRef mb, StringRef archiveName,
-                        uint64_t offsetInArchive, bool isThinArchive,
-                        bool lazy);
+                        uint64_t offsetInArchive, bool lazy);
   // True if we are in --whole-archive and --no-whole-archive.
   bool inWholeArchive = false;
 

lld/ELF/Driver.cpp

@@ -231,16 +231,15 @@ static bool isBitcode(MemoryBufferRef mb) {
 }
 
 bool LinkerDriver::tryAddFatLTOFile(MemoryBufferRef mb, StringRef archiveName,
-                                    uint64_t offsetInArchive,
-                                    bool isThinArchive, bool lazy) {
+                                    uint64_t offsetInArchive, bool lazy) {
   if (!ctx.arg.fatLTOObjects)
     return false;
   Expected<MemoryBufferRef> fatLTOData =
       IRObjectFile::findBitcodeInMemBuffer(mb);
   if (errorToBool(fatLTOData.takeError()))
     return false;
-  files.push_back(std::make_unique<BitcodeFile>(
-      ctx, *fatLTOData, archiveName, offsetInArchive, isThinArchive, lazy));
+  files.push_back(std::make_unique<BitcodeFile>(ctx, *fatLTOData, archiveName,
+                                                offsetInArchive, lazy));
   return true;
 }
 
@@ -263,15 +262,13 @@ void LinkerDriver::addFile(StringRef path, bool withLOption) {
     readLinkerScript(ctx, mbref);
     return;
   case file_magic::archive: {
-    bool isThinArchive = mbref.getBuffer().starts_with(ThinArchiveMagic);
     auto members = getArchiveMembers(ctx, mbref);
     if (inWholeArchive) {
       for (const std::pair<MemoryBufferRef, uint64_t> &p : members) {
         if (isBitcode(p.first))
-          files.push_back(std::make_unique<BitcodeFile>(
-              ctx, p.first, path, p.second, isThinArchive, false));
-        else if (!tryAddFatLTOFile(p.first, path, p.second, isThinArchive,
-                                   false))
+          files.push_back(std::make_unique<BitcodeFile>(ctx, p.first, path,
+                                                        p.second, false));
+        else if (!tryAddFatLTOFile(p.first, path, p.second, false))
           files.push_back(createObjFile(ctx, p.first, path));
       }
       return;
@@ -295,11 +292,11 @@ void LinkerDriver::addFile(StringRef path, bool withLOption) {
     for (const std::pair<MemoryBufferRef, uint64_t> &p : members) {
       auto magic = identify_magic(p.first.getBuffer());
       if (magic == file_magic::elf_relocatable) {
-        if (!tryAddFatLTOFile(p.first, path, p.second, isThinArchive, true))
+        if (!tryAddFatLTOFile(p.first, path, p.second, true))
           files.push_back(createObjFile(ctx, p.first, path, true));
       } else if (magic == file_magic::bitcode)
-        files.push_back(std::make_unique<BitcodeFile>(
-            ctx, p.first, path, p.second, isThinArchive, true));
+        files.push_back(
+            std::make_unique<BitcodeFile>(ctx, p.first, path, p.second, true));
       else
         Warn(ctx) << path << ": archive member '"
                   << p.first.getBufferIdentifier()
@@ -327,11 +324,10 @@ void LinkerDriver::addFile(StringRef path, bool withLOption) {
     return;
   }
   case file_magic::bitcode:
-    files.push_back(
-        std::make_unique<BitcodeFile>(ctx, mbref, "", 0, false, inLib));
+    files.push_back(std::make_unique<BitcodeFile>(ctx, mbref, "", 0, inLib));
     break;
   case file_magic::elf_relocatable:
-    if (!tryAddFatLTOFile(mbref, "", 0, false, inLib))
+    if (!tryAddFatLTOFile(mbref, "", 0, inLib))
       files.push_back(createObjFile(ctx, mbref, "", inLib));
     break;
   default:

lld/ELF/InputFiles.cpp

@@ -1703,49 +1703,61 @@ static uint8_t getOsAbi(const Triple &t) {
   }
 }
 
-static SmallString<64> dtltoGetMemberPathIfThinArchive(StringRef archivePath,
-                                                       StringRef memberPath) {
+// For DTLTO, bitcode member names must be a valid path to a bitcode file on
+// disk. For thin archives, adjust `memberPath` to the full file path of the
+// archive member. Returns true if an adjustment was made; false otherwise.
+// Non-thin archives are not yet supported.
+static bool dtltoAdjustMemberPathIfThinArchive(Ctx &ctx, StringRef archivePath,
+                                               std::string &memberPath) {
   assert(!archivePath.empty());
+  assert(!ctx.arg.dtltoDistributor.empty());
+
+  // Check if the archive file is a thin archive by reading its header.
+  auto memBufferOrError =
+      MemoryBuffer::getFileSlice(archivePath, sizeof(ThinArchiveMagic) - 1, 0);
+  if (std::error_code ec = memBufferOrError.getError()) {
+    ErrAlways(ctx) << "cannot open " << archivePath << ": " << ec.message();
+    return false;
+  }
+  MemoryBufferRef memBufRef = *memBufferOrError.get();
+  if (!memBufRef.getBuffer().starts_with(ThinArchiveMagic))
+    return false;
+
   SmallString<64> archiveMemberPath;
   if (path::is_relative(memberPath)) {
     archiveMemberPath = path::parent_path(archivePath);
     path::append(archiveMemberPath, memberPath);
   } else
     archiveMemberPath = memberPath;
+
   path::remove_dots(archiveMemberPath, /*remove_dot_dot=*/true);
-  return archiveMemberPath;
+  memberPath = archiveMemberPath.str();
+  return true;
 }
 
 BitcodeFile::BitcodeFile(Ctx &ctx, MemoryBufferRef mb, StringRef archiveName,
-                         uint64_t offsetInArchive, bool isThinArchive,
-                         bool lazy)
+                         uint64_t offsetInArchive, bool lazy)
     : InputFile(ctx, BitcodeKind, mb) {
   this->archiveName = archiveName;
   this->lazy = lazy;
 
   std::string path = mb.getBufferIdentifier().str();
   if (ctx.arg.thinLTOIndexOnly)
     path = replaceThinLTOSuffix(ctx, mb.getBufferIdentifier());
-
-  // For DTLTO the member name needs to be a valid path to a bitcode file on
-  // disk. For ThinArchives we compute that. Non-thin archives are not yet
-  // supported.
-  bool dtltoAdjustThinArchivePath = !archiveName.empty() && isThinArchive &&
-                                    !ctx.arg.dtltoDistributor.empty();
-  if (dtltoAdjustThinArchivePath)
-    path = dtltoGetMemberPathIfThinArchive(archiveName, path).str();
-
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two archives define two members with the same name, this
   // causes a collision which result in only one of the objects being taken
   // into consideration at LTO time (which very likely causes undefined
   // symbols later in the link stage). So we append file offset to make
   // filename unique.
   StringSaver &ss = ctx.saver;
-  StringRef name = (archiveName.empty() || dtltoAdjustThinArchivePath)
-                       ? ss.save(path)
-                       : ss.save(archiveName + "(" + path::filename(path) +
-                                 " at " + utostr(offsetInArchive) + ")");
+  StringRef name =
+      (archiveName.empty() ||
+       (!ctx.arg.dtltoDistributor.empty() &&
+        dtltoAdjustMemberPathIfThinArchive(ctx, archiveName, path)))
+          ? ss.save(path)
+          : ss.save(archiveName + "(" + path::filename(path) + " at " +
+                    utostr(offsetInArchive) + ")");
   MemoryBufferRef mbref(mb.getBuffer(), name);
 
   obj = CHECK2(lto::InputFile::create(mbref), this);

lld/ELF/InputFiles.h

@@ -324,7 +324,7 @@ template <class ELFT> class ObjFile : public ELFFileBase {
 class BitcodeFile : public InputFile {
 public:
   BitcodeFile(Ctx &, MemoryBufferRef m, StringRef archiveName,
-              uint64_t offsetInArchive, bool isThinArchive, bool lazy);
+              uint64_t offsetInArchive, bool lazy);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
   void parse();
   void parseLazy();