diff --git a/build/gen.py b/build/gen.py
index 6fb6dfc..eceeafe 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -375,6 +375,7 @@
         'tools/gn/command_path.cc',
         'tools/gn/command_refs.cc',
         'tools/gn/commands.cc',
+        'tools/gn/compile_commands_writer.cc',
         'tools/gn/config.cc',
         'tools/gn/config_values.cc',
         'tools/gn/config_values_extractors.cc',
@@ -425,6 +426,7 @@
         'tools/gn/ninja_copy_target_writer.cc',
         'tools/gn/ninja_create_bundle_target_writer.cc',
         'tools/gn/ninja_group_target_writer.cc',
+        'tools/gn/ninja_target_command_util.cc',
         'tools/gn/ninja_target_writer.cc',
         'tools/gn/ninja_toolchain_writer.cc',
         'tools/gn/ninja_utils.cc',
diff --git a/tools/gn/command_gen.cc b/tools/gn/command_gen.cc
index eb1b4d2..d959fe4 100644
--- a/tools/gn/command_gen.cc
+++ b/tools/gn/command_gen.cc
@@ -11,6 +11,7 @@
 #include "base/timer/elapsed_timer.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/commands.h"
+#include "tools/gn/compile_commands_writer.h"
 #include "tools/gn/eclipse_writer.h"
 #include "tools/gn/json_project_writer.h"
 #include "tools/gn/ninja_target_writer.h"
@@ -49,6 +50,7 @@
 const char kSwitchJsonFileName[] = "json-file-name";
 const char kSwitchJsonIdeScript[] = "json-ide-script";
 const char kSwitchJsonIdeScriptArgs[] = "json-ide-script-args";
+const char kSwitchExportCompileCommands[] = "export-compile-commands";
 
 // Collects Ninja rules for each toolchain. The lock protectes the rules.
 struct TargetWriteInfo {
@@ -279,6 +281,26 @@
   return false;
 }
 
+bool RunCompileCommandsWriter(const BuildSettings* build_settings,
+                              const Builder& builder,
+                              Err* err) {
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  bool quiet = command_line->HasSwitch(switches::kQuiet);
+  base::ElapsedTimer timer;
+
+  std::string file_name = "compile_commands.json";
+
+  bool res = CompileCommandsWriter::RunAndWriteFiles(build_settings, builder,
+                                                     file_name, quiet, err);
+  if (res && !quiet) {
+    OutputString("Generating compile_commands took " +
+                 base::Int64ToString(timer.Elapsed().InMilliseconds()) +
+                 "ms\n");
+  }
+  return res;
+}
+
 }  // namespace
 
 const char kGen[] = "gen";
@@ -455,6 +477,13 @@
     return 1;
   }
 
