SVF::LocSymTableInfo Class Reference

#include <SymbolTableInfo.h>

Inheritance diagram for SVF::LocSymTableInfo:

Public Member Functions
	LocSymTableInfo ()
	Constructor. More...
virtual	~LocSymTableInfo ()
	Destructor. More...
virtual bool	computeGepOffset (const User *V, LocationSet &ls)
	Compute gep offset. More...
virtual LocationSet	getModulusOffset (const MemObj *obj, const LocationSet &ls)
	Given an offset from a Gep Instruction, return it modulus offset by considering memory layout. More...
void	verifyStructSize (StInfo *stInfo, u32_t structSize)
	Verify struct size construction. More...
Public Member Functions inherited from SVF::SymbolTableInfo
SVFModule *	getModule ()
	Module. More...
void	buildMemModel (SVFModule *svfModule)
	Start building memory model. More...
const Type *	getBaseTypeAndFlattenedFields (const Value *V, std::vector< LocationSet > &fields)
	Get the base type and max offset. More...
u32_t	getFields (std::vector< LocationSet > &fields, const Type *T, u32_t msz)
	Replace fields with flatten fields of T if the number of its fields is larger than msz. More...
void	collectTypeInfo (const Type *T)
	Collect type info. More...
void	printFlattenFields (const Type *type)
	Debug method. More...
virtual void	dump ()
	Another debug method. More...
void	setModelConstants (bool _modelConstants)
	Set / Get modelConstants. More...
bool	getModelConstants () const
const CallSiteSet &	getCallSiteSet () const
	Get callsite set. More...
u32_t	getTypeSizeInBytes (const Type *type)
	Helper method to get the size of the type from target data layout. More...
u32_t	getTypeSizeInBytes (const StructType *sty, u32_t field_index)
void	collectSym (const Value *val)
	collect the syms More...
void	collectVal (const Value *val)
void	collectObj (const Value *val)
void	collectRet (const Function *val)
void	collectVararg (const Function *val)
void	handleGlobalCE (const GlobalVariable *G)
	Handle constant expression. More...
void	handleGlobalInitializerCE (const Constant *C, u32_t offset)
void	handleCE (const Value *val)
SymID	getValSym (const Value *val)
	Get different kinds of syms. More...
bool	hasValSym (const Value *val)
const Value *	getGlobalRep (const Value *val) const
	find the unique defined global across multiple modules More...
SymID	getObjSym (const Value *val) const
MemObj *	getObj (SymID id) const
SymID	getRetSym (const Function *val) const
SymID	getVarargSym (const Function *val) const
Size_t	getTotalSymNum () const
	Statistics. More...
u32_t	getMaxStructSize () const
ValueToIDMapTy &	valSyms ()
	Get different kinds of syms maps. More...
ValueToIDMapTy &	objSyms ()
IDToMemMapTy &	idToObjMap ()
FunToIDMapTy &	retSyms ()
FunToIDMapTy &	varargSyms ()
TypeToFieldInfoMap::iterator	getStructInfoIter (const Type *T)
	Get struct info. More...
StInfo *	getStructInfo (const Type *T)
	Get a reference to StructInfo. More...
const std::vector< u32_t > &	getFattenFieldIdxVec (const Type *T)
	Get a reference to the components of struct_info. More...
const std::vector< u32_t > &	getFattenFieldOffsetVec (const Type *T)
const std::vector< FieldInfo > &	getFlattenFieldInfoVec (const Type *T)
const Type *	getOrigSubTypeWithFldInx (const Type *baseType, u32_t field_idx)
const Type *	getOrigSubTypeWithByteOffset (const Type *baseType, u32_t byteOffset)
virtual	~SymbolTableInfo ()
bool	isConstantObjSym (const Value *val)
void	createBlkOrConstantObj (SymID symId)
MemObj *	getBlkObj () const
MemObj *	getConstantObj () const
SymID	blkPtrSymID () const
SymID	nullPtrSymID () const
SymID	constantSymID () const
SymID	blackholeSymID () const
const MemObj *	createDummyObj (SymID symId, const Type *type)
	Can only be invoked by PAG::addDummyNode() when creaing PAG from file. More...

Protected Member Functions
virtual void	collectStructInfo (const StructType *T)
	Collect the struct info. More...
virtual void	collectArrayInfo (const ArrayType *T)
	Collect the array info. More...
Protected Member Functions inherited from SVF::SymbolTableInfo
	SymbolTableInfo (void)
	Constructor. More...
virtual void	collectSimpleTypeInfo (const Type *T)
	Collect simple type (non-aggregate) info. More...

