svf-lib 1.0.973 → 1.0.976

package/SVF-linux/include/SABER/PathCondAllocator.h

@@ -33,7 +33,7 @@
 #include "Util/SVFModule.h"
 #include "SVF-FE/DataFlowUtil.h"
 #include "SVF-FE/BasicTypes.h"
-#include "Util/Conditions.h"
+#include "Util/BDDExpr.h"
 #include "Util/WorkList.h"
 #include "Graphs/SVFG.h"
 
@@ -49,7 +49,7 @@ class PathCondAllocator
 
 public:
 
-    typedef CondExpr Condition;   /// z3 condition
+    typedef BDDExprManager::BDDExpr Condition;   /// z3 condition
 
     typedef Map<u32_t,Condition*> CondPosMap;		///< map a branch to its Condition
     typedef Map<const BasicBlock*, CondPosMap > BBCondMap;	// map bb to a Condition
@@ -133,7 +133,7 @@ public:
     {
         return condMgr->getCondInst(cond);
     }
-    inline void setCondInst(const CondExpr* cond, const Instruction* inst){
+    inline void setCondInst(const Condition* cond, const Instruction* inst){
         condMgr->setCondInst(cond, inst);
     }
     //@}
@@ -286,7 +286,7 @@ private:
     const SVFGNode* curEvalSVFGNode{};			///< current llvm value to evaluate branch condition when computing guards
 
 protected:
-    CondManager* condMgr;		///< z3 manager
+    BDDExprManager* condMgr;		///< z3 manager
     BBCondMap bbConds;						///< map basic block to its successors/predecessors branch conditions
 
 };

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

@@ -30,7 +30,7 @@
 #ifndef SRCSNKANALYSIS_H_
 #define SRCSNKANALYSIS_H_
 
-#include "Util/CFLSolver.h"
+#include "SrcSnkSolver.h"
 #include "Graphs/SVFGOPT.h"
 #include "SABER/ProgSlice.h"
 #include "SABER/SaberSVFGBuilder.h"
@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-typedef CFLSolver<SVFG*,CxtDPItem> CFLSrcSnkSolver;
+typedef SrcSnkSolver<SVFG*,CxtDPItem> CFLSrcSnkSolver;
 
 /*!
  * General source-sink analysis, which serves as a base analysis to be extended for various clients

package/SVF-linux/include/SABER/SrcSnkSolver.h

@@ -0,0 +1,186 @@
+//===- SrcSnkSolver.h -- CFL reachability solver---------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SrcSnkSolver.h
+ *
+ *  Created on: Apr 1, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLSOLVER_H_
+#define CFLSOLVER_H_
+
+#include "Util/WorkList.h"
+#include "Util/DPItem.h"
+
+namespace SVF
+{
+
+/*
+ * 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>
+class SrcSnkSolver
+{
+
+public:
+    ///Define the GTraits and node iterator
+    typedef llvm::GraphTraits<GraphType> GTraits;
+    typedef typename GTraits::NodeType          GNODE;
+    typedef typename GTraits::EdgeType          GEDGE;
+    typedef typename GTraits::nodes_iterator node_iterator;
+    typedef typename GTraits::ChildIteratorType child_iterator;
+
+    /// Define inverse GTraits and note iterator
+    typedef llvm::GraphTraits<llvm::Inverse<GNODE *> > InvGTraits;
+    typedef typename InvGTraits::ChildIteratorType inv_child_iterator;
+
+    /// Define worklist
+    typedef FIFOWorkList<DPIm> WorkList;
+
+protected:
+
+    /// Constructor
+    SrcSnkSolver(): _graph(nullptr)
+    {
+    }
+    /// Destructor
+    virtual ~SrcSnkSolver()
+    {
+    }
+    /// Get/Set graph methods
+    //@{
+    const inline GraphType graph() const
+    {
+        return _graph;
+    }
+    inline void setGraph(GraphType g)
+    {
+        _graph = g;
+    }
+    //@}
+
+    inline GNODE* getNode(NodeID id) const
+    {
+        return _graph->getGNode(id);
+    }
+    virtual inline NodeID getNodeIDFromItem(const DPIm& item) const
+    {
+        return item.getCurNodeID();
+    }
+    /// CFL forward traverse solve
+    virtual void forwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            FWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            child_iterator EI = GTraits::child_begin(v);
+            child_iterator EE = GTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                FWProcessOutgoingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// CFL forward traverse solve
+    virtual void backwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            BWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            inv_child_iterator EI = InvGTraits::child_begin(v);
+            inv_child_iterator EE = InvGTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                BWProcessIncomingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// Process the DP item
+    //@{
+    virtual void FWProcessCurNode(const DPIm&)
+    {
+    }
+    virtual void BWProcessCurNode(const DPIm&)
+    {
+    }
+    //@}
+    /// Propagation for the solving, to be implemented in the child class
+    //@{
+    virtual void FWProcessOutgoingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getDstID());
+        pushIntoWorklist(newItem);
+    }
+    virtual void BWProcessIncomingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getSrcID());
+        pushIntoWorklist(newItem);
+    }
+    //@}
+    /// Worklist operations
+    //@{
+    inline DPIm popFromWorklist()
+    {
+        return worklist.pop();
+    }
+    inline bool pushIntoWorklist(DPIm& item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+    inline bool isInWorklist(DPIm& item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private:
+
+    /// Graph
+    GraphType _graph;
+
+    /// Worklist for resolution
+    WorkList worklist;
+
+};
+
+} // End namespace SVF
+
+#endif /* CFLSOLVER_H_ */

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

