jdynpur-2.0-beta-1/src/ 40755 0 0 0 10763261352 11743 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/ 40755 0 0 0 10763264172 12672 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/assembly/ 40755 0 0 0 10763265060 14506 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/bin/ 40755 0 0 0 10763303071 13432 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/config/ 40755 0 0 0 10564300702 14124 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/ 40755 0 0 0 10526551376 13615 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/java/ 40755 0 0 0 10526551376 14536 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/java/lang/ 40755 0 0 0 10563066014 15446 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/java/lang/jdynpur/ 40755 0 0 0 10564077404 17147 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/ 40755 0 0 0 10526551376 14404 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/softevo/ 40755 0 0 0 10526551376 16071 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/ 40755 0 0 0 10564100254 17547 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/ 40755 0 0 0 10763177222 20510 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/ 40755 0 0 0 10762742201 21236 5 ustar 0 0 jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/util/ 40755 0 0 0 10564100104 20516 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/ 40755 0 0 0 10763261711 12706 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/apt/ 40755 0 0 0 10763302236 13470 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/fml/ 40755 0 0 0 10526551376 13472 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/resources/ 40755 0 0 0 10526551376 14726 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/resources/builds/ 40755 0 0 0 10763261615 16205 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/resources/images/ 40755 0 0 0 10526551376 16173 5 ustar 0 0 jdynpur-2.0-beta-1/src/site/xdoc/ 40755 0 0 0 10763302100 13627 5 ustar 0 0 jdynpur-2.0-beta-1/src/test/ 40755 0 0 0 10526551376 12727 5 ustar 0 0 jdynpur-2.0-beta-1/src/test/java/ 40755 0 0 0 10526551376 13650 5 ustar 0 0 jdynpur-2.0-beta-1/src/test/java/org/ 40755 0 0 0 10526551376 14437 5 ustar 0 0 jdynpur-2.0-beta-1/src/test/java/org/softevo/ 40755 0 0 0 10526551376 16124 5 ustar 0 0 jdynpur-2.0-beta-1/checkstyle.xml 100644 0 0 24311 10564302155 14146 0 ustar 0 0
jdynpur-2.0-beta-1/pom.xml 100644 0 0 25724 10763261475 12626 0 ustar 0 0
4.0.0de.unisb.cs.stjdynpurJDynpurDynamic Purity Analysis for Java Programs2.0-beta-1jarhttp://www.st.cs.uni-sb.de/2007dallmeierValentin Dallmeierdallmeier@st.cs.uni-sb.dehttp://www.st.cs.uni-sb.de/~dallmeier/Software Engineering Group at Saarland Universityhttp://www.st.cs.uni-sb.de/2Developergoscinnyscp://ssh.st.cs.uni-sb.de/home/www/models/jdynpurContinuumhttp://kubrick:8080/continuum/mailtruetruetruetrue
dallmeier@st.cs.uni-sb.de
General Public License (GPL)http://www.gnu.org/licenses/gpl.txtmanualscm:svn:svn+ssh://ssh.st.cs.uni-sb.de/home/SVN/dallmeier/devel/asmdynpur/trunkscm:svn:svn+ssh//ssh.st.cs.uni-sb.de/home/SVN/dallmeier/devel/asmdynpur/trunkSoftware Engineering Group at Saarland Universityhttp://www.st.cs.uni-sb.de/org.softevoutil0.1compilejunitjunit3.8.1testcommons-iocommons-io1.0compilecommons-clicommons-cli1.0compileasmasm2.2.1compileasmasm-commons2.2.1compileasmasm-util2.2.1compilest.cs.uni-sb.deSoftware Engineering Chair repositorydefaulthttp://www.st.cs.uni-sb.de/maven2codehaus-m2-repositoryCodehaus Maven 2.x Repositoryhttp://repository.codehaus.orgorg.apache.maven.pluginsmaven-compiler-plugin1.51.5maven-assembly-pluginsrc/main/assembly/bin.xmlsrc/main/assembly/src.xmlorg.apache.maven.pluginsmaven-clover-plugin1.5pre-siteinstrumentorg.codehaus.mojocobertura-maven-plugincleanorg.apache.maven.pluginsmaven-jar-pluginorg.softevo.jdynpur.runtime.OnTheFlyInstrumenterTrueorg.apache.maven.pluginsmaven-project-info-reports-plugincimdependencieslicenseindexsummaryscmproject-teamorg.apache.maven.pluginsmaven-checkstyle-plugincheckstyle.xmlorg.apache.maven.pluginsmaven-clover-pluginorg.codehaus.mojofindbugs-maven-pluginMax1.0-beta-1org.apache.maven.pluginsmaven-javadoc-plugin128m512morg.apache.maven.pluginsmaven-jxr-pluginorg.apache.maven.pluginsmaven-surefire-report-pluginorg.codehaus.mojocobertura-maven-pluginorg.apache.maven.pluginsmaven-pmd-plugintrue1.5org.codehaus.mojotaglist-maven-pluginTODOFIXMEXXX
jdynpur-2.0-beta-1/src/main/assembly/bin.xml 100644 0 0 3003 10763265050 16070 0 ustar 0 0
bintar.gzzipREADME*LICENSE*NOTICE*src/main/binbinanalyzerun.shtracerun.shunix0755src/main/configconfig*unix0644targetlib*.jarlibjunit:junit
jdynpur-2.0-beta-1/src/main/assembly/src.xml 100644 0 0 1114 10763265060 16111 0 ustar 0 0
srctar.gzzipREADME*LICENSE*NOTICE*pom.xmlcheckstyle.xmlsrc
jdynpur-2.0-beta-1/src/main/bin/analyze_multiple.sh 100644 0 0 736 10664534415 17437 0 ustar 0 0 # JAVA_HOME
JAVA_HOME=
# JDynPur installation directory
INSTALL=
# Version of program
VERSION=
#========================== No need to edit anything from here =========================
LIBDIR=${INSTALL}/lib
for jar in $( find $LIBDIR -name "*.jar" | sort -r )
do
CLASSPATH=$jar:${CLASSPATH}
done
# remove last ':'
CLASSPATH=${CLASSPATH:0:${#CLASSPATH} - 1}
$JAVA_HOME/bin/java -Xmx1000M -classpath $CLASSPATH org.softevo.jdynpur.eval.MultiplePurityTraceAnalyser "$@"
jdynpur-2.0-beta-1/src/main/bin/analyzerun.sh 100644 0 0 1074 10763303071 16255 0 ustar 0 0 #!/bin/bash
# JDynPur installation directory
INSTALL=
# Version of program
VERSION=
#========================== No need to edit anything from here =========================
if [ ! -n "$JAVA_HOME" ]
then echo "You have to set JAVA_HOME to point to your java installation"
exit 128;
fi
LIBDIR=${INSTALL}/lib
for jar in $( find $LIBDIR -name "*.jar" | sort -r )
do
CLASSPATH=$jar:${CLASSPATH}
done
# remove last ':'
CLASSPATH=${CLASSPATH:0:${#CLASSPATH} - 1}
$JAVA_HOME/bin/java -Xmx1000M -classpath $CLASSPATH org.softevo.jdynpur.eval.PurityTraceAnalyser "$@"
jdynpur-2.0-beta-1/src/main/bin/tracerun.sh 100644 0 0 1101 10763303051 15675 0 ustar 0 0 #!/bin/bash
# JDynPur installation directory
INSTALL=
# Version of program
VERSION=
#========================== No need to edit anything from here =========================
if [ ! -n "$JAVA_HOME" ]
then echo "You have to set JAVA_HOME to point to your java installation"
exit 128;
fi
LIBDIR=${INSTALL}/lib
for jar in $( find $LIBDIR -name "*.jar" | sort -r )
do
CLASSPATH=$jar:${CLASSPATH}
done
# remove last ':'
CLASSPATH=${CLASSPATH:0:${#CLASSPATH} - 1}
$JAVA_HOME/bin/java -Xmx1000M -Xbootclasspath/a:$CLASSPATH -javaagent:$INSTALL/lib/jdynpur-$VERSION.jar "$@"
jdynpur-2.0-beta-1/src/main/bin/updatejre.sh 100644 0 0 234 10564300702 16022 0 ustar 0 0 echo "Updating JRE in $1"
cd $1/lib
rm -rf java
cp -r $HOME/projects/asmdynpur/trunk/target/classes/java .
find java -name "*.class" | xargs jar uvf rt.jar
jdynpur-2.0-beta-1/src/main/java/java/lang/jdynpur/Tracer.java 100644 0 0 35203 10763211466 21351 0 ustar 0 0 /*
*
*/
package java.lang.jdynpur;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashSet;
import org.softevo.util.ObjectIdMapper;
import org.softevo.util.asm.FieldIdentifier;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* Methods in this class are called by injected code to write trace events.
* This class continously writes a trace of events into file
* trace.out. If a suffix file (a file named
* suffix_* exists, then the suffix of the filename (e.g. file
* name suffix_0 -> suffix = 0 -> file name = trace.out_0) is appended to the
* name of the outputfile.
*
* @author dallmeier
*/
public class Tracer {
public static MethodIdentifierMapGenerator methodIdentifierMap = null;
public static ObjectIdMapper fieldIdentfierMap = null;
private static HashSet writtenMethodIdentifiers = new HashSet(1000);
private static HashSet writtenFieldIdentifiers = new HashSet(5000);
/**
* The stream used to write events.
*/
private static DataOutputStream dataOutputStream = null;
/**
* The size for the write buffer.
*/
private static final int BUFFERSIZE = 16777216;
/**
* The base name for the output file.
*/
public static final String OUTPUTFILENAME = "trace.out";
/**
* Constant for object creation event.
*/
public static final int EV_OBJECTCREATION = 1;
/**
* Constant for field write event.
*/
public static final int EV_FIELDWRITE = 2;
/**
* Constant for static field write event.
*/
public static final int EV_STATICFIELDWRITE = 3;
/**
* Constant for start of dynamic method event.
*/
public static final int EV_DYNAMICMETHODSTART = 4;
/**
* Constant for start of static method event.
*/
public static final int EV_STATICMETHODSTART = 5;
/**
* Constant for start of dynamic method event.
*/
public static final int EV_DYNAMICMETHODEND = 6;
/**
* Constant for end of static method end event.
*/
public static final int EV_STATICMETHODEND = 7;
/**
* Constant for array creation event.
*/
public static final int EV_ARRAYCREATED = 8;
/**
* Constant for array modification event.
*/
public static final int EV_ARRAYMODIFIED = 9;
public static final int EV_METHODID= 10;
public static final int EV_PARAMETER = 11;
public static final int EV_FIELDID = 12;
public static final int EV_OBJECTFIELDWRITE = 13;
public static final int EV_OBJECTARRAYMODIFIED = 14;
/**
* Constant indicating access to a static variable or execution of a static
* method.
*/
public static final int STATIC = -1;
/**
* Constant for null value.
*/
public static final int NULL = -1;
/**
* Mutex object that protects access to the DataOutputStream
*/
private static Object mutex = null;
/*private static HashMap> threadIdToActiveMethodStackMap = new HashMap>();*/
private static boolean debug = false;
/**
* Static initializer creates the output file and adds a shutdown hook such
* that the class is notified when the vm exits.
*/
static {
String fileName;
// System.out.println("Using up 4 date version of Tracer.");
mutex = new Object();
try {
fileName = System.getProperty("jdynpur.resultfilename", OUTPUTFILENAME);
dataOutputStream = new DataOutputStream(new BufferedOutputStream(
new FileOutputStream(fileName), BUFFERSIZE));
Runtime.getRuntime().addShutdownHook(new Thread(new ShutdownThread()));
} catch (IOException exception) {
System.out.println("Unable to create trace outputStream.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* This method is used to safely write events to the output stream. It is
* thread safe. If anything goes wrong writing to the stream, the vm is
* terminated with error code 5.
*
* @param eventId
* the id of the event to be written
* @param value
* the value of the event
*/
private static void writeEvent(int eventId, int value) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeInt(eventId);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(value);
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* This method writes events that have 2 parameters and adds
* the class of the receiver object as another parameter.
*
* @param eventId
* the id of the event
* @param value1
* the first value
* @param value2
* the second value
*/
private static void writeDynamicMethodEvent(int eventId, int value1, Object object) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeInt(eventId);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(value1);
dataOutputStream.writeInt(System.identityHashCode(object));
dataOutputStream.writeUTF(object.getClass().getName());
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* This method writes events that have 2 parameters and adds
* the class of the receiver object as another parameter.
*
* @param eventId
* the id of the event
* @param value1
* the first value
* @param value2
* the second value
*/
private static void writeParameterEvent(int index, Object parameter) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeInt(EV_PARAMETER);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(index);
if (parameter != null) {
dataOutputStream.writeInt(System.identityHashCode(parameter));
} else {
dataOutputStream.writeInt(System.identityHashCode(NULL));
}
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
private static void writeMethodIdentifier(int methodId) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
if (!writtenMethodIdentifiers.contains(methodId)) {
MethodIdentifier identifier = methodIdentifierMap.getMethodIdentifier(methodId);
if (identifier != null) {
String methodName = identifier.toString();
dataOutputStream.writeInt(EV_METHODID);
dataOutputStream.writeInt(methodId);
dataOutputStream.writeInt(identifier.getAccess());
dataOutputStream.writeUTF(methodName);
writtenMethodIdentifiers.add(methodId);
} else {
System.out.println("Method identifier " + methodId + " not found in identifier map.");
System.out.println("Will now exit!");
System.out.flush();
System.exit(-1);
}
}
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
private static void writeFieldIdentifier(int fieldId) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
if (!writtenFieldIdentifiers.contains(fieldId)) {
FieldIdentifier identifier = fieldIdentfierMap.getObject(fieldId);
if (identifier != null) {
String fieldName = identifier.toString();
dataOutputStream.writeInt(EV_FIELDID);
dataOutputStream.writeInt(fieldId);
dataOutputStream.writeUTF(fieldName);
writtenFieldIdentifiers.add(fieldId);
} else {
System.out.println("Field identifier " + fieldId + " not found in identifier map.");
System.out.println("Will now exit!");
System.out.flush();
System.exit(-1);
}
}
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
public static void objectFieldWritten(Object receiver, Object value, int fieldId) {
writeFieldIdentifier(fieldId);
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeInt(EV_OBJECTFIELDWRITE);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(fieldId);
if (receiver != null) {
dataOutputStream.writeInt(System.identityHashCode(receiver));
} else {
dataOutputStream.writeInt(System.identityHashCode(NULL));
}
if (value != null) {
dataOutputStream.writeInt(System.identityHashCode(value));
} else {
dataOutputStream.writeInt(System.identityHashCode(NULL));
}
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* Called whenever a field is written in an object.
*
* @param object
* the modified object
*/
public static void fieldWritten(Object object) {
if (debug) {
System.out.println("Field written.");
}
writeEvent(EV_FIELDWRITE, System.identityHashCode(object));
}
/**
* Called whenever a new object is created. This method is called after the
* constructor call.
*
* @param object
* the object that is created
*/
public static void objectCreated(Object object) {
if (debug) {
System.out.println("Object created.");
}
writeEvent(EV_OBJECTCREATION, System.identityHashCode(object));
}
/**
* Called whenever a dynamic method is started.
*
* @param methodId
* the id of the method that is started
* @param thisObject
* the object the method is invoked on
*/
public static void dynamicMethodStarted(int methodId, Object thisObject) {
writeMethodIdentifier(methodId);
if (debug) {
System.out.println("Method started " + methodId);
}
writeDynamicMethodEvent(EV_DYNAMICMETHODSTART, methodId, thisObject);
}
public static void parameterPassed(int index, Object parameter) {
writeParameterEvent(index, parameter);
}
/**
* Called whenever a static method is started.
*
* @param methodId
* the id of the method that is started
*/
public static void staticMethodStarted(int methodId) {
writeMethodIdentifier(methodId);
if (debug) {
System.out.println("Static method started " + methodId);
}
writeEvent(EV_STATICMETHODSTART, methodId);
}
/**
* Called whenever a dynamic method has just finished execution.
*
* @param methodId
* the id of the method
*/
public static void dynamicMethodEnded(int methodId) {
if (debug) {
System.out.println("Dynamic method ended " + methodId);
}
writeEvent(EV_DYNAMICMETHODEND, methodId);
}
/**
* Called whenever a static method has just finished execution.
*
* @param methodId
* the id of the method
*/
public static void staticMethodEnded(int methodId) {
if (debug) {
System.out.println("Static method ended " + methodId);
}
writeEvent(EV_STATICMETHODEND, methodId);
}
/**
* Called whenever a static field was written.
*/
public static void staticFieldWritten() {
if (debug) {
System.out.println("Static field written.");
}
writeEvent(EV_STATICFIELDWRITE, STATIC);
}
/**
* Called whenever a new array was created.
*
* @param object
* the array created
*/
public static void arrayCreated(Object object) {
if (debug) {
System.out.println("Array created.");
}
writeEvent(EV_ARRAYCREATED, System.identityHashCode(object));
}
/**
* Called whenever an entry in an array is modified.
*
* @param object
* the array that was modified
*/
public static void arrayModified(Object object) {
if (debug) {
System.out.println("Array modified.");
}
writeEvent(EV_ARRAYMODIFIED, System.identityHashCode(object));
}
public static void objectArrayModified(Object array, int index, Object value) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeInt(EV_OBJECTARRAYMODIFIED);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
if (array != null) {
dataOutputStream.writeInt(System.identityHashCode(array));
} else {
dataOutputStream.writeInt(System.identityHashCode(NULL));
}
dataOutputStream.writeInt(System.identityHashCode(index));
if (value != null) {
dataOutputStream.writeInt(System.identityHashCode(value));
} else {
dataOutputStream.writeInt(System.identityHashCode(NULL));
}
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* This method is called to record creation of multi dimensional arrays. This
* is necessary because otherwise we don't know about the creation of all
* arrays.
*
* @param array
* the object array, possibly containing more object arrays
* @param depth
* the recursion depth
*/
public static void addArraysRecursively(Object[] array, int depth) {
for (int counter = 0; counter < array.length; counter++) {
arrayCreated(array[counter]);
objectArrayModified(array, counter, array[counter]);
if (depth > 0) {
addArraysRecursively((Object[]) array[counter], depth - 1);
}
}
}
/**
* This class implements the shutdown hook needed to assure that all trace
* information gets written at vm shutdown time.
*
* @author dallmeier
*/
private static class ShutdownThread implements Runnable {
/**
* Flushes the stream and closes it.
*/
public void run() {
// System.out.println("Running shutdown thread version 1");
synchronized (mutex) {
try {
if (dataOutputStream != null) {
dataOutputStream.flush();
dataOutputStream.close();
dataOutputStream = null;
}
} catch (IOException finalizeException) {
System.out
.println("An exception occured finalizing trace output stream.");
finalizeException.printStackTrace(System.out);
}
}
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/MethodExecutionDisplayer.java 100644 0 0 17222 10761754746 26467 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This is a utility class used to analyze execution of specific methods. It
* expects a classname and one or more trace files as input and displays
* recorded events only when the specified method is executed.
*/
public class MethodExecutionDisplayer extends PurityTraceAnalyser {
/**
* The method identifier of the method to be displayed.
*/
protected MethodIdentifier identifier = null;
/**
* The integer identifying the sought method.
*/
protected int soughtMethodId = -1;
/**
* The number of times the method is currently active. This is needed for
* recursive calls.
*/
protected int numberOfRunningMethods = 0;
/**
* Creates a new method execution displayer.
*
* @param fileName
* the name of the trace file to replay
* @param identifierMap
* the identifier map for this trace
* @param identifier
* the identifier of the sought method
*/
public MethodExecutionDisplayer(String fileName,
MethodIdentifier identifier) {
super(fileName, null, false, true);
this.identifier = identifier;
this.soughtMethodId = identifierMap.getIdentifier(identifier);
System.out.println("ID of sought method: " + soughtMethodId);
}
/**
* If the sought method is active, this method outputs an array creation
* message on System.out.
*
* @param objectId
* the identifier for the new array
* @param threadId
* the thread id
*/
protected void handleArrayCreation(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Created array " + objectId);
}
super.handleArrayCreation(objectId, threadId);
}
/**
* If the sought method is active, this method outputs an array modification
* message on System.out.
*
* @param objectId
* the identifier for the modified array
* @param threadId
* the thread id
*/
protected void handleArrayModification(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Modified array " + objectId);
}
super.handleArrayModification(objectId, threadId);
}
/**
* If the sought method is active, this method outputs a field modification
* message on System.out.
*
* @param objectId
* the identifier for the modified field
* @param threadId
* the thread id
*/
protected void handleStaticFieldWrite(int threadId) {
if (isMethodRunning()) {
System.out.println("Wrote static field");
}
super.handleStaticFieldWrite(threadId);
}
/**
* If the sought method is active, this method outputs a field modification
* message on System.out.
*
* @param objectId
* the identifier for the modified field
* @param threadId
* the thread id
*/
protected void handleFieldWrite(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Wrote field of object " + objectId);
}
super.handleFieldWrite(objectId, threadId);
}
/**
* If the sought method is active, this method outputs an object creation
* message on System.out.
*
* @param objectId
* the identifier for the new object
* @param threadId
* the thread id
*/
protected void handleObjectCreation(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Created object " + objectId);
}
super.handleObjectCreation(objectId, threadId);
}
/**
* If the sought method is active, this method outputs a method start message
* on System.out and increases the active method count.
*
* @param methodId
* the identifier for the method
* @param threadId
* the thread id
*/
protected void handleMethodStart(int methodId, int threadId, String className) {
if (isSoughtMethod(methodId)) {
numberOfRunningMethods++;
System.out.println("Starting execution of " + identifier + " (" + numberOfRunningMethods + ")");
} else if (isMethodRunning()) {
System.out.println("Intermediate method start " + identifierMap.getMethodIdentifier(methodId));
}
super.handleMethodStart(methodId, threadId, className);
}
/**
* If a method has ended, this method checks if it's execution had
* side-effects and outputs a message on System.out.
*
* @param methodId
* the identifier for the method
* @param threadId
* the thread id
*/
@SuppressWarnings("unchecked")
protected void handleMethodEnd(int methodId, int threadId, String className) {
HashSet createdObjects;
HashSet modifiedObjects;
HashSet setDifference;
Iterator methodIdIterator;
if (isSoughtMethod(methodId)) {
createdObjects = getCreatedObjectSetStack(threadId).pop();
modifiedObjects = getModifiedObjectSetStack(threadId).peek();
if (!createdObjects.containsAll(modifiedObjects)) {
setDifference = (HashSet) modifiedObjects.clone();
setDifference.removeAll(createdObjects);
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId)
+ " impure because of modifications to the following objects:");
methodIdIterator = setDifference.iterator();
while (methodIdIterator.hasNext()) {
System.out.println(methodIdIterator.next());
}
} else {
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId) + " is pure.");
}
getCreatedObjectSetStack(threadId).push(createdObjects);
numberOfRunningMethods--;
System.out.println("Finished execution of " + identifier + " (" + numberOfRunningMethods + ")");
} else if (isMethodRunning()) {
System.out.println("Intermediate method end " + identifierMap.getMethodIdentifier(methodId));
}
super.handleMethodEnd(methodId, threadId, className);
}
/**
* Checks if the sought method is currently executed in the trace.
*/
protected boolean isMethodRunning() {
return numberOfRunningMethods > 0;
}
/**
* Checks if the identifier is for the sought method.
*
* @param methodId
* the id of the method
*/
protected boolean isSoughtMethod(int methodId) {
if (methodId == soughtMethodId) {
return true;
} else {
return false;
}
}
/**
* This method evaluates command line arguments and replays execution for
* every trace file.
*
* @param args
* command line arguments
*/
public static void main(String[] args) throws IOException {
File[] files;
String suffix;
String[] fileNames;
MethodExecutionDisplayer displayer;
String methodIdentifier;
MethodIdentifier identifier;
methodIdentifier = args[0];
files = new File[args.length - 1];
for (int counter = 0; counter < files.length; counter++) {
files[counter] = new File(args[counter + 1]);
}
fileNames = new String[args.length - 1];
for (int counter = 0; counter < fileNames.length; counter++) {
fileNames[counter] = files[counter].getName();
}
for (int counter = 1; counter < args.length; counter++) {
suffix = fileNames[counter - 1].substring(10, fileNames[counter - 1].length());
identifier = MethodIdentifier.parseFromIdentifier(methodIdentifier);
try {
displayer = new MethodExecutionDisplayer(args[counter], identifier);
System.out.println("Analysing trace " + args[counter]);
displayer.analyse(false, false);
} catch (NoSuchElementException methodNotExecutedException) {
System.out.println("Method not executed in trace " + args[counter]);
}
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/MultiplePurityTraceAnalyser.java 100644 0 0 22313 10761771431 27157 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.apache.commons.io.filefilter.PrefixFileFilter;
import org.softevo.jdynpur.eval.PurityTraceAnalyser.ParameterMutabilityInformation;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This class analyzes several execution traces for the same program and merges
* the results. If a method was impure in at least one trace, then it is
* considered to be impure.
*
* @author dallmeier
*/
public class MultiplePurityTraceAnalyser {
/**
* The name of the trace file to be analyzed.
*/
private String fileName = null;
/**
* The set of pure method identifiers.
*/
private HashMap> pureMethodIdentifiers;
/**
* The set of impure method identifiers.
*/
private HashMap> impureMethodIdentifiers;
/**
* The set of executed method identifiers.
*/
private HashMap> executedMethodIdentifiers;
private HashMap> methodsModifyingThis;
private String resultFileName;
private boolean excludeAPIMethodsFromCalls;
private HashMap parameterMutabilityInformation;
/**
* Creates a new analyzer for all traces in the given directory.
*
* @param fileName
* the name of the directory
*/
public MultiplePurityTraceAnalyser(String fileName, String resultFileName, boolean excludeAPIMethodsFromCalls) {
this.fileName = fileName;
this.resultFileName = resultFileName;
this.excludeAPIMethodsFromCalls = excludeAPIMethodsFromCalls;
}
private HashSet getTypeSet(HashMap> map, MethodIdentifier identifier) {
HashSet result;
result = map.get(identifier);
if (result == null) {
result = new HashSet();
map.put(identifier, result);
}
return result;
}
/**
* Analyzes all trace files in the directory. After this method has finished,
* the results are stored in the classes' HashSet fields. This
* method also outputs some information on System.out
*
* @throws IOException
* if an exception occurs reading a trace.
* @throws TransformerException
* @throws ParserConfigurationException
*/
public void analyse() throws IOException, ParserConfigurationException, TransformerException {
File traceDirectory;
File[] children;
File identityMapFile;
String suffix;
String[] fileNames;
MethodIdentifierMapGenerator identifierMap;
PurityTraceAnalyser purityAnalyser;
Iterator newImpureMethodsIterator, newPureMethodsIterator, pureMethodsIterator, impureMethodsIterator;
MethodIdentifier identifier;
boolean isFirstTrace = true;
HashSet pureTypes, impureTypes;
impureMethodIdentifiers = new HashMap>();
pureMethodIdentifiers = new HashMap>();
executedMethodIdentifiers = new HashMap>();
methodsModifyingThis = new HashMap>();
parameterMutabilityInformation = new HashMap();
traceDirectory = new File(fileName);
children = traceDirectory.listFiles((FileFilter) new PrefixFileFilter("trace.out_"));
System.out.println("Found " + children.length + " trace files");
fileNames = new String[children.length];
for (int counter = 0; counter < children.length; counter++) {
fileNames[counter] = children[counter].getName();
}
Arrays.sort(fileNames);
for (int counter = 0; counter < fileNames.length; counter++) {
suffix = fileNames[counter].substring(10, fileNames[counter].length());
System.out.println("Processing files with suffix " + suffix);
purityAnalyser = new PurityTraceAnalyser(children[counter].getAbsolutePath(), null, false, excludeAPIMethodsFromCalls);
System.out.println("Analysing purity trace " + suffix + ".");
purityAnalyser.analyse(false, false);
System.out.println("Analysis results (Pure/Impure/Executed): ("
+ purityAnalyser.getPureMethodIdentifiers().size() + "/"
+ purityAnalyser.getImpureMethodIdentifiers().size() + "/"
+ purityAnalyser.getExecutedMethodIdentifiers().size() + ")");
executedMethodIdentifiers.putAll(purityAnalyser.getExecutedMethodIdentifiers());
methodsModifyingThis.putAll(purityAnalyser.getThisModifyingMethodIdentifiers());
if (isFirstTrace) {
isFirstTrace = false;
pureMethodIdentifiers.putAll(purityAnalyser.getPureMethodIdentifiers());
impureMethodIdentifiers.putAll(purityAnalyser.getImpureMethodIdentifiers());
parameterMutabilityInformation.putAll(purityAnalyser.getParameterMutabilityInformation());
} else {
newImpureMethodsIterator = purityAnalyser.getImpureMethodIdentifiers().keySet().iterator();
while (newImpureMethodsIterator.hasNext()) {
identifier = newImpureMethodsIterator.next();
pureTypes = getTypeSet(pureMethodIdentifiers, identifier);
pureTypes.removeAll(purityAnalyser.getImpureMethodIdentifiers().get(identifier));
impureTypes = getTypeSet(impureMethodIdentifiers, identifier);
impureTypes.addAll(purityAnalyser.getImpureMethodIdentifiers().get(identifier));
}
newPureMethodsIterator = purityAnalyser.getPureMethodIdentifiers().keySet().iterator();
while (newPureMethodsIterator.hasNext()) {
identifier = newPureMethodsIterator.next();
if (!impureMethodIdentifiers.containsKey(identifier)) {
pureTypes = getTypeSet(pureMethodIdentifiers, identifier);
pureTypes.addAll(purityAnalyser.getPureMethodIdentifiers().get(identifier));
}
}
HashMap newParameterInformation = purityAnalyser.getParameterMutabilityInformation();
for (MethodIdentifier methodIdentifier: newParameterInformation.keySet()) {
if (parameterMutabilityInformation.containsKey(methodIdentifier)) {
ParameterMutabilityInformation oldMutabilityInformation = parameterMutabilityInformation.get(methodIdentifier);
ParameterMutabilityInformation newMutabilityInformation = newParameterInformation.get(methodIdentifier);
HashMap> classToUnmodifiedParametersMap = newMutabilityInformation.getRuntimeClassNameToUnmodifiedParametersMap();
for (String className : classToUnmodifiedParametersMap.keySet()) {
oldMutabilityInformation.updateUnmodifiedParameters(className, classToUnmodifiedParametersMap.get(className));
}
} else {
parameterMutabilityInformation.put(methodIdentifier, newParameterInformation.get(methodIdentifier));
}
}
System.out.println("Number of pure methods after trace " + suffix + ": " + pureMethodIdentifiers.size());
System.out.println("Number of impure methods after trace " + suffix + ": " + impureMethodIdentifiers.size());
System.out
.println("Number of executed methods after trace " + suffix + ": " + executedMethodIdentifiers.size());
}
}
System.out.println();
System.out.println("Pure methods:");
pureMethodsIterator = pureMethodIdentifiers.keySet().iterator();
while (pureMethodsIterator.hasNext()) {
System.out.println(pureMethodsIterator.next());
}
System.out.println("Impure methods:");
impureMethodsIterator = impureMethodIdentifiers.keySet().iterator();
while (impureMethodsIterator.hasNext()) {
System.out.println(impureMethodsIterator.next());
}
writeResults();
}
/**
* This method serializes the results to the file system. Pure methods are
* stored in puremethods.ser, impure methods are stored in
* impuremethods.ser, executed methods are stored in
* executedmethods.ser.
* @throws TransformerException
* @throws ParserConfigurationException
* @throws IOException
*/
private void writeResults() throws IOException, ParserConfigurationException, TransformerException {
PurityResults results = new PurityResults(pureMethodIdentifiers, impureMethodIdentifiers,
methodsModifyingThis, executedMethodIdentifiers,
parameterMutabilityInformation);
results.saveXML(resultFileName);
}
/**
* Launches analysis of a directory of trace files. It expects the name of the
* trace directory as its only argument.
*
* @param args
* the command line arguments
* @throws TransformerException
* @throws ParserConfigurationException
*/
public static void main(String[] args) throws IOException, ParserConfigurationException, TransformerException {
MultiplePurityTraceAnalyser traceAnalyser;
if (args.length != 3) {
System.out.println("Usage: java org.softevo.jdynpur.MultiplePurityTraceAnalyser ");
} else {
traceAnalyser = new MultiplePurityTraceAnalyser(args[0], args[1], new Boolean(args[2]));
traceAnalyser.analyse();
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/PurityResults.java 100644 0 0 24110 10763260050 24334 0 ustar 0 0 package org.softevo.jdynpur.eval;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Vector;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.softevo.jdynpur.eval.PurityTraceAnalyser.ParameterMutabilityInformation;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class PurityResults {
/**
* The set of methods known to modify the object they were invoked on.
*/
protected HashMap> methodsModifyingThisObject = null;
/**
* The set of MethodIdentifiers known to be pure.
*/
protected HashMap> pureMethodIdentifiers = null;
/**
* The set of MethodIdentifiers known to be impure.
*/
protected HashMap> impureMethodIdentifiers = null;
/**
* The set of executed MethodIdentifiers.
*/
protected HashMap> executedMethodIdentifiers = null;
private HashMap parameterMutabilityInformation;
public PurityResults() {
methodsModifyingThisObject = new HashMap>();
pureMethodIdentifiers = new HashMap>();
impureMethodIdentifiers = new HashMap>();
executedMethodIdentifiers = new HashMap>();
parameterMutabilityInformation = new HashMap();
}
public PurityResults(HashMap> pureMethodIdentifiers,
HashMap> impureMethodIdentifiers,
HashMap> methodsModifyingThisObject,
HashMap> executedMethodIdentifiers,
HashMap parameterMutabilityInformation) {
this();
this.executedMethodIdentifiers.putAll(executedMethodIdentifiers);
this.impureMethodIdentifiers.putAll(impureMethodIdentifiers);
this.methodsModifyingThisObject.putAll(methodsModifyingThisObject);
this.pureMethodIdentifiers.putAll(pureMethodIdentifiers);
if (parameterMutabilityInformation != null) {
this.parameterMutabilityInformation.putAll(parameterMutabilityInformation);
}
}
public HashMap> getExecutedMethodIdentifiers() {
return executedMethodIdentifiers;
}
public HashMap> getImpureMethodIdentifiers() {
return impureMethodIdentifiers;
}
public HashMap> getMethodsModifyingThisObject() {
return methodsModifyingThisObject;
}
public HashMap> getPureMethodIdentifiers() {
return pureMethodIdentifiers;
}
public HashMap getParameterMutabilityInformation() {
return parameterMutabilityInformation;
}
public void saveXML(String fileName) throws IOException, ParserConfigurationException, TransformerException {
Document targetDocument = null;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
DOMImplementation impl = builder.getDOMImplementation();
targetDocument = impl.createDocument(null, "purityresults", null);
Element root = targetDocument.getDocumentElement();
Element executedMethodsElement = targetDocument.createElement("executedmethods");
root.appendChild(executedMethodsElement);
addMethodElements(executedMethodsElement, targetDocument, executedMethodIdentifiers);
Element methodsModifyingThisElement = targetDocument.createElement("methodsmodifyingself");
root.appendChild(methodsModifyingThisElement);
addMethodElements(methodsModifyingThisElement, targetDocument, methodsModifyingThisObject);
Element impureMethodsElement = targetDocument.createElement("impuremethods");
root.appendChild(impureMethodsElement);
addMethodElements(impureMethodsElement, targetDocument, impureMethodIdentifiers);
Element pureMethodsElement = targetDocument.createElement("puremethods");
root.appendChild(pureMethodsElement);
addMethodElements(pureMethodsElement, targetDocument, pureMethodIdentifiers);
if (parameterMutabilityInformation != null && parameterMutabilityInformation.size() > 0) {
Element parameterElement = targetDocument.createElement("parametermutability");
root.appendChild(parameterElement);
addParameterElements(parameterElement, targetDocument, parameterMutabilityInformation);
}
StreamResult streamResult = new StreamResult(new FileOutputStream(fileName));
TransformerFactory tf = TransformerFactory.newInstance();
Transformer serializer = tf.newTransformer();
serializer.setOutputProperty(OutputKeys.ENCODING,"ISO-8859-1");
serializer.setOutputProperty(OutputKeys.INDENT,"yes");
DOMSource domSource = new DOMSource(targetDocument);
serializer.transform(domSource, streamResult);
}
protected void addParameterElements(Element parent, Document document,
HashMap parameterMutabilityInformation) {
for (MethodIdentifier identifier : parameterMutabilityInformation.keySet()) {
Element identifierElement = document.createElement("method");
parent.appendChild(identifierElement);
identifierElement.setAttribute("classname", identifier.getClassName());
identifierElement.setAttribute("methodname", identifier.getMethodName());
identifierElement.setAttribute("signature", identifier.getSignature());
identifierElement.setAttribute("access", Integer.toString(identifier.getAccess()));
ParameterMutabilityInformation mutabilityInformation = parameterMutabilityInformation.get(identifier);
HashMap> classNameToUnmodifiedParametersMap = mutabilityInformation.getRuntimeClassNameToUnmodifiedParametersMap();
for (String className : classNameToUnmodifiedParametersMap.keySet()) {
HashSet parameterIndexes = mutabilityInformation.getParameters();
if (parameterIndexes.size() > 0) {
HashSet unmodifiedParameterIndexes = classNameToUnmodifiedParametersMap.get(className);
Element classElement = document.createElement("runtimeclass");
classElement.setAttribute("classname", className);
identifierElement.appendChild(classElement);
Vector sortedParameters = new Vector(parameterIndexes);
Collections.sort(sortedParameters);
for (Integer parameterIndex : sortedParameters) {
Element parameterElement = document.createElement("parameter");
classElement.appendChild(parameterElement);
parameterElement.setAttribute("index", Integer.toString(parameterIndex));
if (unmodifiedParameterIndexes.contains(parameterIndex)) {
parameterElement.setAttribute("unmodified", "true");
} else {
parameterElement.setAttribute("unmodified", "false");
}
}
}
}
}
}
protected void addMethodElements(Element parent, Document document,
HashMap> methodIdentifiers) {
for (MethodIdentifier identifier : methodIdentifiers.keySet()) {
Element identifierElement = document.createElement("method");
parent.appendChild(identifierElement);
identifierElement.setAttribute("classname", identifier.getClassName());
identifierElement.setAttribute("methodname", identifier.getMethodName());
identifierElement.setAttribute("signature", identifier.getSignature());
identifierElement.setAttribute("access", Integer.toString(identifier.getAccess()));
HashSet invokedClasses = methodIdentifiers.get(identifier);
for (String className : invokedClasses) {
Element classElement = document.createElement("runtimeclass");
identifierElement.appendChild(classElement);
classElement.setAttribute("classname", className);
}
}
}
public void save(String fileName) throws IOException {
ObjectReaderWriter>> writer;
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(fileName);
writer = new ObjectReaderWriter>>();
writer.write(executedMethodIdentifiers, fileOutputStream);
writer.write(pureMethodIdentifiers, fileOutputStream);
writer.write(impureMethodIdentifiers, fileOutputStream);
writer.write(methodsModifyingThisObject, fileOutputStream);
} finally {
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException finalizeException) {
// ignore exception
}
}
}
}
public static PurityResults read(String fileName) throws IOException {
FileInputStream fileInputStream = null;
ObjectReaderWriter>> reader;
PurityResults result;
reader = new ObjectReaderWriter>>();
result = new PurityResults();
try {
fileInputStream = new FileInputStream(fileName);
result.executedMethodIdentifiers.putAll(reader.read(fileInputStream));
result.pureMethodIdentifiers.putAll(reader.read(fileInputStream));
result.impureMethodIdentifiers.putAll(reader.read(fileInputStream));
result.methodsModifyingThisObject.putAll(reader.read(fileInputStream));
return result;
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException finalizeException) {
// ignore exception
}
}
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/PurityTraceAnalyser.java 100644 0 0 73300 10763271347 25450 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.Serializable;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Stack;
import java.util.Vector;
import java.lang.jdynpur.Tracer;
import org.apache.commons.io.input.CountingInputStream;
import org.softevo.util.ObjectIdMapper;
import org.softevo.util.asm.FieldIdentifier;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This class implements dynamic purity analysis of an execution trace file. The
* main idea of the analysis is as follows:
*
*
For every method, calculate the set of modified and the set of created
* objects.
*
At the end of each method, add the set of created objects to the created
* objects of the calling method.
*
At the end of each method, check whether any object not created during
* the execution of the method was modified. If this is the case, the execution
* was impure, otherwise pure.
*
*
* @author dallmeier
*/
public class PurityTraceAnalyser {
/**
* The name of the trace file to be analyzed.
*/
protected String fileName = null;
/**
* Name of the file where results are saved.
*/
protected String resultsFileName = null;
/**
* Identifier map used for this trace.
*/
protected MethodIdentifierMapGenerator identifierMap = null;
/**
* The set of method ids known to be impure.
*/
protected HashMap> impureMethodIds = null;
/**
* The set of executed methods.
*/
protected HashMap> executedMethodIds = null;
/**
* The set of methods known to modify the object they were invoked on.
*/
protected HashMap> methodsModifyingThisObject = null;
/**
* The set of MethodIdentifiers known to be pure.
*/
protected HashMap> pureMethodIdentifiers = null;
/**
* The set of MethodIdentifiers modifying a this object.
*/
protected HashMap> thisModifyingMethodIdentifiers = null;
/**
* The set of MethodIdentifiers known to be impure.
*/
protected HashMap> impureMethodIdentifiers = null;
/**
* The set of executed MethodIdentifiers.
*/
protected HashMap> executedMethodIdentifiers = null;
/**
* A map of thread ids to a stack of object identifiers created in a method.
*/
protected HashMap>> threadIdToCreatedObjectSetStackMap = null;
protected HashMap>> threadIdToParameterSetStackMap = null;
protected ObjectIdMapper fieldIdentifierMap = null;
/**
* A map of thread ids to a stack of object identifiers modified in a method.
*/
protected HashMap>> threadIdToModifiedObjectSetStackMap = null;
/**
* A map of thread ids to a method call stack.
*/
protected HashMap> threadIdToMethodCallStackMap = null;
/**
* A map of thread ids to a stack of this object identifiers for active
* non-static methods.
*/
protected HashMap> threadIdToThisStackMap = null;
/**
* A map of thread ids to a stack of this type for active
* non-static methods.
*/
protected HashMap> threadIdToThisTypeMap = null;
protected HashMap parameterMutabilityInformation = null;
/**
* Flag for verbose output.
*/
protected boolean verbose = false;
/**
* Flag if pure method identifiers should be printed to
* System.out .
*/
protected boolean printResults = false;
/**
* Flag if results shall be saved.
*/
protected boolean saveResults = false;
/**
* Flag indicating if API methods should be excluded from the result data
* structures.
*/
protected boolean excludeAPIMethodsFromResults = true;
/**
* Flag indicating if the effects of static initializers should be ignored. If
* you are not sure about this flag, set it to true.
*/
protected boolean ignoreEffectsOfStaticInitializers = true;
private HashMap> heap;
private boolean analyseParameterMutability;
/**
* Creates a new purity analyser for a trace file.
*
* @param fileName
* the name of the trace
* @param identifierMap
* the identifier map generated together with the trace
*/
public PurityTraceAnalyser(String fileName, String resultsFileName,
boolean saveResults, boolean analyseParameterMutability) {
this.fileName = fileName;
this.resultsFileName = resultsFileName;
this.saveResults = saveResults;
this.excludeAPIMethodsFromResults = Boolean.FALSE;
this.analyseParameterMutability = analyseParameterMutability;
this.identifierMap = new MethodIdentifierMapGenerator();
this.fieldIdentifierMap = new ObjectIdMapper();
impureMethodIds = new HashMap>();
executedMethodIds = new HashMap>();
methodsModifyingThisObject = new HashMap>();
threadIdToMethodCallStackMap = new HashMap>();
threadIdToCreatedObjectSetStackMap = new HashMap>>();
threadIdToModifiedObjectSetStackMap = new HashMap>>();
threadIdToThisStackMap = new HashMap>();
threadIdToThisTypeMap = new HashMap>();
if (analyseParameterMutability) {
threadIdToParameterSetStackMap = new HashMap>>();
parameterMutabilityInformation = new HashMap();
heap = new HashMap>(10000);
}
}
/**
* Starts analysis of the trace.
*
* @param verbose
* flag if output shall be verbose
* @param printResults
* flag if results should be printed to System.out
* @throws IOException
* if an exception occurs reading from the trace
*/
public void analyse(boolean verbose, boolean printResults) throws IOException {
DataInputStream dataInputStream;
int eventType;
int value, value2, threadId, loopCounter = 0;
String className;
System.out.println("Analyzing trace " + fileName);
this.verbose = verbose;
this.printResults = printResults;
File traceFile = new File(fileName);
long fileSize = traceFile.length();
CountingInputStream countingInputStream = new CountingInputStream(new BufferedInputStream(new FileInputStream(traceFile)));
dataInputStream = new DataInputStream(countingInputStream);
NumberFormat formatter = new DecimalFormat("00");
String percentageString = null;
while (loopCounter >= 0) {
loopCounter++;
if (loopCounter > 0 && loopCounter % 100000 == 0) {
double percentageDone = countingInputStream.getCount()*100d/(fileSize*1.0d);
String newPercentageString = formatter.format(percentageDone);
if (percentageString != null && !newPercentageString.equals(percentageString)) {
System.out.println(percentageString + "% done.");
}
percentageString = newPercentageString;
}
try {
eventType = dataInputStream.readInt();
if (eventType != Tracer.EV_METHODID && eventType != Tracer.EV_FIELDID) {
threadId = dataInputStream.readInt();
value = dataInputStream.readInt();
switch (eventType) {
case Tracer.EV_FIELDWRITE:
handleFieldWrite(value, threadId);
break;
case Tracer.EV_DYNAMICMETHODEND:
if (identifierMap.getMethodIdentifier(value) == null) {
System.out.println("Ignoring method end " + value + " for thread " + threadId);
} else {
handleDynamicMethodEnd(value, threadId);
}
break;
case Tracer.EV_STATICMETHODEND:
handleStaticMethodEnd(value, threadId);
break;
case Tracer.EV_STATICMETHODSTART:
handleStaticMethodStart(value, threadId);
break;
case Tracer.EV_DYNAMICMETHODSTART:
value2 = dataInputStream.readInt();
className = dataInputStream.readUTF().replace('.', '/');
handleDynamicMethodStart(value, value2, threadId, className);
break;
case Tracer.EV_OBJECTCREATION:
handleObjectCreation(value, threadId);
break;
case Tracer.EV_STATICFIELDWRITE:
handleStaticFieldWrite(threadId);
break;
case Tracer.EV_ARRAYCREATED:
handleArrayCreation(value, threadId);
break;
case Tracer.EV_ARRAYMODIFIED:
handleArrayModification(value, threadId);
break;
case Tracer.EV_PARAMETER: {
int objectId = dataInputStream.readInt();
if (analyseParameterMutability) {
handleParameter(value, threadId, objectId);
}
break;
}
case Tracer.EV_OBJECTFIELDWRITE: {
int fieldId = value;
int changedObjectId = dataInputStream.readInt();
int newValueObjectId = dataInputStream.readInt();
handleObjectFieldWrite(fieldId, threadId, changedObjectId, newValueObjectId);
break;
}
case Tracer.EV_OBJECTARRAYMODIFIED: {
int changedObjectId = value;
int arrayIndex = dataInputStream.readInt();
int newObjectId = dataInputStream.readInt();
handleObjectArrayModification(threadId, changedObjectId, arrayIndex, newObjectId);
break;
}
default:
throw new RuntimeException("Illegal trace event code " + eventType);
}
} else {
if (eventType == Tracer.EV_METHODID) {
int methodId = dataInputStream.readInt();
int access = dataInputStream.readInt();
String methodName = dataInputStream.readUTF();
MethodIdentifier identifier = MethodIdentifier.parseFromIdentifier(methodName, access);
identifierMap.add(methodId, identifier);
} else if (eventType == Tracer.EV_FIELDID) {
int fieldId = dataInputStream.readInt();
String fieldIdentifier = dataInputStream.readUTF();
FieldIdentifier identifier = FieldIdentifier.parseIdentifierFromString(fieldIdentifier);
fieldIdentifierMap.put(fieldId, identifier);
}
}
} catch (EOFException eof) {
dataInputStream.close();
handleTraceEnd();
break;
}
}
System.out.println();
}
private HashMap getOrCreateMapForObject(int objectId) {
HashMap result = heap.get(objectId);
if (result == null) {
result = new HashMap();
heap.put(objectId, result);
}
return result;
}
protected HashSet getTransitiveStateForObject(int objectId) {
HashSet result = new HashSet(100);
addStateRecursively(objectId, result);
return result;
}
private void addStateRecursively(int objectId, HashSet result) {
if (!result.contains(objectId)) {
result.add(objectId);
HashMap state = heap.get(objectId);
if (state != null) {
for (Integer childObjectId: state.values()) {
addStateRecursively(childObjectId, result);
}
}
}
}
protected void handleObjectArrayModification(int threadId, int changedObjectId,
int arrayIndex, int newObjectId) {
handleObjectFieldWrite(arrayIndex, threadId, changedObjectId, newObjectId);
}
protected void handleObjectFieldWrite(int fieldId, int threadId,
int changedObjectId, int newValueObjectId) {
if (analyseParameterMutability) {
HashMap objectFields = getOrCreateMapForObject(changedObjectId);
objectFields.put(fieldId, newValueObjectId);
}
getModifiedObjectSetStack(threadId).peek().add(changedObjectId);
}
protected void handleParameter(int index, int threadId, int objectId) {
Stack> parameters = getParameterSetStack(threadId);
assert (parameters.size() > 0) : "No parameter set found.";
parameters.peek().put(index, objectId);
}
protected Stack getThisTypeStack(int threadId) {
Stack result;
result = threadIdToThisTypeMap.get(threadId);
if (result == null) {
result = new Stack();
threadIdToThisTypeMap.put(threadId, result);
}
return result;
}
/**
* Gets the this object stack for a given thread.
*
* @param threadId
* the id of the thread
* @return the stack
*/
protected Stack getThisObjectStack(int threadId) {
Stack result;
result = threadIdToThisStackMap.get(threadId);
if (result == null) {
result = new Stack();
threadIdToThisStackMap.put(threadId, result);
}
return result;
}
/**
* Gets the method call stack for a given thread.
*
* @param threadId
* the id of the thread
* @return the stack
*/
protected Stack getMethodCallStack(int threadId) {
Stack result;
result = threadIdToMethodCallStackMap.get(threadId);
if (result == null) {
result = new Stack();
threadIdToMethodCallStackMap.put(threadId, result);
}
return result;
}
/**
* Gets the created object set stack for a given thread.
*
* @param threadId
* the id of the thread
* @return the stack
*/
protected Stack> getCreatedObjectSetStack(int threadId) {
Stack> result;
result = threadIdToCreatedObjectSetStackMap.get(threadId);
if (result == null) {
result = new Stack>();
threadIdToCreatedObjectSetStackMap.put(threadId, result);
}
return result;
}
/**
* Gets the modified object set stack for a given thread.
*
* @param threadId
* the id of the thread
* @return the stack
*/
protected Stack> getModifiedObjectSetStack(int threadId) {
Stack> result;
result = threadIdToModifiedObjectSetStackMap.get(threadId);
if (result == null) {
result = new Stack>();
threadIdToModifiedObjectSetStackMap.put(threadId, result);
}
return result;
}
protected Stack> getParameterSetStack(int threadId) {
Stack> result;
result = threadIdToParameterSetStackMap.get(threadId);
if (result == null) {
result = new Stack>();
threadIdToParameterSetStackMap.put(threadId, result);
}
return result;
}
/**
* This method checks if the integer passed identifies a user or an API
* method. Identification of API methods is done by class name.
*
* @param methodId
* the method identifier
*/
protected boolean isAPIMethod(int methodId) {
MethodIdentifier identifier;
identifier = identifierMap.getMethodIdentifier(methodId);
if (identifier.getClassName().startsWith("java") || identifier.getClassName().startsWith("sun")) {
return true;
} else {
return false;
}
}
protected HashMap> convertMap(HashMap> map) {
HashMap> result;
Iterator iterator;
int methodId;
result = new HashMap>();
iterator = map.keySet().iterator();
while (iterator.hasNext()) {
methodId = iterator.next();
if (!excludeAPIMethodsFromResults || !isAPIMethod(methodId)) {
result.put(identifierMap.getMethodIdentifier(methodId), map.get(methodId));
}
}
return result;
}
/**
* This method is called upon end of the trace. It fills the result
* datastructures and prints information to System.out if the
* printResults flag is set.
*/
protected void handleTraceEnd() {
Iterator iterator;
Iterator methodNameIterator;
Vector pureMethodNames;
int methodId;
PurityResults results;
iterator = executedMethodIds.keySet().iterator();
pureMethodNames = new Vector(executedMethodIds.size());
pureMethodIdentifiers = new HashMap>();
impureMethodIdentifiers = convertMap(impureMethodIds);
thisModifyingMethodIdentifiers = convertMap(methodsModifyingThisObject);
executedMethodIdentifiers = convertMap(executedMethodIds);
while (iterator.hasNext()) {
methodId = iterator.next();
if (!impureMethodIds.containsKey(methodId)) {
pureMethodNames.add(identifierMap.getMethodIdentifier(methodId).toString());
if (!excludeAPIMethodsFromResults || !isAPIMethod(methodId)) {
pureMethodIdentifiers.put(identifierMap.getMethodIdentifier(methodId),
executedMethodIds.get(methodId));
}
}
}
if (printResults) {
Collections.sort(pureMethodNames);
methodNameIterator = pureMethodNames.iterator();
System.out.println("Pure methods:");
while (methodNameIterator.hasNext()) {
System.out.println(methodNameIterator.next());
}
System.out.println("Number of pure methods: " + pureMethodNames.size());
System.out.println("Number of executed methods: " + executedMethodIds.size());
}
System.out.println("Saving results to " + resultsFileName);
results = new PurityResults(pureMethodIdentifiers, impureMethodIdentifiers, thisModifyingMethodIdentifiers,
executedMethodIdentifiers, parameterMutabilityInformation);
if (saveResults) {
try {
results.saveXML(resultsFileName);
} catch (Exception exception) {
System.out.println("An exception occured saving results.");
exception.printStackTrace(System.out);
}
}
}
/**
* Called to handle an array creation event.
*
* @param objectId
* the id of the new array
* @param threadId
* the thread id
*/
protected void handleArrayCreation(int objectId, int threadId) {
if (verbose) {
System.out.println("Array created with id " + objectId + " in thread " + threadId + ".");
}
getCreatedObjectSetStack(threadId).peek().add(objectId);
}
/**
* Called to handle an array modification event.
*
* @param objectId
* the id of the modified array
* @param threadId
* the thread id
*/
protected void handleArrayModification(int objectId, int threadId) {
if (verbose) {
System.out.println("Array " + objectId + " modified in thread " + threadId + ".");
}
getModifiedObjectSetStack(threadId).peek().add(objectId);
}
/**
* Called to handle a static field write event.
*
* @param threadId
* the thread id
*/
protected void handleStaticFieldWrite(int threadId) {
MethodIdentifier methodIdentifier;
if (verbose) {
System.out.println("Static field written in thread " + threadId + ".");
}
methodIdentifier = identifierMap.getMethodIdentifier(getMethodCallStack(threadId).peek());
if (ignoreEffectsOfStaticInitializers && methodIdentifier.getMethodName().equals("")) {
if (verbose) {
System.out.println("Ignoring static field write in of class " + methodIdentifier.getClassName());
}
} else {
getModifiedObjectSetStack(threadId).peek().add(Tracer.STATIC);
}
}
/**
* Called to handle a field write event.
*
* @param threadId
* the thread id
* @param objectId
* id of the modified object
*/
protected void handleFieldWrite(int objectId, int threadId) {
if (verbose) {
System.out.println("Field written in object " + objectId + " in thread " + threadId + ".");
}
getModifiedObjectSetStack(threadId).peek().add(objectId);
}
/**
* Handles object creation event.
*
* @param objectId
* the id of the new object
* @param threadId
* the thread id
*/
protected void handleObjectCreation(int objectId, int threadId) {
if (verbose) {
System.out.println("Object created with id " + objectId + " in thread " + threadId + ".");
}
getCreatedObjectSetStack(threadId).peek().add(objectId);
}
protected void addToHashMap(HashMap> map, int methodId, String className) {
HashSet types;
types = map.get(methodId);
if (types == null) {
types = new HashSet();
map.put(methodId, types);
}
if (className != null) {
types.add(className);
}
}
/**
* Handles a method start event. This method creates all neccessary
* datastructures to analyze execution of the method.
*
* @param methodId
* the id of the method invoked
* @param threadId
* the thread id
*/
protected void handleMethodStart(int methodId, int threadId, String className) {
if (verbose) {
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId) + " in thread " + threadId
+ " started.");
}
if (className != null) {
addToHashMap(executedMethodIds, methodId, className);
}
getMethodCallStack(threadId).push(methodId);
getCreatedObjectSetStack(threadId).push(new HashSet());
getModifiedObjectSetStack(threadId).push(new HashSet());
if (analyseParameterMutability) {
getParameterSetStack(threadId).push(new HashMap());
}
}
/**
* Handles start of a dynamic method. In addition to calling
* handleMethodStart, this method also modifieds the
* thisObjectStack.
*
* @param methodId
* the method identifier
* @param thisObjectId
* the identifier of the this object
* @param threadId
* the id of the thread
*/
protected void handleDynamicMethodStart(int methodId, int thisObjectId,
int threadId, String className) {
getThisObjectStack(threadId).push(thisObjectId);
getThisTypeStack(threadId).push(className);
handleMethodStart(methodId, threadId, className);
}
/**
* Handles start of a static method. This method only calls
* handleMethodStart
*
* @param methodId
* the identifier of the method
* @param threadId
* the thread id
*/
protected void handleStaticMethodStart(int methodId, int threadId) {
handleMethodStart(methodId, threadId, null);
}
/**
* Handles end of a static method. This method only calls
* handleMethodEnd.
*
* @param methodId
* the id of the method
* @param threadId
* the thread id
*/
protected void handleStaticMethodEnd(int methodId, int threadId) {
handleMethodEnd(methodId, threadId, null);
}
/**
* Handles end of a dynamic method. In addition to calling
* handleMethodEnd, this method also modifies the
* thisObjectStack
*
* @param methodId
* the id of the method
* @param threadId
* the thread id
*/
protected void handleDynamicMethodEnd(int methodId, int threadId) {
HashSet modifiedObjects;
int thisObjectId;
String className;
if (verbose) {
System.out.println("Dynamic method " + identifierMap.getMethodIdentifier(methodId) + " (" + methodId
+ ") in thread " + threadId + " finished.");
}
modifiedObjects = getModifiedObjectSetStack(threadId).peek();
thisObjectId = getThisObjectStack(threadId).pop();
className = getThisTypeStack(threadId).pop();
if (modifiedObjects.contains(thisObjectId)) {
addToHashMap(methodsModifyingThisObject, methodId, className);
}
handleMethodEnd(methodId, threadId, className);
}
/**
* Handles method end events. This method evaluates the set of modified and
* created objects and classifies methods as impure.
*
* @param methodId
* the id of the method
* @param threadId
* the thread id
*/
protected void handleMethodEnd(int methodId, int threadId, String className) {
if (verbose) {
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId) + " in thread " + threadId
+ " finished.");
}
int activeMethodId = getMethodCallStack(threadId).pop();
HashSet createdObjects = getCreatedObjectSetStack(threadId).pop();
HashSet modifiedObjects = getModifiedObjectSetStack(threadId).pop();
if (methodId != activeMethodId) {
System.out.println("Method Start/End mismatch for thread " + threadId);
System.out
.println("Method that finished: " + identifierMap.getMethodIdentifier(methodId) + " (" + methodId + ")");
System.out.println("Method that should have finished: " + identifierMap.getMethodIdentifier(activeMethodId)
+ " (" + activeMethodId + ")");
}
if (className == null) {
MethodIdentifier identifier = identifierMap.getMethodIdentifier(methodId);
className = identifier.getClassName();
}
// this assumes that all objects created in a sub method
// may escape
if (getCreatedObjectSetStack(threadId).size() > 0) {
getCreatedObjectSetStack(threadId).peek().addAll(createdObjects);
}
if (getModifiedObjectSetStack(threadId).size() > 0) {
getModifiedObjectSetStack(threadId).peek().addAll(modifiedObjects);
}
if (!createdObjects.containsAll(modifiedObjects)) {
addToHashMap(impureMethodIds, activeMethodId, className);
}
if (analyseParameterMutability) {
HashMap parameters = getParameterSetStack(threadId).pop();
processParameterModification(parameters, modifiedObjects, methodId, className);
}
}
protected void processParameterModification(HashMap parameters, HashSet modifiedObjects,
int methodId, String className) {
HashSet unmodifiedParameters = new HashSet(parameters.size());
for (int parameterIndex : parameters.keySet()) {
int objectId = parameters.get(parameterIndex);
if ((objectId != Tracer.NULL)) {
HashSet transitiveState = getTransitiveStateForObject(objectId);
boolean isUnmodified = true;
for (Integer stateObjectId : transitiveState) {
if (modifiedObjects.contains(stateObjectId)) {
isUnmodified = false;
break;
}
}
if (isUnmodified) {
unmodifiedParameters.add(parameterIndex);
}
} else {
unmodifiedParameters.add(parameterIndex);
}
}
MethodIdentifier identifier = identifierMap.getMethodIdentifier(methodId);
ParameterMutabilityInformation information = parameterMutabilityInformation.get(identifier);
if (information == null) {
information = new ParameterMutabilityInformation(identifier);
parameterMutabilityInformation.put(identifier, information);
}
information.updateUnmodifiedParameters(className, unmodifiedParameters);
for (Integer parameterIndex : parameters.keySet()) {
information.addParameter(parameterIndex);
}
}
/**
* Launches purity trace analysis. This method expects the name of the trace
* file and the name of the identifier map file.
*
* @param args
* command line arguments
*/
public static void main(String[] args) throws IOException {
PurityTraceAnalyser traceAnalyser;
if (args.length != 3) {
System.out
.println("Usage: java org.softevo.jdynpur.PurityTraceAnalyser ");
} else {
Boolean analyseParameterMutability = new Boolean(args[2]);
if (analyseParameterMutability) {
System.out.println("Parameter Mutability Analysis is turned on.");
} else {
System.out.println("Parameter Mutability Analysis is turned off.");
}
traceAnalyser = new PurityTraceAnalyser(args[0], args[1], true, analyseParameterMutability);
traceAnalyser.analyse(false, true);
}
}
/**
* Gets the set of impure methods.
*/
public HashMap> getImpureMethodIdentifiers() {
return impureMethodIdentifiers;
}
/**
* Gets the set of pure methods.
*/
public HashMap> getPureMethodIdentifiers() {
return pureMethodIdentifiers;
}
/**
* Gets the set of executed methods.
*/
public HashMap> getThisModifyingMethodIdentifiers() {
return thisModifyingMethodIdentifiers;
}
/**
* Gets the set of executed methods.
*/
public HashMap> getExecutedMethodIdentifiers() {
return executedMethodIdentifiers;
}
public static class ParameterMutabilityInformation implements Serializable {
private static final long serialVersionUID = 3550107163836583142L;
private MethodIdentifier methodIdentifier;
private HashMap> runtimeClassNameToUnmodifiedParametersMap;
private HashSet parameters;
public ParameterMutabilityInformation(MethodIdentifier methodIdentifier) {
this.methodIdentifier = methodIdentifier;
this.runtimeClassNameToUnmodifiedParametersMap = new HashMap>();
this.parameters = new HashSet();
}
public MethodIdentifier getMethodIdentifier() {
return methodIdentifier;
}
public void updateUnmodifiedParameters(String runtimeClassName, HashSet unmodifiedParameters) {
HashSet oldUnmodifiedParameters = runtimeClassNameToUnmodifiedParametersMap.get(runtimeClassName);
if (oldUnmodifiedParameters == null) {
runtimeClassNameToUnmodifiedParametersMap.put(runtimeClassName, (HashSet) unmodifiedParameters.clone());
} else {
HashSet parametersToDelete = new HashSet();
for (Integer unmodifiedParameter : oldUnmodifiedParameters) {
if (!unmodifiedParameters.contains(unmodifiedParameter)) {
parametersToDelete.add(unmodifiedParameter);
}
}
for (Integer parameter : parametersToDelete) {
oldUnmodifiedParameters.remove(parameter);
}
}
}
public void addParameter(int parameterIndex) {
parameters.add(parameterIndex);
}
public HashSet getParameters() {
return parameters;
}
public HashMap> getRuntimeClassNameToUnmodifiedParametersMap() {
return runtimeClassNameToUnmodifiedParametersMap;
}
}
public HashMap getParameterMutabilityInformation() {
return parameterMutabilityInformation;
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/eval/StaticDynamicComparer.java 100644 0 0 16265 10564101427 25720 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Vector;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
public class StaticDynamicComparer {
private String dataDirectoryName;
public StaticDynamicComparer(String dataDirectoryName) {
this.dataDirectoryName = dataDirectoryName;
}
/*private HashSet readHashSet(String fileName) throws IOException {
FileInputStream fileInputStream = null;
ObjectInputStream objectInputStream;
try {
fileInputStream = new FileInputStream(fileName);
objectInputStream = new ObjectInputStream(fileInputStream);
try {
return (HashSet) objectInputStream.readObject();
} catch (ClassNotFoundException noSuchClass) {
throw new IOException("Class not found: " + noSuchClass.getMessage());
}
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException finalizeException) {
// ignore exception
}
}
}
}*/
private HashSet filterNotExecutedMethods(HashSet identifiers,
HashSet executedMethods) {
HashSet result;
Iterator idIterator;
MethodIdentifier identifier;
result = new HashSet(identifiers.size());
idIterator = identifiers.iterator();
while (idIterator.hasNext()) {
identifier = idIterator.next();
if (executedMethods.contains(identifier)) {
result.add(identifier);
}
}
return result;
}
private HashSet removeAspectJPackageNames(Collection identifiers) {
HashSet result;
Iterator idIterator;
MethodIdentifier identifier;
result = new HashSet();
idIterator = identifiers.iterator();
while (idIterator.hasNext()) {
identifier = idIterator.next();
/*
* if
* (/*identifier.getClassName().endsWith("AbstractSyntaxTreeVisitorAdapter") &&
* identifier.getMethodName().equals("endVisit")) {
* System.out.println("Old identifier: " + identifier);
* System.out.println("New identifier: " + new
* MethodIdentifier(identifier.getClassName().replaceAll("org\\.aspectj\\.org\\.eclipse",
* "org.eclipse"), identifier.getMethodName(),
* identifier.getSignature().replaceAll("org/aspectj/org/eclipse",
* "org/eclipse"))); }
*/
result.add(new MethodIdentifier(identifier.getClassName().replaceAll("org\\.aspectj\\.org\\.eclipse",
"org.eclipse"), identifier.getMethodName(),
identifier.getSignature().replaceAll("org/aspectj/org/eclipse", "org/eclipse"), identifier.getAccess()));
}
return result;
}
private HashSet getCommonIdentifiers(HashSet firstSet,
HashSet secondSet) {
HashSet result;
Iterator idIterator;
MethodIdentifier identifier;
result = new HashSet();
idIterator = firstSet.iterator();
while (idIterator.hasNext()) {
identifier = idIterator.next();
if (secondSet.contains(identifier)) {
result.add(identifier);
}
}
return result;
}
private void displaySet(HashSet set, String message) {
Iterator methodIdIterator;
methodIdIterator = set.iterator();
System.out.println(message);
while (methodIdIterator.hasNext()) {
System.out.println(methodIdIterator.next());
}
System.out.println("========================================================");
System.out.println();
}
public void compare() throws IOException {
HashSet dynamicImpureMethods, dynamicPureMethods, executedMethods, executedStaticPureMethods, executedStaticImpureMethods, staticAnalyzedMethods, staticPureMethods, staticImpureMethods;
Iterator methodIdIterator;
MethodIdentifier identifier;
ObjectReaderWriter> hashSetReader;
ObjectReaderWriter> vectorReader;
hashSetReader = new ObjectReaderWriter>();
vectorReader = new ObjectReaderWriter>();
staticPureMethods = removeAspectJPackageNames(vectorReader.read(new File(dataDirectoryName + File.separator
+ "staticpuremethods.ser")));
staticImpureMethods = removeAspectJPackageNames(vectorReader.read(new File(dataDirectoryName + File.separator
+ "staticimpuremethods.ser")));
dynamicPureMethods = hashSetReader.read(new File(dataDirectoryName + File.separator + "dynamicpuremethods.ser"));
dynamicImpureMethods = hashSetReader
.read(new File(dataDirectoryName + File.separator + "dynamicimpuremethods.ser"));
executedMethods = hashSetReader.read(new File(dataDirectoryName + File.separator + "dynamicexecutedmethods.ser"));
executedStaticImpureMethods = filterNotExecutedMethods(staticImpureMethods, executedMethods);
executedStaticPureMethods = filterNotExecutedMethods(staticPureMethods, executedMethods);
System.out.println("Static impure methods: " + staticImpureMethods.size());
System.out.println("Static pure methods: " + staticPureMethods.size());
System.out.println("Dynamic pure methods: " + dynamicPureMethods.size());
System.out.println("Dynamic impure methods: " + dynamicImpureMethods.size());
System.out.println("Dynamic executed methods: " + executedMethods.size());
System.out.println("Static executed impure: " + executedStaticImpureMethods.size());
System.out.println("Static executed pure: " + executedStaticPureMethods.size());
System.out.println("Static Pure Dynamic Impure: "
+ getCommonIdentifiers(executedStaticPureMethods, dynamicImpureMethods).size());
if (getCommonIdentifiers(executedStaticPureMethods, dynamicImpureMethods).size() > 0) {
displaySet(getCommonIdentifiers(executedStaticPureMethods, dynamicImpureMethods), "List of methods");
}
System.out.println("Static Pure Dynamic Pure: "
+ getCommonIdentifiers(executedStaticPureMethods, dynamicPureMethods).size());
System.out.println("Static Impure Dynamic Impure: "
+ getCommonIdentifiers(executedStaticImpureMethods, dynamicImpureMethods).size());
System.out.println("Static Impure Dynamic Pure: "
+ getCommonIdentifiers(executedStaticImpureMethods, dynamicPureMethods).size());
System.out.println();
staticAnalyzedMethods = new HashSet(staticImpureMethods);
staticAnalyzedMethods.addAll(staticPureMethods);
System.out.println("Methods executed dynamically but not analyzed:");
methodIdIterator = executedMethods.iterator();
while (methodIdIterator.hasNext()) {
identifier = methodIdIterator.next();
if (!staticAnalyzedMethods.contains(identifier)) {
System.out.println(identifier);
}
}
}
/**
* @param args
*/
public static void main(String[] args) throws Exception {
StaticDynamicComparer comparer;
if (args.length != 1) {
System.out.println("Usage: java org.softevo.jdynpur.StaticDynamicComparer ");
} else {
comparer = new StaticDynamicComparer(args[0]);
comparer.compare();
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/ArrayTracingVisitor.java 100644 0 0 6374 10763211510 26151 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.commons.LocalVariablesSorter;
public class ArrayTracingVisitor extends LocalVariablesSorter implements Opcodes {
private int temporaryVariableIndex = -1;
public ArrayTracingVisitor(MethodVisitor visitor, int access, String desc) {
super(access, desc, visitor);
}
@Override
public void visitTypeInsn(int opcode, String typeDescription) {
if (opcode == ANEWARRAY) {
super.visitTypeInsn(opcode, typeDescription);
super.visitInsn(DUP);
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "arrayCreated", "(Ljava/lang/Object;)V");
} else {
super.visitTypeInsn(opcode, typeDescription);
}
}
@Override
public void visitIntInsn(int opcode, int operand) {
if (opcode == NEWARRAY) {
super.visitIntInsn(opcode, operand);
super.visitInsn(DUP);
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "arrayCreated", "(Ljava/lang/Object;)V");
} else {
super.visitIntInsn(opcode, operand);
}
}
@Override
public void visitInsn(int opcode) {
int storeOpCode, loadOpCode;
if ((opcode == AASTORE) || (opcode == SASTORE) || (opcode == BASTORE) || (opcode == CASTORE) || (opcode == FASTORE)
|| (opcode == IASTORE)) {
super.visitInsn(DUP2_X1);
super.visitInsn(POP2);
super.visitInsn(DUP_X2);
super
.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "arrayModified", "(Ljava/lang/Object;)V");
super.visitInsn(opcode);
} else if (opcode == AASTORE) {
//this effectively duplicates the three top operand stack words
super.visitInsn(DUP2_X1);
super.visitInsn(POP2);
super.visitInsn(DUP_X2);
super.visitInsn(DUP2_X1);
super.visitInsn(POP2);
super.visitInsn(DUP_X2);
super.visitInsn(DUP2_X1);
super.visitInsn(POP2);
super.visitInsn(DUP_X2);
super.visitInsn(opcode);
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "objectArrayModified", "(Ljava/lang/Object;ILjava/lang/Object;)V");
} else if ((opcode == LASTORE) || (opcode == DASTORE)) {
if (opcode == LASTORE) {
storeOpCode = LSTORE;
loadOpCode = LLOAD;
} else {
storeOpCode = DSTORE;
loadOpCode = DLOAD;
}
if (temporaryVariableIndex == -1) {
temporaryVariableIndex = newLocal(2);
}
super.visitVarInsn(storeOpCode, temporaryVariableIndex);
super.visitInsn(SWAP);
super.visitInsn(DUP_X1);
super.visitInsn(SWAP);
super.visitVarInsn(loadOpCode, temporaryVariableIndex);
// add original instruction
super.visitInsn(opcode);
super
.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "arrayModified", "(Ljava/lang/Object;)V");
} else {
super.visitInsn(opcode);
}
}
@Override
public void visitMultiANewArrayInsn(String typeDesc, int dimensions) {
super.visitMultiANewArrayInsn(typeDesc, dimensions);
super.visitInsn(DUP);
super.visitInsn(DUP);
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "arrayCreated", "(Ljava/lang/Object;)V");
super.visitLdcInsn(new Integer(dimensions - 2));
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "addArraysRecursively",
"([Ljava/lang/Object;I)V");
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/ConstructorPurityTracingVisitor.java 100644 0 0 2342 10564077503 30637 0 ustar 0 0 package org.softevo.jdynpur.runtime;
import org.objectweb.asm.MethodAdapter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
public class ConstructorPurityTracingVisitor extends MethodAdapter implements Opcodes {
private String superClassName = null;
private String className = null;
private boolean isConstructor = false;
public ConstructorPurityTracingVisitor(MethodVisitor methodVisitor, String methodName, String className,
String superClassName) {
super(methodVisitor);
this.superClassName = superClassName;
this.className = className;
isConstructor = methodName.equals("");
}
public void visitMethodInsn(int opCode, String owner, String name, String desc) {
if (isConstructor && (opCode == INVOKESPECIAL) && name.equals("")
&& (owner.equals(className) || owner.equals(superClassName))) {
// System.out.println("Found call to this or super constructor");
super.visitMethodInsn(opCode, owner, name, desc);
super.visitVarInsn(ALOAD, 0);
super
.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "objectCreated", "(Ljava/lang/Object;)V");
} else {
super.visitMethodInsn(opCode, owner, name, desc);
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/FieldWriteTracingVisitor.java 100644 0 0 5672 10762762211 27141 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import org.objectweb.asm.MethodAdapter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.softevo.util.ObjectIdMapper;
import org.softevo.util.asm.FieldIdentifier;
public class FieldWriteTracingVisitor extends MethodAdapter implements Opcodes {
protected boolean isConstructor = false;
protected boolean isAfterConstructorCall = false;
protected String className = null;
protected String superClassName = null;
private ObjectIdMapper fieldIdentifierMap;
public FieldWriteTracingVisitor(MethodVisitor mv, String methodName,
String className, String superClassName,
ObjectIdMapper fieldIdentifierMap) {
super(mv);
isConstructor = methodName.equals("");
this.className = className;
this.superClassName = superClassName;
this.fieldIdentifierMap = fieldIdentifierMap;
}
@Override
public void visitMethodInsn(int opCode, String owner, String name, String desc) {
if (isConstructor && (opCode == INVOKESPECIAL) && name.equals("")
&& (owner.equals(className) || owner.equals(superClassName))) {
isAfterConstructorCall = true;
}
super.visitMethodInsn(opCode, owner, name, desc);
}
@Override
public void visitFieldInsn(int opCode, String className, String fieldName, String typeDesc) {
if (!isConstructor || isAfterConstructorCall) {
FieldIdentifier identifier = new FieldIdentifier(className, fieldName, typeDesc);
int id;
if (!fieldIdentifierMap.contains(identifier)) {
id = fieldIdentifierMap.add(identifier);
} else {
id = fieldIdentifierMap.getId(identifier);
}
// we are interested in static and object field writes
if ((opCode == PUTFIELD) || (opCode == PUTSTATIC)) {
if (opCode == PUTFIELD) {
// instructions for 2 word and 1 word fields differ
if (!identifier.isComplexType()) {
if (typeDesc.equals("D") || typeDesc.equals("J")) {
super.visitInsn(DUP2_X1);
super.visitInsn(POP2);
super.visitInsn(DUP_X2);
} else {
super.visitInsn(SWAP);
super.visitInsn(DUP_X1);
}
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "fieldWritten",
"(Ljava/lang/Object;)V");
} else {
super.visitInsn(DUP2);
super.visitLdcInsn(new Integer(id));
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "objectFieldWritten",
"(Ljava/lang/Object;Ljava/lang/Object;I)V");
}
} else {
// trace static field write
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "staticFieldWritten", "()V");
}
// add original instruction
super.visitFieldInsn(opCode, className, fieldName, typeDesc);
} else {
super.visitFieldInsn(opCode, className, fieldName, typeDesc);
}
} else {
super.visitFieldInsn(opCode, className, fieldName, typeDesc);
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/InstrumentingClassFileTransformer.java 100644 0 0 6342 10763212217 31062 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import org.objectweb.asm.ClassAdapter;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.softevo.util.ObjectIdMapper;
import org.softevo.util.asm.FieldIdentifier;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
public class InstrumentingClassFileTransformer extends ClassAdapter implements Opcodes {
private MethodIdentifierMapGenerator identifierMapGenerator = null;
private String className = null;
private String superClassName = null;
private boolean isInterface = false;
private ObjectIdMapper fieldIdentifierMap;
public InstrumentingClassFileTransformer(ClassVisitor classVisitor, String className,
MethodIdentifierMapGenerator identifierMapGenerator, ObjectIdMapper fieldIdentifierMap) {
super(classVisitor);
this.identifierMapGenerator = identifierMapGenerator;
this.className = className;
this.fieldIdentifierMap = fieldIdentifierMap;
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
super.visit(version, access, name, signature, superName, interfaces);
this.superClassName = superName;
if ((access & ACC_INTERFACE) > 0) {
isInterface = true;
}
}
@Override
public MethodVisitor visitMethod(int access, String methodName, String desc, String signature, String[] exceptions) {
MethodVisitor writingMethodVisitor;
MethodStartEndTracingVisitor startEndVisitor;
ArrayTracingVisitor arrayTracingVisitor;
ObjectCreationTracingVisitor objectCreationVisitor;
FieldWriteTracingVisitor fieldWriteVisitor;
ConstructorPurityTracingVisitor constructorVisitor;
ParameterTracingVisitor parameterTracingVisitor;
int methodIdentifier;
if (!isInterface && ((access & ACC_ABSTRACT) == 0) && ((access & ACC_NATIVE) == 0)) {
methodIdentifier = identifierMapGenerator.getIdentifier(className, methodName, desc, access);
MethodIdentifier methodId = identifierMapGenerator.getMethodIdentifier(methodIdentifier);
writingMethodVisitor = super.visitMethod(access, methodName, desc, signature, exceptions);
startEndVisitor = new MethodStartEndTracingVisitor(writingMethodVisitor, access, className,methodName, desc,
methodIdentifier);
parameterTracingVisitor = new ParameterTracingVisitor(startEndVisitor, methodId, superClassName);
arrayTracingVisitor = new ArrayTracingVisitor(parameterTracingVisitor, access, desc);
objectCreationVisitor = new ObjectCreationTracingVisitor(arrayTracingVisitor);
fieldWriteVisitor = new FieldWriteTracingVisitor(objectCreationVisitor, methodName, className, superClassName, fieldIdentifierMap);
constructorVisitor = new ConstructorPurityTracingVisitor(fieldWriteVisitor, methodName, className, superClassName);
return constructorVisitor;
} else {
return super.visitMethod(access, methodName, desc, signature, exceptions);
}
}
public MethodIdentifierMapGenerator getIdentifierMapGenerator() {
return identifierMapGenerator;
}
public void setIdentifierMapGenerator(MethodIdentifierMapGenerator identifierMapGenerator) {
this.identifierMapGenerator = identifierMapGenerator;
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/MethodStartEndTracingVisitor.java 100644 0 0 5666 10564077543 30002 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.commons.LocalVariablesSorter;
public class MethodStartEndTracingVisitor extends LocalVariablesSorter implements Opcodes {
private Label methodStartLabel;
private Label methodEndLabel;
private Label exceptionHandlerStartLabel;
private int identifier;
private int access;
private String name;
public MethodStartEndTracingVisitor(MethodVisitor visitor, int access, String className,
String name, String desc, int identifier) {
super(access, desc, visitor);
this.identifier = identifier;
this.access = access;
this.name = name;
}
public void visitInsn(int opcode) {
if ((opcode == ARETURN) || (opcode == IRETURN) || (opcode == DRETURN) || (opcode == LRETURN) || (opcode == FRETURN)
|| (opcode == RETURN)) {
super.visitLdcInsn(new Integer(identifier));
if (((access & ACC_STATIC) == 0) && !(name.equals(""))) {
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "dynamicMethodEnded", "(I)V");
} else {
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "staticMethodEnded", "(I)V");
}
}
super.visitInsn(opcode);
}
@Override
public void visitCode() {
super.visitCode();
methodStartLabel = new Label();
super.visitLabel(methodStartLabel);
/*
super.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
super.visitLdcInsn(className + "." + name + descriptor);
super.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
*/
super.visitLdcInsn(new Integer(identifier));
if (((access & ACC_STATIC) == 0) && !(name.equals(""))) {
super.visitVarInsn(ALOAD, 0);
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "dynamicMethodStarted",
"(ILjava/lang/Object;)V");
} else {
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "staticMethodStarted", "(I)V");
}
}
public void visitEnd() {
int exceptionVariableIndex = -1;
methodEndLabel = new Label();
exceptionHandlerStartLabel = new Label();
super.visitLabel(methodEndLabel);
super.visitLabel(exceptionHandlerStartLabel);
exceptionVariableIndex = newLocal(1);
super.visitVarInsn(ASTORE, exceptionVariableIndex);
super.visitLdcInsn(new Integer(identifier));
if (((access & ACC_STATIC) == 0) && !(name.equals(""))) {
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "dynamicMethodEnded", "(I)V");
} else {
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "staticMethodEnded", "(I)V");
}
super.visitVarInsn(ALOAD, exceptionVariableIndex);
super.visitInsn(ATHROW);
super.visitTryCatchBlock(methodStartLabel, methodEndLabel, exceptionHandlerStartLabel, null);
super.visitEnd();
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/ObjectCreationTracingVisitor.java 100644 0 0 10237 10564077553 30017 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodAdapter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
public class ObjectCreationTracingVisitor extends MethodAdapter implements Opcodes {
/**
* The class is in this state if, during bytecode processing, we did not
* recently encounter a new instruction.
*/
public static final int ST_DEFAULT = 0;
/**
* Last visited instruction was a new instruction.
*/
public static final int ST_NEW = 1;
/**
* Last but one instruction was new, last instruction dup_x1.
*/
public static final int ST_DUPX1 = 2;
/**
* Current state of the visitor.
*/
private int state = ST_DEFAULT;
protected int newInstructionCounter = 0;
public ObjectCreationTracingVisitor(MethodVisitor visitor) {
super(visitor);
}
@Override
public void visitFieldInsn(int arg0, String arg1, String arg2, String arg3) {
handleStateReset();
super.visitFieldInsn(arg0, arg1, arg2, arg3);
}
@Override
public void visitIincInsn(int arg0, int arg1) {
handleStateReset();
super.visitIincInsn(arg0, arg1);
}
@Override
public void visitInsn(int opCode) {
if (state == ST_NEW) {
if (opCode == DUP_X1) {
state = ST_DUPX1;
} else {
handleStateReset();
super.visitInsn(opCode);
}
} else if (state == ST_DUPX1) {
if (opCode == SWAP) {
super.visitInsn(DUP_X1);
super.visitInsn(DUP_X1);
super.visitInsn(SWAP);
state = ST_DEFAULT;
} else {
handleStateReset();
super.visitInsn(opCode);
}
} else {
// default case!
super.visitInsn(opCode);
}
}
@Override
public void visitIntInsn(int arg0, int arg1) {
handleStateReset();
super.visitIntInsn(arg0, arg1);
}
@Override
public void visitJumpInsn(int arg0, Label arg1) {
handleStateReset();
super.visitJumpInsn(arg0, arg1);
}
@Override
public void visitLdcInsn(Object arg0) {
handleStateReset();
super.visitLdcInsn(arg0);
}
@Override
public void visitLookupSwitchInsn(Label arg0, int[] arg1, Label[] arg2) {
handleStateReset();
super.visitLookupSwitchInsn(arg0, arg1, arg2);
}
@Override
public void visitMethodInsn(int access, String className, String methodName, String desc) {
handleStateReset();
super.visitMethodInsn(access, className, methodName, desc);
if (methodName.equals("")) {
if (newInstructionCounter > 0) {
newInstructionCounter--;
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "objectCreated",
"(Ljava/lang/Object;)V");
}
}
}
@Override
public void visitMultiANewArrayInsn(String arg0, int arg1) {
handleStateReset();
super.visitMultiANewArrayInsn(arg0, arg1);
}
@Override
public void visitTableSwitchInsn(int arg0, int arg1, Label arg2, Label[] arg3) {
handleStateReset();
super.visitTableSwitchInsn(arg0, arg1, arg2, arg3);
}
@Override
public void visitTypeInsn(int opCode, String typeDesc) {
if (opCode == NEW) {
newInstructionCounter++;
handleStateReset();
state = ST_NEW;
} else {
handleStateReset();
}
super.visitTypeInsn(opCode, typeDesc);
}
@Override
public void visitVarInsn(int arg0, int arg1) {
handleStateReset();
super.visitVarInsn(arg0, arg1);
}
protected void handleStateReset() {
if (state == ST_NEW) {
super.visitInsn(DUP);
} else if (state == ST_DUPX1) {
super.visitInsn(DUP);
super.visitInsn(DUP_X1);
}
state = ST_DEFAULT;
}
protected void superVisitMethodInsn(int access, String className, String methodName, String desc) {
super.visitMethodInsn(access, className, methodName, desc);
}
/*
* @Override public void visitLabel(Label label) { System.out.println("visit
* label called"); if (labels.getDupLabels().contains(label)) {
* System.out.println("dup"); super.visitInsn(DUP); } else if
* (labels.getDupX1Labels().contains(label)) { System.out.println("dup_x1");
* super.visitInsn(DUP_X1); } else if
* (labels.getConstructorLabels().contains(label)) {
* System.out.println("constructor");
* super.visitMethodInsn(INVOKESTATIC,OnTheFlyInstrumenter.TRACECLASSNAME,
* "objectCreated", "(Ljava/lang/Object;)V"); } else {
* super.visitLabel(label); } }
*/
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/OnTheFlyInstrumenter.java 100644 0 0 16340 10763210234 26327 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.runtime;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.lang.jdynpur.Tracer;
import java.security.ProtectionDomain;
import java.util.Vector;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.softevo.util.ObjectIdMapper;
import org.softevo.util.asm.FieldIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
public class OnTheFlyInstrumenter implements ClassFileTransformer {
private static OnTheFlyInstrumenter singletonInstance = null;
private ObjectIdMapper fieldIdentiferMap;
private MethodIdentifierMapGenerator identifierMapGenerator = null;
private String suffix = "";
private boolean isShuttingDown = false;
// private static final boolean useOnTheFlyCalculation = false;
public static String TRACECLASSNAME = "java/lang/jdynpur/Tracer";
public static OnTheFlyInstrumenter getInstance() {
return singletonInstance;
}
private OnTheFlyInstrumenter() {
identifierMapGenerator = new MethodIdentifierMapGenerator();
fieldIdentiferMap = new ObjectIdMapper();
readSuffix();
}
public static void premain(String agentArgs, Instrumentation inst) {
singletonInstance = new OnTheFlyInstrumenter();
Tracer.methodIdentifierMap = singletonInstance.identifierMapGenerator;
Tracer.fieldIdentfierMap = singletonInstance.fieldIdentiferMap;
// if (useOnTheFlyCalculation) {
// System.out.println("Initializing on the fly calculator");
// OnTheFlyAnalyser.init(singletonInstance.identifierMapGenerator);
// }
inst.addTransformer(getInstance());
// redefineClasses(inst);
}
public static void redefineClasses(Instrumentation inst) {
Class[] loadedClasses;
ClassDefinition classDefinition;
byte[] classBytes, transformedBytes;
Vector redefinitions;
/*System.out.println("Loaded classes:");
loadedClasses = inst.getAllLoadedClasses();
for (int counter = 0; counter < loadedClasses.length; counter++) {
System.out.println(loadedClasses[counter].getName());
}
System.out.println("End of loaded classes list. Exiting.");
System.exit(0);*/
loadedClasses = inst.getAllLoadedClasses();
redefinitions = new Vector();
for (int counter = 0; counter < loadedClasses.length; counter++) {
if (loadedClasses[counter].getName().startsWith("java.util")) {
classBytes = loadClass(loadedClasses[counter].getName());
transformedBytes = singletonInstance.transform(loadedClasses[counter].getName(), classBytes);
classDefinition = new ClassDefinition(loadedClasses[counter], transformedBytes);
redefinitions.add(classDefinition);
}
}
try {
System.out.println("Redefining classes");
System.out.println("Redefine supported " + inst.isRedefineClassesSupported());
inst.redefineClasses(redefinitions.toArray(new ClassDefinition[redefinitions.size()]));
System.out.println("Redefine finished successfully.");
} catch (Exception redefineException) {
System.out.println(redefineException);
redefineException.printStackTrace();
}
}
private static byte[] loadClass(String className) {
InputStream inputStream;
ByteArrayOutputStream byteBuffer;
try {
inputStream = OnTheFlyInstrumenter.class.getClassLoader().getResourceAsStream(className.replace('.', '/').concat(".class"));
byteBuffer = new ByteArrayOutputStream();
while (inputStream.available() > 0) {
byteBuffer.write(inputStream.read());
}
return byteBuffer.toByteArray();
} catch (Exception loadException) {
System.out.println(loadException);
loadException.printStackTrace(System.out);
}
return null;
}
private byte[] transform(String className, byte[] classBytes ) {
ClassReader classReader;
ClassWriter classWriter;
InstrumentingClassFileTransformer transformer;
byte[] bytes;
try {
classReader = new ClassReader(classBytes);
classWriter = new ClassWriter(true);
transformer = new InstrumentingClassFileTransformer(classWriter, className, identifierMapGenerator, fieldIdentiferMap);
classReader.accept(transformer, false);
bytes = classWriter.toByteArray();
/*if (className.equals("org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding") || className.equals("sun/awt/X11/XToolkit")) {
classReader = new ClassReader(bytes);
System.out.println(className);
classReader.accept(new TraceClassVisitor(new PrintWriter(System.out)), false);
System.out.println("Uninstrumented:");
classReader = new ClassReader(classBytes);
classReader.accept(new TraceClassVisitor(new PrintWriter(System.out)), false);
}*/
// System.out.println("Successfully instrumented " + className);
return bytes;
} catch (Throwable instrumentationError) {
System.out.println("An error occured instrumenting class " + className);
instrumentationError.printStackTrace();
}
return classBytes;
}
public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classBytes) throws IllegalClassFormatException {
if (!isForbiddenClass(className) && !isShuttingDown) {
// System.out.println("Transforming class " + className);
return transform(className, classBytes);
} else {
// System.out.println("Skipping class " + className);
return classBytes;
}
}
private static boolean isForbiddenClass(String className) {
// if (useOnTheFlyCalculation) {
// return isOnTheFlyCalculationForbiddenClass(className);
// } else {
if (className != null) {
return className.startsWith("java/lang/") || className.startsWith("sun/awt/X11") ||
className.startsWith("org/softevo") ||
// className.startsWith("java/util/TreeMap") || className.startsWith("java/util/logging") ||
className.startsWith("java/io");
} else {
return true;
}
// }
}
/*private static boolean isOnTheFlyCalculationForbiddenClass(String className) {
if (className != null) {
return className.startsWith("java/lang/") || className.startsWith("sun/awt/X11") ||
className.startsWith("org/softevo") || className.startsWith("java/security") ||
className.startsWith("java/io") || className.startsWith("java/util/AbstractList$ListItr") ||
className.startsWith("java/util/Arrays") || className.startsWith("java/util/concurrent") ||
className.startsWith("java/util/HashMap") || className.startsWith("java/util/LinkedHashMap") ||
className.startsWith("java/util/ListIterator") || className.startsWith("java/util/Properties") ||
className.startsWith("java/util/regex/") || className.startsWith("sun/security") ||
className.startsWith("sun/misc/FloatingDecimal") || className.startsWith("sun/reflect");
} else {
return true;
}
}*/
private void readSuffix() {
File[] children;
String suffixFileName;
children = new File("./").listFiles();
for (int counter = 0; counter < children.length; counter++) {
if (children[counter].getName().startsWith("suffix_")) {
suffixFileName = children[counter].getName();
suffix = suffixFileName.substring(7, suffixFileName.length());
}
}
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/runtime/ParameterTracingVisitor.java 100644 0 0 4715 10761746152 27025 0 ustar 0 0 package org.softevo.jdynpur.runtime;
import java.util.Collections;
import java.util.HashMap;
import java.util.Vector;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.MethodAdapter;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.softevo.util.asm.MethodIdentifier;
public class ParameterTracingVisitor extends MethodAdapter implements Opcodes {
private MethodIdentifier methodIdentifier;
private HashMap objectParameterIndices = null;
private boolean isConstructor = false;
private String superClassName;
public ParameterTracingVisitor(MethodVisitor visitor, MethodIdentifier methodIdentifier, String superClassName) {
super(visitor);
this.methodIdentifier = methodIdentifier;
this.superClassName = superClassName;
objectParameterIndices = getObjectParameterIndices(methodIdentifier);
isConstructor = methodIdentifier.getMethodName().equals("");
}
protected HashMap getObjectParameterIndices(MethodIdentifier methodIdentifier) {
HashMap result;
Type[] argumentTypes;
int counter;
if ((ACC_STATIC & methodIdentifier.getAccess()) > 0) {
counter = 0;
} else {
counter = 1;
}
argumentTypes = Type.getArgumentTypes(methodIdentifier.getSignature());
result = new HashMap(argumentTypes.length);
int parameterCounter = 0;
for (Type type : argumentTypes) {
if (type.getSort() == Type.OBJECT) {
result.put(parameterCounter, counter);
} else if (type.getSort() == Type.LONG || type.getSort() == Type.DOUBLE) {
counter++;
}
counter++;
parameterCounter++;
}
return result;
}
public void visitMethodInsn(int opCode, String owner, String name, String desc) {
if (isConstructor && (opCode == INVOKESPECIAL) && name.equals("")
&& (owner.equals(methodIdentifier.getClassName()) || owner.equals(superClassName))) {
super.visitMethodInsn(opCode, owner, name, desc);
Vector parameterIndices = new Vector(objectParameterIndices.keySet());
Collections.sort(parameterIndices);
for (Integer index : parameterIndices) {
super.visitLdcInsn(index);
super.visitVarInsn(ALOAD, objectParameterIndices.get(index));
super.visitMethodInsn(INVOKESTATIC, OnTheFlyInstrumenter.TRACECLASSNAME, "parameterPassed",
"(ILjava/lang/Object;)V");
}
} else {
super.visitMethodInsn(opCode, owner, name, desc);
}
}
@Override
public void visitCode() {
super.visitCode();
}
}
jdynpur-2.0-beta-1/src/main/java/org/softevo/jdynpur/util/SibrelibDynpurConverter.java 100644 0 0 2415 10564101373 26316 0 ustar 0 0 package org.softevo.jdynpur.util;
import java.io.*;
import java.util.StringTokenizer;
import java.util.Vector;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
public class SibrelibDynpurConverter {
public static void main(String[] args) throws Exception {
BufferedReader reader;
StringTokenizer splitter;
ObjectReaderWriter> writer;
String currentLine, className, methodName, signature;
MethodIdentifier identifier;
Vector result;
System.out.println("Warning: Access modifier in converted list is invalid.");
result = new Vector();
writer = new ObjectReaderWriter>();
reader = new BufferedReader(new InputStreamReader(new FileInputStream(args[0])));
do {
currentLine = reader.readLine();
if (currentLine != null) {
splitter = new StringTokenizer(currentLine, "#");
className = splitter.nextToken().replace('.', '/');
methodName = splitter.nextToken().replace('.', '/');
signature = splitter.nextToken().replace('.', '/');
identifier = new MethodIdentifier(className, methodName, signature, 0);
result.add(identifier);
}
} while (currentLine != null);
writer.write(result, new File(args[1]));
}
}
jdynpur-2.0-beta-1/src/site/apt/download.apt 100644 0 0 1146 10763302236 16104 0 ustar 0 0 ---
Downloads
---
---
---
Downloads
This page lists available builds of the dynamic purity analysis tool. To find out
how to use the tool, take a look at the {{{howto.html}how-to}}.
*---*---*--------------*
|Build |File |Notes|
*---*---*--------------*
|2.0-beta-1 | {{{builds/jdynpur-2.0-beta-1-bin.tar.gz}Binary}}| This build adds a parameter mutability analysis.|
| | {{{builds/jdynpur-2.0-beta-1-src.tar.gz}Source}}| |
*---*---*--------------*
|1.0 | {{{builds/jdynpur-1.0-bin.tar.gz}Binary}}| Initial release.|
| | {{{builds/jdynpur-1.0-src.tar.gz}Source}}| |
*---*---*--------------*
jdynpur-2.0-beta-1/src/site/apt/reporting.apt 100644 0 0 2012 10763261133 16277 0 ustar 0 0 ---
Problem Reporting
---
---
Problem Reporting
We have thoroughly tested our analysis tool. However, in order to trace all possible modifications,
our tool also needs to instrument the Java Libraries, which is a tough task. For some API-classes,
instrumentation fails and the program crashes with an error message like this:
+---
Exception in thread "Thread-17" java.lang.VerifyError: (class: com/sun/crypto/provider/SunJCE_al,
method: signature: (Lcom/sun/crypto/provider/SunJCE;)V) Expecting to find object/array on stack
at com.sun.crypto.provider.SunJCE.(DashoA12275)
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
...
+---
If you get a similar error message for your run, then don't panick. Mail the stack trace you got to {{dallmeier@st.cs.uni-sb.de}}.
jdynpur-2.0-beta-1/src/site/resources/builds/jdynpur-1.0-bin.tar.gz 100644 0 0 1242745 10564561222 22261 0 ustar 0 0 ԻuP\ͺ>!.!%ww'U}nZ=ݽz~5f^n,l`VS;;{f[c{˿Y! /\_Lv伤}uO#W=ydӅ-@21ޙdFow:*KW什D(rI;e߹J]oV}v4;F w d &~w |ַ:+#\ sLdY( 5a
ΣRК jBN 'HTSg.¸ -WKL[5ӯ5~&q?(]LRo%ѥ#!Đ2lK ZUtѥekLQ^~RrTA^z qy"=,O:4b#H@8Qw ƞ $eQB@|sd4LUC߭| cteA; pQV
ϕ *Vn Oԙ֙nAg#<&$ #! /N'QMEJY
g"洃E=W:'~$Z!2j*,MNmHuGh1QJ/t3 2WsSO;v/4N~8]l a.Vi/C%iv:mlWޗ=9N?礢r~:B6 οq ֫/A0s_2|t(yYhRX^UWNO5)_s\;?PxH/`hl S[ct G% ^^TrToHIPH01 ]^Y
,_ %*K(4 &L*r+jE.\K/zOm ]o
x8}v!Fka6˺fZ܈ISoOX|²i:\y,gó_맢ur-t $I\F@U*s)5 b- Մ1Гn1P4K)h& iZ5·kg^jgr% vR;FCeEGG a -*-u%X @8GS@}p8Pr q k} JAz~(m P?R;AjBV[ɌME *9{ (]#5ͼ-yF~Vp=.f2Yߠ[.W+>.h&)Z^wiDofz(>_ ,Lxiz8af9h̼RvO@+cV=ZXB]#"loZ-^{ڏr;;2HhhamEY*EA.s ub)G\9Z,%m xwm$m 'm[ xvÖy<>({(r>ąlʥa\ /||n S?+v dRb7o|pPur- ?m H JnM%Ȇ&rO>3 9֬Zz飏)dֈhylB&C aa&Z4q;ڷĬ`:a )D|uE !ط ! d~Գt$8*0ޫݢ/EQ
$FׯU
Is%
=ģh%fwv~[3o{%b_"->7s Ǽ ;i=;#F]AK9 ؍SX z
qC *zv$x& 8#_!H0y _7vp%S^N=rY^d#?XLX(7 Ӈ9$\[@ӕ c|fIa2T}1Ң;3ůTز^5_Zk" OD:$$ns3%j4gs i6jmB k #~Wz
wɂcCj1ψ,YwĩlcOe2D|$N+/PFÐӗd7FDtPK~}g~IJ n3;´gZ4V?'%me8uӿNRݘ$o,-MZ&˸Ӫ?K1 ?Nr߅t5?~/87dS+:돫4GNhkXU6Ĵ}tV&ԧzDi/'d@É{5mDU s5.w5mTŨ+%k8_+Zʵae\9o8z^:kz'g7D[ m3I/7,<7"W#y3h&ί)-^eB-c.Ѳo aXPǕKT{aZ0cO&ant:G_+ذ @:P3ڸYp/',OrU5_p<$Vڨ[p,nEϡ1 ɟau'gS1 afIsL#g':V9w?lSZ2_:9x|I% u
kCȳ7m^'u7rqpYc]ȼNڵ B &xu3
ޙ W5^pc
ba3F#kZ%ϝmX-1eƚ6Xi8Ob<6I*A _Q)?s$6%FE;{xT 9A :璧
:&N;¥Fyb~)sQ(Ց +T@ a>aDxBBbBa@&1R9&Ra<Ġ n01oL(4(諞SNtm T7ϔ. u|W@2uB <
979Q
4FQdK7u:&4=b$~$z"W~qMbL= u@ *Z,7%[ (j[s.d( < $Q_> 2.f&# ϧ$G b(@b :Pֈ Ї.HŖcgXFImacDP6.
`2 IBPä&9cĠa0@ITa+-۰- n0?/9T ^KÕ/N/aSe)kPsYB GDBw2O{%k{Q#6N9\+Y " 5}+ xTYV >Q
z4mV ]H0PN ; 8m?Hʜc7JZ!$R壹I.jK(U@;[)Q:r cCn>JYb9I(i娫!@P%0_i.j4NJm ?RrPwtOK\%{ֻH;b4V٢Rn Z~Z|_._ Y)#TLO0b3 a((j
F6} c5 ˡ֬.C^hofSݗ}-k*
4zb18HH@ 0bAN2;dVkΉÌX4%!Kmr$2A@)ʃL7: VQTA@Y/Q,QT Y@y?05j>z yUQ>_ >/Yd{X>}oS*[yQu끿P`O{Iぱ`
|aItȝh\$s3qLɋcS IŇox)I2
_XGyDRp4&`f;WZ%^@s<6YI58Lښ{UsбUVS[eḋ͒0Xa4͏"̓gnY|H @ۨ8_
3kD
wO{eZѺ0`L"6XSPNoz6*S/N.kݓ4 ?}Q웬2zzn8Recu1WkFhߜ;Q?Gn%57Z6L 校g$=f]I{Jh q42G;|u@ |:R*#djg& F]F A8 %?HY{m Y{Ԧ'P?|1~VaуZgD@̯[ {,w_q1Aa-<1op,~O,D R1 N#V0C6ߑ"?nOg W~qYO`_ MS~Fx\¡OiWj
{,E_bN<:Xʾ
nv2"{na]y J=Q v_IL:=4b
M9#JOb.m4*J vuXuyƐ2_ 8> #1 Z= >C6 } { Ž
jk?v8
½a1'$%݃22݁SG Z*~r%3H3ױ +Е6H'jjRCk:ٺbϘ-/DįXȲ):DBId0O*uyr]wj7ՁĥFat .M#{f`Npj}nEu`*(|"330Jfr5&'6YfŲx=gb _Yּ CL9]g]|@ɟwX
$NȁakO_ T@ ;nfN+܉wߏGD,$ˮ>Th 7[lV.J6,= V~oX ]PW 6e sPL? Ix}w0P /BNDF[(War?-LCЇFtY4aܛ3PdO̘o5 '+mɘzm? =(= \X` ix
\! RQohۈ`B?zhd0 x$ƁE0>F@a2[z N.DiF WzPl}~CUe~Cm,WmպLn̾J PN墑Ç n' 9Fטy0_~SP~ceGQS=}^`-(JDTBbI D_US[iI$]6<*6r[T5d$1%$gzmsyÝk>%>@O<; ZfܕCw #ļ_ qrpe4v-C:sc1-܉So
Pj:"zdc6yAVLƪ7yi`g&:|j:yYaY~hr/e?yLkDN_jU *+rsG3 P7BL)<\KG~;t{?SfPW?ܯ꓿j 3/VLmʲUkR 5U?cXW_
3vv<g/30r,7DbH JiPc8ES_-v3ɭ2 M}$g4)3Uy4*ǿ#uSY㇑
~|ƻ?5Xp_;_PDK 2UvxO+URFvYrLiܻN=j3 `0 @c[lK_0:'ƥ0SnLh@|( >g]H $ ]RtvwJ{чZ&)?2ϰxhpY I݊J[/ X[db-VAs!༝|~{ K6k/0 i"#jFӍɰOd=>~&>`LX뾻6 ޏN3EҖ%y.+-cm=aFL^̀ئ* Z+
0O^spbWZ?&} g3F4wOfgFg%n\'"rxYp.9>z)UI2c ̱ D@9-s5)\m\ Y] \f$h
URVHVgi ᢙI^#ci['Y&B_0ŶúVMu #Q_| 6 D
ո1r_&
*IV4u_pվ} m
xcgSPV w -˥Mnr -+5N-S,, LSa|x'ܷ)ˮ`´xb}bGi8nNY2c?bh'O]h >ʨov"IrcNt KsL
P6t0}H}
? (2m# IR{1&vL^~N` r$&FxfXM^x|EH1&o%uS]@$~OŖ_EєERرK9hw`SM>(P7TN8ۢNX1DĂ?Lx0e7
vFIv3]^j>Nz>wT|~/iS9 wҎ?v.[XRO!!)'F e!pL^8==g+'KwYNeD@фa\n&nW25 ԜHӥ(4Cy}z
22?wnnۛ;i8:-]lSs\1ͱo ~ =l"˭t@$8
]Xzz{
R%ﾘ7G'#ZnZmBY(.ep~o^O?=(:~ +4 3jdzc5C 3 ;̣ =Qܢ'ٶ#oiF LnYF|VضG!FPEu6mqڐ縬S?Z\"'ٌOc? *Dgz`":kJ&Glߖׯ: ]:-/Y}61?1!ӔRyꃄ$Vf\(B%N.ˢ+J}[;T^u\d{. ڷR:VjmJpҕދ2r?k qS =߈2>h
TAuaUvn`%t-1uQ3fRte &3_,[RKk,^G;iFrj>ya[WYW}t 44{
V]X}現(Ϧ(QxQLL$>&xU Z%t(F:^ f :4e _S;d
26uW+V7T%ԑ^|1 ۛ3 gy0Tt_Epw_|HF͗{OtC l͚ؔ`٭BEGW6d~| Sqx#G4p1:r;d<4s| D&!Gu4H)DߔH`c+; ώQ?3&'4YEl3ƇP e:D@P{( 5&s @]2ƈrAӂdCĕQ_p 2ՙ-$R2?B58g}b:DF;#G/R"x&
Bh'!8CbkI~)1dKK4raN %dF
aq Cgt CO1vO)CtDbE&t ȏwM®3b5LL EHhJ:V4O.HR<rY*9 q]?/3|4G{ixHJ|,LE3k ay,] >.lPQ p bXqql؎h=AX0o9> '_~>9Mt ^ *8~L5J~> x$ٵ$w!aoCHh܃`=W\x,R4!һ *4.&{Boay7.$^h37Bh776+%͏?)okٸܨԡ EX@TT̳RO*EA'i3HjE HAv,,J]9a ynrxw5$ cP^N{*5XjU ewRB9e.AFLנ6l|%eiȘzl
G
CComr)Fy ChE =qϳ; YyiϧeXm0Ni
Xd 2PcЫ!1P=!i]ί@odfd;уqQ
VfUp±SSǞOJ*ul(ƇŧJZ6>ŵ1d2M^| Sm 喐djR~kUcT]Sc Woy654*fz,:u 2F% ˜<8x'O
Ҿn WNا|jʉusenKl(UI`ζ2Y'譋PS>/&؉
{evqp
. Qj+^8jӛl?;73~ֻlIy5ǽkl 6HI*E%3r^q~fը5vЦ؎]g| CB-XGq H [t δqzJ ƯÑ î_oqY
m+ 1o[1=o&>\ > @$[eRq3|h+QD_Nf?Y yyf T=6צ 0 i$x_ fB)|2 6~_rK^f**݀=geR(u1>L]bQkYR=rJ +PRhr7rl|lUl)Ѭ歍~QK8= !f\=h^[RxrpN3ÁğFADC
Jw*v}xtJzmY=qfurUز`0e~DT<; "NoKuH2l9Yŗf%X*.x{hي LVU#5v n",Pv 'e 7&
za*o%y@ 4[x>3q.vY*6!wfEvB3C3,gp8Hy>W֛S+Cl,O+1.7Dϊ ~__0( Zp<%~ gXƧr;ۥcmv;-s
_ *ʐO<=w:E|@ ERSrZ[5B#\vx ~p tV < vHVm~c A@AO5/"gg g$
W6_x6!
WX88]=("
V>8t~e=^p|f_
գ(F(םN;^3; a
BЋl'I8-gS6@nJ ;$T yN3 F#ы]ЁG-3=SqNpF3} p:tHB+yP]>1`lBfu ,{NP UÍjP #+dXlC0Z./ٿ ^mد축Kg|\ Knwgӿ;E1Eњe (?]PjZ/4,Qי}R6 d3՞=x~dVeua5N!z >Bؚ TED|jN S~ CHeLR9;!
S6)]:l>\,T
:KQ}bPTO 5'Q X>uU,iϫlNa_/h*DΠ c 74l~~:1 ]o8^hWd|\#מUA=8n<λȰW ƻcDUkw~ xHec|6c8߹֯M? ?Gn*.@fh0KYyBECR{ q4ѤV {ݬ l>&` 5+2?-^AHpM%ReapcD=}yV}`o{< J" ;* mvۋ]ȣ8wc:v,U<ӊ ƪsȊz$<̝
-MVr(SڃO\}I}V2o;w91u : ;)2^xE}[Qշ#>Xh v`t9~j=i':yᇺ1ip9=FdsH'`k+?qT`=⥟* pAL5Rv/
hEt䖼agbSߧF}Ocdj,/Y _meK.8ԭԓ\6iLw#YIrUY[^X~
ْwSŧ6t'iKpٛz ξ1HKm۶m۶mۻmۻm۶mnv{|ܙ?čȨ̊ʪ\SO[y s6 рvEKor` k b cRek|Ew ;0D`7s~G (ڙ~ p7d0c"{UKy-lNmUZZR6e
4\E3!eno\P"#}wG W π2r[_¹8~b{DTSEv@c'oYj5K9#ȝpU%~0$osDra,рwϽVaXcײ>_8Ӿޡ{r=L Cӵ%sSw4Zf= [TZI*AڋSڽY͑Pg*;ce_7"=k#/al ESX+?# e⹍%^rQfeUڎ 2c1Uy)
mݨQC%!= p<|v- \[rd6LޕY
QWz:p4?H9\\P {W|؎ķ⾅ԲƼht#7qJ{Dzŋb8bR^&? ?Ց|iqu
V ߏ~*&Ox,ٔCc Z)OX:Qu Z)O8m@?DX B]6>9Iu<& P:=_ EEqag@$nTj~'mc,f{C|{ T<^ ӣtn=Ts4N#v}T*VwlGy,.R֬ٔ.[&'b iA;/`OUzO fn0QjH
˂l =beG5J-Xsh1 |JگHކQ.kۂ ʾv@٨%i
v:j&; +C4tGHRKeD*FxIH U8wtZz#fu
tRc{ ѫO+w+'h
Y_Baۂc/.6hq-r'm!ځ Mmi7ՎsDLC|WNFm3h2Z(@ȸ+,yd}[侢cf?X#|6;#F
Xpvxn
ggmgbm a uB{x
Y U .ݵq?Hҳq ьW Q[.羥͖,ɠ]ݤO\
O^
$@ vv;J5k#bޮ|BS-?H_pH|$qމ6E.!O:jzb& fY~TyY*dc0k_Z,ͲoHYEk7զ%hcx<]cǺβyD:~:Oql/Uɲph 9EWe7,e@gUjvI J?0 * ]/XL1;"b ۴&I]Q\nא |MT?fXL D8&
ԣ9_@W !w_F ɛM~IkOO|(ߏij 0 yF7+SkFfZ+ζ`|MndˣRM"f*l>>fY֊6av>6az>Dz (LypYBB,Dم
>CFֽ`#8Ѫ,0 6R,|0Cw6PĵƔvb Erк@ GrLn\p;%O ݤp;[ʥpE_d;'I۴9L )5$?UH/ )7{ (xhd
蠞<"Qic)K:GKB3ѭẢzy*C~
nFe٨)V
Ru"3Km/.'H_j"Y5No0{A /?
Yƺ&
.9:IhӀ+fqiɯت%#jץA6bӨwn?8NM M
"c^;XBC\r'6B (ebm\k87 bM D1 -@j
F6H[VB1vRg^gk$(b@ oҜꃄ~i9 '4 O8+x3Ds&)k>E\< x[Wz4цS{Ћ&˯k] {Eg3k@ yM$1G4z
6uw)|cK[(Y{uk|Z / aI}3
m./x ÿO qR m1VU 9taM;E|r'MJhasQP
Bg lF< *؞Ɵ=(ayJB6泉 NQB Ny7TYQ Lrj.+w#"QٕbjE&+~&E:xX*3#u#Bnq t"QU>@Y+p1l O&nS6k8E 66]VzcFI &W,JTtJ)>S84؟ FiCFP-z0mb
ĹFM'12/: mO h4fa- Ӹ )W{ yjK5c"2G242 %-#!5$n4`Qrɢb77d_"䌒ʓ^j.$412
y]Dtj62iR'ɢiz2 EjMiz2ʓ&=TyT =&|d7U\*Ő [
.m\nNKI̢U :*.pFL lBz~pݥtȝ|fY~1 ^T:߃
=( /!5@oEOT%1(4-OR$,? 8HFH6 *EjܱF0r ' !w M
Z{J< G01J!g
nIic0WN> ITU֧RU 3&/vRU_8%7[w]'a<7W
>&uԌ
|͋ak8Q╄,Q&{ͯB|
n%EB 6w5J[
n4+oBOky8
s|8Ty50݊3R u N@ !y~Z|`c ͵H"oF/Փ~~C ֣`E* yY` jdCIEgP
P,^dH C5R
R
L$E
\hP&{uݦ
7'B7R5E {b [3Q!CچzPiUPpqpPdd"ӿ.5 xA&Fq,PWN!-5de˨8K(Paw6p]I+wqD{We(LbJ({C>gAs^9&Vi,?SeIҖpg殓`e颱V睈 q~W`$`칂PFh36VO.eC-V9ΖFRp_gPF刧&^TOF4j>*CY-iC I
g
3Jv OS^O# 0. Uǂ#xd.>* N pJhJ\;=&
8JD^FO<IGSpd^Hh'2Z(ζ.wD` Y?cSm6IBnLo`ro/ro3]`YoC)>:0@+Zv+4/& 4m0n B Et_^$g i )q cKˎ
@@ Sx,jeW߀q#43 ӈ6ɀ_hl|~ 1Pmp(Y5t s) 2^G kb::ݡdaǡʎj۳`Io#H<#ׅb 1XDSx\ιd9"xnWH]L8?Q7}N[1/ ֮O\xIx/W~eS/T++\Ojo5Y`NC-'<~s|A]6gϣ>ӌZ2}Jۏ-r*ShgHJ/NfM;HVp!.k?;0wŦԻWnϲy\=z&`g0Q^ -*TճϺSu}}N=]M垊 )=QYCk8JIh\\ަзAFuR1Ȗ# aθ6?zp/8WǬJO 4CX gm<3
)[Kɾ)
Kr< C0%0Z $9e`o-8v$fMOe"e
a
_lm&D3$dC=R̹YP9B dRM?I![
f=MlԆd :3+]jR$]E4]=(SqGH|y`l!@Tfo>yc+&%/'vtה6 YsZ: /|: #H5+sRCuCa")sȝ16O hֈk=b(#E>;L11:RQ7S6Vt
I) tz@/cchRlȗ'e ֥\E ɏGH~_ 3|"#s++[eɁƩ P 4)jZW + }:
M*
&
j!`|
0\X= Zd ed7ɘap/mR4d _j5D*
7ߌc ? ݘ,pԳnza9 OcL!)"2a:ЫFuDYny><7Zdl'cU;9J+Q&$ta7^l^]MVy|Ԗ4XuNB∶\&AYRbM]c nZ Q1wZ)diWGPN $BzV*^E2Oc W2yYpۇcO|q$ f3< !!իx%pm|vEgtJ(wxo@nx Gz& X!֤$@2DQfbKϓr}Z:C:gc@{AgC.G17GcS:>V-(e'q(YY6U^G+DL?.h 蘏uG =m)vP䈩6s'
.g7/;/iekxj3Сn^(MU,${J 8cQ'fvJT /o|ҦX#MdBo*T j6}1-aA߀u@:Xm #hmqNAf[t (G$P}F8 %j
Y~@l0驃Xt$&i3/Lsa>8!oKVFO9 3Dy-&ǶȫT vٕe2imH.>[#B0'Sq!oi=lNzm]f}la1ϛX8cN)7~VR=aAD74=QVyQ "`GL} M}9ϑ'T
B*
TK 1tr+ 4N!f~ Sd,ؽ Z!ViPӖ.mLiZ$. Vmja! m+0yr*o -hQNf/퇏۠<2U^3'9~.G_H18S)X1Ohfܹ`13 %qdJdFp"
uE\5
rLaSBT9tG.c㣆 6
I
nUyMspr`>J#X !䷅]Ӊun[!-n'NZxaDLHoGxP(;m @`
uUZ 3>/>ዖoE7CN )4NfL`H=HwL(JuBպA IZ%4ei,:4 U\8wpqL%hTG±Tqy6Ǐ1n͟7do y\ <=,az#{Pv ;$y3,VK*$CvX}e5֖a
_U.|f{V#wD ^npSԝй"/j㝫
Պhvi lHUOH64"`neg2[xe/] :9o=]}XUTmMR=֔pT'KUj~C
_
N]hV]|]hd-_>Q.ͽ%$K AZyw_Py\M<ЭwVnͥ^ 0@\imA:.[X Vp'ol@F XWb9y
åX@zsPQ 35!g-Kk!^3~/G0'X?
8&b*7-@Y
/U(x4W9C#BM"'oi2sP3ￕBĚDBp x v"KWXY/VV⟨.*!A0ӳBr;rxb"-]9I
g32,'$,@4 jlf.
Btw=W Oꥸח:b >VSVAyBCHhݹ-hIg!F ѡՙd,ily2|IcxԽEda#jr fb[; R) ?[QY{(C]d Z#$r Q+֥^A[
چrS_0̊j2Ҵ 9c>oicYom;Ř3Fk #@;L5@Z5