svf-lib 1.0.973 → 1.0.974

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_ */

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

@@ -0,0 +1,182 @@
+//===- BDDExpr.h -- Context/Path BDD conditions----------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * Condition.h
+ *
+ *  Created on: Oct 19, 2021
+ *      Author: Yulei and Xiao
+ */
+
+#ifndef BITVECTORCOND_H_
+#define BITVECTORCOND_H_
+
+#include "Util/BasicTypes.h"
+#include <cstdio>
+
+#include "CUDD/cuddInt.h"
+#include "z3++.h"
+
+namespace SVF {
+
+class BDDExprManager {
+public:
+    typedef DdNode BDDExpr;
+    typedef Map<u32_t, BDDExpr *> IndexToBDDExpr;
+private:
+    static BDDExprManager *bddExprMgr;
+    IndexToBDDExpr indexToBddCondMap;
+    DdManager *m_bdd_mgr;
+
+    inline BDDExpr *BddOne() const {
+        return Cudd_ReadOne(m_bdd_mgr);
+    }
+
+    inline BDDExpr *BddZero() const {
+        return Cudd_ReadLogicZero(m_bdd_mgr);
+    }
+
+    /// Constructor
+    BDDExprManager();
+
+public:
+    typedef Map<const BDDExpr *, const Instruction *> CondToTermInstMap;    // map a condition to its branch instruction
+    static u32_t totalCondNum; // a counter for fresh condition
+    /// Singleton design here to make sure we only have one instance during any analysis
+    //@{
+    static BDDExprManager *getBDDExprMgr();
+
+    static void releaseBDDExprMgr() {
+        delete bddExprMgr;
+        bddExprMgr = nullptr;
+    }
+    //@}
+
+    /// Destructor
+    virtual ~BDDExprManager();
+
+    BDDExpr *createCond(u32_t i) {
+        assert(indexToBddCondMap.find(i) == indexToBddCondMap.end() &&
+               "This should be fresh index to create new BDD");
+        BDDExpr *bddCond = Cudd_bddIthVar(m_bdd_mgr, i);
+        return indexToBddCondMap.emplace(i, bddCond).first->second;
+    }
+
+    /// Create a fresh condition to encode each program branch
+    virtual BDDExpr *createFreshBranchCond(const Instruction *inst);
+
+    /// Return the number of condition expressions
+    virtual inline u32_t getCondNumber() {
+        return Cudd_ReadNodeCount(m_bdd_mgr);
+    }
+
+
+    /// Return the unique true condition
+    inline BDDExpr *getTrueCond() const {
+        return trueCond;
+    }
+
+    /// Return the unique false condition
+    inline BDDExpr *getFalseCond() const {
+        return falseCond;
+    }
+
+    /// Operations on conditions.
+    //@{
+    virtual BDDExpr *AND(BDDExpr *lhs, BDDExpr *rhs);
+
+    virtual BDDExpr *OR(BDDExpr *lhs, BDDExpr *rhs);
+
+    virtual BDDExpr *NEG(BDDExpr *lhs);
+    //@}
+
+    virtual bool isNegCond(const BDDExpr *cond) {
+        return false;
+    }
+
+    /// Whether the condition is satisfiable
+    virtual bool isSatisfiable(const BDDExpr *cond) {
+        return cond != getFalseCond();
+    }
+
+    /// Whether lhs and rhs are equivalent branch conditions
+    virtual bool isEquivalentBranchCond(const BDDExpr *lhs, const BDDExpr *rhs){
+        return lhs == rhs;
+    }
+
+    /// Whether **All Paths** are reachable
+    bool isAllPathReachable(const BDDExpr *e);
+
+    /// Get condition using condition id (z3 ast id)
+    virtual BDDExpr *getCond(u32_t id) {
+        auto it = indexToBddCondMap.find(id);
+        assert(it != indexToBddCondMap.end() && "condition not found!");
+        return it->second;
+    }
+
+    /// Get/Set llvm conditional expression
+    //{@
+    inline const Instruction *getCondInst(const BDDExpr *cond) const {
+        CondToTermInstMap::const_iterator it = condToInstMap.find(cond);
+        assert(it != condToInstMap.end() && "this should be a fresh condition");
+        return it->second;
+    }
+
+    inline void setCondInst(const BDDExpr *cond, const Instruction *inst) {
+        assert(condToInstMap.find(cond) == condToInstMap.end() && "this should be a fresh condition");
+        condToInstMap[cond] = inst;
+    }
+    //@}
+
+    /**
+     * Utilities for dumping conditions. These methods use global functions from CUDD
+     * package and they can be removed outside this class scope to be used by others.
+     */
+    void ddClearFlag(BDDExpr *f) const;
+
+    void BddSupportStep(BDDExpr *f, NodeBS &support) const;
+
+    void extractSubConds(const BDDExpr *f, NodeBS &support) const;
+
+    void dump(const BDDExpr *lhs, OutStream &O);
+
+    std::string dumpStr(const BDDExpr *e) const;
+
+    inline std::string getMemUsage() {
+        return std::to_string(Cudd_ReadMemoryInUse(m_bdd_mgr));
+    }
+
+protected:
+    static BDDExpr *trueCond;
+    static BDDExpr *falseCond;
+
+private:
+
+    CondToTermInstMap condToInstMap; ///< map condition to llvm instruction
+
+};
+
+
+
+} // End namespace SVF
+
+#endif /* BITVECTORCOND_H_ */

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

