svf-tools 1.0.774 → 1.0.776

package/svf-llvm/lib/LLVMModule.cpp

@@ -175,8 +175,8 @@ void LLVMModuleSet::createSVFDataStructure()
                 candidateDefs.push_back(&func);
             }
         }
-        /// Remove unused functions and annotations in extapi.bc
-        LLVMUtil::removeUnusedFuncsAndAnnotations(removedFuncList);
+        /// Remove unused functions, annotations and global variables in extapi.bc
+        LLVMUtil::removeUnusedFuncsAndAnnotationsAndGlobalVariables(removedFuncList);
     }
     for (const Function* func: candidateDefs)
     {
@@ -814,6 +814,14 @@ void LLVMModuleSet::buildFunToFunMap()
                     funDecls.insert(&fun);
                     declNames.insert(fun.getName().str());
                 }
+                /// Keep svf_main() function and all the functions called in svf_main()
+                else if (fun.getName().str() == "svf__main")
+                {
+                    ExtFuncsVec.push_back(&fun);
+                    // Get all called functions in svf_main()
+                    std::vector<const Function*> calledFunctions = LLVMUtil::getCalledFunctions(&fun);
+                    ExtFuncsVec.insert(ExtFuncsVec.end(), calledFunctions.begin(), calledFunctions.end());
+                }
                 else
                 {
                     extFuncs.insert(&fun);
@@ -931,7 +939,8 @@ void LLVMModuleSet::buildFunToFunMap()
                 decls.push_back(fdecl);
                 // Keep all called functions in extfun
                 // ExtDecl -> ExtDecl in Table 1
-                ExtFuncsVec = LLVMUtil::getCalledFunctions(extfun);
+                std::vector<const Function*> calledFunctions = LLVMUtil::getCalledFunctions(extfun);
+                ExtFuncsVec.insert(ExtFuncsVec.end(), calledFunctions.begin(), calledFunctions.end());
             }
         }
     }
@@ -960,7 +969,8 @@ void LLVMModuleSet::buildFunToFunMap()
                 decls.push_back(declaration);
                 // Keep all called functions in owfunc
                 // ExtDecl -> ExtDecl in Table 1
-                ExtFuncsVec = LLVMUtil::getCalledFunctions(owfunc);
+                std::vector<const Function*> calledFunctions = LLVMUtil::getCalledFunctions(owfunc);
+                ExtFuncsVec.insert(ExtFuncsVec.end(), calledFunctions.begin(), calledFunctions.end());
             }
         }
     }

package/svf-llvm/lib/LLVMUtil.cpp

@@ -563,9 +563,86 @@ std::vector<const Function *> LLVMUtil::getCalledFunctions(const Function *F)
     return calledFunctions;
 }
 
-u32_t LLVMUtil::getTypeSizeInBytes(const Type* type)
+bool LLVMUtil::isUnusedGlobalVariable(const GlobalVariable& global)
+{
+    // Check if it is an empty global annotations
+    if (global.getName() == "llvm.global.annotations" && SVFUtil::isa<ConstantArray>(global.getInitializer()))
+        return false;
+    else
+    {
+        // Check if any global strings has at least one effective user
+        for (auto& use : global.uses())
+            if (use.getUser()->getNumUses() != 0)
+                return false;
+    }
+    return true;
+}
+
+void LLVMUtil::removeUnusedGlobalVariables(Module* module)
 {
+    assert(module && "Null module pointer!");
+    std::vector<GlobalVariable*> unusedGlobals;
+    for (GlobalVariable& global : module->globals())
+        if (isUnusedGlobalVariable(global))
+            // Record unused global variables
+            unusedGlobals.push_back(&global);
+
+    // Delete unused global variables
+    for (GlobalVariable* global : unusedGlobals)
+        global->eraseFromParent();
+}
+
+/// Delete unused functions, annotations and global variables in extapi.bc
+void LLVMUtil::removeUnusedFuncsAndAnnotationsAndGlobalVariables(std::vector<Function*> removedFuncList)
+{
+    if (removedFuncList.empty())
+        return;
+
+    Module* mod = removedFuncList[0]->getParent();
+    if (mod->getName().str() != Options::ExtAPIInput())
+        return;
+
+    /// Delete unused function annotations
+    LLVMUtil::removeFunAnnotations(removedFuncList);
+
+    /// Delete unused functions
+    /// The functions to be deleted from extapi.bc can be categorized into two types.
+    /// The first type includes functions do not contain any invocation statements,
+    /// The second type includes functions whose contain invocation statements.
+    /// It is necessary to delete functions of the second type first before deleting those of the first type;
+    /// Otherwise, errors may occur when calling eraseFromParent().
+    std::vector<Function*> funcsToKeep;
+    /// Check whether a function is called by other functions
+    auto isCalledFunction = [](llvm::Function* F)
+    {
+        assert(F && "Null function pointer!");
+        for (auto& use : F->uses())
+        {
+            llvm::User* user = use.getUser();
+            if (llvm::isa<llvm::CallBase>(user))
+                return true;
+        }
+        return false;
+    };
 
+    for (Function* func : removedFuncList)
+    {
+        if (isCalledFunction(func))
+            // Record first kind function(which does not contain any invocation statements)
+            funcsToKeep.push_back(func);
+        else
+            // Delete second kind function(which contains invocation statements)
+            func->eraseFromParent();
+    }
+    // Delete first kind functions
+    for (Function* func : funcsToKeep)
+        func->eraseFromParent();
+    // Delete unused global variables
+    removeUnusedGlobalVariables(mod);
+}
+
+u32_t LLVMUtil::getTypeSizeInBytes(const Type* type)
+{
     // if the type has size then simply return it, otherwise just return 0
     if(type->isSized())
         return getDataLayout(LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule())->getTypeStoreSize(const_cast<Type*>(type));