contrib/llvm-project/clang/lib/StaticAnalyzer/Frontend/CheckerRegistration.cpp

   1 //===--- CheckerRegistration.cpp - Registration for the Analyzer Checkers -===//
   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 // Defines the registration function for the analyzer checkers.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/StaticAnalyzer/Frontend/CheckerRegistration.h"
  14 #include "clang/Basic/Diagnostic.h"
  15 #include "clang/Frontend/FrontendDiagnostic.h"
  16 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  17 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  18 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
  19 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include <memory>
  23
  24 using namespace clang;
  25 using namespace ento;
  26
  27 std::unique_ptr<CheckerManager> ento::createCheckerManager(
  28     ASTContext &context,
  29     AnalyzerOptions &opts,
  30     ArrayRef<std::string> plugins,
  31     ArrayRef<std::function<void(CheckerRegistry &)>> checkerRegistrationFns,
  32     DiagnosticsEngine &diags) {
  33   auto checkerMgr = llvm::make_unique<CheckerManager>(context, opts);
  34
  35   CheckerRegistry allCheckers(plugins, diags, opts, context.getLangOpts(),
  36                               checkerRegistrationFns);
  37
  38   allCheckers.initializeManager(*checkerMgr);
  39   allCheckers.validateCheckerOptions();
  40   checkerMgr->finishedCheckerRegistration();
  41
  42   return checkerMgr;
  43 }
  44
  45 void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins,
  46                             AnalyzerOptions &anopts,
  47                             DiagnosticsEngine &diags,
  48                             const LangOptions &langOpts) {
  49   out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
  50   out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
  51
  52   CheckerRegistry(plugins, diags, anopts, langOpts)
  53       .printCheckerWithDescList(out);
  54 }
  55
  56 void ento::printEnabledCheckerList(raw_ostream &out,
  57                                    ArrayRef<std::string> plugins,
  58                                    AnalyzerOptions &anopts,
  59                                    DiagnosticsEngine &diags,
  60                                    const LangOptions &langOpts) {
  61   out << "OVERVIEW: Clang Static Analyzer Enabled Checkers List\n\n";
  62
  63   CheckerRegistry(plugins, diags, anopts, langOpts)
  64       .printEnabledCheckerList(out);
  65 }
  66
  67 void ento::printCheckerConfigList(raw_ostream &OS,
  68                                   ArrayRef<std::string> plugins,
  69                                   AnalyzerOptions &opts,
  70                                   DiagnosticsEngine &diags,
  71                                   const LangOptions &LangOpts) {
  72   CheckerRegistry(plugins, diags, opts, LangOpts)
  73       .printCheckerOptionList(OS);
  74 }
  75
  76 void ento::printAnalyzerConfigList(raw_ostream &out) {
  77   out << "OVERVIEW: Clang Static Analyzer -analyzer-config Option List\n\n";
  78   out << "USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>\n\n";
  79   out << "       -analyzer-config OPTION1=VALUE, -analyzer-config "
  80          "OPTION2=VALUE, ...\n\n";
  81   out << "OPTIONS:\n\n";
  82
  83   using OptionAndDescriptionTy = std::pair<StringRef, std::string>;
  84   OptionAndDescriptionTy PrintableOptions[] = {
  85 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
  86     {                                                                          \
  87       CMDFLAG,                                                                 \
  88       llvm::Twine(llvm::Twine() + "(" +                                        \
  89                   (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
  90                   ") " DESC                                                    \
  91                   " (default: " #DEFAULT_VAL ")").str()                        \
  92     },
  93
  94 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
  95                                              SHALLOW_VAL, DEEP_VAL)            \
  96     {                                                                          \
  97       CMDFLAG,                                                                 \
  98       llvm::Twine(llvm::Twine() + "(" +                                        \
  99                   (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) +      \
 100                   ") " DESC                                                    \
 101                   " (default: " #SHALLOW_VAL " in shallow mode, " #DEEP_VAL    \
 102                   " in deep mode)").str()                                      \
 103     },
 104 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
 105 #undef ANALYZER_OPTION
 106 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 107   };
 108
 109   llvm::sort(PrintableOptions, [](const OptionAndDescriptionTy &LHS,
 110                                   const OptionAndDescriptionTy &RHS) {
 111     return LHS.first < RHS.first;
 112   });
 113
 114   for (const auto &Pair : PrintableOptions) {
 115     AnalyzerOptions::printFormattedEntry(out, Pair, /*InitialPad*/ 2,
 116                                          /*EntryWidth*/ 30,
 117                                          /*MinLineWidth*/ 70);
 118     out << "\n\n";
 119   }
 120 }