svf-lib 1.0.1277 → 1.0.1279

package/SVF-linux/include/Util/Casting.h

@@ -334,7 +334,7 @@ inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
 // be used to test for a type as well as cast if successful.  This should be
 // used in the context of an if statement like this:
 //
-//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
+//  if (const Instruction* I = dyn_cast<Instruction>(myVal)) { ... }
 //
 
 template <class X, class Y>

package/SVF-linux/include/Util/CxtStmt.h

@@ -42,7 +42,7 @@ class CxtStmt
 {
 public:
     /// Constructor
-    CxtStmt(const CallStrCxt& c, const Instruction* f) :cxt(c), inst(f)
+    CxtStmt(const CallStrCxt& c, const SVFInstruction* f) :cxt(c), inst(f)
     {
     }
     /// Copy constructor
@@ -59,7 +59,7 @@ public:
         return cxt;
     }
     /// Return current statement
-    inline const Instruction* getStmt() const
+    inline const SVFInstruction* getStmt() const
     {
         return inst;
     }
@@ -108,12 +108,12 @@ public:
     /// Dump CxtStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Stmt: " << SVFUtil::getSourceLoc(inst) << " " << SVFUtil::value2String(inst) << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Stmt: " << SVFUtil::getSourceLoc(inst->getLLVMInstruction()) << " " << SVFUtil::value2String(inst->getLLVMInstruction()) << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 protected:
     CallStrCxt cxt;
-    const Instruction* inst;
+    const SVFInstruction* inst;
 };
 
 
@@ -124,7 +124,7 @@ class CxtThreadStmt : public CxtStmt
 {
 public:
     /// Constructor
-    CxtThreadStmt(NodeID t, const CallStrCxt& c, const Instruction* f) :CxtStmt(c,f), tid(t)
+    CxtThreadStmt(NodeID t, const CallStrCxt& c, const SVFInstruction* f) :CxtStmt(c,f), tid(t)
     {
     }
     /// Copy constructor
@@ -174,7 +174,7 @@ public:
     /// Dump CxtThreadStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << SVFUtil::getSourceLoc(inst) << " " << SVFUtil::value2String(inst) << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << SVFUtil::getSourceLoc(inst->getLLVMInstruction()) << " " << SVFUtil::value2String(inst->getLLVMInstruction()) << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 private:
@@ -189,7 +189,7 @@ class CxtThread
 {
 public:
     /// Constructor
-    CxtThread(const CallStrCxt& c, const CallInst* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
+    CxtThread(const CallStrCxt& c, const SVFInstruction* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
     {
     }
     /// Copy constructor
@@ -207,7 +207,7 @@ public:
         return cxt;
     }
     /// Return forksite
-    inline const CallInst* getThread() const
+    inline const SVFInstruction* getThread() const
     {
         return forksite;
     }
@@ -282,7 +282,8 @@ public:
 
         if(forksite)
         {
-            SVFUtil::outs() << "[ Thread: $" << SVFUtil::getSourceLoc(forksite) << "$ " << SVFUtil::value2String(forksite)  << "\t Contexts: " << cxtToStr()
+            SVFUtil::outs() << "[ Thread: $" << SVFUtil::getSourceLoc(forksite->getLLVMInstruction()) << "$ "
+                            << SVFUtil::value2String(forksite->getLLVMInstruction())  << "\t Contexts: " << cxtToStr()
                             << loop << cycle <<"  ]\n";
         }
         else
@@ -293,7 +294,7 @@ public:
     }
 protected:
     CallStrCxt cxt;
-    const CallInst* forksite;
+    const SVFInstruction* forksite;
     bool inloop;
     bool incycle;
 };
@@ -483,8 +484,8 @@ template <> struct std::hash<SVF::CxtStmt>
 {
     size_t operator()(const SVF::CxtStmt& cs) const
     {
-        std::hash<SVF::Instruction*> h;
-        SVF::Instruction* inst = const_cast<SVF::Instruction*> (cs.getStmt());
+        std::hash<SVF::SVFInstruction*> h;
+        SVF::SVFInstruction* inst = const_cast<SVF::SVFInstruction*> (cs.getStmt());
         return h(inst);
     }
 };

package/SVF-linux/include/Util/SVFBasicTypes.h

@@ -196,84 +196,6 @@ enum AliasResult
     PartialAlias,
 };
 
