SVF::AbstractStateManager Class Reference

#include <AbstractStateManager.h>

Public Member Functions
	AbstractStateManager (SVFIR *svfir, AndersenWaveDiff *pta)
	~AbstractStateManager ()
const AbstractValue &	getAbstractValue (const ValVar *var, const ICFGNode *node)
const AbstractValue &	getAbstractValue (const ObjVar *var, const ICFGNode *node)
	Read an address-taken variable's content via virtual-address load.
const AbstractValue &	getAbstractValue (const SVFVar *var, const ICFGNode *node)
	Dispatch to ValVar or ObjVar overload (checks ObjVar first due to inheritance).
bool	hasAbstractValue (const ValVar *var, const ICFGNode *node) const
bool	hasAbstractValue (const ObjVar *var, const ICFGNode *node) const
	Check whether an ObjVar has a stored value at node.
bool	hasAbstractValue (const SVFVar *var, const ICFGNode *node) const
	Dispatch to ValVar or ObjVar overload.
void	updateAbstractValue (const ValVar *var, const AbstractValue &val, const ICFGNode *node)
	Write a top-level variable's abstract value into abstractTrace[node].
void	updateAbstractValue (const ObjVar *var, const AbstractValue &val, const ICFGNode *node)
	Write an address-taken variable's content via virtual-address store.
void	updateAbstractValue (const SVFVar *var, const AbstractValue &val, const ICFGNode *node)
	Dispatch to ValVar or ObjVar overload.
AbstractState &	getAbstractState (const ICFGNode *node)
	Retrieve the abstract state for a given ICFG node. Asserts if absent.
void	updateAbstractState (const ICFGNode *node, const AbstractState &state)
bool	hasAbstractState (const ICFGNode *node)
	Check if an abstract state exists for a given ICFG node.
void	getAbstractState (const Set< const ValVar * > &vars, AbstractState &result, const ICFGNode *node)
	Retrieve abstract state filtered to specific variable sets.
void	getAbstractState (const Set< const ObjVar * > &vars, AbstractState &result, const ICFGNode *node)
void	getAbstractState (const Set< const SVFVar * > &vars, AbstractState &result, const ICFGNode *node)
IntervalValue	getGepElementIndex (const GepStmt *gep)
	Compute the flattened element index for a GepStmt.
IntervalValue	getGepByteOffset (const GepStmt *gep)
	Compute the byte offset for a GepStmt.
AddressValue	getGepObjAddrs (const ValVar *pointer, IntervalValue offset)
	Compute GEP object addresses for a pointer at a given element offset.
AbstractValue	loadValue (const ValVar *pointer, const ICFGNode *node)
void	storeValue (const ValVar *pointer, const AbstractValue &val, const ICFGNode *node)
const SVFType *	getPointeeElement (const ObjVar *var, const ICFGNode *node)
	Get the pointee type for a pointer variable.
u32_t	getAllocaInstByteSize (const AddrStmt *addr)
	Get the byte size of a stack allocation.
Map< const ICFGNode *, AbstractState > &	getTrace ()
AbstractState &	operator[] (const ICFGNode *node)
Set< const ICFGNode * >	getUseSitesOfObjVar (const ObjVar *obj, const ICFGNode *node) const
	Given an ObjVar and its use-site ICFGNode, find all downstream use-site ICFGNodes.
Set< const ICFGNode * >	getUseSitesOfValVar (const ValVar *var) const
	Given a ValVar, find all use-site ICFGNodes.
const ICFGNode *	getDefSiteOfValVar (const ValVar *var) const
	Given a ValVar, find its definition-site ICFGNode.
const ICFGNode *	getDefSiteOfObjVar (const ObjVar *obj, const ICFGNode *node) const
	Given an ObjVar and its use-site ICFGNode, find the definition-site ICFGNode.

Private Attributes
SVFIR *	svfir
SVFG *	svfg
Map< const ICFGNode *, AbstractState >	abstractTrace

Detailed Description

Manages abstract states across ICFG nodes and provides a unified API for reading/writing abstract values. Encapsulates the dense vs. semi-sparse lookup strategy so that all consumers (updateStateOnXxx, AEDetector, AbsExtAPI) are sparsity-agnostic.

Two sparsity-dependent behaviors live here:

1. getAbstractValue(ValVar*): dense reads from current node's state; semi-sparse pulls from def-site.
2. joinWith (inside AbstractState): dense merges all variables; semi-sparse skips ValVar merge.

