svf-tools 1.0.738 → 1.0.740

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.738",
+  "version": "1.0.740",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/CFL/CFLGrammar.h

@@ -217,9 +217,9 @@ public:
         this->totalKind = totalKind;
     }
 
-    std::string extractKindStrFromSymbolStr(const std::string symbolStr) const;
+    std::string extractKindStrFromSymbolStr(const std::string& symbolStr) const;
 
-    std::string extractAttributeStrFromSymbolStr(const std::string symbolStr) const;
+    std::string extractAttributeStrFromSymbolStr(const std::string& symbolStr) const;
 
     void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
 

package/svf/include/Graphs/ICFGNode.h

@@ -88,7 +88,7 @@ public:
         return fun;
     }
 
-    /// Return the function of this ICFGNode
+    /// Return the basic block of this ICFGNode
     virtual const SVFBasicBlock* getBB() const
     {
         return bb;

package/svf/include/SVFIR/SVFFileSystem.h

@@ -429,6 +429,7 @@ private:
     cJSON* toJson(const SVFLoopAndDomInfo* ldInfo); // Only owned by SVFFunction
     cJSON* toJson(const StInfo* stInfo);
 
+    // No need for 'toJson(short)' because of promotion to int
     static cJSON* toJson(bool flag);
     static cJSON* toJson(unsigned number);
     static cJSON* toJson(int number);
@@ -1044,6 +1045,7 @@ public:
     static void readJson(const cJSON* obj, bool& flag);
     static void readJson(const cJSON* obj, unsigned& val);
     static void readJson(const cJSON* obj, int& val);
+    static void readJson(const cJSON* obj, short& val);
     static void readJson(const cJSON* obj, float& val);
     static void readJson(const cJSON* obj, unsigned long& val);
     static void readJson(const cJSON* obj, long long& val);

package/svf/include/SVFIR/SVFType.h

@@ -282,11 +282,11 @@ public:
         return kind;
     }
 
-    /// Note: Use `os<<svfType` or `svfType.print(os)` when possible to avoid
+    /// \note Use `os<<svfType` or `svfType.print(os)` when possible to avoid
     /// string concatenation.
     std::string toString() const;
 
-    virtual void print(std::ostream& OS) const = 0;
+    virtual void print(std::ostream& os) const = 0;
 
     inline void setPointerTo(const SVFPointerType* ty)
     {
@@ -327,7 +327,7 @@ public:
     }
 };
 
-std::ostream& operator<<(std::ostream& OS, const SVFType& type);
+std::ostream& operator<<(std::ostream& os, const SVFType& type);
 
 class SVFPointerType : public SVFType
 {
@@ -351,11 +351,17 @@ public:
         return ptrElementType;
     }
 
-    void print(std::ostream& OS) const override;
+    void print(std::ostream& os) const override;
 };
 
 class SVFIntegerType : public SVFType
 {
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+private:
+    short signAndWidth; ///< For printing
+
 public:
     SVFIntegerType() : SVFType(true, SVFIntegerTy) {}
     static inline bool classof(const SVFType* node)
@@ -363,7 +369,17 @@ public:
         return node->getKind() == SVFIntegerTy;
     }
 
-    void print(std::ostream& OS) const override;
+    void print(std::ostream& os) const override;
+
+    void setSignAndWidth(short sw)
+    {
+        signAndWidth = sw;
+    }
+
+    bool isSigned() const
+    {
+        return signAndWidth < 0;
+    }
 };
 
 class SVFFunctionType : public SVFType
@@ -388,7 +404,7 @@ public:
         return retTy;
     }
 
-    void print(std::ostream& OS) const override;
+    void print(std::ostream& os) const override;
 };
 
 class SVFStructType : public SVFType
@@ -397,6 +413,7 @@ class SVFStructType : public SVFType
     friend class SVFIRReader;
 
 private:
+    /// @brief Field for printing & debugging
     std::string name;
 
 public:
@@ -407,12 +424,20 @@ public:
         return node->getKind() == SVFStructTy;
     }
 
-    void print(std::ostream& OS) const override;
+    void print(std::ostream& os) const override;
 
-    std::string& getName()
+    const std::string& getName()
     {
         return name;
     }
+    void setName(const std::string& structName)
+    {
+        name = structName;
+    }
+    void setName(std::string&& structName)
+    {
+        name = std::move(structName);
+    }
 };
 
 class SVFArrayType : public SVFType
@@ -421,8 +446,8 @@ class SVFArrayType : public SVFType
     friend class SVFIRReader;
 
 private:
-    unsigned numOfElement; /// For printing
-    SVFType* typeOfElement; /// For printing
+    unsigned numOfElement; /// For printing & debugging
+    const SVFType* typeOfElement; /// For printing & debugging
 
 public:
     SVFArrayType()
@@ -435,9 +460,9 @@ public:
         return node->getKind() == SVFArrayTy;
     }
 
-    void print(std::ostream& OS) const override;
+    void print(std::ostream& os) const override;
 
-    void setTypeOfElement(SVFType* elemType)
+    void setTypeOfElement(const SVFType* elemType)
     {
         typeOfElement = elemType;
     }
@@ -464,12 +489,22 @@ public:
         return node->getKind() == SVFOtherTy;
     }
 
-    std::string& getRepr()
+    const std::string& getRepr()
     {
         return repr;
     }
 
-    void print(std::ostream& OS) const override;
+    void setRepr(std::string&& r)
+    {
+        repr = std::move(r);
+    }
+
+    void setRepr(const std::string& r)
+    {
+        repr = r;
+    }
+
+    void print(std::ostream& os) const override;
 };
 
 /// [FOR DEBUG ONLY, DON'T USE IT UNSIDE `svf`!]

package/svf/include/SVFIR/SVFValue.h

@@ -183,17 +183,17 @@ private:
 
 protected:
     const SVFType* type;   ///< Type of this SVFValue
-    std::string name;       ///< Short name of this value for debugging
+    std::string name;       ///< Short name of value for printing & debugging
     std::string sourceLoc;  ///< Source code information of this value
-    /// Constructor
-    SVFValue(const std::string& val, const SVFType* ty, SVFValKind k)
+    /// Constructor without name
+    SVFValue(const SVFType* ty, SVFValKind k)
         : kind(k), ptrInUncalledFun(false),
-          constDataOrAggData(SVFConstData == k), type(ty), name(val),
-          sourceLoc("No source code Info")
+          constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
     {
     }
 
