OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

334 lines
11 KiB
C++
Raw Blame History

//===- CheckerRegistry.cpp - Maintains all available checkers -------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LLVM.h"
#include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DynamicLibrary.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace clang;
using namespace ento;
using llvm::sys::DynamicLibrary;
using RegisterCheckersFn = void (*)(CheckerRegistry &);
static bool isCompatibleAPIVersion(const char *versionString) {
// If the version string is null, it's not an analyzer plugin.
if (!versionString)
return false;
// For now, none of the static analyzer API is considered stable.
// Versions must match exactly.
return strcmp(versionString, CLANG_ANALYZER_API_VERSION_STRING) == 0;
}
static bool checkerNameLT(const CheckerRegistry::CheckerInfo &a,
const CheckerRegistry::CheckerInfo &b) {
return a.FullName < b.FullName;
}
static constexpr char PackageSeparator = '.';
static bool isInPackage(const CheckerRegistry::CheckerInfo &checker,
StringRef packageName) {
// Does the checker's full name have the package as a prefix?
if (!checker.FullName.startswith(packageName))
return false;
// Is the package actually just the name of a specific checker?
if (checker.FullName.size() == packageName.size())
return true;
// Is the checker in the package (or a subpackage)?
if (checker.FullName[packageName.size()] == PackageSeparator)
return true;
return false;
}
CheckerRegistry::CheckerInfoListRange
CheckerRegistry::getMutableCheckersForCmdLineArg(StringRef CmdLineArg) {
assert(std::is_sorted(Checkers.begin(), Checkers.end(), checkerNameLT) &&
"In order to efficiently gather checkers, this function expects them "
"to be already sorted!");
// Use a binary search to find the possible start of the package.
CheckerRegistry::CheckerInfo
packageInfo(nullptr, nullptr, CmdLineArg, "", "");
auto it = std::lower_bound(Checkers.begin(), Checkers.end(),
packageInfo, checkerNameLT);
if (!isInPackage(*it, CmdLineArg))
return { Checkers.end(), Checkers.end() };
// See how large the package is.
// If the package doesn't exist, assume the option refers to a single
// checker.
size_t size = 1;
llvm::StringMap<size_t>::const_iterator packageSize =
Packages.find(CmdLineArg);
if (packageSize != Packages.end())
size = packageSize->getValue();
return { it, it + size };
}
CheckerRegistry::CheckerRegistry(
ArrayRef<std::string> plugins, DiagnosticsEngine &diags,
AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
ArrayRef<std::function<void(CheckerRegistry &)>>
checkerRegistrationFns)
: Diags(diags), AnOpts(AnOpts), LangOpts(LangOpts) {
// Register builtin checkers.
#define GET_CHECKERS
#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI) \
addChecker(register##CLASS, shouldRegister##CLASS, FULLNAME, HELPTEXT, \
DOC_URI);
#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
#undef CHECKER
#undef GET_CHECKERS
// Register checkers from plugins.
for (ArrayRef<std::string>::iterator i = plugins.begin(), e = plugins.end();
i != e; ++i) {
// Get access to the plugin.
std::string err;
DynamicLibrary lib = DynamicLibrary::getPermanentLibrary(i->c_str(), &err);
if (!lib.isValid()) {
diags.Report(diag::err_fe_unable_to_load_plugin) << *i << err;
continue;
}
// See if it's compatible with this build of clang.
const char *pluginAPIVersion =
(const char *) lib.getAddressOfSymbol("clang_analyzerAPIVersionString");
if (!isCompatibleAPIVersion(pluginAPIVersion)) {
Diags.Report(diag::warn_incompatible_analyzer_plugin_api)
<< llvm::sys::path::filename(*i);
Diags.Report(diag::note_incompatible_analyzer_plugin_api)
<< CLANG_ANALYZER_API_VERSION_STRING
<< pluginAPIVersion;
continue;
}
// Register its checkers.
RegisterCheckersFn registerPluginCheckers =
(RegisterCheckersFn) (intptr_t) lib.getAddressOfSymbol(
"clang_registerCheckers");
if (registerPluginCheckers)
registerPluginCheckers(*this);
}
// Register statically linked checkers, that aren't generated from the tblgen
// file, but rather passed their registry function as a parameter in
// checkerRegistrationFns.
for (const auto &Fn : checkerRegistrationFns)
Fn(*this);
// Sort checkers for efficient collection.
// FIXME: Alphabetical sort puts 'experimental' in the middle.
// Would it be better to name it '~experimental' or something else
// that's ASCIIbetically last?
llvm::sort(Checkers, checkerNameLT);
#define GET_CHECKER_DEPENDENCIES
#define CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY) \
addDependency(FULLNAME, DEPENDENCY);
#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
#undef CHECKER_DEPENDENCY
#undef GET_CHECKER_DEPENDENCIES
// Parse '-analyzer-checker' and '-analyzer-disable-checker' options from the
// command line.
for (const std::pair<std::string, bool> &opt : AnOpts.CheckersControlList) {
CheckerInfoListRange checkersForCmdLineArg =
getMutableCheckersForCmdLineArg(opt.first);
if (checkersForCmdLineArg.begin() == checkersForCmdLineArg.end()) {
Diags.Report(diag::err_unknown_analyzer_checker) << opt.first;
Diags.Report(diag::note_suggest_disabling_all_checkers);
}
for (CheckerInfo &checker : checkersForCmdLineArg) {
checker.State = opt.second ? StateFromCmdLine::State_Enabled :
StateFromCmdLine::State_Disabled;
}
}
}
/// Collects dependencies in \p ret, returns false on failure.
static bool collectDependenciesImpl(
const CheckerRegistry::ConstCheckerInfoList &deps,
const LangOptions &LO,
CheckerRegistry::CheckerInfoSet &ret);
/// Collects dependenies in \p enabledCheckers. Return None on failure.
LLVM_NODISCARD
static llvm::Optional<CheckerRegistry::CheckerInfoSet> collectDependencies(
const CheckerRegistry::CheckerInfo &checker, const LangOptions &LO) {
CheckerRegistry::CheckerInfoSet ret;
// Add dependencies to the enabled checkers only if all of them can be
// enabled.
if (!collectDependenciesImpl(checker.Dependencies, LO, ret))
return None;
return ret;
}
static bool collectDependenciesImpl(
const CheckerRegistry::ConstCheckerInfoList &deps,
const LangOptions &LO,
CheckerRegistry::CheckerInfoSet &ret) {
for (const CheckerRegistry::CheckerInfo *dependency : deps) {
if (dependency->isDisabled(LO))
return false;
// Collect dependencies recursively.
if (!collectDependenciesImpl(dependency->Dependencies, LO, ret))
return false;
ret.insert(dependency);
}
return true;
}
CheckerRegistry::CheckerInfoSet CheckerRegistry::getEnabledCheckers() const {
CheckerInfoSet enabledCheckers;
for (const CheckerInfo &checker : Checkers) {
if (!checker.isEnabled(LangOpts))
continue;
// Recursively enable it's dependencies.
llvm::Optional<CheckerInfoSet> deps =
collectDependencies(checker, LangOpts);
if (!deps) {
// If we failed to enable any of the dependencies, don't enable this
// checker.
continue;
}
// Note that set_union also preserves the order of insertion.
enabledCheckers.set_union(*deps);
// Enable the checker.
enabledCheckers.insert(&checker);
}
return enabledCheckers;
}
void CheckerRegistry::addChecker(InitializationFunction Rfn,
ShouldRegisterFunction Sfn, StringRef Name,
StringRef Desc, StringRef DocsUri) {
Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri);
// Record the presence of the checker in its packages.
StringRef packageName, leafName;
std::tie(packageName, leafName) = Name.rsplit(PackageSeparator);
while (!leafName.empty()) {
Packages[packageName] += 1;
std::tie(packageName, leafName) = packageName.rsplit(PackageSeparator);
}
}
void CheckerRegistry::initializeManager(CheckerManager &checkerMgr) const {
// Collect checkers enabled by the options.
CheckerInfoSet enabledCheckers = getEnabledCheckers();
// Initialize the CheckerManager with all enabled checkers.
for (const auto *i : enabledCheckers) {
checkerMgr.setCurrentCheckName(CheckName(i->FullName));
i->Initialize(checkerMgr);
}
}
void CheckerRegistry::validateCheckerOptions() const {
for (const auto &config : AnOpts.Config) {
size_t pos = config.getKey().find(':');
if (pos == StringRef::npos)
continue;
bool hasChecker = false;
StringRef checkerName = config.getKey().substr(0, pos);
for (const auto &checker : Checkers) {
if (checker.FullName.startswith(checkerName) &&
(checker.FullName.size() == pos || checker.FullName[pos] == '.')) {
hasChecker = true;
break;
}
}
if (!hasChecker)
Diags.Report(diag::err_unknown_analyzer_checker) << checkerName;
}
}
void CheckerRegistry::printHelp(raw_ostream &out,
size_t maxNameChars) const {
// FIXME: Print available packages.
out << "CHECKERS:\n";
// Find the maximum option length.
size_t optionFieldWidth = 0;
for (const auto &i : Checkers) {
// Limit the amount of padding we are willing to give up for alignment.
// Package.Name Description [Hidden]
size_t nameLength = i.FullName.size();
if (nameLength <= maxNameChars)
optionFieldWidth = std::max(optionFieldWidth, nameLength);
}
const size_t initialPad = 2;
for (const auto &i : Checkers) {
out.indent(initialPad) << i.FullName;
int pad = optionFieldWidth - i.FullName.size();
// Break on long option names.
if (pad < 0) {
out << '\n';
pad = optionFieldWidth + initialPad;
}
out.indent(pad + 2) << i.Desc;
out << '\n';
}
}
void CheckerRegistry::printList(raw_ostream &out) const {
// Collect checkers enabled by the options.
CheckerInfoSet enabledCheckers = getEnabledCheckers();
for (const auto *i : enabledCheckers)
out << i->FullName << '\n';
}
Reference in New Issue View Git Blame Copy Permalink