C++ VariableId::isValid方法代码示例

void ExprWalker::visit(SgInitializedName* sgn)
{
  VariableId vid = vidm.variableId(sgn);
  
  // some SgInitializedName do not have symbols
  // VariableId is not created for such SgInitializedName
  // check and return if we are processing such SgInitializedName
  if(!vid.isValid()) {
    //cerr << "WARNING: Skipping SgInitializedName sgn->get_name() = " << sgn->get_name() << " with no symbol\n";
    return;
  }

  DefUseVarsInfo rduvi;
  SgInitializer* initializer = sgn->get_initializer();
  if(initializer) {
    rduvi = getDefUseVarsInfo_rec(initializer, vidm, false);
  }

  // SgInitializedName always define a variable
  // it should always be in def_set
  VarsInfo& def_vars_info = duvi.getDefVarsInfoMod();
  
  // determine the type info
  VariableIdTypeInfo sgn_type_info = getVariableIdTypeInfo(vid, vidm);

  if(vidm.getModeVariableIdForEachArrayElement() && sgn_type_info == arrayType)
    // When defining an array, define all its elements.
    duvi.addAllArrayElements(sgn, vidm, true);
  else
    def_vars_info.first.insert(VariableIdInfo(vid, sgn_type_info));

  duvi = duvi + rduvi;
}

VariableValueRangeInfo VariableConstInfo::createVariableValueRangeInfo(VariableId varId, VarConstSetMap& map) {
    ROSE_ASSERT(map.size()>0);
    ROSE_ASSERT(varId.isValid());
    set<CppCapsuleConstIntLattice> cppCapsuleSet=map[varId];
    AType::ConstIntLattice minVal;
    AType::ConstIntLattice maxVal;
    // in case the set of collected assignments is empty, bot is returned (min and max remain bot).
    if(cppCapsuleSet.size()==0)
        return VariableValueRangeInfo(AType::ConstIntLattice(AType::Bot()));
    for(set<CppCapsuleConstIntLattice>::iterator i=cppCapsuleSet.begin(); i!=cppCapsuleSet.end(); ++i) {
        AType::ConstIntLattice aint=(*i).getValue();
        if(aint.isTop()) {
            return VariableValueRangeInfo(AType::ConstIntLattice(AType::Top()));
        }

        if(minVal.isBot() && maxVal.isBot()) {
            minVal=aint;
            maxVal=aint;
            continue;
        }
        if((aint<minVal).isTrue())
            minVal=aint;
        if((aint>maxVal).isTrue())
            maxVal=aint;
    }
    if(minVal.isBot()||maxVal.isBot())
        return VariableValueRangeInfo(AType::ConstIntLattice(AType::Bot()));
    return VariableValueRangeInfo(minVal,maxVal);
}

// base case for the recursion
void SPRAY::ComputeAddressTakenInfo::OperandToVariableId::visit(SgVarRefExp *sgn)
{ 
  if(debuglevel > 0) debugPrint(sgn);
  VariableId id = cati.vidm.variableId(sgn);
  ROSE_ASSERT(id.isValid());
  // insert the id into VariableIdSet
  cati.addressTakenInfo.second.insert(id);
}

/*! 
  * \author Markus Schordan
  * \date 2012.
 */
string VariableIdMapping::uniqueShortVariableName(VariableId varId) {
  if(!isTemporaryVariableId(varId)) {
    if(!varId.isValid())
      return "$invalidId";
    else
      return variableName(varId)+"_"+varId.toString().substr(1);
    //return SgNodeHelper::uniqueLongVariableName(getSymbol(varId));
  } else {
    return string("tmp")+"_"+varId.toString().substr(1);
  }
}

VariableIdMapping::VariableIdSet VariableIdMapping::variableIdsOfAstSubTree(SgNode* node) {
  VariableIdSet vset;
  RoseAst ast(node);
  for(RoseAst::iterator i=ast.begin();i!=ast.end();++i) {
    VariableId vid; // default creates intentionally an invalid id.
    if(SgVariableDeclaration* varDecl=isSgVariableDeclaration(*i)) {
      vid=variableId(varDecl);
    } else if(SgVarRefExp* varRefExp=isSgVarRefExp(*i)) {
      vid=variableId(varRefExp);
    } else if(SgInitializedName* initName=isSgInitializedName(*i)) {
      vid=variableId(initName);
    }
    if(vid.isValid())
      vset.insert(vid);
  }
  return vset;
}

