/* Soot - a J*va Optimization Framework
* Copyright (C) 1997-1999 Raja Vallee-Rai
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
package soot.jbco.bafTransformations;
import java.util.*;
import soot.*;
import soot.baf.*;
import soot.jbco.IJbcoTransform;
import soot.jimple.*;
import soot.util.*;
import soot.toolkits.graph.*;
/**
* @author Michael Batchelder
*
* Created on 12-May-2006
*/
public class FindDuplicateSequences extends BodyTransformer implements IJbcoTransform {
int totalcounts[] = new int[512];
public static String dependancies[] = new String[] {"bb.jbco_j2bl", "bb.jbco_rds", "bb.jbco_ful", "bb.lp" };
public String[] getDependancies() {
return dependancies;
}
public static String name = "bb.jbco_rds";
public String getName() {
return name;
}
public void outputSummary() {
out.println("Duplicate Sequences:");
for (int count = totalcounts.length - 1; count >= 0; count--)
if (totalcounts[count] > 0)
out.println("\t"+ count + " total: " + totalcounts[count]);
}
protected void internalTransform(Body b, String phaseName, Map options) {
int weight = soot.jbco.Main.getWeight(phaseName, b.getMethod().getSignature());
if (weight == 0) return;
if (output)
out.println("Checking " + b.getMethod().getName()
+ " for duplicate sequences..");
ArrayList<Unit> illegalUnits = new ArrayList<Unit>();
ArrayList seenUnits = new ArrayList();
ArrayList workList = new ArrayList();
PatchingChain units = b.getUnits();
BriefUnitGraph bug = new BriefUnitGraph(b);
workList.addAll(bug.getHeads());
while (workList.size()>0) {
Unit u = (Unit)workList.remove(0);
if (seenUnits.contains(u))
continue;
if (u instanceof NewInst) {
RefType t = ((NewInst)u).getBaseType();
ArrayList tmpWorkList = new ArrayList();
tmpWorkList.add(u);
while (tmpWorkList.size() > 0) {
Unit v = (Unit)tmpWorkList.remove(0);
// horrible approximatin about which init call belongs to which new
if (v instanceof SpecialInvokeInst) {
SpecialInvokeInst si = (SpecialInvokeInst)v;
if (si.getMethodRef().getSignature().indexOf("void <init>") < 0
|| si.getMethodRef().declaringClass() != t.getSootClass())
tmpWorkList.addAll(bug.getSuccsOf(v));
} else {
tmpWorkList.addAll(bug.getSuccsOf(v));
}
illegalUnits.add(v);
}
}
seenUnits.add(u);
workList.addAll(bug.getSuccsOf(u));
}
seenUnits = null;
int controlLocalIndex = 0;
int longestSeq = (units.size() / 2) - 1;
if (longestSeq > 20)
longestSeq = 20;
Local controlLocal = null;
Chain bLocals = b.getLocals();
int counts[] = new int[longestSeq + 1];
//ArrayList protectedUnits = new ArrayList();
HashMap bafToJLocals = soot.jbco.Main.methods2Baf2JLocals.get(b.getMethod());
boolean changed = true;
HashMap stackHeightsBefore = null;
for (int count = longestSeq; count > 2; count--)
{
Object uArry[] = units.toArray();
if (uArry.length <= 0)
return;
//int count = uArry.length > 100 ? 4 : uArry.length > 50 ? 3 : 2;
ArrayList<ArrayList<Unit>> candidates = new ArrayList<ArrayList<Unit>>();
ArrayList<Object> unitIDs = new ArrayList<Object>();
if (changed) {
stackHeightsBefore = StackTypeHeightCalculator
.calculateStackHeights(b,bafToJLocals);
bug = StackTypeHeightCalculator.bug;
changed = false;
}
LOOP:
for (int i = 0; i < uArry.length; i++) {
unitIDs.add(uArry[i]);
if (i + count > uArry.length)
continue;
ArrayList<Unit> seq = new ArrayList<Unit>();
for (int j = 0; j < count; j++) {
Unit u = (Unit)uArry[i + j];
if (u instanceof IdentityInst || u instanceof ReturnInst || illegalUnits.contains(u))
break;
// don't allow units within the sequence that have more than one
// predecessor that is not _within_ the sequence
if (j > 0) {
List preds = bug.getPredsOf(u);
if (preds.size()>0) {
int found = 0;
Iterator pit = preds.iterator();
while (pit.hasNext()) {
Unit p = (Unit)pit.next();
for (int jj = 0; jj < count; jj++) {
if (p == uArry[i+jj]) {
found++;
break;
}
}
}
if (found<preds.size())
continue LOOP;
}
}
seq.add(u);
}
if (seq.size() == count) {
if (seq.get(seq.size() - 1).fallsThrough())
candidates.add(seq);
}
}
HashMap<ArrayList, ArrayList<ArrayList<Object>>> selected = new HashMap<ArrayList, ArrayList<ArrayList<Object>>>();
for (int i = 0; i < candidates.size(); i++) {
ArrayList seq = candidates.get(i);
ArrayList<ArrayList<Object>> matches = new ArrayList<ArrayList<Object>>();
for (int j = 0; j < (uArry.length - count); j++) {
if (overlap(uArry, seq, j, count))
continue;
boolean found = false;
for (int k = 0; k < count; k++) {
Unit u = (Unit) seq.get(k);
found = false;
Unit v = (Unit)uArry[j + k];
if (!equalUnits(u, v, b) || illegalUnits.contains(v))
break;
if (k > 0) {
List preds = bug.getPredsOf(v);
if (preds.size()>0) {
int fcount = 0;
Iterator pit = preds.iterator();
while (pit.hasNext()) {
Unit p = (Unit)pit.next();
for (int jj = 0; jj < count; jj++) {
if (p == uArry[j+jj]) {
fcount++;
break;
}
}
}
if (fcount<preds.size())
break;
}
}
// No need to calc AFTER stack, since they are equal units
if (!stackHeightsBefore.get(u).equals(stackHeightsBefore.get(v)))
break;
found = true;
}
if (found) {
ArrayList<Object> foundSeq = new ArrayList<Object>();
for (int m = 0; m < count; m++)
foundSeq.add(uArry[j + m]);
matches.add(foundSeq);
}
}
if (matches.size() > 0) {
boolean done = false;
for (int x = 0; x < seq.size(); x++)
if (!unitIDs.contains(seq.get(x)))
done = true;
else
unitIDs.remove(seq.get(x));
if (!done) {
matches = cullOverlaps(b, unitIDs, matches);
if (matches.size()>0)
selected.put(seq, matches);
}
}
}
if (selected.size() <= 0)
continue;
Iterator<ArrayList> keys = selected.keySet().iterator();
while (keys.hasNext()) {
ArrayList key = keys.next();
ArrayList avalues = selected.get(key);
if (avalues.size() < 1 || soot.jbco.util.Rand.getInt(10) <= weight)
continue;
changed = true;
controlLocal = Baf.v().newLocal(
"controlLocalfordups" + controlLocalIndex, IntType.v());
bLocals.add(controlLocal);
bafToJLocals.put(controlLocal,Jimple.v().newLocal("controlLocalfordups" + controlLocalIndex++, IntType.v()));
counts[key.size()] += avalues.size();
ArrayList jumps = new ArrayList();
Unit first = (Unit) key.get(0);
//protectedUnits.addAll(key);
Unit store = Baf.v().newStoreInst(IntType.v(), controlLocal);
//protectedUnits.add(store);
units.insertBefore(store, first);
Unit pushUnit = Baf.v().newPushInst(IntConstant.v(0));
//protectedUnits.add(pushUnit);
units.insertBefore(pushUnit, store);
int index = 1;
Iterator values = avalues.iterator();
while (values.hasNext()) {
ArrayList next = (ArrayList) values.next();
Unit jump = (Unit) units.getSuccOf(next.get(next.size() - 1));
//protectedUnits.add(jump);
Unit firstt = (Unit) next.get(0);
Unit storet = (Unit) store.clone();
//protectedUnits.add(storet);
units.insertBefore(storet, firstt);
pushUnit = Baf.v().newPushInst(IntConstant.v(index++));
//protectedUnits.add(pushUnit);
units.insertBefore(pushUnit, storet);
Unit goUnit = Baf.v().newGotoInst(first);
//protectedUnits.add(goUnit);
units.insertAfter(goUnit, storet);
jumps.add(jump);
}
Unit insertAfter = (Unit) key.get(key.size() - 1);
//protectedUnits.add(insertAfter);
Unit swUnit = Baf.v().newTableSwitchInst(
(Unit) units.getSuccOf(insertAfter), 1, jumps.size(), jumps);
//protectedUnits.add(swUnit);
units.insertAfter(swUnit, insertAfter);
Unit loadUnit = Baf.v().newLoadInst(IntType.v(), controlLocal);
//protectedUnits.add(loadUnit);
units.insertAfter(loadUnit, insertAfter);
values = avalues.iterator();
while (values.hasNext()) {
ArrayList next = (ArrayList) values.next();
units.removeAll(next);
//protectedUnits.removeAll(next);
}
}
} // end of for loop for duplicate seq of various length
boolean dupsExist = false;
if (output)
System.out.println("Duplicate Sequences for " + b.getMethod().getName());
for (int count = longestSeq; count >= 0; count--)
if (counts[count] > 0) {
if (output)
out.println(count + " total: " + counts[count]);
dupsExist = true;
totalcounts[count] += counts[count];
}
if (!dupsExist) {
if (output)
out.println("\tnone");
} else if (debug) {
StackTypeHeightCalculator.calculateStackHeights(b);
}
}
private boolean equalUnits(Object o1, Object o2, Body b) {
if (o1.getClass() != o2.getClass())
return false;
// this is actually handled by the predecessor checks
// if units are targets of different jumps then not equal
//if (!((Unit)o1).getBoxesPointingToThis().equals(
// ((Unit)o2).getBoxesPointingToThis()))
// return false;
List<Trap> l1 = getTrapsForUnit(o1,b);
List<Trap> l2 = getTrapsForUnit(o2,b);
if (l1.size() != l2.size())
return false;
else {
for (int i = 0; i < l1.size(); i++)
if (l1.get(i) != l2.get(i)) return false;
}
if (o1 instanceof NoArgInst)
return true;
/*
if (o1 instanceof IncInst) {
IncInst ii = (IncInst)o1;
if (ii.getLocal() != ((IncInst)o2).getLocal() || ii.getConstant() != ((IncInst)o2).getConstant())
return false;
return true;
}*/
if (o1 instanceof TargetArgInst) {
//return false;
//Maybe shouldn't allow duplicate target units?
if (o1 instanceof OpTypeArgInst)
return ((TargetArgInst)o1).getTarget() == ((TargetArgInst)o2).getTarget()
&& ((OpTypeArgInst)o1).getOpType() == ((OpTypeArgInst)o2).getOpType();
else return
((TargetArgInst)o1).getTarget() == ((TargetArgInst)o2).getTarget();
}
if (o1 instanceof OpTypeArgInst)
return ((OpTypeArgInst) o1).getOpType() == ((OpTypeArgInst) o2)
.getOpType();
if (o1 instanceof MethodArgInst)
return ((MethodArgInst) o1).getMethod() == ((MethodArgInst) o2)
.getMethod();
if (o1 instanceof FieldArgInst)
return ((FieldArgInst) o1).getField() == ((FieldArgInst) o2).getField();
if (o1 instanceof PrimitiveCastInst) {
return ((PrimitiveCastInst) o1).getFromType() == ((PrimitiveCastInst) o2)
.getFromType()
&& ((PrimitiveCastInst) o1).getToType() == ((PrimitiveCastInst) o2)
.getToType();
}
if (o1 instanceof DupInst)
return compareDups(o1, o2);
if (o1 instanceof LoadInst)
return ((LoadInst) o1).getLocal() == ((LoadInst) o2).getLocal();
if (o1 instanceof StoreInst)
return ((StoreInst) o1).getLocal() == ((StoreInst) o2).getLocal();
if (o1 instanceof PushInst)
return equalConstants(((PushInst) o1).getConstant(), ((PushInst) o2)
.getConstant());
if (o1 instanceof IncInst)
if (equalConstants(((IncInst) o1).getConstant(), ((IncInst) o2)
.getConstant()))
return (((IncInst) o1).getLocal() == ((IncInst) o2).getLocal());
if (o1 instanceof InstanceCastInst)
return equalTypes(((InstanceCastInst) o1).getCastType(),
((InstanceCastInst) o2).getCastType());
if (o1 instanceof InstanceOfInst)
return equalTypes(((InstanceOfInst) o1).getCheckType(),
((InstanceOfInst) o2).getCheckType());
if (o1 instanceof NewArrayInst)
return equalTypes(((NewArrayInst) o1).getBaseType(), ((NewArrayInst) o2)
.getBaseType());
if (o1 instanceof NewInst)
return equalTypes(((NewInst) o1).getBaseType(), ((NewInst) o2)
.getBaseType());
if (o1 instanceof NewMultiArrayInst)
return equalTypes(((NewMultiArrayInst) o1).getBaseType(),
((NewMultiArrayInst) o2).getBaseType())
&& ((NewMultiArrayInst) o1).getDimensionCount() == ((NewMultiArrayInst) o2)
.getDimensionCount();
if (o1 instanceof PopInst)
return ((PopInst) o1).getWordCount() == ((PopInst) o2).getWordCount();
if (o1 instanceof SwapInst) {
return ((SwapInst) o1).getFromType() == ((SwapInst) o2).getFromType()
&& ((SwapInst) o1).getToType() == ((SwapInst) o2).getToType();
}
return false;
}
private List<Trap> getTrapsForUnit(Object o, Body b) {
ArrayList<Trap> list = new ArrayList<Trap>();
Chain traps = b.getTraps();
if (traps.size() != 0) {
PatchingChain units = b.getUnits();
Iterator it = traps.iterator();
while (it.hasNext()) {
Trap t = (Trap)it.next();
Iterator tit = units.iterator(t.getBeginUnit(),t.getEndUnit());
while (tit.hasNext()) {
if (tit.next() == o) {
list.add(t);
break;
}
}
}
}
return list;
}
private boolean overlap(Object units[], List list, int idx, int count) {
if (idx < 0 || list == null || list.size() == 0)
return false;
Object first = list.get(0);
Object last = list.get(list.size()-1);
for (int i = idx; i < idx + count; i++)
if (i < units.length && (first == units[i] || last == units[i]))
return true;
return false;
}
private boolean equalConstants(Constant c1, Constant c2) {
Type t = c1.getType();
if (t != c2.getType())
return false;
if (t instanceof IntType)
return ((IntConstant) c1).value == ((IntConstant) c2).value;
if (t instanceof FloatType)
return ((FloatConstant) c1).value == ((FloatConstant) c2).value;
if (t instanceof LongType)
return ((LongConstant) c1).value == ((LongConstant) c2).value;
if (t instanceof DoubleType)
return ((DoubleConstant) c1).value == ((DoubleConstant) c2).value;
if (c1 instanceof StringConstant && c2 instanceof StringConstant)
return ((StringConstant) c1).value == ((StringConstant) c2).value;
return c1 instanceof NullConstant && c2 instanceof NullConstant;
}
private boolean compareDups(Object o1, Object o2) {
DupInst d1 = (DupInst) o1;
DupInst d2 = (DupInst) o2;
List<Type> l1 = d1.getOpTypes();
List<Type> l2 = d2.getOpTypes();
for (int k = 0; k < 2; k++) {
if (k == 1) {
l1 = d1.getUnderTypes();
l2 = d2.getUnderTypes();
}
if (l1.size() != l2.size())
return false;
for (int i = 0; i < l1.size(); i++)
if (l1.get(i) != l2.get(i))
return false;
}
return true;
}
private boolean equalTypes(Type t1, Type t2) {
if (t1 instanceof RefType) {
if (t2 instanceof RefType) {
// TODO: more discerning comparison here?
RefType rt1 = (RefType) t1;
return rt1.compareTo(t2) == 0;
}
return false;
}
if (t1 instanceof PrimType && t2 instanceof PrimType)
return t1.getClass() == t2.getClass();
return false;
}
private static ArrayList<ArrayList<Object>> cullOverlaps(Body b, ArrayList<Object> ids, ArrayList<ArrayList<Object>> matches) {
ArrayList<ArrayList<Object>> newMatches = new ArrayList<ArrayList<Object>>();
for (int i = 0; i < matches.size(); i++) {
ArrayList<Object> match = matches.get(i);
Iterator<Object> it = match.iterator();
boolean clean = true;
while (it.hasNext()) {
if (!ids.contains(it.next())) {
clean = false;
break;
}
}
if (clean) {
List targs = b.getUnitBoxes(true);
for (int j = 0; j < targs.size() && clean; j++) {
Unit u = ((UnitBox) targs.get(j)).getUnit();
it = match.iterator();
while (it.hasNext()) {
if (u == it.next()) {
clean = false;
break;
}
}
}
}
if (clean) {
it = match.iterator();
while (it.hasNext())
ids.remove(it.next());
newMatches.add(match);
}
}
return newMatches;
}
}
|