compilerplugins/clang/crosscast.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 // Find uses of dynamic_cast that cast between unrelated classes, which is suspicious and might
  11 // indicate a bug.  The heuristic used to consider two classes unrelated is that neither derives
  12 // from the other (directly or indirectly) and they do not both virtually derive (directly or
  13 // indirectly) from a common third class.  Additionally, class definitions can be attributed with
  14 // SAL_LOPLUGIN_ANNOTATE("crosscast") (from sal/types.h) to suppress false warnings about known-good
  15 // cases casting from or to such a class.
  16
  17 #ifndef LO_CLANG_SHARED_PLUGINS
  18
  19 #include <cassert>
  20 #include <set>
  21
  22 #include "compat.hxx"
  23 #include "plugin.hxx"
  24
  25 namespace
  26 {
  27 void computeVirtualBases(CXXRecordDecl const* decl, std::set<CXXRecordDecl const*>* vbases)
  28 {
  29     assert(vbases != nullptr);
  30     for (auto const& i : decl->bases())
  31     {
  32         auto const d = i.getType()->getAsCXXRecordDecl();
  33         if (d == nullptr)
  34         {
  35             continue;
  36         }
  37         if (i.isVirtual())
  38         {
  39             if (!vbases->insert(d->getCanonicalDecl()).second)
  40             {
  41                 // As we track the already computed virtual bases in vbases anyway, we can cheaply
  42                 // optimize the case where we see a virtual base again, even though we don't bother
  43                 // to optimize the case where we see a non-virtual base multiple times:
  44                 continue;
  45             }
  46         }
  47         computeVirtualBases(d, vbases);
  48     }
  49 }
  50
  51 bool compareVirtualBases(CXXRecordDecl const* decl, std::set<CXXRecordDecl const*>& vbases)
  52 {
  53     for (auto const& i : decl->bases())
  54     {
  55         auto const d = i.getType()->getAsCXXRecordDecl();
  56         if (d == nullptr)
  57         {
  58             continue;
  59         }
  60         if (i.isVirtual() && vbases.count(d->getCanonicalDecl()) == 1)
  61         {
  62             return true;
  63         }
  64         if (compareVirtualBases(d, vbases))
  65         {
  66             return true;
  67         }
  68     }
  69     return false;
  70 }
  71
  72 bool haveCommonVirtualBase(CXXRecordDecl const* decl1, CXXRecordDecl const* decl2)
  73 {
  74     std::set<CXXRecordDecl const*> vbases;
  75     computeVirtualBases(decl1, &vbases);
  76     return compareVirtualBases(decl2, vbases);
  77 }
  78
  79 bool isAllowedInCrossCasts(CXXRecordDecl const* decl)
  80 {
  81     auto const def = decl->getDefinition();
  82     if (def == nullptr)
  83     {
  84         return false;
  85     }
  86     for (auto const attr : def->specific_attrs<AnnotateAttr>())
  87     {
  88         if (attr->getAnnotation() == "loplugin:crosscast")
  89         {
  90             return true;
  91         }
  92     }
  93     return false;
  94 }
  95
  96 class CrossCast final : public loplugin::FilteringPlugin<CrossCast>
  97 {
  98 public:
  99     explicit CrossCast(loplugin::InstantiationData const& data)
 100         : FilteringPlugin(data)
 101     {
 102     }
 103
 104     bool preRun() override { return compiler.getLangOpts().CPlusPlus; }
 105
 106     void run() override
 107     {
 108         if (preRun())
 109         {
 110             TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
 111         }
 112     }
 113
 114     bool VisitCXXDynamicCastExpr(CXXDynamicCastExpr const* expr)
 115     {
 116         if (ignoreLocation(expr))
 117         {
 118             return true;
 119         }
 120         auto const t2 = expr->getTypeAsWritten();
 121         if (t2->isVoidPointerType())
 122         {
 123             return true;
 124         }
 125         auto const d2 = t2->getPointeeCXXRecordDecl();
 126         if (d2 == nullptr)
 127         {
 128             return true;
 129         }
 130         auto const t1 = compat::getSubExprAsWritten(expr)->getType();
 131         auto t1a = t1;
 132         if (auto const t = t1a->getAs<clang::PointerType>())
 133         {
 134             t1a = t->getPointeeType();
 135         }
 136         auto const d1 = t1a->getAsCXXRecordDecl();
 137         if (d1 == nullptr)
 138         {
 139             return true;
 140         }
 141         if (d1->getCanonicalDecl() == d2->getCanonicalDecl() || d1->isDerivedFrom(d2)
 142             || d2->isDerivedFrom(d1) || haveCommonVirtualBase(d1, d2))
 143         {
 144             return true;
 145         }
 146         if (isAllowedInCrossCasts(d1) || isAllowedInCrossCasts(d2))
 147         {
 148             return true;
 149         }
 150         if (suppressWarningAt(expr->getBeginLoc()))
 151         {
 152             return true;
 153         }
 154         report(DiagnosticsEngine::Warning, "suspicious dynamic cross cast from %0 to %1",
 155                expr->getExprLoc())
 156             << t1 << t2 << expr->getSourceRange();
 157         return true;
 158     }
 159 };
 160
 161 loplugin::Plugin::Registration<CrossCast> crosscast("crosscast");
 162 }
 163
 164 #endif
 165
 166 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */