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