1//===--- tools/clang-check/ClangCheck.cpp - Clang check tool --------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements a clang-check tool that runs clang based on the info
10// stored in a compilation database.
11//
12// This tool uses the Clang Tooling infrastructure, see
13// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
14// for details on setting it up with LLVM source tree.
15//
16//===----------------------------------------------------------------------===//
17
18#include "clang/AST/ASTConsumer.h"
19#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
20#include "clang/Driver/Options.h"
21#include "clang/Frontend/ASTConsumers.h"
22#include "clang/Frontend/CompilerInstance.h"
23#include "clang/Rewrite/Frontend/FixItRewriter.h"
24#include "clang/Rewrite/Frontend/FrontendActions.h"
25#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
26#include "clang/Tooling/CommonOptionsParser.h"
27#include "clang/Tooling/Syntax/BuildTree.h"
28#include "clang/Tooling/Syntax/TokenBufferTokenManager.h"
29#include "clang/Tooling/Syntax/Tokens.h"
30#include "clang/Tooling/Syntax/Tree.h"
31#include "clang/Tooling/Tooling.h"
32#include "llvm/ADT/STLExtras.h"
33#include "llvm/Option/OptTable.h"
34#include "llvm/Support/Path.h"
35#include "llvm/Support/Signals.h"
36#include "llvm/Support/TargetSelect.h"
37
38using namespace clang::driver;
39using namespace clang::tooling;
40using namespace llvm;
41
42static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
43static cl::extrahelp MoreHelp(
44 "\tFor example, to run clang-check on all files in a subtree of the\n"
45 "\tsource tree, use:\n"
46 "\n"
47 "\t find path/in/subtree -name '*.cpp'|xargs clang-check\n"
48 "\n"
49 "\tor using a specific build path:\n"
50 "\n"
51 "\t find path/in/subtree -name '*.cpp'|xargs clang-check -p build/path\n"
52 "\n"
53 "\tNote, that path/in/subtree and current directory should follow the\n"
54 "\trules described above.\n"
55 "\n"
56);
57
58static cl::OptionCategory ClangCheckCategory("clang-check options");
59static const opt::OptTable &Options = getDriverOptTable();
60static cl::opt<bool>
61 ASTDump("ast-dump",
62 cl::desc(Options.getOptionHelpText(id: options::OPT_ast_dump)),
63 cl::cat(ClangCheckCategory));
64static cl::opt<bool>
65 ASTList("ast-list",
66 cl::desc(Options.getOptionHelpText(id: options::OPT_ast_list)),
67 cl::cat(ClangCheckCategory));
68static cl::opt<bool>
69 ASTPrint("ast-print",
70 cl::desc(Options.getOptionHelpText(id: options::OPT_ast_print)),
71 cl::cat(ClangCheckCategory));
72static cl::opt<std::string> ASTDumpFilter(
73 "ast-dump-filter",
74 cl::desc(Options.getOptionHelpText(id: options::OPT_ast_dump_filter)),
75 cl::cat(ClangCheckCategory));
76static cl::opt<bool>
77 Analyze("analyze",
78 cl::desc(Options.getOptionHelpText(id: options::OPT_analyze)),
79 cl::cat(ClangCheckCategory));
80static cl::opt<std::string>
81 AnalyzerOutput("analyzer-output-path",
82 cl::desc(Options.getOptionHelpText(id: options::OPT_o)),
83 cl::cat(ClangCheckCategory));
84
85static cl::opt<bool>
86 Fixit("fixit", cl::desc(Options.getOptionHelpText(id: options::OPT_fixit)),
87 cl::cat(ClangCheckCategory));
88static cl::opt<bool> FixWhatYouCan(
89 "fix-what-you-can",
90 cl::desc(Options.getOptionHelpText(id: options::OPT_fix_what_you_can)),
91 cl::cat(ClangCheckCategory));
92
93static cl::opt<bool> SyntaxTreeDump("syntax-tree-dump",
94 cl::desc("dump the syntax tree"),
95 cl::cat(ClangCheckCategory));
96static cl::opt<bool> TokensDump("tokens-dump",
97 cl::desc("dump the preprocessed tokens"),
98 cl::cat(ClangCheckCategory));
99
100namespace {
101
102// FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp
103// into a header file and reuse that.
104class FixItOptions : public clang::FixItOptions {
105public:
106 FixItOptions() {
107 FixWhatYouCan = ::FixWhatYouCan;
108 }
109
110 std::string RewriteFilename(const std::string& filename, int &fd) override {
111 // We don't need to do permission checking here since clang will diagnose
112 // any I/O errors itself.
113
114 fd = -1; // No file descriptor for file.
115
116 return filename;
117 }
118};
119
120/// Subclasses \c clang::FixItRewriter to not count fixed errors/warnings
121/// in the final error counts.
122///
123/// This has the side-effect that clang-check -fixit exits with code 0 on
124/// successfully fixing all errors.
125class FixItRewriter : public clang::FixItRewriter {
126public:
127 FixItRewriter(clang::DiagnosticsEngine& Diags,
128 clang::SourceManager& SourceMgr,
129 const clang::LangOptions& LangOpts,
130 clang::FixItOptions* FixItOpts)
131 : clang::FixItRewriter(Diags, SourceMgr, LangOpts, FixItOpts) {
132 }
133
134 bool IncludeInDiagnosticCounts() const override { return false; }
135};
136
137/// Subclasses \c clang::FixItAction so that we can install the custom
138/// \c FixItRewriter.
139class ClangCheckFixItAction : public clang::FixItAction {
140public:
141 bool BeginSourceFileAction(clang::CompilerInstance& CI) override {
142 FixItOpts.reset(p: new FixItOptions);
143 Rewriter.reset(p: new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
144 CI.getLangOpts(), FixItOpts.get()));
145 return true;
146 }
147};
148
149class DumpSyntaxTree : public clang::ASTFrontendAction {
150public:
151 std::unique_ptr<clang::ASTConsumer>
152 CreateASTConsumer(clang::CompilerInstance &CI, StringRef InFile) override {
153 class Consumer : public clang::ASTConsumer {
154 public:
155 Consumer(clang::CompilerInstance &CI) : Collector(CI.getPreprocessor()) {}
156
157 void HandleTranslationUnit(clang::ASTContext &AST) override {
158 clang::syntax::TokenBuffer TB = std::move(Collector).consume();
159 if (TokensDump)
160 llvm::outs() << TB.dumpForTests();
161 clang::syntax::TokenBufferTokenManager TBTM(TB, AST.getLangOpts(),
162 AST.getSourceManager());
163 clang::syntax::Arena A;
164 llvm::outs()
165 << clang::syntax::buildSyntaxTree(A, TBTM, Context&: AST)->dump(SM: TBTM);
166 }
167
168 private:
169 clang::syntax::TokenCollector Collector;
170 };
171 return std::make_unique<Consumer>(args&: CI);
172 }
173};
174
175class ClangCheckActionFactory {
176public:
177 std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
178 if (ASTList)
179 return clang::CreateASTDeclNodeLister();
180 if (ASTDump)
181 return clang::CreateASTDumper(OS: nullptr /*Dump to stdout.*/, FilterString: ASTDumpFilter,
182 /*DumpDecls=*/true,
183 /*Deserialize=*/false,
184 /*DumpLookups=*/false,
185 /*DumpDeclTypes=*/false,
186 Format: clang::ADOF_Default);
187 if (ASTPrint)
188 return clang::CreateASTPrinter(OS: nullptr, FilterString: ASTDumpFilter);
189 return std::make_unique<clang::ASTConsumer>();
190 }
191};
192
193} // namespace
194
195int main(int argc, const char **argv) {
196 llvm::sys::PrintStackTraceOnErrorSignal(Argv0: argv[0]);
197
198 // Initialize targets for clang module support.
199 llvm::InitializeAllTargets();
200 llvm::InitializeAllTargetMCs();
201 llvm::InitializeAllAsmPrinters();
202 llvm::InitializeAllAsmParsers();
203
204 auto ExpectedParser =
205 CommonOptionsParser::create(argc, argv, Category&: ClangCheckCategory);
206 if (!ExpectedParser) {
207 llvm::errs() << ExpectedParser.takeError();
208 return 1;
209 }
210 CommonOptionsParser &OptionsParser = ExpectedParser.get();
211 ClangTool Tool(OptionsParser.getCompilations(),
212 OptionsParser.getSourcePathList());
213
214 if (Analyze) {
215 // Set output path if is provided by user.
216 //
217 // As the original -o options have been removed by default via the
218 // strip-output adjuster, we only need to add the analyzer -o options here
219 // when it is provided by users.
220 if (!AnalyzerOutput.empty())
221 Tool.appendArgumentsAdjuster(
222 Adjuster: getInsertArgumentAdjuster(Extra: CommandLineArguments{"-o", AnalyzerOutput},
223 Pos: ArgumentInsertPosition::END));
224
225 // Running the analyzer requires --analyze. Other modes can work with the
226 // -fsyntax-only option.
227 //
228 // The syntax-only adjuster is installed by default.
229 // Good: It also strips options that trigger extra output, like -save-temps.
230 // Bad: We don't want the -fsyntax-only when executing the static analyzer.
231 //
232 // To enable the static analyzer, we first strip all -fsyntax-only options
233 // and then add an --analyze option to the front.
234 Tool.appendArgumentsAdjuster(
235 Adjuster: [&](const CommandLineArguments &Args, StringRef /*unused*/) {
236 CommandLineArguments AdjustedArgs;
237 for (const std::string &Arg : Args)
238 if (Arg != "-fsyntax-only")
239 AdjustedArgs.emplace_back(args: Arg);
240 return AdjustedArgs;
241 });
242 Tool.appendArgumentsAdjuster(
243 Adjuster: getInsertArgumentAdjuster(Extra: "--analyze", Pos: ArgumentInsertPosition::BEGIN));
244 }
245
246 ClangCheckActionFactory CheckFactory;
247 std::unique_ptr<FrontendActionFactory> FrontendFactory;
248
249 // Choose the correct factory based on the selected mode.
250 if (Analyze)
251 FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>();
252 else if (Fixit)
253 FrontendFactory = newFrontendActionFactory<ClangCheckFixItAction>();
254 else if (SyntaxTreeDump || TokensDump)
255 FrontendFactory = newFrontendActionFactory<DumpSyntaxTree>();
256 else
257 FrontendFactory = newFrontendActionFactory(ConsumerFactory: &CheckFactory);
258
259 return Tool.run(Action: FrontendFactory.get());
260}
261