SVF::AbstractState Class Reference

#include <AbstractState.h>

Public Types
typedef Map< u32_t, AbstractValue >	VarToAbsValMap
typedef VarToAbsValMap	AddrToAbsValMap

Public Member Functions
	AbstractState ()
	default constructor
	AbstractState (VarToAbsValMap &_varToValMap, AddrToAbsValMap &_locToValMap)
	AbstractState (const AbstractState &rhs)
	copy constructor
virtual	~AbstractState ()=default
void	initObjVar (const ObjVar *objVar)
u32_t	getIDFromAddr (u32_t addr) const
	Return the internal index if addr is an address otherwise return the value of idx.
	AbstractState (AbstractState &&rhs)
	move constructor
AbstractState	bottom () const
	Set all value bottom.
AbstractState	top () const
	Set all value top.
AbstractState	sliceState (Set< u32_t > &sl)
	Copy some values and return a new IntervalExeState.
virtual AbstractValue &	operator[] (u32_t varId)
	get abstract value of variable
virtual const AbstractValue &	operator[] (u32_t varId) const
	get abstract value of variable
virtual AbstractValue &	load (u32_t addr)
virtual const AbstractValue &	load (u32_t addr) const
void	store (u32_t addr, const AbstractValue &val)
bool	inVarToAddrsTable (u32_t id) const
	whether the variable is in varToAddrs table
virtual bool	inVarToValTable (u32_t id) const
	whether the variable is in varToVal table
bool	inAddrToAddrsTable (u32_t id) const
	whether the memory address stores memory addresses
virtual bool	inAddrToValTable (u32_t id) const
	whether the memory address stores abstract value
const VarToAbsValMap &	getVarToVal () const
	get var2val map
const AddrToAbsValMap &	getLocToVal () const
	get loc2val map
AbstractState	widening (const AbstractState &other)
	domain widen with other, and return the widened domain
AbstractState	narrowing (const AbstractState &other)
	domain narrow with other, and return the narrowed domain
void	joinWith (const AbstractState &other)
	domain join with other, important! other widen this.
void	updateAddrStateOnly (const AbstractState &other)
	Replace address-taken (ObjVar) state with other's, preserving ValVar state.
void	meetWith (const AbstractState &other)
	domain meet with other, important! other widen this.
void	addToFreedAddrs (NodeID addr)
bool	isFreedMem (u32_t addr) const
void	printAbstractState () const
std::string	toString () const
u32_t	hash () const
bool	eqVarToValMap (const VarToAbsValMap &lhs, const VarToAbsValMap &rhs) const
bool	geqVarToValMap (const VarToAbsValMap &lhs, const VarToAbsValMap &rhs) const
bool	equals (const AbstractState &other) const
AbstractState &	operator= (const AbstractState &rhs)
	Assignment operator.
AbstractState &	operator= (AbstractState &&rhs)
	operator= move constructor
bool	operator== (const AbstractState &rhs) const
bool	operator!= (const AbstractState &rhs) const
bool	operator< (const AbstractState &rhs) const
bool	operator>= (const AbstractState &rhs) const
void	clear ()
void	clearValVars ()

Static Public Member Functions
static u32_t	getVirtualMemAddress (u32_t idx)
	The physical address starts with 0x7f...... + idx.
static bool	isVirtualMemAddress (u32_t val)
	Check bit value of val start with 0x7F000000, filter by 0xFF000000.
static bool	isNullMem (u32_t addr)
static bool	isBlackHoleObjAddr (u32_t addr)

Protected Attributes
VarToAbsValMap	_varToAbsVal
	Map a variable (symbol) to its abstract value.
AddrToAbsValMap	_addrToAbsVal
	Map a memory address to its stored abstract value.
Set< NodeID >	_freedAddrs

Friends
class	SVFIR2AbsState
class	RelationSolver

Detailed Description

Definition at line 55 of file AbstractState.h.

Member Typedef Documentation

AddrToAbsValMap

