1 //===--- Tooling.cpp - Running clang standalone tools ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements functions to run clang tools standalone instead
11 // of running them as a plugin.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/Tooling/Tooling.h"
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/Tool.h"
19 #include "clang/Frontend/CompilerInstance.h"
20 #include "clang/Frontend/FrontendDiagnostic.h"
21 #include "clang/Frontend/TextDiagnosticPrinter.h"
22 #include "clang/Tooling/ArgumentsAdjusters.h"
23 #include "clang/Tooling/CompilationDatabase.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/Support/Debug.h"
26 #include "llvm/Support/FileSystem.h"
27 #include "llvm/Support/Host.h"
28 #include "llvm/Support/raw_ostream.h"
29
30 // For chdir, see the comment in ClangTool::run for more information.
31 #ifdef _WIN32
32 # include <direct.h>
33 #else
34 # include <unistd.h>
35 #endif
36
37 namespace clang {
38 namespace tooling {
39
~FrontendActionFactory()40 FrontendActionFactory::~FrontendActionFactory() {}
41
42 // FIXME: This file contains structural duplication with other parts of the
43 // code that sets up a compiler to run tools on it, and we should refactor
44 // it to be based on the same framework.
45
46 /// \brief Builds a clang driver initialized for running clang tools.
newDriver(clang::DiagnosticsEngine * Diagnostics,const char * BinaryName)47 static clang::driver::Driver *newDriver(clang::DiagnosticsEngine *Diagnostics,
48 const char *BinaryName) {
49 const std::string DefaultOutputName = "a.out";
50 clang::driver::Driver *CompilerDriver = new clang::driver::Driver(
51 BinaryName, llvm::sys::getDefaultTargetTriple(),
52 DefaultOutputName, *Diagnostics);
53 CompilerDriver->setTitle("clang_based_tool");
54 return CompilerDriver;
55 }
56
57 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.
58 ///
59 /// Returns NULL on error.
getCC1Arguments(clang::DiagnosticsEngine * Diagnostics,clang::driver::Compilation * Compilation)60 static const clang::driver::ArgStringList *getCC1Arguments(
61 clang::DiagnosticsEngine *Diagnostics,
62 clang::driver::Compilation *Compilation) {
63 // We expect to get back exactly one Command job, if we didn't something
64 // failed. Extract that job from the Compilation.
65 const clang::driver::JobList &Jobs = Compilation->getJobs();
66 if (Jobs.size() != 1 || !isa<clang::driver::Command>(*Jobs.begin())) {
67 SmallString<256> error_msg;
68 llvm::raw_svector_ostream error_stream(error_msg);
69 Compilation->PrintJob(error_stream, Compilation->getJobs(), "; ", true);
70 Diagnostics->Report(clang::diag::err_fe_expected_compiler_job)
71 << error_stream.str();
72 return NULL;
73 }
74
75 // The one job we find should be to invoke clang again.
76 const clang::driver::Command *Cmd =
77 cast<clang::driver::Command>(*Jobs.begin());
78 if (StringRef(Cmd->getCreator().getName()) != "clang") {
79 Diagnostics->Report(clang::diag::err_fe_expected_clang_command);
80 return NULL;
81 }
82
83 return &Cmd->getArguments();
84 }
85
86 /// \brief Returns a clang build invocation initialized from the CC1 flags.
newInvocation(clang::DiagnosticsEngine * Diagnostics,const clang::driver::ArgStringList & CC1Args)87 static clang::CompilerInvocation *newInvocation(
88 clang::DiagnosticsEngine *Diagnostics,
89 const clang::driver::ArgStringList &CC1Args) {
90 assert(!CC1Args.empty() && "Must at least contain the program name!");
91 clang::CompilerInvocation *Invocation = new clang::CompilerInvocation;
92 clang::CompilerInvocation::CreateFromArgs(
93 *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
94 *Diagnostics);
95 Invocation->getFrontendOpts().DisableFree = false;
96 return Invocation;
97 }
98
runToolOnCode(clang::FrontendAction * ToolAction,const Twine & Code,const Twine & FileName)99 bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
100 const Twine &FileName) {
101 return runToolOnCodeWithArgs(
102 ToolAction, Code, std::vector<std::string>(), FileName);
103 }
104
runToolOnCodeWithArgs(clang::FrontendAction * ToolAction,const Twine & Code,const std::vector<std::string> & Args,const Twine & FileName)105 bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code,
106 const std::vector<std::string> &Args,
107 const Twine &FileName) {
108 SmallString<16> FileNameStorage;
109 StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
110 std::vector<std::string> Commands;
111 Commands.push_back("clang-tool");
112 Commands.push_back("-fsyntax-only");
113 Commands.insert(Commands.end(), Args.begin(), Args.end());
114 Commands.push_back(FileNameRef.data());
115 FileManager Files((FileSystemOptions()));
116 ToolInvocation Invocation(Commands, ToolAction, &Files);
117
118 SmallString<1024> CodeStorage;
119 Invocation.mapVirtualFile(FileNameRef,
120 Code.toNullTerminatedStringRef(CodeStorage));
121 return Invocation.run();
122 }
123
getAbsolutePath(StringRef File)124 std::string getAbsolutePath(StringRef File) {
125 SmallString<1024> BaseDirectory;
126 if (const char *PWD = ::getenv("PWD"))
127 BaseDirectory = PWD;
128 else
129 llvm::sys::fs::current_path(BaseDirectory);
130 SmallString<1024> PathStorage;
131 if (llvm::sys::path::is_absolute(File)) {
132 llvm::sys::path::native(File, PathStorage);
133 return PathStorage.str();
134 }
135 StringRef RelativePath(File);
136 // FIXME: Should '.\\' be accepted on Win32?
137 if (RelativePath.startswith("./")) {
138 RelativePath = RelativePath.substr(strlen("./"));
139 }
140 SmallString<1024> AbsolutePath(BaseDirectory);
141 llvm::sys::path::append(AbsolutePath, RelativePath);
142 llvm::sys::path::native(Twine(AbsolutePath), PathStorage);
143 return PathStorage.str();
144 }
145
ToolInvocation(ArrayRef<std::string> CommandLine,FrontendAction * ToolAction,FileManager * Files)146 ToolInvocation::ToolInvocation(
147 ArrayRef<std::string> CommandLine, FrontendAction *ToolAction,
148 FileManager *Files)
149 : CommandLine(CommandLine.vec()), ToolAction(ToolAction), Files(Files) {
150 }
151
mapVirtualFile(StringRef FilePath,StringRef Content)152 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
153 SmallString<1024> PathStorage;
154 llvm::sys::path::native(FilePath, PathStorage);
155 MappedFileContents[PathStorage] = Content;
156 }
157
run()158 bool ToolInvocation::run() {
159 std::vector<const char*> Argv;
160 for (int I = 0, E = CommandLine.size(); I != E; ++I)
161 Argv.push_back(CommandLine[I].c_str());
162 const char *const BinaryName = Argv[0];
163 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
164 TextDiagnosticPrinter DiagnosticPrinter(
165 llvm::errs(), &*DiagOpts);
166 DiagnosticsEngine Diagnostics(
167 IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()),
168 &*DiagOpts, &DiagnosticPrinter, false);
169
170 const OwningPtr<clang::driver::Driver> Driver(
171 newDriver(&Diagnostics, BinaryName));
172 // Since the input might only be virtual, don't check whether it exists.
173 Driver->setCheckInputsExist(false);
174 const OwningPtr<clang::driver::Compilation> Compilation(
175 Driver->BuildCompilation(llvm::makeArrayRef(Argv)));
176 const clang::driver::ArgStringList *const CC1Args = getCC1Arguments(
177 &Diagnostics, Compilation.get());
178 if (CC1Args == NULL) {
179 return false;
180 }
181 OwningPtr<clang::CompilerInvocation> Invocation(
182 newInvocation(&Diagnostics, *CC1Args));
183 return runInvocation(BinaryName, Compilation.get(), Invocation.take());
184 }
185
runInvocation(const char * BinaryName,clang::driver::Compilation * Compilation,clang::CompilerInvocation * Invocation)186 bool ToolInvocation::runInvocation(
187 const char *BinaryName,
188 clang::driver::Compilation *Compilation,
189 clang::CompilerInvocation *Invocation) {
190 // Show the invocation, with -v.
191 if (Invocation->getHeaderSearchOpts().Verbose) {
192 llvm::errs() << "clang Invocation:\n";
193 Compilation->PrintJob(llvm::errs(), Compilation->getJobs(), "\n", true);
194 llvm::errs() << "\n";
195 }
196
197 // Create a compiler instance to handle the actual work.
198 clang::CompilerInstance Compiler;
199 Compiler.setInvocation(Invocation);
200 Compiler.setFileManager(Files);
201 // FIXME: What about LangOpts?
202
203 // ToolAction can have lifetime requirements for Compiler or its members, and
204 // we need to ensure it's deleted earlier than Compiler. So we pass it to an
205 // OwningPtr declared after the Compiler variable.
206 OwningPtr<FrontendAction> ScopedToolAction(ToolAction.take());
207
208 // Create the compilers actual diagnostics engine.
209 Compiler.createDiagnostics();
210 if (!Compiler.hasDiagnostics())
211 return false;
212
213 Compiler.createSourceManager(*Files);
214 addFileMappingsTo(Compiler.getSourceManager());
215
216 const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
217
218 Compiler.resetAndLeakFileManager();
219 Files->clearStatCaches();
220 return Success;
221 }
222
addFileMappingsTo(SourceManager & Sources)223 void ToolInvocation::addFileMappingsTo(SourceManager &Sources) {
224 for (llvm::StringMap<StringRef>::const_iterator
225 It = MappedFileContents.begin(), End = MappedFileContents.end();
226 It != End; ++It) {
227 // Inject the code as the given file name into the preprocessor options.
228 const llvm::MemoryBuffer *Input =
229 llvm::MemoryBuffer::getMemBuffer(It->getValue());
230 // FIXME: figure out what '0' stands for.
231 const FileEntry *FromFile = Files->getVirtualFile(
232 It->getKey(), Input->getBufferSize(), 0);
233 Sources.overrideFileContents(FromFile, Input);
234 }
235 }
236
ClangTool(const CompilationDatabase & Compilations,ArrayRef<std::string> SourcePaths)237 ClangTool::ClangTool(const CompilationDatabase &Compilations,
238 ArrayRef<std::string> SourcePaths)
239 : Files((FileSystemOptions())),
240 ArgsAdjuster(new ClangSyntaxOnlyAdjuster()) {
241 for (unsigned I = 0, E = SourcePaths.size(); I != E; ++I) {
242 SmallString<1024> File(getAbsolutePath(SourcePaths[I]));
243
244 std::vector<CompileCommand> CompileCommandsForFile =
245 Compilations.getCompileCommands(File.str());
246 if (!CompileCommandsForFile.empty()) {
247 for (int I = 0, E = CompileCommandsForFile.size(); I != E; ++I) {
248 CompileCommands.push_back(std::make_pair(File.str(),
249 CompileCommandsForFile[I]));
250 }
251 } else {
252 // FIXME: There are two use cases here: doing a fuzzy
253 // "find . -name '*.cc' |xargs tool" match, where as a user I don't care
254 // about the .cc files that were not found, and the use case where I
255 // specify all files I want to run over explicitly, where this should
256 // be an error. We'll want to add an option for this.
257 llvm::outs() << "Skipping " << File << ". Command line not found.\n";
258 }
259 }
260 }
261
mapVirtualFile(StringRef FilePath,StringRef Content)262 void ClangTool::mapVirtualFile(StringRef FilePath, StringRef Content) {
263 MappedFileContents.push_back(std::make_pair(FilePath, Content));
264 }
265
setArgumentsAdjuster(ArgumentsAdjuster * Adjuster)266 void ClangTool::setArgumentsAdjuster(ArgumentsAdjuster *Adjuster) {
267 ArgsAdjuster.reset(Adjuster);
268 }
269
run(FrontendActionFactory * ActionFactory)270 int ClangTool::run(FrontendActionFactory *ActionFactory) {
271 // Exists solely for the purpose of lookup of the resource path.
272 // This just needs to be some symbol in the binary.
273 static int StaticSymbol;
274 // The driver detects the builtin header path based on the path of the
275 // executable.
276 // FIXME: On linux, GetMainExecutable is independent of the value of the
277 // first argument, thus allowing ClangTool and runToolOnCode to just
278 // pass in made-up names here. Make sure this works on other platforms.
279 std::string MainExecutable =
280 llvm::sys::Path::GetMainExecutable("clang_tool", &StaticSymbol).str();
281
282 bool ProcessingFailed = false;
283 for (unsigned I = 0; I < CompileCommands.size(); ++I) {
284 std::string File = CompileCommands[I].first;
285 // FIXME: chdir is thread hostile; on the other hand, creating the same
286 // behavior as chdir is complex: chdir resolves the path once, thus
287 // guaranteeing that all subsequent relative path operations work
288 // on the same path the original chdir resulted in. This makes a difference
289 // for example on network filesystems, where symlinks might be switched
290 // during runtime of the tool. Fixing this depends on having a file system
291 // abstraction that allows openat() style interactions.
292 if (chdir(CompileCommands[I].second.Directory.c_str()))
293 llvm::report_fatal_error("Cannot chdir into \"" +
294 CompileCommands[I].second.Directory + "\n!");
295 std::vector<std::string> CommandLine =
296 ArgsAdjuster->Adjust(CompileCommands[I].second.CommandLine);
297 assert(!CommandLine.empty());
298 CommandLine[0] = MainExecutable;
299 // FIXME: We need a callback mechanism for the tool writer to output a
300 // customized message for each file.
301 DEBUG({
302 llvm::dbgs() << "Processing: " << File << ".\n";
303 });
304 ToolInvocation Invocation(CommandLine, ActionFactory->create(), &Files);
305 for (int I = 0, E = MappedFileContents.size(); I != E; ++I) {
306 Invocation.mapVirtualFile(MappedFileContents[I].first,
307 MappedFileContents[I].second);
308 }
309 if (!Invocation.run()) {
310 // FIXME: Diagnostics should be used instead.
311 llvm::errs() << "Error while processing " << File << ".\n";
312 ProcessingFailed = true;
313 }
314 }
315 return ProcessingFailed ? 1 : 0;
316 }
317
318 } // end namespace tooling
319 } // end namespace clang
320