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 
529