typedef VarToAbsValMap SVF::AbstractState::AddrToAbsValMap

Definition at line 61 of file AbstractState.h.

VarToAbsValMap

typedef Map<u32_t, AbstractValue> SVF::AbstractState::VarToAbsValMap

Definition at line 60 of file AbstractState.h.

Constructor & Destructor Documentation

AbstractState() [1/4]

SVF::AbstractState::AbstractState ( )

inline

default constructor

Definition at line 63 of file AbstractState.h.

    {
    }

AbstractState() [2/4]

SVF::AbstractState::AbstractState ( VarToAbsValMap &  _varToValMap, AddrToAbsValMap &  _locToValMap  )

inline

Definition at line 67 of file AbstractState.h.

: _varToAbsVal(_varToValMap), _addrToAbsVal(_locToValMap) {}

AbstractState() [3/4]

SVF::AbstractState::AbstractState ( const AbstractState &  rhs )

inline

copy constructor

Definition at line 70 of file AbstractState.h.

                                           : _varToAbsVal(rhs.getVarToVal()), _addrToAbsVal(rhs.getLocToVal()), _freedAddrs(rhs._freedAddrs)
    {
 
    }

~AbstractState()

virtual SVF::AbstractState::~AbstractState ( )

virtualdefault

AbstractState() [4/4]

SVF::AbstractState::AbstractState ( AbstractState &&  rhs )

inline

move constructor

Definition at line 100 of file AbstractState.h.

                                      : _varToAbsVal(std::move(rhs._varToAbsVal)),
        _addrToAbsVal(std::move(rhs._addrToAbsVal)),
        _freedAddrs(std::move(rhs._freedAddrs))
    {
 
    }

Member Function Documentation

addToFreedAddrs()

void SVF::AbstractState::addToFreedAddrs ( NodeID  addr )

inline

Definition at line 275 of file AbstractState.h.

    {
        _freedAddrs.insert(addr);
    }

bottom()

AbstractState SVF::AbstractState::bottom ( ) const

inline

Set all value bottom.

Definition at line 108 of file AbstractState.h.

    {
        AbstractState inv = *this;
        for (auto &item: inv._varToAbsVal)
        {
            if (item.second.isInterval())
                item.second.getInterval().set_to_bottom();
        }
        return inv;
    }

clear()

void SVF::AbstractState::clear ( )

inline

Definition at line 344 of file AbstractState.h.

    {
        _addrToAbsVal.clear();
        _varToAbsVal.clear();
        _freedAddrs.clear();
    }

clearValVars()

void SVF::AbstractState::clearValVars ( )

inline

Drop all top-level variables (ValVars), keeping ObjVar storage and freed addresses intact. Used when building a cycle snapshot so the ValVar set is controlled by the caller rather than whatever was cached at the seed node.

Definition at line 355 of file AbstractState.h.

    {
        _varToAbsVal.clear();
    }

equals()

bool AbstractState::equals

(

const AbstractState &

other

)

const

Definition at line 39 of file AbstractState.cpp.

{
    return *this == other;
}

eqVarToValMap()

bool AbstractState::eqVarToValMap	(	const VarToAbsValMap &	lhs,
		const VarToAbsValMap &	rhs
	)		const

Definition at line 325 of file AbstractState.cpp.

{
    if (lhs.size() != rhs.size()) return false;
    for (const auto &item: lhs)
    {
        auto it = rhs.find(item.first);
        if (it == rhs.end())
            return false;
        if (!item.second.equals(it->second))
            return false;
    }
    return true;
}

geqVarToValMap()

bool AbstractState::geqVarToValMap	(	const VarToAbsValMap &	lhs,
		const VarToAbsValMap &	rhs
	)		const

Definition at line 339 of file AbstractState.cpp.

{
    if (rhs.empty()) return true;
    for (const auto &item: rhs)
    {
        auto it = lhs.find(item.first);
        if (it == lhs.end()) return false;
        if (!it->second.getInterval().contain(
                    item.second.getInterval()))
            return false;
    }
    return true;
}