Definition at line 48 of file AbstractStateManager.h.

Constructor & Destructor Documentation

AbstractStateManager()

AbstractStateManager::AbstractStateManager	(	SVFIR *	svfir,
		AndersenWaveDiff *	pta
	)

Definition at line 35 of file AbstractStateManager.cpp.

    : svfir(svfir), svfg(nullptr)
{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::Sparse)
    {
        SVFGBuilder memSSA(true);
        svfg = memSSA.buildFullSVFG(pta);
    }
}

~AbstractStateManager()

AbstractStateManager::~AbstractStateManager

(

)

Definition at line 45 of file AbstractStateManager.cpp.

{
    delete svfg;
}

Member Function Documentation

getAbstractState() [1/4]

AbstractState & AbstractStateManager::getAbstractState

(

const ICFGNode *

node

)

Retrieve the abstract state for a given ICFG node. Asserts if absent.

Definition at line 54 of file AbstractStateManager.cpp.

{
    if (abstractTrace.count(node) == 0)
    {
        assert(false && "No preAbsTrace for this node");
        abort();
    }
    return abstractTrace[node];
}

getAbstractState() [2/4]

void AbstractStateManager::getAbstractState	(	const Set< const ObjVar * > &	vars,
		AbstractState &	result,
		const ICFGNode *	node
	)

Definition at line 290 of file AbstractStateManager.cpp.

{
    AbstractState& as = getAbstractState(node);
    for (const ObjVar* var : vars)
    {
        u32_t addr = AbstractState::getVirtualMemAddress(var->getId());
        result.store(addr, as.load(addr));
    }
}

getAbstractState() [3/4]

void AbstractStateManager::getAbstractState	(	const Set< const SVFVar * > &	vars,
		AbstractState &	result,
		const ICFGNode *	node
	)

Definition at line 300 of file AbstractStateManager.cpp.

{
    AbstractState& as = getAbstractState(node);
    for (const SVFVar* var : vars)
    {
        if (const ValVar* valVar = SVFUtil::dyn_cast<ValVar>(var))
        {
            u32_t id = valVar->getId();
            result[id] = as[id];
        }
        else if (const ObjVar* objVar = SVFUtil::dyn_cast<ObjVar>(var))
        {
            u32_t addr = AbstractState::getVirtualMemAddress(objVar->getId());
            result.store(addr, as.load(addr));
        }
    }
}

getAbstractState() [4/4]

void AbstractStateManager::getAbstractState	(	const Set< const ValVar * > &	vars,
		AbstractState &	result,
		const ICFGNode *	node
	)

Retrieve abstract state filtered to specific variable sets.

Definition at line 280 of file AbstractStateManager.cpp.

{
    AbstractState& as = getAbstractState(node);
    for (const ValVar* var : vars)
    {
        u32_t id = var->getId();
        result[id] = as[id];
    }
}

getAbstractValue() [1/3]

const AbstractValue & AbstractStateManager::getAbstractValue	(	const ObjVar *	var,
		const ICFGNode *	node
	)

Read an address-taken variable's content via virtual-address load.

Definition at line 158 of file AbstractStateManager.cpp.

{
    AbstractState& as = getAbstractState(node);
    u32_t addr = AbstractState::getVirtualMemAddress(var->getId());
    return as.load(addr);
}

getAbstractValue() [2/3]

const AbstractValue & AbstractStateManager::getAbstractValue	(	const SVFVar *	var,
		const ICFGNode *	node
	)

Dispatch to ValVar or ObjVar overload (checks ObjVar first due to inheritance).

Definition at line 165 of file AbstractStateManager.cpp.

{
    // Check ObjVar first since ObjVar inherits from ValVar
    if (const ObjVar* objVar = SVFUtil::dyn_cast<ObjVar>(var))
        return getAbstractValue(objVar, node);
    if (const ValVar* valVar = SVFUtil::dyn_cast<ValVar>(var))
        return getAbstractValue(valVar, node);
    assert(false && "Unknown SVFVar kind");
    abort();
}

getAbstractValue() [3/3]

const AbstractValue & AbstractStateManager::getAbstractValue	(	const ValVar *	var,
		const ICFGNode *	node
	)

Read a top-level variable's abstract value. Dense: reads from abstractTrace[node]. Semi-sparse: checks current state first, then pulls from def-site. Returns top if absent everywhere.

