SVF::SVFIR2AbsState Class Reference

#include <SVFIR2AbsState.h>

Public Member Functions
	SVFIR2AbsState (SVFIR *ir)
void	setRelEs (const RelExeState &relEs)
RelExeState &	getRelEs ()
void	widenAddrs (AbstractState &es, AbstractState &lhs, const AbstractState &rhs)
void	narrowAddrs (AbstractState &es, AbstractState &lhs, const AbstractState &rhs)
AddressValue	getGepObjAddress (AbstractState &es, u32_t pointer, APOffset offset)
	Return the field address given a pointer points to a struct object and an offset. More...
IntervalValue	getRangeLimitFromType (const SVFType *type)
	Return the value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127]. More...
IntervalValue	getZExtValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getSExtValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getFPToSIntValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getFPToUIntValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getSIntToFPValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getUIntToFPValue (const AbstractState &es, const SVFVar *var)
IntervalValue	getTruncValue (const AbstractState &es, const SVFVar *var, const SVFType *dstType)
IntervalValue	getFPTruncValue (const AbstractState &es, const SVFVar *var, const SVFType *dstType)
IntervalValue	getByteOffset (const AbstractState &es, const GepStmt *gep)
IntervalValue	getElementIndex (const AbstractState &es, const GepStmt *gep)
	Return the offset expression of a GepStmt. More...
void	applySummary (AbstractState &es)
void	initObjVar (AbstractState &as, const ObjVar *var)
	Init ObjVar. More...
AbstractValue &	getAddrs (AbstractState &es, u32_t id)
bool	inVarTable (const AbstractState &es, u32_t id) const
bool	inAddrTable (const AbstractState &es, u32_t id) const
bool	inVarToValTable (const AbstractState &es, u32_t id) const
	whether the variable is in varToVal table More...
bool	inVarToAddrsTable (const AbstractState &es, u32_t id) const
	whether the variable is in varToAddrs table More...
bool	inLocToValTable (const AbstractState &es, u32_t id) const
	whether the memory address stores a interval value More...
bool	inLocToAddrsTable (const AbstractState &es, u32_t id) const
	whether the memory address stores memory addresses More...
void	handleAddr (AbstractState &es, const AddrStmt *addr)
void	handleBinary (AbstractState &es, const BinaryOPStmt *binary)
void	handleCmp (AbstractState &es, const CmpStmt *cmp)
void	handleLoad (AbstractState &es, const LoadStmt *load)
void	handleStore (AbstractState &es, const StoreStmt *store)
void	handleCopy (AbstractState &es, const CopyStmt *copy)
void	handleCall (AbstractState &es, const CallPE *callPE)
void	handleRet (AbstractState &es, const RetPE *retPE)
void	handleGep (AbstractState &es, const GepStmt *gep)
void	handleSelect (AbstractState &es, const SelectStmt *select)
void	handlePhi (AbstractState &es, const PhiStmt *phi)

Static Public Member Functions
static z3::context &	getContext ()
static u32_t	getInternalID (u32_t idx)
	Return the internal index if idx is an address otherwise return the value of idx. More...
static u32_t	getVirtualMemAddress (u32_t idx)
	The physical address starts with 0x7f...... + idx. More...
static bool	isVirtualMemAddress (u32_t val)
	Check bit value of val start with 0x7F000000, filter by 0xFF000000. More...

Static Public Attributes
static AbstractValue	globalNulladdrs = AddressValue()

Private Attributes
SVFIR *	_svfir
RelExeState	_relEs

Detailed Description

Definition at line 42 of file SVFIR2AbsState.h.

Constructor & Destructor Documentation

SVFIR2AbsState()

SVF::SVFIR2AbsState::SVFIR2AbsState ( SVFIR *  ir )

inline

Definition at line 47 of file SVFIR2AbsState.h.

: _svfir(ir) {}

Member Function Documentation

applySummary()

void SVF::SVFIR2AbsState::applySummary

(

AbstractState &

es

)

getAddrs()

AbstractValue& SVF::SVFIR2AbsState::getAddrs ( AbstractState &  es, u32_t  id  )

inline

Definition at line 102 of file SVFIR2AbsState.h.

    {
        if (inVarToAddrsTable(es, id))
            return es[id];
        else
            return globalNulladdrs;
    }

getByteOffset()

IntervalValue SVFIR2AbsState::getByteOffset	(	const AbstractState &	as,
		const GepStmt *	gep
	)

Return the byte offset expression of a GepStmt elemBytesize is the element byte size of an static alloc or heap alloc array e.g. GepStmt* gep = [i32*10], x, and x is [0,3] std::pair<s32_t, s32_t> byteOffset = getByteOffset(gep); byteOffset should be [0, 12] since i32 is 4 bytes.

This function, getByteOffset, calculates the byte offset for a given GepStmt.

Parameters

gep	The GepStmt representing the GetElementPtr instruction.

Returns

The calculated byte offset as an IntervalValue.

