Windows precompiled header support in GN

tools/gn/target.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 "tools/gn/target.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 152 matching lines @@
   // inherited through the dependency tree (other flags don't work this way).
   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
     const ConfigValues& cur = iter.cur();
     all_lib_dirs_.append(cur.lib_dirs().begin(), cur.lib_dirs().end());
     all_libs_.append(cur.libs().begin(), cur.libs().end());
   }
 
   PullDependentTargets();
   PullForwardedDependentConfigs();
   PullRecursiveHardDeps();
+  if (!ResolvePrecompiledHeaders(err))
+    return false;
 
   FillOutputFiles();
 
   if (settings()->build_settings()->check_for_bad_items()) {
     if (!CheckVisibility(err))
       return false;
     if (!CheckTestonly(err))
       return false;
     if (!CheckNoNestedStaticLibs(err))
       return false;
@@ skipping 239 matching lines @@
       NormalizePath(&out.value());
   }
 
   // Also count anything the target has declared to be an output.
   std::vector<SourceFile> outputs_as_sources;
   action_values_.GetOutputsAsSourceFiles(this, &outputs_as_sources);
   for (const SourceFile& out : outputs_as_sources)
     computed_outputs_.push_back(OutputFile(settings()->build_settings(), out));
 }
 
+bool Target::ResolvePrecompiledHeaders(Err* err) {
+  // Precompiled headers are stored on a ConfigValues struct. This way, the
+  // build can set all the precompiled header settings in a config and apply
+  // it to many targets. Likewise, the precompiled header values may be
+  // specified directly on a target.
+  //
+  // Unlike other values on configs which are lists that just get concatenated,
+  // the precompiled header settings are unique values. We allow them to be
+  // specified anywhere, but if they are specified in more than one place all
+  // places must match.
+
+  // Track where the current settings came from for issuing errors.
+  const Label* pch_header_settings_from = NULL;
+  if (config_values_.has_precompiled_headers())
+    pch_header_settings_from = &label();
+
+  for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
+    if (!iter.GetCurrentConfig())
+      continue;  // Skip the one on the target itself.
+
+    const Config* config = iter.GetCurrentConfig();
+    const ConfigValues& cur = config->config_values();
+    if (!cur.has_precompiled_headers())
+      continue;  // This one has no precompiled header info, skip.
+
+    if (config_values_.has_precompiled_headers()) {
+      // Already have a precompiled header values, the settings must match.
+      if (config_values_.precompiled_header() != cur.precompiled_header() ||
+          config_values_.precompiled_source() != cur.precompiled_source()) {
+        *err = Err(defined_from(),
+            "Precompiled header setting conflict.",
+            "The target " + label().GetUserVisibleName(false) + "\n"
+            "has conflicting precompiled header settings.\n"
+            "\n"
+            "From " + pch_header_settings_from->GetUserVisibleName(false) +
+            "\n  header: " + config_values_.precompiled_header() +
+            "\n  source: " + config_values_.precompiled_source().value() +
+            "\n\n"
+            "From " + config->label().GetUserVisibleName(false) +
+            "\n  header: " + cur.precompiled_header() +
+            "\n  source: " + cur.precompiled_source().value());
+        return false;
+      }
+    } else {
+      // Have settings from a config, apply them to ourselves.
+      pch_header_settings_from = &config->label();
+      config_values_.set_precompiled_header(cur.precompiled_header());
+      config_values_.set_precompiled_source(cur.precompiled_source());
+    }
+  }
+
+  return true;
+}
+
 bool Target::CheckVisibility(Err* err) const {
   for (const auto& pair : GetDeps(DEPS_ALL)) {
     if (!Visibility::CheckItemVisibility(this, pair.ptr, err))
       return false;
   }
   return true;
 }
 
 bool Target::CheckTestonly(Err* err) const {
   // If the current target is marked testonly, it can include both testonly
@@ skipping 55 matching lines @@
     return;  // Not in output dir, this is OK.
 
   // Tell the scheduler about unknown files. This will be noted for later so
   // the list of files written by the GN build itself (often response files)
   // can be filtered out of this list.
   OutputFile out_file(settings()->build_settings(), source);
   std::set<const Target*> seen_targets;
   if (!EnsureFileIsGeneratedByDependency(this, out_file, true, &seen_targets))
     g_scheduler->AddUnknownGeneratedInput(this, source);
 }