public void outAFullIdentNonvoidType(AFullIdentNonvoidType node) {
String typeName = (String) mProductions.removeLast();
Type t = RefType.v(typeName);
int dim = node.getArrayBrackets().size();
if (dim > 0) t = ArrayType.v(t, dim);
mProductions.addLast(t);
}
/**
* Utility method which prints the abbreviations of the elements in a passed {@link Set} of
* exception types.
*
* @param s The exceptions to print.
* @param connector The character to insert between exceptions.
* @return An abbreviated representation of the exceptions.
*/
private String toAbbreviatedString(Set s, char connector) {
final String JAVA_LANG = "java.lang.";
final int JAVA_LANG_LENGTH = JAVA_LANG.length();
final String EXCEPTION = "Exception";
final int EXCEPTION_LENGTH = EXCEPTION.length();
Collection vmErrorThrowables = ThrowableSet.Manager.v().VM_ERRORS.exceptionsIncluded;
boolean containsAllVmErrors = s.containsAll(vmErrorThrowables);
StringBuffer buf = new StringBuffer();
if (containsAllVmErrors) {
buf.append(connector);
buf.append("vmErrors");
}
for (Iterator it = sortedThrowableIterator(s); it.hasNext(); ) {
RefLikeType reflikeType = (RefLikeType) it.next();
RefType baseType = null;
if (reflikeType instanceof RefType) {
baseType = (RefType) reflikeType;
if (vmErrorThrowables.contains(baseType) && containsAllVmErrors) {
continue; // Already accounted for vmErrors.
} else {
buf.append(connector);
}
} else if (reflikeType instanceof AnySubType) {
buf.append(connector);
buf.append('(');
baseType = ((AnySubType) reflikeType).getBase();
}
String typeName = baseType.toString();
if (typeName.startsWith(JAVA_LANG)) {
typeName = typeName.substring(JAVA_LANG_LENGTH);
}
if (typeName.length() > EXCEPTION_LENGTH && typeName.endsWith(EXCEPTION)) {
typeName = typeName.substring(0, typeName.length() - EXCEPTION_LENGTH);
}
buf.append(typeName);
if (reflikeType instanceof AnySubType) {
buf.append(')');
}
}
return buf.toString();
}
public int compare(Object o1, Object o2) {
RefType t1 = baseType(o1);
RefType t2 = baseType(o2);
if (t1.equals(t2)) {
// There should never be both AnySubType(t) and
// t in a ThrowableSet, but if it happens, put
// AnySubType(t) first:
if (o1 instanceof AnySubType) {
if (o2 instanceof AnySubType) {
return 0;
} else {
return -1;
}
} else if (o2 instanceof AnySubType) {
return 1;
} else {
return 0;
}
} else {
return t1.toString().compareTo(t2.toString());
}
}
/** Given a set of definite receiver types, returns a list of possible targets. */
public List resolveConcreteDispatch(List classes, SootMethod m) {
m.getDeclaringClass().checkLevel(SootClass.HIERARCHY);
checkState();
ArraySet s = new ArraySet();
Iterator classesIt = classes.iterator();
while (classesIt.hasNext()) {
Object cls = classesIt.next();
if (cls instanceof RefType) s.add(resolveConcreteDispatch(((RefType) cls).getSootClass(), m));
else if (cls instanceof ArrayType) {
s.add(resolveConcreteDispatch((RefType.v("java.lang.Object")).getSootClass(), m));
} else throw new RuntimeException("Unable to resolve concrete dispatch of type " + cls);
}
List l = new ArrayList();
l.addAll(s);
return Collections.unmodifiableList(l);
}
/**
* Returns a <code>ThrowableSet</code> which contains <code>e</code> and all of its subclasses as
* well as the exceptions in this set.
*
* <p><code>e</code> should be an instance of {@link AnySubType} if you know that the compile-time
* type of the exception you are representing is <code>e</code>, but the exception may be
* instantiated at run-time by a subclass of <code>e</code>.
*
* <p>For example, if you were recording the type of the exception thrown by
*
* <pre>
* catch (IOException e) {
* throw e;
* }
* </pre>
*
* you would call
*
* <pre>
* <code>add(AnySubtype.v(Scene.v().getRefType("java.lang.Exception.IOException")))</code>
* </pre>
*
* since the handler might rethrow any subclass of <code>IOException</code>.
*
* @param e represents a subtree of the exception class hierarchy to add to this set.
* @return a set containing <code>e</code> and all its subclasses, as well as the exceptions
* represented by this set.
* @throws ThrowableSet.AlreadyHasExclusionsException if this <code>ThrowableSet</code> is the
* result of a {@link #whichCatchableAs(RefType)} operation and, thus, unable to represent the
* addition of <code>e</code>.
*/
public ThrowableSet add(AnySubType e) throws ThrowableSet.AlreadyHasExclusionsException {
if (INSTRUMENTING) {
Manager.v().addsOfAnySubType++;
}
ThrowableSet result = getMemoizedAdds(e);
if (result != null) {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromMemo++;
Manager.v().addsExclusionWithoutSearch++;
}
return result;
} else {
FastHierarchy hierarchy = Scene.v().getOrMakeFastHierarchy();
RefType newBase = e.getBase();
if (INSTRUMENTING) {
if (exceptionsExcluded.size() != 0) {
Manager.v().addsExclusionWithSearch++;
} else {
Manager.v().addsExclusionWithoutSearch++;
}
}
for (Iterator i = exceptionsExcluded.iterator(); i.hasNext(); ) {
RefType exclusionBase = ((AnySubType) i.next()).getBase();
if (hierarchy.canStoreType(newBase, exclusionBase)
|| hierarchy.canStoreType(exclusionBase, newBase)) {
if (INSTRUMENTING) {
// To ensure that the subcategories total properly:
Manager.v().addsInclusionInterrupted++;
}
throw new AlreadyHasExclusionsException(
"ThrowableSet.add("
+ e.toString()
+ ") to the set [ "
+ this.toString()
+ "] where "
+ exclusionBase.toString()
+ " is excluded.");
}
}
if (this.exceptionsIncluded.contains(e)) {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromMap++;
}
return this;
} else {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromSearch++;
}
int changes = 0;
boolean addNewException = true;
Set resultSet = new HashSet();
for (Iterator i = this.exceptionsIncluded.iterator(); i.hasNext(); ) {
RefLikeType incumbent = (RefLikeType) i.next();
if (incumbent instanceof RefType) {
if (hierarchy.canStoreType(incumbent, newBase)) {
// Omit incumbent from result.
changes++;
} else {
resultSet.add(incumbent);
}
} else if (incumbent instanceof AnySubType) {
RefType incumbentBase = ((AnySubType) incumbent).getBase();
// We have to use the base types in these hierarchy calls
// because we want to know if _all_ possible
// types represented by e can be represented by
// the incumbent, or vice versa.
if (hierarchy.canStoreType(newBase, incumbentBase)) {
addNewException = false;
resultSet.add(incumbent);
} else if (hierarchy.canStoreType(incumbentBase, newBase)) {
// Omit incumbent from result;
changes++;
} else {
resultSet.add(incumbent);
}
} else { // assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(AnySubType): Set element "
+ incumbent.toString()
+ " is neither a RefType nor an AnySubType.");
}
}
if (addNewException) {
resultSet.add(e);
changes++;
}
if (changes > 0) {
result = Manager.v().registerSetIfNew(resultSet, this.exceptionsExcluded);
} else {
result = this;
}
memoizedAdds.put(e, result);
return result;
}
}
}
/**
* Returns a <code>ThrowableSet</code> which contains <code>e</code> in addition to the exceptions
* in this <code>ThrowableSet</code>.
*
* <p>Add <code>e</code> as a {@link RefType} when you know that the run-time class of the
* exception you are representing is necessarily <code>e</code> and cannot be a subclass of <code>
* e</code>.
*
* <p>For example, if you were recording the type of the exception thrown by
*
* <pre>
* throw new IOException("Permission denied");
* </pre>
*
* you would call
*
* <pre>
* <code>add(Scene.v().getRefType("java.lang.Exception.IOException"))</code>
* </pre>
*
* since the class of the exception is necessarily <code>IOException</code>.
*
* @param e the exception class
* @return a set containing <code>e</code> as well as the exceptions in this set.
* @throws {@link ThrowableSet.IllegalStateException} if this <code>ThrowableSet</code> is the
* result of a {@link #whichCatchableAs(RefType)} operation and, thus, unable to represent the
* addition of <code>e</code>.
*/
public ThrowableSet add(RefType e) throws ThrowableSet.AlreadyHasExclusionsException {
if (INSTRUMENTING) {
Manager.v().addsOfRefType++;
}
if (this.exceptionsIncluded.contains(e)) {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromMap++;
Manager.v().addsExclusionWithoutSearch++;
}
return this;
} else {
ThrowableSet result = getMemoizedAdds(e);
if (result != null) {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromMemo++;
Manager.v().addsExclusionWithoutSearch++;
}
return result;
} else {
if (INSTRUMENTING) {
Manager.v().addsInclusionFromSearch++;
if (exceptionsExcluded.size() != 0) {
Manager.v().addsExclusionWithSearch++;
} else {
Manager.v().addsExclusionWithoutSearch++;
}
}
FastHierarchy hierarchy = Scene.v().getOrMakeFastHierarchy();
for (Iterator i = exceptionsExcluded.iterator(); i.hasNext(); ) {
RefType exclusionBase = ((AnySubType) i.next()).getBase();
if (hierarchy.canStoreType(e, exclusionBase)) {
throw new AlreadyHasExclusionsException(
"ThrowableSet.add(RefType): adding"
+ e.toString()
+ " to the set [ "
+ this.toString()
+ "] where "
+ exclusionBase.toString()
+ " is excluded.");
}
}
for (Iterator i = exceptionsIncluded.iterator(); i.hasNext(); ) {
RefLikeType incumbent = (RefLikeType) i.next();
if (incumbent instanceof AnySubType) {
// Need to use incumbent.getBase() because
// hierarchy.canStoreType() assumes that parent
// is not an AnySubType.
RefType incumbentBase = ((AnySubType) incumbent).getBase();
if (hierarchy.canStoreType(e, incumbentBase)) {
memoizedAdds.put(e, this);
return this;
}
} else if (!(incumbent instanceof RefType)) {
// assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(RefType): Set element "
+ incumbent.toString()
+ " is neither a RefType nor an AnySubType.");
}
}
Set resultSet = new HashSet(this.exceptionsIncluded);
resultSet.add(e);
result = Manager.v().registerSetIfNew(resultSet, this.exceptionsExcluded);
memoizedAdds.put(e, result);
return result;
}
}
}
public void outAClassNameBaseType(AClassNameBaseType node) {
String type = (String) mProductions.removeLast();
if (type.equals("int")) throw new RuntimeException();
mProductions.addLast(RefType.v(type));
}
/*
* Generates the sequence of instructions needed to instrument ifStmtUnit
*
* @param ifStmtUnit: the unit to be instrumented
* @return A Chain of Units that represent the instrumentation of ifStmtUnit
*/
private static Chain<Unit> generateInstrumentationUnits(Unit ifStmtUnit, Body b) {
AbstractBinopExpr expression =
(AbstractBinopExpr)
((JIfStmt) ifStmtUnit).getCondition(); // implementation of AbstractBinopExpr
Value operand1 = expression.getOp1();
Value operand2 = expression.getOp2();
JimpleLocal op1Local = (JimpleLocal) operand1;
// Local localOperand = Jimple.v().newLocal("op1", operand1.getType());
// b.getLocals().add(localOperand);
// We need to use these operand as Locals or constants
/**
* JimpleLocal test; if(operand1 instanceof soot.jimple.internal.JimpleLocal) test =
* (JimpleLocal)operand1; else test = null;
*/
String op = expression.getClass().toString();
Chain<Unit> resultUnits = new HashChain<Unit>();
Local tmpRef;
// Add locals directely on the top of the body, java.io.printStream tmpRef
tmpRef = Jimple.v().newLocal("tmpRef", RefType.v("java.io.PrintStream"));
b.getLocals().addFirst(tmpRef);
// add "tmpRef = java.lang.System.out"
resultUnits.add(
Jimple.v()
.newAssignStmt(
tmpRef,
Jimple.v()
.newStaticFieldRef(
Scene.v()
.getField("<java.lang.System: java.io.PrintStream out>")
.makeRef())));
{
SootMethod toCall =
Scene.v().getMethod("<java.io.PrintStream: void println(java.lang.String)>");
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operande 1: "))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef,
toCall.makeRef(),
StringConstant.v(operand1.getClass().toString()))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operande 2:"))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef,
toCall.makeRef(),
StringConstant.v(operand2.getClass().toString()))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v()
.newVirtualInvokeExpr(
tmpRef, toCall.makeRef(), StringConstant.v("Operateur: "))));
resultUnits.add(
Jimple.v()
.newInvokeStmt(
Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(), StringConstant.v(op))));
}
return resultUnits;
}