[clang] 2f6bb2a - [clang][Attribute] Fix noderef attribute false-negatives
Leonard Chan via cfe-commits
cfe-commits at lists.llvm.org
Wed Jun 10 12:21:45 PDT 2020
Author: Leonard Chan
Date: 2020-06-10T12:20:54-07:00
New Revision: 2f6bb2a69215f9cae883da12f8f596d3f80f8d71
URL: https://github.com/llvm/llvm-project/commit/2f6bb2a69215f9cae883da12f8f596d3f80f8d71
DIFF: https://github.com/llvm/llvm-project/commit/2f6bb2a69215f9cae883da12f8f596d3f80f8d71.diff
LOG: [clang][Attribute] Fix noderef attribute false-negatives
`noderef` was failing to trigger warnings in some cases related to c++ style
casting. This patch addresses them.
Differential Revision: https://reviews.llvm.org/D77836
Added:
Modified:
clang/include/clang/Sema/Initialization.h
clang/lib/Sema/SemaCast.cpp
clang/lib/Sema/SemaInit.cpp
clang/test/Frontend/noderef.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Sema/Initialization.h b/clang/include/clang/Sema/Initialization.h
index d50ec2addc8f..ca9e0a198cb9 100644
--- a/clang/include/clang/Sema/Initialization.h
+++ b/clang/include/clang/Sema/Initialization.h
@@ -689,6 +689,9 @@ class InitializationKind {
return Context >= IC_StaticCast;
}
+ /// Determine whether this initialization is a static cast.
+ bool isStaticCast() const { return Context == IC_StaticCast; }
+
/// Determine whether this initialization is a C-style cast.
bool isCStyleOrFunctionalCast() const {
return Context >= IC_CStyleCast;
diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp
index f483f7315aec..2efe26052c78 100644
--- a/clang/lib/Sema/SemaCast.cpp
+++ b/clang/lib/Sema/SemaCast.cpp
@@ -161,6 +161,30 @@ namespace {
PlaceholderKind = (BuiltinType::Kind) 0;
}
};
+
+ void CheckNoDeref(Sema &S, const QualType FromType, const QualType ToType,
+ SourceLocation OpLoc) {
+ if (const auto *PtrType = dyn_cast<PointerType>(FromType)) {
+ if (PtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
+ if (const auto *DestType = dyn_cast<PointerType>(ToType)) {
+ if (!DestType->getPointeeType()->hasAttr(attr::NoDeref)) {
+ S.Diag(OpLoc, diag::warn_noderef_to_dereferenceable_pointer);
+ }
+ }
+ }
+ }
+ }
+
+ struct CheckNoDerefRAII {
+ CheckNoDerefRAII(CastOperation &Op) : Op(Op) {}
+ ~CheckNoDerefRAII() {
+ if (!Op.SrcExpr.isInvalid())
+ CheckNoDeref(Op.Self, Op.SrcExpr.get()->getType(), Op.ResultType,
+ Op.OpRange.getBegin());
+ }
+
+ CastOperation &Op;
+ };
}
static void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr,
@@ -723,6 +747,8 @@ static TryCastResult getCastAwayConstnessCastKind(CastAwayConstnessKind CACK,
/// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime-
/// checked downcasts in class hierarchies.
void CastOperation::CheckDynamicCast() {
+ CheckNoDerefRAII NoderefCheck(*this);
+
if (ValueKind == VK_RValue)
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
else if (isPlaceholder())
@@ -876,6 +902,8 @@ void CastOperation::CheckDynamicCast() {
/// const char *str = "literal";
/// legacy_function(const_cast\<char*\>(str));
void CastOperation::CheckConstCast() {
+ CheckNoDerefRAII NoderefCheck(*this);
+
if (ValueKind == VK_RValue)
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
else if (isPlaceholder())
@@ -1045,6 +1073,8 @@ void CastOperation::CheckReinterpretCast() {
/// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
/// implicit conversions explicit and getting rid of data loss warnings.
void CastOperation::CheckStaticCast() {
+ CheckNoDerefRAII NoderefCheck(*this);
+
if (isPlaceholder()) {
checkNonOverloadPlaceholders();
if (SrcExpr.isInvalid())
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 0a98cb2a5ce0..d46e7f86d6b3 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -8200,9 +8200,13 @@ ExprResult InitializationSequence::Perform(Sema &S,
if (const auto *ToPtrType = Step->Type->getAs<PointerType>()) {
if (FromPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
!ToPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
- S.Diag(CurInit.get()->getExprLoc(),
- diag::warn_noderef_to_dereferenceable_pointer)
- << CurInit.get()->getSourceRange();
+ // Do not check static casts here because they are checked earlier
+ // in Sema::ActOnCXXNamedCast()
+ if (!Kind.isStaticCast()) {
+ S.Diag(CurInit.get()->getExprLoc(),
+ diag::warn_noderef_to_dereferenceable_pointer)
+ << CurInit.get()->getSourceRange();
+ }
}
}
}
diff --git a/clang/test/Frontend/noderef.cpp b/clang/test/Frontend/noderef.cpp
index 15eb4e457c20..32d5ca34d1b1 100644
--- a/clang/test/Frontend/noderef.cpp
+++ b/clang/test/Frontend/noderef.cpp
@@ -80,12 +80,28 @@ class A {
int member;
int NODEREF *member2;
int NODEREF member3; // expected-warning{{'noderef' can only be used on an array or pointer type}}
+ int *member4;
+
+ int func() { return member; }
+ virtual int func_virt() { return member; }
+
+ A(NODEREF int *x) : member4(x) {} // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
};
+class Child : public A {};
+
void MemberPointer() {
int NODEREF A::*var = &A::member; // expected-warning{{'noderef' can only be used on an array or pointer type}}
}
+int MethodCall(NODEREF A *a) { // expected-note{{a declared here}}
+ return a->func(); // expected-warning{{dereferencing a; was declared with a 'noderef' type}}
+}
+
+int ChildCall(NODEREF Child *child) { // expected-note{{child declared here}}
+ return child->func(); // expected-warning{{dereferencing child; was declared with a 'noderef' type}}
+}
+
template <class Ty>
class B {
Ty NODEREF *member;
@@ -100,3 +116,53 @@ void test_lambdas() {
int NODEREF *glob_ptr; // expected-note{{glob_ptr declared here}}
int glob_int = *glob_ptr; // expected-warning{{dereferencing glob_ptr; was declared with a 'noderef' type}}
+
+void cast_from_void_ptr(NODEREF void *x) {
+ int *a = static_cast<int *>(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+
+ // Allow regular C-style casts and C-style through reinterpret_casts to be holes
+ int *b = reinterpret_cast<int *>(x);
+ int *c = (int *)x;
+}
+
+void conversion_sequences() {
+ NODEREF int *x;
+ int *x2 = x; // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+ int *x3 = static_cast<int *>(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+ int *x4 = reinterpret_cast<int *>(x);
+
+ // Functional cast - This is exactly equivalent to a C-style cast.
+ typedef int *INT_PTR;
+ int *x5 = INT_PTR(x);
+
+ NODEREF Child *child;
+ Child *child2 = dynamic_cast<Child *>(child); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+int *static_cast_from_same_ptr_type(NODEREF int *x) {
+ return static_cast<int *>(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+A *dynamic_cast_up(NODEREF Child *child) {
+ return dynamic_cast<A *>(child); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+Child *dynamic_cast_down(NODEREF A *a) {
+ return dynamic_cast<Child *>(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+A *dynamic_cast_side(NODEREF A *a) {
+ return dynamic_cast<A *>(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+void *dynamic_cast_to_void_ptr(NODEREF A *a) {
+ return dynamic_cast<void *>(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+int *const_cast_check(NODEREF const int *x) {
+ return const_cast<int *>(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
+
+const int *const_cast_check(NODEREF int *x) {
+ return const_cast<const int *>(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}}
+}
More information about the cfe-commits
mailing list