-class SVFValue
-{
-
-public:
-    typedef s64_t GNodeK;
-
-    enum SVFValKind
-    {
-        SVFVal,
-        SVFFunc,
-        SVFGlob,
-        SVFBB,
-        SVFInst,
-    };
-
-private:
-    const std::string value;
-    GNodeK kind;	///< Type of this SVFValue
-public:
-    /// Constructor
-    SVFValue(const std::string& val, SVFValKind k): value(val), kind(k)
-    {
-    }
-
-    /// Get the type of this SVFValue
-    inline GNodeK getKind() const
-    {
-        return kind;
-    }
-
-    /// Add the hash function for std::set (we also can overload operator< to implement this)
-    //  and duplicated elements in the set are not inserted (binary tree comparison)
-    //@{
-    bool operator()(const SVFValue* lhs, const SVFValue* rhs) const
-    {
-        return lhs->value < rhs->value;
-    }
-
-    inline bool operator==(SVFValue* rhs) const
-    {
-        return value == rhs->value;
-    }
-
-    inline bool operator!=(SVFValue* rhs) const
-    {
-        return value != rhs->value;
-    }
-    //@}
-
-    const std::string getName() const
-    {
-        return value;
-    }
-
-    const std::string& getValue() const
-    {
-        return value;
-    }
-
-    /// Overloading operator << for dumping ICFG node ID
-    //@{
-    friend OutStream& operator<< (OutStream &o, const SVFValue &node)
-    {
-        o << node.getName();
-        return o;
-    }
-    //@}
-
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFValue::SVFVal ||
-               node->getKind() == SVFValue::SVFFunc ||
-               node->getKind() == SVFValue::SVFGlob ||
-               node->getKind() == SVFValue::SVFBB ||
-               node->getKind() == SVFValue::SVFInst;
-    }
-};
-
 } // End namespace SVF
 
 

package/SVF-linux/include/Util/SVFInstruction.h

@@ -0,0 +1,40 @@
+#ifndef SVFINSTRUCTION_H_
+#define SVFINSTRUCTION_H_
+
+#include "Util/BasicTypes.h"
+
+namespace SVF
+{
+class SVFFunction;
+
+class SVFInstruction: public SVFValue
+{
+private:
+    const BasicBlock* parentBB;
+    bool isCallBase;
+
+public:
+    SVFInstruction(const std::string instructionName, const BasicBlock* parentBB): SVFValue(instructionName,SVFValue::SVFInst), parentBB(parentBB)
+    {
+    }
+
+    inline const BasicBlock* getParent() const
+    {
+        return parentBB;
+    }
+
+    inline const bool isCallBase() const
+    {
+        return isCallBase;
+    }
+
+    inline const void setIsCallBase(const bool isCallBase)
+    {
+        this->isCallBase = isCallBase;
+    }
+
+};
+
+};
+
+#endif

package/SVF-linux/include/Util/SVFModule.h

