svf-tools 1.0.1047 → 1.0.1048

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1047",
+  "version": "1.0.1048",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -58,9 +58,9 @@ public:
     typedef Map<const Function*, FunObjVar*> LLVMFun2FunObjVarMap;
     typedef Map<const BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
     typedef Map<const Instruction*, SVFInstruction*> LLVMInst2SVFInstMap;
-    typedef Map<const Argument*, SVFArgument*> LLVMArgument2SVFArgumentMap;
-    typedef Map<const Constant*, SVFConstant*> LLVMConst2SVFConstMap;
-    typedef Map<const Value*, SVFOtherValue*> LLVMValue2SVFOtherValueMap;
+    typedef Map<const Argument*, SVFLLVMValue*> LLVMArgument2SVFArgumentMap;
+    typedef Map<const Constant*, SVFLLVMValue*> LLVMConst2SVFConstMap;
+    typedef Map<const Value*, SVFLLVMValue*> LLVMValue2SVFOtherValueMap;
     typedef Map<const SVFLLVMValue*, const Value*> SVFValue2LLVMValueMap;
     typedef Map<const SVFValue*, const Value*> SVFBaseNode2LLVMValueMap;
     typedef Map<const Type*, SVFType*> LLVMType2SVFTypeMap;
@@ -254,12 +254,12 @@ public:
         addToSVFVar2LLVMValueMap(inst, svfInst);
     }
 
-    inline void addArgumentMap(const Argument* arg, SVFArgument* svfArg)
+    inline void addArgumentMap(const Argument* arg, SVFLLVMValue* svfArg)
     {
         LLVMArgument2SVFArgument[arg] = svfArg;
         setValueAttr(arg,svfArg);
     }
-    inline void addGlobalValueMap(const GlobalValue* glob, SVFGlobalValue* svfglob)
+    inline void addGlobalValueMap(const GlobalValue* glob, SVFLLVMValue* svfglob)
     {
         if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(glob);
                 hasGlobalRep(glob_var))
@@ -269,17 +269,17 @@ public:
         LLVMConst2SVFConst[glob] = svfglob;
         setValueAttr(glob,svfglob);
     }
-    inline void addConstantDataMap(const ConstantData* cd, SVFConstantData* svfcd)
+    inline void addConstantDataMap(const ConstantData* cd, SVFLLVMValue* svfcd)
     {
         LLVMConst2SVFConst[cd] = svfcd;
         setValueAttr(cd,svfcd);
     }
-    inline void addOtherConstantMap(const Constant* cons, SVFConstant* svfcons)
+    inline void addOtherConstantMap(const Constant* cons, SVFLLVMValue* svfcons)
     {
         LLVMConst2SVFConst[cons] = svfcons;
         setValueAttr(cons,svfcons);
     }
-    inline void addOtherValueMap(const Value* ov, SVFOtherValue* svfov)
+    inline void addOtherValueMap(const Value* ov, SVFLLVMValue* svfov)
     {
         LLVMValue2SVFOtherValue[ov] = svfov;
         setValueAttr(ov,svfov);
@@ -353,14 +353,14 @@ public:
         return it->second;
     }
 
-    inline SVFArgument* getSVFArgument(const Argument* arg) const
+    inline SVFLLVMValue* getSVFArgument(const Argument* arg) const
     {
         LLVMArgument2SVFArgumentMap::const_iterator it = LLVMArgument2SVFArgument.find(arg);
         assert(it!=LLVMArgument2SVFArgument.end() && "SVF Argument not found!");
         return it->second;
     }
 
-    inline SVFGlobalValue* getSVFGlobalValue(const GlobalValue* g) const
+    inline SVFLLVMValue* getSVFGlobalValue(const GlobalValue* g) const
     {
         if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(g);
                 hasGlobalRep(glob_var))
@@ -369,14 +369,13 @@ public:
         }
         LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(g);
         assert(it!=LLVMConst2SVFConst.end() && "SVF Global not found!");
-        assert(SVFUtil::isa<SVFGlobalValue>(it->second) && "not a SVFGlobal type!");
-        return SVFUtil::cast<SVFGlobalValue>(it->second);
+        return it->second;
     }
 
-    SVFConstantData* getSVFConstantData(const ConstantData* cd);
-    SVFConstant* getOtherSVFConstant(const Constant* oc);
+    SVFLLVMValue* getSVFConstantData(const ConstantData* cd);
+    SVFLLVMValue* getOtherSVFConstant(const Constant* oc);
 
-    SVFOtherValue* getSVFOtherValue(const Value* ov);
+    SVFLLVMValue* getSVFOtherValue(const Value* ov);
 
     /// Get the corresponding Function based on its name
     inline const SVFFunction* getSVFFunction(const std::string& name)

package/svf-llvm/include/SVF-LLVM/SVFLLVMValue.h

@@ -63,16 +63,7 @@ public:
     {
         SVFVal,
         SVFFunc,
-        SVFBB,
         SVFInst,
-        SVFCall,
-        SVFVCall,
-        SVFGlob,
-        SVFArg,
-        SVFConst,
-        SVFConstData,
-        SVFMetaAsValue,
-        SVFOther
     };
 
 private:
@@ -85,9 +76,9 @@ protected:
     std::string name;       ///< Short name of value for printing & debugging
     std::string sourceLoc;  ///< Source code information of this value
     /// Constructor without name
-    SVFLLVMValue(const SVFType* ty, SVFValKind k)
+    SVFLLVMValue(const SVFType* ty, SVFValKind k = SVFVal)
         : kind(k), ptrInUncalledFun(false),
-          constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
+          constDataOrAggData(false), type(ty), sourceLoc("NoLoc")
     {
     }
 
@@ -405,9 +396,7 @@ public:
 
     static inline bool classof(const SVFLLVMValue *node)
     {
-        return node->getKind() == SVFInst ||
-               node->getKind() == SVFCall ||
-               node->getKind() == SVFVCall;
+        return node->getKind() == SVFInst;
     }
 
     inline const SVFBasicBlock* getParent() const
@@ -426,242 +415,6 @@ public:
     }
 };
 