Definition at line 87 of file AbstractStateManager.cpp.

{
    u32_t id = var->getId();
    bool semiSparse = Options::AESparsity() == AbstractInterpretation::AESparsity::SemiSparse;
 
    // Constants: store into current node's state and return
    AbstractState& as = abstractTrace[node];
    if (const ConstIntValVar* constInt = SVFUtil::dyn_cast<ConstIntValVar>(var))
    {
        as[id] = IntervalValue(constInt->getSExtValue(), constInt->getSExtValue());
        return as[id];
    }
    if (const ConstFPValVar* constFP = SVFUtil::dyn_cast<ConstFPValVar>(var))
    {
        as[id] = IntervalValue(constFP->getFPValue(), constFP->getFPValue());
        return as[id];
    }
    if (SVFUtil::isa<ConstNullPtrValVar>(var))
    {
        as[id] = AddressValue();
        return as[id];
    }
    if (SVFUtil::isa<ConstDataValVar>(var))
    {
        as[id] = IntervalValue::top();
        return as[id];
    }
 
    // Dense mode: try current node's state first.
    // If absent, fall through to the def-site lookup below — matching
    // upstream behaviour where getAbstractValue always reads from the
    // def-site.  Returning top or bottom here would be wrong: top loses
    // concrete values like NULL addresses; bottom misjudges branch
    // feasibility for uninitialised variables like argc.
    if (!semiSparse)
    {
        if (as.inVarToValTable(id) || as.inVarToAddrsTable(id))
            return as[id];
    }
 
    // Semi-sparse mode: pull from def-site first, then check current state
    const ICFGNode* defNode = var->getICFGNode();
    if (defNode && hasAbstractState(defNode))
    {
        const auto& varMap = getAbstractState(defNode).getVarToVal();
        if (varMap.count(id))
            return getAbstractState(defNode)[id];
    }
 
    // Fallback for call-result ValVars: their getICFGNode() returns
    // CallICFGNode but the value is written by RetPE at RetICFGNode.
    if (const CallICFGNode* callNode =
                defNode ? SVFUtil::dyn_cast<CallICFGNode>(defNode) : nullptr)
    {
        const RetICFGNode* retNode = callNode->getRetICFGNode();
        if (hasAbstractState(retNode))
        {
            const auto& retMap = getAbstractState(retNode).getVarToVal();
            if (retMap.count(id))
                return getAbstractState(retNode)[id];
        }
    }
 
    as[id] = IntervalValue::top();
    return as[id];
}

getAllocaInstByteSize()

u32_t AbstractStateManager::getAllocaInstByteSize

(

const AddrStmt *

addr

)

Get the byte size of a stack allocation.

Definition at line 504 of file AbstractStateManager.cpp.

{
    const ICFGNode* node = addr->getICFGNode();
    if (const ObjVar* objvar = SVFUtil::dyn_cast<ObjVar>(addr->getRHSVar()))
    {
        if (svfir->getBaseObject(objvar->getId())->isConstantByteSize())
        {
            return svfir->getBaseObject(objvar->getId())->getByteSizeOfObj();
        }
        else
        {
            const std::vector<SVFVar*>& sizes = addr->getArrSize();
            u32_t elementSize = 1;
            u64_t res = elementSize;
            for (const SVFVar* value : sizes)
            {
                const AbstractValue& sizeVal = getAbstractValue(value, node);
                IntervalValue itv = sizeVal.getInterval();
                if (itv.isBottom())
                    itv = IntervalValue(Options::MaxFieldLimit());
                res = res * itv.ub().getIntNumeral() > Options::MaxFieldLimit()
                      ? Options::MaxFieldLimit() : res * itv.ub().getIntNumeral();
            }
            return (u32_t)res;
        }
    }
    assert(false && "Addr rhs value is not ObjVar");
    abort();
}

getDefSiteOfObjVar()

const ICFGNode * AbstractStateManager::getDefSiteOfObjVar	(	const ObjVar *	obj,
		const ICFGNode *	node
	)		const

Given an ObjVar and its use-site ICFGNode, find the definition-site ICFGNode.

Definition at line 577 of file AbstractStateManager.cpp.

{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::Sparse)
    {
        assert(svfg && "SVFG is not built for sparse AE");
        return svfg->getDefSiteOfObjVar(obj, node);
    }
    for (const auto* edge : node->getInEdges())
        return edge->getSrcNode();
    return nullptr;
}

