svf-tools 1.0.758 → 1.0.760

package/svf/lib/Util/Options.cpp

@@ -772,7 +772,7 @@ const Option<bool> Options::VtableInSVFIR(
 
 //WPAPass.cpp
 const Option<std::string> Options::ExtAPIInput(
-    "extapi", "External API ext.bc", ""
+    "extapi", "External API extapi.bc", std::string(EXTAPI_PATH) + "/extapi.bc"
 );
 
 const Option<bool> Options::AnderSVFG(

package/svf/lib/Util/SVFBugReport.cpp

@@ -51,14 +51,12 @@ const std::map<GenericBug::BugType, std::string> GenericBug::BugType2Str =
 const std::string GenericBug::getLoc() const
 {
     const SVFBugEvent&sourceInstEvent = bugEventStack.at(bugEventStack.size() -1);
-    assert(sourceInstEvent.getEventType() == SVFBugEvent::SourceInst && "bugEventStack top should be a SourceInst event");
     return sourceInstEvent.getEventLoc();
 }
 
 const std::string GenericBug::getFuncName() const
 {
     const SVFBugEvent&sourceInstEvent = bugEventStack.at(bugEventStack.size() -1);
-    assert(sourceInstEvent.getEventType() == SVFBugEvent::SourceInst && "bugEventStack top should be a SourceInst event");
     return sourceInstEvent.getFuncName();
 }
 

package/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-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-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-llvm/lib/LLVMModule.cpp

@@ -29,7 +29,6 @@
 
 #include <queue>
 #include <algorithm>
-#include "Util/Options.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
@@ -153,48 +152,27 @@ void LLVMModuleSet::build()
 void LLVMModuleSet::createSVFDataStructure()
 {
     getSVFType(IntegerType::getInt8Ty(getContext()));
-    Set<const Function*> candidateDecls;
-    Set<const Function*> candidateDefs;
-
+    // Functions need to be retrieved in the order of insertion
+    std::vector<const Function*> candidateFuncs;
     for (Module& mod : modules)
     {
         std::vector<Function*> removedFuncList;
         /// Function
         for (Function& func : mod.functions())
         {
-            if (func.isDeclaration())
+            if (isUsedExtFunction(&func))
             {
-                /// if this function is declaration
-                candidateDecls.insert(&func);
+                removedFuncList.push_back(&func);
             }
             else
             {
-                /// if this function is definition
-                if (mod.getName().str() == Options::ExtAPIInput() && FunDefToDeclsMap[&func].empty() && func.getName().str() != "svf__main")
-                {
-                    /// if this function func defined in ExtAPI but never used in application code (without any corresponding declared functions).
-                    removedFuncList.push_back(&func);
-                    continue;
-                }
-                else
-                {
-                    /// if this function is in app bc, any def func should be added.
-                    /// if this function is in ext bc, only functions which have declarations(should be used by app bc) can be inserted.
-                    candidateDefs.insert(&func);
-                }
+                candidateFuncs.push_back(&func);
             }
         }
-        for (Function* func : removedFuncList)
-        {
-            mod.getFunctionList().remove(func);
-        }
-    }
-    for (const Function* func: candidateDefs)
-    {
-        createSVFFunction(func);
+        /// Remove unused functions and annotations in extapi.bc
+        LLVMUtil::removeUnusedFuncsAndAnnotations(removedFuncList);
     }
-
-    for (const Function* func: candidateDecls)
+    for (const Function* func: candidateFuncs)
     {
         createSVFFunction(func);
     }
@@ -238,7 +216,7 @@ void LLVMModuleSet::createSVFFunction(const Function* func)
         SVFUtil::cast<SVFFunctionType>(
             getSVFType(func->getFunctionType())),
         func->isDeclaration(), LLVMUtil::isIntrinsicFun(func),
-        func->hasAddressTaken(), func->isVarArg(), new SVFLoopAndDomInfo);
+        func->hasAddressTaken(), func->isVarArg(), new SVFLoopAndDomInfo, LLVMUtil::getFunAnnotations(func));
     svfFunc->setName(func->getName().str());
     svfModule->addFunctionSet(svfFunc);
     addFunctionMap(func, svfFunc);
@@ -553,8 +531,10 @@ void LLVMModuleSet::loadExtAPIModules()
             Err.print("SVFModuleLoader", llvm::errs());
             abort();
         }
