ObjTypeInference.h

Go to the documentation of this file.

//===- ObjTypeInference.h -- Type inference----------------------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * ObjTypeInference.h
 *
 *  Created by Xiao Cheng on 10/01/24.
 *
 */
 
#ifndef SVF_OBJTYPEINFERENCE_H
#define SVF_OBJTYPEINFERENCE_H
 
#include "Util/SVFUtil.h"
#include "SVF-LLVM/BasicTypes.h"
#include "Util/ThreadAPI.h"
 
namespace SVF
{
class ObjTypeInference
{
 
public:
    typedef Set<const Value *> ValueSet;
    typedef Map<const Value *, ValueSet> ValueToValueSet;
    typedef ValueToValueSet ValueToInferSites;
    typedef ValueToValueSet ValueToSources;
    typedef Map<const Value *, const Type *> ValueToType;
    typedef std::pair<const Value *, bool> ValueBoolPair;
    typedef Map<const Value *, Set<std::string>> ValueToClassNames;
    typedef Map<const Value *, Set<const CallBase *>> ObjToClsNameSources;
 
 
private:
    ValueToInferSites _valueToInferSites; // value inference site cache
    ValueToType _valueToType; // value type cache
    ValueToSources _valueToAllocs; // value allocations (stack, static, heap) cache
    ValueToClassNames _thisPtrClassNames; // thisptr class name cache
    ValueToSources _valueToAllocOrClsNameSources; // value alloc/clsname sources cache
    ObjToClsNameSources _objToClsNameSources; // alloc clsname sources cache
 
 
public:
 
    explicit ObjTypeInference() = default;
 
    ~ObjTypeInference() = default;
 
 
    const Type *inferObjType(const Value *var);
 
    const Type *inferPointsToType(const Value *var);
 
    void validateTypeCheck(const CallBase *cs);
 
    void typeSizeDiffTest(const PointerType *oPTy, const Type *iTy, const Value *val);
 
    const Type *defaultType(const Value *val);
 
    inline const Type *ptrType()
    {
        return PointerType::getUnqual(getLLVMCtx());
    }
 
    inline const IntegerType *int8Type()
    {
        return Type::getInt8Ty(getLLVMCtx());
    }
 
    LLVMContext &getLLVMCtx();
 
private:
 
    const Type *fwInferObjType(const Value *var);
 
    Set<const Value *>& bwfindAllocOfVar(const Value *var);
 
    bool isAlloc(const SVF::Value *val);
 
public:
    const Type *selectLargestSizedType(Set<const Type *> &objTys);
 
    u32_t objTyToNumFields(const Type *objTy);
 
    u32_t getArgPosInCall(const CallBase *callBase, const Value *arg);
 
public:
    Set<std::string> &inferThisPtrClsName(const Value *thisPtr);
 
protected:
 
    Set<const Value *> &bwFindAllocOrClsNameSources(const Value *startValue);
 
    Set<const CallBase *> &fwFindClsNameSources(const Value *startValue);
};
}
#endif //SVF_OBJTYPEINFERENCE_H