It is byte offset rather than flatten index. e.g. var2 = getelementptr inbounds struct.OuterStruct, struct.OuterStruct* var0, i64 0, i32 2, i32 0, i64 var1 struct.OuterStruct = type { i32, i32, struct.InnerStruct } struct.InnerStruct = type { [2 x i32] } there are 4 GepTypePairs (<0, struct.OuterStruct*>, <2, struct.OuterStruct>, <0, struct.InnerStruct>, <var1, [2xi32]>) this function process arr/ptr subtype by calculating elemByteSize * indexOperand and process struct subtype by calculating the byte offset from beginning to the field of struct e.g. for 0th pair <0, struct.OuterStruct*>, it is 0* ptrSize(struct.OuterStruct*) = 0 bytes for 1st pair <2, struct.OuterStruct>, it is 2nd field in struct.OuterStruct = 8 bytes for 2nd pair <0, struct.InnerStruct>, it is 0th field in struct.InnerStruct = 0 bytes

for 3rd pair <%var1, [2xi32]>, it is %var1'th element in array [2xi32] = 4bytes * %var1

Therefore the final byteoffset is [8+4*var1.lb(), 8+4*var1.ub()]

Definition at line 365 of file SVFIR2AbsState.cpp.

{
    IntervalValue byte_res = IntervalValue(0);
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        AccessPath::IdxOperandPair IdxVarAndType =
            gep->getOffsetVarAndGepTypePairVec()[i];
        const SVFValue *value =
            gep->getOffsetVarAndGepTypePairVec()[i].first->getValue();
        const SVFType *type = IdxVarAndType.second;
        s64_t idxLb = 0;
        s64_t idxUb = 0;
        s64_t byteLb = 0;
        s64_t byteUb = 0;
        // get lb and ub of the index value
        if (const SVFConstantInt* constInt = SVFUtil::dyn_cast<SVFConstantInt>(value))
            idxLb = idxUb = constInt->getSExtValue();
        else
        {
            IntervalValue idxItv = as[_svfir->getValueNode(value)].getInterval();
            if (idxItv.isBottom())
                idxLb = idxUb = 0;
            else
            {
                idxLb = idxItv.lb().getIntNumeral();
                idxUb = idxItv.ub().getIntNumeral();
            }
        }
        // for pointer type, elemByteSize * indexOperand
        if (SVFUtil::isa<SVFPointerType>(type))
        {
            u32_t elemByte = gep->getAccessPath().gepSrcPointeeType()->getByteSize();
            byteLb = (double)Options::MaxFieldLimit() / elemByte < idxLb? Options::MaxFieldLimit(): idxLb * elemByte;
            byteUb = (double)Options::MaxFieldLimit() / elemByte < idxUb? Options::MaxFieldLimit(): idxUb * elemByte;
 
        }
        // for array or struct, get flattened index from SymbolTable Info
        // and then calculate the byte offset from beginning to the field of struct
        else
        {
            if(Options::ModelArrays())
            {
                const std::vector<u32_t>& so = SymbolTableInfo::SymbolInfo()
                                               ->getTypeInfo(type)
                                               ->getFlattenedElemIdxVec();
                if (so.empty() || idxUb >= (APOffset)so.size() || idxLb < 0)
                {
                    byteLb = byteUb = 0;
                }
                else
                {
                    idxLb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(
                                type, idxLb);
                    idxUb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(
                                type, idxUb);
                    for (u32_t idx = 0; idx < idxLb; ++idx)
                    {
                        s64_t byte = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, idx)->getByteSize();
                        byteLb += byte;
                    }
                    byteUb = byteLb;
                    for (u32_t idx = idxLb; idx < idxUb; ++idx)
                    {
                        s64_t byte = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, idx)->getByteSize();
                        byteUb += byte;
                    }
                }
            }
            else
            {
                byteLb = byteUb = 0;
            }
 
        }
        byte_res = byte_res + IntervalValue(byteLb, byteUb);
    }
 
    if (byte_res.isBottom())
    {
        byte_res = IntervalValue(0);
    }
    return byte_res;
}

getContext()

static z3::context& SVF::SVFIR2AbsState::getContext ( )

inlinestatic

Definition at line 90 of file SVFIR2AbsState.h.

    {
        return Z3Expr::getContext();
    }

getElementIndex()

IntervalValue SVFIR2AbsState::getElementIndex	(	const AbstractState &	as,
		const GepStmt *	gep
	)

Return the offset expression of a GepStmt.

This function, getElementIndex, calculates the offset range as a pair of APOffset values for a given GepStmt.

Parameters

gep	The GepStmt representing the GetElementPtr instruction.

Returns

A pair of APOffset values representing the offset range.

Definition at line 457 of file SVFIR2AbsState.cpp.

{
    if (gep->isConstantOffset())
        return IntervalValue((s64_t)gep->accumulateConstantOffset());
    IntervalValue res = IntervalValue(0);
    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
    {
        AccessPath::IdxOperandPair IdxVarAndType =
            gep->getOffsetVarAndGepTypePairVec()[i];
        const SVFValue *value =
            gep->getOffsetVarAndGepTypePairVec()[i].first->getValue();
        const SVFType *type = IdxVarAndType.second;
        // idxLb/Ub is the flattened offset generated by the current OffsetVarAndGepTypePair
        s64_t idxLb;
        s64_t idxUb;
        // get lb and ub of the index value
        if (const SVFConstantInt* constInt = SVFUtil::dyn_cast<SVFConstantInt>(value))
            idxLb = idxUb = constInt->getSExtValue();
        else
        {
            IntervalValue idxItv = as[_svfir->getValueNode(value)].getInterval();
            if (idxItv.isBottom())
                idxLb = idxUb = 0;
            else
            {
                idxLb = idxItv.lb().getIntNumeral();
                idxUb = idxItv.ub().getIntNumeral();
            }
        }
        // for pointer type, flattened index = elemNum * idx
        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;
        }
        // for array or struct, get flattened index from SymbolTable 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;
        }
        res = res + IntervalValue(idxLb, idxUb);
    }
    res.meet_with(IntervalValue((s64_t)0, (s64_t)Options::MaxFieldLimit()));
    if (res.isBottom())
    {
        res = IntervalValue(0);
    }
    return res;
}