getIDFromAddr()

u32_t SVF::AbstractState::getIDFromAddr ( u32_t  addr ) const

inline

Return the internal index if addr is an address otherwise return the value of idx.

Definition at line 94 of file AbstractState.h.

    {
        return _freedAddrs.count(addr) ?  AddressValue::getInternalID(BlackHoleObjAddr) : AddressValue::getInternalID(addr);
    }

getLocToVal()

const AddrToAbsValMap & SVF::AbstractState::getLocToVal ( ) const

inline

get loc2val map

Definition at line 250 of file AbstractState.h.

    {
        return _addrToAbsVal;
    }

getVarToVal()

const VarToAbsValMap & SVF::AbstractState::getVarToVal ( ) const

inline

get var2val map

Definition at line 244 of file AbstractState.h.

    {
        return _varToAbsVal;
    }

getVirtualMemAddress()

static u32_t SVF::AbstractState::getVirtualMemAddress ( u32_t  idx )

inlinestatic

The physical address starts with 0x7f...... + idx.

Definition at line 82 of file AbstractState.h.

    {
        return AddressValue::getVirtualMemAddress(idx);
    }

hash()

u32_t AbstractState::hash

(

)

const

Definition at line 44 of file AbstractState.cpp.

{
    size_t h = getVarToVal().size() * 2;
    Hash<u32_t> hf;
    for (const auto &t: getVarToVal())
    {
        h ^= hf(t.first) + 0x9e3779b9 + (h << 6) + (h >> 2);
    }
    size_t h2 = getLocToVal().size() * 2;
    for (const auto &t: getLocToVal())
    {
        h2 ^= hf(t.first) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
    }
    Hash<std::pair<u32_t, u32_t>> pairH;
    return pairH({h, h2});
}

inAddrToAddrsTable()

bool SVF::AbstractState::inAddrToAddrsTable ( u32_t  id ) const

inline

whether the memory address stores memory addresses

Definition at line 218 of file AbstractState.h.

    {
        if (_addrToAbsVal.find(id)!= _addrToAbsVal.end())
        {
            if (_addrToAbsVal.at(id).isAddr())
            {
                return true;
            }
        }
        return false;
    }

inAddrToValTable()

virtual bool SVF::AbstractState::inAddrToValTable ( u32_t  id ) const

inlinevirtual

whether the memory address stores abstract value

Definition at line 231 of file AbstractState.h.

    {
        if (_addrToAbsVal.find(id) != _addrToAbsVal.end())
        {
            if (_addrToAbsVal.at(id).isInterval())
            {
                return true;
            }
        }
        return false;
    }

initObjVar()

void AbstractState::initObjVar

(

const ObjVar *

objVar

)

Definition at line 170 of file AbstractState.cpp.

{
    NodeID varId = objVar->getId();
 
    // Check if the object variable has an associated value
 
    const BaseObjVar* obj = PAG::getPAG()->getBaseObject(objVar->getId());
 
    // Handle constant data, arrays, and structures
    if (obj->isConstDataOrConstGlobal() || obj->isConstantArray() || obj->isConstantStruct())
    {
        if (const ConstIntObjVar* consInt = SVFUtil::dyn_cast<ConstIntObjVar>(objVar))
        {
            s64_t numeral = consInt->getSExtValue();
            (*this)[varId] = IntervalValue(numeral, numeral);
        }
        else if (const ConstFPObjVar* consFP = SVFUtil::dyn_cast<ConstFPObjVar>(objVar))
        {
            (*this)[varId] = IntervalValue(consFP->getFPValue(), consFP->getFPValue());
        }
        else if (SVFUtil::isa<ConstNullPtrObjVar>(objVar))
        {
            (*this)[varId] = IntervalValue(0, 0);
        }
        else if (SVFUtil::isa<GlobalObjVar>(objVar))
        {
            (*this)[varId] = AddressValue(AbstractState::getVirtualMemAddress(varId));
        }
        else if (obj->isConstantArray() || obj->isConstantStruct())
        {
            (*this)[varId] = IntervalValue::top();
        }
        else
        {
            (*this)[varId] = IntervalValue::top();
        }
    }
    // Handle non-constant memory objects
    else
    {
        (*this)[varId] = AddressValue(AbstractState::getVirtualMemAddress(varId));
    }
    return;
}

