contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

   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 = 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
  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::mayInlineCXXAllocator() {
 138   return getBooleanOption(InlineCXXAllocator,
 139                           "c++-allocator-inlining",
 140                           /*Default=*/false);
 141 }
 142
 143 bool AnalyzerOptions::mayInlineCXXContainerMethods() {
 144   return getBooleanOption(InlineCXXContainerMethods,
 145                           "c++-container-inlining",
 146                           /*Default=*/false);
 147 }
 148
 149 bool AnalyzerOptions::mayInlineCXXSharedPtrDtor() {
 150   return getBooleanOption(InlineCXXSharedPtrDtor,
 151                           "c++-shared_ptr-inlining",
 152                           /*Default=*/false);
 153 }
 154
 155
 156 bool AnalyzerOptions::mayInlineObjCMethod() {
 157   return getBooleanOption(ObjCInliningMode,
 158                           "objc-inlining",
 159                           /* Default = */ true);
 160 }
 161
 162 bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
 163   return getBooleanOption(SuppressNullReturnPaths,
 164                           "suppress-null-return-paths",
 165                           /* Default = */ true);
 166 }
 167
 168 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
 169   return getBooleanOption(AvoidSuppressingNullArgumentPaths,
 170                           "avoid-suppressing-null-argument-paths",
 171                           /* Default = */ false);
 172 }
 173
 174 bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() {
 175   return getBooleanOption(SuppressInlinedDefensiveChecks,
 176                           "suppress-inlined-defensive-checks",
 177                           /* Default = */ true);
 178 }
 179
 180 bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() {
 181   return getBooleanOption(SuppressFromCXXStandardLibrary,
 182                           "suppress-c++-stdlib",
 183                           /* Default = */ false);
 184 }
 185
 186 bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() {
 187   return getBooleanOption(ReportIssuesInMainSourceFile,
 188                           "report-in-main-source-file",
 189                           /* Default = */ false);
 190 }
 191
 192
 193 bool AnalyzerOptions::shouldWriteStableReportFilename() {
 194   return getBooleanOption(StableReportFilename,
 195                           "stable-report-filename",
 196                           /* Default = */ false);
 197 }
 198
 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
 212 unsigned AnalyzerOptions::getAlwaysInlineSize() {
 213   if (!AlwaysInlineSize.hasValue())
 214     AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
 215   return AlwaysInlineSize.getValue();
 216 }
 217
 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
 239 unsigned AnalyzerOptions::getGraphTrimInterval() {
 240   if (!GraphTrimInterval.hasValue())
 241     GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);
 242   return GraphTrimInterval.getValue();
 243 }
 244
 245 unsigned AnalyzerOptions::getMaxTimesInlineLarge() {
 246   if (!MaxTimesInlineLarge.hasValue())
 247     MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);
 248   return MaxTimesInlineLarge.getValue();
 249 }
 250
 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
 270 bool AnalyzerOptions::shouldSynthesizeBodies() {
 271   return getBooleanOption("faux-bodies", true);
 272 }
 273
 274 bool AnalyzerOptions::shouldPrunePaths() {
 275   return getBooleanOption("prune-paths", true);
 276 }
 277
 278 bool AnalyzerOptions::shouldConditionalizeStaticInitializers() {
 279   return getBooleanOption("cfg-conditional-static-initializers", true);
 280 }
 281