maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[JSONCompilationDatabase] Strip distcc/ccache/gomacc wrappers from parsed commands." 

New test is failing on Windows bot

This reverts commit 9c0391b36a.

llvm-svn: 365906
This commit is contained in:
Russell Gallop 2019-07-12 15:15:56 +00:00
parent 1d062dae15
commit 614a78c15a
2 changed files with 4 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
clang/lib/Tooling/JSONCompilationDatabase.cpp
View File

@ -256,57 +256,15 @@ JSONCompilationDatabase::getAllCompileCommands() const {
return Commands;
}
static llvm::StringRef stripExecutableExtension(llvm::StringRef Name) {
Name.consume_back(".exe");
return Name;
}
// There are compiler-wrappers (ccache, distcc, gomacc) that take the "real"
// compiler as an argument, e.g. distcc gcc -O3 foo.c.
// These end up in compile_commands.json when people set CC="distcc gcc".
// Clang's driver doesn't understand this, so we need to unwrap.
static bool unwrapCommand(std::vector<std::string> &Args) {
if (Args.size() < 2)
return false;
StringRef Wrapper =
stripExecutableExtension(llvm::sys::path::filename(Args.front()));
if (Wrapper == "distcc" || Wrapper == "gomacc" || Wrapper == "ccache") {
// Most of these wrappers support being invoked 3 ways:
// `distcc g++ file.c` This is the mode we're trying to match.
// We need to drop `distcc`.
// `distcc file.c` This acts like compiler is cc or similar.
// Clang's driver can handle this, no change needed.
// `g++ file.c` g++ is a symlink to distcc.
// We don't even notice this case, and all is well.
//
// We need to distinguish between the first and second case.
// The wrappers themselves don't take flags, so Args[1] is a compiler flag,
// an input file, or a compiler. Inputs have extensions, compilers don't.
bool HasCompiler =
(Args[1][0] != '-') &&
!llvm::sys::path::has_extension(stripExecutableExtension(Args[1]));
if (HasCompiler) {
Args.erase(Args.begin());
return true;
}
// If !HasCompiler, wrappers act like GCC. Fine: so do we.
}
return false;
}
static std::vector<std::string>
nodeToCommandLine(JSONCommandLineSyntax Syntax,
const std::vector<llvm::yaml::ScalarNode *> &Nodes) {
SmallString<1024> Storage;
std::vector<std::string> Arguments;
if (Nodes.size() == 1)
Arguments = unescapeCommandLine(Syntax, Nodes[0]->getValue(Storage));
else
for (const auto *Node : Nodes)
Arguments.push_back(Node->getValue(Storage));
// There may be multiple wrappers: using distcc and ccache together is common.
while (unwrapCommand(Arguments))
;
return unescapeCommandLine(Syntax, Nodes[0]->getValue(Storage));
std::vector<std::string> Arguments;
for (const auto *Node : Nodes)
Arguments.push_back(Node->getValue(Storage));
return Arguments;
}

24
clang/unittests/Tooling/CompilationDatabaseTest.cpp
View File

@ -370,30 +370,6 @@ TEST(findCompileArgsInJsonDatabase, FindsEntry) {
EXPECT_EQ("command4", FoundCommand.CommandLine[0]) << ErrorMessage;
}
TEST(findCompileArgsInJsonDatabase, ParsesCompilerWrappers) {
std::vector<std::pair<std::string, std::string>> Cases = {
{"distcc gcc foo.c", "gcc foo.c"},
{"gomacc clang++ foo.c", "clang++ foo.c"},
{"ccache gcc foo.c", "gcc foo.c"},
{"ccache.exe gcc foo.c", "gcc foo.c"},
{"ccache g++.exe foo.c", "g++.exe foo.c"},
{"ccache distcc gcc foo.c", "gcc foo.c"},
{"distcc foo.c", "distcc foo.c"},
{"distcc -I/foo/bar foo.c", "distcc -I/foo/bar foo.c"},
};
std::string ErrorMessage;
for (const auto &Case : Cases) {
std::string DB = R"([{"directory":".", "file":"/foo.c", "command":")" +
Case.first + "\"}]";
CompileCommand FoundCommand =
findCompileArgsInJsonDatabase("/foo.c", DB, ErrorMessage);
EXPECT_EQ(Case.second, llvm::join(FoundCommand.CommandLine, " "))
<< Case.first;
}
}
static std::vector<std::string> unescapeJsonCommandLine(StringRef Command) {
std::string JsonDatabase =
("[{\"directory\":\"//net/root\", \"file\":\"test\", \"command\": \"" +