svf-lib 1.0.1363 → 1.0.1365

package/SVF-osx/include/MTA/MTA.h

@@ -36,6 +36,7 @@
 
 #include <set>
 #include <vector>
+#include "SVF-LLVM/BasicTypes.h"
 #include "SVFIR/SVFValue.h"
 
 namespace SVF

package/SVF-osx/include/MTA/MTAStat.h

@@ -31,6 +31,7 @@
 #define MTASTAT_H_
 
 #include "Util/PTAStat.h"
+#include "SVF-LLVM/BasicTypes.h"
 
 namespace SVF
 {

package/SVF-osx/include/MemoryModel/PersistentPointsToCache.h

@@ -17,6 +17,7 @@
 #include <iomanip>
 #include <iostream>
 #include <vector>
+#include <functional>
 
 #include "SVFIR/SVFType.h"
 

package/SVF-osx/include/SVF-LLVM/DCHG.h

@@ -16,7 +16,8 @@
 
 #include "Graphs/GenericGraph.h"
 #include "Graphs/CHG.h"
-#include "SVF-LLVM/CPPUtil.h"
+#include "Util/CppUtil.h"
+#include "SVF-LLVM/BasicTypes.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
 #include "Util/WorkList.h"

package/SVF-osx/include/SVF-LLVM/LLVMLoopAnalysis.h

@@ -32,6 +32,7 @@
 
 #include "SVFIR/SVFIR.h"
 #include "MemoryModel/SVFLoop.h"
+#include "SVF-LLVM/BasicTypes.h"
 
 namespace SVF
 {

package/SVF-osx/include/SVF-LLVM/LLVMModule.h

@@ -31,7 +31,7 @@
 #define INCLUDE_SVF_FE_LLVMMODULE_H_
 
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/CPPUtil.h"
+#include "Util/CppUtil.h"
 #include "SVFIR/SVFValue.h"
 #include "SVFIR/SVFModule.h"
 
@@ -234,7 +234,7 @@ public:
     SVFOtherValue* getSVFOtherValue(const Value* ov);
 
     /// Get the corresponding Function based on its name
-    inline const SVFFunction* getSVFFunction(std::string name)
+    inline const SVFFunction* getSVFFunction(const std::string& name)
     {
         Function* fun = nullptr;
 

package/SVF-osx/include/SVF-LLVM/LLVMUtil.h

@@ -30,9 +30,9 @@
 #ifndef INCLUDE_SVF_FE_LLVMUTIL_H_
 #define INCLUDE_SVF_FE_LLVMUTIL_H_
 
-#include "SVF-LLVM/BasicTypes.h"
 #include "Util/SVFUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
+#include "SVF-LLVM/LLVMModule.h"
 #include "SVFIR/SVFValue.h"
 #include "Util/ExtAPI.h"
 #include "Util/ThreadAPI.h"
@@ -51,16 +51,14 @@ inline bool isCallSite(const Instruction* inst)
 /// Whether an instruction is a call or invoke instruction
 inline bool isCallSite(const Value* val)
 {
-    if(SVFUtil::isa<CallBase>(val))
-        return true;
-    else
-        return false;
+    return SVFUtil::isa<CallBase>(val);
 }
 
 /// Get the definition of a function across multiple modules
 inline const Function* getDefFunForMultipleModule(const Function* fun)
 {
-    if(fun == nullptr) return nullptr;
+    if (fun == nullptr)
+        return nullptr;
     LLVMModuleSet* llvmModuleset = LLVMModuleSet::getLLVMModuleSet();
     if (fun->isDeclaration() && llvmModuleset->hasDefinition(fun))
         fun = LLVMModuleSet::getLLVMModuleSet()->getDefinition(fun);
@@ -78,38 +76,39 @@ inline const Function* getCallee(const CallBase* cs)
 {
     // FIXME: do we need to strip-off the casts here to discover more library functions
     const Function* callee = SVFUtil::dyn_cast<Function>(cs->getCalledOperand()->stripPointerCasts());
-    if(callee)
-        return getDefFunForMultipleModule(callee);
-    else
-        return nullptr;
+    return callee ? getDefFunForMultipleModule(callee) : nullptr;
 }
 
 /// Return LLVM function if this value is
 inline const Function* getLLVMFunction(const Value* val)
 {
-    const Function* fun = SVFUtil::dyn_cast<Function>(val->stripPointerCasts());
-    return fun;
+    return SVFUtil::dyn_cast<Function>(val->stripPointerCasts());
 }
 
 /// Get program entry function from module.
 inline const Function* getProgFunction(const std::string& funName)
 {
-    for (Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
+    for (const Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
     {
-        for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
+        for (const Function& fun : M)
         {
-            const Function *fun = &*F;
-            if (fun->getName().str()==funName)
-                return fun;
+            if (fun.getName() == funName)
+                return &fun;
         }
     }
     return nullptr;
 }
 
+/// Check whether a function is an entry function (i.e., main)
+inline bool isProgEntryFunction(const Function* fun)
+{
+    return fun && fun->getName() == "main";
+}
+
 /// Check whether this value is a black hole
 inline bool isBlackholeSym(const Value* val)
 {
-    return (SVFUtil::isa<UndefValue>(val));
+    return SVFUtil::isa<UndefValue>(val);
 }
 
 /// Check whether this value is a black hole
@@ -162,16 +161,16 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const Instruction* inst)
 //@}
 
 /// Return true if this value refers to a object
-bool isObject (const Value*  ref);
+bool isObject(const Value* ref);
 
 /// Method for dead function, which does not have any possible caller
 /// function address is not taken and never be used in call or invoke instruction
 //@{
 /// whether this is a function without any possible caller?
-bool isUncalledFunction (const Function*  fun);
+bool isUncalledFunction(const Function* fun);
 
 /// whether this is an argument in dead function
-inline bool ArgInDeadFunction (const Value*  val)
+inline bool ArgInDeadFunction(const Value* val)
 {
     return SVFUtil::isa<Argument>(val)
            && isUncalledFunction(SVFUtil::cast<Argument>(val)->getParent());
@@ -179,13 +178,14 @@ inline bool ArgInDeadFunction (const Value*  val)
 //@}
 
 /// Return true if this is an argument of a program entry function (e.g. main)
-inline bool ArgInProgEntryFunction (const Value*  val)
+inline bool ArgInProgEntryFunction(const Value* val)
 {
-    return SVFUtil::isa<Argument>(val)
-           && SVFUtil::isProgEntryFunction(SVFUtil::cast<Argument>(val)->getParent());
+    return SVFUtil::isa<Argument>(val) &&
+           LLVMUtil::isProgEntryFunction(
+               SVFUtil::cast<Argument>(val)->getParent());
 }
 /// Return true if this is value in a dead function (function without any caller)
-bool isPtrInUncalledFunction (const Value*  value);
+bool isPtrInUncalledFunction(const Value* value);
 //@}
 
 //@}
@@ -193,9 +193,9 @@ bool isPtrInUncalledFunction (const Value*  value);
 /// Function does not have any possible caller in the call graph
 //@{
 /// Return true if the function does not have a caller (either it is a main function or a dead function)
-inline bool isNoCallerFunction (const Function*  fun)
+inline bool isNoCallerFunction(const Function* fun)
 {
-    return isUncalledFunction(fun) || SVFUtil::isProgEntryFunction(fun);
+    return isUncalledFunction(fun) || LLVMUtil::isProgEntryFunction(fun);
 }
 
 /// Return true if the argument in a function does not have a caller
@@ -206,81 +206,84 @@ inline bool isArgOfUncalledFunction (const Value*  val)
 }
 //@}
 
-/// Return true if the function has a return instruction reachable from function entry
-bool functionDoesNotRet (const Function*  fun);
+/// Return true if the function has a return instruction reachable from function
+/// entry
+bool functionDoesNotRet(const Function* fun);
 
 /// Get reachable basic block from function entry
-void getFunReachableBBs (const Function* svfFun, std::vector<const SVFBasicBlock*>& bbs);
+void getFunReachableBBs(const Function* svfFun,
+                        std::vector<const SVFBasicBlock*>& bbs);
 
 /// Strip off the constant casts
-const Value*  stripConstantCasts(const Value* val);
+const Value* stripConstantCasts(const Value* val);
 
 /// Strip off the all casts
-const Value* stripAllCasts(const Value* val) ;
+const Value* stripAllCasts(const Value* val);
 
 /// Get the type of the heap allocation
-const Type* getTypeOfHeapAlloc(const Instruction* inst) ;
+const Type* getTypeOfHeapAlloc(const Instruction* inst);
 
-/// Return the bitcast instruction which is val's only use site, otherwise return nullptr
+/// Return the bitcast instruction which is val's only use site, otherwise
+/// return nullptr
 const Value* getUniqueUseViaCastInst(const Value* val);
 
 /// Return corresponding constant expression, otherwise return nullptr
 //@{
-inline const ConstantExpr *isGepConstantExpr(const Value* val)
+inline const ConstantExpr* isGepConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::GetElementPtr)
+        if (constExpr->getOpcode() == Instruction::GetElementPtr)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isInt2PtrConstantExpr(const Value* val)
+inline const ConstantExpr* isInt2PtrConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::IntToPtr)
+        if (constExpr->getOpcode() == Instruction::IntToPtr)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isPtr2IntConstantExpr(const Value* val)
+inline const ConstantExpr* isPtr2IntConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::PtrToInt)
+        if (constExpr->getOpcode() == Instruction::PtrToInt)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isCastConstantExpr(const Value* val)
+inline const ConstantExpr* isCastConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::BitCast)
+        if (constExpr->getOpcode() == Instruction::BitCast)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isSelectConstantExpr(const Value* val)
+inline const ConstantExpr* isSelectConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::Select)
+        if (constExpr->getOpcode() == Instruction::Select)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isTruncConstantExpr(const Value* val)
+inline const ConstantExpr* isTruncConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::Trunc ||
+        if (constExpr->getOpcode() == Instruction::Trunc ||
                 constExpr->getOpcode() == Instruction::FPTrunc ||
                 constExpr->getOpcode() == Instruction::ZExt ||
                 constExpr->getOpcode() == Instruction::SExt ||
@@ -290,31 +293,34 @@ inline const ConstantExpr *isTruncConstantExpr(const Value* val)
     return nullptr;
 }
 