Additional Inherited Members
Public Types inherited from SVF::SymbolTableInfo
typedef OrderedMap< const Value *, SymID >	ValueToIDMapTy
	various maps defined More...
typedef OrderedMap< SymID, MemObj * >	IDToMemMapTy
	sym id to memory object map More...
typedef OrderedMap< const Function *, SymID >	FunToIDMapTy
	function to sym id map More...
typedef OrderedMap< SymID, SYMTYPE >	IDToSymTyMapTy
	sym id to sym type map More...
typedef OrderedMap< const Type *, StInfo * >	TypeToFieldInfoMap
	struct type to struct info map More...
typedef Set< CallSite >	CallSiteSet
typedef OrderedMap< const Instruction *, CallSiteID >	CallSiteToIDMapTy
typedef OrderedMap< CallSiteID, const Instruction * >	IDToCallSiteMapTy
Static Public Member Functions inherited from SVF::SymbolTableInfo
static DataLayout *	getDataLayout (Module *mod)
	Get target machine data layout. More...
static std::string	toString (SYMTYPE symtype)
static SymbolTableInfo *	SymbolInfo ()
	Singleton design here to make sure we only have one instance during any analysis. More...
static void	releaseSymbolInfo ()
static bool	isNullPtrSym (const Value *val)
	special value More...
static bool	isBlackholeSym (const Value *val)
static bool	isBlkPtr (NodeID id)
static bool	isNullPtr (NodeID id)
static bool	isBlkObj (NodeID id)
static bool	isConstantObj (NodeID id)
static bool	isBlkObjOrConstantObj (NodeID id)
Protected Attributes inherited from SVF::SymbolTableInfo
TypeToFieldInfoMap	typeToFieldInfo
const Type *	maxStruct
	The struct type with the most fields. More...
u32_t	maxStSize
	The number of fields in max_struct. More...

Detailed Description

Bytes/bits-level modeling of memory locations to handle weakly type languages. (declared with one type but accessed as another) Abstract memory objects are created according to the static allocated size.

Definition at line 460 of file SymbolTableInfo.h.

Constructor & Destructor Documentation

LocSymTableInfo()

SVF::LocSymTableInfo::LocSymTableInfo ( )

inline

Constructor.

Definition at line 465 of file SymbolTableInfo.h.

    {
    }

~LocSymTableInfo()

virtual SVF::LocSymTableInfo::~LocSymTableInfo ( )

inlinevirtual

Destructor.

Definition at line 469 of file SymbolTableInfo.h.

    {
    }

Member Function Documentation

collectArrayInfo()

void LocSymTableInfo::collectArrayInfo ( const ArrayType *  T )

protectedvirtual

Collect the array info.

Collect array information

Reimplemented from SVF::SymbolTableInfo.

Definition at line 400 of file MemModel.cpp.

{
    /*
    StInfo *stinfo = new StInfo();
    typeToFieldInfo[ty] = stinfo;

    u64_t out_num = ty->getNumElements();
    const Type* elemTy = ty->getElementType();
    u32_t out_stride = getTypeSizeInBytes(elemTy);

    stinfo->addOffsetWithType(0, elemTy);

    while (const ArrayType* aty = dyn_cast<ArrayType>(elemTy)) {
        out_num *= aty->getNumElements();
        elemTy = aty->getElementType();
        out_stride = getTypeSizeInBytes(elemTy);
    }

    StInfo* elemStInfo = getStructInfo(elemTy);
    u32_t nfE = elemStInfo->getFlattenFieldInfoVec().size();
    for (u32_t j = 0; j < nfE; j++) {
        u32_t off = elemStInfo->getFlattenFieldInfoVec()[j].getFlattenOffset();
        const Type* fieldTy = elemStInfo->getFlattenFieldInfoVec()[j].getFlattenElemTy();
        FieldInfo::ElemNumStridePairVec pair = elemStInfo->getFlattenFieldInfoVec()[j].getElemNumStridePairVect();
        pair.push_back(std::make_pair(out_num, out_stride));
        FieldInfo field(off, fieldTy, pair);
        stinfo->getFlattenFieldInfoVec().push_back(field);
    }
    */
}

collectStructInfo()

void LocSymTableInfo::collectStructInfo ( const StructType *  T )

protectedvirtual

Collect the struct info.

Reimplemented from SVF::SymbolTableInfo.

Definition at line 443 of file MemModel.cpp.

