SymbolTableInfo.h

Go to the documentation of this file.

//===- SymbolTableInfo.h -- Symbol information from IR------------------------//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013->  <Yulei Sui>
//
 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
 
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * SymbolTableInfo.h
 *
 *  Created on: Nov 11, 2013
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_SVFIR_SYMBOLTABLEINFO_H_
#define INCLUDE_SVFIR_SYMBOLTABLEINFO_H_
 
 
#include "Util/SVFUtil.h"
#include "MemoryModel/AccessPath.h"
#include "SVFIR/SVFModule.h"
namespace SVF
{
 
class MemObj;
class ObjTypeInfo;
class StInfo;
 
class SymbolTableInfo
{
    friend class SymbolTableBuilder;
    friend class SVFIRWriter;
    friend class SVFIRReader;
 
public:
 
    enum SYMTYPE
    {
        NullPtr,
        BlkPtr,
        BlackHole,
        ConstantObj,
        ValSymbol,
        ObjSymbol,
        RetSymbol,
        VarargSymbol
    };
 
    //{@
    typedef OrderedMap<const SVFValue*, SymID> ValueToIDMapTy;
    typedef OrderedMap<SymID, MemObj*> IDToMemMapTy;
    typedef OrderedMap<const SVFFunction*, SymID> FunToIDMapTy;
    typedef Set<const SVFType*> SVFTypeSet;
 
private:
    ValueToIDMapTy valSymMap;  
    ValueToIDMapTy objSymMap;  
    FunToIDMapTy returnSymMap; 
    FunToIDMapTy varargSymMap; 
    IDToMemMapTy objMap;       
 
    // Singleton pattern here to enable instance of SymbolTableInfo can only be created once.
    static SymbolTableInfo* symInfo;
 
    SVFModule* mod;
 
    void destroy();
 
    bool modelConstants;
 
    SymID totalSymNum;
 
protected:
    SymbolTableInfo(void)
        : mod(nullptr), modelConstants(false), totalSymNum(0),
          maxStruct(nullptr), maxStSize(0)
    {
    }
 
public:
 
 
    static SymbolTableInfo* SymbolInfo();
 
    static void releaseSymbolInfo()
    {
        delete symInfo;
        symInfo = nullptr;
    }
    virtual ~SymbolTableInfo()
    {
        destroy();
    }
 
 
    void setModelConstants(bool _modelConstants)
    {
        modelConstants = _modelConstants;
    }
    bool getModelConstants() const
    {
        return modelConstants;
    }
 
    inline SVFModule* getModule()
    {
        return mod;
    }
    inline void setModule(SVFModule* m)
    {
        mod = m;
    }
 
    // @{
    static inline bool isBlkPtr(NodeID id)
    {
        return (id == BlkPtr);
    }
    static inline bool isNullPtr(NodeID id)
    {
        return (id == NullPtr);
    }
    static inline bool isBlkObj(NodeID id)
    {
        return (id == BlackHole);
    }
    static inline bool isConstantObj(NodeID id)
    {
        return (id == ConstantObj);
    }
    static inline bool isBlkObjOrConstantObj(NodeID id)
    {
        return (isBlkObj(id) || isConstantObj(id));
    }
 
    inline MemObj* getBlkObj() const
    {
        return getObj(blackholeSymID());
    }
    inline MemObj* getConstantObj() const
    {
        return getObj(constantSymID());
    }
 
    inline SymID blkPtrSymID() const
    {
        return BlkPtr;
    }
 
    inline SymID nullPtrSymID() const
    {
        return NullPtr;
    }
 
    inline SymID constantSymID() const
    {
        return ConstantObj;
    }
 
    inline SymID blackholeSymID() const
    {
        return BlackHole;
    }
 
    const MemObj* createDummyObj(SymID symId, const SVFType* type);
    // @}
 
 
    SymID getValSym(const SVFValue* val);
 
    bool hasValSym(const SVFValue* val);
 
    inline SymID getObjSym(const SVFValue* val) const
    {
        const SVFValue* svfVal = val;
        if(const SVFGlobalValue* g = SVFUtil::dyn_cast<SVFGlobalValue>(val))
            svfVal = g->getDefGlobalForMultipleModule();
        ValueToIDMapTy::const_iterator iter = objSymMap.find(svfVal);
        assert(iter!=objSymMap.end() && "obj sym not found");
        return iter->second;
    }
 