-        modules.emplace_back(*mod);
-        owned_modules.emplace_back(std::move(mod));
+        // The module of extapi.bc needs to be inserted before applications modules, like std::vector<std::reference_wrapper<Module>> modules{extapi_module, app_module}.
+        // Otherwise, when overwriting the app function with SVF extern function, the corresponding SVFFunction of the extern function will not be found.
+        modules.insert(modules.begin(), *mod);
+        owned_modules.insert(owned_modules.begin(),std::move(mod));
     }
 }
 
@@ -741,28 +721,111 @@ void LLVMModuleSet::addSVFMain()
     }
 }
 
-
+/*
+    For a more detailed explanation of the Function declaration and definition mapping relationships and how External APIs are handled,
+    please refer to the SVF Wiki: https://github.com/SVF-tools/SVF/wiki/Handling-External-APIs-with-extapi.c
+
+                                    Table 1
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+    |         |      AppDef       |     AppDecl     |      ExtDef       |   ExtDecl   |
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+    | AppDef  |        X          | FunDefToDeclsMap| FunDeclToDefMap   |      X      |
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+    | AppDecl | FunDeclToDefMap   |        X        | FunDeclToDefMap   |      X      |
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+    | ExtDef  | FunDefToDeclsMap  | FunDefToDeclsMap|        X          |      X      |
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+    | ExtDecl | FunDeclToDefMap   |        X        |        X          | ExtFuncsVec |
+    | ------- | ----------------- | --------------- | ----------------- | ----------- |
+
+    When a user wants to use functions in extapi.c to overwrite the functions defined in the app code, two relationships, "AppDef -> ExtDef" and "ExtDef -> AppDef," are used.
+    Use Ext function definition to override the App function definition (Ext function with "__attribute__((annotate("OVERWRITE")))" in extapi.c).
+    The app function definition will be changed to an app function declaration.
+    Then, put the app function declaration and its corresponding Ext function definition into FunDeclToDefMap/FunDefToDeclsMap.
+    ------------------------------------------------------
+    AppDef -> ExtDef (overwrite):
+        For example,
+            App function:
+                char* foo(char *a, char *b){return a;}
+            Ext function:
+                __attribute__((annotate("OVERWRITE")))
+                char* foo(char *a, char *b){return b;}
+
+            When SVF handles the foo function in the App module,
+            the definition of
+                foo: char* foo(char *a, char *b){return a;}
+            will be changed to a declaration
+                foo: char* foo(char *a, char *b);
+            Then,
+                foo: char* foo(char *a, char *b);
+                and
+                __attribute__((annotate("OVERWRITE")))
+                char* foo(char *a, char *b){return b;}
+            will be put into FunDeclToDefMap
+    ------------------------------------------------------
+    ExtDef -> AppDef (overwrite):
+        __attribute__((annotate("OVERWRITE")))
+        char* foo(char *a, char *b){return b;}
+        and
+        foo: char* foo(char *a, char *b);
+        are put into FunDefToDeclsMap;
+    ------------------------------------------------------
+    In principle, all functions in extapi.c have bodies (definitions), but some functions (those starting with "sse_")
+    have only function declarations without definitions. ExtFuncsVec is used to record function declarations starting with "sse_" that are used.
+
+    ExtDecl -> ExtDecl:
+        For example,
+        App function:
+            foo(){call memcpy();}
+        Ext function:
+            declare sse_check_overflow();
+            memcpy(){sse_check_overflow();}
+
+        sse_check_overflow() used in the Ext function but not in the App function.
+        sse_check_overflow should be kept in ExtFuncsVec.
+*/
 void LLVMModuleSet::buildFunToFunMap()
 {
-    Set<const Function*> funDecls, funDefs;
+    Set<const Function*> funDecls, funDefs, extFuncs, overwriteExtFuncs;
     OrderedSet<string> declNames, defNames, intersectNames;
     typedef Map<string, const Function*> NameToFunDefMapTy;
     typedef Map<string, Set<const Function*>> NameToFunDeclsMapTy;
 
     for (Module& mod : modules)
     {
-        /// Function
-        for (const Function& fun : mod.functions())
+        // extapi.bc functions
+        if (mod.getName().str() == Options::ExtAPIInput())
         {
-            if (fun.isDeclaration())
+            for (const Function& fun : mod.functions())
             {
-                funDecls.insert(&fun);
-                declNames.insert(fun.getName().str());
+                extFuncs.insert(&fun);
+                // Find overwrite functions in extapi.bc
+                std::vector<std::string> annotations = LLVMUtil::getFunAnnotations(&fun);
+                auto it = std::find_if(annotations.begin(), annotations.end(), [&](const std::string& annotation)
+                {
+                    return annotation.find("OVERWRITE") != std::string::npos;
+                });
+                if (it != annotations.end())
+                {
+                    overwriteExtFuncs.insert(&fun);
+                }
             }
-            else
+        }
+        else
+        {
+            /// app functions
+            for (const Function& fun : mod.functions())
             {
-                funDefs.insert(&fun);
-                defNames.insert(fun.getName().str());
+                if (fun.isDeclaration())
+                {
+                    funDecls.insert(&fun);
+                    declNames.insert(fun.getName().str());
+                }
+                else
+                {
+                    funDefs.insert(&fun);
+                    defNames.insert(fun.getName().str());
+                }
             }
         }
     }
@@ -827,6 +890,57 @@ void LLVMModuleSet::buildFunToFunMap()
             decls.push_back(decl);
         }
     }