getFPToSIntValue()

IntervalValue SVFIR2AbsState::getFPToSIntValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 161 of file SVFIR2AbsState.cpp.

{
    // IntervalValue are BoundedInt, so we can directly return the value
    return getSExtValue(as, var);
}

getFPToUIntValue()

IntervalValue SVFIR2AbsState::getFPToUIntValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 167 of file SVFIR2AbsState.cpp.

{
    // IntervalValue are BoundedInt, so we can directly return the value
    return getZExtValue(as, var);
}

getFPTruncValue()

IntervalValue SVFIR2AbsState::getFPTruncValue	(	const AbstractState &	es,
		const SVFVar *	var,
		const SVFType *	dstType
	)

Definition at line 236 of file SVFIR2AbsState.cpp.

{
    // TODO: now we do not really handle fptrunc
    return as[var->getId()].getInterval();
}

getGepObjAddress()

AddressValue SVFIR2AbsState::getGepObjAddress	(	AbstractState &	es,
		u32_t	pointer,
		APOffset	offset
	)

Return the field address given a pointer points to a struct object and an offset.

Definition at line 328 of file SVFIR2AbsState.cpp.

{
    AbstractValue addrs = getAddrs(as, pointer);
    AddressValue ret = AddressValue();
    for (const auto &addr: addrs.getAddrs())
    {
        s64_t baseObj = getInternalID(addr);
        assert(SVFUtil::isa<ObjVar>(_svfir->getGNode(baseObj)) && "Fail to get the base object address!");
        NodeID gepObj = _svfir->getGepObjVar(baseObj, offset);
        as[gepObj] = AddressValue(AbstractState::getVirtualMemAddress(gepObj));
        ret.insert(AbstractState::getVirtualMemAddress(gepObj));
    }
    return ret;
}

getInternalID()

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

inlinestatic

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

Definition at line 168 of file SVFIR2AbsState.h.

    {
        return AbstractState::getInternalID(idx);
    }

getRangeLimitFromType()

IntervalValue SVFIR2AbsState::getRangeLimitFromType

(

const SVFType *

type

)

Return the value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127].

This function, getRangeLimitFromType, calculates the lower and upper bounds of a numeric range for a given SVFType. It is used to determine the possible value range of integer types. If the type is an SVFIntegerType, it calculates the bounds based on the size and signedness of the type. The calculated bounds are returned as an IntervalValue representing the lower (lb) and upper (ub) limits of the range.

Parameters

type	The SVFType for which to calculate the value range.

Returns

An IntervalValue representing the lower and upper bounds of the range.

Definition at line 49 of file SVFIR2AbsState.cpp.

{
    if (const SVFIntegerType* intType = SVFUtil::dyn_cast<SVFIntegerType>(type))
    {
        u32_t bits = type->getByteSize() * 8;
        s64_t ub = 0;
        s64_t lb = 0;
        if (bits >= 32)
        {
            if (intType->isSigned())
            {
                ub = static_cast<s64_t>(std::numeric_limits<s32_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<s32_t>::min());
            }
            else
            {
                ub = static_cast<s64_t>(std::numeric_limits<u32_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<u32_t>::min());
            }
        }
        else if (bits == 16)
        {
            if (intType->isSigned())
            {
                ub = static_cast<s64_t>(std::numeric_limits<s16_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<s16_t>::min());
            }
            else
            {
                ub = static_cast<s64_t>(std::numeric_limits<u16_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<u16_t>::min());
            }
        }
        else if (bits == 8)
        {
            if (intType->isSigned())
            {
                ub = static_cast<s64_t>(std::numeric_limits<int8_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<int8_t>::min());
            }
            else
            {
                ub = static_cast<s64_t>(std::numeric_limits<u_int8_t>::max());
                lb = static_cast<s64_t>(std::numeric_limits<u_int8_t>::min());
            }
        }
        return IntervalValue(lb, ub);
    }
    else if (SVFUtil::isa<SVFOtherType>(type))
    {
        // handle other type like float double, set s32_t as the range
        s64_t ub = static_cast<s64_t>(std::numeric_limits<s32_t>::max());
        s64_t lb = static_cast<s64_t>(std::numeric_limits<s32_t>::min());
        return IntervalValue(lb, ub);
    }
    else
    {
        return IntervalValue::top();
        // other types, return top interval
    }
}

getRelEs()

RelExeState& SVF::SVFIR2AbsState::getRelEs ( )

inline

Definition at line 55 of file SVFIR2AbsState.h.

    {
        return _relEs;
    }

