ExprEngine.cpp

Go to the documentation of this file.

//===- ExprEngine.cpp - Path-Sensitive Expression-Level Dataflow ----------===//
//
// 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 a meta-engine for path-sensitive dataflow analysis that
//  is built on CoreEngine, but provides the boilerplate to execute transfer
//  functions and build the ExplodedGraph at the expression level.
//
//===----------------------------------------------------------------------===//
 
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
#include "PrettyStackTraceStackFrame.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/ParentMap.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtCXX.h"
#include "clang/AST/StmtObjC.h"
#include "clang/AST/Type.h"
#include "clang/Analysis/AnalysisDeclContext.h"
#include "clang/Analysis/CFG.h"
#include "clang/Analysis/ConstructionContext.h"
#include "clang/Analysis/ProgramPoint.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/JsonSupport.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/PrettyStackTrace.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/Specifiers.h"
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicExtent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/ImmutableMap.h"
#include "llvm/ADT/ImmutableSet.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DOTGraphTraits.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/GraphWriter.h"
#include "llvm/Support/IOSandbox.h"
#include "llvm/Support/TimeProfiler.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
using namespace clang;
using namespace ento;
 
#define DEBUG_TYPE "ExprEngine"
 
STAT_COUNTER(NumRemoveDeadBindings,
             "The # of times RemoveDeadBindings is called");
STAT_COUNTER(
    NumMaxBlockCountReached,
    "The # of aborted paths due to reaching the maximum block count in "
    "a top level function");
STAT_COUNTER(
    NumMaxBlockCountReachedInInlined,
    "The # of aborted paths due to reaching the maximum block count in "
    "an inlined function");
STAT_COUNTER(NumTimesRetriedWithoutInlining,
             "The # of times we re-evaluated a call without inlining");
 
//===----------------------------------------------------------------------===//
// Internal program state traits.
//===----------------------------------------------------------------------===//
 
namespace {
 
// When modeling a C++ constructor, for a variety of reasons we need to track
// the location of the object for the duration of its ConstructionContext.
// ObjectsUnderConstruction maps statements within the construction context
// to the object's location, so that on every such statement the location
// could have been retrieved.
 
/// ConstructedObjectKey is used for being able to find the path-sensitive
/// memory region of a freshly constructed object while modeling the AST node
/// that syntactically represents the object that is being constructed.
/// Semantics of such nodes may sometimes require access to the region that's
/// not otherwise present in the program state, or to the very fact that
/// the construction context was present and contained references to these
/// AST nodes.
class ConstructedObjectKey {
  using ConstructedObjectKeyImpl =
      std::pair<ConstructionContextItem, const StackFrame *>;
  const ConstructedObjectKeyImpl Impl;
 
public:
  explicit ConstructedObjectKey(const ConstructionContextItem &Item,
                                const StackFrame *SF)
      : Impl(Item, SF) {}
 
  const ConstructionContextItem &getItem() const { return Impl.first; }
  const StackFrame *getStackFrame() const { return Impl.second; }
 
  ASTContext &getASTContext() const {
    return getStackFrame()->getDecl()->getASTContext();
  }
 
  void printJson(llvm::raw_ostream &Out, PrinterHelper *Helper,
                 PrintingPolicy &PP) const {
    const Stmt *S = getItem().getStmtOrNull();
    const CXXCtorInitializer *I = nullptr;
    if (!S)
      I = getItem().getCXXCtorInitializer();
 
    if (S)
      Out << "\"stmt_id\": " << S->getID(getASTContext());
    else
      Out << "\"init_id\": " << I->getID(getASTContext());
 
    // Kind
    Out << ", \"kind\": \"" << getItem().getKindAsString()
        << "\", \"argument_index\": ";
 
    if (getItem().getKind() == ConstructionContextItem::ArgumentKind)
      Out << getItem().getIndex();
    else
      Out << "null";
 
    // Pretty-print
    Out << ", \"pretty\": ";
 
    if (S) {
      S->printJson(Out, Helper, PP, /*AddQuotes=*/true);
    } else {
      Out << '\"' << I->getAnyMember()->getDeclName() << '\"';
    }
  }
 
  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.Add(Impl.first);
    ID.AddPointer(Impl.second);
  }
 
  bool operator==(const ConstructedObjectKey &RHS) const {
    return Impl == RHS.Impl;
  }
 
  bool operator<(const ConstructedObjectKey &RHS) const {
    return Impl < RHS.Impl;
  }
};
} // namespace
 
typedef llvm::ImmutableMap<ConstructedObjectKey, SVal>
    ObjectsUnderConstructionMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction,
                                 ObjectsUnderConstructionMap)
 
// This trait is responsible for storing the index of the element that is to be
// constructed in the next iteration. As a result a CXXConstructExpr is only
// stored if it is array type. Also the index is the index of the continuous
// memory region, which is important for multi-dimensional arrays. E.g:: int
// arr[2][2]; assume arr[1][1] will be the next element under construction, so
// the index is 3.
typedef llvm::ImmutableMap<
    std::pair<const CXXConstructExpr *, const StackFrame *>, unsigned>
    IndexOfElementToConstructMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(IndexOfElementToConstruct,
                                 IndexOfElementToConstructMap)
 
// This trait is responsible for holding our pending ArrayInitLoopExprs.
// It pairs the StackFrame and the initializer CXXConstructExpr with
// the size of the array that's being copy initialized.
typedef llvm::ImmutableMap<
    std::pair<const CXXConstructExpr *, const StackFrame *>, unsigned>
    PendingInitLoopMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(PendingInitLoop, PendingInitLoopMap)
 
typedef llvm::ImmutableMap<const StackFrame *, unsigned>
    PendingArrayDestructionMap;
REGISTER_TRAIT_WITH_PROGRAMSTATE(PendingArrayDestruction,
                                 PendingArrayDestructionMap)
 
//===----------------------------------------------------------------------===//
// Engine construction and deletion.
//===----------------------------------------------------------------------===//
 
static const char* TagProviderName = "ExprEngine";
 
ExprEngine::ExprEngine(cross_tu::CrossTranslationUnitContext &CTU,
                       AnalysisManager &mgr, SetOfConstDecls *VisitedCalleesIn,
                       FunctionSummariesTy *FS, InliningModes HowToInlineIn)
    : CTU(CTU), IsCTUEnabled(mgr.getAnalyzerOptions().IsNaiveCTUEnabled),
      AMgr(mgr), AnalysisDeclContexts(mgr.getAnalysisDeclContextManager()),
      Engine(*this, FS, mgr.getAnalyzerOptions()), G(Engine.getGraph()),
      StateMgr(getContext(), mgr.getStoreManagerCreator(),
               mgr.getConstraintManagerCreator(), G.getAllocator(), this),
      SymMgr(StateMgr.getSymbolManager()), MRMgr(StateMgr.getRegionManager()),
      svalBuilder(StateMgr.getSValBuilder()), ObjCNoRet(mgr.getASTContext()),
      BR(mgr, *this), VisitedCallees(VisitedCalleesIn),
      HowToInline(HowToInlineIn) {
  unsigned TrimInterval = mgr.options.GraphTrimInterval;
  if (TrimInterval != 0) {
    // Enable eager node reclamation when constructing the ExplodedGraph.
    G.enableNodeReclamation(TrimInterval);
  }
}
 
//===----------------------------------------------------------------------===//
// Utility methods.
//===----------------------------------------------------------------------===//
 
ProgramStateRef ExprEngine::getInitialState(const StackFrame *InitSF) {
  ProgramStateRef state = StateMgr.getInitialState(InitSF);
  const Decl *D = InitSF->getDecl();
 
  // Preconditions.
  // FIXME: It would be nice if we had a more general mechanism to add
  // such preconditions.  Some day.
  do {
    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
      // Precondition: the first argument of 'main' is an integer guaranteed
      //  to be > 0.
      const IdentifierInfo *II = FD->getIdentifier();
      if (!II || !(II->getName() == "main" && FD->getNumParams() > 0))
        break;
 
      const ParmVarDecl *PD = FD->getParamDecl(0);
      QualType T = PD->getType();
      const auto *BT = dyn_cast<BuiltinType>(T);
      if (!BT || !BT->isInteger())
        break;
 
      const MemRegion *R = state->getRegion(PD, InitSF);
      if (!R)
        break;
 
      SVal V = state->getSVal(loc::MemRegionVal(R));
      SVal Constraint_untested = evalBinOp(state, BO_GT, V,
                                           svalBuilder.makeZeroVal(T),
                                           svalBuilder.getConditionType());
 
      std::optional<DefinedOrUnknownSVal> Constraint =
          Constraint_untested.getAs<DefinedOrUnknownSVal>();
 
      if (!Constraint)
        break;
 
      if (ProgramStateRef newState = state->assume(*Constraint, true))
        state = newState;
    }
    break;
  }
  while (false);
 
  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
    // Precondition: 'self' is always non-null upon entry to an Objective-C
    // method.
    const ImplicitParamDecl *SelfD = MD->getSelfDecl();
    const MemRegion *R = state->getRegion(SelfD, InitSF);
    SVal V = state->getSVal(loc::MemRegionVal(R));
 
    if (std::optional<Loc> LV = V.getAs<Loc>()) {
      // Assume that the pointer value in 'self' is non-null.
      state = state->assume(*LV, true);
      assert(state && "'self' cannot be null");
    }
  }
 
  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
    if (MD->isImplicitObjectMemberFunction()) {
      // Precondition: 'this' is always non-null upon entry to the
      // top-level function.  This is our starting assumption for
      // analyzing an "open" program.
      const StackFrame *SF = InitSF;
      if (SF->getParent() == nullptr) {
        loc::MemRegionVal L = svalBuilder.getCXXThis(MD, SF);
        SVal V = state->getSVal(L);
        if (std::optional<Loc> LV = V.getAs<Loc>()) {
          state = state->assume(*LV, true);
          assert(state && "'this' cannot be null");
        }
      }
    }
  }
 
  return state;
}
 
ProgramStateRef ExprEngine::createTemporaryRegionIfNeeded(
    ProgramStateRef State, const StackFrame *SF,
    const Expr *InitWithAdjustments, const Expr *Result,
    const SubRegion **OutRegionWithAdjustments) {
  // FIXME: This function is a hack that works around the quirky AST
  // we're often having with respect to C++ temporaries. If only we modelled
  // the actual execution order of statements properly in the CFG,
  // all the hassle with adjustments would not be necessary,
  // and perhaps the whole function would be removed.
  SVal InitValWithAdjustments = State->getSVal(InitWithAdjustments, SF);
  if (!Result) {
    // If we don't have an explicit result expression, we're in "if needed"
    // mode. Only create a region if the current value is a NonLoc.
    if (!isa<NonLoc>(InitValWithAdjustments)) {
      if (OutRegionWithAdjustments)
        *OutRegionWithAdjustments = nullptr;
      return State;
    }
    Result = InitWithAdjustments;
  } else {
    // We need to create a region no matter what. Make sure we don't try to
    // stuff a Loc into a non-pointer temporary region.
    assert(!isa<Loc>(InitValWithAdjustments) ||
           Loc::isLocType(Result->getType()) ||
           Result->getType()->isMemberPointerType());
  }
 
  ProgramStateManager &StateMgr = State->getStateManager();
  MemRegionManager &MRMgr = StateMgr.getRegionManager();
  StoreManager &StoreMgr = StateMgr.getStoreManager();
 
  // MaterializeTemporaryExpr may appear out of place, after a few field and
  // base-class accesses have been made to the object, even though semantically
  // it is the whole object that gets materialized and lifetime-extended.
  //
  // For example:
  //
  //   `-MaterializeTemporaryExpr
  //     `-MemberExpr
  //       `-CXXTemporaryObjectExpr
  //
  // instead of the more natural
  //
  //   `-MemberExpr
  //     `-MaterializeTemporaryExpr
  //       `-CXXTemporaryObjectExpr
  //
  // Use the usual methods for obtaining the expression of the base object,
  // and record the adjustments that we need to make to obtain the sub-object
  // that the whole expression 'Ex' refers to. This trick is usual,
  // in the sense that CodeGen takes a similar route.
 
  SmallVector<const Expr *, 2> CommaLHSs;
  SmallVector<SubobjectAdjustment, 2> Adjustments;
 
  const Expr *Init = InitWithAdjustments->skipRValueSubobjectAdjustments(
      CommaLHSs, Adjustments);
 
  // Take the region for Init, i.e. for the whole object. If we do not remember
  // the region in which the object originally was constructed, come up with
  // a new temporary region out of thin air and copy the contents of the object
  // (which are currently present in the Environment, because Init is an rvalue)
  // into that region. This is not correct, but it is better than nothing.
  const TypedValueRegion *TR = nullptr;
  if (const auto *MT = dyn_cast<MaterializeTemporaryExpr>(Result)) {
    if (std::optional<SVal> V = getObjectUnderConstruction(State, MT, SF)) {
      State = finishObjectConstruction(State, MT, SF);
      State = State->BindExpr(Result, SF, *V);
      return State;
    } else if (const ValueDecl *VD = MT->getExtendingDecl()) {
      StorageDuration SD = MT->getStorageDuration();
      assert(SD != SD_FullExpression);
      // If this object is bound to a reference with static storage duration, we
      // put it in a different region to prevent "address leakage" warnings.
      if (SD == SD_Static || SD == SD_Thread) {
        TR = MRMgr.getCXXStaticLifetimeExtendedObjectRegion(Init, VD);
      } else {
        TR = MRMgr.getCXXLifetimeExtendedObjectRegion(Init, VD, SF);
      }
    } else {
      assert(MT->getStorageDuration() == SD_FullExpression);
      TR = MRMgr.getCXXTempObjectRegion(Init, SF);
    }
  } else {
    TR = MRMgr.getCXXTempObjectRegion(Init, SF);
  }
 
  SVal Reg = loc::MemRegionVal(TR);
  SVal BaseReg = Reg;
 
  // Make the necessary adjustments to obtain the sub-object.
  for (const SubobjectAdjustment &Adj : llvm::reverse(Adjustments)) {
    switch (Adj.Kind) {
    case SubobjectAdjustment::DerivedToBaseAdjustment:
      Reg = StoreMgr.evalDerivedToBase(Reg, Adj.DerivedToBase.BasePath);
      break;
    case SubobjectAdjustment::FieldAdjustment:
      Reg = StoreMgr.getLValueField(Adj.Field, Reg);
      break;
    case SubobjectAdjustment::MemberPointerAdjustment:
      // FIXME: Unimplemented.
      State = State->invalidateRegions(Reg, getCFGElementRef(),
                                       getNumVisitedCurrent(), SF, true,
                                       nullptr, nullptr, nullptr);
      return State;
    }
  }
 
  // What remains is to copy the value of the object to the new region.
  // FIXME: In other words, what we should always do is copy value of the
  // Init expression (which corresponds to the bigger object) to the whole
  // temporary region TR. However, this value is often no longer present
  // in the Environment. If it has disappeared, we instead invalidate TR.
  // Still, what we can do is assign the value of expression Ex (which
  // corresponds to the sub-object) to the TR's sub-region Reg. At least,
  // values inside Reg would be correct.
  SVal InitVal = State->getSVal(Init, SF);
  if (InitVal.isUnknown()) {
    InitVal = getSValBuilder().conjureSymbolVal(
        getCFGElementRef(), SF, Init->getType(), getNumVisitedCurrent());
    State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, SF, false);
 
    // Then we'd need to take the value that certainly exists and bind it
    // over.
    if (InitValWithAdjustments.isUnknown()) {
      // Try to recover some path sensitivity in case we couldn't
      // compute the value.
      InitValWithAdjustments = getSValBuilder().conjureSymbolVal(
          getCFGElementRef(), SF, InitWithAdjustments->getType(),
          getNumVisitedCurrent());
    }
    State =
        State->bindLoc(Reg.castAs<Loc>(), InitValWithAdjustments, SF, false);
  } else {
    State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, SF, false);
  }
 
  // The result expression would now point to the correct sub-region of the
  // newly created temporary region. Do this last in order to getSVal of Init
  // correctly in case (Result == Init).
  if (Result->isGLValue()) {
    State = State->BindExpr(Result, SF, Reg);
  } else {
    State = State->BindExpr(Result, SF, InitValWithAdjustments);
  }
 
  // Notify checkers once for two bindLoc()s.
  State = processRegionChange(State, TR, SF);
 
  if (OutRegionWithAdjustments)
    *OutRegionWithAdjustments = cast<SubRegion>(Reg.getAsRegion());
  return State;
}
 
ProgramStateRef
ExprEngine::setIndexOfElementToConstruct(ProgramStateRef State,
                                         const CXXConstructExpr *E,
                                         const StackFrame *SF, unsigned Idx) {
  auto Key = std::make_pair(E, SF);
 
  assert(!State->contains<IndexOfElementToConstruct>(Key) || Idx > 0);
 
  return State->set<IndexOfElementToConstruct>(Key, Idx);
}
 
std::optional<unsigned>
ExprEngine::getPendingInitLoop(ProgramStateRef State, const CXXConstructExpr *E,
                               const StackFrame *SF) {
  const unsigned *V = State->get<PendingInitLoop>({E, SF});
  return V ? std::make_optional(*V) : std::nullopt;
}
 
ProgramStateRef ExprEngine::removePendingInitLoop(ProgramStateRef State,
                                                  const CXXConstructExpr *E,
                                                  const StackFrame *SF) {
  auto Key = std::make_pair(E, SF);
 
  assert(E && State->contains<PendingInitLoop>(Key));
  return State->remove<PendingInitLoop>(Key);
}
 
ProgramStateRef ExprEngine::setPendingInitLoop(ProgramStateRef State,
                                               const CXXConstructExpr *E,
                                               const StackFrame *SF,
                                               unsigned Size) {
  auto Key = std::make_pair(E, SF);
 
  assert(!State->contains<PendingInitLoop>(Key) && Size > 0);
 
  return State->set<PendingInitLoop>(Key, Size);
}
 
std::optional<unsigned> ExprEngine::getIndexOfElementToConstruct(
    ProgramStateRef State, const CXXConstructExpr *E, const StackFrame *SF) {
  const unsigned *V = State->get<IndexOfElementToConstruct>({E, SF});
  return V ? std::make_optional(*V) : std::nullopt;
}
 
ProgramStateRef ExprEngine::removeIndexOfElementToConstruct(
    ProgramStateRef State, const CXXConstructExpr *E, const StackFrame *SF) {
  auto Key = std::make_pair(E, SF);
 
  assert(E && State->contains<IndexOfElementToConstruct>(Key));
  return State->remove<IndexOfElementToConstruct>(Key);
}
 
std::optional<unsigned>
ExprEngine::getPendingArrayDestruction(ProgramStateRef State,
                                       const StackFrame *SF) {
  assert(SF && "StackFrame shouldn't be null!");
 
  const unsigned *V = State->get<PendingArrayDestruction>(SF);
  return V ? std::make_optional(*V) : std::nullopt;
}
 
ProgramStateRef ExprEngine::setPendingArrayDestruction(ProgramStateRef State,
                                                       const StackFrame *SF,
                                                       unsigned Idx) {
  assert(SF && "StackFrame shouldn't be null!");
  return State->set<PendingArrayDestruction>(SF, Idx);
}
 
