| 1 |
//===- CheckerRegistry.cpp - Maintains all available 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 |
#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h" |
| 10 |
#include "clang/Basic/Diagnostic.h" |
| 11 |
#include "clang/Basic/LLVM.h" |
| 12 |
#include "clang/Driver/DriverDiagnostic.h" |
| 13 |
#include "clang/Frontend/FrontendDiagnostic.h" |
| 14 |
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" |
| 15 |
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" |
| 16 |
#include "clang/StaticAnalyzer/Core/CheckerManager.h" |
| 17 |
#include "llvm/ADT/STLExtras.h" |
| 18 |
#include "llvm/ADT/StringMap.h" |
| 19 |
#include "llvm/ADT/StringRef.h" |
| 20 |
#include "llvm/Support/DynamicLibrary.h" |
| 21 |
#include "llvm/Support/Path.h" |
| 22 |
#include "llvm/Support/raw_ostream.h" |
| 23 |
#include <algorithm> |
| 24 |
|
| 25 |
using namespace clang; |
| 26 |
using namespace ento; |
| 27 |
using namespace checker_registry; |
| 28 |
using llvm::sys::DynamicLibrary; |
| 29 |
|
| 30 |
//===----------------------------------------------------------------------===// |
| 31 |
// Utilities. |
| 32 |
//===----------------------------------------------------------------------===// |
| 33 |
|
| 34 |
static bool isCompatibleAPIVersion(const char *VersionString) { |
| 35 |
// If the version string is null, its not an analyzer plugin. |
| 36 |
if (!VersionString) |
| 37 |
return false; |
| 38 |
|
| 39 |
// For now, none of the static analyzer API is considered stable. |
| 40 |
// Versions must match exactly. |
| 41 |
return strcmp(VersionString, CLANG_ANALYZER_API_VERSION_STRING) == 0; |
| 42 |
} |
| 43 |
|
| 44 |
static constexpr char PackageSeparator = '.'; |
| 45 |
|
| 46 |
//===----------------------------------------------------------------------===// |
| 47 |
// Methods of CheckerRegistry. |
| 48 |
//===----------------------------------------------------------------------===// |
| 49 |
|
| 50 |
CheckerRegistry::CheckerRegistry( |
| 51 |
CheckerRegistryData &Data, ArrayRef<std::string> Plugins, |
| 52 |
DiagnosticsEngine &Diags, AnalyzerOptions &AnOpts, |
| 53 |
ArrayRef<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns) |
| 54 |
: Data(Data), Diags(Diags), AnOpts(AnOpts) { |
| 55 |
|
| 56 |
// Register builtin checkers. |
| 57 |
#define GET_CHECKERS |
| 58 |
#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN) \ |
| 59 |
addChecker(register##CLASS, shouldRegister##CLASS, FULLNAME, HELPTEXT, \ |
| 60 |
DOC_URI, IS_HIDDEN); |
| 61 |
|
| 62 |
#define GET_PACKAGES |
| 63 |
#define PACKAGE(FULLNAME) addPackage(FULLNAME); |
| 64 |
|
| 65 |
#include "clang/StaticAnalyzer/Checkers/Checkers.inc" |
| 66 |
#undef CHECKER |
| 67 |
#undef GET_CHECKERS |
| 68 |
#undef PACKAGE |
| 69 |
#undef GET_PACKAGES |
| 70 |
|
| 71 |
// Register checkers from plugins. |
| 72 |
for (const std::string &Plugin : Plugins) { |
| 73 |
// Get access to the plugin. |
| 74 |
std::string ErrorMsg; |
| 75 |
DynamicLibrary Lib = |
| 76 |
DynamicLibrary::getPermanentLibrary(Plugin.c_str(), &ErrorMsg); |
| 77 |
if (!Lib.isValid()) { |
| 78 |
Diags.Report(diag::err_fe_unable_to_load_plugin) << Plugin << ErrorMsg; |
| 79 |
continue; |
| 80 |
} |
| 81 |
|
| 82 |
// See if its compatible with this build of clang. |
| 83 |
const char *PluginAPIVersion = static_cast<const char *>( |
| 84 |
Lib.getAddressOfSymbol("clang_analyzerAPIVersionString")); |
| 85 |
|
| 86 |
if (!isCompatibleAPIVersion(PluginAPIVersion)) { |
| 87 |
Diags.Report(diag::warn_incompatible_analyzer_plugin_api) |
| 88 |
<< llvm::sys::path::filename(Plugin); |
| 89 |
Diags.Report(diag::note_incompatible_analyzer_plugin_api) |
| 90 |
<< CLANG_ANALYZER_API_VERSION_STRING << PluginAPIVersion; |
| 91 |
continue; |
| 92 |
} |
| 93 |
|
| 94 |
using RegisterPluginCheckerFn = void (*)(CheckerRegistry &); |
| 95 |
// Register its checkers. |
| 96 |
RegisterPluginCheckerFn RegisterPluginCheckers = |
| 97 |
reinterpret_cast<RegisterPluginCheckerFn>( |
| 98 |
Lib.getAddressOfSymbol("clang_registerCheckers")); |
| 99 |
if (RegisterPluginCheckers) |
| 100 |
RegisterPluginCheckers(*this); |
| 101 |
} |
| 102 |
|
| 103 |
// Register statically linked checkers, that aren't generated from the tblgen |
| 104 |
// file, but rather passed their registry function as a parameter in |
| 105 |
// checkerRegistrationFns. |
| 106 |
|
| 107 |
for (const auto &Fn : CheckerRegistrationFns) |
| 108 |
Fn(*this); |
| 109 |
|
| 110 |
// Sort checkers for efficient collection. |
| 111 |
// FIXME: Alphabetical sort puts 'experimental' in the middle. |
| 112 |
// Would it be better to name it '~experimental' or something else |
| 113 |
// that's ASCIIbetically last? |
| 114 |
llvm::sort(Data.Packages, checker_registry::PackageNameLT{}); |
| 115 |
llvm::sort(Data.Checkers, checker_registry::CheckerNameLT{}); |
| 116 |
|
| 117 |
#define GET_CHECKER_DEPENDENCIES |
| 118 |
|
| 119 |
#define CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY) \ |
| 120 |
addDependency(FULLNAME, DEPENDENCY); |
| 121 |
|
| 122 |
#define GET_CHECKER_WEAK_DEPENDENCIES |
| 123 |
|
| 124 |
#define CHECKER_WEAK_DEPENDENCY(FULLNAME, DEPENDENCY) \ |
| 125 |
addWeakDependency(FULLNAME, DEPENDENCY); |
| 126 |
|
| 127 |
#define GET_CHECKER_OPTIONS |
| 128 |
#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, \ |
| 129 |
DEVELOPMENT_STATUS, IS_HIDDEN) \ |
| 130 |
addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, \ |
| 131 |
DEVELOPMENT_STATUS, IS_HIDDEN); |
| 132 |
|
| 133 |
#define GET_PACKAGE_OPTIONS |
| 134 |
#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, \ |
| 135 |
DEVELOPMENT_STATUS, IS_HIDDEN) \ |
| 136 |
addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, \ |
| 137 |
DEVELOPMENT_STATUS, IS_HIDDEN); |
| 138 |
|
| 139 |
#include "clang/StaticAnalyzer/Checkers/Checkers.inc" |
| 140 |
#undef CHECKER_DEPENDENCY |
| 141 |
#undef GET_CHECKER_DEPENDENCIES |
| 142 |
#undef CHECKER_WEAK_DEPENDENCY |
| 143 |
#undef GET_CHECKER_WEAK_DEPENDENCIES |
| 144 |
#undef CHECKER_OPTION |
| 145 |
#undef GET_CHECKER_OPTIONS |
| 146 |
#undef PACKAGE_OPTION |
| 147 |
#undef GET_PACKAGE_OPTIONS |
| 148 |
|
| 149 |
resolveDependencies<true>(); |
| 150 |
resolveDependencies<false>(); |
| 151 |
|
| 152 |
#ifndef NDEBUG |
| 153 |
for (auto &DepPair : Data.Dependencies) { |
| 154 |
for (auto &WeakDepPair : Data.WeakDependencies) { |
| 155 |
// Some assertions to enforce that strong dependencies are relations in |
| 156 |
// between purely modeling checkers, and weak dependencies are about |
| 157 |
// diagnostics. |
| 158 |
assert(WeakDepPair != DepPair && |
| 159 |
"A checker cannot strong and weak depend on the same checker!"); |
| 160 |
assert(WeakDepPair.first != DepPair.second && |
| 161 |
"A strong dependency mustn't have weak dependencies!"); |
| 162 |
assert(WeakDepPair.second != DepPair.second && |
| 163 |
"A strong dependency mustn't be a weak dependency as well!"); |
| 164 |
} |
| 165 |
} |
| 166 |
#endif |
| 167 |
|
| 168 |
resolveCheckerAndPackageOptions(); |
| 169 |
|
| 170 |
// Parse '-analyzer-checker' and '-analyzer-disable-checker' options from the |
| 171 |
// command line. |
| 172 |
for (const std::pair<std::string, bool> &Opt : AnOpts.CheckersAndPackages) { |
| 173 |
CheckerInfoListRange CheckerForCmdLineArg = |
| 174 |
Data.getMutableCheckersForCmdLineArg(Opt.first); |
| 175 |
|
| 176 |
if (CheckerForCmdLineArg.begin() == CheckerForCmdLineArg.end()) { |
| 177 |
Diags.Report(diag::err_unknown_analyzer_checker_or_package) << Opt.first; |
| 178 |
Diags.Report(diag::note_suggest_disabling_all_checkers); |
| 179 |
} |
| 180 |
|
| 181 |
for (CheckerInfo &checker : CheckerForCmdLineArg) { |
| 182 |
checker.State = Opt.second ? StateFromCmdLine::State_Enabled |
| 183 |
: StateFromCmdLine::State_Disabled; |
| 184 |
} |
| 185 |
} |
| 186 |
validateCheckerOptions(); |
| 187 |
} |
| 188 |
|
| 189 |
//===----------------------------------------------------------------------===// |
| 190 |
// Dependency resolving. |
| 191 |
//===----------------------------------------------------------------------===// |
| 192 |
|
| 193 |
template <typename IsEnabledFn> |
| 194 |
static bool collectStrongDependencies(const ConstCheckerInfoList &Deps, |
| 195 |
const CheckerManager &Mgr, |
| 196 |
CheckerInfoSet &Ret, |
| 197 |
IsEnabledFn IsEnabled); |
| 198 |
|
| 199 |
/// Collects weak dependencies in \p enabledData.Checkers. |
| 200 |
template <typename IsEnabledFn> |
| 201 |
static void collectWeakDependencies(const ConstCheckerInfoList &Deps, |
| 202 |
const CheckerManager &Mgr, |
| 203 |
CheckerInfoSet &Ret, IsEnabledFn IsEnabled); |
| 204 |
|
| 205 |
void CheckerRegistry::initializeRegistry(const CheckerManager &Mgr) { |
| 206 |
// First, we calculate the list of enabled checkers as specified by the |
| 207 |
// invocation. Weak dependencies will not enable their unspecified strong |
| 208 |
// depenencies, but its only after resolving strong dependencies for all |
| 209 |
// checkers when we know whether they will be enabled. |
| 210 |
CheckerInfoSet Tmp; |
| 211 |
auto IsEnabledFromCmdLine = [&](const CheckerInfo *Checker) { |
| 212 |
return !Checker->isDisabled(Mgr); |
| 213 |
}; |
| 214 |
for (const CheckerInfo &Checker : Data.Checkers) { |
| 215 |
if (!Checker.isEnabled(Mgr)) |
| 216 |
continue; |
| 217 |
|
| 218 |
CheckerInfoSet Deps; |
| 219 |
if (!collectStrongDependencies(Checker.Dependencies, Mgr, Deps, |
| 220 |
IsEnabledFromCmdLine)) { |
| 221 |
// If we failed to enable any of the dependencies, don't enable this |
| 222 |
// checker. |
| 223 |
continue; |
| 224 |
} |
| 225 |
|
| 226 |
Tmp.insert(Deps.begin(), Deps.end()); |
| 227 |
|
| 228 |
// Enable the checker. |
| 229 |
Tmp.insert(&Checker); |
| 230 |
} |
| 231 |
|
| 232 |
// Calculate enabled checkers with the correct registration order. As this is |
| 233 |
// done recursively, its arguably cheaper, but for sure less error prone to |
| 234 |
// recalculate from scratch. |
| 235 |
auto IsEnabled = [&](const CheckerInfo *Checker) { |
| 236 |
return llvm::is_contained(Tmp, Checker); |
| 237 |
}; |
| 238 |
for (const CheckerInfo &Checker : Data.Checkers) { |
| 239 |
if (!Checker.isEnabled(Mgr)) |
| 240 |
continue; |
| 241 |
|
| 242 |
CheckerInfoSet Deps; |
| 243 |
|
| 244 |
collectWeakDependencies(Checker.WeakDependencies, Mgr, Deps, IsEnabled); |
| 245 |
|
| 246 |
if (!collectStrongDependencies(Checker.Dependencies, Mgr, Deps, |
| 247 |
IsEnabledFromCmdLine)) { |
| 248 |
// If we failed to enable any of the dependencies, don't enable this |
| 249 |
// checker. |
| 250 |
continue; |
| 251 |
} |
| 252 |
|
| 253 |
// Note that set_union also preserves the order of insertion. |
| 254 |
Data.EnabledCheckers.set_union(Deps); |
| 255 |
Data.EnabledCheckers.insert(&Checker); |
| 256 |
} |
| 257 |
} |
| 258 |
|
| 259 |
template <typename IsEnabledFn> |
| 260 |
static bool collectStrongDependencies(const ConstCheckerInfoList &Deps, |
| 261 |
const CheckerManager &Mgr, |
| 262 |
CheckerInfoSet &Ret, |
| 263 |
IsEnabledFn IsEnabled) { |
| 264 |
|
| 265 |
for (const CheckerInfo *Dependency : Deps) { |
| 266 |
if (!IsEnabled(Dependency)) |
| 267 |
return false; |
| 268 |
|
| 269 |
// Collect dependencies recursively. |
| 270 |
if (!collectStrongDependencies(Dependency->Dependencies, Mgr, Ret, |
| 271 |
IsEnabled)) |
| 272 |
return false; |
| 273 |
Ret.insert(Dependency); |
| 274 |
} |
| 275 |
|
| 276 |
return true; |
| 277 |
} |
| 278 |
|
| 279 |
template <typename IsEnabledFn> |
| 280 |
static void collectWeakDependencies(const ConstCheckerInfoList &WeakDeps, |
| 281 |
const CheckerManager &Mgr, |
| 282 |
CheckerInfoSet &Ret, |
| 283 |
IsEnabledFn IsEnabled) { |
| 284 |
|
| 285 |
for (const CheckerInfo *Dependency : WeakDeps) { |
| 286 |
// Don't enable this checker if strong dependencies are unsatisfied, but |
| 287 |
// assume that weak dependencies are transitive. |
| 288 |
collectWeakDependencies(Dependency->WeakDependencies, Mgr, Ret, IsEnabled); |
| 289 |
|
| 290 |
if (IsEnabled(Dependency) && |
| 291 |
collectStrongDependencies(Dependency->Dependencies, Mgr, Ret, |
| 292 |
IsEnabled)) |
| 293 |
Ret.insert(Dependency); |
| 294 |
} |
| 295 |
} |
| 296 |
|
| 297 |
template <bool IsWeak> void CheckerRegistry::resolveDependencies() { |
| 298 |
for (const std::pair<StringRef, StringRef> &Entry : |
| 299 |
(IsWeak ? Data.WeakDependencies : Data.Dependencies)) { |
| 300 |
|
| 301 |
auto CheckerIt = binaryFind(Data.Checkers, Entry.first); |
| 302 |
assert(CheckerIt != Data.Checkers.end() && |
| 303 |
CheckerIt->FullName == Entry.first && |
| 304 |
"Failed to find the checker while attempting to set up its " |
| 305 |
"dependencies!"); |
| 306 |
|
| 307 |
auto DependencyIt = binaryFind(Data.Checkers, Entry.second); |
| 308 |
assert(DependencyIt != Data.Checkers.end() && |
| 309 |
DependencyIt->FullName == Entry.second && |
| 310 |
"Failed to find the dependency of a checker!"); |
| 311 |
|
| 312 |
// We do allow diagnostics from unit test/example dependency checkers. |
| 313 |
assert((DependencyIt->FullName.startswith("test") || |
| 314 |
DependencyIt->FullName.startswith("example") || IsWeak || |
| 315 |
DependencyIt->IsHidden) && |
| 316 |
"Strong dependencies are modeling checkers, and as such " |
| 317 |
"non-user facing! Mark them hidden in Checkers.td!"); |
| 318 |
|
| 319 |
if (IsWeak) |
| 320 |
CheckerIt->WeakDependencies.emplace_back(&*DependencyIt); |
| 321 |
else |
| 322 |
CheckerIt->Dependencies.emplace_back(&*DependencyIt); |
| 323 |
} |
| 324 |
} |
| 325 |
|
| 326 |
void CheckerRegistry::addDependency(StringRef FullName, StringRef Dependency) { |
| 327 |
Data.Dependencies.emplace_back(FullName, Dependency); |
| 328 |
} |
| 329 |
|
| 330 |
void CheckerRegistry::addWeakDependency(StringRef FullName, |
| 331 |
StringRef Dependency) { |
| 332 |
Data.WeakDependencies.emplace_back(FullName, Dependency); |
| 333 |
} |
| 334 |
|
| 335 |
//===----------------------------------------------------------------------===// |
| 336 |
// Checker option resolving and validating. |
| 337 |
//===----------------------------------------------------------------------===// |
| 338 |
|
| 339 |
/// Insert the checker/package option to AnalyzerOptions' config table, and |
| 340 |
/// validate it, if the user supplied it on the command line. |
| 341 |
static void insertAndValidate(StringRef FullName, const CmdLineOption &Option, |
| 342 |
AnalyzerOptions &AnOpts, |
| 343 |
DiagnosticsEngine &Diags) { |
| 344 |
|
| 345 |
std::string FullOption = (FullName + ":" + Option.OptionName).str(); |
| 346 |
|
| 347 |
auto It = |
| 348 |
AnOpts.Config.insert({FullOption, std::string(Option.DefaultValStr)}); |
| 349 |
|
| 350 |
// Insertation was successful -- CmdLineOption's constructor will validate |
| 351 |
// whether values received from plugins or TableGen files are correct. |
| 352 |
if (It.second) |
| 353 |
return; |
| 354 |
|
| 355 |
// Insertion failed, the user supplied this package/checker option on the |
| 356 |
// command line. If the supplied value is invalid, we'll restore the option |
| 357 |
// to it's default value, and if we're in non-compatibility mode, we'll also |
| 358 |
// emit an error. |
| 359 |
|
| 360 |
StringRef SuppliedValue = It.first->getValue(); |
| 361 |
|
| 362 |
if (Option.OptionType == "bool") { |
| 363 |
if (SuppliedValue != "true" && SuppliedValue != "false") { |
| 364 |
if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) { |
| 365 |
Diags.Report(diag::err_analyzer_checker_option_invalid_input) |
| 366 |
<< FullOption << "a boolean value"; |
| 367 |
} |
| 368 |
|
| 369 |
It.first->setValue(std::string(Option.DefaultValStr)); |
| 370 |
} |
| 371 |
return; |
| 372 |
} |
| 373 |
|
| 374 |
if (Option.OptionType == "int") { |
| 375 |
int Tmp; |
| 376 |
bool HasFailed = SuppliedValue.getAsInteger(0, Tmp); |
| 377 |
if (HasFailed) { |
| 378 |
if (AnOpts.ShouldEmitErrorsOnInvalidConfigValue) { |
| 379 |
Diags.Report(diag::err_analyzer_checker_option_invalid_input) |
| 380 |
<< FullOption << "an integer value"; |
| 381 |
} |
| 382 |
|
| 383 |
It.first->setValue(std::string(Option.DefaultValStr)); |
| 384 |
} |
| 385 |
return; |
| 386 |
} |
| 387 |
} |
| 388 |
|
| 389 |
template <class T> |
| 390 |
static void insertOptionToCollection(StringRef FullName, T &Collection, |
| 391 |
const CmdLineOption &Option, |
| 392 |
AnalyzerOptions &AnOpts, |
| 393 |
DiagnosticsEngine &Diags) { |
| 394 |
auto It = binaryFind(Collection, FullName); |
| 395 |
assert(It != Collection.end() && |
| 396 |
"Failed to find the checker while attempting to add a command line " |
| 397 |
"option to it!"); |
| 398 |
|
| 399 |
insertAndValidate(FullName, Option, AnOpts, Diags); |
| 400 |
|
| 401 |
It->CmdLineOptions.emplace_back(Option); |
| 402 |
} |
| 403 |
|
| 404 |
void CheckerRegistry::resolveCheckerAndPackageOptions() { |
| 405 |
for (const std::pair<StringRef, CmdLineOption> &CheckerOptEntry : |
| 406 |
Data.CheckerOptions) { |
| 407 |
insertOptionToCollection(CheckerOptEntry.first, Data.Checkers, |
| 408 |
CheckerOptEntry.second, AnOpts, Diags); |
| 409 |
} |
| 410 |
|
| 411 |
for (const std::pair<StringRef, CmdLineOption> &PackageOptEntry : |
| 412 |
Data.PackageOptions) { |
| 413 |
insertOptionToCollection(PackageOptEntry.first, Data.Packages, |
| 414 |
PackageOptEntry.second, AnOpts, Diags); |
| 415 |
} |
| 416 |
} |
| 417 |
|
| 418 |
void CheckerRegistry::addPackage(StringRef FullName) { |
| 419 |
Data.Packages.emplace_back(PackageInfo(FullName)); |
| 420 |
} |
| 421 |
|
| 422 |
void CheckerRegistry::addPackageOption(StringRef OptionType, |
| 423 |
StringRef PackageFullName, |
| 424 |
StringRef OptionName, |
| 425 |
StringRef DefaultValStr, |
| 426 |
StringRef Description, |
| 427 |
StringRef DevelopmentStatus, |
| 428 |
bool IsHidden) { |
| 429 |
Data.PackageOptions.emplace_back( |
| 430 |
PackageFullName, CmdLineOption{OptionType, OptionName, DefaultValStr, |
| 431 |
Description, DevelopmentStatus, IsHidden}); |
| 432 |
} |
| 433 |
|
| 434 |
void CheckerRegistry::addChecker(RegisterCheckerFn Rfn, |
| 435 |
ShouldRegisterFunction Sfn, StringRef Name, |
| 436 |
StringRef Desc, StringRef DocsUri, |
| 437 |
bool IsHidden) { |
| 438 |
Data.Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri, IsHidden); |
| 439 |
|
| 440 |
// Record the presence of the checker in its packages. |
| 441 |
StringRef PackageName, LeafName; |
| 442 |
std::tie(PackageName, LeafName) = Name.rsplit(PackageSeparator); |
| 443 |
while (!LeafName.empty()) { |
| 444 |
Data.PackageSizes[PackageName] += 1; |
| 445 |
std::tie(PackageName, LeafName) = PackageName.rsplit(PackageSeparator); |
| 446 |
} |
| 447 |
} |
| 448 |
|
| 449 |
void CheckerRegistry::addCheckerOption(StringRef OptionType, |
| 450 |
StringRef CheckerFullName, |
| 451 |
StringRef OptionName, |
| 452 |
StringRef DefaultValStr, |
| 453 |
StringRef Description, |
| 454 |
StringRef DevelopmentStatus, |
| 455 |
bool IsHidden) { |
| 456 |
Data.CheckerOptions.emplace_back( |
| 457 |
CheckerFullName, CmdLineOption{OptionType, OptionName, DefaultValStr, |
| 458 |
Description, DevelopmentStatus, IsHidden}); |
| 459 |
} |
| 460 |
|
| 461 |
void CheckerRegistry::initializeManager(CheckerManager &CheckerMgr) const { |
| 462 |
// Initialize the CheckerManager with all enabled checkers. |
| 463 |
for (const auto *Checker : Data.EnabledCheckers) { |
| 464 |
CheckerMgr.setCurrentCheckerName(CheckerNameRef(Checker->FullName)); |
| 465 |
Checker->Initialize(CheckerMgr); |
| 466 |
} |
| 467 |
} |
| 468 |
|
| 469 |
static void isOptionContainedIn(const CmdLineOptionList &OptionList, |
| 470 |
StringRef SuppliedChecker, |
| 471 |
StringRef SuppliedOption, |
| 472 |
const AnalyzerOptions &AnOpts, |
| 473 |
DiagnosticsEngine &Diags) { |
| 474 |
|
| 475 |
if (!AnOpts.ShouldEmitErrorsOnInvalidConfigValue) |
| 476 |
return; |
| 477 |
|
| 478 |
auto SameOptName = [SuppliedOption](const CmdLineOption &Opt) { |
| 479 |
return Opt.OptionName == SuppliedOption; |
| 480 |
}; |
| 481 |
|
| 482 |
if (llvm::none_of(OptionList, SameOptName)) { |
| 483 |
Diags.Report(diag::err_analyzer_checker_option_unknown) |
| 484 |
<< SuppliedChecker << SuppliedOption; |
| 485 |
return; |
| 486 |
} |
| 487 |
} |
| 488 |
|
| 489 |
void CheckerRegistry::validateCheckerOptions() const { |
| 490 |
for (const auto &Config : AnOpts.Config) { |
| 491 |
|
| 492 |
StringRef SuppliedCheckerOrPackage; |
| 493 |
StringRef SuppliedOption; |
| 494 |
std::tie(SuppliedCheckerOrPackage, SuppliedOption) = |
| 495 |
Config.getKey().split(':'); |
| 496 |
|
| 497 |
if (SuppliedOption.empty()) |
| 498 |
continue; |
| 499 |
|
| 500 |
// AnalyzerOptions' config table contains the user input, so an entry could |
| 501 |
// look like this: |
| 502 |
// |
| 503 |
// cor:NoFalsePositives=true |
| 504 |
// |
| 505 |
// Since lower_bound would look for the first element *not less* than "cor", |
| 506 |
// it would return with an iterator to the first checker in the core, so we |
| 507 |
// we really have to use find here, which uses operator==. |
| 508 |
auto CheckerIt = |
| 509 |
llvm::find(Data.Checkers, CheckerInfo(SuppliedCheckerOrPackage)); |
| 510 |
if (CheckerIt != Data.Checkers.end()) { |
| 511 |
isOptionContainedIn(CheckerIt->CmdLineOptions, SuppliedCheckerOrPackage, |
| 512 |
SuppliedOption, AnOpts, Diags); |
| 513 |
continue; |
| 514 |
} |
| 515 |
|
| 516 |
const auto *PackageIt = |
| 517 |
llvm::find(Data.Packages, PackageInfo(SuppliedCheckerOrPackage)); |
| 518 |
if (PackageIt != Data.Packages.end()) { |
| 519 |
isOptionContainedIn(PackageIt->CmdLineOptions, SuppliedCheckerOrPackage, |
| 520 |
SuppliedOption, AnOpts, Diags); |
| 521 |
continue; |
| 522 |
} |
| 523 |
|
| 524 |
Diags.Report(diag::err_unknown_analyzer_checker_or_package) |
| 525 |
<< SuppliedCheckerOrPackage; |
| 526 |
} |
| 527 |
} |
| 528 |
|