C++ BindingsTy类代码示例

void BasicStoreManager::iterBindings(Store store, BindingsHandler& f) {
    BindingsTy B = GetBindings(store);

    for (BindingsTy::iterator I=B.begin(), E=B.end(); I != E; ++I)
        f.HandleBinding(*this, store, I.getKey(), I.getData());

}

void CXXInstanceCall::getInitialStackFrameContents(
                                            const StackFrameContext *CalleeCtx,
                                            BindingsTy &Bindings) const {
  AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);

  // Handle the binding of 'this' in the new stack frame.
  SVal ThisVal = getCXXThisVal();
  if (!ThisVal.isUnknown()) {
    ProgramStateManager &StateMgr = getState()->getStateManager();
    SValBuilder &SVB = StateMgr.getSValBuilder();

    const CXXMethodDecl *MD = cast<CXXMethodDecl>(CalleeCtx->getDecl());
    Loc ThisLoc = SVB.getCXXThis(MD, CalleeCtx);

    // If we devirtualized to a different member function, we need to make sure
    // we have the proper layering of CXXBaseObjectRegions.
    if (MD->getCanonicalDecl() != getDecl()->getCanonicalDecl()) {
      ASTContext &Ctx = SVB.getContext();
      const CXXRecordDecl *Class = MD->getParent();
      QualType Ty = Ctx.getPointerType(Ctx.getRecordType(Class));

      // FIXME: CallEvent maybe shouldn't be directly accessing StoreManager.
      bool Failed;
      ThisVal = StateMgr.getStoreManager().evalDynamicCast(ThisVal, Ty, Failed);
      assert(!Failed && "Calling an incorrectly devirtualized method");
    }

    if (!ThisVal.isUnknown())
      Bindings.push_back(std::make_pair(ThisLoc, ThisVal));
  }
}

SVal BasicStoreManager::Retrieve(Store store, Loc loc, QualType T) {
    if (isa<UnknownVal>(loc))
        return UnknownVal();

    assert(!isa<UndefinedVal>(loc));

    switch (loc.getSubKind()) {

    case loc::MemRegionKind: {
        const MemRegion* R = cast<loc::MemRegionVal>(loc).getRegion();

        if (!(isa<VarRegion>(R) || isa<ObjCIvarRegion>(R)))
            return UnknownVal();

        BindingsTy B = GetBindings(store);
        BindingsTy::data_type *Val = B.lookup(R);
        const TypedRegion *TR = cast<TypedRegion>(R);

        if (Val)
            return CastRetrievedVal(*Val, TR, T);

        SVal V = LazyRetrieve(store, TR);
        return V.isUnknownOrUndef() ? V : CastRetrievedVal(V, TR, T);
    }

    case loc::ConcreteIntKind:
        // Some clients may call GetSVal with such an option simply because
        // they are doing a quick scan through their Locs (potentially to
        // invalidate their bindings).  Just return Undefined.
        return UndefinedVal();

    default:
        assert (false && "Invalid Loc.");
        break;
    }

    return UnknownVal();
}

void BlockCall::getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
                                             BindingsTy &Bindings) const {
  SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
  ArrayRef<ParmVarDecl*> Params;
  if (isConversionFromLambda()) {
    auto *LambdaOperatorDecl = cast<CXXMethodDecl>(CalleeCtx->getDecl());
    Params = LambdaOperatorDecl->parameters();

    // For blocks converted from a C++ lambda, the callee declaration is the
    // operator() method on the lambda so we bind "this" to
    // the lambda captured by the block.
    const VarRegion *CapturedLambdaRegion = getRegionStoringCapturedLambda();
    SVal ThisVal = loc::MemRegionVal(CapturedLambdaRegion);
    Loc ThisLoc = SVB.getCXXThis(LambdaOperatorDecl, CalleeCtx);
    Bindings.push_back(std::make_pair(ThisLoc, ThisVal));
  } else {
    Params = cast<BlockDecl>(CalleeCtx->getDecl())->parameters();
  }

  addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
                               Params);
}