ArrayBoundChecker.cpp

Go to the documentation of this file.

//== ArrayBoundChecker.cpp -------------------------------------------------==//
//
// 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 security.ArrayBound, which is a path-sensitive checker
// that looks for out of bounds access of memory regions.
//
//===----------------------------------------------------------------------===//
 
#include "clang/AST/CharUnits.h"
#include "clang/AST/ParentMapContext.h"
#include "clang/StaticAnalyzer/Checkers/BoundsChecking.h"
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Checkers/Taint.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/APSIntType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicExtent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/raw_ostream.h"
#include <optional>
 
using namespace clang;
using namespace ento;
using namespace taint;
using llvm::formatv;
 
namespace {
/// If `E` is an array subscript expression with a base that is "clean" (= not
/// modified by pointer arithmetic = the beginning of a memory region), return
/// it as a pointer to ArraySubscriptExpr; otherwise return nullptr.
/// This helper function is used by two separate heuristics that are only valid
/// in these "clean" cases.
static const ArraySubscriptExpr *
getAsCleanArraySubscriptExpr(const Expr *E, const CheckerContext &C) {
  const auto *ASE = dyn_cast<ArraySubscriptExpr>(E);
  if (!ASE)
    return nullptr;
 
  const MemRegion *SubscriptBaseReg = C.getSVal(ASE->getBase()).getAsRegion();
  if (!SubscriptBaseReg)
    return nullptr;
 
  // The base of the subscript expression is affected by pointer arithmetics,
  // so we want to report byte offsets instead of indices and we don't want to
  // activate the "index is unsigned -> cannot be negative" shortcut.
  if (isa<ElementRegion>(SubscriptBaseReg->StripCasts()))
    return nullptr;
 
  return ASE;
}
 
class SizeUnit {
  QualType AsType;
  int64_t AsCharUnits;
 
  SizeUnit() : AsType(), AsCharUnits(1) {}
 
public:
  SizeUnit(QualType T, const ASTContext &ACtx)
      : AsType(T), AsCharUnits(ACtx.getTypeSizeInChars(T).getQuantity()) {
    assert(!T.isNull());
  }
 
  static SizeUnit bytes() { return SizeUnit(); }
 
  bool isBytes() const { return AsType.isNull(); }
 
  /// Return the element type that is "natural" for reporting out-of-bounds
  /// memory access to \p ER.
  static SizeUnit forElementRegion(const ElementRegion *ER,
                                   const ASTContext &ACtx) {
    return SizeUnit(ER->getElementType(), ACtx);
  }
 
  /// If `E` is a "clean" array subscript expression, return the type of the
  /// accessed element; otherwise return 'Bytes' because that's the best (or
  /// least bad) option for the assumption messages that use this.
  /// FIXME: It is unfortunate that this heuristic differs from the heuristic
  /// used for reporting assumption; but this difference is currently needed
  /// due to the unfortunate phrasing of the assumption messages.
  /// Get rid of this when the assumption note is rephrased and improved.
  static SizeUnit forExpr(const Expr *E, const CheckerContext &C) {
    const auto *ASE = getAsCleanArraySubscriptExpr(E, C);
    if (!ASE)
      return bytes();
 
    return SizeUnit(ASE->getType(), C.getASTContext());
  }
 
  int64_t asCharUnits() const { return AsCharUnits; }
 
  bool canExpress(std::optional<int64_t> Val) const {
    return asCharUnits() && (!Val || !(*Val % asCharUnits()));
  }
 
  std::string asExtentDesc() const {
    if (isBytes())
      return "the extent of";
    return formatv("the number of '{0}' elements in", AsType.getAsString());
  }
 
