gn: Add runtime_link_output to tool("solib")

tools/gn/function_toolchain.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
@@ skipping 463 matching lines @@
     "        are relative to the build output directory. There must always be\n"
     "        at least one output file. There can be more than one output (a\n"
     "        linker might produce a library and an import library, for\n"
     "        example).\n"
     "\n"
     "        This array just declares to GN what files the tool will\n"
     "        produce. It is your responsibility to specify the tool command\n"
     "        that actually produces these files.\n"
     "\n"
     "        If you specify more than one output for shared library links,\n"
-    "        you should consider setting link_output and depend_output.\n"
-    "        Otherwise, the first entry in the outputs list should always be\n"
-    "        the main output which will be linked to.\n"
+    "        you should consider setting link_output, depend_output, and\n"
+    "        runtime_link_output. Otherwise, the first entry in the\n"
+    "        outputs list should always be the main output which will be\n"
+    "        linked to.\n"
     "\n"
     "        Example for a compiler tool that produces .obj files:\n"
     "          outputs = [\n"
     "            \"{{source_out_dir}}/{{source_name_part}}.obj\"\n"
     "          ]\n"
     "\n"
     "        Example for a linker tool that produces a .dll and a .lib. The\n"
     "        use of {{output_extension}} rather than hardcoding \".dll\"\n"
     "        allows the extension of the library to be overridden on a\n"
     "        target-by-target basis, but in this example, it always\n"
     "        produces a \".lib\" import library:\n"
     "          outputs = [\n"
     "            \"{{root_out_dir}}/{{target_output_name}}"
                      "{{output_extension}}\",\n"
     "            \"{{root_out_dir}}/{{target_output_name}}.lib\",\n"
     "          ]\n"
     "\n"
     "    link_output  [string with substitutions]\n"
     "    depend_output  [string with substitutions]\n"
+    "    runtime_link_output  [string with substitutions]\n"
     "        Valid for: \"solink\" only (optional)\n"
     "\n"
-    "        These two files specify which of the outputs from the solink\n"
+    "        These three files specify which of the outputs from the solink\n"
     "        tool should be used for linking and dependency tracking. These\n"
     "        should match entries in the \"outputs\". If unspecified, the\n"
-    "        first item in the \"outputs\" array will be used for both. See\n"
+    "        first item in the \"outputs\" array will be used for all. See\n"
     "        \"Separate linking and dependencies for shared libraries\"\n"
-    "        below for more.\n"
+    "        below for more.  If link_output is set but runtime_link_output\n"
+    "        is not set, runtime_link_output defaults to link_output\n"

[Dirk Pranke, 2016/02/11 02:18:08]

Nit: Add a trailing period.

[Nico, 2016/02/11 02:23:41]

Done.

     "\n"
     "        On Windows, where the tools produce a .dll shared library and\n"
     "        a .lib import library, you will want both of these to be the\n"

[Dirk Pranke, 2016/02/11 02:18:08]

Nit: maybe reword this as "you will want the first two to be the import library,
and the third to be the .dll file".

[Nico, 2016/02/11 02:23:41]

Done.

-    "        import library. On Linux, if you're not doing the separate\n"
-    "        linking/dependency optimization, both of these should be the\n"
+    "        import library, while runtime_link_output should be set to the\n"
+    "        .dll file. On Linux, if you're not doing the separate\n"
+    "        linking/dependency optimization, all of these should be the\n"
     "        .so output.\n"
     "\n"
     "    output_prefix  [string]\n"
     "        Valid for: Linker tools (optional)\n"
     "\n"
     "        Prefix to use for the output name. Defaults to empty. This\n"
     "        prefix will be prepended to the name of the target (or the\n"
     "        output_name if one is manually specified for it) if the prefix\n"
     "        is not already there. The result will show up in the\n"
     "        {{output_name}} substitution pattern.\n"
@@ skipping 291 matching lines @@
   scoped_ptr<Tool> tool(new Tool);
 
   if (!ReadPattern(&block_scope, "command", subst_validator, tool.get(),
                    &Tool::set_command, err) ||
       !ReadOutputExtension(&block_scope, tool.get(), err) ||
       !ReadPattern(&block_scope, "depfile", subst_validator, tool.get(),
                    &Tool::set_depfile, err) ||
       !ReadDepsFormat(&block_scope, tool.get(), err) ||
       !ReadPattern(&block_scope, "description", subst_validator, tool.get(),
                    &Tool::set_description, err) ||
-      !ReadString(&block_scope, "lib_switch", tool.get(),
-                  &Tool::set_lib_switch, err) ||
+      !ReadString(&block_scope, "lib_switch", tool.get(), &Tool::set_lib_switch,
+                  err) ||
       !ReadString(&block_scope, "lib_dir_switch", tool.get(),
                   &Tool::set_lib_dir_switch, err) ||
       !ReadPattern(&block_scope, "link_output", subst_validator, tool.get(),
                    &Tool::set_link_output, err) ||
       !ReadPattern(&block_scope, "depend_output", subst_validator, tool.get(),
                    &Tool::set_depend_output, err) ||
+      !ReadPattern(&block_scope, "runtime_link_output", subst_validator,
+                   tool.get(), &Tool::set_runtime_link_output, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
       !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err)) {
     return Value();
   }
 
   if (tool_type != Toolchain::TYPE_COPY && tool_type != Toolchain::TYPE_STAMP) {
     // All tools except the copy and stamp tools should have outputs. The copy
     // and stamp tool's outputs are generated internally.
     if (!ReadOutputs(&block_scope, function, subst_output_validator,
                      tool.get(), err))
       return Value();
   }
 
-  // Validate that the link_output and depend_output refer to items in the
-  // outputs and aren't defined for irrelevant tool types.
+  // Validate that the link_output, depend_output, and runtime_link_output
+  // refer to items in the outputs and aren't defined for irrelevant tool
+  // types.
   if (!tool->link_output().empty()) {
     if (tool_type != Toolchain::TYPE_SOLINK &&
         tool_type != Toolchain::TYPE_SOLINK_MODULE) {
       *err = Err(function, "This tool specifies a link_output.",
           "This is only valid for solink and solink_module tools.");
       return Value();
     }
     if (!IsPatternInOutputList(tool->outputs(), tool->link_output())) {
       *err = Err(function, "This tool's link_output is bad.",
                  "It must match one of the outputs.");
@@ skipping 12 matching lines @@
                  "It must match one of the outputs.");
       return Value();
     }
   }
   if ((!tool->link_output().empty() && tool->depend_output().empty()) ||
       (tool->link_output().empty() && !tool->depend_output().empty())) {
     *err = Err(function, "Both link_output and depend_output should either "
         "be specified or they should both be empty.");
     return Value();
   }
+  if (!tool->runtime_link_output().empty()) {
+    if (tool_type != Toolchain::TYPE_SOLINK &&
+        tool_type != Toolchain::TYPE_SOLINK_MODULE) {
+      *err = Err(function, "This tool specifies a runtime_link_output.",
+          "This is only valid for solink and solink_module tools.");
+      return Value();
+    }
+    if (!IsPatternInOutputList(tool->outputs(), tool->runtime_link_output())) {
+      *err = Err(function, "This tool's runtime_link_output is bad.",
+                 "It must match one of the outputs.");
+      return Value();
+    }
+  }
 
   // Make sure there weren't any vars set in this tool that were unused.
   if (!block_scope.CheckForUnusedVars(err))
     return Value();
 
   toolchain->SetTool(tool_type, std::move(tool));
   return Value();
 }
 
 // toolchain_args --------------------------------------------------------------
@@ skipping 66 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions