1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
//===-- AnalyzerOptions.cpp - Analysis Engine Options -----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains special accessors for analyzer configuration options
// with string representations.
//
//===----------------------------------------------------------------------===//
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
#include "llvm/ADT/StringSwitch.h"
using namespace clang;
using namespace llvm;
bool
AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const {
if (IPAMode < Inlining)
return false;
if (!CXXMemberInliningMode) {
static const char *ModeKey = "c++-inlining";
std::string ModeStr = Config.lookup(ModeKey);
CXXInlineableMemberKind &MutableMode =
const_cast<CXXInlineableMemberKind &>(CXXMemberInliningMode);
MutableMode = llvm::StringSwitch<CXXInlineableMemberKind>(ModeStr)
.Case("", CIMK_MemberFunctions)
.Case("constructors", CIMK_Constructors)
.Case("destructors", CIMK_Destructors)
.Case("none", CIMK_None)
.Case("methods", CIMK_MemberFunctions)
.Default(CXXInlineableMemberKind());
if (!MutableMode) {
// FIXME: We should emit a warning here about an unknown inlining kind,
// but the AnalyzerOptions doesn't have access to a diagnostic engine.
MutableMode = CIMK_None;
}
}
return CXXMemberInliningMode >= K;
}
bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal) const {
// FIXME: We should emit a warning here if the value is something other than
// "true", "false", or the empty string (meaning the default value),
// but the AnalyzerOptions doesn't have access to a diagnostic engine.
return llvm::StringSwitch<bool>(Config.lookup(Name))
.Case("true", true)
.Case("false", false)
.Default(DefaultVal);
}
bool AnalyzerOptions::includeTemporaryDtorsInCFG() const {
if (!IncludeTemporaryDtorsInCFG.hasValue())
const_cast<llvm::Optional<bool> &>(IncludeTemporaryDtorsInCFG) =
getBooleanOption("cfg-temporary-dtors", /*Default=*/false);
return *IncludeTemporaryDtorsInCFG;
}
bool AnalyzerOptions::mayInlineCXXStandardLibrary() const {
if (!InlineCXXStandardLibrary.hasValue())
const_cast<llvm::Optional<bool> &>(InlineCXXStandardLibrary) =
getBooleanOption("c++-stdlib-inlining", /*Default=*/false);
return *InlineCXXStandardLibrary;
}
bool AnalyzerOptions::mayInlineTemplateFunctions() const {
if (!InlineTemplateFunctions.hasValue())
const_cast<llvm::Optional<bool> &>(InlineTemplateFunctions) =
getBooleanOption("c++-template-inlining", /*Default=*/true);
return *InlineTemplateFunctions;
}
bool AnalyzerOptions::mayInlineObjCMethod() const {
if (!ObjCInliningMode.hasValue())
const_cast<llvm::Optional<bool> &>(ObjCInliningMode) =
getBooleanOption("objc-inlining", /*Default=*/true);
return *ObjCInliningMode;
}
int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal) const {
std::string OptStr = Config.lookup(Name);
if (OptStr.empty())
return DefaultVal;
int Res = DefaultVal;
assert(StringRef(OptStr).getAsInteger(10, Res) == false &&
"analyzer-config option should be numeric.");
return Res;
}
unsigned AnalyzerOptions::getAlwaysInlineSize() const {
if (!AlwaysInlineSize.hasValue()) {
unsigned DefaultSize = 3;
const_cast<Optional<unsigned> &>(AlwaysInlineSize) =
getOptionAsInteger("ipa-always-inline-size", DefaultSize);
}
return AlwaysInlineSize.getValue();
}
|
