[GN]: Precompiled header support for GCC.

tools/gn/ninja_binary_target_writer.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/ninja_binary_target_writer.h"
 
 #include <cstring>
 #include <set>
 #include <sstream>
 
@@ skipping 114 matching lines @@
   const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
   if (!tool)
     return false;  // Tool does not apply for this toolchain.file.
 
   // Figure out what output(s) this compiler produces.
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       target, source, tool->outputs(), outputs);
   return !outputs->empty();
 }
 
-// Returns the language-specific prefix/suffix for precomiled header files.
-const char* GetPCHLangForToolType(Toolchain::ToolType type) {
+// Returns the language-specific suffix for precompiled header files.
+const char* GetPCHSuffixForToolType(Toolchain::ToolType type) {
   switch (type) {
     case Toolchain::TYPE_CC:
       return "c";
     case Toolchain::TYPE_CXX:
       return "cc";
     case Toolchain::TYPE_OBJC:
       return "m";
     case Toolchain::TYPE_OBJCXX:
       return "mm";
     default:
       NOTREACHED() << "Not a valid PCH tool type type";
       return "";
   }
 }
 
+// Returns the language-specific lang recognized by gcc’s -x flag for
+// precompiled header files.
+const char* GetPCHLangForToolType(Toolchain::ToolType type) {
+  switch (type) {
+    case Toolchain::TYPE_CC:
+      return "c-header";
+    case Toolchain::TYPE_CXX:
+      return "c++-header";
+    case Toolchain::TYPE_OBJC:
+      return "objective-c-header";
+    case Toolchain::TYPE_OBJCXX:
+      return "objective-c++-header";
+    default:
+      NOTREACHED() << "Not a valid PCH tool type type";
+      return "";
+  }
+}
+
 // Returns the object files for the precompiled header of the given type (flag
 // type and tool type must match).
-void GetWindowsPCHObjectFiles(const Target* target,
-                              Toolchain::ToolType tool_type,
-                              std::vector<OutputFile>* outputs) {
+void GetPCHObjectFiles(const Target* target,
+                       Toolchain::ToolType tool_type,
+                       std::vector<OutputFile>* outputs) {
   outputs->clear();
 
   // Compute the tool. This must use the tool type passed in rather than the
   // detected file type of the precompiled source file since the same
   // precompiled source file will be used for separate C/C++ compiles.
   const Tool* tool = target->toolchain()->GetTool(tool_type);
   if (!tool)
     return;
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       target, target->config_values().precompiled_source(),
       tool->outputs(), outputs);
 
   if (outputs->empty())
     return;
   if (outputs->size() > 1)
     outputs->resize(1);  // Only link the first output from the compiler tool.
 
   // Need to annotate the obj files with the language type. For example:
   //   obj/foo/target_name.precompile.obj ->
   //   obj/foo/target_name.precompile.cc.obj
-  const char* lang_suffix = GetPCHLangForToolType(tool_type);
+  const char* lang_suffix = GetPCHSuffixForToolType(tool_type);

[brettw, 2015/08/24 19:36:05]

I'm having a hard time trying to compute the intersection of what you're doing
and what the GCC docs say to do.

Can you paste an example ninja file generated by your code for me to look at?

I thought that the output name needed to be <header>.gch. From my reading of
this code, this will generate a .o file and link to it. On Windows you need .obj
files for precompiled headers, but in GCC you don't (to my knowledge).

[Bons, 2015/08/24 19:53:57]

defines =
include_dirs =
cflags =
cflags_cc =
target_output_name = pch_target

build withpch/obj/build/pch_target.precompile.cc.o: cxx ../../build/precompile.h
  cflags_cc = ${cflags_cc} -x c++-header

build withpch/obj/foo/pch_target.input1.o: cxx ../../foo/input1.cc |
withpch/obj/build/pch_target.precompile.cc.o

build withpch/obj/foo/pch_target.stamp: stamp
withpch/obj/foo/pch_target.input1.o withpch/obj/build/pch_target.precompile.cc.o

 
You’re correct. The output should be <header>.gch, not .o

   std::string& output_value = (*outputs)[0].value();
   size_t extension_offset = FindExtensionOffset(output_value);
   if (extension_offset == std::string::npos) {
     NOTREACHED() << "No extension found";
   } else {
     DCHECK(extension_offset >= 1);
     DCHECK(output_value[extension_offset - 1] == '.');
     output_value.insert(extension_offset - 1, ".");
     output_value.insert(extension_offset, lang_suffix);
   }
@@ skipping 12 matching lines @@
     Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
     if (GetOutputFilesForSource(source_set, source, &tool_type, &tool_outputs))
       obj_files->push_back(tool_outputs[0]);
 
     used_types.Set(GetSourceFileType(source));
   }
 
   // Precompiled header object files.
   if (source_set->config_values().has_precompiled_headers()) {
     if (used_types.Get(SOURCE_C)) {
-      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_CC, &tool_outputs);
+      GetPCHObjectFiles(source_set, Toolchain::TYPE_CC, &tool_outputs);
       obj_files->Append(tool_outputs.begin(), tool_outputs.end());
     }
     if (used_types.Get(SOURCE_CPP)) {
-      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_CXX, &tool_outputs);
+      GetPCHObjectFiles(source_set, Toolchain::TYPE_CXX, &tool_outputs);
       obj_files->Append(tool_outputs.begin(), tool_outputs.end());
     }
     if (used_types.Get(SOURCE_M)) {
-      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_OBJC, &tool_outputs);
+      GetPCHObjectFiles(source_set, Toolchain::TYPE_OBJC, &tool_outputs);
       obj_files->Append(tool_outputs.begin(), tool_outputs.end());
     }
     if (used_types.Get(SOURCE_MM)) {
-      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_OBJCXX,
+      GetPCHObjectFiles(source_set, Toolchain::TYPE_OBJCXX,
                                &tool_outputs);
       obj_files->Append(tool_outputs.begin(), tool_outputs.end());
     }
   }
 }
 
 }  // namespace
 
 NinjaBinaryTargetWriter::NinjaBinaryTargetWriter(const Target* target,
                                                  std::ostream& out)
