svf-lib 1.0.2158 → 1.0.2159

package/SVF-osx/Release-build/include/AE/Core/IntervalValue.h

@@ -1002,7 +1002,7 @@ inline IntervalValue operator|(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.is_numeral() && rhs.is_numeral())
         return IntervalValue(lhs.lb() | rhs.lb());
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
-                                      rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
+             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
         s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
         s64_t ub = next_power_of_2(s64_t(m)) - 1;
@@ -1031,7 +1031,7 @@ inline IntervalValue operator^(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.is_numeral() && rhs.is_numeral())
         return IntervalValue(lhs.lb() ^ rhs.lb());
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
-                                      rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
+             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
         s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
         s64_t ub = next_power_of_2(s64_t(m)) - 1;

package/SVF-osx/Release-build/include/AE/Core/NumericValue.h

@@ -908,9 +908,9 @@ public:
     static double safeAdd(double lhs, double rhs)
     {
         if ((lhs == std::numeric_limits<double>::infinity() &&
-        rhs == -std::numeric_limits<double>::infinity()) ||
-        (lhs == -std::numeric_limits<double>::infinity() &&
-        rhs == std::numeric_limits<double>::infinity()))
+                rhs == -std::numeric_limits<double>::infinity()) ||
+                (lhs == -std::numeric_limits<double>::infinity() &&
+                 rhs == std::numeric_limits<double>::infinity()))
         {
             assert(false && "invalid add");
         }

package/SVF-osx/Release-build/include/CFL/CFGrammar.h

@@ -147,17 +147,17 @@ public:
     template<typename Key, typename Value, typename Hash = SymbolHash,
              typename KeyEqual = std::equal_to<Key>,
              typename Allocator = std::allocator<std::pair<const Key, Value>>>
-    using SymbolMap = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+                 using SymbolMap = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
 
-    template <typename Key, typename Hash = SymbolVectorHash, typename KeyEqual = std::equal_to<Key>,
-              typename Allocator = std::allocator<Key>>
-    using SymbolSet = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
+             template <typename Key, typename Hash = SymbolVectorHash, typename KeyEqual = std::equal_to<Key>,
+                       typename Allocator = std::allocator<Key>>
+             using SymbolSet = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 
-    typedef std::vector<Symbol> Production;
-    typedef SymbolSet<Production> Productions;
+             typedef std::vector<Symbol> Production;
+             typedef SymbolSet<Production> Productions;
 
 
-    inline Map<std::string, Kind>& getNonterminals()
+             inline Map<std::string, Kind>& getNonterminals()
     {
         return this->nonterminals;
     }

package/SVF-osx/Release-build/include/Graphs/ConsG.h

@@ -131,7 +131,7 @@ public:
     {
         ConstraintEdge edge(src,dst,kind);
         if(kind == ConstraintEdge::Copy ||
-        kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep)
+                kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep)
             return directEdgeSet.find(&edge) != directEdgeSet.end();
         else if(kind == ConstraintEdge::Addr)
             return AddrCGEdgeSet.find(&edge) != AddrCGEdgeSet.end();

package/SVF-osx/Release-build/include/Graphs/ConsGEdge.h

@@ -75,11 +75,11 @@ public:
     static inline bool classof(const GenericConsEdgeTy *edge)
     {
         return edge->getEdgeKind() == Addr ||
-        edge->getEdgeKind() == Copy ||
-        edge->getEdgeKind() == Store ||
-        edge->getEdgeKind() == Load ||
-        edge->getEdgeKind() == NormalGep ||
-        edge->getEdgeKind() == VariantGep;
+               edge->getEdgeKind() == Copy ||
+               edge->getEdgeKind() == Store ||
+               edge->getEdgeKind() == Load ||
+               edge->getEdgeKind() == NormalGep ||
+               edge->getEdgeKind() == VariantGep;
     }
     /// Constraint edge type
     typedef GenericNode<ConstraintNode,ConstraintEdge>::GEdgeSetTy ConstraintEdgeSetTy;