-inline const ConstantExpr *isCmpConstantExpr(const Value* val)
+inline const ConstantExpr* isCmpConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if(constExpr->getOpcode() == Instruction::ICmp || constExpr->getOpcode() == Instruction::FCmp)
+        if (constExpr->getOpcode() == Instruction::ICmp ||
+                constExpr->getOpcode() == Instruction::FCmp)
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isBinaryConstantExpr(const Value* val)
+inline const ConstantExpr* isBinaryConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if((constExpr->getOpcode() >= Instruction::BinaryOpsBegin) && (constExpr->getOpcode() <= Instruction::BinaryOpsEnd))
+        if ((constExpr->getOpcode() >= Instruction::BinaryOpsBegin) &&
+                (constExpr->getOpcode() <= Instruction::BinaryOpsEnd))
             return constExpr;
     }
     return nullptr;
 }
 
-inline const ConstantExpr *isUnaryConstantExpr(const Value* val)
+inline const ConstantExpr* isUnaryConstantExpr(const Value* val)
 {
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
+    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
-        if((constExpr->getOpcode() >= Instruction::UnaryOpsBegin) && (constExpr->getOpcode() <= Instruction::UnaryOpsEnd))
+        if ((constExpr->getOpcode() >= Instruction::UnaryOpsBegin) &&
+                (constExpr->getOpcode() <= Instruction::UnaryOpsEnd))
             return constExpr;
     }
     return nullptr;