@@ -0,0 +1,321 @@
+/*
+ * Annotator.h
+ *
+ *  Created on: March 22, 2021
+ *      Author: Nicholas Tsom
+ */
+
+#ifndef IRANNOTATOR_H_
+#define IRANNOTATOR_H_
+
+#include "MemoryModel/SVFIR.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Util/SVFUtil.h"
+#include "llvm/IR/Metadata.h"
+
+
+namespace SVF
+{
+/*!
+ * Program annotator to write metadata information on LLVM IR
+ */
+class IRAnnotator
+{
+public:
+    IRAnnotator():
+        mainModule(nullptr),
+        ptsTo(nullptr)
+    {}
+    ~IRAnnotator() {}
+
+    void processAndersenResults(SVFIR *pag, BVDataPTAImpl *ptsTo, bool writeFlag)
+    {
+        this->ptsTo = ptsTo;
+        mainModule = LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule();
+
+        // Add a named metadata node used to check whether or not 
+        // this IR has been annotated with Andersen information
+        if (writeFlag)
+            mainModule->getOrInsertNamedMetadata("SVFIR-Annotated");
+
+        for (auto it = pag->begin(); it != pag->end(); ++it)
+        {
+            auto nodeId = it->first;
+            auto pagNode = it->second;
+            auto gepNode = SVFUtil::dyn_cast<GepObjVar>(pagNode);
+
+            if (gepNode && writeFlag)
+            {
+                writePAGgepNode(nodeId, gepNode);
+            }
+            else if (pagNode->hasValue())
+            {
+                processPAGNode(pagNode->getValue(), nodeId, writeFlag);
+            }
+        }
+
+        if (!writeFlag)
+            readPAGgepNodes(pag);
+    }
+
+private:
+    // 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, GepObjVar* gepNode)
+    {
+        auto baseNodeId = gepNode->getBaseNode();
+        auto locationSetOffset = gepNode->getConstantFieldIdx();
+
+        LLVMContext &context = mainModule->getContext();
+        llvm::SmallVector<llvm::Metadata *, 32> operands;
+        operands.push_back(llvm::MDString::get(context, std::to_string(baseNodeId)));
+        operands.push_back(llvm::MDString::get(context, std::to_string(locationSetOffset)));
+
+        llvm::MDTuple *metadata = llvm::MDTuple::get(context, operands);
+        std::string label = "gepnode-" + std::to_string(nodeId);
+
+        mainModule->getOrInsertNamedMetadata(label)->addOperand(metadata);
+    }
+
+    // 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(SVFIR *pag)
+    {
+        for (auto it = mainModule->named_metadata_begin(); it != mainModule->named_metadata_end(); ++it)
+        {
+            std::string label = it->getName().str();
+            std::string toErase = "gepnode-";
+            std::size_t pos = label.find(toErase);
+            if (pos == std::string::npos)
+            {
+                continue;
+            }
+            label.erase(pos, toErase.length());
+
+            SVF::NodeID nodeId = std::stoi(label);
+            auto mdNode = it->getOperand(0);
+
+            SVF::NodeID baseNodeId = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(0))->getString().str());
+            SVF::s32_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
+
+            LocationSet locationSet = LocationSet(locationSetOffset);
+            SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
+
+            assert(nodeId == gepnodeId && "nodeId != gepnodeId");
+        }
+    }
+
+    // Deduce the LLVM value's type, and process the metadata accordingly
+    void processPAGNode(const Value *value, SVF::NodeID nodeId, bool writeFlag)
+    {
+        if (auto instruction = const_cast<Instruction *>(SVFUtil::dyn_cast<Instruction>(value)))
+        {
+            processInstructionNode(instruction, nodeId, writeFlag);
+        }
+        else if (auto argument = const_cast<Argument *>(SVFUtil::dyn_cast<Argument>(value)))
+        {
+            processArgumentNode(argument, nodeId, writeFlag);
+        }
+        else if (auto function = const_cast<Function *>(SVFUtil::dyn_cast<Function>(value)))
+        {
+            processFunctionNode(function, nodeId, writeFlag);
+        }
+        else if (auto globalVar = const_cast<GlobalVariable *>(SVFUtil::dyn_cast<GlobalVariable>(value)))
+        {
+            processGlobalVarNode(globalVar, nodeId, writeFlag);
+        }
+        else if (auto basicBlock = const_cast<BasicBlock *>(SVFUtil::dyn_cast<BasicBlock>(value)))
+        {
+            processBasicBlockNode(basicBlock, nodeId, writeFlag);
+        }
+        else if (SVFUtil::isa<Constant>(value))
+        {
+            processConstantNode(nodeId, writeFlag);
+        }
+        else if (auto inlineAsm = const_cast<llvm::InlineAsm *>(SVFUtil::dyn_cast<llvm::InlineAsm>(value)))
+        {
+            processInlineAsmNode(inlineAsm, nodeId, writeFlag);
+        }
+        else
+        {
+            SVFUtil::outs() << "Value is NOT a Instruction, Argument, Function, GlobalVariable, BasicBlock, Constant or InlineAsm" << std::endl;
+            SVFUtil::outs() << SVFUtil::value2String(value) << "\n";
+        }
+    }
+
+    void processInstructionNode(Instruction *instruction, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "inode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = instruction->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            instruction->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = instruction->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processArgumentNode(Argument *argument, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "anode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = argument->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            argument->getParent()->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = argument->getParent()->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at argument");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processFunctionNode(Function *function, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "fnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = function->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            function->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = function->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at function");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processGlobalVarNode(GlobalVariable *globalVar, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "gnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = globalVar->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            globalVar->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = globalVar->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processBasicBlockNode(BasicBlock *basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "bnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = basicBlock->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            basicBlock->getParent()->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = basicBlock->getParent()->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at basicBlock");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processConstantNode(const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "cnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = mainModule->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            mainModule->getOrInsertNamedMetadata(label)->addOperand(mdNodePts);
+        }
+        else
+        {
+            auto mdNode = mainModule->getNamedMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenNamedMetdata(nodeId, mdNode);
+        }
+    }
+
+    void processInlineAsmNode(llvm::InlineAsm *inlineAsm, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "iAsmnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = mainModule->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            mainModule->getOrInsertNamedMetadata(label)->addOperand(mdNodePts);
+        }
+        else
+        {
+            auto mdNode = mainModule->getNamedMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at inlineAsm");
+            addAndersenNamedMetdata(nodeId, mdNode);
+        }
+    }
+
+    void addAndersenMetadata(const SVF::NodeID &nodeId, MDNode *mdNode)
+    {
+        if (mdNode)
+        {
+            for (unsigned int i = 0; i < mdNode->getNumOperands(); i++)
+            {
+                auto anderNodeIdStr = llvm::cast<llvm::MDString>(mdNode->getOperand(i))->getString().str();
+                auto anderNodeId = SVF::NodeID(std::stoul(anderNodeIdStr));
+                ptsTo->addPts(nodeId, anderNodeId);
+            }
+        }
+    }
+
+    void addAndersenNamedMetdata(const SVF::NodeID &nodeId, NamedMDNode *mdNode)
+    {
+        if (mdNode)
+        {
+            for (unsigned int i = 0; i < mdNode->getNumOperands(); i++)
+            {
+                auto node = mdNode->getOperand(i);
+
+                for (unsigned int j = 0; j < node->getNumOperands(); j++)
+                {
+                    auto anderNodeIdStr = llvm::cast<llvm::MDString>(node->getOperand(j))->getString().str();
+                    auto anderNodeId = SVF::NodeID(std::stoul(anderNodeIdStr));
+                    ptsTo->addPts(nodeId, anderNodeId);
+                }
+            }
+        }
+    }
+
+    inline llvm::MDTuple* getMdNodePts(const SVF::NodeID &nodeId, LLVMContext &context)
+    {
+        llvm::SmallVector<llvm::Metadata *, 32> operands;
+        auto &ptTo = ptsTo->getPts(nodeId);
+        for (const auto p : ptTo)
+        {
+            operands.push_back(llvm::MDString::get(context, std::to_string(p)));
+        }
+        return llvm::MDTuple::get(context, operands);
+    }
+
+    Module* mainModule;
+    BVDataPTAImpl *ptsTo;
+
+};
+
+} // End namespace SVF
+
+#endif /* IRANNOTATOR_H_ */