svf-tools 1.0.1074 → 1.0.1076

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1074",
+  "version": "1.0.1076",
   "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/AE/Core/ICFGWTO.h

@@ -89,7 +89,7 @@ public:
     CallGraph *cg;
 
     explicit ICFGIWTO(ICFG* graph, const ICFGNode* node, NodeBS & funcPar, CallGraph* cg) :
-          Base(graph, node), funcPar(funcPar), cg(cg) {}
+        Base(graph, node), funcPar(funcPar), cg(cg) {}
 
     virtual ~ICFGIWTO()
     {

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

@@ -106,7 +106,7 @@ void AbstractInterpretation::initWTO()
         }
         // In WIDEN_TOP or WIDEN_NARROW mode, calculate the IWTO
         else if (Options::HandleRecur() == WIDEN_ONLY ||
-            Options::HandleRecur() == WIDEN_NARROW)
+                 Options::HandleRecur() == WIDEN_NARROW)
         {
             const FunObjVar *fun = it->second->getFunction();
             if (fun->isDeclaration())
@@ -133,10 +133,10 @@ void AbstractInterpretation::initWTO()
                         callSite = *(inEdge->getIndirectCalls().begin());
                     else
                         assert(false && "CallGraphEdge must "
-                                        "be either direct or indirect!");
+                               "be either direct or indirect!");
 
                     nonRecursiveCallSites.insert(
-                        {callSite, inEdge->getDstNode()->getFunction()->getId()});
+                    {callSite, inEdge->getDstNode()->getFunction()->getId()});
                 }
             }
 
@@ -195,7 +195,7 @@ bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode * icfgNo
         {
 
             if (const IntraCFGEdge *intraCfgEdge =
-                    SVFUtil::dyn_cast<IntraCFGEdge>(edge))
+                        SVFUtil::dyn_cast<IntraCFGEdge>(edge))
             {
                 AbstractState tmpEs = abstractTrace[edge->getSrcNode()];
                 if (intraCfgEdge->getCondition())
@@ -220,26 +220,26 @@ bool AbstractInterpretation::mergeStatesFromPredecessors(const ICFGNode * icfgNo
 
                 // context insensitive implementation
                 workList.push_back(
-                        abstractTrace[callCfgEdge->getSrcNode()]);
+                    abstractTrace[callCfgEdge->getSrcNode()]);
             }
             else if (const RetCFGEdge *retCfgEdge =
                          SVFUtil::dyn_cast<RetCFGEdge>(edge))
             {
                 switch (Options::HandleRecur())
                 {
-                    case TOP:
-                    {
+                case TOP:
+                {
+                    workList.push_back(abstractTrace[retCfgEdge->getSrcNode()]);
+                    break;
+                }
+                case WIDEN_ONLY:
+                case WIDEN_NARROW:
+                {
+                    const RetICFGNode* returnSite = SVFUtil::dyn_cast<RetICFGNode>(icfgNode);
+                    const CallICFGNode* callSite = returnSite->getCallICFGNode();
+                    if (hasAbsStateFromTrace(callSite))
                         workList.push_back(abstractTrace[retCfgEdge->getSrcNode()]);
-                        break;
-                    }
-                    case WIDEN_ONLY:
-                    case WIDEN_NARROW:
-                    {
-                        const RetICFGNode* returnSite = SVFUtil::dyn_cast<RetICFGNode>(icfgNode);
-                        const CallICFGNode* callSite = returnSite->getCallICFGNode();
-                        if (hasAbsStateFromTrace(callSite))
-                            workList.push_back(abstractTrace[retCfgEdge->getSrcNode()]);
-                    }
+                }
                 }
             }
             else
@@ -692,10 +692,10 @@ void AbstractInterpretation::recursiveCallPass(const CallICFGNode *callNode)
 }
 
 bool AbstractInterpretation::isRecursiveCallSite(const CallICFGNode* callNode,
-                                                const FunObjVar* callee)
+        const FunObjVar* callee)
 {
     return nonRecursiveCallSites.find({callNode, callee->getId()}) ==
-            nonRecursiveCallSites.end();
+           nonRecursiveCallSites.end();
 }
 
 bool AbstractInterpretation::isDirectCall(const CallICFGNode *callNode)

