C++ CFGNode::getNode方法代码示例

void CFG::buildCFG(CFGNode n)
{
    ROSE_ASSERT(n.getNode());

    if (explored_.count(n) > 0)
        return;
    explored_.insert(n);

    SgGraphNode* from = NULL;
    if (all_nodes_.count(n) > 0)
    {
        from = all_nodes_[n];
    }
    else
    {
        from = new SgGraphNode;
        from->set_SgNode(n.getNode());
        from->addNewAttribute("info", new CFGNodeAttribute(n.getIndex(), graph_));
        all_nodes_[n] = from;
        graph_->addNode(from);
    }

    std::vector<VirtualCFG::CFGEdge> outEdges = n.outEdges();
    foreach (const VirtualCFG::CFGEdge& edge, outEdges)
    {
        CFGNode tar = edge.target();

        SgGraphNode* to = NULL;
        if (all_nodes_.count(tar) > 0)
            to = all_nodes_[tar];
        else
        {
            to = new SgGraphNode;
            to->set_SgNode(tar.getNode());
            to->addNewAttribute("info", new CFGNodeAttribute(tar.getIndex(), graph_));
            all_nodes_[tar] = to;
            graph_->addNode(to);
        }

        graph_->addDirectedEdge(new SgDirectedGraphEdge(from, to));
    }

 // the default interesting filter
 bool defaultFilter (CFGNode cfgn)
 {
    SgNode * node = cfgn.getNode();
     assert (node != NULL) ;
     //Keep the last index for initialized names. This way the definition of the variable doesn't
     //propagate to its assign initializer.
     if (isSgInitializedName(node))
     { 
       return (cfgn == node->cfgForEnd());
     }
     else
       return (cfgn.isInteresting());
 }

  // the default interesting filter
  bool defaultFilter (CFGNode cfgn)
  {
    SgNode * node = cfgn.getNode();
    assert (node != NULL) ;
    //Keep the last index for initialized names. This way the definition of the variable doesn't
    //propagate to its assign initializer.
    // if (isSgInitializedName(node))
    // { 
    //   return (cfgn == node->cfgForEnd());
    // }
    // else
    //   return (cfgn.isInteresting());
    switch(node->variantT()) {         
      //Keep the last index for initialized names. This way the definition of the variable doesn't
      //propagate to its assign initializer.
      case V_SgInitializedName:
          return (cfgn == node->cfgForEnd());

      // filter out this node type
      // abstract memory object cannot be created for these nodes
      case V_SgExprListExp:
      case V_SgNullStatement:
      case V_SgExprStatement:
      case V_SgFunctionRefExp:
          return false;

      case V_SgFunctionCallExp:
          return cfgn.getIndex()==2 || cfgn.getIndex()==3;

      case V_SgFunctionParameterList:
          return true;
          //return cfgn.getIndex()==1;*/
          
      case V_SgFunctionDefinition:
          return cfgn.getIndex()==3;
      
      case V_SgReturnStmt:
          return cfgn.getIndex()==1;
          
      // Filter out intermediate dot expressions. We only care about the complete ones.
      case V_SgDotExp:
        //cout << "defaultFilter() node="<<cfgUtils::SgNode2Str(node)<<" node->get_parent()="<<cfgUtils::SgNode2Str(node->get_parent())<<" interesting="<<(!isSgDotExp(node->get_parent()))<<endl;
        return !isSgDotExp(node->get_parent());
      /*case V_SgCastExp:
          return false;*/
      
      default:
          return cfgn.isInteresting();
    }
  }

 bool isDataflowInteresting(CFGNode cn) {
         ROSE_ASSERT (cn.getNode());
         return (cn.getNode()->cfgIsIndexInteresting(cn.getIndex()) && 
                //!isSgFunctionRefExp(cn.getNode()) &&
                !isSgExprListExp(cn.getNode()) &&
                !isSgForInitStatement(cn.getNode()) &&
                //!isSgVarRefExp(cn.getNode()) &&
                //!isSgValueExp(cn.getNode()) &&
                //!isSgExprStatement(cn.getNode()) &&
                !(isSgInitializedName(cn.getNode()) && cn.getIndex()==0)) 
                ||
                (isSgIfStmt(cn.getNode()) &&
                 cn.getIndex()==1 || cn.getIndex()==2);
 }

 //! Constructor
 CFGEdge(CFGNode src, CFGNode tgt): src(src), tgt(tgt) { assert(src.getNode() != NULL && tgt.getNode() != NULL); }