ProgramStateRef
ExprEngine::removePendingArrayDestruction(ProgramStateRef State,
                                          const StackFrame *SF) {
  assert(SF && "StackFrame shouldn't be null!");
  assert(State->contains<PendingArrayDestruction>(SF));
  return State->remove<PendingArrayDestruction>(SF);
}
 
ProgramStateRef
ExprEngine::addObjectUnderConstruction(ProgramStateRef State,
                                       const ConstructionContextItem &Item,
                                       const StackFrame *SF, SVal V) {
  ConstructedObjectKey Key(Item, SF);
 
  const Expr *Init = nullptr;
 
  if (auto DS = dyn_cast_or_null<DeclStmt>(Item.getStmtOrNull())) {
    if (auto VD = dyn_cast_or_null<VarDecl>(DS->getSingleDecl()))
      Init = VD->getInit();
  }
 
  if (auto LE = dyn_cast_or_null<LambdaExpr>(Item.getStmtOrNull()))
    Init = *(LE->capture_init_begin() + Item.getIndex());
 
  if (!Init && !Item.getStmtOrNull())
    Init = Item.getCXXCtorInitializer()->getInit();
 
  // In an ArrayInitLoopExpr the real initializer is returned by
  // getSubExpr(). Note that AILEs can be nested in case of
  // multidimesnional arrays.
  if (const auto *AILE = dyn_cast_or_null<ArrayInitLoopExpr>(Init))
    Init = extractElementInitializerFromNestedAILE(AILE);
 
  // FIXME: Currently the state might already contain the marker due to
  // incorrect handling of temporaries bound to default parameters.
  // The state will already contain the marker if we construct elements
  // in an array, as we visit the same statement multiple times before
  // the array declaration. The marker is removed when we exit the
  // constructor call.
  assert((!State->get<ObjectsUnderConstruction>(Key) ||
          Key.getItem().getKind() ==
              ConstructionContextItem::TemporaryDestructorKind ||
          State->contains<IndexOfElementToConstruct>(
              {dyn_cast_or_null<CXXConstructExpr>(Init), SF})) &&
         "The object is already marked as `UnderConstruction`, when it's not "
         "supposed to!");
  return State->set<ObjectsUnderConstruction>(Key, V);
}
 
std::optional<SVal>
ExprEngine::getObjectUnderConstruction(ProgramStateRef State,
                                       const ConstructionContextItem &Item,
                                       const StackFrame *SF) {
  ConstructedObjectKey Key(Item, SF);
  const SVal *V = State->get<ObjectsUnderConstruction>(Key);
  return V ? std::make_optional(*V) : std::nullopt;
}
 
ProgramStateRef
ExprEngine::finishObjectConstruction(ProgramStateRef State,
                                     const ConstructionContextItem &Item,
                                     const StackFrame *SF) {
  ConstructedObjectKey Key(Item, SF);
  assert(State->contains<ObjectsUnderConstruction>(Key));
  return State->remove<ObjectsUnderConstruction>(Key);
}
 
ProgramStateRef ExprEngine::elideDestructor(ProgramStateRef State,
                                            const CXXBindTemporaryExpr *BTE,
                                            const StackFrame *SF) {
  ConstructedObjectKey Key({BTE, /*IsElided=*/true}, SF);
  // FIXME: Currently the state might already contain the marker due to
  // incorrect handling of temporaries bound to default parameters.
  return State->set<ObjectsUnderConstruction>(Key, UnknownVal());
}
 
ProgramStateRef
ExprEngine::cleanupElidedDestructor(ProgramStateRef State,
                                    const CXXBindTemporaryExpr *BTE,
                                    const StackFrame *SF) {
  ConstructedObjectKey Key({BTE, /*IsElided=*/true}, SF);
  assert(State->contains<ObjectsUnderConstruction>(Key));
  return State->remove<ObjectsUnderConstruction>(Key);
}
 
bool ExprEngine::isDestructorElided(ProgramStateRef State,
                                    const CXXBindTemporaryExpr *BTE,
                                    const StackFrame *SF) {
  ConstructedObjectKey Key({BTE, /*IsElided=*/true}, SF);
  return State->contains<ObjectsUnderConstruction>(Key);
}
 
bool ExprEngine::areAllObjectsFullyConstructed(ProgramStateRef State,
                                               const StackFrame *FromSF,
                                               const StackFrame *ToSF) {
  const StackFrame *SF = FromSF;
  while (SF != ToSF) {
    assert(SF && "ToSF must be a parent of FromSF!");
    for (auto I : State->get<ObjectsUnderConstruction>())
      if (I.first.getStackFrame() == SF)
        return false;
 
    SF = SF->getParent();
  }
  return true;
}
 
//===----------------------------------------------------------------------===//
// Top-level transfer function logic (Dispatcher).
//===----------------------------------------------------------------------===//
 
/// evalAssume - Called by ConstraintManager. Used to call checker-specific
///  logic for handling assumptions on symbolic values.
ProgramStateRef ExprEngine::processAssume(ProgramStateRef state,
                                              SVal cond, bool assumption) {
  return getCheckerManager().runCheckersForEvalAssume(state, cond, assumption);
}
 
ProgramStateRef ExprEngine::processRegionChanges(
    ProgramStateRef state, const InvalidatedSymbols *invalidated,
    ArrayRef<const MemRegion *> Explicits, ArrayRef<const MemRegion *> Regions,
    const StackFrame *SF, const CallEvent *Call) {
  return getCheckerManager().runCheckersForRegionChanges(
      state, invalidated, Explicits, Regions, SF, Call);
}
 
static void
printObjectsUnderConstructionJson(raw_ostream &Out, ProgramStateRef State,
                                  const char *NL, const StackFrame *SF,
                                  unsigned int Space = 0, bool IsDot = false) {
  PrintingPolicy PP =
      SF->getAnalysisDeclContext()->getASTContext().getPrintingPolicy();
 
  ++Space;
  bool HasItem = false;
 
  // Store the last key.
  const ConstructedObjectKey *LastKey = nullptr;
  for (const auto &I : State->get<ObjectsUnderConstruction>()) {
    const ConstructedObjectKey &Key = I.first;
    if (Key.getStackFrame() != SF)
      continue;
 
    if (!HasItem) {
      Out << '[' << NL;
      HasItem = true;
    }
 
    LastKey = &Key;
  }
 
  for (const auto &I : State->get<ObjectsUnderConstruction>()) {
    const ConstructedObjectKey &Key = I.first;
    SVal Value = I.second;
    if (Key.getStackFrame() != SF)
      continue;
 
    Indent(Out, Space, IsDot) << "{ ";
    Key.printJson(Out, nullptr, PP);
    Out << ", \"value\": \"" << Value << "\" }";
 
    if (&Key != LastKey)
      Out << ',';
    Out << NL;
  }
 
  if (HasItem)
    Indent(Out, --Space, IsDot) << ']'; // End of "location_context".
  else {
    Out << "null ";
  }
}
 
static void printIndicesOfElementsToConstructJson(
    raw_ostream &Out, ProgramStateRef State, const char *NL,
    const StackFrame *SF, unsigned int Space = 0, bool IsDot = false) {
  using KeyT = std::pair<const Expr *, const StackFrame *>;
 
  const auto &Context = SF->getAnalysisDeclContext()->getASTContext();
  PrintingPolicy PP = Context.getPrintingPolicy();
 
  ++Space;
  bool HasItem = false;
 
  // Store the last key.
  KeyT LastKey;
  for (const auto &I : State->get<IndexOfElementToConstruct>()) {
    const KeyT &Key = I.first;
    if (Key.second != SF)
      continue;
 
    if (!HasItem) {
      Out << '[' << NL;
      HasItem = true;
    }
 
    LastKey = Key;
  }
 
  for (const auto &I : State->get<IndexOfElementToConstruct>()) {
    const KeyT &Key = I.first;
    unsigned Value = I.second;
    if (Key.second != SF)
      continue;
 
    Indent(Out, Space, IsDot) << "{ ";
 
    // Expr
    const Expr *E = Key.first;
    Out << "\"stmt_id\": " << E->getID(Context);
 
    // Kind
    Out << ", \"kind\": null";
 
    // Pretty-print
    Out << ", \"pretty\": ";
    Out << "\"" << E->getStmtClassName() << ' '
        << E->getSourceRange().printToString(Context.getSourceManager()) << " '"
        << QualType::getAsString(E->getType().split(), PP);
    Out << "'\"";
 
    Out << ", \"value\": \"Current index: " << Value - 1 << "\" }";
 
    if (Key != LastKey)
      Out << ',';
    Out << NL;
  }
 
  if (HasItem)
    Indent(Out, --Space, IsDot) << ']'; // End of "location_context".
  else {
    Out << "null ";
  }
}
 
static void printPendingInitLoopJson(raw_ostream &Out, ProgramStateRef State,
                                     const char *NL, const StackFrame *SF,
                                     unsigned int Space = 0,
                                     bool IsDot = false) {
  using KeyT = std::pair<const CXXConstructExpr *, const StackFrame *>;
 
  const auto &Context = SF->getAnalysisDeclContext()->getASTContext();
  PrintingPolicy PP = Context.getPrintingPolicy();
 
  ++Space;
  bool HasItem = false;
 
  // Store the last key.
  KeyT LastKey;
  for (const auto &I : State->get<PendingInitLoop>()) {
    const KeyT &Key = I.first;
    if (Key.second != SF)
      continue;
 
    if (!HasItem) {
      Out << '[' << NL;
      HasItem = true;
    }
 
    LastKey = Key;
  }
 
  for (const auto &I : State->get<PendingInitLoop>()) {
    const KeyT &Key = I.first;
    unsigned Value = I.second;
    if (Key.second != SF)
      continue;
 
    Indent(Out, Space, IsDot) << "{ ";
 
    const CXXConstructExpr *E = Key.first;
    Out << "\"stmt_id\": " << E->getID(Context);
 
    Out << ", \"kind\": null";
    Out << ", \"pretty\": ";
    Out << '\"' << E->getStmtClassName() << ' '
        << E->getSourceRange().printToString(Context.getSourceManager()) << " '"
        << QualType::getAsString(E->getType().split(), PP);
    Out << "'\"";
 
    Out << ", \"value\": \"Flattened size: " << Value << "\"}";
 
    if (Key != LastKey)
      Out << ',';
    Out << NL;
  }
 
  if (HasItem)
    Indent(Out, --Space, IsDot) << ']'; // End of "location_context".
  else {
    Out << "null ";
  }
}
 
static void
printPendingArrayDestructionsJson(raw_ostream &Out, ProgramStateRef State,
                                  const char *NL, const StackFrame *SF,
                                  unsigned int Space = 0, bool IsDot = false) {
  using KeyT = const StackFrame *;
 
  ++Space;
  bool HasItem = false;
 
  // Store the last key.
  KeyT LastKey = nullptr;
  for (const auto &I : State->get<PendingArrayDestruction>()) {
    const KeyT &Key = I.first;
    if (Key != SF)
      continue;
 
    if (!HasItem) {
      Out << '[' << NL;
      HasItem = true;
    }
 
    LastKey = Key;
  }
 
  for (const auto &I : State->get<PendingArrayDestruction>()) {
    const KeyT &Key = I.first;
    if (Key != SF)
      continue;
 
    Indent(Out, Space, IsDot) << "{ ";
 
    Out << "\"stmt_id\": null";
    Out << ", \"kind\": null";
    Out << ", \"pretty\": \"Current index: \"";
    Out << ", \"value\": \"" << I.second << "\" }";
 
    if (Key != LastKey)
      Out << ',';
    Out << NL;
  }
 
  if (HasItem)
    Indent(Out, --Space, IsDot) << ']'; // End of "location_context".
  else {
    Out << "null ";
  }
}
 
/// A helper function to generalize program state trait printing.
/// The function invokes Printer as 'Printer(Out, State, NL, SF, Space, IsDot,
/// std::forward<Args>(args)...)'. \n One possible type for Printer is
/// 'void()(raw_ostream &, ProgramStateRef, const char *, const StackFrame *,
/// unsigned int, bool, ...)' \n \param Trait The state trait to be printed.
/// \param Printer A void function that prints Trait.
/// \param Args An additional parameter pack that is passed to Print upon
/// invocation.
template <typename Trait, typename Printer, typename... Args>
static void printStateTraitWithStackFrameJson(
    raw_ostream &Out, ProgramStateRef State, const StackFrame *SF,
    const char *NL, unsigned int Space, bool IsDot,
    const char *jsonPropertyName, Printer printer, Args &&...args) {
 
  using RequiredType =
      void (*)(raw_ostream &, ProgramStateRef, const char *, const StackFrame *,
               unsigned int, bool, Args &&...);
 
  // Try to do as much compile time checking as possible.
  // FIXME: check for invocable instead of function?
  static_assert(std::is_function_v<std::remove_pointer_t<Printer>>,
                "Printer is not a function!");
  static_assert(std::is_convertible_v<Printer, RequiredType>,
                "Printer doesn't have the required type!");
 
  if (SF && !State->get<Trait>().isEmpty()) {
    Indent(Out, Space, IsDot) << '\"' << jsonPropertyName << "\": ";
    ++Space;
    Out << '[' << NL;
    SF->printJson(Out, NL, Space, IsDot, [&](const StackFrame *SF) {
      printer(Out, State, NL, SF, Space, IsDot, std::forward<Args>(args)...);
    });
 
    --Space;
    Indent(Out, Space, IsDot) << "]," << NL; // End of "jsonPropertyName".
  }
}
 
void ExprEngine::printJson(raw_ostream &Out, ProgramStateRef State,
                           const StackFrame *SF, const char *NL,
                           unsigned int Space, bool IsDot) const {
 
  printStateTraitWithStackFrameJson<ObjectsUnderConstruction>(
      Out, State, SF, NL, Space, IsDot, "constructing_objects",
      printObjectsUnderConstructionJson);
  printStateTraitWithStackFrameJson<IndexOfElementToConstruct>(
      Out, State, SF, NL, Space, IsDot, "index_of_element",
      printIndicesOfElementsToConstructJson);
  printStateTraitWithStackFrameJson<PendingInitLoop>(
      Out, State, SF, NL, Space, IsDot, "pending_init_loops",
      printPendingInitLoopJson);
  printStateTraitWithStackFrameJson<PendingArrayDestruction>(
      Out, State, SF, NL, Space, IsDot, "pending_destructors",
      printPendingArrayDestructionsJson);
 
  getCheckerManager().runCheckersForPrintStateJson(Out, State, NL, Space,
                                                   IsDot);
}
 
void ExprEngine::processEndWorklist() {
  // This prints the name of the top-level function if we crash.
  PrettyStackTraceStackFrame CrashInfo(getRootStackFrame());
  getCheckerManager().runCheckersForEndAnalysis(G, BR, *this);
}
 
void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
                                   unsigned StmtIdx) {
  currStmtIdx = StmtIdx;
 
  switch (E.getKind()) {
    case CFGElement::Statement:
    case CFGElement::Constructor:
    case CFGElement::CXXRecordTypedCall:
      ProcessStmt(E.castAs<CFGStmt>().getStmt(), Pred);
      return;
    case CFGElement::Initializer:
      ProcessInitializer(E.castAs<CFGInitializer>(), Pred);
      return;
    case CFGElement::NewAllocator:
      ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(),
                          Pred);
      return;
    case CFGElement::AutomaticObjectDtor:
    case CFGElement::DeleteDtor:
    case CFGElement::BaseDtor:
    case CFGElement::MemberDtor:
    case CFGElement::TemporaryDtor:
      ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
      return;
    case CFGElement::LoopExit:
      ProcessLoopExit(E.castAs<CFGLoopExit>().getLoopStmt(), Pred);
      return;
    case CFGElement::LifetimeEnds:
      ProcessLifetimeEnd(E.castAs<CFGLifetimeEnds>().getTriggerStmt(),
                         E.castAs<CFGLifetimeEnds>().getVarDecl(), Pred);
      return;
    case CFGElement::CleanupFunction:
    case CFGElement::FullExprCleanup:
    case CFGElement::ScopeBegin:
    case CFGElement::ScopeEnd:
      return;
  }
}
 
static bool shouldRemoveDeadBindings(AnalysisManager &AMgr, const Stmt *S,
                                     const ExplodedNode *Pred,
                                     const StackFrame *SF) {
  // Are we never purging state values?
  if (AMgr.options.AnalysisPurgeOpt == PurgeNone)
    return false;
 
  // Is this the beginning of a basic block?
  if (Pred->getLocation().getAs<BlockEntrance>())
    return true;
 
  // Is this on a non-expression?
  if (!isa<Expr>(S))
    return true;
 
  // Run before processing a call.
  if (CallEvent::isCallStmt(S))
    return true;
 
  // Is this an expression that is consumed by another expression?  If so,
  // postpone cleaning out the state.
  ParentMap &PM = SF->getAnalysisDeclContext()->getParentMap();
  return !PM.isConsumedExpr(cast<Expr>(S));
}
 
void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
                            const Stmt *ReferenceStmt, const StackFrame *SF,
                            const Stmt *DiagnosticStmt, ProgramPoint::Kind K) {
  llvm::TimeTraceScope TimeScope("ExprEngine::removeDead");
  assert((K == ProgramPoint::PreStmtPurgeDeadSymbolsKind ||
          ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt))
          && "PostStmt is not generally supported by the SymbolReaper yet");
  assert(SF && "Must pass the current (or expiring) StackFrame");
 
  if (!DiagnosticStmt) {
    DiagnosticStmt = ReferenceStmt;
    assert(DiagnosticStmt && "Required for clearing a StackFrame");
  }
 
  NumRemoveDeadBindings++;
  ProgramStateRef CleanedState = Pred->getState();
 
  // SF is the stack frame being destroyed, but SymbolReaper wants a
  // stack frame that is still live. (If this is the top-level stack
  // frame, this will be null.)
  if (!ReferenceStmt) {
    assert(K == ProgramPoint::PostStmtPurgeDeadSymbolsKind &&
           "Use PostStmtPurgeDeadSymbolsKind for clearing a StackFrame");
    SF = SF->getParent();
  }
 
  SymbolReaper SymReaper(SF, ReferenceStmt, SymMgr, getStoreManager());
 
  for (auto I : CleanedState->get<ObjectsUnderConstruction>()) {
    if (SymbolRef Sym = I.second.getAsSymbol())
      SymReaper.markLive(Sym);
    if (const MemRegion *MR = I.second.getAsRegion())
      SymReaper.markLive(MR);
  }
 
  getCheckerManager().runCheckersForLiveSymbols(CleanedState, SymReaper);
 
  // Create a state in which dead bindings are removed from the environment
  // and the store. TODO: The function should just return new env and store,
  // not a new state.
  CleanedState = StateMgr.removeDeadBindingsFromEnvironmentAndStore(
      CleanedState, SF, SymReaper);
 
  // Process any special transfer function for dead symbols.
  // Call checkers with the non-cleaned state so that they could query the
  // values of the soon to be dead symbols.
  ExplodedNodeSet CheckedSet;
  getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
                                                DiagnosticStmt, *this, K);
 
  // Extend lifetime of symbols used for dynamic extent while the parent region
  // is live. In this way size information about memory allocations is not lost
  // if the region remains live.
  markAllDynamicExtentLive(CleanedState, SymReaper);
 
  // For each node in CheckedSet, generate CleanedNodes that have the
  // environment, the store, and the constraints cleaned up but have the
  // user-supplied states as the predecessors.
  for (const auto I : CheckedSet) {
    ProgramStateRef CheckerState = I->getState();
 
    // The constraint manager has not been cleaned up yet, so clean up now.
    CheckerState =
        getConstraintManager().removeDeadBindings(CheckerState, SymReaper);
 
    assert(StateMgr.haveEqualEnvironments(CheckerState, Pred->getState()) &&
           "Checkers are not allowed to modify the Environment as a part of "
           "checkDeadSymbols processing.");
    assert(StateMgr.haveEqualStores(CheckerState, Pred->getState()) &&
           "Checkers are not allowed to modify the Store as a part of "
           "checkDeadSymbols processing.");
 
    // Create a state based on CleanedState with CheckerState GDM and
    // generate a transition to that state.
    ProgramStateRef CleanedCheckerSt =
        StateMgr.getPersistentStateWithGDM(CleanedState, CheckerState);
    const ProgramPoint &L = ProgramPoint::getProgramPoint(
        DiagnosticStmt, K, I->getStackFrame(), cleanupNodeTag());
    Out.insert(Engine.makeNode(L, CleanedCheckerSt, I));
  }
}
 
const ProgramPointTag *ExprEngine::cleanupNodeTag() {
  static SimpleProgramPointTag cleanupTag(TagProviderName, "Clean Node");
  return &cleanupTag;
}
 
namespace {
enum class VisitKind {
  Pre,
  Post,
};
}
 
static bool shouldJustCallCheckers(const Stmt *S, VisitKind K) {
 
  switch (S->getStmtClass()) {
 
  default:
    return true;
 
  // FIXME: Does not call checkers
  case Stmt::GNUNullExprClass:
    return false;
 
  // FIXME: Does not call PostVisit checkers
  case Stmt::ObjCAtSynchronizedStmtClass:
    return K == VisitKind::Pre;
 
  // FIXME: They do not call checkers
  case Expr::ConstantExprClass:
  case Stmt::ExprWithCleanupsClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::MSAsmStmtClass:
    return false;
 
  // FIXME: Does not call PreVisit checkers
  case Stmt::BlockExprClass:
    return K == VisitKind::Post;
 
  // FIXME: Does not call PreVisit checkers
  // Currently the engine does not call PostVisit checkers when
  // lambda inlining is disabled, so K == PostVisitKind
  // cannot be returned here.
  case Stmt::LambdaExprClass:
    return false;
 
  // Checkers are called manually with custom logic when this calls
  // VisitBinaryOperator, but calls no checkers during VisitLogicalExpr
  case Stmt::BinaryOperatorClass:
    return false;
 
  // Checkers are called manually with custom logic in these cases
  // (VisitCallExpr)
  case Stmt::CXXOperatorCallExprClass:
  case Stmt::CallExprClass:
  case Stmt::CXXMemberCallExprClass:
  case Stmt::UserDefinedLiteralClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::CXXCatchStmtClass:
    return false;
 
  // Checkers are called manually with custom logic in these cases
  // (handleConstructor)
  case Stmt::CXXTemporaryObjectExprClass:
  case Stmt::CXXConstructExprClass:
    return false;
 
  // Checkers are called manually with custom logic in this case
  // (handleConstructor)
  case Stmt::CXXInheritedCtorInitExprClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::ChooseExprClass:
    return false;
 
  // Checkers are called manually with custom logic in this case
  // (VisitBinaryOperator)
  case Stmt::CompoundAssignOperatorClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::CompoundLiteralExprClass:
    return false;
 
  // FIXME: These do not call checkers
  case Stmt::BinaryConditionalOperatorClass:
  case Stmt::ConditionalOperatorClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::CXXThisExprClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::DeclRefExprClass:
    return false;
 
  // Checkers are called manually with custom logic in this case
  case Stmt::DeclStmtClass:
    return false;
 
  // FIXME: These do not call checkers
  // (ConstructInitList)
  case Stmt::InitListExprClass:
  case Expr::CXXParenListInitExprClass:
    return false;
 
  // FIXME: Does not call PreVisit checkers
  case Stmt::ObjCIvarRefExprClass:
    return K == VisitKind::Post;
 
  // FIXME: Does not call PreVisit checkers
  case Stmt::ObjCForCollectionStmtClass:
    return K == VisitKind::Post;
 
  // FIXME: Does not call checkers
  case Stmt::ObjCMessageExprClass:
    return false;
 
  // FIXME: These do not call checkers
  case Stmt::ObjCAtThrowStmtClass:
  case Stmt::CXXThrowExprClass:
    return false;
 
  // FIXME: Does not call PostVisit checkers
  case Stmt::ReturnStmtClass:
    return K == VisitKind::Pre;
 
  // FIXME: Does not call checkers
  case Stmt::StmtExprClass:
    return false;
 
  // Checkers are called manually with custom logic in this case
  case Stmt::UnaryOperatorClass:
    return false;
 
  // FIXME: Does not call checkers
  case Stmt::PseudoObjectExprClass:
    return false;
 
  // FIXME: Does not call checkers
  case Expr::ObjCIndirectCopyRestoreExprClass:
    return false;
  }
}
 
void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
  // Reclaim any unnecessary nodes in the ExplodedGraph.
  G.reclaimRecentlyAllocatedNodes();
 
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                currStmt->getBeginLoc(),
                                "Error evaluating statement");
 
  // Remove dead bindings and symbols.
  ExplodedNodeSet CleanedStates;
  if (shouldRemoveDeadBindings(AMgr, currStmt, Pred, Pred->getStackFrame())) {
    removeDead(Pred, CleanedStates, currStmt, Pred->getStackFrame());
  } else
    CleanedStates.insert(Pred);
 
  ExplodedNodeSet PreVisited;
  if (shouldJustCallCheckers(currStmt, VisitKind::Pre)) {
    getCheckerManager().runCheckersForPreStmt(PreVisited, CleanedStates,
                                              currStmt, *this);
  } else
    PreVisited.insert(CleanedStates);
 
  ExplodedNodeSet Visited;
  for (const auto I : PreVisited) {
    ExplodedNodeSet Tmp;
    Visit(currStmt, I, Tmp);
    Visited.insert(Tmp);
  }
 
  ExplodedNodeSet PostVisited;
  if (shouldJustCallCheckers(currStmt, VisitKind::Post)) {
    getCheckerManager().runCheckersForPostStmt(PostVisited, Visited, currStmt,
                                               *this);
  } else
    PostVisited.insert(Visited);
 
  // Enqueue the new nodes onto the work list.
  Engine.enqueueStmtNodes(PostVisited, getCurrBlock(), currStmtIdx);
}
 
void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                S->getBeginLoc(),
                                "Error evaluating end of the loop");
  ProgramStateRef NewState = Pred->getState();
 
  if(AMgr.options.ShouldUnrollLoops)
    NewState = processLoopEnd(S, NewState);
 
  LoopExit PP(S, Pred->getStackFrame());
  if (ExplodedNode *N = Engine.makeNode(PP, NewState, Pred))
    Engine.enqueueStmtNode(N, getCurrBlock(), currStmtIdx);
}
 
void ExprEngine::ProcessLifetimeEnd(const Stmt *S, const VarDecl *D,
                                    ExplodedNode *Pred) {
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                S->getBeginLoc(),
                                "Error evaluating end of a lifetime");
  LifetimeEnd PP(S, D, Pred->getStackFrame());
  ExplodedNode *Src = Engine.makeNode(PP, Pred->getState(), Pred);
 
  ExplodedNodeSet Dst;
  getCheckerManager().runCheckersForLifetimeEnd(Dst, Src, D, *this);
  Engine.enqueueStmtNodes(Dst, getCurrBlock(), currStmtIdx);
}
 
void ExprEngine::ProcessInitializer(const CFGInitializer CFGInit,
                                    ExplodedNode *Pred) {
  const CXXCtorInitializer *BMI = CFGInit.getInitializer();
  const Expr *Init = BMI->getInit()->IgnoreImplicit();
  const StackFrame *SF = Pred->getStackFrame();
 
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                BMI->getSourceLocation(),
                                "Error evaluating initializer");
 
  // We don't clean up dead bindings here.
  const auto *decl = cast<CXXConstructorDecl>(SF->getDecl());
 
  ProgramStateRef State = Pred->getState();
  SVal thisVal = State->getSVal(svalBuilder.getCXXThis(decl, SF));
 
  ExplodedNodeSet Tmp;
  SVal FieldLoc;
 
  // Evaluate the initializer, if necessary
  if (BMI->isAnyMemberInitializer()) {
    // Constructors build the object directly in the field,
    // but non-objects must be copied in from the initializer.
    if (getObjectUnderConstruction(State, BMI, SF)) {
      // The field was directly constructed, so there is no need to bind.
      // But we still need to stop tracking the object under construction.
      State = finishObjectConstruction(State, BMI, SF);
      PostStore PS(Init, SF, /*Loc*/ nullptr, /*tag*/ nullptr);
      Tmp.insert(Engine.makeNode(PS, State, Pred));
    } else {
      const ValueDecl *Field;
      if (BMI->isIndirectMemberInitializer()) {
        Field = BMI->getIndirectMember();
        FieldLoc = State->getLValue(BMI->getIndirectMember(), thisVal);
      } else {
        Field = BMI->getMember();
        FieldLoc = State->getLValue(BMI->getMember(), thisVal);
      }
 
      SVal InitVal;
      if (Field->getType()->isArrayType()) {
        // Handle arrays of trivial type. We can represent this with a
        // primitive load/copy from the base array region.
        const ArraySubscriptExpr *ASE;
        while ((ASE = dyn_cast<ArraySubscriptExpr>(Init)))
          Init = ASE->getBase()->IgnoreImplicit();
 
        InitVal = State->getSVal(Init, SF);
 
        // If we fail to get the value for some reason, use a symbolic value.
        if (InitVal.isUnknownOrUndef()) {
          SValBuilder &SVB = getSValBuilder();
          InitVal = SVB.conjureSymbolVal(
              getCFGElementRef(), SF, Field->getType(), getNumVisitedCurrent());
        }
      } else {
        InitVal = State->getSVal(BMI->getInit(), SF);
      }
 
      PostInitializer PP(BMI, FieldLoc.getAsRegion(), SF);
      evalBind(Tmp, Init, Pred, FieldLoc, InitVal, /*isInit=*/true, &PP);
    }
  } else if (BMI->isBaseInitializer() && isa<InitListExpr>(Init)) {
    // When the base class is initialized with an initialization list and the
    // base class does not have a ctor, there will not be a CXXConstructExpr to
    // initialize the base region. Hence, we need to make the bind for it.
    SVal BaseLoc = getStoreManager().evalDerivedToBase(
        thisVal, QualType(BMI->getBaseClass(), 0), BMI->isBaseVirtual());
    SVal InitVal = State->getSVal(Init, SF);
    evalBind(Tmp, Init, Pred, BaseLoc, InitVal, /*isInit=*/true);
  } else {
    assert(BMI->isBaseInitializer() || BMI->isDelegatingInitializer());
    Tmp.insert(Pred);
    // We already did all the work when visiting the CXXConstructExpr.
  }
 
  // Construct PostInitializer nodes whether the state changed or not,
  // so that the diagnostics don't get confused.
  PostInitializer PP(BMI, FieldLoc.getAsRegion(), SF);
 
  ExplodedNodeSet Dst;
  for (ExplodedNode *Pred : Tmp)
    Dst.insert(Engine.makeNode(PP, Pred->getState(), Pred));
  // Enqueue the new nodes onto the work list.
  Engine.enqueueStmtNodes(Dst, getCurrBlock(), currStmtIdx);
}
 
std::pair<ProgramStateRef, uint64_t>
ExprEngine::prepareStateForArrayDestruction(const ProgramStateRef State,
                                            const MemRegion *Region,
                                            const QualType &ElementTy,
                                            const StackFrame *SF,
                                            SVal *ElementCountVal) {
  assert(Region != nullptr && "Not-null region expected");
 
  QualType Ty = ElementTy.getDesugaredType(getContext());
  while (const auto *NTy = dyn_cast<ArrayType>(Ty))
    Ty = NTy->getElementType().getDesugaredType(getContext());
 
  auto ElementCount = getDynamicElementCount(State, Region, svalBuilder, Ty);
 
  if (ElementCountVal)
    *ElementCountVal = ElementCount;
 
  // Note: the destructors are called in reverse order.
  unsigned Idx = 0;
  if (auto OptionalIdx = getPendingArrayDestruction(State, SF)) {
    Idx = *OptionalIdx;
  } else {
    // The element count is either unknown, or an SVal that's not an integer.
    if (!ElementCount.isConstant())
      return {State, 0};
 
    Idx = ElementCount.getAsInteger()->getLimitedValue();
  }
 
  if (Idx == 0)
    return {State, 0};
 
  --Idx;
 
  return {setPendingArrayDestruction(State, SF, Idx), Idx};
}
 
void ExprEngine::ProcessImplicitDtor(const CFGImplicitDtor D,
                                     ExplodedNode *Pred) {
  ExplodedNodeSet Dst;
  switch (D.getKind()) {
  case CFGElement::AutomaticObjectDtor:
    ProcessAutomaticObjDtor(D.castAs<CFGAutomaticObjDtor>(), Pred, Dst);
    break;
  case CFGElement::BaseDtor:
    ProcessBaseDtor(D.castAs<CFGBaseDtor>(), Pred, Dst);
    break;
  case CFGElement::MemberDtor:
    ProcessMemberDtor(D.castAs<CFGMemberDtor>(), Pred, Dst);
    break;
  case CFGElement::TemporaryDtor:
    ProcessTemporaryDtor(D.castAs<CFGTemporaryDtor>(), Pred, Dst);
    break;
  case CFGElement::DeleteDtor:
    ProcessDeleteDtor(D.castAs<CFGDeleteDtor>(), Pred, Dst);
    break;
  default:
    llvm_unreachable("Unexpected dtor kind.");
  }
 
  // Enqueue the new nodes onto the work list.
  Engine.enqueueStmtNodes(Dst, getCurrBlock(), currStmtIdx);
}
 
void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
                                     ExplodedNode *Pred) {
  ExplodedNodeSet Dst;
  AnalysisManager &AMgr = getAnalysisManager();
  AnalyzerOptions &Opts = AMgr.options;
  // TODO: We're not evaluating allocators for all cases just yet as
  // we're not handling the return value correctly, which causes false
  // positives when the alpha.cplusplus.NewDeleteLeaks check is on.
  if (Opts.MayInlineCXXAllocator)
    VisitCXXNewAllocatorCall(NE, Pred, Dst);
  else {
    const StackFrame *SF = Pred->getStackFrame();
    PostImplicitCall PP(NE->getOperatorNew(), NE->getBeginLoc(), SF,
                        getCFGElementRef());
    Dst.insert(Engine.makeNode(PP, Pred->getState(), Pred));
  }
  Engine.enqueueStmtNodes(Dst, getCurrBlock(), currStmtIdx);
}
 
void ExprEngine::ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,
                                         ExplodedNode *Pred,
                                         ExplodedNodeSet &Dst) {
  const auto *DtorDecl = Dtor.getDestructorDecl(getContext());
  const VarDecl *varDecl = Dtor.getVarDecl();
  QualType varType = varDecl->getType();
 
  ProgramStateRef state = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  SVal dest = state->getLValue(varDecl, SF);
  const MemRegion *Region = dest.castAs<loc::MemRegionVal>().getRegion();
 
  if (varType->isReferenceType()) {
    const MemRegion *ValueRegion = state->getSVal(Region).getAsRegion();
    if (!ValueRegion) {
      // FIXME: This should not happen. The language guarantees a presence
      // of a valid initializer here, so the reference shall not be undefined.
      // It seems that we're calling destructors over variables that
      // were not initialized yet.
      return;
    }
    Region = ValueRegion->getBaseRegion();
    varType = cast<TypedValueRegion>(Region)->getValueType();
  }
 
  unsigned Idx = 0;
  if (isa<ArrayType>(varType)) {
    SVal ElementCount;
    std::tie(state, Idx) = prepareStateForArrayDestruction(
        state, Region, varType, SF, &ElementCount);
 
    if (ElementCount.isConstant()) {
      uint64_t ArrayLength = ElementCount.getAsInteger()->getLimitedValue();
      assert(ArrayLength &&
             "An automatic dtor for a 0 length array shouldn't be triggered!");
 
      // Still handle this case if we don't have assertions enabled.
      if (!ArrayLength) {
        static SimpleProgramPointTag PT(
            "ExprEngine", "Skipping automatic 0 length array destruction, "
                          "which shouldn't be in the CFG.");
        PostImplicitCall PP(DtorDecl, varDecl->getLocation(), SF,
                            getCFGElementRef(), &PT);
        Engine.makeNode(PP, Pred->getState(), Pred, /*MarkAsSink=*/true);
        return;
      }
    }
  }
 
  EvalCallOptions CallOpts;
  Region = makeElementRegion(state, loc::MemRegionVal(Region), varType,
                             CallOpts.IsArrayCtorOrDtor, Idx)
               .getAsRegion();
 
  static SimpleProgramPointTag PT("ExprEngine",
                                  "Prepare for object destruction");
  PreImplicitCall PP(DtorDecl, varDecl->getLocation(), SF, getCFGElementRef(),
                     &PT);
  Pred = Engine.makeNode(PP, state, Pred);
 
  if (!Pred)
    return;
 
  VisitCXXDestructor(varType, Region, Dtor.getTriggerStmt(),
                     /*IsBase=*/false, Pred, Dst, CallOpts);
}
 
void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
                                   ExplodedNode *Pred,
                                   ExplodedNodeSet &Dst) {
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
  const CXXDeleteExpr *DE = Dtor.getDeleteExpr();
  const Expr *Arg = DE->getArgument();
  QualType DTy = DE->getDestroyedType();
  SVal ArgVal = State->getSVal(Arg, SF);
 
  // If the argument to delete is known to be a null value,
  // don't run destructor.
  if (State->isNull(ArgVal).isConstrainedTrue()) {
    QualType BTy = getContext().getBaseElementType(DTy);
    const CXXRecordDecl *RD = BTy->getAsCXXRecordDecl();
    const CXXDestructorDecl *Dtor = RD->getDestructor();
 
    PostImplicitCall PP(Dtor, DE->getBeginLoc(), SF, getCFGElementRef());
    Dst.insert(Engine.makeNode(PP, Pred->getState(), Pred));
    return;
  }
 
  auto getDtorDecl = [](const QualType &DTy) {
    const CXXRecordDecl *RD = DTy->getAsCXXRecordDecl();
    return RD->getDestructor();
  };
 
  unsigned Idx = 0;
  EvalCallOptions CallOpts;
  const MemRegion *ArgR = ArgVal.getAsRegion();
 
  if (DE->isArrayForm()) {
    CallOpts.IsArrayCtorOrDtor = true;
    // Yes, it may even be a multi-dimensional array.
    while (const auto *AT = getContext().getAsArrayType(DTy))
      DTy = AT->getElementType();
 
    if (ArgR) {
      SVal ElementCount;
      std::tie(State, Idx) =
          prepareStateForArrayDestruction(State, ArgR, DTy, SF, &ElementCount);
 
      // If we're about to destruct a 0 length array, don't run any of the
      // destructors.
      if (ElementCount.isConstant() &&
          ElementCount.getAsInteger()->getLimitedValue() == 0) {
 
        static SimpleProgramPointTag PT(
            "ExprEngine", "Skipping 0 length array delete destruction");
        PostImplicitCall PP(getDtorDecl(DTy), DE->getBeginLoc(), SF,
                            getCFGElementRef(), &PT);
        Dst.insert(Engine.makeNode(PP, Pred->getState(), Pred));
        return;
      }
 
      ArgR = State->getLValue(DTy, svalBuilder.makeArrayIndex(Idx), ArgVal)
                 .getAsRegion();
    }
  }
 
  static SimpleProgramPointTag PT("ExprEngine",
                                  "Prepare for object destruction");
  PreImplicitCall PP(getDtorDecl(DTy), DE->getBeginLoc(), SF,
                     getCFGElementRef(), &PT);
  Pred = Engine.makeNode(PP, State, Pred);
 
  if (!Pred)
    return;
 
  VisitCXXDestructor(DTy, ArgR, DE, /*IsBase=*/false, Pred, Dst, CallOpts);
}
 