+  if (command_line->HasSwitch(kSwitchExportCompileCommands) &&
+      !RunCompileCommandsWriter(&setup->build_settings(), setup->builder(),
+                                &err)) {
+    err.PrintToStdout();
+    return 1;
+  }
+
   TickDelta elapsed_time = timer.Elapsed();
 
   if (!command_line->HasSwitch(switches::kQuiet)) {
diff --git a/tools/gn/compile_commands_writer.cc b/tools/gn/compile_commands_writer.cc
new file mode 100644
index 0000000..772d8d2
--- /dev/null
+++ b/tools/gn/compile_commands_writer.cc
@@ -0,0 +1,284 @@
+// 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/compile_commands_writer.h"
+
+#include <sstream>
+
+#include "base/strings/stringprintf.h"
+#include "tools/gn/builder.h"
+#include "tools/gn/config_values_extractors.h"
+#include "tools/gn/escape.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/ninja_target_command_util.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/substitution_writer.h"
+
+// Structure of JSON output file
+// [
+//   {
+//      "directory": "The build directory."
+//      "file": "The main source file processed by this compilation step.
+//               Must be absolute or relative to the above build directory."
+//      "command": "The compile command executed."
+//   }
+//   ...
+// ]
+
+namespace {
+
+#if defined(OS_WIN)
+const char kPrettyPrintLineEnding[] = "\r\n";
+#else
+const char kPrettyPrintLineEnding[] = "\n";
+#endif
+
+struct CompileFlags {
+  std::string includes;
+  std::string defines;
+  std::string cflags;
+  std::string cflags_c;
+  std::string cflags_cc;
+  std::string cflags_objc;
+  std::string cflags_objcc;
+};
+
+void SetupCompileFlags(const Target* target,
+                       PathOutput& path_output,
+                       EscapeOptions opts,
+                       CompileFlags& flags) {
+  bool has_precompiled_headers =
+      target->config_values().has_precompiled_headers();
+
+  std::ostringstream defines_out;
+  RecursiveTargetConfigToStream<std::string>(
+      target, &ConfigValues::defines,
+      DefineWriter(ESCAPE_NINJA_PREFORMATTED_COMMAND, true), defines_out);
+  flags.defines = defines_out.str();
+
+  std::ostringstream includes_out;
+  RecursiveTargetConfigToStream<SourceDir>(target, &ConfigValues::include_dirs,
+                                           IncludeWriter(path_output),
+                                           includes_out);
+  flags.includes = includes_out.str();
+
+  std::ostringstream cflags_out;
+  WriteOneFlag(target, SUBSTITUTION_CFLAGS, false, Toolchain::TYPE_NONE,
+               &ConfigValues::cflags, opts, path_output, cflags_out,
+               /*write_substitution=*/false);
+  flags.cflags = cflags_out.str();
+
+  std::ostringstream cflags_c_out;
+  WriteOneFlag(target, SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
+               Toolchain::TYPE_CC, &ConfigValues::cflags_c, opts, path_output,
+               cflags_c_out, /*write_substitution=*/false);
+  flags.cflags_c = cflags_c_out.str();
+
+  std::ostringstream cflags_cc_out;
+  WriteOneFlag(target, SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
+               Toolchain::TYPE_CXX, &ConfigValues::cflags_cc, opts, path_output,
+               cflags_cc_out, /*write_substitution=*/false);
+  flags.cflags_cc = cflags_cc_out.str();
+
+  std::ostringstream cflags_objc_out;
+  WriteOneFlag(target, SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
+               Toolchain::TYPE_OBJC, &ConfigValues::cflags_objc, opts,
+               path_output, cflags_objc_out, /*write_substitution=*/false);
+  flags.cflags_objc = cflags_objc_out.str();
+
+  std::ostringstream cflags_objcc_out;
+  WriteOneFlag(target, SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
+               Toolchain::TYPE_OBJCXX, &ConfigValues::cflags_objcc, opts,
+               path_output, cflags_objcc_out, /*write_substitution=*/false);
+  flags.cflags_objcc = cflags_objcc_out.str();
+}
+
+void WriteFile(const SourceFile& source,
+               PathOutput& path_output,
+               std::string* compile_commands) {
+  std::ostringstream rel_source_path;
+  path_output.WriteFile(rel_source_path, source);
+  compile_commands->append("    \"file\": \"");
+  compile_commands->append(rel_source_path.str());
+}
+
+void WriteDirectory(std::string build_dir, std::string* compile_commands) {
+  compile_commands->append("\",");
+  compile_commands->append(kPrettyPrintLineEnding);
+  compile_commands->append("    \"directory\": \"");
+  compile_commands->append(build_dir);
+  compile_commands->append("\",");
+}
+
+void WriteCommand(const Target* target,
+                  const SourceFile& source,
+                  const CompileFlags& flags,
+                  std::vector<OutputFile>& tool_outputs,
+                  PathOutput& path_output,
+                  SourceFileType source_type,
+                  Toolchain::ToolType tool_type,
+                  EscapeOptions opts,
+                  std::string* compile_commands) {
+  EscapeOptions no_quoting(opts);
+  no_quoting.inhibit_quoting = true;
+  const Tool* tool = target->toolchain()->GetTool(tool_type);
+  std::ostringstream command_out;
+
+  for (const auto& range : tool->command().ranges()) {
+    // TODO: this is emitting a bonus space prior to each substitution.
+    switch (range.type) {
+      case SUBSTITUTION_LITERAL:
+        EscapeStringToStream(command_out, range.literal, no_quoting);
+        break;
+      case SUBSTITUTION_OUTPUT:
+        path_output.WriteFiles(command_out, tool_outputs);
+        break;
+      case SUBSTITUTION_DEFINES:
+        command_out << flags.defines;
+        break;
+      case SUBSTITUTION_INCLUDE_DIRS:
+        command_out << flags.includes;
+        break;
+      case SUBSTITUTION_CFLAGS:
+        command_out << flags.cflags;
+        break;
+      case SUBSTITUTION_CFLAGS_C:
+        if (source_type == SOURCE_C)
+          command_out << flags.cflags_c;
+        break;
+      case SUBSTITUTION_CFLAGS_CC:
+        if (source_type == SOURCE_CPP)
+          command_out << flags.cflags_cc;
+        break;
+      case SUBSTITUTION_CFLAGS_OBJC:
+        if (source_type == SOURCE_M)
+          command_out << flags.cflags_objc;
+        break;
+      case SUBSTITUTION_CFLAGS_OBJCC:
+        if (source_type == SOURCE_MM)
+          command_out << flags.cflags_objcc;
+        break;
+      case SUBSTITUTION_LABEL:
+      case SUBSTITUTION_LABEL_NAME:
+      case SUBSTITUTION_ROOT_GEN_DIR:
+      case SUBSTITUTION_ROOT_OUT_DIR:
+      case SUBSTITUTION_TARGET_GEN_DIR:
+      case SUBSTITUTION_TARGET_OUT_DIR:
+      case SUBSTITUTION_TARGET_OUTPUT_NAME:
+      case SUBSTITUTION_SOURCE:
+      case SUBSTITUTION_SOURCE_NAME_PART:
+      case SUBSTITUTION_SOURCE_FILE_PART:
+      case SUBSTITUTION_SOURCE_DIR:
+      case SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR:
+      case SUBSTITUTION_SOURCE_GEN_DIR:
+      case SUBSTITUTION_SOURCE_OUT_DIR:
+      case SUBSTITUTION_SOURCE_TARGET_RELATIVE:
+        EscapeStringToStream(command_out,
+                             SubstitutionWriter::GetCompilerSubstitution(
+                                 target, source, range.type),
+                             opts);
+        break;
+
+      // Other flags shouldn't be relevant to compiling C/C++/ObjC/ObjC++
+      // source files.
+      default:
+        NOTREACHED() << "Unsupported substitution for this type of target : "
+                     << kSubstitutionNames[range.type];
+        continue;
+    }
+  }
+  compile_commands->append(kPrettyPrintLineEnding);
+  compile_commands->append("    \"command\": \"");
+  compile_commands->append(command_out.str());
+}
+
+void RenderJSON(const BuildSettings* build_settings,
+                const Builder& builder,
+                std::vector<const Target*>& all_targets,
+                std::string* compile_commands) {
+  // TODO: Determine out an appropriate size to reserve.
+  compile_commands->reserve(all_targets.size() * 100);
+  compile_commands->append("[");
+  compile_commands->append(kPrettyPrintLineEnding);
+  bool first = true;
+  auto build_dir = build_settings->GetFullPath(build_settings->build_dir());
+  std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
+
+  EscapeOptions opts;
+  opts.mode = ESCAPE_NINJA_PREFORMATTED_COMMAND;
+
+  for (const auto* target : all_targets) {
+    if (!target->IsBinary())
+      continue;
+
+    // Precompute values that are the same for all sources in a target to avoid
+    // computing for every source.
+
+    PathOutput path_output(
+        target->settings()->build_settings()->build_dir(),
+        target->settings()->build_settings()->root_path_utf8(),
+        ESCAPE_NINJA_COMMAND);
+
+    CompileFlags flags;
+    SetupCompileFlags(target, path_output, opts, flags);
+
+    for (const auto& source : target->sources()) {
+      // If this source is not a C/C++/ObjC/ObjC++ source (not header) file,
+      // continue as it does not belong in the compilation database.
+      SourceFileType source_type = GetSourceFileType(source);
+      if (source_type != SOURCE_CPP && source_type != SOURCE_C &&
+          source_type != SOURCE_M && source_type != SOURCE_MM)
+        continue;
+
+      Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
+      if (!target->GetOutputFilesForSource(source, &tool_type, &tool_outputs))
+        continue;
+
+      if (!first) {
+        compile_commands->append(",");
+        compile_commands->append(kPrettyPrintLineEnding);
+      }
+      first = false;
+      compile_commands->append("  {");
+      compile_commands->append(kPrettyPrintLineEnding);
+
+      WriteFile(source, path_output, compile_commands);
+      WriteDirectory(base::StringPrintf("%" PRIsFP, build_dir.value().c_str()),
+                     compile_commands);
+      WriteCommand(target, source, flags, tool_outputs, path_output,
+                   source_type, tool_type, opts, compile_commands);
+      compile_commands->append("\"");
+      compile_commands->append(kPrettyPrintLineEnding);
+      compile_commands->append("  }");
+    }
+  }
+
+  compile_commands->append(kPrettyPrintLineEnding);
+  compile_commands->append("]");
+  compile_commands->append(kPrettyPrintLineEnding);
+}
+
+}  // namespace
+
+bool CompileCommandsWriter::RunAndWriteFiles(
+    const BuildSettings* build_settings,
+    const Builder& builder,
+    const std::string& file_name,
+    bool quiet,
+    Err* err) {
+  SourceFile output_file = build_settings->build_dir().ResolveRelativeFile(
+      Value(nullptr, file_name), err);
+  if (output_file.is_null())
+    return false;
+
+  base::FilePath output_path = build_settings->GetFullPath(output_file);
+
+  std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();
+
+  std::string json;
+  RenderJSON(build_settings, builder, all_targets, &json);
+  if (!WriteFileIfChanged(output_path, json, err))
+    return false;
+  return true;
+}
diff --git a/tools/gn/compile_commands_writer.h b/tools/gn/compile_commands_writer.h
new file mode 100644
index 0000000..ad98dc2
--- /dev/null
+++ b/tools/gn/compile_commands_writer.h
@@ -0,0 +1,23 @@
+// 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.
+
+#ifndef TOOLS_GN_COMPILE_COMMANDS_WRITER_H_
+#define TOOLS_GN_COMPILE_COMMANDS_WRITER_H_
+
+#include "tools/gn/err.h"
+#include "tools/gn/target.h"
+
+class Builder;
+class BuildSettings;
+
+class CompileCommandsWriter {
+ public:
+  static bool RunAndWriteFiles(const BuildSettings* build_setting,
+                               const Builder& builder,
+                               const std::string& file_name,
+                               bool quiet,
+                               Err* err);
+};
+
+#endif  // TOOLS_GN_COMPILE_COMMANDS_WRITER_H_
diff --git a/tools/gn/ninja_binary_target_writer.cc b/tools/gn/ninja_binary_target_writer.cc
index 48982d3..9e5632e 100644
--- a/tools/gn/ninja_binary_target_writer.cc
+++ b/tools/gn/ninja_binary_target_writer.cc
@@ -19,6 +19,7 @@
 #include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/ninja_utils.h"
+#include "tools/gn/ninja_target_command_util.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_file_type.h"
@@ -50,78 +51,6 @@
   return opts;
 }
 
