tools/clang-check/ClangCheck.cpp

   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 }