svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/Util/Annotator.h

@@ -0,0 +1,180 @@
+/*
+ * Annotator.h
+ *
+ *  Created on: May 4, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef ANNOTATOR_H_
+#define ANNOTATOR_H_
+
+#include <SVF-LLVM/BasicTypes.h> // TODO: Remove LLVM Header
+#include "SVFIR/SVFValue.h"
+#include <vector>
+
+namespace SVF
+{
+
+/*!
+ * Program annotator to write meta data information on LLVM IR
+ */
+class Annotator
+{
+
+public:
+    /// Constructor
+    Annotator()
+    {
+        SB_SLICESOURCE = "SOURCE_";
+        SB_SLICESINK = "SINK_";
+        SB_FESIBLE = "FESIBLE_";
+        SB_INFESIBLE = "INFESIBLE_";
+
+        DR_NOT_CHECK = "DRNOTCHECK_";
+        DR_CHECK = "DRCHECK_";
+    }
+
+    /// Destructor
+    virtual ~Annotator()
+    {
+    }
+
+    /// SB Has flag methods
+    //@{
+    inline bool hasSBSourceFlag(Instruction* inst) const
+    {
+        std::vector<Value* > values;
+        return evalMDTag(inst, inst, SB_SLICESOURCE, values);
+    }
+
+    inline bool hasSBSinkFlag(Instruction* inst) const
+    {
+        std::vector<Value* > values;
+        return evalMDTag(inst, inst, SB_SLICESINK, values);
+    }
+    //@}
+
+    /// Race Detection Has flag methods
+    //@{
+    inline bool hasDRNotCheckFlag(Instruction* inst) const
+    {
+        //std::vector<Value* > values;
+        //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
+        return inst->getMetadata(DR_NOT_CHECK);
+    }
+
+    inline bool hasDRNotCheckFlag(const Instruction* inst) const
+    {
+        //std::vector<Value* > values;
+        //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
+        return inst->getMetadata(DR_NOT_CHECK);
+    }
+
+    inline bool hasDRCheckFlag(Instruction* inst) const
+    {
+        //std::vector<Value* > values;
+        //return evalMDTag(inst, inst, DR_CHECK, values);
+        return inst->getMetadata(DR_CHECK);
+    }
+
+    inline bool hasDRCheckFlag(const Instruction* inst) const
+    {
+        //std::vector<Value* > values;
+        //return evalMDTag(inst, inst, DR_CHECK, values);
+        return inst->getMetadata(DR_CHECK);
+    }
+    //@}
+
+    /// Simple add/remove meta data information
+    //@{
+    inline void addMDTag(Instruction* inst, std::string str)
+    {
+        addMDTag(inst, inst, str);
+    }
+    inline void removeMDTag(Instruction* inst, std::string str)
+    {
+        removeMDTag(inst, inst, str);
+    }
+    //@}
+
+    /// manipulate llvm meta data on instructions for a specific value
+    //@{
+    /// add flag to llvm metadata
+    inline void addMDTag(Instruction* inst, Value* val, std::string str)
+    {
+        assert(!val->getType()->isVoidTy() && "expecting non-void value for MD!");
+        std::vector<Value* > values;
+        //std::vector<llvm::Metadata *> metavalues;
+        // add the flag if we did not see it before
+        if (evalMDTag(inst, val, str, values) == false)
+        {
+
+            values.push_back(val);
+            //llvm::ArrayRef<llvm::Metadata*> ar(metavalues);
+            // FIXME: delete the old MDNode
+            inst->setMetadata(str, MDNode::get(inst->getContext(), nullptr));
+            //inst->setMetadata(str, llvm::MDNode::get(inst->getContext(), ar));
+        }
+    }
+
+    /// remove flag from llvm metadata
+    inline void removeMDTag(Instruction* inst, Value* val, std::string str)
+    {
+        assert(!val->getType()->isVoidTy() && "expecting non-void value for MD!");
+        std::vector<Value* > values;
+
+        // remove the flag if it is there
+        if (evalMDTag(inst, val, str, values) == true)
+        {
+            llvm::ArrayRef<Value* > ar(values);
+            // FIXME: delete the old MDNode
+            //inst->setMetadata(str, llvm::MDNode::get(inst->getContext(), ar));
+        }
+    }
+    //@}
+
+private:
+
+    /// evaluate llvm metadata
+    inline bool evalMDTag(const Instruction* inst, const Value* val, std::string str,
+                          std::vector<Value* >&) const
+    {
+
+        assert(val && "value should not be null");
+
+        bool hasFlag = false;
+        if (MDNode *mdNode = inst->getMetadata(str))
+        {
+            /// When mdNode has operands and value is not null
+            for (unsigned k = 0; k < mdNode->getNumOperands(); ++k)
+            {
+                //Value* v = mdNode->getOperand(k);
+                // if (v == val)
+                //    hasFlag = true;
+                //else
+                //    values.push_back(v);
+            }
+        }
+        return hasFlag;
+    }
+
+protected:
+
+    /// Saber annotations
+    //@{
+    const char* SB_SLICESOURCE;
+    const char* SB_SLICESINK;
+    const char* SB_FESIBLE;
+    const char* SB_INFESIBLE;
+    //@}
+
+    /// Race Detection annotations
+    //@{
+    const char* DR_NOT_CHECK;
+    const char* DR_CHECK;
+    //@}
+};
+
+} // End namespace SVF
+
+#endif /* ANNOTATOR_H_ */

