svf-lib 1.0.1621 → 1.0.1623

package/SVF-linux/svf/include/Util/SVFUtil.h

@@ -202,7 +202,7 @@ inline CallSite getSVFCallSite(const SVFInstruction* inst)
 
 /// 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 paramter number)
+/// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
 bool matchArgs(const SVFInstruction* cs, const SVFFunction* callee);
 
 /// Return LLVM callsite given a value
@@ -304,17 +304,21 @@ bool startAnalysisLimitTimer(unsigned timeLimit);
 void stopAnalysisLimitTimer(bool limitTimerSet);
 
 /// Return true if the call is an external call (external library in function summary table)
-/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
+/// If the library function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
 //@{
 inline bool isExtCall(const SVFFunction* fun)
 {
     return fun && ExtAPI::getExtAPI()->is_ext(fun);
 }
 
-// Return true if extern function contains memset_like or memcpy_like operations
-inline bool isMemSetOrCpyExtFun(const SVFFunction* fun)
+inline bool isMemcpyExtFun(const SVFFunction* fun)
 {
-    return fun && ExtAPI::getExtAPI()->is_memset_or_memcpy(fun);
+    return fun && ExtAPI::getExtAPI()->is_memcpy(fun);
+}
+
+inline bool isMemsetExtFun(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->is_memset(fun);
 }
 
 /// Return true if the call is a heap allocator/reallocator
@@ -346,14 +350,6 @@ inline bool isReallocExtFun(const SVFFunction* fun)
     return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
 }
 
-/// Return true if the call is a heap dealloc or not
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isDeallocExtFun(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_dealloc(fun));
-}
-
 /// Return true if the call is a static global call
 //@{
 /// note that this function is not suppose to be used externally
@@ -498,17 +494,6 @@ inline bool isReallocExtCall(const SVFInstruction *inst)
 }
 //@}
 
-inline bool isDeallocExtCall(const CallSite cs)
-{
-    return isDeallocExtFun(getCallee(cs));
-}
-
-inline bool isDeallocExtCall(const SVFInstruction *inst)
-{
-    return isDeallocExtFun(getCallee(inst));
-}
-//@}
-
 inline bool isStaticExtCall(const CallSite cs)
 {
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
@@ -643,7 +628,7 @@ inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
 }
 //@}
 
-/// Return the task data argument of the parallel_for rountine
+/// Return the task data argument of the parallel_for routine
 //@{
 inline const SVFValue* getTaskDataAtHareParForSite(const CallSite cs)
 {
@@ -672,7 +657,7 @@ move(T &&t) noexcept
     return std::move(t);
 }
 
-/// void_t is not avaiable until C++17. We define it here for C++11/14.
+/// void_t is not available until C++17. We define it here for C++11/14.
 template <typename... Ts> struct make_void
 {
     typedef void type;

package/SVF-linux/svf/include/Util/WorkList.h

@@ -221,7 +221,7 @@ private:
 };
 
 /**
- * Worlist with "first in last out" order.
+ * Worklist with "first in last out" order.
  * New nodes will be pushed at back and popped from back.
  * Elements in the list are unique as they're recorded by Set.
  */

package/SVF-linux/svf/include/Util/cJSON.h

@@ -111,7 +111,7 @@ typedef struct cJSON
     /* The type of the item, as above. */
     int type;
 
-    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    /* The item's string, if type==cJSON_String and type == cJSON_Raw */
     char *valuestring;
     /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
     int valueint;

package/SVF-linux/svf/include/WPA/Andersen.h

@@ -327,7 +327,7 @@ protected:
     void mergeSccNodes(NodeID repNodeId, const NodeBS& subNodes);
     void mergeSccCycle();
     //@}
-    /// Collapse a field object into its base for field insensitive anlaysis
+    /// Collapse a field object into its base for field insensitive analysis
     //@{
     virtual void collapsePWCNode(NodeID nodeId);
     void collapseFields();

package/SVF-linux/svf/include/WPA/FlowSensitive.h

@@ -75,7 +75,7 @@ public:
     /// Destructor
     ~FlowSensitive() override = default;
 
-    /// Create signle instance of flow-sensitive pointer analysis
+    /// Create single instance of flow-sensitive pointer analysis
     static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)

package/SVF-linux/svf/include/WPA/WPASolver.h

@@ -196,7 +196,7 @@ protected:
     WorkList worklist;
 
 public:
-    /// num of iterations during constaint solving
+    /// num of iterations during constraint solving
     u32_t numOfIteration;
 };
 

package/SVF-linux/svf-llvm/include/SVF-LLVM/GEPTypeBridgeIterator.h

@@ -89,7 +89,7 @@ public:
     }
 
     // non-standard operators, these may not need be bridged but seems it's