getSExtValue()

IntervalValue SVFIR2AbsState::getSExtValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 156 of file SVFIR2AbsState.cpp.

{
    return as[var->getId()].getInterval();
}

getSIntToFPValue()

IntervalValue SVFIR2AbsState::getSIntToFPValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 173 of file SVFIR2AbsState.cpp.

{
    // IntervalValue are BoundedInt, so we can directly return the value
    return getSExtValue(as, var);
}

getTruncValue()

IntervalValue SVFIR2AbsState::getTruncValue	(	const AbstractState &	es,
		const SVFVar *	var,
		const SVFType *	dstType
	)

Definition at line 185 of file SVFIR2AbsState.cpp.

{
    const IntervalValue& itv = as[var->getId()].getInterval();
    if(itv.isBottom()) return itv;
    // get the value of ub and lb
    s64_t int_lb = itv.lb().getIntNumeral();
    s64_t int_ub = itv.ub().getIntNumeral();
    // get dst type
    u32_t dst_bits = dstType->getByteSize() * 8;
    if (dst_bits == 8)
    {
        // get the signed value of ub and lb
        int8_t s8_lb = static_cast<int8_t>(int_lb);
        int8_t s8_ub = static_cast<int8_t>(int_ub);
        if (s8_lb > s8_ub)
        {
            // return range of s8
            return IntervalValue::top();
        }
        return IntervalValue(s8_lb, s8_ub);
    }
    else if (dst_bits == 16)
    {
        // get the signed value of ub and lb
        s16_t s16_lb = static_cast<s16_t>(int_lb);
        s16_t s16_ub = static_cast<s16_t>(int_ub);
        if (s16_lb > s16_ub)
        {
            // return range of s16
            return IntervalValue::top();
        }
        return IntervalValue(s16_lb, s16_ub);
    }
    else if (dst_bits == 32)
    {
        // get the signed value of ub and lb
        s32_t s32_lb = static_cast<s32_t>(int_lb);
        s32_t s32_ub = static_cast<s32_t>(int_ub);
        if (s32_lb > s32_ub)
        {
            // return range of s32
            return IntervalValue::top();
        }
        return IntervalValue(s32_lb, s32_ub);
    }
    else
    {
        assert(false && "cannot support dst int type other than u8/16/32");
    }
}

getUIntToFPValue()

IntervalValue SVFIR2AbsState::getUIntToFPValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 179 of file SVFIR2AbsState.cpp.

{
    // IntervalValue are BoundedInt, so we can directly return the value
    return getZExtValue(as, var);
}

getVirtualMemAddress()

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

inlinestatic

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

Definition at line 174 of file SVFIR2AbsState.h.

    {
        return AbstractState::getVirtualMemAddress(idx);
    }

getZExtValue()

IntervalValue SVFIR2AbsState::getZExtValue	(	const AbstractState &	es,
		const SVFVar *	var
	)

Definition at line 111 of file SVFIR2AbsState.cpp.

{
    const SVFType* type = var->getType();
    if (SVFUtil::isa<SVFIntegerType>(type))
    {
        u32_t bits = type->getByteSize() * 8;
        if (as[var->getId()].getInterval().is_numeral())
        {
            if (bits == 8)
            {
                int8_t signed_i8_value = as[var->getId()].getInterval().getIntNumeral();
                u32_t unsigned_value = static_cast<uint8_t>(signed_i8_value);
                return IntervalValue(unsigned_value, unsigned_value);
            }
            else if (bits == 16)
            {
                s16_t signed_i16_value = as[var->getId()].getInterval().getIntNumeral();
                u32_t unsigned_value = static_cast<u16_t>(signed_i16_value);
                return IntervalValue(unsigned_value, unsigned_value);
            }
            else if (bits == 32)
            {
                s32_t signed_i32_value = as[var->getId()].getInterval().getIntNumeral();
                u32_t unsigned_value = static_cast<u32_t>(signed_i32_value);
                return IntervalValue(unsigned_value, unsigned_value);
            }
            else if (bits == 64)
            {
                s64_t signed_i64_value = as[var->getId()].getInterval().getIntNumeral();
                return IntervalValue((s64_t)signed_i64_value, (s64_t)signed_i64_value);
                // we only support i64 at most
            }
            else
            {
                assert(false && "cannot support int type other than u8/16/32/64");
            }
        }
        else
        {
            return IntervalValue::top(); // TODO: may have better solution
        }
    }
    return IntervalValue::top(); // TODO: may have better solution
}

handleAddr()

void SVFIR2AbsState::handleAddr	(	AbstractState &	es,
		const AddrStmt *	addr
	)

Definition at line 563 of file SVFIR2AbsState.cpp.

{
    initObjVar(as, SVFUtil::cast<ObjVar>(addr->getRHSVar()));
    if (addr->getRHSVar()->getType()->getKind() == SVFType::SVFIntegerTy)
        as[addr->getRHSVarID()].getInterval().meet_with(getRangeLimitFromType(addr->getRHSVar()->getType()));
    as[addr->getLHSVarID()] = as[addr->getRHSVarID()];
}

handleBinary()

void SVFIR2AbsState::handleBinary	(	AbstractState &	es,
		const BinaryOPStmt *	binary
	)

