contrib/llvm/tools/clang/lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

   1 //===--- CheckerRegistration.cpp - Registration for the Analyzer Checkers -===//
   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 // Defines the registration function for the analyzer checkers.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
  15 #include "clang/Basic/Diagnostic.h"
  16 #include "clang/Frontend/FrontendDiagnostic.h"
  17 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  18 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  19 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
  20 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/Support/FormattedStream.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <memory>
  25
  26 using namespace clang;
  27 using namespace ento;
  28
  29 std::unique_ptr<CheckerManager> ento::createCheckerManager(
  30     ASTContext &context,
  31     AnalyzerOptions &opts,
  32     ArrayRef<std::string> plugins,
  33     ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
  34     DiagnosticsEngine &diags) {
  35   auto checkerMgr = llvm::make_unique<CheckerManager>(context, opts);
  36
  37   CheckerRegistry allCheckers(plugins, diags);
  38
  39   for (const auto &Fn : checkerRegistrationFns)
  40     Fn(allCheckers);
  41
  42   allCheckers.initializeManager(*checkerMgr, opts);
  43   allCheckers.validateCheckerOptions(opts);
  44   checkerMgr->finishedCheckerRegistration();
  45
  46   return checkerMgr;
  47 }
  48
  49 void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins,
  50                             DiagnosticsEngine &diags) {
  51   out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
  52   out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
  53
  54   CheckerRegistry(plugins, diags).printHelp(out);
  55 }
  56
  57 void ento::printEnabledCheckerList(raw_ostream &out,
  58                                    ArrayRef<std::string> plugins,
  59                                    const AnalyzerOptions &opts,
  60                                    DiagnosticsEngine &diags) {
  61   out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
  62
  63   CheckerRegistry(plugins, diags).printList(out, opts);
  64 }
  65
  66 void ento::printAnalyzerConfigList(raw_ostream &out) {
  67   out << "OVERVIEW: Clang Static Analyzer -analyzer-config Option List\n\n";
  68   out << "USAGE: clang -cc1 [CLANG_OPTIONS] -analyzer-config "
  69                                         "<OPTION1=VALUE,OPTION2=VALUE,...>\n\n";
  70   out << "       clang -cc1 [CLANG_OPTIONS] -analyzer-config OPTION1=VALUE, "
  71                                       "-analyzer-config OPTION2=VALUE, ...\n\n";
  72   out << "       clang [CLANG_OPTIONS] -Xclang -analyzer-config -Xclang"
  73                                         "<OPTION1=VALUE,OPTION2=VALUE,...>\n\n";
  74   out << "       clang [CLANG_OPTIONS] -Xclang -analyzer-config -Xclang "
  75                               "OPTION1=VALUE, -Xclang -analyzer-config -Xclang "
  76                               "OPTION2=VALUE, ...\n\n";
  77   out << "OPTIONS:\n\n";
  78
  79   using OptionAndDescriptionTy = std::pair<StringRef, std::string>;
  80   OptionAndDescriptionTy PrintableOptions[] = {
  81 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
  82     {                                                                          \
  83       CMDFLAG,                                                                 \
  84       llvm::Twine(llvm::Twine() + "(" +                                        \
  85                   (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
  86                   ") " DESC                                                    \
  87                   " (default: " #DEFAULT_VAL ")").str()                        \
  88     },
  89
  90 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
  91                                              SHALLOW_VAL, DEEP_VAL)            \
  92     {                                                                          \
  93       CMDFLAG,                                                                 \
  94       llvm::Twine(llvm::Twine() + "(" +                                        \
  95                   (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
  96                   ") " DESC                                                    \
  97                   " (default: " #SHALLOW_VAL " in shallow mode, " #DEEP_VAL    \
  98                   " in deep mode)").str()                                      \
  99     },
 100 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
 101 #undef ANALYZER_OPTION
 102 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 103   };
 104
 105   llvm::sort(PrintableOptions, [](const OptionAndDescriptionTy &LHS,
 106                                   const OptionAndDescriptionTy &RHS) {
 107     return LHS.first < RHS.first;
 108   });
 109
 110   constexpr size_t MinLineWidth = 70;
 111   constexpr size_t PadForOpt = 2;
 112   constexpr size_t OptionWidth = 30;
 113   constexpr size_t PadForDesc = PadForOpt + OptionWidth;
 114   static_assert(MinLineWidth > PadForDesc, "MinLineWidth must be greater!");
 115
 116   llvm::formatted_raw_ostream FOut(out);
 117
 118   for (const auto &Pair : PrintableOptions) {
 119     FOut.PadToColumn(PadForOpt) << Pair.first;
 120
 121     // If the buffer's length is greater then PadForDesc, print a newline.
 122     if (FOut.getColumn() > PadForDesc)
 123       FOut << '\n';
 124
 125     FOut.PadToColumn(PadForDesc);
 126
 127     for (char C : Pair.second) {
 128       if (FOut.getColumn() > MinLineWidth && C == ' ') {
 129         FOut << '\n';
 130         FOut.PadToColumn(PadForDesc);
 131         continue;
 132       }
 133       FOut << C;
 134     }
 135     FOut << "\n\n";
 136   }
 137 }