Robust/src/Analysis/Pointer/BasicBlock.java

   1 package Analysis.Pointer;
   2 import Analysis.Disjoint.PointerMethod;
   3 import java.util.*;
   4 import IR.Flat.*;
   5
   6 public class BasicBlock {
   7   public BBlock start;
   8   public BBlock exit;
   9   public Set<BBlock> blockset;
  10
  11   public BasicBlock(BBlock start, BBlock exit, Set<BBlock> blockset) {
  12     this.start=start;
  13     this.exit=exit;
  14     this.blockset=blockset;
  15   }
  16
  17   public Set<BBlock> getBlocks() {
  18     return blockset;
  19   }
  20
  21   public BBlock getStart() {
  22     return start;
  23   }
  24
  25   public BBlock getExit() {
  26     return exit;
  27   }
  28
  29   public static class BBlock {
  30     Vector<FlatNode> nodes;
  31     Vector<BBlock> prevb;
  32     Vector<BBlock> nextb;
  33     boolean callReturn;
  34
  35     public BBlock() {
  36       nodes=new Vector<FlatNode>();
  37       prevb=new Vector<BBlock>();
  38       nextb=new Vector<BBlock>();
  39     }
  40
  41     public Vector<FlatNode> nodes() {
  42       return nodes;
  43     }
  44     public Vector<BBlock> next() {
  45       return nextb;
  46     }
  47     public Vector<BBlock> prev() {
  48       return prevb;
  49     }
  50   }
  51
  52   public static BasicBlock getBBlock(FlatMethod fm) {
  53     BBlock exit=null;
  54     Stack<FlatNode> toprocess=new Stack<FlatNode>();
  55     HashMap<FlatNode, BBlock> map=new HashMap<FlatNode, BBlock>();
  56     PointerMethod pm=new PointerMethod();
  57     HashSet<BBlock> blockset=new HashSet<BBlock>();
  58     pm.analyzeMethod(fm);
  59     toprocess.add(fm);
  60     BBlock b=new BBlock();
  61     blockset.add(b);
  62     map.put(fm, b);
  63
  64     while(!toprocess.isEmpty()) {
  65       FlatNode fn=toprocess.pop();
  66       BBlock block=map.get(fn);
  67       block.nodes.add(fn);
  68       if (fn.kind()==FKind.FlatExit)
  69         exit=block;
  70       do {
  71         if (pm.numNext(fn)!=1) {
  72           for(int i=0; i<pm.numNext(fn); i++) {
  73             FlatNode fnext=pm.getNext(fn,i);
  74             if (!map.containsKey(fnext)) {
  75               BBlock newb=new BBlock();
  76               blockset.add(newb);
  77               map.put(fnext, newb);
  78               toprocess.add(fnext);
  79             }
  80             //link block in
  81             if (!block.nextb.contains(map.get(fnext))) {
  82               block.nextb.add(map.get(fnext));
  83               map.get(fnext).prevb.add(block);
  84             }
  85           }
  86           break;
  87         }
  88         fn=pm.getNext(fn,0);
  89         if (pm.numPrev(fn)>1) {
  90           //new basic block
  91           if (!map.containsKey(fn)) {
  92             BBlock newb=new BBlock();
  93             blockset.add(newb);
  94             map.put(fn, newb);
  95             toprocess.add(fn);
  96           }
  97           //link block in
  98           if (!block.nextb.contains(map.get(fn))) {
  99             block.nextb.add(map.get(fn));
 100             map.get(fn).prevb.add(block);
 101           }
 102           break;
 103         }
 104         block.nodes.add(fn);
 105         if (fn.kind()==FKind.FlatExit)
 106           exit=block;
 107       } while(true);
 108     }
 109     return new BasicBlock(map.get(fm), exit, blockset);
 110   }
 111 }