/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- CheckerRegistry.h - Maintains all available checkers -----*- C++ -*-===// |
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 | | // Contains the logic for parsing the TableGen file Checkers.td, and parsing the |
10 | | // specific invocation of the analyzer (which checker/package is enabled, values |
11 | | // of their options, etc). This is in the frontend library because checker |
12 | | // registry functions are called from here but are defined in the dependent |
13 | | // library libStaticAnalyzerCheckers, but the actual data structure that holds |
14 | | // the parsed information is in the Core library. |
15 | | // |
16 | | //===----------------------------------------------------------------------===// |
17 | | |
18 | | #ifndef LLVM_CLANG_STATICANALYZER_FRONTEND_CHECKERREGISTRY_H |
19 | | #define LLVM_CLANG_STATICANALYZER_FRONTEND_CHECKERREGISTRY_H |
20 | | |
21 | | #include "clang/Basic/LLVM.h" |
22 | | #include "clang/StaticAnalyzer/Core/CheckerRegistryData.h" |
23 | | #include "llvm/ADT/StringRef.h" |
24 | | |
25 | | // FIXME: move this information to an HTML file in docs/. |
26 | | // At the very least, a checker plugin is a dynamic library that exports |
27 | | // clang_analyzerAPIVersionString. This should be defined as follows: |
28 | | // |
29 | | // extern "C" |
30 | | // const char clang_analyzerAPIVersionString[] = |
31 | | // CLANG_ANALYZER_API_VERSION_STRING; |
32 | | // |
33 | | // This is used to check whether the current version of the analyzer is known to |
34 | | // be incompatible with a plugin. Plugins with incompatible version strings, |
35 | | // or without a version string at all, will not be loaded. |
36 | | // |
37 | | // To add a custom checker to the analyzer, the plugin must also define the |
38 | | // function clang_registerCheckers. For example: |
39 | | // |
40 | | // extern "C" |
41 | | // void clang_registerCheckers (CheckerRegistry ®istry) { |
42 | | // registry.addChecker<MainCallChecker>("example.MainCallChecker", |
43 | | // "Disallows calls to functions called main"); |
44 | | // } |
45 | | // |
46 | | // The first method argument is the full name of the checker, including its |
47 | | // enclosing package. By convention, the registered name of a checker is the |
48 | | // name of the associated class (the template argument). |
49 | | // The second method argument is a short human-readable description of the |
50 | | // checker. |
51 | | // |
52 | | // The clang_registerCheckers function may add any number of checkers to the |
53 | | // registry. If any checkers require additional initialization, use the three- |
54 | | // argument form of CheckerRegistry::addChecker. |
55 | | // |
56 | | // To load a checker plugin, specify the full path to the dynamic library as |
57 | | // the argument to the -load option in the cc1 frontend. You can then enable |
58 | | // your custom checker using the -analyzer-checker: |
59 | | // |
60 | | // clang -cc1 -load </path/to/plugin.dylib> -analyze |
61 | | // -analyzer-checker=<example.MainCallChecker> |
62 | | // |
63 | | // For a complete working example, see examples/analyzer-plugin. |
64 | | |
65 | | #ifndef CLANG_ANALYZER_API_VERSION_STRING |
66 | | // FIXME: The Clang version string is not particularly granular; |
67 | | // the analyzer infrastructure can change a lot between releases. |
68 | | // Unfortunately, this string has to be statically embedded in each plugin, |
69 | | // so we can't just use the functions defined in Version.h. |
70 | | #include "clang/Basic/Version.h" |
71 | 0 | #define CLANG_ANALYZER_API_VERSION_STRING CLANG_VERSION_STRING |
72 | | #endif |
73 | | |
74 | | namespace clang { |
75 | | |
76 | | class AnalyzerOptions; |
77 | | class DiagnosticsEngine; |
78 | | |
79 | | namespace ento { |
80 | | |
81 | | class CheckerManager; |
82 | | |
83 | | /// Manages a set of available checkers for running a static analysis. |
84 | | /// The checkers are organized into packages by full name, where including |
85 | | /// a package will recursively include all subpackages and checkers within it. |
86 | | /// For example, the checker "core.builtin.NoReturnFunctionChecker" will be |
87 | | /// included if initializeManager() is called with an option of "core", |
88 | | /// "core.builtin", or the full name "core.builtin.NoReturnFunctionChecker". |
89 | | class CheckerRegistry { |
90 | | public: |
91 | | CheckerRegistry(CheckerRegistryData &Data, ArrayRef<std::string> Plugins, |
92 | | DiagnosticsEngine &Diags, AnalyzerOptions &AnOpts, |
93 | | ArrayRef<std::function<void(CheckerRegistry &)>> |
94 | | CheckerRegistrationFns = {}); |
95 | | |
96 | | /// Collects all enabled checkers in the field EnabledCheckers. It preserves |
97 | | /// the order of insertion, as dependencies have to be enabled before the |
98 | | /// checkers that depend on them. |
99 | | void initializeRegistry(const CheckerManager &Mgr); |
100 | | |
101 | | |
102 | | private: |
103 | | /// Default initialization function for checkers -- since CheckerManager |
104 | | /// includes this header, we need to make it a template parameter, and since |
105 | | /// the checker must be a template parameter as well, we can't put this in the |
106 | | /// cpp file. |
107 | 0 | template <typename MGR, typename T> static void initializeManager(MGR &mgr) { |
108 | 0 | mgr.template registerChecker<T>(); |
109 | 0 | } Unexecuted instantiation: MainCallChecker.cpp:void clang::ento::CheckerRegistry::initializeManager<clang::ento::CheckerManager, (anonymous namespace)::MainCallChecker>(clang::ento::CheckerManager&) Unexecuted instantiation: CheckerDependencyHandling.cpp:void clang::ento::CheckerRegistry::initializeManager<clang::ento::CheckerManager, (anonymous namespace)::Dependency>(clang::ento::CheckerManager&) Unexecuted instantiation: CheckerDependencyHandling.cpp:void clang::ento::CheckerRegistry::initializeManager<clang::ento::CheckerManager, (anonymous namespace)::DependendentChecker>(clang::ento::CheckerManager&) |
110 | | |
111 | 0 | template <typename T> static bool returnTrue(const CheckerManager &mgr) { |
112 | 0 | return true; |
113 | 0 | } Unexecuted instantiation: MainCallChecker.cpp:bool clang::ento::CheckerRegistry::returnTrue<(anonymous namespace)::MainCallChecker>(clang::ento::CheckerManager const&) Unexecuted instantiation: CheckerDependencyHandling.cpp:bool clang::ento::CheckerRegistry::returnTrue<(anonymous namespace)::Dependency>(clang::ento::CheckerManager const&) Unexecuted instantiation: CheckerDependencyHandling.cpp:bool clang::ento::CheckerRegistry::returnTrue<(anonymous namespace)::DependendentChecker>(clang::ento::CheckerManager const&) |
114 | | |
115 | | public: |
116 | | /// Adds a checker to the registry. Use this non-templated overload when your |
117 | | /// checker requires custom initialization. |
118 | | void addChecker(RegisterCheckerFn Fn, ShouldRegisterFunction sfn, |
119 | | StringRef FullName, StringRef Desc, StringRef DocsUri, |
120 | | bool IsHidden); |
121 | | |
122 | | /// Adds a checker to the registry. Use this templated overload when your |
123 | | /// checker does not require any custom initialization. |
124 | | /// This function isn't really needed and probably causes more headaches than |
125 | | /// the tiny convenience that it provides, but external plugins might use it, |
126 | | /// and there isn't a strong incentive to remove it. |
127 | | template <class T> |
128 | | void addChecker(StringRef FullName, StringRef Desc, StringRef DocsUri, |
129 | 0 | bool IsHidden = false) { |
130 | | // Avoid MSVC's Compiler Error C2276: |
131 | | // http://msdn.microsoft.com/en-us/library/850cstw1(v=VS.80).aspx |
132 | 0 | addChecker(&CheckerRegistry::initializeManager<CheckerManager, T>, |
133 | 0 | &CheckerRegistry::returnTrue<T>, FullName, Desc, DocsUri, |
134 | 0 | IsHidden); |
135 | 0 | } Unexecuted instantiation: MainCallChecker.cpp:void clang::ento::CheckerRegistry::addChecker<(anonymous namespace)::MainCallChecker>(llvm::StringRef, llvm::StringRef, llvm::StringRef, bool) Unexecuted instantiation: CheckerDependencyHandling.cpp:void clang::ento::CheckerRegistry::addChecker<(anonymous namespace)::Dependency>(llvm::StringRef, llvm::StringRef, llvm::StringRef, bool) Unexecuted instantiation: CheckerDependencyHandling.cpp:void clang::ento::CheckerRegistry::addChecker<(anonymous namespace)::DependendentChecker>(llvm::StringRef, llvm::StringRef, llvm::StringRef, bool) |
136 | | |
137 | | /// Makes the checker with the full name \p fullName depend on the checker |
138 | | /// called \p dependency. |
139 | | void addDependency(StringRef FullName, StringRef Dependency); |
140 | | |
141 | | /// Makes the checker with the full name \p fullName weak depend on the |
142 | | /// checker called \p dependency. |
143 | | void addWeakDependency(StringRef FullName, StringRef Dependency); |
144 | | |
145 | | /// Registers an option to a given checker. A checker option will always have |
146 | | /// the following format: |
147 | | /// CheckerFullName:OptionName=Value |
148 | | /// And can be specified from the command line like this: |
149 | | /// -analyzer-config CheckerFullName:OptionName=Value |
150 | | /// |
151 | | /// Options for unknown checkers, or unknown options for a given checker, or |
152 | | /// invalid value types for that given option are reported as an error in |
153 | | /// non-compatibility mode. |
154 | | void addCheckerOption(StringRef OptionType, StringRef CheckerFullName, |
155 | | StringRef OptionName, StringRef DefaultValStr, |
156 | | StringRef Description, StringRef DevelopmentStatus, |
157 | | bool IsHidden = false); |
158 | | |
159 | | /// Adds a package to the registry. |
160 | | void addPackage(StringRef FullName); |
161 | | |
162 | | /// Registers an option to a given package. A package option will always have |
163 | | /// the following format: |
164 | | /// PackageFullName:OptionName=Value |
165 | | /// And can be specified from the command line like this: |
166 | | /// -analyzer-config PackageFullName:OptionName=Value |
167 | | /// |
168 | | /// Options for unknown packages, or unknown options for a given package, or |
169 | | /// invalid value types for that given option are reported as an error in |
170 | | /// non-compatibility mode. |
171 | | void addPackageOption(StringRef OptionType, StringRef PackageFullName, |
172 | | StringRef OptionName, StringRef DefaultValStr, |
173 | | StringRef Description, StringRef DevelopmentStatus, |
174 | | bool IsHidden = false); |
175 | | |
176 | | // FIXME: This *really* should be added to the frontend flag descriptions. |
177 | | /// Initializes a CheckerManager by calling the initialization functions for |
178 | | /// all checkers specified by the given CheckerOptInfo list. The order of this |
179 | | /// list is significant; later options can be used to reverse earlier ones. |
180 | | /// This can be used to exclude certain checkers in an included package. |
181 | | void initializeManager(CheckerManager &CheckerMgr) const; |
182 | | |
183 | | /// Check if every option corresponds to a specific checker or package. |
184 | | void validateCheckerOptions() const; |
185 | | |
186 | | private: |
187 | | template <bool IsWeak> void resolveDependencies(); |
188 | | void resolveCheckerAndPackageOptions(); |
189 | | |
190 | | CheckerRegistryData &Data; |
191 | | |
192 | | DiagnosticsEngine &Diags; |
193 | | AnalyzerOptions &AnOpts; |
194 | | }; |
195 | | |
196 | | } // namespace ento |
197 | | } // namespace clang |
198 | | |
199 | | #endif // LLVM_CLANG_STATICANALYZER_FRONTEND_CHECKERREGISTRY_H |