inVarToAddrsTable()

bool SVF::AbstractState::inVarToAddrsTable ( u32_t  id ) const

inline

whether the variable is in varToAddrs table

Definition at line 196 of file AbstractState.h.

    {
        if (_varToAbsVal.find(id)!= _varToAbsVal.end())
        {
            if (_varToAbsVal.at(id).isAddr())
                return true;
        }
        return false;
    }

inVarToValTable()

virtual bool SVF::AbstractState::inVarToValTable ( u32_t  id ) const

inlinevirtual

whether the variable is in varToVal table

Definition at line 207 of file AbstractState.h.

    {
        if (_varToAbsVal.find(id) != _varToAbsVal.end())
        {
            if (_varToAbsVal.at(id).isInterval())
                return true;
        }
        return false;
    }

isBlackHoleObjAddr()

static bool SVF::AbstractState::isBlackHoleObjAddr ( u32_t  addr )

inlinestatic

Definition at line 145 of file AbstractState.h.

    {
        return addr == BlackHoleObjAddr;
    }

isFreedMem()

bool SVF::AbstractState::isFreedMem ( u32_t  addr ) const

inline

Definition at line 280 of file AbstractState.h.

    {
        return _freedAddrs.find(addr) != _freedAddrs.end();
    }

isNullMem()

static bool SVF::AbstractState::isNullMem ( u32_t  addr )

inlinestatic

Definition at line 140 of file AbstractState.h.

    {
        return addr == NullMemAddr;
    }

isVirtualMemAddress()

static bool SVF::AbstractState::isVirtualMemAddress ( u32_t  val )

inlinestatic

Check bit value of val start with 0x7F000000, filter by 0xFF000000.

Definition at line 88 of file AbstractState.h.

    {
        return AddressValue::isVirtualMemAddress(val);
    }

joinWith()

void AbstractState::joinWith

(

const AbstractState &

other

)

domain join with other, important! other widen this.

Definition at line 104 of file AbstractState.cpp.

{
    // In semi-sparse mode, skip ValVar (_varToAbsVal) merge — ValVars are
    // pulled on demand from def-sites via getAbstractValue.
    // In dense mode, merge everything.
    if (Options::AESparsity() != AbstractInterpretation::AESparsity::SemiSparse)
    {
        for (auto it = other._varToAbsVal.begin(); it != other._varToAbsVal.end(); ++it)
        {
            auto key = it->first;
            auto oit = _varToAbsVal.find(key);
            if (oit != _varToAbsVal.end())
            {
                oit->second.join_with(it->second);
            }
            else
            {
                _varToAbsVal.emplace(key, it->second);
            }
        }
    }
    for (auto it = other._addrToAbsVal.begin(); it != other._addrToAbsVal.end(); ++it)
    {
        auto key = it->first;
        auto oit = _addrToAbsVal.find(key);
        if (oit != _addrToAbsVal.end())
        {
            oit->second.join_with(it->second);
        }
        else
        {
            _addrToAbsVal.emplace(key, it->second);
        }
    }
    _freedAddrs.insert(other._freedAddrs.begin(), other._freedAddrs.end());
}

load() [1/2]

virtual AbstractValue & SVF::AbstractState::load ( u32_t  addr )

inlinevirtual

Definition at line 173 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "not virtual address?");
        u32_t objId = getIDFromAddr(addr);
        return _addrToAbsVal[objId];
    }

load() [2/2]

virtual const AbstractValue & SVF::AbstractState::load ( u32_t  addr ) const

inlinevirtual

Definition at line 180 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "not virtual address?");
        u32_t objId = getIDFromAddr(addr);
        return _addrToAbsVal.at(objId);
    }

