1//===--- tools/clang-check/ClangCheck.cpp - Clang check tool --------------===//
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 a clang-check tool that runs clang based on the info
11//  stored in a compilation database.
12//
13//  This tool uses the Clang Tooling infrastructure, see
14//    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
15//  for details on setting it up with LLVM source tree.
16//
17//===----------------------------------------------------------------------===//
18
19#include "clang/AST/ASTConsumer.h"
20#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
21#include "clang/Driver/Options.h"
22#include "clang/Frontend/ASTConsumers.h"
23#include "clang/Frontend/CompilerInstance.h"
24#include "clang/Rewrite/Frontend/FixItRewriter.h"
25#include "clang/Rewrite/Frontend/FrontendActions.h"
26#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
27#include "clang/Tooling/CommonOptionsParser.h"
28#include "clang/Tooling/Tooling.h"
29#include "llvm/ADT/STLExtras.h"
30#include "llvm/Option/OptTable.h"
31#include "llvm/Support/Path.h"
32#include "llvm/Support/Signals.h"
33#include "llvm/Support/TargetSelect.h"
34
35using namespace clang::driver;
36using namespace clang::tooling;
37using namespace llvm;
38
39static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
40static cl::extrahelp MoreHelp(
41    "\tFor example, to run clang-check on all files in a subtree of the\n"
42    "\tsource tree, use:\n"
43    "\n"
44    "\t  find path/in/subtree -name '*.cpp'|xargs clang-check\n"
45    "\n"
46    "\tor using a specific build path:\n"
47    "\n"
48    "\t  find path/in/subtree -name '*.cpp'|xargs clang-check -p build/path\n"
49    "\n"
50    "\tNote, that path/in/subtree and current directory should follow the\n"
51    "\trules described above.\n"
52    "\n"
53);
54
55static cl::OptionCategory ClangCheckCategory("clang-check options");
56static std::unique_ptr<opt::OptTable> Options(createDriverOptTable());
57static cl::opt<bool>
58ASTDump("ast-dump", cl::desc(Options->getOptionHelpText(options::OPT_ast_dump)),
59        cl::cat(ClangCheckCategory));
60static cl::opt<bool>
61ASTList("ast-list", cl::desc(Options->getOptionHelpText(options::OPT_ast_list)),
62        cl::cat(ClangCheckCategory));
63static cl::opt<bool>
64ASTPrint("ast-print",
65         cl::desc(Options->getOptionHelpText(options::OPT_ast_print)),
66         cl::cat(ClangCheckCategory));
67static cl::opt<std::string> ASTDumpFilter(
68    "ast-dump-filter",
69    cl::desc(Options->getOptionHelpText(options::OPT_ast_dump_filter)),
70    cl::cat(ClangCheckCategory));
71static cl::opt<bool>
72Analyze("analyze", cl::desc(Options->getOptionHelpText(options::OPT_analyze)),
73        cl::cat(ClangCheckCategory));
74
75static cl::opt<bool>
76Fixit("fixit", cl::desc(Options->getOptionHelpText(options::OPT_fixit)),
77      cl::cat(ClangCheckCategory));
78static cl::opt<bool> FixWhatYouCan(
79    "fix-what-you-can",
80    cl::desc(Options->getOptionHelpText(options::OPT_fix_what_you_can)),
81    cl::cat(ClangCheckCategory));
82
83namespace {
84
85// FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp
86// into a header file and reuse that.
87class FixItOptions : public clang::FixItOptions {
88public:
89  FixItOptions() {
90    FixWhatYouCan = ::FixWhatYouCan;
91  }
92
93  std::string RewriteFilename(const std::string& filename, int &fd) override {
94    assert(llvm::sys::path::is_absolute(filename) &&
95           "clang-fixit expects absolute paths only.");
96
97    // We don't need to do permission checking here since clang will diagnose
98    // any I/O errors itself.
99
100    fd = -1;  // No file descriptor for file.
101
102    return filename;
103  }
104};
105
106/// \brief Subclasses \c clang::FixItRewriter to not count fixed errors/warnings
107/// in the final error counts.
108///
109/// This has the side-effect that clang-check -fixit exits with code 0 on
110/// successfully fixing all errors.
111class FixItRewriter : public clang::FixItRewriter {
112public:
113  FixItRewriter(clang::DiagnosticsEngine& Diags,
114                clang::SourceManager& SourceMgr,
115                const clang::LangOptions& LangOpts,
116                clang::FixItOptions* FixItOpts)
117      : clang::FixItRewriter(Diags, SourceMgr, LangOpts, FixItOpts) {
118  }
119
120  bool IncludeInDiagnosticCounts() const override { return false; }
121};
122
123/// \brief Subclasses \c clang::FixItAction so that we can install the custom
124/// \c FixItRewriter.
125class FixItAction : public clang::FixItAction {
126public:
127  bool BeginSourceFileAction(clang::CompilerInstance& CI,
128                             StringRef Filename) override {
129    FixItOpts.reset(new FixItOptions);
130    Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
131                                     CI.getLangOpts(), FixItOpts.get()));
132    return true;
133  }
134};
135
136class ClangCheckActionFactory {
137public:
138  std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
139    if (ASTList)
140      return clang::CreateASTDeclNodeLister();
141    if (ASTDump)
142      return clang::CreateASTDumper(ASTDumpFilter, /*DumpDecls=*/true,
143                                    /*DumpLookups=*/false);
144    if (ASTPrint)
145      return clang::CreateASTPrinter(&llvm::outs(), ASTDumpFilter);
146    return llvm::make_unique<clang::ASTConsumer>();
147  }
148};
149
150} // namespace
151
152int main(int argc, const char **argv) {
153  llvm::sys::PrintStackTraceOnErrorSignal();
154
155  // Initialize targets for clang module support.
156  llvm::InitializeAllTargets();
157  llvm::InitializeAllTargetMCs();
158  llvm::InitializeAllAsmPrinters();
159  llvm::InitializeAllAsmParsers();
160
161  CommonOptionsParser OptionsParser(argc, argv, ClangCheckCategory);
162  ClangTool Tool(OptionsParser.getCompilations(),
163                 OptionsParser.getSourcePathList());
164
165  // Clear adjusters because -fsyntax-only is inserted by the default chain.
166  Tool.clearArgumentsAdjusters();
167  Tool.appendArgumentsAdjuster(getClangStripOutputAdjuster());
168
169  // Running the analyzer requires --analyze. Other modes can work with the
170  // -fsyntax-only option.
171  Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
172      Analyze ? "--analyze" : "-fsyntax-only", ArgumentInsertPosition::BEGIN));
173
174  ClangCheckActionFactory CheckFactory;
175  std::unique_ptr<FrontendActionFactory> FrontendFactory;
176
177  // Choose the correct factory based on the selected mode.
178  if (Analyze)
179    FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>();
180  else if (Fixit)
181    FrontendFactory = newFrontendActionFactory<FixItAction>();
182  else
183    FrontendFactory = newFrontendActionFactory(&CheckFactory);
184
185  return Tool.run(FrontendFactory.get());
186}
187