{
    /*
    StInfo *stinfo = new StInfo();
    typeToFieldInfo[ty] = stinfo;

    const StructLayout *stTySL = getDataLayout(getModule().getMainLLVMModule())->getStructLayout( const_cast<StructType *>(ty) );

    u32_t field_idx = 0;
    for (StructType::element_iterator it = ty->element_begin(), ie =
                ty->element_end(); it != ie; ++it, ++field_idx) {
        const Type *et = *it;

        // The offset is where this element will be placed in the struct.
        // This offset is computed after alignment with the current struct
        u64_t eOffsetInBytes = stTySL->getElementOffset(field_idx);

        //The offset is where this element will be placed in the exp. struct.
        stinfo->addOffsetWithType(static_cast<u32_t>(eOffsetInBytes), et);

        StInfo* fieldStinfo = getStructInfo(et);
        u32_t nfE = fieldStinfo->getFlattenFieldInfoVec().size();
        //Copy ST's info, whose element 0 is the size of ST itself.
        for (u32_t j = 0; j < nfE; j++) {
            u32_t oft = eOffsetInBytes + fieldStinfo->getFlattenFieldInfoVec()[j].getFlattenOffset();
            const Type* elemTy = fieldStinfo->getFlattenFieldInfoVec()[j].getFlattenElemTy();
            FieldInfo::ElemNumStridePairVec pair = fieldStinfo->getFlattenFieldInfoVec()[j].getElemNumStridePairVect();
            pair.push_back(std::make_pair(1, 0));
            FieldInfo newField(oft, elemTy, pair);
            stinfo->getFlattenFieldInfoVec().push_back(newField);
        }
    }

    //  verifyStructSize(stinfo,stTySL->getSizeInBytes());

    //Record the size of the complete struct and update max_struct.
    if (stTySL->getSizeInBytes() > maxStSize) {
        maxStruct = ty;
        maxStSize = stTySL->getSizeInBytes();
    }
    */
}

computeGepOffset()

bool LocSymTableInfo::computeGepOffset ( const User *  V, LocationSet &  ls  )

virtual

Compute gep offset.

Compute gep offset

variant offset

Reimplemented from SVF::SymbolTableInfo.

Definition at line 305 of file MemModel.cpp.

{

    assert(V);
    int baseIndex = -1;
    int index = 0;
    for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
            gi != ge; ++gi, ++index)
    {
        if(SVFUtil::isa<ConstantInt>(gi.getOperand()) == false)
            baseIndex = index;
    }

    index = 0;
    for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
            gi != ge; ++gi, ++index)
    {

        if (index <= baseIndex)
        {
            // Handling pointer types
            if (const PointerType* pty = SVFUtil::dyn_cast<PointerType>(*gi))
            {
                const Type* et = pty->getElementType();
                Size_t sz = getTypeSizeInBytes(et);

                Size_t num = 1;
                if (const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(et))
                    num = aty->getNumElements();
                else
                    num = StInfo::getMaxFieldLimit();

                ls.addElemNumStridePair(std::make_pair(num, sz));
            }
            // Calculate the size of the array element
            else if(const ArrayType* at = SVFUtil::dyn_cast<ArrayType>(*gi))
            {
                const Type* et = at->getElementType();
                Size_t sz = getTypeSizeInBytes(et);
                Size_t num = at->getNumElements();
                ls.addElemNumStridePair(std::make_pair(num, sz));
            }
            else
                assert(false && "what other types?");
        }
        // constant offset
        else
        {
            assert(SVFUtil::isa<ConstantInt>(gi.getOperand()) && "expecting a constant");

            ConstantInt *op = SVFUtil::cast<ConstantInt>(gi.getOperand());

            //The actual index
            Size_t idx = op->getSExtValue();

            // Handling pointer types
            // These GEP instructions are simply making address computations from the base pointer address
            // e.g. idx1 = (char*) &MyVar + 4,  at this case gep only one offset index (idx)
            if (const PointerType* pty = SVFUtil::dyn_cast<PointerType>(*gi))
            {
                const Type* et = pty->getElementType();
                Size_t sz = getTypeSizeInBytes(et);
                ls.setByteOffset(ls.getByteOffset() + idx * sz);
            }
            // Calculate the size of the array element
            else if(const ArrayType* at = SVFUtil::dyn_cast<ArrayType>(*gi))
            {
                const Type* et = at->getElementType();
                Size_t sz = getTypeSizeInBytes(et);
                ls.setByteOffset(ls.getByteOffset() + idx * sz);
            }
            // Handling struct here
            else if (const StructType *ST = SVFUtil::dyn_cast<StructType>(*gi))
            {
                assert(op && "non-const struct index in GEP");
                const vector<u32_t> &so = SymbolTableInfo::SymbolInfo()->getFattenFieldOffsetVec(ST);
                if ((unsigned)idx >= so.size())
                {
                    outs() << "!! Struct index out of bounds" << idx << "\n";
                    assert(0);
                }
                //add the translated offset
                ls.setByteOffset(ls.getByteOffset() + so[idx]);
            }
            else
                assert(false && "what other types?");
        }
    }
    return true;
}