@@ -324,38 +330,41 @@ inline const ConstantExpr *isUnaryConstantExpr(const Value* val)
 inline static DataLayout* getDataLayout(Module* mod)
 {
     static DataLayout *dl = nullptr;
-    if (dl == nullptr) dl = new DataLayout(mod);
+    if (dl == nullptr)
+        dl = new DataLayout(mod);
     return dl;
 }
 
 /// Get the next instructions following control flow
-void getNextInsts(const Instruction* curInst, std::vector<const SVFInstruction*>& instList);
+void getNextInsts(const Instruction* curInst,
+                  std::vector<const SVFInstruction*>& instList);
 
 /// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst, std::vector<const SVFInstruction*>& instList);
+void getPrevInsts(const Instruction* curInst,
+                  std::vector<const SVFInstruction*>& instList);
 
 /// Get the next instructions following control flow
-void getNextInsts(const Instruction* curInst, std::vector<const Instruction*>& instList);
+void getNextInsts(const Instruction* curInst,
+                  std::vector<const Instruction*>& instList);
 
 /// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst, std::vector<const Instruction*>& instList);
+void getPrevInsts(const Instruction* curInst,
+                  std::vector<const Instruction*>& instList);
 
 /// Get num of BB's predecessors
 u32_t getBBPredecessorNum(const BasicBlock* BB);
 
-
-
 /// Check whether a file is an LLVM IR file
-bool isIRFile(const std::string &filename);
+bool isIRFile(const std::string& filename);
 
 /// Parse argument for multi-module analysis
-void processArguments(int argc, char **argv, int &arg_num, char **arg_value,
-                      std::vector<std::string> &moduleNameVec);
+void processArguments(int argc, char** argv, int& arg_num, char** arg_value,
+                      std::vector<std::string>& moduleNameVec);
 
 /// Helper method to get the size of the type from target data layout
 //@{
 u32_t getTypeSizeInBytes(const Type* type);
-u32_t getTypeSizeInBytes(const StructType *sty, u32_t field_index);
+u32_t getTypeSizeInBytes(const StructType* sty, u32_t field_index);
 //@}
 
 const std::string getSourceLoc(const Value* val);
@@ -365,7 +374,7 @@ bool isIntrinsicInst(const Instruction* inst);
 bool isIntrinsicFun(const Function* func);
 
 /// Get the corresponding Function based on its name
-inline const SVFFunction* getFunction(std::string name)
+inline const SVFFunction* getFunction(const std::string& name)
 {
     return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(name);
 }
