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 
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 
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 = 0;
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
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 
99 static StringRef toString(bool b) { return b ? "true" : "false"; }
100 
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 
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 
119 bool AnalyzerOptions::includeTemporaryDtorsInCFG() {
120   return getBooleanOption(IncludeTemporaryDtorsInCFG,
121                           "cfg-temporary-dtors",
122                           /* Default = */ false);
123 }
124 
125 bool AnalyzerOptions::mayInlineCXXStandardLibrary() {
126   return getBooleanOption(InlineCXXStandardLibrary,
127                           "c++-stdlib-inlining",
128                           /*Default=*/true);
129 }
130 
131 bool AnalyzerOptions::mayInlineTemplateFunctions() {
132   return getBooleanOption(InlineTemplateFunctions,
133                           "c++-template-inlining",
134                           /*Default=*/true);
135 }
136 
137 bool AnalyzerOptions::mayInlineCXXContainerCtorsAndDtors() {
138   return getBooleanOption(InlineCXXContainerCtorsAndDtors,
139                           "c++-container-inlining",
140                           /*Default=*/false);
141 }
142 
143 
144 bool AnalyzerOptions::mayInlineObjCMethod() {
145   return getBooleanOption(ObjCInliningMode,
146                           "objc-inlining",
147                           /* Default = */ true);
148 }
149 
150 bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
151   return getBooleanOption(SuppressNullReturnPaths,
152                           "suppress-null-return-paths",
153                           /* Default = */ true);
154 }
155 
156 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
157   return getBooleanOption(AvoidSuppressingNullArgumentPaths,
158                           "avoid-suppressing-null-argument-paths",
159                           /* Default = */ false);
160 }
161 
162 bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() {
163   return getBooleanOption(SuppressInlinedDefensiveChecks,
164                           "suppress-inlined-defensive-checks",
165                           /* Default = */ true);
166 }
167 
168 bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() {
169   return getBooleanOption(SuppressFromCXXStandardLibrary,
170                           "suppress-c++-stdlib",
171                           /* Default = */ false);
172 }
173 
174 int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) {
175   SmallString<10> StrBuf;
176   llvm::raw_svector_ostream OS(StrBuf);
177   OS << DefaultVal;
178 
179   StringRef V(Config.GetOrCreateValue(Name, OS.str()).getValue());
180   int Res = DefaultVal;
181   bool b = V.getAsInteger(10, Res);
182   assert(!b && "analyzer-config option should be numeric");
183   (void) b;
184   return Res;
185 }
186 
187 unsigned AnalyzerOptions::getAlwaysInlineSize() {
188   if (!AlwaysInlineSize.hasValue())
189     AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
190   return AlwaysInlineSize.getValue();
191 }
192 
193 unsigned AnalyzerOptions::getMaxInlinableSize() {
194   if (!MaxInlinableSize.hasValue()) {
195 
196     int DefaultValue = 0;
197     UserModeKind HighLevelMode = getUserMode();
198     switch (HighLevelMode) {
199       default:
200         llvm_unreachable("Invalid mode.");
201       case UMK_Shallow:
202         DefaultValue = 4;
203         break;
204       case UMK_Deep:
205         DefaultValue = 50;
206         break;
207     }
208 
209     MaxInlinableSize = getOptionAsInteger("max-inlinable-size", DefaultValue);
210   }
211   return MaxInlinableSize.getValue();
212 }
213 
214 unsigned AnalyzerOptions::getGraphTrimInterval() {
215   if (!GraphTrimInterval.hasValue())
216     GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);
217   return GraphTrimInterval.getValue();
218 }
219 
220 unsigned AnalyzerOptions::getMaxTimesInlineLarge() {
221   if (!MaxTimesInlineLarge.hasValue())
222     MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);
223   return MaxTimesInlineLarge.getValue();
224 }
225 
226 unsigned AnalyzerOptions::getMaxNodesPerTopLevelFunction() {
227   if (!MaxNodesPerTopLevelFunction.hasValue()) {
228     int DefaultValue = 0;
229     UserModeKind HighLevelMode = getUserMode();
230     switch (HighLevelMode) {
231       default:
232         llvm_unreachable("Invalid mode.");
233       case UMK_Shallow:
234         DefaultValue = 75000;
235         break;
236       case UMK_Deep:
237         DefaultValue = 150000;
238         break;
239     }
240     MaxNodesPerTopLevelFunction = getOptionAsInteger("max-nodes", DefaultValue);
241   }
242   return MaxNodesPerTopLevelFunction.getValue();
243 }
244 
245 bool AnalyzerOptions::shouldSynthesizeBodies() {
246   return getBooleanOption("faux-bodies", true);
247 }
248 
249 bool AnalyzerOptions::shouldPrunePaths() {
250   return getBooleanOption("prune-paths", true);
251 }
252 
253 bool AnalyzerOptions::shouldConditionalizeStaticInitializers() {
254   return getBooleanOption("cfg-conditional-static-initializers", true);
255 }
256 
257