Robust/src/Analysis/Disjoint/TaintSet.java

   1 package Analysis.Disjoint;
   2
   3 import IR.*;
   4 import IR.Flat.*;
   5 import java.util.*;
   6 import java.io.*;
   7
   8 ///////////////////////////////////////////
   9 //  IMPORTANT
  10 //  This class is an immutable Canonical, so
  11 //
  12 //  0) construct them with a factory pattern
  13 //  to ensure only canonical versions escape
  14 //
  15 //  1) any operation that modifies a Canonical
  16 //  is a static method in the Canonical class
  17 //
  18 //  2) operations that just read this object
  19 //  should be defined here
  20 //
  21 //  3) every Canonical subclass hashCode should
  22 //  throw an error if the hash ever changes
  23 //
  24 ///////////////////////////////////////////
  25
  26 // a taint set is simply the union of possible
  27 // taints for an abstract reference edge--in a
  28 // concrete heap each reference would have
  29 // exactly one taint
  30
  31 public class TaintSet extends Canonical {
  32
  33   protected HashSet<Taint> taints;
  34
  35   public static TaintSet factory(HashSet<Taint> taints) {
  36     TaintSet out = new TaintSet(taints);
  37     out = (TaintSet) Canonical.makeCanonical(out);
  38     return out;
  39   }
  40
  41   public TaintSet reTaint(FlatNode fn) {
  42     HashSet<Taint> taintset=new HashSet<Taint>();
  43     for(Taint t : taints) {
  44       if (t.getWhereDefined()!=fn) {
  45         t=t.reTaint(fn);
  46       }
  47       taintset.add(t);
  48     }
  49
  50     TaintSet out=new TaintSet(taintset);
  51     out = (TaintSet) Canonical.makeCanonical(out);
  52     return out;
  53   }
  54
  55   public static TaintSet factory() {
  56     TaintSet out = new TaintSet();
  57     out = (TaintSet) Canonical.makeCanonical(out);
  58     return out;
  59   }
  60
  61   public static TaintSet factory(Taint t) {
  62     assert t != null;
  63     assert t.isCanonical();
  64     TaintSet out = new TaintSet();
  65     out.taints.add(t);
  66     out = (TaintSet) Canonical.makeCanonical(out);
  67     return out;
  68   }
  69
  70   public static TaintSet factory(TaintSet ts,
  71                                  ExistPredSet preds) {
  72     assert ts != null;
  73     assert ts.isCanonical();
  74
  75     TaintSet out = new TaintSet();
  76
  77     Iterator<Taint> tItr = ts.iterator();
  78     while( tItr.hasNext() ) {
  79       Taint t    = tItr.next();
  80       Taint tOut = Taint.factory(t.sese,
  81                                  t.stallSite,
  82                                  t.var,
  83                                  t.allocSite,
  84                                  t.fnDefined,
  85                                  preds);
  86       out.taints.add(tOut);
  87     }
  88
  89     out = (TaintSet) Canonical.makeCanonical(out);
  90     return out;
  91   }
  92
  93   public TaintSet add(Taint t) {
  94     return Canonical.addPTR(this, t);
  95     /*    TaintSet newt=new TaintSet();
  96        newt.taints.addAll(taints);
  97        newt.taints.add(t);
  98        return (TaintSet) Canonical.makeCanonical(newt);*/
  99   }
 100
 101   public TaintSet merge(TaintSet ts) {
 102     return Canonical.unionPTR(this, ts);
 103     /*    TaintSet newt=new TaintSet();
 104        newt.taints.addAll(taints);
 105        newt.taints.addAll(ts.taints);
 106        return (TaintSet) Canonical.makeCanonical(newt);*/
 107   }
 108
 109   protected TaintSet() {
 110     taints = new HashSet<Taint>();
 111   }
 112
 113   protected TaintSet(HashSet<Taint> taints) {
 114     this.taints = taints;
 115   }
 116
 117   public Set<Taint> getTaints() {
 118     return taints;
 119   }
 120
 121   public Iterator iterator() {
 122     return taints.iterator();
 123   }
 124
 125   public boolean isEmpty() {
 126     return taints.isEmpty();
 127   }
 128
 129   public Taint containsIgnorePreds(Taint t) {
 130     assert t != null;
 131
 132     Iterator<Taint> tItr = taints.iterator();
 133     while( tItr.hasNext() ) {
 134       Taint tThis = tItr.next();
 135       if( tThis.equalsIgnorePreds(t) ) {
 136         return tThis;
 137       }
 138     }
 139
 140     return null;
 141   }
 142
 143   public boolean equalsSpecific(Object o) {
 144     if( o == null ) {
 145       return false;
 146     }
 147
 148     if( !(o instanceof TaintSet) ) {
 149       return false;
 150     }
 151
 152     TaintSet ts = (TaintSet) o;
 153     return taints.equals(ts.taints);
 154   }
 155
 156   public int hashCodeSpecific() {
 157     return taints.hashCode();
 158   }
 159
 160   public String toStringEscNewline( boolean suppressPredicates ) {
 161     String s = "taints[";
 162
 163     Iterator<Taint> tItr = taints.iterator();
 164     while( tItr.hasNext() ) {
 165       Taint t = tItr.next();
 166
 167       s += t.toString( suppressPredicates );
 168       if( tItr.hasNext() ) {
 169         s += ",\\n";
 170       }
 171     }
 172     s += "]";
 173     return s;
 174   }
 175
 176   public String toString() {
 177     return taints.toString();
 178   }
 179 }