/**
* Returns a <code>ThrowableSet</code> representing the set of exceptions included in <code>
* include</code> minus the set of exceptions included in <code>exclude</code>. Creates a new
* <code>ThrowableSet</code> only if there was not already one whose contents correspond to
* <code>include</code> - <code>exclude</code>.
*
* @param include A set of {@link RefLikeType} objects representing exception types included in
* the result; may be <code>null</code> if there are no included types.
* @param exclude A set of {@link AnySubType} objects representing exception types excluded from
* the result; may be <code>null</code> if there are no excluded types.
* @return a <code>ThrowableSet</code> representing the set of exceptions corresponding to
* <code>include</code> - <code>exclude</code>.
*/
private ThrowableSet registerSetIfNew(Set include, Set exclude) {
if (INSTRUMENTING) {
registrationCalls++;
}
if (include == null) {
include = Collections.EMPTY_SET;
}
if (exclude == null) {
exclude = Collections.EMPTY_SET;
}
int size = include.size() + exclude.size();
Integer sizeKey = new Integer(size);
List sizeList = (List) sizeToSets.get(sizeKey);
if (sizeList == null) {
sizeList = new LinkedList();
sizeToSets.put(sizeKey, sizeList);
}
for (Iterator i = sizeList.iterator(); i.hasNext(); ) {
ThrowableSet set = (ThrowableSet) i.next();
if (set.exceptionsIncluded.equals(include) && set.exceptionsExcluded.equals(exclude)) {
return set;
}
}
if (INSTRUMENTING) {
registeredSets++;
}
ThrowableSet result = new ThrowableSet(include, exclude);
sizeList.add(result);
return result;
}
public void outANonstaticInvokeExpr(ANonstaticInvokeExpr node) {
List args;
if (node.getArgList() != null) args = (List) mProductions.removeLast();
else args = new ArrayList();
SootMethodRef method = (SootMethodRef) mProductions.removeLast();
String local = (String) mProductions.removeLast();
Local l = (Local) mLocals.get(local);
if (l == null) throw new RuntimeException("did not find local: " + local);
Node invokeType = (Node) node.getNonstaticInvoke();
Expr invokeExpr;
if (invokeType instanceof ASpecialNonstaticInvoke) {
invokeExpr = Jimple.v().newSpecialInvokeExpr(l, method, args);
} else if (invokeType instanceof AVirtualNonstaticInvoke) {
invokeExpr = Jimple.v().newVirtualInvokeExpr(l, method, args);
} else {
if (debug)
if (!(invokeType instanceof AInterfaceNonstaticInvoke))
throw new RuntimeException("expected interface invoke.");
invokeExpr = Jimple.v().newInterfaceInvokeExpr(l, method, args);
}
mProductions.addLast(invokeExpr);
}
public void outALocalImmediate(ALocalImmediate node) {
String local = (String) mProductions.removeLast();
Local l = (Local) mLocals.get(local);
if (l == null) throw new RuntimeException("did not find local: " + local);
mProductions.addLast(l);
}
public void outAIdentityNoTypeStatement(AIdentityNoTypeStatement node) {
mProductions.removeLast(); // get rid of @caughtexception string presently on top of the stack
Value local =
(Value) mLocals.get(mProductions.removeLast()); // the local ref from it's identifier
Unit u = Jimple.v().newIdentityStmt(local, Jimple.v().newCaughtExceptionRef());
mProductions.addLast(u);
}
private void addBoxToPatch(String aLabelName, UnitBox aUnitBox) {
List patchList = (List) mLabelToPatchList.get(aLabelName);
if (patchList == null) {
patchList = new ArrayList();
mLabelToPatchList.put(aLabelName, patchList);
}
patchList.add(aUnitBox);
}
public void outAArrayRef(AArrayRef node) {
Value immediate = (Value) mProductions.removeLast();
String identifier = (String) mProductions.removeLast();
Local l = (Local) mLocals.get(identifier);
if (l == null) throw new RuntimeException("did not find local: " + identifier);
mProductions.addLast(Jimple.v().newArrayRef(l, immediate));
}
public void outALocalFieldRef(ALocalFieldRef node) {
SootFieldRef field = (SootFieldRef) mProductions.removeLast();
String local = (String) mProductions.removeLast();
Local l = (Local) mLocals.get(local);
if (l == null) throw new RuntimeException("did not find local: " + local);
mProductions.addLast(Jimple.v().newInstanceFieldRef(l, field));
}
public void outAIdentityStatement(AIdentityStatement node) {
Type identityRefType = (Type) mProductions.removeLast();
String atClause = (String) mProductions.removeLast();
Value local =
(Value) mLocals.get(mProductions.removeLast()); // the local ref from it's identifier
Value ref = null;
if (atClause.startsWith("@this")) {
ref = Jimple.v().newThisRef((RefType) identityRefType);
} else if (atClause.startsWith("@parameter")) {
int index = Integer.parseInt(atClause.substring(10, atClause.length() - 1));
ref = Jimple.v().newParameterRef(identityRefType, index);
} else
throw new RuntimeException(
"shouldn't @caughtexception be handled by outAIdentityNoTypeStatement: got" + atClause);
Unit u = Jimple.v().newIdentityStmt(local, ref);
mProductions.addLast(u);
}
private ThrowableSet getMemoizedAdds(Object key) {
if (memoizedAdds == null) {
memoizedAdds = new HashMap();
}
return (ThrowableSet) memoizedAdds.get(key);
}
public void outAFullMethodBody(AFullMethodBody node) {
Object catchClause = null;
JimpleBody jBody = Jimple.v().newBody();
if (node.getCatchClause() != null) {
int size = node.getCatchClause().size();
for (int i = 0; i < size; i++) jBody.getTraps().addFirst((Trap) mProductions.removeLast());
}
if (node.getStatement() != null) {
int size = node.getStatement().size();
Unit lastStmt = null;
for (int i = 0; i < size; i++) {
Object o = mProductions.removeLast();
if (o instanceof Unit) {
jBody.getUnits().addFirst(o);
lastStmt = (Unit) o;
} else if (o instanceof String) {
if (lastStmt == null) throw new RuntimeException("impossible");
mLabelToStmtMap.put(o, lastStmt);
} else throw new RuntimeException("impossible");
}
}
if (node.getDeclaration() != null) {
int size = node.getDeclaration().size();
for (int i = 0; i < size; i++) {
List localList = (List) mProductions.removeLast();
int listSize = localList.size();
for (int j = listSize - 1; j >= 0; j--) jBody.getLocals().addFirst(localList.get(j));
}
}
Iterator it = mLabelToPatchList.keySet().iterator();
while (it.hasNext()) {
String label = (String) it.next();
Unit target = (Unit) mLabelToStmtMap.get(label);
Iterator patchIt = ((List) mLabelToPatchList.get(label)).iterator();
while (patchIt.hasNext()) {
UnitBox box = (UnitBox) patchIt.next();
box.setUnit(target);
}
}
/*
Iterator it = mLabelToStmtMap.keySet().iterator();
while(it.hasNext()) {
String label = (String) it.next();
Unit target = (Unit) mLabelToStmtMap.get(label);
List l = (List) mLabelToPatchList.get(label);
if(l != null) {
Iterator patchIt = l.iterator();
while(patchIt.hasNext()) {
UnitBox box = (UnitBox) patchIt.next();
box.setUnit(target);
}
}
}
*/
mProductions.addLast(jBody);
}
private static boolean internalAggregate(
StmtBody body, Map<ValueBox, Zone> boxToZone, boolean onlyStackVars) {
LocalUses localUses;
LocalDefs localDefs;
ExceptionalUnitGraph graph;
boolean hadAggregation = false;
Chain<Unit> units = body.getUnits();
graph = new ExceptionalUnitGraph(body);
localDefs = new SmartLocalDefs(graph, new SimpleLiveLocals(graph));
localUses = new SimpleLocalUses(graph, localDefs);
List<Unit> unitList = new PseudoTopologicalOrderer<Unit>().newList(graph, false);
for (Unit u : unitList) {
if (!(u instanceof AssignStmt)) continue;
AssignStmt s = (AssignStmt) u;
Value lhs = s.getLeftOp();
if (!(lhs instanceof Local)) continue;
Local lhsLocal = (Local) lhs;
if (onlyStackVars && !lhsLocal.getName().startsWith("$")) continue;
List<UnitValueBoxPair> lu = localUses.getUsesOf(s);
if (lu.size() != 1) continue;
UnitValueBoxPair usepair = lu.get(0);
Unit use = usepair.unit;
ValueBox useBox = usepair.valueBox;
List<Unit> ld = localDefs.getDefsOfAt(lhsLocal, use);
if (ld.size() != 1) continue;
// Check to make sure aggregation pair in the same zone
if (boxToZone.get(s.getRightOpBox()) != boxToZone.get(usepair.valueBox)) {
continue;
}
/* we need to check the path between def and use */
/* to see if there are any intervening re-defs of RHS */
/* in fact, we should check that this path is unique. */
/* if the RHS uses only locals, then we know what
to do; if RHS has a method invocation f(a, b,
c) or field access, we must ban field writes, other method
calls and (as usual) writes to a, b, c. */
boolean cantAggr = false;
boolean propagatingInvokeExpr = false;
boolean propagatingFieldRef = false;
boolean propagatingArrayRef = false;
ArrayList<FieldRef> fieldRefList = new ArrayList<FieldRef>();
LinkedList<Value> localsUsed = new LinkedList<Value>();
for (ValueBox vb : s.getUseBoxes()) {
Value v = vb.getValue();
if (v instanceof Local) localsUsed.add(v);
else if (v instanceof InvokeExpr) propagatingInvokeExpr = true;
else if (v instanceof ArrayRef) propagatingArrayRef = true;
else if (v instanceof FieldRef) {
propagatingFieldRef = true;
fieldRefList.add((FieldRef) v);
}
}
// look for a path from s to use in graph.
// only look in an extended basic block, though.
List<Unit> path = graph.getExtendedBasicBlockPathBetween(s, use);
if (path == null) continue;
Iterator<Unit> pathIt = path.iterator();
// skip s.
if (pathIt.hasNext()) pathIt.next();
while (pathIt.hasNext() && !cantAggr) {
Stmt between = (Stmt) (pathIt.next());
if (between != use) {
// Check for killing definitions
for (ValueBox vb : between.getDefBoxes()) {
Value v = vb.getValue();
if (localsUsed.contains(v)) {
cantAggr = true;
break;
}
if (propagatingInvokeExpr || propagatingFieldRef || propagatingArrayRef) {
if (v instanceof FieldRef) {
if (propagatingInvokeExpr) {
cantAggr = true;
break;
} else if (propagatingFieldRef) {
// Can't aggregate a field access if passing a definition of a field
// with the same name, because they might be aliased
for (FieldRef fieldRef : fieldRefList) {
if (((FieldRef) v).getField() == fieldRef.getField()) {
cantAggr = true;
break;
}
}
}
} else if (v instanceof ArrayRef) {
if (propagatingInvokeExpr) {
// Cannot aggregate an invoke expr past an array write
cantAggr = true;
break;
} else if (propagatingArrayRef) {
// cannot aggregate an array read past a write
// this is somewhat conservative
// (if types differ they may not be aliased)
cantAggr = true;
break;
}
}
}
}
// Make sure not propagating past a {enter,exit}Monitor
if (propagatingInvokeExpr && between instanceof MonitorStmt) cantAggr = true;
}
// Check for intervening side effects due to method calls
if (propagatingInvokeExpr || propagatingFieldRef || propagatingArrayRef) {
for (final ValueBox box : between.getUseBoxes()) {
if (between == use && box == useBox) {
// Reached use point, stop looking for
// side effects
break;
}
Value v = box.getValue();
if (v instanceof InvokeExpr
|| (propagatingInvokeExpr && (v instanceof FieldRef || v instanceof ArrayRef))) {
cantAggr = true;
break;
}
}
}
}
// we give up: can't aggregate.
if (cantAggr) {
continue;
}
/* assuming that the d-u chains are correct, */
/* we need not check the actual contents of ld */
Value aggregatee = s.getRightOp();
if (usepair.valueBox.canContainValue(aggregatee)) {
boolean wasSimpleCopy = isSimpleCopy(usepair.unit);
usepair.valueBox.setValue(aggregatee);
units.remove(s);
hadAggregation = true;
// clean up the tags. If s was not a simple copy, the new statement should get
// the tags of s.
// OK, this fix was wrong. The condition should not be
// "If s was not a simple copy", but rather "If usepair.unit
// was a simple copy". This way, when there's a load of a constant
// followed by an invoke, the invoke gets the tags.
if (wasSimpleCopy) {
// usepair.unit.removeAllTags();
usepair.unit.addAllTagsOf(s);
}
} else {
/*
if(Options.v().verbose())
{
G.v().out.println("[debug] failed aggregation");
G.v().out.println("[debug] tried to put "+aggregatee+
" into "+usepair.stmt +
": in particular, "+usepair.valueBox);
G.v().out.println("[debug] aggregatee instanceof Expr: "
+(aggregatee instanceof Expr));
}*/
}
}
return hadAggregation;
}