void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D,
                                 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
  const StackFrame *SF = Pred->getStackFrame();
 
  const auto *CurDtor = cast<CXXDestructorDecl>(SF->getDecl());
  Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor, SF);
  SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
 
  // Create the base object region.
  const CXXBaseSpecifier *Base = D.getBaseSpecifier();
  QualType BaseTy = Base->getType();
  SVal BaseVal = getStoreManager().evalDerivedToBase(ThisVal, BaseTy,
                                                     Base->isVirtual());
 
  EvalCallOptions CallOpts;
  VisitCXXDestructor(BaseTy, BaseVal.getAsRegion(), CurDtor->getBody(),
                     /*IsBase=*/true, Pred, Dst, CallOpts);
}
 
void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D,
                                   ExplodedNode *Pred, ExplodedNodeSet &Dst) {
  const auto *DtorDecl = D.getDestructorDecl(getContext());
  const FieldDecl *Member = D.getFieldDecl();
  QualType T = Member->getType();
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  const auto *CurDtor = cast<CXXDestructorDecl>(SF->getDecl());
  Loc ThisStorageLoc = getSValBuilder().getCXXThis(CurDtor, SF);
  Loc ThisLoc = State->getSVal(ThisStorageLoc).castAs<Loc>();
  SVal FieldVal = State->getLValue(Member, ThisLoc);
 
  unsigned Idx = 0;
  if (isa<ArrayType>(T)) {
    SVal ElementCount;
    std::tie(State, Idx) = prepareStateForArrayDestruction(
        State, FieldVal.getAsRegion(), T, SF, &ElementCount);
 
    if (ElementCount.isConstant()) {
      uint64_t ArrayLength = ElementCount.getAsInteger()->getLimitedValue();
      assert(ArrayLength &&
             "A member dtor for a 0 length array shouldn't be triggered!");
 
      // Still handle this case if we don't have assertions enabled.
      if (!ArrayLength) {
        static SimpleProgramPointTag PT(
            "ExprEngine", "Skipping member 0 length array destruction, which "
                          "shouldn't be in the CFG.");
        PostImplicitCall PP(DtorDecl, Member->getLocation(), SF,
                            getCFGElementRef(), &PT);
        Engine.makeNode(PP, Pred->getState(), Pred, /*MarkAsSink=*/true);
        return;
      }
    }
  }
 
  EvalCallOptions CallOpts;
  FieldVal =
      makeElementRegion(State, FieldVal, T, CallOpts.IsArrayCtorOrDtor, Idx);
 
  static SimpleProgramPointTag PT("ExprEngine",
                                  "Prepare for object destruction");
  PreImplicitCall PP(DtorDecl, Member->getLocation(), SF, getCFGElementRef(),
                     &PT);
  Pred = Engine.makeNode(PP, State, Pred);
 
  if (!Pred)
    return;
 
  VisitCXXDestructor(T, FieldVal.getAsRegion(), CurDtor->getBody(),
                     /*IsBase=*/false, Pred, Dst, CallOpts);
}
 
void ExprEngine::ProcessTemporaryDtor(const CFGTemporaryDtor D,
                                      ExplodedNode *Pred,
                                      ExplodedNodeSet &Dst) {
  const CXXBindTemporaryExpr *BTE = D.getBindTemporaryExpr();
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
  const MemRegion *MR = nullptr;
 
  if (std::optional<SVal> V = getObjectUnderConstruction(State, BTE, SF)) {
    // FIXME: Currently we insert temporary destructors for default parameters,
    // but we don't insert the constructors, so the entry in
    // ObjectsUnderConstruction may be missing.
    State = finishObjectConstruction(State, BTE, SF);
    MR = V->getAsRegion();
  }
 
  // If copy elision has occurred, and the constructor corresponding to the
  // destructor was elided, we need to skip the destructor as well.
  if (isDestructorElided(State, BTE, SF)) {
    State = cleanupElidedDestructor(State, BTE, SF);
    PostImplicitCall PP(D.getDestructorDecl(getContext()), BTE->getBeginLoc(),
                        SF, getCFGElementRef());
    Dst.insert(Engine.makeNode(PP, State, Pred));
    return;
  }
 
  ExplodedNode *CleanPred = Engine.makePostStmtNode(BTE, State, Pred);
  if (!CleanPred) {
    // FIXME: We can get a null node here due to temporaries being
    // bound to default parameters.
    CleanPred = Pred;
  }
 
  QualType T = BTE->getSubExpr()->getType();
 
  EvalCallOptions CallOpts;
  CallOpts.IsTemporaryCtorOrDtor = true;
  if (!MR) {
    // FIXME: If we have no MR, we still need to unwrap the array to avoid
    // destroying the whole array at once.
    //
    // For this case there is no universal solution as there is no way to
    // directly create an array of temporary objects. There are some expressions
    // however which can create temporary objects and have an array type.
    //
    // E.g.: std::initializer_list<S>{S(), S()};
    //
    // The expression above has a type of 'const struct S[2]' but it's a single
    // 'std::initializer_list<>'. The destructors of the 2 temporary 'S()'
    // objects will be called anyway, because they are 2 separate objects in 2
    // separate clusters, i.e.: not an array.
    //
    // Now the 'std::initializer_list<>' is not an array either even though it
    // has the type of an array. The point is, we only want to invoke the
    // destructor for the initializer list once not twice or so.
    while (const ArrayType *AT = getContext().getAsArrayType(T)) {
      T = AT->getElementType();
 
      // FIXME: Enable this flag once we handle this case properly.
      // CallOpts.IsArrayCtorOrDtor = true;
    }
  } else {
    // FIXME: We'd eventually need to makeElementRegion() trick here,
    // but for now we don't have the respective construction contexts,
    // so MR would always be null in this case. Do nothing for now.
  }
  VisitCXXDestructor(T, MR, BTE,
                     /*IsBase=*/false, CleanPred, Dst, CallOpts);
}
 
void ExprEngine::processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
                                               ExplodedNode *Pred,
                                               ExplodedNodeSet &Dst,
                                               const CFGBlock *DstT,
                                               const CFGBlock *DstF) {
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  std::optional<SVal> Obj = getObjectUnderConstruction(State, BTE, SF);
  if (const CFGBlock *DstBlock = Obj ? DstT : DstF) {
    BlockEdge BE(getCurrBlock(), DstBlock, SF);
    Dst.insert(Engine.makeNode(BE, State, Pred));
  }
}
 
void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
                                           ExplodedNode *Pred,
                                           ExplodedNodeSet &Dst) {
  // This is a fallback solution in case we didn't have a construction
  // context when we were constructing the temporary. Otherwise the map should
  // have been populated there.
  if (!getAnalysisManager().options.ShouldIncludeTemporaryDtorsInCFG) {
    // In case we don't have temporary destructors in the CFG, do not mark
    // the initialization - we would otherwise never clean it up.
    Dst.insert(Pred);
    return;
  }
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
  if (!getObjectUnderConstruction(State, BTE, SF)) {
    // FIXME: Currently the state might also already contain the marker due to
    // incorrect handling of temporaries bound to default parameters; for
    // those, we currently skip the CXXBindTemporaryExpr but rely on adding
    // temporary destructor nodes.
    State = addObjectUnderConstruction(State, BTE, SF, UnknownVal());
  }
  Dst.insert(Engine.makePostStmtNode(BTE, State, Pred));
}
 
ProgramStateRef ExprEngine::escapeValues(ProgramStateRef State,
                                         ArrayRef<SVal> Vs,
                                         PointerEscapeKind K,
                                         const CallEvent *Call) const {
  class CollectReachableSymbolsCallback final : public SymbolVisitor {
    InvalidatedSymbols &Symbols;
 
  public:
    explicit CollectReachableSymbolsCallback(InvalidatedSymbols &Symbols)
        : Symbols(Symbols) {}
 
    const InvalidatedSymbols &getSymbols() const { return Symbols; }
 
    bool VisitSymbol(SymbolRef Sym) override {
      Symbols.insert(Sym);
      return true;
    }
  };
  InvalidatedSymbols Symbols;
  CollectReachableSymbolsCallback CallBack(Symbols);
  for (SVal V : Vs)
    State->scanReachableSymbols(V, CallBack);
 
  return getCheckerManager().runCheckersForPointerEscape(
      State, CallBack.getSymbols(), Call, K, nullptr);
}
 