Definition at line 572 of file SVFIR2AbsState.cpp.

{
    u32_t op0 = binary->getOpVarID(0);
    u32_t op1 = binary->getOpVarID(1);
    u32_t res = binary->getResID();
    if (!inVarToValTable(as, op0)) as[op0] = IntervalValue::top();
    if (!inVarToValTable(as, op1)) as[op1] = IntervalValue::top();
    IntervalValue &lhs = as[op0].getInterval(), &rhs = as[op1].getInterval();
    IntervalValue resVal;
    switch (binary->getOpcode())
    {
    case BinaryOPStmt::Add:
    case BinaryOPStmt::FAdd:
        resVal = (lhs + rhs);
        break;
    case BinaryOPStmt::Sub:
    case BinaryOPStmt::FSub:
        resVal = (lhs - rhs);
        break;
    case BinaryOPStmt::Mul:
    case BinaryOPStmt::FMul:
        resVal = (lhs * rhs);
        break;
    case BinaryOPStmt::SDiv:
    case BinaryOPStmt::FDiv:
    case BinaryOPStmt::UDiv:
        resVal = (lhs / rhs);
        break;
    case BinaryOPStmt::SRem:
    case BinaryOPStmt::FRem:
    case BinaryOPStmt::URem:
        resVal = (lhs % rhs);
        break;
    case BinaryOPStmt::Xor:
        resVal = (lhs ^ rhs);
        break;
    case BinaryOPStmt::And:
        resVal = (lhs & rhs);
        break;
    case BinaryOPStmt::Or:
        resVal = (lhs | rhs);
        break;
    case BinaryOPStmt::AShr:
        resVal = (lhs >> rhs);
        break;
    case BinaryOPStmt::Shl:
        resVal = (lhs << rhs);
        break;
    case BinaryOPStmt::LShr:
        resVal = (lhs >> rhs);
        break;
    default:
        assert(false && "undefined binary: ");
    }
    as[res] = resVal;
}

handleCall()

void SVFIR2AbsState::handleCall	(	AbstractState &	es,
		const CallPE *	callPE
	)

Definition at line 945 of file SVFIR2AbsState.cpp.

{
    NodeID lhs = callPE->getLHSVarID();
    NodeID rhs = callPE->getRHSVarID();
    as[lhs] = as[rhs];
}

handleCmp()

void SVFIR2AbsState::handleCmp	(	AbstractState &	es,
		const CmpStmt *	cmp
	)

Definition at line 629 of file SVFIR2AbsState.cpp.