getDefSiteOfValVar()

const ICFGNode * AbstractStateManager::getDefSiteOfValVar

(

const ValVar *

var

)

const

Given a ValVar, find its definition-site ICFGNode.

Definition at line 567 of file AbstractStateManager.cpp.

{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::Sparse)
    {
        assert(svfg && "SVFG is not built for sparse AE");
        return svfg->getDefSiteOfValVar(var);
    }
    return var->getICFGNode();
}

getGepByteOffset()

IntervalValue AbstractStateManager::getGepByteOffset

(

const GepStmt *

gep

)

Compute the byte offset for a GepStmt.

Definition at line 379 of file AbstractStateManager.cpp.

{
    const ICFGNode* node = gep->getICFGNode();
    if (gep->isConstantOffset())
        return IntervalValue((s64_t)gep->accumulateConstantByteOffset());
 
    IntervalValue res(0);
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        const ValVar* idxOperandVar = gep->getOffsetVarAndGepTypePairVec()[i].first;
        const SVFType* idxOperandType = gep->getOffsetVarAndGepTypePairVec()[i].second;
 
        if (SVFUtil::isa<SVFArrayType>(idxOperandType) || SVFUtil::isa<SVFPointerType>(idxOperandType))
        {
            u32_t elemByteSize = 1;
            if (const SVFArrayType* arrOperandType = SVFUtil::dyn_cast<SVFArrayType>(idxOperandType))
                elemByteSize = arrOperandType->getTypeOfElement()->getByteSize();
            else if (SVFUtil::isa<SVFPointerType>(idxOperandType))
                elemByteSize = gep->getAccessPath().gepSrcPointeeType()->getByteSize();
            else
                assert(false && "idxOperandType must be ArrType or PtrType");
 
            if (const ConstIntValVar* op = SVFUtil::dyn_cast<ConstIntValVar>(idxOperandVar))
            {
                s64_t lb = (double)Options::MaxFieldLimit() / elemByteSize >= op->getSExtValue()
                           ? op->getSExtValue() * elemByteSize
                           : Options::MaxFieldLimit();
                res = res + IntervalValue(lb, lb);
            }
            else
            {
                IntervalValue idxVal = getAbstractValue(idxOperandVar, node).getInterval();
                if (idxVal.isBottom())
                    res = res + IntervalValue(0, 0);
                else
                {
                    s64_t ub = (idxVal.ub().getIntNumeral() < 0) ? 0
                               : (double)Options::MaxFieldLimit() / elemByteSize >= idxVal.ub().getIntNumeral()
                               ? elemByteSize * idxVal.ub().getIntNumeral()
                               : Options::MaxFieldLimit();
                    s64_t lb = (idxVal.lb().getIntNumeral() < 0) ? 0
                               : (double)Options::MaxFieldLimit() / elemByteSize >= idxVal.lb().getIntNumeral()
                               ? elemByteSize * idxVal.lb().getIntNumeral()
                               : Options::MaxFieldLimit();
                    res = res + IntervalValue(lb, ub);
                }
            }
        }
        else if (const SVFStructType* structOperandType = SVFUtil::dyn_cast<SVFStructType>(idxOperandType))
        {
            res = res + IntervalValue(gep->getAccessPath().getStructFieldOffset(idxOperandVar, structOperandType));
        }
        else
        {
            assert(false && "gep type pair only support arr/ptr/struct");
        }
    }
    return res;
}

getGepElementIndex()

IntervalValue AbstractStateManager::getGepElementIndex

(

const GepStmt *

gep

)

Compute the flattened element index for a GepStmt.

Definition at line 322 of file AbstractStateManager.cpp.

