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