diff --git a/clang/include/clang/Sema/Initialization.h b/clang/include/clang/Sema/Initialization.h --- a/clang/include/clang/Sema/Initialization.h +++ b/clang/include/clang/Sema/Initialization.h @@ -689,6 +689,9 @@ 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 --- a/clang/lib/Sema/SemaCast.cpp +++ b/clang/lib/Sema/SemaCast.cpp @@ -159,6 +159,30 @@ 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, @@ -229,7 +253,6 @@ unsigned &msg, CastKind &Kind); - /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's. ExprResult Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, @@ -708,6 +731,8 @@ /// 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()) @@ -861,6 +886,8 @@ /// 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()) @@ -1018,6 +1045,8 @@ /// 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 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -8179,9 +8179,13 @@ 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 --- a/clang/test/Frontend/noderef.cpp +++ b/clang/test/Frontend/noderef.cpp @@ -80,12 +80,28 @@ 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 @@ 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}} +}