svf-lib 1.0.2245 → 1.0.2247

package/SVF-linux-x86_64/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -39,7 +39,6 @@
 namespace SVF
 {
 
-class SVFModule;
 /*!
  *  SVFIR Builder to create SVF variables and statements and PAG
  */
@@ -48,13 +47,12 @@ class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
 
 private:
     SVFIR* pag;
-    SVFModule* svfModule;
     const SVFBasicBlock* curBB;	///< Current basic block during SVFIR construction when visiting the module
-    const SVFLLVMValue* curVal;	///< Current Value during SVFIR construction when visiting the module
+    const Value* curVal;	///< Current Value during SVFIR construction when visiting the module
 
 public:
     /// Constructor
-    SVFIRBuilder(SVFModule* mod): pag(SVFIR::getPAG()), svfModule(mod), curBB(nullptr),curVal(nullptr)
+    SVFIRBuilder(): pag(SVFIR::getPAG()), curBB(nullptr),curVal(nullptr)
     {
     }
     /// Destructor
@@ -71,12 +69,19 @@ public:
         return pag;
     }
 
+    void createFunObjVars();
+    void initFunObjVar();
+
     /// Initialize nodes and edges
     //@{
     void initialiseNodes();
     void initialiseBaseObjVars();
     void initialiseValVars();
-    void initialiseFunObjVars();
+
+    void initSVFBasicBlock(const Function* func);
+
+    void initDomTree(FunObjVar* func, const Function* f);
+
     void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
                  APOffset offset = 0, Instruction* cs = nullptr);
     // @}
@@ -93,15 +98,13 @@ public:
         processCE(V);
 
         // strip off the constant cast and return the value node
-        SVFLLVMValue* svfVal = llvmModuleSet()->getSVFValue(V);
-        return llvmModuleSet()->getValueNode(svfVal);
+        return llvmModuleSet()->getValueNode(V);
     }
 
     /// GetObject - Return the object node (stack/global/heap/function) according to a LLVM Value
     inline NodeID getObjectNode(const Value* V)
     {
-        SVFLLVMValue* svfVal = llvmModuleSet()->getSVFValue(V);
-        return llvmModuleSet()->getObjectNode(svfVal);
+        return llvmModuleSet()->getObjectNode(V);
     }
 
     /// getReturnNode - Return the node representing the unique return value of a function.
@@ -209,7 +212,7 @@ public:
 protected:
     /// Handle globals including (global variable and functions)
     //@{
-    void visitGlobal(SVFModule* svfModule);
+    void visitGlobal();
     void InitialGlobal(const GlobalVariable *gvar, Constant *C,
                        u32_t offset);
     NodeID getGlobalVarField(const GlobalVariable *gvar, u32_t offset, SVFType* tpy);
@@ -237,21 +240,21 @@ protected:
     //@{
     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);
+    virtual void handleExtCall(const CallBase* cs, const Function* callee);
     //@}
 
     /// Set current basic block in order to keep track of control flow information
     inline void setCurrentLocation(const Value* val, const BasicBlock* bb)
     {
         curBB = (bb == nullptr? nullptr : llvmModuleSet()->getSVFBasicBlock(bb));
-        curVal = (val == nullptr ? nullptr: llvmModuleSet()->getSVFValue(val));
+        curVal = (val == nullptr ? nullptr: val);
     }
-    inline void setCurrentLocation(const SVFLLVMValue* val, const SVFBasicBlock* bb)
+    inline void setCurrentLocation(const Value* val, const SVFBasicBlock* bb)
     {
         curBB = bb;
         curVal = val;
     }
-    inline const SVFLLVMValue* getCurrentValue() const
+    inline const Value* getCurrentValue() const
     {
         return curVal;
     }
@@ -263,9 +266,9 @@ protected:
     /// Add global black hole Address edge
     void addGlobalBlackHoleAddrEdge(NodeID node, const ConstantExpr *int2Ptrce)
     {
-        const SVFLLVMValue* cval = getCurrentValue();
+        const Value* cval = getCurrentValue();
         const SVFBasicBlock* cbb = getCurrentBB();
-        setCurrentLocation(int2Ptrce,nullptr);
+        setCurrentLocation(int2Ptrce,(SVFBasicBlock*) nullptr);
         addBlackHoleAddrEdge(node);
         setCurrentLocation(cval,cbb);
     }
@@ -277,7 +280,7 @@ protected:
         ConstantPointerNull* constNull = ConstantPointerNull::get(PointerType::getUnqual(cxt));
         NodeID nullPtr = pag->addConstantNullPtrValNode(pag->getNullPtr(), nullptr, llvmModuleSet()->getSVFType(constNull->getType()));
         llvmModuleSet()->addToSVFVar2LLVMValueMap(constNull, pag->getGNode(pag->getNullPtr()));
