update based on comments

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

@@ -36,8 +36,6 @@
 #include "SVFIR/SVFValue.h"
 #include "Util/ThreadAPI.h"
 
-#define VALUE_WITH_DBGINFO(value)                                              \
-    LLVMUtil::dumpValue(value) + LLVMUtil::getSourceLoc(value)
 
 namespace SVF
 {
@@ -133,13 +131,6 @@ static inline Type* getPtrElementType(const PointerType* pty)
 u32_t getNumOfElements(const Type* ety);
 
 
-/// Select the largest (conservative) type from all types
-const Type* selectLargestType(std::vector<const Type*>& objTys);
-
-u32_t getArgNoInCallBase(const CallBase* callBase, const Value* arg);
-
-
-
 /// Return true if this value refers to a object
 bool isObject(const Value* ref);
 
@@ -473,6 +464,7 @@ std::string dumpValue(const Value* val);
 
 std::string dumpType(const Type* type);
 
+std::string dumpValueAndDbgInfo(const Value* val);
 
 /**
  * See more: https://github.com/SVF-tools/SVF/pull/1191

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

@@ -85,10 +85,10 @@ class SymbolTableBuilder
     // @}
 
 
-    std::unique_ptr<TypeInference> & getTypeInference();
+    TypeInference* getTypeInference();
 
     /// Forward collect all possible infer sites starting from a value
-    const Type* getOrInferLLVMObjType(const Value *startValue);
+    const Type* inferObjType(const Value *startValue);
 
     /// Get the reference type of heap/static object from an allocation site.
     //@{

svf-llvm/include/SVF-LLVM/TypeInference.h

@@ -46,7 +46,7 @@ class TypeInference {
 
 
 private:
-    static std::unique_ptr<TypeInference> _typeInference;
+    static TypeInference* _typeInference;
     ValueToInferSites _valueToInferSites; // value inference site cache
     ValueToType _valueToType; // value type cache
     ValueToSources _valueToAllocs; // value allocations (stack, static, heap) cache
@@ -58,15 +58,20 @@ class TypeInference {
     ~TypeInference() = default;
 
     /// Singleton
-    static inline std::unique_ptr<TypeInference> &getTypeInference() {
+    static inline TypeInference *getTypeInference() {
         if (_typeInference == nullptr) {
-            _typeInference = std::unique_ptr<TypeInference>(new TypeInference());
+            _typeInference = new TypeInference();
         }
         return _typeInference;
     }
 
+    static void releaseTypeInference() {
+        delete _typeInference;
+        _typeInference = nullptr;
+    }
+
     /// get or infer the type of a value
-    const Type *getOrInferLLVMObjType(const Value *startValue);
+    const Type *inferObjType(const Value *startValue);
 
     /// Validate type inference
     void validateTypeCheck(const CallBase *cs);
@@ -88,10 +93,10 @@ class TypeInference {
 private:
 
     /// Forward collect all possible infer sites starting from a value
-    const Type *fwGetOrInferLLVMObjType(const Value *startValue);
+    const Type *fwInferObjType(const Value *startValue);
 
     /// Backward collect all possible allocation sites (stack, static, heap) starting from a value
-    Set<const Value *> bwGetOrfindAllocations(const Value *startValue);
+    Set<const Value *> bwfindAllocations(const Value *startValue);
 
     /// Determine type based on infer site
     static const Type *infersiteToType(const Value *val);
@@ -100,6 +105,12 @@ class TypeInference {
         return LLVMUtil::isObject(val);
     }
 
+public:
+    /// Select the largest (conservative) type from all types
+    const Type *selectLargestType(std::vector<const Type *> &objTys);
+
+    u32_t getArgNoInCallBase(const CallBase *callBase, const Value *arg);
+
 };
 }
 #endif //SVF_TYPEINFERENCE_H

svf-llvm/lib/LLVMUtil.cpp

@@ -364,12 +364,7 @@ const Value* LLVMUtil::getFirstUseViaCastInst(const Value* val)
     return latestUse;
 }
 
-u32_t LLVMUtil::getArgNoInCallBase(const CallBase *callBase, const Value *arg) {
-    assert(callBase->hasArgument(arg) && "callInst does not have argument arg?");
-    auto it = std::find(callBase->arg_begin(), callBase->arg_end(), arg);
-    assert(it != callBase->arg_end() && "Didn't find argument?");
-    return std::distance(callBase->arg_begin(), it);
-}
+
 
 
 /*!
@@ -390,28 +385,6 @@ u32_t LLVMUtil::getNumOfElements(const Type* ety)
 }
 
 
-const Type* LLVMUtil::selectLargestType(std::vector<const Type*>& objTys) {
-    if(objTys.empty()) return nullptr;
-    // map type size to types from with key in descending order
-    OrderedMap<u32_t, Set<const Type*>, std::greater<int>> typeSzToTypes;
-    for (const Type *ty: objTys) {
-        u32_t num = Options::MaxFieldLimit();
-        if (SVFUtil::isa<ArrayType>(ty))
-            num = getNumOfElements(ty);
-        else if (const StructType *st = SVFUtil::dyn_cast<StructType>(ty)) {
-            /// For an C++ class, it can have variant elements depending on the vtable size,
-            /// Hence we only handle non-cpp-class object, the type of the cpp class is treated as default PointerType
-            if (!classTyHasVTable(st))
-                num = getNumOfElements(st);
-        }
-        typeSzToTypes[num].insert(ty);
-    }
-    assert(!typeSzToTypes.empty() && "typeSzToTypes cannot be empty");
-    const std::pair<u32_t, Set<const Type*>> &largestElement = *typeSzToTypes.begin();
-    assert(!largestElement.second.empty() && "largest element cannot be empty");
-    return *largestElement.second.begin();
-}
-
 /*!
  * Get the num of BB's predecessors
  */
@@ -1250,6 +1223,8 @@ std::string LLVMUtil::dumpValue(const Value* val)
     return rawstr.str();
 }
 
