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/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/Tooling.h" 28 #include "llvm/Option/OptTable.h" 29 #include "llvm/Support/Path.h" 30 #include "llvm/Support/Signals.h" 31 32 using namespace clang::driver; 33 using namespace clang::tooling; 34 using namespace llvm; 35 36 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage); 37 static cl::extrahelp MoreHelp( 38 "\tFor example, to run clang-check on all files in a subtree of the\n" 39 "\tsource tree, use:\n" 40 "\n" 41 "\t find path/in/subtree -name '*.cpp'|xargs clang-check\n" 42 "\n" 43 "\tor using a specific build path:\n" 44 "\n" 45 "\t find path/in/subtree -name '*.cpp'|xargs clang-check -p build/path\n" 46 "\n" 47 "\tNote, that path/in/subtree and current directory should follow the\n" 48 "\trules described above.\n" 49 "\n" 50 ); 51 52 static cl::OptionCategory ClangCheckCategory("clang-check options"); 53 static std::unique_ptr<opt::OptTable> Options(createDriverOptTable()); 54 static cl::opt<bool> 55 ASTDump("ast-dump", cl::desc(Options->getOptionHelpText(options::OPT_ast_dump)), 56 cl::cat(ClangCheckCategory)); 57 static cl::opt<bool> 58 ASTList("ast-list", cl::desc(Options->getOptionHelpText(options::OPT_ast_list)), 59 cl::cat(ClangCheckCategory)); 60 static cl::opt<bool> 61 ASTPrint("ast-print", 62 cl::desc(Options->getOptionHelpText(options::OPT_ast_print)), 63 cl::cat(ClangCheckCategory)); 64 static cl::opt<std::string> ASTDumpFilter( 65 "ast-dump-filter", 66 cl::desc(Options->getOptionHelpText(options::OPT_ast_dump_filter)), 67 cl::cat(ClangCheckCategory)); 68 static cl::opt<bool> 69 Analyze("analyze", cl::desc(Options->getOptionHelpText(options::OPT_analyze)), 70 cl::cat(ClangCheckCategory)); 71 72 static cl::opt<bool> 73 Fixit("fixit", cl::desc(Options->getOptionHelpText(options::OPT_fixit)), 74 cl::cat(ClangCheckCategory)); 75 static cl::opt<bool> FixWhatYouCan( 76 "fix-what-you-can", 77 cl::desc(Options->getOptionHelpText(options::OPT_fix_what_you_can)), 78 cl::cat(ClangCheckCategory)); 79 80 static cl::list<std::string> ArgsAfter( 81 "extra-arg", 82 cl::desc("Additional argument to append to the compiler command line"), 83 cl::cat(ClangCheckCategory)); 84 static cl::list<std::string> ArgsBefore( 85 "extra-arg-before", 86 cl::desc("Additional argument to prepend to the compiler command line"), 87 cl::cat(ClangCheckCategory)); 88 89 namespace { 90 91 // FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp 92 // into a header file and reuse that. 93 class FixItOptions : public clang::FixItOptions { 94 public: 95 FixItOptions() { 96 FixWhatYouCan = ::FixWhatYouCan; 97 } 98 99 std::string RewriteFilename(const std::string& filename, int &fd) override { 100 assert(llvm::sys::path::is_absolute(filename) && 101 "clang-fixit expects absolute paths only."); 102 103 // We don't need to do permission checking here since clang will diagnose 104 // any I/O errors itself. 105 106 fd = -1; // No file descriptor for file. 107 108 return filename; 109 } 110 }; 111 112 /// \brief Subclasses \c clang::FixItRewriter to not count fixed errors/warnings 113 /// in the final error counts. 114 /// 115 /// This has the side-effect that clang-check -fixit exits with code 0 on 116 /// successfully fixing all errors. 117 class FixItRewriter : public clang::FixItRewriter { 118 public: 119 FixItRewriter(clang::DiagnosticsEngine& Diags, 120 clang::SourceManager& SourceMgr, 121 const clang::LangOptions& LangOpts, 122 clang::FixItOptions* FixItOpts) 123 : clang::FixItRewriter(Diags, SourceMgr, LangOpts, FixItOpts) { 124 } 125 126 bool IncludeInDiagnosticCounts() const override { return false; } 127 }; 128 129 /// \brief Subclasses \c clang::FixItAction so that we can install the custom 130 /// \c FixItRewriter. 131 class FixItAction : public clang::FixItAction { 132 public: 133 bool BeginSourceFileAction(clang::CompilerInstance& CI, 134 StringRef Filename) override { 135 FixItOpts.reset(new FixItOptions); 136 Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(), 137 CI.getLangOpts(), FixItOpts.get())); 138 return true; 139 } 140 }; 141 142 class InsertAdjuster: public clang::tooling::ArgumentsAdjuster { 143 public: 144 enum Position { BEGIN, END }; 145 146 InsertAdjuster(const CommandLineArguments &Extra, Position Pos) 147 : Extra(Extra), Pos(Pos) { 148 } 149 150 InsertAdjuster(const char *Extra, Position Pos) 151 : Extra(1, std::string(Extra)), Pos(Pos) { 152 } 153 154 virtual CommandLineArguments 155 Adjust(const CommandLineArguments &Args) override { 156 CommandLineArguments Return(Args); 157 158 CommandLineArguments::iterator I; 159 if (Pos == END) { 160 I = Return.end(); 161 } else { 162 I = Return.begin(); 163 ++I; // To leave the program name in place 164 } 165 166 Return.insert(I, Extra.begin(), Extra.end()); 167 return Return; 168 } 169 170 private: 171 const CommandLineArguments Extra; 172 const Position Pos; 173 }; 174 175 } // namespace 176 177 // Anonymous namespace here causes problems with gcc <= 4.4 on MacOS 10.6. 178 // "Non-global symbol: ... can't be a weak_definition" 179 namespace clang_check { 180 class ClangCheckActionFactory { 181 public: 182 clang::ASTConsumer *newASTConsumer() { 183 if (ASTList) 184 return clang::CreateASTDeclNodeLister(); 185 if (ASTDump) 186 return clang::CreateASTDumper(ASTDumpFilter); 187 if (ASTPrint) 188 return clang::CreateASTPrinter(&llvm::outs(), ASTDumpFilter); 189 return new clang::ASTConsumer(); 190 } 191 }; 192 } 193 194 int main(int argc, const char **argv) { 195 llvm::sys::PrintStackTraceOnErrorSignal(); 196 CommonOptionsParser OptionsParser(argc, argv, ClangCheckCategory); 197 ClangTool Tool(OptionsParser.getCompilations(), 198 OptionsParser.getSourcePathList()); 199 200 // Clear adjusters because -fsyntax-only is inserted by the default chain. 201 Tool.clearArgumentsAdjusters(); 202 Tool.appendArgumentsAdjuster(new ClangStripOutputAdjuster()); 203 if (ArgsAfter.size() > 0) { 204 Tool.appendArgumentsAdjuster(new InsertAdjuster(ArgsAfter, 205 InsertAdjuster::END)); 206 } 207 if (ArgsBefore.size() > 0) { 208 Tool.appendArgumentsAdjuster(new InsertAdjuster(ArgsBefore, 209 InsertAdjuster::BEGIN)); 210 } 211 212 // Running the analyzer requires --analyze. Other modes can work with the 213 // -fsyntax-only option. 214 Tool.appendArgumentsAdjuster(new InsertAdjuster( 215 Analyze ? "--analyze" : "-fsyntax-only", InsertAdjuster::BEGIN)); 216 217 clang_check::ClangCheckActionFactory CheckFactory; 218 std::unique_ptr<FrontendActionFactory> FrontendFactory; 219 220 // Choose the correct factory based on the selected mode. 221 if (Analyze) 222 FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>(); 223 else if (Fixit) 224 FrontendFactory = newFrontendActionFactory<FixItAction>(); 225 else 226 FrontendFactory = newFrontendActionFactory(&CheckFactory); 227 228 return Tool.run(FrontendFactory.get()); 229 } 230
