svf-tools 1.0.987 → 1.0.988

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.987",
+  "version": "1.0.988",
   "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/include/SVFIR/SVFValue.h

@@ -319,7 +319,6 @@ private:
     const SVFFunction* realDefFun;  /// the definition of a function across multiple modules
     std::vector<const SVFBasicBlock*> allBBs;   /// all BasicBlocks of this function
     std::vector<const SVFArgument*> allArgs;    /// all formal arguments of this function
-    std::vector<std::string> annotations; /// annotations of this function
     SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
 
 protected:
@@ -463,16 +462,6 @@ public:
         return  !isNotRet;
     }
 
-    inline const std::vector<std::string>& getAnnotations() const
-    {
-        return annotations;
-    }
-
-    inline void setAnnotations(std::vector<std::string>& annotations)
-    {
-        this->annotations = annotations;
-    }
-
     inline void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const
     {
         return loopAndDom->getExitBlocksOfLoop(bb,exitbbs);

package/svf/include/Util/ExtAPI.h

@@ -43,10 +43,14 @@ namespace SVF
 
 class ExtAPI
 {
+    friend class LLVMModuleSet;
 private:
 
     static ExtAPI *extOp;
 
+    // Map SVFFunction to its annotations
+    Map<const SVFFunction*, std::vector<std::string>> func2Annotations;
+
     // extapi.bc file path
     static std::string extBcPath;
 
@@ -67,6 +71,8 @@ public:
     // Get the annotation of (F)
     std::string getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
 
+    const std::vector<std::string>& getExtFuncAnnotations(const SVFFunction* fun);
+
     // Does (F) have some annotation?
     bool hasExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
 
@@ -94,6 +100,10 @@ public:
     // Should (F) be considered "external" (either not defined in the program
     //   or a user-defined version of a known alloc or no-op)?
     bool is_ext(const SVFFunction *F);
+
+private:
+    // Set the annotation of (F)
+    void setExtFuncAnnotations(const SVFFunction* fun, const std::vector<std::string>& funcAnnotations);
 };
 } // End namespace SVF
 

package/svf/include/Util/SVFUtil.h

@@ -391,19 +391,13 @@ bool isExtCall(const ICFGNode* node);
 
 bool isHeapAllocExtCallViaArg(const CallICFGNode* cs);
 
-bool isHeapAllocExtCallViaArg(const SVFInstruction *inst);
-
-bool isHeapAllocExtCallViaRet(const SVFInstruction *inst);
 
 /// interfaces to be used externally
 bool isHeapAllocExtCallViaRet(const CallICFGNode* cs);
 
 bool isHeapAllocExtCall(const ICFGNode* cs);
 
-inline bool isHeapAllocExtCall(const SVFInstruction *inst)
-{
-    return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
-}
+
 
 //@}
 

package/svf/lib/AE/Svfexe/AEDetector.cpp

@@ -150,7 +150,7 @@ void BufOverflowDetector::detectExtAPI(AbstractState& as,
     AbstractInterpretation::ExtAPIType extType = AbstractInterpretation::UNCLASSIFIED;
 
     // Determine the type of external memory API
-    for (const std::string &annotation : call->getCalledFunction()->getAnnotations())
+    for (const std::string &annotation : ExtAPI::getExtAPI()->getExtFuncAnnotations(call->getCalledFunction()))
     {
         if (annotation.find("MEMCPY") != std::string::npos)
             extType = AbstractInterpretation::MEMCPY;

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -1377,7 +1377,7 @@ void AbstractInterpretation::handleExtAPI(const CallICFGNode *call)
     assert(fun && "SVFFunction* is nullptr");
     ExtAPIType extType = UNCLASSIFIED;
     // get type of mem api
-    for (const std::string &annotation: fun->getAnnotations())
+    for (const std::string &annotation: ExtAPI::getExtAPI()->getExtFuncAnnotations(fun))
     {
         if (annotation.find("MEMCPY") != std::string::npos)
             extType =  MEMCPY;

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -549,7 +549,6 @@ cJSON* SVFIRWriter::contentToJson(const SVFFunction* value)
     F(realDefFun);
     F(allBBs);
     F(allArgs);
-    F(annotations);
 #undef F
     return root;
 }
@@ -2357,7 +2356,6 @@ void SVFIRReader::fill(const cJSON*& fieldJson, SVFFunction* value)
     F(realDefFun);
     F(allBBs);
     F(allArgs);
-    F(annotations);
 #undef F
 }
 

package/svf/lib/Util/ExtAPI.cpp

@@ -161,24 +161,47 @@ std::string ExtAPI::getExtBcPath()
     abort();
 }
 