  std::string asElementName() const {
    if (isBytes())
      return "byte";
    return formatv("'{0}' element", AsType.getAsString());
  }
};
 
/// Strings that will be passed to the parameters 'desc' and 'fullDesc' of the
/// constructor of 'PathSensitiveBugReport'.
struct BugDescription {
  std::string Short;
  std::string Full;
};
 
// NOTE: The `ArraySubscriptExpr` and `UnaryOperator` callbacks are `PostStmt`
// instead of `PreStmt` because the current implementation passes the whole
// expression to `CheckerContext::getSVal()` which only works after the
// symbolic evaluation of the expression. (To turn them into `PreStmt`
// callbacks, we'd need to duplicate the logic that evaluates these
// expressions.) The `MemberExpr` callback would work as `PreStmt` but it's
// defined as `PostStmt` for the sake of consistency with the other callbacks.
class ArrayBoundChecker : public Checker<check::PostStmt<ArraySubscriptExpr>,
                                         check::PostStmt<UnaryOperator>,
                                         check::PostStmt<MemberExpr>> {
  BugType BT{this, "Out-of-bound access"};
  BugType TaintBT{this, "Out-of-bound access", categories::TaintedData};
 
  void handleAccessExpr(const Expr *E, CheckerContext &C) const;
 
  void reportOOB(CheckerContext &C, ProgramStateRef ErrorState,
                 BugDescription Desc, NonLoc Offset,
                 std::optional<NonLoc> Extent, bool IsTaintBug = false) const;
 
  static void markPartsInteresting(PathSensitiveBugReport &BR,
                                   ProgramStateRef ErrorState, NonLoc Val,
                                   bool MarkTaint);
 
  static bool isFromCtypeMacro(const Expr *E, ASTContext &AC);
 
  static bool isOffsetObviouslyNonnegative(const Expr *E, CheckerContext &C);
 
  static bool isInAddressOf(const Stmt *S, ASTContext &AC);
 
public:
  void checkPostStmt(const ArraySubscriptExpr *E, CheckerContext &C) const {
    handleAccessExpr(E, C);
  }
  void checkPostStmt(const UnaryOperator *E, CheckerContext &C) const {
    if (E->getOpcode() == UO_Deref)
      handleAccessExpr(E, C);
  }
  void checkPostStmt(const MemberExpr *E, CheckerContext &C) const {
    if (E->isArrow())
      handleAccessExpr(E->getBase(), C);
  }
};
 
} // anonymous namespace
 
/// Return true if information about the value of \p SV can put constraints
/// on some symbol which is interesting within the bug report \p BR.
/// In particular, this returns true when \p SV is interesting within \p BR;
/// but it also returns true if \p SV is an expression that contains integer
/// constants and a single symbolic operand which is interesting (in \p BR).
/// We need to use this instead of plain `BR.isInteresting()` because if we
/// are analyzing code like
///   int array[10];
///   int f(int arg) {
///     return array[arg] && array[arg + 10];
///   }
/// then the byte offsets are `arg * 4` and `(arg + 10) * 4`, which are not
/// sub-expressions of each other (but `getSimplifiedOffsets` is smart enough
/// to detect this out of bounds access).
static bool isDeterminedByInterestingSymbol(SVal SV,
                                            PathSensitiveBugReport &BR) {
  SymbolRef Sym = SV.getAsSymbol();
  if (!Sym)
    return false;
  for (SymbolRef PartSym : Sym->symbols()) {
    // The interestingess mark may appear on any layer as we're stripping off
    // the SymIntExpr, UnarySymExpr etc. layers...
    if (BR.isInteresting(PartSym))
      return true;
    // ...but if both sides of the expression are symbolic, then there is no
    // practical algorithm to produce separate constraints for the two
    // operands (from the single combined result).
    if (isa<SymSymExpr>(PartSym))
      return false;
  }
  return false;
}
 
static int64_t getElementSize(const ElementRegion *ER, SValBuilder &SVB) {
  QualType ElemType = ER->getElementType();
 
  assert(!ElemType->isIncompleteType() && "ElemType cannot be incomplete");
 
  return SVB.getContext().getTypeSizeInChars(ElemType).getQuantity();
}
 