void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
                       ExplodedNodeSet &Dst) {
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                S->getBeginLoc(), "Error evaluating statement");
 
  assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());
 
  switch (S->getStmtClass()) {
    // C++, OpenMP and ARC stuff we don't support yet.
    case Stmt::CXXDependentScopeMemberExprClass:
    case Stmt::CXXReflectExprClass:
    case Stmt::CXXTryStmtClass:
    case Stmt::CXXTypeidExprClass:
    case Stmt::CXXUuidofExprClass:
    case Stmt::CXXFoldExprClass:
    case Stmt::MSPropertyRefExprClass:
    case Stmt::MSPropertySubscriptExprClass:
    case Stmt::CXXUnresolvedConstructExprClass:
    case Stmt::DependentScopeDeclRefExprClass:
    case Stmt::ArrayTypeTraitExprClass:
    case Stmt::ExpressionTraitExprClass:
    case Stmt::UnresolvedLookupExprClass:
    case Stmt::UnresolvedMemberExprClass:
    case Stmt::DependentTemplateIdExprClass:
    case Stmt::RecoveryExprClass:
    case Stmt::CXXNoexceptExprClass:
    case Stmt::PackExpansionExprClass:
    case Stmt::PackIndexingExprClass:
    case Stmt::SubstNonTypeTemplateParmPackExprClass:
    case Stmt::FunctionParmPackExprClass:
    case Stmt::CoroutineBodyStmtClass:
    case Stmt::CoawaitExprClass:
    case Stmt::DependentCoawaitExprClass:
    case Stmt::CoreturnStmtClass:
    case Stmt::CoyieldExprClass:
    case Stmt::SEHTryStmtClass:
    case Stmt::SEHExceptStmtClass:
    case Stmt::SEHLeaveStmtClass:
    case Stmt::SEHFinallyStmtClass:
    case Stmt::CXXExpansionStmtPatternClass:
    case Stmt::CXXExpansionStmtInstantiationClass:
    case Stmt::CXXExpansionSelectExprClass:
    case Stmt::OMPCanonicalLoopClass:
    case Stmt::OMPParallelDirectiveClass:
    case Stmt::OMPSimdDirectiveClass:
    case Stmt::OMPForDirectiveClass:
    case Stmt::OMPForSimdDirectiveClass:
    case Stmt::OMPSectionsDirectiveClass:
    case Stmt::OMPSectionDirectiveClass:
    case Stmt::OMPScopeDirectiveClass:
    case Stmt::OMPSingleDirectiveClass:
    case Stmt::OMPMasterDirectiveClass:
    case Stmt::OMPCriticalDirectiveClass:
    case Stmt::OMPParallelForDirectiveClass:
    case Stmt::OMPParallelForSimdDirectiveClass:
    case Stmt::OMPParallelSectionsDirectiveClass:
    case Stmt::OMPParallelMasterDirectiveClass:
    case Stmt::OMPParallelMaskedDirectiveClass:
    case Stmt::OMPTaskDirectiveClass:
    case Stmt::OMPTaskyieldDirectiveClass:
    case Stmt::OMPBarrierDirectiveClass:
    case Stmt::OMPTaskwaitDirectiveClass:
    case Stmt::OMPErrorDirectiveClass:
    case Stmt::OMPTaskgroupDirectiveClass:
    case Stmt::OMPFlushDirectiveClass:
    case Stmt::OMPDepobjDirectiveClass:
    case Stmt::OMPScanDirectiveClass:
    case Stmt::OMPOrderedStandaloneDirectiveClass:
    case Stmt::OMPOrderedBlockAssocDirectiveClass:
    case Stmt::OMPAtomicDirectiveClass:
    case Stmt::OMPAssumeDirectiveClass:
    case Stmt::OMPTargetDirectiveClass:
    case Stmt::OMPTargetDataDirectiveClass:
    case Stmt::OMPTargetEnterDataDirectiveClass:
    case Stmt::OMPTargetExitDataDirectiveClass:
    case Stmt::OMPTargetParallelDirectiveClass:
    case Stmt::OMPTargetParallelForDirectiveClass:
    case Stmt::OMPTargetUpdateDirectiveClass:
    case Stmt::OMPTeamsDirectiveClass:
    case Stmt::OMPCancellationPointDirectiveClass:
    case Stmt::OMPCancelDirectiveClass:
    case Stmt::OMPTaskLoopDirectiveClass:
    case Stmt::OMPTaskLoopSimdDirectiveClass:
    case Stmt::OMPMasterTaskLoopDirectiveClass:
    case Stmt::OMPMaskedTaskLoopDirectiveClass:
    case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
    case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
    case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
    case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
    case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
    case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
    case Stmt::OMPDistributeDirectiveClass:
    case Stmt::OMPDistributeParallelForDirectiveClass:
    case Stmt::OMPDistributeParallelForSimdDirectiveClass:
    case Stmt::OMPDistributeSimdDirectiveClass:
    case Stmt::OMPTargetParallelForSimdDirectiveClass:
    case Stmt::OMPTargetSimdDirectiveClass:
    case Stmt::OMPTeamsDistributeDirectiveClass:
    case Stmt::OMPTeamsDistributeSimdDirectiveClass:
    case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
    case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
    case Stmt::OMPTargetTeamsDirectiveClass:
    case Stmt::OMPTargetTeamsDistributeDirectiveClass:
    case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
    case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
    case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
    case Stmt::OMPReverseDirectiveClass:
    case Stmt::OMPStripeDirectiveClass:
    case Stmt::OMPTileDirectiveClass:
    case Stmt::OMPInterchangeDirectiveClass:
    case Stmt::OMPFlattenDirectiveClass:
    case Stmt::OMPSplitDirectiveClass:
    case Stmt::OMPFuseDirectiveClass:
    case Stmt::OMPInteropDirectiveClass:
    case Stmt::OMPDispatchDirectiveClass:
    case Stmt::OMPMaskedDirectiveClass:
    case Stmt::OMPGenericLoopDirectiveClass:
    case Stmt::OMPTeamsGenericLoopDirectiveClass:
    case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
    case Stmt::OMPParallelGenericLoopDirectiveClass:
    case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
    case Stmt::CapturedStmtClass:
    case Stmt::SYCLKernelCallStmtClass:
    case Stmt::UnresolvedSYCLKernelCallStmtClass:
    case Stmt::OpenACCComputeConstructClass:
    case Stmt::OpenACCLoopConstructClass:
    case Stmt::OpenACCCombinedConstructClass:
    case Stmt::OpenACCDataConstructClass:
    case Stmt::OpenACCEnterDataConstructClass:
    case Stmt::OpenACCExitDataConstructClass:
    case Stmt::OpenACCHostDataConstructClass:
    case Stmt::OpenACCWaitConstructClass:
    case Stmt::OpenACCCacheConstructClass:
    case Stmt::OpenACCInitConstructClass:
    case Stmt::OpenACCShutdownConstructClass:
    case Stmt::OpenACCSetConstructClass:
    case Stmt::OpenACCUpdateConstructClass:
    case Stmt::OpenACCAtomicConstructClass:
    case Stmt::OMPUnrollDirectiveClass:
    case Stmt::OMPMetaDirectiveClass:
    case Stmt::HLSLOutArgExprClass: {
      const ExplodedNode *Node = Engine.makePostStmtNode(
          S, Pred->getState(), Pred, /*MarkAsSink=*/true);
      Engine.addAbortedBlock(Node, getCurrBlock());
      break;
    }
 
    case Stmt::ParenExprClass:
      llvm_unreachable("ParenExprs already handled.");
    case Stmt::GenericSelectionExprClass:
      llvm_unreachable("GenericSelectionExprs already handled.");
    // Cases that should never be evaluated simply because they shouldn't
    // appear in the CFG.
    case Stmt::BreakStmtClass:
    case Stmt::CaseStmtClass:
    case Stmt::CompoundStmtClass:
    case Stmt::ContinueStmtClass:
    case Stmt::CXXForRangeStmtClass:
    case Stmt::DefaultStmtClass:
    case Stmt::DoStmtClass:
    case Stmt::ForStmtClass:
    case Stmt::GotoStmtClass:
    case Stmt::IfStmtClass:
    case Stmt::IndirectGotoStmtClass:
    case Stmt::LabelStmtClass:
    case Stmt::NoStmtClass:
    case Stmt::NullStmtClass:
    case Stmt::SwitchStmtClass:
    case Stmt::WhileStmtClass:
    case Stmt::DeferStmtClass:
    case Expr::MSDependentExistsStmtClass:
      llvm_unreachable("Stmt should not be in analyzer evaluation loop");
    case Stmt::ImplicitValueInitExprClass:
      // These nodes are shared in the CFG and would case caching out.
      // Moreover, no additional evaluation required for them, the
      // analyzer can reconstruct these values from the AST.
      llvm_unreachable("Should be pruned from CFG");
 
    case Stmt::ObjCSubscriptRefExprClass:
    case Stmt::ObjCPropertyRefExprClass:
      llvm_unreachable("These are handled by PseudoObjectExpr");
 
    case Stmt::GNUNullExprClass: {
      // GNU __null is a pointer-width integer, not an actual pointer.
      SVal Val = svalBuilder.makeIntValWithWidth(getContext().VoidPtrTy, 0);
      Dst.insert(Engine.makeNodeWithBinding(Pred, cast<Expr>(S), Val));
      break;
    }
 
    case Stmt::ObjCAtSynchronizedStmtClass: {
      Dst.insert(Pred);
      break;
    }
 
    case Expr::ConstantExprClass:
    case Stmt::ExprWithCleanupsClass:
      Dst.insert(Pred);
      // Handled due to fully linearised CFG.
      break;
 
    case Stmt::CXXBindTemporaryExprClass:
      VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), Pred, Dst);
      break;
 
    case Stmt::ArrayInitLoopExprClass:
      VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), Pred, Dst);
      break;
    // Cases not handled yet; but will handle some day.
    case Stmt::DesignatedInitExprClass:
    case Stmt::DesignatedInitUpdateExprClass:
    case Stmt::ArrayInitIndexExprClass:
    case Stmt::ExtVectorElementExprClass:
    case Stmt::MatrixElementExprClass:
    case Stmt::MatrixSingleSubscriptExprClass:
    case Stmt::MatrixSubscriptExprClass:
    case Stmt::ImaginaryLiteralClass:
    case Stmt::ObjCAtCatchStmtClass:
    case Stmt::ObjCAtFinallyStmtClass:
    case Stmt::ObjCAtTryStmtClass:
    case Stmt::ObjCAutoreleasePoolStmtClass:
    case Stmt::ObjCEncodeExprClass:
    case Stmt::ObjCIsaExprClass:
    case Stmt::ObjCProtocolExprClass:
    case Stmt::ObjCSelectorExprClass:
    case Stmt::ParenListExprClass:
    case Stmt::ShuffleVectorExprClass:
    case Stmt::ConvertVectorExprClass:
    case Stmt::VAArgExprClass:
    case Stmt::CUDAKernelCallExprClass:
    case Stmt::OpaqueValueExprClass:
    case Stmt::AsTypeExprClass:
    case Stmt::ConceptSpecializationExprClass:
    case Stmt::CXXRewrittenBinaryOperatorClass:
    case Stmt::RequiresExprClass:
    case Stmt::EmbedExprClass:
      // Fall through.
 
    // Cases we intentionally don't evaluate, since they don't need
    // to be explicitly evaluated.
    case Stmt::PredefinedExprClass:
    case Stmt::AddrLabelExprClass:
    case Stmt::IntegerLiteralClass:
    case Stmt::FixedPointLiteralClass:
    case Stmt::CharacterLiteralClass:
    case Stmt::CXXScalarValueInitExprClass:
    case Stmt::CXXBoolLiteralExprClass:
    case Stmt::ObjCBoolLiteralExprClass:
    case Stmt::ObjCAvailabilityCheckExprClass:
    case Stmt::FloatingLiteralClass:
    case Stmt::NoInitExprClass:
    case Stmt::SizeOfPackExprClass:
    case Stmt::StringLiteralClass:
    case Stmt::SourceLocExprClass:
    case Stmt::ObjCStringLiteralClass:
    case Stmt::CXXPseudoDestructorExprClass:
    case Stmt::SubstNonTypeTemplateParmExprClass:
    case Stmt::CXXNullPtrLiteralExprClass:
    case Stmt::ArraySectionExprClass:
    case Stmt::OMPArrayShapingExprClass:
    case Stmt::OMPIteratorExprClass:
    case Stmt::SYCLUniqueStableNameExprClass:
    case Stmt::OpenACCAsteriskSizeExprClass:
    case Stmt::TypeTraitExprClass: {
      Dst.insert(Pred);
      break;
    }
 
    case Stmt::AttributedStmtClass:
      VisitAttributedStmt(cast<AttributedStmt>(S), Pred, Dst);
      break;
 
    case Stmt::CXXDefaultArgExprClass:
    case Stmt::CXXDefaultInitExprClass: {
 
      const Expr *ArgE;
      if (const auto *DefE = dyn_cast<CXXDefaultArgExpr>(S))
        ArgE = DefE->getExpr();
      else if (const auto *DefE = dyn_cast<CXXDefaultInitExpr>(S))
        ArgE = DefE->getExpr();
      else
        llvm_unreachable("unknown constant wrapper kind");
 
      bool IsTemporary = false;
      if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
        ArgE = MTE->getSubExpr();
        IsTemporary = true;
      }
 
      std::optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
      if (!ConstantVal)
        ConstantVal = UnknownVal();
 
      const StackFrame *SF = Pred->getStackFrame();
      ProgramStateRef State = Pred->getState();
      State = State->BindExpr(cast<Expr>(S), SF, *ConstantVal);
      if (IsTemporary)
        State = createTemporaryRegionIfNeeded(State, SF, cast<Expr>(S),
                                              cast<Expr>(S));
      Dst.insert(Engine.makePostStmtNode(S, State, Pred));
 
      break;
    }
 
    // Cases we evaluate as opaque expressions, conjuring a symbol.
    case Stmt::CXXStdInitializerListExprClass:
    case Expr::ObjCArrayLiteralClass:
    case Expr::ObjCDictionaryLiteralClass:
    case Expr::ObjCBoxedExprClass: {
      const auto *Ex = cast<Expr>(S);
      QualType resultType = Ex->getType();
 
      const StackFrame *SF = Pred->getStackFrame();
      SVal result = svalBuilder.conjureSymbolVal(
          /*symbolTag=*/nullptr, getCFGElementRef(), SF, resultType,
          getNumVisitedCurrent());
      ProgramStateRef State = Pred->getState()->BindExpr(Ex, SF, result);
 
      // Escape pointers passed into the list, unless it's an ObjC boxed
      // expression which is not a boxable C structure.
      if (!(isa<ObjCBoxedExpr>(Ex) &&
            !cast<ObjCBoxedExpr>(Ex)->getSubExpr()->getType()->isRecordType()))
        for (auto Child : Ex->children()) {
          assert(Child);
          const auto *ChildExpr = dyn_cast<Expr>(Child);
          SVal Val = ChildExpr ? State->getSVal(ChildExpr, SF) : UnknownVal();
          State = escapeValues(State, Val, PSK_EscapeOther);
        }
 
      Dst.insert(Engine.makePostStmtNode(S, State, Pred));
      break;
    }
 
    case Stmt::ArraySubscriptExprClass:
      VisitArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
      break;
 
    case Stmt::GCCAsmStmtClass:
      VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
      break;
 
    case Stmt::MSAsmStmtClass:
      VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
      break;
 
    case Stmt::BlockExprClass:
      VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
      break;
 
    case Stmt::LambdaExprClass:
      VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
      break;
 
    case Stmt::BinaryOperatorClass: {
      const auto *B = cast<BinaryOperator>(S);
      if (B->isLogicalOp()) {
        VisitLogicalExpr(B, Pred, Dst);
        break;
      } else if (B->getOpcode() == BO_Comma) {
        SVal Val =
            Pred->getState()->getSVal(B->getRHS(), Pred->getStackFrame());
        Dst.insert(Engine.makeNodeWithBinding(Pred, B, Val));
        break;
      }
 
      if (AMgr.options.ShouldEagerlyAssume &&
          (B->isRelationalOp() || B->isEqualityOp())) {
        ExplodedNodeSet Tmp;
        VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
        evalEagerlyAssumeBifurcation(Dst, Tmp, cast<Expr>(S));
      }
      else
        VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
 
      break;
    }
 
    case Stmt::CXXOperatorCallExprClass:
    case Stmt::CallExprClass:
    case Stmt::CXXMemberCallExprClass:
    case Stmt::UserDefinedLiteralClass:
      VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
      break;
 
    case Stmt::CXXCatchStmtClass:
      VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
      break;
 
    case Stmt::CXXTemporaryObjectExprClass:
    case Stmt::CXXConstructExprClass:
      VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
      break;
 
    case Stmt::CXXInheritedCtorInitExprClass:
      VisitCXXInheritedCtorInitExpr(cast<CXXInheritedCtorInitExpr>(S), Pred,
                                    Dst);
      break;
 
    case Stmt::CXXNewExprClass:
      VisitCXXNewExpr(cast<CXXNewExpr>(S), Pred, Dst);
      break;
 
    case Stmt::CXXDeleteExprClass:
      VisitCXXDeleteExpr(cast<CXXDeleteExpr>(S), Pred, Dst);
      break;
 
    // FIXME: ChooseExpr is really a constant.  We need to fix
    //        the CFG do not model them as explicit control-flow.
    case Stmt::ChooseExprClass: { // __builtin_choose_expr
      const auto *C = cast<ChooseExpr>(S);
      VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
      break;
    }
 
    case Stmt::CompoundAssignOperatorClass:
      VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
      break;
 
    case Stmt::CompoundLiteralExprClass:
      VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
      break;
 
    case Stmt::BinaryConditionalOperatorClass:
    case Stmt::ConditionalOperatorClass: { // '?' operator
      const auto *C = cast<AbstractConditionalOperator>(S);
      VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
      break;
    }
 
    case Stmt::CXXThisExprClass:
      VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
      break;
 
    case Stmt::DeclRefExprClass: {
      const auto *DE = cast<DeclRefExpr>(S);
      VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
      break;
    }
 
    case Stmt::DeclStmtClass:
      VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
      break;
 
    case Stmt::ImplicitCastExprClass:
    case Stmt::CStyleCastExprClass:
    case Stmt::CXXStaticCastExprClass:
    case Stmt::CXXDynamicCastExprClass:
    case Stmt::CXXReinterpretCastExprClass:
    case Stmt::CXXConstCastExprClass:
    case Stmt::CXXFunctionalCastExprClass:
    case Stmt::BuiltinBitCastExprClass:
    case Stmt::ObjCBridgedCastExprClass:
    case Stmt::CXXAddrspaceCastExprClass:
      VisitCastExpr(cast<CastExpr>(S), Pred, Dst);
      break;
 
    case Expr::MaterializeTemporaryExprClass:
      VisitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(S), Pred,
                                    Dst);
      break;
 
    case Stmt::InitListExprClass: {
      const InitListExpr *E = cast<InitListExpr>(S);
      ConstructInitList(E, E->inits(), E->isTransparent(), Pred, Dst);
      break;
    }
 
    case Expr::CXXParenListInitExprClass:
      VisitCXXParenListInitExpr(cast<CXXParenListInitExpr>(S), Pred, Dst);
      break;
 
    case Stmt::MemberExprClass:
      VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
      break;
 
    case Stmt::AtomicExprClass:
      VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
      break;
 
    case Stmt::ObjCIvarRefExprClass:
      VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
      break;
 
    case Stmt::ObjCForCollectionStmtClass:
      VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
      break;
 
    case Stmt::ObjCMessageExprClass:
      VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
      break;
 
    case Stmt::ObjCAtThrowStmtClass:
    case Stmt::CXXThrowExprClass:
      // FIXME: This is not complete.  We basically treat @throw as
      // an abort.
      Engine.makePostStmtNode(S, Pred->getState(), Pred, /*MarkAsSink=*/true);
      break;
 
    case Stmt::ReturnStmtClass:
      VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
      break;
 
    case Stmt::OffsetOfExprClass:
      VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Pred, Dst);
      break;
 
    case Stmt::UnaryExprOrTypeTraitExprClass:
      VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S), Pred,
                                    Dst);
      break;
 
    case Stmt::StmtExprClass:
      VisitStmtExpr(cast<StmtExpr>(S), Pred, Dst);
      break;
 
    case Stmt::UnaryOperatorClass: {
      const auto *U = cast<UnaryOperator>(S);
      if (AMgr.options.ShouldEagerlyAssume && (U->getOpcode() == UO_LNot)) {
        ExplodedNodeSet Tmp;
        VisitUnaryOperator(U, Pred, Tmp);
        evalEagerlyAssumeBifurcation(Dst, Tmp, U);
      }
      else
        VisitUnaryOperator(U, Pred, Dst);
      break;
    }
 
    case Stmt::PseudoObjectExprClass:
      VisitPseudoObjectExpr(cast<PseudoObjectExpr>(S), Pred, Dst);
      break;
 
    case Expr::ObjCIndirectCopyRestoreExprClass:
      VisitObjCIndirectCopyRestoreExpr(cast<ObjCIndirectCopyRestoreExpr>(S),
                                       Pred, Dst);
      break;
    }
}
 
bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
                                       const StackFrame *CalleeSF) {
  const StackFrame *CallerSF = CalleeSF->getParent();
  assert(CalleeSF && CallerSF);
  ExplodedNode *BeforeProcessingCall = nullptr;
  const Expr *CE = CalleeSF->getCallSite();
 
  // Find the first node before we started processing the call expression.
  while (N) {
    ProgramPoint L = N->getLocation();
    BeforeProcessingCall = N;
    N = N->pred_empty() ? nullptr : *(N->pred_begin());
 
    // Skip the nodes corresponding to the inlined code.
    if (L.getStackFrame() != CallerSF)
      continue;
    // We reached the caller. Find the node right before we started
    // processing the call.
    if (L.isPurgeKind())
      continue;
    if (L.getAs<PreImplicitCall>())
      continue;
    if (L.getAs<CallEnter>())
      continue;
    if (std::optional<StmtPoint> SP = L.getAs<StmtPoint>())
      if (SP->getStmt() == CE)
        continue;
    break;
  }
 
  if (!BeforeProcessingCall)
    return false;
 
  // TODO: Clean up the unneeded nodes.
 
  // Build an Epsilon node from which we will restart the analyzes.
  // Note that CE is permitted to be NULL!
  static SimpleProgramPointTag PT("ExprEngine", "Replay without inlining");
  ProgramPoint NewNodeLoc =
      EpsilonPoint(BeforeProcessingCall->getStackFrame(), CE, nullptr, &PT);
  // Add the special flag to GDM to signal retrying with no inlining.
  // Note, changing the state ensures that we are not going to cache out.
  // NOTE: This stores the call site (CE) in the state trait, but the the
  // actual pointer value is only checked by an assertion; for the analysis,
  // only the presence or absence of this trait matters.
  // TODO: If we are handling a destructor call, CE is nullpointer (because it
  // ultimately comes from the `Origin` of a `CXXDestructorCall`), which is
  // indistinguishable from the absence (default state) of this state trait.
  // I don't think that this bad logic causes actually observable problems, but
  // it would be nice to clean it up if somebody has time to do so.
  ProgramStateRef NewNodeState = BeforeProcessingCall->getState();
  NewNodeState = NewNodeState->set<ReplayWithoutInlining>(CE);
 
  // Make the new node a successor of BeforeProcessingCall.
  bool IsNew = false;
  ExplodedNode *NewNode = G.getNode(NewNodeLoc, NewNodeState, false, &IsNew);
  // We cached out at this point. Caching out is common due to us backtracking
  // from the inlined function, which might spawn several paths.
  // NOTE: We must return before the `addPredecessor()` call, otherwise the
  // node vectors `NewNode->Preds` and `BeforeProcessingCall->Succs` would
  // end up containing multiple copies of `BeforeProcessingCall` / `NewNode`.
  if (!IsNew)
    return true;
 
  NewNode->addPredecessor(BeforeProcessingCall, G);
 
  // Add the new node to the work list.
  Engine.enqueueStmtNode(NewNode, CalleeSF->getCallSiteBlock(),
                                  CalleeSF->getIndex());
  NumTimesRetriedWithoutInlining++;
  return true;
}
 
/// Block entrance.  (Update counters).
ExplodedNode *ExprEngine::processCFGBlockEntrance(const BlockEntrance &BE,
                                                  ExplodedNode *Pred) {
  const StackFrame *SF = Pred->getStackFrame();
  const Stmt *Term = getCurrBlock()->getTerminatorStmt();
  ProgramStateRef State = Pred->getState();
  unsigned MaxBlockVisit = AMgr.options.maxBlockVisitOnPath;
 
  // If we reach a loop which has a known bound (and meets other constraints)
  // then consider completely unrolling it.
  if (AMgr.options.ShouldUnrollLoops) {
    if (Term)
      State = updateLoopStack(Term, AMgr.getASTContext(), Pred, MaxBlockVisit);
    // Is we are inside an unrolled loop then no need the check the counters.
    if (isUnrolledState(State))
      return Engine.makeNode(BE, State, Pred);
  }
 
  // If this block is terminated by a loop and it has already been visited the
  // maximum number of times, widen the loop.
  unsigned int BlockCount = getNumVisitedCurrent();
  if (BlockCount == MaxBlockVisit - 1 && AMgr.options.ShouldWidenLoops) {
    if (!isa_and_nonnull<ForStmt, WhileStmt, DoStmt, CXXForRangeStmt>(Term))
      return Engine.makeNode(BE, State, Pred);
 
    // FIXME:
    // We cannot use the CFG element from the via `ExprEngine::getCFGElementRef`
    // since we are currently at the block entrance and the current reference
    // would be stale.  Ideally, we should pass on the terminator of the CFG
    // block, but the terminator cannot be referred as a CFG element.
    // Here we just pass the the first CFG element in the block.
    ProgramStateRef WidenedState = getWidenedLoopState(
        State, SF, BlockCount, *getCurrBlock()->ref_begin());
    return Engine.makeNode(BE, WidenedState, Pred);
  }
 
  // If we did not reach MaxBlockVisitOnPath, continue the analysis normally.
  if (BlockCount < MaxBlockVisit)
    return Engine.makeNode(BE, State, Pred);
 
  // ... otherwise, discard this execution path.
  static SimpleProgramPointTag Tag(TagProviderName, "Block count exceeded");
  const ExplodedNode *Sink =
      Engine.makeNode(BE.withTag(&Tag), State, Pred, /*MarkAsSink=*/true);
 
  if (!SF->inTopFrame()) {
    // FIXME: This will unconditionally prevent inlining this function (even
    // from other entry points), which is not a reasonable heuristic: even if
    // we reached max block count on this particular execution path, there
    // may be other execution paths (especially with other parametrizations)
    // where the analyzer can reach the end of the function (so there is no
    // natural reason to avoid inlining it). However, disabling this would
    // significantly increase the analysis time (because more entry points
    // would exhaust their allocated budget), so it must be compensated by a
    // different (more reasonable) reduction of analysis scope.
    Engine.FunctionSummaries->markShouldNotInline(SF->getDecl());
 
    // Re-run the call evaluation without inlining it, by storing the
    // no-inlining policy in the state and enqueuing the new work item on
    // the list. Replay should almost never fail. Use the stats to catch it
    // if it does.
    if (!AMgr.options.NoRetryExhausted && replayWithoutInlining(Pred, SF))
      return nullptr;
    NumMaxBlockCountReachedInInlined++;
  } else
    NumMaxBlockCountReached++;
 
  // Make sink nodes as exhausted(for stats) only if retry failed.
  Engine.blocksExhausted.push_back(std::make_pair(BE, Sink));
 
  return nullptr;
}
 
void ExprEngine::runCheckersForBlockEntrance(const BlockEntrance &Entrance,
                                             ExplodedNode *Pred,
                                             ExplodedNodeSet &Dst) {
  llvm::PrettyStackTraceFormat CrashInfo(
      "Processing block entrance B%d -> B%d",
      Entrance.getPreviousBlock()->getBlockID(),
      Entrance.getBlock()->getBlockID());
  getCheckerManager().runCheckersForBlockEntrance(Dst, Pred, Entrance, *this);
}
 
//===----------------------------------------------------------------------===//
// Branch processing.
//===----------------------------------------------------------------------===//
 
