[GN]: Support for loadable modules

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 "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
@@ skipping 177 matching lines @@
          type == Toolchain::TYPE_CXX ||
          type == Toolchain::TYPE_OBJC ||
          type == Toolchain::TYPE_OBJCXX ||
          type == Toolchain::TYPE_RC ||
          type == Toolchain::TYPE_ASM;
 }
 
 bool IsLinkerTool(Toolchain::ToolType type) {
   return type == Toolchain::TYPE_ALINK ||
          type == Toolchain::TYPE_SOLINK ||
+         type == Toolchain::TYPE_SOLINK_MODULE ||
          type == Toolchain::TYPE_LINK;
 }
 
 bool IsPatternInOutputList(const SubstitutionList& output_list,
                            const SubstitutionPattern& pattern) {
   for (const auto& cur : output_list.list()) {
     if (pattern.ranges().size() == cur.ranges().size() &&
         std::equal(pattern.ranges().begin(), pattern.ranges().end(),
                    cur.ranges().begin()))
       return true;
@@ skipping 183 matching lines @@
     "    Compiler tools:\n"
     "      \"cc\": C compiler\n"
     "      \"cxx\": C++ compiler\n"
     "      \"objc\": Objective C compiler\n"
     "      \"objcxx\": Objective C++ compiler\n"
     "      \"rc\": Resource compiler (Windows .rc files)\n"
     "      \"asm\": Assembler\n"
     "\n"
     "    Linker tools:\n"
     "      \"alink\": Linker for static libraries (archives)\n"
     "      \"solink\": Linker for shared libraries\n"

[Nico, 2016/02/11 00:32:52]

this didn't add solink_module to the documentation. can you fix that?

[Bons, 2016/02/12 16:09:22]

since you’re in the this code already why not add it?

[Nico, 2016/02/12 16:20:00]

I don't know what to write :-) I looked at the docs to find out what this does
and then noticed that it doesn't say. I gather it's similar to the same thing in
gyp; but when I last talked with brettw about this over a year ago, I think the
plan was to make loadable_module a bit on shared_library. Since things turned
out differently, I'm not sure what to write, so I need some help at least. Can
you give me a short summary of what to write?

I guess solink_module is used for loadable_module() targets and is generally
very similar to solink. Is solink_module() ever used on non-mac? Does
link_output vs depend_output make sense for it? (Neither's set on Windows for
solink_module in Chromium's case.)

     "      \"link\": Linker for executables\n"
     "\n"
     "    Other tools:\n"
     "      \"stamp\": Tool for creating stamp files\n"
     "      \"copy\": Tool to copy files.\n"
     "\n"
     "Tool variables\n"
     "\n"
     "    command  [string with substitutions]\n"
     "        Valid for: all tools (required)\n"
@@ skipping 84 matching lines @@
     "          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"
     "        Valid for: \"solink\" only (optional)\n"
     "\n"
-    "        These two files specify whch of the outputs from the solink\n"
+    "        These two 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"
     "        \"Separate linking and dependencies for shared libraries\"\n"
     "        below for more.\n"
     "\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"
     "        import library. On Linux, if you're not doing the separate\n"
     "        linking/dependency optimization, both of these should be the\n"
@@ skipping 323 matching lines @@
     // 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.
   if (!tool->link_output().empty()) {
-    if (tool_type != Toolchain::TYPE_SOLINK) {
+    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 tools.");
+          "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.");
       return Value();
     }
   }
   if (!tool->depend_output().empty()) {
-    if (tool_type != Toolchain::TYPE_SOLINK) {
+    if (tool_type != Toolchain::TYPE_SOLINK &&
+        tool_type != Toolchain::TYPE_SOLINK_MODULE) {
       *err = Err(function, "This tool specifies a depend_output.",
-          "This is only valid for solink tools.");
+          "This is only valid for solink and solink_module tools.");
       return Value();
     }
     if (!IsPatternInOutputList(tool->outputs(), tool->depend_output())) {
       *err = Err(function, "This tool's depend_output is bad.",
                  "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())) {
@@ skipping 80 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions