svf-lib 1.0.1301 → 1.0.1302

package/SVF-osx/include/SVF-FE/BreakConstantExpr.h

@@ -1,94 +0,0 @@
-//===- BreakConstantGEPs.h - Change constant GEPs into GEP instructions --- --//
-//
-//                          The SAFECode Compiler
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This pass changes all GEP constant expressions into GEP instructions.  This
-// permits the rest of SAFECode to put run-time checks on them if necessary.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef BREAKCONSTANTGEPS_H
-#define BREAKCONSTANTGEPS_H
-
-#include "Util/BasicTypes.h"
-
-namespace SVF
-{
-
-//
-// Pass: BreakConstantGEPs
-//
-// Description:
-//  This pass modifies a function so that it uses GEP instructions instead of
-//  GEP constant expressions.
-//
-class BreakConstantGEPs : public ModulePass
-{
-private:
-    // Private methods
-
-    // Private variables
-
-public:
-    static char ID;
-    BreakConstantGEPs() : ModulePass(ID) {}
-    llvm::StringRef getPassName() const
-    {
-        return "Remove Constant GEP Expressions";
-    }
-    virtual bool runOnModule (Module & M);
-};
-
-
-//
-// Pass: MergeFunctionRets
-//
-// Description:
-//  This pass modifies a function so that each function only have one unified exit basic block
-//
-class MergeFunctionRets : public ModulePass
-{
-private:
-    // Private methods
-
-    // Private variables
-
-public:
-    static char ID;
-    MergeFunctionRets() : ModulePass(ID) {}
-    llvm::StringRef getPassName() const
-    {
-        return "unify function exit into one dummy exit basic block";
-    }
-    virtual bool runOnModule (Module & M)
-    {
-        UnifyFunctionExit(M);
-        return true;
-    }
-    inline void UnifyFunctionExit(Module& module)
-    {
-        for (Module::const_iterator iter = module.begin(), eiter = module.end();
-                iter != eiter; ++iter)
-        {
-            const Function& fun = *iter;
-            if(fun.isDeclaration())
-                continue;
-            getUnifyExit(fun)->runOnFunction(const_cast<Function&>(fun));
-        }
-    }
-    /// Get Unified Exit basic block node
-    inline UnifyFunctionExitNodes* getUnifyExit(const Function& fn)
-    {
-        assert(!fn.isDeclaration() && "external function does not have DF");
-        return &getAnalysis<UnifyFunctionExitNodes>(const_cast<Function&>(fn));
-    }
-};
-
-} // End namespace SVF
-
-#endif

package/SVF-osx/include/SVF-FE/CHG.h