@@ skipping 11 matching lines @@
   for (const auto& source : target_->sources())
     used_types.Set(GetSourceFileType(source));
 
   WriteCompilerVars(used_types);
 
   // The input dependencies will be an order-only dependency. This will cause
   // Ninja to make sure the inputs are up-to-date before compiling this source,
   // but changes in the inputs deps won't cause the file to be recompiled.
   //
   // This is important to prevent changes in unrelated actions that are
-  // upstream of this target from causing everything to be recompiled
+  // upstream of this target from causing everything to be recompiled.
   //
   // Why can we get away with this rather than using implicit deps ("|", which
-  // will force rebuilds when the inputs change)?  For source code, the
+  // will force rebuilds when the inputs change)? For source code, the
   // computed dependencies of all headers will be computed by the compiler,
   // which will cause source rebuilds if any "real" upstream dependencies
   // change.
   //
   // If a .cc file is generated by an input dependency, Ninja will see the
   // input to the build rule doesn't exist, and that it is an output from a
   // previous step, and build the previous step first. This is a "real"
   // dependency and doesn't need | or || to express.
   //
   // The only case where this rule matters is for the first build where no .d
@@ skipping 71 matching lines @@
         IncludeWriter(include_path_output), out_);
     out_ << std::endl;
   }
 
   bool has_precompiled_headers =
       target_->config_values().has_precompiled_headers();
 
   // Some toolchains pass cflags to the assembler since it's the same command,
   // and cflags_c might also be sent to the objective C compiler.
   //