{
    const ICFGNode* node = gep->getICFGNode();
    if (gep->isConstantOffset())
        return IntervalValue((s64_t)gep->accumulateConstantOffset());
 
    IntervalValue res(0);
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        const ValVar* var = gep->getOffsetVarAndGepTypePairVec()[i].first;
        const SVFType* type = gep->getOffsetVarAndGepTypePairVec()[i].second;
 
        s64_t idxLb, idxUb;
        if (const ConstIntValVar* constInt = SVFUtil::dyn_cast<ConstIntValVar>(var))
            idxLb = idxUb = constInt->getSExtValue();
        else
        {
            IntervalValue idxItv = getAbstractValue(var, node).getInterval();
            if (idxItv.isBottom())
                idxLb = idxUb = 0;
            else
            {
                idxLb = idxItv.lb().getIntNumeral();
                idxUb = idxItv.ub().getIntNumeral();
            }
        }
 
        if (SVFUtil::isa<SVFPointerType>(type))
        {
            u32_t elemNum = gep->getAccessPath().getElementNum(gep->getAccessPath().gepSrcPointeeType());
            idxLb = (double)Options::MaxFieldLimit() / elemNum < idxLb ? Options::MaxFieldLimit() : idxLb * elemNum;
            idxUb = (double)Options::MaxFieldLimit() / elemNum < idxUb ? Options::MaxFieldLimit() : idxUb * elemNum;
        }
        else
        {
            if (Options::ModelArrays())
            {
                const std::vector<u32_t>& so = PAG::getPAG()->getTypeInfo(type)->getFlattenedElemIdxVec();
                if (so.empty() || idxUb >= (APOffset)so.size() || idxLb < 0)
                    idxLb = idxUb = 0;
                else
                {
                    idxLb = PAG::getPAG()->getFlattenedElemIdx(type, idxLb);
                    idxUb = PAG::getPAG()->getFlattenedElemIdx(type, idxUb);
                }
            }
            else
                idxLb = idxUb = 0;
        }
        res = res + IntervalValue(idxLb, idxUb);
    }
    res.meet_with(IntervalValue((s64_t)0, (s64_t)Options::MaxFieldLimit()));
    if (res.isBottom())
        res = IntervalValue(0);
    return res;
}

getGepObjAddrs()

AddressValue AbstractStateManager::getGepObjAddrs	(	const ValVar *	pointer,
		IntervalValue	offset
	)

Compute GEP object addresses for a pointer at a given element offset.

Definition at line 439 of file AbstractStateManager.cpp.

{
    const ICFGNode* node = pointer->getICFGNode();
    AddressValue gepAddrs;
    AbstractState& as = getAbstractState(node);
    APOffset lb = offset.lb().getIntNumeral() < Options::MaxFieldLimit() ? offset.lb().getIntNumeral()
                  : Options::MaxFieldLimit();
    APOffset ub = offset.ub().getIntNumeral() < Options::MaxFieldLimit() ? offset.ub().getIntNumeral()
                  : Options::MaxFieldLimit();
    for (APOffset i = lb; i <= ub; i++)
    {
        const AbstractValue& addrs = getAbstractValue(pointer, node);
        for (const auto& addr : addrs.getAddrs())
        {
            s64_t baseObj = as.getIDFromAddr(addr);
            assert(SVFUtil::isa<ObjVar>(svfir->getSVFVar(baseObj)) && "Fail to get the base object address!");
            NodeID gepObj = svfir->getGepObjVar(baseObj, i);
            as[gepObj] = AddressValue(AbstractState::getVirtualMemAddress(gepObj));
            gepAddrs.insert(AbstractState::getVirtualMemAddress(gepObj));
        }
    }
    return gepAddrs;
}

getPointeeElement()

const SVFType * AbstractStateManager::getPointeeElement	(	const ObjVar *	var,
		const ICFGNode *	node
	)

Get the pointee type for a pointer variable.

Definition at line 489 of file AbstractStateManager.cpp.

{
    const AbstractValue& ptrVal = getAbstractValue(var, node);
    if (!ptrVal.isAddr())
        return nullptr;
    for (auto addr : ptrVal.getAddrs())
    {
        NodeID objId = getAbstractState(node).getIDFromAddr(addr);
        if (objId == 0)
            continue;
        return svfir->getBaseObject(objId)->getType();
    }
    return nullptr;
}

getTrace()

Map< const ICFGNode *, AbstractState > & SVF::AbstractStateManager::getTrace ( )

inline

Definition at line 154 of file AbstractStateManager.h.

    {
        return abstractTrace;
    }

getUseSitesOfObjVar()

Set< const ICFGNode * > AbstractStateManager::getUseSitesOfObjVar	(	const ObjVar *	obj,
		const ICFGNode *	node
	)		const

Given an ObjVar and its use-site ICFGNode, find all downstream use-site ICFGNodes.

Definition at line 538 of file AbstractStateManager.cpp.