meetWith()

void AbstractState::meetWith

(

const AbstractState &

other

)

domain meet with other, important! other widen this.

Definition at line 142 of file AbstractState.cpp.

{
    for (auto it = other._varToAbsVal.begin(); it != other._varToAbsVal.end(); ++it)
    {
        auto key = it->first;
        auto oit = _varToAbsVal.find(key);
        if (oit != _varToAbsVal.end())
        {
            oit->second.meet_with(it->second);
        }
    }
    for (auto it = other._addrToAbsVal.begin(); it != other._addrToAbsVal.end(); ++it)
    {
        auto key = it->first;
        auto oit = _addrToAbsVal.find(key);
        if (oit != _addrToAbsVal.end())
        {
            oit->second.meet_with(it->second);
        }
    }
    Set<NodeID> intersection;
    std::set_intersection(_freedAddrs.begin(), _freedAddrs.end(),
                          other._freedAddrs.begin(), other._freedAddrs.end(),
                          std::inserter(intersection, intersection.begin()));
    _freedAddrs = std::move(intersection);
}

narrowing()

AbstractState AbstractState::narrowing

(

const AbstractState &

other

)

domain narrow with other, and return the narrowed domain

Definition at line 82 of file AbstractState.cpp.

{
    AbstractState es = *this;
    for (auto it = es._varToAbsVal.begin(); it != es._varToAbsVal.end(); ++it)
    {
        auto key = it->first;
        if (other._varToAbsVal.find(key) != other._varToAbsVal.end())
            if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
                it->second.getInterval().narrow_with(other._varToAbsVal.at(key).getInterval());
    }
    for (auto it = es._addrToAbsVal.begin(); it != es._addrToAbsVal.end(); ++it)
    {
        auto key = it->first;
        if (other._addrToAbsVal.find(key) != other._addrToAbsVal.end())
            if (it->second.isInterval() && other._addrToAbsVal.at(key).isInterval())
                it->second.getInterval().narrow_with(other._addrToAbsVal.at(key).getInterval());
    }
    return es;
 
}

operator!=()

bool SVF::AbstractState::operator!= ( const AbstractState &  rhs ) const

inline

Definition at line 329 of file AbstractState.h.

    {
        return !(*this == rhs);
    }

operator<()

bool SVF::AbstractState::operator< ( const AbstractState &  rhs ) const

inline

Definition at line 334 of file AbstractState.h.

    {
        return !(*this >= rhs);
    }

operator=() [1/2]

AbstractState & SVF::AbstractState::operator= ( AbstractState &&  rhs )

inline

operator= move constructor

Definition at line 312 of file AbstractState.h.

    {
        if (&rhs != this)
        {
            _varToAbsVal = std::move(rhs._varToAbsVal);
            _addrToAbsVal = std::move(rhs._addrToAbsVal);
            _freedAddrs = std::move(rhs._freedAddrs);
        }
        return *this;
    }

operator=() [2/2]

AbstractState & SVF::AbstractState::operator= ( const AbstractState &  rhs )

inline

Assignment operator.

Definition at line 300 of file AbstractState.h.

    {
        if (&rhs != this)
        {
            _varToAbsVal = rhs._varToAbsVal;
            _addrToAbsVal = rhs._addrToAbsVal;
            _freedAddrs = rhs._freedAddrs;
        }
        return *this;
    }

operator==()

bool SVF::AbstractState::operator== ( const AbstractState &  rhs ) const

inline

Definition at line 323 of file AbstractState.h.

    {
        return  eqVarToValMap(_varToAbsVal, rhs.getVarToVal()) &&
                eqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
    }

operator>=()

bool SVF::AbstractState::operator>= ( const AbstractState &  rhs ) const

inline

Definition at line 339 of file AbstractState.h.

    {
        return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) && geqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
    }

operator[]() [1/2]

virtual AbstractValue & SVF::AbstractState::operator[] ( u32_t  varId )

inlinevirtual

get abstract value of variable

Definition at line 160 of file AbstractState.h.

    {
        assert(!isVirtualMemAddress(varId) && "varId is a virtual memory address, use load() instead");
        return _varToAbsVal[varId];
    }

operator[]() [2/2]

virtual const AbstractValue & SVF::AbstractState::operator[] ( u32_t  varId ) const

inlinevirtual

get abstract value of variable

Definition at line 167 of file AbstractState.h.

    {
        assert(!isVirtualMemAddress(varId) && "varId is a virtual memory address, use load() instead");
        return _varToAbsVal.at(varId);
    }

printAbstractState()

void AbstractState::printAbstractState

(

)

const

Definition at line 215 of file AbstractState.cpp.

{
    SVFUtil::outs() << "-----------Var and Value-----------\n";
    u32_t fieldWidth = 20;
    SVFUtil::outs().flags(std::ios::left);
    std::vector<std::pair<u32_t, AbstractValue>> varToAbsValVec(_varToAbsVal.begin(), _varToAbsVal.end());
    std::sort(varToAbsValVec.begin(), varToAbsValVec.end(), [](const auto &a, const auto &b)
    {
        return a.first < b.first;
    });
    for (const auto &item: varToAbsValVec)
    {
        SVFUtil::outs() << std::left << std::setw(fieldWidth) << ("Var" + std::to_string(item.first));
        if (item.second.isInterval())
        {
            SVFUtil::outs() << " Value: " << item.second.getInterval().toString() << "\n";
        }
        else if (item.second.isAddr())
        {
            SVFUtil::outs() << " Value: {";
            u32_t i = 0;
            for (const auto& addr: item.second.getAddrs())
            {
                ++i;
                if (i < item.second.getAddrs().size())
                {
                    SVFUtil::outs() << "0x" << std::hex << addr << ", ";
                }
                else
                {
                    SVFUtil::outs() << "0x" << std::hex << addr;
                }
            }
            SVFUtil::outs() << "}\n";
        }
        else
        {
            SVFUtil::outs() << " Value: ⊥\n";
        }
    }
 
    std::vector<std::pair<u32_t, AbstractValue>> addrToAbsValVec(_addrToAbsVal.begin(), _addrToAbsVal.end());
    std::sort(addrToAbsValVec.begin(), addrToAbsValVec.end(), [](const auto &a, const auto &b)
    {
        return a.first < b.first;
    });
 
    for (const auto& item: addrToAbsValVec)
    {
        std::ostringstream oss;
        oss << "0x" << std::hex << AbstractState::getVirtualMemAddress(item.first);
        SVFUtil::outs() << std::left << std::setw(fieldWidth) << oss.str();
        if (item.second.isInterval())
        {
            SVFUtil::outs() << " Value: " << item.second.getInterval().toString() << "\n";
        }
        else if (item.second.isAddr())
        {
            SVFUtil::outs() << " Value: {";
            u32_t i = 0;
            for (const auto& addr: item.second.getAddrs())
            {
                ++i;
                if (i < item.second.getAddrs().size())
                {
                    SVFUtil::outs() << "0x" << std::hex << addr << ", ";
                }
                else
                {
                    SVFUtil::outs() << "0x" << std::hex << addr;
                }
            }
            SVFUtil::outs() << "}\n";
        }
        else
        {
            SVFUtil::outs() << " Value: ⊥\n";
        }
    }
    SVFUtil::outs() << "-----------------------------------------\n";
}

sliceState()

AbstractState SVF::AbstractState::sliceState ( Set< u32_t > &  sl )

inline

Copy some values and return a new IntervalExeState.

Definition at line 132 of file AbstractState.h.

    {
        AbstractState inv;
        for (u32_t id: sl)
            inv._varToAbsVal[id] = _varToAbsVal[id];
        return inv;
    }

store()

void SVF::AbstractState::store ( u32_t  addr, const AbstractValue &  val  )

inline