getModulusOffset()

LocationSet LocSymTableInfo::getModulusOffset ( const MemObj *  obj, const LocationSet &  ls  )

virtual

Given an offset from a Gep Instruction, return it modulus offset by considering memory layout.

Given LocationSet from a Gep Instruction, return a new LocationSet which matches the field information of this ObjTypeInfo by considering memory layout

Find an appropriate field for this LocationSet

This location set represent one object

if the offset is negative, it's possible that we're looking for an obj node out of range of current struct. Make the offset positive so we can still get a node within current struct to represent this obj.

This location set represents multiple objects

Reimplemented from SVF::SymbolTableInfo.

Definition at line 493 of file MemModel.cpp.

{
    const Type* ety = obj->getType();

    if (SVFUtil::isa<StructType>(ety) || SVFUtil::isa<ArrayType>(ety))
    {
        const std::vector<FieldInfo>& infovec = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(ety);
        std::vector<FieldInfo>::const_iterator it = infovec.begin();
        std::vector<FieldInfo>::const_iterator eit = infovec.end();
        for (; it != eit; ++it)
        {
            const FieldInfo& fieldLS = *it;
            LocationSet rhsLS(fieldLS);
            LocationSet::LSRelation result = LocationSet::checkRelation(ls, rhsLS);
            if (result == LocationSet::Same ||
                    result == LocationSet::Superset ||
                    result == LocationSet::Subset)
                return ls;
            else if (result == LocationSet::Overlap)
            {
                // TODO:
                return ls;
            }
            else if (result == LocationSet::NonOverlap)
            {
                continue;
            }

            assert(false && "cannot find an appropriate field for specified LocationSet");
            return ls;
        }
    }
    else
    {
        if (obj->isStaticObj() || obj->isHeap())
        {
            // TODO: Objects which cannot find proper field for a certain offset including
            //       arguments in main(), static objects allocated before main and heap
            //       objects. Right now they're considered to have infinite fields. So we
            //       just return the location set without modifying it.
            return ls;
        }
        else
        {
            // TODO: Using new memory model (locMM) may create objects with spurious offset
            //       as we simply return new offset by mod operation without checking its
            //       correctness in LocSymTableInfo::getModulusOffset(). So the following
            //       assertion may fail. Try to refine the new memory model.
            assert(ls.isConstantOffset() && "expecting a constant location set");
            return ls;
        }
    }

    if (ls.isConstantOffset())
    {
        Size_t offset = ls.getOffset();
        if(offset < 0)
        {
            writeWrnMsg("try to create a gep node with negative offset.");
            offset = abs(offset);
        }
        u32_t maxOffset = obj->getMaxFieldOffsetLimit();
        if (maxOffset != 0)
            offset = offset % maxOffset;
        else
            offset = 0;
    }
    else
    {

    }

    return ls;
}

verifyStructSize()

void LocSymTableInfo::verifyStructSize	(	StInfo *	stinfo,
		u32_t	structSize
	)

Verify struct size construction.

Verify struct size

Please note this verify may not be complete as different machine has different alignment mechanism

Definition at line 577 of file MemModel.cpp.

{

    u32_t lastOff = stinfo->getFlattenFieldInfoVec().back().getFlattenByteOffset();
    u32_t strideSize = 0;
    FieldInfo::ElemNumStridePairVec::const_iterator pit = stinfo->getFlattenFieldInfoVec().back().elemStridePairBegin();
    FieldInfo::ElemNumStridePairVec::const_iterator epit = stinfo->getFlattenFieldInfoVec().back().elemStridePairEnd();
    for(; pit!=epit; ++pit)
        strideSize += pit->first * pit->second;

    u32_t lastSize = getTypeSizeInBytes(stinfo->getFlattenFieldInfoVec().back().getFlattenElemTy());
    assert((structSize == lastOff + strideSize + lastSize) && "struct size not consistent");

}

---

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

• /home/runner/work/SVF-1/SVF-1/include/SVF-FE/SymbolTableInfo.h
• /home/runner/work/SVF-1/SVF-1/lib/MemoryModel/MemModel.cpp