-struct DefineWriter {
-  DefineWriter() { options.mode = ESCAPE_NINJA_COMMAND; }
-
-  void operator()(const std::string& s, std::ostream& out) const {
-    out << " ";
-    EscapeStringToStream(out, "-D" + s, options);
-  }
-
-  EscapeOptions options;
-};
-
-struct IncludeWriter {
-  explicit IncludeWriter(PathOutput& path_output) : path_output_(path_output) {}
-  ~IncludeWriter() = default;
-
-  void operator()(const SourceDir& d, std::ostream& out) const {
-    std::ostringstream path_out;
-    path_output_.WriteDir(path_out, d, PathOutput::DIR_NO_LAST_SLASH);
-    const std::string& path = path_out.str();
-    if (path[0] == '"')
-      out << " \"-I" << path.substr(1);
-    else
-      out << " -I" << path;
-  }
-
-  PathOutput& path_output_;
-};
-
-// Returns the language-specific suffix for precompiled header files.
-const char* GetPCHLangSuffixForToolType(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 "";
-  }
-}
-
-std::string GetWindowsPCHObjectExtension(Toolchain::ToolType tool_type,
-                                         const std::string& obj_extension) {
-  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_type);
-  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;
-}
-
-std::string GetGCCPCHOutputExtension(Toolchain::ToolType tool_type) {
-  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_type);
-  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;
-}
-
 // Returns the language-specific lang recognized by gcc’s -x flag for
 // precompiled header files.
 const char* GetPCHLangForToolType(Toolchain::ToolType type) {
@@ -140,55 +69,6 @@
   }
 }
 
