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 38 using namespace clang::driver; 39 using namespace clang::tooling; 40 using namespace llvm; 41 42 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage); 43 static 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 58 static cl::OptionCategory ClangCheckCategory("clang-check options"); 59 static const opt::OptTable &Options = getDriverOptTable(); 60 static cl::opt<bool> 61 ASTDump("ast-dump", 62 cl::desc(Options.getOptionHelpText(options::OPT_ast_dump)), 63 cl::cat(ClangCheckCategory)); 64 static cl::opt<bool> 65 ASTList("ast-list", 66 cl::desc(Options.getOptionHelpText(options::OPT_ast_list)), 67 cl::cat(ClangCheckCategory)); 68 static cl::opt<bool> 69 ASTPrint("ast-print", 70 cl::desc(Options.getOptionHelpText(options::OPT_ast_print)), 71 cl::cat(ClangCheckCategory)); 72 static cl::opt<std::string> ASTDumpFilter( 73 "ast-dump-filter", 74 cl::desc(Options.getOptionHelpText(options::OPT_ast_dump_filter)), 75 cl::cat(ClangCheckCategory)); 76 static cl::opt<bool> 77 Analyze("analyze", 78 cl::desc(Options.getOptionHelpText(options::OPT_analyze)), 79 cl::cat(ClangCheckCategory)); 80 static cl::opt<std::string> 81 AnalyzerOutput("analyzer-output-path", 82 cl::desc(Options.getOptionHelpText(options::OPT_o)), 83 cl::cat(ClangCheckCategory)); 84 85 static cl::opt<bool> 86 Fixit("fixit", cl::desc(Options.getOptionHelpText(options::OPT_fixit)), 87 cl::cat(ClangCheckCategory)); 88 static cl::opt<bool> FixWhatYouCan( 89 "fix-what-you-can", 90 cl::desc(Options.getOptionHelpText(options::OPT_fix_what_you_can)), 91 cl::cat(ClangCheckCategory)); 92 93 static cl::opt<bool> SyntaxTreeDump("syntax-tree-dump", 94 cl::desc("dump the syntax tree"), 95 cl::cat(ClangCheckCategory)); 96 static cl::opt<bool> TokensDump("tokens-dump", 97 cl::desc("dump the preprocessed tokens"), 98 cl::cat(ClangCheckCategory)); 99 100 namespace { 101 102 // FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp 103 // into a header file and reuse that. 104 class FixItOptions : public clang::FixItOptions { 105 public: 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. 125 class FixItRewriter : public clang::FixItRewriter { 126 public: 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. 139 class ClangCheckFixItAction : public clang::FixItAction { 140 public: 141 bool BeginSourceFileAction(clang::CompilerInstance& CI) override { 142 FixItOpts.reset(new FixItOptions); 143 Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(), 144 CI.getLangOpts(), FixItOpts.get())); 145 return true; 146 } 147 }; 148 149 class DumpSyntaxTree : public clang::ASTFrontendAction { 150 public: 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, AST)->dump(TBTM); 166 } 167 168 private: 169 clang::syntax::TokenCollector Collector; 170 }; 171 return std::make_unique<Consumer>(CI); 172 } 173 }; 174 175 class ClangCheckActionFactory { 176 public: 177 std::unique_ptr<clang::ASTConsumer> newASTConsumer() { 178 if (ASTList) 179 return clang::CreateASTDeclNodeLister(); 180 if (ASTDump) 181 return clang::CreateASTDumper(nullptr /*Dump to stdout.*/, ASTDumpFilter, 182 /*DumpDecls=*/true, 183 /*Deserialize=*/false, 184 /*DumpLookups=*/false, 185 /*DumpDeclTypes=*/false, 186 clang::ADOF_Default); 187 if (ASTPrint) 188 return clang::CreateASTPrinter(nullptr, ASTDumpFilter); 189 return std::make_unique<clang::ASTConsumer>(); 190 } 191 }; 192 193 } // namespace 194 195 int main(int argc, const char **argv) { 196 llvm::sys::PrintStackTraceOnErrorSignal(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, 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 getInsertArgumentAdjuster(CommandLineArguments{"-o", AnalyzerOutput}, 223 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 [&](const CommandLineArguments &Args, StringRef /*unused*/) { 236 CommandLineArguments AdjustedArgs; 237 for (const std::string &Arg : Args) 238 if (Arg != "-fsyntax-only") 239 AdjustedArgs.emplace_back(Arg); 240 return AdjustedArgs; 241 }); 242 Tool.appendArgumentsAdjuster( 243 getInsertArgumentAdjuster("--analyze", 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(&CheckFactory); 258 259 return Tool.run(FrontendFactory.get()); 260 } 261