@@ -373,17 +382,14 @@ inline const SVFFunction* getFunction(std::string name)
 /// Return true if the value refers to constant data, e.g., i32 0
 inline bool isConstDataOrAggData(const Value* val)
 {
-    bool constDataOrConstAggregate = SVFUtil::isa<ConstantData>(val)
-                                     || SVFUtil::isa<ConstantAggregate>(val)
-                                     || SVFUtil::isa<MetadataAsValue>(val)
-                                     || SVFUtil::isa<BlockAddress>(val);
-    return constDataOrConstAggregate;
+    return SVFUtil::isa<ConstantData, ConstantAggregate,
+           MetadataAsValue, BlockAddress>(val);
 }
 
 /// find the unique defined global across multiple modules
 inline const Value* getGlobalRep(const Value* val)
 {
-    if(const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
+    if (const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
     {
         if (LLVMModuleSet::getLLVMModuleSet()->hasGlobalRep(gvar))
             val = LLVMModuleSet::getLLVMModuleSet()->getGlobalRep(gvar);
@@ -403,6 +409,56 @@ void viewCFG(const Function* fun);
 // Dump Control Flow Graph of llvm function, without instructions
 void viewCFGOnly(const Function* fun);
 
+bool isValVtbl(const Value* val);
+bool isLoadVtblInst(const LoadInst* loadInst);
+bool isVirtualCallSite(const CallBase* cs);
+bool isConstructor(const Function* F);
+bool isDestructor(const Function* F);
+bool isCPPThunkFunction(const Function* F);
+const Function* getThunkTarget(const Function* F);
+
+/*
+ * VtableA = {&A::foo}
+ * A::A(this){
+ *   *this = &VtableA;
+ * }
+ *
+ *
+ * A* p = new A;
+ * cs: p->foo(...)
+ * ==>
+ *  vtptr = *p;
+ *  vfn = &vtptr[i]
+ *  %funp = *vfn
+ *  call %funp(p,...)
+ * getConstructorThisPtr(A) return "this" pointer
+ * getVCallThisPtr(cs) return p (this pointer)
+ * getVCallVtblPtr(cs) return vtptr
+ * getVCallIdx(cs) return i
+ * getClassNameFromVtblObj(VtableA) return
+ * getClassNameFromType(type of p) return type A
+ */
+const Argument* getConstructorThisPtr(const Function* fun);
+const Value* getVCallThisPtr(const CallBase* cs);
+const Value* getVCallVtblPtr(const CallBase* cs);
+s32_t getVCallIdx(const CallBase* cs);
+std::string getClassNameFromType(const Type* ty);
+std::string getClassNameOfThisPtr(const CallBase* cs);
+std::string getFunNameOfVCallSite(const CallBase* cs);
+bool VCallInCtorOrDtor(const CallBase* cs);
+
+/*
+ *  A(A* this){
+ *      store this this.addr;
+ *      tmp = load this.addr;
+ *      this1 = bitcast(tmp);
+ *      B(this1);
+ *  }
+ *  this and this1 are the same thisPtr in the constructor
+ */
+bool isSameThisPtrInConstructor(const Argument* thisPtr1,
+                                const Value* thisPtr2);
+
 } // End namespace LLVMUtil
 
 } // End namespace SVF

package/SVF-osx/include/SVF-LLVM/SVFIRBuilder.h

@@ -34,6 +34,7 @@
 #include "Util/ExtAPI.h"
 #include "SVF-LLVM/BasicTypes.h"
 #include "SVF-LLVM/ICFGBuilder.h"
+#include "SVF-LLVM/LLVMModule.h"
 
 namespace SVF
 {

package/SVF-osx/include/SVFIR/PAGBuilderFromFile.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
-#define INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
+#ifndef INCLUDE_SVFIR_PAGBUILDERFROMFILE_H_
+#define INCLUDE_SVFIR_PAGBUILDERFROMFILE_H_
 
 #include "SVFIR/SVFIR.h"
 
@@ -77,4 +77,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_ */
+#endif /* INCLUDE_SVFIR_PAGBUILDERFROMFILE_H_ */

package/SVF-osx/include/SVFIR/SVFIR.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef SVFIR_H_
-#define SVFIR_H_
+#ifndef INCLUDE_SVFIR_H_
+#define INCLUDE_SVFIR_H_
 
 #include "Graphs/IRGraph.h"
 
@@ -656,4 +656,4 @@ typedef SVFIR PAG;
 
 
 
-#endif /* SVFIR_H_ */
+#endif /* INCLUDE_SVFIR_H_ */

package/SVF-osx/include/SVFIR/SVFModule.h

@@ -27,8 +27,8 @@
  *      Author: Xiaokang Fan
  */
 
-#ifndef SVFMODULE_H_
-#define SVFMODULE_H_
+#ifndef INCLUDE_SVFMODULE_H_
+#define INCLUDE_SVFMODULE_H_
 
 #include "SVFIR/SVFValue.h"
 #include "Util/ExtAPI.h"
@@ -230,4 +230,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* SVFMODULE_H_ */
+#endif /* INCLUDE_SVFMODULE_H_ */

package/SVF-osx/include/SVFIR/SVFStatements.h

@@ -28,8 +28,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef PAGEDGE_H_
-#define PAGEDGE_H_
+#ifndef INCLUDE_SVFIR_SVFSTATEMENT_H_
+#define INCLUDE_SVFIR_SVFSTATEMENT_H_
 
 #include "Graphs/GenericGraph.h"
 #include "MemoryModel/LocationSet.h"
@@ -1144,4 +1144,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* PAGEDGE_H_ */
+#endif /* INCLUDE_SVFIR_SVFSTATEMENT_H_ */

package/SVF-osx/include/SVFIR/SVFType.h

@@ -27,21 +27,20 @@
  *      Author: Yulei Sui
  */
 
+#ifndef INCLUDE_SVFIR_SVFTYPE_H_
+#define INCLUDE_SVFIR_SVFTYPE_H_
 
-#ifndef INCLUDE_UTIL_SVFBASICTYPES_H_
-#define INCLUDE_UTIL_SVFBASICTYPES_H_
-
-#include <Util/SparseBitVector.h>
+#include "Util/SparseBitVector.h"
 
+#include <deque>
 #include <iostream>
-#include <vector>
 #include <list>
-#include <set>
-#include <unordered_set>
 #include <map>
-#include <unordered_map>
+#include <set>
 #include <stack>
-#include <deque>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 namespace SVF
 {
@@ -72,7 +71,7 @@ template <class S, class T> struct Hash<std::pair<S, T>>
         return a > b ? b * b + a : a * a + a + b;
     }
 
-    size_t operator()(const std::pair<S, T> &t) const
+    size_t operator()(const std::pair<S, T>& t) const
     {
         Hash<decltype(t.first)> first;
         Hash<decltype(t.second)> second;
@@ -82,65 +81,68 @@ template <class S, class T> struct Hash<std::pair<S, T>>
 
 template <class T> struct Hash
 {
-    size_t operator()(const T &t) const
+    size_t operator()(const T& t) const
     {
         std::hash<T> h;
         return h(t);
     }
 };
 
-template <typename Key, typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>,
+template <typename Key, typename Hash = Hash<Key>,
+          typename KeyEqual = std::equal_to<Key>,
           typename Allocator = std::allocator<Key>>
 using Set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 
-template<typename Key, typename Value, typename Hash = Hash<Key>,
-         typename KeyEqual = std::equal_to<Key>,
-         typename Allocator = std::allocator<std::pair<const Key, Value>>>
-                 using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
-
-         template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key>>
-         using OrderedSet = std::set<Key, Compare, Allocator>;
-
-         template<typename Key, typename Value, typename Compare = std::less<Key>,
-                  typename Allocator = std::allocator<std::pair<const Key, Value>>>
-                          using OrderedMap = std::map<Key, Value, Compare, Allocator>;
-
-                  typedef std::pair<NodeID, NodeID> NodePair;
-                  typedef OrderedSet<NodeID> OrderedNodeSet;
-                  typedef Set<NodeID> NodeSet;
-                  typedef Set<NodePair> NodePairSet;
-                  typedef Map<NodePair,NodeID> NodePairMap;
-                  typedef std::vector<NodeID> NodeVector;
-                  typedef std::vector<EdgeID> EdgeVector;
-                  typedef std::stack<NodeID> NodeStack;
-                  typedef std::list<NodeID> NodeList;
-                  typedef std::deque<NodeID> NodeDeque;
-                  typedef NodeSet EdgeSet;
-                  typedef std::vector<u32_t> CallStrCxt;
-                  typedef unsigned Version;
-                  typedef Set<Version> VersionSet;
-                  typedef std::pair<NodeID, Version> VersionedVar;
-                  typedef Set<VersionedVar> VersionedVarSet;
-
-                  class SVFType;
-                  class SVFPointerType;
-
-                  /*!
-                   * Flatterned type information of StructType, ArrayType and SingleValueType
-                   */
-                  class StInfo
+template <typename Key, typename Value, typename Hash = Hash<Key>,
+          typename KeyEqual = std::equal_to<Key>,
+          typename Allocator = std::allocator<std::pair<const Key, Value>>>
+                  using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+          template <typename Key, typename Compare = std::less<Key>,
+                    typename Allocator = std::allocator<Key>>
+          using OrderedSet = std::set<Key, Compare, Allocator>;
+
+          template <typename Key, typename Value, typename Compare = std::less<Key>,
+                    typename Allocator = std::allocator<std::pair<const Key, Value>>>
+                            using OrderedMap = std::map<Key, Value, Compare, Allocator>;
+
+                    typedef std::pair<NodeID, NodeID> NodePair;
+                    typedef OrderedSet<NodeID> OrderedNodeSet;
+                    typedef Set<NodeID> NodeSet;
+                    typedef Set<NodePair> NodePairSet;
+                    typedef Map<NodePair, NodeID> NodePairMap;
+                    typedef std::vector<NodeID> NodeVector;
+                    typedef std::vector<EdgeID> EdgeVector;
+                    typedef std::stack<NodeID> NodeStack;
+                    typedef std::list<NodeID> NodeList;
+                    typedef std::deque<NodeID> NodeDeque;
+                    typedef NodeSet EdgeSet;
+                    typedef std::vector<u32_t> CallStrCxt;
+                    typedef unsigned Version;
+                    typedef Set<Version> VersionSet;
+                    typedef std::pair<NodeID, Version> VersionedVar;
+                    typedef Set<VersionedVar> VersionedVarSet;
+
+                    class SVFType;
+                    class SVFPointerType;
+
+                    /*!
+                     * Flatterned type information of StructType, ArrayType and SingleValueType
+                     */
+                    class StInfo
 {
-
 private:
     /// flattened field indices of a struct (ignoring arrays)
     std::vector<u32_t> fldIdxVec;
-    /// flattened element indices including structs and arrays by considering strides
+    /// flattened element indices including structs and arrays by considering
+    /// strides
     std::vector<u32_t> elemIdxVec;
     /// Types of all fields of a struct
     Map<u32_t, const SVFType*> fldIdx2TypeMap;
     /// All field infos after flattening a struct
     std::vector<const SVFType*> finfo;
-    /// stride represents the number of repetitive elements if this StInfo represent an ArrayType. stride is 1 by default.
+    /// stride represents the number of repetitive elements if this StInfo
+    /// represent an ArrayType. stride is 1 by default.
     u32_t stride;
     /// number of elements after flattenning (including array elements)
     u32_t numOfFlattenElements;
@@ -156,14 +158,15 @@ public:
     void operator=(const StInfo&) = delete;
 
     /// Constructor
-    explicit StInfo(u32_t s) : stride(s), numOfFlattenElements(s), numOfFlattenFields(s)
+    explicit StInfo(u32_t s)
+        : stride(s), numOfFlattenElements(s), numOfFlattenFields(s)
     {
     }
     /// Destructor
     ~StInfo() = default;
 
-    ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
-    ///  OriginalFieldType of b with field_idx 1 : Struct A
+    ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}  B b;
+    // OriginalFieldType of b with field_idx 1 : Struct A
     ///  FlatternedFieldType of b with field_idx 1 : int
     //{@
     const SVFType* getOriginalElemType(u32_t fldIdx) const;
@@ -248,27 +251,30 @@ public:
     };
 
 private:
-    GNodeK kind;	///< used for classof
-    const SVFPointerType* getPointerToTy; /// Return a pointer to the current type
-    StInfo* typeinfo; /// < SVF's TypeInfo
-    bool isSingleValTy; ///< The type represents a single value, not struct or array
+    GNodeK kind; ///< used for classof
+    const SVFPointerType*
+    getPointerToTy; /// Return a pointer to the current type
+    StInfo* typeinfo;   /// < SVF's TypeInfo
+    bool isSingleValTy; ///< The type represents a single value, not struct or
+    ///< array
 protected:
-    SVFType(bool svt, SVFTyKind k) : kind(k), getPointerToTy(nullptr), typeinfo(nullptr), isSingleValTy(svt)
+    SVFType(bool svt, SVFTyKind k)
+        : kind(k), getPointerToTy(nullptr), typeinfo(nullptr),
+          isSingleValTy(svt)
     {
     }
 
 public:
     SVFType(void) = delete;
-    virtual ~SVFType()
-    {
-    }
+    virtual ~SVFType() {}
 
     inline GNodeK getKind() const
     {
         return kind;
     }
 
-    /// Needs to be implemented by a specific SVF front end (e.g., the implementation in LLVMUtil)
+    /// Needs to be implemented by a specific SVF front end (e.g., the
+    /// implementation in LLVMUtil)
     virtual const std::string toString() const;
 
     inline void setPointerTo(const SVFPointerType* ty)
@@ -276,13 +282,13 @@ public:
         getPointerToTy = ty;
     }
 
-    inline const SVFPointerType* getPointerTo () const
+    inline const SVFPointerType* getPointerTo() const
     {
         assert(getPointerToTy && "set the getPointerToTy first");
         return getPointerToTy;
     }
 
-    inline void setTypeInfo (StInfo* ti)
+    inline void setTypeInfo(StInfo* ti)
     {
         typeinfo = ti;
     }
@@ -301,7 +307,7 @@ public:
 
     inline bool isPointerTy() const
     {
-        return kind==SVFPointerTy;
+        return kind == SVFPointerTy;
     }
 
     inline bool isSingleValueType() const
@@ -317,10 +323,11 @@ private:
     const SVFType* ptrElementType;
 
 public:
-    SVFPointerType(const SVFType* pty) : SVFType(true, SVFPointerTy), ptrElementType(pty)
+    SVFPointerType(const SVFType* pty)
+        : SVFType(true, SVFPointerTy), ptrElementType(pty)
     {
     }
-    static inline bool classof(const SVFType *node)
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFPointerTy;
     }
@@ -333,10 +340,8 @@ public:
 class SVFIntergerType : public SVFType
 {
 public:
-    SVFIntergerType() : SVFType(true, SVFIntergerTy)
-    {
-    }
-    static inline bool classof(const SVFType *node)
+    SVFIntergerType() : SVFType(true, SVFIntergerTy) {}
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFIntergerTy;
     }
@@ -348,10 +353,11 @@ private:
     const SVFType* retTy;
 
 public:
-    SVFFunctionType(const SVFType* rt) : SVFType(false, SVFFunctionTy), retTy(rt)
+    SVFFunctionType(const SVFType* rt)
+        : SVFType(false, SVFFunctionTy), retTy(rt)
     {
     }
-    static inline bool classof(const SVFType *node)
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFFunctionTy;
     }
