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

VariableId VariableIdMapping::variableIdOfArrayElement(VariableId arrayVar, int elemIndex) {
  int idCode = arrayVar.getIdCode();
  int elemIdCode = idCode + elemIndex;
  VariableId elemVarId;
  elemVarId.setIdCode(elemIdCode);
  return elemVarId;
}

/*! 
  * \author Markus Schordan
  * \date 2013.
 */
void RDTransferFunctions::transferExpression(Label lab, SgExpression* node, Lattice& element0) {
  RDLattice* element1=dynamic_cast<RDLattice*>(&element0);
  ROSE_ASSERT(element1);
  RDLattice& element=*element1;
  // update analysis information
  // this is only correct for RERS12-C programs
  // 1) remove all pairs with lhs-variableid
  // 2) add (lab,lhs.varid)

  // (for programs with pointers we require a set here)
  VariableIdSet defVarIds=AnalysisAbstractionLayer::defVariables(node,*_variableIdMapping);  
  ROSE_ASSERT(_pointerAnalysisInterface);
  if(hasDereferenceOperation(node)) {
    VariableIdSet modVarIds=_pointerAnalysisInterface->getModByPointer();
    // union sets
    defVarIds+=modVarIds;
  }
  if(defVarIds.size()>1 /* TODO: || existsArrayVarId(defVarIds)*/ ) {
    // If an unknown array element is referenced, we consider
    // all its elements modified in the same statement.
    // Here *var* is an array element if its symbol is equal to at
    // least one of those corresponding to VariableIds with next or previous ids.
    for(VariableIdMapping::VariableIdSet::iterator i=defVarIds.begin();i!=defVarIds.end();++i) {
      VariableId var = *i;
      VariableId prev_var_id;
      VariableId next_var_id;
      prev_var_id.setIdCode(var.getIdCode() - 1);
      next_var_id.setIdCode(var.getIdCode() + 1);
      SgSymbol *var_smb = _variableIdMapping->getSymbol(var);
      SgSymbol *prev_var_smb = _variableIdMapping->getSymbol(prev_var_id);
      SgSymbol *next_var_smb = _variableIdMapping->getSymbol(next_var_id);
      if((var_smb == prev_var_smb) || (var_smb == next_var_smb))
        element.removeAllPairsWithVariableId(var);
    }
    // since multiple memory locations may be modified, we cannot know which one will be updated and can only add information
    for(VariableIdMapping::VariableIdSet::iterator i=defVarIds.begin();i!=defVarIds.end();++i) {
      element.insertPair(lab,*i);
    }
  } else if(defVarIds.size()==1) {
    // one unique memory location (variable). We can remove all pairs with this variable
    VariableId var=*defVarIds.begin();
    element.removeAllPairsWithVariableId(var);
    element.insertPair(lab,var);
  }
}

//NOTE: missing: UD must take uses in initializers into account
void RDTransferFunctions::transferDeclaration(Label lab, SgVariableDeclaration* declnode, Lattice& element0) {
  RDLattice& element=dynamic_cast<RDLattice&>(element0);
  //  ROSE_ASSERT(element1);
  //RDLattice& element=*element1;

  SgInitializedName* node=SgNodeHelper::getInitializedNameOfVariableDeclaration(declnode);
  ROSE_ASSERT(node);
  // same as in transferExpression ... needs to be refined
  VariableIdSet defVarIds=AnalysisAbstractionLayer::defVariables(node,*_variableIdMapping);  
  if(defVarIds.size()>1 /* TODO: || existsArrayVarId(defVarIds)*/ ) {
    // If an array is defined, we add all its elements to def set.
    // Remove pairs corresponding to array elements as in transferExpression()
    // but now assert that only elements of one array were modified.
    unsigned elements = 0;
    SgSymbol *array_smb = _variableIdMapping->getSymbol(*(defVarIds.begin()));
    for(VariableIdMapping::VariableIdSet::iterator i=defVarIds.begin();i!=defVarIds.end();++i) {
      VariableId var = *i;
      VariableId prev_var_id;
      VariableId next_var_id;
      prev_var_id.setIdCode(var.getIdCode() - 1);
      next_var_id.setIdCode(var.getIdCode() + 1);
      SgSymbol *var_smb = _variableIdMapping->getSymbol(var);
      SgSymbol *prev_var_smb = _variableIdMapping->getSymbol(prev_var_id);
      SgSymbol *next_var_smb = _variableIdMapping->getSymbol(next_var_id);
      if((var_smb == prev_var_smb) || (var_smb == next_var_smb)) {
        element.removeAllPairsWithVariableId(var);
        elements++;
      }
      if(var_smb != array_smb)
        assert(0); // more than one array is modified
    }
    // since multiple memory locations may be modified, we cannot know which one will be updated and can only add information
    for(VariableIdMapping::VariableIdSet::iterator i=defVarIds.begin();i!=defVarIds.end();++i) {
      element.insertPair(lab,*i);
    }
    if(elements != defVarIds.size())
      assert(0);
  } else if(defVarIds.size()==1) {
    // one unique memory location (variable). We can remove all pairs with this variable
    VariableId var=*defVarIds.begin();
    element.removeAllPairsWithVariableId(var);
    element.insertPair(lab,var);
  }
}