/// RecoverCastedSymbol - A helper function for ProcessBranch that is used
/// to try to recover some path-sensitivity for casts of symbolic
/// integers that promote their values (which are currently not tracked well).
/// This function returns the SVal bound to Condition->IgnoreCasts if all the
//  cast(s) did was sign-extend the original value.
static SVal RecoverCastedSymbol(ProgramStateRef state, const Stmt *Condition,
                                const StackFrame *SF, ASTContext &Ctx) {
 
  const auto *Ex = dyn_cast<Expr>(Condition);
  if (!Ex)
    return UnknownVal();
 
  uint64_t bits = 0;
  bool bitsInit = false;
 
  while (const auto *CE = dyn_cast<CastExpr>(Ex)) {
    QualType T = CE->getType();
 
    if (!T->isIntegralOrEnumerationType())
      return UnknownVal();
 
    uint64_t newBits = Ctx.getTypeSize(T);
    if (!bitsInit || newBits < bits) {
      bitsInit = true;
      bits = newBits;
    }
 
    Ex = CE->getSubExpr();
  }
 
  // We reached a non-cast.  Is it a symbolic value?
  QualType T = Ex->getType();
 
  if (!bitsInit || !T->isIntegralOrEnumerationType() ||
      Ctx.getTypeSize(T) > bits)
    return UnknownVal();
 
  return state->getSVal(Ex, SF);
}
 
#ifndef NDEBUG
static const Stmt *getRightmostLeaf(const Stmt *Condition) {
  while (Condition) {
    const auto *BO = dyn_cast<BinaryOperator>(Condition);
    if (!BO || !BO->isLogicalOp()) {
      return Condition;
    }
    Condition = BO->getRHS()->IgnoreParens();
  }
  return nullptr;
}
#endif
 
// Returns the condition the branch at the end of 'B' depends on and whose value
// has been evaluated within 'B'.
// In most cases, the terminator condition of 'B' will be evaluated fully in
// the last statement of 'B'; in those cases, the resolved condition is the
// given 'Condition'.
// If the condition of the branch is a logical binary operator tree, the CFG is
// optimized: in that case, we know that the expression formed by all but the
// rightmost leaf of the logical binary operator tree must be true, and thus
// the branch condition is at this point equivalent to the truth value of that
// rightmost leaf; the CFG block thus only evaluates this rightmost leaf
// expression in its final statement. As the full condition in that case was
// not evaluated, and is thus not in the SVal cache, we need to use that leaf
// expression to evaluate the truth value of the condition in the current state
// space.
static const Stmt *ResolveCondition(const Stmt *Condition,
                                    const CFGBlock *B) {
  if (const auto *Ex = dyn_cast<Expr>(Condition))
    Condition = Ex->IgnoreParens();
 
  const auto *BO = dyn_cast<BinaryOperator>(Condition);
  if (!BO || !BO->isLogicalOp())
    return Condition;
 
  assert(B->getTerminator().isStmtBranch() &&
         "Other kinds of branches are handled separately!");
 
  // For logical operations, we still have the case where some branches
  // use the traditional "merge" approach and others sink the branch
  // directly into the basic blocks representing the logical operation.
  // We need to distinguish between those two cases here.
 
  // The invariants are still shifting, but it is possible that the
  // last element in a CFGBlock is not a CFGStmt.  Look for the last
  // CFGStmt as the value of the condition.
  for (CFGElement Elem : llvm::reverse(*B)) {
    std::optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
    if (!CS)
      continue;
    const Stmt *LastStmt = CS->getStmt();
    assert(LastStmt == Condition || LastStmt == getRightmostLeaf(Condition));
    return LastStmt;
  }
  llvm_unreachable("could not resolve condition");
}
 
using ObjCForLctxPair =
    std::pair<const ObjCForCollectionStmt *, const StackFrame *>;
 
REGISTER_MAP_WITH_PROGRAMSTATE(ObjCForHasMoreIterations, ObjCForLctxPair, bool)
 
ProgramStateRef ExprEngine::setWhetherHasMoreIteration(
    ProgramStateRef State, const ObjCForCollectionStmt *O, const StackFrame *SF,
    bool HasMoreIteraton) {
  assert(!State->contains<ObjCForHasMoreIterations>({O, SF}));
  return State->set<ObjCForHasMoreIterations>({O, SF}, HasMoreIteraton);
}
 
ProgramStateRef ExprEngine::removeIterationState(ProgramStateRef State,
                                                 const ObjCForCollectionStmt *O,
                                                 const StackFrame *SF) {
  assert(State->contains<ObjCForHasMoreIterations>({O, SF}));
  return State->remove<ObjCForHasMoreIterations>({O, SF});
}
 
bool ExprEngine::hasMoreIteration(ProgramStateRef State,
                                  const ObjCForCollectionStmt *O,
                                  const StackFrame *SF) {
  assert(State->contains<ObjCForHasMoreIterations>({O, SF}));
  return *State->get<ObjCForHasMoreIterations>({O, SF});
}
 
/// Split the state on whether there are any more iterations left for this loop.
/// Returns a (HasMoreIteration, HasNoMoreIteration) pair, or std::nullopt when
/// the acquisition of the loop condition value failed.
static std::optional<std::pair<ProgramStateRef, ProgramStateRef>>
assumeCondition(const Stmt *ConditionStmt, ExplodedNode *N) {
  ProgramStateRef State = N->getState();
  if (const auto *ObjCFor = dyn_cast<ObjCForCollectionStmt>(ConditionStmt)) {
    bool HasMoreIteraton =
        ExprEngine::hasMoreIteration(State, ObjCFor, N->getStackFrame());
    // Checkers have already ran on branch conditions, so the current
    // information as to whether the loop has more iteration becomes outdated
    // after this point.
    State =
        ExprEngine::removeIterationState(State, ObjCFor, N->getStackFrame());
    if (HasMoreIteraton)
      return std::pair<ProgramStateRef, ProgramStateRef>{State, nullptr};
    else
      return std::pair<ProgramStateRef, ProgramStateRef>{nullptr, State};
  }
 
  const auto *ConditionExpr = dyn_cast<Expr>(ConditionStmt);
  assert(ConditionExpr && "The condition must be an Expr from here!");
 
  SVal X = State->getSVal(ConditionExpr, N->getStackFrame());
 
  if (X.isUnknownOrUndef()) {
    // Give it a chance to recover from unknown.
    if (const auto *Ex = dyn_cast<Expr>(ConditionExpr)) {
      if (Ex->getType()->isIntegralOrEnumerationType()) {
        // Try to recover some path-sensitivity.  Right now casts of symbolic
        // integers that promote their values are currently not tracked well.
        // If 'ConditionExpr' is such an expression, try and recover the
        // underlying value and use that instead.
        SVal recovered =
            RecoverCastedSymbol(State, ConditionExpr, N->getStackFrame(),
                                N->getState()->getStateManager().getContext());
 
        if (!recovered.isUnknown()) {
          X = recovered;
        }
      }
    }
  }
 
  // If the condition is still unknown, give up.
  if (X.isUnknownOrUndef())
    return std::nullopt;
 
  DefinedSVal V = X.castAs<DefinedSVal>();
 
  return State->assume(V);
}
 
void ExprEngine::processBranch(
    const Stmt *Condition, ExplodedNode *Pred, ExplodedNodeSet &Dst,
    const CFGBlock *DstT, const CFGBlock *DstF,
    std::optional<unsigned> IterationsCompletedInLoop) {
  assert((!Condition || !isa<CXXBindTemporaryExpr>(Condition)) &&
         "CXXBindTemporaryExprs are handled by processBindTemporary.");
 
  const StackFrame *SF = Pred->getStackFrame();
 
  // Check for NULL conditions; e.g. "for(;;)"
  if (!Condition) {
    if (!DstT) {
      // I _hope_ that this "null condition + null transition to loop body"
      // case is impossible, but I cannot prove this, so let's cover it.
      return;
    }
    BlockEdge BE(getCurrBlock(), DstT, SF);
    Dst.insert(Engine.makeNode(BE, Pred->getState(), Pred));
    return;
  }
 
  if (const auto *Ex = dyn_cast<Expr>(Condition))
    Condition = Ex->IgnoreParens();
 
  Condition = ResolveCondition(Condition, getCurrBlock());
  PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
                                Condition->getBeginLoc(),
                                "Error evaluating branch");
 
  ExplodedNodeSet CheckersOutSet;
  getCheckerManager().runCheckersForBranchCondition(Condition, CheckersOutSet,
                                                    Pred, *this);
  // We generated only sinks.
  if (CheckersOutSet.empty())
    return;
 
  for (ExplodedNode *PredN : CheckersOutSet) {
    ProgramStateRef PrevState = PredN->getState();
 
    ProgramStateRef StTrue = PrevState, StFalse = PrevState;
    if (const auto KnownCondValueAssumption = assumeCondition(Condition, PredN))
      std::tie(StTrue, StFalse) = *KnownCondValueAssumption;
 
    if (StTrue && StFalse)
      assert(!isa<ObjCForCollectionStmt>(Condition));
 
    // We want to ensure consistent behavior between `eagerly-assume=false`,
    // when the state split is always performed by the `assumeCondition()`
    // call within this function and `eagerly-assume=true` (the default), when
    // some conditions (comparison operators, unary negation) can trigger a
    // state split before this callback. There are some contrived corner cases
    // that behave differently with and without `eagerly-assume`, but I don't
    // know about an example that could plausibly appear in "real" code.
    bool BothFeasible =
        (StTrue && StFalse) ||
        didEagerlyAssumeBifurcateAt(PrevState, dyn_cast<Expr>(Condition));
 
    if (StTrue) {
      // In a loop, if both branches are feasible (i.e. the analyzer doesn't
      // understand the loop condition) and two iterations have already been
      // completed, then don't assume a third iteration because it is a
      // redundant execution path (unlikely to be different from earlier loop
      // exits) and can cause false positives if e.g. the loop iterates over a
      // two-element structure with an opaque condition.
      //
      // The iteration count "2" is hardcoded because it's the natural limit:
      // * the fact that the programmer wrote a loop (and not just an `if`)
      //   implies that they thought that the loop body might be executed twice;
      // * however, there are situations where the programmer knows that there
      //   are at most two iterations but writes a loop that appears to be
      //   generic, because there is no special syntax for "loop with at most
      //   two iterations". (This pattern is common in FFMPEG and appears in
      //   many other projects as well.)
      bool CompletedTwoIterations = IterationsCompletedInLoop.value_or(0) >= 2;
      bool SkipTrueBranch = BothFeasible && CompletedTwoIterations;
 
      // FIXME: This "don't assume third iteration" heuristic partially
      // conflicts with the widen-loop analysis option (which is off by
      // default). If we intend to support and stabilize the loop widening,
      // we must ensure that it 'plays nicely' with this logic.
      if (!SkipTrueBranch || AMgr.options.ShouldWidenLoops) {
        if (DstT) {
          BlockEdge BE(getCurrBlock(), DstT, SF);
          Dst.insert(Engine.makeNode(BE, StTrue, PredN));
        }
      } else if (!AMgr.options.InlineFunctionsWithAmbiguousLoops) {
        // FIXME: There is an ancient and arbitrary heuristic in
        // `ExprEngine::processCFGBlockEntrance` which prevents all further
        // inlining of a function if it finds an execution path within that
        // function which reaches the `MaxBlockVisitOnPath` limit (a/k/a
        // `analyzer-max-loop`, by default four iterations in a loop). Adding
        // this "don't assume third iteration" logic significantly increased
        // the analysis runtime on some inputs because less functions were
        // arbitrarily excluded from being inlined, so more entry points used
        // up their full allocated budget. As a hacky compensation for this,
        // here we apply the "should not inline" mark in cases when the loop
        // could potentially reach the `MaxBlockVisitOnPath` limit without the
        // "don't assume third iteration" logic. This slightly overcompensates
        // (activates if the third iteration can be entered, and will not
        // recognize cases where the fourth iteration would't be completed), but
        // should be good enough for practical purposes.
        if (!SF->inTopFrame()) {
          Engine.FunctionSummaries->markShouldNotInline(SF->getDecl());
        }
      }
    }
 
    if (StFalse) {
      // In a loop, if both branches are feasible (i.e. the analyzer doesn't
      // understand the loop condition), we are before the first iteration and
      // the analyzer option `assume-at-least-one-iteration` is set to `true`,
      // then avoid creating the execution path where the loop is skipped.
      //
      // In some situations this "loop is skipped" execution path is an
      // important corner case that may evade the notice of the developer and
      // hide significant bugs -- however, there are also many situations where
      // it's guaranteed that at least one iteration will happen (e.g. some
      // data structure is always nonempty), but the analyzer cannot realize
      // this and will produce false positives when it assumes that the loop is
      // skipped.
      bool BeforeFirstIteration = IterationsCompletedInLoop == std::optional{0};
      bool SkipFalseBranch = BothFeasible && BeforeFirstIteration &&
                             AMgr.options.ShouldAssumeAtLeastOneIteration;
      if (!SkipFalseBranch && DstF) {
        BlockEdge BE(getCurrBlock(), DstF, SF);
        Dst.insert(Engine.makeNode(BE, StFalse, PredN));
      }
    }
  }
}
 
/// The GDM component containing the set of global variables which have been
/// previously initialized with explicit initializers.
REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,
                                 llvm::ImmutableSet<const VarDecl *>)
 
void ExprEngine::processStaticInitializer(const DeclStmt *DS,
                                          ExplodedNode *Pred,
                                          ExplodedNodeSet &Dst,
                                          const CFGBlock *DstT,
                                          const CFGBlock *DstF) {
  const auto *VD = cast<VarDecl>(DS->getSingleDecl());
  ProgramStateRef State = Pred->getState();
  bool InitHasRun = State->contains<InitializedGlobalsSet>(VD);
  if (!InitHasRun)
    State = State->add<InitializedGlobalsSet>(VD);
 
  if (const CFGBlock *DstBlock = InitHasRun ? DstT : DstF) {
    BlockEdge BE(getCurrBlock(), DstBlock, Pred->getStackFrame());
    Dst.insert(Engine.makeNode(BE, State, Pred));
  }
}
 
/// processIndirectGoto - Called by CoreEngine.  Used to generate successor
///  nodes by processing the 'effects' of a computed goto jump.
void ExprEngine::processIndirectGoto(ExplodedNodeSet &Dst, const Expr *Tgt,
                                     const CFGBlock *Dispatch,
                                     ExplodedNode *Pred) {
  ProgramStateRef State = Pred->getState();
  SVal V = State->getSVal(Tgt, getCurrStackFrame());
 
  // We cannot dispatch anywhere if the label is undefined, NULL or some other
  // concrete number.
  // FIXME: Emit a warning in this situation.
  if (isa<UndefinedVal, loc::ConcreteInt>(V))
    return;
 
  // If 'V' is the address of a concrete goto label (on this execution path),
  // then only transition along the edge to that label.
  // FIXME: Implement dispatch for symbolic pointers, utilizing information
  // that they are equal or not equal to pointers to a certain goto label.
  const LabelDecl *L = nullptr;
  if (auto LV = V.getAs<loc::GotoLabel>())
    L = LV->getLabel();
 
  // Dispatch to the label 'L' or to all labels if 'L' is null.
  for (const CFGBlock *Succ : Dispatch->succs()) {
    if (!L || cast<LabelStmt>(Succ->getLabel())->getDecl() == L) {
      // FIXME: If 'V' was a symbolic value, then record that on this execution
      // path it is equal to the address of the label leading to 'Succ'.
      BlockEdge BE(getCurrBlock(), Succ, Pred->getStackFrame());
      Dst.insert(Engine.makeNode(BE, State, Pred));
    }
  }
}
 
void ExprEngine::processBeginOfFunction(ExplodedNode *Pred,
                                        ExplodedNodeSet &Dst,
                                        const BlockEdge &L) {
  getCheckerManager().runCheckersForBeginFunction(Dst, L, Pred, *this);
}
 
/// ProcessEndPath - Called by CoreEngine.  Used to generate end-of-path
///  nodes when the control reaches the end of a function.
void ExprEngine::processEndOfFunction(ExplodedNode *Pred,
                                      const ReturnStmt *RS) {
  ProgramStateRef State = Pred->getState();
 
  if (!Pred->getStackFrame()->inTopFrame())
    State = finishArgumentConstruction(
        State, *getStateManager().getCallEventManager().getCaller(
                   Pred->getStackFrame(), Pred->getState()));
 
  // FIXME: We currently cannot assert that temporaries are clear, because
  // lifetime extended temporaries are not always modelled correctly. In some
  // cases when we materialize the temporary, we do
  // createTemporaryRegionIfNeeded(), and the region changes, and also the
  // respective destructor becomes automatic from temporary. So for now clean up
  // the state manually before asserting. Ideally, this braced block of code
  // should go away.
  {
    const StackFrame *FromSF = Pred->getStackFrame();
    const StackFrame *ToSF = FromSF->getParent();
    const StackFrame *SF = FromSF;
    while (SF != ToSF) {
      assert(SF && "ToSF must be a parent of FromSF!");
      for (auto I : State->get<ObjectsUnderConstruction>())
        if (I.first.getStackFrame() == SF) {
          // The comment above only pardons us for not cleaning up a
          // temporary destructor. If any other statements are found here,
          // it must be a separate problem.
          assert(I.first.getItem().getKind() ==
                     ConstructionContextItem::TemporaryDestructorKind ||
                 I.first.getItem().getKind() ==
                     ConstructionContextItem::ElidedDestructorKind);
          State = State->remove<ObjectsUnderConstruction>(I.first);
        }
      SF = SF->getParent();
    }
  }
 
  // Perform the transition with cleanups.
  if (State != Pred->getState()) {
    Pred = Engine.makeNode(Pred->getLocation(), State, Pred);
    if (!Pred) {
      // The node with clean temporaries already exists. We might have reached
      // it on a path on which we initialize different temporaries.
      return;
    }
  }
 
  assert(areAllObjectsFullyConstructed(Pred->getState(), Pred->getStackFrame(),
                                       Pred->getStackFrame()->getParent()));
  ExplodedNodeSet Dst;
  if (Pred->getStackFrame()->inTopFrame()) {
    // Remove dead symbols.
    ExplodedNodeSet AfterRemovedDead;
    removeDeadOnEndOfFunction(Pred, AfterRemovedDead);
 
    // Notify checkers.
    for (const auto I : AfterRemovedDead)
      getCheckerManager().runCheckersForEndFunction(Dst, I, *this, RS);
  } else {
    getCheckerManager().runCheckersForEndFunction(Dst, Pred, *this, RS);
  }
 
  Engine.enqueueEndOfFunction(Dst, RS);
}
 
