svf-tools 1.0.828 → 1.0.830

package/svf/lib/SVFIR/SymbolTableInfo.cpp

@@ -258,6 +258,7 @@ void SymbolTableInfo::printFlattenFields(const SVFType* type)
     }
     else if (const SVFPointerType* pt= SVFUtil::dyn_cast<SVFPointerType>(type))
     {
+        // TODO: getPtrElementType to be removed
         u32_t eSize = getNumOfFlattenElements(pt->getPtrElementType());
         outs() << "  {Type: " << *pt << "}\n"
                << "\t [target size = " << eSize << "]\n"
@@ -373,7 +374,7 @@ bool ObjTypeInfo::isNonPtrFieldObj(const APOffset& apOffset)
     if (hasPtrObj() == false)
         return true;
 
-    const SVFType* ety = getType();
+    const SVFType* ety = type;
 
     if (SVFUtil::isa<SVFStructType, SVFArrayType>(ety))
     {

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

@@ -177,6 +177,7 @@ typedef llvm::VAStartInst VAStartInst;
 typedef llvm::BinaryOperator BinaryOperator;
 typedef llvm::UnaryOperator UnaryOperator;
 typedef llvm::UndefValue UndefValue;
+typedef llvm::GEPOperator GEPOperator;
 
 // Related to Switch Case
 typedef std::pair<const BasicBlock*, const ConstantInt*> SuccBBAndCondValPair;

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

@@ -126,6 +126,10 @@ static inline Type* getPtrElementType(const PointerType* pty)
 #endif
 }
 
+/// Infer type based on llvm value, this is for the migration to opaque pointer
+/// please refer to: https://llvm.org/docs/OpaquePointers.html#migration-instructions
+Type *getPointeeType(const Value *value);
+
 /// Get the reference type of heap/static object from an allocation site.
 //@{
 inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallBase* cs)
@@ -139,6 +143,7 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallBase* cs)
         int argPos = SVFUtil::getHeapAllocHoldingArgPosition(svfcs);
         const Value* arg = cs->getArgOperand(argPos);
         if (const PointerType *argType = SVFUtil::dyn_cast<PointerType>(arg->getType()))
+            // TODO: getPtrElementType need type inference
             refType = SVFUtil::dyn_cast<PointerType>(getPtrElementType(argType));
     }
     // Case 2: heap object held by return value.
@@ -389,6 +394,7 @@ inline u32_t SVFType2ByteSize(const SVFType* type)
     const llvm::Type* llvm_rhs = LLVMModuleSet::getLLVMModuleSet()->getLLVMType(type);
     const llvm::PointerType* llvm_rhs_ptr = SVFUtil::dyn_cast<PointerType>(llvm_rhs);
     assert(llvm_rhs_ptr && "not a pointer type?");
+    // TODO: getPtrElementType need type inference
     const Type *ptrElementType = getPtrElementType(llvm_rhs_ptr);
     u32_t llvm_rhs_size = LLVMUtil::getTypeSizeInBytes(ptrElementType);
     u32_t llvm_elem_size = -1;
@@ -496,7 +502,7 @@ const Argument* getConstructorThisPtr(const Function* fun);
 const Value* getVCallThisPtr(const CallBase* cs);
 const Value* getVCallVtblPtr(const CallBase* cs);
 s32_t getVCallIdx(const CallBase* cs);
-std::string getClassNameFromType(const Type* ty);
+std::string getClassNameFromType(const StructType* ty);
 std::string getClassNameOfThisPtr(const CallBase* cs);
 std::string getFunNameOfVCallSite(const CallBase* cs);
 bool VCallInCtorOrDtor(const CallBase* cs);