package/SVF-osx/Release-build/include/SVF/Util/BitVector.h

@@ -0,0 +1,55 @@
+//===- BitVector.h -- variably sized bit vector data structure ------------//
+
+/*
+ * BitVector.h
+ *
+ * Contiguous bit vector with trailing 0s stripped.
+ *
+ *  Created on: Jul 4, 2021
+ *      Author: Mohamad Barbar
+ */
+
+#ifndef BITVECTOR_H_
+#define BITVECTOR_H_
+
+#include <Util/CoreBitVector.h>
+
+namespace SVF
+{
+
+/// A contiguous bit vector in which trailing 0s are stripped.
+/// Does not shrink - only grows. This isn't a problem for
+/// points-to analysis, usually, but may be for other applications.
+///
+/// Implemented as a CBV that has an offset of zero.
+/// There is an extremely slight performance penalty in the form
+/// of checking if we need to extend backwards.
+/// Since the CBV also grows monotonically, this means this BV will
+/// always contain a word for 0 till the last ever set bit.
+/// TODO: if we change the CBV to shrink, we need to modify this
+///       implementation accordingly.
+class BitVector : public CoreBitVector
+{
+public:
+    /// Construct empty BV.
+    BitVector(void);
+
+    /// Construct empty BV with space reserved for n Words.
+    BitVector(size_t n);
+
+    /// Copy constructor.
+    BitVector(const BitVector &bv);
+
+    /// Move constructor.
+    BitVector(BitVector &&bv);
+
+    /// Copy assignment.
+    BitVector &operator=(const BitVector &rhs);
+
+    /// Move assignment.
+    BitVector &operator=(BitVector &&rhs);
+};
+
+};  // namespace SVF
+
+#endif  // BITVECTOR_H_

package/SVF-osx/Release-build/include/SVF/Util/CDGBuilder.h