/// ProcessSwitch - Called by CoreEngine.  Used to generate successor
///  nodes by processing the 'effects' of a switch statement.
void ExprEngine::processSwitch(const SwitchStmt *Switch, ExplodedNode *Pred,
                               ExplodedNodeSet &Dst) {
  const ASTContext &ACtx = getContext();
  const StackFrame *SF = Pred->getStackFrame();
  const Expr *Condition = Switch->getCond();
 
  // The block that is terminated by the switch statement.
  const CFGBlock *SwitchBlock = getCurrBlock();
  // Note that successors may be null if they are pruned as unreachable.
  assert(SwitchBlock->succ_size() && "Switch must have at least one successor");
  // The reversed iteration order is present since the beginning, when in 2008
  // commit 80ebc1d1c95704b0ff0386b3a3cbc8b3ff960654 added support for handling
  // switch statements. I don't see any advantage over regular forward
  // iteration -- but switching the order would perturb the insertion order of
  // the work list and therefore the analysis results.
  llvm::iterator_range<CFGBlock::const_succ_reverse_iterator> CaseBlocks(
      SwitchBlock->succ_rbegin() + 1, SwitchBlock->succ_rend());
  const CFGBlock *DefaultBlock = *SwitchBlock->succ_rbegin();
 
  ExplodedNodeSet CheckersOutSet;
 
  getCheckerManager().runCheckersForBranchCondition(
      Condition->IgnoreParens(), CheckersOutSet, Pred, *this);
 
  for (ExplodedNode *Node : CheckersOutSet) {
    ProgramStateRef State = Node->getState();
 
    SVal CondV = State->getSVal(Condition, SF);
    if (CondV.isUndef()) {
      // This can only happen if core.uninitialized.Branch is disabled.
      continue;
    }
    std::optional<NonLoc> CondNL = CondV.getAs<NonLoc>();
 
    for (const CFGBlock *CaseBlock : CaseBlocks) {
      // Successor may be pruned out during CFG construction.
      if (!CaseBlock)
        continue;
 
      const CaseStmt *Case = cast<CaseStmt>(CaseBlock->getLabel());
 
      // Evaluate the LHS of the case value.
      llvm::APSInt V1 = Case->getLHS()->EvaluateKnownConstInt(ACtx);
      assert(V1.getBitWidth() ==
             getContext().getIntWidth(Condition->getType()));
 
      // Get the RHS of the case, if it exists.
      llvm::APSInt V2;
      if (const Expr *E = Case->getRHS())
        V2 = E->EvaluateKnownConstInt(ACtx);
      else
        V2 = V1;
 
      ProgramStateRef StateMatching;
      if (CondNL) {
        // Split the state: this "case:" matches / does not match.
        std::tie(StateMatching, State) =
            State->assumeInclusiveRange(*CondNL, V1, V2);
      } else {
        // The switch condition is UnknownVal, so we enter each "case:" without
        // any state update.
        StateMatching = State;
      }
 
      if (StateMatching) {
        BlockEdge BE(SwitchBlock, CaseBlock, SF);
        Dst.insert(Engine.makeNode(BE, StateMatching, Node));
      }
 
      // If _not_ entering the current case is infeasible, then we are done
      // with processing the paths through the current Node.
      if (!State)
        break;
    }
    if (!State)
      continue;
 
    // The default block may be null if it is "optimized out" by CFG creation.
    if (!DefaultBlock)
      continue;
 
    // If we have switch(enum value), the default branch is not
    // feasible if all of the enum constants not covered by 'case:' statements
    // are not feasible values for the switch condition.
    //
    // Note that this isn't as accurate as it could be.  Even if there isn't
    // a case for a particular enum value as long as that enum value isn't
    // feasible then it shouldn't be considered for making 'default:' reachable.
    if (Condition->IgnoreParenImpCasts()->getType()->isEnumeralType()) {
      if (Switch->isAllEnumCasesCovered())
        continue;
    }
 
    BlockEdge BE(SwitchBlock, DefaultBlock, SF);
    Dst.insert(Engine.makeNode(BE, State, Node));
  }
}
 
//===----------------------------------------------------------------------===//
// Transfer functions: Loads and stores.
//===----------------------------------------------------------------------===//
 
std::optional<std::pair<SVal, QualType>>
ExprEngine::resolveAsLambdaCapturedVar(const Expr *Ex, const ValueDecl *VD,
                                       const ExplodedNode *Pred) const {
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  const auto *MD = dyn_cast<CXXMethodDecl>(SF->getDecl());
  const auto *DeclRefEx = dyn_cast<DeclRefExpr>(Ex);
  if (!AMgr.options.ShouldInlineLambdas || !DeclRefEx ||
      !DeclRefEx->refersToEnclosingVariableOrCapture() || !MD ||
      !MD->getParent()->isLambda()) {
    return std::nullopt;
  }
  // Lookup the field of the lambda.
  const CXXRecordDecl *CXXRec = MD->getParent();
  llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
  FieldDecl *LambdaThisCaptureField;
  CXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
 
  // Sema follows a sequence of complex rules to determine whether the
  // variable should be captured.
  if (const FieldDecl *FD = LambdaCaptureFields[VD]) {
    if (MD->isImplicitObjectMemberFunction()) {
      Loc CXXThis = svalBuilder.getCXXThis(MD, SF);
      SVal CXXThisVal = State->getSVal(CXXThis);
      return {{State->getLValue(FD, CXXThisVal), FD->getType()}};
    }
    const ParmVarDecl *PVD = MD->getParamDecl(0);
    if (const Expr *CallSite = SF->getCallSite()) {
      const ParamVarRegion *PVR =
          MRMgr.getParamVarRegion(CallSite, /*Index=*/0, SF);
      const Expr *SelfArgExpr = cast<CallExpr>(CallSite)->getArg(0);
      if (PVD->getType()->isReferenceType()) {
        // TODO: This binding should happen at call entry instead. The same way
        // it does for the implicit object parameter (CXXThisRegion, bound in
        // CXXInstanceCall::getInitialStackFrameContents). The explicit object
        // parameter's ParamVarRegion is never bound there today, so this
        // binding is just a workaround. A follow-up PR should properly bind it
        // at call entry, so it is no longer needed here.
        State =
            State->bindLoc(loc::MemRegionVal(PVR),
                           State->getSVal(SelfArgExpr, SF->getParent()), SF);
        SVal ParamSVal = State->getSVal(loc::MemRegionVal(PVR));
        return {{State->getLValue(FD, ParamSVal), FD->getType()}};
      }
      return {{State->getLValue(FD, loc::MemRegionVal(PVR)), FD->getType()}};
    }
  }
  return std::nullopt;
}
 
void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
                                        ExplodedNode *Pred,
                                        ExplodedNodeSet &Dst) {
  ProgramStateRef state = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  if (const auto *VD = dyn_cast<VarDecl>(D)) {
    // C permits "extern void v", and if you cast the address to a valid type,
    // you can even do things with it. We simply pretend
    assert(Ex->isGLValue() || VD->getType()->isVoidType());
    std::optional<std::pair<SVal, QualType>> VInfo =
        resolveAsLambdaCapturedVar(Ex, VD, Pred);
 
    if (!VInfo)
      VInfo = std::make_pair(state->getLValue(VD, SF), VD->getType());
 
    SVal V = VInfo->first;
    bool IsReference = VInfo->second->isReferenceType();
 
    // For references, the 'lvalue' is the pointer address stored in the
    // reference region.
    if (IsReference) {
      if (const MemRegion *R = V.getAsRegion())
        V = state->getSVal(R);
      else
        V = UnknownVal();
    }
 
    Dst.insert(
        Engine.makeNodeWithBinding(Pred, Ex, V, ProgramPoint::PostLValueKind));
    return;
  }
  if (const auto *ED = dyn_cast<EnumConstantDecl>(D)) {
    assert(!Ex->isGLValue());
    SVal V = svalBuilder.makeIntVal(ED->getInitVal());
    Dst.insert(Engine.makeNodeWithBinding(Pred, Ex, V));
    return;
  }
  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
    SVal V = svalBuilder.getFunctionPointer(FD);
    Dst.insert(
        Engine.makeNodeWithBinding(Pred, Ex, V, ProgramPoint::PostLValueKind));
    return;
  }
  if (isa<FieldDecl, IndirectFieldDecl>(D)) {
    // Delegate all work related to pointer to members to the surrounding
    // operator&.
    Dst.insert(Pred);
    return;
  }
  if (const auto *BD = dyn_cast<BindingDecl>(D)) {
    // Handle structured bindings captured by lambda.
    if (std::optional<std::pair<SVal, QualType>> VInfo =
            resolveAsLambdaCapturedVar(Ex, BD, Pred)) {
      auto [V, T] = VInfo.value();
 
      if (T->isReferenceType()) {
        if (const MemRegion *R = V.getAsRegion())
          V = state->getSVal(R);
        else
          V = UnknownVal();
      }
 
      Dst.insert(Engine.makeNodeWithBinding(Pred, Ex, V,
                                            ProgramPoint::PostLValueKind));
      return;
    }
 
    const auto *DD = cast<DecompositionDecl>(BD->getDecomposedDecl());
 
    SVal Base = state->getLValue(DD, SF);
    if (DD->getType()->isReferenceType()) {
      if (const MemRegion *R = Base.getAsRegion())
        Base = state->getSVal(R);
      else
        Base = UnknownVal();
    }
 
    SVal V = UnknownVal();
 
    // Handle binding to data members
    if (const auto *ME = dyn_cast<MemberExpr>(BD->getBinding())) {
      const auto *Field = cast<FieldDecl>(ME->getMemberDecl());
      V = state->getLValue(Field, Base);
    }
    // Handle binding to arrays
    else if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(BD->getBinding())) {
      SVal Idx = state->getSVal(ASE->getIdx(), SF);
 
      // Note: the index of an element in a structured binding is automatically
      // created and it is a unique identifier of the specific element. Thus it
      // cannot be a value that varies at runtime.
      assert(Idx.isConstant() && "BindingDecl array index is not a constant!");
 
      V = state->getLValue(BD->getType(), Idx, Base);
    }
    // Handle binding to tuple-like structures
    else if (const auto *HV = BD->getHoldingVar()) {
      V = state->getLValue(HV, SF);
 
      if (HV->getType()->isReferenceType()) {
        if (const MemRegion *R = V.getAsRegion())
          V = state->getSVal(R);
        else
          V = UnknownVal();
      }
    } else
      llvm_unreachable("An unknown case of structured binding encountered!");
 
    // In case of tuple-like types the references are already handled, so we
    // don't want to handle them again.
    if (BD->getType()->isReferenceType() && !BD->getHoldingVar()) {
      if (const MemRegion *R = V.getAsRegion())
        V = state->getSVal(R);
      else
        V = UnknownVal();
    }
 
    Dst.insert(
        Engine.makeNodeWithBinding(Pred, Ex, V, ProgramPoint::PostLValueKind));
    return;
  }
 
  if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {
    // FIXME: We should meaningfully implement this.
    (void)TPO;
    Dst.insert(Pred);
    return;
  }
 
  llvm_unreachable("Support for this Decl not implemented.");
}
 
/// VisitArrayInitLoopExpr - Transfer function for array init loop.
void ExprEngine::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *Ex,
                                        ExplodedNode *Pred,
                                        ExplodedNodeSet &Dst) {
  const Expr *Arr = Ex->getCommonExpr()->getSourceExpr();
 
  // The constructor visitor has already handled everything
  if (isa<CXXConstructExpr>(Ex->getSubExpr())) {
    Dst.insert(Pred);
    return;
  }
 
  const StackFrame *SF = Pred->getStackFrame();
  ProgramStateRef state = Pred->getState();
 
  SVal Base = UnknownVal();
 
  // As in case of this expression the sub-expressions are not visited by any
  // other transfer functions, they are handled by matching their AST.
 
  // Case of implicit copy or move ctor of object with array member
  //
  // Note: ExprEngine::VisitMemberExpr is not able to bind the array to the
  // environment.
  //
  //    struct S {
  //      int arr[2];
  //    };
  //
  //
  //    S a;
  //    S b = a;
  //
  // The AST in case of a *copy constructor* looks like this:
  //    ArrayInitLoopExpr
  //    |-OpaqueValueExpr
  //    | `-MemberExpr              <-- match this
  //    |   `-DeclRefExpr
  //    ` ...
  //
  //
  //    S c;
  //    S d = std::move(d);
  //
  // In case of a *move constructor* the resulting AST looks like:
  //    ArrayInitLoopExpr
  //    |-OpaqueValueExpr
  //    | `-MemberExpr              <-- match this first
  //    |   `-CXXStaticCastExpr     <-- match this after
  //    |     `-DeclRefExpr
  //    ` ...
  if (const auto *ME = dyn_cast<MemberExpr>(Arr)) {
    Expr *MEBase = ME->getBase();
 
    // Move ctor
    if (auto CXXSCE = dyn_cast<CXXStaticCastExpr>(MEBase)) {
      MEBase = CXXSCE->getSubExpr();
    }
 
    auto ObjDeclExpr = cast<DeclRefExpr>(MEBase);
    SVal Obj = state->getLValue(cast<VarDecl>(ObjDeclExpr->getDecl()), SF);
 
    Base = state->getLValue(cast<FieldDecl>(ME->getMemberDecl()), Obj);
  }
 
  // Case of lambda capture and decomposition declaration
  //
  //    int arr[2];
  //
  //    [arr]{ int a = arr[0]; }();
  //    auto[a, b] = arr;
  //
  // In both of these cases the AST looks like the following:
  //    ArrayInitLoopExpr
  //    |-OpaqueValueExpr
  //    | `-DeclRefExpr             <-- match this
  //    ` ...
  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arr))
    Base = state->getLValue(cast<VarDecl>(DRE->getDecl()), SF);
 
  // Create a lazy compound value to the original array
  if (const MemRegion *R = Base.getAsRegion())
    Base = state->getSVal(R);
  else
    Base = UnknownVal();
 
  Dst.insert(Engine.makeNodeWithBinding(Pred, Ex, Base));
}
 
/// VisitArraySubscriptExpr - Transfer function for array accesses
void ExprEngine::VisitArraySubscriptExpr(const ArraySubscriptExpr *A,
                                         ExplodedNode *Pred,
                                         ExplodedNodeSet &Dst) {
  const Expr *Base = A->getBase()->IgnoreParens();
  const Expr *Idx  = A->getIdx()->IgnoreParens();
 
  bool IsVectorType = A->getBase()->getType()->isVectorType();
 
  // The "like" case is for situations where C standard prohibits the type to
  // be an lvalue, e.g. taking the address of a subscript of an expression of
  // type "void *".
  bool IsGLValueLike = A->isGLValue() ||
    (A->getType().isCForbiddenLValueType() && !AMgr.getLangOpts().CPlusPlus);
 
  const StackFrame *SF = Pred->getStackFrame();
  ProgramStateRef state = Pred->getState();
 
  if (IsGLValueLike) {
    QualType T = A->getType();
 
    // One of the forbidden LValue types! We still need to have sensible
    // symbolic locations to represent this stuff. Note that arithmetic on
    // void pointers is a GCC extension.
    if (T->isVoidType())
      T = getContext().CharTy;
 
    SVal V =
        state->getLValue(T, state->getSVal(Idx, SF), state->getSVal(Base, SF));
    Dst.insert(
        Engine.makeNodeWithBinding(Pred, A, V, ProgramPoint::PostLValueKind));
  } else if (IsVectorType) {
    // FIXME: non-glvalue vector reads are not modelled.
    Dst.insert(Engine.makePostStmtNode(A, state, Pred));
  } else {
    llvm_unreachable("Array subscript should be an lValue when not \
a vector and not a forbidden lvalue type");
  }
}
 
/// VisitMemberExpr - Transfer function for member expressions.
void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
                                 ExplodedNodeSet &Dst) {
  ValueDecl *Member = M->getMemberDecl();
 
  // Handle static member variables and enum constants accessed via
  // member syntax.
  if (isa<VarDecl, EnumConstantDecl>(Member)) {
    VisitCommonDeclRefExpr(M, Member, Pred, Dst);
    return;
  }
 
  ProgramStateRef state = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
  Expr *BaseExpr = M->getBase();
 
  // Handle C++ method calls.
  if (const auto *MD = dyn_cast<CXXMethodDecl>(Member)) {
    if (MD->isImplicitObjectMemberFunction())
      state = createTemporaryRegionIfNeeded(state, SF, BaseExpr);
 
    SVal MDVal = svalBuilder.getFunctionPointer(MD);
 
    Dst.insert(Engine.makeNodeWithBinding(Pred, M, MDVal, state));
    return;
  }
 
  // Handle regular struct fields / member variables.
  const SubRegion *MR = nullptr;
  state = createTemporaryRegionIfNeeded(state, SF, BaseExpr,
                                        /*Result=*/nullptr,
                                        /*OutRegionWithAdjustments=*/&MR);
  SVal baseExprVal = MR ? loc::MemRegionVal(MR) : state->getSVal(BaseExpr, SF);
 
  // FIXME: Copied from RegionStoreManager::bind()
  if (const auto *SR =
          dyn_cast_or_null<SymbolicRegion>(baseExprVal.getAsRegion())) {
    QualType T = SR->getPointeeStaticType();
    baseExprVal =
        loc::MemRegionVal(getStoreManager().GetElementZeroRegion(SR, T));
  }
 
  const auto *field = cast<FieldDecl>(Member);
  SVal L = state->getLValue(field, baseExprVal);
 
  if (M->isGLValue() || M->getType()->isArrayType()) {
    // We special-case rvalues of array type because the analyzer cannot
    // reason about them, since we expect all regions to be wrapped in Locs.
    // We instead treat these as lvalues and assume that they will decay to
    // pointers as soon as they are used.
    if (!M->isGLValue()) {
      assert(M->getType()->isArrayType());
      const auto *PE = dyn_cast<ImplicitCastExpr>(
          Pred->getParentMap().getParentIgnoreParens(M));
      if (!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {
        llvm_unreachable("should always be wrapped in ArrayToPointerDecay");
      }
    }
 
    if (field->getType()->isReferenceType()) {
      if (const MemRegion *R = L.getAsRegion())
        L = state->getSVal(R);
      else
        L = UnknownVal();
    }
 
    Dst.insert(Engine.makeNodeWithBinding(Pred, M, L, state,
                                          ProgramPoint::PostLValueKind));
  } else {
    evalLoad(Dst, M, M, Pred, state, L);
  }
}
 
void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
                                 ExplodedNodeSet &Dst) {
  // For now, treat all the arguments to C11 atomics as escaping.
  // FIXME: Ideally we should model the behavior of the atomics precisely here.
 
  ProgramStateRef State = Pred->getState();
  const StackFrame *SF = Pred->getStackFrame();
 
  SmallVector<SVal, 8> ValuesToInvalidate;
  for (const Stmt *SubExpr : AE->children()) {
    SVal SubExprVal = State->getSVal(cast<Expr>(SubExpr), SF);
    ValuesToInvalidate.push_back(SubExprVal);
  }
 
  State = State->invalidateRegions(ValuesToInvalidate, getCFGElementRef(),
                                   getNumVisitedCurrent(), SF,
                                   /*CausedByPointerEscape*/ true,
                                   /*Symbols=*/nullptr);
 
  Dst.insert(Engine.makeNodeWithBinding(Pred, AE, UnknownVal(), State));
}
 
