svf-lib 1.0.1375 → 1.0.1376

package/SVF-osx/svf/include/include/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(), llvm::None));
+            //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/svf/include/include/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/svf/include/include/Util/CallGraphBuilder.h

@@ -0,0 +1,74 @@
+//===- 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+
+/*
+ * CallGraphBuilder.h
+ *
+ *  Created on: 13Mar.,2020
+ *      Author: Yulei Sui
+ */
+
+#ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
+#define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
+
+#include "Graphs/PTACallGraph.h"
+#include "Graphs/ThreadCallGraph.h"
+
+namespace SVF
+{
+
+class ICFG;
+
+class CallGraphBuilder
+{
+
+protected:
+    PTACallGraph* callgraph;
+    ICFG* icfg;
+public:
+    CallGraphBuilder(PTACallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
+    {
+    }
+
+    /// Build normal callgraph
+    PTACallGraph* buildCallGraph(SVFModule* svfModule);
+
+};
+
+class ThreadCallGraphBuilder : public CallGraphBuilder
+{
+
+public:
+    ThreadCallGraphBuilder(ThreadCallGraph* cg, ICFG* i): CallGraphBuilder(cg,i)
+    {
+    }
+
+    /// Build thread-aware callgraph
+    PTACallGraph* buildThreadCallGraph(SVFModule* svfModule);
+
+};
+
+} // End namespace SVF
+
+
+#endif /* INCLUDE_UTIL_CALLGRAPHBUILDER_H_ */