{
    u32_t op0 = cmp->getOpVarID(0);
    u32_t op1 = cmp->getOpVarID(1);
    if (!inVarToValTable(as, op0)) as[op0] = IntervalValue::top();
    if (!inVarToValTable(as, op1)) as[op1] = IntervalValue::top();
    u32_t res = cmp->getResID();
    if (inVarToValTable(as, op0) && inVarToValTable(as, op1))
    {
        IntervalValue resVal;
        IntervalValue &lhs = as[op0].getInterval(), &rhs = as[op1].getInterval();
        //AbstractValue
        auto predicate = cmp->getPredicate();
        switch (predicate)
        {
        case CmpStmt::ICMP_EQ:
        case CmpStmt::FCMP_OEQ:
        case CmpStmt::FCMP_UEQ:
            resVal = (lhs == rhs);
            // resVal = (lhs.getInterval() == rhs.getInterval());
            break;
        case CmpStmt::ICMP_NE:
        case CmpStmt::FCMP_ONE:
        case CmpStmt::FCMP_UNE:
            resVal = (lhs != rhs);
            break;
        case CmpStmt::ICMP_UGT:
        case CmpStmt::ICMP_SGT:
        case CmpStmt::FCMP_OGT:
        case CmpStmt::FCMP_UGT:
            resVal = (lhs > rhs);
            break;
        case CmpStmt::ICMP_UGE:
        case CmpStmt::ICMP_SGE:
        case CmpStmt::FCMP_OGE:
        case CmpStmt::FCMP_UGE:
            resVal = (lhs >= rhs);
            break;
        case CmpStmt::ICMP_ULT:
        case CmpStmt::ICMP_SLT:
        case CmpStmt::FCMP_OLT:
        case CmpStmt::FCMP_ULT:
            resVal = (lhs < rhs);
            break;
        case CmpStmt::ICMP_ULE:
        case CmpStmt::ICMP_SLE:
        case CmpStmt::FCMP_OLE:
        case CmpStmt::FCMP_ULE:
            resVal = (lhs <= rhs);
            break;
        case CmpStmt::FCMP_FALSE:
            resVal = IntervalValue(0, 0);
            break;
        case CmpStmt::FCMP_TRUE:
            resVal = IntervalValue(1, 1);
            break;
        default:
        {
            assert(false && "undefined compare: ");
        }
        }
        as[res] = resVal;
    }
    else if (inVarToAddrsTable(as, op0) && inVarToAddrsTable(as, op1))
    {
        IntervalValue resVal;
        AbstractValue &lhs = getAddrs(as, op0), &rhs = getAddrs(as, op1);
        auto predicate = cmp->getPredicate();
        switch (predicate)
        {
        case CmpStmt::ICMP_EQ:
        case CmpStmt::FCMP_OEQ:
        case CmpStmt::FCMP_UEQ:
        {
            if (lhs.getAddrs().hasIntersect(rhs.getAddrs()))
            {
                resVal = IntervalValue(0, 1);
            }
            else if (lhs.getAddrs().empty() && rhs.getAddrs().empty())
            {
                resVal = IntervalValue(1, 1);
            }
            else
            {
                resVal = IntervalValue(0, 0);
            }
            break;
        }
        case CmpStmt::ICMP_NE:
        case CmpStmt::FCMP_ONE:
        case CmpStmt::FCMP_UNE:
        {
            if (lhs.getAddrs().hasIntersect(rhs.getAddrs()))
            {
                resVal = IntervalValue(0, 1);
            }
            else if (lhs.getAddrs().empty() && rhs.getAddrs().empty())
            {
                resVal = IntervalValue(0, 0);
            }
            else
            {
                resVal = IntervalValue(1, 1);
            }
            break;
        }
        case CmpStmt::ICMP_UGT:
        case CmpStmt::ICMP_SGT:
        case CmpStmt::FCMP_OGT:
        case CmpStmt::FCMP_UGT:
        {
            if (lhs.getAddrs().size() == 1 && rhs.getAddrs().size() == 1)
            {
                resVal = IntervalValue(*lhs.getAddrs().begin() > *rhs.getAddrs().begin());
            }
            else
            {
                resVal = IntervalValue(0, 1);
            }
            break;
        }
        case CmpStmt::ICMP_UGE:
        case CmpStmt::ICMP_SGE:
        case CmpStmt::FCMP_OGE:
        case CmpStmt::FCMP_UGE:
        {
            if (lhs.getAddrs().size() == 1 && rhs.getAddrs().size() == 1)
            {
                resVal = IntervalValue(*lhs.getAddrs().begin() >= *rhs.getAddrs().begin());
            }
            else
            {
                resVal = IntervalValue(0, 1);
            }
            break;
        }
        case CmpStmt::ICMP_ULT:
        case CmpStmt::ICMP_SLT:
        case CmpStmt::FCMP_OLT:
        case CmpStmt::FCMP_ULT:
        {
            if (lhs.getAddrs().size() == 1 && rhs.getAddrs().size() == 1)
            {
                resVal = IntervalValue(*lhs.getAddrs().begin() < *rhs.getAddrs().begin());
            }
            else
            {
                resVal = IntervalValue(0, 1);
            }
            break;
        }
        case CmpStmt::ICMP_ULE:
        case CmpStmt::ICMP_SLE:
        case CmpStmt::FCMP_OLE:
        case CmpStmt::FCMP_ULE:
        {
            if (lhs.getAddrs().size() == 1 && rhs.getAddrs().size() == 1)
            {
                resVal = IntervalValue(*lhs.getAddrs().begin() <= *rhs.getAddrs().begin());
            }
            else
            {
                resVal = IntervalValue(0, 1);
            }
            break;
        }
        case CmpStmt::FCMP_FALSE:
            resVal = IntervalValue(0, 0);
            break;
        case CmpStmt::FCMP_TRUE:
            resVal = IntervalValue(1, 1);
            break;
        default:
        {
            assert(false && "undefined compare: ");
        }
        }
        as[res] = resVal;
    }
}

handleCopy()

void SVFIR2AbsState::handleCopy	(	AbstractState &	es,
		const CopyStmt *	copy
	)

Definition at line 833 of file SVFIR2AbsState.cpp.

{
    u32_t lhs = copy->getLHSVarID();
    u32_t rhs = copy->getRHSVarID();
 
    if (copy->getCopyKind() == CopyStmt::COPYVAL)
    {
        as[lhs] = as[rhs];
    }
    else if (copy->getCopyKind() == CopyStmt::ZEXT)
    {
        as[lhs] = getZExtValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::SEXT)
    {
        as[lhs] = getSExtValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::FPTOSI)
    {
        as[lhs] = getFPToSIntValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::FPTOUI)
    {
        as[lhs] = getFPToUIntValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::SITOFP)
    {
        as[lhs] = getSIntToFPValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::UITOFP)
    {
        as[lhs] = getUIntToFPValue(as, copy->getRHSVar());
    }
    else if (copy->getCopyKind() == CopyStmt::TRUNC)
    {
        as[lhs] = getTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
    }
    else if (copy->getCopyKind() == CopyStmt::FPTRUNC)
    {
        as[lhs] = getFPTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
    }
    else if (copy->getCopyKind() == CopyStmt::INTTOPTR)
    {
        //insert nullptr
    }
    else if (copy->getCopyKind() == CopyStmt::PTRTOINT)
    {
        as[lhs] = IntervalValue::top();
    }
    else if (copy->getCopyKind() == CopyStmt::BITCAST)
    {
        if (as[rhs].isAddr())
        {
            as[lhs] = as[rhs];
        }
        else
        {
            // do nothing
        }
    }
    else
    {
        assert(false && "undefined copy kind");
        abort();
    }
}

handleGep()

void SVFIR2AbsState::handleGep	(	AbstractState &	es,
		const GepStmt *	gep
	)

Definition at line 900 of file SVFIR2AbsState.cpp.

