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
AddressValue	getGepObjAddrs (u32_t pointer, IntervalValue offset)
void	initObjVar (ObjVar *objVar)
IntervalValue	getElementIndex (const GepStmt *gep)
IntervalValue	getByteOffset (const GepStmt *gep)
AbstractValue	loadValue (NodeID varId)
void	storeValue (NodeID varId, AbstractValue val)
u32_t	getAllocaInstByteSize (const AddrStmt *addr)
AbstractState &	operator= (const AbstractState &rhs)
	AbstractState (AbstractState &&rhs)
	move constructor
AbstractState &	operator= (AbstractState &&rhs)
	operator= 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
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	meetWith (const AbstractState &other)
	domain meet with other, important! other widen this.
const SVFType *	getPointeeElement (NodeID id)
u32_t	hash () const
void	store (u32_t addr, const AbstractValue &val)
virtual AbstractValue &	load (u32_t addr)
void	printAbstractState () const
std::string	toString () const
bool	equals (const AbstractState &other) const
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 ()

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 u32_t	getInternalID (u32_t idx)
	Return the internal index if idx is an address otherwise return the value of idx.
static bool	isNullPtr (u32_t addr)
static bool	eqVarToValMap (const VarToAbsValMap &lhs, const VarToAbsValMap &rhs)
static bool	lessThanVarToValMap (const VarToAbsValMap &lhs, const VarToAbsValMap &rhs)
static bool	geqVarToValMap (const VarToAbsValMap &lhs, const VarToAbsValMap &rhs)

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

Friends
class	SVFIR2AbsState
class	RelationSolver

Detailed Description

Definition at line 58 of file AbstractState.h.

Member Typedef Documentation

AddrToAbsValMap

typedef VarToAbsValMap SVF::AbstractState::AddrToAbsValMap

Definition at line 65 of file AbstractState.h.

VarToAbsValMap

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

Definition at line 63 of file AbstractState.h.

Constructor & Destructor Documentation

AbstractState() [1/4]

SVF::AbstractState::AbstractState ( )

inline

default constructor

Definition at line 69 of file AbstractState.h.

    {
    }

AbstractState() [2/4]

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

inline

Definition at line 73 of file AbstractState.h.

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

AbstractState() [3/4]

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

inline

copy constructor

Definition at line 76 of file AbstractState.h.

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

~AbstractState()

virtual SVF::AbstractState::~AbstractState ( )

virtualdefault

AbstractState() [4/4]

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

inline

move constructor

Definition at line 135 of file AbstractState.h.

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

Member Function Documentation

bottom()

AbstractState SVF::AbstractState::bottom ( ) const

inline

Set all value bottom.

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

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

equals()

bool AbstractState::equals

(

const AbstractState &

other

)

const

Definition at line 37 of file AbstractState.cpp.

{
    return *this == other;
}

eqVarToValMap()

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

inlinestatic

Definition at line 326 of file AbstractState.h.

    {
        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;
            else
            {
            }
        }
        return true;
    }

geqVarToValMap()

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

inlinestatic

Definition at line 357 of file AbstractState.h.

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

getAllocaInstByteSize()

u32_t AbstractState::getAllocaInstByteSize

(

const AddrStmt *

addr

)

Definition at line 486 of file AbstractState.cpp.

{
    SVFIR* svfir = PAG::getPAG();
    if (const ObjVar* objvar = SVFUtil::dyn_cast<ObjVar>(addr->getRHSVar()))
    {
        objvar->getType();
        if (objvar->getMemObj()->isConstantByteSize())
        {
            u32_t sz = objvar->getMemObj()->getByteSizeOfObj();
            return sz;
        }
 
        else
        {
            const std::vector<SVFValue*>& sizes = addr->getArrSize();
            // Default element size is set to 1.
            u32_t elementSize = 1;
            u64_t res = elementSize;
            for (const SVFValue* value: sizes)
            {
                if (!inVarToValTable(svfir->getValueNode(value)))
                {
                    (*this)[svfir->getValueNode(value)] = IntervalValue(Options::MaxFieldLimit());
                }
                IntervalValue itv =
                    (*this)[svfir->getValueNode(value)].getInterval();
                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();
}

getByteOffset()

IntervalValue AbstractState::getByteOffset

(

const GepStmt *

gep

)

Definition at line 298 of file AbstractState.cpp.

{
    // If the GEP statement has a constant byte offset, return it directly as the interval value
    if (gep->isConstantOffset())
        return IntervalValue((s64_t)gep->accumulateConstantByteOffset());
 
    IntervalValue res(0); // Initialize the result interval 'res' to 0.
 
    // Loop through the offsetVarAndGepTypePairVec in reverse order.
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        const SVFVar* idxOperandVar = gep->getOffsetVarAndGepTypePairVec()[i].first;
        const SVFType* idxOperandType = gep->getOffsetVarAndGepTypePairVec()[i].second;
 
        // Calculate the byte offset for array or pointer types
        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 ConstantIntValVar* op = SVFUtil::dyn_cast<ConstantIntValVar>(idxOperandVar))
            {
                // Calculate the lower bound (lb) of the interval value
                s64_t lb = (double)Options::MaxFieldLimit() / elemByteSize >= op->getSExtValue()
                           ? op->getSExtValue() * elemByteSize
                           : Options::MaxFieldLimit();
                res = res + IntervalValue(lb, lb);
            }
            else
            {
                IntervalValue idxVal = (*this)[idxOperandVar->getId()].getInterval();
 
                if (idxVal.isBottom())
                    res = res + IntervalValue(0, 0);
                else
                {
                    // Ensure the bounds are non-negative and within the field limit
                    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);
                }
            }
        }
        // Process struct subtypes by calculating the byte offset from the beginning to the field of the struct
        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; // Return the resulting byte offset as an IntervalValue.
}