    inline MemObj* getObj(SymID id) const
    {
        IDToMemMapTy::const_iterator iter = objMap.find(id);
        assert(iter!=objMap.end() && "obj not found");
        return iter->second;
    }
 
    inline SymID getRetSym(const SVFFunction* val) const
    {
        FunToIDMapTy::const_iterator iter =  returnSymMap.find(val);
        assert(iter!=returnSymMap.end() && "ret sym not found");
        return iter->second;
    }
 
    inline SymID getVarargSym(const SVFFunction* val) const
    {
        FunToIDMapTy::const_iterator iter =  varargSymMap.find(val);
        assert(iter!=varargSymMap.end() && "vararg sym not found");
        return iter->second;
    }
 
 
 
    inline u32_t getTotalSymNum() const
    {
        return totalSymNum;
    }
    inline u32_t getMaxStructSize() const
    {
        return maxStSize;
    }
 
 
    inline ValueToIDMapTy& valSyms()
    {
        return valSymMap;
    }
 
    inline ValueToIDMapTy& objSyms()
    {
        return objSymMap;
    }
 
    inline IDToMemMapTy& idToObjMap()
    {
        return objMap;
    }
 
    inline const IDToMemMapTy& idToObjMap() const
    {
        return objMap;
    }
 
    inline FunToIDMapTy& retSyms()
    {
        return returnSymMap;
    }
 
    inline FunToIDMapTy& varargSyms()
    {
        return varargSymMap;
    }
 
 
 
    inline const SVFTypeSet& getSVFTypes() const
    {
        return svfTypes;
    }
 
    inline const Set<const StInfo*>& getStInfos() const
    {
        return stInfos;
    }
 
 
    const StInfo* getTypeInfo(const SVFType* T) const;
    inline bool hasSVFTypeInfo(const SVFType* T)
    {
        return svfTypes.find(T) != svfTypes.end();
    }
 
    u32_t getNumOfFlattenElements(const SVFType* T);
    u32_t getFlattenedElemIdx(const SVFType* T, u32_t origId);
    const SVFType* getFlatternedElemType(const SVFType* baseType, u32_t flatten_idx);
    const SVFType* getOriginalElemType(const SVFType* baseType, u32_t origId) const;
 
    void printFlattenFields(const SVFType* type);
 
    static std::string toString(SYMTYPE symtype);
 
    virtual void dump();
 
    virtual APOffset getModulusOffset(const MemObj* obj,
                                      const APOffset& apOffset);
 
    const SVFType* maxStruct;
 
    u32_t maxStSize;
 
    inline void addTypeInfo(const SVFType* ty)
    {
        bool inserted = svfTypes.insert(ty).second;
        if(!inserted)
            assert(false && "this type info has been added before");
    }
 
    inline void addStInfo(StInfo* stInfo)
    {
        stInfos.insert(stInfo);
    }
 
protected:
 
    const std::vector<const SVFType*>& getFlattenFieldTypes(const SVFStructType *T);
 
    ObjTypeInfo* createObjTypeInfo(const SVFType* type);
 
    SVFTypeSet svfTypes;
 
    Set<const StInfo*> stInfos;
};
 
class SVFBaseNode;
 
class MemObj
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class SVFIRBuilder;
 
private:
    ObjTypeInfo* typeInfo;
    const SVFValue* refVal;
    SymID symId;
 
    const SVFBaseNode* gNode;
 
public:
    MemObj(SymID id, ObjTypeInfo* ti, const SVFValue* val = nullptr, const SVFBaseNode* node = nullptr);
 
    virtual ~MemObj()
    {
        destroy();
    }
 
    virtual const std::string toString() const;
 
    inline const SVFValue* getValue() const
    {
        return refVal;
    }
 
    inline const SVFBaseNode* getGNode() const
    {
        return gNode;
    }
 
    inline SymID getId() const
    {
        return symId;
    }
 
    const SVFType* getType() const;
 
    u32_t getNumOfElements() const;
 
    void setNumOfElements(u32_t num);
 
    u32_t getMaxFieldOffsetLimit() const;
 
    bool isFieldInsensitive() const;
 
    void setFieldInsensitive();
 
    void setFieldSensitive();
 
    bool isBlackHoleObj() const;
 
    u32_t getByteSizeOfObj() const;
 
    bool isConstantByteSize() const;
 
 
 
