contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/CheckerRegistry.cpp

   1 //===--- CheckerRegistry.cpp - Maintains all available checkers -*- C++ -*-===//
   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 #include "clang/StaticAnalyzer/Core/CheckerRegistry.h"
  11 #include "clang/Basic/Diagnostic.h"
  12 #include "clang/Frontend/FrontendDiagnostic.h"
  13 #include "clang/StaticAnalyzer/Core/CheckerOptInfo.h"
  14 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  15 #include "llvm/ADT/SetVector.h"
  16 #include "llvm/Support/raw_ostream.h"
  17
  18 using namespace clang;
  19 using namespace ento;
  20
  21 static const char PackageSeparator = '.';
  22 typedef llvm::SetVector<const CheckerRegistry::CheckerInfo *> CheckerInfoSet;
  23
  24
  25 static bool checkerNameLT(const CheckerRegistry::CheckerInfo &a,
  26                           const CheckerRegistry::CheckerInfo &b) {
  27   return a.FullName < b.FullName;
  28 }
  29
  30 static bool isInPackage(const CheckerRegistry::CheckerInfo &checker,
  31                         StringRef packageName) {
  32   // Does the checker's full name have the package as a prefix?
  33   if (!checker.FullName.startswith(packageName))
  34     return false;
  35
  36   // Is the package actually just the name of a specific checker?
  37   if (checker.FullName.size() == packageName.size())
  38     return true;
  39
  40   // Is the checker in the package (or a subpackage)?
  41   if (checker.FullName[packageName.size()] == PackageSeparator)
  42     return true;
  43
  44   return false;
  45 }
  46
  47 static void collectCheckers(const CheckerRegistry::CheckerInfoList &checkers,
  48                             const llvm::StringMap<size_t> &packageSizes,
  49                             CheckerOptInfo &opt, CheckerInfoSet &collected) {
  50   // Use a binary search to find the possible start of the package.
  51   CheckerRegistry::CheckerInfo packageInfo(nullptr, opt.getName(), "");
  52   CheckerRegistry::CheckerInfoList::const_iterator e = checkers.end();
  53   CheckerRegistry::CheckerInfoList::const_iterator i =
  54     std::lower_bound(checkers.begin(), e, packageInfo, checkerNameLT);
  55
  56   // If we didn't even find a possible package, give up.
  57   if (i == e)
  58     return;
  59
  60   // If what we found doesn't actually start the package, give up.
  61   if (!isInPackage(*i, opt.getName()))
  62     return;
  63
  64   // There is at least one checker in the package; claim the option.
  65   opt.claim();
  66
  67   // See how large the package is.
  68   // If the package doesn't exist, assume the option refers to a single checker.
  69   size_t size = 1;
  70   llvm::StringMap<size_t>::const_iterator packageSize =
  71     packageSizes.find(opt.getName());
  72   if (packageSize != packageSizes.end())
  73     size = packageSize->getValue();
  74
  75   // Step through all the checkers in the package.
  76   for (e = i+size; i != e; ++i) {
  77     if (opt.isEnabled())
  78       collected.insert(&*i);
  79     else
  80       collected.remove(&*i);
  81   }
  82 }
  83
  84 void CheckerRegistry::addChecker(InitializationFunction fn, StringRef name,
  85                                  StringRef desc) {
  86   Checkers.push_back(CheckerInfo(fn, name, desc));
  87
  88   // Record the presence of the checker in its packages.
  89   StringRef packageName, leafName;
  90   std::tie(packageName, leafName) = name.rsplit(PackageSeparator);
  91   while (!leafName.empty()) {
  92     Packages[packageName] += 1;
  93     std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
  94   }
  95 }
  96
  97 void CheckerRegistry::initializeManager(CheckerManager &checkerMgr,
  98                                   SmallVectorImpl<CheckerOptInfo> &opts) const {
  99   // Sort checkers for efficient collection.
 100   std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 101
 102   // Collect checkers enabled by the options.
 103   CheckerInfoSet enabledCheckers;
 104   for (SmallVectorImpl<CheckerOptInfo>::iterator
 105          i = opts.begin(), e = opts.end(); i != e; ++i) {
 106     collectCheckers(Checkers, Packages, *i, enabledCheckers);
 107   }
 108
 109   // Initialize the CheckerManager with all enabled checkers.
 110   for (CheckerInfoSet::iterator
 111          i = enabledCheckers.begin(), e = enabledCheckers.end(); i != e; ++i) {
 112     checkerMgr.setCurrentCheckName(CheckName((*i)->FullName));
 113     (*i)->Initialize(checkerMgr);
 114   }
 115 }
 116
 117 void CheckerRegistry::validateCheckerOptions(const AnalyzerOptions &opts,
 118                                              DiagnosticsEngine &diags) const {
 119   for (auto &config : opts.Config) {
 120     size_t pos = config.getKey().find(':');
 121     if (pos == StringRef::npos)
 122       continue;
 123
 124     bool hasChecker = false;
 125     StringRef checkerName = config.getKey().substr(0, pos);
 126     for (auto &checker : Checkers) {
 127       if (checker.FullName.startswith(checkerName) &&
 128           (checker.FullName.size() == pos || checker.FullName[pos] == '.')) {
 129         hasChecker = true;
 130         break;
 131       }
 132     }
 133     if (!hasChecker) {
 134       diags.Report(diag::err_unknown_analyzer_checker) << checkerName;
 135     }
 136   }
 137 }
 138
 139 void CheckerRegistry::printHelp(raw_ostream &out,
 140                                 size_t maxNameChars) const {
 141   // FIXME: Alphabetical sort puts 'experimental' in the middle.
 142   // Would it be better to name it '~experimental' or something else
 143   // that's ASCIIbetically last?
 144   std::sort(Checkers.begin(), Checkers.end(), checkerNameLT);
 145
 146   // FIXME: Print available packages.
 147
 148   out << "CHECKERS:\n";
 149
 150   // Find the maximum option length.
 151   size_t optionFieldWidth = 0;
 152   for (CheckerInfoList::const_iterator i = Checkers.begin(), e = Checkers.end();
 153        i != e; ++i) {
 154     // Limit the amount of padding we are willing to give up for alignment.
 155     //   Package.Name     Description  [Hidden]
 156     size_t nameLength = i->FullName.size();
 157     if (nameLength <= maxNameChars)
 158       optionFieldWidth = std::max(optionFieldWidth, nameLength);
 159   }
 160
 161   const size_t initialPad = 2;
 162   for (CheckerInfoList::const_iterator i = Checkers.begin(), e = Checkers.end();
 163        i != e; ++i) {
 164     out.indent(initialPad) << i->FullName;
 165
 166     int pad = optionFieldWidth - i->FullName.size();
 167
 168     // Break on long option names.
 169     if (pad < 0) {
 170       out << '\n';
 171       pad = optionFieldWidth + initialPad;
 172     }
 173     out.indent(pad + 2) << i->Desc;
 174
 175     out << '\n';
 176   }
 177 }