// A value escapes in four possible cases:
// (1) We are binding to something that is not a memory region.
// (2) We are binding to a MemRegion that does not have stack storage.
// (3) We are binding to a top-level parameter region with a non-trivial
//     destructor. We won't see the destructor during analysis, but it's there.
// (4) We are binding to a MemRegion with stack storage that the store
//     does not understand.
ProgramStateRef ExprEngine::processPointerEscapedOnBind(
    ProgramStateRef State, ArrayRef<std::pair<SVal, SVal>> LocAndVals,
    const StackFrame *SF, PointerEscapeKind Kind, const CallEvent *Call) {
  SmallVector<SVal, 8> Escaped;
  for (const std::pair<SVal, SVal> &LocAndVal : LocAndVals) {
    // Cases (1) and (2).
    const MemRegion *MR = LocAndVal.first.getAsRegion();
    const MemSpaceRegion *Space = MR ? MR->getMemorySpace(State) : nullptr;
    if (!MR || !isa<StackSpaceRegion, StaticGlobalSpaceRegion>(Space)) {
      Escaped.push_back(LocAndVal.second);
      continue;
    }
 
    // Case (3).
    if (const auto *VR = dyn_cast<VarRegion>(MR->getBaseRegion()))
      if (isa<StackArgumentsSpaceRegion>(Space) &&
          VR->getStackFrame()->inTopFrame())
        if (const auto *RD = VR->getValueType()->getAsCXXRecordDecl())
          if (!RD->hasTrivialDestructor()) {
            Escaped.push_back(LocAndVal.second);
            continue;
          }
 
    // Case (4): in order to test that, generate a new state with the binding
    // added. If it is the same state, then it escapes (since the store cannot
    // represent the binding).
    // Do this only if we know that the store is not supposed to generate the
    // same state.
    SVal StoredVal = State->getSVal(MR);
    if (StoredVal != LocAndVal.second)
      if (State ==
          (State->bindLoc(loc::MemRegionVal(MR), LocAndVal.second, SF)))
        Escaped.push_back(LocAndVal.second);
  }
 
  if (Escaped.empty())
    return State;
 
  return escapeValues(State, Escaped, Kind, Call);
}
 
ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State,
                                                        SVal Loc, SVal Val,
                                                        const StackFrame *SF) {
  std::pair<SVal, SVal> LocAndVal(Loc, Val);
  return processPointerEscapedOnBind(State, LocAndVal, SF, PSK_EscapeOnBind,
                                     nullptr);
}
 
ProgramStateRef
ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
    const InvalidatedSymbols *Invalidated,
    ArrayRef<const MemRegion *> ExplicitRegions,
    const CallEvent *Call,
    RegionAndSymbolInvalidationTraits &ITraits) {
  if (!Invalidated || Invalidated->empty())
    return State;
 
  if (!Call)
    return getCheckerManager().runCheckersForPointerEscape(State,
                                                           *Invalidated,
                                                           nullptr,
                                                           PSK_EscapeOther,
                                                           &ITraits);
 
  // If the symbols were invalidated by a call, we want to find out which ones
  // were invalidated directly due to being arguments to the call.
  InvalidatedSymbols SymbolsDirectlyInvalidated;
  for (const auto I : ExplicitRegions) {
    if (const SymbolicRegion *R = I->StripCasts()->getAs<SymbolicRegion>())
      SymbolsDirectlyInvalidated.insert(R->getSymbol());
  }
 
  InvalidatedSymbols SymbolsIndirectlyInvalidated;
  for (const auto &sym : *Invalidated) {
    if (SymbolsDirectlyInvalidated.count(sym))
      continue;
    SymbolsIndirectlyInvalidated.insert(sym);
  }
 
  if (!SymbolsDirectlyInvalidated.empty())
    State = getCheckerManager().runCheckersForPointerEscape(State,
        SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall, &ITraits);
 
  // Notify about the symbols that get indirectly invalidated by the call.
  if (!SymbolsIndirectlyInvalidated.empty())
    State = getCheckerManager().runCheckersForPointerEscape(State,
        SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall, &ITraits);
 
  return State;
}
 
/// evalBind - Handle the semantics of binding a value to a specific location.
///  This method is used by evalStore, VisitDeclStmt, and others.
void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
                          ExplodedNode *Pred, SVal Location, SVal Val,
                          bool AtDeclInit, const ProgramPoint *PP) {
 
  // It may be a Loc, UnknownVal or perhaps UndefinedVal.
  assert(!isa<NonLoc>(Location) && "evalBind location should not be NonLoc!");
 
  const StackFrame *SF = Pred->getStackFrame();
  PostStmt DefaultPP(StoreE, SF);
 
  if (!PP)
    PP = &DefaultPP;
 
  // Do a previsit of the bind.
  ExplodedNodeSet CheckedSet;
  getCheckerManager().runCheckersForBind(CheckedSet, Pred, Location, Val,
                                         StoreE, AtDeclInit, *this, *PP);
 
  for (ExplodedNode *PredI : CheckedSet) {
    ProgramStateRef State = PredI->getState();
 
    // Check and record that 'Val' may escape:
    State = processPointerEscapedOnBind(State, Location, Val, SF);
 
    if (auto AsLoc = Location.getAs<Loc>()) {
      // When binding the value, pass on the hint that this is a
      // initialization. For initializations, we do not need to inform clients
      // of region changes.
      State = State->bindLoc(*AsLoc, Val, SF, /*notifyChanges=*/!AtDeclInit);
    }
 
    PostStore PS(StoreE, SF, Location.getAsRegion(), /*tag=*/nullptr);
    Dst.insert(Engine.makeNode(PS, State, PredI));
  }
}
 
/// evalStore - Handle the semantics of a store via an assignment.
///  @param Dst The node set to store generated state nodes
///  @param AssignE The assignment expression if the store happens in an
///         assignment.
///  @param LocationE The location expression that is stored to.
///  @param state The current simulation state
///  @param location The location to store the value
///  @param Val The value to be stored
void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
                             const Expr *LocationE,
                             ExplodedNode *Pred,
                             ProgramStateRef state, SVal location, SVal Val,
                             const ProgramPointTag *tag) {
  // Proceed with the store.  We use AssignE as the anchor for the PostStore
  // ProgramPoint if it is non-NULL, and LocationE otherwise.
  const Expr *StoreE = AssignE ? AssignE : LocationE;
 
  // Evaluate the location (checks for bad dereferences).
  ExplodedNodeSet Tmp;
  evalLocation(Tmp, AssignE, LocationE, Pred, state, location, false);
 
  if (Tmp.empty())
    return;
 
  if (location.isUndef())
    return;
 
  for (const auto I : Tmp)
    evalBind(Dst, StoreE, I, location, Val, false);
}
 
void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
                          const Expr *NodeEx,
                          const Expr *BoundEx,
                          ExplodedNode *Pred,
                          ProgramStateRef state,
                          SVal location,
                          const ProgramPointTag *tag,
                          QualType LoadTy) {
  assert(!isa<NonLoc>(location) && "location cannot be a NonLoc.");
  assert(NodeEx);
  assert(BoundEx);
  // Evaluate the location (checks for bad dereferences).
  ExplodedNodeSet Tmp;
  evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location, true);
  if (Tmp.empty())
    return;
 
  if (location.isUndef()) {
    Dst.insert(Tmp);
    return;
  }
 
  // Proceed with the load.
  for (const auto I : Tmp) {
    state = I->getState();
 
    SVal V = UnknownVal();
    if (location.isValid()) {
      if (LoadTy.isNull())
        LoadTy = BoundEx->getType();
      V = state->getSVal(location.castAs<Loc>(), LoadTy);
    }
 
    const auto *SF = I->getStackFrame();
    PostLoad Loc(NodeEx, SF, tag);
    Dst.insert(Engine.makeNode(Loc, state->BindExpr(BoundEx, SF, V), I));
  }
}
 
void ExprEngine::evalLocation(ExplodedNodeSet &Dst, const Stmt *NodeEx,
                              const Stmt *BoundEx, ExplodedNode *Pred,
                              ProgramStateRef state, SVal location,
                              bool isLoad) {
  // Early checks for performance reason.
  if (location.isUnknown()) {
    Dst.insert(Pred);
    return;
  }
 
  ExplodedNodeSet Src;
  if (Pred->getState() == state) {
    Src.insert(Pred);
  } else {
    // Associate this new state with an ExplodedNode.
    // FIXME: If I pass null tag, the graph is incorrect, e.g for
    //   int *p;
    //   p = 0;
    //   *p = 0xDEADBEEF;
    // "p = 0" is not noted as "Null pointer value stored to 'p'" but
    // instead "int *p" is noted as
    // "Variable 'p' initialized to a null pointer value"
 
    static SimpleProgramPointTag tag(TagProviderName, "Location");
    PostStmt Loc(NodeEx, Pred->getStackFrame(), &tag);
    Src.insert(Engine.makeNode(Loc, state, Pred));
  }
 
  ExplodedNodeSet Tmp;
  getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad,
                                             NodeEx, BoundEx, *this);
  Dst.insert(Tmp);
}
 
std::pair<const ProgramPointTag *, const ProgramPointTag *>
ExprEngine::getEagerlyAssumeBifurcationTags() {
  static SimpleProgramPointTag TrueTag(TagProviderName, "Eagerly Assume True"),
      FalseTag(TagProviderName, "Eagerly Assume False");
 
  return std::make_pair(&TrueTag, &FalseTag);
}
 
/// If the last EagerlyAssume attempt was successful (i.e. the true and false
/// cases were both feasible), this state trait stores the expression where it
/// happened; otherwise this holds nullptr.
REGISTER_TRAIT_WITH_PROGRAMSTATE(LastEagerlyAssumeExprIfSuccessful,
                                 const Expr *)
 
void ExprEngine::evalEagerlyAssumeBifurcation(ExplodedNodeSet &Dst,
                                              ExplodedNodeSet &Src,
                                              const Expr *Ex) {
  for (ExplodedNode *Pred : Src) {
    const StackFrame *SF = Pred->getStackFrame();
    // Test if the previous node was as the same expression.  This can happen
    // when the expression fails to evaluate to anything meaningful and
    // (as an optimization) we don't generate a node.
    ProgramPoint P = Pred->getLocation();
    if (!P.getAs<PostStmt>() || P.castAs<PostStmt>().getStmt() != Ex) {
      Dst.insert(Pred);
      continue;
    }
 
    ProgramStateRef State = Pred->getState();
    State = State->set<LastEagerlyAssumeExprIfSuccessful>(nullptr);
    SVal V = State->getSVal(Ex, SF);
    std::optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
    if (SEV && SEV->isExpression()) {
      const auto &[TrueTag, FalseTag] = getEagerlyAssumeBifurcationTags();
 
      auto [StateTrue, StateFalse] = State->assume(*SEV);
 
      if (StateTrue && StateFalse) {
        StateTrue = StateTrue->set<LastEagerlyAssumeExprIfSuccessful>(Ex);
        StateFalse = StateFalse->set<LastEagerlyAssumeExprIfSuccessful>(Ex);
      }
 
      // First assume that the condition is true.
      if (StateTrue) {
        SVal Val = svalBuilder.makeIntVal(1U, Ex->getType());
        StateTrue = StateTrue->BindExpr(Ex, SF, Val);
        PostStmt PostStmtTrue(Ex, SF, TrueTag);
        Dst.insert(Engine.makeNode(PostStmtTrue, StateTrue, Pred));
      }
 
      // Next, assume that the condition is false.
      if (StateFalse) {
        SVal Val = svalBuilder.makeIntVal(0U, Ex->getType());
        StateFalse = StateFalse->BindExpr(Ex, SF, Val);
        PostStmt PostStmtFalse(Ex, SF, FalseTag);
        Dst.insert(Engine.makeNode(PostStmtFalse, StateFalse, Pred));
      }
    } else {
      Dst.insert(Pred);
    }
  }
}
 
bool ExprEngine::didEagerlyAssumeBifurcateAt(ProgramStateRef State,
                                             const Expr *Ex) const {
  return Ex && State->get<LastEagerlyAssumeExprIfSuccessful>() == Ex;
}
 
void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
                                 ExplodedNodeSet &Dst) {
  // We have processed both the inputs and the outputs.  All of the outputs
  // should evaluate to Locs.  Nuke all of their values.
 
  // FIXME: Some day in the future it would be nice to allow a "plug-in"
  // which interprets the inline asm and stores proper results in the
  // outputs.
 
  ProgramStateRef state = Pred->getState();
 
  for (const Expr *O : A->outputs()) {
    SVal X = state->getSVal(O, Pred->getStackFrame());
    assert(!isa<NonLoc>(X)); // Should be an Lval, or unknown, undef.
 
    if (std::optional<Loc> LV = X.getAs<Loc>())
      state = state->invalidateRegions(*LV, getCFGElementRef(),
                                       getNumVisitedCurrent(),
                                       Pred->getStackFrame(),
                                       /*CausedByPointerEscape=*/true);
  }
 
  // Do not reason about locations passed inside inline assembly.
  for (const Expr *I : A->inputs()) {
    SVal X = state->getSVal(I, Pred->getStackFrame());
 
    if (std::optional<Loc> LV = X.getAs<Loc>())
      state = state->invalidateRegions(*LV, getCFGElementRef(),
                                       getNumVisitedCurrent(),
                                       Pred->getStackFrame(),
                                       /*CausedByPointerEscape=*/true);
  }
 
  Dst.insert(Engine.makePostStmtNode(A, state, Pred));
}
 
void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
                                ExplodedNodeSet &Dst) {
  Dst.insert(Engine.makePostStmtNode(A, Pred->getState(), Pred));
}
 
//===----------------------------------------------------------------------===//
// Visualization.
//===----------------------------------------------------------------------===//
 
namespace llvm {
 
template<>
struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
  DOTGraphTraits (bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
 
  static bool nodeHasBugReport(const ExplodedNode *N) {
    BugReporter &BR = static_cast<ExprEngine &>(
      N->getState()->getStateManager().getOwningEngine()).getBugReporter();
 
    for (const auto &Class : BR.equivalenceClasses()) {
      for (const auto &Report : Class.getReports()) {
        const auto *PR = dyn_cast<PathSensitiveBugReport>(Report.get());
        if (!PR)
          continue;
        const ExplodedNode *EN = PR->getErrorNode();
        if (EN->getState() == N->getState() &&
            EN->getLocation() == N->getLocation())
          return true;
      }
    }
    return false;
  }
 
  /// \p PreCallback: callback before break.
  /// \p PostCallback: callback after break.
  /// \p Stop: stop iteration if returns @c true
  /// \return Whether @c Stop ever returned @c true.
  static bool traverseHiddenNodes(
      const ExplodedNode *N,
      llvm::function_ref<void(const ExplodedNode *)> PreCallback,
      llvm::function_ref<void(const ExplodedNode *)> PostCallback,
      llvm::function_ref<bool(const ExplodedNode *)> Stop) {
    while (true) {
      PreCallback(N);
      if (Stop(N))
        return true;
 
      if (N->succ_size() != 1 || !isNodeHidden(N->getFirstSucc(), nullptr))
        break;
      PostCallback(N);
 
      N = N->getFirstSucc();
    }
    return false;
  }
 
  static bool isNodeHidden(const ExplodedNode *N, const ExplodedGraph *G) {
    return N->isTrivial();
  }
 
  static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G){
    std::string Buf;
    llvm::raw_string_ostream Out(Buf);
 
    const bool IsDot = true;
    const unsigned int Space = 1;
    ProgramStateRef State = N->getState();
 
    Out << "{ \"state_id\": " << State->getID()
        << ",\\l";
 
    Indent(Out, Space, IsDot) << "\"program_points\": [\\l";
 
    // Dump program point for all the previously skipped nodes.
    traverseHiddenNodes(
        N,
        [&](const ExplodedNode *OtherNode) {
          Indent(Out, Space + 1, IsDot) << "{ ";
          OtherNode->getLocation().printJson(Out, /*NL=*/"\\l");
          Out << ", \"tag\": ";
          if (const ProgramPointTag *Tag = OtherNode->getLocation().getTag())
            Out << '\"' << Tag->getDebugTag() << '\"';
          else
            Out << "null";
          Out << ", \"node_id\": " << OtherNode->getID() <<
                 ", \"is_sink\": " << OtherNode->isSink() <<
                 ", \"has_report\": " << nodeHasBugReport(OtherNode) << " }";
        },
        // Adds a comma and a new-line between each program point.
        [&](const ExplodedNode *) { Out << ",\\l"; },
        [&](const ExplodedNode *) { return false; });
 
    Out << "\\l"; // Adds a new-line to the last program point.
    Indent(Out, Space, IsDot) << "],\\l";
 
    State->printDOT(Out, N->getStackFrame(), Space);
 
    Out << "\\l}\\l";
    return Buf;
  }
};
 
} // namespace llvm
 
void ExprEngine::ViewGraph(bool trim) {
  std::string Filename = DumpGraph(trim);
  llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
}
 
void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode *> Nodes) {
  std::string Filename = DumpGraph(Nodes);
  llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
}
 
std::string ExprEngine::DumpGraph(bool trim, StringRef Filename) {
  if (trim) {
    std::vector<const ExplodedNode *> Src;
 
    // Iterate through the reports and get their nodes.
    for (const auto &Class : BR.equivalenceClasses()) {
      const auto *R =
          dyn_cast<PathSensitiveBugReport>(Class.getReports()[0].get());
      if (!R)
        continue;
      const auto *N = const_cast<ExplodedNode *>(R->getErrorNode());
      Src.push_back(N);
    }
    return DumpGraph(Src, Filename);
  }
 
  // FIXME(sandboxing): Remove this by adopting `llvm::vfs::OutputBackend`.
  auto BypassSandbox = llvm::sys::sandbox::scopedDisable();
  return llvm::WriteGraph(&G, "ExprEngine", /*ShortNames=*/false,
                          /*Title=*/"Exploded Graph",
                          /*Filename=*/std::string(Filename));
}
 
std::string ExprEngine::DumpGraph(ArrayRef<const ExplodedNode *> Nodes,
                                  StringRef Filename) {
  std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
 
  if (!TrimmedG) {
    llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
    return "";
  }
 
  // FIXME(sandboxing): Remove this by adopting `llvm::vfs::OutputBackend`.
  auto BypassSandbox = llvm::sys::sandbox::scopedDisable();
  return llvm::WriteGraph(TrimmedG.get(), "TrimmedExprEngine",
                          /*ShortNames=*/false,
                          /*Title=*/"Trimmed Exploded Graph",
                          /*Filename=*/std::string(Filename));
}
 
void *ProgramStateTrait<ReplayWithoutInlining>::GDMIndex() {
  static int index = 0;
  return &index;
}
 
void ExprEngine::anchor() { }
 
void ExprEngine::ConstructInitList(const Expr *E, ArrayRef<Expr *> Args,
                                   bool IsTransparent, ExplodedNode *Pred,
                                   ExplodedNodeSet &Dst) {
  assert((isa<InitListExpr, CXXParenListInitExpr>(E)));
 
  const StackFrame *SF = Pred->getStackFrame();
 
  ProgramStateRef S = Pred->getState();
  QualType T = E->getType().getCanonicalType();
 
  bool IsCompound = T->isArrayType() || T->isRecordType() ||
                    T->isAnyComplexType() || T->isVectorType();
 
  SVal Val;
  if (Args.size() > 1 || (E->isPRValue() && IsCompound && !IsTransparent)) {
    llvm::ImmutableList<SVal> ArgList = getBasicVals().getEmptySValList();
    for (Expr *E : llvm::reverse(Args))
      ArgList = getBasicVals().prependSVal(S->getSVal(E, SF), ArgList);
 
    Val = getSValBuilder().makeCompoundVal(T, ArgList);
  } else if (Args.size() == 0) {
    Val = getSValBuilder().makeZeroVal(T);
  } else {
    Val = S->getSVal(Args.front(), SF);
  }
  Dst.insert(Engine.makeNodeWithBinding(Pred, E, Val));
}