UninitializedPointee.cpp

Go to the documentation of this file.

//===----- UninitializedPointee.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 functions and methods for handling pointers and references
// to reduce the size and complexity of UninitializedObjectChecker.cpp.
//
// To read about command line options and documentation about how the checker
// works, refer to UninitializedObjectChecker.h.
//
//===----------------------------------------------------------------------===//
 
#include "UninitializedObject.h"
#include <optional>
 
using namespace clang;
using namespace clang::ento;
 
namespace {
 
/// Represents a pointer or a reference field.
class LocField final : public FieldNode {
  /// We'll store whether the pointee or the pointer itself is uninitialited.
  const bool IsDereferenced;
 
public:
  LocField(const FieldRegion *FR, const bool IsDereferenced = true)
      : FieldNode(FR), IsDereferenced(IsDereferenced) {}
 
  void printNoteMsg(llvm::raw_ostream &Out) const override {
    if (IsDereferenced)
      Out << "uninitialized pointee ";
    else
      Out << "uninitialized pointer ";
  }
 
  void printPrefix(llvm::raw_ostream &Out) const override {}
 
  void printNode(llvm::raw_ostream &Out) const override {
    Out << getVariableName(getDecl());
  }
 
  void printSeparator(llvm::raw_ostream &Out) const override {
    if (getDecl()->getType()->isPointerType())
      Out << "->";
    else
      Out << '.';
  }
};
 
/// Represents a nonloc::LocAsInteger or void* field, that point to objects, but
/// needs to be casted back to its dynamic type for a correct note message.
class NeedsCastLocField final : public FieldNode {
  QualType CastBackType;
 
public:
  NeedsCastLocField(const FieldRegion *FR, const QualType &T)
      : FieldNode(FR), CastBackType(T) {}
 
  void printNoteMsg(llvm::raw_ostream &Out) const override {
    Out << "uninitialized pointee ";
  }
 
  void printPrefix(llvm::raw_ostream &Out) const override {
    // If this object is a nonloc::LocAsInteger.
    if (getDecl()->getType()->isIntegerType())
      Out << "reinterpret_cast";
    // If this pointer's dynamic type is different then it's static type.
    else
      Out << "static_cast";
    Out << '<' << CastBackType.getAsString() << ">(";
  }
 
  void printNode(llvm::raw_ostream &Out) const override {
    Out << getVariableName(getDecl()) << ')';
  }
 
  void printSeparator(llvm::raw_ostream &Out) const override { Out << "->"; }
};
 
/// Represents a Loc field that points to itself.
class CyclicLocField final : public FieldNode {
 
public:
  CyclicLocField(const FieldRegion *FR) : FieldNode(FR) {}
 
  void printNoteMsg(llvm::raw_ostream &Out) const override {
    Out << "object references itself ";
  }
 
  void printPrefix(llvm::raw_ostream &Out) const override {}
 
  void printNode(llvm::raw_ostream &Out) const override {
    Out << getVariableName(getDecl());
  }
 
  void printSeparator(llvm::raw_ostream &Out) const override {
    llvm_unreachable("CyclicLocField objects must be the last node of the "
                     "fieldchain!");
  }
};
 
} // end of anonymous namespace
 
// Utility function declarations.
 
struct DereferenceInfo {
  const TypedValueRegion *R;
  const bool NeedsCastBack;
  const bool IsCyclic;
  DereferenceInfo(const TypedValueRegion *R, bool NCB, bool IC)
      : R(R), NeedsCastBack(NCB), IsCyclic(IC) {}
};
 
/// Dereferences \p FR and returns with the pointee's region, and whether it
/// needs to be casted back to it's location type. If for whatever reason
/// dereferencing fails, returns std::nullopt.
static std::optional<DereferenceInfo> dereference(ProgramStateRef State,
                                                  const FieldRegion *FR);
 
/// Returns whether \p T can be (transitively) dereferenced to a void pointer
/// type (void*, void**, ...).
static bool isVoidPointer(QualType T);
 
//===----------------------------------------------------------------------===//
//                   Methods for FindUninitializedFields.
//===----------------------------------------------------------------------===//
 