@@ -364,10 +370,8 @@ public:
 class SVFStructType : public SVFType
 {
 public:
-    SVFStructType() : SVFType(false, SVFStructTy)
-    {
-    }
-    static inline bool classof(const SVFType *node)
+    SVFStructType() : SVFType(false, SVFStructTy) {}
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFStructTy;
     }
@@ -376,10 +380,8 @@ public:
 class SVFArrayType : public SVFType
 {
 public:
-    SVFArrayType() : SVFType(false, SVFArrayTy)
-    {
-    }
-    static inline bool classof(const SVFType *node)
+    SVFArrayType() : SVFType(false, SVFArrayTy) {}
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFArrayTy;
     }
@@ -388,20 +390,17 @@ public:
 class SVFOtherType : public SVFType
 {
 public:
-    SVFOtherType(bool isSingleValueTy) : SVFType(isSingleValueTy, SVFOtherTy)
-    {
-    }
-    static inline bool classof(const SVFType *node)
+    SVFOtherType(bool isSingleValueTy) : SVFType(isSingleValueTy, SVFOtherTy) {}
+    static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFOtherTy;
     }
 };
 
-
 // TODO: be explicit that this is a pair of 32-bit unsigneds?
 template <> struct Hash<NodePair>
 {
-    size_t operator()(const NodePair &p) const
+    size_t operator()(const NodePair& p) const
     {
         // Make sure our assumptions are sound: use u32_t
         // and u64_t. If NodeID is not actually u32_t or size_t
@@ -413,12 +412,32 @@ template <> struct Hash<NodePair>
     }
 };
 
