svf-lib 1.0.1164 → 1.0.1165

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

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

package/SVF-osx/include/MemoryModel/SymbolTableInfo.h

@@ -88,8 +88,6 @@ private:
     IDToMemMapTy		objMap;		///< map a memory sym id to its obj
 
     CallSiteSet callSiteSet;
-    Set<const Value*> nullPtrSyms;
-    Set<const Value*> blackholeSyms;
 
     // Singleton pattern here to enable instance of SymbolTableInfo can only be created once.
     static SymbolTableInfo* symInfo;
@@ -165,6 +163,13 @@ public:
     // @{
     static bool isNullPtrSym(const Value *val);
     static bool isBlackholeSym(const Value *val);
+    static bool isArgOfUncalledFunction(const Value *val);
+    static bool isReturn(const Instruction *inst);
+    static bool isPtrInUncalledFunction (const Value * value);
+    static const u32_t getBBSuccessorNum(const BasicBlock *bb);
+    static const Type* getPtrElementType(const PointerType* pty);
+    static const u32_t getBBSuccessorPos(const BasicBlock *BB, const BasicBlock *Succ);
+    static const u32_t getBBPredecessorPos(const BasicBlock *BB, const BasicBlock *Pred);
 
     static inline bool isBlkPtr(NodeID id)
     {

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

@@ -118,13 +118,13 @@ bool isObject (const Value * ref);
 /// function address is not taken and never be used in call or invoke instruction
 //@{
 /// whether this is a function without any possible caller?
-bool isDeadFunction (const Function * fun);
+bool isUncalledFunction (const Function * fun);
 
 /// whether this is an argument in dead function
 inline bool ArgInDeadFunction (const Value * val)
 {
     return SVFUtil::isa<Argument>(val)
-           && isDeadFunction(SVFUtil::cast<Argument>(val)->getParent());
+           && isUncalledFunction(SVFUtil::cast<Argument>(val)->getParent());
 }
 //@}
 
@@ -135,7 +135,7 @@ inline bool ArgInProgEntryFunction (const Value * val)
            && 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);
+bool isPtrInUncalledFunction (const Value * value);
 //@}
 
 //@}
@@ -145,11 +145,11 @@ 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) || SVFUtil::isProgEntryFunction(fun);
+    return isUncalledFunction(fun) || SVFUtil::isProgEntryFunction(fun);
 }
 
 /// Return true if the argument in a function does not have a caller
-inline bool ArgInNoCallerFunction (const Value * val)
+inline bool isArgOfUncalledFunction (const Value * val)
 {
     return SVFUtil::isa<Argument>(val)
            && isNoCallerFunction(SVFUtil::cast<Argument>(val)->getParent());
@@ -160,12 +160,14 @@ inline bool ArgInNoCallerFunction (const Value * val)
 bool functionDoesNotRet (const Function * fun);
 
 /// Get reachable basic block from function entry
-void getFunReachableBBs (const Function * fun, DominatorTree* dt,std::vector<const BasicBlock*>& bbs);
+void getFunReachableBBs (const SVFFunction* svfFun, std::vector<const BasicBlock*>& bbs);
 
 /// Get function exit basic block
 /// FIXME: this back() here is only valid when UnifyFunctionExitNodes pass is invoked
-inline const BasicBlock* getFunExitBB(const Function* fun)
+inline const BasicBlock* getFunExitBB(const SVFFunction* svfFun)
 {
+    const Function* fun = svfFun->getLLVMFun();
+    assert(!SVFUtil::isExtCall(svfFun) && "The function cannot be an external call");
     return &fun->back();
 }
 /// Strip off the constant casts

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

@@ -58,6 +58,8 @@ public:
     //@{
     void collectNullPtrBlackholeSyms(const Value *val);
 
+    void collectSpecialSym(const Value* val);
+
     void collectSym(const Value *val);
 
     void collectVal(const Value *val);

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

@@ -129,16 +129,26 @@ private:
     bool isDecl;
     bool isIntri;
     Function* fun;
+    BasicBlock* exitBB;
+    std::vector<const BasicBlock*> reachableBBs;
+    bool isUncalled;
+    bool isNotRet;
 public:
     SVFFunction(const std::string& val): SVFValue(val,SVFValue::SVFFunc),
-        isDecl(false), isIntri(false), fun(nullptr)
+        isDecl(false), isIntri(false), fun(nullptr), exitBB(nullptr), isUncalled(false), isNotRet(false)
     {
     }
 
     SVFFunction(Function* f): SVFValue(f->getName().str(),SVFValue::SVFFunc),
-        isDecl(f->isDeclaration()), isIntri(f->isIntrinsic()), fun(f)
+        isDecl(f->isDeclaration()), isIntri(f->isIntrinsic()), fun(f), exitBB(nullptr), isUncalled(false), isNotRet(false)
     {
     }
+
+    SVFFunction(Function* f, BasicBlock* exitBB, std::vector<const BasicBlock*> reachableBBs): SVFValue(f->getName().str(),SVFValue::SVFFunc),
+        isDecl(f->isDeclaration()), isIntri(f->isIntrinsic()), fun(f), exitBB(exitBB), reachableBBs(reachableBBs), isUncalled(false), isNotRet(false)
+    {
+    }
+
     inline Function* getLLVMFun() const
     {
         assert(fun && "no LLVM Function found!");
@@ -170,6 +180,46 @@ public:
         return getLLVMFun()->isVarArg();
     }
 
+    inline const std::vector<const BasicBlock*>& getReachableBBs() const
+    {
+        return reachableBBs;
+    }
+
+    inline const bool isUncalledFunction() const
+    {
+        return isUncalled;
+    }
+
+    inline const void setIsUncalledFunction(const bool isUncalledFunction)
+    {
+        this->isUncalled = isUncalledFunction;
+    }
+
+    inline const void setIsNotRet(const bool doesNotRet)
+    {
+        this->isNotRet = doesNotRet;
+    }
+
+    inline const void setExitBB(BasicBlock* exitBB)
+    {
+        this->exitBB = exitBB;
+    }
+
+    inline const void setReachableBBs(std::vector<const BasicBlock*> reachableBBs)
+    {
+        this->reachableBBs = reachableBBs;
+    }
+
+    inline const bool isNotRetFunction() const
+    {
+        return isNotRet;
+    }
+
+    inline const BasicBlock* getExitBB() const
+    {
+        return this->exitBB;
+    }
+
     // Dump Control Flow Graph of llvm function, with instructions
     void viewCFG();
 

package/SVF-osx/include/Util/DPItem.h

@@ -615,4 +615,4 @@ struct std::hash<SVF::ContextCond>
         return h(cc.getContexts());
     }
 };