-    ///@{ attributes to be set only through Module builders e.g., LLVMModule
+    ///@{ attributes to be set only through Module builders e.g.,
+    /// LLVMModule
     inline void setConstDataOrAggData()
     {
         constDataOrAggData = true;
@@ -213,14 +213,17 @@ public:
         return kind;
     }
 
-    // TODO: (Optimization) Returns `const std::string&`?
-    inline virtual const std::string getName() const
+    inline const std::string &getName() const
     {
         return name;
     }
-    inline virtual void setName(const std::string& valueName)
+    inline void setName(const std::string& n)
+    {
+        name = n;
+    }
+    inline void setName(std::string&& n)
     {
-        name = valueName;
+        name = std::move(n);
     }
 
     inline virtual const SVFType* getType() const
@@ -252,15 +255,18 @@ public:
         return sourceLoc;
     }
 
-    /// Needs to be implemented by a specific SVF front end (e.g., the implementation in LLVMUtil)
-    virtual const std::string toString() const;
+    /// \note Use `os<<SVFvalue` or `svfValue.print(os)` when possible to avoid
+    /// string concatenation.
+    std::string toString() const;
+
+    virtual void print(OutStream& os) const = 0;
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const SVFValue &node)
+    friend OutStream& operator<<(OutStream &os, const SVFValue &value)
     {
-        o << node.toString();
-        return o;
+        value.print(os);
+        return os;
     }
     //@}
 };
@@ -291,7 +297,6 @@ private:
     std::vector<const SVFBasicBlock*> allBBs;   /// all BasicBlocks of this function
     std::vector<const SVFArgument*> allArgs;    /// all formal arguments of this function
 
-
 protected:
     ///@{ attributes to be set only through Module builders e.g., LLVMModule
     inline void addBasicBlock(const SVFBasicBlock* bb)
@@ -321,8 +326,7 @@ protected:
     /// @}
 
 public:
-    SVFFunction(const std::string& f, const SVFType* ty,const SVFFunctionType* ft, bool declare, bool intrinsic, bool addrTaken, bool varg, SVFLoopAndDomInfo* ld);
-    SVFFunction(const std::string& f) = delete;
+    SVFFunction(const SVFType* ty,const SVFFunctionType* ft, bool declare, bool intrinsic, bool addrTaken, bool varg, SVFLoopAndDomInfo* ld);
     SVFFunction(void) = delete;
     virtual ~SVFFunction();
 
@@ -331,6 +335,8 @@ public:
         return node->getKind() == SVFFunc;
     }
 
+    void print(OutStream& os) const override;
+
     inline SVFLoopAndDomInfo* getLoopAndDomInfo()
     {
         return loopAndDom;
@@ -479,7 +485,6 @@ public:
     {
         return loopAndDom->postDominate(bbKey,bbValue);
     }
-
 };
 
 class SVFBasicBlock : public SVFValue
@@ -517,7 +522,8 @@ protected:
     /// @}
 
 public:
-    SVFBasicBlock(const std::string& b, const SVFType* ty, const SVFFunction* f);
+    /// Constructor without name
+    SVFBasicBlock(const SVFType* ty, const SVFFunction* f);
     SVFBasicBlock() = delete;
     ~SVFBasicBlock() override;
 
@@ -526,6 +532,8 @@ public:
         return node->getKind() == SVFBB;
     }
 
+    void print(OutStream& os) const override;
+
     inline const std::vector<const SVFInstruction*>& getInstructionList() const
     {
         return allInsts;
@@ -599,8 +607,9 @@ private:
     InstVec predInsts;  /// predecessor Instructions
 
 public:
-    SVFInstruction(const std::string& i, const SVFType* ty, const SVFBasicBlock* b, bool tm, bool isRet, SVFValKind k = SVFInst);
-    SVFInstruction(const std::string& i) = delete;
+    /// Constructor without name, set name with setName()
+    SVFInstruction(const SVFType* ty, const SVFBasicBlock* b, bool tm,
+                   bool isRet, SVFValKind k = SVFInst);
     SVFInstruction(void) = delete;
 
     static inline bool classof(const SVFValue *node)
@@ -610,6 +619,8 @@ public:
                node->getKind() == SVFVCall;
     }
 
+    void print(OutStream& os) const override;
+
     inline const SVFBasicBlock* getParent() const
     {
         return bb;
@@ -676,11 +687,10 @@ protected:
     /// @}
 
 public:
-    SVFCallInst(const std::string& i, const SVFType* ty, const SVFBasicBlock* b, bool va, bool tm, SVFValKind k = SVFCall) :
-        SVFInstruction(i, ty, b, tm, false, k), varArg(va), calledVal(nullptr)
+    SVFCallInst(const SVFType* ty, const SVFBasicBlock* b, bool va, bool tm, SVFValKind k = SVFCall) :
+        SVFInstruction(ty, b, tm, false, k), varArg(va), calledVal(nullptr)
     {
     }
-    SVFCallInst(const std::string& i) = delete;
     SVFCallInst(void) = delete;
 
     static inline bool classof(const SVFValue *node)
@@ -752,8 +762,10 @@ protected:
     }
 
 public:
-    SVFVirtualCallInst(const std::string& i, const SVFType* ty, const SVFBasicBlock* b, bool vararg, bool tm) :
-        SVFCallInst(i,ty,b,vararg,tm, SVFVCall), vCallVtblPtr(nullptr), virtualFunIdx(-1), funNameOfVcall("")
+    SVFVirtualCallInst(const SVFType* ty, const SVFBasicBlock* b, bool vararg,
+                       bool tm)
+        : SVFCallInst(ty, b, vararg, tm, SVFVCall), vCallVtblPtr(nullptr),
+          virtualFunIdx(-1), funNameOfVcall()
     {
     }
     inline const SVFValue* getVtablePtr() const
@@ -789,7 +801,7 @@ class SVFConstant : public SVFValue
     friend class SVFIRWriter;
     friend class SVFIRReader;
 public:
-    SVFConstant(const std::string& _const, const SVFType* ty, SVFValKind k = SVFConst): SVFValue(_const, ty, k)
+    SVFConstant(const SVFType* ty, SVFValKind k = SVFConst): SVFValue(ty, k)
     {
     }
     SVFConstant() = delete;
@@ -804,6 +816,8 @@ public:
                node->getKind() == SVFNullPtr ||
                node->getKind() == SVFBlackHole;
     }
+
+    void print(OutStream& os) const override;
 };
 
 class SVFGlobalValue : public SVFConstant
@@ -822,11 +836,16 @@ protected:
     }
 
 public:
-    SVFGlobalValue(const std::string& _gv, const SVFType* ty): SVFConstant(_gv, ty, SVFValue::SVFGlob), realDefGlobal(nullptr)
+    SVFGlobalValue(const SVFType* ty): SVFConstant(ty, SVFValue::SVFGlob), realDefGlobal(nullptr)
     {
     }
+    SVFGlobalValue(std::string&& name, const SVFType* ty) : SVFGlobalValue(ty)
+    {
+        setName(std::move(name));
+    }
     SVFGlobalValue() = delete;
 
+    void print(OutStream& os) const override;
 
     inline const SVFValue* getDefGlobalForMultipleModule() const
     {
@@ -853,11 +872,16 @@ private:
     u32_t argNo;
     bool uncalled;
 public:
-    SVFArgument(const std::string& _arg, const SVFType* ty, const SVFFunction* _fun, u32_t _argNo, bool _uncalled): SVFValue(_arg, ty, SVFValue::SVFArg), fun(_fun), argNo(_argNo), uncalled(_uncalled)
+    SVFArgument(const SVFType* ty, const SVFFunction* fun, u32_t argNo,
+                bool uncalled)
+        : SVFValue(ty, SVFValue::SVFArg), fun(fun), argNo(argNo),
+          uncalled(uncalled)
     {
     }
     SVFArgument() = delete;
 
+    void print(OutStream& os) const override;
+
     inline const SVFFunction* getParent() const
     {
         return fun;
@@ -881,18 +905,19 @@ public:
     }
 };
 
-
-
 class SVFConstantData : public SVFConstant
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 public:
-    SVFConstantData(const std::string& _const, const SVFType* ty, SVFValKind k = SVFConstData): SVFConstant(_const, ty, k)
+    SVFConstantData(const SVFType* ty, SVFValKind k = SVFConstData)
+        : SVFConstant(ty, k)
     {
     }
     SVFConstantData() = delete;
 
+    void print(OutStream& os) const override;
+
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConstData ||
@@ -911,7 +936,6 @@ public:
     }
 };
 
-
 class SVFConstantInt : public SVFConstantData
 {
     friend class SVFIRWriter;
@@ -920,11 +944,14 @@ private:
     u64_t zval;
     s64_t sval;
 public:
-    SVFConstantInt(const std::string& _const, const SVFType* ty, u64_t z, s64_t s): SVFConstantData(_const, ty, SVFValue::SVFConstInt), zval(z), sval(s)
+    SVFConstantInt(const SVFType* ty, u64_t z, s64_t s)
+        : SVFConstantData(ty, SVFValue::SVFConstInt), zval(z), sval(s)
     {
     }
     SVFConstantInt() = delete;
 
+    void print(OutStream& os) const override;
+
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFConstInt;
@@ -945,7 +972,6 @@ public:
     }
 };
 
-
 class SVFConstantFP : public SVFConstantData
 {
     friend class SVFIRWriter;
@@ -953,11 +979,14 @@ class SVFConstantFP : public SVFConstantData
 private:
     float dval;
 public:
-    SVFConstantFP(const std::string& _const, const SVFType* ty, double d): SVFConstantData(_const, ty, SVFValue::SVFConstFP), dval(d)
+    SVFConstantFP(const SVFType* ty, double d)
+        : SVFConstantData(ty, SVFValue::SVFConstFP), dval(d)
     {
     }
     SVFConstantFP() = delete;
 
+    void print(OutStream& os) const override;
+
     inline double getFPValue () const
     {
         return dval;
@@ -972,18 +1001,20 @@ public:
     }
 };
 
-
 class SVFConstantNullPtr : public SVFConstantData
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
 public:
-    SVFConstantNullPtr(const std::string& _const, const SVFType* ty): SVFConstantData(_const, ty, SVFValue::SVFNullPtr)
+    SVFConstantNullPtr(const SVFType* ty)
+        : SVFConstantData(ty, SVFValue::SVFNullPtr)
     {
     }
     SVFConstantNullPtr() = delete;
 
+    void print(OutStream& os) const override;
+
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFNullPtr;
@@ -1000,11 +1031,14 @@ class SVFBlackHoleValue : public SVFConstantData
     friend class SVFIRReader;
 
 public:
-    SVFBlackHoleValue(const std::string& _const, const SVFType* ty): SVFConstantData(_const, ty, SVFValue::SVFBlackHole)
+    SVFBlackHoleValue(const SVFType* ty)
+        : SVFConstantData(ty, SVFValue::SVFBlackHole)
     {
     }
     SVFBlackHoleValue() = delete;
 
+    void print(OutStream& os) const override;
+
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFBlackHole;
@@ -1020,7 +1054,8 @@ class SVFOtherValue : public SVFValue
     friend class SVFIRWriter;
     friend class SVFIRReader;
 public:
-    SVFOtherValue(const std::string& other, const SVFType* ty, SVFValKind k = SVFValue::SVFOther): SVFValue(other, ty, k)
+    SVFOtherValue(const SVFType* ty, SVFValKind k = SVFValue::SVFOther)
+        : SVFValue(ty, k)
     {
     }
     SVFOtherValue() = delete;
@@ -1029,6 +1064,8 @@ public:
     {
         return node->getKind() == SVFOther || node->getKind() == SVFMetaAsValue;
     }