package/svf/lib/Util/Options.cpp

@@ -783,14 +783,20 @@ const OptionMap<AbstractInterpretation::HandleRecur> Options::HandleRecur(
     "handle-recur",
     "Recursion handling mode in abstract execution (Default -widen-narrow)",
     AbstractInterpretation::HandleRecur::WIDEN_NARROW,
+{
+    {
+        AbstractInterpretation::HandleRecur::TOP, "top",
+        "The return value, and any stored object pointed by q at *q = p in recursive functions will be set to the top value."
+    },
     {
-        {AbstractInterpretation::HandleRecur::TOP, "top",
-         "The return value, and any stored object pointed by q at *q = p in recursive functions will be set to the top value."},
-        {AbstractInterpretation::HandleRecur::WIDEN_ONLY, "widen-only",
-         "Only apply widening at the cycle head of recursive functions."},
-        {AbstractInterpretation::HandleRecur::WIDEN_NARROW, "widen-narrow",
-         "Apply both widening and narrowing at the cycle head of recursive functions."}
+        AbstractInterpretation::HandleRecur::WIDEN_ONLY, "widen-only",
+        "Only apply widening at the cycle head of recursive functions."
+    },
+    {
+        AbstractInterpretation::HandleRecur::WIDEN_NARROW, "widen-narrow",
+        "Apply both widening and narrowing at the cycle head of recursive functions."
     }
+}
 );
 const Option<u32_t> Options::Timeout(
     "timeout", "time out (seconds), set -1 (no timeout), default 14400s",14400);

package/svf-llvm/lib/LLVMModule.cpp

@@ -727,7 +727,68 @@ void LLVMModuleSet::buildFunToFunMap()
         }
         if (cloneBody)
         {
-            // Clone the body of extFunToClone into clonedFunction
+            // Collect global variables referenced by extFunToClone
+            // This step identifies all global variables used within the function to be cloned
+            std::set<GlobalVariable*> referencedGlobals;
+            for (const BasicBlock& BB : *extFunToClone)
+            {
+                for (const Instruction& I : BB)
+                {
+                    for (const Value* operand : I.operands())
+                    {
+                        // Check if the operand is a global variable
+                        if (const GlobalVariable* GV = SVFUtil::dyn_cast<GlobalVariable>(operand))
+                        {
+                            referencedGlobals.insert(const_cast<GlobalVariable*>(GV));
+                        }
+                    }
+                }
+            }
+
+            // Copy global variables to target module and update valueMap
+            // When cloning a function, we need to ensure all global variables it references are available in the target module
+            for (GlobalVariable* GV : referencedGlobals)
+            {
+                // Check if the global variable already exists in the target module
+                GlobalVariable* existingGV = appModule->getGlobalVariable(GV->getName());
+                if (existingGV)
+                {
+                    // If the global variable already exists, ensure type consistency
+                    assert(existingGV->getType() == GV->getType() && "Global variable type mismatch in client module!");
+                    // Map the original global to the existing one in the target module
+                    valueMap[GV] = existingGV; // Map to existing global variable
+                }
+                else
+                {
+                    // If the global variable doesn't exist in the target module, create a new one with the same properties
+                    GlobalVariable* newGV = new GlobalVariable(
+                        *appModule,                   // Target module
+                        GV->getValueType(),           // Type of the global variable
+                        GV->isConstant(),             // Whether it's constant
+                        GV->getLinkage(),             // Linkage type
+                        nullptr,                      // No initializer yet
+                        GV->getName(),                // Same name
+                        nullptr,                      // No insert before instruction
+                        GV->getThreadLocalMode(),     // Thread local mode
+                        GV->getAddressSpace()         // Address space
+                    );
+
+                    // Copy initializer if present to maintain the global's value
+                    if (GV->hasInitializer())
+                    {
+                        Constant* init = GV->getInitializer();
+                        newGV->setInitializer(init); // Simple case: direct copy
+                    }
+
+                    // Copy other attributes like alignment to ensure identical behavior
+                    newGV->copyAttributesFrom(GV);
+
+                    // Add mapping from original global to the new one for use during function cloning
+                    valueMap[GV] = newGV;
+                }
+            }
+
+            // Clone function body with updated valueMap
             llvm::SmallVector<ReturnInst*, 8> ignoredReturns;
             CloneFunctionInto(clonedFunction, extFunToClone, valueMap, llvm::CloneFunctionChangeType::LocalChangesOnly, ignoredReturns, "", nullptr);
         }
