LinkerInvocation: refactor argument forwarding approach (#11)

General workflow for generating an "rpath'd" import library:

* Run the linker (link.exe) and allow it to produce a dll and import
  library.
* Parse the linker command line, and extract what we think we need.
  Pass that to the librarian (lib) along with the absolute path to
  the dll as the name.
* Replace the old import lib with the new one.

Previously the wrapper had an ad-hoc approach to forwarding arguments
from the linker to the librarian; this resulted in cases where CLI
args needed by the librarian would be dropped.

This PR dds a map including every argument that is valid for both the
linker and librarian (and makes sense to forward for our case), and
checks that map against the linker CLI to ensure we're forwarding all
arguments verbatim (with handling for quoting).

Author: johnwparent

src/ld.cxx

@@ -36,19 +36,18 @@ DWORD LdInvocation::InvokeToolchain() {
         std::string const imp_lib_name = link_run.get_implib_name();
         std::string dll_name = link_run.get_mangled_out();
         std::string const abs_out_imp_lib_name = imp_lib_name + ".dll-abs.lib";
-        std::string const def_file = link_run.get_def_file();
-        std::string def_line = "-def";
-        def_line += !def_file.empty() ? ":" + def_file : "";
+        std::string def = "-def ";
+        std::string piped_args = link_run.get_lib_link_args();
         // create command line to generate new import lib
-        this->rpath_executor = ExecuteCommand(
-            "lib.exe",
-            LdInvocation::ComposeCommandLists({
-                {def_line, "-name:" + dll_name, "-out:" + abs_out_imp_lib_name},
-                {link_run.get_rsp_file()},
-                this->obj_args,
-                this->lib_args,
-                this->lib_dir_args,
-            }));
+        this->rpath_executor =
+            ExecuteCommand("lib.exe", LdInvocation::ComposeCommandLists({
+                                          {def, piped_args, "-name:" + dll_name,
+                                           "-out:" + abs_out_imp_lib_name},
+                                          {link_run.get_rsp_file()},
+                                          this->obj_args,
+                                          this->lib_args,
+                                          this->lib_dir_args,
+                                      }));
         this->rpath_executor.Execute();
         DWORD const err_code = this->rpath_executor.Join();
         if (err_code != 0) {

src/linker_invocation.cxx

@@ -32,7 +32,7 @@ void LinkerInvocation::Parse() {
     for (auto token = this->tokens_.begin(); token != this->tokens_.end();
          ++token) {
         std::string normal_token = *token;
-        lower(normal_token);
+        normalArg(normal_token);
         // implib specifies the eventuall import libraries name_
         // and thus will contain a ".lib" extension, which
         // the next check will process as a library argument
@@ -53,16 +53,16 @@ void LinkerInvocation::Parse() {
             this->output_ = split(*token, ":")[1];
         } else if (endswith(normal_token, ".obj")) {
             this->objs_.push_back(*token);
-        } else if (normal_token.find("def:") != std::string::npos) {
-            StrList def_line = split(*token, ":");
-            this->def_file_ = def_line[1];
         } else if (startswith(normal_token, "@") &&
                    endswith(normal_token, ".rsp")) {
             // RSP files are used to describe object files, libraries, other CLI
             // Switches relevant to the tool the rsp file is being passed to
             // Primarily utilized by CMake and MSBuild projects to bypass
             // Command line length limits
             this->rsp_file_ = *token;
+        } else if (this->piped_args_.find(normal_token) !=
+                   this->piped_args_.end()) {
+            this->piped_args_.at(normal_token).emplace_back(normal_token);
         }
     }
     std::string const ext = this->is_exe_ ? ".exe" : ".dll";
@@ -83,6 +83,22 @@ std::string LinkerInvocation::get_implib_name() {
     return this->implibname_;
 }
 
+std::string LinkerInvocation::get_lib_link_args() {
+    std::string lib_link_line;
+    for (const auto& var_args : this->piped_args_) {
+        // Most of these should be single arguments
+        // however some can be defined multiple times
+        // namely libpath and include
+        // this allows for all arguments to be processed
+        // correctly
+        auto vars = var_args.second;
+        if (!vars.empty()) {
+            lib_link_line += join(var_args.second);
+        }
+    }
+    return lib_link_line;
+}
+
 std::string LinkerInvocation::get_def_file() {
     return this->def_file_;
 }

src/linker_invocation.h

@@ -22,6 +22,7 @@ class LinkerInvocation {
     std::string get_implib_name();
     std::string get_def_file();
     std::string get_rsp_file();
+    std::string get_lib_link_args();
 
    private:
     std::string line_;
@@ -34,4 +35,10 @@ class LinkerInvocation {
     StrList libs_;
     StrList objs_;
     bool is_exe_;
+    std::map<std::string, StrList> piped_args_ = {
+        {"def", {}},          {"export", {}},    {"include", {}},
+        {"libpath", {}},      {"ltcg", {}},      {"machine", {}},
+        {"nodefaultlib", {}}, {"subsystem", {}}, {"verbose", {}},
+        {"wx", {}},
+    };
 };