summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h21
-rw-r--r--clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp32
-rw-r--r--clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp30
-rw-r--r--clang/test/Analysis/inlining/stl.cpp29
-rw-r--r--clang/test/Analysis/system-header-simulator-cxx.h57
-rw-r--r--clang/test/Analysis/temp-obj-dtors-cfg-output.cpp2
-rw-r--r--clang/test/Analysis/templates.cpp8
7 files changed, 176 insertions, 3 deletions
diff --git a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
index 5dba158f123..30650986954 100644
--- a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
+++ b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
@@ -17,7 +17,9 @@
#include <string>
#include <vector>
+#include "clang/Basic/LLVM.h"
#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/Optional.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
namespace clang {
@@ -166,6 +168,12 @@ public:
private:
/// Controls which C++ member functions will be considered for inlining.
CXXInlineableMemberKind CXXMemberInliningMode;
+
+ llvm::Optional<bool> IncludeTemporaryDtorsInCFG;
+ llvm::Optional<bool> InlineCXXStandardLibrary;
+ llvm::Optional<bool> InlineTemplateFunctions;
+
+ bool getBooleanOption(StringRef Name, bool DefaultVal = false) const;
public:
/// Returns the option controlling which C++ member functions will be
@@ -183,6 +191,19 @@ public:
/// non-empty value is considered to be 'true'.
bool includeTemporaryDtorsInCFG() const;
+ /// Returns whether or not C++ standard library functions may be considered
+ /// for inlining.
+ ///
+ /// This is controlled by the 'c++-stdlib-inlining' config option, which
+ /// accepts the values "true" and "false".
+ bool mayInlineCXXStandardLibrary() const;
+
+ /// Returns whether or not templated functions may be considered for inlining.
+ ///
+ /// This is controlled by the 'c++-template-inlining' config option, which
+ /// accepts the values "true" and "false".
+ bool mayInlineTemplateFunctions() const;
+
public:
AnalyzerOptions() : CXXMemberInliningMode() {
AnalysisStoreOpt = RegionStoreModel;
diff --git a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
index 9e45a115283..b410890f8ee 100644
--- a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
+++ b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
@@ -47,6 +47,36 @@ AnalyzerOptions::mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const {
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 {
- return !Config.lookup("cfg-temporary-dtors").empty();
+ if (!IncludeTemporaryDtorsInCFG.hasValue())
+ const_cast<llvm::Optional<bool> &>(IncludeTemporaryDtorsInCFG) =
+ getBooleanOption("cfg-temporary-dtors");
+
+ return *IncludeTemporaryDtorsInCFG;
+}
+
+bool AnalyzerOptions::mayInlineCXXStandardLibrary() const {
+ if (!InlineCXXStandardLibrary.hasValue())
+ const_cast<llvm::Optional<bool> &>(InlineCXXStandardLibrary) =
+ getBooleanOption("c++-stdlib-inlining");
+
+ return *InlineCXXStandardLibrary;
+}
+
+bool AnalyzerOptions::mayInlineTemplateFunctions() const {
+ if (!InlineTemplateFunctions.hasValue())
+ const_cast<llvm::Optional<bool> &>(InlineTemplateFunctions) =
+ getBooleanOption("c++-template-inlining", /*Default=*/true);
+
+ return *InlineTemplateFunctions;
}
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
index fd94c1926b5..9bf63c5b961 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
@@ -257,6 +257,21 @@ static unsigned getNumberStackFrames(const LocationContext *LCtx) {
return count;
}
+static bool IsInStdNamespace(const FunctionDecl *FD) {
+ const DeclContext *DC = FD->getEnclosingNamespaceContext();
+ const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC);
+ if (!ND)
+ return false;
+
+ while (const DeclContext *Parent = ND->getParent()) {
+ if (!isa<NamespaceDecl>(Parent))
+ break;
+ ND = cast<NamespaceDecl>(Parent);
+ }
+
+ return ND->getName() == "std";
+}
+
// Determine if we should inline the call.
bool ExprEngine::shouldInlineDecl(const Decl *D, ExplodedNode *Pred) {
AnalysisDeclContext *CalleeADC = AMgr.getAnalysisDeclContext(D);
@@ -287,6 +302,21 @@ bool ExprEngine::shouldInlineDecl(const Decl *D, ExplodedNode *Pred) {
return false;
}
+ if (getContext().getLangOpts().CPlusPlus) {
+ if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+ // Conditionally allow the inlining of template functions.
+ if (!getAnalysisManager().options.mayInlineTemplateFunctions())
+ if (FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate)
+ return false;
+
+ // Conditionally allow the inlining of C++ standard library functions.
+ if (!getAnalysisManager().options.mayInlineCXXStandardLibrary())
+ if (getContext().getSourceManager().isInSystemHeader(FD->getLocation()))
+ if (IsInStdNamespace(FD))
+ return false;
+ }
+ }
+
// It is possible that the live variables analysis cannot be
// run. If so, bail out.
if (!CalleeADC->getAnalysis<RelaxedLiveVariables>())
diff --git a/clang/test/Analysis/inlining/stl.cpp b/clang/test/Analysis/inlining/stl.cpp
new file mode 100644
index 00000000000..d9b3e02e79e
--- /dev/null
+++ b/clang/test/Analysis/inlining/stl.cpp
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-ipa=dynamic -verify %s
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-ipa=dynamic -analyzer-config c++-stdlib-inlining=true -DINLINE=1 -verify %s
+
+#include "../system-header-simulator-cxx.h"
+
+void clang_analyzer_eval(bool);
+
+void testVector(std::vector<int> &nums) {
+ if (nums.begin()) return;
+ if (nums.end()) return;
+
+ clang_analyzer_eval(nums.size() == 0);
+#if INLINE
+ // expected-warning@-2 {{TRUE}}
+#else
+ // expected-warning@-4 {{UNKNOWN}}
+#endif
+}
+
+void testException(std::exception e) {
+ // Notice that the argument is NOT passed by reference, so we can devirtualize.
+ const char *x = e.what();
+ clang_analyzer_eval(x == 0);
+#if INLINE
+ // expected-warning@-2 {{TRUE}}
+#else
+ // expected-warning@-4 {{UNKNOWN}}
+#endif
+}
diff --git a/clang/test/Analysis/system-header-simulator-cxx.h b/clang/test/Analysis/system-header-simulator-cxx.h
new file mode 100644
index 00000000000..e762d0a1bdf
--- /dev/null
+++ b/clang/test/Analysis/system-header-simulator-cxx.h
@@ -0,0 +1,57 @@
+#pragma clang system_header
+
+namespace std {
+ template <class T1, class T2>
+ struct pair {
+ T1 first;
+ T2 second;
+
+ pair() : first(), second() {}
+ pair(const T1 &a, const T2 &b) : first(a), second(b) {}
+
+ template<class U1, class U2>
+ pair(const pair<U1, U2> &other) : first(other.first), second(other.second) {}
+ };
+
+ typedef __typeof__(sizeof(int)) size_t;
+
+ template<typename T>
+ class vector {
+ T *_start;
+ T *_finish;
+ T *_end_of_storage;
+ public:
+ vector() : _start(0), _finish(0), _end_of_storage(0) {}
+ ~vector();
+
+ size_t size() const {
+ return size_t(_finish - _start);
+ }
+
+ void push_back();
+ T pop_back();
+
+ T &operator[](size_t n) {
+ return _start[n];
+ }
+
+ const T &operator[](size_t n) const {
+ return _start[n];
+ }
+
+ T *begin() { return _start; }
+ const T *begin() const { return _start; }
+
+ T *end() { return _finish; }
+ const T *end() const { return _finish; }
+ };
+
+ class exception {
+ public:
+ exception() throw();
+ virtual ~exception() throw();
+ virtual const char *what() const throw() {
+ return 0;
+ }
+ };
+}
diff --git a/clang/test/Analysis/temp-obj-dtors-cfg-output.cpp b/clang/test/Analysis/temp-obj-dtors-cfg-output.cpp
index d13083ddf01..c8844754bef 100644
--- a/clang/test/Analysis/temp-obj-dtors-cfg-output.cpp
+++ b/clang/test/Analysis/temp-obj-dtors-cfg-output.cpp
@@ -1,5 +1,5 @@
// RUN: rm -f %t
-// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-temporary-dtors=1 %s > %t 2>&1
+// RUN: %clang_cc1 -analyze -analyzer-checker=debug.DumpCFG -analyzer-config cfg-temporary-dtors=true %s > %t 2>&1
// RUN: FileCheck --input-file=%t %s
// XPASS: *
diff --git a/clang/test/Analysis/templates.cpp b/clang/test/Analysis/templates.cpp
index 671aa785820..faa5c1a7620 100644
--- a/clang/test/Analysis/templates.cpp
+++ b/clang/test/Analysis/templates.cpp
@@ -1,4 +1,5 @@
// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -fblocks -verify %s
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -fblocks -analyzer-config c++-template-inlining=false -DNO_INLINE -verify %s
void clang_analyzer_eval(bool);
@@ -39,6 +40,11 @@ inline unsigned array_lengthof(T (&)[N]) {
void testNonTypeTemplateInstantiation() {
const char *S[] = { "a", "b" };
- clang_analyzer_eval(array_lengthof(S) == 2); // expected-warning{{TRUE}}
+ clang_analyzer_eval(array_lengthof(S) == 2);
+#ifndef NO_INLINE
+ // expected-warning@-2 {{TRUE}}
+#else
+ // expected-warning@-4 {{UNKNOWN}}
+#endif
}
OpenPOWER on IntegriCloud