+
+
 std::string LLVMUtil::dumpType(const Type* type)
 {
     std::string str;
@@ -1261,6 +1236,15 @@ std::string LLVMUtil::dumpType(const Type* type)
     return rawstr.str();
 }
 
+std::string LLVMUtil::dumpValueAndDbgInfo(const Value *val) {
+    std::string str;
+    llvm::raw_string_ostream rawstr(str);
+    if (val)
+        rawstr << dumpValue(val) << getSourceLoc(val);
+    else
+        rawstr << " llvm Value is null";
+    return rawstr.str();
+}
 
 namespace SVF
 {

svf-llvm/lib/SVFIRExtAPI.cpp

@@ -44,7 +44,7 @@ const Type* SVFIRBuilder::getBaseTypeAndFlattenedFields(const Value* V, std::vec
 {
     assert(V);
     const Value* value = getBaseValueForExtArg(V);
-    const Type *objType = TypeInference::getTypeInference()->getOrInferLLVMObjType(value);
+    const Type *objType = TypeInference::getTypeInference()->inferObjType(value);
     u32_t numOfElems = pag->getSymbolInfo()->getNumOfFlattenElements(LLVMModuleSet::getLLVMModuleSet()->getSVFType(objType));
     /// use user-specified size for this copy operation if the size is a constaint int
     if(szValue && SVFUtil::isa<ConstantInt>(szValue))

svf-llvm/lib/SymbolTableBuilder.cpp

@@ -570,13 +570,13 @@ void SymbolTableBuilder::handleGlobalInitializerCE(const Constant* C)
     }
 }
 
-std::unique_ptr<TypeInference> & SymbolTableBuilder::getTypeInference() {
+TypeInference *SymbolTableBuilder::getTypeInference() {
     return TypeInference::getTypeInference();
 }
 
 
-const Type* SymbolTableBuilder::getOrInferLLVMObjType(const Value *startValue) {
-    return getTypeInference()->getOrInferLLVMObjType(startValue);
+const Type* SymbolTableBuilder::inferObjType(const Value *startValue) {
+    return getTypeInference()->inferObjType(startValue);
 }
 
 /*!
@@ -597,15 +597,15 @@ const Type* SymbolTableBuilder::inferTypeOfHeapObjOrStaticObj(const Instruction
                 originalPType = newTy;
             }
         }
-        inferedType = getOrInferLLVMObjType(startValue);
+        inferedType = inferObjType(startValue);
     }
     else if(SVFUtil::isHeapAllocExtCallViaArg(svfinst))
     {
         const CallBase* cs = LLVMUtil::getLLVMCallSite(inst);
         int arg_pos = SVFUtil::getHeapAllocHoldingArgPosition(SVFUtil::getSVFCallSite(svfinst));
         const Value* arg = cs->getArgOperand(arg_pos);
         originalPType = SVFUtil::dyn_cast<PointerType>(arg->getType());
-        inferedType = getOrInferLLVMObjType(startValue = arg);
+        inferedType = inferObjType(startValue = arg);
     }
     else
     {
@@ -650,7 +650,7 @@ ObjTypeInfo* SymbolTableBuilder::createObjTypeInfo(const Value* val)
             }
             else
             {
-                SVFUtil::errs() << VALUE_WITH_DBGINFO(val) << "\n";
+                SVFUtil::errs() << dumpValueAndDbgInfo(val) << "\n";
                 assert(false && "not an allocation or global?");
             }
         }

svf-llvm/lib/TypeInference.cpp

@@ -71,7 +71,7 @@ using namespace SVF;
 using namespace SVFUtil;
 using namespace LLVMUtil;
 
-std::unique_ptr<TypeInference> TypeInference::_typeInference = nullptr;
+TypeInference *TypeInference::_typeInference = nullptr;
 
 const std::string TYPEMALLOC = "TYPE_MALLOC";
 
@@ -88,16 +88,16 @@ const Type *TypeInference::defaultTy(const Value *val) {
 
 /*!
  * get or infer type of a value
- * if the start value is a source (alloc/global, heap, static), call fwGetOrInferLLVMObjType
+ * if the start value is a source (alloc/global, heap, static), call fwInferObjType
  * if not, find sources and then forward get or infer types
  * @param startValue
  */
-const Type *TypeInference::getOrInferLLVMObjType(const Value *startValue) {
-    if (isAllocation(startValue)) return fwGetOrInferLLVMObjType(startValue);
-    Set<const Value *> sources = TypeInference::getTypeInference()->bwGetOrfindAllocations(startValue);
+const Type *TypeInference::inferObjType(const Value *startValue) {
+    if (isAllocation(startValue)) return fwInferObjType(startValue);
+    Set<const Value *> sources = TypeInference::getTypeInference()->bwfindAllocations(startValue);
     std::vector<const Type *> types;
     for (const auto &source: sources) {
-        types.push_back(TypeInference::getTypeInference()->fwGetOrInferLLVMObjType(source));
+        types.push_back(TypeInference::getTypeInference()->fwInferObjType(source));
     }
     return selectLargestType(types);
 }
@@ -106,7 +106,7 @@ const Type *TypeInference::getOrInferLLVMObjType(const Value *startValue) {
  * Forward collect all possible infer sites starting from a value
  * @param startValue
  */
-const Type *TypeInference::fwGetOrInferLLVMObjType(const Value *startValue) {
+const Type *TypeInference::fwInferObjType(const Value *startValue) {
     // consult cache
     auto tIt = _valueToType.find(startValue);
     if (tIt != _valueToType.end()) {
@@ -279,7 +279,7 @@ const Type *TypeInference::fwGetOrInferLLVMObjType(const Value *startValue) {
     const Type *type = _valueToType[startValue];
     if (type == nullptr) {
         type = defaultTy(startValue);
-        WARN_MSG("Using default type, trace ID is " + std::to_string(traceId) + ":" + VALUE_WITH_DBGINFO(startValue));
+        WARN_MSG("Using default type, trace ID is " + std::to_string(traceId) + ":" + dumpValueAndDbgInfo(startValue));
     }
     return type;
 }
@@ -289,12 +289,12 @@ const Type *TypeInference::fwGetOrInferLLVMObjType(const Value *startValue) {
  * @param startValue 
  * @return 
  */
-Set<const Value *> TypeInference::bwGetOrfindAllocations(const Value *startValue) {
+Set<const Value *> TypeInference::bwfindAllocations(const Value *startValue) {
 
     // consult cache
     auto tIt = _valueToAllocs.find(startValue);
     if (tIt != _valueToAllocs.end()) {
-        WARN_IFNOT(!tIt->second.empty(), "empty type:" + VALUE_WITH_DBGINFO(startValue));
+        WARN_IFNOT(!tIt->second.empty(), "empty type:" + dumpValueAndDbgInfo(startValue));
         return !tIt->second.empty() ? tIt->second : Set<const Value *>({startValue});
     }
 
@@ -356,7 +356,7 @@ Set<const Value *> TypeInference::bwGetOrfindAllocations(const Value *startValue
                 }
             }
         } else if (const CallBase *callBase = SVFUtil::dyn_cast<CallBase>(curValue)) {
-            ABORT_IFNOT(!callBase->doesNotReturn(), "callbase does not return:" + VALUE_WITH_DBGINFO(callBase));
+            ABORT_IFNOT(!callBase->doesNotReturn(), "callbase does not return:" + dumpValueAndDbgInfo(callBase));
             if (Function *callee = callBase->getCalledFunction()) {
                 if (!callee->isDeclaration()) {
                     const SVFFunction *svfFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(callee);
@@ -374,7 +374,7 @@ Set<const Value *> TypeInference::bwGetOrfindAllocations(const Value *startValue
     Set<const Value *> srcs = _valueToAllocs[startValue];
     if (srcs.empty()) {
         srcs = {startValue};
-        WARN_MSG("Using default type, trace ID is " + std::to_string(traceId) + ":" + VALUE_WITH_DBGINFO(startValue));
+        WARN_MSG("Using default type, trace ID is " + std::to_string(traceId) + ":" + dumpValueAndDbgInfo(startValue));
     }
     return srcs;
 }
@@ -386,7 +386,7 @@ Set<const Value *> TypeInference::bwGetOrfindAllocations(const Value *startValue
 void TypeInference::validateTypeCheck(const CallBase *cs) {
     if (const Function *func = cs->getCalledFunction()) {
         if (func->getName().find(TYPEMALLOC) != std::string::npos) {
-            const Type *objType = fwGetOrInferLLVMObjType(cs);
+            const Type *objType = fwInferObjType(cs);
             ConstantInt *pInt =
                     SVFUtil::dyn_cast<llvm::ConstantInt>(cs->getOperand(1));
             assert(pInt && "the second argument is a integer");
@@ -400,11 +400,11 @@ void TypeInference::validateTypeCheck(const CallBase *cs) {
                     iTyNum = getNumOfElements(st);
             }
             if (iTyNum >= pInt->getZExtValue())
-                SVFUtil::outs() << SVFUtil::sucMsg("\t SUCCESS :") << VALUE_WITH_DBGINFO(cs)
+                SVFUtil::outs() << SVFUtil::sucMsg("\t SUCCESS :") << dumpValueAndDbgInfo(cs)
                                 << SVFUtil::pasMsg(" TYPE: ")
                                 << dumpType(objType) << "\n";
             else {
-                SVFUtil::errs() << SVFUtil::errMsg("\t FAILURE :") << ":" << VALUE_WITH_DBGINFO(cs) << " TYPE: "
+                SVFUtil::errs() << SVFUtil::errMsg("\t FAILURE :") << ":" << dumpValueAndDbgInfo(cs) << " TYPE: "
                                 << dumpType(objType) << "\n";
                 abort();
             }
@@ -427,7 +427,7 @@ void TypeInference::typeSizeDiffTest(const PointerType *oPTy, const Type *iTy, c
     if (getNumOfElements(oTy) > iTyNum) {
         ERR_MSG("original type is:" + dumpType(oTy));
         ERR_MSG("infered type is:" + dumpType(iTy));
-        ABORT_MSG("wrong type, trace ID is " + std::to_string(traceId) + ":" + VALUE_WITH_DBGINFO(val));
+        ABORT_MSG("wrong type, trace ID is " + std::to_string(traceId) + ":" + dumpValueAndDbgInfo(val));
     }
 #endif
 }
@@ -447,6 +447,36 @@ const Type *TypeInference::infersiteToType(const Value *val) {
     } else if (const GlobalValue *globalValue = SVFUtil::dyn_cast<GlobalValue>(val)) {
         return globalValue->getValueType();
     } else {
-        ABORT_MSG("unknown value:" + VALUE_WITH_DBGINFO(val));
+        ABORT_MSG("unknown value:" + dumpValueAndDbgInfo(val));
     }
-}
+}
+
+u32_t TypeInference::getArgNoInCallBase(const CallBase *callBase, const Value *arg) {
+    assert(callBase->hasArgument(arg) && "callInst does not have argument arg?");
+    auto it = std::find(callBase->arg_begin(), callBase->arg_end(), arg);
+    assert(it != callBase->arg_end() && "Didn't find argument?");
+    return std::distance(callBase->arg_begin(), it);
+}
+
+
+const Type *TypeInference::selectLargestType(std::vector<const Type *> &objTys) {
+    if (objTys.empty()) return nullptr;
+    // map type size to types from with key in descending order
+    OrderedMap<u32_t, Set<const Type *>, std::greater<int>> typeSzToTypes;
+    for (const Type *ty: objTys) {
+        u32_t num = Options::MaxFieldLimit();
+        if (SVFUtil::isa<ArrayType>(ty))
+            num = getNumOfElements(ty);
+        else if (const StructType *st = SVFUtil::dyn_cast<StructType>(ty)) {
+            /// For an C++ class, it can have variant elements depending on the vtable size,
+            /// Hence we only handle non-cpp-class object, the type of the cpp class is treated as default PointerType
+            if (!classTyHasVTable(st))
+                num = getNumOfElements(st);
+        }
+        typeSzToTypes[num].insert(ty);
+    }
+    assert(!typeSzToTypes.empty() && "typeSzToTypes cannot be empty");
+    const std::pair<u32_t, Set<const Type *>> &largestElement = *typeSzToTypes.begin();
+    assert(!largestElement.second.empty() && "largest element cannot be empty");
+    return *largestElement.second.begin();
+}

svf-llvm/tools/CFL/cfl.cpp

@@ -34,6 +34,8 @@
 #include "SVF-LLVM/SVFIRBuilder.h"
 #include "CFL/CFLAlias.h"
 #include "CFL/CFLVF.h"
+#include "SVF-LLVM/TypeInference.h"
+
 
 using namespace llvm;
 using namespace SVF;
@@ -83,6 +85,8 @@ int main(int argc, char ** argv)
     SVFIR::releaseSVFIR();
     SVF::LLVMModuleSet::releaseLLVMModuleSet();
 
+    TypeInference::releaseTypeInference();
+
     return 0;
 
 }