-        setCurrentLocation(constNull, nullptr);
+        setCurrentLocation(constNull, (SVFBasicBlock*) nullptr);
         addBlackHoleAddrEdge(pag->getBlkPtr());
         return nullPtr;
     }
@@ -454,7 +457,7 @@ protected:
     inline void addStoreEdge(NodeID src, NodeID dst)
     {
         ICFGNode* node;
-        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(llvmModuleSet()->getLLVMValue(curVal)))
+        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
             node = llvmModuleSet()->getICFGNode(
                        SVFUtil::cast<Instruction>(inst));
         else

package/SVF-linux-x86_64/Release-build/include/SVF-LLVM/SymbolTableBuilder.h

@@ -54,7 +54,7 @@ public:
     }
 
     /// Start building memory model
-    void buildMemModel(SVFModule* svfModule);
+    void buildMemModel();
 
     /// Return size of this object based on LLVM value
     u32_t getNumOfElements(const Type* ety);

package/SVF-linux-x86_64/Release-build/include/SVFIR/SVFVariables.h

@@ -955,6 +955,7 @@ class FunObjVar : public BaseObjVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
     friend class SVFIRBuilder;
+    friend class LLVMModuleSet;
 
 public:
     typedef SVFLoopAndDomInfo::BBSet BBSet;
@@ -976,7 +977,7 @@ private:
     const FunObjVar * realDefFun;  /// the definition of a function across multiple modules
     BasicBlockGraph* bbGraph; /// the basic block graph of this function
     std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
-    SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
+    const SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
 
 
 private:
@@ -1015,9 +1016,16 @@ public:
     /// Constructor
     FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node);
 
+
+    virtual ~FunObjVar()
+    {
+        delete loopAndDom;
+        delete bbGraph;
+    }
+
     void initFunObjVar(bool decl, bool intrinc, bool addr, bool uncalled, bool notret, bool vararg, const SVFFunctionType *ft,
                        SVFLoopAndDomInfo *ld, const FunObjVar *real, BasicBlockGraph *bbg,
-                       const std::vector<const ArgValVar *> &allarg, SVFBasicBlock *exit);
+                       const std::vector<const ArgValVar *> &allarg, const SVFBasicBlock *exit);
 
     void setRelDefFun(const FunObjVar *real)
     {
@@ -1072,7 +1080,7 @@ public:
         return funcType->getReturnType();
     }
 
-    inline SVFLoopAndDomInfo* getLoopAndDomInfo()
+    inline SVFLoopAndDomInfo* getLoopAndDomInfo() const
     {
         return loopAndDom;
     }

package/SVF-linux-x86_64/Release-build/include/Util/CallGraphBuilder.h

@@ -37,7 +37,6 @@ namespace SVF
 {
 
 class ICFG;
-class SVFModule;
 class CallGraph;
 class ThreadCallGraph;
 

package/SVF-linux-x86_64/Release-build/include/Util/ThreadAPI.h

@@ -35,7 +35,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class ICFGNode;
 class CallICFGNode;
 class SVFVar;

package/SVF-linux-x86_64/Release-build/include/WPA/Andersen.h

@@ -45,7 +45,6 @@
 namespace SVF
 {
 
-class SVFModule;
 
 class ThreadCallGraph;
 

package/SVF-linux-x86_64/Release-build/include/WPA/FlowSensitive.h

@@ -40,7 +40,6 @@ namespace SVF
 {
 
 class AndersenWaveDiff;
-class SVFModule;
 
 /*!
  * Flow sensitive whole program pointer analysis

package/SVF-linux-x86_64/Release-build/include/WPA/VersionedFlowSensitive.h

@@ -24,7 +24,6 @@ namespace SVF
 {
 
 class AndersenWaveDiff;
-class SVFModule;
 
 /*!
  * Versioned flow sensitive whole program pointer analysis

package/SVF-linux-x86_64/Release-build/include/WPA/WPAPass.h

@@ -42,7 +42,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class SVFG;
 
 /*!

package/package.json

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

package/SVF-linux-aarch64/Release-build/include/SVF-LLVM/SVFLLVMValue.h

@@ -1,387 +0,0 @@
-//===- BasicTypes.h -- Basic types used in SVF-------------------------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * BasicTypes.h
- *
- *  Created on: Apr 1, 2014
- *      Author: Yulei Sui
- */
-
-#ifndef INCLUDE_SVFLLVM_SVFVALUE_H_
-#define INCLUDE_SVFLLVM_SVFVALUE_H_
-
-#include "SVFIR/SVFType.h"
-#include "Graphs/GraphPrinter.h"
-#include "Util/Casting.h"
-#include "Graphs/BasicBlockG.h"
-#include "SVFIR/SVFValue.h"
-#include "Util/SVFLoopAndDomInfo.h"
-
-namespace SVF
-{
-
-/// LLVM Aliases and constants
-typedef SVF::GraphPrinter GraphPrinter;
-
-class CallGraphNode;
-class SVFInstruction;
-class SVFBasicBlock;
-class SVFArgument;
-class SVFFunction;
-class SVFType;
-
-class SVFLLVMValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-
-public:
-    typedef s64_t GNodeK;
-
-    enum SVFValKind
-    {
-        SVFVal,
-        SVFFunc,
-    };
-
-private:
-    GNodeK kind;	///< used for classof
-    bool ptrInUncalledFun;  ///< true if this pointer is in an uncalled function
-    bool constDataOrAggData;    ///< true if this value is a ConstantData (e.g., numbers, string, floats) or a constantAggregate
-
-protected:
-    const SVFType* type;   ///< Type of this SVFValue
-    std::string name;       ///< Short name of value for printing & debugging
-    std::string sourceLoc;  ///< Source code information of this value
-    /// Constructor without name
-    SVFLLVMValue(const SVFType* ty, SVFValKind k = SVFVal)
-        : kind(k), ptrInUncalledFun(false),
-          constDataOrAggData(false), type(ty), sourceLoc("NoLoc")
-    {
-    }
-
-    ///@{ attributes to be set only through Module builders e.g.,
-    /// LLVMModule
-    inline void setConstDataOrAggData()
-    {
-        constDataOrAggData = true;
-    }
-    inline void setPtrInUncalledFunction()
-    {
-        ptrInUncalledFun = true;
-    }
-    ///@}
-public:
-    SVFLLVMValue() = delete;
-    virtual ~SVFLLVMValue() = default;
-
-    /// Get the type of this SVFValue
-    inline GNodeK getKind() const
-    {
-        return kind;
-    }
-
-    inline const std::string &getName() const
-    {
-        return name;
-    }
-
-    inline void setName(std::string&& n)
-    {
-        name = std::move(n);
-    }
-
-    inline virtual const SVFType* getType() const
-    {
-        return type;
-    }
-    inline bool isConstDataOrAggData() const
-    {
-        return constDataOrAggData;
-    }
-    inline bool ptrInUncalledFunction() const
-    {
-        return ptrInUncalledFun;
-    }
-    inline virtual void setSourceLoc(const std::string& sourceCodeInfo)
-    {
-        sourceLoc = sourceCodeInfo;
-    }
-    inline virtual const std::string getSourceLoc() const
-    {
-        return sourceLoc;
-    }
-
-    /// Needs to be implemented by a SVF front end
-    std::string toString() const;
-
-    /// Overloading operator << for dumping ICFG node ID
-    //@{
-    friend OutStream& operator<<(OutStream &os, const SVFLLVMValue &value)
-    {
-        return os << value.toString();
-    }
-    //@}
-};
-
-class ArgValVar;
-
-class SVFFunction : public SVFLLVMValue
-{
-    friend class LLVMModuleSet;
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class SVFIRBuilder;
-
-public:
-    typename BasicBlockGraph::IDToNodeMapTy::iterator iterator;
-    typedef BasicBlockGraph::IDToNodeMapTy::const_iterator const_iterator;
-    typedef SVFLoopAndDomInfo::BBSet BBSet;
-    typedef SVFLoopAndDomInfo::BBList BBList;
-    typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
-
-private:
-    bool isDecl;   /// return true if this function does not have a body
-    bool intrinsic; /// return true if this function is an intrinsic function (e.g., llvm.dbg), which does not reside in the application code
-    bool addrTaken; /// return true if this function is address-taken (for indirect call purposes)
-    bool isUncalled;    /// return true if this function is never called
-    bool isNotRet;   /// return true if this function never returns
-    bool varArg;    /// return true if this function supports variable arguments
-    const SVFFunctionType* funcType; /// FunctionType, which is different from the type (PointerType) of this SVFFunction
-    SVFLoopAndDomInfo* loopAndDom;  /// the loop and dominate information
-    const SVFFunction* realDefFun;  /// the definition of a function across multiple modules
-    std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
-    SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
-    BasicBlockGraph* bbGraph; /// the basic block graph of this function
-
-protected:
-
-    inline void addArgument(const ArgValVar* arg)
-    {
-        allArgs.push_back(arg);
-    }
-
-    inline void setIsUncalledFunction(bool uncalledFunction)
-    {
-        isUncalled = uncalledFunction;
-    }
-
-    inline void setIsNotRet(bool notRet)
-    {
-        isNotRet = notRet;
-    }
-
-    inline void setDefFunForMultipleModule(const SVFFunction* deffun)
-    {
-        realDefFun = deffun;
-    }
-    /// @}
-
-public:
-    SVFFunction(const SVFType* ty,const SVFFunctionType* ft, bool declare, bool intrinsic, bool addrTaken, bool varg, SVFLoopAndDomInfo* ld);
-    SVFFunction(void) = delete;
-    virtual ~SVFFunction();
-
-    static inline bool classof(const SVFLLVMValue *node)
-    {
-        return node->getKind() == SVFFunc;
-    }
-
-    inline SVFLoopAndDomInfo* getLoopAndDomInfo()
-    {
-        return loopAndDom;
-    }
-    inline bool isDeclaration() const
-    {
-        return isDecl;
-    }
-
-    void setBasicBlockGraph(BasicBlockGraph* graph)
-    {
-        this->bbGraph = graph;
-    }
-
-    BasicBlockGraph* getBasicBlockGraph()
-    {
-        return bbGraph;
-    }
-
-    const BasicBlockGraph* getBasicBlockGraph() const
-    {
-        return bbGraph;
-    }
-
-    inline bool isIntrinsic() const
-    {
-        return intrinsic;
-    }
-
-    inline bool hasAddressTaken() const
-    {
-        return addrTaken;
-    }
-
-    /// Returns the FunctionType
-    inline const SVFFunctionType* getFunctionType() const
-    {
-        return funcType;
-    }
-
-    /// Returns the FunctionType
-    inline const SVFType* getReturnType() const
-    {
-        return funcType->getReturnType();
-    }
-
-    inline const SVFFunction* getDefFunForMultipleModule() const
-    {
-        if(realDefFun==nullptr)
-            return this;
-        return realDefFun;
-    }
-
-    u32_t arg_size() const;
-    const ArgValVar* getArg(u32_t idx) const;
-    bool isVarArg() const;
-
-    inline bool hasBasicBlock() const
-    {
-        return bbGraph && bbGraph->begin() != bbGraph->end();
-    }
-
-    inline const SVFBasicBlock* getEntryBlock() const
-    {
-        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
-        assert(bbGraph->begin()->second->getInEdges().size() == 0 && "the first basic block is not entry block");
-        return bbGraph->begin()->second;
-    }
-
-    /// Carefully! when you call getExitBB, you need ensure the function has return instruction
-    /// more refer to: https://github.com/SVF-tools/SVF/pull/1262
-    const SVFBasicBlock* getExitBB() const;
-
-    void setExitBlock(SVFBasicBlock *bb);
-
-    inline const SVFBasicBlock* front() const
-    {
-        return getEntryBlock();
-    }
-
-    inline const SVFBasicBlock* back() const
-    {
-        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
-        /// Carefully! 'back' is just the last basic block of function,
-        /// but not necessarily a exit basic block
-        /// more refer to: https://github.com/SVF-tools/SVF/pull/1262
-        return std::prev(bbGraph->end())->second;
-    }
-
-    inline const_iterator begin() const
-    {
-        return bbGraph->begin();
-    }
-
-    inline const_iterator end() const
-    {
-        return bbGraph->end();
-    }
-
-
-    inline const std::vector<const SVFBasicBlock*>& getReachableBBs() const
-    {
-        return loopAndDom->getReachableBBs();
-    }
-
-    inline bool isUncalledFunction() const
-    {
-        return isUncalled;
-    }
-
-    inline bool hasReturn() const
-    {
-        return  !isNotRet;
-    }
-
-    inline void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const
-    {
-        return loopAndDom->getExitBlocksOfLoop(bb,exitbbs);
-    }
-
-    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->hasLoopInfo(bb);
-    }
-
-    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->getLoopInfo(bb);
-    }
-
-    inline const SVFBasicBlock* getLoopHeader(const BBList& lp) const
-    {
-        return loopAndDom->getLoopHeader(lp);
-    }
-
-    inline bool loopContainsBB(const BBList& lp, const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->loopContainsBB(lp,bb);
-    }
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
-    {
-        return loopAndDom->getDomTreeMap();
-    }
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
-    {
-        return loopAndDom->getDomFrontierMap();
-    }
-
-    inline bool isLoopHeader(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->isLoopHeader(bb);
-    }
-
-    inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
-    {
-        return loopAndDom->dominate(bbKey,bbValue);
-    }
-
-    inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
-    {
-        return loopAndDom->postDominate(bbKey,bbValue);
-    }
-};
-
-/// [FOR DEBUG ONLY, DON'T USE IT UNSIDE `svf`!]
-/// Converts an SVFValue to corresponding LLVM::Value, then get the string
-/// representation of it. Use it only when you are debugging. Don't use
-/// it in any SVF algorithm because it relies on information stored in LLVM bc.
-std::string dumpLLVMValue(const SVFLLVMValue* svfValue);
-
-
-
-} // End namespace SVF
-
-#endif /* INCLUDE_SVFLLVM_SVFVALUE_H_ */