svf-lib 1.0.1822 → 1.0.1824

package/SVF-linux/svf-llvm/include/SVF-LLVM/CppUtil.h

@@ -0,0 +1,155 @@
+//===- 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 Affero 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 Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero 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"
+#include "SVF-LLVM/BasicTypes.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);
+
+/*
+ * Get the vtable struct of a class.
+ *
+ * Given the class:
+ *
+ *   class A {
+ *     virtual ~A();
+ *   };
+ *   A::~A() = default;
+ *
+ *  The corresponding vtable @_ZTV1A is of type:
+ *
+ *    { [4 x i8*] }
+ *
+ *  If the program has been compiled with AddressSanitizer,
+ *  the vtable will have redzones and appear as:
+ *
+ *    { { [4 x i8*] }, [32 x i8] }
+ *
+ *  See https://github.com/SVF-tools/SVF/issues/1114 for more.
+ */
+const ConstantStruct *getVtblStruct(const GlobalValue *vtbl);
+
+bool isValVtbl(const Value* val);
+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);
+bool classTyHasVTable(const StructType* ty);
+std::string getClassNameFromType(const StructType* 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);
+
+/// 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-linux/svf-llvm/include/SVF-LLVM/DCHG.h

@@ -16,7 +16,6 @@
 
 #include "Graphs/GenericGraph.h"
 #include "Graphs/CHG.h"
-#include "Util/CppUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
@@ -413,14 +412,7 @@ private:
     DCHNode* getOrCreateNode(const DIType* type);
 
     /// Retrieves the metadata associated with a *virtual* callsite.
-    const DIType* getCSStaticType(CallBase* cs) const
-    {
-        MDNode *md = cs->getMetadata(cppUtil::ctir::derefMDName);
-        assert(md != nullptr && "Missing type metadata at virtual callsite");
-        DIType *diType = SVFUtil::dyn_cast<DIType>(md);
-        assert(diType != nullptr && "Incorrect metadata type at virtual callsite");
-        return diType;
-    }
+    const DIType* getCSStaticType(CallBase* cs) const;
 
     const DIType *getCSStaticType(CallSite cs) const
     {

package/SVF-linux/svf-llvm/include/SVF-LLVM/ICFGBuilder.h

@@ -32,6 +32,7 @@
 
 #include "Graphs/ICFG.h"
 #include "Util/WorkList.h"
+#include "BasicTypes.h"
 
 namespace SVF
 {

package/SVF-linux/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -31,7 +31,6 @@
 #define INCLUDE_SVF_FE_LLVMMODULE_H_
 
 #include "SVF-LLVM/BasicTypes.h"
-#include "Util/CppUtil.h"
 #include "SVFIR/SVFValue.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/Options.h"

package/SVF-linux/svf-llvm/include/SVF-LLVM/LLVMUtil.h

@@ -32,7 +32,6 @@
 
 #include "Util/SVFUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/LLVMModule.h"
 #include "SVFIR/SVFValue.h"
 #include "Util/ThreadAPI.h"
 
@@ -54,15 +53,7 @@ inline bool isCallSite(const Value* val)
 }
 
 /// Get the definition of a function across multiple modules
-inline const Function* getDefFunForMultipleModule(const Function* fun)
-{
-    if (fun == nullptr)
-        return nullptr;
-    LLVMModuleSet* llvmModuleset = LLVMModuleSet::getLLVMModuleSet();
-    if (fun->isDeclaration() && llvmModuleset->hasDefinition(fun))
-        fun = LLVMModuleSet::getLLVMModuleSet()->getDefinition(fun);
-    return fun;
-}
+const Function* getDefFunForMultipleModule(const Function* fun);
 
 /// Return LLVM callsite given a value
 inline const CallBase* getLLVMCallSite(const Value* value)
@@ -85,18 +76,7 @@ inline const Function* getLLVMFunction(const Value* val)
 }
 
 /// Get program entry function from module.
-inline const Function* getProgFunction(const std::string& funName)
-{
-    for (const Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
-    {
-        for (const Function& fun : M)
-        {
-            if (fun.getName() == funName)
-                return &fun;
-        }
-    }
-    return nullptr;
-}
+const Function* getProgFunction(const std::string& funName);
 
 /// Check whether a function is an entry function (i.e., main)
 inline bool isProgEntryFunction(const Function* fun)
@@ -354,10 +334,7 @@ void removeUnusedGlobalVariables(Module* module);
 void removeUnusedFuncsAndAnnotationsAndGlobalVariables(std::vector<Function*> removedFuncList);
 
 /// Get the corresponding Function based on its name
-inline const SVFFunction* getFunction(const std::string& name)
-{
-    return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(name);
-}
+const SVFFunction* getFunction(const std::string& name);
 
 /// Return true if the value refers to constant data, e.g., i32 0
 inline bool isConstDataOrAggData(const Value* val)
@@ -367,15 +344,7 @@ inline bool isConstDataOrAggData(const Value* 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 (LLVMModuleSet::getLLVMModuleSet()->hasGlobalRep(gvar))
-            val = LLVMModuleSet::getLLVMModuleSet()->getGlobalRep(gvar);
-    }
-    return val;
-}
+const Value* getGlobalRep(const Value* val);
 
 /// Check whether this value points-to a constant object
 bool isConstantObjSym(const SVFValue* val);