@@ -248,12 +248,12 @@ public:
     static inline bool classof(const ConstraintEdge *edge)
     {
         return edge->getEdgeKind() == NormalGep ||
-        edge->getEdgeKind() == VariantGep;
+               edge->getEdgeKind() == VariantGep;
     }
     static inline bool classof(const GenericConsEdgeTy *edge)
     {
         return edge->getEdgeKind() == NormalGep ||
-        edge->getEdgeKind() == VariantGep;
+               edge->getEdgeKind() == VariantGep;
     }
     //@}
 

package/SVF-osx/Release-build/include/Graphs/GenericGraph.h

@@ -123,8 +123,8 @@ public:
     virtual inline bool operator==(const GenericEdge<NodeType>* rhs) const
     {
         return (rhs->edgeFlag == this->edgeFlag &&
-        rhs->getSrcID() == this->getSrcID() &&
-        rhs->getDstID() == this->getDstID());
+                rhs->getSrcID() == this->getSrcID() &&
+                rhs->getDstID() == this->getDstID());
     }
     //@}
 
@@ -680,8 +680,8 @@ public:
     inline void removeGNode(NodeType* node)
     {
         assert(node->hasIncomingEdge() == false
-        && node->hasOutgoingEdge() == false
-                                          && "node which have edges can't be deleted");
+               && node->hasOutgoingEdge() == false
+               && "node which have edges can't be deleted");
         iterator it = IDToNodeMap.find(node->getId());
         assert(it != IDToNodeMap.end() && "can not find the node");
         IDToNodeMap.erase(it);

package/SVF-osx/Release-build/include/Graphs/ICFGEdge.h

@@ -72,7 +72,7 @@ public:
     inline bool isCFGEdge() const
     {
         return getEdgeKind() == IntraCF || getEdgeKind() == CallCF ||
-        getEdgeKind() == RetCF;
+               getEdgeKind() == RetCF;
     }
     inline bool isCallCFGEdge() const
     {

package/SVF-osx/Release-build/include/Graphs/PTACallGraph.h

@@ -148,8 +148,8 @@ public:
     static inline bool classof(const GenericPTACallGraphEdgeTy *edge)
     {
         return edge->getEdgeKind() == PTACallGraphEdge::CallRetEdge ||
-        edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge ||
-        edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
+               edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge ||
+               edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
     }
     //@}
 
@@ -431,14 +431,14 @@ public:
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
-                   && "call instruction does not have a valid callee");
+               && "call instruction does not have a valid callee");
         return it->second.begin();
     }
     inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallICFGNode* inst) const
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
-                   && "call instruction does not have a valid callee");
+               && "call instruction does not have a valid callee");
         return it->second.end();
     }
     //@}

package/SVF-osx/Release-build/include/Graphs/SVFGEdge.h

@@ -72,16 +72,16 @@ public:
     static inline bool classof(const VFGEdge *edge)
     {
         return edge->getEdgeKind() == IntraIndirectVF  ||
-        edge->getEdgeKind() == CallIndVF ||
-        edge->getEdgeKind() == RetIndVF ||
-        edge->getEdgeKind() == TheadMHPIndirectVF;
+               edge->getEdgeKind() == CallIndVF ||
+               edge->getEdgeKind() == RetIndVF ||
+               edge->getEdgeKind() == TheadMHPIndirectVF;
     }
     static inline bool classof(const GenericVFGEdgeTy *edge)
     {
         return edge->getEdgeKind() == IntraIndirectVF  ||
-        edge->getEdgeKind() == CallIndVF ||
-        edge->getEdgeKind() == RetIndVF ||
-        edge->getEdgeKind() == TheadMHPIndirectVF;
+               edge->getEdgeKind() == CallIndVF ||
+               edge->getEdgeKind() == RetIndVF ||
+               edge->getEdgeKind() == TheadMHPIndirectVF;
     }
     //@}
 

package/SVF-osx/Release-build/include/Graphs/ThreadCallGraph.h

@@ -205,7 +205,7 @@ public:
     inline bool hasThreadForkEdge(const CallICFGNode* cs) const
     {
         return callinstToThreadForkEdgesMap.find(cs) !=
-                   callinstToThreadForkEdgesMap.end();
+               callinstToThreadForkEdgesMap.end();
     }
     inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallICFGNode* cs) const
     {

package/SVF-osx/Release-build/include/Graphs/VFGEdge.h

@@ -155,14 +155,14 @@ public:
     static inline bool classof(const VFGEdge *edge)
     {
         return edge->getEdgeKind() == IntraDirectVF  ||
-        edge->getEdgeKind() == CallDirVF ||
-        edge->getEdgeKind() == RetDirVF;
+               edge->getEdgeKind() == CallDirVF ||
+               edge->getEdgeKind() == RetDirVF;
     }
     static inline bool classof(const GenericVFGEdgeTy *edge)
     {
         return edge->getEdgeKind() == IntraDirectVF  ||
-        edge->getEdgeKind() == CallDirVF ||
-        edge->getEdgeKind() == RetDirVF;
+               edge->getEdgeKind() == CallDirVF ||
+               edge->getEdgeKind() == RetDirVF;
     }
     //@}
 

package/SVF-osx/Release-build/include/MSSA/MSSAMuChi.h

@@ -439,8 +439,8 @@ public:
     static inline bool classof(const MSSADEF *chi)
     {
         return chi->getType() == MSSADEF::EntryMSSACHI ||
-        chi->getType() == MSSADEF::StoreMSSACHI ||
-        chi->getType() == MSSADEF::SSACHI ;
+               chi->getType() == MSSADEF::StoreMSSACHI ||
+               chi->getType() == MSSADEF::SSACHI ;
     }
     //@}
 

package/SVF-osx/Release-build/include/MemoryModel/AbstractPointsToDS.h

@@ -180,8 +180,8 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == PTDataTy::Diff
-        || ptd->getPTDTY() == PTDataTy::MutDiff
-        || ptd->getPTDTY() == PTDataTy::PersDiff;
+               || ptd->getPTDTY() == PTDataTy::MutDiff
+               || ptd->getPTDTY() == PTDataTy::PersDiff;
     }
     ///@}
 };
@@ -254,10 +254,10 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == BasePTData::DataFlow
-        || ptd->getPTDTY() == BasePTData::MutDataFlow
-        || ptd->getPTDTY() == BasePTData::MutIncDataFlow
-        || ptd->getPTDTY() == BasePTData::PersDataFlow
-        || ptd->getPTDTY() == BasePTData::PersIncDataFlow;
+               || ptd->getPTDTY() == BasePTData::MutDataFlow
+               || ptd->getPTDTY() == BasePTData::MutIncDataFlow
+               || ptd->getPTDTY() == BasePTData::PersDataFlow
+               || ptd->getPTDTY() == BasePTData::PersIncDataFlow;
     }
     ///@}
 };
@@ -299,8 +299,8 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == PTDataTy::Versioned
-        || ptd->getPTDTY() == PTDataTy::MutVersioned
-        || ptd->getPTDTY() == PTDataTy::PersVersioned;
+               || ptd->getPTDTY() == PTDataTy::MutVersioned
+               || ptd->getPTDTY() == PTDataTy::PersVersioned;
     }
 private:
     using BasePTData::getPts;

package/SVF-osx/Release-build/include/MemoryModel/AccessPath.h

@@ -91,7 +91,7 @@ public:
     inline bool operator==(const AccessPath& rhs) const
     {
         return this->fldIdx == rhs.fldIdx &&
-        this->idxOperandPairs == rhs.idxOperandPairs && this->gepPointeeType == rhs.gepPointeeType;
+               this->idxOperandPairs == rhs.idxOperandPairs && this->gepPointeeType == rhs.gepPointeeType;
     }
     //@}
 

package/SVF-osx/Release-build/include/MemoryModel/MutablePointsToDS.h

@@ -589,7 +589,7 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == BaseDFPTData::MutDataFlow
-        || ptd->getPTDTY() == BaseDFPTData::MutIncDataFlow;
+               || ptd->getPTDTY() == BaseDFPTData::MutIncDataFlow;
     }
     ///@}
 

package/SVF-osx/Release-build/include/MemoryModel/PersistentPointsToDS.h

@@ -541,7 +541,7 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet> *ptd)
     {
         return ptd->getPTDTY() == PTDataTy::PersDataFlow
-        || ptd->getPTDTY() == PTDataTy::PersIncDataFlow;
+               || ptd->getPTDTY() == PTDataTy::PersIncDataFlow;
     }
     ///@}
 

package/SVF-osx/Release-build/include/SVF-LLVM/DCHG.h

@@ -321,7 +321,7 @@ public:
         }
 
         if (!(base->getTag() == dwarf::DW_TAG_class_type ||
-        base->getTag() == dwarf::DW_TAG_structure_type))
+                base->getTag() == dwarf::DW_TAG_structure_type))
         {
             return nullptr;
         }

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -233,10 +233,10 @@ inline const ConstantExpr* isTruncConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::Trunc ||
-        constExpr->getOpcode() == Instruction::FPTrunc ||
-        constExpr->getOpcode() == Instruction::ZExt ||
-        constExpr->getOpcode() == Instruction::SExt ||
-        constExpr->getOpcode() == Instruction::FPExt)
+                constExpr->getOpcode() == Instruction::FPTrunc ||
+                constExpr->getOpcode() == Instruction::ZExt ||
+                constExpr->getOpcode() == Instruction::SExt ||
+                constExpr->getOpcode() == Instruction::FPExt)
             return constExpr;
     }
     return nullptr;
@@ -247,7 +247,7 @@ inline const ConstantExpr* isCmpConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::ICmp ||
-        constExpr->getOpcode() == Instruction::FCmp)
+                constExpr->getOpcode() == Instruction::FCmp)
             return constExpr;
     }
     return nullptr;