void ExprWalker::visit(SgVarRefExp* sgn)
{
  // get the VariableId
  VariableId vid = vidm.variableId(sgn);
  
  ROSE_ASSERT(vid.isValid());

  // determine type info
  VariableIdTypeInfo sgn_type_info = getVariableIdTypeInfo(vid, vidm); 

  VarsInfo& def_vars_info = duvi.getDefVarsInfoMod();
  VarsInfo& use_vars_info = duvi.getUseVarsInfoMod();

  if(isModExpr) {
    def_vars_info.first.insert(VariableIdInfo(vid, sgn_type_info));
  }
  else {
    use_vars_info.first.insert(VariableIdInfo(vid, sgn_type_info));
  }
}

//.........这里部分代码省略.........
              if(_variableIdMapping->hasArrayType(arrayVarId)) {
                // has already correct id
                // nothing to do
              } else if(_variableIdMapping->hasPointerType(arrayVarId)) {
                // in case it is a pointer retrieve pointer value
                //cout<<"DEBUG: pointer-array access!"<<endl;
                if(pstate->varExists(arrayVarId)) {
                  AValue aValuePtr=pstate2[arrayVarId].getValue();
                  // convert integer to VariableId
                  int aValueInt=aValuePtr.getIntValue();
                  // change arrayVarId to refered array!
                  //cout<<"DEBUG: defering pointer-to-array: ptr:"<<_variableIdMapping->variableName(arrayVarId);
                  arrayVarId=_variableIdMapping->variableIdFromCode(aValueInt);
                  //cout<<" to "<<_variableIdMapping->variableName(arrayVarId)<<endl;//DEBUG
                } else {
                  cerr<<"Error: pointer variable does not exist in PState."<<endl;
                  exit(1);
                }
              } else {
                cerr<<"Error: unkown type of array or pointer."<<endl;
                exit(1);
              }
              VariableId arrayElementId;
              AValue aValue=rhsResult.value();
              if(aValue.isConstInt()) {
                int index=aValue.getIntValue();
                arrayElementId=_variableIdMapping->variableIdOfArrayElement(arrayVarId,index);
                //cout<<"DEBUG: arrayElementVarId:"<<arrayElementId.toString()<<":"<<_variableIdMapping->variableName(arrayVarId)<<" Index:"<<index<<endl;
              } else {
                cerr<<"Error: array index cannot be evaluated to a constant. Not supported yet."<<endl;
                cerr<<"expr: "<<varRefExp->unparseToString()<<endl;
                exit(1);
              }
              ROSE_ASSERT(arrayElementId.isValid());
              // read value of variable var id (same as for VarRefExp - TODO: reuse)
              if(pstate->varExists(arrayElementId)) {
                res.result=pstate2[arrayElementId].getValue();
                //cout<<"DEBUG: retrieved value:"<<res.result<<endl;
                if(res.result.isTop() && useConstraints) {
                  AType::ConstIntLattice val=res.estate.constraints()->varConstIntLatticeValue(arrayElementId);
                  res.result=val;
                }
                return listify(res);
              } else {
                cerr<<"Error: Array Element does not exist (out of array access?)"<<endl;
                cerr<<"array-element-id: "<<arrayElementId.toString()<<" name:"<<_variableIdMapping->variableName(arrayElementId)<<endl;
                cerr<<"PState: "<<pstate->toString(_variableIdMapping)<<endl;
                cerr<<"AST: "<<node->unparseToString()<<endl;
                exit(1);
              }
            } else {
              cerr<<"Error: array-access uses expr for denoting the array. Not supported yet."<<endl;
              cerr<<"expr: "<<lhs->unparseToString()<<endl;
              cerr<<"arraySkip: "<<getSkipArrayAccesses()<<endl;
              exit(1);
            }
          }
          break;
        }
        default:
            cerr << "Binary Op:"<<SgNodeHelper::nodeToString(node)<<"(nodetype:"<<node->class_name()<<")"<<endl;
          throw "Error: evalConstInt::unkown binary operation.";
        }
      }
    }
    return resultList;