svf-tools 1.0.829 → 1.0.830

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;

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
@@ -933,6 +1001,7 @@ bool LLVMUtil::isLoadVtblInst(const LoadInst* loadInst)
         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);
         }
@@ -1198,6 +1267,7 @@ std::string LLVMUtil::getClassNameOfThisPtr(const CallBase* inst)
     {
         const Value* thisPtr = LLVMUtil::getVCallThisPtr(inst);
         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);
     }

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))