svf-tools 1.0.811 → 1.0.813

package/svf/lib/MemoryModel/AccessPath.cpp

@@ -41,14 +41,14 @@ using namespace SVFUtil;
  */
 bool AccessPath::addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType)
 {
-    offsetVarAndGepTypePairs.emplace_back(var, gepIterType);
+    idxOperandPairs.emplace_back(var, gepIterType);
     return true;
 }
 
 /// Return true if all offset values are constants
 bool AccessPath::isConstantOffset() const
 {
-    for(auto it : offsetVarAndGepTypePairs)
+    for(auto it : idxOperandPairs)
     {
         if(SVFUtil::isa<SVFConstantInt>(it.first->getValue()) == false)
             return false;
@@ -99,19 +99,19 @@ APOffset AccessPath::computeConstantByteOffset() const
     assert(isConstantOffset() && "not a constant offset");
 
     APOffset totalConstOffset = 0;
-    for(int i = offsetVarAndGepTypePairs.size() - 1; i >= 0; i--)
+    for(int i = idxOperandPairs.size() - 1; i >= 0; i--)
     {
         /// For example, there is struct DEST{int a, char b[10], int c[5]}
         /// (1) %c = getelementptr inbounds %struct.DEST, %struct.DEST* %arr, i32 0, i32 2
         //  (2) %arrayidx = getelementptr inbounds [10 x i8], [10 x i8]* %b, i64 0, i64 8
-        const SVFValue* value = offsetVarAndGepTypePairs[i].first->getValue();
+        const SVFValue* value = idxOperandPairs[i].first->getValue();
         /// for (1) offsetVarAndGepTypePairs.size()  = 2
         ///     i = 0, type: %struct.DEST*, PtrType, op = 0
         ///     i = 1, type: %struct.DEST, StructType, op = 2
         /// for (2) offsetVarAndGepTypePairs.size()  = 2
         ///     i = 0, type: [10 x i8]*, PtrType, op = 0
         ///     i = 1, type: [10 x i8], ArrType, op = 8
-        const SVFType* type = offsetVarAndGepTypePairs[i].second;
+        const SVFType* type = idxOperandPairs[i].second;
         /// if offsetVarAndGepTypePairs[i].second is nullptr, it means
         ///   GepStmt comes from external API, this GepStmt is assigned in SVFIRExtAPI.cpp
         ///   at SVFIRBuilder::getBaseTypeAndFlattenedFields ls.addOffsetVarAndGepTypePair()
@@ -154,6 +154,28 @@ APOffset AccessPath::computeConstantByteOffset() const
     return totalConstOffset;
 }
 
+/// Return byte offset from the beginning of the structure to the field where it is located for struct type
+///
+// e.g. idxOperandVar: i32 2  idxOperandType: %struct.Student = type { i32, [i8 x 12], i32 }
+//  we accumulate field 0 (i32) byte size (4 Bytes), and field 1 ([i8x12]) byte size (12 Bytes)
+//  then the return byte offset is 16 Bytes.
+u32_t AccessPath::getStructFieldOffset(const SVFVar* idxOperandVar, const SVFStructType* idxOperandType) const
+{
+    const SVFValue* idxValue = idxOperandVar->getValue();
+    u32_t structByteOffset = 0;
+    if (const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(idxValue))
+    {
+        for (u32_t structField = 0; structField < (u32_t)op->getSExtValue(); ++structField)
+        {
+            u32_t flattenIdx = idxOperandType->getTypeInfo()->getFlattenedFieldIdxVec()[structField];
+            structByteOffset += idxOperandType->getTypeInfo()->getOriginalElemType(flattenIdx)->getByteSize();
+        }
+        return structByteOffset;
+    }
+    else
+        assert(false && "struct type can only pair with constant idx");
+}
+
 /// Return accumulated constant offset
 ///
 /// "value" is the offset variable (must be a constant)
@@ -187,14 +209,14 @@ APOffset AccessPath::computeConstantOffset() const
 
     assert(isConstantOffset() && "not a constant offset");
 
-    if(offsetVarAndGepTypePairs.empty())
+    if(idxOperandPairs.empty())
         return getConstantFieldIdx();
 
     APOffset totalConstOffset = 0;
-    for(int i = offsetVarAndGepTypePairs.size() - 1; i >= 0; i--)
+    for(int i = idxOperandPairs.size() - 1; i >= 0; i--)
     {
-        const SVFValue* value = offsetVarAndGepTypePairs[i].first->getValue();
-        const SVFType* type = offsetVarAndGepTypePairs[i].second;
+        const SVFValue* value = idxOperandPairs[i].first->getValue();
+        const SVFType* type = idxOperandPairs[i].second;
         const SVFConstantInt* op = SVFUtil::dyn_cast<SVFConstantInt>(value);
         assert(op && "not a constant offset?");
         if(type==nullptr)
@@ -235,7 +257,7 @@ AccessPath AccessPath::operator+(const AccessPath& rhs) const
 {
     AccessPath ap(rhs);
     ap.fldIdx += getConstantFieldIdx();
-    for (auto &p : ap.getOffsetVarAndGepTypePairVec())
+    for (auto &p : ap.getIdxOperandPairVec())
         ap.addOffsetVarAndGepTypePair(p.first, p.second);
 
     return ap;
@@ -247,14 +269,14 @@ bool AccessPath::operator< (const AccessPath& rhs) const
         return (fldIdx < rhs.fldIdx);
     else
     {
-        const IdxVarAndGepTypePairs& pairVec = getOffsetVarAndGepTypePairVec();
-        const IdxVarAndGepTypePairs& rhsPairVec = rhs.getOffsetVarAndGepTypePairVec();
+        const IdxOperandPairs& pairVec = getIdxOperandPairVec();
+        const IdxOperandPairs& rhsPairVec = rhs.getIdxOperandPairVec();
         if (pairVec.size() != rhsPairVec.size())
             return (pairVec.size() < rhsPairVec.size());
         else
         {
-            IdxVarAndGepTypePairs::const_iterator it = pairVec.begin();
-            IdxVarAndGepTypePairs::const_iterator rhsIt = rhsPairVec.begin();
+            IdxOperandPairs::const_iterator it = pairVec.begin();
+            IdxOperandPairs::const_iterator rhsIt = rhsPairVec.begin();
             for (; it != pairVec.end() && rhsIt != rhsPairVec.end(); ++it, ++rhsIt)
             {
                 return (*it) < (*rhsIt);
@@ -294,9 +316,9 @@ std::string AccessPath::dump() const
 
     rawstr << "AccessPath\tField_Index: " << getConstantFieldIdx();
     rawstr << ",\tNum-Stride: {";
-    const IdxVarAndGepTypePairs& vec = getOffsetVarAndGepTypePairVec();
-    IdxVarAndGepTypePairs::const_iterator it = vec.begin();
-    IdxVarAndGepTypePairs::const_iterator eit = vec.end();
+    const IdxOperandPairs& vec = getIdxOperandPairVec();
+    IdxOperandPairs::const_iterator it = vec.begin();
+    IdxOperandPairs::const_iterator eit = vec.end();
     for (; it != eit; ++it)
     {
         const SVFType* ty = it->second;

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -1256,7 +1256,7 @@ cJSON* SVFIRWriter::toJson(const AccessPath& ap)
 {
     cJSON* root = jsonCreateObject();
     JSON_WRITE_FIELD(root, &ap, fldIdx);
-    JSON_WRITE_FIELD(root, &ap, offsetVarAndGepTypePairs);
+    JSON_WRITE_FIELD(root, &ap, idxOperandPairs);
     return root;
 }
 
@@ -1866,7 +1866,7 @@ void SVFIRReader::readJson(const cJSON* obj, AccessPath& ap)
     ABORT_IFNOT(jsonIsObject(obj), "Expected obj for AccessPath");
     obj = obj->child;
     JSON_READ_FIELD_FWD(obj, &ap, fldIdx);
-    JSON_READ_FIELD_FWD(obj, &ap, offsetVarAndGepTypePairs);
+    JSON_READ_FIELD_FWD(obj, &ap, idxOperandPairs);
     ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in AccessPath");
 }