NoDeleteChecker.cpp

Go to the documentation of this file.

//=======- NoDeleteChecker.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
//
//===----------------------------------------------------------------------===//
 
#include "DiagOutputUtils.h"
#include "PtrTypesSemantics.h"
#include "clang/AST/CXXInheritance.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DynamicRecursiveASTVisitor.h"
#include "clang/AST/QualTypeNames.h"
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Basic/SourceLocation.h"
#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"
 
using namespace clang;
using namespace ento;
 
namespace {
 
class NoDeleteChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> {
  BugType Bug;
  mutable BugReporter *BR = nullptr;
  mutable TrivialFunctionAnalysis TFA;
 
public:
  NoDeleteChecker()
      : Bug(this,
            "Incorrect [[clang::annotate_type(\"webkit.nodelete\")]] "
            "annotation",
            "WebKit coding guidelines") {}
 
  void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
                    BugReporter &BRArg) const {
    BR = &BRArg;
 
    // The calls to checkAST* from AnalysisConsumer don't
    // visit template instantiations or lambda classes. We
    // want to visit those, so we make our own visitor.
    struct LocalVisitor final : public ConstDynamicRecursiveASTVisitor {
      const NoDeleteChecker *Checker;
      Decl *DeclWithIssue{nullptr};
 
      explicit LocalVisitor(const NoDeleteChecker *Checker) : Checker(Checker) {
        assert(Checker);
        ShouldVisitTemplateInstantiations = true;
        ShouldWalkTypesOfTypeLocs = true;
        ShouldVisitImplicitCode = false;
        ShouldVisitLambdaBody = true;
      }
 
      bool VisitFunctionDecl(const FunctionDecl *FD) override {
        Checker->visitFunctionDecl(FD);
        return true;
      }
    };
 
    LocalVisitor visitor(this);
    visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD));
  }
 
  void visitFunctionDecl(const FunctionDecl *FD) const {
    if (!FD->doesThisDeclarationHaveABody() || FD->isDependentContext())
      return;
 
    if (!isNoDeleteFunction(FD))
      return;
 
    auto Body = FD->getBody();
    if (!Body)
      return;
 
    NamedDecl *ParamDecl = nullptr;
    for (auto *D : FD->parameters()) {
      if (!TFA.hasTrivialDtor(D)) {
        ParamDecl = D;
        break;
      }
    }
 
    const FieldDecl *Field = nullptr;
    const Stmt *OffendingInit = nullptr;
    bool IsCtor = false;
    bool IsDtor = false;
    if (auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
      IsCtor = true;
      Field = TFA.fieldWithNonTrivialCtor(Ctor->getParent());
      if (!Field) {
        for (auto *CtorInit : Ctor->inits()) {
          auto *Init = CtorInit->getInit();
          if (!TFA.isTrivial(Init)) {
            OffendingInit = Init;
            break;
          }
        }
      }
    } else if (auto *Dtor = dyn_cast<CXXDestructorDecl>(FD)) {
      IsDtor = true;
      Field = TFA.fieldWithNonTrivialDtor(Dtor->getParent());
    }
 
    if (!ParamDecl && !Field && !OffendingInit && TFA.isTrivial(Body))
      return;
 
    SmallString<100> Buf;
    llvm::raw_svector_ostream Os(Buf);
 
    if (IsCtor)
      Os << "A constructor ";
    else if (IsDtor)
      Os << "A destructor ";
    else
      Os << "A function ";
    printQuotedName(Os, FD);
    // FIXME: Update this to say clang::annotate("webkit.nodelete").
    Os << " has [[clang::annotate_type(\"webkit.nodelete\")]] but it ";
    if (IsCtor && Field)
      Os << "constructs ";
    else if (IsDtor && Field)
      Os << "destructs ";
    else
      Os << "contains ";
    SourceLocation SrcLocToReport;
    SourceRange Range;
    NonTrivialityReason Reason;
    if (ParamDecl) {
      Os << "a parameter ";
      printQuotedName(Os, ParamDecl);
      Os << " which could destruct an object.";
      SrcLocToReport = FD->getBeginLoc();
      Range = ParamDecl->getSourceRange();
    } else if (Field && !OffendingInit) {
      Os << "a member variable ";
      printQuotedName(Os, Field);
      Os << " that could destruct an object.";
      SrcLocToReport = FD->getBeginLoc();
      Range = Field->getSourceRange();
    } else {
      Reason = TrivialFunctionAnalysis::computeReason(
          OffendingInit ? OffendingInit : Body);
      Os << "code that could destruct an object.";
      const Stmt *Offender = Reason.OffendingStmt;
      SrcLocToReport = Offender ? Offender->getBeginLoc() : FD->getBeginLoc();
      Range = Offender ? Offender->getSourceRange() : FD->getSourceRange();
    }
 
    PathDiagnosticLocation BSLoc(SrcLocToReport, BR->getSourceManager());
    auto Report = std::make_unique<BasicBugReport>(Bug, Os.str(), BSLoc);
    Report->addRange(Range);
    Report->setDeclWithIssue(FD);
    addCallStackNotes(*Report, Reason);
    BR->emitReport(std::move(Report));
  }
 
  static const FunctionDecl *getDirectCallee(const Stmt *S) {
    if (const auto *CE = dyn_cast_or_null<CallExpr>(S))
      return CE->getDirectCallee();
    if (const auto *CE = dyn_cast_or_null<CXXConstructExpr>(S))
      return CE->getConstructor();
    return nullptr;
  }
 
  // The offending statement is often just the nearest call to a function that
  // is itself unsafe several levels down. Walk the whole chain of calls, one
  // note per function, down to the code that destructs an object or the
  // function without a visible definition, since that is where the fix belongs.
  void addCallStackNotes(BasicBugReport &Report,
                         const NonTrivialityReason &Reason) const {
    ArrayRef<NonTrivialityReason::Frame> CallStack = Reason.CallStack;
    if (CallStack.empty())
      return;
 
    // Nothing to add when the offending statement is the call to a function
    // that is opaque or rejected outright; a note would only point back at its
    // declaration, which the primary diagnostic already names.
    const auto &First = CallStack.front();
    const FunctionDecl *Callee = getDirectCallee(Reason.OffendingStmt);
    if (CallStack.size() == 1 && !First.OffendingStmt && Callee &&
        Callee->getCanonicalDecl() == First.Callee->getCanonicalDecl())
      return;
 
    for (size_t I = 0; I < CallStack.size(); ++I) {
      const FunctionDecl *Fn = CallStack[I].Callee;
      const Stmt *Offender = CallStack[I].OffendingStmt;
      // Implicit special members have nothing worth pointing at.
      if (!Offender && !Fn->getLocation().isValid())
        continue;
 
      SmallString<100> Buf;
      llvm::raw_svector_ostream Os(Buf);
      // Each note sits on the line it describes, which already spells out the
      // enclosing function and the callee, so name only the callee: naming
      // both would repeat every function in the chain twice.
      if (I + 1 < CallStack.size()) {
        Os << "Calling ";
        printQuotedName(Os, CallStack[I + 1].Callee);
      } else if (Fn->doesThisDeclarationHaveABody()) {
        Os << "Could destruct an object";
      } else {
        printQuotedName(Os, Fn);
        Os << " has no visible definition here, so it is assumed to destruct "
              "an object. Annotate it with "
              "[[clang::annotate_type(\"webkit.nodelete\")]] if it does not.";
      }
 
      SourceLocation Loc =
          Offender ? Offender->getBeginLoc() : Fn->getLocation();
      SourceRange Range =
          Offender ? Offender->getSourceRange() : Fn->getSourceRange();
      Report.addNote(
          Os.str(), PathDiagnosticLocation(Loc, BR->getSourceManager()), Range);
    }
  }
};
 
} // namespace
 
void ento::registerNoDeleteChecker(CheckerManager &Mgr) {
  Mgr.registerChecker<NoDeleteChecker>();
}
 
bool ento::shouldRegisterNoDeleteChecker(const CheckerManager &) {
  return true;
}