+#ifndef DEBUG_WITH_TYPE
+#    ifndef NDBUG
+// TODO: This comes from the following link
+// https://github.com/llvm/llvm-project/blob/75e33f71c2dae584b13a7d1186ae0a038ba98838/llvm/include/llvm/Support/Debug.h#L64
+// The original LLVM implementation makes use of type. But we can get that info,
+// so we can't simulate the full behaviour for now.
+#        define DEBUG_WITH_TYPE(TYPE, X)                                       \
+            do                                                                 \
+            {                                                                  \
+                X;                                                             \
+            } while (false)
+#    else
+#        define DEBUG_WITH_TYPE(TYPE, X)                                       \
+            do                                                                 \
+            {                                                                  \
+            } while (false)
+#    endif
+#endif
+
 /// LLVM debug macros, define type of your DEBUG model of each pass
-#define DBOUT(TYPE, X) 	DEBUG_WITH_TYPE(TYPE, X)
-#define DOSTAT(X) 	X
-#define DOTIMESTAT(X) 	X
+#define DBOUT(TYPE, X) DEBUG_WITH_TYPE(TYPE, X)
+#define DOSTAT(X) X
+#define DOTIMESTAT(X) X
 
-/// General debug flag is for each phase of a pass, it is often in a colorful output format
+/// General debug flag is for each phase of a pass, it is often in a colorful
+/// output format
 #define DGENERAL "general"
 
 #define DPAGBuild "pag"