getElementIndex()

IntervalValue AbstractState::getElementIndex

(

const GepStmt *

gep

)

Definition at line 225 of file AbstractState.cpp.

{
    // If the GEP statement has a constant offset, return it directly as the interval value
    if (gep->isConstantOffset())
        return IntervalValue((s64_t)gep->accumulateConstantOffset());
 
    IntervalValue res(0);
    // Iterate over the list of offset variable and type pairs in reverse order
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        AccessPath::IdxOperandPair IdxVarAndType = gep->getOffsetVarAndGepTypePairVec()[i];
        const SVFVar* var = gep->getOffsetVarAndGepTypePairVec()[i].first;
        const SVFType* type = IdxVarAndType.second;
 
        // Variables to store the lower and upper bounds of the index value
        s64_t idxLb;
        s64_t idxUb;
 
        // Determine the lower and upper bounds based on whether the value is a constant
        if (const ConstantIntValVar* constInt = SVFUtil::dyn_cast<ConstantIntValVar>(var))
            idxLb = idxUb = constInt->getSExtValue();
        else
        {
            IntervalValue idxItv = (*this)[var->getId()].getInterval();
            if (idxItv.isBottom())
                idxLb = idxUb = 0;
            else
            {
                idxLb = idxItv.lb().getIntNumeral();
                idxUb = idxItv.ub().getIntNumeral();
            }
        }
 
        // Adjust the bounds if the type is a pointer
        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;
        }
        // Adjust the bounds for array or struct types using the symbol table info
        else
        {
            if (Options::ModelArrays())
            {
                const std::vector<u32_t>& so = SymbolTableInfo::SymbolInfo()->getTypeInfo(type)->getFlattenedElemIdxVec();
                if (so.empty() || idxUb >= (APOffset)so.size() || idxLb < 0)
                {
                    idxLb = idxUb = 0;
                }
                else
                {
                    idxLb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(type, idxLb);
                    idxUb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(type, idxUb);
                }
            }
            else
                idxLb = idxUb = 0;
        }
 
        // Add the calculated interval to the result
        res = res + IntervalValue(idxLb, idxUb);
    }
 
    // Ensure the result is within the bounds of [0, MaxFieldLimit]
    res.meet_with(IntervalValue((s64_t)0, (s64_t)Options::MaxFieldLimit()));
    if (res.isBottom())
    {
        res = IntervalValue(0);
    }
    return res;
}

getGepObjAddrs()

AddressValue AbstractState::getGepObjAddrs	(	u32_t	pointer,
		IntervalValue	offset
	)

Definition at line 156 of file AbstractState.cpp.

{
    AddressValue gepAddrs;
    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++)
    {
        AbstractValue addrs = (*this)[pointer];
        for (const auto& addr : addrs.getAddrs())
        {
            s64_t baseObj = AbstractState::getInternalID(addr);
            assert(SVFUtil::isa<ObjVar>(PAG::getPAG()->getGNode(baseObj)) && "Fail to get the base object address!");
            NodeID gepObj = PAG::getPAG()->getGepObjVar(baseObj, i);
            (*this)[gepObj] = AddressValue(AbstractState::getVirtualMemAddress(gepObj));
            gepAddrs.insert(AbstractState::getVirtualMemAddress(gepObj));
        }
    }
 
    return gepAddrs;
}

getInternalID()

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

inlinestatic

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

Definition at line 114 of file AbstractState.h.

    {
        return AddressValue::getInternalID(idx);
    }

getLocToVal()

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

inline

get loc2val map

Definition at line 266 of file AbstractState.h.

    {
        return _addrToAbsVal;
    }

getPointeeElement()

const SVFType * AbstractState::getPointeeElement

(

NodeID

id

)