/// For a given \p CurRegion that can be represented as a symbolic expression
/// Arr[Idx] (or perhaps Arr[Idx1][Idx2] etc.), return the parent memory block
/// Arr and the distance of Location from the beginning of Arr (expressed in a
/// NonLoc that specifies the number of CharUnits). Returns nullopt when these
/// cannot be determined.
static std::optional<std::pair<const SubRegion *, NonLoc>>
computeOffset(ProgramStateRef State, SValBuilder &SVB,
              const ElementRegion *CurRegion) {
  QualType T = SVB.getArrayIndexType();
  auto EvalBinOp = [&SVB, State, T](BinaryOperatorKind Op, NonLoc L, NonLoc R) {
    // We will use this utility to add and multiply values.
    return SVB.evalBinOpNN(State, Op, L, R, T).getAs<NonLoc>();
  };
 
  const SubRegion *OwnerRegion = nullptr;
  std::optional<NonLoc> Offset = SVB.makeZeroArrayIndex();
 
  while (CurRegion) {
    const auto Index = CurRegion->getIndex().getAs<NonLoc>();
    if (!Index)
      return std::nullopt;
 
    // Calculate Delta = Index * sizeof(ElemType).
    NonLoc Size = SVB.makeArrayIndex(getElementSize(CurRegion, SVB));
    auto Delta = EvalBinOp(BO_Mul, *Index, Size);
    if (!Delta)
      return std::nullopt;
 
    // Perform Offset += Delta.
    Offset = EvalBinOp(BO_Add, *Offset, *Delta);
    if (!Offset)
      return std::nullopt;
 
    OwnerRegion = CurRegion->getSuperRegion()->getAs<SubRegion>();
    // When this is just another ElementRegion layer, we need to continue the
    // offset calculations:
    CurRegion = dyn_cast_or_null<ElementRegion>(OwnerRegion);
  }
 
  if (OwnerRegion)
    return std::make_pair(OwnerRegion, *Offset);
 
  return std::nullopt;
}
 
static std::optional<int64_t> getConcreteValue(NonLoc SV) {
  if (auto ConcreteVal = SV.getAs<nonloc::ConcreteInt>()) {
    return ConcreteVal->getValue()->tryExtValue();
  }
  return std::nullopt;
}
 
static std::optional<int64_t> getConcreteValue(std::optional<NonLoc> SV) {
  return SV ? getConcreteValue(*SV) : std::nullopt;
}
 
static StringRef getAdjective(const bounds::CheckResult &R) {
  return (R.mayUnderflow()
              ? (R.mayOverflow() ? "a negative or overflowing" : "a negative")
              : (R.mayOverflow() ? "an overflowing" : "a valid"));
}
 
static StringRef getPreposition(const bounds::CheckResult &R) {
  return (R.mayUnderflow() ? (R.mayOverflow() ? "around" : "preceding")
                           : (R.mayOverflow() ? "after the end of" : "within"));
}
 
static BugDescription describeInvalidAccess(bounds::CheckResult Res,
                                            StringRef RegName, SizeUnit SU) {
  assert(Res.mayBeInvalid());
 
  std::optional<int64_t> OffsetN = getConcreteValue(Res.getOffset());
  std::optional<int64_t> ExtentN =
      getConcreteValue(Res.getExtentIfMayOverflow());
 
  if (SU.canExpress(OffsetN) && SU.canExpress(ExtentN)) {
    if (OffsetN)
      *OffsetN /= SU.asCharUnits();
    if (ExtentN)
      *ExtentN /= SU.asCharUnits();
  } else {
    // Fall back to reporting the offsets in bytes.
    SU = SizeUnit::bytes();
  }
 
  StringRef OffsetOrIndex = SU.isBytes() ? "byte offset" : "index";
 
  SmallString<256> Buf;
  llvm::raw_svector_ostream Out(Buf);
  Out << "Access of ";
  if (OffsetN && !ExtentN && !SU.isBytes()) {
    // If the offset is reported as an index, then the report must mention the
    // element type (because it is not always clear from the code). It's more
    // natural to mention the element type later where the extent is described,
    // but if the extent is unknown/irrelevant, then the element type can be
    // inserted into the message at this point.
    Out << SU.asElementName() << " in ";
  }
  Out << RegName << " at ";
  if (OffsetN) {
    if (Res.mayUnderflow() && !Res.mayOverflow())
      Out << "negative ";
    Out << OffsetOrIndex << " " << *OffsetN;
  } else {
    Out << getAdjective(Res) << " " << OffsetOrIndex;
  }
  if (ExtentN) {
    Out << ", while it holds only ";
    if (*ExtentN != 1)
      Out << *ExtentN;
    else
      Out << "a single";
 
    Out << ' ' << SU.asElementName();
 
    if (*ExtentN != 1)
      Out << "s";
  }
 
  return {formatv("Out of bound access to memory {0} {1}", getPreposition(Res),
                  RegName),
          std::string(Buf)};
}
 