-class SVFCallInst : public SVFInstruction
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-    friend class SVFIRBuilder;
-
-private:
-    std::vector<const SVFLLVMValue*> args;
-    bool varArg;
-    const SVFLLVMValue* calledVal;
-
-protected:
-    ///@{ attributes to be set only through Module builders e.g., LLVMModule
-    inline void addArgument(const SVFLLVMValue* a)
-    {
-        args.push_back(a);
-    }
-    inline void setCalledOperand(const SVFLLVMValue* v)
-    {
-        calledVal = v;
-    }
-    /// @}
-
-public:
-    SVFCallInst(const SVFType* ty, const SVFBasicBlock* b, bool va, bool tm, SVFValKind k = SVFCall) :
-        SVFInstruction(ty, b, tm, false, k), varArg(va), calledVal(nullptr)
-    {
-    }
-    SVFCallInst(void) = delete;
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFCall || node->getKind() == SVFVCall;
-    }
-    static inline bool classof(const SVFInstruction *node)
-    {
-        return node->getKind() == SVFCall || node->getKind() == SVFVCall;
-    }
-    inline u32_t arg_size() const
-    {
-        return args.size();
-    }
-    inline bool arg_empty() const
-    {
-        return args.empty();
-    }
-    inline const SVFLLVMValue* getArgOperand(u32_t i) const
-    {
-        assert(i < arg_size() && "out of bound access of the argument");
-        return args[i];
-    }
-    inline u32_t getNumArgOperands() const
-    {
-        return arg_size();
-    }
-    inline const SVFLLVMValue* getCalledOperand() const
-    {
-        return calledVal;
-    }
-    inline bool isVarArg() const
-    {
-        return varArg;
-    }
-    inline const SVFFunction* getCalledFunction() const
-    {
-        return SVFUtil::dyn_cast<SVFFunction>(calledVal);
-    }
-    inline  const FunObjVar* getCaller() const
-    {
-        return getFunction();
-    }
-};
-
-class SVFConstant : public SVFLLVMValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFConstant(const SVFType* ty, SVFValKind k = SVFConst): SVFLLVMValue(ty, k)
-    {
-    }
-    SVFConstant() = delete;
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFConst ||
-               node->getKind() == SVFGlob ||
-               node->getKind() == SVFConstData;
-    }
-
-};
-
-class SVFGlobalValue : public SVFConstant
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-
-private:
-    const SVFLLVMValue* realDefGlobal;  /// the definition of a function across multiple modules
-
-protected:
-    inline void setDefGlobalForMultipleModule(const SVFLLVMValue* defg)
-    {
-        realDefGlobal = defg;
-    }
-
-public:
-    SVFGlobalValue(const SVFType* ty): SVFConstant(ty, SVFLLVMValue::SVFGlob), realDefGlobal(nullptr)
-    {
-    }
-    SVFGlobalValue(std::string&& name, const SVFType* ty) : SVFGlobalValue(ty)
-    {
-        setName(std::move(name));
-    }
-    SVFGlobalValue() = delete;
-
-    inline const SVFLLVMValue* getDefGlobalForMultipleModule() const
-    {
-        if(realDefGlobal==nullptr)
-            return this;
-        return realDefGlobal;
-    }
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFGlob;
-    }
-    static inline bool classof(const SVFConstant *node)
-    {
-        return node->getKind() == SVFGlob;
-    }
-};
-
-class SVFArgument : public SVFLLVMValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-private:
-    const SVFFunction* fun;
-    u32_t argNo;
-    bool uncalled;
-public:
-    SVFArgument(const SVFType* ty, const SVFFunction* fun, u32_t argNo,
-                bool uncalled)
-        : SVFLLVMValue(ty, SVFLLVMValue::SVFArg), fun(fun), argNo(argNo),
-          uncalled(uncalled)
-    {
-    }
-    SVFArgument() = delete;
-
-    inline const SVFFunction* getParent() const
-    {
-        return fun;
-    }
-
-    ///  Return the index of this formal argument in its containing function.
-    /// For example in "void foo(int a, float b)" a is 0 and b is 1.
-    inline u32_t getArgNo() const
-    {
-        return argNo;
-    }
-
-    inline bool isArgOfUncalledFunction() const
-    {
-        return uncalled;
-    }
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFArg;
-    }
-};
-
-class SVFConstantData : public SVFConstant
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFConstantData(const SVFType* ty, SVFValKind k = SVFConstData)
-        : SVFConstant(ty, k)
-    {
-    }
-    SVFConstantData() = delete;
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFConstData;
-    }
-    static inline bool classof(const SVFConstantData *node)
-    {
-        return node->getKind() == SVFConstData;
-    }
-};
-
-class SVFOtherValue : public SVFLLVMValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFOtherValue(const SVFType* ty, SVFValKind k = SVFLLVMValue::SVFOther)
-        : SVFLLVMValue(ty, k)
-    {
-    }
-    SVFOtherValue() = delete;
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFOther || node->getKind() == SVFMetaAsValue;
-    }
-};
-
-/*
- * This class is only for LLVM's MetadataAsValue
-*/
-class SVFMetadataAsValue : public SVFOtherValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFMetadataAsValue(const SVFType* ty)
-        : SVFOtherValue(ty, SVFLLVMValue::SVFMetaAsValue)
-    {
-    }
-    SVFMetadataAsValue() = delete;
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFMetaAsValue;
-    }
-    static inline bool classof(const SVFOtherValue *node)
-    {
-        return node->getKind() == SVFMetaAsValue;
-    }
-};
-
 
 /// [FOR DEBUG ONLY, DON'T USE IT UNSIDE `svf`!]
 /// Converts an SVFValue to corresponding LLVM::Value, then get the string

