Allow GN toolchains to specify runtime deps outputs.

tools/gn/runtime_deps.cc

 // Copyright 2015 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 "tools/gn/runtime_deps.h"
 
 #include <map>
 #include <set>
 #include <sstream>
 
@@ skipping 32 matching lines @@
               const Target* source,
               RuntimeDepsVector* deps,
               std::set<OutputFile>* found_file) {
   OutputFile output_file(RebasePath(
       str,
       source->settings()->build_settings()->build_dir(),
       source->settings()->build_settings()->root_path_utf8()));
   AddIfNew(output_file, source, deps, found_file);
 }
 
-// Returns the output file that the runtime deps considers for the given
-// targets. This is weird only for shared libraries.
-const OutputFile& GetMainOutput(const Target* target) {
-  if (target->output_type() == Target::SHARED_LIBRARY)
-    return target->runtime_link_output_file();
-  return target->dependency_output_file();
-}
-
 // To avoid duplicate traversals of targets, or duplicating output files that
 // might be listed by more than one target, the set of targets and output files
 // that have been found so far is passed. The "value" of the seen_targets map
 // is a boolean indicating if the seen dep was a data dep (true = data_dep).
 // data deps add more stuff, so we will want to revisit a target if it's a
 // data dependency and we've previously only seen it as a regular dep.
 void RecursiveCollectRuntimeDeps(const Target* target,
                                  bool is_target_data_dep,
                                  RuntimeDepsVector* deps,
                                  std::map<const Target*, bool>* seen_targets,
                                  std::set<OutputFile>* found_files) {
   const auto& found_seen_target = seen_targets->find(target);
   if (found_seen_target != seen_targets->end()) {
     // Already visited.
     if (found_seen_target->second || !is_target_data_dep) {
       // Already visited as a data dep, or the current dep is not a data
       // dep so visiting again will be a no-op.
       return;
     }
     // In the else case, the previously seen target was a regular dependency
     // and we'll now process it as a data dependency.
   }
   (*seen_targets)[target] = is_target_data_dep;
 
   // Add the main output file for executables, shared libraries, and
   // loadable modules.
   if (target->output_type() == Target::EXECUTABLE ||
       target->output_type() == Target::LOADABLE_MODULE ||
-      target->output_type() == Target::SHARED_LIBRARY)
-    AddIfNew(GetMainOutput(target), target, deps, found_files);
+      target->output_type() == Target::SHARED_LIBRARY) {
+    for (const auto& runtime_output : target->runtime_outputs())
+      AddIfNew(runtime_output, target, deps, found_files);
+  }
 
   // Add all data files.
   for (const auto& file : target->data())
     AddIfNew(file, target, deps, found_files);
 
   // Actions/copy have all outputs considered when the're a data dep.
   if (is_target_data_dep &&
       (target->output_type() == Target::ACTION ||
        target->output_type() == Target::ACTION_FOREACH ||
        target->output_type() == Target::COPY_FILES)) {
@@ skipping 65 matching lines @@
     const Target* target = item ? item->AsTarget() : nullptr;
     if (!target) {
       *err = Err(Location(), "The label \"" + label.GetUserVisibleName(true) +
           "\" isn't a target.",
           "When reading the line:\n  " + line + "\n"
           "from the --" + switches::kRuntimeDepsListFile + "=" +
           deps_target_list_file);
       return false;
     }
 
-    OutputFile output_file =
-        OutputFile(GetMainOutput(target).value() + ".runtime_deps");
+    OutputFile output_file;
+    const char extension[] = ".runtime_deps";
+    if (target->output_type() == Target::SHARED_LIBRARY ||
+        target->output_type() == Target::LOADABLE_MODULE) {
+      // Force the first output for shared-library-type linker outputs since
+      // the dependency output files might not be the main output.
+      CHECK(!target->computed_outputs().empty());
+      output_file =
+          OutputFile(target->computed_outputs()[0].value() + extension);
+    } else {
+      output_file =
+          OutputFile(target->dependency_output_file().value() + extension);
+    }
     files_to_write->push_back(std::make_pair(output_file, target));
   }
   return true;
 }
 
 bool WriteRuntimeDepsFile(const OutputFile& output_file,
                           const Target* target,
                           Err* err) {
   SourceFile output_as_source =
       output_file.AsSourceFile(target->settings()->build_settings());
@@ skipping 67 matching lines @@
     "\n"
     "  The results of static_library or source_set targets are not considered\n"
     "  runtime dependencies since these are assumed to be intermediate\n"
     "  targets only. If you need to list a static library as a runtime\n"
     "  dependency, you can manually compute the .a/.lib file name for the\n"
     "  current platform and list it in the \"data\" list of a target\n"
     "  (possibly on the static library target itself).\n"
     "\n"
     "Multiple outputs\n"
     "\n"
-    "  When a tool produces more than one output, only the first output\n"
-    "  is considered. For example, a shared library target may produce a\n"
-    "  .dll and a .lib file on Windows. Only the .dll file will be considered\n"
-    "  a runtime dependency. This applies only to linker tools. Scripts and\n"
-    "  copy steps with multiple outputs will get all outputs listed.\n";
+    "  Linker tools can specify which of their outputs should be considered\n"
+    "  when computing the runtime deps by setting runtime_outputs. If this\n"
+    "  is unset on the tool, the default will be the first output only.\n";
 
 RuntimeDepsVector ComputeRuntimeDeps(const Target* target) {
   RuntimeDepsVector result;
   std::map<const Target*, bool> seen_targets;
   std::set<OutputFile> found_files;
 
   // The initial target is not considered a data dependency so that actions's
   // outputs (if the current target is an action) are not automatically
   // considered data deps.
   RecursiveCollectRuntimeDeps(target, false,
@@ skipping 14 matching lines @@
 
   for (const auto& entry : files_to_write) {
     // Currently this writes all runtime deps files sequentially. We generally
     // expect few of these. We can run this on the worker pool if it looks
     // like it's talking a long time.
     if (!WriteRuntimeDepsFile(entry.first, entry.second, err))
       return false;
   }
   return true;
 }