svf-tools 1.0.1075 → 1.0.1077

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1075",
+  "version": "1.0.1077",
   "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-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;
+}