+
+    void print(OutStream& os) const override;
 };
 
 /*
@@ -1039,7 +1076,8 @@ class SVFMetadataAsValue : public SVFOtherValue
     friend class SVFIRWriter;
     friend class SVFIRReader;
 public:
-    SVFMetadataAsValue(const std::string& other, const SVFType* ty): SVFOtherValue(other, ty, SVFValue::SVFMetaAsValue)
+    SVFMetadataAsValue(const SVFType* ty)
+        : SVFOtherValue(ty, SVFValue::SVFMetaAsValue)
     {
     }
     SVFMetadataAsValue() = delete;
@@ -1052,6 +1090,8 @@ public:
     {
         return node->getKind() == SVFMetaAsValue;
     }
+
+    void print(OutStream& os) const override;
 };
 
 

package/svf/lib/CFL/CFLGrammar.cpp

@@ -204,7 +204,7 @@ inline GrammarBase::Kind GrammarBase::insertNonterminalKind(std::string const ki
     return kind;
 }
 
-std::string GrammarBase::extractKindStrFromSymbolStr(const std::string symbolStr) const
+std::string GrammarBase::extractKindStrFromSymbolStr(const std::string& symbolStr) const
 {
     std::string kindStr;
     // symbolStr end with '_', the whole symbolStr treat as kind, not with attribute.
@@ -216,7 +216,7 @@ std::string GrammarBase::extractKindStrFromSymbolStr(const std::string symbolStr
     return symbolStr.substr(0, underscorePosition);
 }
 
-std::string GrammarBase::extractAttributeStrFromSymbolStr(const std::string symbolStr) const
+std::string GrammarBase::extractAttributeStrFromSymbolStr(const std::string& symbolStr) const
 {
     std::string attributeStr;
     // symbolStr end with '_', the whole symbolStr treat as kind, not with attribute.

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -43,45 +43,51 @@ SVFType* createSVFType(SVFType::GNodeK kind, bool isSingleValTy)
 }
 
 static SVFValue* createSVFValue(SVFValue::GNodeK kind, const SVFType* type,
-                                const std::string& name)
+                                std::string&& name)
 {
-    switch (kind)
+    auto creator = [=]() -> SVFValue*
     {
-    default:
-        ABORT_MSG(kind << " is an impossible SVFValueKind in create()");
-    case SVFValue::SVFVal:
-        ABORT_MSG("Creation of RAW SVFValue isn't allowed");
-    case SVFValue::SVFFunc:
-        return new SVFFunction(name, type, {}, {}, {}, {}, {}, {});
-    case SVFValue::SVFBB:
-        return new SVFBasicBlock(name, type, {});
-    case SVFValue::SVFInst:
-        return new SVFInstruction(name, type, {}, {}, {});
-    case SVFValue::SVFCall:
-        return new SVFCallInst(name, type, {}, {}, {});
-    case SVFValue::SVFVCall:
-        return new SVFVirtualCallInst(name, type, {}, {}, {});
-    case SVFValue::SVFGlob:
-        return new SVFGlobalValue(name, type);
-    case SVFValue::SVFArg:
-        return new SVFArgument(name, type, {}, {}, {});
-    case SVFValue::SVFConst:
-        return new SVFConstant(name, type);
-    case SVFValue::SVFConstData:
-        return new SVFConstantData(name, type);
-    case SVFValue::SVFConstInt:
-        return new SVFConstantInt(name, type, {}, {});
-    case SVFValue::SVFConstFP:
-        return new SVFConstantFP(name, type, {});
-    case SVFValue::SVFNullPtr:
-        return new SVFConstantNullPtr(name, type);
-    case SVFValue::SVFBlackHole:
-        return new SVFBlackHoleValue(name, type);
-    case SVFValue::SVFMetaAsValue:
-        return new SVFMetadataAsValue(name, type);
-    case SVFValue::SVFOther:
-        return new SVFOtherValue(name, type);
-    }
+        switch (kind)
+        {
+        default:
+            ABORT_MSG(kind << " is an impossible SVFValueKind in create()");
+        case SVFValue::SVFVal:
+            ABORT_MSG("Creation of RAW SVFValue isn't allowed");
+        case SVFValue::SVFFunc:
+            return new SVFFunction(type, {}, {}, {}, {}, {}, {});
+        case SVFValue::SVFBB:
+            return new SVFBasicBlock(type, {});
+        case SVFValue::SVFInst:
+            return new SVFInstruction(type, {}, {}, {});
+        case SVFValue::SVFCall:
+            return new SVFCallInst(type, {}, {}, {});
+        case SVFValue::SVFVCall:
+            return new SVFVirtualCallInst(type, {}, {}, {});
+        case SVFValue::SVFGlob:
+            return new SVFGlobalValue(type);
+        case SVFValue::SVFArg:
+            return new SVFArgument(type, {}, {}, {});
+        case SVFValue::SVFConst:
+            return new SVFConstant(type);
+        case SVFValue::SVFConstData:
+            return new SVFConstantData(type);
+        case SVFValue::SVFConstInt:
+            return new SVFConstantInt(type, {}, {});
+        case SVFValue::SVFConstFP:
+            return new SVFConstantFP(type, {});
+        case SVFValue::SVFNullPtr:
+            return new SVFConstantNullPtr(type);
+        case SVFValue::SVFBlackHole:
+            return new SVFBlackHoleValue(type);
+        case SVFValue::SVFMetaAsValue:
+            return new SVFMetadataAsValue(type);
+        case SVFValue::SVFOther:
+            return new SVFOtherValue(type);
+        }
+    };
+    auto val = creator();
+    val->setName(std::move(name));
+    return val;
 }
 
 template <typename SmallNumberType>
@@ -486,7 +492,9 @@ cJSON* SVFIRWriter::contentToJson(const SVFPointerType* type)
 
 cJSON* SVFIRWriter::contentToJson(const SVFIntegerType* type)
 {
-    return contentToJson(static_cast<const SVFType*>(type));
+    cJSON* root = contentToJson(static_cast<const SVFType*>(type));
+    JSON_WRITE_FIELD(root, type, signAndWidth);
+    return root;
 }
 
 cJSON* SVFIRWriter::contentToJson(const SVFFunctionType* type)
@@ -1426,7 +1434,7 @@ const cJSON* SVFIRReader::createObjs(const cJSON* root)
         JSON_DEF_READ_FWD(svfValueFldJson, SVFValue::GNodeK, kind);
         JSON_DEF_READ_FWD(svfValueFldJson, const SVFType*, type, {});
         JSON_DEF_READ_FWD(svfValueFldJson, std::string, name);
-        return createSVFValue(kind, type, name);
+        return createSVFValue(kind, type, std::move(name));
     },
     // SVFValue Filler
     [this](const cJSON*& svfVarFldJson, SVFValue* value)
@@ -1528,6 +1536,11 @@ void SVFIRReader::readJson(const cJSON* obj, int& val)
     readSmallNumber(obj, val);
 }
 
+void SVFIRReader::readJson(const cJSON* obj, short& val)
+{
+    readSmallNumber(obj, val);
+}
+
 void SVFIRReader::readJson(const cJSON* obj, float& val)
 {
     readSmallNumber(obj, val);
@@ -2488,6 +2501,7 @@ void SVFIRReader::fill(const cJSON*& fieldJson, SVFPointerType* type)
 void SVFIRReader::fill(const cJSON*& fieldJson, SVFIntegerType* type)
 {
     fill(fieldJson, static_cast<SVFType*>(type));
+    JSON_READ_FIELD_FWD(fieldJson, type, signAndWidth);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, SVFFunctionType* type)

package/svf/lib/SVFIR/SVFType.cpp

@@ -10,42 +10,43 @@ std::string SVFType::toString() const
     return os.str();
 }
 
-std::ostream& operator<<(std::ostream& OS, const SVFType& type)
+std::ostream& operator<<(std::ostream& os, const SVFType& type)
 {
-    type.print(OS);
-    return OS;
+    type.print(os);
+    return os;
 }
 
-void SVFPointerType::print(std::ostream& OS) const
+void SVFPointerType::print(std::ostream& os) const
 {
-    getPtrElementType()->print(OS);
-    OS << "*";
+    os << *getPtrElementType() << '*';
 }
 
-void SVFIntegerType::print(std::ostream& OS) const
+void SVFIntegerType::print(std::ostream& os) const
 {
-    // Making it more informative?
-    OS << "I";
+    if (signAndWidth < 0)
+        os << 'i' << -signAndWidth;
+    else
+        os << 'u' << signAndWidth;
 }
 
-void SVFFunctionType::print(std::ostream& OS) const
+void SVFFunctionType::print(std::ostream& os) const
 {
-    OS << *getReturnType() << "()";
+    os << *getReturnType() << "()";
 }
 
-void SVFStructType::print(std::ostream& OS) const
+void SVFStructType::print(std::ostream& os) const
 {
-    OS << "S." << name;
+    os << "S." << name;
 }
 
-void SVFArrayType::print(std::ostream& OS) const
+void SVFArrayType::print(std::ostream& os) const
 {
-    OS << "[" << numOfElement << "x" << *typeOfElement << "]";
+    os << '[' << numOfElement << 'x' << *typeOfElement << ']';
 }
 
-void SVFOtherType::print(std::ostream& OS) const
+void SVFOtherType::print(std::ostream& os) const
 {
-    OS << repr;
+    os << repr;
 }
 
 } // namespace SVF

package/svf/lib/SVFIR/SVFValue.cpp

@@ -122,10 +122,17 @@ bool SVFLoopAndDomInfo::isLoopHeader(const SVFBasicBlock* bb) const
     return false;
 }
 
-SVFFunction::SVFFunction(const std::string& f, const SVFType* ty,
-                         const SVFFunctionType* ft, bool declare, bool intrinsic,
-                         bool adt, bool varg, SVFLoopAndDomInfo* ld)
-    : SVFValue(f, ty, SVFValue::SVFFunc), isDecl(declare), intrinsic(intrinsic),
+std::string SVFValue::toString() const
+{
+    std::ostringstream os;
+    print(os);
+    return os.str();
+}
+
+SVFFunction::SVFFunction(const SVFType* ty, const SVFFunctionType* ft,
+                         bool declare, bool intrinsic, bool adt, bool varg,
+                         SVFLoopAndDomInfo* ld)
+    : SVFValue(ty, SVFValue::SVFFunc), isDecl(declare), intrinsic(intrinsic),
       addrTaken(adt), isUncalled(false), isNotRet(false), varArg(varg),
       funcType(ft), loopAndDom(ld), realDefFun(nullptr)
 {
@@ -156,8 +163,8 @@ bool SVFFunction::isVarArg() const
     return varArg;
 }
 
-SVFBasicBlock::SVFBasicBlock(const std::string& b, const SVFType* ty, const SVFFunction* f):
-    SVFValue(b, ty, SVFValue::SVFBB), fun(f)
+SVFBasicBlock::SVFBasicBlock(const SVFType* ty, const SVFFunction* f)
+    : SVFValue(ty, SVFValue::SVFBB), fun(f)
 {
 }
 
@@ -231,7 +238,96 @@ u32_t SVFBasicBlock::getBBPredecessorPos(const SVFBasicBlock* succbb) const
     return pos;
 }
 
-SVFInstruction::SVFInstruction(const std::string& i, const SVFType* ty, const SVFBasicBlock* b,  bool tm, bool isRet, SVFValKind k):
-    SVFValue(i, ty, k), bb(b), terminator(tm), ret(isRet)
+SVFInstruction::SVFInstruction(const SVFType* ty, const SVFBasicBlock* b,
+                               bool tm, bool isRet, SVFValKind k)
+    : SVFValue(ty, k), bb(b), terminator(tm), ret(isRet)
+{
+}
+
+void SVFFunction::print(OutStream& os) const
+{
+    os << "fun " << getName();
+}
+
+void SVFBasicBlock::print(OutStream& os) const
+{
+    os << "BB";
+    if (!getName().empty())
+        os << ' ' << getName();
+    os << " in " << getFunction()->getName();
+}
+
+void SVFInstruction::print(OutStream& os) const
+{
+    os << '`' << getName() << "` in " << getFunction()->getName();
+    const std::string& bbName = getParent()->getName();
+    if (bbName.size())
+        os << " BB " << bbName;
+}
+
+void SVFConstant::print(OutStream& os) const
 {
-}
+    os << "Const " << getName();
+}
+
+void SVFGlobalValue::print(OutStream& os) const
+{
+    os << "@" << getName();
+}
+
+void SVFArgument::print(OutStream& os) const
+{
+    os << "arg %" << getName() << " of " << getParent()->getName();
+}
+
+void SVFConstantData::print(OutStream& os) const
+{
+    // N.B. Haven't found instance of this class so far
+    os << "ConstData " << getName();
+}
+
+void SVFConstantInt::print(OutStream& os) const
+{
+    os << "ConstInt ";
+    if (!getName().empty())
+        os << getName() << ' ';
+    auto ty = dyn_cast<SVFIntegerType>(getType());
+    assert(ty && "ConstantInt has non-integer type?");
+    os << *ty << ' ';
+    if (ty->isSigned())
+        os << getSExtValue();
+    else
+        os << getZExtValue();
+}
+
+void SVFConstantFP::print(OutStream& os) const
+{
+    os << "ConstFP ";
+    if (!getName().empty())
+        os << getName() << ' ';
+    os << *getType() << ' ' << getFPValue();
+}
+
+void SVFConstantNullPtr::print(OutStream& os) const
+{
+    os << "ConstNull " << *getType();
+    if (!getName().empty())
+        os << ' ' << getName();
+}
+
+void SVFBlackHoleValue::print(OutStream& os) const
+{
+    os << "BlackHole " << *getType();
+    if (!getName().empty())
+        os << ' ' << getName();
+}
+
+void SVFOtherValue::print(OutStream& os) const
+{
+    os << "OtherVal " << getName();
+}
+
+void SVFMetadataAsValue::print(OutStream& os) const
+{
+    os << "MetaDataVal " << getName();
+}

package/svf/lib/Util/CppUtil.cpp

@@ -41,7 +41,7 @@ const std::string vtblLabelAfterDemangle = "vtable for ";
 const std::string NVThunkFunLabel = "non-virtual thunk to ";
 const std::string VThunkFuncLabel = "virtual thunk to ";
 
-static bool isOperOverload(const std::string name)
+static bool isOperOverload(const std::string& name)
 {
     u32_t leftnum = 0, rightnum = 0;
     std::string subname = name;

package/svf-llvm/include/SVF-LLVM/CHGBuilder.h

@@ -54,13 +54,13 @@ public:
     void buildInternalMaps();
     void readInheritanceMetadataFromModule(const Module &M);
 
-    CHNode *createNode(const std::string name);
+    CHNode *createNode(const std::string& name);
 
     void connectInheritEdgeViaCall(const Function* caller, const CallBase* cs);
     void connectInheritEdgeViaStore(const Function* caller, const StoreInst* store);
 
     void buildClassNameToAncestorsDescendantsMap();
-    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string className);
+    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string& className);
 
     void analyzeVTables(const Module &M);
     void buildVirtualFunctionToIDMap();

package/svf-llvm/include/SVF-LLVM/LLVMUtil.h

@@ -482,6 +482,13 @@ bool VCallInCtorOrDtor(const CallBase* cs);
 bool isSameThisPtrInConstructor(const Argument* thisPtr1,
                                 const Value* thisPtr2);
 
+template<typename T>
+std::string llvmToString(const T& val)
+{
+    std::string str;
+    llvm::raw_string_ostream(str) << val;
+    return str;
+}
 } // End namespace LLVMUtil
 
 } // End namespace SVF

package/svf-llvm/lib/CHGBuilder.cpp

@@ -232,7 +232,7 @@ void CHGBuilder::readInheritanceMetadataFromModule(const Module &M)
     }
 }
 
-CHNode *CHGBuilder::createNode(const std::string className)
+CHNode *CHGBuilder::createNode(const std::string& className)
 {
     assert(!chg->getNode(className) && "this node should never be created before!");
     CHNode * node = new CHNode(className, chg->classNum++);
@@ -292,8 +292,8 @@ void CHGBuilder::buildClassNameToAncestorsDescendantsMap()
     }
 }
 
-
-const CHGraph::CHNodeSetTy& CHGBuilder::getInstancesAndDescendants(const string className)
+const CHGraph::CHNodeSetTy& CHGBuilder::getInstancesAndDescendants(
+    const string& className)
 {
 
     CHGraph::NameToCHNodesMap::const_iterator it = chg->classNameToInstAndDescsMap.find(className);

package/svf-llvm/lib/LLVMModule.cpp

@@ -72,6 +72,19 @@ using namespace SVF;
 LLVMModuleSet* LLVMModuleSet::llvmModuleSet = nullptr;
 bool LLVMModuleSet::preProcessed = false;
 
+/// Helper function to summarize a long string
+static void shortenLongInfo(std::string& info, unsigned bestLen = 15)
+{
+    if (info.size() <= bestLen)
+        return;
+    // If it is of form "name = value", keep on the name part
+    size_t index = info.find(" =");
+    if (index != std::string::npos)
+        info.resize(index);
+    else
+        info.resize(bestLen);
+}
+
 LLVMModuleSet::LLVMModuleSet()
     : symInfo(SymbolTableInfo::SymbolInfo()),
       svfModule(SVFModule::getSVFModule()), cxts(nullptr)
@@ -159,27 +172,36 @@ void LLVMModuleSet::createSVFDataStructure()
         for (const Function& func : mod.functions())
         {
             SVFFunction* svfFunc = new SVFFunction(
-                func.getName().str(), getSVFType(func.getType()),
+                getSVFType(func.getType()),
                 SVFUtil::cast<SVFFunctionType>(
                     getSVFType(func.getFunctionType())),
                 func.isDeclaration(), LLVMUtil::isIntrinsicFun(&func),
                 func.hasAddressTaken(), func.isVarArg(), new SVFLoopAndDomInfo);
+            svfFunc->setName(func.getName().str());
             svfModule->addFunctionSet(svfFunc);
             addFunctionMap(&func, svfFunc);
 
             for (const Argument& arg : func.args())
             {
                 SVFArgument* svfarg = new SVFArgument(
-                    arg.getName().str(), getSVFType(arg.getType()), svfFunc,
-                    arg.getArgNo(), LLVMUtil::isArgOfUncalledFunction(&arg));
+                    getSVFType(arg.getType()), svfFunc, arg.getArgNo(),
+                    LLVMUtil::isArgOfUncalledFunction(&arg));
+                // Setting up arg name
+                if (arg.hasName())
+                    svfarg->setName(arg.getName().str());
+                else
+                    svfarg->setName(std::to_string(arg.getArgNo()));
+
                 svfFunc->addArgument(svfarg);
                 addArgumentMap(&arg, svfarg);
             }
 
             for (const BasicBlock& bb : func)
             {
-                SVFBasicBlock* svfBB = new SVFBasicBlock(
-                    bb.getName().str(), getSVFType(bb.getType()), svfFunc);
+                SVFBasicBlock* svfBB =
+                    new SVFBasicBlock(getSVFType(bb.getType()), svfFunc);
+                if (bb.hasName())
+                    svfBB->setName(bb.getName().str());
                 svfFunc->addBasicBlock(svfBB);
                 addBasicBlockMap(&bb, svfBB);
                 for (const Instruction& inst : bb)
@@ -189,23 +211,36 @@ void LLVMModuleSet::createSVFDataStructure()
                     {
                         if (LLVMUtil::isVirtualCallSite(call))
                             svfInst = new SVFVirtualCallInst(
-                                call->getName().str(),
                                 getSVFType(call->getType()), svfBB,
                                 call->getFunctionType()->isVarArg(),
                                 inst.isTerminator());
                         else
                             svfInst = new SVFCallInst(
-                                call->getName().str(),
                                 getSVFType(call->getType()), svfBB,
                                 call->getFunctionType()->isVarArg(),
                                 inst.isTerminator());
                     }
                     else
                     {
-                        svfInst = new SVFInstruction(
-                            inst.getName().str(), getSVFType(inst.getType()),
-                            svfBB, inst.isTerminator(),
-                            SVFUtil::isa<ReturnInst>(inst));
+                        svfInst =
+                            new SVFInstruction(getSVFType(inst.getType()),
+                                               svfBB, inst.isTerminator(),
+                                               SVFUtil::isa<ReturnInst>(inst));
+                    }
+
+                    // Set instruction's string representation
+                    if (inst.hasName() && !inst.getName().empty())
+                    {
+                        svfInst->setName(inst.getName().str());
+                    }
+                    else
+                    {
+                        std::string str = LLVMUtil::llvmToString(inst);
+                        auto it = str.begin(), ite = str.end();
+                        while (it != ite && std::isspace(*it))
+                            ++it;
+                        // 0xf (15) is the max length a local string can hold
+                        svfInst->setName({it, std::min(it + 0xf, ite)});
                     }
                     svfBB->addInstruction(svfInst);
                     addInstructionMap(&inst, svfInst);
@@ -850,25 +885,30 @@ SVFConstantData* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
             /// bitwidth <=64 1 : cint has value from getSExtValue()
             /// bitwidth >64 1 : cint has value 0 because it represents an invalid int
             if(cint->getBitWidth() == 1)
-                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), cint->getZExtValue(), cint->getZExtValue());
+                svfcd = new SVFConstantInt(getSVFType(cint->getType()), cint->getZExtValue(), cint->getZExtValue());
             else if(cint->getBitWidth() <= 64 && cint->getBitWidth() > 1)
-                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), cint->getZExtValue(), cint->getSExtValue());
+                svfcd = new SVFConstantInt(getSVFType(cint->getType()), cint->getZExtValue(), cint->getSExtValue());
             else
-                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), 0, 0);
+                svfcd = new SVFConstantInt(getSVFType(cint->getType()), 0, 0);
         }
         else if(const ConstantFP* cfp = SVFUtil::dyn_cast<ConstantFP>(cd))
         {
             double dval = 0;
+            // TODO: Why only double is considered? What about float?
             if(cfp->isNormalFP() &&  (&cfp->getValueAPF().getSemantics()== &llvm::APFloatBase::IEEEdouble()))
                 dval =  cfp->getValueAPF().convertToDouble();
-            svfcd = new SVFConstantFP(cd->getName().str(), getSVFType(cd->getType()), dval);
+            svfcd = new SVFConstantFP(getSVFType(cd->getType()), dval);
         }
         else if(SVFUtil::isa<ConstantPointerNull>(cd))
-            svfcd = new SVFConstantNullPtr(cd->getName().str(), getSVFType(cd->getType()));
+            svfcd = new SVFConstantNullPtr(getSVFType(cd->getType()));
         else if (SVFUtil::isa<UndefValue>(cd))
-            svfcd = new SVFBlackHoleValue(cd->getName().str(), getSVFType(cd->getType()));
+            svfcd = new SVFBlackHoleValue(getSVFType(cd->getType()));
         else
-            svfcd = new SVFConstantData(cd->getName().str(), getSVFType(cd->getType()));
+            svfcd = new SVFConstantData(getSVFType(cd->getType()));
+
+        if (cd->hasName())
+            svfcd->setName(cd->getName().str());
+
         svfModule->addConstant(svfcd);
         addConstantDataMap(cd,svfcd);
         return svfcd;
@@ -884,9 +924,32 @@ SVFConstant* LLVMModuleSet::getOtherSVFConstant(const Constant* oc)
     }
     else
     {
-        SVFConstant* svfoc = new SVFConstant(oc->getName().str(), getSVFType(oc->getType()));
+        SVFConstant* svfoc = new SVFConstant(getSVFType(oc->getType()));
         svfModule->addConstant(svfoc);
         addOtherConstantMap(oc,svfoc);
+
+        // Setting up string representation.
+        // Usually is a bitcast from a global variable's address
+        std::string str = LLVMUtil::llvmToString(*oc);
+        const char* spaceChars = " \t\n\v\f\r";
+        size_t space = str.find_first_of(spaceChars);
+        const int maxLen = 62; // Arbitrary chosen small number that fits string
+        // within one line
+        if (space != str.npos &&
+                (space = str.find_first_of(spaceChars, space + 1)) != str.npos)
+        {
+            size_t name = str.find('@', space);
+            str.erase(space, name - space);
+        }
+        else if (str.size() > maxLen)
+        {
+            int extra = str.size() - maxLen;
+            int half = maxLen / 2;
+            str[half++] = '~';
+            str.erase(half, half + extra);
+        }
+        svfoc->setName(std::move(str));
+
         return svfoc;
     }
 }
@@ -900,11 +963,18 @@ SVFOtherValue* LLVMModuleSet::getSVFOtherValue(const Value* ov)
     }
     else
     {
-        SVFOtherValue* svfov = nullptr;
-        if(SVFUtil::isa<MetadataAsValue>(ov))
-            svfov = new SVFMetadataAsValue(ov->getName().str(), getSVFType(ov->getType()));
+        SVFOtherValue* svfov =
+            SVFUtil::isa<MetadataAsValue>(ov)
+            ? new SVFMetadataAsValue(getSVFType(ov->getType()))
+            : new SVFOtherValue(getSVFType(ov->getType()));
+        if (ov->hasName())
+            svfov->setName(ov->getName().str());
         else
-            svfov = new SVFOtherValue(ov->getName().str(), getSVFType(ov->getType()));
+        {
+            auto str = LLVMUtil::llvmToString(*ov);
+            shortenLongInfo(str, 30);
+            svfov->setName(std::move(str));
+        }
         svfModule->addOtherValue(svfov);
         addOtherValueMap(ov,svfov);
         return svfov;
@@ -1008,15 +1078,21 @@ SVFType* LLVMModuleSet::addSVFTypeInfo(const Type* T)
     SVFType* svftype;
     if (const PointerType* pt = SVFUtil::dyn_cast<PointerType>(T))
         svftype = new SVFPointerType(getSVFType(LLVMUtil::getPtrElementType(pt)));
-    else if (SVFUtil::isa<IntegerType>(T))
-        svftype = new SVFIntegerType();
+    else if (const IntegerType* intT = SVFUtil::dyn_cast<IntegerType>(T))
+    {
+        auto svfIntT = new SVFIntegerType();
+        unsigned signWidth = intT->getBitWidth();
+        assert(signWidth < INT16_MAX && "Integer width too big");
+        svfIntT->setSignAndWidth(intT->getSignBit() ? -signWidth : signWidth);
+        svftype = svfIntT;
+    }
     else if (const FunctionType* ft = SVFUtil::dyn_cast<FunctionType>(T))
         svftype = new SVFFunctionType(getSVFType(ft->getReturnType()));
     else if (const StructType* st = SVFUtil::dyn_cast<StructType>(T))
     {
         auto svfst = new SVFStructType();
-        if(st->hasName())
-            svfst->getName() = st->getName().str();
+        if (st->hasName())
+            svfst->setName(st->getName().str());
         svftype = svfst;
     }
     else if (const auto at = SVFUtil::dyn_cast<ArrayType>(T))
@@ -1028,8 +1104,10 @@ SVFType* LLVMModuleSet::addSVFTypeInfo(const Type* T)
     }
     else
     {
+        std::string buffer;
         auto ot = new SVFOtherType(T->isSingleValueType());
-        llvm::raw_string_ostream(ot->getRepr()) << *T;
+        llvm::raw_string_ostream(buffer) << *T;
+        ot->setRepr(std::move(buffer));
         svftype = ot;
     }
 

package/svf-llvm/lib/LLVMUtil.cpp

@@ -560,7 +560,7 @@ const std::string LLVMUtil::getSourceLoc(const Value* val )
     }
     else
     {
-        rawstr << "Can only get source location for instruction, argument, global var, function or constant data.";
+        rawstr << "N/A";
     }
     rawstr << " }";
 
@@ -1039,20 +1039,15 @@ s32_t LLVMUtil::getVCallIdx(const CallBase* cs)
 
 namespace SVF
 {
-const std::string SVFValue::toString() const
-{
-    // TODO: Should only use info in SVFValue. Refactor it later.
-    return dumpLLVMValue(this);
-}
-
 std::string dumpLLVMValue(const SVFValue* svfValue)
 {
     std::string str;
     llvm::raw_string_ostream rawstr(str);
     if (LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(svfValue) == nullptr)
     {
-        assert((SVFUtil::isa<SVFInstruction>(svfValue) ||
-                SVFUtil::isa<SVFBasicBlock>(svfValue)) && "Manually created SVF call inst, actual parameter and BasicBlock by ExtAPI do not have LLVM value!");
+        assert((SVFUtil::isa<SVFInstruction, SVFBasicBlock>(svfValue)) &&
+               "Manually created SVF call inst, actual parameter and "
+               "BasicBlock by ExtAPI do not have LLVM value!");
         rawstr << svfValue->getName();
         return rawstr.str();
     }
@@ -1079,11 +1074,8 @@ std::string dumpLLVMValue(const SVFValue* svfValue)
 
 std::string dumpLLVMType(const SVFType* svfType)
 {
-    std::string str;
-    llvm::raw_string_ostream rawstr(str);
     const Type* ty = LLVMModuleSet::getLLVMModuleSet()->getLLVMType(svfType);
-    rawstr << *ty;
-    return rawstr.str();
+    return LLVMUtil::llvmToString(*ty);
 }
 
 } // namespace SVF

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -135,7 +135,10 @@ NodeID SVFIRBuilder::getExtID(ExtAPI::OperationType operationType, const std::st
     }
     // return value = -6 is an illegal operand format
     else
+    {
         assert(false && "The operand format of function operation is illegal!");
+        abort();
+    }
 }
 
 void SVFIRBuilder::parseAtomaticOp(SVF::ExtAPI::Operand &atomaticOp, const SVFCallInst* svfCall, std::map<std::string, NodeID> &nodeIDMap)
@@ -214,8 +217,8 @@ void SVFIRBuilder::parseExtFunctionOps(ExtAPI::ExtFunctionOps &extFunctionOps, c
 
 SVFCallInst* SVFIRBuilder::addSVFExtCallInst(const SVFCallInst* svfInst, SVFBasicBlock* svfBB, const SVFFunction* svfCaller, const SVFFunction* svfCallee)
 {
-    SVFCallInst* svfCall = new SVFCallInst("ext_inst", svfCallee->getFunctionType(), svfBB, false, false);
-    assert(svfCall && "Failed to create External SVFCallInst");
+    SVFCallInst* svfCall = new SVFCallInst(svfCallee->getFunctionType(), svfBB, false, false);
+    svfCall->setName("ext_inst");
     LLVMModuleSet::getLLVMModuleSet()->SVFValue2LLVMValue[svfCall] = nullptr;
     svfCall->setCalledOperand(svfCallee);
     setCurrentLocation(svfCall, svfBB);
@@ -293,8 +296,8 @@ SVFInstruction* SVFIRBuilder::addSVFExtInst(const std::string& instName, const S
     }
 
     assert(ptType != nullptr && "At least one argument of an external call is of pointer type!");
-    SVFInstruction* inst = new SVFInstruction(instName, ptType, svfBB, false, false);
-    assert(inst && "Failed to create External SVFInstruction!");
+    SVFInstruction* inst = new SVFInstruction(ptType, svfBB, false, false);
+    inst->setName(instName);
     LLVMModuleSet::getLLVMModuleSet()->SVFValue2LLVMValue[inst] = nullptr;
     svfBB->addInstruction(inst);
     SymbolTableInfo::ValueToIDMapTy::iterator iter = pag->getSymbolInfo()->valSyms().find(inst);
@@ -327,8 +330,8 @@ SVFBasicBlock* SVFIRBuilder::extFuncInitialization(const SVFCallInst* svfInst, S
         pag->addFunArgs(svfCaller,pag->getGNode(dstFA));
     }
 
-    SVFBasicBlock* svfBB = new SVFBasicBlock("ext_bb", svfInst->getParent()->getType(), svfCaller);
-    assert(svfBB && "Failed to create External SVFBasicBlock!");
+    SVFBasicBlock* svfBB = new SVFBasicBlock(svfInst->getParent()->getType(), svfCaller);
+    svfBB->setName("ext_bb");
     LLVMModuleSet::getLLVMModuleSet()->SVFValue2LLVMValue[svfBB] = nullptr;
 
     if (!svfCaller->isNotRetFunction())