Move MinGW-specific code out of LinkerDriver::link. NFC.

[ruiu]

Summary

LinkerDriver::link is getting too long, it's time to simplify it.

I will rebase this patch after you submit https://reviews.llvm.org/D58380.

[mstorsjo]

LGTM when rebased on top of D58380.

lld/trunk/COFF/Driver.h

private:
   StringRef doFindLibMinGW(StringRef Filename);
 
   // Parses LIB environment which contains a list of search paths.
   void addLibSearchPaths();
 
   // Library search path. The first element is always "" (current directory).
   std::vector<StringRef> SearchPaths;
 
+  void maybeExportMinGWSymbols(const llvm::opt::InputArgList &Args);
+
   // We don't want to add the same file more than once.
   // Files are uniquified by their filesystem and file number.
   std::set<llvm::sys::fs::UniqueID> VisitedFiles;
 
   std::set<std::string> VisitedLibs;
 
   Symbol *addUndefined(StringRef Sym);
 

lld/trunk/COFF/Driver.cpp

while (Cursor < AltPath.size()) {
     }
 
     Cursor = SecondMark + 1;
   }
 
   Config->PDBAltPath = Buf;
 }
 
+// In MinGW, if no symbols are chosen to be exported, then all symbols are
+// automatically exported by default. This behavior can be forced by the
+// -export-all-symbols option, so that it happens even when exports are
+// explicitly specified. The automatic behavior can be disabled using the
+// -exclude-all-symbols option, so that lld-link behaves like link.exe rather
+// than MinGW in the case that nothing is explicitly exported.
+void LinkerDriver::maybeExportMinGWSymbols(const opt::InputArgList &Args) {
+  if (!Config->DLL)
+    return;
+
+  if (!Args.hasArg(OPT_export_all_symbols)) {
+    if (!Config->Exports.empty())
+      return;
+    if (Args.hasArg(OPT_exclude_all_symbols))
+      return;
+  }
+
+  AutoExporter Exporter;
+
+  for (auto *Arg : Args.filtered(OPT_wholearchive_file))
+    if (Optional<StringRef> Path = doFindFile(Arg->getValue()))
+      Exporter.addWholeArchive(*Path);
+
+  Symtab->forEachSymbol([&](Symbol *S) {
+    auto *Def = dyn_cast<Defined>(S);
+    if (!Exporter.shouldExport(Def))
+      return;
+
+    Export E;
+    E.Name = Def->getName();
+    E.Sym = Def;
+    if (Chunk *C = Def->getChunk())
+      if (!(C->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
+        E.Data = true;
+    Config->Exports.push_back(E);
+  });
+}
+
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
   if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
     if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
       fatal("lib failed");
     return;
   }
warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to "
          "disable");
     Config->Incremental = false;
   }
 
   if (errorCount())
     return;
 
   std::set<sys::fs::UniqueID> WholeArchives;
-  AutoExporter Exporter;
-  for (auto *Arg : Args.filtered(OPT_wholearchive_file)) {
-    if (Optional<StringRef> Path = doFindFile(Arg->getValue())) {
+  for (auto *Arg : Args.filtered(OPT_wholearchive_file))
+    if (Optional<StringRef> Path = doFindFile(Arg->getValue()))
       if (Optional<sys::fs::UniqueID> ID = getUniqueID(*Path))
         WholeArchives.insert(*ID);
-      Exporter.addWholeArchive(*Path);
-    }
-  }
 
   // A predicate returning true if a given path is an argument for
   // /wholearchive:, or /wholearchive is enabled globally.
   // This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
   // needs to be handled as "/wholearchive:foo.obj foo.obj".
   auto IsWholeArchive = [&](StringRef Path) -> bool {
     if (Args.hasArg(OPT_wholearchive_flag))
       return true;
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (Args.hasFlag(OPT_safeseh, OPT_safeseh_no, false)) {
     for (ObjFile *File : ObjFile::Instances)
       if (!File->hasSafeSEH())
         error("/safeseh: " + File->getName() + " is not compatible with SEH");
     if (errorCount())
       return;
   }
 
-  // In MinGW, if no symbols are chosen to be exported, then all symbols are
-  // automatically exported by default. This behavior can be forced by the
-  // -export-all-symbols option, so that it happens even when exports are
-  // explicitly specified. The automatic behavior can be disabled using the
-  // -exclude-all-symbols option, so that lld-link behaves like link.exe rather
-  // than MinGW in the case that nothing is explicitly exported.
-  if (Config->MinGW && Config->DLL &&
-      ((Config->Exports.empty() && !Args.hasArg(OPT_exclude_all_symbols)) ||
-       Args.hasArg(OPT_export_all_symbols))) {
-    Exporter.initSymbolExcludes();
-
-    Symtab->forEachSymbol([=](Symbol *S) {
-      auto *Def = dyn_cast<Defined>(S);
-      if (!Exporter.shouldExport(Def))
-        return;
-      Export E;
-      E.Name = Def->getName();
-      E.Sym = Def;
-      if (Def->getChunk() &&
-          !(Def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
-        E.Data = true;
-      Config->Exports.push_back(E);
-    });
-  }
+  // In MinGW, all symbols are automatically exported if no symbols
+  // are chosen to be exported.
+  if (Config->MinGW)
+    maybeExportMinGWSymbols(Args);
 
   // Windows specific -- when we are creating a .dll file, we also
   // need to create a .lib file.
   if (!Config->Exports.empty() || Config->DLL) {
     fixupExports();
     createImportLibrary(/*AsLib=*/false);
     assignExportOrdinals();
   }

lld/trunk/COFF/MinGW.h

 namespace coff {
 
 // Logic for deciding what symbols to export, when exporting all
 // symbols for MinGW.
 class AutoExporter {
 public:
   AutoExporter();
 
-  void initSymbolExcludes();
-
   void addWholeArchive(StringRef Path);
 
   llvm::StringSet<> ExcludeSymbols;
   llvm::StringSet<> ExcludeSymbolPrefixes;
   llvm::StringSet<> ExcludeSymbolSuffixes;
   llvm::StringSet<> ExcludeLibs;
   llvm::StringSet<> ExcludeObjects;
 

lld/trunk/COFF/MinGW.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lld;
 using namespace lld::coff;
 using namespace llvm;
 using namespace llvm::COFF;
 
-void AutoExporter::initSymbolExcludes() {
+AutoExporter::AutoExporter() {
+  ExcludeLibs = {
+      "libgcc",
+      "libgcc_s",
+      "libstdc++",
+      "libmingw32",
+      "libmingwex",
+      "libg2c",
+      "libsupc++",
+      "libobjc",
+      "libgcj",
+      "libclang_rt.builtins",
+      "libclang_rt.builtins-aarch64",
+      "libclang_rt.builtins-arm",
+      "libclang_rt.builtins-i386",
+      "libclang_rt.builtins-x86_64",
+      "libc++",
+      "libc++abi",
+      "libunwind",
+      "libmsvcrt",
+      "libucrtbase",
+  };
+
+  ExcludeObjects = {
+      "crt0.o",    "crt1.o",  "crt1u.o", "crt2.o",  "crt2u.o",    "dllcrt1.o",
+      "dllcrt2.o", "gcrt0.o", "gcrt1.o", "gcrt2.o", "crtbegin.o", "crtend.o",
+  };
+
   ExcludeSymbolPrefixes = {
       // Import symbols
       "__imp_",
       "__IMPORT_DESCRIPTOR_",
       // Extra import symbols from GNU import libraries
       "__nm_",
       // C++ symbols
       "__rtti_",
       "__builtin_",
       // Artifical symbols such as .refptr
       ".",
   };
+
   ExcludeSymbolSuffixes = {
       "_iname",
       "_NULL_THUNK_DATA",
   };
+
   if (Config->Machine == I386) {
     ExcludeSymbols = {
         "__NULL_IMPORT_DESCRIPTOR",
         "__pei386_runtime_relocator",
         "_do_pseudo_reloc",
         "_impure_ptr",
         "__impure_ptr",
         "__fmode",
ExcludeSymbols = {
         "DllMain",
         "DllEntryPoint",
         "DllMainCRTStartup",
     };
     ExcludeSymbolPrefixes.insert("_head_");
   }
 }
 
-AutoExporter::AutoExporter() {
-  ExcludeLibs = {
-      "libgcc",
-      "libgcc_s",
-      "libstdc++",
-      "libmingw32",
-      "libmingwex",
-      "libg2c",
-      "libsupc++",
-      "libobjc",
-      "libgcj",
-      "libclang_rt.builtins",
-      "libclang_rt.builtins-aarch64",
-      "libclang_rt.builtins-arm",
-      "libclang_rt.builtins-i386",
-      "libclang_rt.builtins-x86_64",
-      "libc++",
-      "libc++abi",
-      "libunwind",
-      "libmsvcrt",
-      "libucrtbase",
-  };
-  ExcludeObjects = {
-      "crt0.o",
-      "crt1.o",
-      "crt1u.o",
-      "crt2.o",
-      "crt2u.o",
-      "dllcrt1.o",
-      "dllcrt2.o",
-      "gcrt0.o",
-      "gcrt1.o",
-      "gcrt2.o",
-      "crtbegin.o",
-      "crtend.o",
-  };
-}
-
 void AutoExporter::addWholeArchive(StringRef Path) {
   StringRef LibName = sys::path::filename(Path);
   // Drop the file extension, to match the processing below.
   LibName = LibName.substr(0, LibName.rfind('.'));
   ExcludeLibs.erase(LibName);
 }
 
 bool AutoExporter::shouldExport(Defined *Sym) const {