-std::string ExtAPI::getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation)
+void ExtAPI::setExtFuncAnnotations(const SVFFunction* fun, const std::vector<std::string>& funcAnnotations)
 {
     assert(fun && "Null SVFFunction* pointer");
-    for (const std::string& annotation : fun->getAnnotations())
-        if (annotation.find(funcAnnotation) != std::string::npos)
-            return annotation;
-    return "";
+    func2Annotations[fun] = funcAnnotations;
 }
 
 bool ExtAPI::hasExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation)
 {
     assert(fun && "Null SVFFunction* pointer");
-    for (const std::string& annotation : fun->getAnnotations())
-        if (annotation.find(funcAnnotation) != std::string::npos)
-            return true;
+    auto it = func2Annotations.find(fun);
+    if (it != func2Annotations.end())
+    {
+        for (const std::string& annotation : it->second)
+            if (annotation.find(funcAnnotation) != std::string::npos)
+                return true;
+    }
     return false;
 }
 
+std::string ExtAPI::getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation)
+{
+    assert(fun && "Null SVFFunction* pointer");
+    auto it = func2Annotations.find(fun);
+    if (it != func2Annotations.end())
+    {
+        for (const std::string& annotation : it->second)
+            if (annotation.find(funcAnnotation) != std::string::npos)
+                return annotation;
+    }
+    return "";
+}
+
+const std::vector<std::string>& ExtAPI::getExtFuncAnnotations(const SVFFunction* fun)
+{
+    assert(fun && "Null SVFFunction* pointer");
+    auto it = func2Annotations.find(fun);
+    if (it != func2Annotations.end())
+        return it->second;
+    return func2Annotations[fun];
+}
+
 bool ExtAPI::is_memcpy(const SVFFunction *F)
 {
     return F &&
@@ -232,8 +255,8 @@ bool ExtAPI::is_ext(const SVFFunction* F)
     assert(F && "Null SVFFunction* pointer");
     if (F->isDeclaration() || F->isIntrinsic())
         return true;
-    else if (hasExtFuncAnnotation(F, "OVERWRITE") && F->getAnnotations().size() == 1)
+    else if (hasExtFuncAnnotation(F, "OVERWRITE") && getExtFuncAnnotations(F).size() == 1)
         return false;
     else
-        return !F->getAnnotations().empty();
+        return !getExtFuncAnnotations(F).empty();
 }

package/svf/lib/Util/SVFUtil.cpp

@@ -353,13 +353,6 @@ bool SVFUtil::isHeapAllocExtCallViaArg(const CallICFGNode* cs)
     return isHeapAllocExtFunViaArg(cs->getCalledFunction());
 }
 
-bool SVFUtil::isHeapAllocExtCallViaArg(const SVFInstruction *inst)
-{
-    if(const SVFCallInst* call = SVFUtil::dyn_cast<SVFCallInst>(inst))
-        return isHeapAllocExtFunViaArg(call->getCalledFunction());
-    else
-        return false;
-}
 
 u32_t SVFUtil::getHeapAllocHoldingArgPosition(const CallICFGNode* cs)
 {
@@ -391,14 +384,6 @@ bool SVFUtil::isReallocExtCall(const CallICFGNode* cs)
     return isPtrTy && isReallocExtFun(cs->getCalledFunction());
 }
 