if this NodeID in SVFIR is a pointer, get the pointee type e.g arr = (int*) malloc(10*sizeof(int)) getPointeeType(arr) -> return int we can set arr[0]='c', arr[1]='c', arr[2]='\0'

Parameters

call	callnode of memset like api

Definition at line 465 of file AbstractState.cpp.

{
    SVFIR* svfir = PAG::getPAG();
    if (inVarToAddrsTable(id))
    {
        const AbstractValue& addrs = (*this)[id];
        for (auto addr: addrs.getAddrs())
        {
            NodeID addr_id = AbstractState::getInternalID(addr);
            if (addr_id == 0) // nullptr has no memobj, skip
                continue;
            return SVFUtil::dyn_cast<ObjVar>(svfir->getGNode(addr_id))->getMemObj()->getType();
        }
    }
    else
    {
        // do nothing if no record in addrs table.
    }
    return nullptr;
}

getVarToVal()

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

inline

get var2val map

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

    {
        return AddressValue::getVirtualMemAddress(idx);
    }

hash()

u32_t AbstractState::hash

(

)

const

Definition at line 42 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 234 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 247 of file AbstractState.h.

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

initObjVar()

void AbstractState::initObjVar

(

ObjVar *

objVar

)

Definition at line 179 of file AbstractState.cpp.

{
    NodeID varId = objVar->getId();
 
    // Check if the object variable has an associated value
 
    const MemObj* obj = objVar->getMemObj();
 
    // Handle constant data, arrays, and structures
    if (obj->isConstDataOrConstGlobal() || obj->isConstantArray() || obj->isConstantStruct())
    {
        if (const ConstantIntObjVar* consInt = SVFUtil::dyn_cast<ConstantIntObjVar>(objVar))
        {
            s64_t numeral = consInt->getSExtValue();
            (*this)[varId] = IntervalValue(numeral, numeral);
        }
        else if (const ConstantFPObjVar* consFP = SVFUtil::dyn_cast<ConstantFPObjVar>(objVar))
        {
            (*this)[varId] = IntervalValue(consFP->getFPValue(), consFP->getFPValue());
        }
        else if (SVFUtil::isa<ConstantNullPtrObjVar>(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 208 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 221 of file AbstractState.h.

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

isNullPtr()

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

inlinestatic

Definition at line 119 of file AbstractState.h.

    {
        return getInternalID(addr) == 0;
    }

isVirtualMemAddress()

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

inlinestatic

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

Definition at line 108 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 102 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);
        }
    }
}

lessThanVarToValMap()

static bool SVF::AbstractState::lessThanVarToValMap ( const VarToAbsValMap &  lhs, const VarToAbsValMap &  rhs  )

inlinestatic

Definition at line 343 of file AbstractState.h.

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

load()

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

inlinevirtual

Definition at line 307 of file AbstractState.h.

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

loadValue()

AbstractValue AbstractState::loadValue

(

NodeID

varId

)

Definition at line 365 of file AbstractState.cpp.

{
    AbstractValue res;
    for (auto addr : (*this)[varId].getAddrs())
    {
        res.join_with(load(addr)); // q = *p
    }
    return res;
}

meetWith()

void AbstractState::meetWith

(

const AbstractState &

other

)

domain meet with other, important! other widen this.

Definition at line 133 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);
        }
    }
}

narrowing()

AbstractState AbstractState::narrowing

(

const AbstractState &

other

)

domain narrow with other, and return the narrowed domain

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

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

operator<()

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

inline

Definition at line 384 of file AbstractState.h.

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

operator=() [1/2]

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

inline

operator= move constructor

Definition at line 142 of file AbstractState.h.

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

operator=() [2/2]

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

inline

Definition at line 124 of file AbstractState.h.

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

operator==()

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

inline

Definition at line 373 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 390 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 196 of file AbstractState.h.

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

    {
        return _varToAbsVal.at(varId);
    }

printAbstractState()

void AbstractState::printAbstractState

(

)

const

Definition at line 383 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 177 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 299 of file AbstractState.h.

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

storeValue()

void AbstractState::storeValue	(	NodeID	varId,
		AbstractValue	val
	)

Definition at line 375 of file AbstractState.cpp.

{
    for (auto addr : (*this)[varId].getAddrs())
    {
        store(addr, val); // *p = q
    }
}

top()

AbstractState SVF::AbstractState::top ( ) const

inline

Set all value top.

Definition at line 165 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 SVF::AbstractState::toString ( ) const

inline

Definition at line 318 of file AbstractState.h.

    {
        return "";
    }

widening()

AbstractState AbstractState::widening

(

const AbstractState &

other

)

domain widen with other, and return the widened domain

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

SVFIR2AbsState

friend class SVFIR2AbsState

friend

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

_varToAbsVal

VarToAbsValMap SVF::AbstractState::_varToAbsVal

protected

Map a variable (symbol) to its abstract value.

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