svf-lib 1.0.732 → 1.0.736

package/SVF-linux/include/SVF-FE/SVFIRBuilder.h

@@ -0,0 +1,398 @@
+//===- SVFIRBuilder.h -- Building SVFIR-------------------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFIRBuilder.h
+ *
+ *  Created on: Nov 1, 2013
+ *      Author: Yulei Sui
+ */
+
+#ifndef PAGBUILDER_H_
+#define PAGBUILDER_H_
+
+#include "MemoryModel/SVFIR.h"
+#include "Util/ExtAPI.h"
+#include "SVF-FE/ICFGBuilder.h"
+
+namespace SVF
+{
+
+class SVFModule;
+/*!
+ *  SVFIR Builder to create SVF variables and statements and PAG
+ */
+class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
+{
+
+private:
+    SVFIR* pag;
+    SVFModule* svfMod;
+    const BasicBlock* curBB;	///< Current basic block during SVFIR construction when visiting the module
+    const Value* curVal;	///< Current Value during SVFIR construction when visiting the module
+
+public:
+    /// Constructor
+    SVFIRBuilder(): pag(SVFIR::getPAG()), svfMod(nullptr), curBB(nullptr),curVal(nullptr)
+    {
+    }
+    /// Destructor
+    virtual ~SVFIRBuilder()
+    {
+    }
+
+    /// Start building SVFIR here
+    virtual SVFIR* build(SVFModule* svfModule);
+
+    /// Return SVFIR
+    SVFIR* getPAG() const
+    {
+        return pag;
+    }
+
+    /// Initialize nodes and edges
+    //@{
+    void initialiseNodes();
+    void addEdge(NodeID src, NodeID dst, PAGEdge::PEDGEK kind,
+                 Size_t offset = 0, Instruction* cs = nullptr);
+    // @}
+
+    /// Sanity check for SVFIR
+    void sanityCheck();
+
+    /// Get different kinds of node
+    //@{
+    // GetValNode - Return the value node according to a LLVM Value.
+    NodeID getValueNode(const Value *V)
+    {
+        // first handle gep edge if val if a constant expression
+        processCE(V);
+
+        // strip off the constant cast and return the value node
+        return pag->getValueNode(V);
+    }
+
+    /// GetObject - Return the object node (stack/global/heap/function) according to a LLVM Value
+    inline NodeID getObjectNode(const Value *V)
+    {
+        return pag->getObjectNode(V);
+    }
+
+    /// getReturnNode - Return the node representing the unique return value of a function.
+    inline NodeID getReturnNode(const SVFFunction *func)
+    {
+        return pag->getReturnNode(func);
+    }
+
+    /// getVarargNode - Return the node representing the unique variadic argument of a function.
+    inline NodeID getVarargNode(const SVFFunction *func)
+    {
+        return pag->getVarargNode(func);
+    }
+    //@}
+
+    /// Handle globals including (global variable and functions)
+    //@{
+    void visitGlobal(SVFModule* svfModule);
+    void InitialGlobal(const GlobalVariable *gvar, Constant *C,
+                       u32_t offset);
+    NodeID getGlobalVarField(const GlobalVariable *gvar, u32_t offset);
+    //@}
+
+    /// Process constant expression
+    void processCE(const Value *val);
+
+    /// Compute offset of a gep instruction or gep constant expression
+    bool computeGepOffset(const User *V, LocationSet& ls);
+
+    /// Handle direct call
+    void handleDirectCall(CallSite cs, const SVFFunction *F);
+
+    /// Handle indirect call
+    void handleIndCall(CallSite cs);
+
+    /// Handle external call
+    //@{
+    virtual void handleExtCall(CallSite cs, const SVFFunction *F);
+    const Type *getBaseTypeAndFlattenedFields(Value* v, std::vector<LocationSet> &fields);
+    void addComplexConsForExt(Value *D, Value *S,u32_t sz = 0);
+    //@}
+
+    /// Our visit overrides.
+    //@{
+    // Instructions that cannot be folded away.
+    virtual void visitAllocaInst(AllocaInst &AI);
+    void visitPHINode(PHINode &I);
+    void visitStoreInst(StoreInst &I);
+    void visitLoadInst(LoadInst &I);
+    void visitGetElementPtrInst(GetElementPtrInst &I);
+    void visitCallInst(CallInst &I)
+    {
+        visitCallSite(&I);
+    }
+    void visitInvokeInst(InvokeInst &II)
+    {
+        visitCallSite(&II);
+    }
+    void visitCallBrInst(CallBrInst &I) {
+      return visitCallSite(&I);
+    }
+    void visitCallSite(CallSite cs);
+    void visitReturnInst(ReturnInst &I);
+    void visitCastInst(CastInst &I);
+    void visitSelectInst(SelectInst &I);
+    void visitExtractValueInst(ExtractValueInst  &EVI);
+    void visitBranchInst(BranchInst &I);
+    void visitSwitchInst(SwitchInst &I);
+    void visitInsertValueInst(InsertValueInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+    // TerminatorInst and UnwindInst have been removed since llvm-8.0.0
+    // void visitTerminatorInst(TerminatorInst &TI) {}
+    // void visitUnwindInst(UnwindInst &I) { /*returns void*/}
+
+    void visitBinaryOperator(BinaryOperator &I);
+    void visitUnaryOperator(UnaryOperator &I);
+    void visitCmpInst(CmpInst &I);
+
+    /// TODO: var arguments need to be handled.
+    /// https://llvm.org/docs/LangRef.html#id1911
+    void visitVAArgInst(VAArgInst&);
+    void visitVACopyInst(VACopyInst&){}
+    void visitVAEndInst(VAEndInst&){}
+    void visitVAStartInst(VAStartInst&){}
+
+    /// <result> = freeze ty <val>
+    /// If <val> is undef or poison, ‘freeze’ returns an arbitrary, but fixed value of type `ty`
+    /// Otherwise, this instruction is a no-op and returns the input <val>
+    void visitFreezeInst(FreezeInst& I);
+
+    void visitExtractElementInst(ExtractElementInst &I);
+
+    void visitInsertElementInst(InsertElementInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+    void visitShuffleVectorInst(ShuffleVectorInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+    void visitLandingPadInst(LandingPadInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+
+    /// Instruction not that often
+    void visitResumeInst(ResumeInst&)   /*returns void*/
+    {
+    }
+    void visitUnreachableInst(UnreachableInst&)   /*returns void*/
+    {
+    }
+    void visitFenceInst(FenceInst &I)   /*returns void*/
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+    void visitAtomicCmpXchgInst(AtomicCmpXchgInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+    void visitAtomicRMWInst(AtomicRMWInst &I)
+    {
+        addBlackHoleAddrEdge(getValueNode(&I));
+    }
+
+    /// Provide base case for our instruction visit.
+    inline void visitInstruction(Instruction&)
+    {
+        // If a new instruction is added to LLVM that we don't handle.
+        // TODO: ignore here:
+    }
+    //}@
+
+    /// Set current basic block in order to keep track of control flow information
+    inline void setCurrentLocation(const Value* val, const BasicBlock* bb)
+    {
+        curBB = bb;
+        curVal = val;
+    }
+    inline const Value *getCurrentValue() const
+    {
+        return curVal;
+    }
+    inline const BasicBlock *getCurrentBB() const
+    {
+        return curBB;
+    }
+
+    /// Add global black hole Address edge
+    void addGlobalBlackHoleAddrEdge(NodeID node, const ConstantExpr *int2Ptrce)
+    {
+        const Value* cval = getCurrentValue();
+        const BasicBlock* cbb = getCurrentBB();
+        setCurrentLocation(int2Ptrce,nullptr);
+        addBlackHoleAddrEdge(node);
+        setCurrentLocation(cval,cbb);
+    }
+
+    /// Add NullPtr PAGNode
+    inline NodeID addNullPtrNode()
+    {
+        NodeID nullPtr = pag->addDummyValNode(pag->getNullPtr());
+        /// let all undef value or non-determined pointers points-to black hole
+        LLVMContext &cxt = LLVMModuleSet::getLLVMModuleSet()->getContext();
+        ConstantPointerNull *constNull = ConstantPointerNull::get(Type::getInt8PtrTy(cxt));
+        setCurrentLocation(constNull, nullptr);
+        addBlackHoleAddrEdge(pag->getBlkPtr());
+        return nullPtr;
+    }
+
+    NodeID getGepValNode(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
+
+    void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
+
+    inline PAGEdge* addBlackHoleAddrEdge(NodeID node)
+    {
+        PAGEdge *edge = pag->addBlackHoleAddrPE(node);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+
+    /// Add Address edge
+    inline AddrPE* addAddrEdge(NodeID src, NodeID dst)
+    {
+        AddrPE *edge = pag->addAddrPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline CopyPE* addCopyEdge(NodeID src, NodeID dst)
+    {
+        CopyPE *edge = pag->addCopyPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline PhiPE* addPhiNode(NodeID res, NodeID opnd)
+    {
+        const CopyPE* copy = addCopyEdge(opnd, res);
+        PhiPE *edge = pag->addPhiNode(res,opnd);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline CmpPE* addCmpEdge(NodeID op1, NodeID op2, NodeID dst)
+    {
+        CmpPE *edge = pag->addCmpPE(op1, op2, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline BinaryOPPE* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst)
+    {
+        BinaryOPPE *edge = pag->addBinaryOPPE(op1, op2, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Unary edge
+    inline UnaryOPPE* addUnaryOPEdge(NodeID src, NodeID dst)
+    {
+        UnaryOPPE *edge = pag->addUnaryOPPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Load edge
+    inline LoadPE* addLoadEdge(NodeID src, NodeID dst)
+    {
+        LoadPE *edge = pag->addLoadPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Store edge
+    inline StorePE* addStoreEdge(NodeID src, NodeID dst)
+    {
+        IntraBlockNode* node;
+        if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
+            node = pag->getICFG()->getIntraBlockNode(inst);
+        else
+            node = nullptr;
+        StorePE *edge = pag->addStorePE(src, dst, node);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Call edge
+    inline CallPE* addCallEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    {
+        CallPE *edge = pag->addCallPE(src, dst, cs);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Return edge
+    inline RetPE* addRetEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    {
+        RetPE *edge = pag->addRetPE(src, dst, cs);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Gep edge
+    inline GepPE* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+    {
+        GepPE *edge = pag->addGepPE(src, dst, ls, constGep);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Offset(Gep) edge
+    inline NormalGepPE* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    {
+        NormalGepPE *edge = pag->addNormalGepPE(src, dst, ls);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Variant(Gep) edge
+    inline VariantGepPE* addVariantGepEdge(NodeID src, NodeID dst)
+    {
+        VariantGepPE *edge = pag->addVariantGepPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Thread fork edge for parameter passing
+    inline TDForkPE* addThreadForkEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    {
+        TDForkPE *edge = pag->addThreadForkPE(src, dst, cs);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Thread join edge for parameter passing
+    inline TDJoinPE* addThreadJoinEdge(NodeID src, NodeID dst, const CallBlockNode* cs)
+    {
+        TDJoinPE *edge = pag->addThreadJoinPE(src, dst, cs);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    //@}
+
+};
+
+} // End namespace SVF
+
+#endif /* PAGBUILDER_H_ */

package/SVF-linux/include/SVF-FE/SymbolTableBuilder.h

@@ -30,7 +30,6 @@
 #ifndef SymbolTableBuilder_H_
 #define SymbolTableBuilder_H_
 
-#include "MemoryModel/SVFSymbols.h"
 #include "SVF-FE/LLVMModule.h"
 #include "MemoryModel/SymbolTableInfo.h"
 

package/SVF-linux/include/Util/CFLSolver.h

@@ -37,7 +37,7 @@ namespace SVF
 {
 
 /*
- * Generic CFL solver for demand-driven analysis based on different graphs (e.g. PAG, VFG, ThreadVFG)
+ * Generic CFL solver for demand-driven analysis based on different graphs (e.g. SVFIR, VFG, ThreadVFG)
  * Extend this class for sophisticated CFL-reachability resolution (e.g. field, flow, path)
  */
 template<class GraphType, class DPIm = DPItem>

package/SVF-linux/include/Util/ExtAPI.h

@@ -105,7 +105,7 @@ private:
         isext_cache.clear();
     }
 
-    // Singleton pattern here to enable instance of PAG can only be created once.
+    // Singleton pattern here to enable instance of SVFIR can only be created once.
     static ExtAPI* extAPI;
 
 public:

package/SVF-linux/include/Util/IRAnnotator.h

@@ -8,7 +8,7 @@
 #ifndef IRANNOTATOR_H_
 #define IRANNOTATOR_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/SVFUtil.h"
 #include "llvm/IR/Metadata.h"
@@ -28,7 +28,7 @@ public:
     {}
     ~IRAnnotator() {}
 
-    void processAndersenResults(PAG *pag, BVDataPTAImpl *ptsTo, bool writeFlag)
+    void processAndersenResults(SVFIR *pag, BVDataPTAImpl *ptsTo, bool writeFlag)
     {
         this->ptsTo = ptsTo;
         mainModule = LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule();
@@ -36,7 +36,7 @@ public:
         // Add a named metadata node used to check whether or not 
         // this IR has been annotated with Andersen information
         if (writeFlag)
-            mainModule->getOrInsertNamedMetadata("PAG-Annotated");
+            mainModule->getOrInsertNamedMetadata("SVFIR-Annotated");
 
         for (auto it = pag->begin(); it != pag->end(); ++it)
         {
@@ -59,7 +59,7 @@ public:
     }
 
 private:
-    // Write the PAGgepNode to the IR such that metadata name is the PAG node id and the operands
+    // Write the PAGgepNode to the IR such that metadata name is the SVFIR node id and the operands
     // are its base node's id and location offset
     void writePAGgepNode(SVF::NodeID nodeId, GepObjPN* gepNode)
     {
@@ -77,9 +77,9 @@ private:
         mainModule->getOrInsertNamedMetadata(label)->addOperand(metadata);
     }
 
-    // Reads the PAGGepNodes in the annotated IR and creates a new PAG Node based on the
+    // Reads the PAGGepNodes in the annotated IR and creates a new SVFIR Node based on the
     // data contained in the operands of the metadata node
-    void readPAGgepNodes(PAG *pag)
+    void readPAGgepNodes(SVFIR *pag)
     {
         for (auto it = mainModule->named_metadata_begin(); it != mainModule->named_metadata_end(); ++it)
         {

package/SVF-linux/include/Util/Options.h

@@ -108,7 +108,7 @@ public:
     // Offline constraint graph (OfflineConsG.cpp)
     static const llvm::cl::opt<bool> OCGDotGraph;
 
-    // Program Assignment Graph for pointer analysis (PAG.cpp)
+    // Program Assignment Graph for pointer analysis (SVFIR.cpp)
     static llvm::cl::opt<bool> HandBlackHole;
     static const llvm::cl::opt<bool> FirstFieldEqBase;
 

package/SVF-linux/include/Util/TypeBasedHeapCloning.h

@@ -11,7 +11,7 @@
  */
 
 #include "SVF-FE/DCHG.h"
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/BasicTypes.h"
 
@@ -48,8 +48,8 @@ protected:
 
     /// DCHG *must* be set by extending class once the DCHG is available.
     void setDCHG(DCHGraph *dchg);
-    /// PAG *must* be set by extending class once the PAG is available.
-    void setPAG(PAG *pag);
+    /// SVFIR *must* be set by extending class once the SVFIR is available.
+    void setPAG(SVFIR *pag);
 
     /// Check if an object is a black hole obj or a constant object. Required since
     /// other implementations obviously do not account for clones.
@@ -97,7 +97,7 @@ protected:
     const NodeBS &getGepObjs(NodeID base);
 
     /// Returns the GEP object node(s) of base for ls. This may include clones.
-    /// If there are no GEP objects, then getGepObjNode is called on the PAG
+    /// If there are no GEP objects, then getGepObjNode is called on the SVFIR
     /// (through base's getGepObjNode) which will create one.
     const NodeBS getGepObjClones(NodeID base, unsigned offset);
 
@@ -109,11 +109,11 @@ protected:
     /// as a result of reuse.
     NodeID cloneObject(NodeID o, const DIType *type, bool reuse);
 
-    /// Add clone dummy object node to PAG.
+    /// Add clone dummy object node to SVFIR.
     inline NodeID addCloneDummyObjNode(const MemObj *mem);
-    /// Add clone GEP object node to PAG.
+    /// Add clone GEP object node to SVFIR.
     inline NodeID addCloneGepObjNode(const MemObj *mem, const LocationSet &l);
-    /// Add clone FI object node to PAG.
+    /// Add clone FI object node to SVFIR.
     inline NodeID addCloneFIObjNode(const MemObj *mem);
 
     /// Returns the ctir type attached to the value, nullptr if non-existant.
@@ -145,20 +145,20 @@ protected:
 private:
     /// PTA extending this class.
     BVDataPTAImpl *pta;
-    /// PAG the PTA uses. Just a shortcut for getPAG().
-    PAG *ppag = nullptr;
+    /// SVFIR the PTA uses. Just a shortcut for getPAG().
+    SVFIR *ppag = nullptr;
 
     /// Object -> its type.
     Map<NodeID, const DIType *> objToType;
     /// Object -> allocation site.
     /// The value NodeID depends on the pointer analysis (could be
-    /// an SVFG node or PAG node for example).
+    /// an SVFG node or SVFIR node for example).
     Map<NodeID, NodeID> objToAllocation;
     /// (Original) object -> set of its clones.
     Map<NodeID, NodeBS> objToClones;
     /// (Clone) object -> original object (opposite of objToclones).
     Map<NodeID, NodeID> cloneToOriginalObj;
-    /// Maps nodes (a location like a PAG node or SVFG node) to their filter set.
+    /// Maps nodes (a location like a SVFIR node or SVFG node) to their filter set.
     Map<NodeID, PointsTo> locToFilterSet;
     /// Maps objects to the GEP nodes beneath them.
     Map<NodeID, NodeBS> objToGeps;

package/SVF-linux/include/WPA/Andersen.h

@@ -33,7 +33,7 @@
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "WPA/WPAStat.h"
 #include "WPA/WPASolver.h"
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/ConsG.h"
 #include "Graphs/OfflineConsG.h"
 
@@ -52,7 +52,7 @@ class AndersenBase:  public WPAConstraintSolver, public BVDataPTAImpl
 public:
 
     /// Constructor
-    AndersenBase(PAG* _pag, PTATY type = Andersen_BASE, bool alias_check = true)
+    AndersenBase(SVFIR* _pag, PTATY type = Andersen_BASE, bool alias_check = true)
         :  BVDataPTAImpl(_pag, type, alias_check), consCG(nullptr)
     {
         iterationForPrintStat = OnTheFlyIterBudgetForStat;
@@ -155,7 +155,7 @@ public:
     typedef OrderedMap<CallSite, NodeID> CallSite2DummyValPN;
 
     /// Constructor
-    Andersen(PAG* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
+    Andersen(SVFIR* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
         :  AndersenBase(_pag, type, alias_check), pwcOpt(false), diffOpt(true)
     {
     }
@@ -424,10 +424,10 @@ private:
     static AndersenWaveDiff* diffWave; // static instance
 
 public:
-    AndersenWaveDiff(PAG* _pag, PTATY type = AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
+    AndersenWaveDiff(SVFIR* _pag, PTATY type = AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenWaveDiff* createAndersenWaveDiff(PAG* _pag)
+    static AndersenWaveDiff* createAndersenWaveDiff(SVFIR* _pag)
     {
         if(diffWave==nullptr)
         {
@@ -475,13 +475,13 @@ private:
     NodeSet lcdCandidates;
 
 public:
-    AndersenLCD(PAG* _pag, PTATY type = AndersenLCD_WPA) :
+    AndersenLCD(SVFIR* _pag, PTATY type = AndersenLCD_WPA) :
         Andersen(_pag, type), metEdges({}), lcdCandidates( {})
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenLCD* createAndersenLCD(PAG* _pag)
+    static AndersenLCD* createAndersenLCD(SVFIR* _pag)
     {
         if (lcdAndersen == nullptr)
         {
@@ -557,13 +557,13 @@ private:
     OfflineConsG* oCG;
 
 public:
-    AndersenHCD(PAG* _pag, PTATY type = AndersenHCD_WPA) :
+    AndersenHCD(SVFIR* _pag, PTATY type = AndersenHCD_WPA) :
         Andersen(_pag, type), oCG(nullptr)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenHCD *createAndersenHCD(PAG* _pag)
+    static AndersenHCD *createAndersenHCD(SVFIR* _pag)
     {
         if (hcdAndersen == nullptr)
         {
@@ -628,13 +628,13 @@ private:
     static AndersenHLCD* hlcdAndersen;
 
 public:
-    AndersenHLCD(PAG* _pag, PTATY type = AndersenHLCD_WPA) :
+    AndersenHLCD(SVFIR* _pag, PTATY type = AndersenHLCD_WPA) :
         Andersen(_pag, type), AndersenHCD(_pag, type), AndersenLCD(_pag, type)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenHLCD *createAndersenHLCD(PAG* _pag)
+    static AndersenHLCD *createAndersenHLCD(SVFIR* _pag)
     {
         if (hlcdAndersen == nullptr)
         {

package/SVF-linux/include/WPA/AndersenSFR.h

@@ -52,13 +52,13 @@ protected:
     NodeToNodeMap pwcReps;
 
 public:
-    AndersenSCD(PAG* _pag, PTATY type = AndersenSCD_WPA) :
+    AndersenSCD(SVFIR* _pag, PTATY type = AndersenSCD_WPA) :
         Andersen(_pag,type)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenSCD *createAndersenSCD(PAG* _pag)
+    static AndersenSCD *createAndersenSCD(SVFIR* _pag)
     {
         if (scdAndersen == nullptr)
         {
@@ -114,13 +114,13 @@ private:
     FieldReps fieldReps;
 
 public:
-    AndersenSFR(PAG* _pag, PTATY type = AndersenSFR_WPA) :
+    AndersenSFR(SVFIR* _pag, PTATY type = AndersenSFR_WPA) :
         AndersenSCD(_pag, type), csc(nullptr)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenSFR *createAndersenSFR(PAG* _pag)
+    static AndersenSFR *createAndersenSFR(SVFIR* _pag)
     {
         if (sfrAndersen == nullptr)
         {

package/SVF-linux/include/WPA/FlowSensitive.h

@@ -58,7 +58,7 @@ public:
     typedef BVDataPTAImpl::MutDFPTDataTy::PtsMap PtsMap;
 
     /// Constructor
-    FlowSensitive(PAG* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
+    FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
     {
         svfg = nullptr;
         solveTime = sccTime = processTime = propagationTime = updateTime = 0;
@@ -81,7 +81,7 @@ public:
     }
 
     /// Create signle instance of flow-sensitive pointer analysis
-    static FlowSensitive* createFSWPA(PAG* _pag)
+    static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)
         {