@@ -297,7 +297,7 @@ void getNextInsts(const Instruction* curInst,
 inline bool isNoPrecessorBasicBlock(const BasicBlock* bb)
 {
     return bb != &bb->getParent()->getEntryBlock() &&
-                 pred_empty(bb);
+           pred_empty(bb);
 }
 
 /// Check whether a file is an LLVM IR file

package/SVF-osx/Release-build/include/SVFIR/SVFFileSystem.h

@@ -618,7 +618,7 @@ private:
 
     template <typename T,
               typename = std::enable_if_t<SVFUtil::is_iterable_v<T>>>
-    cJSON* toJson(const T& container)
+                                          cJSON* toJson(const T& container)
     {
         cJSON* array = jsonCreateArray();
         for (const auto& item : container)
@@ -790,7 +790,7 @@ public:
     template <typename FillFunc> void fillObjs(FillFunc fillFunc)
     {
         assert(jsonArray.size() == ptrPool.size() &&
-                                   "jsonArray and ptrPool should have same size");
+               "jsonArray and ptrPool should have same size");
         for (size_t i = 0; i < jsonArray.size(); ++i)
         {
             const cJSON*& objFieldJson = jsonArray[i];

package/SVF-osx/Release-build/include/SVFIR/SVFIR.h

@@ -216,7 +216,7 @@ public:
     inline bool hasPTASVFStmtList(const ICFGNode* inst) const
     {
         return icfgNode2PTASVFStmtsMap.find(inst) !=
-                   icfgNode2PTASVFStmtsMap.end();
+               icfgNode2PTASVFStmtsMap.end();
     }
     /// Given an instruction, get all its PAGEdges
     inline SVFStmtList& getSVFStmtList(const ICFGNode* inst)
@@ -625,16 +625,16 @@ private:
     inline NodeID addValNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-                              "Strategy::DBUG to SEQ or DENSE");
+               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+               "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a memory obj node
     inline NodeID addObjNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-                              "Strategy::DBUG to SEQ or DENSE");
+               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+               "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a unique return node for a procedure

package/SVF-osx/Release-build/include/SVFIR/SVFStatements.h

@@ -107,20 +107,20 @@ public:
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-        edge->getEdgeKind() == SVFStmt::Copy ||
-        edge->getEdgeKind() == SVFStmt::Store ||
-        edge->getEdgeKind() == SVFStmt::Load ||
-        edge->getEdgeKind() == SVFStmt::Call ||
-        edge->getEdgeKind() == SVFStmt::Ret ||
-        edge->getEdgeKind() == SVFStmt::Gep ||
-        edge->getEdgeKind() == SVFStmt::Phi ||
-        edge->getEdgeKind() == SVFStmt::Select ||
-        edge->getEdgeKind() == SVFStmt::Cmp ||
-        edge->getEdgeKind() == SVFStmt::BinaryOp ||
-        edge->getEdgeKind() == SVFStmt::UnaryOp ||
-        edge->getEdgeKind() == SVFStmt::Branch ||
-        edge->getEdgeKind() == SVFStmt::ThreadFork ||
-        edge->getEdgeKind() == SVFStmt::ThreadJoin;
+               edge->getEdgeKind() == SVFStmt::Copy ||
+               edge->getEdgeKind() == SVFStmt::Store ||
+               edge->getEdgeKind() == SVFStmt::Load ||
+               edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::Ret ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
+               edge->getEdgeKind() == SVFStmt::Phi ||
+               edge->getEdgeKind() == SVFStmt::Select ||
+               edge->getEdgeKind() == SVFStmt::Cmp ||
+               edge->getEdgeKind() == SVFStmt::BinaryOp ||
+               edge->getEdgeKind() == SVFStmt::UnaryOp ||
+               edge->getEdgeKind() == SVFStmt::Branch ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     ///@}
 
@@ -264,26 +264,26 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-        edge->getEdgeKind() == SVFStmt::Copy ||
-        edge->getEdgeKind() == SVFStmt::Store ||
-        edge->getEdgeKind() == SVFStmt::Load ||
-        edge->getEdgeKind() == SVFStmt::Call ||
-        edge->getEdgeKind() == SVFStmt::Ret ||
-        edge->getEdgeKind() == SVFStmt::Gep ||
-        edge->getEdgeKind() == SVFStmt::ThreadFork ||
-        edge->getEdgeKind() == SVFStmt::ThreadJoin;
+               edge->getEdgeKind() == SVFStmt::Copy ||
+               edge->getEdgeKind() == SVFStmt::Store ||
+               edge->getEdgeKind() == SVFStmt::Load ||
+               edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::Ret ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-        edge->getEdgeKind() == SVFStmt::Copy ||
-        edge->getEdgeKind() == SVFStmt::Store ||
-        edge->getEdgeKind() == SVFStmt::Load ||
-        edge->getEdgeKind() == SVFStmt::Call ||
-        edge->getEdgeKind() == SVFStmt::Ret ||
-        edge->getEdgeKind() == SVFStmt::Gep ||
-        edge->getEdgeKind() == SVFStmt::ThreadFork ||
-        edge->getEdgeKind() == SVFStmt::ThreadJoin;
+               edge->getEdgeKind() == SVFStmt::Copy ||
+               edge->getEdgeKind() == SVFStmt::Store ||
+               edge->getEdgeKind() == SVFStmt::Load ||
+               edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::Ret ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -633,12 +633,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-        edge->getEdgeKind() == SVFStmt::ThreadFork;
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-        edge->getEdgeKind() == SVFStmt::ThreadFork;
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     //@}
 
@@ -694,12 +694,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-        edge->getEdgeKind() == SVFStmt::ThreadJoin;
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-        edge->getEdgeKind() == SVFStmt::ThreadJoin;
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -763,12 +763,12 @@ public:
     static inline bool classof(const SVFStmt* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     static inline bool classof(const GenericPAGEdgeTy* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     //@}
     /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and
@@ -853,14 +853,14 @@ public:
         : MultiOpndStmt(s, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
     {
         assert(opnds.size() == icfgNodes.size() &&
-                               "Numbers of operands and their ICFGNodes are not consistent?");
+               "Numbers of operands and their ICFGNodes are not consistent?");
     }
     void addOpVar(SVFVar* op, const ICFGNode* inode)
     {
         opVars.push_back(op);
         opICFGNodes.push_back(inode);
         assert(opVars.size() == opICFGNodes.size() &&
-                                "Numbers of operands and their ICFGNodes are not consistent?");
+               "Numbers of operands and their ICFGNodes are not consistent?");
     }
 
     /// Return the corresponding ICFGNode of this operand

package/SVF-osx/Release-build/include/SVFIR/SVFValue.h

@@ -149,7 +149,7 @@ public:
     inline bool isUnreachable(const SVFBasicBlock* bb) const
     {
         return std::find(reachableBBs.begin(), reachableBBs.end(), bb) ==
-                   reachableBBs.end();
+               reachableBBs.end();
     }
 
     inline const BBList& getReachableBBs() const
@@ -215,7 +215,7 @@ protected:
     /// Constructor without name
     SVFValue(const SVFType* ty, SVFValKind k)
         : kind(k), ptrInUncalledFun(false),
-        constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
+          constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
     {
     }
 
@@ -551,7 +551,7 @@ protected:
     inline void addICFGNode(const ICFGNode* icfgNode)
     {
         assert(std::find(getICFGNodeList().begin(), getICFGNodeList().end(),
-        icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
+                         icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
         allICFGNodes.push_back(icfgNode);
     }
 
@@ -652,8 +652,8 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFInst ||
-        node->getKind() == SVFCall ||
-        node->getKind() == SVFVCall;
+               node->getKind() == SVFCall ||
+               node->getKind() == SVFVCall;
     }
 
     inline const SVFBasicBlock* getParent() const
@@ -759,12 +759,12 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConst ||
-        node->getKind() == SVFGlob ||
-        node->getKind() == SVFConstData ||
-        node->getKind() == SVFConstInt ||
-        node->getKind() == SVFConstFP ||
-        node->getKind() == SVFNullPtr ||
-        node->getKind() == SVFBlackHole;
+               node->getKind() == SVFGlob ||
+               node->getKind() == SVFConstData ||
+               node->getKind() == SVFConstInt ||
+               node->getKind() == SVFConstFP ||
+               node->getKind() == SVFNullPtr ||
+               node->getKind() == SVFBlackHole;
     }
 
 };
@@ -864,18 +864,18 @@ public:
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConstData ||
-        node->getKind() == SVFConstInt ||
-        node->getKind() == SVFConstFP ||
-        node->getKind() == SVFNullPtr ||
-        node->getKind() == SVFBlackHole;
+               node->getKind() == SVFConstInt ||
+               node->getKind() == SVFConstFP ||
+               node->getKind() == SVFNullPtr ||
+               node->getKind() == SVFBlackHole;
     }
     static inline bool classof(const SVFConstantData *node)
     {
         return node->getKind() == SVFConstData ||
-        node->getKind() == SVFConstInt ||
-        node->getKind() == SVFConstFP ||
-        node->getKind() == SVFNullPtr ||
-        node->getKind() == SVFBlackHole;
+               node->getKind() == SVFConstInt ||
+               node->getKind() == SVFConstFP ||
+               node->getKind() == SVFNullPtr ||
+               node->getKind() == SVFBlackHole;
     }
 };
 