Definition at line 187 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "not virtual address?");
        u32_t objId = getIDFromAddr(addr);
        if (isNullMem(addr)) return;
        _addrToAbsVal[objId] = val;
    }

top()

AbstractState SVF::AbstractState::top ( ) const

inline

Set all value top.

Definition at line 120 of file AbstractState.h.

    {
        AbstractState inv = *this;
        for (auto &item: inv._varToAbsVal)
        {
            if (item.second.isInterval())
                item.second.getInterval().set_to_top();
        }
        return inv;
    }

toString()

std::string AbstractState::toString

(

)

const

Definition at line 297 of file AbstractState.cpp.

{
    u32_t varIntervals = 0, varAddrs = 0, varBottom = 0;
    for (const auto& item : _varToAbsVal)
    {
        if (item.second.isInterval()) ++varIntervals;
        else if (item.second.isAddr()) ++varAddrs;
        else ++varBottom;
    }
    u32_t addrIntervals = 0, addrAddrs = 0, addrBottom = 0;
    for (const auto& item : _addrToAbsVal)
    {
        if (item.second.isInterval()) ++addrIntervals;
        else if (item.second.isAddr()) ++addrAddrs;
        else ++addrBottom;
    }
    std::ostringstream oss;
    oss << "AbstractState {\n"
        << "  VarToAbsVal: " << _varToAbsVal.size() << " entries ("
        << varIntervals << " intervals, " << varAddrs << " addresses, " << varBottom << " bottom)\n"
        << "  AddrToAbsVal: " << _addrToAbsVal.size() << " entries ("
        << addrIntervals << " intervals, " << addrAddrs << " addresses, " << addrBottom << " bottom)\n"
        << "  FreedAddrs: " << _freedAddrs.size() << "\n"
        << "}";
    return oss.str();
}

updateAddrStateOnly()

void SVF::AbstractState::updateAddrStateOnly ( const AbstractState &  other )

inline

Replace address-taken (ObjVar) state with other's, preserving ValVar state.

Definition at line 266 of file AbstractState.h.

    {
        _addrToAbsVal = other._addrToAbsVal;
        _freedAddrs = other._freedAddrs;
    }

widening()

AbstractState AbstractState::widening

(

const AbstractState &

other

)

domain widen with other, and return the widened domain

Definition at line 61 of file AbstractState.cpp.

{
    // widen interval
    AbstractState es = *this;
    for (auto it = es._varToAbsVal.begin(); it != es._varToAbsVal.end(); ++it)
    {
        auto key = it->first;
        if (other._varToAbsVal.find(key) != other._varToAbsVal.end())
            if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
                it->second.getInterval().widen_with(other._varToAbsVal.at(key).getInterval());
    }
    for (auto it = es._addrToAbsVal.begin(); it != es._addrToAbsVal.end(); ++it)
    {
        auto key = it->first;
        if (other._addrToAbsVal.find(key) != other._addrToAbsVal.end())
            if (it->second.isInterval() && other._addrToAbsVal.at(key).isInterval())
                it->second.getInterval().widen_with(other._addrToAbsVal.at(key).getInterval());
    }
    return es;
}

Friends And Related Symbol Documentation

RelationSolver

friend class RelationSolver

friend

Definition at line 58 of file AbstractState.h.

SVFIR2AbsState

friend class SVFIR2AbsState

friend

Definition at line 57 of file AbstractState.h.

Member Data Documentation

_addrToAbsVal

AddrToAbsValMap SVF::AbstractState::_addrToAbsVal

protected

Map a memory address to its stored abstract value.

Definition at line 153 of file AbstractState.h.

_freedAddrs

Set<NodeID> SVF::AbstractState::_freedAddrs

protected

Definition at line 154 of file AbstractState.h.

_varToAbsVal

VarToAbsValMap SVF::AbstractState::_varToAbsVal

protected

Map a variable (symbol) to its abstract value.

Definition at line 152 of file AbstractState.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/AE/Core/AbstractState.h
• /home/runner/work/SVF/SVF/svf/lib/AE/Core/AbstractState.cpp