static BugDescription describeTaintBug(bounds::CheckResult Res,
                                       StringRef RegName,
                                       StringRef OffsetName) {
  assert(Res.mayBeInvalid());
  return {formatv("Potential out of bound access to {0} with tainted {1}",
                  RegName, OffsetName),
          formatv("Access of {0} with a tainted {1} that may be{2}{3}{4}",
                  RegName, OffsetName, Res.mayUnderflow() ? " negative" : "",
                  (Res.mayUnderflow() && Res.mayOverflow()) ? " or" : "",
                  Res.mayOverflow() ? " too large" : "")};
}
 
/// When the access was ambiguous (that is, mayBeInBounds() && mayBeInvalid()),
/// returns the note "assuming in bounds" note that is relevant for the bug
/// report \p BR. When the access wasn't ambiguous or the the assumption is
/// irrelevant for \p BR, this returns the empty string (which signifies "do
/// not emit a note tag" when returned by a note tag callback).
static std::string getAssumptionNote(bounds::CheckResult Res,
                                     PathSensitiveBugReport &BR,
                                     StringRef RegName, SizeUnit SU) {
  bool ShouldReportNonNegative = Res.mayUnderflow();
  if (!isDeterminedByInterestingSymbol(Res.getOffset(), BR)) {
    std::optional<NonLoc> E = Res.getExtentIfMayOverflow();
    if (E && isDeterminedByInterestingSymbol(*E, BR)) {
      // Even if the byte offset isn't interesting (e.g. it's a constant value),
      // the assumption can still be interesting if it provides information
      // about an interesting symbolic upper bound.
      ShouldReportNonNegative = false;
    } else {
      // We don't have anything interesting, don't report the assumption.
      return "";
    }
  }
 
  std::optional<int64_t> OffsetN = getConcreteValue(Res.getOffset());
  std::optional<int64_t> ExtentN =
      getConcreteValue(Res.getExtentIfMayOverflow());
 
  if (SU.canExpress(OffsetN) && SU.canExpress(ExtentN)) {
    if (OffsetN)
      *OffsetN /= SU.asCharUnits();
    if (ExtentN)
      *ExtentN /= SU.asCharUnits();
  } else {
    // Fall back to reporting the offsets in bytes.
    SU = SizeUnit::bytes();
  }
 
  SmallString<256> Buf;
  llvm::raw_svector_ostream Out(Buf);
  Out << "Assuming ";
  if (!SU.isBytes()) {
    Out << "index ";
    if (OffsetN)
      Out << "'" << OffsetN << "' ";
  } else if (Res.mayOverflow()) {
    Out << "byte offset ";
    if (OffsetN)
      Out << "'" << OffsetN << "' ";
  } else {
    Out << "offset ";
  }
 
  Out << "is";
  if (ShouldReportNonNegative) {
    Out << " non-negative";
  }
  if (Res.mayOverflow()) {
    if (ShouldReportNonNegative)
      Out << " and";
    Out << " less than ";
    if (ExtentN)
      Out << *ExtentN << ", ";
    Out << SU.asExtentDesc() << ' ' << RegName;
  }
  return std::string(Out.str());
}
 