//.........这里部分代码省略.........
      break;
      case V_SgCastExp: {
        // TODO: model effect of cast when sub language is extended
        //SgCastExp* castExp=isSgCastExp(node);
        res.result=operandResult.result;
        res.exprConstraints=operandResult.exprConstraints;
        resultList.push_back(res);
        break;
      }
        // unary minus
      case V_SgMinusOp: {
        res.result=-operandResult.result; // using overloaded operator
        res.exprConstraints=operandResult.exprConstraints;
        resultList.push_back(res);
        break;
      }
      default:
        cerr << "@NODE:"<<node->sage_class_name()<<endl;
        throw "Error: evalConstInt::unknown unary operation.";
      } // end switch
    }
    return  resultList;
  }
  
  ROSE_ASSERT(!dynamic_cast<SgBinaryOp*>(node) && !dynamic_cast<SgUnaryOp*>(node));
  
  // ALL REMAINING CASES DO NOT GENERATE CONSTRAINTS
  // EXPRESSION LEAF NODES
  switch(node->variantT()) {
  case V_SgBoolValExp: {
    SgBoolValExp* boolValExp=isSgBoolValExp(node);
    assert(boolValExp);
    int boolVal= boolValExp->get_value();
    if(boolVal==0) {
      res.result=false;
      return listify(res);
    }
    if(boolVal==1) {
      res.result=true;
      return listify(res);
    }
    break;
  }
  case V_SgDoubleVal: {
    //SgDoubleVal* doubleValNode=isSgDoubleVal(node);
    // floating point values are currently not computed
    res.result=AType::Top();
    return listify(res);
  }
  case V_SgIntVal: {
    SgIntVal* intValNode=isSgIntVal(node);
    int intVal=intValNode->get_value();
    res.result=intVal;
    return listify(res);
  }
  case V_SgVarRefExp: {
    VariableId varId;
    bool isVar=ExprAnalyzer::variable(node,varId);
    assert(isVar);
    const PState* pstate=estate.pstate();
    if(pstate->varExists(varId)) {
      PState pstate2=*pstate; // also removes constness

      if(_variableIdMapping->hasArrayType(varId)) {
        // CODE-POINT-1
        // for arrays (by default the address is used) return its pointer value (the var-id-code)
        res.result=AType::ConstIntLattice(varId.getIdCode());
      } else {
        res.result=pstate2[varId].getValue(); // this include assignment of pointer values
      }
      if(res.result.isTop() && useConstraints) {
        // in case of TOP we try to extract a possibly more precise value from the constraints
        AType::ConstIntLattice val=res.estate.constraints()->varConstIntLatticeValue(varId);
        // TODO: TOPIFY-MODE: most efficient here
        res.result=val;
      }
      return listify(res);
    } else {
      res.result=AType::Top();
      cerr << "WARNING: variable not in PState (var="<<_variableIdMapping->uniqueLongVariableName(varId)<<"). Initialized with top."<<endl;
      return listify(res);
    }
    break;
  }
  case V_SgFunctionCallExp: {
    if(getSkipSelectedFunctionCalls()) {
      // return default value
      return listify(res);
    } else {
      throw "Error: evalConstInt::function call inside expression.";
    }

  }

  default:
    cerr << "@NODE:"<<node->sage_class_name()<<endl;
    throw "Error: evalConstInt::unknown operation failed.";
  } // end of switch
  throw "Error: evalConstInt failed.";
}

/*! 
  * \author Markus Schordan
  * \date 2012.
 */
size_t SPRAY::hash_value(const VariableId& vid) {
  return vid.getIdCode();
}