bool FindUninitializedFields::isDereferencableUninit(
    const FieldRegion *FR, FieldChainInfo LocalChain) {
 
  SVal V = State->getSVal(FR);
 
  assert((isDereferencableType(FR->getDecl()->getType()) ||
          isa<nonloc::LocAsInteger>(V)) &&
         "This method only checks dereferenceable objects!");
 
  if (V.isUnknown() || isa<loc::ConcreteInt>(V)) {
    IsAnyFieldInitialized = true;
    return false;
  }
 
  if (V.isUndef()) {
    return addFieldToUninits(
        LocalChain.add(LocField(FR, /*IsDereferenced*/ false)), FR);
  }
 
  if (!Opts.CheckPointeeInitialization) {
    IsAnyFieldInitialized = true;
    return false;
  }
 
  // At this point the pointer itself is initialized and points to a valid
  // location, we'll now check the pointee.
  std::optional<DereferenceInfo> DerefInfo = dereference(State, FR);
  if (!DerefInfo) {
    IsAnyFieldInitialized = true;
    return false;
  }
 
  if (DerefInfo->IsCyclic)
    return addFieldToUninits(LocalChain.add(CyclicLocField(FR)), FR);
 
  const TypedValueRegion *R = DerefInfo->R;
  const bool NeedsCastBack = DerefInfo->NeedsCastBack;
 
  QualType DynT = R->getLocationType();
  QualType PointeeT = DynT->getPointeeType();
 
  if (PointeeT->isStructureOrClassType()) {
    if (NeedsCastBack)
      return isNonUnionUninit(R, LocalChain.add(NeedsCastLocField(FR, DynT)));
    return isNonUnionUninit(R, LocalChain.add(LocField(FR)));
  }
 
  if (PointeeT->isUnionType()) {
    if (isUnionUninit(R)) {
      if (NeedsCastBack)
        return addFieldToUninits(LocalChain.add(NeedsCastLocField(FR, DynT)),
                                 R);
      return addFieldToUninits(LocalChain.add(LocField(FR)), R);
    } else {
      IsAnyFieldInitialized = true;
      return false;
    }
  }
 
  if (PointeeT->isArrayType()) {
    IsAnyFieldInitialized = true;
    return false;
  }
 
  assert((isPrimitiveType(PointeeT) || isDereferencableType(PointeeT)) &&
         "At this point FR must either have a primitive dynamic type, or it "
         "must be a null, undefined, unknown or concrete pointer!");
 
  SVal PointeeV = State->getSVal(R);
 
  if (isPrimitiveUninit(PointeeV)) {
    if (NeedsCastBack)
      return addFieldToUninits(LocalChain.add(NeedsCastLocField(FR, DynT)), R);
    return addFieldToUninits(LocalChain.add(LocField(FR)), R);
  }
 
  IsAnyFieldInitialized = true;
  return false;
}
 
//===----------------------------------------------------------------------===//
//                           Utility functions.
//===----------------------------------------------------------------------===//
 
static std::optional<DereferenceInfo> dereference(ProgramStateRef State,
                                                  const FieldRegion *FR) {
 
  llvm::SmallPtrSet<const TypedValueRegion *, 5> VisitedRegions;
 
  SVal V = State->getSVal(FR);
  assert(V.getAsRegion() && "V must have an underlying region!");
 
  // If the static type of the field is a void pointer, or it is a
  // nonloc::LocAsInteger, we need to cast it back to the dynamic type before
  // dereferencing.
  bool NeedsCastBack =
      isVoidPointer(FR->getDecl()->getType()) || isa<nonloc::LocAsInteger>(V);
 
  // The region we'd like to acquire.
  const auto *R = V.getAsRegion()->getAs<TypedValueRegion>();
  if (!R)
    return std::nullopt;
 
  VisitedRegions.insert(R);
 
  // We acquire the dynamic type of R,
  QualType DynT = R->getLocationType();
 
  while (const MemRegion *Tmp = State->getSVal(R, DynT).getAsRegion()) {
 
    R = Tmp->getAs<TypedValueRegion>();
    if (!R)
      return std::nullopt;
 
    // We found a cyclic pointer, like int *ptr = (int *)&ptr.
    if (!VisitedRegions.insert(R).second)
      return DereferenceInfo{R, NeedsCastBack, /*IsCyclic*/ true};
 
    DynT = R->getLocationType();
    // In order to ensure that this loop terminates, we're also checking the
    // dynamic type of R, since type hierarchy is finite.
    if (isDereferencableType(DynT->getPointeeType()))
      break;
  }
 
  while (isa<CXXBaseObjectRegion>(R)) {
    NeedsCastBack = true;
    const auto *SuperR = dyn_cast<TypedValueRegion>(R->getSuperRegion());
    if (!SuperR)
      break;
 
    R = SuperR;
  }
 
  return DereferenceInfo{R, NeedsCastBack, /*IsCyclic*/ false};
}
 
static bool isVoidPointer(QualType T) {
  while (!T.isNull()) {
    if (T->isVoidPointerType())
      return true;
    T = T->getPointeeType();
  }
  return false;
}