• Home
  • History
  • Annotate
  • 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