{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::Sparse)
    {
        assert(svfg && "SVFG is not built for sparse AE");
        return svfg->getUseSitesOfObjVar(obj, node);
    }
    Set<const ICFGNode*> succs;
    for (const auto* edge : node->getOutEdges())
        succs.insert(edge->getDstNode());
    return succs;
}

getUseSitesOfValVar()

Set< const ICFGNode * > AbstractStateManager::getUseSitesOfValVar

(

const ValVar *

var

)

const

Given a ValVar, find all use-site ICFGNodes.

Definition at line 551 of file AbstractStateManager.cpp.

{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::Sparse)
    {
        assert(svfg && "SVFG is not built for sparse AE");
        return svfg->getUseSitesOfValVar(var);
    }
    Set<const ICFGNode*> succs;
    if (const ICFGNode* node = var->getICFGNode())
    {
        for (const auto* edge : node->getOutEdges())
            succs.insert(edge->getDstNode());
    }
    return succs;
}

hasAbstractState()

bool AbstractStateManager::hasAbstractState

(

const ICFGNode *

node

)

Check if an abstract state exists for a given ICFG node.

Definition at line 78 of file AbstractStateManager.cpp.

{
    return abstractTrace.count(node) != 0;
}

hasAbstractValue() [1/3]

bool AbstractStateManager::hasAbstractValue	(	const ObjVar *	var,
		const ICFGNode *	node
	)		const

Check whether an ObjVar has a stored value at node.

Definition at line 223 of file AbstractStateManager.cpp.

{
    auto it = abstractTrace.find(node);
    if (it == abstractTrace.end())
        return false;
    u32_t objId = var->getId();
    return it->second.getLocToVal().count(objId) != 0;
}

hasAbstractValue() [2/3]

bool AbstractStateManager::hasAbstractValue	(	const SVFVar *	var,
		const ICFGNode *	node
	)		const

Dispatch to ValVar or ObjVar overload.

Definition at line 232 of file AbstractStateManager.cpp.

{
    if (const ObjVar* objVar = SVFUtil::dyn_cast<ObjVar>(var))
        return hasAbstractValue(objVar, node);
    if (const ValVar* valVar = SVFUtil::dyn_cast<ValVar>(var))
        return hasAbstractValue(valVar, node);
    return false;
}

hasAbstractValue() [3/3]

bool AbstractStateManager::hasAbstractValue	(	const ValVar *	var,
		const ICFGNode *	node
	)		const

Check whether a ValVar has a real stored value reachable by getAbstractValue. Unlike getAbstractValue, this is side-effect free and does NOT treat the final top-fallback as "present" — so callers that plan to write the fetched value back (e.g. cycle widen/narrow) can distinguish a genuine stored value from the top sentinel.

Definition at line 184 of file AbstractStateManager.cpp.

{
    // Constants are always "present" (their value is intrinsic).
    if (SVFUtil::isa<ConstIntValVar>(var) || SVFUtil::isa<ConstFPValVar>(var) ||
            SVFUtil::isa<ConstNullPtrValVar>(var) || SVFUtil::isa<ConstDataValVar>(var))
        return true;
 
    u32_t id = var->getId();
    bool semiSparse = Options::AESparsity() == AbstractInterpretation::AESparsity::SemiSparse;
 
    // Dense mode: stored at the current node.
    if (!semiSparse)
    {
        auto it = abstractTrace.find(node);
        if (it != abstractTrace.end() &&
                (it->second.inVarToValTable(id) || it->second.inVarToAddrsTable(id)))
            return true;
    }
 
    // Semi-sparse (and dense fall-through): check the def-site.
    const ICFGNode* defNode = var->getICFGNode();
    if (defNode)
    {
        auto it = abstractTrace.find(defNode);
        if (it != abstractTrace.end() && it->second.getVarToVal().count(id))
            return true;
 
        // Fallback for call-result ValVars: value lives at the RetICFGNode.
        if (const CallICFGNode* callNode = SVFUtil::dyn_cast<CallICFGNode>(defNode))
        {
            const RetICFGNode* retNode = callNode->getRetICFGNode();
            auto rit = abstractTrace.find(retNode);
            if (rit != abstractTrace.end() && rit->second.getVarToVal().count(id))
                return true;
        }
    }
    return false;
}

loadValue()

AbstractValue AbstractStateManager::loadValue	(	const ValVar *	pointer,
		const ICFGNode *	node
	)

