From 2f6bb2a69215f9cae883da12f8f596d3f80f8d71 Mon Sep 17 00:00:00 2001 From: Leonard Chan Date: Wed, 10 Jun 2020 12:20:54 -0700 Subject: [PATCH] [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 --- clang/include/clang/Sema/Initialization.h | 3 ++ clang/lib/Sema/SemaCast.cpp | 30 ++++++++++++++ clang/lib/Sema/SemaInit.cpp | 10 +++-- clang/test/Frontend/noderef.cpp | 66 +++++++++++++++++++++++++++++++ 4 files changed, 106 insertions(+), 3 deletions(-) diff --git a/clang/include/clang/Sema/Initialization.h b/clang/include/clang/Sema/Initialization.h index d50ec2a..ca9e0a1 100644 --- a/clang/include/clang/Sema/Initialization.h +++ b/clang/include/clang/Sema/Initialization.h @@ -689,6 +689,9 @@ public: 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 f483f73..2efe260 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(FromType)) { + if (PtrType->getPointeeType()->hasAttr(attr::NoDeref)) { + if (const auto *DestType = dyn_cast(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\(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 0a98cb2..d46e7f8 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()) { 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 15eb4e4..32d5ca3 100644 --- a/clang/test/Frontend/noderef.cpp +++ b/clang/test/Frontend/noderef.cpp @@ -80,12 +80,28 @@ public: 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 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(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(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(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} + int *x4 = reinterpret_cast(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); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +int *static_cast_from_same_ptr_type(NODEREF int *x) { + return static_cast(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +A *dynamic_cast_up(NODEREF Child *child) { + return dynamic_cast(child); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +Child *dynamic_cast_down(NODEREF A *a) { + return dynamic_cast(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +A *dynamic_cast_side(NODEREF A *a) { + return dynamic_cast(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +void *dynamic_cast_to_void_ptr(NODEREF A *a) { + return dynamic_cast(a); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +int *const_cast_check(NODEREF const int *x) { + return const_cast(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} + +const int *const_cast_check(NODEREF int *x) { + return const_cast(x); // expected-warning{{casting to dereferenceable pointer removes 'noderef' attribute}} +} -- 2.7.4