@@ -30,7 +30,7 @@
 #ifndef DPITEM_H_
 #define DPITEM_H_
 
-#include "Util/Conditions.h"
+#include "Util/BDDExpr.h"
 #include "MemoryModel/ConditionalPT.h"
 #include <algorithm>    // std::sort
 

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

@@ -0,0 +1,172 @@
+//===- ExeState.h -- Execution State ----------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * ExeState.h
+ *
+ *  Created on: April 29, 2022
+ *      Author: Xiao
+ */
+
+#ifndef SVF_EXESTATE_H
+#define SVF_EXESTATE_H
+#include "Util/Z3Expr.h"
+#include "MemoryModel/SVFVariables.h"
+
+namespace SVF {
+
+#define AddressMask 0x7f000000
+#define FlippedAddressMask (AddressMask^0xffffffff)
+
+class ExeState {
+public:
+    typedef Map<u32_t, Z3Expr> VarToValMap;
+    typedef Map<u32_t, Z3Expr> LocToValMap;
+
+protected:
+    VarToValMap varToVal;
+    LocToValMap locToVal;
+    Z3Expr pathConstraint;
+
+public:
+    ExeState() : pathConstraint(getContext().bool_val(true)) {}
+
+    ExeState(const Z3Expr &_pc, VarToValMap &_varToValMap, LocToValMap &_locToValMap) : varToVal(_varToValMap),
+                                                                                        locToVal(_locToValMap),
+                                                                                        pathConstraint(_pc) {}
+
+    ExeState(const ExeState &rhs) : varToVal(rhs.getVarToVal()), locToVal(rhs.getLocToVal()),
+                                    pathConstraint(rhs.getPathConstraint()) {
+
+    }
+
+    virtual ~ExeState() = default;
+
+    ExeState &operator=(const ExeState &rhs);
+
+    /// Overloading Operator==
+    bool operator==(const ExeState &rhs) const;
+
+    /// Overloading Operator!=
+    inline bool operator!=(const ExeState &rhs) const {
+        return !(*this == rhs);
+    }
+
+    /// Overloading Operator==
+    bool operator<(const ExeState &rhs) const;
+
+    z3::context &getContext() {
+        return Z3Expr::getContext();
+    }
+
+    const VarToValMap &getVarToVal() const {
+        return varToVal;
+    }
+
+    const LocToValMap &getLocToVal() const {
+        return locToVal;
+    }
+
+    const Z3Expr &getPathConstraint() const {
+        return pathConstraint;
+    }
+
+    void setPathConstraint(const Z3Expr &pc) {
+        pathConstraint = pc.simplify();
+    }
+
+    inline Z3Expr &operator[](u32_t varId) {
+        return getZ3Expr(varId);
+    }
+
+    /// Init Z3Expr for ValVar
+    void initValVar(const ValVar *valVar, Z3Expr &e);
+
+    /// Init Z3Expr for ObjVar
+    void initObjVar(const ObjVar *objVar, Z3Expr &e);
+
+    /// Return Z3 expression based on SVFVar ID
+    Z3Expr &getZ3Expr(u32_t varId);
+
+    /// Store value to location
+    void store(const Z3Expr &loc, const Z3Expr &value);
+
+    /// Load value at location
+    Z3Expr &load(const Z3Expr &loc);
+
+    /// The physical address starts with 0x7f...... + idx
+    inline u32_t getVirtualMemAddress(u32_t idx) const {
+        return AddressMask + idx;
+    }
+
+    /// Check bit value of val start with 0x7F000000, filter by 0xFF000000
+    inline bool isVirtualMemAddress(u32_t val) {
+        return (val & 0xff000000) == AddressMask;
+    }
+
+    /// Return the internal index if idx is an address otherwise return the value of idx
+    inline u32_t getInternalID(u32_t idx) const {
+        return (idx & FlippedAddressMask);
+    }
+
+    /// Return int value from an expression if it is a numeral, otherwise return an approximate value
+    inline s32_t z3Expr2NumValue(const Z3Expr &e) {
+        assert(e.is_numeral() && "not numeral?");
+        return e.get_numeral_int64();
+    }
+
+    /// Print values of all expressions
+    void printExprValues();
+
+protected:
+    inline void store(u32_t objId, const Z3Expr &z3Expr) {
+        locToVal[objId] = z3Expr.simplify();
+    }
+
+    inline Z3Expr &load(u32_t objId) {
+        return locToVal[objId];
+    }
+};
+}
+
+template<>
+struct std::hash<SVF::ExeState> {
+    size_t operator()(const SVF::ExeState &exeState) const {
+
+        size_t h = exeState.getVarToVal().size() * 2;
+        SVF::Hash<SVF::u32_t> hf;
+        for (const auto &t: exeState.getVarToVal()) {
+            h ^= hf(t.first) + 0x9e3779b9 + (h << 6) + (h >> 2);
+            h ^= hf(t.second.id()) + 0x9e3779b9 + (h << 6) + (h >> 2);
+        }
+
+        size_t h2 = exeState.getVarToVal().size() * 2;
+
+        for (const auto &t: exeState.getLocToVal()) {
+            h2 ^= hf(t.first) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
+            h2 ^= hf(t.second.id()) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
+        }
+        SVF::Hash<std::pair<SVF::u32_t, SVF::u32_t>> pairH;
+
+        return pairH(make_pair(pairH(make_pair(h, h2)), exeState.getPathConstraint().id()));
+    }
+};
+#endif //SVF_EXESTATE_H

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

