blob: 74f69903076b852be6314855e0b5e108a37187e3 [file] [log] [blame]
// 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 "gn/compile_commands_writer.h"
#include <sstream>
#include "base/json/string_escape.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "gn/builder.h"
#include "gn/c_substitution_type.h"
#include "gn/c_tool.h"
#include "gn/config_values_extractors.h"
#include "gn/deps_iterator.h"
#include "gn/escape.h"
#include "gn/ninja_target_command_util.h"
#include "gn/path_output.h"
#include "gn/string_output_buffer.h"
#include "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;
std::string framework_dirs;
std::string frameworks;
};
// Helper template function to call RecursiveTargetConfigToStream<std::string>
// and return the JSON-escaped resulting string.
//
// NOTE: The Windows compiler cannot properly deduce the first parameter type
// so pass it at each call site to ensure proper builds for this platform.
template <typename T, typename Writer>
std::string FlagsGetter(RecursiveWriterConfig config,
const Target* target,
const std::vector<T>& (ConfigValues::*getter)() const,
const Writer& writer) {
std::string result;
std::ostringstream out;
RecursiveTargetConfigToStream<T>(config, target, getter, writer, out);
base::EscapeJSONString(out.str(), false, &result);
return result;
};
void SetupCompileFlags(const Target* target,
PathOutput& path_output,
EscapeOptions opts,
CompileFlags& flags) {
bool has_precompiled_headers =
target->config_values().has_precompiled_headers();
flags.defines = FlagsGetter<std::string>(
kRecursiveWriterSkipDuplicates, target, &ConfigValues::defines,
DefineWriter(ESCAPE_COMPILATION_DATABASE));
flags.framework_dirs = FlagsGetter<SourceDir>(
kRecursiveWriterSkipDuplicates, target, &ConfigValues::framework_dirs,
FrameworkDirsWriter(path_output, "-F"));
flags.frameworks = FlagsGetter<std::string>(
kRecursiveWriterSkipDuplicates, target, &ConfigValues::frameworks,
FrameworksWriter(ESCAPE_COMPILATION_DATABASE, "-framework"));
flags.frameworks += FlagsGetter<std::string>(
kRecursiveWriterSkipDuplicates, target, &ConfigValues::weak_frameworks,
FrameworksWriter(ESCAPE_COMPILATION_DATABASE, "-weak_framework"));
flags.includes = FlagsGetter<SourceDir>(kRecursiveWriterSkipDuplicates,
target, &ConfigValues::include_dirs,
IncludeWriter(path_output));
// Helper lambda to call WriteOneFlag() and return the resulting
// escaped JSON string.
auto one_flag = [&](RecursiveWriterConfig config,
const Substitution* substitution,
bool has_precompiled_headers, const char* tool_name,
const std::vector<std::string>& (ConfigValues::*getter)()
const) -> std::string {
std::string result;
std::ostringstream out;
WriteOneFlag(config, target, substitution, has_precompiled_headers,
tool_name, getter, opts, path_output, out,
/*write_substitution=*/false);
base::EscapeJSONString(out.str(), false, &result);
return result;
};
flags.cflags = one_flag(kRecursiveWriterKeepDuplicates, &CSubstitutionCFlags,
false, Tool::kToolNone, &ConfigValues::cflags);
flags.cflags_c = one_flag(kRecursiveWriterKeepDuplicates,
&CSubstitutionCFlagsC, has_precompiled_headers,
CTool::kCToolCc, &ConfigValues::cflags_c);
flags.cflags_cc = one_flag(kRecursiveWriterKeepDuplicates,
&CSubstitutionCFlagsCc, has_precompiled_headers,
CTool::kCToolCxx, &ConfigValues::cflags_cc);
flags.cflags_objc = one_flag(
kRecursiveWriterKeepDuplicates, &CSubstitutionCFlagsObjC,
has_precompiled_headers, CTool::kCToolObjC, &ConfigValues::cflags_objc);
flags.cflags_objcc =
one_flag(kRecursiveWriterKeepDuplicates, &CSubstitutionCFlagsObjCc,
has_precompiled_headers, CTool::kCToolObjCxx,
&ConfigValues::cflags_objcc);
}
void WriteFile(const SourceFile& source,
PathOutput& path_output,
std::ostream& out) {
std::ostringstream rel_source_path;
out << " \"file\": \"";
path_output.WriteFile(out, source);
}
void WriteDirectory(std::string build_dir, std::ostream& out) {
out << "\",";
out << kPrettyPrintLineEnding;
out << " \"directory\": \"";
out << build_dir;
out << "\",";
}
void WriteCommand(const Target* target,
const SourceFile& source,
const CompileFlags& flags,
std::vector<OutputFile>& tool_outputs,
PathOutput& path_output,
SourceFile::Type source_type,
const char* tool_name,
EscapeOptions opts,
std::ostream& out) {
EscapeOptions no_quoting(opts);
no_quoting.inhibit_quoting = true;
const Tool* tool = target->toolchain()->GetTool(tool_name);
out << kPrettyPrintLineEnding;
out << " \"command\": \"";
for (const auto& range : tool->command().ranges()) {
// TODO: this is emitting a bonus space prior to each substitution.
if (range.type == &SubstitutionLiteral) {
EscapeJSONStringToStream(out, range.literal, no_quoting);
} else if (range.type == &SubstitutionOutput) {
path_output.WriteFiles(out, tool_outputs);
} else if (range.type == &CSubstitutionDefines) {
out << flags.defines;
} else if (range.type == &CSubstitutionFrameworkDirs) {
out << flags.framework_dirs;
} else if (range.type == &CSubstitutionFrameworks) {
out << flags.frameworks;
} else if (range.type == &CSubstitutionIncludeDirs) {
out << flags.includes;
} else if (range.type == &CSubstitutionCFlags) {
out << flags.cflags;
} else if (range.type == &CSubstitutionCFlagsC) {
if (source_type == SourceFile::SOURCE_C)
out << flags.cflags_c;
} else if (range.type == &CSubstitutionCFlagsCc) {
if (source_type == SourceFile::SOURCE_CPP)
out << flags.cflags_cc;
} else if (range.type == &CSubstitutionCFlagsObjC) {
if (source_type == SourceFile::SOURCE_M)
out << flags.cflags_objc;
} else if (range.type == &CSubstitutionCFlagsObjCc) {
if (source_type == SourceFile::SOURCE_MM)
out << flags.cflags_objcc;
} else if (range.type == &SubstitutionLabel ||
range.type == &SubstitutionLabelName ||
range.type == &SubstitutionLabelNoToolchain ||
range.type == &SubstitutionRootGenDir ||
range.type == &SubstitutionRootOutDir ||
range.type == &SubstitutionTargetGenDir ||
range.type == &SubstitutionTargetOutDir ||
range.type == &SubstitutionTargetOutputName ||
range.type == &SubstitutionSource ||
range.type == &SubstitutionSourceNamePart ||
range.type == &SubstitutionSourceFilePart ||
range.type == &SubstitutionSourceDir ||
range.type == &SubstitutionSourceRootRelativeDir ||
range.type == &SubstitutionSourceGenDir ||
range.type == &SubstitutionSourceOutDir ||
range.type == &SubstitutionSourceTargetRelative) {
EscapeStringToStream(out,
SubstitutionWriter::GetCompilerSubstitution(
target, source, range.type),
opts);
} else {
// Other flags shouldn't be relevant to compiling C/C++/ObjC/ObjC++
// source files.
NOTREACHED() << "Unsupported substitution for this type of target : "
<< range.type->name;
continue;
}
}
}
void OutputJSON(const BuildSettings* build_settings,
std::vector<const Target*>& all_targets,
std::ostream& out) {
out << '[';
out << kPrettyPrintLineEnding;
bool first = true;
auto build_dir = build_settings->GetFullPath(build_settings->build_dir())
.StripTrailingSeparators();
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.
SourceFile::Type source_type = source.type();
if (source_type != SourceFile::SOURCE_CPP &&
source_type != SourceFile::SOURCE_C &&
source_type != SourceFile::SOURCE_M &&
source_type != SourceFile::SOURCE_MM)
continue;
const char* tool_name = Tool::kToolNone;
if (!target->GetOutputFilesForSource(source, &tool_name, &tool_outputs))
continue;
if (!first) {
out << ',';
out << kPrettyPrintLineEnding;
}
first = false;
out << " {";
out << kPrettyPrintLineEnding;
WriteFile(source, path_output, out);
WriteDirectory(base::StringPrintf("%" PRIsFP, PATH_CSTR(build_dir)), out);
WriteCommand(target, source, flags, tool_outputs, path_output,
source_type, tool_name, opts, out);
out << "\"";
out << kPrettyPrintLineEnding;
out << " }";
}
}
out << kPrettyPrintLineEnding;
out << "]";
out << kPrettyPrintLineEnding;
}
} // namespace
std::string CompileCommandsWriter::RenderJSON(
const BuildSettings* build_settings,
std::vector<const Target*>& all_targets) {
StringOutputBuffer json;
std::ostream out(&json);
OutputJSON(build_settings, all_targets, out);
return json.str();
}
bool CompileCommandsWriter::RunAndWriteFiles(
const BuildSettings* build_settings,
const Builder& builder,
const std::string& file_name,
const std::string& target_filters,
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::set<std::string> target_filters_set;
for (auto& target :
base::SplitString(target_filters, ",", base::TRIM_WHITESPACE,
base::SPLIT_WANT_NONEMPTY)) {
target_filters_set.insert(target);
}
StringOutputBuffer json;
std::ostream output_to_json(&json);
if (target_filters_set.empty()) {
OutputJSON(build_settings, all_targets, output_to_json);
} else {
std::vector<const Target*> preserved_targets =
FilterTargets(all_targets, target_filters_set);
OutputJSON(build_settings, preserved_targets, output_to_json);
}
return json.WriteToFileIfChanged(output_path, err);
}
std::vector<const Target*> CompileCommandsWriter::FilterTargets(
const std::vector<const Target*>& all_targets,
const std::set<std::string>& target_filters_set) {
std::vector<const Target*> preserved_targets;
std::set<const Target*> visited;
for (auto& target : all_targets) {
if (target_filters_set.count(target->label().name())) {
VisitDeps(target, &visited);
}
}
preserved_targets.reserve(visited.size());
// Preserve the original ordering of all_targets
// to allow easier debugging and testing.
for (auto& target : all_targets) {
if (visited.count(target)) {
preserved_targets.push_back(target);
}
}
return preserved_targets;
}
void CompileCommandsWriter::VisitDeps(const Target* target,
std::set<const Target*>* visited) {
if (!visited->count(target)) {
visited->insert(target);
for (const auto& pair : target->GetDeps(Target::DEPS_ALL)) {
VisitDeps(pair.ptr, visited);
}
}
}