• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- AnalyzerOptions.cpp - Analysis Engine Options -----------*- C++ -*-===//
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 // This file contains special accessors for analyzer configuration options
11 // with string representations.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
16 #include "clang/StaticAnalyzer/Core/Checker.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/raw_ostream.h"
21 
22 using namespace clang;
23 using namespace ento;
24 using namespace llvm;
25 
getUserMode()26 AnalyzerOptions::UserModeKind AnalyzerOptions::getUserMode() {
27   if (UserMode == UMK_NotSet) {
28     StringRef ModeStr =
29         Config.insert(std::make_pair("mode", "deep")).first->second;
30     UserMode = llvm::StringSwitch<UserModeKind>(ModeStr)
31       .Case("shallow", UMK_Shallow)
32       .Case("deep", UMK_Deep)
33       .Default(UMK_NotSet);
34     assert(UserMode != UMK_NotSet && "User mode is invalid.");
35   }
36   return UserMode;
37 }
38 
getIPAMode()39 IPAKind AnalyzerOptions::getIPAMode() {
40   if (IPAMode == IPAK_NotSet) {
41 
42     // Use the User Mode to set the default IPA value.
43     // Note, we have to add the string to the Config map for the ConfigDumper
44     // checker to function properly.
45     const char *DefaultIPA = nullptr;
46     UserModeKind HighLevelMode = getUserMode();
47     if (HighLevelMode == UMK_Shallow)
48       DefaultIPA = "inlining";
49     else if (HighLevelMode == UMK_Deep)
50       DefaultIPA = "dynamic-bifurcate";
51     assert(DefaultIPA);
52 
53     // Lookup the ipa configuration option, use the default from User Mode.
54     StringRef ModeStr =
55         Config.insert(std::make_pair("ipa", DefaultIPA)).first->second;
56     IPAKind IPAConfig = llvm::StringSwitch<IPAKind>(ModeStr)
57             .Case("none", IPAK_None)
58             .Case("basic-inlining", IPAK_BasicInlining)
59             .Case("inlining", IPAK_Inlining)
60             .Case("dynamic", IPAK_DynamicDispatch)
61             .Case("dynamic-bifurcate", IPAK_DynamicDispatchBifurcate)
62             .Default(IPAK_NotSet);
63     assert(IPAConfig != IPAK_NotSet && "IPA Mode is invalid.");
64 
65     // Set the member variable.
66     IPAMode = IPAConfig;
67   }
68 
69   return IPAMode;
70 }
71 
72 bool
mayInlineCXXMemberFunction(CXXInlineableMemberKind K)73 AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) {
74   if (getIPAMode() < IPAK_Inlining)
75     return false;
76 
77   if (!CXXMemberInliningMode) {
78     static const char *ModeKey = "c++-inlining";
79 
80     StringRef ModeStr =
81         Config.insert(std::make_pair(ModeKey, "destructors")).first->second;
82 
83     CXXInlineableMemberKind &MutableMode =
84       const_cast<CXXInlineableMemberKind &>(CXXMemberInliningMode);
85 
86     MutableMode = llvm::StringSwitch<CXXInlineableMemberKind>(ModeStr)
87       .Case("constructors", CIMK_Constructors)
88       .Case("destructors", CIMK_Destructors)
89       .Case("none", CIMK_None)
90       .Case("methods", CIMK_MemberFunctions)
91       .Default(CXXInlineableMemberKind());
92 
93     if (!MutableMode) {
94       // FIXME: We should emit a warning here about an unknown inlining kind,
95       // but the AnalyzerOptions doesn't have access to a diagnostic engine.
96       MutableMode = CIMK_None;
97     }
98   }
99 
100   return CXXMemberInliningMode >= K;
101 }
102 
toString(bool b)103 static StringRef toString(bool b) { return b ? "true" : "false"; }
104 
getCheckerOption(StringRef CheckerName,StringRef OptionName,StringRef Default,bool SearchInParents)105 StringRef AnalyzerOptions::getCheckerOption(StringRef CheckerName,
106                                             StringRef OptionName,
107                                             StringRef Default,
108                                             bool SearchInParents) {
109   // Search for a package option if the option for the checker is not specified
110   // and search in parents is enabled.
111   ConfigTable::const_iterator E = Config.end();
112   do {
113     ConfigTable::const_iterator I =
114         Config.find((Twine(CheckerName) + ":" + OptionName).str());
115     if (I != E)
116       return StringRef(I->getValue());
117     size_t Pos = CheckerName.rfind('.');
118     if (Pos == StringRef::npos)
119       return Default;
120     CheckerName = CheckerName.substr(0, Pos);
121   } while (!CheckerName.empty() && SearchInParents);
122   return Default;
123 }
124 
getBooleanOption(StringRef Name,bool DefaultVal,const CheckerBase * C,bool SearchInParents)125 bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal,
126                                        const CheckerBase *C,
127                                        bool SearchInParents) {
128   // FIXME: We should emit a warning here if the value is something other than
129   // "true", "false", or the empty string (meaning the default value),
130   // but the AnalyzerOptions doesn't have access to a diagnostic engine.
131   StringRef Default = toString(DefaultVal);
132   StringRef V =
133       C ? getCheckerOption(C->getTagDescription(), Name, Default,
134                            SearchInParents)
135         : StringRef(Config.insert(std::make_pair(Name, Default)).first->second);
136   return llvm::StringSwitch<bool>(V)
137       .Case("true", true)
138       .Case("false", false)
139       .Default(DefaultVal);
140 }
141 
getBooleanOption(Optional<bool> & V,StringRef Name,bool DefaultVal,const CheckerBase * C,bool SearchInParents)142 bool AnalyzerOptions::getBooleanOption(Optional<bool> &V, StringRef Name,
143                                        bool DefaultVal, const CheckerBase *C,
144                                        bool SearchInParents) {
145   if (!V.hasValue())
146     V = getBooleanOption(Name, DefaultVal, C, SearchInParents);
147   return V.getValue();
148 }
149 
includeTemporaryDtorsInCFG()150 bool AnalyzerOptions::includeTemporaryDtorsInCFG() {
151   return getBooleanOption(IncludeTemporaryDtorsInCFG,
152                           "cfg-temporary-dtors",
153                           /* Default = */ false);
154 }
155 
mayInlineCXXStandardLibrary()156 bool AnalyzerOptions::mayInlineCXXStandardLibrary() {
157   return getBooleanOption(InlineCXXStandardLibrary,
158                           "c++-stdlib-inlining",
159                           /*Default=*/true);
160 }
161 
mayInlineTemplateFunctions()162 bool AnalyzerOptions::mayInlineTemplateFunctions() {
163   return getBooleanOption(InlineTemplateFunctions,
164                           "c++-template-inlining",
165                           /*Default=*/true);
166 }
167 
mayInlineCXXAllocator()168 bool AnalyzerOptions::mayInlineCXXAllocator() {
169   return getBooleanOption(InlineCXXAllocator,
170                           "c++-allocator-inlining",
171                           /*Default=*/false);
172 }
173 
mayInlineCXXContainerMethods()174 bool AnalyzerOptions::mayInlineCXXContainerMethods() {
175   return getBooleanOption(InlineCXXContainerMethods,
176                           "c++-container-inlining",
177                           /*Default=*/false);
178 }
179 
mayInlineCXXSharedPtrDtor()180 bool AnalyzerOptions::mayInlineCXXSharedPtrDtor() {
181   return getBooleanOption(InlineCXXSharedPtrDtor,
182                           "c++-shared_ptr-inlining",
183                           /*Default=*/false);
184 }
185 
186 
mayInlineObjCMethod()187 bool AnalyzerOptions::mayInlineObjCMethod() {
188   return getBooleanOption(ObjCInliningMode,
189                           "objc-inlining",
190                           /* Default = */ true);
191 }
192 
shouldSuppressNullReturnPaths()193 bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
194   return getBooleanOption(SuppressNullReturnPaths,
195                           "suppress-null-return-paths",
196                           /* Default = */ true);
197 }
198 
shouldAvoidSuppressingNullArgumentPaths()199 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
200   return getBooleanOption(AvoidSuppressingNullArgumentPaths,
201                           "avoid-suppressing-null-argument-paths",
202                           /* Default = */ false);
203 }
204 
shouldSuppressInlinedDefensiveChecks()205 bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() {
206   return getBooleanOption(SuppressInlinedDefensiveChecks,
207                           "suppress-inlined-defensive-checks",
208                           /* Default = */ true);
209 }
210 
shouldSuppressFromCXXStandardLibrary()211 bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() {
212   return getBooleanOption(SuppressFromCXXStandardLibrary,
213                           "suppress-c++-stdlib",
214                           /* Default = */ false);
215 }
216 
shouldReportIssuesInMainSourceFile()217 bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() {
218   return getBooleanOption(ReportIssuesInMainSourceFile,
219                           "report-in-main-source-file",
220                           /* Default = */ false);
221 }
222 
223 
shouldWriteStableReportFilename()224 bool AnalyzerOptions::shouldWriteStableReportFilename() {
225   return getBooleanOption(StableReportFilename,
226                           "stable-report-filename",
227                           /* Default = */ false);
228 }
229 
getOptionAsInteger(StringRef Name,int DefaultVal,const CheckerBase * C,bool SearchInParents)230 int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal,
231                                         const CheckerBase *C,
232                                         bool SearchInParents) {
233   SmallString<10> StrBuf;
234   llvm::raw_svector_ostream OS(StrBuf);
235   OS << DefaultVal;
236 
237   StringRef V = C ? getCheckerOption(C->getTagDescription(), Name, OS.str(),
238                                      SearchInParents)
239                   : StringRef(Config.insert(std::make_pair(Name, OS.str()))
240                                   .first->second);
241 
242   int Res = DefaultVal;
243   bool b = V.getAsInteger(10, Res);
244   assert(!b && "analyzer-config option should be numeric");
245   (void)b;
246   return Res;
247 }
248 
getOptionAsString(StringRef Name,StringRef DefaultVal,const CheckerBase * C,bool SearchInParents)249 StringRef AnalyzerOptions::getOptionAsString(StringRef Name,
250                                              StringRef DefaultVal,
251                                              const CheckerBase *C,
252                                              bool SearchInParents) {
253   return C ? getCheckerOption(C->getTagDescription(), Name, DefaultVal,
254                               SearchInParents)
255            : StringRef(
256                  Config.insert(std::make_pair(Name, DefaultVal)).first->second);
257 }
258 
getAlwaysInlineSize()259 unsigned AnalyzerOptions::getAlwaysInlineSize() {
260   if (!AlwaysInlineSize.hasValue())
261     AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
262   return AlwaysInlineSize.getValue();
263 }
264 
getMaxInlinableSize()265 unsigned AnalyzerOptions::getMaxInlinableSize() {
266   if (!MaxInlinableSize.hasValue()) {
267 
268     int DefaultValue = 0;
269     UserModeKind HighLevelMode = getUserMode();
270     switch (HighLevelMode) {
271       default:
272         llvm_unreachable("Invalid mode.");
273       case UMK_Shallow:
274         DefaultValue = 4;
275         break;
276       case UMK_Deep:
277         DefaultValue = 50;
278         break;
279     }
280 
281     MaxInlinableSize = getOptionAsInteger("max-inlinable-size", DefaultValue);
282   }
283   return MaxInlinableSize.getValue();
284 }
285 
getGraphTrimInterval()286 unsigned AnalyzerOptions::getGraphTrimInterval() {
287   if (!GraphTrimInterval.hasValue())
288     GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);
289   return GraphTrimInterval.getValue();
290 }
291 
getMaxTimesInlineLarge()292 unsigned AnalyzerOptions::getMaxTimesInlineLarge() {
293   if (!MaxTimesInlineLarge.hasValue())
294     MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);
295   return MaxTimesInlineLarge.getValue();
296 }
297 
getMinCFGSizeTreatFunctionsAsLarge()298 unsigned AnalyzerOptions::getMinCFGSizeTreatFunctionsAsLarge() {
299   if (!MinCFGSizeTreatFunctionsAsLarge.hasValue())
300     MinCFGSizeTreatFunctionsAsLarge = getOptionAsInteger(
301       "min-cfg-size-treat-functions-as-large", 14);
302   return MinCFGSizeTreatFunctionsAsLarge.getValue();
303 }
304 
getMaxNodesPerTopLevelFunction()305 unsigned AnalyzerOptions::getMaxNodesPerTopLevelFunction() {
306   if (!MaxNodesPerTopLevelFunction.hasValue()) {
307     int DefaultValue = 0;
308     UserModeKind HighLevelMode = getUserMode();
309     switch (HighLevelMode) {
310       default:
311         llvm_unreachable("Invalid mode.");
312       case UMK_Shallow:
313         DefaultValue = 75000;
314         break;
315       case UMK_Deep:
316         DefaultValue = 150000;
317         break;
318     }
319     MaxNodesPerTopLevelFunction = getOptionAsInteger("max-nodes", DefaultValue);
320   }
321   return MaxNodesPerTopLevelFunction.getValue();
322 }
323 
shouldSynthesizeBodies()324 bool AnalyzerOptions::shouldSynthesizeBodies() {
325   return getBooleanOption("faux-bodies", true);
326 }
327 
shouldPrunePaths()328 bool AnalyzerOptions::shouldPrunePaths() {
329   return getBooleanOption("prune-paths", true);
330 }
331 
shouldConditionalizeStaticInitializers()332 bool AnalyzerOptions::shouldConditionalizeStaticInitializers() {
333   return getBooleanOption("cfg-conditional-static-initializers", true);
334 }
335 
shouldInlineLambdas()336 bool AnalyzerOptions::shouldInlineLambdas() {
337   if (!InlineLambdas.hasValue())
338     InlineLambdas = getBooleanOption("inline-lambdas", /*Default=*/true);
339   return InlineLambdas.getValue();
340 }
341 
shouldWidenLoops()342 bool AnalyzerOptions::shouldWidenLoops() {
343   if (!WidenLoops.hasValue())
344     WidenLoops = getBooleanOption("widen-loops", /*Default=*/false);
345   return WidenLoops.getValue();
346 }
347