COFF: Read linker directives from bitcode files.

[ruiu]

COFF/SymbolTable.cpp

44 ↗

(On Diff #27232)

I'd reverse the condition to return early.

81 ↗

(On Diff #27232)

I'm wondering what kind of command line options compiled bitcode would actually contain. Is that /defaultlib option? Can you give me an example?

[pcc]

Address review comments

COFF/SymbolTable.cpp

44 ↗

(On Diff #27232)

Done

81 ↗

(On Diff #27232)

Yes, /defaultlib. For example, if I compile an empty translation unit with clang-cl, I'll see IR like this:

!llvm.module.flags = !{!0, !...}

!0 = !{i32 6, !"Linker Options", !1}
!1 = !{!2, !3}
!2 = !{!"/DEFAULTLIB:libcmt.lib"}
!3 = !{!"/DEFAULTLIB:oldnames.lib"}

[ruiu]

LGTM

lld/trunk/COFF/InputFiles.h

public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind), MB(M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   StringRef getName() override { return MB.getBufferIdentifier(); }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   LTOModule *getModule() const { return M.get(); }
   LTOModule *releaseModule() { return M.release(); }
 
+  // Returns linker directives from module flags metadata if present.
+  StringRef getDirectives() { return Directives; }
+
 private:
   std::error_code parse() override;
 
   MemoryBufferRef MB;
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   std::unique_ptr<LTOModule> M;
+  std::string Directives;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/InputFiles.cpp

for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
     StringRef SymName = M->getSymbolName(I);
     if ((M->getSymbolAttributes(I) & LTO_SYMBOL_DEFINITION_MASK) ==
         LTO_SYMBOL_DEFINITION_UNDEFINED) {
       SymbolBodies.push_back(new (Alloc) Undefined(SymName));
     } else {
       SymbolBodies.push_back(new (Alloc) DefinedBitcode(SymName));
     }
   }
+
+  // Extract any linker directives from the bitcode file, which are represented
+  // as module flags with the key "Linker Options".
+  llvm::SmallVector<llvm::Module::ModuleFlagEntry, 8> Flags;
+  M->getModule().getModuleFlagsMetadata(Flags);
+  for (auto &&Flag : Flags) {
+    if (Flag.Key->getString() != "Linker Options")
+      continue;
+
+    for (llvm::Metadata *Op : cast<llvm::MDNode>(Flag.Val)->operands()) {
+      for (llvm::Metadata *InnerOp : cast<llvm::MDNode>(Op)->operands()) {
+        Directives += " ";
+        Directives += cast<llvm::MDString>(InnerOp)->getString();
+      }
+    }
+  }
+
   return std::error_code();
 }
 
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/SymbolTable.h

public:
 
   // Creates an Undefined symbol for a given name.
   std::error_code addUndefined(StringRef Name);
 
   // Rename From -> To in the symbol table.
   std::error_code rename(StringRef From, StringRef To);
 
 private:
+  std::error_code addDirectives(StringRef Dir);
+
   std::error_code addObject(ObjectFile *File);
   std::error_code addArchive(ArchiveFile *File);
   std::error_code addImport(ImportFile *File);
   std::error_code addBitcode(BitcodeFile *File);
 
   std::error_code resolve(SymbolBody *Body);
   std::error_code addMemberFile(Lazy *Body);
 

lld/trunk/COFF/SymbolTable.cpp

if (auto *P = dyn_cast<ObjectFile>(FileP))
     return addObject(P);
   if (auto *P = dyn_cast<ArchiveFile>(FileP))
     return addArchive(P);
   if (auto *P = dyn_cast<BitcodeFile>(FileP))
     return addBitcode(P);
   return addImport(cast<ImportFile>(FileP));
 }
 
+std::error_code SymbolTable::addDirectives(StringRef Dir) {
+  if (Dir.empty())
+    return std::error_code();
+  std::vector<std::unique_ptr<InputFile>> Libs;
+  if (auto EC = Driver->parseDirectives(Dir, &Libs))
+    return EC;
+  for (std::unique_ptr<InputFile> &Lib : Libs)
+    addFile(std::move(Lib));
+  return std::error_code();
+}
+
 std::error_code SymbolTable::addObject(ObjectFile *File) {
   ObjectFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (Body->isExternal())
       if (auto EC = resolve(Body))
         return EC;
 
   // If an object file contains .drectve section, read it and add
   // files listed in the section.
-  StringRef Dir = File->getDirectives();
-  if (!Dir.empty()) {
-    std::vector<std::unique_ptr<InputFile>> Libs;
-    if (auto EC = Driver->parseDirectives(Dir, &Libs))
-      return EC;
-    for (std::unique_ptr<InputFile> &Lib : Libs)
-      addFile(std::move(Lib));
-  }
-  return std::error_code();
+  return addDirectives(File->getDirectives());
 }
 
 std::error_code SymbolTable::addArchive(ArchiveFile *File) {
   ArchiveFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (auto EC = resolve(Body))
       return EC;
   return std::error_code();
 }
 
 std::error_code SymbolTable::addBitcode(BitcodeFile *File) {
   BitcodeFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (Body->isExternal())
       if (auto EC = resolve(Body))
         return EC;
 
-  // TODO: Handle linker directives.
-  return std::error_code();
+  // Add any linker directives from the module flags metadata.
+  return addDirectives(File->getDirectives());
 }
 
 std::error_code SymbolTable::addImport(ImportFile *File) {
   ImportFiles.emplace_back(File);
   for (SymbolBody *Body : File->getSymbols())
     if (auto EC = resolve(Body))
       return EC;
   return std::error_code();

lld/trunk/test/COFF/lto-linker-opts.ll

+; RUN: llvm-as -o %T/lto-linker-opts.obj %s
+; RUN: env LIB=%S/Inputs lld -flavor link2 /out:%T/lto-linker-opts.exe /entry:main /subsystem:console %T/lto-linker-opts.obj
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+!llvm.module.flags = !{!0}
+
+!0 = !{i32 6, !"Linker Options", !1}
+!1 = !{!2}
+!2 = !{!"/DEFAULTLIB:ret42.lib"}