Robust/src/Analysis/Disjoint/PointerMethod.java

   1 package Analysis.Disjoint;
   2
   3 import IR.*;
   4 import IR.Flat.*;
   5 import java.util.*;
   6
   7
   8 public class PointerMethod {
   9   public PointerMethod() {
  10     nextmap=new Hashtable<FlatNode, Vector<FlatNode>>();
  11     prevmap=new Hashtable<FlatNode, Vector<FlatNode>>();
  12   }
  13
  14   Hashtable<FlatNode, Vector<FlatNode>> nextmap;
  15   Hashtable<FlatNode, Vector<FlatNode>> prevmap;
  16
  17   public void analyzeMethod(FlatMethod fm) {
  18     Hashtable<FlatNode, HashSet<FlatNode>> map=new Hashtable<FlatNode, HashSet<FlatNode>>();
  19     HashSet<FlatNode> toprocess=new HashSet<FlatNode>();
  20     toprocess.add(fm);
  21     while(!toprocess.isEmpty()) {
  22       FlatNode fn=toprocess.iterator().next();
  23       toprocess.remove(fn);
  24       HashSet<FlatNode> myset=new HashSet<FlatNode>();
  25       if (!analysisCares(fn)) {
  26         for(int i=0;i<fn.numPrev();i++) {
  27           myset.addAll(map.get(fn.getPrev(i)));
  28         }
  29       } else {
  30         myset.add(fn);
  31       }
  32       if (!map.containsKey(fn)||!map.get(fn).equals(myset)) {
  33         map.put(fn, myset);
  34         for(int i=0;i<fn.numNext();i++) {
  35           toprocess.add(fn.getNext(i));
  36         }
  37       }
  38     }
  39     for(Iterator<FlatNode> it=map.keySet().iterator();it.hasNext();) {
  40       FlatNode fn=it.next();
  41       if (analysisCares(fn)) {
  42         HashSet<FlatNode> myset=new HashSet<FlatNode>();
  43         for(int i=0;i<fn.numPrev();i++) {
  44           myset.addAll(map.get(fn.getPrev(i)));
  45         }
  46         if (!prevmap.containsKey(fn))
  47           prevmap.put(fn, new Vector());
  48         for(Iterator<FlatNode> it2=myset.iterator();it2.hasNext();) {
  49           FlatNode fnprev=it2.next();
  50           if (!nextmap.containsKey(fnprev))
  51             nextmap.put(fnprev, new Vector());
  52           nextmap.get(fnprev).add(fn);
  53           prevmap.get(fn).add(fnprev);
  54         }
  55       }
  56     }
  57   }
  58
  59   public int numNext(FlatNode fn) {
  60     return nextmap.get(fn).size();
  61   }
  62
  63   public FlatNode getNext(FlatNode fn, int i) {
  64     return nextmap.get(fn).get(i);
  65   }
  66
  67   public int numPrev(FlatNode fn) {
  68     return prevmap.get(fn).size();
  69   }
  70
  71   public FlatNode getPrev(FlatNode fn, int i) {
  72     return prevmap.get(fn).get(i);
  73   }
  74
  75   public boolean analysisCares(FlatNode fn) {
  76     switch(fn.kind()) {
  77     case FKind.FlatMethod:
  78     case FKind.FlatFieldNode:
  79     case FKind.FlatSetFieldNode:
  80     case FKind.FlatElementNode:
  81     case FKind.FlatSetElementNode:
  82     case FKind.FlatNew:
  83     case FKind.FlatCall:
  84     case FKind.FlatReturnNode:
  85       return true;
  86     case FKind.FlatCastNode:
  87       FlatCastNode fcn=(FlatCastNode)fn;
  88       TypeDescriptor td=fcn.getType();
  89       return td.isPtr();
  90     case FKind.FlatOpNode:
  91       FlatOpNode fon = (FlatOpNode) fn;
  92       return fon.getOp().getOp()==Operation.ASSIGN&&fon.getLeft().getType().isPtr();
  93     default:
  94       return false;
  95     }
  96   }
  97 }