-  // TODO(brettw) remove the SOURCE_M from the CFLAGS_C writing once the Chrome
+  // TODO(brettw): remove the SOURCE_M from the CFLAGS_C writing once the Chrome
   // Mac build is updated not to pass cflags_c to .m files.
   EscapeOptions opts = GetFlagOptions();
   if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_CPP) ||
       used_types.Get(SOURCE_M) || used_types.Get(SOURCE_MM) ||
       used_types.Get(SOURCE_S) || used_types.Get(SOURCE_ASM)) {
     WriteOneFlag(SUBSTITUTION_CFLAGS, false, Toolchain::TYPE_NONE,
                  &ConfigValues::cflags, opts);
   }
   if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_M) ||
       used_types.Get(SOURCE_S) || used_types.Get(SOURCE_ASM)) {
@@ skipping 47 matching lines @@
 
 void NinjaBinaryTargetWriter::WritePrecompiledHeaderCommands(
     const SourceFileTypeSet& used_types,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files) {
   if (!target_->config_values().has_precompiled_headers())
     return;
 
   const Tool* tool_c = target_->toolchain()->GetTool(Toolchain::TYPE_CC);
   if (tool_c &&
-      tool_c->precompiled_header_type() == Tool::PCH_MSVC &&
+      tool_c->precompiled_header_type() != Tool::PCH_NONE &&
       used_types.Get(SOURCE_C)) {
-    WriteWindowsPCHCommand(SUBSTITUTION_CFLAGS_C,
-                           Toolchain::TYPE_CC,
-                           order_only_dep, object_files);
+    WritePCHCommand(SUBSTITUTION_CFLAGS_C,
+                    Toolchain::TYPE_CC,
+                    tool_c->precompiled_header_type(),
+                    order_only_dep, object_files);
   }
   const Tool* tool_cxx = target_->toolchain()->GetTool(Toolchain::TYPE_CXX);
   if (tool_cxx &&
-      tool_cxx->precompiled_header_type() == Tool::PCH_MSVC &&
+      tool_cxx->precompiled_header_type() != Tool::PCH_NONE &&
       used_types.Get(SOURCE_CPP)) {
-    WriteWindowsPCHCommand(SUBSTITUTION_CFLAGS_CC,
-                           Toolchain::TYPE_CXX,
-                           order_only_dep, object_files);
+    WritePCHCommand(SUBSTITUTION_CFLAGS_CC,
+                    Toolchain::TYPE_CXX,
+                    tool_cxx->precompiled_header_type(),
+                    order_only_dep, object_files);
+  }
+
+  const Tool* tool_objc = target_->toolchain()->GetTool(Toolchain::TYPE_OBJC);
+  if (tool_objc &&
+      tool_objc->precompiled_header_type() == Tool::PCH_GCC &&
+      used_types.Get(SOURCE_M)) {
+    WritePCHCommand(SUBSTITUTION_CFLAGS_OBJC,
+                    Toolchain::TYPE_OBJC,
+                    tool_objc->precompiled_header_type(),
+                    order_only_dep, object_files);
+  }
+
+  const Tool* tool_objcxx =
+      target_->toolchain()->GetTool(Toolchain::TYPE_OBJCXX);
+  if (tool_objcxx &&
+      tool_objcxx->precompiled_header_type() == Tool::PCH_GCC &&
+      used_types.Get(SOURCE_MM)) {
+    WritePCHCommand(SUBSTITUTION_CFLAGS_OBJCC,
+                    Toolchain::TYPE_OBJCXX,
+                    tool_objcxx->precompiled_header_type(),
+                    order_only_dep, object_files);
   }
 }
 
-void NinjaBinaryTargetWriter::WriteWindowsPCHCommand(
-    SubstitutionType flag_type,
-    Toolchain::ToolType tool_type,
-    const OutputFile& order_only_dep,
-    std::vector<OutputFile>* object_files) {
+void NinjaBinaryTargetWriter::WritePCHCommand(
+  SubstitutionType flag_type,
+  Toolchain::ToolType tool_type,
+  Tool::PrecompiledHeaderType header_type,
+  const OutputFile& order_only_dep,
+  std::vector<OutputFile>* object_files) {
+  // With the GCC toolset, ensure the precompiled source and precompiled header
+  // are the same target.
+  if (header_type == Tool::PCH_GCC) {
+    SourceFile source = target_->config_values().precompiled_source();
+    std::string header_str = target_->config_values().precompiled_header();
+    header_str.insert(0, "//");
+    SourceFile header = SourceFile(SourceFile::SWAP_IN, &header_str);
+    if (source != header) {
+      NOTREACHED() << "PCH source file must equal header for GCC toolchain";
+    }
+  }
+
   // Compute the object file (it will be language-specific).
   std::vector<OutputFile> outputs;
-  GetWindowsPCHObjectFiles(target_, tool_type, &outputs);
+  GetPCHObjectFiles(target_, tool_type, &outputs);
   if (outputs.empty())
     return;
   object_files->insert(object_files->end(), outputs.begin(), outputs.end());
 
   // Build line to compile the file.
   WriteCompilerBuildLine(target_->config_values().precompiled_source(),
                          std::vector<OutputFile>(), order_only_dep, tool_type,
                          outputs);
 
-  // This build line needs a custom language-specific flags value. It needs to
-  // include the switch to generate the .pch file in addition to the normal
-  // ones. Rule-specific variables are just indented underneath the rule line,
-  // and this defines the new one in terms of the old value.
+  // This build line needs a custom language-specific flags value. Rule-specific
+  // variables are just indented underneath the rule line, and this defines the
+  // new one in terms of the old value.
   out_ << "  " << kSubstitutionNinjaNames[flag_type] << " =";
   out_ << " ${" << kSubstitutionNinjaNames[flag_type] << "}";
 
-  // Append the command to generate the .pch file.
-  out_ << " /Yc" << target_->config_values().precompiled_header();
+  switch (header_type) {
+    case Tool::PCH_MSVC:
+      // Append the command to generate the .pch file.
+      out_ << " /Yc" << target_->config_values().precompiled_header();
+      break;
+    case Tool::PCH_GCC:
+      // Append the command to specify the language of the .gch file.
+      out_ << " -x " << GetPCHLangForToolType(tool_type);
+      break;
+    case Tool::PCH_NONE:
+      NOTREACHED() << "Cannot write a PCH command with no PCH header type";
+      break;
+  }
 
   // Write two blank lines to help separate the PCH build lines from the
   // regular source build lines.
   out_ << std::endl << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
     const std::vector<OutputFile>& extra_deps,
     const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files,
@@ skipping 312 matching lines @@
     for (const auto& non_linkable_dep : non_linkable_deps) {
       out_ << " ";
       path_output_.WriteFile(out_, non_linkable_dep->dependency_output_file());
     }
   }
 }
 
 OutputFile NinjaBinaryTargetWriter::GetWindowsPCHFile(
     Toolchain::ToolType tool_type) const {
   // Use "obj/{dir}/{target_name}_{lang}.pch" which ends up
-  // looking like "obj/chrome/browser/browser.cc.pch"
+  // looking like "obj/chrome/browser/browser_cc.pch"
   OutputFile ret = GetTargetOutputDirAsOutputFile(target_);
   ret.value().append(target_->label().name());
   ret.value().push_back('_');
-  ret.value().append(GetPCHLangForToolType(tool_type));
+  ret.value().append(GetPCHSuffixForToolType(tool_type));
   ret.value().append(".pch");
 
   return ret;
 }
 
 bool NinjaBinaryTargetWriter::CheckForDuplicateObjectFiles(
     const std::vector<OutputFile>& files) const {
   base::hash_set<std::string> set;
   for (const auto& file : files) {
     if (!set.insert(file.value()).second) {
@@ skipping 11 matching lines @@
           "\n"
           "In the latter case, either rename one of the files or move one of\n"
           "the sources to a separate source_set to avoid them both being in\n"
           "the same target.");
       g_scheduler->FailWithError(err);
       return false;
     }
   }
   return true;
 }