package/svf-llvm/include/SVF-LLVM/SVFModule.h

@@ -44,10 +44,10 @@ class SVFModule
 
 public:
     typedef std::vector<const SVFFunction*> FunctionSetType;
-    typedef std::vector<SVFGlobalValue*> GlobalSetType;
-    typedef std::vector<SVFGlobalValue*> AliasSetType;
-    typedef std::vector<SVFConstant*> ConstantType;
-    typedef std::vector<SVFOtherValue*> OtherValueType;
+    typedef std::vector<SVFLLVMValue*> GlobalSetType;
+    typedef std::vector<SVFLLVMValue*> AliasSetType;
+    typedef std::vector<SVFLLVMValue*> ConstantType;
+    typedef std::vector<SVFLLVMValue*> OtherValueType;
 
     /// Iterators type def
     typedef FunctionSetType::iterator iterator;
@@ -86,21 +86,19 @@ public:
     {
         FunctionSet.push_back(svfFunc);
     }
-    inline void addGlobalSet(SVFGlobalValue* glob)
+    inline void addGlobalSet(SVFLLVMValue* glob)
     {
         GlobalSet.push_back(glob);
-        addConstant(glob);
     }
-    inline void addAliasSet(SVFGlobalValue* alias)
+    inline void addAliasSet(SVFLLVMValue* alias)
     {
         AliasSet.push_back(alias);
-        addConstant(alias);
     }
-    inline void addConstant(SVFConstant* cd)
+    inline void addConstant(SVFLLVMValue* cd)
     {
         ConstantSet.push_back(cd);
     }
-    inline void addOtherValue(SVFOtherValue* ov)
+    inline void addOtherValue(SVFLLVMValue* ov)
     {
         OtherValueSet.push_back(ov);
     }

package/svf-llvm/lib/DCHG.cpp

@@ -177,7 +177,7 @@ void DCHGraph::buildVTables(const SVFModule &module)
                 DIType *type = SVFUtil::dyn_cast<DIType>(gv->getMetadata(cppUtil::ctir::vtMDName));
                 assert(type && "DCHG::buildVTables: bad metadata for ctir.vt");
                 DCHNode *node = getOrCreateNode(type);
-                const SVFGlobalValue* svfgv = LLVMModuleSet::getLLVMModuleSet()->getSVFGlobalValue(gv);
+                const SVFLLVMValue* svfgv = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(gv);
                 NodeID i = LLVMModuleSet::getLLVMModuleSet()->getObjectNode(svfgv);
                 GlobalObjVar* globalObjVar =
                     SVFUtil::cast<GlobalObjVar>(PAG::getPAG()->getGNode(i));

package/svf-llvm/lib/LLVMModule.cpp

@@ -237,8 +237,7 @@ void LLVMModuleSet::createSVFDataStructure()
         /// GlobalVariable
         for (const GlobalVariable& global :  mod.globals())
         {
-            SVFGlobalValue* svfglobal = new SVFGlobalValue(
-                global.getName().str(), getSVFType(global.getType()));
+            SVFLLVMValue* svfglobal = new SVFLLVMValue(getSVFType(global.getType()));
             svfModule->addGlobalSet(svfglobal);
             addGlobalValueMap(&global, svfglobal);
         }
@@ -246,8 +245,8 @@ void LLVMModuleSet::createSVFDataStructure()
         /// GlobalAlias
         for (const GlobalAlias& alias : mod.aliases())
         {
-            SVFGlobalValue* svfalias = new SVFGlobalValue(
-                alias.getName().str(), getSVFType(alias.getType()));
+            SVFLLVMValue* svfalias = new SVFLLVMValue(
+                getSVFType(alias.getType()));
             svfModule->addAliasSet(svfalias);
             addGlobalValueMap(&alias, svfalias);
         }