package/SVF-osx/Release-build/include/SVFIR/SVFVariables.h

@@ -83,8 +83,8 @@ public:
     inline const SVFValue* getValue() const
     {
         assert(this->getNodeKind() != DummyValNode &&
-                                      this->getNodeKind() != DummyObjNode &&
-                                          "dummy node do not have value!");
+               this->getNodeKind() != DummyObjNode &&
+               "dummy node do not have value!");
         assert(!SymbolTableInfo::isBlkObjOrConstantObj(this->getId()) &&
                "blackhole and constant obj do not have value");
         assert(value && "value is null (GepObjNode whose basenode is a DummyObj?)");

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

@@ -98,30 +98,30 @@ using Set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 template <typename Key, typename Value, typename Hash = Hash<Key>,
           typename KeyEqual = std::equal_to<Key>,
           typename Allocator = std::allocator<std::pair<const Key, Value>>>
-using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
-
-template <typename Key, typename Compare = std::less<Key>,
-          typename Allocator = std::allocator<Key>>
-using OrderedSet = std::set<Key, Compare, Allocator>;
-
-template <typename Key, typename Value, typename Compare = std::less<Key>,
-          typename Allocator = std::allocator<std::pair<const Key, Value>>>
-using OrderedMap = std::map<Key, Value, Compare, Allocator>;
-
-typedef std::pair<NodeID, NodeID> NodePair;
-typedef OrderedSet<NodeID> OrderedNodeSet;
-typedef Set<NodeID> NodeSet;
-typedef Set<NodePair> NodePairSet;
-typedef Map<NodePair, NodeID> NodePairMap;
-typedef std::vector<NodeID> NodeVector;
-typedef std::vector<EdgeID> EdgeVector;
-typedef std::stack<NodeID> NodeStack;
-typedef std::list<NodeID> NodeList;
-typedef std::deque<NodeID> NodeDeque;
-typedef NodeSet EdgeSet;
-typedef std::vector<u32_t> CallStrCxt;
-typedef unsigned Version;
-typedef Set<Version> VersionSet;
-typedef std::pair<NodeID, Version> VersionedVar;
-typedef Set<VersionedVar> VersionedVarSet;
+              using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+          template <typename Key, typename Compare = std::less<Key>,
+                    typename Allocator = std::allocator<Key>>
+          using OrderedSet = std::set<Key, Compare, Allocator>;
+
+          template <typename Key, typename Value, typename Compare = std::less<Key>,
+                    typename Allocator = std::allocator<std::pair<const Key, Value>>>
+                        using OrderedMap = std::map<Key, Value, Compare, Allocator>;
+
+                    typedef std::pair<NodeID, NodeID> NodePair;
+                    typedef OrderedSet<NodeID> OrderedNodeSet;
+                    typedef Set<NodeID> NodeSet;
+                    typedef Set<NodePair> NodePairSet;
+                    typedef Map<NodePair, NodeID> NodePairMap;
+                    typedef std::vector<NodeID> NodeVector;
+                    typedef std::vector<EdgeID> EdgeVector;
+                    typedef std::stack<NodeID> NodeStack;
+                    typedef std::list<NodeID> NodeList;
+                    typedef std::deque<NodeID> NodeDeque;
+                    typedef NodeSet EdgeSet;
+                    typedef std::vector<u32_t> CallStrCxt;
+                    typedef unsigned Version;
+                    typedef Set<Version> VersionSet;
+                    typedef std::pair<NodeID, Version> VersionedVar;
+                    typedef Set<VersionedVar> VersionedVarSet;
 }

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

