CXXDeleteChecker.cpp

Go to the documentation of this file.

//=== CXXDeleteChecker.cpp -------------------------------------*- C++ -*--===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the following new checkers for C++ delete expressions:
//
//   * DeleteWithNonVirtualDtorChecker
//       Defines a checker for the OOP52-CPP CERT rule: Do not delete a
//       polymorphic object without a virtual destructor.
//
//       Diagnostic flags -Wnon-virtual-dtor and -Wdelete-non-virtual-dtor
//       report if an object with a virtual function but a non-virtual
//       destructor exists or is deleted, respectively.
//
//       This check exceeds them by comparing the dynamic and static types of
//       the object at the point of destruction and only warns if it happens
//       through a pointer to a base type without a virtual destructor. The
//       check places a note at the last point where the conversion from
//       derived to base happened.
//
//   * CXXArrayDeleteChecker
//       Defines a checker for the EXP51-CPP CERT rule: Do not delete an array
//       through a pointer of the incorrect type.
//
//===----------------------------------------------------------------------===//
 
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 
using namespace clang;
using namespace ento;
 
namespace {
class CXXDeleteChecker : public Checker<check::PreStmt<CXXDeleteExpr>> {
protected:
  class PtrCastVisitor : public BugReporterVisitor {
  public:
    void Profile(llvm::FoldingSetNodeID &ID) const override {
      static int X = 0;
      ID.AddPointer(&X);
    }
    PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
                                     BugReporterContext &BRC,
                                     PathSensitiveBugReport &BR) override;
  };
 
  virtual void
  checkTypedDeleteExpr(const CXXDeleteExpr *DE, CheckerContext &C,
                       const TypedValueRegion *BaseClassRegion,
                       const SymbolicRegion *DerivedClassRegion) const = 0;
 
public:
  void checkPreStmt(const CXXDeleteExpr *DE, CheckerContext &C) const;
};
 
class DeleteWithNonVirtualDtorChecker : public CXXDeleteChecker {
  const BugType BT{
      this, "Destruction of a polymorphic object with no virtual destructor"};
 
  void
  checkTypedDeleteExpr(const CXXDeleteExpr *DE, CheckerContext &C,
                       const TypedValueRegion *BaseClassRegion,
                       const SymbolicRegion *DerivedClassRegion) const override;
};
 
class CXXArrayDeleteChecker : public CXXDeleteChecker {
  const BugType BT{this,
                   "Deleting an array of polymorphic objects is undefined"};
 
  void
  checkTypedDeleteExpr(const CXXDeleteExpr *DE, CheckerContext &C,
                       const TypedValueRegion *BaseClassRegion,
                       const SymbolicRegion *DerivedClassRegion) const override;
};
} // namespace
 
void CXXDeleteChecker::checkPreStmt(const CXXDeleteExpr *DE,
                                    CheckerContext &C) const {
  const Expr *DeletedObj = DE->getArgument();
  const MemRegion *MR = C.getSVal(DeletedObj).getAsRegion();
  if (!MR)
    return;
 
  OverloadedOperatorKind DeleteKind =
      DE->getOperatorDelete()->getOverloadedOperator();
 
  if (DeleteKind != OO_Delete && DeleteKind != OO_Array_Delete)
    return;
 
  const auto *BaseClassRegion = MR->getAs<TypedValueRegion>();
  const auto *DerivedClassRegion = MR->getBaseRegion()->getAs<SymbolicRegion>();
  if (!BaseClassRegion || !DerivedClassRegion)
    return;
 
  checkTypedDeleteExpr(DE, C, BaseClassRegion, DerivedClassRegion);
}
 
void DeleteWithNonVirtualDtorChecker::checkTypedDeleteExpr(
    const CXXDeleteExpr *DE, CheckerContext &C,
    const TypedValueRegion *BaseClassRegion,
    const SymbolicRegion *DerivedClassRegion) const {
  const auto *BaseClass = BaseClassRegion->getValueType()->getAsCXXRecordDecl();
  const auto *DerivedClass =
      DerivedClassRegion->getSymbol()->getType()->getPointeeCXXRecordDecl();
  if (!BaseClass || !DerivedClass)
    return;
 
  if (!BaseClass->hasDefinition() || !DerivedClass->hasDefinition())
    return;
 
  if (BaseClass->getDestructor()->isVirtual())
    return;
 
  if (!DerivedClass->isDerivedFrom(BaseClass))
    return;
 
  ExplodedNode *N = C.generateNonFatalErrorNode();
  if (!N)
    return;
  auto R = std::make_unique<PathSensitiveBugReport>(BT, BT.getDescription(), N);
 
  // Mark region of problematic base class for later use in the BugVisitor.
  R->markInteresting(BaseClassRegion);
  R->addVisitor<PtrCastVisitor>();
  C.emitReport(std::move(R));
}
 
