[lld] Fix shared libraries build

[garious]

Summary

• Removed cyclic dependency between lldPECOFF and lldDriver
• Added missing dependencies in unit tests

[ruiu]

LGTM. Thank you for doing this!

[shankarke]

LGTM.

lld/trunk/include/lld/Driver/Driver.h

public:
 
   /// Uses Windows style link command line options to fill in options struct.
   /// Returns true iff there was an error.
   static bool parse(int argc, const char *argv[], PECOFFLinkingContext &info,
                     raw_ostream &diagnostics = llvm::errs(),
                     bool isDirective = false,
                     std::set<StringRef> *undefinedSymbols = nullptr);
 
+  // Same as parse(), but restricted to the context of directives.
+  static bool parseDirectives(int argc, const char *argv[],
+                    PECOFFLinkingContext &info,
+                    raw_ostream &diagnostics = llvm::errs(),
+                    std::set<StringRef> *undefinedSymbols = nullptr) {
+    return parse(argc, argv, info, diagnostics, true, undefinedSymbols);
+  }
+
 private:
   WinLinkDriver() LLVM_DELETED_FUNCTION;
 };
 
 /// Driver for lld unit tests
 class CoreDriver : public Driver {
 public:
 

lld/trunk/include/lld/ReaderWriter/PECOFFLinkingContext.h

PECOFFLinkingContext()
         _minOSVersion(6, 0), _nxCompat(true), _largeAddressAware(false),
         _allowBind(true), _allowIsolation(true), _swapRunFromCD(false),
         _swapRunFromNet(false), _baseRelocationEnabled(true),
         _terminalServerAware(true), _dynamicBaseEnabled(true),
         _createManifest(true), _embedManifest(false), _manifestId(1),
         _manifestUAC(true), _manifestLevel("'asInvoker'"),
         _manifestUiAccess("'false'"), _isDll(false), _highEntropyVA(true),
         _requireSEH(false), _noSEH(false), _implib(""), _debug(false),
-        _pdbFilePath(""), _dosStub(llvm::makeArrayRef(DEFAULT_DOS_STUB)) {
+        _pdbFilePath(""), _dosStub(llvm::makeArrayRef(DEFAULT_DOS_STUB)),
+        _parseDirectives(nullptr) {
     setDeadStripping(true);
   }
 
   struct Version {
     Version(int v1, int v2) : majorVersion(v1), minorVersion(v2) {}
     int majorVersion;
     int minorVersion;
   };
struct ExportDesc {
     std::string externalName;
     std::string mangledName;
     int ordinal;
     bool noname;
     bool isData;
     bool isPrivate;
   };
 
+  typedef bool (*ParseDirectives)(int, const char **, PECOFFLinkingContext &,
+                                  raw_ostream &, std::set<StringRef> *);
+
   /// \brief Casting support
   static inline bool classof(const LinkingContext *info) { return true; }
 
   Writer &writer() const override;
   bool validateImpl(raw_ostream &diagnostics) override;
 
   void addPasses(PassManager &pm) override;
 
void setModuleDefinitionFile(const std::string val) {
     _moduleDefinitionFile = val;
   }
   std::string getModuleDefinitionFile() const {
     return _moduleDefinitionFile;
   }
 
   std::recursive_mutex &getMutex() { return _mutex; }
 
+  void setParseDirectives(ParseDirectives parseDirectives) {
+    _parseDirectives = parseDirectives;
+  }
+
+  ParseDirectives getParseDirectives() {
+    return _parseDirectives;
+  }
+
 protected:
   /// Method to create a internal file for the entry symbol
   std::unique_ptr<File> createEntrySymbolFile() const override;
 
   /// Method to create a internal file for an undefined symbol
   std::unique_ptr<File> createUndefinedSymbolFile() const override;
 
 private:
private:
   ArrayRef<uint8_t> _dosStub;
 
   // Name of the temporary file for lib.exe subcommand. For debugging
   // only.
   std::string _moduleDefinitionFile;
 
   std::set<std::string> _definedSyms;
   std::set<Node *> _seen;
+
+  ParseDirectives _parseDirectives;
 };
 
 } // end namespace lld
 
 #endif

lld/trunk/lib/Driver/WinLinkDriver.cpp

 // Main driver
 //
 
 bool WinLinkDriver::linkPECOFF(int argc, const char **argv, raw_ostream &diag) {
   if (maybeRunLibCommand(argc, argv, diag))
     return true;
 
   PECOFFLinkingContext ctx;
+  ctx.setParseDirectives(parseDirectives);
   ctx.registry().addSupportCOFFObjects(ctx);
   ctx.registry().addSupportCOFFImportLibraries(ctx);
   ctx.registry().addSupportArchives(ctx.logInputFiles());
   ctx.registry().addSupportNativeObjects();
   ctx.registry().addSupportYamlFiles();
 
   std::vector<const char *> newargv = processLinkEnv(ctx, argc, argv);
   processLibEnv(ctx);

lld/trunk/lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

FileCOFF::parseDirectiveSection(StringRef directives,
   tokens.push_back(nullptr);
 
   // Calls the command line parser to interpret the token string as if they
   // were given via the command line.
   int argc = tokens.size() - 1;
   const char **argv = &tokens[0];
   std::string errorMessage;
   llvm::raw_string_ostream stream(errorMessage);
-  bool parseFailed = !WinLinkDriver::parse(argc, argv, _ctx, stream,
-                                           /*isDirective*/ true,
-                                           undefinedSymbols);
+  PECOFFLinkingContext::ParseDirectives parseDirectives =
+    _ctx.getParseDirectives();
+  bool parseFailed = !parseDirectives(argc, argv, _ctx, stream,
   stream.flush();
   // Print error message if error.
   if (parseFailed) {
     auto msg = Twine("Failed to parse '") + directives + "'\n"
     + "Reason: " + errorMessage;
     return make_dynamic_error_code(msg);
   }
   if (!errorMessage.empty()) {

lld/trunk/tools/lld/CMakeLists.txt

 add_llvm_executable(lld
   lld.cpp
   )
 
 target_link_libraries(lld
   lldDriver
+  LLVMSupport
   )
 
 install(TARGETS lld
   RUNTIME DESTINATION bin)
 
 # Create the lld-link[.exe] symlink in the build directory. If symlink is not
 # supported by the operating system, create a copy instead.
 if(UNIX)

lld/trunk/unittests/DriverTests/CMakeLists.txt

 add_lld_unittest(DriverTests
   UniversalDriverTest.cpp
   GnuLdDriverTest.cpp
   DarwinLdDriverTest.cpp
   WinLinkDriverTest.cpp
   WinLinkModuleDefTest.cpp
   )
 
 target_link_libraries(DriverTests
   lldDriver
+  lldCore
+  lldPECOFF
+  lldMachO
   )