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