@@ -465,10 +484,9 @@ enum AliasResult
 
 } // End namespace SVF
 
-
 template <> struct std::hash<SVF::NodePair>
 {
-    size_t operator()(const SVF::NodePair &p) const
+    size_t operator()(const SVF::NodePair& p) const
     {
         // Make sure our assumptions are sound: use u32_t
         // and u64_t. If NodeID is not actually u32_t or size_t
@@ -481,26 +499,25 @@ template <> struct std::hash<SVF::NodePair>
 };
 
 /// Specialise hash for SparseBitVectors.
-template <unsigned N>
-struct std::hash<SVF::SparseBitVector<N>>
+template <unsigned N> struct std::hash<SVF::SparseBitVector<N>>
 {
-    size_t operator()(const SVF::SparseBitVector<N> &sbv) const
+    size_t operator()(const SVF::SparseBitVector<N>& sbv) const
     {
         SVF::Hash<std::pair<std::pair<size_t, size_t>, size_t>> h;
-        return h(std::make_pair(std::make_pair(sbv.count(), sbv.find_first()), sbv.find_last()));
+        return h(std::make_pair(std::make_pair(sbv.count(), sbv.find_first()),
+                                sbv.find_last()));
     }
 };
 
-template <typename T>
-struct std::hash<std::vector<T>>
+template <typename T> struct std::hash<std::vector<T>>
 {
-    size_t operator()(const std::vector<T> &v) const
+    size_t operator()(const std::vector<T>& v) const
     {
         // TODO: repetition with CBV.
         size_t h = v.size();
 
         SVF::Hash<T> hf;
-        for (const T &t : v)
+        for (const T& t : v)
         {
             h ^= hf(t) + 0x9e3779b9 + (h << 6) + (h >> 2);
         }
@@ -509,4 +526,4 @@ struct std::hash<std::vector<T>>
     }
 };
 
-#endif /* INCLUDE_UTIL_SVFBASICTYPES_H_ */
+#endif /* INCLUDE_SVFIR_SVFTYPE_H_ */

package/SVF-osx/include/SVFIR/SVFValue.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef BASICTYPES_H_
-#define BASICTYPES_H_
+#ifndef INCLUDE_SVFIR_SVFVALUE_H_
+#define INCLUDE_SVFIR_SVFVALUE_H_
 
 #include "SVFIR/SVFType.h"
 #include "Graphs/GraphPrinter.h"
@@ -1117,4 +1117,4 @@ template <> struct std::hash<SVF::CallSite>
     }
 };
 
-#endif /* BASICTYPES_H_ */
+#endif /* INCLUDE_SVFIR_SVFVALUE_H_ */

package/SVF-osx/include/SVFIR/SVFVariables.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef OBJECTANDSYMBOL_H_
-#define OBJECTANDSYMBOL_H_
+#ifndef INCLUDE_SVFIR_SVFVARIABLE_H_
+#define INCLUDE_SVFIR_SVFVARIABLE_H_
 
 #include "Graphs/GenericGraph.h"
 #include "SVFIR/SymbolTableInfo.h"
@@ -718,4 +718,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* OBJECTANDSYMBOL_H_ */
+#endif /* INCLUDE_SVFIR_SVFVARIABLE_H_ */

package/SVF-osx/include/SVFIR/SymbolTableInfo.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef INCLUDE_SVF_FE_SYMBOLTABLEINFO_H_
-#define INCLUDE_SVF_FE_SYMBOLTABLEINFO_H_
+#ifndef INCLUDE_SVFIR_SYMBOLTABLEINFO_H_
+#define INCLUDE_SVFIR_SYMBOLTABLEINFO_H_
 
 
 #include "Util/SVFUtil.h"
