AnalyzerOptions.cpp revision d95b70175646829c26344d5f0bda1ec3009f2a5b
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 "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 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::mayInlineCXXContainerCtorsAndDtors() { 138 return getBooleanOption(InlineCXXContainerCtorsAndDtors, 139 "c++-container-inlining", 140 /*Default=*/false); 141} 142 143 144bool AnalyzerOptions::mayInlineObjCMethod() { 145 return getBooleanOption(ObjCInliningMode, 146 "objc-inlining", 147 /* Default = */ true); 148} 149 150bool AnalyzerOptions::shouldSuppressNullReturnPaths() { 151 return getBooleanOption(SuppressNullReturnPaths, 152 "suppress-null-return-paths", 153 /* Default = */ true); 154} 155 156bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() { 157 return getBooleanOption(AvoidSuppressingNullArgumentPaths, 158 "avoid-suppressing-null-argument-paths", 159 /* Default = */ false); 160} 161 162bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() { 163 return getBooleanOption(SuppressInlinedDefensiveChecks, 164 "suppress-inlined-defensive-checks", 165 /* Default = */ true); 166} 167 168bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() { 169 return getBooleanOption(SuppressFromCXXStandardLibrary, 170 "suppress-c++-stdlib", 171 /* Default = */ false); 172} 173 174bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() { 175 return getBooleanOption(ReportIssuesInMainSourceFile, 176 "report-in-main-source-file", 177 /* Default = */ false); 178} 179 180int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) { 181 SmallString<10> StrBuf; 182 llvm::raw_svector_ostream OS(StrBuf); 183 OS << DefaultVal; 184 185 StringRef V(Config.GetOrCreateValue(Name, OS.str()).getValue()); 186 int Res = DefaultVal; 187 bool b = V.getAsInteger(10, Res); 188 assert(!b && "analyzer-config option should be numeric"); 189 (void) b; 190 return Res; 191} 192 193unsigned AnalyzerOptions::getAlwaysInlineSize() { 194 if (!AlwaysInlineSize.hasValue()) 195 AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3); 196 return AlwaysInlineSize.getValue(); 197} 198 199unsigned AnalyzerOptions::getMaxInlinableSize() { 200 if (!MaxInlinableSize.hasValue()) { 201 202 int DefaultValue = 0; 203 UserModeKind HighLevelMode = getUserMode(); 204 switch (HighLevelMode) { 205 default: 206 llvm_unreachable("Invalid mode."); 207 case UMK_Shallow: 208 DefaultValue = 4; 209 break; 210 case UMK_Deep: 211 DefaultValue = 50; 212 break; 213 } 214 215 MaxInlinableSize = getOptionAsInteger("max-inlinable-size", DefaultValue); 216 } 217 return MaxInlinableSize.getValue(); 218} 219 220unsigned AnalyzerOptions::getGraphTrimInterval() { 221 if (!GraphTrimInterval.hasValue()) 222 GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000); 223 return GraphTrimInterval.getValue(); 224} 225 226unsigned AnalyzerOptions::getMaxTimesInlineLarge() { 227 if (!MaxTimesInlineLarge.hasValue()) 228 MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32); 229 return MaxTimesInlineLarge.getValue(); 230} 231 232unsigned AnalyzerOptions::getMaxNodesPerTopLevelFunction() { 233 if (!MaxNodesPerTopLevelFunction.hasValue()) { 234 int DefaultValue = 0; 235 UserModeKind HighLevelMode = getUserMode(); 236 switch (HighLevelMode) { 237 default: 238 llvm_unreachable("Invalid mode."); 239 case UMK_Shallow: 240 DefaultValue = 75000; 241 break; 242 case UMK_Deep: 243 DefaultValue = 150000; 244 break; 245 } 246 MaxNodesPerTopLevelFunction = getOptionAsInteger("max-nodes", DefaultValue); 247 } 248 return MaxNodesPerTopLevelFunction.getValue(); 249} 250 251bool AnalyzerOptions::shouldSynthesizeBodies() { 252 return getBooleanOption("faux-bodies", true); 253} 254 255bool AnalyzerOptions::shouldPrunePaths() { 256 return getBooleanOption("prune-paths", true); 257} 258 259bool AnalyzerOptions::shouldConditionalizeStaticInitializers() { 260 return getBooleanOption("cfg-conditional-static-initializers", true); 261} 262 263