svf-lib 1.0.729 → 1.0.733

package/SVF-osx/include/SABER/SaberSVFGBuilder.h

@@ -37,8 +37,6 @@
 namespace SVF
 {
 
-class PAGNode;
-
 class SaberSVFGBuilder : public SVFGBuilder
 {
 

package/SVF-osx/include/SABER/SrcSnkDDA.h

@@ -110,10 +110,10 @@ public:
         dumpSlices();
     }
 
-    /// Get PAG
-    PAG* getPAG() const
+    /// Get SVFIR
+    SVFIR* getPAG() const
     {
-        return PAG::getPAG();
+        return SVFIR::getPAG();
     }
 
     /// Get SVFG

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

@@ -1,9 +1,7 @@
 #ifndef INCLUDE_SVF_FE_GRAPH2JSON_H_
 #define INCLUDE_SVF_FE_GRAPH2JSON_H_
 
-#include "Graphs/PAG.h"
-#include "Graphs/PAGEdge.h"
-#include "Graphs/PAGNode.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/ICFG.h"
 #include "Graphs/ICFGNode.h"
 #include "Graphs/ICFGEdge.h"

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

@@ -0,0 +1,392 @@
+//===- 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 CmpPE* addCmpEdge(NodeID src, NodeID dst)
+    {
+        CmpPE *edge = pag->addCmpPE(src, dst);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline BinaryOPPE* addBinaryOPEdge(NodeID src, NodeID dst)
+    {
+        BinaryOPPE *edge = pag->addBinaryOPPE(src, 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;
+    }
+    //@}
+
+};
+
+typedef SVFIRBuilder PAGBuilder;
+
+} // End namespace SVF
+
+#endif /* PAGBUILDER_H_ */

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

@@ -0,0 +1,89 @@
+//===- SymbolTableBuilder.h -- Symbol Table 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SymbolTableBuilder.h
+ *
+ *  Created on: Apr 28, 2014
+ *      Author: Yulei
+ */
+
+#ifndef SymbolTableBuilder_H_
+#define SymbolTableBuilder_H_
+
+#include "SVF-FE/LLVMModule.h"
+#include "MemoryModel/SymbolTableInfo.h"
+
+/*
+* This class is to build SymbolTableInfo, MemObjs and ObjTypeInfo
+*/
+namespace SVF
+{
+
+class SymbolTableBuilder 
+{
+
+private:
+    SymbolTableInfo* symInfo;
+
+public:
+    /// Constructor
+    SymbolTableBuilder(SymbolTableInfo* si): symInfo(si){
+    }
+
+    /// Start building memory model
+    void buildMemModel(SVFModule* svfModule);
+
+    /// collect the syms
+    //@{
+    void collectSym(const Value *val);
+
+    void collectVal(const Value *val);
+
+    void collectObj(const Value *val);
+
+    void collectRet(const Function *val);
+
+    void collectVararg(const Function *val);
+    //@}
+
+    /// Handle constant expression
+    // @{
+    void handleGlobalCE(const GlobalVariable *G);
+    void handleGlobalInitializerCE(const Constant *C, u32_t offset);
+    void handleCE(const Value *val);
+    // @}
+
+    /// Create an objectInfo based on LLVM value
+    ObjTypeInfo* createObjTypeInfo(const Value *val);
+
+    /// Initialize TypeInfo based on LLVM Value
+    void initTypeInfo(ObjTypeInfo* typeinfo, const Value* value);
+    /// Analyse types of all flattened fields of this object
+    void analyzeGlobalStackObjType(ObjTypeInfo* typeinfo, const Value* val);
+    /// Return size of this object based on LLVM value
+    u32_t getObjSize(const Value* val);
+};
+
+}
+
+#endif /* SymbolTableBuilder_H_ */

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

@@ -300,16 +300,6 @@ public:
 
 };
 
-class SVFInstruction : public SVFValue
-{
-
-public:
-    SVFInstruction(const std::string& val): SVFValue(val,SVFValue::SVFInst)
-    {
-    }
-
-};
-
 class CallSite {
 private:
     CallBase *CB;

package/SVF-osx/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-osx/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-osx/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-osx/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-osx/include/Util/SVFUtil.h

@@ -241,6 +241,17 @@ inline const SVFFunction* getFunction(StringRef name)
     return nullptr;
 }
 
+/// 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;
+}
+
 /// Get the definition of a function across multiple modules
 inline const SVFFunction* getDefFunForMultipleModule(const Function* fun)
 {