@@ -10,7 +10,6 @@
 #include "Util/NodeIDAllocator.h"
 #include "MSSA/MemSSA.h"
 #include "WPA/WPAPass.h"
-#include "Util/Conditions.h"
 
 namespace SVF
 {
@@ -255,8 +254,6 @@ public:
     // DOTGraphTraits
     static const llvm::cl::opt<bool> ShowHiddenNode;
 
-    // Conditions
-    static const llvm::cl::opt<CondManager::CondMgrKind> ConditionType;
 };
 }  // namespace SVF
 

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

@@ -0,0 +1,235 @@
+//===- Z3Expr.h -- Z3 conditions----------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * Z3Expr.h
+ *
+ *  Created on: April 29, 2022
+ *      Author: Xiao
+ */
+
+#ifndef Z3_EXAMPLE_Z3EXPR_H
+#define Z3_EXAMPLE_Z3EXPR_H
+
+#include "z3++.h"
+#include "Util/SVFBasicTypes.h"
+
+namespace SVF {
+
+    class Z3Expr {
+    public:
+        static z3::context *ctx;
+
+    private:
+        z3::expr e;
+
+        Z3Expr(float f); // placeholder don't support floating point expression
+        Z3Expr(double f); // placeholder don't support floating point expression
+
+    public:
+
+        Z3Expr() : e(nullExpr()) {
+        }
+
+        Z3Expr(const z3::expr &_e) : e(_e) {
+        }
+
+        Z3Expr(int i) : e(getContext().int_val(i)) {
+        }
+
+        Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr()) {
+        }
+
+        virtual ~Z3Expr() = default;
+
+        inline Z3Expr &operator=(const Z3Expr &rhs) {
+            if (this->id() != rhs.id()) {
+                e = rhs.getExpr();
+            }
+            return *this;
+        }
+
+        const z3::expr &getExpr() const {
+            return e;
+        }
+
+        /// Get z3 context, singleton design here to make sure we only have one context
+        static z3::context &getContext() {
+            if (ctx == nullptr) {
+                ctx = new z3::context();
+            }
+            return *ctx;
+        }
+
+        /// release z3 context
+        static void releaseContext() {
+            delete ctx;
+            ctx = nullptr;
+        }
+
+        /// null expression
+        static z3::expr nullExpr() {
+            return getContext().int_const("null");
+        }
+
+        /// get id
+        inline u32_t id() const {
+            return e.id();
+        }
+
+        inline const std::string to_string() const {
+            return e.to_string();
+        }
+
+        inline bool is_numeral() const {
+            return e.is_numeral();
+        }
+
+        inline bool is_bool() const {
+            return e.is_bool();
+        }
+
+        inline Z3Expr simplify() const {
+            return e.simplify();
+        }
+
+        inline int64_t get_numeral_int64() const {
+            return e.get_numeral_int64();
+        }
+
+        inline int get_numeral_int() const {
+            return e.get_numeral_int();
+        }
+
+        //{% reload operator
+        friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() == rhs.getExpr();
+        }
+
+        friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() != rhs.getExpr();
+        }
+
+        friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() > rhs.getExpr();
+        }
+
+        friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() < rhs.getExpr();
+        }
+
+        friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() <= rhs.getExpr();
+        }
+
+        friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() >= rhs.getExpr();
+        }
+
+        friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() + rhs.getExpr();
+        }
+
+        friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() - rhs.getExpr();
+        }
+
+        friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() * rhs.getExpr();
+        }
+
+        friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() / rhs.getExpr();
+        }
+
+        friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() % rhs.getExpr();
+        }
+
+        friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() ^ rhs.getExpr();
+        }
+
+        friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() & rhs.getExpr();
+        }
+
+        friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() | rhs.getExpr();
+        }
+
+        friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return ashr(lhs.getExpr(), rhs.getExpr());
+        }
+
+        friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return shl(lhs.getExpr(), rhs.getExpr());
+        }
+
+        friend Z3Expr int2bv(u32_t n, const Z3Expr &e) {
+            return int2bv(n, e.getExpr());
+        }
+
+        friend Z3Expr bv2int(const Z3Expr &e, bool isSigned) {
+            return z3::bv2int(e.getExpr(), isSigned);
+        }
+
+        friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() && rhs.getExpr();
+        }
+
+        friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return lhs.getExpr() || rhs.getExpr();
+        }
+
+        friend Z3Expr operator!(const Z3Expr &lhs) {
+            return !lhs.getExpr();
+        }
+
+        friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs) {
+            return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
+        }
+
+        friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr) {
+            out << expr.getExpr();
+            return out;
+        }
+
+        friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs) {
+            return eq(lhs.getExpr(), rhs.getExpr());
+        }
+
+        z3::sort get_sort() const {
+            return getExpr().get_sort();
+        }
+        //%}
+    };
+}
+
+/// Specialise hash for AbsCxtDPItem.
+template<>
+struct std::hash<SVF::Z3Expr> {
+    size_t operator()(const SVF::Z3Expr &z3Expr) const {
+        return z3Expr.id();
+    }
+};
+
+#endif //Z3_EXAMPLE_Z3EXPR_H

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