@@ -513,13 +519,10 @@ 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;
-}
+std::string dumpValue(const Value* val);
+
+std::string dumpType(const Type* type);
+
 
 /**
  * See more: https://github.com/SVF-tools/SVF/pull/1191

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

@@ -90,7 +90,7 @@ protected:
     /// Analyse types of all flattened fields of this object
     void analyzeObjType(ObjTypeInfo* typeinfo, const Value* val);
     /// Analyse types of heap and static objects
-    void analyzeHeapObjType(ObjTypeInfo* typeinfo, const Value* val);
+    u32_t analyzeHeapObjType(ObjTypeInfo* typeinfo, const Value* val);
     /// Analyse types of heap and static objects
     void analyzeStaticObjType(ObjTypeInfo* typeinfo, const Value* val);
 

package/svf-llvm/lib/LLVMModule.cpp

@@ -1384,6 +1384,7 @@ SVFType* LLVMModuleSet::addSVFTypeInfo(const Type* T)
         //cast svftype to SVFPointerType
         SVFPointerType* svfPtrType = SVFUtil::dyn_cast<SVFPointerType>(svftype);
         assert(svfPtrType && "this is not SVFPointerType");
+        // TODO: getPtrElementType to be removed
         svfPtrType->setPtrElementType(getSVFType(LLVMUtil::getPtrElementType(pt)));
     }
 

package/svf-llvm/lib/LLVMUtil.cpp

@@ -241,6 +241,71 @@ const Value* LLVMUtil::stripConstantCasts(const Value* val)
     return val;
 }
 
+/// Infer type based on llvm value, this is for the migration to opaque pointer
+/// please refer to: https://llvm.org/docs/OpaquePointers.html#migration-instructions
+Type *LLVMUtil::getPointeeType(const Value *value)
+{
+    assert(value && "value cannot be nullptr!");
+    if (const LoadInst *loadInst = SVFUtil::dyn_cast<LoadInst>(value))
+    {
+        // get the pointee type of rhs based on lhs
+        // e.g., for `%lhs = load i64, ptr %rhs`, we return i64
+        return loadInst->getType();
+    }
+    else if (const StoreInst *storeInst = SVFUtil::dyn_cast<StoreInst>(value))
+    {
+        // get the pointee type of op1 based on op0
+        // e.g., for `store i64 %op0, ptr %op1`, we return i64
+        return storeInst->getValueOperand()->getType();
+    }
+    else if (const GetElementPtrInst *gepInst = SVFUtil::dyn_cast<GetElementPtrInst>(value))
+    {
+        // get the source element type of a gep instruction
+        // e.g., for `gep %struct.foo, ptr %base, i64 0`, we return struct.foo
+        return gepInst->getSourceElementType();
+    }
+    else if (const GEPOperator* gepOperator = SVFUtil::dyn_cast<GEPOperator>(value))
+    {
+        // get the source element type of a gep instruction
+        // e.g., for `gep %struct.foo, ptr %base, i64 0`, we return struct.foo
+        return gepOperator->getSourceElementType();
+    }
+    else if (const CallInst *callInst = SVFUtil::dyn_cast<CallInst>(value))
+    {
+        // get the pointee type of return value
+        // e.g., for `%call = call ptr @_Znwm(i64 noundef 8)`, we return i64
+        return callInst->getFunctionType();
+    }
+    else if (const CallBase *callBase = SVFUtil::dyn_cast<CallBase>(value))
+    {
+        // get the pointee type of return value
+        // e.g., for `%call = call ptr @_Znwm(i64 noundef 8)`, we return i64
+        return callBase->getFunctionType();
+    }
+    else if (const AllocaInst *allocaInst = SVFUtil::dyn_cast<AllocaInst>(value))
+    {
+        // get the type of the allocated memory
+        // e.g., for `%retval = alloca i64, align 4`, we return i64
+        return allocaInst->getAllocatedType();
+    }
+    else if (const GlobalVariable *globalVar = SVFUtil::dyn_cast<GlobalVariable>(value))
+    {
+        // get the pointee type of the global pointer
+        return globalVar->getValueType();
+    }
+    else if (const Function* func = SVFUtil::dyn_cast<Function>(value))
+    {
+        // get the pointee type of return value
+        // e.g., for `%call = call ptr @_Znwm(i64 noundef 8)`, we return i64
+        return func->getFunctionType();
+    }
+    else
+    {
+        assert(false && (LLVMUtil::dumpValue(value) + "Unknown llvm Type, cannot get Ptr Element Type").c_str());
+        abort();
+    }
+}
+
 void LLVMUtil::viewCFG(const Function* fun)
 {
     if (fun != nullptr)
@@ -351,6 +416,7 @@ const Value* LLVMUtil::getFirstUseViaCastInst(const Value* val)
     const PointerType * type = SVFUtil::dyn_cast<PointerType>(val->getType());
     assert(type && "this value should be a pointer type!");
     /// If type is void* (i8*) and val is immediately used at a bitcast instruction
+    // TODO: getPtrElementType to be removed
     if (IntegerType *IT = SVFUtil::dyn_cast<IntegerType>(getPtrElementType(type)))
     {
         if (IT->getBitWidth() == 8)
@@ -397,6 +463,7 @@ const Type* LLVMUtil::getTypeOfHeapAlloc(const Instruction *inst)
     }
 
     assert(type && "not a pointer type?");
+    // TODO: getPtrElementType need type inference
     return getPtrElementType(type);
 }
 
@@ -922,6 +989,7 @@ bool LLVMUtil::isLoadVtblInst(const LoadInst* loadInst)
     const Type* elemTy = valTy;
     for (u32_t i = 0; i < 3; ++i)
     {
+        // TODO: getPtrElementType to be removed
         if (const PointerType* ptrTy = SVFUtil::dyn_cast<PointerType>(elemTy))
             elemTy = LLVMUtil::getPtrElementType(ptrTy);
         else
@@ -930,7 +998,13 @@ bool LLVMUtil::isLoadVtblInst(const LoadInst* loadInst)
     if (const FunctionType* functy = SVFUtil::dyn_cast<FunctionType>(elemTy))
     {
         const Type* paramty = functy->getParamType(0);
-        std::string className = LLVMUtil::getClassNameFromType(paramty);
+        std::string className = "";
+        if(const PointerType* ptrTy = SVFUtil::dyn_cast<PointerType>(paramty))
+        {
+            // TODO: getPtrElementType need type inference
+            if(const StructType* st = SVFUtil::dyn_cast<StructType>(getPtrElementType(ptrTy)))
+                className = LLVMUtil::getClassNameFromType(st);
+        }
         if (className.size() > 0)
         {
             return true;
@@ -1163,25 +1237,19 @@ bool LLVMUtil::VCallInCtorOrDtor(const CallBase* cs)
     return false;
 }
 
-std::string LLVMUtil::getClassNameFromType(const Type* ty)
+std::string LLVMUtil::getClassNameFromType(const StructType* ty)
 {
     std::string className = "";
-    if (const PointerType* ptrType = SVFUtil::dyn_cast<PointerType>(ty))
+    if (!((SVFUtil::cast<StructType>(ty))->isLiteral()))
     {
-        const Type* elemType = LLVMUtil::getPtrElementType(ptrType);
-        if (SVFUtil::isa<StructType>(elemType) &&
-                !((SVFUtil::cast<StructType>(elemType))->isLiteral()))
+        std::string elemTypeName = ty->getStructName().str();
+        if (elemTypeName.compare(0, clsName.size(), clsName) == 0)
         {
-            std::string elemTypeName = elemType->getStructName().str();
-            if (elemTypeName.compare(0, clsName.size(), clsName) == 0)
-            {
-                className = elemTypeName.substr(clsName.size());
-            }
-            else if (elemTypeName.compare(0, structName.size(), structName) ==
-                     0)
-            {
-                className = elemTypeName.substr(structName.size());
-            }
+            className = elemTypeName.substr(clsName.size());
+        }
+        else if (elemTypeName.compare(0, structName.size(), structName) == 0)
+        {
+            className = elemTypeName.substr(structName.size());
         }
     }
     return className;
@@ -1189,7 +1257,7 @@ std::string LLVMUtil::getClassNameFromType(const Type* ty)
 
 std::string LLVMUtil::getClassNameOfThisPtr(const CallBase* inst)
 {
-    std::string thisPtrClassName;
+    std::string thisPtrClassName = "";
     if (const MDNode* N = inst->getMetadata("VCallPtrType"))
     {
         const MDString* mdstr = SVFUtil::cast<MDString>(N->getOperand(0).get());
@@ -1198,7 +1266,10 @@ std::string LLVMUtil::getClassNameOfThisPtr(const CallBase* inst)
     if (thisPtrClassName.size() == 0)
     {
         const Value* thisPtr = LLVMUtil::getVCallThisPtr(inst);
-        thisPtrClassName = getClassNameFromType(thisPtr->getType());
+        if(const PointerType* ptrTy = SVFUtil::dyn_cast<PointerType>(thisPtr->getType()))
+            // TODO: getPtrElementType need type inference
+            if(const StructType* st = SVFUtil::dyn_cast<StructType>(getPtrElementType(ptrTy)))
+                thisPtrClassName = getClassNameFromType(st);
     }
 
     size_t found = thisPtrClassName.find_last_not_of("0123456789");
@@ -1285,6 +1356,29 @@ s64_t LLVMUtil::getCaseValue(const SwitchInst &switchInst, SuccBBAndCondValPair
     return val;
 }
 
+std::string LLVMUtil::dumpValue(const Value* val)
+{
+    std::string str;
+    llvm::raw_string_ostream rawstr(str);
+    if (val)
+        rawstr << " " << *val << " ";
+    else
+        rawstr << " llvm Value is null";
+    return rawstr.str();
+}
+
+std::string LLVMUtil::dumpType(const Type* type)
+{
+    std::string str;
+    llvm::raw_string_ostream rawstr(str);
+    if (type)
+        rawstr << " " << *type << " ";
+    else
+        rawstr << " llvm type is null";
+    return rawstr.str();
+}
+
+
 namespace SVF
 {
 

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -318,8 +318,10 @@ bool SVFIRBuilder::computeGepOffset(const User *V, AccessPath& ap)
             // If it's a non-constant offset access
             // If its point-to target is struct or array, it's likely an array accessing (%result = gep %struct.A* %a, i32 %non-const-index)
             // If its point-to target is single value (pointer arithmetic), then it's a variant gep (%result = gep i8* %p, i32 %non-const-index)
-            if(!op && gepTy->isPointerTy() && getPtrElementType(SVFUtil::dyn_cast<PointerType>(gepTy))->isSingleValueType())
+            if(!op && gepTy->isPointerTy() && LLVMUtil::getPointeeType(V)->isSingleValueType())
+            {
                 isConst = false;
+            }
 
             // The actual index
             //s32_t idx = op->getSExtValue();

package/svf-llvm/lib/SymbolTableBuilder.cpp

@@ -237,6 +237,7 @@ void SymbolTableBuilder::collectSVFTypeInfo(const Value* val)
     (void)getOrAddSVFTypeInfo(val->getType());
     if (const PointerType * ptrType = SVFUtil::dyn_cast<PointerType>(val->getType()))
     {
+        // TODO: getPtrElementType to be removed
         const Type* objtype = LLVMUtil::getPtrElementType(ptrType);
         (void)getOrAddSVFTypeInfo(objtype);
     }
@@ -575,6 +576,7 @@ void SymbolTableBuilder::handleGlobalInitializerCE(const Constant* C)
  */
 ObjTypeInfo* SymbolTableBuilder::createObjTypeInfo(const Value* val)
 {
+    /// TODO: getPtrElementType to be removed
     const PointerType* refTy = nullptr;
 
     const Instruction* I = SVFUtil::dyn_cast<Instruction>(val);
@@ -627,7 +629,8 @@ void SymbolTableBuilder::analyzeObjType(ObjTypeInfo* typeinfo, const Value* val)
 
     const PointerType* refty = SVFUtil::dyn_cast<PointerType>(val->getType());
     assert(refty && "this value should be a pointer type!");
-    Type* elemTy = getPtrElementType(refty);
+    // TODO: getPtrElementType need type inference
+    Type *elemTy = getPtrElementType(refty);
     bool isPtrObj = false;
     // Find the inter nested array element
     while (const ArrayType* AT = SVFUtil::dyn_cast<ArrayType>(elemTy))
@@ -753,20 +756,32 @@ u32_t SymbolTableBuilder::analyzeHeapAllocByteSize(const Value* val)
 /*!
  * Analyse types of heap and static objects
  */
-void SymbolTableBuilder::analyzeHeapObjType(ObjTypeInfo* typeinfo, const Value* val)
+u32_t SymbolTableBuilder::analyzeHeapObjType(ObjTypeInfo* typeinfo, const Value* val)
 {
     if(const Value* castUse = getFirstUseViaCastInst(val))
     {
         typeinfo->setFlag(ObjTypeInfo::HEAP_OBJ);
-        typeinfo->resetTypeForHeapStaticObj(
-            LLVMModuleSet::getLLVMModuleSet()->getSVFType(castUse->getType()));
+        const Type* objTy = getTypeOfHeapAlloc(SVFUtil::cast<Instruction>(val));
+        typeinfo->resetTypeForHeapStaticObj(LLVMModuleSet::getLLVMModuleSet()->getSVFType(objTy));
         analyzeObjType(typeinfo,castUse);
+        if(SVFUtil::isa<ArrayType>(objTy))
+            return getNumOfElements(objTy);
+        else if(const StructType* st = SVFUtil::dyn_cast<StructType>(objTy))
+        {
+            /// 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 PointerType at the cast site
+            if(getClassNameFromType(st).empty())
+                return getNumOfElements(objTy);
+            else
+                typeinfo->resetTypeForHeapStaticObj(LLVMModuleSet::getLLVMModuleSet()->getSVFType(castUse->getType()));
+        }
     }
     else
     {
         typeinfo->setFlag(ObjTypeInfo::HEAP_OBJ);
         typeinfo->setFlag(ObjTypeInfo::HASPTR_OBJ);
     }
+    return typeinfo->getMaxFieldOffsetLimit();
 }
 
 /*!
@@ -777,8 +792,7 @@ void SymbolTableBuilder::analyzeStaticObjType(ObjTypeInfo* typeinfo, const Value
     if(const Value* castUse = getFirstUseViaCastInst(val))
     {
         typeinfo->setFlag(ObjTypeInfo::STATIC_OBJ);
-        typeinfo->resetTypeForHeapStaticObj(
-            LLVMModuleSet::getLLVMModuleSet()->getSVFType(castUse->getType()));
+        typeinfo->resetTypeForHeapStaticObj(LLVMModuleSet::getLLVMModuleSet()->getSVFType(castUse->getType()));
         analyzeObjType(typeinfo,castUse);
     }
     else
@@ -844,9 +858,7 @@ void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val,
                  LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(
                      SVFUtil::cast<Instruction>(val))))
     {
-        analyzeHeapObjType(typeinfo,val);
-        // Heap object, label its field as infinite here
-        elemNum = typeinfo->getMaxFieldOffsetLimit();
+        elemNum = analyzeHeapObjType(typeinfo,val);
         // analyze heap alloc like (malloc/calloc/...), the alloc functions have
         // annotation like "AllocSize:Arg1". Please refer to extapi.c.
         // e.g. calloc(4, 10), annotation is "AllocSize:Arg0*Arg1",