@@ -1,334 +0,0 @@
-//===----- CHG.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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CHG.h (previously CHA.h)
- *
- *  Created on: Apr 13, 2016
- *      Author: Xiaokang Fan
- */
-
-#ifndef CHA_H_
-#define CHA_H_
-
-#include "Util/SVFModule.h"
-#include "SVF-FE/CommonCHG.h"
-#include "Graphs/GenericGraph.h"
-#include "Util/WorkList.h"
-
-namespace SVF
-{
-
-class SVFModule;
-class CHNode;
-
-typedef GenericEdge<CHNode> GenericCHEdgeTy;
-class CHEdge: public GenericCHEdgeTy
-{
-public:
-    typedef enum
-    {
-        INHERITANCE = 0x1, // inheritance relation
-        INSTANTCE = 0x2 // template-instance relation
-    } CHEDGETYPE;
-
-    typedef GenericNode<CHNode,CHEdge>::GEdgeSetTy CHEdgeSetTy;
-
-    CHEdge(CHNode *s, CHNode *d, CHEDGETYPE et, GEdgeFlag k = 0):
-        GenericCHEdgeTy(s,d,k)
-    {
-        edgeType = et;
-    }
-
-    CHEDGETYPE getEdgeType() const
-    {
-        return edgeType;
-    }
-
-private:
-    CHEDGETYPE edgeType;
-};
-
-typedef GenericNode<CHNode,CHEdge> GenericCHNodeTy;
-class CHNode: public GenericCHNodeTy
-{
-public:
-    typedef enum
-    {
-        PURE_ABSTRACT = 0x1, // pure virtual abstract class
-        MULTI_INHERITANCE = 0x2, // multi inheritance class
-        TEMPLATE = 0x04 // template class
-    } CLASSATTR;
-
-    typedef std::vector<const SVFFunction*> FuncVector;
-
-    CHNode (const std::string name, NodeID i = 0, GNodeK k = 0):
-        GenericCHNodeTy(i, k), vtable(nullptr), className(name), flags(0)
-    {
-    }
-    ~CHNode()
-    {
-    }
-    std::string getName() const
-    {
-        return className;
-    }
-    /// Flags
-    //@{
-    inline void setFlag(CLASSATTR mask)
-    {
-        flags |= mask;
-    }
-    inline bool hasFlag(CLASSATTR mask) const
-    {
-        return (flags & mask) == mask;
-    }
-    //@}
-
-    /// Attribute
-    //@{
-    inline void setPureAbstract()
-    {
-        setFlag(PURE_ABSTRACT);
-    }
-    inline void setMultiInheritance()
-    {
-        setFlag(MULTI_INHERITANCE);
-    }
-    inline void setTemplate()
-    {
-        setFlag(TEMPLATE);
-    }
-    inline bool isPureAbstract() const
-    {
-        return hasFlag(PURE_ABSTRACT);
-    }
-    inline bool isMultiInheritance() const
-    {
-        return hasFlag(MULTI_INHERITANCE);
-    }
-    inline bool isTemplate() const
-    {
-        return hasFlag(TEMPLATE);
-    }
-    //@}
-
-    void addVirtualFunctionVector(FuncVector vfuncvec)
-    {
-        virtualFunctionVectors.push_back(vfuncvec);
-    }
-    const std::vector<FuncVector> &getVirtualFunctionVectors() const
-    {
-        return virtualFunctionVectors;
-    }
-    void getVirtualFunctions(u32_t idx, FuncVector &virtualFunctions) const;
-
-    const GlobalValue *getVTable() const
-    {
-        return vtable;
-    }
-
-    void setVTable(const GlobalValue *vtbl)
-    {
-        vtable = vtbl;
-    }
-
-private:
-    const GlobalValue* vtable;
-    std::string className;
-    size_t flags;
-    /*
-     * virtual functions inherited from different classes are separately stored
-     * to model different vtables inherited from different fathers.
-     *
-     * Example:
-     * class C: public A, public B
-     * vtableC = {Af1, Af2, ..., inttoptr, Bg1, Bg2, ...} ("inttoptr"
-     * instruction works as the delimiter for separating virtual functions
-     * inherited from different classes)
-     *
-     * virtualFunctionVectors = {{Af1, Af2, ...}, {Bg1, Bg2, ...}}
-     */
-    std::vector<FuncVector> virtualFunctionVectors;
-};
-
-/// class hierarchy graph
-typedef GenericGraph<CHNode,CHEdge> GenericCHGraphTy;
-class CHGraph: public CommonCHGraph, public GenericCHGraphTy
-{
-public:
-    typedef Set<const CHNode*> CHNodeSetTy;
-    typedef FIFOWorkList<const CHNode*> WorkList;
-    typedef Map<std::string, CHNodeSetTy> NameToCHNodesMap;
-    typedef Map<CallSite, CHNodeSetTy> CallSiteToCHNodesMap;
-    typedef Map<CallSite, VTableSet> CallSiteToVTableSetMap;
-    typedef Map<CallSite, VFunSet> CallSiteToVFunSetMap;
-
-    typedef enum
-    {
-        CONSTRUCTOR = 0x1, // connect node based on constructor
-        DESTRUCTOR = 0x2 // connect node based on destructor
-    } RELATIONTYPE;
-
-    CHGraph(SVFModule* svfModule): svfMod(svfModule), classNum(0), vfID(0), buildingCHGTime(0)
-    {
-        this->kind = Standard;
-    }
-    ~CHGraph() override = default;
-
-    void buildCHG();
-    void buildInternalMaps();
-    void buildCHGNodes(const GlobalValue *V);
-    void buildCHGNodes(const SVFFunction* F);
-    void buildCHGEdges(const SVFFunction* F);
-    void connectInheritEdgeViaCall(const SVFFunction* caller, CallSite cs);
-    void connectInheritEdgeViaStore(const SVFFunction* caller, const StoreInst* store);
-    void addEdge(const std::string className,
-                 const std::string baseClassName,
-                 CHEdge::CHEDGETYPE edgeType);
-    CHNode *getNode(const std::string name) const;
-    CHNode *createNode(const std::string name);
-    void buildClassNameToAncestorsDescendantsMap();
-    void buildVirtualFunctionToIDMap();
-    void buildCSToCHAVtblsAndVfnsMap();
-    void readInheritanceMetadataFromModule(const Module &M);
-    void analyzeVTables(const Module &M);
-    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string className);
-    const CHNodeSetTy& getCSClasses(CallSite cs);
-    void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
-    void dump(const std::string& filename);
-    void view();
-    void printCH();
-
-    inline s32_t getVirtualFunctionID(const SVFFunction* vfn) const
-    {
-        Map<const SVFFunction*, s32_t>::const_iterator it =
-            virtualFunctionToIDMap.find(vfn);
-        if (it != virtualFunctionToIDMap.end())
-            return it->second;
-        else
-            return -1;
-    }
-    inline const SVFFunction* getVirtualFunctionBasedonID(s32_t id) const
-    {
-        Map<const SVFFunction*, s32_t>::const_iterator it, eit;
-        for (it = virtualFunctionToIDMap.begin(), eit =
-                    virtualFunctionToIDMap.end(); it != eit; ++it)
-        {
-            if (it->second == id)
-                return it->first;
-        }
-        return nullptr;
-    }
-
-    inline void addInstances(const std::string templateName, CHNode* node)
-    {
-        NameToCHNodesMap::iterator it = templateNameToInstancesMap.find(
-                                            templateName);
-        if (it != templateNameToInstancesMap.end())
-            it->second.insert(node);
-        else
-            templateNameToInstancesMap[templateName].insert(node);
-    }
-    inline const CHNodeSetTy &getDescendants(const std::string className)
-    {
-        return classNameToDescendantsMap[className];
-    }
-    inline const CHNodeSetTy &getInstances(const std::string className)
-    {
-        return templateNameToInstancesMap[className];
-    }
-
-    inline bool csHasVtblsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
-        return it != csToCHAVtblsMap.end();
-    }
-    inline bool csHasVFnsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
-        return it != csToCHAVFnsMap.end();
-    }
-    inline const VTableSet &getCSVtblsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
-        assert(it != csToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
-        return it->second;
-    }
-    inline const VFunSet &getCSVFsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
-        assert(it != csToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
-        return it->second;
-    }
-
-    static inline bool classof(const CommonCHGraph *chg)
-    {
-        return chg->getKind() == Standard;
-    }
-
-protected:
-    void addFuncToFuncVector(CHNode::FuncVector &v, const SVFFunction *f);
-
-private:
-    SVFModule* svfMod;
-    u32_t classNum;
-    s32_t vfID;
-    double buildingCHGTime;
-    Map<std::string, CHNode *> classNameToNodeMap;
-    NameToCHNodesMap classNameToDescendantsMap;
-    NameToCHNodesMap classNameToAncestorsMap;
-    NameToCHNodesMap classNameToInstAndDescsMap;
-    NameToCHNodesMap templateNameToInstancesMap;
-    CallSiteToCHNodesMap csToClassesMap;
-
-    Map<const SVFFunction*, s32_t> virtualFunctionToIDMap;
-    CallSiteToVTableSetMap csToCHAVtblsMap;
-    CallSiteToVFunSetMap csToCHAVFnsMap;
-};
-
-} // End namespace SVF
-
-namespace llvm
-{
-/* !
- * GraphTraits specializations for generic graph algorithms.
- * Provide graph traits for traversing from a constraint node using standard graph traversals.
- */
-template<> struct GraphTraits<SVF::CHNode*> : public GraphTraits<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>*  >
-{
-};
-
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
-template<>
-struct GraphTraits<Inverse<SVF::CHNode*> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>* > >
-{
-};
-
-template<> struct GraphTraits<SVF::CHGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CHNode,SVF::CHEdge>* >
-{
-    typedef SVF::CHNode *NodeRef;
-};
-
-} // End namespace llvm
-
-#endif /* CHA_H_ */

