svf-lib 1.0.992 → 1.0.993

package/SVF-linux/include/SVF-FE/IRAnnotator.h

@@ -33,7 +33,7 @@ public:
         this->ptsTo = ptsTo;
         mainModule = LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule();
 
-        // Add a named metadata node used to check whether or not 
+        // 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");
@@ -146,7 +146,7 @@ private:
     void processInstructionNode(Instruction *instruction, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "inode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = instruction->getContext();
@@ -164,7 +164,7 @@ private:
     void processArgumentNode(Argument *argument, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "anode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = argument->getContext();
@@ -182,7 +182,7 @@ private:
     void processFunctionNode(Function *function, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "fnode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = function->getContext();
@@ -200,7 +200,7 @@ private:
     void processGlobalVarNode(GlobalVariable *globalVar, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "gnode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = globalVar->getContext();
@@ -218,7 +218,7 @@ private:
     void processBasicBlockNode(BasicBlock *basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "bnode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = basicBlock->getContext();
@@ -236,7 +236,7 @@ private:
     void processConstantNode(const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "cnode-" + std::to_string(nodeId);
-        
+
         if (writeFlag)
         {
             LLVMContext &context = mainModule->getContext();
@@ -254,7 +254,7 @@ private:
     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();

package/SVF-linux/include/SVF-FE/LLVMModule.h

@@ -83,10 +83,11 @@ public:
     SVFModule* buildSVFModule(Module &mod);
     SVFModule* buildSVFModule(const std::vector<std::string> &moduleNameVec);
 
-	inline SVFModule* getSVFModule() {
-		assert(svfModule && "svfModule has not been built yet!");
-		return svfModule;
-	}
+    inline SVFModule* getSVFModule()
+    {
+        assert(svfModule && "svfModule has not been built yet!");
+        return svfModule;
+    }
 
     void preProcessBCs(std::vector<std::string> &moduleNameVec);
 
@@ -148,15 +149,15 @@ public:
 
     bool hasDeclaration(const SVFFunction *fun) const
     {
-    	if(fun->isDeclaration() && !hasDefinition(fun))
-    		return false;
+        if(fun->isDeclaration() && !hasDefinition(fun))
+            return false;
 
-    	const SVFFunction* funDef = fun;
+        const SVFFunction* funDef = fun;
         if(fun->isDeclaration() && hasDefinition(fun))
-        	funDef = getDefinition(fun);
+            funDef = getDefinition(fun);
 
-    	FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-    	return it != FunDefToDeclsMap.end();
+        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
+        return it != FunDefToDeclsMap.end();
     }
 
     const FunctionSetType& getDeclaration(const Function *fun) const
@@ -166,9 +167,9 @@ public:
 
     const FunctionSetType& getDeclaration(const SVFFunction *fun) const
     {
-    	const SVFFunction* funDef = fun;
+        const SVFFunction* funDef = fun;
         if(fun->isDeclaration() && hasDefinition(fun))
-        	funDef = getDefinition(fun);
+            funDef = getDefinition(fun);
 
         FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
         assert(it != FunDefToDeclsMap.end() && "does not have a function definition (body)?");

package/SVF-linux/include/SVF-FE/LLVMUtil.h

@@ -406,10 +406,10 @@ bool isObject (const Value * ref);
 /// Return true if the value refers to constant data, e.g., i32 0
 inline bool isConstantData(const Value* val)
 {
-	return SVFUtil::isa<ConstantData>(val)
-			|| SVFUtil::isa<ConstantAggregate>(val)
-			|| SVFUtil::isa<MetadataAsValue>(val)
-			|| SVFUtil::isa<BlockAddress>(val);
+    return SVFUtil::isa<ConstantData>(val)
+           || SVFUtil::isa<ConstantAggregate>(val)
+           || SVFUtil::isa<MetadataAsValue>(val)
+           || SVFUtil::isa<BlockAddress>(val);
 }
 
 /// Method for dead function, which does not have any possible caller

package/SVF-linux/include/SVF-FE/SVFIRBuilder.h

@@ -130,8 +130,9 @@ public:
     {
         visitCallSite(&II);
     }
-    void visitCallBrInst(CallBrInst &I) {
-      return visitCallSite(&I);
+    void visitCallBrInst(CallBrInst &I)
+    {
+        return visitCallSite(&I);
     }
     void visitCallSite(CallSite cs);
     void visitReturnInst(ReturnInst &I);
@@ -155,9 +156,9 @@ public:
     /// TODO: var arguments need to be handled.
     /// https://llvm.org/docs/LangRef.html#id1911
     void visitVAArgInst(VAArgInst&);
-    void visitVACopyInst(VACopyInst&){}
-    void visitVAEndInst(VAEndInst&){}
-    void visitVAStartInst(VAStartInst&){}
+    void visitVACopyInst(VACopyInst&) {}
+    void visitVAEndInst(VAEndInst&) {}
+    void visitVAStartInst(VAStartInst&) {}
 
     /// <result> = freeze ty <val>
     /// If <val> is undef or poison, ‘freeze’ returns an arbitrary, but fixed value of type `ty`
@@ -293,7 +294,8 @@ protected:
     /// Add Address edge
     inline AddrStmt* addAddrEdge(NodeID src, NodeID dst)
     {
-        if(AddrStmt *edge = pag->addAddrStmt(src, dst)){
+        if(AddrStmt *edge = pag->addAddrStmt(src, dst))
+        {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
@@ -302,7 +304,8 @@ protected:
     /// Add Copy edge
     inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
     {
-        if(CopyStmt *edge = pag->addCopyStmt(src, dst)){
+        if(CopyStmt *edge = pag->addCopyStmt(src, dst))
+        {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
@@ -339,8 +342,9 @@ protected:
         if(UnaryOPStmt *edge = pag->addUnaryOPStmt(src, dst, opcode))
             setCurrentBBAndValueForPAGEdge(edge);
     }
-    /// Add Branch statement 
-    inline void addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs){
+    /// Add Branch statement
+    inline void addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs)
+    {
         if(BranchStmt *edge = pag->addBranchStmt(br, cond, succs))
             setCurrentBBAndValueForPAGEdge(edge);
     }

package/SVF-linux/include/SVF-FE/SymbolTableBuilder.h

@@ -39,7 +39,7 @@
 namespace SVF
 {
 
-class SymbolTableBuilder 
+class SymbolTableBuilder
 {
 
 private:
@@ -47,7 +47,8 @@ private:
 
 public:
     /// Constructor
-    SymbolTableBuilder(SymbolTableInfo* si): symInfo(si){
+    SymbolTableBuilder(SymbolTableInfo* si): symInfo(si)
+    {
     }
 
     /// Start building memory model

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

@@ -36,9 +36,11 @@
 #include "CUDD/cuddInt.h"
 #include "z3++.h"
 
-namespace SVF {
+namespace SVF
+{
 
-class BDDExprManager {
+class BDDExprManager
+{
 public:
     typedef DdNode BDDExpr;
     typedef Map<u32_t, BDDExpr *> IndexToBDDExpr;
@@ -47,11 +49,13 @@ private:
     IndexToBDDExpr indexToBddCondMap;
     DdManager *m_bdd_mgr;
 
-    inline BDDExpr *BddOne() const {
+    inline BDDExpr *BddOne() const
+    {
         return Cudd_ReadOne(m_bdd_mgr);
     }
 
-    inline BDDExpr *BddZero() const {
+    inline BDDExpr *BddZero() const
+    {
         return Cudd_ReadLogicZero(m_bdd_mgr);
     }
 
@@ -65,7 +69,8 @@ public:
     //@{
     static BDDExprManager *getBDDExprMgr();
 
-    static void releaseBDDExprMgr() {
+    static void releaseBDDExprMgr()
+    {
         delete bddExprMgr;
         bddExprMgr = nullptr;
     }
@@ -74,7 +79,8 @@ public:
     /// Destructor
     virtual ~BDDExprManager();
 
-    BDDExpr *createCond(u32_t i) {
+    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);
@@ -85,18 +91,21 @@ public:
     virtual BDDExpr *createFreshBranchCond(const Instruction *inst);
 
     /// Return the number of condition expressions
-    virtual inline u32_t getCondNumber() {
+    virtual inline u32_t getCondNumber()
+    {
         return Cudd_ReadNodeCount(m_bdd_mgr);
     }
 
 
     /// Return the unique true condition
-    inline BDDExpr *getTrueCond() const {
+    inline BDDExpr *getTrueCond() const
+    {
         return trueCond;
     }
 
     /// Return the unique false condition
-    inline BDDExpr *getFalseCond() const {
+    inline BDDExpr *getFalseCond() const
+    {
         return falseCond;
     }
 
@@ -109,17 +118,20 @@ public:
     virtual BDDExpr *NEG(BDDExpr *lhs);
     //@}
 
-    virtual bool isNegCond(const BDDExpr *cond) {
+    virtual bool isNegCond(const BDDExpr *cond)
+    {
         return false;
     }
 
     /// Whether the condition is satisfiable
-    virtual bool isSatisfiable(const BDDExpr *cond) {
+    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){
+    virtual bool isEquivalentBranchCond(const BDDExpr *lhs, const BDDExpr *rhs)
+    {
         return lhs == rhs;
     }
 
@@ -127,7 +139,8 @@ public:
     bool isAllPathReachable(const BDDExpr *e);
 
     /// Get condition using condition id (z3 ast id)
-    virtual BDDExpr *getCond(u32_t id) {
+    virtual BDDExpr *getCond(u32_t id)
+    {
         auto it = indexToBddCondMap.find(id);
         assert(it != indexToBddCondMap.end() && "condition not found!");
         return it->second;
@@ -135,13 +148,15 @@ public:
 
     /// Get/Set llvm conditional expression
     //{@
-    inline const Instruction *getCondInst(const BDDExpr *cond) const {
+    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) {
+    inline void setCondInst(const BDDExpr *cond, const Instruction *inst)
+    {
         assert(condToInstMap.find(cond) == condToInstMap.end() && "this should be a fresh condition");
         condToInstMap[cond] = inst;
     }
@@ -161,7 +176,8 @@ public:
 
     std::string dumpStr(const BDDExpr *e) const;
 
-    inline std::string getMemUsage() {
+    inline std::string getMemUsage()
+    {
         return std::to_string(Cudd_ReadMemoryInUse(m_bdd_mgr));
     }
 

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

@@ -84,9 +84,9 @@ typedef llvm::Use Use;
 typedef llvm::Loop Loop;
 typedef llvm::LoopInfo LoopInfo;
 #if LLVM_VERSION_MAJOR >= 12
-    typedef llvm::UnifyFunctionExitNodesLegacyPass UnifyFunctionExitNodes;
+typedef llvm::UnifyFunctionExitNodesLegacyPass UnifyFunctionExitNodes;
 #else
-    typedef llvm::UnifyFunctionExitNodes UnifyFunctionExitNodes;
+typedef llvm::UnifyFunctionExitNodes UnifyFunctionExitNodes;
 #endif
 typedef llvm::ModulePass ModulePass;
 
@@ -150,9 +150,9 @@ typedef llvm::LoopInfoWrapperPass LoopInfoWrapperPass;
 /// LLVM Iterators
 typedef llvm::inst_iterator inst_iterator;
 #if LLVM_VERSION_MAJOR >= 11
-    typedef llvm::const_succ_iterator succ_const_iterator;
+typedef llvm::const_succ_iterator succ_const_iterator;
 #else
-    typedef llvm::succ_const_iterator succ_const_iterator;
+typedef llvm::succ_const_iterator succ_const_iterator;
 #endif
 typedef llvm::const_inst_iterator const_inst_iterator;
 typedef llvm::const_pred_iterator const_pred_iterator;
@@ -251,32 +251,82 @@ public:
 
 };
 
-class CallSite {
+class CallSite
+{
 private:
     CallBase *CB;
 public:
     CallSite(Instruction *I) : CB(SVFUtil::dyn_cast<CallBase>(I)) {}
     CallSite(Value *I) : CB(SVFUtil::dyn_cast<CallBase>(I)) {}
 
-    CallBase *getInstruction() const { return CB; }
+    CallBase *getInstruction() const
+    {
+        return CB;
+    }
     using arg_iterator = User::const_op_iterator;
-    Value *getArgument(unsigned ArgNo) const { return CB->getArgOperand(ArgNo);}
-    Type *getType() const { return CB->getType(); }
-    User::const_op_iterator arg_begin() const { return CB->arg_begin();}
-    User::const_op_iterator arg_end() const { return CB->arg_end();}
-    unsigned arg_size() const { return CB->arg_size(); }
-    bool arg_empty() const { return CB->arg_empty(); }
-    Value *getArgOperand(unsigned i) const { return CB->getArgOperand(i); }
-    unsigned getNumArgOperands() const { return CB->arg_size(); }
-    Function *getCalledFunction() const { return CB->getCalledFunction(); }
-    Value *getCalledValue() const { return CB->getCalledOperand(); }
-    Function *getCaller() const { return CB->getCaller(); }
-    FunctionType *getFunctionType() const { return CB->getFunctionType(); }
-    bool paramHasAttr(unsigned ArgNo, llvm::Attribute::AttrKind Kind) const { return CB->paramHasAttr(ArgNo, Kind); }
-
-    bool operator==(const CallSite &CS) const { return CB == CS.CB; }
-    bool operator!=(const CallSite &CS) const { return CB != CS.CB; }
-    bool operator<(const CallSite &CS) const {
+    Value *getArgument(unsigned ArgNo) const
+    {
+        return CB->getArgOperand(ArgNo);
+    }
+    Type *getType() const
+    {
+        return CB->getType();
+    }
+    User::const_op_iterator arg_begin() const
+    {
+        return CB->arg_begin();
+    }
+    User::const_op_iterator arg_end() const
+    {
+        return CB->arg_end();
+    }
+    unsigned arg_size() const
+    {
+        return CB->arg_size();
+    }
+    bool arg_empty() const
+    {
+        return CB->arg_empty();
+    }
+    Value *getArgOperand(unsigned i) const
+    {
+        return CB->getArgOperand(i);
+    }
+    unsigned getNumArgOperands() const
+    {
+        return CB->arg_size();
+    }
+    Function *getCalledFunction() const
+    {
+        return CB->getCalledFunction();
+    }
+    Value *getCalledValue() const
+    {
+        return CB->getCalledOperand();
+    }
+    Function *getCaller() const
+    {
+        return CB->getCaller();
+    }
+    FunctionType *getFunctionType() const
+    {
+        return CB->getFunctionType();
+    }
+    bool paramHasAttr(unsigned ArgNo, llvm::Attribute::AttrKind Kind) const
+    {
+        return CB->paramHasAttr(ArgNo, Kind);
+    }
+
+    bool operator==(const CallSite &CS) const
+    {
+        return CB == CS.CB;
+    }
+    bool operator!=(const CallSite &CS) const
+    {
+        return CB != CS.CB;
+    }
+    bool operator<(const CallSite &CS) const
+    {
         return getInstruction() < CS.getInstruction();
     }
 
@@ -292,8 +342,10 @@ OutStream& operator<< (OutStream &o, const std::pair<F, S> &var)
 } // End namespace SVF
 
 /// Specialise hash for CallSites.
-template <> struct std::hash<SVF::CallSite> {
-    size_t operator()(const SVF::CallSite &cs) const {
+template <> struct std::hash<SVF::CallSite>
+{
+    size_t operator()(const SVF::CallSite &cs) const
+    {
         std::hash<SVF::Instruction *> h;
         return h(cs.getInstruction());
     }

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

@@ -203,7 +203,8 @@ private:
 template <>
 struct Hash<CoreBitVector>
 {
-    size_t operator()(const CoreBitVector &cbv) const {
+    size_t operator()(const CoreBitVector &cbv) const
+    {
         return cbv.hash();
     }
 };

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

@@ -455,36 +455,46 @@ private:
 
 } // End namespace SVF
 // Specialise has for class defined in this header file
-template <> struct std::hash<SVF::CxtThread> {
-	size_t operator()(const SVF::CxtThread& cs) const {
-		std::hash<SVF::CallStrCxt> h;
-		return h(cs.getContext());
-	}
+template <> struct std::hash<SVF::CxtThread>
+{
+    size_t operator()(const SVF::CxtThread& cs) const
+    {
+        std::hash<SVF::CallStrCxt> h;
+        return h(cs.getContext());
+    }
 };
-template <> struct std::hash<SVF::CxtThreadProc> {
-	size_t operator()(const SVF::CxtThreadProc& ctp) const {
-		std::hash<SVF::NodeID> h;
-		return h(ctp.getTid());
-	}
+template <> struct std::hash<SVF::CxtThreadProc>
+{
+    size_t operator()(const SVF::CxtThreadProc& ctp) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(ctp.getTid());
+    }
 };
-template <> struct std::hash<SVF::CxtThreadStmt> {
-	size_t operator()(const SVF::CxtThreadStmt& cts) const {
-		std::hash<SVF::NodeID> h;
-		return h(cts.getTid());
-	}
+template <> struct std::hash<SVF::CxtThreadStmt>
+{
+    size_t operator()(const SVF::CxtThreadStmt& cts) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(cts.getTid());
+    }
 };
-template <> struct std::hash<SVF::CxtStmt> {
-	size_t operator()(const SVF::CxtStmt& cs) const {
-		std::hash<SVF::Instruction*> h;
-		SVF::Instruction* inst = const_cast<SVF::Instruction*> (cs.getStmt());
-		return h(inst);
-	}
+template <> struct std::hash<SVF::CxtStmt>
+{
+    size_t operator()(const SVF::CxtStmt& cs) const
+    {
+        std::hash<SVF::Instruction*> h;
+        SVF::Instruction* inst = const_cast<SVF::Instruction*> (cs.getStmt());
+        return h(inst);
+    }
 };
-template <> struct std::hash<SVF::CxtProc> {
-	size_t operator()(const SVF::CxtProc& cs) const {
-		std::hash<SVF::SVFFunction*> h;
-		SVF::SVFFunction* fun = const_cast<SVF::SVFFunction*> (cs.getProc());
-		return h(fun);
-	}
+template <> struct std::hash<SVF::CxtProc>
+{
+    size_t operator()(const SVF::CxtProc& cs) const
+    {
+        std::hash<SVF::SVFFunction*> h;
+        SVF::SVFFunction* fun = const_cast<SVF::SVFFunction*> (cs.getProc());
+        return h(fun);
+    }
 };
 #endif /* INCLUDE_UTIL_CXTSTMT_H_ */