-bool SVFUtil::isHeapAllocExtCallViaRet(const SVFInstruction *inst)
-{
-    bool isPtrTy = inst->getType()->isPointerTy();
-    if(const SVFCallInst* call = SVFUtil::dyn_cast<SVFCallInst>(inst))
-        return isPtrTy && isHeapAllocExtFunViaRet(call->getCalledFunction());
-    else
-        return false;
-}
 
 bool SVFUtil::isRetInstNode(const ICFGNode* node)
 {

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

@@ -61,7 +61,7 @@ public:
     typedef Map<const SVFValue*, const Value*> SVFValue2LLVMValueMap;
     typedef Map<const Type*, SVFType*> LLVMType2SVFTypeMap;
     typedef Map<const Type*, StInfo*> Type2TypeInfoMap;
-    typedef Map<const Function*,  std::vector<std::string>> Fun2AnnoMap;
+    typedef Map<std::string, std::vector<std::string>> Fun2AnnoMap;
 
 private:
     static LLVMModuleSet* llvmModuleSet;
@@ -72,10 +72,6 @@ private:
     std::vector<std::unique_ptr<Module>> owned_modules;
     std::vector<std::reference_wrapper<Module>> modules;
 
-    /// Function declaration to function definition map
-    FunDeclToDefMapTy FunDeclToDefMap;
-    /// Function definition to function declaration map
-    FunDefToDeclsMapTy FunDefToDeclsMap;
     /// Record some "sse_" function declarations used in other ext function definition, e.g., svf_ext_foo(), and svf_ext_foo() used in app functions
     FunctionSetType ExtFuncsVec;
     /// Record annotations of function in extapi.bc
@@ -253,19 +249,6 @@ public:
 
     SVFOtherValue* getSVFOtherValue(const Value* ov);
 
-    /// Remove unused function in extapi.bc module
-    bool isCalledExtFunction(Function* func)
-    {
-        /// if this function func defined in extapi.bc but never used in application code (without any corresponding declared functions).
-        if (func->getParent()->getName().str() == ExtAPI::getExtAPI()->getExtBcPath()
-                && FunDefToDeclsMap.find(func) == FunDefToDeclsMap.end()
-                && std::find(ExtFuncsVec.begin(), ExtFuncsVec.end(), func) == ExtFuncsVec.end())
-        {
-            return true;
-        }
-        return false;
-    }
-
     /// Get the corresponding Function based on its name
     inline const SVFFunction* getSVFFunction(const std::string& name)
     {
@@ -283,45 +266,6 @@ public:
         return nullptr;
     }
 
-    bool hasDefinition(const Function* fun) const
-    {
-        assert(fun->isDeclaration() && "not a function declaration?");
-        FunDeclToDefMapTy::const_iterator it = FunDeclToDefMap.find(fun);
-        return it != FunDeclToDefMap.end();
-    }
-
-    const Function* getDefinition(const Function* fun) const
-    {
-        assert(fun->isDeclaration() && "not a function declaration?");
-        FunDeclToDefMapTy::const_iterator it = FunDeclToDefMap.find(fun);
-        assert(it != FunDeclToDefMap.end() && "has no definition?");
-        return it->second;
-    }
-
-    bool hasDeclaration(const Function* fun) const
-    {
-        if(fun->isDeclaration() && !hasDefinition(fun))
-            return false;
-
-        const Function* funDef = fun;
-        if(fun->isDeclaration() && hasDefinition(fun))
-            funDef = getDefinition(fun);
-
-        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-        return it != FunDefToDeclsMap.end();
-    }
-
-    const FunctionSetType& getDeclaration(const Function* fun) const
-    {
-        const Function* funDef = fun;
-        if(fun->isDeclaration() && hasDefinition(fun))
-            funDef = getDefinition(fun);
-
-        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-        assert(it != FunDefToDeclsMap.end() && "does not have a function definition (body)?");
-        return it->second;
-    }
-
     /// Global to rep
     bool hasGlobalRep(const GlobalVariable* val) const
     {
@@ -400,7 +344,6 @@ private:
     void prePassSchedule();
     void buildSymbolTable() const;
     void collectExtFunAnnotations(const Module* mod);
-    void removeUnusedExtAPIs();
 };
 
 } // End namespace SVF

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