void CXXArrayDeleteChecker::checkTypedDeleteExpr(
    const CXXDeleteExpr *DE, CheckerContext &C,
    const TypedValueRegion *BaseClassRegion,
    const SymbolicRegion *DerivedClassRegion) const {
  const auto *BaseClass = BaseClassRegion->getValueType()->getAsCXXRecordDecl();
  const auto *DerivedClass =
      DerivedClassRegion->getSymbol()->getType()->getPointeeCXXRecordDecl();
  if (!BaseClass || !DerivedClass)
    return;
 
  if (!BaseClass->hasDefinition() || !DerivedClass->hasDefinition())
    return;
 
  if (DE->getOperatorDelete()->getOverloadedOperator() != OO_Array_Delete)
    return;
 
  if (!DerivedClass->isDerivedFrom(BaseClass))
    return;
 
  ExplodedNode *N = C.generateNonFatalErrorNode();
  if (!N)
    return;
 
  SmallString<256> Buf;
  llvm::raw_svector_ostream OS(Buf);
 
  QualType SourceType = BaseClassRegion->getValueType();
  QualType TargetType =
      DerivedClassRegion->getSymbol()->getType()->getPointeeType();
 
  OS << "Deleting an array of '" << TargetType.getAsString()
     << "' objects as their base class '"
     << SourceType.getAsString(C.getASTContext().getPrintingPolicy())
     << "' is undefined";
 
  auto R = std::make_unique<PathSensitiveBugReport>(BT, OS.str(), N);
 
  // Mark region of problematic base class for later use in the BugVisitor.
  R->markInteresting(BaseClassRegion);
  R->addVisitor<PtrCastVisitor>();
  C.emitReport(std::move(R));
}
 
PathDiagnosticPieceRef
CXXDeleteChecker::PtrCastVisitor::VisitNode(const ExplodedNode *N,
                                            BugReporterContext &BRC,
                                            PathSensitiveBugReport &BR) {
  const Stmt *S = N->getStmtForDiagnostics();
  if (!S)
    return nullptr;
 
  const auto *CastE = dyn_cast<CastExpr>(S);
  if (!CastE)
    return nullptr;
 
  // FIXME: This way of getting base types does not support reference types.
  QualType SourceType = CastE->getSubExpr()->getType()->getPointeeType();
  QualType TargetType = CastE->getType()->getPointeeType();
 
  if (SourceType.isNull() || TargetType.isNull() || SourceType == TargetType)
    return nullptr;
 
  // Region associated with the current cast expression.
  const MemRegion *M = N->getSVal(CastE).getAsRegion();
  if (!M)
    return nullptr;
 
  // Check if target region was marked as problematic previously.
  if (!BR.isInteresting(M))
    return nullptr;
 
  SmallString<256> Buf;
  llvm::raw_svector_ostream OS(Buf);
 
  OS << "Casting from '" << SourceType.getAsString() << "' to '"
     << TargetType.getAsString() << "' here";
 
  PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
                             N->getLocationContext());
  return std::make_shared<PathDiagnosticEventPiece>(Pos, OS.str(),
                                                    /*addPosRange=*/true);
}
 
void ento::registerArrayDeleteChecker(CheckerManager &mgr) {
  mgr.registerChecker<CXXArrayDeleteChecker>();
}
 
bool ento::shouldRegisterArrayDeleteChecker(const CheckerManager &mgr) {
  return true;
}
 
void ento::registerDeleteWithNonVirtualDtorChecker(CheckerManager &mgr) {
  mgr.registerChecker<DeleteWithNonVirtualDtorChecker>();
}
 
bool ento::shouldRegisterDeleteWithNonVirtualDtorChecker(
    const CheckerManager &mgr) {
  return true;
}