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/raw_ostream.h"
19 
20 using namespace clang;
21 using namespace llvm;
22 
23 AnalyzerOptions::UserModeKind AnalyzerOptions::getUserMode() {
24   if (UserMode == UMK_NotSet) {
25     StringRef ModeStr(Config.GetOrCreateValue("mode", "deep").getValue());
26     UserMode = llvm::StringSwitch<UserModeKind>(ModeStr)
27       .Case("shallow", UMK_Shallow)
28       .Case("deep", UMK_Deep)
29       .Default(UMK_NotSet);
30     assert(UserMode != UMK_NotSet && "User mode is not set or invalid.");
31   }
32   return UserMode;
33 }
34 
35 IPAKind AnalyzerOptions::getIPAMode() {
36   if (IPAMode == IPAK_NotSet) {
37 
38     // Use the User Mode to set the default IPA value.
39     // Note, we have to add the string to the Config map for the ConfigDumper
40     // checker to function properly.
41     const char *DefaultIPA = 0;
42     UserModeKind HighLevelMode = getUserMode();
43     if (HighLevelMode == UMK_Shallow)
44       DefaultIPA = "basic-inlining";
45     else if (HighLevelMode == UMK_Deep)
46       DefaultIPA = "dynamic-bifurcate";
47     assert(DefaultIPA);
48 
49     // Lookup the ipa configuration option, use the default from User Mode.
50     StringRef ModeStr(Config.GetOrCreateValue("ipa", DefaultIPA).getValue());
51     IPAKind IPAConfig = llvm::StringSwitch<IPAKind>(ModeStr)
52             .Case("none", IPAK_None)
53             .Case("basic-inlining", IPAK_BasicInlining)
54             .Case("inlining", IPAK_Inlining)
55             .Case("dynamic", IPAK_DynamicDispatch)
56             .Case("dynamic-bifurcate", IPAK_DynamicDispatchBifurcate)
57             .Default(IPAK_NotSet);
58     assert(IPAConfig != IPAK_NotSet && "IPA Mode is not set or invalid.");
59 
60     // Set the member variable.
61     IPAMode = IPAConfig;
62   }
63 
64   return IPAMode;
65 }
66 
67 bool
68 AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) {
69   if (getIPAMode() < IPAK_Inlining)
70     return false;
71 
72   if (!CXXMemberInliningMode) {
73     static const char *ModeKey = "c++-inlining";
74 
75     StringRef ModeStr(Config.GetOrCreateValue(ModeKey,
76                                               "methods").getValue());
77 
78     CXXInlineableMemberKind &MutableMode =
79       const_cast<CXXInlineableMemberKind &>(CXXMemberInliningMode);
80 
81     MutableMode = llvm::StringSwitch<CXXInlineableMemberKind>(ModeStr)
82       .Case("constructors", CIMK_Constructors)
83       .Case("destructors", CIMK_Destructors)
84       .Case("none", CIMK_None)
85       .Case("methods", CIMK_MemberFunctions)
86       .Default(CXXInlineableMemberKind());
87 
88     if (!MutableMode) {
89       // FIXME: We should emit a warning here about an unknown inlining kind,
90       // but the AnalyzerOptions doesn't have access to a diagnostic engine.
91       MutableMode = CIMK_None;
92     }
93   }
94 
95   return CXXMemberInliningMode >= K;
96 }
97 
98 static StringRef toString(bool b) { return b ? "true" : "false"; }
99 
100 bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal) {
101   // FIXME: We should emit a warning here if the value is something other than
102   // "true", "false", or the empty string (meaning the default value),
103   // but the AnalyzerOptions doesn't have access to a diagnostic engine.
104   StringRef V(Config.GetOrCreateValue(Name, toString(DefaultVal)).getValue());
105   return llvm::StringSwitch<bool>(V)
106       .Case("true", true)
107       .Case("false", false)
108       .Default(DefaultVal);
109 }
110 
111 bool AnalyzerOptions::getBooleanOption(llvm::Optional<bool> &V,
112                                        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::mayInlineObjCMethod() {
138   return getBooleanOption(ObjCInliningMode,
139                           "objc-inlining",
140                           /* Default = */ true);
141 }
142 
143 bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
144   return getBooleanOption(SuppressNullReturnPaths,
145                           "suppress-null-return-paths",
146                           /* Default = */ true);
147 }
148 
149 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
150   return getBooleanOption(AvoidSuppressingNullArgumentPaths,
151                           "avoid-suppressing-null-argument-paths",
152                           /* Default = */ false);
153 }
154 
155 int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) {
156   SmallString<10> StrBuf;
157   llvm::raw_svector_ostream OS(StrBuf);
158   OS << DefaultVal;
159 
160   StringRef V(Config.GetOrCreateValue(Name, OS.str()).getValue());
161   int Res = DefaultVal;
162   bool b = V.getAsInteger(10, Res);
163   assert(!b && "analyzer-config option should be numeric");
164   (void) b;
165   return Res;
166 }
167 
168 unsigned AnalyzerOptions::getAlwaysInlineSize() {
169   if (!AlwaysInlineSize.hasValue())
170     AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
171   return AlwaysInlineSize.getValue();
172 }
173 
174 unsigned AnalyzerOptions::getGraphTrimInterval() {
175   if (!GraphTrimInterval.hasValue())
176     GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);
177   return GraphTrimInterval.getValue();
178 }
179 
180 unsigned AnalyzerOptions::getMaxTimesInlineLarge() {
181   if (!MaxTimesInlineLarge.hasValue())
182     MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);
183   return MaxTimesInlineLarge.getValue();
184 }
185 
186 bool AnalyzerOptions::shouldSynthesizeBodies() {
187   return getBooleanOption("faux-bodies", true);
188 }
189 
190 bool AnalyzerOptions::shouldPrunePaths() {
191   return getBooleanOption("prune-paths", true);
192 }
193