-    // predunt to do so...
+    // prudent to do so...
     Type* operator->() const
     {
         return operator*();

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

@@ -34,6 +34,7 @@
 #include "Util/CppUtil.h"
 #include "SVFIR/SVFValue.h"
 #include "SVFIR/SVFModule.h"
+#include "Util/Options.h"
 
 namespace SVF
 {
@@ -74,6 +75,8 @@ private:
     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;
     /// Global definition to a rep definition map
     GlobalDefToRepMapTy GlobalDefToRepMap;
 
@@ -233,6 +236,20 @@ public:
 
     SVFOtherValue* getSVFOtherValue(const Value* ov);
 
+    /// Remove unused function in extapi.bc module
+    bool isUsedExtFunction(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() == Options::ExtAPIInput()
+                && func->getName().str() != "svf__main"
+                && 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)
     {

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

@@ -34,7 +34,6 @@
 #include "SVF-LLVM/BasicTypes.h"
 #include "SVF-LLVM/LLVMModule.h"
 #include "SVFIR/SVFValue.h"
-#include "Util/ExtAPI.h"
 #include "Util/ThreadAPI.h"
 
 namespace SVF
@@ -373,6 +372,20 @@ const std::string getSourceLocOfFunction(const Function* F);
 bool isIntrinsicInst(const Instruction* inst);
 bool isIntrinsicFun(const Function* func);
 
+/// Get all called funcions in a parent function
+std::vector<const Function *> getCalledFunctions(const Function *F);
+std::vector<std::string> getFunAnnotations(const Function* fun);
+void removeFunAnnotations(std::vector<Function*>& removedFuncList);
+
+inline void removeUnusedFuncsAndAnnotations(std::vector<Function*> removedFuncList)
+{
+    /// Remove unused function annotations in extapi.bc
+    LLVMUtil::removeFunAnnotations(removedFuncList);
+    /// Remove unused function in extapi.bc
+    for (Function* func : removedFuncList)
+        func->eraseFromParent();
+}
+
 /// Get the corresponding Function based on its name
 inline const SVFFunction* getFunction(const std::string& name)
 {

package/SVF-linux/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h

@@ -31,10 +31,10 @@
 #define PAGBUILDER_H_
 
 #include "SVFIR/SVFIR.h"
-#include "Util/ExtAPI.h"
 #include "SVF-LLVM/BasicTypes.h"
 #include "SVF-LLVM/ICFGBuilder.h"
 #include "SVF-LLVM/LLVMModule.h"
+#include "SVF-LLVM/LLVMUtil.h"
 
 namespace SVF
 {
@@ -232,18 +232,9 @@ protected:
 
     /// Handle external call
     //@{
-    virtual SVFCallInst* addSVFExtCallInst(const SVFCallInst* svfInst, SVFBasicBlock* svfBB, const SVFFunction* svfCaller, const SVFFunction* svfCallee);
-    virtual void addSVFExtRetInst(SVFCallInst* svfCall, SVFBasicBlock* svfBB, SVFFunction* svfCaller);
-    virtual SVFInstruction* addSVFExtInst(const std::string& instName, const SVFCallInst* svfInst, SVFBasicBlock* svfBB, SVF::ExtAPI::OperationType opType, const SVFType* svfType);
-    virtual void extFuncAtomaticOperation(ExtAPI::Operand& atomicOp, const SVFCallInst* svfInst);
-    virtual SVFBasicBlock* extFuncInitialization(const SVFCallInst* svfInst, SVFFunction* svfCaller);
-    virtual void handleExtCallStat(ExtAPI::ExtFunctionOps &extFunctionOps, const SVFCallInst* svfInst);
-    virtual NodeID getExtID(ExtAPI::OperationType operationType, const std::string &s, const SVFCallInst* svfCall);
-    virtual void parseAtomaticOp(SVF::ExtAPI::Operand &atomaticOp, const SVFCallInst* svfCall, std::map<std::string, NodeID> &nodeIDMap);
-    virtual void parseExtFunctionOps(ExtAPI::ExtFunctionOps &extFunctionOps, const SVFCallInst* svfCall);
-    virtual void preProcessExtCall(CallBase* cs);
-    virtual void handleExtCall(const SVFInstruction* svfInst, const SVFFunction* svfCallee);
-    void addComplexConsForExt(const SVFValue* D, const SVFValue* S, const SVFValue* sz);
+    virtual const Type *getBaseTypeAndFlattenedFields(const Value *V, std::vector<AccessPath> &fields, const Value* szValue);
+    virtual void addComplexConsForExt(Value *D, Value *S, const Value* sz);
+    virtual void handleExtCall(const CallBase* cs, const SVFFunction* svfCallee);
     //@}
 
     /// Set current basic block in order to keep track of control flow information
@@ -287,7 +278,7 @@ protected:
         return nullPtr;
     }
 
-    NodeID getGepValVar(const SVFValue* val, const AccessPath& ap, const SVFType* baseType);
+    NodeID getGepValVar(const Value* val, const AccessPath& ap, const SVFType* elementType);
 
     void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
 

package/SVF-linux/svf-llvm/include/SVF-LLVM/SymbolTableBuilder.h

@@ -94,7 +94,7 @@ protected:
     void analyzeStaticObjType(ObjTypeInfo* typeinfo, const Value* val);
 
     ///Get a reference to the components of struct_info.
-    /// Number of flattenned elements of an array or struct
+    /// Number of flattened elements of an array or struct
     u32_t getNumOfFlattenElements(const Type* T);
 
     ///Get a reference to StructInfo.

package/package.json

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