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 "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include "llvm/Support/raw_ostream.h"
20
21 using namespace clang;
22 using namespace llvm;
23
getUserMode()24 AnalyzerOptions::UserModeKind AnalyzerOptions::getUserMode() {
25 if (UserMode == UMK_NotSet) {
26 StringRef ModeStr(Config.GetOrCreateValue("mode", "deep").getValue());
27 UserMode = llvm::StringSwitch<UserModeKind>(ModeStr)
28 .Case("shallow", UMK_Shallow)
29 .Case("deep", UMK_Deep)
30 .Default(UMK_NotSet);
31 assert(UserMode != UMK_NotSet && "User mode is invalid.");
32 }
33 return UserMode;
34 }
35
getIPAMode()36 IPAKind AnalyzerOptions::getIPAMode() {
37 if (IPAMode == IPAK_NotSet) {
38
39 // Use the User Mode to set the default IPA value.
40 // Note, we have to add the string to the Config map for the ConfigDumper
41 // checker to function properly.
42 const char *DefaultIPA = nullptr;
43 UserModeKind HighLevelMode = getUserMode();
44 if (HighLevelMode == UMK_Shallow)
45 DefaultIPA = "inlining";
46 else if (HighLevelMode == UMK_Deep)
47 DefaultIPA = "dynamic-bifurcate";
48 assert(DefaultIPA);
49
50 // Lookup the ipa configuration option, use the default from User Mode.
51 StringRef ModeStr(Config.GetOrCreateValue("ipa", DefaultIPA).getValue());
52 IPAKind IPAConfig = llvm::StringSwitch<IPAKind>(ModeStr)
53 .Case("none", IPAK_None)
54 .Case("basic-inlining", IPAK_BasicInlining)
55 .Case("inlining", IPAK_Inlining)
56 .Case("dynamic", IPAK_DynamicDispatch)
57 .Case("dynamic-bifurcate", IPAK_DynamicDispatchBifurcate)
58 .Default(IPAK_NotSet);
59 assert(IPAConfig != IPAK_NotSet && "IPA Mode is invalid.");
60
61 // Set the member variable.
62 IPAMode = IPAConfig;
63 }
64
65 return IPAMode;
66 }
67
68 bool
mayInlineCXXMemberFunction(CXXInlineableMemberKind K)69 AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) {
70 if (getIPAMode() < IPAK_Inlining)
71 return false;
72
73 if (!CXXMemberInliningMode) {
74 static const char *ModeKey = "c++-inlining";
75
76 StringRef ModeStr(Config.GetOrCreateValue(ModeKey,
77 "destructors").getValue());
78
79 CXXInlineableMemberKind &MutableMode =
80 const_cast<CXXInlineableMemberKind &>(CXXMemberInliningMode);
81
82 MutableMode = llvm::StringSwitch<CXXInlineableMemberKind>(ModeStr)
83 .Case("constructors", CIMK_Constructors)
84 .Case("destructors", CIMK_Destructors)
85 .Case("none", CIMK_None)
86 .Case("methods", CIMK_MemberFunctions)
87 .Default(CXXInlineableMemberKind());
88
89 if (!MutableMode) {
90 // FIXME: We should emit a warning here about an unknown inlining kind,
91 // but the AnalyzerOptions doesn't have access to a diagnostic engine.
92 MutableMode = CIMK_None;
93 }
94 }
95
96 return CXXMemberInliningMode >= K;
97 }
98
toString(bool b)99 static StringRef toString(bool b) { return b ? "true" : "false"; }
100
getBooleanOption(StringRef Name,bool DefaultVal)101 bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal) {
102 // FIXME: We should emit a warning here if the value is something other than
103 // "true", "false", or the empty string (meaning the default value),
104 // but the AnalyzerOptions doesn't have access to a diagnostic engine.
105 StringRef V(Config.GetOrCreateValue(Name, toString(DefaultVal)).getValue());
106 return llvm::StringSwitch<bool>(V)
107 .Case("true", true)
108 .Case("false", false)
109 .Default(DefaultVal);
110 }
111
getBooleanOption(Optional<bool> & V,StringRef Name,bool DefaultVal)112 bool AnalyzerOptions::getBooleanOption(Optional<bool> &V, StringRef Name,
113 bool DefaultVal) {
114 if (!V.hasValue())
115 V = getBooleanOption(Name, DefaultVal);
116 return V.getValue();
117 }
118
includeTemporaryDtorsInCFG()119 bool AnalyzerOptions::includeTemporaryDtorsInCFG() {
120 return getBooleanOption(IncludeTemporaryDtorsInCFG,
121 "cfg-temporary-dtors",
122 /* Default = */ false);
123 }
124
mayInlineCXXStandardLibrary()125 bool AnalyzerOptions::mayInlineCXXStandardLibrary() {
126 return getBooleanOption(InlineCXXStandardLibrary,
127 "c++-stdlib-inlining",
128 /*Default=*/true);
129 }
130
mayInlineTemplateFunctions()131 bool AnalyzerOptions::mayInlineTemplateFunctions() {
132 return getBooleanOption(InlineTemplateFunctions,
133 "c++-template-inlining",
134 /*Default=*/true);
135 }
136
mayInlineCXXAllocator()137 bool AnalyzerOptions::mayInlineCXXAllocator() {
138 return getBooleanOption(InlineCXXAllocator,
139 "c++-allocator-inlining",
140 /*Default=*/false);
141 }
142
mayInlineCXXContainerMethods()143 bool AnalyzerOptions::mayInlineCXXContainerMethods() {
144 return getBooleanOption(InlineCXXContainerMethods,
145 "c++-container-inlining",
146 /*Default=*/false);
147 }
148
mayInlineCXXSharedPtrDtor()149 bool AnalyzerOptions::mayInlineCXXSharedPtrDtor() {
150 return getBooleanOption(InlineCXXSharedPtrDtor,
151 "c++-shared_ptr-inlining",
152 /*Default=*/false);
153 }
154
155
mayInlineObjCMethod()156 bool AnalyzerOptions::mayInlineObjCMethod() {
157 return getBooleanOption(ObjCInliningMode,
158 "objc-inlining",
159 /* Default = */ true);
160 }
161
shouldSuppressNullReturnPaths()162 bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
163 return getBooleanOption(SuppressNullReturnPaths,
164 "suppress-null-return-paths",
165 /* Default = */ true);
166 }
167
shouldAvoidSuppressingNullArgumentPaths()168 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
169 return getBooleanOption(AvoidSuppressingNullArgumentPaths,
170 "avoid-suppressing-null-argument-paths",
171 /* Default = */ false);
172 }
173
shouldSuppressInlinedDefensiveChecks()174 bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() {
175 return getBooleanOption(SuppressInlinedDefensiveChecks,
176 "suppress-inlined-defensive-checks",
177 /* Default = */ true);
178 }
179
shouldSuppressFromCXXStandardLibrary()180 bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() {
181 return getBooleanOption(SuppressFromCXXStandardLibrary,
182 "suppress-c++-stdlib",
183 /* Default = */ false);
184 }
185
shouldReportIssuesInMainSourceFile()186 bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() {
187 return getBooleanOption(ReportIssuesInMainSourceFile,
188 "report-in-main-source-file",
189 /* Default = */ false);
190 }
191
192
shouldWriteStableReportFilename()193 bool AnalyzerOptions::shouldWriteStableReportFilename() {
194 return getBooleanOption(StableReportFilename,
195 "stable-report-filename",
196 /* Default = */ false);
197 }
198
getOptionAsInteger(StringRef Name,int DefaultVal)199 int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) {
200 SmallString<10> StrBuf;
201 llvm::raw_svector_ostream OS(StrBuf);
202 OS << DefaultVal;
203
204 StringRef V(Config.GetOrCreateValue(Name, OS.str()).getValue());
205 int Res = DefaultVal;
206 bool b = V.getAsInteger(10, Res);
207 assert(!b && "analyzer-config option should be numeric");
208 (void) b;
209 return Res;
210 }
211
getAlwaysInlineSize()212 unsigned AnalyzerOptions::getAlwaysInlineSize() {
213 if (!AlwaysInlineSize.hasValue())
214 AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
215 return AlwaysInlineSize.getValue();
216 }
217
getMaxInlinableSize()218 unsigned AnalyzerOptions::getMaxInlinableSize() {
219 if (!MaxInlinableSize.hasValue()) {
220
221 int DefaultValue = 0;
222 UserModeKind HighLevelMode = getUserMode();
223 switch (HighLevelMode) {
224 default:
225 llvm_unreachable("Invalid mode.");
226 case UMK_Shallow:
227 DefaultValue = 4;
228 break;
229 case UMK_Deep:
230 DefaultValue = 50;
231 break;
232 }
233
234 MaxInlinableSize = getOptionAsInteger("max-inlinable-size", DefaultValue);
235 }
236 return MaxInlinableSize.getValue();
237 }
238
getGraphTrimInterval()239 unsigned AnalyzerOptions::getGraphTrimInterval() {
240 if (!GraphTrimInterval.hasValue())
241 GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);
242 return GraphTrimInterval.getValue();
243 }
244
getMaxTimesInlineLarge()245 unsigned AnalyzerOptions::getMaxTimesInlineLarge() {
246 if (!MaxTimesInlineLarge.hasValue())
247 MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);
248 return MaxTimesInlineLarge.getValue();
249 }
250
getMaxNodesPerTopLevelFunction()251 unsigned AnalyzerOptions::getMaxNodesPerTopLevelFunction() {
252 if (!MaxNodesPerTopLevelFunction.hasValue()) {
253 int DefaultValue = 0;
254 UserModeKind HighLevelMode = getUserMode();
255 switch (HighLevelMode) {
256 default:
257 llvm_unreachable("Invalid mode.");
258 case UMK_Shallow:
259 DefaultValue = 75000;
260 break;
261 case UMK_Deep:
262 DefaultValue = 150000;
263 break;
264 }
265 MaxNodesPerTopLevelFunction = getOptionAsInteger("max-nodes", DefaultValue);
266 }
267 return MaxNodesPerTopLevelFunction.getValue();
268 }
269
shouldSynthesizeBodies()270 bool AnalyzerOptions::shouldSynthesizeBodies() {
271 return getBooleanOption("faux-bodies", true);
272 }
273
shouldPrunePaths()274 bool AnalyzerOptions::shouldPrunePaths() {
275 return getBooleanOption("prune-paths", true);
276 }
277
shouldConditionalizeStaticInitializers()278 bool AnalyzerOptions::shouldConditionalizeStaticInitializers() {
279 return getBooleanOption("cfg-conditional-static-initializers", true);
280 }
281
282