@@ -13,7 +13,7 @@
 #include "SVF-FE/DCHG.h"
 #include "Graphs/SVFGOPT.h"
 #include "MSSA/SVFGBuilder.h"
-#include "Util/TypeBasedHeapCloning.h"
+#include "TypeBasedHeapCloning.h"
 #include "WPA/FlowSensitive.h"
 #include "MemoryModel/PointsTo.h"
 

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

@@ -0,0 +1,188 @@
+//===- TypeBasedHeapCloning.h -- Type filter/type-based heap cloning base ------------//
+
+/*
+ * TypeBasedHeapCloning.h
+ *
+ * Contains data structures and functions to extend a pointer analysis
+ * with type-based heap cloning/type filtering.
+ *
+ *  Created on: Feb 08, 2020
+ *      Author: Mohamad Barbar
+ */
+
+#include "SVF-FE/DCHG.h"
+#include "MemoryModel/SVFIR.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Util/BasicTypes.h"
+
+namespace SVF
+{
+
+class TypeBasedHeapCloning
+{
+public:
+    /// Returns raw ctir metadata of a Value. Returns null if it doesn't exist.
+    static const MDNode *getRawCTirMetadata(const Value *);
+
+    virtual ~TypeBasedHeapCloning() { };
+
+protected:
+    /// The undefined type (•); void.
+    static const DIType *undefType;
+
+    /// deref function for TBHC alias tests.
+    static const std::string derefFnName;
+    /// deref function (mangled) for TBHC alias tests.
+    static const std::string mangledDerefFnName;
+
+    /// Constructor. pta is the pointer analysis using this object (i.e. that which is extending).
+    TypeBasedHeapCloning(BVDataPTAImpl *pta);
+
+    /// Required by user. Handles back-propagation of newly created clone after all
+    /// metadata has been set. Used by cloneObject.
+    virtual void backPropagate(NodeID clone) = 0;
+
+    /// Class hierarchy graph built from debug information. Required, CHG from
+    /// IR is insufficient.
+    DCHGraph *dchg = nullptr;
+
+    /// DCHG *must* be set by extending class once the DCHG is available.
+    void setDCHG(DCHGraph *dchg);
+    /// 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.
+    bool isBlkObjOrConstantObj(NodeID o) const;
+
+    /// Wrapper around DCHGraph::isBase. Purpose is to keep our conditions clean
+    /// by only passing two parameters like the rules.
+    bool isBase(const DIType *a, const DIType *b) const;
+
+    /// Returns true if o is a clone.
+    bool isClone(NodeID o) const;
+
+    /// Sets the type (in objToType) of o.
+    void setType(NodeID o, const DIType *t);
+    /// Returns the type (from objToType) of o. Asserts existence.
+    const DIType *getType(NodeID o) const;
+
+    /// Sets the allocation site (in objToAllocation) of o.
+    void setAllocationSite(NodeID o, NodeID site);
+    /// Returns the allocation site (from objToAllocation) of o. Asserts existence.
+    NodeID getAllocationSite(NodeID o) const;
+
+    /// Returns objects that have clones (any key in objToClones).
+    const NodeBS getObjsWithClones(void);
+    /// Add a clone c to object o.
+    void addClone(NodeID o, NodeID c);
+    /// Returns all the clones of o.
+    const NodeBS &getClones(NodeID o);
+
+    // Set o as the original object of clone c.
+    void setOriginalObj(NodeID c, NodeID o);
+    /// Returns the original object c is cloned from. If c is not a clone, returns itself.
+    NodeID getOriginalObj(NodeID c) const;
+
+    /// Returns the filter set of a location. Not const; could create empty PointsTo.
+    PointsTo &getFilterSet(NodeID loc);
+
+    /// Associates gep with base (through objToGeps and memObjToGeps).
+    void addGepToObj(NodeID gep, NodeID base, unsigned offset);
+    /// Returns all gep objects at a particular offset for memory object.
+    /// Not const; could create empty set.
+    const NodeBS &getGepObjsFromMemObj(const MemObj *memObj, unsigned offset);
+    /// Returns all gep objects under an object.
+    /// Not const; could create empty set.
+    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 getGepObjVar is called on the SVFIR
+    /// (through base's getGepObjVar) which will create one.
+    const NodeBS getGepObjClones(NodeID base, unsigned offset);
+
+    /// Initialise the pointees of p at loc (which is type tildet *). reuse indicates
+    /// whether reuse is a possibility for this initialisation. Returns whether p changed.
+    bool init(NodeID loc, NodeID p, const DIType *tildet, bool reuse, bool gep=false);
+
+    /// Returns a clone of o with type type. reuse indicates whether we are cloning
+    /// as a result of reuse.
+    NodeID cloneObject(NodeID o, const DIType *type, bool reuse);
+
+    /// Add clone dummy object node to SVFIR.
+    inline NodeID addCloneDummyObjNode(const MemObj *mem);
+    /// Add clone GEP object node to SVFIR.
+    inline NodeID addCloneGepObjNode(const MemObj *mem, const LocationSet &l);
+    /// 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.
+    /// Not static because it needs the DCHG to return the canonical type.
+    /// Not static because we need dchg's getCanonicalType.
+    const DIType *getTypeFromCTirMetadata(const Value *);
+
+    /// Runs tests on MAYALIAS, NOALIAS, etc. built from TBHC_MAYALIAS,
+    /// TBHC_NOALIAS, etc. macros.
+    /// TBHC_XALIAS macros produce:
+    ///   call XALIAS(...)
+    ///   %1 = load ...
+    ///   ...
+    ///   %n = load %p
+    ///   store ... %n-1, ...* %n !ctir !t1
+    ///   call deref()
+    ///   %n+1 = load ...
+    ///   ...
+    ///   %n+n = load %q
+    ///   store ... %n+n-1, ...* %n+n !ctir !t2
+    ///   call deref()
+    /// We want to test the points-to sets of %n and
+    /// %n+n after filtering with !t1 and !t2 respectively.
+    void validateTBHCTests(SVFModule *svfMod);
+
+    /// Dump some statistics we tracked.
+    void dumpStats(void);
+
+private:
+    /// PTA extending this class.
+    BVDataPTAImpl *pta;
+    /// 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 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 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;
+    /// Maps memory objects to their GEP objects. (memobj -> (fieldidx -> geps))
+    Map<const MemObj *, Map<unsigned, NodeBS>> memObjToGeps;
+
+    /// Test whether object is a GEP object. For convenience.
+    bool isGep(const PAGNode *n) const;
+
+    // Bunch of stats to keep track of.
+    unsigned numInit  = 0;
+    unsigned numTBWU  = 0;
+    unsigned numTBSSU = 0;
+    unsigned numTBSU  = 0;
+    unsigned numReuse = 0;
+    unsigned numAgg   = 0;
+
+    // Previous stats but only upon stack/global objects.
+    unsigned numSGInit  = 0;
+    unsigned numSGTBWU  = 0;
+    unsigned numSGTBSSU = 0;
+    unsigned numSGTBSU  = 0;
+    unsigned numSGReuse = 0;
+    unsigned numSGAgg   = 0;
+};
+
+} // End namespace SVF

package/package.json

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