COP 5021 Lecture -*- Outline -*-

* Control Flow Graphs (2.1)

** use of (Control) flow graphs
------------------------------------------
       USE OF (CONTROL) FLOW GRAPHS

CFGs are used to:
   summarize control flow in a program,
   direct information in a dataflow analysis
------------------------------------------

** overview in JastAdd
------------------------------------------
          CFGs IN JASTADD

Not a built-in feature of JastAdd

I implemented in:

  a Java class: FlowGraph<L,L>
and/or
  as attributes in a CFG.jrag file

------------------------------------------

** CFG.jarg file
------------------------------------------

import java.util.*;
import utility.SetRepUtility;
import utility.FlowGraph;

aspect CFG {

   syn Label S.init();
   // ...
   syn Set<Label> S.finals();
   // ...

   // Blocks are kinds of control flow graph nodes.
   public interface Block {}
   S implements Block;
   LabeledBExpr implements Block;	

   // Set of blocks in a statement
   syn Set<Block> S.blocks();
   // ...
   // Set of labels in a statement
   syn Set<Label> S.labels();
   // ...
   // Set of flows inside a statement
   syn FlowGraph<Label, Label> S.flows();  // flows inside of S
   // ...

   // Mapping from labels to back to blocks
   inh Block Label.itsBlock();
   // ...

   // Flows into a block
   inh Set<Label> S.inFlows();	
   inh Set<Label> LabeledBExpr.inFlows();
   // ...

   // Next statement in a sequence (lexically)
   // This is a helping attribute for outFlows (below)
   inh S S.next();
   // ...

   // Flows out of a block
   inh Set<Label> S.outFlows();	
   inh Set<Label> LabeledBExpr.outFlows();
   // ...
}

------------------------------------------

------------------------------------------
            INIT ATTRIBUTE

syn Label S.init();	

eq AssignS.init() = getLabelAST();
eq SkipS.init() = getLabelAST();
eq IfS.init() = getLabeledBExpr().getLabelAST();
eq WhileS.init() = getLabeledBExpr().getLabelAST();
eq CompoundS.init() = getSList(1).init();

------------------------------------------
        Q: Why do IfS and WhileS use getLabeledBExpr()?

------------------------------------------
          FINALS ATTRIBUTE

	syn Set<Label> S.finals();

eq AssignS.finals() = SetRepUtility.singleton(getLabelAST());
eq SkipS.finals() = SetRepUtility.singleton(getLabelAST());

eq IfS.finals() {




   }
eq WhileS.finals() = SetRepUtility.singleton(getLabeledBExpr().getLabelAST());
eq CompoundS.finals() = getSList(getNumSList()-1).finals();

------------------------------------------
        ... Set<Label> ret = getS1().finals();
	    ret.addAll(getS2().finals());
	    return ret;

------------------------------------------
             BLOCKS ATTRIBUTE

// from CFG.jrag:

   // Blocks are kinds of control flow graph nodes.
   public interface Block {}
   S implements Block;
   LabeledBExpr implements Block;	

// DFG.jrag file:
syn Set<Block> S.blocks();
eq AssignS.blocks() = SetRepUtility.singleton(this);
eq SkipS.blocks() = SetRepUtility.singleton(this);
eq IfS.blocks() {





   }
eq WhileS.blocks() {




   }
eq CompoundS.blocks() {
     Set<Block> ret = SetRepUtility.emptySet();
     for (int i =0; i < getNumSList(); i++) {
        ret.addAll(getSList(i).blocks());
     }
     return ret;
   }
eq AssertS.blocks() = SetRepUtility.singleton(this);
------------------------------------------
 ... // for IfS
     Set<Block> ret = getS1().blocks();
     ret.addAll(getS2().blocks());
     ret.add(getLabeledBExpr());
     return ret;

... // for WhileS
      Set<Block> ret = getS().blocks();
      ret.add(getLabeledBExpr());
      return ret;

------------------------------------------
            LABELS ATTRIBUTE

syn Set<Label> S.labels();

eq AssignS.labels() = SetRepUtility.singleton(getLabelAST());
eq SkipS.labels() = SetRepUtility.singleton(getLabelAST());
eq IfS.labels() {
     Set ret = getS1().labels();
     ret.addAll(getS2().labels());
     ret.add(getLabeledBExpr().getLabelAST());
     return ret;
   }