@@ -52,8 +52,6 @@ inline bool isCallSite(const Value* val)
     return SVFUtil::isa<CallBase>(val);
 }
 
-/// Get the definition of a function across multiple modules
-const Function* getDefFunForMultipleModule(const Function* fun);
 
 /// Return LLVM callsite given a value
 inline const CallBase* getLLVMCallSite(const Value* value)
@@ -65,8 +63,7 @@ inline const CallBase* getLLVMCallSite(const Value* value)
 inline const Function* getCallee(const CallBase* cs)
 {
     // FIXME: do we need to strip-off the casts here to discover more library functions
-    const Function* callee = SVFUtil::dyn_cast<Function>(cs->getCalledOperand()->stripPointerCasts());
-    return callee ? getDefFunForMultipleModule(callee) : nullptr;
+    return SVFUtil::dyn_cast<Function>(cs->getCalledOperand()->stripPointerCasts());
 }
 
 /// Return LLVM function if this value is
@@ -291,9 +288,6 @@ inline static DataLayout* getDataLayout(Module* mod)
 void getNextInsts(const Instruction* curInst,
                   std::vector<const Instruction*>& instList);
 
-/// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst,
-                  std::vector<const Instruction*>& instList);
 
 /// Basic block does not have predecessors
 /// map-1.cpp.bc
@@ -306,9 +300,6 @@ inline bool isNoPrecessorBasicBlock(const BasicBlock* bb)
            pred_empty(bb);
 }
 
-/// Get num of BB's predecessors
-u32_t getBBPredecessorNum(const BasicBlock* BB);
-
 /// Check whether a file is an LLVM IR file
 bool isIRFile(const std::string& filename);
 
@@ -316,10 +307,6 @@ bool isIRFile(const std::string& filename);
 void processArguments(int argc, char** argv, int& arg_num, char** arg_value,
                       std::vector<std::string>& moduleNameVec);
 
-/// Helper method to get the size of the type from target data layout
-//@{
-u32_t getTypeSizeInBytes(const Type* type);
-u32_t getTypeSizeInBytes(const StructType* sty, u32_t field_index);
 //@}
 
 const std::string getSourceLoc(const Value* val);
@@ -330,11 +317,6 @@ bool isIntrinsicFun(const Function* func);
 
 /// Get all called funcions in a parent function
 std::vector<const Function *> getCalledFunctions(const Function *F);
-void removeFunAnnotations(Set<Function*>& removedFuncList);
-bool isUnusedGlobalVariable(const GlobalVariable& global);
-void removeUnusedGlobalVariables(Module* module);
-/// Delete unused functions, annotations and global variables in extapi.bc
-void removeUnusedFuncsAndAnnotationsAndGlobalVariables(Set<Function*> removedFuncList);
 // Converts a mangled name to C naming style to match functions in extapi.c.
 std::string restoreFuncName(std::string funcName);
 
@@ -369,6 +351,15 @@ std::string dumpType(const Type* type);
 
 std::string dumpValueAndDbgInfo(const Value* val);
 
+bool isHeapAllocExtCallViaRet(const Instruction *inst);
+
+bool isHeapAllocExtCallViaArg(const Instruction *inst);
+
+inline bool isHeapAllocExtCall(const Instruction *inst)
+{
+    return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
+}
+
 } // End namespace LLVMUtil
 
 } // End namespace SVF

package/svf-llvm/lib/CHGBuilder.cpp

@@ -71,9 +71,9 @@ void CHGBuilder::buildCHG()
         for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
             buildCHGNodes(&(*I));
         for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
-            buildCHGNodes(LLVMUtil::getDefFunForMultipleModule(&(*F)));
+            buildCHGNodes(&(*F));
         for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
-            buildCHGEdges(LLVMUtil::getDefFunForMultipleModule(&(*F)));
+            buildCHGEdges(&(*F));
 
         analyzeVTables(M);
     }