svf-lib 1.0.2088 → 1.0.2090

package/SVF-linux/Release-build/include/AE/Svfexe/AEDetector.h

@@ -218,21 +218,9 @@ public:
      */
     void addBugToReporter(const AEException& e, const ICFGNode* node)
     {
-        const SVFInstruction* inst = nullptr;
-
-        // Determine the instruction associated with the ICFG node
-        if (const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(node))
-        {
-            inst = call->getCallSite(); // If the node is a call node, get the call site instruction
-        }
-        else
-        {
-            inst = node->getSVFStmts().back()->getInst(); // Otherwise, get the last instruction of the node's
-            // statements
-        }
 
         GenericBug::EventStack eventStack;
-        SVFBugEvent sourceInstEvent(SVFBugEvent::EventType::SourceInst, inst);
+        SVFBugEvent sourceInstEvent(SVFBugEvent::EventType::SourceInst, node);
         eventStack.push_back(sourceInstEvent); // Add the source instruction event to the event stack
 
         if (eventStack.empty())

package/SVF-linux/Release-build/include/Graphs/ICFGNode.h

@@ -132,6 +132,8 @@ public:
 
     virtual const std::string toString() const;
 
+    virtual const std::string getSourceLoc() const = 0;
+
     void dump() const;
 
 protected:
@@ -172,6 +174,11 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return "Global ICFGNode";
+    }
 };
 
 /*!
@@ -218,6 +225,11 @@ public:
     //@}
 
     const std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return inst->getSourceLoc();
+    }
 };
 
 class InterICFGNode : public ICFGNode
@@ -252,6 +264,7 @@ public:
                || node->getNodeKind() == FunRetBlock;
     }
     //@}
+    virtual const std::string getSourceLoc() const = 0;
 };
 
 
@@ -316,6 +329,11 @@ public:
     //@}
 
     const virtual std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return "function entry: " + fun->getSourceLoc();
+    }
 };
 
 /*!
@@ -377,6 +395,11 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return "function ret: " + fun->getSourceLoc();
+    }
 };
 
 /*!
@@ -478,6 +501,11 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return "CallICFGNode: " + cs->getSourceLoc();
+    }
 };
 
 
@@ -554,6 +582,11 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    virtual const std::string getSourceLoc() const
+    {
+        return "RetICFGNode: " + cs->getSourceLoc();
+    }
 };
 
 } // End namespace SVF

package/SVF-linux/Release-build/include/Graphs/VFGNode.h

@@ -181,12 +181,6 @@ public:
                || node->getNodeKind() == Store
                || node->getNodeKind() == Load;
     }
-
-    inline const SVFInstruction* getInst() const
-    {
-        /// should return a valid instruction unless it is a global PAGEdge
-        return pagEdge->getInst();
-    }
     //@}
 
     const SVFValue* getValue() const override;

package/SVF-linux/Release-build/include/MTA/LockAnalysis.h

@@ -339,7 +339,7 @@ private:
     void handleIntra(const CxtStmt& cts);
 
     /// Handle call relations
-    void handleCallRelation(CxtLockProc& clp, const CallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtLockProc& clp, const CallGraphEdge* cgEdge, const CallICFGNode* call);
 
     /// Return true it a lock matches an unlock
     bool isAliasedLocks(const CxtLock& cl1, const CxtLock& cl2)

package/SVF-linux/Release-build/include/MTA/TCT.h

@@ -167,15 +167,6 @@ public:
     {
         destroy();
     }
-    /// Get CallICFGNode given inst
-    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
-    {
-        return pta->getICFG()->getCallICFGNode(inst);
-    }
-    const ICFGNode* getICFGNode(const SVFInstruction* inst)
-    {
-        return pta->getICFG()->getICFGNode(inst);
-    }
 
     /// Get SVFFModule
     SVFModule* getSVFModule() const
@@ -497,7 +488,7 @@ private:
     //@}
 
     /// Handle call relations
-    void handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, const CallICFGNode* call);
 
     /// Get or create a tct node based on CxtThread
     //@{

package/SVF-linux/Release-build/include/SABER/SaberCondAllocator.h

@@ -49,7 +49,7 @@ class SaberCondAllocator
 public:
 
     typedef Z3Expr Condition;   /// z3 condition
-    typedef Map<u32_t, const SVFInstruction *> IndexToTermInstMap; /// id to instruction map for z3
+    typedef Map<u32_t, const ICFGNode*> IndexToTermInstMap; /// id to instruction map for z3
     typedef Map<u32_t,Condition> CondPosMap;		///< map a branch to its Condition
     typedef Map<const SVFBasicBlock*, CondPosMap > BBCondMap;	/// map bb to a Condition
     typedef Set<const SVFBasicBlock*> BasicBlockSet;
@@ -118,21 +118,21 @@ public:
     }
 
     /// Allocate a new condition
-    Condition newCond(const SVFInstruction* inst);
+    Condition newCond(const ICFGNode* inst);
 
     /// Perform path allocation
     void allocate(const SVFModule* module);
 
     /// Get/Set instruction based on Z3 expression id
     //{@
-    inline const SVFInstruction* getCondInst(u32_t id) const
+    inline const ICFGNode* getCondInst(u32_t id) const
     {
         IndexToTermInstMap::const_iterator it = idToTermInstMap.find(id);
         assert(it != idToTermInstMap.end() && "this should be a fresh condition");
         return it->second;
     }
 
-    inline void setCondInst(const Condition &condition, const SVFInstruction* inst)
+    inline void setCondInst(const Condition &condition, const ICFGNode* inst)
     {
         assert(idToTermInstMap.find(condition.id()) == idToTermInstMap.end() && "this should be a fresh condition");
         idToTermInstMap[condition.id()] = inst;
@@ -235,7 +235,7 @@ public:
 
 
     /// mark neg Z3 expression
-    inline void setNegCondInst(const Condition &condition, const SVFInstruction* inst)
+    inline void setNegCondInst(const Condition &condition, const ICFGNode* inst)
     {
         setCondInst(condition, inst);
         negConds.set(condition.id());

package/SVF-linux/Release-build/include/Util/SVFBugReport.h

@@ -62,10 +62,10 @@ public:
 
 protected:
     u32_t typeAndInfoFlag;
-    const SVFInstruction *eventInst;
+    const ICFGNode *eventInst;
 
 public:
-    SVFBugEvent(u32_t typeAndInfoFlag, const SVFInstruction *eventInst): typeAndInfoFlag(typeAndInfoFlag), eventInst(eventInst) { };
+    SVFBugEvent(u32_t typeAndInfoFlag, const ICFGNode *eventInst): typeAndInfoFlag(typeAndInfoFlag), eventInst(eventInst) { };
     virtual ~SVFBugEvent() = default;
 
     inline u32_t getEventType() const

package/SVF-linux/Release-build/include/Util/SVFUtil.h

@@ -206,7 +206,12 @@ inline bool isNonInstricCallSite(const ICFGNode* inst)
     return isCallSite(inst);
 }
 
-/// Return LLVM callsite given an instruction
+
+
+/// Return callsite given an instruction
+CallSite getSVFCallSite(const ICFGNode* inst);
+
+/// Return callsite given an instruction
 inline CallSite getSVFCallSite(const SVFInstruction* inst)
 {
     assert(isCallSite(inst) && "not a callsite?");

package/SVF-osx/Release-build/include/Util/SVFUtil.h

@@ -169,14 +169,8 @@ void dumpPointsToList(const PointsToList& ptl);
 /// Return true if it is an llvm intrinsic instruction
 bool isIntrinsicInst(const SVFInstruction* inst);
 bool isIntrinsicInst(const ICFGNode* inst);
-
 //@}
 
-/// Whether an instruction is a call or invoke instruction
-inline bool isCallSite(const SVFInstruction* inst)
-{
-    return SVFUtil::isa<SVFCallInst>(inst);
-}
 /// Whether an instruction is a call or invoke instruction
 inline bool isCallSite(const SVFValue* val)
 {
@@ -207,31 +201,15 @@ inline bool isNonInstricCallSite(const ICFGNode* inst)
 }
 
 
-
 /// Return callsite given an instruction
 CallSite getSVFCallSite(const ICFGNode* inst);
 
-/// Return callsite given an instruction
-inline CallSite getSVFCallSite(const SVFInstruction* inst)
-{
-    assert(isCallSite(inst) && "not a callsite?");
-    CallSite cs(inst);
-    return cs;
-}
 
 /// Match arguments for callsite at caller and callee
 /// if the arg size does not match then we do not need to connect this parameter
 /// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
-bool matchArgs(const CallSite cs, const SVFFunction* callee);
+bool matchArgs(const CallICFGNode* cs, const SVFFunction* callee);
 
-/// Return LLVM callsite given a value
-inline CallSite getSVFCallSite(const SVFValue* value)
-{
-    assert(isCallSite(value) && "not a callsite?");
-    const SVFCallInst* svfInst = SVFUtil::cast<SVFCallInst>(value);
-    CallSite cs(svfInst);
-    return cs;
-}
 
 /// Split into two substrings around the first occurrence of a separator string.
 inline std::vector<std::string> split(const std::string& s, char separator)
@@ -423,7 +401,7 @@ inline bool isArgOfUncalledFunction(const SVFValue* svfval)
 
 /// Return thread fork function
 //@{
-inline const SVFValue* getForkedFun(const SVFInstruction *inst)
+inline const SVFValue* getForkedFun(const ICFGNode *inst)
 {
     return ThreadAPI::getThreadAPI()->getForkedFun(inst);
 }
@@ -488,7 +466,7 @@ inline bool isReallocExtCall(const CallSite cs)
 
 /// Return true if this is a thread creation call
 ///@{
-inline bool isThreadForkCall(const SVFInstruction *inst)
+inline bool isThreadForkCall(const ICFGNode *inst)
 {
     return ThreadAPI::getThreadAPI()->isTDFork(inst);
 }
@@ -496,49 +474,49 @@ inline bool isThreadForkCall(const SVFInstruction *inst)
 
 /// Return true if this is a thread join call
 ///@{
-inline bool isThreadJoinCall(const CallSite cs)
+inline bool isThreadJoinCall(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDJoin(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->isTDJoin(cs);
 }
 //@}
 
 /// Return true if this is a thread exit call
 ///@{
-inline bool isThreadExitCall(const CallSite cs)
+inline bool isThreadExitCall(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDExit(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->isTDExit(cs);
 }
 //@}
 
 /// Return true if this is a lock acquire call
 ///@{
-inline bool isLockAquireCall(const CallSite cs)
+inline bool isLockAquireCall(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDAcquire(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->isTDAcquire(cs);
 }
 //@}
 
 /// Return true if this is a lock acquire call
 ///@{
-inline bool isLockReleaseCall(const CallSite cs)
+inline bool isLockReleaseCall(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDRelease(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->isTDRelease(cs);
 }
 //@}
 
 /// Return true if this is a barrier wait call
 //@{
-inline bool isBarrierWaitCall(const CallSite cs)
+inline bool isBarrierWaitCall(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDBarWait(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->isTDBarWait(cs);
 }
 //@}
 
 /// Return sole argument of the thread routine
 //@{
-inline const SVFValue* getActualParmAtForkSite(const CallSite cs)
+inline const SVFValue* getActualParmAtForkSite(const ICFGNode* cs)
 {
-    return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs.getInstruction());
+    return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs);
 }
 //@}
 

package/SVF-osx/Release-build/include/Util/ThreadAPI.h

@@ -37,6 +37,7 @@ namespace SVF
 
 class SVFModule;
 class ICFGNode;
+class CallICFGNode;
 
 /*
  * ThreadAPI class contains interfaces for pthread programs
@@ -121,8 +122,6 @@ public:
     /// Return the callee/callsite/func
     //@{
     const SVFFunction* getCallee(const ICFGNode *inst) const;
-    const SVFFunction* getCallee(const SVFInstruction *inst) const;
-    const CallSite getSVFCallSite(const SVFInstruction *inst) const;
     const CallSite getSVFCallSite(const ICFGNode *inst) const;
     //@}
 
@@ -132,10 +131,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_FORK;
     }
-    inline bool isTDFork(const SVFInstruction* cs) const
-    {
-        return getType(getCallee(cs)) == TD_FORK;
-    }
     //@}
 
     /// Return arguments/attributes of pthread_create / hare_parallel_for
@@ -148,13 +143,6 @@ public:
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(0);
     }
-    inline const SVFValue* getForkedThread(const SVFInstruction* inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(0);
-    }
-
     /// Return the third argument of the call,
     /// Note that, it could be function type or a void* pointer
     inline const SVFValue* getForkedFun(const ICFGNode *inst) const
@@ -163,12 +151,6 @@ public:
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(2);
     }
-    inline const SVFValue* getForkedFun(const SVFInstruction* inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(2);
-    }
 
     /// Return the forth argument of the call,
     /// Note that, it is the sole argument of start routine ( a void* pointer )
@@ -178,12 +160,6 @@ public:
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(3);
     }
-    inline const SVFValue* getActualParmAtForkSite(const SVFInstruction* inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(3);
-    }
     //@}
 
     /// Return true if this call wait for a worker thread
@@ -192,10 +168,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_JOIN;
     }
-    inline bool isTDJoin(const SVFInstruction* inst) const
-    {
-        return getType(getCallee(inst)) == TD_JOIN;
-    }
     //@}
 
     /// Return arguments/attributes of pthread_join
@@ -211,12 +183,6 @@ public:
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(1);
     }
-    inline const SVFValue* getRetParmAtJoinedSite(const SVFInstruction* inst) const
-    {
-        assert(isTDJoin(inst) && "not a thread join function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(1);
-    }
     //@}
 
 
@@ -226,11 +192,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_EXIT;
     }
-
-    inline bool isTDExit(const SVFInstruction* inst) const
-    {
-        return getType(getCallee(inst)) == TD_EXIT;
-    }
     //@}
 
     /// Return true if this call acquire a lock
@@ -239,11 +200,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_ACQUIRE;
     }
-
-    inline bool isTDAcquire(const SVFInstruction* inst) const
-    {
-        return getType(getCallee(inst)) == TD_ACQUIRE;
-    }
     //@}
 
     /// Return true if this call release a lock
@@ -252,11 +208,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_RELEASE;
     }
-
-    inline bool isTDRelease(const SVFInstruction* inst) const
-    {
-        return getType(getCallee(inst)) == TD_RELEASE;
-    }
     //@}
 
     /// Return lock value
@@ -271,11 +222,6 @@ public:
     {
         return getType(getCallee(inst)) == TD_BAR_WAIT;
     }
-
-    inline bool isTDBarWait(const SVFInstruction* inst) const
-    {
-        return getType(getCallee(inst)) == TD_BAR_WAIT;
-    }
     //@}
 
     void performAPIStat(SVFModule* m);

package/package.json

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