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)
const Set< NodeID > &	getFreedAddrs () const
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)
static bool	isNullOrBlackHoleAddr (u32_t addr)
	Whether addr has no concrete backing memory object.

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 56 of file AbstractState.h.

Member Typedef Documentation

AddrToAbsValMap

typedef VarToAbsValMap SVF::AbstractState::AddrToAbsValMap

Definition at line 62 of file AbstractState.h.

VarToAbsValMap

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

Definition at line 61 of file AbstractState.h.

Constructor & Destructor Documentation

AbstractState() [1/4]

SVF::AbstractState::AbstractState ( )

inline

default constructor

Definition at line 64 of file AbstractState.h.

    {
    }

AbstractState() [2/4]

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

inline

Definition at line 68 of file AbstractState.h.

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

AbstractState() [3/4]

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

inline

copy constructor

Definition at line 71 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 101 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 282 of file AbstractState.h.

    {
        _freedAddrs.insert(addr);
    }

bottom()

AbstractState SVF::AbstractState::bottom ( ) const

inline

Set all value bottom.

Definition at line 109 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 363 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 374 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 319 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 333 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;
}

getFreedAddrs()

const Set< NodeID > & SVF::AbstractState::getFreedAddrs ( ) const

inline

Definition at line 287 of file AbstractState.h.

    {
        return _freedAddrs;
    }

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 95 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 258 of file AbstractState.h.

    {
        return _addrToAbsVal;
    }

getVarToVal()

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

inline

get var2val map

Definition at line 252 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 83 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 226 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 239 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 164 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 204 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 215 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 147 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "needs to be a virtual memory address");
        return addr == BlackHoleObjAddr;
    }

isFreedMem()

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

inline

Definition at line 292 of file AbstractState.h.

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

isNullMem()

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

inlinestatic

Definition at line 141 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "needs to be a virtual memory address");
        return addr == NullMemAddr;
    }

isNullOrBlackHoleAddr()

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

inlinestatic

Whether addr has no concrete backing memory object.

Definition at line 154 of file AbstractState.h.

    {
        return isNullMem(addr) || isBlackHoleObjAddr(addr);
    }

isVirtualMemAddress()

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

inlinestatic

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

Definition at line 89 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.

{
    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 182 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 189 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 136 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 342 of file AbstractState.h.

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

operator<()

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

inline

Definition at line 347 of file AbstractState.h.

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

operator=() [1/2]

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

inline

operator= move constructor

Definition at line 324 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 312 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 335 of file AbstractState.h.

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

operator>=()

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

inline

Definition at line 352 of file AbstractState.h.

    {
        return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) &&
               geqVarToValMap(_addrToAbsVal, rhs.getLocToVal()) &&
               std::all_of(rhs._freedAddrs.begin(), rhs._freedAddrs.end(),
                           [this](NodeID addr)
        {
            return _freedAddrs.count(addr) != 0;
        });
    }

operator[]() [1/2]

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

inlinevirtual

get abstract value of variable

Definition at line 169 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 176 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 209 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 133 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 196 of file AbstractState.h.

    {
        assert(isVirtualMemAddress(addr) && "not virtual address?");
        if (!isNullOrBlackHoleAddr(addr))
            _addrToAbsVal[getIDFromAddr(addr)] = val;
    }

top()

AbstractState SVF::AbstractState::top ( ) const

inline

Set all value top.

Definition at line 121 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 291 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 273 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 59 of file AbstractState.h.

SVFIR2AbsState

friend class SVFIR2AbsState

friend

Definition at line 58 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 162 of file AbstractState.h.

_freedAddrs

Set<NodeID> SVF::AbstractState::_freedAddrs

protected

Definition at line 163 of file AbstractState.h.

_varToAbsVal

VarToAbsValMap SVF::AbstractState::_varToAbsVal

protected

Map a variable (symbol) to its abstract value.

Definition at line 161 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