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 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 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 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 103 static StringRef toString(bool b) { return b ? "true" : "false"; } 104 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 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 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 150 bool AnalyzerOptions::includeTemporaryDtorsInCFG() { 151 return getBooleanOption(IncludeTemporaryDtorsInCFG, 152 "cfg-temporary-dtors", 153 /* Default = */ false); 154 } 155 156 bool AnalyzerOptions::mayInlineCXXStandardLibrary() { 157 return getBooleanOption(InlineCXXStandardLibrary, 158 "c++-stdlib-inlining", 159 /*Default=*/true); 160 } 161 162 bool AnalyzerOptions::mayInlineTemplateFunctions() { 163 return getBooleanOption(InlineTemplateFunctions, 164 "c++-template-inlining", 165 /*Default=*/true); 166 } 167 168 bool AnalyzerOptions::mayInlineCXXAllocator() { 169 return getBooleanOption(InlineCXXAllocator, 170 "c++-allocator-inlining", 171 /*Default=*/false); 172 } 173 174 bool AnalyzerOptions::mayInlineCXXContainerMethods() { 175 return getBooleanOption(InlineCXXContainerMethods, 176 "c++-container-inlining", 177 /*Default=*/false); 178 } 179 180 bool AnalyzerOptions::mayInlineCXXSharedPtrDtor() { 181 return getBooleanOption(InlineCXXSharedPtrDtor, 182 "c++-shared_ptr-inlining", 183 /*Default=*/false); 184 } 185 186 187 bool AnalyzerOptions::mayInlineObjCMethod() { 188 return getBooleanOption(ObjCInliningMode, 189 "objc-inlining", 190 /* Default = */ true); 191 } 192 193 bool AnalyzerOptions::shouldSuppressNullReturnPaths() { 194 return getBooleanOption(SuppressNullReturnPaths, 195 "suppress-null-return-paths", 196 /* Default = */ true); 197 } 198 199 bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() { 200 return getBooleanOption(AvoidSuppressingNullArgumentPaths, 201 "avoid-suppressing-null-argument-paths", 202 /* Default = */ false); 203 } 204 205 bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() { 206 return getBooleanOption(SuppressInlinedDefensiveChecks, 207 "suppress-inlined-defensive-checks", 208 /* Default = */ true); 209 } 210 211 bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() { 212 return getBooleanOption(SuppressFromCXXStandardLibrary, 213 "suppress-c++-stdlib", 214 /* Default = */ false); 215 } 216 217 bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() { 218 return getBooleanOption(ReportIssuesInMainSourceFile, 219 "report-in-main-source-file", 220 /* Default = */ false); 221 } 222 223 224 bool AnalyzerOptions::shouldWriteStableReportFilename() { 225 return getBooleanOption(StableReportFilename, 226 "stable-report-filename", 227 /* Default = */ false); 228 } 229 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 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 259 unsigned AnalyzerOptions::getAlwaysInlineSize() { 260 if (!AlwaysInlineSize.hasValue()) 261 AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3); 262 return AlwaysInlineSize.getValue(); 263 } 264 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 286 unsigned AnalyzerOptions::getGraphTrimInterval() { 287 if (!GraphTrimInterval.hasValue()) 288 GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000); 289 return GraphTrimInterval.getValue(); 290 } 291 292 unsigned AnalyzerOptions::getMaxTimesInlineLarge() { 293 if (!MaxTimesInlineLarge.hasValue()) 294 MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32); 295 return MaxTimesInlineLarge.getValue(); 296 } 297 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 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 324 bool AnalyzerOptions::shouldSynthesizeBodies() { 325 return getBooleanOption("faux-bodies", true); 326 } 327 328 bool AnalyzerOptions::shouldPrunePaths() { 329 return getBooleanOption("prune-paths", true); 330 } 331 332 bool AnalyzerOptions::shouldConditionalizeStaticInitializers() { 333 return getBooleanOption("cfg-conditional-static-initializers", true); 334 } 335 336 bool AnalyzerOptions::shouldInlineLambdas() { 337 if (!InlineLambdas.hasValue()) 338 InlineLambdas = getBooleanOption("inline-lambdas", /*Default=*/true); 339 return InlineLambdas.getValue(); 340 } 341 342 bool AnalyzerOptions::shouldWidenLoops() { 343 if (!WidenLoops.hasValue()) 344 WidenLoops = getBooleanOption("widen-loops", /*Default=*/false); 345 return WidenLoops.getValue(); 346 } 347
