svf-lib 1.0.1621 → 1.0.1622

package/SVF-linux/svf/include/AbstractExecution/ConsExeState.h

@@ -42,7 +42,7 @@ namespace SVF
  *         /    /   |   \  \    \
  *       true ...  c0  c1 ...  false        constant
  *         \    \   \   |  |    |
- *                   ⊥                      not contant
+ *                   ⊥                      not constant
  */
 class ConsExeState final : public ExeState
 {

package/SVF-linux/svf/include/AbstractExecution/IntervalExeState.h

@@ -264,7 +264,7 @@ public:
         return (s32_t) e.lb().getNumeral();
     }
 
-    ///TODO: Create new inteval value
+    ///TODO: Create new interval value
     IntervalValue createIntervalValue(double lb, double ub, NodeID id)
     {
         _varToItvVal[id] = IntervalValue(lb, ub);

package/SVF-linux/svf/include/AbstractExecution/IntervalValue.h

@@ -473,7 +473,7 @@ inline IntervalValue operator+(const IntervalValue &lhs,
     }
 }
 
-/// Substract IntervalValues
+/// Subtract IntervalValues
 inline IntervalValue operator-(const IntervalValue &lhs,
                                const IntervalValue &rhs)
 {

package/SVF-linux/svf/include/AbstractExecution/SymState.h

@@ -60,7 +60,7 @@ public:
     /// Constructor
     SymState(ConsExeState _es, TypeState _as);
 
-    /// Desstructor
+    /// Destructor
     virtual ~SymState() = default;
 
     /// Copy Constructor

package/SVF-linux/svf/include/CFL/CFGrammar.h

@@ -48,7 +48,7 @@ public:
         /// Default Value for Symbol is 0.
         Symbol() : kind(0), attribute(0), variableAttribute(0) {}
 
-        /// Contruct from u32_t move the bit to right field
+        /// Construct from u32_t move the bit to right field
         Symbol(const u32_t& num) : kind(num & 0xFF), attribute((num >> 8 ) & 0xFFFF), variableAttribute((num >> 24)) {}
 
         /// Conversion of u32_t

package/SVF-linux/svf/include/CFL/GrammarBuilder.h

@@ -49,7 +49,7 @@ namespace SVF
  *
  * Production Format:
  *      <symbol> -> <symbol> *;
- *      LHS and RHS, Seperate by '->', symbol seperate by ' ', end by ';'
+ *      LHS and RHS, Separate by '->', symbol separate by ' ', end by ';'
  *      support '*', '?', '(', ')'
  *
  * Input Format:
@@ -57,10 +57,10 @@ namespace SVF
  *      M                   // Specify Start Symbol in Second Line
  *      Terminal:
  *      Addr Copy Store Load Gep Vgep // Specify the order of terminal Addr->0, Copy->1 ..
- *      Productions:        // Each Symbol seperate by 'Space', production end with ';'
+ *      Productions:        // Each Symbol separate by 'Space', production end with ';'
  *      M -> V d;           // Terminal in NonCapital
  *      M -> dbar V d;      // NonTerminal in Capital
- *      V -> M abar M a M;  // LHS and RHS, Seperate by '->'
+ *      V -> M abar M a M;  // LHS and RHS, Separate by '->'
  *      V -> ( M ? abar ) * M ? ( a M ? ) *;    // Support '(' ')' '?' '*' four regular expression sign
  *      Gep_j -> Gep_i F vgep; // Support variable attribute with variable attribute
  *      Gep_1 -> Gep_2;      // Support fix number attribute

package/SVF-linux/svf/include/FastCluster/fastcluster.h

@@ -1,5 +1,5 @@
 //
-// C++ standalone verion of fastcluster by Daniel Muellner
+// C++ standalone version of fastcluster by Daniel Muellner
 //
 // Copyright: Daniel Muellner, 2011
 //            Christoph Dalitz, 2020
@@ -25,7 +25,7 @@ void cutree_k(int n, const int* merge, int nclust, int* labels);
 
 //
 // Assigns cluster labels (0, ..., nclust-1) to the n points such
-// that the hierarchical clsutering is stopped at cluster distance cdist
+// that the hierarchical clustering is stopped at cluster distance cdist
 //
 // Input arguments:
 //   n      = number of observables
@@ -53,7 +53,7 @@ void cutree_cdist(int n, const int* merge, double* height, double cdist, int* la
 // Output arguments:
 //   merge   = allocated (n-1)x2 matrix (2*(n-1) array) for storing result.
 //             Result follows R hclust convention:
-//              - observabe indices start with one
+//              - observable indices start with one
 //              - merge[i][] contains the merged nodes in step i
 //              - merge[i][j] is negative when the node is an atom
 //   height  = allocated (n-1) array with distances at each merge step
@@ -68,7 +68,7 @@ enum hclust_fast_methods
     HCLUST_METHOD_SINGLE = 0,
     // complete link with the nearest-neighbor-chain algorithm (Murtagh, 1984)
     HCLUST_METHOD_COMPLETE = 1,
-    // omplete link with the nearest-neighbor-chain algorithm (Murtagh, 1984)
+    // complete link with the nearest-neighbor-chain algorithm (Murtagh, 1984)
     HCLUST_METHOD_AVERAGE = 2,
     // median link with the generic algorithm (Müllner, 2011)
     HCLUST_METHOD_MEDIAN = 3,

package/SVF-linux/svf/include/Graphs/CHG.h

@@ -1,4 +1,4 @@
-//===----- CHG.h -- Class hirachary graph  ---------------------------//
+//===----- CHG.h -- Class hierarchy graph  ---------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //

package/SVF-linux/svf/include/Graphs/ConsG.h

@@ -72,7 +72,7 @@ protected:
         return pag->getPTASVFStmtSet(kind);
     }
 
-    /// Wappers used internally, not expose to Andernsen Pass
+    /// Wrappers used internally, not expose to Andersen Pass
     //@{
     inline NodeID getValueNode(const SVFValue* value) const
     {
@@ -214,9 +214,9 @@ public:
 
     /// Used for cycle elimination
     //@{
-    /// Remove edge from old dst target, change edge dst id and add modifed edge into new dst
+    /// Remove edge from old dst target, change edge dst id and add modified edge into new dst
     void reTargetDstOfEdge(ConstraintEdge* edge, ConstraintNode* newDstNode);
-    /// Remove edge from old src target, change edge dst id and add modifed edge into new src
+    /// Remove edge from old src target, change edge dst id and add modified edge into new src
     void reTargetSrcOfEdge(ConstraintEdge* edge, ConstraintNode* newSrcNode);
     /// Remove addr edge from their src and dst edge sets
     void removeAddrEdge(AddrCGEdge* edge);

package/SVF-linux/svf/include/Graphs/GenericGraph.h

@@ -248,7 +248,7 @@ public:
     }
     //@}
 
-    /// Iterators used for SCC detection, overwrite it in child class if necessory
+    /// Iterators used for SCC detection, overwrite it in child class if necessary
     //@{
     virtual inline iterator directOutEdgeBegin()
     {
@@ -460,7 +460,7 @@ public:
 
 /* !
  * GenericGraphTraits specializations for generic graph algorithms.
- * Provide graph traits for tranversing from a node using standard graph traversals.
+ * Provide graph traits for traversing from a node using standard graph traversals.
  */
 namespace SVF
 {

package/SVF-linux/svf/include/Graphs/GraphTraits.h

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines the little GenericGraphTraits<X> template class that should be
-// specialized by classes that want to be iteratable by generic graph iterators.
+// specialized by classes that want to be iterable by generic graph iterators.
 //
 // This file also defines the marker class Inverse that is used to iterate over
 // graphs in a graph defined, inverse ordering...

package/SVF-linux/svf/include/Graphs/GraphWriter.h

@@ -301,7 +301,7 @@ public:
                   const void *DestNodeID, int DestNodePort,
                   const std::string &Attrs)
     {
-        if (SrcNodePort  > 64) return;             // Eminating from truncated part?
+        if (SrcNodePort  > 64) return;             // Emanating from truncated part?
         if (DestNodePort > 64) DestNodePort = 64;  // Targeting the truncated part?
 
         O << "\tNode" << SrcNodeID;

package/SVF-linux/svf/include/Graphs/IRGraph.h

@@ -233,7 +233,7 @@ namespace SVF
 
 /* !
  * GenericGraphTraits specializations of SVFIR to be used for the generic graph algorithms.
- * Provide graph traits for tranversing from a SVFIR node using standard graph traversals.
+ * Provide graph traits for traversing from a SVFIR node using standard graph traversals.
  */
 template<> struct GenericGraphTraits<SVF::SVFVar*> : public GenericGraphTraits<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>*  >
 {

package/SVF-linux/svf/include/Graphs/PTACallGraph.h

@@ -373,7 +373,7 @@ public:
         return getCallSitePair(id).second;
     }
     //@}
-    /// Whether we have aleady created this call graph edge
+    /// Whether we have already created this call graph edge
     PTACallGraphEdge* hasGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,PTACallGraphEdge::CEDGEK kind, CallSiteID csId) const;
     /// Get call graph edge via nodes
     PTACallGraphEdge* getGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,PTACallGraphEdge::CEDGEK kind, CallSiteID csId);

package/SVF-linux/svf/include/Graphs/VFGNode.h

@@ -841,7 +841,7 @@ public:
 };
 
 /*
- * ICFG Node stands for acutal parameter node (top level pointers)
+ * ICFG Node stands for actual parameter node (top level pointers)
  */
 class ActualParmVFGNode : public ArgumentVFGNode
 {
@@ -962,7 +962,7 @@ public:
 };
 
 /*!
- * Callsite receive paramter
+ * Callsite receive parameter
  */
 class ActualRetVFGNode: public ArgumentVFGNode
 {

package/SVF-linux/svf/include/MSSA/MSSAMuChi.h

@@ -341,7 +341,7 @@ protected:
     MRVer* resVer;
 
 public:
-    /// Constructor/Destructer for MSSADEF
+    /// Constructor/Destructor for MSSADEF
     //@{
     MSSADEF(DEFTYPE t, const MemRegion* m): type(t), mr(m), resVer(nullptr)
     {
@@ -401,7 +401,7 @@ private:
     Cond cond;
 public:
     typedef typename MSSADEF::DEFTYPE CHITYPE;
-    /// Constructor/Destructer for MSSACHI
+    /// Constructor/Destructor for MSSACHI
     //@{
     MSSACHI(CHITYPE t, const MemRegion* m, Cond c): MSSADEF(t,m), opVer(nullptr), cond(c)
     {

package/SVF-linux/svf/include/MSSA/MemRegion.h

@@ -107,7 +107,7 @@ public:
     }
 
     /// add the hash function here to sort elements and remove
-    /// and remove duplicated element in the set (binary tree comparision)
+    /// and remove duplicated element in the set (binary tree comparison)
     //@{
     typedef struct equalMemRegion
     {

package/SVF-linux/svf/include/MSSA/MemSSA.h

@@ -124,7 +124,7 @@ protected:
 
     /// Create mu chi for candidate regions in a function
     virtual void createMUCHI(const SVFFunction& fun);
-    /// Insert phi for candidate regions in a fucntion
+    /// Insert phi for candidate regions in a function
     virtual void insertPHI(const SVFFunction& fun);
     /// SSA rename for a function
     virtual void SSARename(const SVFFunction& fun);

package/SVF-linux/svf/include/MTA/FSMPTA.h

@@ -223,7 +223,7 @@ public:
         return mhp->getTCT()->getPTA()->getPAG();
     }
 
-    /// Create signle instance of flow-sensitive pointer analysis
+    /// Create single instance of flow-sensitive pointer analysis
     static FSMPTA* createFSMPTA(SVFModule* module, MHP* m, LockAnalysis* la)
     {
         if (mfspta == nullptr)

package/SVF-linux/svf/include/MTA/MHP.h

@@ -207,7 +207,7 @@ private:
     void updateSiblingThreads(NodeID tid);
     //@}
 
-    /// Thread curTid can be fully joined by parentTid recurively
+    /// Thread curTid can be fully joined by parentTid recursively
     bool isRecurFullJoin(NodeID parentTid, NodeID curTid);
 
     /// Whether a join site must join a thread t

package/SVF-linux/svf/include/MTA/TCT.h

@@ -193,7 +193,7 @@ public:
     {
         return getGNode(id);
     }
-    /// Whether we have aleady created this call graph edge
+    /// Whether we have already created this call graph edge
     TCTEdge* hasGraphEdge(TCTNode* src, TCTNode* dst, TCTEdge::CEDGEK kind) const;
     /// Get call graph edge via nodes
     TCTEdge* getGraphEdge(TCTNode* src, TCTNode* dst, TCTEdge::CEDGEK kind);

package/SVF-linux/svf/include/MemoryModel/ConditionalPT.h

@@ -327,7 +327,7 @@ public:
         _condPts = cptsSet.pointsTo();
     }
 
-    /// Get Conditional PointsTo and starndard points-to
+    /// Get Conditional PointsTo and standard points-to
     //@{
     inline CondPts &pointsTo(void)
     {

package/SVF-linux/svf/include/MemoryModel/MutablePointsToDS.h

@@ -848,7 +848,7 @@ private:
             return it->second.test(var);
         return false;
     }
-    /// Get all var which have new pts informationin loc's IN set
+    /// Get all var which have new pts information in loc's IN set
     inline const DataSet& getDFInUpdatedVar(LocID loc)
     {
         return inUpdatedVarMap[loc];
@@ -877,7 +877,7 @@ private:
             return it->second.test(var);
         return false;
     }
-    /// Get all var which have new pts informationin loc's OUT set
+    /// Get all var which have new pts information in loc's OUT set
     inline const DataSet& getDFOutUpdatedVar(LocID loc)
     {
         return outUpdatedVarMap[loc];

package/SVF-linux/svf/include/MemoryModel/PersistentPointsToDS.h

@@ -754,7 +754,7 @@ private:
         return false;
     }
 
-    /// Get all variables which have new pts informationin loc's IN set
+    /// Get all variables which have new pts information in loc's IN set
     inline const KeySet& getDFInUpdatedVar(LocID loc)
     {
         return inUpdatedVarMap[loc];

package/SVF-linux/svf/include/MemoryModel/PointerAnalysis.h

@@ -76,7 +76,7 @@ public:
         VFS_WPA,		///< Versioned sparse flow-sensitive WPA
         FSCS_WPA,			///< Flow-, context- sensitive WPA
         CFLFICI_WPA,		///< Flow-, context-, insensitive CFL-reachability-based analysis
-        CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive  CFL-reachability-based analysis
+        CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive CFL-reachability-based analysis
         CFLFSCS_WPA,	///< Flow-, context-, CFL-reachability-based analysis
         TypeCPP_WPA, ///<  Type-based analysis for C++
 

package/SVF-linux/svf/include/MemoryModel/PointsTo.h

@@ -112,7 +112,7 @@ public:
     /// Returns true if this set changed.
     bool intersectWithComplement(const PointsTo &rhs);
 
-    /// Put intersection of lhs with complemenet of rhs into this set (overwrites).
+    /// Put intersection of lhs with complement of rhs into this set (overwrites).
     void intersectWithComplement(const PointsTo &lhs, const PointsTo &rhs);
 
     /// Returns this points-to set as a NodeBS.

package/SVF-linux/svf/include/SABER/SaberCondAllocator.h

@@ -255,7 +255,7 @@ private:
     //@}
     /// Evaluate branch conditions
     //@{
-    /// Evaluate the branch condtion
+    /// Evaluate the branch condition
     Condition evaluateBranchCond(const SVFBasicBlock*  bb, const SVFBasicBlock* succ) ;
     /// Evaluate loop exit branch
     Condition evaluateLoopExitBranch(const SVFBasicBlock*  bb, const SVFBasicBlock* succ);

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

@@ -313,7 +313,7 @@ protected:
     {
         return _curSlice->isPartialReachable();
     }
-    /// Dump SVFG with annotated slice informaiton
+    /// Dump SVFG with annotated slice information
     //@{
     void dumpSlices();
     void annotateSlice(ProgSlice* slice);

package/SVF-linux/svf/include/SVFIR/SVFFileSystem.h

@@ -586,7 +586,7 @@ private:
     }
 
     /** The following 2 functions are intended to convert SparseBitVectors
-     * to JSON. But they're buggy. Commentting them out would enable the
+     * to JSON. But they're buggy. Commenting them out would enable the
      * toJson(T) where is_iterable_v<T> is true. But that implementation is less
      * space-efficient if the bitvector contains many elements.
      * It is observed that upon construction, SVF IR bitvectors contain at most
@@ -1147,7 +1147,7 @@ private:
         if (!basePtr)
             return; // ptr is nullptr when read
         ptr = SVFUtil::dyn_cast<T>(basePtr);
-        ABORT_IFNOT(ptr, "Cast: " << obj->string << " shoudn't have kind "
+        ABORT_IFNOT(ptr, "Cast: " << obj->string << " shouldn't have kind "
                     << KindBaseHelper<T>::getKind(ptr));
     }
 
@@ -1201,7 +1201,7 @@ private:
     std::enable_if_t<SVFUtil::is_map_v<C>> readJson(const cJSON* obj, C& map)
     {
         assert(map.empty() && "map should be empty");
-        ABORT_IFNOT(jsonIsMap(obj), "expects an map (represted by array)");
+        ABORT_IFNOT(jsonIsMap(obj), "expects an map (represented by array)");
         jsonForEach(elemJson, obj)
         {
             auto jpair = jsonUnpackPair(elemJson);

package/SVF-linux/svf/include/SVFIR/SVFIR.h

@@ -327,7 +327,7 @@ public:
     }
     //@}
 
-    /// Due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValVar.
+    /// Due to constraint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValVar.
     NodeID getGepValVar(const SVFValue* curInst, NodeID base,
                         const AccessPath& ap) const;
 

package/SVF-linux/svf/include/SVFIR/SVFStatements.h

@@ -232,7 +232,7 @@ private:
 /*
  Parent class of Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, ThreadFork, ThreadJoin
  connecting RHS expression and LHS expression with an assignment  (e.g., LHSExpr = RHSExpr)
- Only one operand on the right handside of an assignment
+ Only one operand on the right hand side of an assignment
 */
 class AssignStmt : public SVFStmt
 {
@@ -251,7 +251,7 @@ private:
 protected:
     /// constructor
     AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k) : SVFStmt(s, d, k) {}
-    /// Constructor to create empty AssignStmt (for SVFIRReader/serilization)
+    /// Constructor to create empty AssignStmt (for SVFIRReader/serialization)
     AssignStmt(GEdgeFlag k) : SVFStmt(k) {}
 
 public:
@@ -316,7 +316,7 @@ class AddrStmt: public AssignStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty AddrStmt (for SVFIRReader/serilization)
+    /// Constructs empty AddrStmt (for SVFIRReader/serialization)
     AddrStmt() : AssignStmt(SVFStmt::Addr) {}
     AddrStmt(const AddrStmt&);       ///< place holder
     void operator=(const AddrStmt&); ///< place holder
@@ -353,7 +353,7 @@ class CopyStmt: public AssignStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty CopyStmt (for SVFIRReader/serilization)
+    /// Constructs empty CopyStmt (for SVFIRReader/serialization)
     CopyStmt() : AssignStmt(SVFStmt::Copy) {}
     CopyStmt(const CopyStmt&);       ///< place holder
     void operator=(const CopyStmt&); ///< place holder
@@ -389,7 +389,7 @@ class StoreStmt: public AssignStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty StoreStmt (for SVFIRReader/serilization)
+    /// Constructs empty StoreStmt (for SVFIRReader/serialization)
     StoreStmt() : AssignStmt(SVFStmt::Store) {}
     StoreStmt(const StoreStmt&);      ///< place holder
     void operator=(const StoreStmt&); ///< place holder
@@ -426,7 +426,7 @@ class LoadStmt: public AssignStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty LoadStmt (for SVFIRReader/serilization)
+    /// Constructs empty LoadStmt (for SVFIRReader/serialization)
     LoadStmt(): AssignStmt(SVFStmt::Load) {}
     LoadStmt(const LoadStmt&);       ///< place holder
     void operator=(const LoadStmt&); ///< place holder
@@ -463,7 +463,7 @@ class GepStmt: public AssignStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty GepStmt (for SVFIRReader/serilization)
+    /// Constructs empty GepStmt (for SVFIRReader/serialization)
     GepStmt() : AssignStmt(SVFStmt::Gep) {}
     GepStmt(const GepStmt &);  ///< place holder
     void operator=(const GepStmt &); ///< place holder
@@ -543,7 +543,7 @@ private:
     const CallICFGNode* call;      /// the callsite statement calling from
     const FunEntryICFGNode* entry; /// the function exit statement calling to
 protected:
-    /// Constructs empty CallPE (for SVFIRReader/serilization)
+    /// Constructs empty CallPE (for SVFIRReader/serialization)
     CallPE(GEdgeFlag k = SVFStmt::Call) : AssignStmt(k), call{}, entry{} {}
 
 public:
@@ -604,7 +604,7 @@ private:
     const FunExitICFGNode* exit; /// the function exit statement returned from
 
 protected:
-    /// Constructs empty RetPE (for SVFIRReader/serilization)
+    /// Constructs empty RetPE (for SVFIRReader/serialization)
     RetPE(GEdgeFlag k = SVFStmt::Ret) : AssignStmt(k), call{}, exit{} {}
 
 public:
@@ -671,9 +671,9 @@ private:
 
 protected:
     OPVars opVars;
-    /// Constructor, only used by subclassess but not external users
+    /// Constructor, only used by subclasses but not external users
     MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k);
-    /// Constructs empty MultiOpndStmt (for SVFIRReader/serilization)
+    /// Constructs empty MultiOpndStmt (for SVFIRReader/serialization)
     MultiOpndStmt(GEdgeFlag k) : SVFStmt(k) {}
 
 public:
@@ -743,7 +743,7 @@ public:
     typedef std::vector<const ICFGNode*> OpICFGNodeVec;
 
 private:
-    /// Constructs empty PhiStmt (for SVFIRReader/serilization)
+    /// Constructs empty PhiStmt (for SVFIRReader/serialization)
     PhiStmt() : MultiOpndStmt(SVFStmt::Phi) {}
     PhiStmt(const PhiStmt&);        ///< place holder
     void operator=(const PhiStmt&); ///< place holder
@@ -808,7 +808,7 @@ class SelectStmt: public MultiOpndStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty SelectStmt (for SVFIRReader/serilization)
+    /// Constructs empty SelectStmt (for SVFIRReader/serialization)
     SelectStmt() : MultiOpndStmt(SVFStmt::Select), condition{} {}
     SelectStmt(const SelectStmt&);     ///< place holder
     void operator=(const SelectStmt&); ///< place holder
@@ -863,7 +863,7 @@ class CmpStmt: public MultiOpndStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty CmpStmt (for SVFIRReader/serilization)
+    /// Constructs empty CmpStmt (for SVFIRReader/serialization)
     CmpStmt() : MultiOpndStmt(SVFStmt::Cmp) {}
     CmpStmt(const CmpStmt&);        ///< place holder
     void operator=(const CmpStmt&); ///< place holder
@@ -949,7 +949,7 @@ class BinaryOPStmt: public MultiOpndStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty BinaryOPStmt (for SVFIRReader/serilization)
+    /// Constructs empty BinaryOPStmt (for SVFIRReader/serialization)
     BinaryOPStmt() : MultiOpndStmt(SVFStmt::BinaryOp) {}
     BinaryOPStmt(const BinaryOPStmt&);   ///< place holder
     void operator=(const BinaryOPStmt&); ///< place holder
@@ -1019,7 +1019,7 @@ class UnaryOPStmt: public SVFStmt
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty UnaryOPStmt (for SVFIRReader/serilization)
+    /// Constructs empty UnaryOPStmt (for SVFIRReader/serialization)
     UnaryOPStmt() : SVFStmt(SVFStmt::UnaryOp) {}
     UnaryOPStmt(const UnaryOPStmt&);    ///< place holder
     void operator=(const UnaryOPStmt&); ///< place holder
@@ -1089,7 +1089,7 @@ public:
     typedef std::vector<std::pair<const ICFGNode*, s32_t>> SuccAndCondPairVec;
 
 private:
-    /// Constructs empty BranchStmt (for SVFIRReader/serilization)
+    /// Constructs empty BranchStmt (for SVFIRReader/serialization)
     BranchStmt() : SVFStmt(SVFStmt::Branch), cond{}, brInst{} {}
     BranchStmt(const BranchStmt&);     ///< place holder
     void operator=(const BranchStmt&); ///< place holder
@@ -1176,7 +1176,7 @@ class TDForkPE: public CallPE
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty TDForkPE (for SVFIRReader/serilization)
+    /// Constructs empty TDForkPE (for SVFIRReader/serialization)
     TDForkPE() : CallPE(SVFStmt::ThreadFork) {}
     TDForkPE(const TDForkPE&);       ///< place holder
     void operator=(const TDForkPE&); ///< place holder
@@ -1217,7 +1217,7 @@ class TDJoinPE: public RetPE
     friend class SVFIRReader;
 
 private:
-    /// Constructs empty TDJoinPE (for SVFIRReader/serilization)
+    /// Constructs empty TDJoinPE (for SVFIRReader/serialization)
     TDJoinPE() : RetPE(SVFStmt::ThreadJoin) {}
     TDJoinPE(const TDJoinPE&);       ///< place holder
     void operator=(const TDJoinPE&); ///< place holder

package/SVF-linux/svf/include/SVFIR/SVFType.h

@@ -147,9 +147,9 @@ private:
     /// stride represents the number of repetitive elements if this StInfo
     /// represent an ArrayType. stride is 1 by default.
     u32_t stride;
-    /// number of elements after flattenning (including array elements)
+    /// number of elements after flattening (including array elements)
     u32_t numOfFlattenElements;
-    /// number of fields after flattenning (ignoring array elements)
+    /// number of fields after flattening (ignoring array elements)
     u32_t numOfFlattenFields;
     /// Type vector of fields
     std::vector<const SVFType*> flattenElementTypes;
@@ -214,20 +214,20 @@ public:
     /// Add field index and element index and their corresponding type
     void addFldWithType(u32_t fldIdx, const SVFType* type, u32_t elemIdx);
 
-    /// Set number of fields and elements of an aggrate
+    /// Set number of fields and elements of an aggregate
     inline void setNumOfFieldsAndElems(u32_t nf, u32_t ne)
     {
         numOfFlattenFields = nf;
         numOfFlattenElements = ne;
     }
 
-    /// Return number of elements after flattenning (including array elements)
+    /// Return number of elements after flattening (including array elements)
     inline u32_t getNumOfFlattenElements() const
     {
         return numOfFlattenElements;
     }
 
-    /// Return the number of fields after flattenning (ignoring array elements)
+    /// Return the number of fields after flattening (ignoring array elements)
     inline u32_t getNumOfFlattenFields() const
     {
         return numOfFlattenFields;

package/SVF-linux/svf/include/SVFIR/SVFValue.h

@@ -946,7 +946,7 @@ public:
     {
         return zval;
     }
-    // Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the type of this constan
+    // Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the type of this constant
     inline s64_t getSExtValue () const
     {
         return sval;

package/SVF-linux/svf/include/SVFIR/SVFVariables.h

@@ -56,8 +56,8 @@ public:
     /// ObjNode: memory object
     /// RetNode: unique return node
     /// Vararg: unique node for vararg parameter
-    /// GepValNode: tempory gep value node for field sensitivity
-    /// GepValNode: tempory gep obj node for field sensitivity
+    /// GepValNode: temporary gep value node for field sensitivity
+    /// GepValNode: temporary gep obj node for field sensitivity
     /// FIObjNode: for field insensitive analysis
     /// DummyValNode and DummyObjNode: for non-llvm-value node
     enum PNODEK
@@ -122,7 +122,7 @@ public:
     /// or llvm's metadata, i.e., metadata !4087
     bool isConstDataOrAggDataButNotNullPtr() const;
 
-    /// Whether this is an isoloated node on the SVFIR graph
+    /// Whether this is an isolated node on the SVFIR graph
     bool isIsolatedNode() const;
 
     /// Get name of the LLVM value

package/SVF-linux/svf/include/SVFIR/SymbolTableInfo.h

@@ -200,7 +200,7 @@ public:
         return BlackHole;
     }
 
-    /// Can only be invoked by SVFIR::addDummyNode() when creaing SVFIR from file.
+    /// Can only be invoked by SVFIR::addDummyNode() when creating SVFIR from file.
     const MemObj* createDummyObj(SymID symId, const SVFType* type);
     // @}
 
@@ -312,9 +312,9 @@ public:
     }
 
     ///Get a reference to the components of struct_info.
-    /// Number of flattenned elements of an array or struct
+    /// Number of flattened elements of an array or struct
     u32_t getNumOfFlattenElements(const SVFType* T);
-    /// Flatterned element idx of an array or struct by considering stride
+    /// Flattened element idx of an array or struct by considering stride
     u32_t getFlattenedElemIdx(const SVFType* T, u32_t origId);
     /// Return the type of a flattened element given a flattened index
     const SVFType* getFlatternedElemType(const SVFType* baseType, u32_t flatten_idx);

package/SVF-linux/svf/include/Util/Casting.h

@@ -62,7 +62,7 @@ namespace SVF
 namespace SVFUtil
 {
 
-//===- Part of llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===//
+//===- Part of llvm/Support/type_traits.h - Simplified type traits -------*- C++ -*-===//
 
 /// If T is a pointer to X, return a pointer to const X. If it is not,
 /// return const T.

package/SVF-linux/svf/include/Util/CoreBitVector.h

@@ -102,11 +102,11 @@ public:
     /// Returns true if CBV changed.
     bool operator-=(const CoreBitVector &rhs);
 
-    /// Put intersection of this CBV with complemenet of rhs into this CBV.
+    /// Put intersection of this CBV with complement of rhs into this CBV.
     /// Returns true if this CBV changed.
     bool intersectWithComplement(const CoreBitVector &rhs);
 
-    /// Put intersection of lhs with complemenet of rhs into this CBV.
+    /// Put intersection of lhs with complement of rhs into this CBV.
     void intersectWithComplement(const CoreBitVector &lhs, const CoreBitVector &rhs);
 
     /// Hash for this CBV.

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

@@ -37,7 +37,7 @@ namespace SVF
 {
 
 /*!
- * Dynamic programming item for CFL researchability search
+ * Dynamic programming item for CFL reachability search
  * This serves as a base class for CFL-reachability formulation by matching parentheses.
  * Extend this class for further sophisticated CFL-reachability items (e.g. field, flow, path)
  */

package/SVF-linux/svf/include/Util/NodeIDAllocator.h

@@ -184,7 +184,7 @@ public:
         /// x in pt(p) and y in pt(p) -> x is reachable from y.
         static inline std::vector<unsigned> regionObjects(const Map<NodeID, Set<NodeID>> &graph, size_t numObjects, size_t &numLabels);
 
-        // From all the candidates, returns the best mapping for pointsToSets (points-to set -> # occurences).
+        // From all the candidates, returns the best mapping for pointsToSets (points-to set -> # occurrences).
         static inline std::pair<hclust_fast_methods, std::vector<NodeID>> determineBestMapping(
                     const std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates,
                     Map<PointsTo, unsigned> pointsToSets, const std::string &evalSubtitle, double &evalTime);

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

@@ -61,7 +61,7 @@ public:
     /// Align identifiers in each region to a word.
     static const Option<bool> RegionAlign;
 
-    /// Predict occurences of points-to sets in the staged points-to set to
+    /// Predict occurrences of points-to sets in the staged points-to set to
     /// weigh more common points-to sets as more important.
     static const Option<bool> PredictPtOcc;
 

package/SVF-linux/svf/include/Util/SVFBugReport.h

@@ -387,7 +387,7 @@ public:
         }
         default:
         {
-            assert(false && "Abstract Execution does NOT hava his bug type!");
+            assert(false && "Abstract Execution does NOT have this bug type!");
             break;
         }
         }

package/SVF-linux/svf/include/Util/SVFUtil.h

@@ -202,7 +202,7 @@ inline CallSite getSVFCallSite(const SVFInstruction* inst)
 
 /// Match arguments for callsite at caller and callee
 /// if the arg size does not match then we do not need to connect this parameter
-/// unless the callee is a variadic function (the first parameter of variadic function is its paramter number)
+/// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
 bool matchArgs(const SVFInstruction* cs, const SVFFunction* callee);
 
 /// Return LLVM callsite given a value
@@ -304,7 +304,7 @@ bool startAnalysisLimitTimer(unsigned timeLimit);
 void stopAnalysisLimitTimer(bool limitTimerSet);
 
 /// Return true if the call is an external call (external library in function summary table)
-/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
+/// If the library function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
 //@{
 inline bool isExtCall(const SVFFunction* fun)
 {
@@ -643,7 +643,7 @@ inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
 }
 //@}
 
-/// Return the task data argument of the parallel_for rountine
+/// Return the task data argument of the parallel_for routine
 //@{
 inline const SVFValue* getTaskDataAtHareParForSite(const CallSite cs)
 {
@@ -672,7 +672,7 @@ move(T &&t) noexcept
     return std::move(t);
 }
 
-/// void_t is not avaiable until C++17. We define it here for C++11/14.
+/// void_t is not available until C++17. We define it here for C++11/14.
 template <typename... Ts> struct make_void
 {
     typedef void type;

package/SVF-linux/svf/include/Util/WorkList.h

@@ -221,7 +221,7 @@ private:
 };
 
 /**
- * Worlist with "first in last out" order.
+ * Worklist with "first in last out" order.
  * New nodes will be pushed at back and popped from back.
  * Elements in the list are unique as they're recorded by Set.
  */

package/SVF-linux/svf/include/Util/cJSON.h

@@ -111,7 +111,7 @@ typedef struct cJSON
     /* The type of the item, as above. */
     int type;
 
-    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    /* The item's string, if type==cJSON_String and type == cJSON_Raw */
     char *valuestring;
     /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
     int valueint;

package/SVF-linux/svf/include/WPA/Andersen.h

@@ -327,7 +327,7 @@ protected:
     void mergeSccNodes(NodeID repNodeId, const NodeBS& subNodes);
     void mergeSccCycle();
     //@}
-    /// Collapse a field object into its base for field insensitive anlaysis
+    /// Collapse a field object into its base for field insensitive analysis
     //@{
     virtual void collapsePWCNode(NodeID nodeId);
     void collapseFields();

package/SVF-linux/svf/include/WPA/FlowSensitive.h

@@ -75,7 +75,7 @@ public:
     /// Destructor
     ~FlowSensitive() override = default;
 
-    /// Create signle instance of flow-sensitive pointer analysis
+    /// Create single instance of flow-sensitive pointer analysis
     static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)

package/SVF-linux/svf/include/WPA/WPASolver.h

@@ -196,7 +196,7 @@ protected:
     WorkList worklist;
 
 public:
-    /// num of iterations during constaint solving
+    /// num of iterations during constraint solving
     u32_t numOfIteration;
 };
 

package/SVF-linux/svf-llvm/include/SVF-LLVM/GEPTypeBridgeIterator.h

@@ -89,7 +89,7 @@ public:
     }
 
     // non-standard operators, these may not need be bridged but seems it's
-    // predunt to do so...
+    // prudent to do so...
     Type* operator->() const
     {
         return operator*();

package/SVF-linux/svf-llvm/include/SVF-LLVM/SymbolTableBuilder.h

@@ -94,7 +94,7 @@ protected:
     void analyzeStaticObjType(ObjTypeInfo* typeinfo, const Value* val);
 
     ///Get a reference to the components of struct_info.
-    /// Number of flattenned elements of an array or struct
+    /// Number of flattened elements of an array or struct
     u32_t getNumOfFlattenElements(const Type* T);
 
     ///Get a reference to StructInfo.

package/package.json

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