svf-tools 1.0.404 → 1.0.407

package/lib/MTA/MHP.cpp

@@ -1045,7 +1045,7 @@ static bool accessSameArrayIndex(const GetElementPtrInst* ptr1, const GetElement
     {
         if(ConstantInt* ci = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand()))
         {
-            s64_t idx = ci->getSExtValue();
+            s32_t idx = ci->getSExtValue();
             ptr1vec.push_back(idx);
         }
         else
@@ -1058,7 +1058,7 @@ static bool accessSameArrayIndex(const GetElementPtrInst* ptr1, const GetElement
     {
         if(ConstantInt* ci = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand()))
         {
-            s64_t idx = ci->getSExtValue();
+            s32_t idx = ci->getSExtValue();
             ptr2vec.push_back(idx);
         }
         else

package/lib/MemoryModel/LocationSet.cpp

@@ -108,14 +108,14 @@ u32_t LocationSet::getElementNum(const Type* type) const{
 ///     value1: i64 0  type1: [3 x i8]*
 ///     value2: i64 2  type2: [3 x i8]
 ///     accumulateConstantOffset = 2
-s64_t LocationSet::accumulateConstantOffset() const{
+s32_t LocationSet::accumulateConstantOffset() const{
     
     assert(isConstantOffset() && "not a constant offset");
 
     if(offsetValues.empty())
         return accumulateConstantFieldIdx();
 
-    s64_t totalConstOffset = 0;
+    s32_t totalConstOffset = 0;
     for(int i = offsetValues.size() - 1; i >= 0; i--){
         const Value* value = offsetValues[i].first;
         const Type* type = offsetValues[i].second;
@@ -129,7 +129,7 @@ s64_t LocationSet::accumulateConstantOffset() const{
         if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type))
             totalConstOffset += op->getSExtValue() * getElementNum(pty->getElementType());
         else{
-            s64_t offset = op->getSExtValue();
+            s32_t offset = op->getSExtValue();
             u32_t flattenOffset = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(type, offset); 
             totalConstOffset += flattenOffset;
         }

package/lib/MemoryModel/PAGBuilderFromFile.cpp

@@ -103,7 +103,7 @@ SVFIR* PAGBuilderFromFile::build()
             {
                 NodeID nodeSrc;
                 NodeID nodeDst;
-                s64_t offsetOrCSId;
+                s32_t offsetOrCSId;
                 string edge;
                 istringstream ss(line);
                 ss >> nodeSrc;
@@ -144,7 +144,7 @@ SVFIR* PAGBuilderFromFile::build()
  * Add SVFIR edge according to a file format
  */
 void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
-                                 s64_t offsetOrCSId, std::string edge)
+                                 s32_t offsetOrCSId, std::string edge)
 {
 
     //check whether these two nodes available

package/lib/MemoryModel/SVFIR.cpp

@@ -455,7 +455,7 @@ NodeID SVFIR::addGepObjNode(const MemObj* obj, const LocationSet& ls)
     assert(0==GepObjVarMap.count(std::make_pair(base, ls))
            && "this node should not be created before");
 
-    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.accumulateConstantFieldIdx(), StInfo::getMaxFieldLimit());
+    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.accumulateConstantFieldIdx(), Options::MaxFieldLimit);
     GepObjVarMap[std::make_pair(base, ls)] = gepId;
     GepObjVar *node = new GepObjVar(obj, gepId, ls);
     memToFieldsMap[base].set(gepId);
@@ -559,7 +559,7 @@ NodeID SVFIR::getGepValVar(const Value* curInst, NodeID base, const LocationSet&
  * Get a base SVFVar given a pointer
  * Return the source node of its connected normal gep edge
  * Otherwise return the node id itself
- * s64_t offset : gep offset
+ * s32_t offset : gep offset
  */
 LocationSet SVFIR::getLocationSetFromBaseNode(NodeID nodeId)
 {

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -41,10 +41,9 @@ using namespace SVFUtil;
 
 DataLayout* SymbolTableInfo::dl = nullptr;
 SymbolTableInfo* SymbolTableInfo::symInfo = nullptr;
-u32_t StInfo::maxFieldLimit = 0;
 
 
-ObjTypeInfo::ObjTypeInfo(const Type* t, u32_t max) : type(t), flags(0), maxOffsetLimit(max)
+ObjTypeInfo::ObjTypeInfo(const Type* t, u32_t max) : type(t), flags(0), maxOffsetLimit(max), elemNum(max)
 {
     assert(t && "no type information for this object?");
 }
@@ -93,7 +92,7 @@ SymbolTableInfo::TypeToFieldInfoMap::iterator SymbolTableInfo::getStructInfoIter
  */
 ObjTypeInfo* SymbolTableInfo::createObjTypeInfo(const Type* type)
 {
-    ObjTypeInfo* typeInfo = new ObjTypeInfo(type, StInfo::getMaxFieldLimit());
+    ObjTypeInfo* typeInfo = new ObjTypeInfo(type, Options::MaxFieldLimit);
     if(type && type->isPointerTy()){
         typeInfo->setFlag(ObjTypeInfo::HEAP_OBJ);
         typeInfo->setFlag(ObjTypeInfo::HASPTR_OBJ);
@@ -200,7 +199,7 @@ void SymbolTableInfo::collectStructInfo(const StructType *sty)
                 sty->element_end(); it != ie; ++it)
     {
         const Type *et = *it;
-        /// offset with int_32 (s64_t) is large enough and will not cause overflow
+        /// offset with int_32 (s32_t) is large enough and will not cause overflow
         stinfo->addFldWithType(nf, et, strideOffset);
 
         if (SVFUtil::isa<StructType>(et) || SVFUtil::isa<ArrayType>(et))
@@ -269,7 +268,7 @@ LocationSet SymbolTableInfo::getModulusOffset(const MemObj* obj, const LocationS
     /// of current struct. Make the offset positive so we can still get a node within current
     /// struct to represent this obj.
 
-    s64_t offset = ls.accumulateConstantFieldIdx();
+    s32_t offset = ls.accumulateConstantFieldIdx();
     if(offset < 0)
     {
         writeWrnMsg("try to create a gep node with negative offset.");
@@ -405,7 +404,7 @@ u32_t SymbolTableInfo::getNumOfFlattenElements(const Type *T)
 }
 
 /// Flatterned offset information of a struct or an array including its array fields 
-u32_t SymbolTableInfo::getFlattenedElemIdx(const Type *T, s64_t origId)
+u32_t SymbolTableInfo::getFlattenedElemIdx(const Type *T, u32_t origId)
 {
     if(Options::ModelArrays){
         std::vector<u32_t>& so = getStructInfoIter(T)->second->getFlattenedElemIdxVec();
@@ -624,7 +623,7 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
  */
 void MemObj::setFieldSensitive()
 {
-    typeInfo->setMaxFieldOffsetLimit(StInfo::getMaxFieldLimit());
+    typeInfo->setMaxFieldOffsetLimit(typeInfo->getNumOfElements());
 }
 
 
@@ -648,17 +647,7 @@ bool MemObj::isBlackHoleObj() const
 /// Get obj type info
 const Type* MemObj::getType() const
 {
-    if (isHeap() == false)
-    {
-        if(const PointerType* type = SVFUtil::dyn_cast<PointerType>(typeInfo->getType()))
-            return type->getElementType();
-        else
-            return typeInfo->getType();
-    }
-    else if (getValue() && SVFUtil::isa<Instruction>(getValue()))
-        return SVFUtil::getTypeOfHeapAlloc(SVFUtil::cast<Instruction>(getValue()));
-    else
-        return typeInfo->getType();
+    return typeInfo->getType();
 }
 /*
  * Destroy the fields of the memory object

package/lib/SVF-FE/CPPUtil.cpp

@@ -55,7 +55,7 @@ const string structName = "struct.";
 
 static bool isOperOverload(const string name)
 {
-    s64_t leftnum = 0, rightnum = 0;
+    u32_t leftnum = 0, rightnum = 0;
     string subname = name;
     size_t leftpos, rightpos;
     leftpos = subname.find("<");
@@ -88,7 +88,7 @@ static string getBeforeParenthesis(const string &name)
     size_t lastRightParen = name.rfind(")");
     assert(lastRightParen > 0);
 
-    s64_t paren_num = 1, pos;
+    s32_t paren_num = 1, pos;
     for (pos = lastRightParen - 1; pos >= 0; pos--)
     {
         if (name[pos] == ')')
@@ -107,7 +107,7 @@ string cppUtil::getBeforeBrackets(const string &name)
     {
         return name;
     }
-    s64_t bracket_num = 1, pos;
+    s32_t bracket_num = 1, pos;
     for (pos = name.size() - 2; pos >= 0; pos--)
     {
         if (name[pos] == '>')
@@ -228,7 +228,7 @@ bool cppUtil::isLoadVtblInst(const LoadInst *loadInst)
     const Value *loadSrc = loadInst->getPointerOperand();
     const Type *valTy = loadSrc->getType();
     const Type *elemTy = valTy;
-    for (s64_t i = 0; i < 3; ++i)
+    for (u32_t i = 0; i < 3; ++i)
     {
         if (const PointerType *ptrTy = SVFUtil::dyn_cast<PointerType>(elemTy))
             elemTy = ptrTy->getElementType();

package/lib/SVF-FE/ICFGBuilder.cpp

@@ -123,7 +123,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                     /// branch condition value
                     const ConstantInt* condVal = const_cast<SwitchInst*>(si)->findCaseDest(const_cast<BasicBlock*>(succ->getParent()));
                     /// default case is set to -1;
-                    s64_t val = condVal ? condVal->getSExtValue() : -1;
+                    s32_t val = condVal ? condVal->getSExtValue() : -1;
                     icfg->addConditionalIntraEdge(srcNode, dstNode, si->getCondition(),val);
                 }
                 else

package/lib/SVF-FE/LLVMUtil.cpp

@@ -263,6 +263,23 @@ void SVFUtil::getPrevInsts(const Instruction* curInst, std::vector<const Instruc
     }
 }
 
+/*
+ * Get the first dominated cast instruction for heap allocations since they typically come from void* (i8*) 
+ * for example, %4 = call align 16 i8* @malloc(i64 10); %5 = bitcast i8* %4 to i32*
+ * return %5 whose type is i32* but not %4 whose type is i8*
+ */
+const Value* SVFUtil::getUniqueUseViaCastInst(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 only used at a bitcast instruction
+    if (IntegerType *IT = SVFUtil::dyn_cast<IntegerType>(type->getPointerElementType())){
+        if (IT->getBitWidth() == 8 && val->getNumUses()==1){
+            const Use *u = &*val->use_begin();
+            return SVFUtil::dyn_cast<BitCastInst>(u->getUser());
+        }
+    }
+    return nullptr;
+}
 
 /*!
  * Return the type of the object from a heap allocation
@@ -273,10 +290,10 @@ const Type* SVFUtil::getTypeOfHeapAlloc(const Instruction *inst)
 
     if(isHeapAllocExtCallViaRet(inst))
     {
-        const Instruction* nextInst = inst->getNextNode();
-        if(nextInst && nextInst->getOpcode() == Instruction::BitCast)
-            // we only consider bitcast instructions and ignore others (e.g., IntToPtr and ZExt)
-            type = SVFUtil::dyn_cast<PointerType>(inst->getNextNode()->getType());
+        if(const Value* v = getUniqueUseViaCastInst(inst)){
+            if(const PointerType* newTy = SVFUtil::dyn_cast<PointerType>(v->getType()))
+                type = newTy;
+        }
     }
     else if(isHeapAllocExtCallViaArg(inst))
     {
@@ -371,7 +388,7 @@ void SVFUtil::processArguments(int argc, char **argv, int &arg_num, char **arg_v
                                std::vector<std::string> &moduleNameVec)
 {
     bool first_ir_file = true;
-    for (s64_t i = 0; i < argc; ++i)
+    for (u32_t i = 0; i < argc; ++i)
     {
         std::string argument(argv[i]);
         if (SVFUtil::isIRFile(argument))

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -219,7 +219,7 @@ void SVFIRBuilder::initialiseNodes()
     e.g. field_idx = getelementptr i8, %struct_type %p, i64 1
 
 */
-u32_t SVFIRBuilder::inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s64_t idx){
+u32_t SVFIRBuilder::inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s32_t idx){
     return 0;
 }
 
@@ -238,7 +238,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
     llvm::APInt byteOffset(dataLayout->getIndexSizeInBits(gepOp->getPointerAddressSpace()),0,true);
     if(gepOp && dataLayout && gepOp->accumulateConstantOffset(*dataLayout,byteOffset))
     {
-        s64_t bo = byteOffset.getSExtValue();
+        s32_t bo = byteOffset.getSExtValue();
     }
 
     for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
@@ -256,7 +256,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
         if(SVFUtil::isa<ArrayType>(gepTy)){
             if(!op) 
                 continue;
-            s64_t idx = op->getSExtValue();
+            s32_t idx = op->getSExtValue();
             u32_t offset = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(gepTy, idx);
             ls.setFldIdx(ls.accumulateConstantFieldIdx() + offset);  
         }
@@ -264,7 +264,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
         {
             assert(op && "non-const offset accessing a struct");
             //The actual index
-            s64_t idx = op->getSExtValue();
+            s32_t idx = op->getSExtValue();
             u32_t offset = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(ST, idx);
             ls.setFldIdx(ls.accumulateConstantFieldIdx() + offset);
         }
@@ -277,7 +277,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
                 return false;              
             
             // The actual index
-            //s64_t idx = op->getSExtValue();
+            //s32_t idx = op->getSExtValue();
 
             // For pointer arithmetic we ignore the byte offset
             // consider using inferFieldIdxFromByteOffset(geopOp,dataLayout,ls,idx)?
@@ -871,7 +871,7 @@ void SVFIRBuilder::visitSwitchInst(SwitchInst &inst){
         const Instruction* succInst = &inst.getSuccessor(i)->front();
         const ConstantInt* condVal = inst.findCaseDest(inst.getSuccessor(i));
         /// default case is set to -1;
-        s64_t val = condVal ? condVal->getSExtValue() : -1;
+        s32_t val = condVal ? condVal->getSExtValue() : -1;
         const ICFGNode* icfgNode = pag->getICFG()->getICFGNode(succInst);
         successors.push_back(std::make_pair(icfgNode,val));
     }
@@ -977,7 +977,7 @@ const Value* SVFIRBuilder::getBaseValueForExtArg(const Value* V){
     const Value * value = stripAllCasts(V);
     assert(value && "null ptr?");
     if(const GetElementPtrInst* gep = SVFUtil::dyn_cast<GetElementPtrInst>(value)){
-        s64_t totalidx = 0;
+        s32_t totalidx = 0;
         for (bridge_gep_iterator gi = bridge_gep_begin(gep), ge = bridge_gep_end(gep); gi != ge; ++gi){
             if(const ConstantInt *op = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand()))
                 totalidx += op->getSExtValue();
@@ -1322,7 +1322,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 // We have vArg3 points to the entry of _Rb_tree_node_base { color; parent; left; right; }.
                 // Now we calculate the offset from base to vArg3
                 NodeID vnArg3 = pag->getValueNode(vArg3);
-                s64_t offset = pag->getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
+                s32_t offset = pag->getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
 
                 // We get all flattened fields of base
                 vector<LocationSet> fields;
@@ -1349,7 +1349,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
 
                 Value *vArg = cs.getArgument(0);
                 NodeID vnArg = pag->getValueNode(vArg);
-                s64_t offset = pag->getLocationSetFromBaseNode(vnArg).accumulateConstantFieldIdx();
+                s32_t offset = pag->getLocationSetFromBaseNode(vnArg).accumulateConstantFieldIdx();
 
                 // We get all fields
                 vector<LocationSet> fields;

package/lib/SVF-FE/SymbolTableBuilder.cpp

@@ -51,8 +51,6 @@ void SymbolTableBuilder::buildMemModel(SVFModule* svfModule)
 
     symInfo->setModule(svfModule);
 
-    StInfo::setMaxFieldLimit(Options::MaxFieldLimit);
-
     // Pointer #0 always represents the null pointer.
     assert(symInfo->totalSymNum++ == SymbolTableInfo::NullPtr && "Something changed!");
 
@@ -586,30 +584,12 @@ void SymbolTableBuilder::analyzeStaticObjType(ObjTypeInfo* typeinfo, const Value
     }
 }
 
-/*
- * Get the first dominated cast instruction for heap allocations since they typically come from void* (i8*) 
- * for example, %4 = call align 16 i8* @malloc(i64 10); %5 = bitcast i8* %4 to i32*
- * return %5 whose type is i32* but not %4 whose type is i8*
- */
-const Value* SymbolTableBuilder::getUniqueUseViaCastInst(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 only used at a bitcast instruction
-    if (IntegerType *IT = SVFUtil::dyn_cast<IntegerType>(type->getPointerElementType())){
-        if (IT->getBitWidth() == 8 && val->getNumUses()==1){
-            const Use *u = &*val->use_begin();
-            return SVFUtil::dyn_cast<BitCastInst>(u->getUser());
-        }
-    }
-    return nullptr;
-}
-
 /*!
  * Initialize the type info of an object
  */
 void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
     
-    s64_t objSize = 1;
+    s32_t objSize = 1;
     // Global variable
     if (SVFUtil::isa<Function>(val))
     {
@@ -652,6 +632,7 @@ void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
     else if(SVFUtil::isConstantData(val))
     {
         typeinfo->setFlag(ObjTypeInfo::CONST_DATA);
+        objSize = SymbolTableInfo::SymbolInfo()->getNumOfFlattenElements(val->getType());
     }
     else{
         assert("what other object do we have??");
@@ -660,7 +641,7 @@ void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
 
     // Reset maxOffsetLimit if it is over the total fieldNum of this object
     if(objSize > 0 && typeinfo->getMaxFieldOffsetLimit() > objSize)
-        typeinfo->setMaxFieldOffsetLimit(objSize);
+        typeinfo->setNumOfElements(objSize);
 }
 
 /*!

package/lib/Util/Conditions.cpp

@@ -182,7 +182,7 @@ void CondManager::printModel()
     z3::model m = sol.get_model();
     for (u32_t i = 0; i < m.size(); i++)
     {
-        z3::func_decl v = m[static_cast<s64_t>(i)];
+        z3::func_decl v = m[i];
         SVFUtil::outs() << v.name() << " = " << m.get_const_interp(v) << "\n";
     }
 }

package/lib/Util/TypeBasedHeapCloning.cpp

@@ -152,7 +152,7 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
 
     // totalOffset is the offset from the real base (i.e. base of base),
     // offset is the offset into base, whether it is a field itself or not.
-    s64_t totalOffset = offset;
+    s32_t totalOffset = offset;
     if (const GepObjVar *baseGep = SVFUtil::dyn_cast<GepObjVar>(baseNode))
     {
         totalOffset += baseGep->getConstantFieldIdx();

package/lib/WPA/AndersenSFR.cpp

@@ -96,7 +96,7 @@ bool AndersenSFR::processGepPts(PointsTo& pts, const GepCGEdge* edge)
             for (NodeID ptd : srcInits)
                 sortSrcInits.insert(ptd);
 
-            s64_t offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getConstantFieldIdx();
+            s32_t offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getConstantFieldIdx();
             fieldExpand(sortSrcInits, offset, dst->strides, tmpDstPts);
         }
 
@@ -116,7 +116,7 @@ bool AndersenSFR::processGepPts(PointsTo& pts, const GepCGEdge* edge)
 /*!
  *
  */
-void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides, PointsTo& expandPts)
+void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides, PointsTo& expandPts)
 {
     numOfFieldExpand++;
 
@@ -132,7 +132,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides,
             PAGNode* initPN = pag->getGNode(init);
             const MemObj* obj = pag->getBaseObj(init);
             const u32_t maxLimit = obj->getMaxFieldOffsetLimit();
-            s64_t initOffset;
+            s32_t initOffset;
             if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(initPN))
                 initOffset = gepNode->getConstantFieldIdx();
             else if (SVFUtil::isa<FIObjVar>(initPN) || SVFUtil::isa<DummyObjVar>(initPN))
@@ -140,7 +140,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides,
             else
                 assert(false && "Not an object node!!");
 
-            Set<s64_t> offsets;
+            Set<s32_t> offsets;
             offsets.insert(offset);
 
             // calculate offsets
@@ -151,7 +151,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides,
                 for (auto _f : offsets)
                     for (auto _s : strides)
                     {
-                        s64_t _f1 = _f + _s;
+                        s32_t _f1 = _f + _s;
                         loopFlag = (offsets.find(_f1) == offsets.end()) && (initOffset + _f1 < maxLimit);
                         if (loopFlag)
                             offsets.insert(_f1);
@@ -159,7 +159,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides,
             }
 
             // get gep objs
-            for (s64_t _f : offsets)
+            for (s32_t _f : offsets)
             {
                 NodeID gepId = consCG->getGepObjVar(init, LocationSet(_f));
                 initials.erase(gepId);  // gep id in initials should be removed to avoid redundant derivation

package/lib/WPA/CSC.cpp

@@ -73,7 +73,7 @@ void CSC::find(NodeStack& candidates)
 /*!
  *
  */
-void CSC::visit(NodeID nodeId, s64_t _w)
+void CSC::visit(NodeID nodeId, s32_t _w)
 {
 //    pwcReps[nodeId] = _scc->repNode(nodeId);
     setVisited(nodeId);
@@ -85,7 +85,7 @@ void CSC::visit(NodeID nodeId, s64_t _w)
     ConstraintNode* node = _consG->getConstraintNode(nodeId);
     for (ConstraintNode::const_iterator eit = node->directOutEdgeBegin(); eit != node->directOutEdgeEnd(); ++eit)
     {
-        s64_t offset;
+        s32_t offset;
         if (NormalGepCGEdge* gepCGEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(*eit))
             offset = gepCGEdge->getConstantFieldIdx();
         else
@@ -107,8 +107,8 @@ void CSC::visit(NodeID nodeId, s64_t _w)
         if (_consG->hasEdge(node, backNode, ConstraintEdge::NormalGep))
         {
             NormalGepCGEdge* normalGep = SVFUtil::dyn_cast<NormalGepCGEdge>(_consG->getEdge(node, backNode, ConstraintEdge::NormalGep));
-            s64_t _w = normalGep->getConstantFieldIdx();
-            s64_t _l = _D[nodeId] +_w - _D[backNodeId];
+            s32_t _w = normalGep->getConstantFieldIdx();
+            s32_t _l = _D[nodeId] +_w - _D[backNodeId];
             backNode->strides.set(_l);
             for (auto cNodeId : _C)
                 _consG->getConstraintNode(cNodeId)->strides.set(_l);
@@ -116,7 +116,7 @@ void CSC::visit(NodeID nodeId, s64_t _w)
         else if (_consG->hasEdge(node, backNode, ConstraintEdge::VariantGep) ||
                  _consG->hasEdge(node, backNode, ConstraintEdge::Copy))
         {
-            s64_t _l = _D[nodeId] - _D[backNodeId];
+            s32_t _l = _D[nodeId] - _D[backNodeId];
             backNode->strides.set(_l);
             for (auto cNodeId : _C)
                 _consG->getConstraintNode(cNodeId)->strides.set(_l);

package/lib/WPA/TypeAnalysis.cpp

@@ -104,7 +104,7 @@ void TypeAnalysis::dumpCHAStats()
         return;
     }
 
-    s64_t pure_abstract_class_num = 0,
+    u32_t pure_abstract_class_num = 0,
           multi_inheritance_class_num = 0;
     for (CHGraph::const_iterator it = chgraph->begin(), eit = chgraph->end();
             it != eit; ++it)
@@ -127,7 +127,7 @@ void TypeAnalysis::dumpCHAStats()
      * vtbl max vfunction
      * pure abstract class
      */
-    s64_t vtblnum = 0,
+    u32_t vtblnum = 0,
           vfunc_total = 0,
           vtbl_max = 0,
           pure_abstract = 0;
@@ -139,7 +139,7 @@ void TypeAnalysis::dumpCHAStats()
         if (node->isPureAbstract())
             pure_abstract++;
 
-        s64_t vfuncs_size = 0;
+        u32_t vfuncs_size = 0;
         const vector<CHNode::FuncVector>& vecs = node->getVirtualFunctionVectors();
         for (vector<CHNode::FuncVector>::const_iterator vit = vecs.begin(),
                 veit = vecs.end(); vit != veit; ++vit)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.404",
+  "version": "1.0.407",
   "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": {