@@ -389,79 +358,6 @@ void viewCFG(const Function* fun);
 // Dump Control Flow Graph of llvm function, without instructions
 void viewCFGOnly(const Function* fun);
 
-/*
- * Get the vtable struct of a class.
- *
- * Given the class:
- *
- *   class A {
- *     virtual ~A();
- *   };
- *   A::~A() = default;
- *
- *  The corresponding vtable @_ZTV1A is of type:
- *
- *    { [4 x i8*] }
- *
- *  If the program has been compiled with AddressSanitizer,
- *  the vtable will have redzones and appear as:
- *
- *    { { [4 x i8*] }, [32 x i8] }
- *
- *  See https://github.com/SVF-tools/SVF/issues/1114 for more.
- */
-const ConstantStruct *getVtblStruct(const GlobalValue *vtbl);
-
-bool isValVtbl(const Value* val);
-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);
-bool classTyHasVTable(const StructType* ty);
-std::string getClassNameFromType(const StructType* 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);
-
 std::string dumpValue(const Value* val);
 
 std::string dumpType(const Type* type);

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

@@ -243,6 +243,7 @@ class SVFType
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class LLVMModuleSet;
 
 public:
     typedef s64_t GNodeK;
@@ -258,6 +259,25 @@ public:
         SVFOtherTy,
     };
 
+public:
+
+    inline static SVFType* getPtrTy()
+    {
+        assert(ptrTy && "ptr type not set?");
+        return ptrTy;
+    }
+
+    inline static SVFType* getI8Ty()
+    {
+        assert(i8Ty && "int8 type not set?");
+        return i8Ty;
+    }
+
+private:
+
+    static SVFType* ptrTy; ///< ptr type
+    static SVFType* i8Ty; ///< 8-bit int type
+
 private:
     GNodeK kind; ///< used for classof
     const SVFPointerType*
@@ -268,7 +288,7 @@ private:
     ///< array
 
 protected:
-    SVFType(bool svt, SVFTyKind k, u32_t Sz)
+    SVFType(bool svt, SVFTyKind k, u32_t Sz = 1)
         : kind(k), getPointerToTy(nullptr), typeinfo(nullptr),
           isSingleValTy(svt), byteSize(Sz)
     {
@@ -357,7 +377,7 @@ private:
     const SVFType* ptrElementType;
 
 public:
-    SVFPointerType(u32_t byteSize)
+    SVFPointerType(u32_t byteSize = 1)
         : SVFType(true, SVFPointerTy, byteSize), ptrElementType(nullptr)
     {
     }
@@ -389,7 +409,7 @@ private:
     short signAndWidth; ///< For printing
 
 public:
-    SVFIntegerType(u32_t byteSize) : SVFType(true, SVFIntegerTy, byteSize) {}
+    SVFIntegerType(u32_t byteSize = 1) : SVFType(true, SVFIntegerTy, byteSize) {}
     static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFIntegerTy;
@@ -418,7 +438,7 @@ private:
 
 public:
     SVFFunctionType(const SVFType* rt)
-        : SVFType(false, SVFFunctionTy, 0), retTy(rt)
+        : SVFType(false, SVFFunctionTy, 1), retTy(rt)
     {
     }
     static inline bool classof(const SVFType* node)
@@ -443,7 +463,7 @@ private:
     std::string name;
 
 public:
-    SVFStructType(u32_t byteSize) : SVFType(false, SVFStructTy, byteSize) {}
+    SVFStructType(u32_t byteSize = 1) : SVFType(false, SVFStructTy, byteSize) {}
 
     static inline bool classof(const SVFType* node)
     {
@@ -476,7 +496,7 @@ private:
     const SVFType* typeOfElement; /// For printing & debugging
 
 public:
-    SVFArrayType(u32_t byteSize)
+    SVFArrayType(u32_t byteSize = 1)
         : SVFType(false, SVFArrayTy, byteSize), numOfElement(0), typeOfElement(nullptr)
     {
     }
@@ -515,7 +535,7 @@ private:
     std::string repr; /// Field representation for printing
 
 public:
-    SVFOtherType(u32_t byteSize, bool isSingleValueTy) : SVFType(isSingleValueTy, SVFOtherTy, byteSize) {}
+    SVFOtherType(bool isSingleValueTy, u32_t byteSize = 1) : SVFType(isSingleValueTy, SVFOtherTy, byteSize) {}
 
     static inline bool classof(const SVFType* node)
     {

package/package.json

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