-#endif /* DPITEM_H_ */
+#endif /* DPITEM_H_ */

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

@@ -65,6 +65,16 @@ private:
     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
+    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
     SVFModule(std::string moduleName = "") : moduleIdentifier(moduleName)
@@ -101,12 +111,11 @@ public:
     void buildSymbolTableInfo();
 
     ///@{
-    inline void addFunctionSet(Function* fun)
+    inline void addFunctionSet(SVFFunction* svfFunc)
     {
-        SVFFunction* svfFunc = new SVFFunction(fun);
         FunctionSet.push_back(svfFunc);
-        LLVMFunctionSet.push_back(fun);
-        LLVMFunc2SVFFunc[fun] = svfFunc;
+        LLVMFunctionSet.push_back(svfFunc->getLLVMFun());
+        LLVMFunc2SVFFunc[svfFunc->getLLVMFun()] = svfFunc;
     }
     inline void addGlobalSet(GlobalVariable* glob)
     {
@@ -209,6 +218,125 @@ public:
         }
     }
 
+    inline const FunctionSetType& getFunctionSet() const
+    {
+        return FunctionSet;
+    }
+
+    inline const Set<const Value*>& getNullPtrSyms() const
+    {
+        return nullPtrSyms;
+    }
+
+    inline const Set<const Value*>& getBlackholeSyms() const
+    {
+        return blackholeSyms;
+    }
+
+    inline const Set<const Value*>& getArgsOfUncalledFunction() const
+    {
+        return argsOfUncalledFunction;
+    }
+
+    inline const Set<const Instruction*>& getReturns() const
+    {
+        return returnInsts;
+    }
+
+    inline const Set<const Value*>& getPtrsInUncalledFunctions() const
+    {
+        return ptrsInUncalledFunctions;
+    }
+
+    inline const Map<const BasicBlock*, const u32_t>& getBBSuccessorNumMap()
+    {
+        return bbSuccessorNumMap;
+    }
+
+    inline const Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>& getBBSuccessorPosMap()
+    {
+        return bbSuccessorPosMap;
+    }
+
+    inline const Map<const BasicBlock*, const Map<const BasicBlock*, const u32_t>>& getBBPredecessorPosMap()
+    {
+        return bbPredecessorPosMap;
+    }
+
+    inline const Map<const PointerType*, const Type*>& getPtrElementTypeMap()
+    {
+        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)
+    {
+        ptrsInUncalledFunctions.insert(value);
+    }
+
+    inline void addNullPtrSyms(const Value *val)
+    {
+        nullPtrSyms.insert(val);
+    }
+
+    inline void addBlackholeSyms(const Value *val)
+    {
+        blackholeSyms.insert(val);
+    }
+
+    inline void addArgsOfUncalledFunction(const Value *val)
+    {
+        argsOfUncalledFunction.insert(val);
+    }
+
+    inline void addReturn(const Instruction* inst)
+    {
+        returnInsts.insert(inst);
+    }
+
 };
 
 } // End namespace SVF

package/package.json

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