Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java

   1 package Analysis.OwnershipAnalysis;
   2
   3 import IR.*;
   4 import IR.Flat.*;
   5 import java.util.*;
   6 import java.io.*;
   7
   8
   9 public class OwnershipGraph {
  10
  11     protected int heapRegionNodeIDs;
  12     protected Vector<OwnershipHeapRegionNode> heapRoots;
  13
  14     protected int labelNodeIDs;
  15     protected Hashtable<TempDescriptor, OwnershipLabelNode> td2ln;
  16
  17     public OwnershipGraph() {
  18         heapRegionNodeIDs = 0;
  19         heapRoots = new Vector<OwnershipHeapRegionNode>();
  20
  21         labelNodeIDs = 0;
  22         td2ln = new Hashtable<TempDescriptor, OwnershipLabelNode>();
  23     }
  24
  25     public void assignTempToTemp( TempDescriptor src,
  26                                   TempDescriptor dst ) {
  27         OwnershipLabelNode srcln = getLabelNodeFromTemp( src );
  28         OwnershipHeapRegionNode hrn = srcln.getOwnershipHeapRegionNode();
  29         OwnershipLabelNode dstln = getLabelNodeFromTemp( dst );
  30         dstln.setOwnershipHeapRegionNode( hrn );
  31     }
  32
  33     public void assignTempToField( TempDescriptor src,
  34                                    TempDescriptor dst,
  35                                    FieldDescriptor fd ) {
  36         OwnershipLabelNode srcln = getLabelNodeFromTemp( src );
  37         OwnershipHeapRegionNode hrn = srcln.getOwnershipHeapRegionNode();
  38         OwnershipLabelNode dstln = getLabelNodeFromTemp( dst );
  39         dstln.setOwnershipHeapRegionNode( hrn.getField( fd ) );
  40     }
  41
  42     public void assignFieldToTemp( TempDescriptor src,
  43                                    TempDescriptor dst,
  44                                    FieldDescriptor fd ) {
  45         OwnershipLabelNode srcln = getLabelNodeFromTemp( src );
  46         OwnershipHeapRegionNode srchrn = srcln.getOwnershipHeapRegionNode();
  47         OwnershipLabelNode dstln = getLabelNodeFromTemp( dst );
  48         OwnershipHeapRegionNode dsthrn = dstln.getOwnershipHeapRegionNode();
  49         dsthrn.setField( fd, srchrn );
  50     }
  51
  52     public void newHeapRegion( TempDescriptor td ) {
  53         TypeDescriptor typeDesc = td.getType();
  54         OwnershipHeapRegionNode hrn = allocate( typeDesc );
  55         OwnershipLabelNode ln = getLabelNodeFromTemp( td );
  56         ln.setOwnershipHeapRegionNode( hrn );
  57         heapRoots.add( hrn );
  58     }
  59
  60     protected OwnershipHeapRegionNode allocate( TypeDescriptor typeDesc ) {
  61         OwnershipHeapRegionNode hrn =
  62             new OwnershipHeapRegionNode( heapRegionNodeIDs );
  63         ++heapRegionNodeIDs;
  64
  65         if( typeDesc.isClass() ) {
  66             ClassDescriptor classDesc = typeDesc.getClassDesc();
  67             Iterator fieldItr = classDesc.getFields();
  68             while( fieldItr.hasNext() ) {
  69                 FieldDescriptor fd = (FieldDescriptor)fieldItr.next();
  70                 TypeDescriptor fieldType = fd.getType();
  71                 OwnershipHeapRegionNode fieldNode = allocate( fieldType );
  72                 hrn.setField( fd, fieldNode );
  73             }
  74         }
  75
  76         return hrn;
  77     }
  78
  79     protected OwnershipLabelNode getLabelNodeFromTemp( TempDescriptor td ) {
  80         if( !td2ln.containsKey( td ) ) {
  81             td2ln.put( td, new OwnershipLabelNode( labelNodeIDs, td ) );
  82             ++labelNodeIDs;
  83         }
  84
  85         return td2ln.get( td );
  86     }
  87
  88     /*
  89     public void addEdge( TempDescriptor tu, TempDescriptor tv ) {
  90         OwnershipLabelNode nu = getOwnershipFromTemp( tu );
  91         OwnershipLabelNode nv = getOwnershipFromTemp( tv );
  92
  93         nu.addOutEdge( nv );
  94         nv.addInEdge( nu );
  95     }
  96
  97     public OwnershipGraph copy() {
  98         OwnershipGraph newog = new OwnershipGraph();
  99
 100         // first create a node in the new graph from
 101         // every temp desc in the old graph
 102         Set s = td2on.entrySet();
 103         Iterator i = s.iterator();
 104         while( i.hasNext() ) {
 105             Map.Entry me = (Map.Entry) i.next();
 106             OwnershipLabelNode nu = (OwnershipLabelNode) me.getValue();
 107             newog.getOwnershipFromTemp( nu.getTempDescriptor() );
 108         }
 109
 110         // then use every out-edge of the old graph to
 111         // create the edges of the new graph
 112         i = s.iterator();
 113         while( i.hasNext() ) {
 114             Map.Entry me = (Map.Entry) i.next();
 115             OwnershipLabelNode nu = (OwnershipLabelNode) me.getValue();
 116             for( int j = 0; j < nu.numOutEdges(); ++j ) {
 117                 OwnershipLabelNode nv = nu.getOutEdge( j );
 118                 newog.addEdge( nu.getTempDescriptor(), nv.getTempDescriptor() );
 119             }
 120         }
 121
 122         return newog;
 123     }
 124     */
 125
 126
 127     public void writeGraph( String graphName ) throws java.io.IOException {
 128         BufferedWriter bw = new BufferedWriter( new FileWriter( graphName+".dot" ) );
 129         bw.write( "digraph "+graphName+" {\n" );
 130
 131         for( int i = 0; i < heapRoots.size(); ++i ) {
 132             OwnershipHeapRegionNode hrn = heapRoots.get( i );
 133             visitHeapNodes( bw, hrn );
 134         }
 135
 136         Set s = td2ln.entrySet();
 137         Iterator i = s.iterator();
 138         while( i.hasNext() ) {
 139             Map.Entry me = (Map.Entry) i.next();
 140             OwnershipLabelNode ln = (OwnershipLabelNode) me.getValue();
 141             OwnershipHeapRegionNode lnhrn = ln.getOwnershipHeapRegionNode();
 142             bw.write( "  "+ln.toString()+" -> "+lnhrn.toString()+";\n" );
 143         }
 144
 145         bw.write( "}\n" );
 146         bw.close();
 147     }
 148
 149     protected void visitHeapNodes( BufferedWriter bw,
 150                                    OwnershipHeapRegionNode hrn ) throws java.io.IOException {
 151         bw.write( "  "+hrn.toString()+"[shape=box];\n" );
 152
 153         Iterator fitr = hrn.getFieldIterator();
 154         while( fitr.hasNext() ) {
 155             Map.Entry me = (Map.Entry) fitr.next();
 156             FieldDescriptor         fd       = (FieldDescriptor)         me.getKey();
 157             OwnershipHeapRegionNode childhrn = (OwnershipHeapRegionNode) me.getValue();
 158             bw.write( "  "+hrn.toString()+" -> "+childhrn.toString()+
 159                       "[label=\""+fd.getSymbol()+"\"];\n" );
 160             visitHeapNodes( bw, childhrn );
 161         }
 162     }
 163 }