{
    u32_t rhs = gep->getRHSVarID();
    u32_t lhs = gep->getLHSVarID();
    IntervalValue offsetPair = getElementIndex(as, gep);
    AbstractValue gepAddrs;
    APOffset lb = offsetPair.lb().getIntNumeral() < Options::MaxFieldLimit()?
                  offsetPair.lb().getIntNumeral(): Options::MaxFieldLimit();
    APOffset ub = offsetPair.ub().getIntNumeral() < Options::MaxFieldLimit()?
                  offsetPair.ub().getIntNumeral(): Options::MaxFieldLimit();
    for (APOffset i = lb; i <= ub; i++)
        gepAddrs.join_with(getGepObjAddress(as, rhs, i));
    as[lhs] = gepAddrs;
}

handleLoad()

void SVFIR2AbsState::handleLoad	(	AbstractState &	es,
		const LoadStmt *	load
	)

Definition at line 810 of file SVFIR2AbsState.cpp.

{
    u32_t rhs = load->getRHSVarID();
    u32_t lhs = load->getLHSVarID();
    AbstractValue &addrs = as[rhs];
    AbstractValue rhsVal; // interval::bottom Address::bottom
    // AbstractValue absRhs
    for (const auto &addr: addrs.getAddrs())
        rhsVal.join_with(as.load(addr));
    as[lhs] = rhsVal;
}

handlePhi()

void SVFIR2AbsState::handlePhi	(	AbstractState &	es,
		const PhiStmt *	phi
	)

Definition at line 932 of file SVFIR2AbsState.cpp.

{
    u32_t res = phi->getResID();
    AbstractValue rhs;
    for (u32_t i = 0; i < phi->getOpVarNum(); i++)
    {
        NodeID curId = phi->getOpVarID(i);
        rhs.join_with(as[curId]);
    }
    as[res] = rhs;
}

handleRet()

void SVFIR2AbsState::handleRet	(	AbstractState &	es,
		const RetPE *	retPE
	)

Definition at line 952 of file SVFIR2AbsState.cpp.

{
    NodeID lhs = retPE->getLHSVarID();
    NodeID rhs = retPE->getRHSVarID();
    as[lhs] = as[rhs];
}

handleSelect()

void SVFIR2AbsState::handleSelect	(	AbstractState &	es,
		const SelectStmt *	select
	)

Definition at line 915 of file SVFIR2AbsState.cpp.

{
    u32_t res = select->getResID();
    u32_t tval = select->getTrueValue()->getId();
    u32_t fval = select->getFalseValue()->getId();
    u32_t cond = select->getCondition()->getId();
    if (as[cond].getInterval().is_numeral())
    {
        as[res] = as[cond].getInterval().is_zero() ? as[fval] : as[tval];
    }
    else
    {
        as[res] = as[tval];
        as[res].join_with(as[fval]);
    }
}

handleStore()

void SVFIR2AbsState::handleStore	(	AbstractState &	es,
		const StoreStmt *	store
	)

Definition at line 822 of file SVFIR2AbsState.cpp.

{
    u32_t rhs = store->getRHSVarID();
    u32_t lhs = store->getLHSVarID();
 
    for (const auto &addr: as[lhs].getAddrs())
    {
        as.store(addr, as[rhs]);
    }
}

inAddrTable()

bool SVF::SVFIR2AbsState::inAddrTable ( const AbstractState &  es, u32_t  id  ) const

inline

Definition at line 115 of file SVFIR2AbsState.h.

    {
        return es.inAddrToValTable(id) || es.inAddrToAddrsTable(id);
    }

initObjVar()

void SVFIR2AbsState::initObjVar	(	AbstractState &	as,
		const ObjVar *	var
	)

Init ObjVar.

constant data

Definition at line 527 of file SVFIR2AbsState.cpp.

{
    NodeID varId = var->getId();
    if (var->hasValue())
    {
        const MemObj *obj = var->getMemObj();
        if (obj->isConstDataOrConstGlobal() || obj->isConstantArray() || obj->isConstantStruct())
        {
            if (const SVFConstantInt *consInt = SVFUtil::dyn_cast<SVFConstantInt>(obj->getValue()))
            {
                s64_t numeral = consInt->getSExtValue();
                as[varId] = IntervalValue(numeral, numeral);
            }
            else if (const SVFConstantFP* consFP = SVFUtil::dyn_cast<SVFConstantFP>(obj->getValue()))
                as[varId] = IntervalValue(consFP->getFPValue(), consFP->getFPValue());
            else if (SVFUtil::isa<SVFConstantNullPtr>(obj->getValue()))
                as[varId] = IntervalValue(0, 0);
            else if (SVFUtil::isa<SVFGlobalValue>(obj->getValue()))
            {
                as[varId] = AddressValue(getVirtualMemAddress(varId));
            }
 
            else if (obj->isConstantArray() || obj->isConstantStruct())
                as[varId] = IntervalValue::top();
            else
                as[varId] = IntervalValue::top();
        }
        else
            as[varId] = AddressValue(getVirtualMemAddress(varId));
    }
    else
        as[varId] = AddressValue(getVirtualMemAddress(varId));
}

inLocToAddrsTable()

