public StronglyConnectedComponentsBV(BitVector typeVariableList, TypeResolverBV resolver)
throws TypeException {
this.resolver = resolver;
variables = typeVariableList;
black = new TreeSet();
finished = new LinkedList();
for (BitSetIterator i = variables.iterator(); i.hasNext(); ) {
TypeVariableBV var = resolver.typeVariableForId(i.next());
if (!black.contains(var)) {
black.add(var);
dfsg_visit(var);
}
}
black = new TreeSet();
for (Iterator i = finished.iterator(); i.hasNext(); ) {
TypeVariableBV var = (TypeVariableBV) i.next();
if (!black.contains(var)) {
current_tree = new LinkedList();
forest.add(current_tree);
black.add(var);
dfsgt_visit(var);
}
}
for (Iterator i = forest.iterator(); i.hasNext(); ) {
LinkedList list = (LinkedList) i.next();
TypeVariableBV previous = null;
StringBuffer s = null;
if (DEBUG) {
s = new StringBuffer("scc:\n");
}
for (Iterator j = list.iterator(); j.hasNext(); ) {
TypeVariableBV current = (TypeVariableBV) j.next();
if (DEBUG) {
s.append(" " + current + "\n");
}
if (previous == null) {
previous = current;
} else {
try {
previous = previous.union(current);
} catch (TypeException e) {
if (DEBUG) {
G.v().out.println(s);
}
throw e;
}
}
}
}
}
/**
* Utility method for building sets of exceptional types for a {@link Pair}.
*
* @param e The exceptional type to add to the set.
* @param set The <code>Set</code> to which to add the types, or <code>null</code> if no <code>Set
* </code> has yet been allocated.
* @return A <code>Set</code> containing the elements in <code>set</code> plus <code>e</code>.
*/
private Set addExceptionToSet(RefLikeType e, Set set) {
if (set == null) {
set = new HashSet();
}
set.add(e);
return set;
}
public void computeMonitorObjs() {
Set maps = monitor.entrySet();
for (Iterator iter = maps.iterator(); iter.hasNext(); ) {
Map.Entry entry = (Map.Entry) iter.next();
FlowSet fs = (FlowSet) entry.getValue();
Iterator it = fs.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (!monitorObjs.contains(obj)) monitorObjs.add(obj);
}
}
}
private void dfsgt_visit(TypeVariableBV var) {
current_tree.add(var);
BitVector children = var.children();
for (BitSetIterator i = children.iterator(); i.hasNext(); ) {
TypeVariableBV child = resolver.typeVariableForId(i.next());
if (!black.contains(child)) {
black.add(child);
dfsgt_visit(child);
}
}
}
private void dfsg_visit(TypeVariableBV var) {
BitVector parents = var.parents();
for (BitSetIterator i = parents.iterator(); i.hasNext(); ) {
TypeVariableBV parent = resolver.typeVariableForId(i.next());
if (!black.contains(parent)) {
black.add(parent);
dfsg_visit(parent);
}
}
finished.add(0, var);
}
private void visitNode(
Set<Object> gray,
Object obj,
LinkedList<Object> changedUnits,
HashSet<Object> changedUnitsSet) {
gray.add(obj);
changedUnits.addLast(obj);
changedUnitsSet.add(obj);
nodes.add(obj);
valueBefore.add(newInitialFlow());
valueAfter.add(newInitialFlow());
Iterator succsIt = graph.getSuccsOf(obj).iterator();
if (g.getSuccsOf(obj).size() > 0) {
while (succsIt.hasNext()) {
Object succ = succsIt.next();
if (!gray.contains(succ)) {
visitNode(gray, succ, changedUnits, changedUnitsSet);
}
}
}
}
/**
* Returns a <code>ThrowableSet</code> which contains all the exceptions in <code>addedExceptions
* </code> in addition to those in this <code>ThrowableSet</code>.
*
* @param addedExceptions a set of {@link RefLikeType} and {@link AnySubType} objects to be added
* to the types included in this <code>ThrowableSet</code>.
* @return a set containing all the <code>addedExceptions</code> as well as the exceptions in this
* set.
*/
private ThrowableSet add(Set addedExceptions) {
Set resultSet = new HashSet(this.exceptionsIncluded);
int changes = 0;
FastHierarchy hierarchy = Scene.v().getOrMakeFastHierarchy();
// This algorithm is O(n m), where n and m are the sizes of the
// two sets, so hope that the sets are small.
for (Iterator i = addedExceptions.iterator(); i.hasNext(); ) {
RefLikeType newType = (RefLikeType) i.next();
if (!resultSet.contains(newType)) {
boolean addNewType = true;
if (newType instanceof RefType) {
for (Iterator j = resultSet.iterator(); j.hasNext(); ) {
RefLikeType incumbentType = (RefLikeType) j.next();
if (incumbentType instanceof RefType) {
if (newType == incumbentType) {
// assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(Set): resultSet.contains() failed to screen duplicate RefType "
+ newType);
}
} else if (incumbentType instanceof AnySubType) {
RefType incumbentBase = ((AnySubType) incumbentType).getBase();
if (hierarchy.canStoreType(newType, incumbentBase)) {
// No need to add this class.
addNewType = false;
}
} else { // assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(Set): incumbent Set element "
+ incumbentType
+ " is neither a RefType nor an AnySubType.");
}
}
} else if (newType instanceof AnySubType) {
RefType newBase = ((AnySubType) newType).getBase();
for (Iterator j = resultSet.iterator(); j.hasNext(); ) {
RefLikeType incumbentType = (RefLikeType) j.next();
if (incumbentType instanceof RefType) {
RefType incumbentBase = (RefType) incumbentType;
if (hierarchy.canStoreType(incumbentBase, newBase)) {
j.remove();
changes++;
}
} else if (incumbentType instanceof AnySubType) {
RefType incumbentBase = ((AnySubType) incumbentType).getBase();
if (newBase == incumbentBase) {
// assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(Set): resultSet.contains() failed to screen duplicate AnySubType "
+ newBase);
} else if (hierarchy.canStoreType(incumbentBase, newBase)) {
j.remove();
changes++;
} else if (hierarchy.canStoreType(newBase, incumbentBase)) {
// No need to add this class.
addNewType = false;
}
} else { // assertion failure.
throw new IllegalStateException(
"ThrowableSet.add(Set): old Set element "
+ incumbentType
+ " is neither a RefType nor an AnySubType.");
}
}
} else { // assertion failure.
throw new IllegalArgumentException(
"ThrowableSet.add(Set): new Set element "
+ newType
+ " is neither a RefType nor an AnySubType.");
}
if (addNewType) {
changes++;
resultSet.add(newType);
}
}
}
ThrowableSet result = null;
if (changes > 0) {
result = Manager.v().registerSetIfNew(resultSet, this.exceptionsExcluded);
} else {
result = this;
}
return result;
}
/**
* 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;
}
}
}
/**
* Constructs a <code>ThrowableSet.Manager</code> for inclusion in Soot's global variable
* manager, {@link G}.
*
* @param g guarantees that the constructor may only be called from {@link Singletons}.
*/
public Manager(Singletons.Global g) {
// First ensure the Exception classes are represented in Soot.
// Runtime errors:
RUNTIME_EXCEPTION = Scene.v().getRefType("java.lang.RuntimeException");
ARITHMETIC_EXCEPTION = Scene.v().getRefType("java.lang.ArithmeticException");
ARRAY_STORE_EXCEPTION = Scene.v().getRefType("java.lang.ArrayStoreException");
CLASS_CAST_EXCEPTION = Scene.v().getRefType("java.lang.ClassCastException");
ILLEGAL_MONITOR_STATE_EXCEPTION =
Scene.v().getRefType("java.lang.IllegalMonitorStateException");
INDEX_OUT_OF_BOUNDS_EXCEPTION = Scene.v().getRefType("java.lang.IndexOutOfBoundsException");
ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION =
Scene.v().getRefType("java.lang.ArrayIndexOutOfBoundsException");
NEGATIVE_ARRAY_SIZE_EXCEPTION = Scene.v().getRefType("java.lang.NegativeArraySizeException");
NULL_POINTER_EXCEPTION = Scene.v().getRefType("java.lang.NullPointerException");
INSTANTIATION_ERROR = Scene.v().getRefType("java.lang.InstantiationError");
EMPTY = registerSetIfNew(null, null);
Set allThrowablesSet = new HashSet();
allThrowablesSet.add(AnySubType.v(Scene.v().getRefType("java.lang.Throwable")));
ALL_THROWABLES = registerSetIfNew(allThrowablesSet, null);
Set vmErrorSet = new HashSet();
vmErrorSet.add(Scene.v().getRefType("java.lang.InternalError"));
vmErrorSet.add(Scene.v().getRefType("java.lang.OutOfMemoryError"));
vmErrorSet.add(Scene.v().getRefType("java.lang.StackOverflowError"));
vmErrorSet.add(Scene.v().getRefType("java.lang.UnknownError"));
// The Java library's deprecated Thread.stop(Throwable) method
// would actually allow _any_ Throwable to be delivered
// asynchronously, not just java.lang.ThreadDeath.
vmErrorSet.add(Scene.v().getRefType("java.lang.ThreadDeath"));
VM_ERRORS = registerSetIfNew(vmErrorSet, null);
Set resolveClassErrorSet = new HashSet();
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.ClassCircularityError"));
// We add AnySubType(ClassFormatError) so that we can
// avoid adding its subclass,
// UnsupportedClassVersionError, explicitly. This is a
// hack to allow Soot to analyze older class libraries
// (UnsupportedClassVersionError was added in JDK 1.2).
// TODO: The class "ClassFormatError" does not exist in TakaTuka so our best guess is that
// commenting the following line out won't affect the analysis in any way. But this
// is a "fault point" to look at if any problems arise in the future.
// resolveClassErrorSet.add(AnySubType.v(Scene.v().getRefType("java.lang.ClassFormatError")));
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.IllegalAccessError"));
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.IncompatibleClassChangeError"));
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.LinkageError"));
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.NoClassDefFoundError"));
resolveClassErrorSet.add(Scene.v().getRefType("java.lang.VerifyError"));
RESOLVE_CLASS_ERRORS = registerSetIfNew(resolveClassErrorSet, null);
Set resolveFieldErrorSet = new HashSet(resolveClassErrorSet);
resolveFieldErrorSet.add(Scene.v().getRefType("java.lang.NoSuchFieldError"));
RESOLVE_FIELD_ERRORS = registerSetIfNew(resolveFieldErrorSet, null);
Set resolveMethodErrorSet = new HashSet(resolveClassErrorSet);
resolveMethodErrorSet.add(Scene.v().getRefType("java.lang.AbstractMethodError"));
resolveMethodErrorSet.add(Scene.v().getRefType("java.lang.NoSuchMethodError"));
resolveMethodErrorSet.add(Scene.v().getRefType("java.lang.UnsatisfiedLinkError"));
RESOLVE_METHOD_ERRORS = registerSetIfNew(resolveMethodErrorSet, null);
// The static initializers of a newly loaded class might
// throw any Error (if they threw an Exception---even a
// RuntimeException---it would be replaced by an
// ExceptionInInitializerError):
//
Set initializationErrorSet = new HashSet();
initializationErrorSet.add(AnySubType.v(Scene.v().getRefType("java.lang.Error")));
INITIALIZATION_ERRORS = registerSetIfNew(initializationErrorSet, null);
}