package/SVF-osx/include/SVF-FE/CHGBuilder.h

@@ -1,73 +0,0 @@
-//===----- CHGBuiler.h -- Class hierarchy graph builder ---------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CHGBuiler.h
- *
- *  Created on: Jun 4, 2021
- *      Author: Yulei Sui
- */
-
-#include "Graphs/CHG.h"
-#include "SVF-FE/BasicTypes.h"
-
-namespace SVF
-{
-
-class CHGBuilder
-{
-
-private:
-    CHGraph* chg;
-
-public:
-    typedef CHGraph::CHNodeSetTy CHNodeSetTy;
-    typedef CHGraph::WorkList WorkList;
-
-    CHGBuilder(CHGraph* c): chg(c)
-    {
-
-    }
-    void buildCHG();
-    void buildCHGNodes(const GlobalValue *V);
-    void buildCHGNodes(const SVFFunction* F);
-    void buildCHGEdges(const SVFFunction* F);
-    void buildInternalMaps();
-    void readInheritanceMetadataFromModule(const Module &M);
-
-    CHNode *createNode(const std::string name);
-
-    void connectInheritEdgeViaCall(const SVFFunction* caller, CallSite cs);
-    void connectInheritEdgeViaStore(const SVFFunction* caller, const StoreInst* store);
-
-    void buildClassNameToAncestorsDescendantsMap();
-    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string className);
-
-    void analyzeVTables(const Module &M);
-    void buildVirtualFunctionToIDMap();
-    void buildCSToCHAVtblsAndVfnsMap();
-    const CHNodeSetTy& getCSClasses(CallSite cs);
-    void addFuncToFuncVector(CHNode::FuncVector &v, const SVFFunction *f);
-};
-
-} // End namespace SVF
-

