Home | History | Annotate | Download | only in Frontend 
      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/Checkers/ClangCheckers.h"
     18 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
     19 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
     20 #include "clang/StaticAnalyzer/Core/CheckerOptInfo.h"
     21 #include "clang/StaticAnalyzer/Core/CheckerRegistry.h"
     22 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
     23 #include "llvm/ADT/SmallVector.h"
     24 #include "llvm/Support/DynamicLibrary.h"
     25 #include "llvm/Support/Path.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 #include <memory>
     28 
     29 using namespace clang;
     30 using namespace ento;
     31 using llvm::sys::DynamicLibrary;
     32 
     33 namespace {
     34 class ClangCheckerRegistry : public CheckerRegistry {
     35   typedef void (*RegisterCheckersFn)(CheckerRegistry &);
     36 
     37   static bool isCompatibleAPIVersion(const char *versionString);
     38   static void warnIncompatible(DiagnosticsEngine *diags, StringRef pluginPath,
     39                                const char *pluginAPIVersion);
     40 
     41 public:
     42   ClangCheckerRegistry(ArrayRef<std::string> plugins,
     43                        DiagnosticsEngine *diags = nullptr);
     44 };
     45 
     46 } // end anonymous namespace
     47 
     48 ClangCheckerRegistry::ClangCheckerRegistry(ArrayRef<std::string> plugins,
     49                                            DiagnosticsEngine *diags) {
     50   registerBuiltinCheckers(*this);
     51 
     52   for (ArrayRef<std::string>::iterator i = plugins.begin(), e = plugins.end();
     53        i != e; ++i) {
     54     // Get access to the plugin.
     55     std::string err;
     56     DynamicLibrary lib = DynamicLibrary::getPermanentLibrary(i->c_str(), &err);
     57     if (!lib.isValid()) {
     58       diags->Report(diag::err_fe_unable_to_load_plugin) << *i << err;
     59       continue;
     60     }
     61 
     62     // See if it's compatible with this build of clang.
     63     const char *pluginAPIVersion =
     64       (const char *) lib.getAddressOfSymbol("clang_analyzerAPIVersionString");
     65     if (!isCompatibleAPIVersion(pluginAPIVersion)) {
     66       warnIncompatible(diags, *i, pluginAPIVersion);
     67       continue;
     68     }
     69 
     70     // Register its checkers.
     71     RegisterCheckersFn registerPluginCheckers =
     72       (RegisterCheckersFn) (intptr_t) lib.getAddressOfSymbol(
     73                                                       "clang_registerCheckers");
     74     if (registerPluginCheckers)
     75       registerPluginCheckers(*this);
     76   }
     77 }
     78 
     79 bool ClangCheckerRegistry::isCompatibleAPIVersion(const char *versionString) {
     80   // If the version string is null, it's not an analyzer plugin.
     81   if (!versionString)
     82     return false;
     83 
     84   // For now, none of the static analyzer API is considered stable.
     85   // Versions must match exactly.
     86   return strcmp(versionString, CLANG_ANALYZER_API_VERSION_STRING) == 0;
     87 }
     88 
     89 void ClangCheckerRegistry::warnIncompatible(DiagnosticsEngine *diags,
     90                                             StringRef pluginPath,
     91                                             const char *pluginAPIVersion) {
     92   if (!diags)
     93     return;
     94   if (!pluginAPIVersion)
     95     return;
     96 
     97   diags->Report(diag::warn_incompatible_analyzer_plugin_api)
     98       << llvm::sys::path::filename(pluginPath);
     99   diags->Report(diag::note_incompatible_analyzer_plugin_api)
    100       << CLANG_ANALYZER_API_VERSION_STRING
    101       << pluginAPIVersion;
    102 }
    103 
    104 std::unique_ptr<CheckerManager>
    105 ento::createCheckerManager(AnalyzerOptions &opts, const LangOptions &langOpts,
    106                            ArrayRef<std::string> plugins,
    107                            DiagnosticsEngine &diags) {
    108   std::unique_ptr<CheckerManager> checkerMgr(
    109       new CheckerManager(langOpts, &opts));
    110 
    111   SmallVector<CheckerOptInfo, 8> checkerOpts;
    112   for (unsigned i = 0, e = opts.CheckersControlList.size(); i != e; ++i) {
    113     const std::pair<std::string, bool> &opt = opts.CheckersControlList[i];
    114     checkerOpts.push_back(CheckerOptInfo(opt.first.c_str(), opt.second));
    115   }
    116 
    117   ClangCheckerRegistry allCheckers(plugins, &diags);
    118   allCheckers.initializeManager(*checkerMgr, checkerOpts);
    119   allCheckers.validateCheckerOptions(opts, diags);
    120   checkerMgr->finishedCheckerRegistration();
    121 
    122   for (unsigned i = 0, e = checkerOpts.size(); i != e; ++i) {
    123     if (checkerOpts[i].isUnclaimed()) {
    124       diags.Report(diag::err_unknown_analyzer_checker)
    125           << checkerOpts[i].getName();
    126       diags.Report(diag::note_suggest_disabling_all_checkers);
    127     }
    128 
    129   }
    130 
    131   return checkerMgr;
    132 }
    133 
    134 void ento::printCheckerHelp(raw_ostream &out, ArrayRef<std::string> plugins) {
    135   out << "OVERVIEW: Clang Static Analyzer Checkers List\n\n";
    136   out << "USAGE: -analyzer-checker <CHECKER or PACKAGE,...>\n\n";
    137 
    138   ClangCheckerRegistry(plugins).printHelp(out);
    139 }
    140