How to use

PointsToAnalysis

in

soot

protected PointsToSet reachingObjects(Local l) {
 PointsToSet ret = localToReachingObjects.get(l);
 if (ret == null) {
  localToReachingObjects.put(l, ret = pa.reachingObjects(l));
 }
 return ret;
}

 for (Iterator<Local> receiverIt = receivers.iterator(); receiverIt.hasNext();) {
  final Local receiver = receiverIt.next();
  final PointsToSet p2set = pa.reachingObjects(receiver);
  for (Iterator<Type> typeIt = p2set.possibleTypes().iterator(); typeIt.hasNext();) {
   final Type type = typeIt.next();
if (bases != null) {
 for (Local base : bases) {
  PointsToSet pts = pa.reachingObjects(base);
  for (Type ty : pts.possibleTypes()) {
   ofcgb.addBaseType(base, momc.context(), ty);
if (argArrays != null) {
 for (final Local argArray : argArrays) {
  PointsToSet pts = pa.reachingObjects(argArray);
  if (pts instanceof PointsToSetInternal) {
   PointsToSetInternal ptsi = (PointsToSetInternal) pts;
  for (Type t : pa.reachingObjectsOfArrayElement(pts).possibleTypes()) {
   ofcgb.addInvokeArgType(argArray, momc.context(), t);
 for (Iterator<Local> stringConstantIt = stringConstants.iterator(); stringConstantIt.hasNext();) {
  final Local stringConstant = stringConstantIt.next();
  PointsToSet p2set = pa.reachingObjects(stringConstant);
  Collection<String> possibleStringConstants = p2set.possibleStringConstants();
  if (possibleStringConstants == null) {

 private void fill(Set<IdentityStmt> parms, IdentityStmt parm, int colour, PointsToAnalysis pa) {
  if (!parms.contains(parm)) {
   return;
  }
  parm.getRightOpBox().addTag(new ColorTag(colour, "Parameter Alias"));
  parms.remove(parm);
  PointsToSet ps = pa.reachingObjects((Local) parm.getLeftOp());
  for (Iterator<IdentityStmt> parm2It = (new LinkedList<IdentityStmt>(parms)).iterator(); parm2It.hasNext();) {
   final IdentityStmt parm2 = parm2It.next();
   if (ps.hasNonEmptyIntersection(pa.reachingObjects((Local) parm2.getLeftOp()))) {
    fill(parms, parm2, colour, pa);
   }
  }
 }
}

/**
 * Gets the points-to set for a given value. The value can be, for example, a variable or a field.
 * 
 * @param value A value.
 * @return The points-to set for the input value.
 */
public static PointsToSet getPointsToSetForValue(Value value) {
 if (pointsToAnalysis == null) {
  pointsToAnalysis = Scene.v().getPointsToAnalysis();
 }
 if (value instanceof Local) {
  return pointsToAnalysis.reachingObjects((Local) value);
 } else if (value instanceof InstanceFieldRef) {
  InstanceFieldRef sootFieldRef = (InstanceFieldRef) value;
  PointsToSet refPointsToSet = pointsToAnalysis.reachingObjects((Local) sootFieldRef.getBase());
  return pointsToAnalysis.reachingObjects(refPointsToSet, sootFieldRef.getField());
 } else if (value instanceof StaticFieldRef) {
  StaticFieldRef sootFieldRef = (StaticFieldRef) value;
  return pointsToAnalysis.reachingObjects(sootFieldRef.getField());
 } else if (value instanceof ArrayRef) {
  ArrayRef arrayRef = (ArrayRef) value;
  PointsToSet arrayPointsToSet = pointsToAnalysis.reachingObjects((Local) arrayRef.getBase());
  return pointsToAnalysis.reachingObjectsOfArrayElement(arrayPointsToSet);
 } else {
  return EmptyPointsToSet.v();
 }
}

 protected void handleClass(PrintWriter out, SootClass c) {
  for (SootMethod m : c.getMethods()) {
   if (!m.isConcrete()) {
    continue;
   }
   Body b = m.retrieveActiveBody();

   Local[] sortedLocals = b.getLocals().toArray(new Local[b.getLocalCount()]);
   Arrays.sort(sortedLocals, new StringComparator<Local>());

   for (Local l : sortedLocals) {
    out.println("V " + m + l);
    if (l.getType() instanceof RefLikeType) {
     Set<Type> types = pa.reachingObjects(l).possibleTypes();

     Type[] sortedTypes = types.toArray(new Type[types.size()]);
     Arrays.sort(sortedTypes, new StringComparator<Type>());

     for (Type type : sortedTypes) {
      out.println("T " + type);
     }
    }
   }
  }
 }
}

/**
 * Creates a new instance key representing the value stored in local, just before stmt. The identity of the key is defined
 * via lmaa, and its must-not-alias relationship to other keys via lmna.
 *
 * @param local
 *          the local variable whose value this key represents
 * @param stmt
 *          the statement at which this key represents the value
 * @param owner
 *          the method containing local
 * @param lmaa
 *          a {@link LocalMustAliasAnalysis}
 * @param lmna
 *          a {@link LocalMustNotAliasAnalysis}
 */
public InstanceKey(Local local, Stmt stmt, SootMethod owner, LocalMustAliasAnalysis lmaa, LocalMustNotAliasAnalysis lmna) {
 this.assignedLocal = local;
 this.owner = owner;
 this.stmtAfterAssignStmt = stmt;
 this.lmaa = lmaa;
 this.lnma = lmna;
 PointsToAnalysis pta = Scene.v().getPointsToAnalysis();
 this.pts = new PointsToSetEqualsWrapper((EqualsSupportingPointsToSet) pta.reachingObjects(local));
 this.hashCode = computeHashCode();
}

 lockPT = (PointsToSetInternal) pta.reachingObjects((Local) lock);
} else if (lock instanceof StaticFieldRef) {
 lockPT = null;
 Local base = (Local) ((InstanceFieldRef) lock).getBase();
 if (base instanceof FakeJimpleLocal) {
  lockPT = (PointsToSetInternal) pta.reachingObjects(((FakeJimpleLocal) base).getRealLocal(),
    ((FieldRef) lock).getField());
 } else {
  lockPT = (PointsToSetInternal) pta.reachingObjects(base, ((FieldRef) lock).getField());

protected RWSet addValue(Value v, SootMethod m, Stmt s) {
 RWSet ret = null;
 if (v instanceof InstanceFieldRef) {
  InstanceFieldRef ifr = (InstanceFieldRef) v;
  PointsToSet base = pa.reachingObjects((Local) ifr.getBase());
  ret = new StmtRWSet();
  ret.addFieldRef(base, ifr.getField());
 } else if (v instanceof StaticFieldRef) {
  StaticFieldRef sfr = (StaticFieldRef) v;
  ret = new StmtRWSet();
  ret.addGlobal(sfr.getField());
 } else if (v instanceof ArrayRef) {
  ArrayRef ar = (ArrayRef) v;
  PointsToSet base = pa.reachingObjects((Local) ar.getBase());
  ret = new StmtRWSet();
  ret.addFieldRef(base, PointsToAnalysis.ARRAY_ELEMENTS_NODE);
 }
 return ret;
}

 emptyEdge = !tn1.origLock.equals(tn2.origLock);
} else {
 emptyEdge = !pta.reachingObjects((Local) tn1.origLock)
   .hasNonEmptyIntersection(pta.reachingObjects((Local) tn2.origLock));

if (v instanceof Local) {
 Local vLocal = (Local) v;
 PointsToSet base = pa.reachingObjects(vLocal);

 PointsToSet base = pa.reachingObjects((Local) ifr.getBase());
 ret = new StmtRWSet();
 ret.addFieldRef(base, ifr.getField());
} else if (v instanceof ArrayRef) {
 ArrayRef ar = (ArrayRef) v;
 PointsToSet base = pa.reachingObjects((Local) ar.getBase());
 ret = new StmtRWSet();
 ret.addFieldRef(base, PointsToAnalysis.ARRAY_ELEMENTS_NODE);
} else if (v instanceof Local) {
 Local vLocal = (Local) v;
 PointsToSet base = pa.reachingObjects(vLocal);
 ret = new CodeBlockRWSet();
 CodeBlockRWSet stmtRW = new CodeBlockRWSet();

if (specialRead instanceof Local) {
 Local vLocal = (Local) specialRead;
 PointsToSet base = pa.reachingObjects(vLocal);

 InstanceFieldRef ifr = (InstanceFieldRef) v;
 Local baseLocal = (Local) ifr.getBase();
 PointsToSet base = pa.reachingObjects(baseLocal);
 if (baseLocal.getType() instanceof RefType) {
  SootClass baseClass = ((RefType) baseLocal.getType()).getSootClass();
} else if (v instanceof ArrayRef) {
 ArrayRef ar = (ArrayRef) v;
 PointsToSet base = pa.reachingObjects((Local) ar.getBase());
 ret = new StmtRWSet();
 ret.addFieldRef(base, PointsToAnalysis.ARRAY_ELEMENTS_NODE);

protected PointsToSet reachingObjects( Local l ) {
PointsToSet ret = localToReachingObjects.get( l );
if( ret == null ) {
  localToReachingObjects.put( l, 
    ret = pa.reachingObjects( l ) );
}
return ret;
}

protected PointsToSet reachingObjects( Local l ) {
PointsToSet ret = localToReachingObjects.get( l );
if( ret == null ) {
  localToReachingObjects.put( l, 
    ret = pa.reachingObjects( l ) );
}
return ret;
}

  private void fill( Set<IdentityStmt> parms, IdentityStmt parm, int colour, PointsToAnalysis pa ) {
    if( !parms.contains(parm) ) return;
    parm.getRightOpBox().addTag( new ColorTag(colour, "Parameter Alias") );
    parms.remove( parm );
    PointsToSet ps = pa.reachingObjects( (Local) parm.getLeftOp() );
    for( Iterator<IdentityStmt> parm2It = (new LinkedList<IdentityStmt>(parms)).iterator(); parm2It.hasNext(); ) {
      final IdentityStmt parm2 = parm2It.next();
      if( ps.hasNonEmptyIntersection(
            pa.reachingObjects( (Local) parm2.getLeftOp() ) ) ) {
        fill( parms, parm2, colour, pa );
      }
    }
  }
}

  private void fill( Set<IdentityStmt> parms, IdentityStmt parm, int colour, PointsToAnalysis pa ) {
    if( !parms.contains(parm) ) return;
    parm.getRightOpBox().addTag( new ColorTag(colour, "Parameter Alias") );
    parms.remove( parm );
    PointsToSet ps = pa.reachingObjects( (Local) parm.getLeftOp() );
    for( Iterator<IdentityStmt> parm2It = (new LinkedList<IdentityStmt>(parms)).iterator(); parm2It.hasNext(); ) {
      final IdentityStmt parm2 = parm2It.next();
      if( ps.hasNonEmptyIntersection(
            pa.reachingObjects( (Local) parm2.getLeftOp() ) ) ) {
        fill( parms, parm2, colour, pa );
      }
    }
  }
}

/**
 * Gets the points-to-set for the given value
 * @param targetValue The value for which to get the points-to-set
 * @return The points-to-set for the given value
 */
private PointsToSet getPointsToSet(Value targetValue) {
  PointsToAnalysis pta = Scene.v().getPointsToAnalysis();
  synchronized (pta) {			
    if (targetValue instanceof Local)
      return pta.reachingObjects((Local) targetValue);
    else if (targetValue instanceof InstanceFieldRef) {
      InstanceFieldRef iref = (InstanceFieldRef) targetValue;
      return pta.reachingObjects((Local) iref.getBase(), iref.getField());
    }
    else if (targetValue instanceof StaticFieldRef) {
      StaticFieldRef sref = (StaticFieldRef) targetValue;
      return pta.reachingObjects(sref.getField());
    }
    else if (targetValue instanceof ArrayRef) {
      ArrayRef aref = (ArrayRef) targetValue;
      return pta.reachingObjects((Local) aref.getBase());
    }
    else
      throw new RuntimeException("Unexpected value type for aliasing: " + targetValue.getClass());
  }
}

protected void handleClass( PrintWriter out, SootClass c ) {
  for( Iterator mIt = c.methodIterator(); mIt.hasNext(); ) {
    final SootMethod m = (SootMethod) mIt.next();
    if( !m.isConcrete() ) continue;
    Body b = m.retrieveActiveBody();
    TreeSet sortedLocals = new TreeSet( new StringComparator() );
    sortedLocals.addAll( b.getLocals() );
    for( Iterator lIt = sortedLocals.iterator(); lIt.hasNext(); ) {
      final Local l = (Local) lIt.next();
      out.println( "V "+m+l );
      if( l.getType() instanceof RefLikeType ) {
        Set types = pa.reachingObjects( l ).possibleTypes();
        TreeSet sortedTypes = new TreeSet( new StringComparator() );
        sortedTypes.addAll( types );
        for( Iterator tIt = sortedTypes.iterator(); tIt.hasNext(); ) {
          out.println( "T "+tIt.next() );
        }
      }
    }
  }
}
class StringComparator implements Comparator {

protected void handleClass( PrintWriter out, SootClass c ) {
  for( Iterator mIt = c.methodIterator(); mIt.hasNext(); ) {
    final SootMethod m = (SootMethod) mIt.next();
    if( !m.isConcrete() ) continue;
    Body b = m.retrieveActiveBody();
    TreeSet sortedLocals = new TreeSet( new StringComparator() );
    sortedLocals.addAll( b.getLocals() );
    for( Iterator lIt = sortedLocals.iterator(); lIt.hasNext(); ) {
      final Local l = (Local) lIt.next();
      out.println( "V "+m+l );
      if( l.getType() instanceof RefLikeType ) {
        Set types = pa.reachingObjects( l ).possibleTypes();
        TreeSet sortedTypes = new TreeSet( new StringComparator() );
        sortedTypes.addAll( types );
        for( Iterator tIt = sortedTypes.iterator(); tIt.hasNext(); ) {
          out.println( "T "+tIt.next() );
        }
      }
    }
  }
}
class StringComparator implements Comparator {