Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.dataflow;
  
  import java.util.BitSet;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
 
 
 public abstract class DataFlowProblem {
 /* -------------- Public fields and methods below ---------------- */
     public enum DF_Direction { FORWARD, BACKWARD, BIDIRECTIONAL };
 
     public final DF_Direction direction;
 
     public DataFlowProblem(DF_Direction d) {
          = d;
          = new ArrayList<DataFlowVar>();
          = -1;
     }
 
 // ------- Abstract methods without a default implementation -------
     abstract public FlowGraphNode buildFlowGraphNode(BasicBlock bb);
     abstract public String getName();
 
 // ------- Default implementation methods below -------
     
Are there are available data flow facts to run this problem? SSS FIXME: Silly optimization?
 
     public boolean isEmpty() {
         return false;
     }
 
     public DF_Direction getFlowDirection() {
         return ;
     }
 
     public void setup(IRScope scope) {
         this. = scope;
         buildFlowGraph();
     }
 
     public IRScope getScope() {
         return ;
     }
 
     /* Compute Meet Over All Paths solution for this dataflow problem on the input CFG.
      * This implements a standard worklist algorithm. */
     public void compute_MOP_Solution() {
        
Are there are available data flow facts to run this problem? SSS FIXME: Silly optimization?
 
         if (!isEmpty()) {
             // 2. Initialize work list based on flow direction to make processing efficient!
             LinkedList<FlowGraphNodeworkList = getInitialWorkList();
 
             // 3. Initialize a bitset with a flag set for all basic blocks
             int numNodes = .cfg().getMaxNodeID();
             BitSet bbSet = new BitSet(1+numNodes);
             bbSet.flip(0, numNodes);
 
             // 4. Iteratively compute data flow info
             while (!workList.isEmpty()) {
                 workList.removeFirst().computeDataFlowInfo(workListbbSet);
             }
         }
     }
 
         LinkedList<FlowGraphNodewl = new LinkedList<FlowGraphNode>();
         if ( == .) {
            ListIterator<BasicBlockit = .cfg().getReversePostOrderTraverser();
            while (it.hasPrevious()) {
               wl.add(getFlowGraphNode(it.previous()));
            }
         } else {
            ListIterator<BasicBlockit = .cfg().getPostOrderTraverser();
            while (it.hasNext()) {
               wl.add(getFlowGraphNode(it.next()));
            }
         }
 
         return wl;
     }
 
     public int getDFVarsCount() {
         return .size();
     }
 
         return .cfg().getIncomingSources(bb);
     }
 
         return .cfg().getOutgoingDestinations(bb);
     }
 
     /* Individual analyses should override this */
     public String getDataFlowVarsForOutput() {
        return "";
    }
    @Override
    public String toString() {
        StringBuilder buf = new StringBuilder();
        buf.append("----").append(getName()).append("----\n");
        buf.append("---- Data Flow Vars: ----\n");
        buf.append(getDataFlowVarsForOutput());
        buf.append("-------------------------\n");
        for (FlowGraphNode n) {
            buf.append("DF State for BB ").append(n.basicBlock.getID()).append(":\n").append(n.toString());
        }
        return buf.toString();
    }
/* -------------- Packaged/protected fields and methods below ---------------- */
    int addDataFlowVar(DataFlowVar v) {
        // We want unique ids for dataflow variables
        ++;
        .add(v);
        return ;
    }
/* -------------- Protected fields and methods below ---------------- */
    protected List<FlowGraphNode>    flowGraphNodes;
    protected IRScope scope;
    protected FlowGraphNode getFlowGraphNode(BasicBlock b) {
        return .get(b.getID());
    }
/* -------------- Private fields and methods below ---------------- */
    private int     nextVariableId;
    private ArrayList<DataFlowVarvariables;
    private void buildFlowGraph() {
         = new LinkedList<FlowGraphNode>();
         = new HashMap<IntegerFlowGraphNode>();
        for (BasicBlock bb.cfg().getBasicBlocks()) {
            FlowGraphNode fgNode = buildFlowGraphNode(bb);
            fgNode.init();
            fgNode.buildDataFlowVars();
            .add(fgNode);
            .put(bb.getID(), fgNode);
        }
    }
New to GrepCode? Check out our FAQ X