+
+    /// App Func decl -> SVF extern Func def
+    for (const Function* fdecl : funDecls)
+    {
+        for (const Function* extfun : extFuncs)
+        {
+            std::string declName = fdecl->getName().str();
+            // Since C function names cannot include '.', change the function name from llvm.memcpy.p0i8.p0i8.i64 to llvm_memcpy_p0i8_p0i8_i64."
+            std::replace(declName.begin(), declName.end(), '.', '_');
+            if (extfun->getName().str().compare(declName) == 0)
+            {
+                // AppDecl -> ExtDef in Table 1
+                FunDeclToDefMap[fdecl] = extfun;
+                // ExtDef -> AppDecl in Table 1
+                std::vector<const Function*>& decls = FunDefToDeclsMap[extfun];
+                decls.push_back(fdecl);
+                // Keep all called functions in extfun
+                // ExtDecl -> ExtDecl in Table 1
+                ExtFuncsVec = LLVMUtil::getCalledFunctions(extfun);
+            }
+        }
+    }
+
+    /// Overwrite
+    /// App Func def -> SVF extern Func def
+    for (const Function* appfunc : funDefs)
+    {
+        for (const Function* owfunc : overwriteExtFuncs)
+        {
+            if (appfunc->getName().str().compare(owfunc->getName().str()) == 0)
+            {
+                Function* fun = const_cast<Function*>(appfunc);
+                Module* mod = fun->getParent();
+                FunctionType* funType = fun->getFunctionType();
+                std::string funName = fun->getName().str();
+                // Replace app function definition with declaration
+                Function* declaration = Function::Create(funType, GlobalValue::ExternalLinkage, funName, mod);
+                fun->replaceAllUsesWith(declaration);
+                fun->eraseFromParent();
+                declaration->setName(funName);
+                // AppDef -> ExtDef in Table 1, AppDef has been changed to AppDecl
+                FunDeclToDefMap[declaration] = owfunc;
+                // ExtDef -> AppDef in Table 1
+                std::vector<const Function*>& decls = FunDefToDeclsMap[owfunc];
+                decls.push_back(declaration);
+                // Keep all called functions in owfunc
+                // ExtDecl -> ExtDecl in Table 1
+                ExtFuncsVec = LLVMUtil::getCalledFunctions(owfunc);
+            }
+        }
+    }
 }
 
 void LLVMModuleSet::buildGlobalDefToRepMap()

package/svf-llvm/lib/LLVMUtil.cpp