package/SVF-osx/include/SVF-FE/CPPUtil.h

@@ -1,130 +0,0 @@
-//===- 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 "Util/BasicTypes.h"
-#include "SVF-FE/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);
-bool isValVtbl(const Value* val);
-bool isLoadVtblInst(const LoadInst *loadInst);
-bool isVirtualCallSite(CallSite 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(CallSite cs);
-const Value* getVCallVtblPtr(CallSite cs);
-u64_t getVCallIdx(CallSite cs);
-std::string getClassNameFromVtblObj(const Value* value);
-std::string getClassNameFromType(const Type *ty);
-std::string getClassNameOfThisPtr(CallSite cs);
-std::string getFunNameOfVCallSite(CallSite cs);
-bool VCallInCtorOrDtor(CallSite 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;
-}
-
-} // End namespace cppUtil
-
-} // End namespace SVF
-
-#endif /* CPPUtil_H_ */

package/SVF-osx/include/SVF-FE/CallGraphBuilder.h

@@ -1,74 +0,0 @@
-//===- CallGraphBuilder.h ----------------------------------------------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <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/>.
-//
-//===----------------------------------------------------------------------===//
-
-
-/*
- * CallGraphBuilder.h
- *
- *  Created on: 13Mar.,2020
- *      Author: Yulei Sui
- */
-
-#ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
-#define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
-
-#include "Graphs/PTACallGraph.h"
-#include "Graphs/ThreadCallGraph.h"
-
-namespace SVF
-{
-
-class ICFG;
-
-class CallGraphBuilder
-{
-
-protected:
-    PTACallGraph* callgraph;
-    ICFG* icfg;
-public:
-    CallGraphBuilder(PTACallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
-    {
-    }
-
-    /// Build normal callgraph
-    PTACallGraph* buildCallGraph(SVFModule* svfModule);
-
-};
-
-class ThreadCallGraphBuilder : public CallGraphBuilder
-{
-
-public:
-    ThreadCallGraphBuilder(ThreadCallGraph* cg, ICFG* i): CallGraphBuilder(cg,i)
-    {
-    }
-
-    /// Build thread-aware callgraph
-    PTACallGraph* buildThreadCallGraph(SVFModule* svfModule);
-
-};
-
-} // End namespace SVF
-
-
-#endif /* INCLUDE_UTIL_CALLGRAPHBUILDER_H_ */