Load value through a pointer: resolve pointer's address set via getAbstractValue (sparsity-aware), then load from each ObjVar address.

Parameters

pointer	The pointer SVFVar (ValVar).
node	The ICFG node providing context.

Returns

The joined abstract value from all pointed-to objects.

Definition at line 467 of file AbstractStateManager.cpp.

{
    const AbstractValue& ptrVal = getAbstractValue(pointer, node);
    AbstractState& as = getAbstractState(node);
    AbstractValue res;
    for (auto addr : ptrVal.getAddrs())
        res.join_with(as.load(addr));
    return res;
}

operator[]()

AbstractState & SVF::AbstractStateManager::operator[] ( const ICFGNode *  node )

inline

Definition at line 158 of file AbstractStateManager.h.

    {
        return abstractTrace[node];
    }

storeValue()

void AbstractStateManager::storeValue	(	const ValVar *	pointer,
		const AbstractValue &	val,
		const ICFGNode *	node
	)

Store value through a pointer: resolve pointer's address set via getAbstractValue (sparsity-aware), then store to each ObjVar address.

Parameters

pointer	The pointer SVFVar (ValVar).
val	The value to store.
node	The ICFG node providing context.

Definition at line 477 of file AbstractStateManager.cpp.

{
    const AbstractValue& ptrVal = getAbstractValue(pointer, node);
    AbstractState& as = getAbstractState(node);
    for (auto addr : ptrVal.getAddrs())
        as.store(addr, val);
}

updateAbstractState()

void AbstractStateManager::updateAbstractState	(	const ICFGNode *	node,
		const AbstractState &	state
	)

Definition at line 64 of file AbstractStateManager.cpp.

{
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::SemiSparse)
    {
        // Semi-sparse: only replace ObjVar state. ValVars live at their
        // def-sites and must not be overwritten by state replacement.
        abstractTrace[node].updateAddrStateOnly(state);
    }
    else
    {
        abstractTrace[node] = state;
    }
}

updateAbstractValue() [1/3]

void AbstractStateManager::updateAbstractValue	(	const ObjVar *	var,
		const AbstractValue &	val,
		const ICFGNode *	node
	)

Write an address-taken variable's content via virtual-address store.

Definition at line 259 of file AbstractStateManager.cpp.

{
    AbstractState& as = getAbstractState(node);
    u32_t addr = AbstractState::getVirtualMemAddress(var->getId());
    as.store(addr, val);
}

updateAbstractValue() [2/3]

void AbstractStateManager::updateAbstractValue	(	const SVFVar *	var,
		const AbstractValue &	val,
		const ICFGNode *	node
	)

Dispatch to ValVar or ObjVar overload.

Definition at line 266 of file AbstractStateManager.cpp.

{
    if (const ObjVar* objVar = SVFUtil::dyn_cast<ObjVar>(var))
        updateAbstractValue(objVar, val, node);
    else if (const ValVar* valVar = SVFUtil::dyn_cast<ValVar>(var))
        updateAbstractValue(valVar, val, node);
    else
        assert(false && "Unknown SVFVar kind");
}

updateAbstractValue() [3/3]

void AbstractStateManager::updateAbstractValue	(	const ValVar *	var,
		const AbstractValue &	val,
		const ICFGNode *	node
	)

Write a top-level variable's abstract value into abstractTrace[node].

Definition at line 245 of file AbstractStateManager.cpp.

{
    // In semi-sparse mode, write to the var's def-site so that
    // getAbstractValue (which reads from def-site) stays consistent.
    const ICFGNode* target = node;
    if (Options::AESparsity() == AbstractInterpretation::AESparsity::SemiSparse)
    {
        const ICFGNode* defNode = var->getICFGNode();
        if (defNode)
            target = defNode;
    }
    abstractTrace[target][var->getId()] = val;
}

Member Data Documentation

abstractTrace

Map<const ICFGNode*, AbstractState> SVF::AbstractStateManager::abstractTrace

private

Definition at line 182 of file AbstractStateManager.h.

svfg

SVFG* SVF::AbstractStateManager::svfg

private

Definition at line 181 of file AbstractStateManager.h.

svfir

SVFIR* SVF::AbstractStateManager::svfir

private

Definition at line 180 of file AbstractStateManager.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/AE/Svfexe/AbstractStateManager.h
• /home/runner/work/SVF/SVF/svf/lib/AE/Svfexe/AbstractStateManager.cpp