RawPtrRefSafetyModel.cpp

Go to the documentation of this file.

//=======- RawPtrRefSafetyModel.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 "RawPtrRefSafetyModel.h"
#include "ASTUtils.h"
#include "DiagOutputUtils.h"
#include "clang/AST/Decl.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/Type.h"
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/STLExtras.h"
 
using namespace clang;
 
namespace {
 
class RefCountedSafetyModel : public PtrRefSafetyModel {
public:
  std::optional<bool> isUnsafeType(QualType QT) const override {
    return isUncounted(QT);
  }
  std::optional<bool> isUnsafePtr(QualType QT, bool) const override {
    return isUncountedPtr(QT.getCanonicalType());
  }
  bool isSafePtr(const CXXRecordDecl *Record) const override {
    return isRefCounted(Record) || isCheckedPtr(Record);
  }
  bool isSafePtrType(QualType T) const override {
    return isRefOrCheckedPtrType(T);
  }
  bool isPtrType(const std::string &Name) const override {
    return isRefType(Name);
  }
  const char *typeName() const override { return "RefPtr-capable type"; }
};
 
class CheckedPtrSafetyModel : public PtrRefSafetyModel {
public:
  std::optional<bool> isUnsafeType(QualType QT) const override {
    return isUnchecked(QT);
  }
  std::optional<bool> isUnsafePtr(QualType QT, bool) const override {
    return isUncheckedPtr(QT.getCanonicalType());
  }
  bool isSafePtr(const CXXRecordDecl *Record) const override {
    return isRefCounted(Record) || isCheckedPtr(Record);
  }
  bool isSafePtrType(QualType T) const override {
    return isRefOrCheckedPtrType(T);
  }
  bool isPtrType(const std::string &Name) const override {
    return isCheckedPtr(Name);
  }
  bool isSafeExpr(const Expr *E, bool, QualType, bool) const override {
    return isExprToGetCheckedPtrCapableMember(E);
  }
  const char *typeName() const override { return "CheckedPtr-capable type"; }
};
 
class RetainPtrSafetyModel : public PtrRefSafetyModel {
  mutable RetainTypeChecker RTC;
 
public:
  std::optional<bool> isUnsafeType(QualType QT) const override {
    return RTC.isUnretained(QT);
  }
  std::optional<bool> isUnsafePtr(QualType QT, bool IgnoreARC) const override {
    return RTC.isUnretained(QT, IgnoreARC);
  }
  bool isSafePtr(const CXXRecordDecl *Record) const override {
    return isRetainPtrOrOSPtr(Record);
  }
  bool isSafePtrType(QualType T) const override {
    return isRetainPtrOrOSPtrType(T);
  }
  bool isPtrType(const std::string &Name) const override {
    return isRetainPtrOrOSPtr(Name);
  }
  bool isSafeExpr(const Expr *E, bool, QualType, bool) const override {
    return ento::cocoa::isCocoaObjectRef(E->getType()) &&
           isa<ObjCMessageExpr>(E);
  }
  bool isSafeDecl(const Decl *D, const SourceManager &SM) const override {
    // Treat NS/CF globals in system header as immortal.
    return SM.isInSystemHeader(D->getLocation());
  }
  void describeHazard(llvm::raw_ostream &Os, const Expr *Origin,
                      QualType SinkType) const override {
    auto *VarType = SinkType.getTypePtr();
    if (isa<TypedefType>(VarType)) {
      Os << typeName() << " ";
      if (auto *Decl = RTC.getCanonicalDecl(SinkType)) {
        printQuotedQualifiedName(Os, Decl);
      } else {
        const auto *Typedef = VarType->getAs<TypedefType>();
        assert(Typedef);
        printQuotedQualifiedName(Os, Typedef->getDecl());
      }
      return;
    }
    PtrRefSafetyModel::describeHazard(Os, Origin, SinkType);
  }
  const char *typeName() const override { return "RetainPtr-capable type"; }
  RetainTypeChecker *retainTypeChecker() const override { return &RTC; }
};
 
static std::optional<bool> isCanBorrowType(QualType T) {
  auto *Record = T->getAsCXXRecordDecl();
  if (!Record)
    return false;
  return isBorrowable(Record);
}
 
static bool isSameRecord(QualType A, QualType B) {
  auto *RecordA = A->getAsCXXRecordDecl();
  auto *RecordB = B->getAsCXXRecordDecl();
  return RecordA && RecordB &&
         RecordA->getCanonicalDecl() == RecordB->getCanonicalDecl();
}
 
static const ValueDecl *declaredObject(const Expr *E) {
  const Expr *Stripped = E->IgnoreParenImpCasts();
  if (auto *DeclRef = dyn_cast<DeclRefExpr>(Stripped))
    return DeclRef->getDecl();
  if (auto *Member = dyn_cast<MemberExpr>(Stripped))
    return Member->getMemberDecl();
  return nullptr;
}
 
// Returns the const-declared variable or member that E denotes, directly or
// through a dereference that vends it as const, or nullptr.
static const ValueDecl *constDeclaredObject(const Expr *E) {
  const Expr *Stripped = E->IgnoreParenImpCasts();
 
  if (auto *Op = dyn_cast<CXXOperatorCallExpr>(Stripped)) {
    OverloadedOperatorKind Kind = Op->getOperator();
    if ((Kind != OO_Star && Kind != OO_Arrow) || Op->getNumArgs() != 1)
      return nullptr;
    if (!pointeeType(Op->getType()).isConstQualified())
      return nullptr;
    return constDeclaredObject(Op->getArg(0));
  }
 
  const ValueDecl *Decl = declaredObject(Stripped);
  if (!isa_and_nonnull<VarDecl>(Decl) && !isa_and_nonnull<FieldDecl>(Decl))
    return nullptr;
  QualType T = Decl->getType();
  if (!T.isConstQualified() || T->isReferenceType() || T->isPointerType())
    return nullptr;
  return Decl;
}
 
static bool mayHoldPointerTo(QualType ViewType, QualType CanBorrowType) {
  if (ViewType.isNull() || CanBorrowType.isNull())
    return false;
 
  if (QualType Pointee = ViewType->getPointeeType(); !Pointee.isNull())
    return isSameRecord(Pointee, CanBorrowType);
 
  auto *Record = ViewType->getAsCXXRecordDecl();
  if (!Record)
    return false;
  if (isBorrow(Record))
    return isSameRecord(borrowedType(ViewType), CanBorrowType);
  Record = Record->getDefinition();
  if (!Record)
    return true;
 
  return llvm::any_of(Record->fields(),
                      [&](const FieldDecl *Field) {
                        return mayHoldPointerTo(Field->getType(),
                                                CanBorrowType);
                      }) ||
         llvm::any_of(Record->bases(), [&](const CXXBaseSpecifier &Base) {
           return mayHoldPointerTo(Base.getType(), CanBorrowType);
         });
}
 
class BorrowSafetyModel : public PtrRefSafetyModel {
public:
  std::optional<bool> isUnsafeType(QualType QT) const override {
    return isView(QT);
  }
  std::optional<bool> isUnsafePtr(QualType QT, bool) const override {
    return isView(QT);
  }
  bool isSafePtr(const CXXRecordDecl *Record) const override {
    return isBorrow(Record);
  }
  bool isSafePtrType(QualType T) const override { return isBorrowType(T); }
  bool isPtrType(const std::string &Name) const override {
    return isBorrow(Name);
  }
 
