[lto] add getLinkerOpts()

[inglorion]

Summary

Some compilers, including MSVC and Clang, allow linker options to be specified in source files. In the legacy LTO API, there is a getLinkerOpts() method that returns linker options for the bitcode module being processed. This change adds that method to the new API, so that the COFF linker can get the right linker options when using the new LTO API.

[pcc]

lib/LTO/LTO.cpp

255

We deliberately enable lazy loading of metadata here for performance reasons (debug metadata can be expensive to load).

Eventually I think we will want to add the linker options to the bitcode symbol table (see pr27551), so that we will not need to load metadata at all in the COFF linker at symbol resolution time.

In the meantime, I think it would be best to produce the linker options string on demand in getLinkerOpts after calling materializeMetadata. That way, linkers for other object formats don't pay the cost of loading metadata. Can you please also add a FIXME to add this to the symbol table?

275

This loop (and the one below) can be a range for loop.

284

It's probably best to emit the /export flags from here as well, see TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal.

[mehdi_amini]

lib/LTO/LTO.cpp

255

I agree.

I'll add that technically if it is really important for you to get cheaply this you could hook it up to the MD lazy-loading scheme to load this without loading all the MDs.

[inglorion]

Thanks for the comments! I've changed it so that metadata is only materialized if someone actually calls getLinkerOpts, and converted the loops to use ranges.

[pcc]

lib/LTO/LTO.cpp

309

This will lead to a use after free I think.

[pcc]

lib/LTO/LTO.cpp

309

Sorry, no, I didn't notice that this was a field.

I would just remove the field and make this return a std::string.

[inglorion]

lib/LTO/LTO.cpp

309

Hmm, I don't think so. The StringRef here is a reference to LinkerOpts, which is a std::string stored on the InputFile. So that should still be valid after this function returns. LOS.str() just calls flush() on the ostream and returns the StringRef. I think this is ok.

[inglorion]

remove LinkerOpts field and use std::string in the return value

[inglorion]

Made getLinkerOpts() also sythesize /export flags for symbols with dllexport linkage, as @pcc suggested

[inglorion]

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

922 ↗

(On Diff #86749)

I moved this into a separate function so that we don't have to do the whole TargetTriple, TargetRegistry, SubtargetFeatures, etc. etc. dance to create a TargetLOweringObjectFileImpl, just to call one method that doesn't need all that information.

[pcc]

lib/LTO/LTO.cpp

303–307

Remove braces

312

The Mods list should never be empty, nor should the module's target triple, so you can initialize TT with just Mods[0].Mod->getTargetTriple().

317

You could enumerate SymTab.symbols() instead to avoid needing to befriend InputFile.

[inglorion]

Removed braces, friend declaration, and defensive programming.
Iterate ModuleSymbolTable instead of using symbol_iterator.

[pcc]

LGTM, thanks

include/llvm/LTO/LTO.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/Linker/IRMover.h"
 #include "llvm/Object/IRObjectFile.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/thread.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 
 namespace llvm {
 
 class BitcodeModule;
 class Error;

 class InputFile {
   // FIXME: Remove LTO class friendship once we have bitcode symbol tables.
   friend LTO;
   InputFile() = default;
 
   // FIXME: Remove the LLVMContext once we have bitcode symbol tables.
   LLVMContext Ctx;
   struct InputModule;
+  std::string LinkerOpts;
   std::vector<InputModule> Mods;
   ModuleSymbolTable SymTab;
 
   std::vector<StringRef> Comdats;
   DenseMap<const Comdat *, unsigned> ComdatMap;
 
 public:
   ~InputFile();
public:
 
   /// A range over the symbols in this InputFile.
   iterator_range<symbol_iterator> symbols() {
     return llvm::make_range(
         symbol_iterator(SymTab.symbols().begin(), SymTab, this),
         symbol_iterator(SymTab.symbols().end(), SymTab, this));
   }
 
+  /// Returns linker options specified in the input file.
+  Expected<StringRef> getLinkerOpts();
+
   /// Returns the path to the InputFile.
   StringRef getName() const;
 
   /// Returns the source file path specified at compile time.
   StringRef getSourceFileName() const;
 
   // Returns a table with all the comdats used by this file.
   ArrayRef<StringRef> getComdatTable() const { return Comdats; }

lib/LTO/LTO.cpp

 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/LTO/LTOBackend.h"
 #include "llvm/Linker/IRMover.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) {
   if (BMsOrErr->empty())
     return make_error<StringError>("Bitcode file does not contain any modules",
                                    inconvertibleErrorCode());
 
   // Create an InputModule for each module in the InputFile, and add it to the
   // ModuleSymbolTable.
   for (auto BM : *BMsOrErr) {
     Expected<std::unique_ptr<Module>> MOrErr =
         BM.getLazyModule(File->Ctx, /*ShouldLazyLoadMetadata*/ true,
                          /*IsImporting*/ false);
     if (!MOrErr)
       return MOrErr.takeError();
 
     size_t SymBegin = File->SymTab.symbols().size();
     File->SymTab.addModule(MOrErr->get());
     size_t SymEnd = File->SymTab.symbols().size();
 
     for (const auto &C : (*MOrErr)->getComdatSymbolTable()) {
       auto P = File->ComdatMap.insert(
           std::make_pair(&C.second, File->Comdats.size()));
       assert(P.second);
       (void)P;
       File->Comdats.push_back(C.first());
     }
 
     File->Mods.push_back({BM, std::move(*MOrErr), SymBegin, SymEnd});
   }
 
   return std::move(File);
 }
 
 Expected<int> InputFile::Symbol::getComdatIndex() const {
   if (!isGV())
     return -1;
   const GlobalObject *GO = getGV()->getBaseObject();
   if (!GO)
     return make_error<StringError>("Unable to determine comdat of alias!",
                                    inconvertibleErrorCode());
   if (const Comdat *C = GO->getComdat()) {
     auto I = File->ComdatMap.find(C);
     assert(I != File->ComdatMap.end());
     return I->second;
   }
   return -1;
 }
 
+Expected<StringRef> InputFile::getLinkerOpts() {
+  raw_string_ostream LOS(LinkerOpts);
+  // Extract linker options.
+  for (InputModule &Mod : Mods) {
+    std::unique_ptr<Module> &M = Mod.Mod;
+    if (auto E = M->materializeMetadata())
+      return std::move(E);
+    if (Metadata *Val = M->getModuleFlag("Linker Options")) {
+      MDNode *LinkerOptions = cast<MDNode>(Val);
+      for (const MDOperand &MDOptions : LinkerOptions->operands()) {
+  for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands()) {
+    LOS << " " << cast<MDString>(MDOption)->getString();
+  }
+      }
+    }
+  }
+  return LOS.str();
+}
+
 StringRef InputFile::getName() const {
   return Mods[0].BM.getModuleIdentifier();
 }
 
 StringRef InputFile::getSourceFileName() const {
   return Mods[0].Mod->getSourceFileName();
 }
 
 iterator_range<InputFile::symbol_iterator>
 InputFile::module_symbols(InputModule &IM) {
   return llvm::make_range(
       symbol_iterator(SymTab.symbols().data() + IM.SymBegin, SymTab, this),
       symbol_iterator(SymTab.symbols().data() + IM.SymEnd, SymTab, this));
 }