@@ -1505,4 +1566,4 @@ bool LLVMModuleSet::is_ext(const Function* F)
         return false;
     else
         return !getExtFuncAnnotations(F).empty();
-}
+}

package/svf-llvm/lib/extapi.c

@@ -255,12 +255,6 @@ char *crypt(const char *key, const char *salt)
     return NULL;
 }
 
-__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
-char *ctime(const void *timer)
-{
-    return NULL;
-}
-
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
 char *dlerror(void)
 {
@@ -291,12 +285,6 @@ const char *svfgcry_md_algo_name_(int errcode)
     return NULL;
 }
 
-__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
-char *getenv(const char *name)
-{
-    return NULL;
-}
-
 __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:UNKNOWN")))
 char *getlogin(void)
 {
@@ -1045,242 +1033,241 @@ void _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_(void **arg
     *arg0 = arg1;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char getenv_global[10];
+char *getenv(const char *name)
+{
+    return getenv_global;
+}
+
+unsigned short ctype_b_loc_global[10];
 const unsigned short **__ctype_b_loc(void)
 {
-    return NULL;
+    return (const unsigned short **)&ctype_b_loc_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+int ctype_tolower_loc_global[10];
 int **__ctype_tolower_loc(void)
 {
-    return NULL;
+    return &ctype_tolower_loc_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+int ctype_toupper_loc_global[10];
 int **__ctype_toupper_loc(void)
 {
-    return NULL;
+    return &ctype_toupper_loc_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+int error_global[10];
 int *__errno_location(void)
 {
-    return NULL;
+    return error_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+int h_error_global[10];
 int * __h_errno_location(void)
 {
-    return NULL;
+    return h_error_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+int res_state_global[10];
 void* __res_state(void)
 {
-    return NULL;
+    return res_state_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+void *time_global[10];
 char *asctime(const void *timeptr)
 {
-    return NULL;
+    return time_global;
+}
+
+char *ctime(const void *timer)
+{
+    return time_global;
+}
+
+void *gmtime(const void *timer)
+{
+    return time_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+void *localtime(const void *timer)
+{
+    return time_global;
+}
+
+char bindtextdomain_global[10];
 char * bindtextdomain(const char * domainname, const char * dirname)
 {
-    return NULL;
+    return bindtextdomain_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char bind_textdomain_codeset_global[10];
 char * bind_textdomain_codeset(const char * domainname, const char * codeset)
 {
-    return NULL;
+    return bind_textdomain_codeset_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char ctermid_global[10];
 char *ctermid(char *s)
 {
-    return s;
+    return s ? s : ctermid_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char gettext_global[10];
 char * dcgettext(const char * domainname, const char * msgid, int category)
 {
-    return NULL;
+    return gettext_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
 char * dgettext(const char * domainname, const char * msgid)
 {
-    return NULL;
+    return gettext_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
 char * dngettext(const char * domainname, const char * msgid, const char * msgid_plural, unsigned long int n)
 {
-    return NULL;
+    return gettext_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct group *getgrgid(unsigned int gid)
+char * gettext(const char * msgid)
 {
-    return NULL;
+    return gettext_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct group *getgrnam(const char *name)
+char * ngettext(const char * msgid, const char * msgid_plural, unsigned long int n)
 {
-    return NULL;
+    return gettext_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct hostent *gethostbyaddr(const void *addr, unsigned int len, int type)
+void *getgrgid_global[10];
+void *getgrgid(unsigned int gid)
 {
-    return NULL;
+    return getgrgid_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct hostent *gethostbyname(const char *name)
+void *getgrnam_global[10];
+void *getgrnam(const char *name)
 {
-    return NULL;
+    return getgrnam_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct hostent *gethostbyname2(const char *name, int af)
+void *gethostby_global[10];
+void *gethostbyaddr(const void *addr, unsigned int len, int type)
 {
-    return NULL;
+    return gethostby_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct mntent *getmntent(void *stream)
+void *gethostbyname(const char *name)
 {
-    return NULL;
+    return gethostby_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct protoent *getprotobyname(const char *name)
+void *gethostbyname2(const char *name, int af)
 {
-    return NULL;
+    return gethostby_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct protoent *getprotobynumber(int proto)
+void *getmntent_global[10];
+void *getmntent(void *stream)
 {
-    return NULL;
+    return getmntent_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct passwd *getpwent(void)
+void *getproto_global[10];
+void *getprotobyname(const char *name)
 {
-    return NULL;
+    return getproto_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct passwd *getpwnam(const char *name)
+void *getprotobynumber(int proto)
 {
-    return NULL;
+    return getproto_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct passwd *getpwuid(unsigned int uid)
+void *getpw_global[10];
+void *getpwent(void)
 {
-    return NULL;
+    return getpw_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct servent *getservbyname(const char *name, const char *proto)
+void *getpwnam(const char *name)
 {
-    return NULL;
+    return getpw_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct servent *getservbyport(int port, const char *proto)
+void *getpwuid(unsigned int uid)
 {
-    return NULL;
+    return getpw_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct spwd *getspnam(const char *name)
+void *getserv_global[10];
+void *getservbyname(const char *name, const char *proto)
 {
-    return NULL;
+    return getserv_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-char * gettext(const char * msgid)
+void *getservbyport(int port, const char *proto)
 {
-    return NULL;
+    return getserv_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct tm *gmtime(const void *timer)
+void *getspnam_global[10];
+void *getspnam(const char *name)
 {
-    return NULL;
+    return getspnam_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char gnu_get_libc_version_global[10];
 const char *gnu_get_libc_version(void)
 {
-    return NULL;
+    return gnu_get_libc_version_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char gnutls_check_version_global[10];
 const char * gnutls_check_version(const char * req_version)
 {
-    return NULL;
-}
-
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct lconv *localeconv(void)
-{
-    return NULL;
+    return gnutls_check_version_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-struct tm *localtime(const void *timer)
+void *localeconv_global[10];
+void *localeconv(void)
 {
-    return NULL;
+    return localeconv_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
-char * ngettext(const char * msgid, const char * msgid_plural, unsigned long int n)
-{
-    return NULL;
-}
-
-__attribute__((annotate("ALLOC_STACK_RET")))
+void *pango_cairo_font_map_global[10];
 void *pango_cairo_font_map_get_default(void)
 {
-    return NULL;
+    return pango_cairo_font_map_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char re_comp_global[10];
 char *re_comp(const char *regex)
 {
-    return NULL;
+    return re_comp_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char setlocale_global[10];
 char *setlocale(int category, const char *locale)
 {
-    return NULL;
+    return setlocale_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char tgoto_global[10];
 char *tgoto(const char *cap, int col, int row)
 {
-    return NULL;
+    return tgoto_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char tparm_global[10];
 char *tparm(char *str, ...)
 {
-    return NULL;
+    return tparm_global;
 }
 
-__attribute__((annotate("ALLOC_STACK_RET")))
+char zError_global[10];
 const char *zError(int a)
 {
-    return NULL;
-}
+    return zError_global;
+}