@@ -255,8 +254,8 @@ void LLVMModuleSet::createSVFDataStructure()
         /// GlobalIFunc
         for (const GlobalIFunc& ifunc : mod.ifuncs())
         {
-            SVFGlobalValue* svfifunc = new SVFGlobalValue(
-                ifunc.getName().str(), getSVFType(ifunc.getType()));
+            SVFLLVMValue* svfifunc = new SVFLLVMValue(
+                getSVFType(ifunc.getType()));
             svfModule->addAliasSet(svfifunc);
             addGlobalValueMap(&ifunc, svfifunc);
         }
@@ -278,12 +277,8 @@ void LLVMModuleSet::createSVFFunction(const Function* func)
 
     for (const Argument& arg : func->args())
     {
-        SVFArgument* svfarg = new SVFArgument(
-            getSVFType(arg.getType()), svfFunc, arg.getArgNo(),
-            LLVMUtil::isArgOfUncalledFunction(&arg));
-        // Setting up arg name
-        if (!arg.hasName())
-            svfarg->setName(std::to_string(arg.getArgNo()));
+        SVFLLVMValue* svfarg = new SVFLLVMValue(
+            getSVFType(arg.getType()));
 
         addArgumentMap(&arg, svfarg);
     }
@@ -293,21 +288,9 @@ void LLVMModuleSet::createSVFFunction(const Function* func)
         addBasicBlock(svfFunc, &bb);
         for (const Instruction& inst : bb)
         {
-            SVFInstruction* svfInst = nullptr;
-            if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(&inst))
-            {
-                svfInst = new SVFCallInst(
-                    getSVFType(call->getType()), getSVFBasicBlock(&bb),
-                    call->getFunctionType()->isVarArg(),
-                    inst.isTerminator());
-            }
-            else
-            {
-                svfInst =
-                    new SVFInstruction(getSVFType(inst.getType()),
-                                       getSVFBasicBlock(&bb), inst.isTerminator(),
-                                       SVFUtil::isa<ReturnInst>(inst));
-            }
+            SVFInstruction* svfInst = new SVFInstruction(getSVFType(inst.getType()),
+                    getSVFBasicBlock(&bb), inst.isTerminator(),
+                    SVFUtil::isa<ReturnInst>(inst));
 
             addInstructionMap(&inst, svfInst);
         }
@@ -361,31 +344,6 @@ void LLVMModuleSet::initSVFBasicBlock(const Function* func)
                 svfFun->setExitBlock(svfbb);
             }
         }
-
-        for (BasicBlock::const_iterator iit = bb->begin(), eiit = bb->end(); iit != eiit; ++iit)
-        {
-            const Instruction* inst = &*iit;
-            if(const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
-            {
-                SVFInstruction* svfinst = getSVFInstruction(call);
-                SVFCallInst* svfcall = SVFUtil::cast<SVFCallInst>(svfinst);
-                auto called_llvmval = call->getCalledOperand()->stripPointerCasts();
-                if (const Function* called_llvmfunc = SVFUtil::dyn_cast<Function>(called_llvmval))
-                {
-                    SVFFunction* callee = getSVFFunction(called_llvmfunc);
-                    svfcall->setCalledOperand(callee);
-                }
-                else
-                {
-                    svfcall->setCalledOperand(getSVFValue(called_llvmval));
-                }
-                for(u32_t i = 0; i < call->arg_size(); i++)
-                {
-                    SVFLLVMValue* svfval = getSVFValue(call->getArgOperand(i));
-                    svfcall->addArgument(svfval);
-                }
-            }
-        }
     }
     // For no return functions, we set the last block as exit BB
     // This ensures that each function that has definition must have an exit BB