@@ -42,38 +42,37 @@ class SVFModule
 {
 public:
     typedef std::vector<const SVFFunction*> FunctionSetType;
-    typedef std::vector<Function*> LLVMFunctionSetType;
-    typedef std::vector<GlobalVariable*> GlobalSetType;
-    typedef std::vector<GlobalAlias*> AliasSetType;
-    typedef Map<const Function*,const SVFFunction*> LLVMFun2SVFFunMap;
+    typedef std::vector<const Function*> LLVMFunctionSetType;
+    typedef std::vector<SVFGlobalValue*> GlobalSetType;
+    typedef std::vector<SVFGlobalValue*> AliasSetType;
+    typedef std::vector<SVFConstantData*> ConstantDataType;
+    typedef std::vector<SVFOtherValue*> OtherValueType;
 
     /// Iterators type def
     typedef FunctionSetType::iterator iterator;
     typedef FunctionSetType::const_iterator const_iterator;
-    typedef LLVMFunctionSetType::iterator llvm_iterator;
-    typedef LLVMFunctionSetType::const_iterator llvm_const_iterator;
     typedef GlobalSetType::iterator global_iterator;
     typedef GlobalSetType::const_iterator const_global_iterator;
     typedef AliasSetType::iterator alias_iterator;
     typedef AliasSetType::const_iterator const_alias_iterator;
+    typedef ConstantDataType::iterator cdata_iterator;
+    typedef ConstantDataType::const_iterator const_cdata_iterator;
+    typedef OtherValueType::iterator ovalue_iterator;
+    typedef OtherValueType::const_iterator const_ovalue_iterator;
 
 private:
     static std::string pagReadFromTxt;
     std::string moduleIdentifier;
     FunctionSetType FunctionSet;  ///< The Functions in the module
-    LLVMFunctionSetType LLVMFunctionSet;  ///< The Functions in the module
     GlobalSetType GlobalSet;      ///< The Global Variables in the module
     AliasSetType AliasSet;        ///< The Aliases in the module
-    LLVMFun2SVFFunMap LLVMFunc2SVFFunc; ///< Map an LLVM Function to an SVF Function
+    ConstantDataType ConstantDataSet;        ///< The ConstantData in the module
+    OtherValueType  OtherValueSet;   ///< All other values in the module
+
     Set<const Value*> argsOfUncalledFunction;
-    Set<const Instruction*> returnInsts;
-    Set<const Value*> nullPtrSyms;
     Set<const Value*> blackholeSyms;
     Set<const Value*> ptrsInUncalledFunctions;
-    Map<const BasicBlock*, const u32_t> bbSuccessorNumMap;
     Map<const PointerType*, const Type*> ptrElementTypeMap;
-    Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>> bbSuccessorPosMap;
-    Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>> bbPredecessorPosMap;
 
 public:
     /// Constructors
@@ -81,14 +80,7 @@ public:
     {
     }
 
-    ~SVFModule()
-    {
-        for (auto * f : FunctionSet)
-            delete f;
-        NodeIDAllocator::unset();
-        ThreadAPI::destroy();
-        ExtAPI::destory();
-    }
+    ~SVFModule();
 
     static inline void setPagFromTXT(std::string txt)
     {
@@ -114,45 +106,28 @@ public:
     inline void addFunctionSet(SVFFunction* svfFunc)
     {
         FunctionSet.push_back(svfFunc);
-        LLVMFunctionSet.push_back(svfFunc->getLLVMFun());
-        LLVMFunc2SVFFunc[svfFunc->getLLVMFun()] = svfFunc;
     }
-    inline void addGlobalSet(GlobalVariable* glob)
+    inline void addGlobalSet(SVFGlobalValue* glob)
     {
         GlobalSet.push_back(glob);
     }
-    inline void addAliasSet(GlobalAlias* alias)
+    inline void addAliasSet(SVFGlobalValue* alias)
     {
         AliasSet.push_back(alias);
     }
-    ///@}
-
-    inline const SVFFunction* getSVFFunction(const Function* fun) const
-    {
-        LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);
-        assert(it!=LLVMFunc2SVFFunc.end() && "SVF Function not found!");
-        return it->second;
-    }
-
-    /// Iterators
-    ///@{
-    llvm_iterator llvmFunBegin()
-    {
-        return LLVMFunctionSet.begin();
-    }
-    llvm_const_iterator llvmFunBegin() const
-    {
-        return LLVMFunctionSet.begin();
-    }
-    llvm_iterator llvmFunEnd()
+    inline void addConstantData(SVFConstantData* cd)
     {
-        return LLVMFunctionSet.end();
+        ConstantDataSet.push_back(cd);
     }
-    llvm_const_iterator llvmFunEnd() const
+    inline void addOtherValue(SVFOtherValue* ov)
     {
-        return LLVMFunctionSet.end();
+        OtherValueSet.push_back(ov);
     }
 
+    ///@}
+
+    /// Iterators
+    ///@{
     iterator begin()
     {
         return FunctionSet.begin();
@@ -203,13 +178,30 @@ public:
     {
         return AliasSet.end();
     }
+
+    cdata_iterator cdata_begin()
+    {
+        return ConstantDataSet.begin();
+    }
+    const_cdata_iterator cdata_begin() const
+    {
+        return ConstantDataSet.begin();
+    }
+    cdata_iterator cdata_end()
+    {
+        return ConstantDataSet.end();
+    }
+    const_cdata_iterator cdata_end() const
+    {
+        return ConstantDataSet.end();
+    }
     ///@}
 
     const std::string& getModuleIdentifier() const
     {
         if (pagReadFromTxt.empty())
         {
-            assert(moduleIdentifier.empty()==false && "No LLVM module found! Are you reading from a file other than LLVM-IR?");
+            assert(moduleIdentifier.empty()==false && "No module found! Are you reading from a file other than LLVM-IR?");
             return moduleIdentifier;
         }
         else
@@ -222,45 +214,36 @@ public:
     {
         return FunctionSet;
     }
-
-    inline const Set<const Value*>& getNullPtrSyms() const
+    inline const ConstantDataType& getConstantDataSet() const
     {
-        return nullPtrSyms;
+        return ConstantDataSet;
     }
-
-    inline const Set<const Value*>& getBlackholeSyms() const
+    inline const GlobalSetType& getGlobalSet() const
     {
-        return blackholeSyms;
+        return GlobalSet;
     }
-
-    inline const Set<const Value*>& getArgsOfUncalledFunction() const
+    inline const AliasSetType& getAliasSet() const
     {
-        return argsOfUncalledFunction;
+        return AliasSet;
     }
-
-    inline const Set<const Instruction*>& getReturns() const
+    inline const OtherValueType& getOtherValueSet() const
     {
-        return returnInsts;
+        return OtherValueSet;
     }
 
-    inline const Set<const Value*>& getPtrsInUncalledFunctions() const
-    {
-        return ptrsInUncalledFunctions;
-    }
-
-    inline const Map<const BasicBlock*, const u32_t>& getBBSuccessorNumMap()
+    inline const Set<const Value*>& getBlackholeSyms() const
     {
-        return bbSuccessorNumMap;
+        return blackholeSyms;
     }
 
-    inline const Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>& getBBSuccessorPosMap()
+    inline const Set<const Value*>& getArgsOfUncalledFunction() const
     {
-        return bbSuccessorPosMap;
+        return argsOfUncalledFunction;
     }
 
-    inline const Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>& getBBPredecessorPosMap()
+    inline const Set<const Value*>& getPtrsInUncalledFunctions() const
     {
-        return bbPredecessorPosMap;
+        return ptrsInUncalledFunctions;
     }
 
     inline const Map<const PointerType*, const Type*>& getPtrElementTypeMap()
@@ -268,75 +251,26 @@ public:
         return ptrElementTypeMap;
     }
 
-    inline void addBBSuccessorNum(const BasicBlock *bb, const u32_t num)
-    {
-        bbSuccessorNumMap.insert({bb,num});
-    }
-
-    inline void addBBSuccessorPos(const BasicBlock *bb, const BasicBlock* succ,const u32_t pos)
-    {
-        Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>::iterator bbSuccessorPosMapIter = bbSuccessorPosMap.find(bb);
-        if(bbSuccessorPosMapIter != bbSuccessorPosMap.end())
-        {
-            Map<const BasicBlock*, const u32_t> foundValue = bbSuccessorPosMapIter->second;
-            foundValue.insert({succ,pos});
-            bbSuccessorPosMap.insert({bb,foundValue});
-        }
-        else
-        {
-            Map<const BasicBlock*, const u32_t> valueMap;
-            valueMap.insert({succ,pos});
-            bbSuccessorPosMap.insert({bb,valueMap});
-        }
-    }
-
-    inline void addBBPredecessorPos(const BasicBlock *bb, const BasicBlock* Pred,const u32_t pos)
-    {
-        Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>::iterator bbPredecessorPosMapIter = bbPredecessorPosMap.find(bb);
-        if(bbPredecessorPosMapIter != bbPredecessorPosMap.end())
-        {
-            Map<const BasicBlock*, const u32_t> foundValue = bbPredecessorPosMapIter->second;
-            foundValue.insert({Pred,pos});
-            bbPredecessorPosMap.insert({bb,foundValue});
-        }
-        else
-        {
-            Map<const BasicBlock*, const u32_t> valueMap;
-            valueMap.insert({Pred,pos});
-            bbPredecessorPosMap.insert({bb,valueMap});
-        }
-    }
-
     inline void addptrElementType(const PointerType* ptrType, const Type* type)
     {
         ptrElementTypeMap.insert({ptrType, type});
     }
 
-    inline void addPtrInUncalledFunction (const Value * value)
+    inline void addPtrInUncalledFunction (const Value*  value)
     {
         ptrsInUncalledFunctions.insert(value);
     }
 
-    inline void addNullPtrSyms(const Value *val)
-    {
-        nullPtrSyms.insert(val);
-    }
-
-    inline void addBlackholeSyms(const Value *val)
+    inline void addBlackholeSyms(const Value* val)
     {
         blackholeSyms.insert(val);
     }
 
-    inline void addArgsOfUncalledFunction(const Value *val)
+    inline void addArgsOfUncalledFunction(const Value* val)
     {
         argsOfUncalledFunction.insert(val);
     }
 
-    inline void addReturn(const Instruction* inst)
-    {
-        returnInsts.insert(inst);
-    }
-
 };
 
 } // End namespace SVF