@@ -443,6 +443,127 @@ void LLVMUtil::processArguments(int argc, char **argv, int &arg_num, char **arg_
     }
 }
 
+std::vector<std::string> LLVMUtil::getFunAnnotations(const Function* fun)
+{
+    std::vector<std::string> annotations;
+    // Get annotation variable
+    GlobalVariable *glob = fun->getParent()->getGlobalVariable("llvm.global.annotations");
+    if (glob == nullptr || !glob->hasInitializer())
+        return annotations;
+
+    ConstantArray *ca = SVFUtil::dyn_cast<ConstantArray>(glob->getInitializer());
+    if (ca == nullptr)
+        return annotations;
+
+    for (unsigned i = 0; i < ca->getNumOperands(); ++i)
+    {
+        ConstantStruct *structAn = SVFUtil::dyn_cast<ConstantStruct>(ca->getOperand(i));
+        if (structAn == nullptr)
+            continue;
+
+        ConstantExpr *expr = SVFUtil::dyn_cast<ConstantExpr>(structAn->getOperand(0));
+        if (expr == nullptr || expr->getOpcode() != Instruction::BitCast || expr->getOperand(0) != fun)
+            continue;
+
+        ConstantExpr *note = SVFUtil::cast<ConstantExpr>(structAn->getOperand(1));
+        if (note->getOpcode() != Instruction::GetElementPtr)
+            continue;
+
+        GlobalVariable *annotateStr = SVFUtil::dyn_cast<GlobalVariable>(note->getOperand(0));
+        if (annotateStr == nullptr || !annotateStr->hasInitializer())
+            continue;
+
+        ConstantDataSequential *data = SVFUtil::dyn_cast<ConstantDataSequential>(annotateStr->getInitializer());
+        if (data->isString())
+        {
+            std::string annotation = data->getAsString().str();
+            if (!annotation.empty())
+                annotations.push_back(annotation);
+        }
+    }
+    return annotations;
+}
+
+void LLVMUtil::removeFunAnnotations(std::vector<Function*>& removedFuncList)
+{
+    if (removedFuncList.empty())
+        return; // No functions to remove annotations in extapi.bc module
+
+    Module* module = removedFuncList[0]->getParent();
+    GlobalVariable* glob = module->getGlobalVariable("llvm.global.annotations");
+    if (glob == nullptr || !glob->hasInitializer())
+        return;
+
+    ConstantArray* ca = SVFUtil::dyn_cast<ConstantArray>(glob->getInitializer());
+    if (ca == nullptr)
+        return;
+
+    std::vector<Constant*> newAnnotations;
+    for (unsigned i = 0; i < ca->getNumOperands(); ++i)
+    {
+        ConstantStruct* structAn = SVFUtil::dyn_cast<ConstantStruct>(ca->getOperand(i));
+        if (structAn == nullptr)
+            continue;
+
+        ConstantExpr* expr = SVFUtil::dyn_cast<ConstantExpr>(structAn->getOperand(0));
+        if (expr == nullptr || expr->getOpcode() != Instruction::BitCast)
+        {
+            // Keep the annotation if it's not created using BitCast
+            newAnnotations.push_back(structAn);
+            continue;
+        }
+
+        Function* annotatedFunc = SVFUtil::dyn_cast<Function>(expr->getOperand(0));
+        if (annotatedFunc == nullptr || std::find(removedFuncList.begin(), removedFuncList.end(), annotatedFunc) != removedFuncList.end())
+            continue;
+
+        // Keep the annotation for all other functions
+        newAnnotations.push_back(structAn);
+    }
+
+    if (newAnnotations.size() == ca->getNumOperands())
+        return; // No annotations to remove
+
+    ArrayType* annotationsType = ArrayType::get(ca->getType()->getElementType(), newAnnotations.size());
+    Constant* newCA = ConstantArray::get(annotationsType, newAnnotations);
+
+    // Check if a global variable with the name llvm.global.annotations already exists
+    GlobalVariable* existingGlobal = module->getGlobalVariable("llvm.global.annotations");
+    if (existingGlobal)
+        // Rename the existing llvm.global.annotations to llvm.global.annotations_old
+        existingGlobal->setName("llvm.global.annotations_old");
+
+    // Create a new global variable with the updated annotations
+    GlobalVariable* newGlobal = new GlobalVariable(*module, newCA->getType(), glob->isConstant(),
+            glob->getLinkage(), newCA, "llvm.global.annotations", glob, glob->getThreadLocalMode());
+
+    // Copy other properties from the old global variable to the new one
+    newGlobal->setSection(glob->getSection());
+    newGlobal->setAlignment(llvm::MaybeAlign(glob->getAlignment()));
+
+    // Remove the old global variable
+    glob->eraseFromParent();
+}
+
+/// Get all called funcions in a parent function
+std::vector<const Function *> LLVMUtil::getCalledFunctions(const Function *F)
+{
+    std::vector<const Function *> calledFunctions;
+    for (const Instruction &I : instructions(F))
+    {
+        if (const CallBase *callInst = SVFUtil::dyn_cast<CallBase>(&I))
+        {
+            Function *calledFunction = callInst->getCalledFunction();
+            if (calledFunction)
+            {
+                calledFunctions.push_back(calledFunction);
+                std::vector<const Function *> nestedCalledFunctions = getCalledFunctions(calledFunction);
+                calledFunctions.insert(calledFunctions.end(), nestedCalledFunctions.begin(), nestedCalledFunctions.end());
+            }
+        }
+    }
+    return calledFunctions;
+}
 
 u32_t LLVMUtil::getTypeSizeInBytes(const Type* type)
 {

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -470,7 +470,7 @@ NodeID SVFIRBuilder::getGlobalVarField(const GlobalVariable *gvar, u32_t offset,
     /// then we need to create a gep node for this field
     else
     {
-        return getGepValVar(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(gvar), AccessPath(offset), tpy);
+        return getGepValVar(gvar, AccessPath(offset), tpy);
     }
 }
 
@@ -847,9 +847,7 @@ void SVFIRBuilder::visitCallSite(CallBase* cs)
         const SVFFunction* svfcallee = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(callee);
         if (isExtCall(svfcallee))
         {
-            // There is no extpag for the function, use the old method.
-            preProcessExtCall(cs);
-            handleExtCall(svfcall, svfcallee);
+            handleExtCall(cs, svfcallee);
         }
         else
         {
@@ -1115,73 +1113,6 @@ const Value* SVFIRBuilder::getBaseValueForExtArg(const Value* V)
     return value;
 }
 
-void SVFIRBuilder::preProcessExtCall(CallBase* cs)
-{
-    const SVFInstruction* svfinst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(cs);
-    const SVFCallInst* svfcall = SVFUtil::cast<SVFCallInst>(svfinst);
-    /// Currently focusing on providing specialized treatment for the extern function void *dlsym(void *handle, const char *funname)
-    /// and generalization will be done later.
-    if (svfcall->getCalledFunction()->getName() == "dlsym")
-    {
-        const Value* src = cs->getArgOperand(1);
-        if(const GetElementPtrInst* gep = SVFUtil::dyn_cast<GetElementPtrInst>(src))
-            src = stripConstantCasts(gep->getPointerOperand());
-
-        auto getHookFn = [](const Value* src)->const Function*
-        {
-            if (!SVFUtil::isa<GlobalVariable>(src))
-                return nullptr;
-
-            auto *glob = SVFUtil::cast<GlobalVariable>(src);
-            if (!glob->hasInitializer() || !SVFUtil::isa<ConstantDataArray>(glob->getInitializer()))
-                return nullptr;
-
-            auto *constarray = SVFUtil::cast<ConstantDataArray>(glob->getInitializer());
-            return LLVMUtil::getProgFunction(constarray->getAsCString().str());
-        };
-
-        if (const Function *fn = getHookFn(src))
-        {
-            NodeID srcNode = getValueNode(fn);
-            addCopyEdge(srcNode,  getValueNode(cs));
-        }
-        return;
-    }
-    /// Preprocess the arguments of functions such as memset() and memcpy() that involve arrays or structures,
-    /// and identify the original data types of these arguments, flattening each subfield.
-    if (isMemSetOrCpyExtFun(svfcall->getCalledFunction()))
-    {
-        for (u32_t i = 0; i < cs->arg_size(); i++)
-        {
-            const Type* T = getBaseValueForExtArg(cs->getArgOperand(i))->getType();
-            while (const PointerType *ptype = SVFUtil::dyn_cast<PointerType>(T))
-                T = getPtrElementType(ptype);
-            const SVFType *st = LLVMModuleSet::getLLVMModuleSet()->getSVFType(T);
-            std::vector<AccessPath> fields;
-            u32_t numOfElems = pag->getSymbolInfo()->getNumOfFlattenElements(st);
-            LLVMContext& context = LLVMModuleSet::getLLVMModuleSet()->getContext();
-            for(u32_t ei = 0; ei < numOfElems; ei++)
-            {
-                AccessPath ap(ei);
-                // make a ConstantInt and create char for the content type due to byte-wise copy
-                const ConstantInt* offset = ConstantInt::get(context, llvm::APInt(32, ei));
-                const SVFValue* svfOffset = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(offset);
-                if (!pag->getSymbolInfo()->hasValSym(svfOffset))
-                {
-                    SymbolTableBuilder builder(pag->getSymbolInfo());
-                    builder.collectSym(offset);
-                    pag->addValNode(svfOffset, pag->getSymbolInfo()->getValSym(svfOffset));
-                }
-                ap.addOffsetVarAndGepTypePair(getPAG()->getGNode(getPAG()->getValueNode(svfOffset)), nullptr);
-                fields.push_back(ap);
-            }
-            NodeID argId = pag->getValueNode(svfcall->getArgOperand(i));
-            std::pair<const SVFType*, std::vector<AccessPath>> pairToInsert = std::make_pair(st, fields);
-            pag->addToTypeLocSetsMap(argId, pairToInsert);
-        }
-    }
-}
-
 /*!
  * Indirect call is resolved on-the-fly during pointer analysis
  */
@@ -1211,9 +1142,8 @@ void SVFIRBuilder::updateCallGraph(PTACallGraph* callgraph)
             if (isExtCall(*func_iter))
             {
                 setCurrentLocation(callee, callee->empty() ? nullptr : &callee->getEntryBlock());
-                SVFInstruction* svfinst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(callbase);
                 const SVFFunction* svfcallee = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(callee);
-                handleExtCall(svfinst, svfcallee);
+                handleExtCall(callbase, svfcallee);
             }
             else
             {
@@ -1257,9 +1187,9 @@ void SVFIRBuilder::sanityCheck()
  * Add a temp field value node according to base value and offset
  * this node is after the initial node method, it is out of scope of symInfo table
  */
-NodeID SVFIRBuilder::getGepValVar(const SVFValue* val, const AccessPath& ap, const SVFType* elementType)
+NodeID SVFIRBuilder::getGepValVar(const Value* val, const AccessPath& ap, const SVFType* elementType)
 {
-    NodeID base = pag->getBaseValVar(pag->getValueNode(val));
+    NodeID base = pag->getBaseValVar(getValueNode(val));
     NodeID gepval = pag->getGepValVar(curVal, base, ap);
     if (gepval==UINT_MAX)
     {
@@ -1279,7 +1209,8 @@ NodeID SVFIRBuilder::getGepValVar(const SVFValue* val, const AccessPath& ap, con
         const SVFValue* cval = getCurrentValue();
         const SVFBasicBlock* cbb = getCurrentBB();
         setCurrentLocation(curVal, nullptr);
-        NodeID gepNode= pag->addGepValNode(curVal, val, ap, NodeIDAllocator::get()->allocateValueId(),elementType->getPointerTo());
+        LLVMModuleSet* llvmmodule = LLVMModuleSet::getLLVMModuleSet();
+        NodeID gepNode= pag->addGepValNode(curVal, llvmmodule->getSVFValue(val),ap, NodeIDAllocator::get()->allocateValueId(),elementType->getPointerTo());
         addGepEdge(base, gepNode, ap, true);
         setCurrentLocation(cval, cbb);
         return gepNode;