@@ -1234,8 +1192,9 @@ bool LLVMModuleSet::hasValueNode(const SVFLLVMValue *val)
 NodeID LLVMModuleSet::getObjectNode(const SVFLLVMValue *val)
 {
     const SVFLLVMValue *svfVal = val;
-    if (const SVFGlobalValue *g = SVFUtil::dyn_cast<SVFGlobalValue>(val))
-        svfVal = g->getDefGlobalForMultipleModule();
+    auto llvm_value = llvmModuleSet->getLLVMValue(svfVal);
+    if (const GlobalVariable* glob = SVFUtil::dyn_cast<GlobalVariable>(llvm_value))
+        svfVal = llvmModuleSet->getSVFValue(LLVMUtil::getGlobalRep(glob));
     ValueToIDMapTy::const_iterator iter = objSymMap.find(svfVal);
     assert(iter!=objSymMap.end() && "obj sym not found");
     return iter->second;
@@ -1292,12 +1251,6 @@ void LLVMModuleSet::setValueAttr(const Value* val, SVFLLVMValue* svfvalue)
     if (LLVMUtil::isConstDataOrAggData(val))
         svfvalue->setConstDataOrAggData();
 
-    if (SVFGlobalValue* glob = SVFUtil::dyn_cast<SVFGlobalValue>(svfvalue))
-    {
-        const Value* llvmVal = LLVMUtil::getGlobalRep(val);
-        assert(SVFUtil::isa<GlobalValue>(llvmVal) && "not a GlobalValue?");
-        glob->setDefGlobalForMultipleModule(getSVFGlobalValue(SVFUtil::cast<GlobalValue>(llvmVal)));
-    }
     if (SVFFunction* svffun = SVFUtil::dyn_cast<SVFFunction>(svfvalue))
     {
         const Function* func = SVFUtil::cast<Function>(val);
@@ -1317,24 +1270,23 @@ void LLVMModuleSet::addToSVFVar2LLVMValueMap(const Value* val,
     svfBaseNode->setName(val->getName().str());
 }
 
-SVFConstantData* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
+SVFLLVMValue* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
 {
     LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(cd);
     if(it!=LLVMConst2SVFConst.end())
     {
-        assert(SVFUtil::isa<SVFConstantData>(it->second) && "not a SVFConstantData type!");
-        return SVFUtil::cast<SVFConstantData>(it->second);
+        return it->second;
     }
     else
     {
-        SVFConstantData* svfcd = new SVFConstantData(getSVFType(cd->getType()));
+        SVFLLVMValue* svfcd = new SVFLLVMValue(getSVFType(cd->getType()));
         svfModule->addConstant(svfcd);
         addConstantDataMap(cd,svfcd);
         return svfcd;
     }
 }
 
-SVFConstant* LLVMModuleSet::getOtherSVFConstant(const Constant* oc)
+SVFLLVMValue* LLVMModuleSet::getOtherSVFConstant(const Constant* oc)
 {
     LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(oc);
     if(it!=LLVMConst2SVFConst.end())
@@ -1343,14 +1295,14 @@ SVFConstant* LLVMModuleSet::getOtherSVFConstant(const Constant* oc)
     }
     else
     {
-        SVFConstant* svfoc = new SVFConstant(getSVFType(oc->getType()));
+        SVFLLVMValue* svfoc = new SVFLLVMValue(getSVFType(oc->getType()));
         svfModule->addConstant(svfoc);
         addOtherConstantMap(oc,svfoc);
         return svfoc;
     }
 }
 
-SVFOtherValue* LLVMModuleSet::getSVFOtherValue(const Value* ov)
+SVFLLVMValue* LLVMModuleSet::getSVFOtherValue(const Value* ov)
 {
     LLVMValue2SVFOtherValueMap::const_iterator it = LLVMValue2SVFOtherValue.find(ov);
     if(it!=LLVMValue2SVFOtherValue.end())
@@ -1359,10 +1311,7 @@ SVFOtherValue* LLVMModuleSet::getSVFOtherValue(const Value* ov)
     }
     else
     {
-        SVFOtherValue* svfov =
-            SVFUtil::isa<MetadataAsValue>(ov)
-            ? new SVFMetadataAsValue(getSVFType(ov->getType()))
-            : new SVFOtherValue(getSVFType(ov->getType()));
+        SVFLLVMValue* svfov = new SVFLLVMValue(getSVFType(ov->getType()));
         svfModule->addOtherValue(svfov);
         addOtherValueMap(ov,svfov);
         return svfov;

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -1490,7 +1490,7 @@ NodeID SVFIRBuilder::getGepValVar(const Value* val, const AccessPath& ap, const
          * 1. Instruction
          * 2. GlobalVariable
          */
-        assert((SVFUtil::isa<SVFInstruction, SVFGlobalValue>(curVal)) && "curVal not an instruction or a globalvariable?");
+        assert((SVFUtil::isa<SVFInstruction>(curVal) || SVFUtil::isa<GlobalVariable>(llvmModuleSet()->getLLVMValue(curVal))) && "curVal not an instruction or a globalvariable?");
 
         // We assume every GepValNode and its GepEdge to the baseNode are unique across the whole program
         // We preserve the current BB information to restore it after creating the gepNode
@@ -1569,15 +1569,15 @@ void SVFIRBuilder::setCurrentBBAndValueForPAGEdge(PAGEdge* edge)
                 icfgNode = llvmMS->getICFGNode(SVFUtil::cast<Instruction>(llvmMS->getLLVMValue(curInst)));
         }
     }
-    else if (const SVFArgument* arg = SVFUtil::dyn_cast<SVFArgument>(curVal))
+    else if (const Argument* arg = SVFUtil::dyn_cast<Argument>(llvmModuleSet()->getLLVMValue(curVal)))
     {
         assert(curBB && (curBB->getParent()->getEntryBlock() == curBB));
         icfgNode = pag->getICFG()->getFunEntryICFGNode(
-                       llvmModuleSet()->getFunObjVar(SVFUtil::cast<Function>(llvmModuleSet()->getLLVMValue(arg->getParent()))));
+                       llvmModuleSet()->getFunObjVar(SVFUtil::cast<Function>(arg->getParent())));
     }