@@ -338,8 +338,8 @@ const SVFFunction* getProgEntryFunction();
 inline bool isProgExitFunction (const SVFFunction * fun)
 {
     return fun && (fun->getName() == "exit" ||
-    fun->getName() == "__assert_rtn" ||
-    fun->getName() == "__assert_fail" );
+                   fun->getName() == "__assert_rtn" ||
+                   fun->getName() == "__assert_fail" );
 }
 
 /// Return true if this argument belongs to an uncalled function
@@ -464,7 +464,7 @@ template <typename... Ts> using void_t = typename make_void<Ts...>::type;
 template <typename T, typename = void> struct is_iterable : std::false_type {};
 template <typename T>
 struct is_iterable<T, void_t<decltype(std::begin(std::declval<T&>()) !=
-        std::end(std::declval<T&>()))>>
+                                      std::end(std::declval<T&>()))>>
     : std::true_type {};
 template <typename T> constexpr bool is_iterable_v = is_iterable<T>::value;
 ///@}

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

@@ -388,7 +388,7 @@ public:
         unsigned BitPos = Curr % BITWORD_SIZE;
         BitWord Copy = Bits[WordPos];
         assert(WordPos <= BITWORDS_PER_ELEMENT
-                          && "Word Position outside of element");
+               && "Word Position outside of element");
 
         // Mask off previous bits.
         Copy &= ~0UL << BitPos;