  bool isSafeExpr(const Expr *Origin, bool PtrIsLifetimeBoundToOrigin,
                  QualType SinkType, bool SinkMayEscape) const override {
    QualType OriginType = pointeeType(Origin->getType());
    if (OriginType.isNull())
      return true;
 
    // A Borrow or a non-global const object guards a loan only within its own
    // scope, so neither vouches for a sink that may outlive that scope. This
    // holds for a reference to the Borrow itself, not just a loan through it.
    if (isBorrowType(OriginType))
      return !SinkMayEscape;
 
    if (!PtrIsLifetimeBoundToOrigin)
      return true;
 
    if (const ValueDecl *ConstObject = constDeclaredObject(Origin)) {
      auto *ConstVar = dyn_cast<VarDecl>(ConstObject);
      if (!SinkMayEscape || (ConstVar && ConstVar->hasGlobalStorage()))
        return true;
    }
 
    if (Origin->isPRValue() &&
        isCanBorrowType(Origin->getType()).value_or(false) &&
        !SinkType.isNull() && !mayHoldPointerTo(SinkType, Origin->getType()))
      return true;
 
    auto *Record = OriginType->getAsCXXRecordDecl();
    if (!Record)
      return true;
 
    auto Borrowable = isBorrowable(Record);
    return !Borrowable || !*Borrowable;
  }
 
  bool checksForInteriorDestruction() const override { return true; }
  bool recognizesIndirectStores() const override { return true; }
  const char *typeName() const override { return "CanBorrow type"; }
 
  void describeHazard(llvm::raw_ostream &Os, const Expr *Origin,
                      QualType SinkType) const override {
    QualType SinkObject = pointeeType(SinkType);
    if (!SinkObject.isNull() && isBorrowType(SinkObject)) {
      Os << "Borrow that does not travel with the lambda";
      return;
    }
 
    Os << "loan on ";
    QualType OriginType = Origin ? pointeeType(Origin->getType()) : QualType();
 
    // Name the borrowed type, not the Borrow<T> guard, when the loan was
    // taken from a Borrow<T>.
    if (!OriginType.isNull() && isBorrowType(OriginType))
      OriginType = borrowedType(OriginType);
 
    if (!OriginType.isNull() && OriginType->getAsRecordDecl()) {
      Os << "CanBorrow type ";
      printTypeName(Os, OriginType);
    } else
      Os << "a CanBorrow object";
    Os << " that is not guarded by const or a Borrow";
  }
};
 
} // namespace
 
std::optional<bool> clang::isUnsafePtrForStorage(const PtrRefSafetyModel &Model,
                                                 QualType T, bool IgnoreARC) {
  // A __strong / __weak Objective-C storage location is memory managed and
  // thus safe. This exemption applies to variables/members/captures but not to
  // call arguments, so it lives here rather than in the policy itself.
  if (Model.retainTypeChecker() && T.hasStrongOrWeakObjCLifetime())
    return false;
  return Model.isUnsafePtr(T, IgnoreARC);
}
 
std::unique_ptr<PtrRefSafetyModel> clang::makeRefPtrSafetyModel() {
  return std::make_unique<RefCountedSafetyModel>();
}
 
std::unique_ptr<PtrRefSafetyModel> clang::makeCheckedPtrSafetyModel() {
  return std::make_unique<CheckedPtrSafetyModel>();
}
 
std::unique_ptr<PtrRefSafetyModel> clang::makeRetainPtrSafetyModel() {
  return std::make_unique<RetainPtrSafetyModel>();
}
 
std::unique_ptr<PtrRefSafetyModel> clang::makeBorrowSafetyModel() {
  return std::make_unique<BorrowSafetyModel>();
}