eq WhileS.labels() {
     Set ret = getS().blocks();
     ret.add(getLabeledBExpr());
     return ret;
   }
eq CompoundS.labels() {
     Set ret = SetRepUtility.emptySet();
     for (int i = 0; i < getNumSList()-1; i++) {
       ret.addAll(getSList(i).labels());
     }
     return ret;
   }

------------------------------------------

------------------------------------------
        FLOW GRAPHS AS AN ADT

// file FlowGraph.java
package utility;

import java.util.AbstractMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/** A Map from labels to labels that can be used as a flow graph. 
 * @param <V>
 * @param <K>*/
public class FlowGraph<K, V> extends AbstractMap<K, V> implements Map<K, V> {
   
   /** The representation of this flowgraph. */
   private Map<K, V> map = new HashMap<K, V>();
   
   /** Initialize this object to be an empty flowgraph. */
   public FlowGraph() {
   }
   
   public FlowGraph(K k, V v) {
      map.put(k, v);
   }
   
   public Set<Map.Entry<K,V>> entrySet(){
      return map.entrySet();
   }
   
   @Override
   public V get(Object key) { return map.get(key); }
   
   /** Returns the converse of this map as a relation. */
   public Map<V,Set<K>> converse() { 
      Map<V, Set<K>>rev = new HashMap<V,Set<K>>();
      for (Map.Entry<K,V> kv : map.entrySet()) {
         V val = kv.getValue();
         if (rev.containsKey(val)) {
            Set<K> s = (Set<K>) rev.get(val);
            s.add(kv.getKey());
            rev.put(val,s);
         } else {
            Set<K> s = new HashSet<K>();
            s.add(kv.getKey());
            rev.put(kv.getValue(), s);
         }
      }
      return rev;
   }
   
   /** Returns the set of keys that map to the given value. */
   public Set<K> whatMapsTo(V v) {
      Map<V,Set<K>> rev = converse();
      return rev.get(v);
   }
   
   public static <T> FlowGraph<T, T> crossWith(/*@ non_null @*/ Set<T> s, T e) {
      FlowGraph<T, T> ret = new FlowGraph<T, T>();
      Iterator<T> i = s.iterator();
       while (i.hasNext()) {
         ret.put(i.next(), e);
      }
       return ret;
   }
}
------------------------------------------

------------------------------------------
       ALLOWING LABELS TO BE HASHED

aspect CFG { // ...

   // the following are needed so that labels can be hashed...
   public boolean NumLabel.equals(Object oth) {
      if (oth == null || !(oth instanceof NumLabel)) { return false; }
      NumLabel l = (NumLabel) oth;
      return getNum().equals(l.getNum());
   }
   public int NumLabel.hashCode() {
      return getNum().hashCode();
   }
}
------------------------------------------

------------------------------------------
           FLOWS ATTRIBUTE

syn FlowGraph<Label, Label> S.flows();  // flows inside of S
eq AssignS.flows() = new FlowGraph<Label, Label>();
eq SkipS.flows() = new FlowGraph<Label, Label>();
eq IfS.flows() {





   }
eq WhileS.flows() {
     Label l = getLabeledBExpr().getLabelAST();
     FlowGraph<Label, Label> ret = getS().flows();
     ret.put(l, getS().init());
     ret.putAll(FlowGraph.crossWith(getS().finals(), l));
     return ret;
   }
eq CompoundS.flows() {
     FlowGraph<Label, Label> ret = new FlowGraph<Label, Label>();
     for (int i = 1; i < getNumSList()-1; i++) {
       ret.putAll(getSList(i-1).flows());
       Set<Label> finalsM1 = getSList(i-1).finals();
       ret.putAll(FlowGraph.crossWith(finalsM1, getSList(i).init()));
     }
     ret.putAll(getSList(getNumSList()-1).flows());
     return ret;
   }
------------------------------------------

 ... // for IfS
     FlowGraph<Label, Label> ret = getS1().flows();
     ret.putAll(getS2().flows());
     ret.put(getLabeledBExpr().getLabelAST(), getS1().init());
     ret.put(getLabeledBExpr().getLabelAST(), getS2().init());
     return ret;