-// Fills |outputs| with the object or gch file for the precompiled header of the
-// given type (flag type and tool type must match).
-void GetPCHOutputFiles(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.
-
-  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;
-  Tool::PrecompiledHeaderType header_type = tool->precompiled_header_type();
-  switch (header_type) {
-    case Tool::PCH_MSVC:
-      output_extension = GetWindowsPCHObjectExtension(
-          tool_type, output_value.substr(extension_offset - 1));
-      break;
-    case Tool::PCH_GCC:
-      output_extension = GetGCCPCHOutputExtension(tool_type);
-      break;
-    case Tool::PCH_NONE:
-      NOTREACHED() << "No outputs for no PCH type.";
-      break;
-  }
-  output_value.replace(extension_offset - 1, std::string::npos,
-                       output_extension);
-}
-
 // Appends the object files generated by the given source set to the given
 // output vector.
 void AddSourceSetObjectFiles(const Target* source_set,
@@ -372,29 +252,29 @@
 
   EscapeOptions opts = GetFlagOptions();
   if (used_types.Get(SOURCE_S) || used_types.Get(SOURCE_ASM)) {
-    WriteOneFlag(SUBSTITUTION_ASMFLAGS, false, Toolchain::TYPE_NONE,
-                 &ConfigValues::asmflags, opts);
+    WriteOneFlag(target_, SUBSTITUTION_ASMFLAGS, false, Toolchain::TYPE_NONE,
+                 &ConfigValues::asmflags, opts, path_output_, out_);
   }
   if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_CPP) ||
       used_types.Get(SOURCE_M) || used_types.Get(SOURCE_MM)) {
-    WriteOneFlag(SUBSTITUTION_CFLAGS, false, Toolchain::TYPE_NONE,
-                 &ConfigValues::cflags, opts);
+    WriteOneFlag(target_, SUBSTITUTION_CFLAGS, false, Toolchain::TYPE_NONE,
+                 &ConfigValues::cflags, opts, path_output_, out_);
   }
   if (used_types.Get(SOURCE_C)) {
-    WriteOneFlag(SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
-                 Toolchain::TYPE_CC, &ConfigValues::cflags_c, opts);
+    WriteOneFlag(target_, SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
+                 Toolchain::TYPE_CC, &ConfigValues::cflags_c, opts, path_output_, out_);
   }
   if (used_types.Get(SOURCE_CPP)) {
-    WriteOneFlag(SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
-                 Toolchain::TYPE_CXX, &ConfigValues::cflags_cc, opts);
+    WriteOneFlag(target_, SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
+                 Toolchain::TYPE_CXX, &ConfigValues::cflags_cc, opts, path_output_, out_);
   }
   if (used_types.Get(SOURCE_M)) {
-    WriteOneFlag(SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
-                 Toolchain::TYPE_OBJC, &ConfigValues::cflags_objc, opts);
+    WriteOneFlag(target_, SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
+                 Toolchain::TYPE_OBJC, &ConfigValues::cflags_objc, opts, path_output_, out_);
   }
   if (used_types.Get(SOURCE_MM)) {
-    WriteOneFlag(SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
-                 Toolchain::TYPE_OBJCXX, &ConfigValues::cflags_objcc, opts);
+    WriteOneFlag(target_, SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
+                 Toolchain::TYPE_OBJCXX, &ConfigValues::cflags_objcc, opts, path_output_, out_);
   }
 
   WriteSharedVars(subst);