    bool isFunction() const;
    bool isGlobalObj() const;
    bool isStaticObj() const;
    bool isStack() const;
    bool isHeap() const;
    bool isStruct() const;
    bool isArray() const;
    bool isVarStruct() const;
    bool isVarArray() const;
    bool isConstantStruct() const;
    bool isConstantArray() const;
    bool isConstDataOrConstGlobal() const;
    bool isConstDataOrAggData() const;
 
    inline bool operator==(const MemObj& mem) const
    {
        return getValue() == mem.getValue();
    }
 
    void destroy();
};
 
class ObjTypeInfo
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class SymbolTableBuilder;
 
public:
    typedef enum
    {
        FUNCTION_OBJ = 0x1,  // object is a function
        GLOBVAR_OBJ = 0x2,  // object is a global variable
        STATIC_OBJ = 0x4,  // object is a static variable allocated before main
        STACK_OBJ = 0x8,  // object is a stack variable
        HEAP_OBJ = 0x10,  // object is a heap variable
        VAR_STRUCT_OBJ = 0x20,  // object contains struct
        VAR_ARRAY_OBJ = 0x40,  // object contains array
        CONST_STRUCT_OBJ = 0x80,  // constant struct
        CONST_ARRAY_OBJ = 0x100,  // constant array
        CONST_GLOBAL_OBJ = 0x200,  // global constant object
        CONST_DATA = 0x400,  // constant object str e.g. 5, 10, 1.0
    } MEMTYPE;
 
private:
    const SVFType* type;
    u32_t flags;
    u32_t maxOffsetLimit;
    u32_t elemNum;
 
    u32_t byteSize;
 
    void resetTypeForHeapStaticObj(const SVFType* type);
public:
 
    ObjTypeInfo(const SVFType* t, u32_t max);
 
    virtual ~ObjTypeInfo()
    {
    }
 
    inline const SVFType* getType() const
    {
        return type;
    }
 
    inline u32_t getMaxFieldOffsetLimit()
    {
        return maxOffsetLimit;
    }
 
    inline void setMaxFieldOffsetLimit(u32_t limit)
    {
        maxOffsetLimit = limit;
    }
 
    inline void setNumOfElements(u32_t num)
    {
        elemNum = num;
        setMaxFieldOffsetLimit(num);
    }
 
    inline u32_t getNumOfElements() const
    {
        return elemNum;
    }
 
    inline u32_t getByteSizeOfObj() const
    {
        assert(isConstantByteSize() && "This Obj's byte size is not constant.");
        return byteSize;
    }
 
    inline void setByteSizeOfObj(u32_t size)
    {
        byteSize = size;
    }
 
    inline bool isConstantByteSize() const
    {
        return byteSize != 0;
    }
 
 
    inline void setFlag(MEMTYPE mask)
    {
        flags |= mask;
    }
    inline bool hasFlag(MEMTYPE mask)
    {
        return (flags & mask) == mask;
    }
 
 
    inline bool isFunction()
    {
        return hasFlag(FUNCTION_OBJ);
    }
    inline bool isGlobalObj()
    {
        return hasFlag(GLOBVAR_OBJ);
    }
    inline bool isStaticObj()
    {
        return hasFlag(STATIC_OBJ);
    }
    inline bool isStack()
    {
        return hasFlag(STACK_OBJ);
    }
    inline bool isHeap()
    {
        return hasFlag(HEAP_OBJ);
    }
 
 
    inline bool isVarStruct()
    {
        return hasFlag(VAR_STRUCT_OBJ);
    }
    inline bool isConstantStruct()
    {
        return hasFlag(CONST_STRUCT_OBJ);
    }
    inline bool isStruct()
    {
        return hasFlag(VAR_STRUCT_OBJ) || hasFlag(CONST_STRUCT_OBJ);
    }
    inline bool isVarArray()
    {
        return hasFlag(VAR_ARRAY_OBJ);
    }
    inline bool isConstantArray()
    {
        return  hasFlag(CONST_ARRAY_OBJ);
    }
    inline bool isArray()
    {
        return hasFlag(VAR_ARRAY_OBJ) || hasFlag(CONST_ARRAY_OBJ);
    }
    inline bool isConstDataOrConstGlobal()
    {
        return hasFlag(CONST_GLOBAL_OBJ) || hasFlag(CONST_DATA);
    }
    inline bool isConstDataOrAggData()
    {
        return hasFlag(CONST_DATA);
    }
};
 
 
} // End namespace SVF
 
#endif /* INCLUDE_SVFIR_SYMBOLTABLEINFO_H_ */