void ArrayBoundChecker::handleAccessExpr(const Expr *E,
                                         CheckerContext &C) const {
  ASTContext &ACtx = C.getASTContext();
  const ElementRegion *AccessedER =
      dyn_cast_or_null<ElementRegion>(C.getSVal(E).getAsRegion());
  if (!AccessedER)
    return;
 
  // The header ctype.h (from e.g. glibc) implements the isXXXXX() macros as
  //   #define isXXXXX(arg) (LOOKUP_TABLE[arg] & BITMASK_FOR_XXXXX)
  // and incomplete analysis of these leads to false positives. As even
  // accurate reports would be confusing for the users, just disable reports
  // from these macros:
  if (isFromCtypeMacro(E, ACtx))
    return;
 
  ProgramStateRef State = C.getState();
  SValBuilder &SVB = C.getSValBuilder();
 
  const std::optional<std::pair<const SubRegion *, NonLoc>> &RawOffset =
      computeOffset(State, SVB, AccessedER);
 
  if (!RawOffset)
    return;
 
  auto [Reg, ByteOffset] = *RawOffset;
 
  const MemSpaceRegion *Space = Reg->getMemorySpace(State);
  auto Extent = getDynamicExtent(State, Reg, SVB).getAs<NonLoc>();
 
  // A symbolic region in unknown space represents an unknown pointer that
  // may point into the middle of an array, so we don't look for underflows.
  // Both conditions are significant because we want to check underflows in
  // symbolic regions on the heap (which may be introduced by checkers like
  // MallocChecker that call SValBuilder::getConjuredHeapSymbolVal()) and
  // non-symbolic regions (e.g. a field subregion of a symbolic region) in
  // unknown space.
 
  bounds::CheckFlags Flags = {
      /*CheckUnderflow=*/!(isa<SymbolicRegion>(Reg) &&
                           isa<UnknownSpaceRegion>(Space)),
      /*OffsetObviouslyNonnegative=*/isOffsetObviouslyNonnegative(E, C),
      /*AlsoAcceptEquality=*/(getElementSize(AccessedER, SVB) == 0)};
 
  bounds::CheckResult Res = checkBounds(State, SVB, ByteOffset, Extent, Flags);
 
  if (Res.isCorruptedState()) {
    C.addSink();
    return;
  }
 
  std::string RegName =
      Reg->getDescriptiveName(/*UseQuotes=*/true, /*AllowFallback=*/true);
 
  const NoteTag *T = nullptr;
  if (Res.mayBeInvalid()) {
    if (!Res.mayBeInBounds()) {
      if (isa<ArraySubscriptExpr>(E) && isInAddressOf(E, ACtx) && Extent) {
        // Recognize and accept the idiomatic `&array[size]` expression that
        // forms the past-the-end pointer without actually dereferencing it.
        auto [EqualsToThreshold, NotEqualToThreshold] =
            bounds::compareValueToThreshold(State, SVB, ByteOffset, *Extent,
                                            bounds::Comparison::EQ);
        if (EqualsToThreshold && !NotEqualToThreshold) {
          C.addTransition(EqualsToThreshold);
          return;
        }
      }
 
      SizeUnit SU = SizeUnit::forElementRegion(AccessedER, ACtx);
      BugDescription Desc = describeInvalidAccess(Res, RegName, SU);
      reportOOB(C, State, Desc, ByteOffset, Res.getExtentIfMayOverflow());
      return;
    }
 
    if (isTainted(State, ByteOffset)) {
      // Diagnostic detail: saying "tainted offset" is always correct, but
      // the common case is that 'idx' is tainted in 'arr[idx]' and then it's
      // nicer to say "tainted index".
      StringRef OffsetName = "offset";
      if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(E))
        if (isTainted(State, ASE->getIdx(), C.getStackFrame()))
          OffsetName = "index";
 
      BugDescription Desc = describeTaintBug(Res, RegName, OffsetName);
      reportOOB(C, State, Desc, ByteOffset, Res.getExtentIfMayOverflow(),
                /*IsTaintBug=*/true);
      return;
    }
 
    SizeUnit SU = SizeUnit::forExpr(E, C);
    T = C.getNoteTag(
        [Res, RegName, SU](PathSensitiveBugReport &BR) -> std::string {
          return getAssumptionNote(Res, BR, RegName, SU);
        });
  }
 
  C.addTransition(Res.getInBoundsState(), T);
}
 
void ArrayBoundChecker::markPartsInteresting(PathSensitiveBugReport &BR,
                                             ProgramStateRef ErrorState,
                                             NonLoc Val, bool MarkTaint) {
  if (SymbolRef Sym = Val.getAsSymbol()) {
    // If the offset is a symbolic value, iterate over its "parts" with
    // `SymExpr::symbols()` and mark each of them as interesting.
    // For example, if the offset is `x*4 + y` then we put interestingness onto
    // the SymSymExpr `x*4 + y`, the SymIntExpr `x*4` and the two data symbols
    // `x` and `y`.
    for (SymbolRef PartSym : Sym->symbols())
      BR.markInteresting(PartSym);
  }
 
  if (MarkTaint) {
    // If the issue that we're reporting depends on the taintedness of the
    // offset, then put interestingness onto symbols that could be the origin
    // of the taint. Note that this may find symbols that did not appear in
    // `Sym->symbols()` (because they're only loosely connected to `Val`).
    for (SymbolRef Sym : getTaintedSymbols(ErrorState, Val))
      BR.markInteresting(Sym);
  }
}
 
