tools/gn/ninja_target_command_util.cc

// Copyright 2018 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_target_command_util.h"

#include <string.h>

#include "tools/gn/c_tool.h"
#include "tools/gn/substitution_writer.h"

namespace {

// Returns the language-specific suffix for precompiled header files.
const char* GetPCHLangSuffixForToolType(const char* name) {
  if (name == CTool::kCToolCc)
    return "c";
  if (name == CTool::kCToolCxx)
    return "cc";
  if (name == CTool::kCToolObjC)
    return "m";
  if (name == CTool::kCToolObjCxx)
    return "mm";
  NOTREACHED() << "Not a valid PCH tool type: " << name;
  return "";
}

}  // namespace

// Returns the computed name of the Windows .pch file for the given
// tool type. The tool must support precompiled headers.
OutputFile GetWindowsPCHFile(const Target* target, const char* tool_name) {
  // Use "obj/{dir}/{target_name}_{lang}.pch" which ends up
  // looking like "obj/chrome/browser/browser_cc.pch"
  OutputFile ret = GetBuildDirForTargetAsOutputFile(target, BuildDirType::OBJ);
  ret.value().append(target->label().name());
  ret.value().push_back('_');
  ret.value().append(GetPCHLangSuffixForToolType(tool_name));
  ret.value().append(".pch");

  return ret;
}

void WriteOneFlag(const Target* target,
                  const Substitution* subst_enum,
                  bool has_precompiled_headers,
                  const char* tool_name,
                  const std::vector<std::string>& (ConfigValues::*getter)()
                      const,
                  EscapeOptions flag_escape_options,
                  PathOutput& path_output,
                  std::ostream& out,
                  bool write_substitution) {
  if (!target->toolchain()->substitution_bits().used.count(subst_enum))
    return;

  if (write_substitution)
    out << subst_enum->ninja_name << " =";

  if (has_precompiled_headers) {
    const CTool* tool = target->toolchain()->GetToolAsC(tool_name);
    if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
      // Name the .pch file.
      out << " /Fp";
      path_output.WriteFile(out, GetWindowsPCHFile(target, tool_name));

      // Enables precompiled headers and names the .h file. It's a string
      // rather than a file name (so no need to rebase or use path_output).
      out << " /Yu" << target->config_values().precompiled_header();
      RecursiveTargetConfigStringsToStream(target, getter, flag_escape_options,
                                           out);
    } else if (tool && tool->precompiled_header_type() == CTool::PCH_GCC) {
      // The targets to build the .gch files should omit the -include flag
      // below. To accomplish this, each substitution flag is overwritten in
      // the target rule and these values are repeated. The -include flag is
      // omitted in place of the required -x <header lang> flag for .gch
      // targets.
      RecursiveTargetConfigStringsToStream(target, getter, flag_escape_options,
                                           out);

      // Compute the gch file (it will be language-specific).
      std::vector<OutputFile> outputs;
      GetPCHOutputFiles(target, tool_name, &outputs);
      if (!outputs.empty()) {
        // Trim the .gch suffix for the -include flag.
        // e.g. for gch file foo/bar/target.precompiled.h.gch:
        //          -include foo/bar/target.precompiled.h
        std::string pch_file = outputs[0].value();
        pch_file.erase(pch_file.length() - 4);
        out << " -include " << pch_file;
      }
    } else {
      RecursiveTargetConfigStringsToStream(target, getter, flag_escape_options,
                                           out);
    }
  } else {
    RecursiveTargetConfigStringsToStream(target, getter, flag_escape_options,
                                         out);
  }

  if (write_substitution)
    out << std::endl;
}

void GetPCHOutputFiles(const Target* target,
                       const char* tool_name,
                       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 CTool* tool = target->toolchain()->GetToolAsC(tool_name);
  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.

  std::string& output_value = (*outputs)[0].value();
  size_t extension_offset = FindExtensionOffset(output_value);
  if (extension_offset == std::string::npos) {
    // No extension found.
    return;
  }
  DCHECK(extension_offset >= 1);
  DCHECK(output_value[extension_offset - 1] == '.');

  std::string output_extension;
  CTool::PrecompiledHeaderType header_type = tool->precompiled_header_type();
  switch (header_type) {
    case CTool::PCH_MSVC:
      output_extension = GetWindowsPCHObjectExtension(
          tool_name, output_value.substr(extension_offset - 1));
      break;
    case CTool::PCH_GCC:
      output_extension = GetGCCPCHOutputExtension(tool_name);
      break;
    case CTool::PCH_NONE:
      NOTREACHED() << "No outputs for no PCH type.";
      break;
  }
  output_value.replace(extension_offset - 1, std::string::npos,
                       output_extension);
}

std::string GetGCCPCHOutputExtension(const char* tool_name) {
  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_name);
  std::string result = ".";
  // For GCC, the output name must have a .gch suffix and be annotated with
  // the language type. For example:
  //   obj/foo/target_name.header.h ->
  //   obj/foo/target_name.header.h-cc.gch
  // In order for the compiler to pick it up, the output name (minus the .gch
  // suffix MUST match whatever is passed to the -include flag).
  result += "h-";
  result += lang_suffix;
  result += ".gch";
  return result;
}

std::string GetWindowsPCHObjectExtension(const char* tool_name,
                                         const std::string& obj_extension) {
  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_name);
  std::string result = ".";
  // For MSVC, annotate the obj files with the language type. For example:
  //   obj/foo/target_name.precompile.obj ->
  //   obj/foo/target_name.precompile.cc.obj
  result += lang_suffix;
  result += obj_extension;
  return result;
}