@@ -0,0 +1,107 @@
+//===----- CDGBuilder.h -- Control Dependence Graph 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 Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CDGBuilder.h
+ *
+ *  Created on: Sep 27, 2023
+ *      Author: Xiao Cheng
+ */
+#ifndef SVF_CDGBUILDER_H
+#define SVF_CDGBUILDER_H
+
+#include "Graphs/CDG.h"
+#include "SVFIR/SVFValue.h"
+
+// control dependence builder
+namespace SVF
+{
+class CDGBuilder
+{
+public:
+
+    /// constructor
+    CDGBuilder() : _controlDG(CDG::getCDG())
+    {
+
+    }
+
+    /// destructor
+    ~CDGBuilder()
+    {
+
+    }
+
+    /// start here
+    void build();
+
+    /// build control dependence for each function
+    void buildControlDependence();
+
+    /// build map at icfg node level
+    void buildICFGNodeControlMap();
+
+
+
+private:
+
+
+    /// extract basic block edges to be processed
+    static void
+    extractBBS(const FunObjVar *func,
+               Map<const SVFBasicBlock *, std::vector<const SVFBasicBlock *>> &res);
+
+    /// extract nodes between two nodes in pdom tree
+    void
+    extractNodesBetweenPdomNodes(const SVFBasicBlock *succ, const SVFBasicBlock *LCA,
+                                 std::vector<const SVFBasicBlock *> &tgtNodes);
+
+
+    void dfsNodesBetweenPdomNodes(const SVFBasicBlock *cur,
+                                  const SVFBasicBlock *tgt,
+                                  std::vector<const SVFBasicBlock *> &path,
+                                  std::vector<const SVFBasicBlock *> &tgtNodes,
+                                  SVFLoopAndDomInfo *ld);
+
+
+    s64_t getBBSuccessorBranchID(const SVFBasicBlock *BB, const SVFBasicBlock *Succ);
+
+
+    /// update map
+    inline void updateMap(const SVFBasicBlock *pred, const SVFBasicBlock *bb, s32_t pos)
+    {
+        _svfcontrolMap[pred][bb].insert(pos);
+        _svfdependentOnMap[bb][pred].insert(pos);
+    }
+
+
+private:
+    CDG *_controlDG;
+    Map<const SVFBasicBlock *, Map<const SVFBasicBlock *, Set<s32_t>>> _svfcontrolMap; ///< map a basicblock to its controlling BBs (position, set of BBs)
+    Map<const SVFBasicBlock *, Map<const SVFBasicBlock *, Set<s32_t>>> _svfdependentOnMap; ///< map a basicblock to its dependent on BBs (position, set of BBs)
+    Map<const ICFGNode *, Map<const ICFGNode *, Set<s32_t>>> _nodeControlMap; ///< map an ICFG node to its controlling ICFG nodes (position, set of Nodes)
+    Map<const ICFGNode *, Map<const ICFGNode *, Set<s32_t>>> _nodeDependentOnMap; ///< map an ICFG node to its dependent on ICFG nodes (position, set of Nodes)
+};
+}
+
+
+#endif //SVF_CDGBUILDER_H

package/SVF-osx/Release-build/include/SVF/Util/CallGraphBuilder.h

@@ -0,0 +1,61 @@
+//===- CallGraphBuilder.h ----------------------------------------------------------------//
+//
+//                     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 Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+
+/*
+ * CallGraphBuilder.h
+ *
+ *  Created on: 13Mar.,2020
+ *      Author: Yulei Sui
+ */
+
+#ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
+#define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
+
+#include "Graphs/ThreadCallGraph.h"
+
+namespace SVF
+{
+
+class ICFG;
+class CallGraph;
+class ThreadCallGraph;
+
+class CallGraphBuilder
+{
+public:
+    CallGraphBuilder()=default;
+
+    /// Buidl SVFIR callgraoh
+    CallGraph* buildSVFIRCallGraph(const std::vector<const FunObjVar*>& funset);
+
+    /// Buidl PTA callgraoh
+    CallGraph* buildPTACallGraph();
+
+    /// Build thread-aware callgraph
+    ThreadCallGraph* buildThreadCallGraph();
+};
+
+} // End namespace SVF
+
+
+#endif /* INCLUDE_UTIL_CALLGRAPHBUILDER_H_ */