sandboxed-api/sandboxed_api/tools/clang_generator/compilation_database.cc

230 lines
7.8 KiB
C++
Raw Normal View History

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "sandboxed_api/tools/clang_generator/compilation_database.h"
#include <algorithm>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/strings/strip.h"
#include "clang/Driver/Types.h"
#include "clang/Tooling/CompilationDatabase.h"
#include "llvm/Support/Path.h"
namespace sapi {
class WrappingCompilationDatabase : public clang::tooling::CompilationDatabase {
public:
explicit WrappingCompilationDatabase(
clang::tooling::CompilationDatabase& inner)
: inner_(&inner) {}
private:
std::vector<clang::tooling::CompileCommand> getCompileCommands(
llvm::StringRef file_path) const override {
return inner_->getCompileCommands(file_path);
}
std::vector<std::string> getAllFiles() const override {
return inner_->getAllFiles();
}
std::vector<clang::tooling::CompileCommand> getAllCompileCommands()
const override {
return inner_->getAllCompileCommands();
}
clang::tooling::CompilationDatabase* inner_;
};
std::unique_ptr<clang::tooling::CompilationDatabase> NonOwningCompileCommands(
clang::tooling::CompilationDatabase& inner) {
return std::make_unique<WrappingCompilationDatabase>(inner);
}
// Returns the command-line argument for setting the highest C language standard
// version for a given C++ standard version. If the specified string does not
// indicate a C++ standard, it is returned unchanged.
std::string CxxStdToCStd(const std::string& arg) {
absl::string_view std = arg;
if (!absl::ConsumePrefix(&std, "--std=c++") &&
!absl::ConsumePrefix(&std, "-std=c++")) {
return arg;
}
if (std == "23" || std == "2z" || std == "20" || std == "2a") {
return "--std=c17";
}
if (std == "17" || std == "1z" || std == "14" || std == "1y") {
return "--std=c11";
}
if (std == "11" || std == "0x") {
return "--std=c99";
}
return "--std=c89";
}
class FromCxxAjustedCompilationDatabase
: public clang::tooling::CompilationDatabase {
public:
explicit FromCxxAjustedCompilationDatabase(
std::unique_ptr<clang::tooling::CompilationDatabase> inner)
: inner_(std::move(inner)) {}
std::vector<clang::tooling::CompileCommand> getCompileCommands(
llvm::StringRef file_path) const override {
clang::driver::types::ID id =
llvm::sys::path::has_extension(file_path)
? clang::driver::types::lookupTypeForExtension(
llvm::sys::path::extension(file_path).drop_front())
: clang::driver::types::TY_CXXHeader;
std::vector<clang::tooling::CompileCommand> cmds =
inner_->getCompileCommands(file_path);
for (auto& cmd : cmds) {
auto& argv = cmd.CommandLine;
if (clang::driver::types::isCXX(id) ||
id == clang::driver::types::TY_CHeader) {
argv[0] = "clang++";
if (id == clang::driver::types::TY_CHeader) {
// Parse all headers as C++. Well-behaved headers should have an
// include guard.
argv.insert(argv.begin() + 1, {"-x", "c++"});
}
} else {
argv[0] = "clang";
std::transform(argv.begin(), argv.end(), argv.begin(), CxxStdToCStd);
}
}
return cmds;
}
std::vector<std::string> getAllFiles() const override {
return inner_->getAllFiles();
}
std::vector<clang::tooling::CompileCommand> getAllCompileCommands()
const override {
return {};
}
std::unique_ptr<clang::tooling::CompilationDatabase> inner_;
};
std::unique_ptr<clang::tooling::CompilationDatabase>
FromCxxAjustedCompileCommands(
std::unique_ptr<clang::tooling::CompilationDatabase> inner) {
return std::make_unique<FromCxxAjustedCompilationDatabase>(std::move(inner));
}
llvm::Expected<OptionsParser> OptionsParser::create(
int& argc, const char** argv, llvm::cl::OptionCategory& category,
llvm::cl::NumOccurrencesFlag occurrences_flag, const char* overview) {
OptionsParser parser;
if (llvm::Error err =
parser.init(argc, argv, category, occurrences_flag, overview);
err) {
return err;
}
return parser;
}
llvm::Error OptionsParser::init(int& argc, const char** argv,
llvm::cl::OptionCategory& category,
llvm::cl::NumOccurrencesFlag occurrences_flag,
const char* overview) {
static auto* build_path = new llvm::cl::opt<std::string>(
"p", llvm::cl::desc("Build path"), llvm::cl::Optional,
llvm::cl::cat(category), llvm::cl::sub(*llvm::cl::AllSubCommands));
static auto* source_paths = new llvm::cl::list<std::string>(
llvm::cl::Positional, llvm::cl::desc("<source0> [... <sourceN>]"),
occurrences_flag, llvm::cl::cat(category),
llvm::cl::sub(*llvm::cl::AllSubCommands));
static auto* args_after = new llvm::cl::list<std::string>(
"extra-arg",
llvm::cl::desc(
"Additional argument to append to the compiler command line"),
llvm::cl::cat(category), llvm::cl::sub(*llvm::cl::AllSubCommands));
static auto* args_before = new llvm::cl::list<std::string>(
"extra-arg-before",
llvm::cl::desc(
"Additional argument to prepend to the compiler command line"),
llvm::cl::cat(category), llvm::cl::sub(*llvm::cl::AllSubCommands));
llvm::cl::ResetAllOptionOccurrences();
llvm::cl::HideUnrelatedOptions(category);
{
std::string error_message;
compilations_ =
clang::tooling::FixedCompilationDatabase::loadFromCommandLine(
argc, argv, error_message);
if (!error_message.empty()) {
error_message.append("\n");
}
// Stop initializing if command-line option parsing failed.
if (llvm::raw_string_ostream os(error_message);
!llvm::cl::ParseCommandLineOptions(argc, argv, overview, &os)) {
os.flush();
return llvm::make_error<llvm::StringError>(
error_message, llvm::inconvertibleErrorCode());
}
}
llvm::cl::PrintOptionValues();
source_path_list_ = *source_paths;
if ((occurrences_flag == llvm::cl::ZeroOrMore ||
occurrences_flag == llvm::cl::Optional) &&
source_path_list_.empty()) {
return llvm::Error::success();
}
if (!compilations_) {
std::string error_message;
if (!build_path->empty()) {
compilations_ =
clang::tooling::CompilationDatabase::autoDetectFromDirectory(
*build_path, error_message);
} else {
compilations_ = clang::tooling::CompilationDatabase::autoDetectFromSource(
(*source_paths)[0], error_message);
}
if (!compilations_) {
compilations_.reset(new clang::tooling::FixedCompilationDatabase(
".", std::vector<std::string>()));
}
}
auto adjusting_compilations =
std::make_unique<clang::tooling::ArgumentsAdjustingCompilations>(
std::move(compilations_));
adjuster_ = getInsertArgumentAdjuster(
*args_before, clang::tooling::ArgumentInsertPosition::BEGIN);
adjuster_ = clang::tooling::combineAdjusters(
std::move(adjuster_),
getInsertArgumentAdjuster(*args_after,
clang::tooling::ArgumentInsertPosition::END));
adjusting_compilations->appendArgumentsAdjuster(adjuster_);
compilations_ = std::move(adjusting_compilations);
return llvm::Error::success();
}
} // namespace sapi