-    else if (SVFUtil::isa<SVFConstant>(curVal) ||
+    else if (SVFUtil::isa<Constant>(llvmModuleSet()->getLLVMValue(curVal)) ||
              SVFUtil::isa<SVFFunction>(curVal) ||
-             SVFUtil::isa<SVFMetadataAsValue>(curVal))
+             SVFUtil::isa<MetadataAsValue>(llvmModuleSet()->getLLVMValue(curVal)))
     {
         if (!curBB)
             pag->addGlobalPAGEdge(edge);

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -129,7 +129,6 @@ void SVFIRBuilder::addComplexConsForExt(Value *D, Value *S, const Value* szValue
 void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCallee)
 {
     const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(cs);
-    const SVFCallInst* svfCall = SVFUtil::cast<SVFCallInst>(svfInst);
     const CallICFGNode *callICFGNode = llvmModuleSet()->getCallICFGNode(cs);
 
     if (isHeapAllocExtCallViaRet(callICFGNode))
@@ -141,7 +140,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
     else if (isHeapAllocExtCallViaArg(callICFGNode))
     {
         u32_t arg_pos = LLVMUtil::getHeapAllocHoldingArgPosition(svfCallee);
-        const SVFLLVMValue* arg = svfCall->getArgOperand(arg_pos);
+        const SVFLLVMValue* arg = llvmModuleSet()->getSVFValue(cs->getArgOperand(arg_pos));
         if (arg->getType()->isPointerTy())
         {
             NodeID vnArg = llvmModuleSet()->getValueNode(arg);
@@ -166,7 +165,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
             addComplexConsForExt(cs->getArgOperand(3), cs->getArgOperand(1), nullptr);
         else if(svfCallee->getName().find("bcopy") != std::string::npos)
             addComplexConsForExt(cs->getArgOperand(1), cs->getArgOperand(0), cs->getArgOperand(2));
-        if(svfCall->arg_size() == 3)
+        if(cs->arg_size() == 3)
             addComplexConsForExt(cs->getArgOperand(0), cs->getArgOperand(1), cs->getArgOperand(2));
         else
             addComplexConsForExt(cs->getArgOperand(0), cs->getArgOperand(1), nullptr);
@@ -233,11 +232,11 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
     else if(svfCallee->getName().find("_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_") != std::string::npos)
     {
         // The purpose of this function is to insert a new node into the red-black tree and then rebalance the tree to ensure that the red-black tree properties are maintained.
-        assert(svfCall->arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
+        assert(cs->arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
 
         // We have vArg3 points to the entry of _Rb_tree_node_base { color; parent; left; right; }.
         // Now we calculate the offset from base to vArg3
-        NodeID vnArg3 = llvmModuleSet()->getValueNode(svfCall->getArgOperand(3));
+        NodeID vnArg3 = llvmModuleSet()->getValueNode(llvmModuleSet()->getSVFValue(cs->getArgOperand(3)));
         APOffset offset =
             getAccessPathFromBaseNode(vnArg3).getConstantStructFldIdx();
 
@@ -253,7 +252,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
             const SVFType* elementType = pag->getFlatternedElemType(pag->getTypeLocSetsMap(vnArg3).first,
                                          fields[i].getConstantStructFldIdx());
             NodeID vnD = getGepValVar(cs->getArgOperand(3), fields[i], elementType);
-            NodeID vnS = llvmModuleSet()->getValueNode(svfCall->getArgOperand(1));
+            NodeID vnS = llvmModuleSet()->getValueNode(llvmModuleSet()->getSVFValue(cs->getArgOperand(1)));
             if(vnD && vnS)
                 addStoreEdge(vnS,vnD);
         }

package/svf-llvm/lib/SVFModule.cpp

@@ -35,7 +35,11 @@ SVFModule::~SVFModule()
 {
     for (const SVFFunction* f : FunctionSet)
         delete f;
-    for (const SVFConstant* c : ConstantSet)
+    for (const SVFLLVMValue* v: GlobalSet)
+        delete v;
+    for (const SVFLLVMValue* v: AliasSet)
+        delete v;
+    for (const SVFLLVMValue * c : ConstantSet)
         delete c;
     for (const SVFLLVMValue* o : OtherValueSet)
         delete o;

package/svf-llvm/lib/SymbolTableBuilder.cpp

@@ -592,7 +592,6 @@ const Type* SymbolTableBuilder::inferTypeOfHeapObjOrStaticObj(const Instruction
     const PointerType *originalPType = SVFUtil::dyn_cast<PointerType>(inst->getType());
     const Type* inferedType = nullptr;
     assert(originalPType && "empty type?");
-    const SVFInstruction* svfinst = llvmModuleSet()->getSVFInstruction(inst);
     if(LLVMUtil::isHeapAllocExtCallViaRet(inst))
     {
         if(const Value* v = getFirstUseViaCastInst(inst))
@@ -607,7 +606,7 @@ const Type* SymbolTableBuilder::inferTypeOfHeapObjOrStaticObj(const Instruction
     else if(LLVMUtil::isHeapAllocExtCallViaArg(inst))
     {
         const CallBase* cs = LLVMUtil::getLLVMCallSite(inst);
-        u32_t arg_pos = LLVMUtil::getHeapAllocHoldingArgPosition(SVFUtil::cast<SVFCallInst>(svfinst)->getCalledFunction());
+        u32_t arg_pos = LLVMUtil::getHeapAllocHoldingArgPosition(llvmModuleSet()->getSVFFunction(cs->getCalledFunction()));
         const Value* arg = cs->getArgOperand(arg_pos);
         originalPType = SVFUtil::dyn_cast<PointerType>(arg->getType());
         inferedType = inferObjType(startValue = arg);