bool SVF::SVFIR2AbsState::inLocToAddrsTable ( const AbstractState &  es, u32_t  id  ) const

inline

whether the memory address stores memory addresses

Definition at line 140 of file SVFIR2AbsState.h.

    {
        return es.inAddrToAddrsTable(id);
    }

inLocToValTable()

bool SVF::SVFIR2AbsState::inLocToValTable ( const AbstractState &  es, u32_t  id  ) const

inline

whether the memory address stores a interval value

Definition at line 134 of file SVFIR2AbsState.h.

    {
        return es.inAddrToValTable(id);
    }

inVarTable()

bool SVF::SVFIR2AbsState::inVarTable ( const AbstractState &  es, u32_t  id  ) const

inline

Definition at line 110 of file SVFIR2AbsState.h.

    {
        return es.inVarToValTable(id) || es.inVarToAddrsTable(id);
    }

inVarToAddrsTable()

bool SVF::SVFIR2AbsState::inVarToAddrsTable ( const AbstractState &  es, u32_t  id  ) const

inline

whether the variable is in varToAddrs table

Definition at line 127 of file SVFIR2AbsState.h.

    {
        return es.inVarToAddrsTable(id);
    }

inVarToValTable()

bool SVF::SVFIR2AbsState::inVarToValTable ( const AbstractState &  es, u32_t  id  ) const

inline

whether the variable is in varToVal table

Definition at line 121 of file SVFIR2AbsState.h.

    {
        return es.inVarToValTable(id);
    }

isVirtualMemAddress()

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

inlinestatic

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

Definition at line 180 of file SVFIR2AbsState.h.

    {
        return AbstractState::isVirtualMemAddress(val);
    }

narrowAddrs()

void SVFIR2AbsState::narrowAddrs	(	AbstractState &	es,
		AbstractState &	lhs,
		const AbstractState &	rhs
	)

Definition at line 288 of file SVFIR2AbsState.cpp.

{
    for (const auto &rhsItem: rhs._varToAbsVal)
    {
        auto lhsIter = lhs._varToAbsVal.find(rhsItem.first);
        if (lhsIter != lhs._varToAbsVal.end())
        {
            if (lhsIter->second.isAddr())
            {
                for (const auto &addr: lhsIter->second.getAddrs())
                {
                    if (!rhsItem.second.getAddrs().contains(addr))
                    {
                        lhsIter->second = rhsItem.second;
                        break;
                    }
                }
            }
        }
    }
    for (const auto &rhsItem: rhs._addrToAbsVal)
    {
        auto lhsIter = lhs._addrToAbsVal.find(rhsItem.first);
        if (lhsIter != lhs._addrToAbsVal.end())
        {
            if (lhsIter->second.isAddr())
            {
                for (const auto& addr : lhsIter->second.getAddrs())
                {
                    if (!rhsItem.second.getAddrs().contains(addr))
                    {
                        lhsIter->second = rhsItem.second;
                        break;
                    }
                }
            }
        }
    }
}

setRelEs()

void SVF::SVFIR2AbsState::setRelEs ( const RelExeState &  relEs )

inline

Definition at line 50 of file SVFIR2AbsState.h.

    {
        _relEs = relEs;
    }

widenAddrs()

void SVFIR2AbsState::widenAddrs	(	AbstractState &	es,
		AbstractState &	lhs,
		const AbstractState &	rhs
	)

Definition at line 242 of file SVFIR2AbsState.cpp.

{
    for (const auto &rhsItem: rhs._varToAbsVal)
    {
        auto lhsIter = lhs._varToAbsVal.find(rhsItem.first);
        if (lhsIter != lhs._varToAbsVal.end())
        {
            if (rhsItem.second.isAddr())
            {
                for (const auto &addr: rhsItem.second.getAddrs())
                {
                    if (!lhsIter->second.getAddrs().contains(addr))
                    {
                        for (s32_t i = 0; i < (s32_t) Options::MaxFieldLimit(); i++)
                        {
                            lhsIter->second.join_with(getGepObjAddress(as, getInternalID(addr), i));
                        }
                    }
                }
            }
        }
    }
    for (const auto &rhsItem: rhs._addrToAbsVal)
    {
        auto lhsIter = lhs._addrToAbsVal.find(rhsItem.first);
        if (lhsIter != lhs._addrToAbsVal.end())
        {
            if (rhsItem.second.isAddr())
            {
                for (const auto& addr : rhsItem.second.getAddrs())
                {
                    if (!lhsIter->second.getAddrs().contains(addr))
                    {
                        for (s32_t i = 0; i < (s32_t)Options::MaxFieldLimit();
                                i++)
                        {
                            lhsIter->second.join_with(
                                getGepObjAddress(as, getInternalID(addr), i));
                        }
                    }
                }
            }
        }
    }
}

Member Data Documentation

_relEs

RelExeState SVF::SVFIR2AbsState::_relEs

private

Definition at line 187 of file SVFIR2AbsState.h.

_svfir

SVFIR* SVF::SVFIR2AbsState::_svfir

private

Definition at line 186 of file SVFIR2AbsState.h.

globalNulladdrs

AbstractValue SVF::SVFIR2AbsState::globalNulladdrs = AddressValue()

static

Definition at line 45 of file SVFIR2AbsState.h.

---

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

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