void ArrayBoundChecker::reportOOB(CheckerContext &C, ProgramStateRef ErrorState,
                                  BugDescription Desc, NonLoc Offset,
                                  std::optional<NonLoc> Extent,
                                  bool IsTaintBug /*=false*/) const {
 
  ExplodedNode *ErrorNode = C.generateErrorNode(ErrorState);
  if (!ErrorNode)
    return;
 
  auto BR = std::make_unique<PathSensitiveBugReport>(
      IsTaintBug ? TaintBT : BT, Desc.Short, Desc.Full, ErrorNode);
 
  // FIXME: ideally we would just call trackExpressionValue() and that would
  // "do the right thing": mark the relevant symbols as interesting, track the
  // control dependencies and statements storing the relevant values and add
  // helpful diagnostic pieces. However, right now trackExpressionValue() is
  // a heap of unreliable heuristics, so it would cause several issues:
  // - Interestingness is not applied consistently, e.g. if `array[x+10]`
  //   causes an overflow, then `x` is not marked as interesting.
  // - We get irrelevant diagnostic pieces, e.g. in the code
  //   `int *p = (int*)malloc(2*sizeof(int)); p[3] = 0;`
  //   it places a "Storing uninitialized value" note on the `malloc` call
  //   (which is technically true, but irrelevant).
  // If trackExpressionValue() becomes reliable, it should be applied instead
  // of this custom markPartsInteresting().
  markPartsInteresting(*BR, ErrorState, Offset, IsTaintBug);
  if (Extent)
    markPartsInteresting(*BR, ErrorState, *Extent, IsTaintBug);
 
  C.emitReport(std::move(BR));
}
 
bool ArrayBoundChecker::isFromCtypeMacro(const Expr *E, ASTContext &ACtx) {
  SourceLocation Loc = E->getBeginLoc();
  if (!Loc.isMacroID())
    return false;
 
  StringRef MacroName = Lexer::getImmediateMacroName(
      Loc, ACtx.getSourceManager(), ACtx.getLangOpts());
 
  if (MacroName.size() < 7 || MacroName[0] != 'i' || MacroName[1] != 's')
    return false;
 
  return ((MacroName == "isalnum") || (MacroName == "isalpha") ||
          (MacroName == "isblank") || (MacroName == "isdigit") ||
          (MacroName == "isgraph") || (MacroName == "islower") ||
          (MacroName == "isnctrl") || (MacroName == "isprint") ||
          (MacroName == "ispunct") || (MacroName == "isspace") ||
          (MacroName == "isupper") || (MacroName == "isxdigit"));
}
 
bool ArrayBoundChecker::isOffsetObviouslyNonnegative(const Expr *E,
                                                     CheckerContext &C) {
  const ArraySubscriptExpr *ASE = getAsCleanArraySubscriptExpr(E, C);
  if (!ASE)
    return false;
  return ASE->getIdx()->getType()->isUnsignedIntegerOrEnumerationType();
}
 
bool ArrayBoundChecker::isInAddressOf(const Stmt *S, ASTContext &ACtx) {
  ParentMapContext &ParentCtx = ACtx.getParentMapContext();
  do {
    const DynTypedNodeList Parents = ParentCtx.getParents(*S);
    if (Parents.empty())
      return false;
    S = Parents[0].get<Stmt>();
  } while (isa_and_nonnull<ParenExpr, ImplicitCastExpr>(S));
  const auto *UnaryOp = dyn_cast_or_null<UnaryOperator>(S);
  return UnaryOp && UnaryOp->getOpcode() == UO_AddrOf;
}
 
void ento::registerArrayBoundChecker(CheckerManager &mgr) {
  mgr.registerChecker<ArrayBoundChecker>();
}
 
bool ento::shouldRegisterArrayBoundChecker(const CheckerManager &mgr) {
  return true;
}