@@ -440,59 +320,6 @@
   return input_stamp_file;
 }
 
-void NinjaBinaryTargetWriter::WriteOneFlag(
-    SubstitutionType subst_enum,
-    bool has_precompiled_headers,
-    Toolchain::ToolType tool_type,
-    const std::vector<std::string>& (ConfigValues::*getter)() const,
-    EscapeOptions flag_escape_options) {
-  if (!target_->toolchain()->substitution_bits().used[subst_enum])
-    return;
-
-  out_ << kSubstitutionNinjaNames[subst_enum] << " =";
-
-  if (has_precompiled_headers) {
-    const Tool* tool = target_->toolchain()->GetTool(tool_type);
-    if (tool && tool->precompiled_header_type() == Tool::PCH_MSVC) {
-      // Name the .pch file.
-      out_ << " /Fp";
-      path_output_.WriteFile(out_, GetWindowsPCHFile(tool_type));
-
-      // 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() == Tool::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_type, &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_);
-  }
-  out_ << std::endl;
-}
-
 void NinjaBinaryTargetWriter::WritePCHCommands(
     const SourceFileTypeSet& used_types,
     const OutputFile& input_dep,
@@ -1033,19 +860,6 @@
   }
 }
 
-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"
-  OutputFile ret = GetBuildDirForTargetAsOutputFile(target_, BuildDirType::OBJ);
-  ret.value().append(target_->label().name());
-  ret.value().push_back('_');
-  ret.value().append(GetPCHLangSuffixForToolType(tool_type));
-  ret.value().append(".pch");
-
-  return ret;
-}
-
 bool NinjaBinaryTargetWriter::CheckForDuplicateObjectFiles(
     const std::vector<OutputFile>& files) const {
   std::unordered_set<std::string> set;
diff --git a/tools/gn/ninja_binary_target_writer.h b/tools/gn/ninja_binary_target_writer.h
index 4bc5b44..5cb7ab5 100644
--- a/tools/gn/ninja_binary_target_writer.h
+++ b/tools/gn/ninja_binary_target_writer.h
@@ -37,21 +37,6 @@
   // will be empty if there are no inputs.
   OutputFile WriteInputsStampAndGetDep() const;
 
-  // has_precompiled_headers is set when this substitution matches a tool type
-  // that supports precompiled headers, and this target supports precompiled
-  // headers. It doesn't indicate if the tool has precompiled headers (this
-  // will be looked up by this function).
-  //
-  // The tool_type indicates the corresponding tool for flags that are
-  // tool-specific (e.g. "cflags_c"). For non-tool-specific flags (e.g.
-  // "defines") tool_type should be TYPE_NONE.
-  void WriteOneFlag(SubstitutionType subst_enum,
-                    bool has_precompiled_headers,
-                    Toolchain::ToolType tool_type,
-                    const std::vector<std::string>& (ConfigValues::*getter)()
-                        const,
-                    EscapeOptions flag_escape_options);
-
   // Writes build lines required for precompiled headers. Any generated
   // object files will be appended to the |object_files|. Any generated
   // non-object files (for instance, .gch files from a GCC toolchain, are
@@ -140,9 +125,6 @@
   void WriteOrderOnlyDependencies(
       const UniqueVector<const Target*>& non_linkable_deps);
 
-  // Returns the computed name of the Windows .pch file for the given
-  // tool type. The tool must support precompiled headers.
-  OutputFile GetWindowsPCHFile(Toolchain::ToolType tool_type) const;
 
   // Checks for duplicates in the given list of output files. If any duplicates
   // are found, throws an error and return false.
diff --git a/tools/gn/ninja_binary_target_writer_unittest.cc b/tools/gn/ninja_binary_target_writer_unittest.cc
index 6d02a8b..a0a7ce8 100644
--- a/tools/gn/ninja_binary_target_writer_unittest.cc
+++ b/tools/gn/ninja_binary_target_writer_unittest.cc
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "tools/gn/config.h"
+#include "tools/gn/ninja_target_command_util.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scheduler.h"
diff --git a/tools/gn/ninja_target_command_util.cc b/tools/gn/ninja_target_command_util.cc
new file mode 100644
index 0000000..29662cd
--- /dev/null
+++ b/tools/gn/ninja_target_command_util.cc
@@ -0,0 +1,179 @@
+// 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/substitution_writer.h"
+
+namespace {
+
+// Returns the language-specific suffix for precompiled header files.
+const char* GetPCHLangSuffixForToolType(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 "";
+  }
+}
+
+}  // 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,
+                             Toolchain::ToolType tool_type) {
+  // 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_type));
+  ret.value().append(".pch");
+
+  return ret;
+}
+
+void WriteOneFlag(const Target* target,
+                  SubstitutionType subst_enum,
+                  bool has_precompiled_headers,
+                  Toolchain::ToolType tool_type,
+                  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[subst_enum])
+    return;
+
+  if (write_substitution)
+    out << kSubstitutionNinjaNames[subst_enum] << " =";
+
+  if (has_precompiled_headers) {
+    const Tool* tool = target->toolchain()->GetTool(tool_type);
+    if (tool && tool->precompiled_header_type() == Tool::PCH_MSVC) {
+      // Name the .pch file.
+      out << " /Fp";
+      path_output.WriteFile(out, GetWindowsPCHFile(target, tool_type));
+
+      // 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() == Tool::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_type, &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,
+                       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.
+
+  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;
+  Tool::PrecompiledHeaderType header_type = tool->precompiled_header_type();
+  switch (header_type) {
+    case Tool::PCH_MSVC:
+      output_extension = GetWindowsPCHObjectExtension(
+          tool_type, output_value.substr(extension_offset - 1));
+      break;
+    case Tool::PCH_GCC:
+      output_extension = GetGCCPCHOutputExtension(tool_type);
+      break;
+    case Tool::PCH_NONE:
+      NOTREACHED() << "No outputs for no PCH type.";
+      break;
+  }
+  output_value.replace(extension_offset - 1, std::string::npos,
+                       output_extension);
+}
+
+std::string GetGCCPCHOutputExtension(Toolchain::ToolType tool_type) {
+  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_type);
+  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(Toolchain::ToolType tool_type,
+                                         const std::string& obj_extension) {
+  const char* lang_suffix = GetPCHLangSuffixForToolType(tool_type);
+  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;
+}
diff --git a/tools/gn/ninja_target_command_util.h b/tools/gn/ninja_target_command_util.h
new file mode 100644
index 0000000..619add3
--- /dev/null
+++ b/tools/gn/ninja_target_command_util.h
@@ -0,0 +1,84 @@
+// 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.
+
+#ifndef TOOLS_GN_NINJA_TARGET_COMMAND_WRITER_H_
+#define TOOLS_GN_NINJA_TARGET_COMMAND_WRITER_H_
+
+#include "base/json/string_escape.h"
+#include "tools/gn/config_values_extractors.h"
+#include "tools/gn/escape.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/target.h"
+#include "tools/gn/toolchain.h"
+
+struct DefineWriter {
+  DefineWriter() { options.mode = ESCAPE_NINJA_COMMAND; }
+  DefineWriter(EscapingMode mode, bool escape_strings)
+      : escape_strings(escape_strings) {
+    options.mode = mode;
+  }
+
+  void operator()(const std::string& s, std::ostream& out) const {
+    out << " ";
+    if (escape_strings) {
+      std::string dest;
+      base::EscapeJSONString(s, false, &dest);
+      EscapeStringToStream(out, "-D" + dest, options);
+      return;
+    }
+    EscapeStringToStream(out, "-D" + s, options);
+  }
+
+  EscapeOptions options;
+  bool escape_strings = false;
+};
+
+struct IncludeWriter {
+  explicit IncludeWriter(PathOutput& path_output) : path_output_(path_output) {}
+  ~IncludeWriter() = default;
+
+  void operator()(const SourceDir& d, std::ostream& out) const {
+    std::ostringstream path_out;
+    path_output_.WriteDir(path_out, d, PathOutput::DIR_NO_LAST_SLASH);
+    const std::string& path = path_out.str();
+    if (path[0] == '"')
+      out << " \"-I" << path.substr(1);
+    else
+      out << " -I" << path;
+  }
+
+  PathOutput& path_output_;
+};
+
+// has_precompiled_headers is set when this substitution matches a tool type
+// that supports precompiled headers, and this target supports precompiled
+// headers. It doesn't indicate if the tool has precompiled headers (this
+// will be looked up by this function).
+//
+// The tool_type indicates the corresponding tool for flags that are
+// tool-specific (e.g. "cflags_c"). For non-tool-specific flags (e.g.
+// "defines") tool_type should be TYPE_NONE.
+void WriteOneFlag(const Target* target,
+                  SubstitutionType subst_enum,
+                  bool has_precompiled_headers,
+                  Toolchain::ToolType tool_type,
+                  const std::vector<std::string>& (ConfigValues::*getter)()
+                      const,
+                  EscapeOptions flag_escape_options,
+                  PathOutput& path_output,
+                  std::ostream& out,
+                  bool write_substitution = true);
+
+// Fills |outputs| with the object or gch file for the precompiled header of the
+// given type (flag type and tool type must match).
+void GetPCHOutputFiles(const Target* target,
+                       Toolchain::ToolType tool_type,
+                       std::vector<OutputFile>* outputs);
+
+std::string GetGCCPCHOutputExtension(Toolchain::ToolType tool_type);
+std::string GetWindowsPCHObjectExtension(Toolchain::ToolType tool_type,
+                                         const std::string& obj_extension);
+
+#endif  // TOOLS_GN_NINJA_TARGET_COMMAND_WRITER_H_