svf-lib 1.0.1047 → 1.0.1050

package/SVF-linux/include/SVF-FE/BasicTypes.h

@@ -58,6 +58,7 @@ typedef llvm::ConstantExpr ConstantExpr;
 typedef llvm::ConstantDataArray ConstantDataArray;
 typedef llvm::ConstantData ConstantData;
 typedef llvm::ConstantArray ConstantArray;
+typedef llvm::Constant Constant;
 
 // LLVM Instructions
 typedef llvm::AllocaInst AllocaInst;

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

@@ -91,7 +91,6 @@ typedef llvm::FunctionType FunctionType;
 
 /// LLVM Aliases and constants
 typedef llvm::Argument Argument;
-typedef llvm::Constant Constant;
 typedef llvm::ConstantInt ConstantInt;
 typedef llvm::ConstantPointerNull ConstantPointerNull;
 typedef llvm::GlobalAlias GlobalAlias;

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

@@ -0,0 +1,118 @@
+//===- SymState.h -- Symbolic State----------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SymState.h
+ *
+ *  Created on: 2022/6/21
+ *      Author: Xiao Cheng
+ */
+
+#ifndef SVF_SYMSTATE_H
+#define SVF_SYMSTATE_H
+
+#include "ExeState.h"
+
+namespace SVF
+{
+class SymState
+{
+public:
+    typedef std::string AbstractState;
+
+    SymState(const ExeState &_es, const AbstractState &_as) : exeState(_es), absState(_as)
+    {
+
+    }
+
+    virtual ~SymState()
+    {
+
+    }
+
+    SymState(const SymState &symState) : absState(symState.getAbstractState()),
+        exeState(symState.getExecutionState())
+    {
+    }
+
+
+    const AbstractState& getAbstractState() const
+    {
+        return absState;
+    }
+
+    const ExeState& getExecutionState() const
+    {
+        return exeState;
+    }
+
+    SymState &operator=(const SymState &rhs)
+    {
+        if (*this != rhs)
+        {
+            exeState = rhs.getExecutionState();
+            absState = rhs.getAbstractState();
+        }
+        return *this;
+    }
+
+    /// Overloading Operator==
+    inline bool operator==(const SymState &rhs) const
+    {
+        return absState == rhs.getAbstractState() && exeState = rhs.getExecutionState();
+    }
+
+    /// Overloading Operator!=
+    inline bool operator!=(const SymState &rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    /// Overloading Operator==
+    inline bool operator<(const SymState &rhs) const
+    {
+        if (absState != rhs.getAbstractState())
+            return absState < rhs.getAbstractState();
+        if (exeState != rhs.getExecutionState())
+            return exeState < rhs.getExecutionState();
+        return false;
+    }
+
+private:
+    ExeState exeState;
+    AbstractState absState;
+};
+}
+
+template<>
+struct std::hash<SVF::SymState>
+{
+    size_t operator()(const SVF::SymState &symState) const
+    {
+
+        SVF::Hash<std::pair<SVF::AbstractState, SVF::ExeState>> pairH;
+
+        return pairH(make_pair(symState.getAbstractState(), symState.getExecutionState()));
+    }
+};
+
+#endif //SVF_SYMSTATE_H

package/SVF-osx/include/MTA/MHP.h

@@ -341,7 +341,7 @@ public:
         NodeID parentTid = tct->getParentThread(tid);
         const CxtThread& parentct = tct->getTCTNode(parentTid)->getCxtThread();
         const Function* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
-        return &(SVFUtil::getFunExitBB(parentRoutine)->back());
+        return &(LLVMUtil::getFunExitBB(parentRoutine)->back());
     }
 
     /// Get loop for join site

package/SVF-osx/include/SVF-FE/LLVMUtil.h

@@ -40,7 +40,7 @@
 namespace SVF
 {
 
-namespace SVFUtil
+namespace LLVMUtil
 {
 
 
@@ -86,9 +86,9 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
 {
     const PointerType *refType = nullptr;
     // Case 1: heap object held by *argument, we should get its element type.
-    if (isHeapAllocExtCallViaArg(cs))
+    if (SVFUtil::isHeapAllocExtCallViaArg(cs))
     {
-        int argPos = getHeapAllocHoldingArgPosition(cs);
+        int argPos = SVFUtil::getHeapAllocHoldingArgPosition(cs);
         const Value *arg = cs.getArgument(argPos);
         if (const PointerType *argType = SVFUtil::dyn_cast<PointerType>(arg->getType()))
             refType = SVFUtil::dyn_cast<PointerType>(getPtrElementType(argType));
@@ -96,7 +96,7 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
     // Case 2: heap/static object held by return value.
     else
     {
-        assert((isStaticExtCall(cs) || isHeapAllocExtCallViaRet(cs))
+        assert((SVFUtil::isStaticExtCall(cs) || SVFUtil::isHeapAllocExtCallViaRet(cs))
                && "Must be heap alloc via ret, or static allocation site");
         refType = SVFUtil::dyn_cast<PointerType>(cs.getType());
     }
@@ -132,7 +132,7 @@ inline bool ArgInDeadFunction (const Value * val)
 inline bool ArgInProgEntryFunction (const Value * val)
 {
     return SVFUtil::isa<Argument>(val)
-           && isProgEntryFunction(SVFUtil::cast<Argument>(val)->getParent());
+           && SVFUtil::isProgEntryFunction(SVFUtil::cast<Argument>(val)->getParent());
 }
 /// Return true if this is value in a dead function (function without any caller)
 bool isPtrInDeadFunction (const Value * value);
@@ -145,7 +145,7 @@ bool isPtrInDeadFunction (const Value * value);
 /// Return true if the function does not have a caller (either it is a main function or a dead function)
 inline bool isNoCallerFunction (const Function * fun)
 {
-    return isDeadFunction(fun) || isProgEntryFunction(fun);
+    return isDeadFunction(fun) || SVFUtil::isProgEntryFunction(fun);
 }
 
 /// Return true if the argument in a function does not have a caller
@@ -315,7 +315,7 @@ u32_t getTypeSizeInBytes(const StructType *sty, u32_t field_index);
 //@}
 
 
-} // End namespace SVFUtil
+} // End namespace LLVMUtil
 
 } // End namespace SVF
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1047",
+  "version": "1.0.1050",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {