MemModel.h

Go to the documentation of this file.

//===- MemModel.h -- Memory model for pointer analysis------------------------//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013-2017>  <Yulei Sui>
//

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//===----------------------------------------------------------------------===//

/*
 * MemModel.h
 *
 *  Created on: Nov 11, 2013
 *      Author: Yulei Sui
 */

#ifndef OBJECTANDSYMBOL_H_
#define OBJECTANDSYMBOL_H_

#include "MemoryModel/LocationSet.h"
#include "Util/SVFModule.h"

namespace SVF
{

enum SYMTYPE
{
    BlackHole,
    ConstantObj,
    BlkPtr,
    NullPtr,
    ValSym,
    ObjSym,
    RetSym,
    VarargSym
};

class StInfo
{

private:
    std::vector<u32_t> fldIdxVec;
    std::vector<u32_t> foffset;
    Map<u32_t, const llvm::Type*> fldIdx2TypeMap;
    Map<u32_t, const llvm::Type*> offset2TypeMap;
    std::vector<FieldInfo> finfo;

    static u32_t maxFieldLimit;

public:
    StInfo()
    {
    }
    ~StInfo()
    {
    }

    static inline void setMaxFieldLimit(u32_t limit)
    {
        maxFieldLimit = limit;
    }

    static inline u32_t getMaxFieldLimit()
    {
        return maxFieldLimit;
    }

    //{@
    inline const llvm::Type* getFieldTypeWithFldIdx(u32_t fldIdx)
    {
        return fldIdx2TypeMap[fldIdx];
    }
    inline const llvm::Type* getFieldTypeWithByteOffset(u32_t offset)
    {
        return offset2TypeMap[offset];
    }
    inline std::vector<u32_t>& getFieldIdxVec()
    {
        return fldIdxVec;
    }
    inline std::vector<u32_t>& getFieldOffsetVec()
    {
        return foffset;
    }
    inline std::vector<FieldInfo>& getFlattenFieldInfoVec()
    {
        return finfo;
    }

    inline void addFldWithType(u32_t fldIdx, u32_t offset, const llvm::Type* type)
    {
        fldIdxVec.push_back(fldIdx);
        foffset.push_back(offset);
        fldIdx2TypeMap[fldIdx] = type;
        offset2TypeMap[offset] = type;
    }
};

class ObjTypeInfo
{

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_OBJ = 0x200,  // constant object str e.g.
        HASPTR_OBJ = 0x400      // non pointer object including compound type have field that is a pointer type
    } MEMTYPE;

private:
    const Type* type;
    Size_t flags;
    u32_t maxOffsetLimit;
public:

    ObjTypeInfo(const Value*, const Type* t, u32_t max) :
        type(t), flags(0), maxOffsetLimit(max)
    {
    }
    ObjTypeInfo(u32_t max, const Type* t) : type(t), flags(0), maxOffsetLimit(max)
    {

    }
    virtual ~ObjTypeInfo()
    {

    }
    void init(const Value* value);

    virtual u32_t getObjSize(const Value* val);

    void analyzeGlobalStackObjType(const Value* val);

    void analyzeHeapStaticObjType(const Value* val);

    inline const Type* getType() const
    {
        return type;
    }

    inline u32_t getMaxFieldOffsetLimit()
    {
        return maxOffsetLimit;
    }

    inline void setMaxFieldOffsetLimit(u32_t limit)
    {
        maxOffsetLimit = limit;
    }


    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 isConstStruct()
    {
        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 isConstArray()
    {
        return  hasFlag(CONST_ARRAY_OBJ);
    }
    inline bool isArray()
    {
        return hasFlag(VAR_ARRAY_OBJ) || hasFlag(CONST_ARRAY_OBJ);
    }
    inline bool isConstant()
    {
        return hasFlag(CONST_OBJ);
    }
    inline bool hasPtrObj()
    {
        return hasFlag(HASPTR_OBJ);
    }
    virtual bool isNonPtrFieldObj(const LocationSet& ls);
};

class MemObj
{

private:
    const Value *refVal;
    SymID GSymID;
    ObjTypeInfo* typeInfo;

public:

    MemObj(const Value *val, SymID id);

    MemObj(SymID id, const Type* type = nullptr);

    ~MemObj()
    {
        destroy();
    }

    void init(const Value *val);

    void init(const Type* type);

    const llvm::Type* getType() const;

    inline Size_t getMaxFieldOffsetLimit() const
    {
        return typeInfo->getMaxFieldOffsetLimit();
    }

    inline const Value *getRefVal() const
    {
        return refVal;
    }

    inline SymID getSymId() const
    {
        return GSymID;
    }

    inline bool isFieldInsensitive() const
    {
        return getMaxFieldOffsetLimit() == 0;
    }

    inline void setFieldInsensitive()
    {
        typeInfo->setMaxFieldOffsetLimit(0);
    }

    void setFieldSensitive();

    bool isBlackHoleObj() const;


    inline bool isFunction() const
    {
        return typeInfo->isFunction();
    }
    inline bool isGlobalObj() const
    {
        return typeInfo->isGlobalObj();
    }
    inline bool isStaticObj() const
    {
        return typeInfo->isStaticObj();
    }
    inline bool isStack() const
    {
        return typeInfo->isStack();
    }
    inline bool isHeap() const
    {
        return typeInfo->isHeap();
    }

    inline bool isStruct() const
    {
        return typeInfo->isStruct();
    }
    inline bool isArray() const
    {
        return typeInfo->isArray();
    }
    inline bool isVarStruct() const
    {
        return typeInfo->isVarStruct();
    }
    inline bool isVarArray() const
    {
        return typeInfo->isVarArray();
    }
    inline bool isConstStruct() const
    {
        return typeInfo->isConstStruct();
    }
    inline bool isConstArray() const
    {
        return typeInfo->isConstArray();
    }
    inline bool isConstant() const
    {
        return typeInfo->isConstant();
    }
    inline bool hasPtrObj() const
    {
        return typeInfo->hasPtrObj();
    }
    inline bool isNonPtrFieldObj(const LocationSet& ls) const
    {
        return typeInfo->isNonPtrFieldObj(ls);
    }

    inline bool operator==(const MemObj &mem) const
    {
        return refVal == mem.getRefVal();
    }

    void destroy();
};

} // End namespace SVF




#endif /* OBJECTANDSYMBOL_H_ */