@@ -552,13 +552,13 @@ class SparseBitVector
         else if (CurrElementIter->index() > ElementIndex)
         {
             while (ElementIter != Begin
-                                  && ElementIter->index() > ElementIndex)
+                    && ElementIter->index() > ElementIndex)
                 --ElementIter;
         }
         else
         {
             while (ElementIter != End &&
-                                  ElementIter->index() < ElementIndex)
+                    ElementIter->index() < ElementIndex)
                 ++ElementIter;
         }
         CurrElementIter = ElementIter;
@@ -758,7 +758,7 @@ public:
         // If we can't find an element that is supposed to contain this bit, there
         // is nothing more to do.
         if (ElementIter == Elements.end() ||
-                           ElementIter->index() != ElementIndex)
+                ElementIter->index() != ElementIndex)
             return false;
         return ElementIter->test(Idx % ElementSize);
     }
@@ -774,7 +774,7 @@ public:
         // If we can't find an element that is supposed to contain this bit, there
         // is nothing more to do.
         if (ElementIter == Elements.end() ||
-                           ElementIter->index() != ElementIndex)
+                ElementIter->index() != ElementIndex)
             return;
         ElementIter->reset(Idx % ElementSize);
 
@@ -799,13 +799,13 @@ public:
             ElementIter = FindLowerBound(ElementIndex);
 
             if (ElementIter == Elements.end() ||
-                               ElementIter->index() != ElementIndex)
+                    ElementIter->index() != ElementIndex)
             {
                 // We may have hit the beginning of our SparseBitVector, in which case,
                 // we may need to insert right after this element, which requires moving
                 // the current iterator forward one, because insert does insert before.
                 if (ElementIter != Elements.end() &&
-                                   ElementIter->index() < ElementIndex)
+                        ElementIter->index() < ElementIndex)
                     ++ElementIter;
                 ElementIter = Elements.emplace(ElementIter, ElementIndex);
             }

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

@@ -173,7 +173,7 @@ public:
             IsRandomAccess,
             "Relational operators are only defined for random access iterators.");
         return !(static_cast<const DerivedT &>(*this) < RHS) &&
-        !(static_cast<const DerivedT &>(*this) == RHS);
+               !(static_cast<const DerivedT &>(*this) == RHS);
     }
     bool operator<=(const DerivedT &RHS) const
     {

package/SVF-osx/Release-build/include/WPA/Andersen.h

@@ -109,12 +109,12 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return ( pta->getAnalysisTy() == Andersen_BASE
-        || pta->getAnalysisTy() == Andersen_WPA
-        || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-        || pta->getAnalysisTy() == AndersenSCD_WPA
-        || pta->getAnalysisTy() == AndersenSFR_WPA
-        || pta->getAnalysisTy() == TypeCPP_WPA
-        || pta->getAnalysisTy() == Steensgaard_WPA);
+                 || pta->getAnalysisTy() == Andersen_WPA
+                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+                 || pta->getAnalysisTy() == AndersenSCD_WPA
+                 || pta->getAnalysisTy() == AndersenSFR_WPA
+                 || pta->getAnalysisTy() == TypeCPP_WPA
+                 || pta->getAnalysisTy() == Steensgaard_WPA);
     }
     //@}
 
@@ -229,9 +229,9 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return (pta->getAnalysisTy() == Andersen_WPA
-        || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-        || pta->getAnalysisTy() == AndersenSCD_WPA
-        || pta->getAnalysisTy() == AndersenSFR_WPA);
+                || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+                || pta->getAnalysisTy() == AndersenSCD_WPA
+                || pta->getAnalysisTy() == AndersenSFR_WPA);
     }
     //@}
 

package/package.json

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