@@ -594,4 +594,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* INCLUDE_SVF_FE_SYMBOLTABLEINFO_H_ */
+#endif /* INCLUDE_SVFIR_SYMBOLTABLEINFO_H_ */

package/SVF-osx/include/Util/Annotator.h

@@ -8,6 +8,7 @@
 #ifndef ANNOTATOR_H_
 #define ANNOTATOR_H_
 
+#include <SVF-LLVM/BasicTypes.h> // TODO: Remove LLVM Header
 #include "SVFIR/SVFValue.h"
 #include <vector>
 
@@ -36,7 +37,6 @@ public:
     /// Destructor
     virtual ~Annotator()
     {
-
     }
 
     /// SB Has flag methods
@@ -46,6 +46,7 @@ public:
         std::vector<Value* > values;
         return evalMDTag(inst, inst, SB_SLICESOURCE, values);
     }
+
     inline bool hasSBSinkFlag(Instruction* inst) const
     {
         std::vector<Value* > values;
@@ -59,38 +60,28 @@ public:
     {
         //std::vector<Value* > values;
         //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
-        if (inst->getMetadata(DR_NOT_CHECK))
-            return true;
-        else
-            return false;
+        return inst->getMetadata(DR_NOT_CHECK);
     }
+
     inline bool hasDRNotCheckFlag(const Instruction* inst) const
     {
         //std::vector<Value* > values;
         //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
-        if (inst->getMetadata(DR_NOT_CHECK))
-            return true;
-        else
-            return false;
+        return inst->getMetadata(DR_NOT_CHECK);
     }
 
     inline bool hasDRCheckFlag(Instruction* inst) const
     {
         //std::vector<Value* > values;
         //return evalMDTag(inst, inst, DR_CHECK, values);
-        if (inst->getMetadata(DR_CHECK))
-            return true;
-        else
-            return false;
+        return inst->getMetadata(DR_CHECK);
     }
+
     inline bool hasDRCheckFlag(const Instruction* inst) const
     {
         //std::vector<Value* > values;
         //return evalMDTag(inst, inst, DR_CHECK, values);
-        if (inst->getMetadata(DR_CHECK))
-            return true;
-        else
-            return false;
+        return inst->getMetadata(DR_CHECK);
     }
     //@}
 

package/SVF-osx/include/Util/CppUtil.h

@@ -0,0 +1,81 @@
+//===- CPPUtil.h -- Base class of pointer analyses ---------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CPPUtil.h
+ *
+ *  Created on: Apr 13, 2016
+ *      Author: Xiaokang Fan
+ */
+
+#ifndef CPPUtil_H_
+#define CPPUtil_H_
+
+#include "SVFIR/SVFValue.h"
+
+namespace SVF
+{
+
+class CHGraph;
+/*
+ * Util class to assist pointer analysis for cpp programs
+ */
+
+namespace cppUtil
+{
+
+struct DemangledName
+{
+    std::string className;
+    std::string funcName;
+    bool isThunkFunc;
+};
+
+struct DemangledName demangle(const std::string& name);
+
+std::string getBeforeBrackets(const std::string& name);
+std::string getClassNameFromVtblObj(const std::string& vtblName);
+
+/// Constants pertaining to CTir, for C and C++.
+/// TODO: move helper functions here too?
+namespace ctir
+{
+/// On loads, stores, GEPs representing dereferences, and calls
+/// representing virtual calls.
+/// (The static type.)
+const std::string derefMDName = "ctir";
+/// On the (global) virtual table itself.
+/// (The class it corresponds to.)
+const std::string vtMDName = "ctir.vt";
+/// On the bitcast of `this` to i8*.
+/// (The class the constructor it corresponds to.)
+const std::string vtInitMDName = "ctir.vt.init";
+
+/// Value we expect a ctir-annotated module to have.
+const uint32_t moduleFlagValue = 1;
+} // namespace ctir
+
+} // End namespace cppUtil
+
+} // End namespace SVF
+
+#endif /* CPPUtil_H_ */

package/SVF-osx/include/Util/SVFUtil.h

@@ -31,8 +31,9 @@
 #define AnalysisUtil_H_
 
 #include "FastCluster/fastcluster.h"
-#include "SVF-LLVM/LLVMModule.h"
 #include "SVFIR/SVFValue.h"
+#include "SVFIR/SVFModule.h"
+#include "Util/ExtAPI.h"
 #include "MemoryModel/PointsTo.h"
 #include <time.h>
 
@@ -345,12 +346,11 @@ inline bool isStaticExtFun(const SVFFunction* fun)
 /// Program entry function e.g. main
 //@{
 /// Return true if this is a program entry function (e.g. main)
-inline bool isProgEntryFunction (const SVFFunction * fun)
+inline bool isProgEntryFunction(const SVFFunction* fun)
 {
     return fun && fun->getName() == "main";
 }
 
-
 /// Get program entry function from module.
 inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
 {
@@ -636,12 +636,6 @@ inline const SVFValue* getTaskDataAtHareParForSite(const SVFInstruction *inst)
 }
 //@}
 
-inline bool isProgEntryFunction (const Function*  fun)
-{
-    return fun && fun->getName() == "main";
-}
-
-
 inline bool isProgExitCall(const CallSite cs)
 {
     return isProgExitFunction(getCallee(cs));

package/package.json

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