adabu2-pachika-0.5/pom.xml 100644 0 0 7135 11227606707 12574 0 ustar 0 0
de.unisb.cs.st
adabu2
0.5
4.0.0
adabu2-pachika
Adabu2 Pachika
jar
org.apache.commons
commons-exec
1.0.0-SNAPSHOT
asm
asm-tree
3.1
asm
asm
3.1
de.unisb.cs.st
adabu2-plural
de.unisb.cs.st
adabu2-hoare
net.sf.jung
jung-graph-impl
2.0
net.sf.jung
jung-io
2.0
net.sourceforge.collections
collections-generic
4.01
net.sf.jung
jung-api
2.0
net.sf.jung
jung-algorithms
2.0
org.softevo
util
0.3
org.codehaus.groovy
groovy
1.6.0
org.apache.maven.plugins
maven-jar-plugin
de.unisb.cs.st.adabu2.pachika.instrument.Instrumenter
True
maven-assembly-plugin
src/main/assembly/bin.xml
src/main/assembly/src.xml
target/assembly
adabu2-pachika-0.5/src/ 40755 0 0 0 11177767660 11755 5 ustar 0 0 adabu2-pachika-0.5/src/main/ 40755 0 0 0 11177767660 12701 5 ustar 0 0 adabu2-pachika-0.5/src/main/assembly/ 40755 0 0 0 11204444571 14500 5 ustar 0 0 adabu2-pachika-0.5/src/main/bin/ 40755 0 0 0 11231003763 13423 5 ustar 0 0 adabu2-pachika-0.5/src/main/config/ 40755 0 0 0 11177767660 14146 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/ 40755 0 0 0 11177767660 13622 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/ 40755 0 0 0 11177767660 14212 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/ 40755 0 0 0 11177767660 15332 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/ 40755 0 0 0 11177767660 15737 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/ 40755 0 0 0 11177767660 16365 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/ 40755 0 0 0 11177767660 17523 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/ 40755 0 0 0 11177767660 21123 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/ 40755 0 0 0 11177767660 21672 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/ 40755 0 0 0 11177767660 23333 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/miner/ 40755 0 0 0 11177767660 22235 5 ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/util/ 40755 0 0 0 11177767660 22100 5 ustar 0 0 adabu2-pachika-0.5/src/main/resources/ 40755 0 0 0 11177776517 14714 5 ustar 0 0 adabu2-pachika-0.5/src/site/ 40755 0 0 0 11227610063 12675 5 ustar 0 0 adabu2-pachika-0.5/src/site/apt/ 40755 0 0 0 11177767660 13505 5 ustar 0 0 adabu2-pachika-0.5/src/site/resources/ 40755 0 0 0 11177767660 14733 5 ustar 0 0 adabu2-pachika-0.5/src/site/resources/images/ 40755 0 0 0 11177767660 16200 5 ustar 0 0 adabu2-pachika-0.5/src/test/ 40755 0 0 0 11177767660 12734 5 ustar 0 0 adabu2-pachika-0.5/src/test/java/ 40755 0 0 0 11177767660 13655 5 ustar 0 0 adabu2-pachika-0.5/src/test/resources/ 40755 0 0 0 11177767660 14746 5 ustar 0 0 adabu2-pachika-0.5/src/main/assembly/bin.xml 100644 0 0 1725 11177775677 16123 0 ustar 0 0
bin
tar.gz
zip
src/main/bin
bin
minemodels.sh
minevisibleobjects.sh
runpachika.sh
unix
0755
README*
LICENSE*
NOTICE*
lib
adabu2-pachika-0.5/src/main/assembly/src.xml 100644 0 0 1033 11204444571 16103 0 ustar 0 0
src
tar.gz
zip
README*
LICENSE*
NOTICE*
pom.xml
src
adabu2-pachika-0.5/src/main/bin/minemodels.sh 100644 0 0 1201 11231003727 16202 0 ustar 0 0 #!/bin/bash
# Installation directory
INSTALL=
# Optional arguments for the virtual machine (like -Xmx )
JAVA_OPTS=
#========================== No need to edit anything from here =========================
# Version of program
VERSION=0.4
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 -cp $CLASSPATH $JAVA_OPTS de.unisb.cs.st.adabu2.pachika.cli.HeapPathDeepModelMiner "$@"
adabu2-pachika-0.5/src/main/bin/minevisibleobjects.sh 100644 0 0 1203 11231003740 17723 0 ustar 0 0 #!/bin/bash
# Installation directory
INSTALL=
# Optional arguments for the virtual machine (like -Xmx )
JAVA_OPTS=
#========================== No need to edit anything from here =========================
# Version of program
VERSION=0.4
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 -cp $CLASSPATH $JAVA_OPTS de.unisb.cs.st.adabu2.pachika.cli.SimpleUsedObjectSetMiner "$@"
adabu2-pachika-0.5/src/main/bin/runpachika.sh 100644 0 0 1162 11231003763 16201 0 ustar 0 0 #!/bin/bash
# Installation directory
INSTALL=
# Optional arguments for the virtual machine (like -Xmx )
JAVA_OPTS=
#========================== No need to edit anything from here =========================
# Version of program
VERSION=0.4
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 -cp $CLASSPATH $JAVA_OPTS de.unisb.cs.st.adabu2.pachika.cli.Pachika "$@"
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/AllInterestingModelsMiner.java 100644 0 0 16762 11177767660 27751 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.pachika.miner.TypeSetMiner;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
public class AllInterestingModelsMiner {
private static final Logger logger = Logger.getLogger(AllInterestingModelsMiner.class);
private int heapPathLength;
private Pattern typePattern;
private File resultDirectory;
private File traceFile;
private int maxNumberOfModelsPerRun = 3000;
public AllInterestingModelsMiner(File traceFile, File resultDirectory, Pattern typePattern, int heapPathLength) {
this.traceFile = traceFile;
this.resultDirectory = resultDirectory;
this.typePattern = typePattern;
this.heapPathLength = heapPathLength;
}
/**
* @param args
*/
public static void main(String[] args) {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
File resultDirectory = new File(cmdLine.getOptionValue("resultDirectory"));
Pattern typePattern = Pattern.compile(cmdLine.getOptionValue("typePattern"));
int heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
AllInterestingModelsMiner miner = new AllInterestingModelsMiner(traceFile, resultDirectory, typePattern, heapPathLength);
miner.createModels();
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
} catch (Exception exception) {
logger.fatal("An exception occured.", exception);
}
}
private boolean isAcceptedType(String className ) {
Matcher matcher = typePattern.matcher(className);
return matcher.matches();
}
private List mineModelsForTypes(Map> types) throws IOException {
HashSet objectIds = new HashSet();
for (String className : types.keySet()) {
objectIds.addAll(types.get(className));
}
ObjectSetTransitiveModelMiner miner = new ObjectSetTransitiveModelMiner(traceFile, heapPathLength, objectIds);
miner.readTrace();
return miner.getModels();
}
private void createModels() throws IOException {
logger.info("Mining type set map.");
TypeSetMiner miner = new TypeSetMiner(traceFile);
miner.readTrace();
Map> typeMap = miner.getTypeSet();
Map> typesForCurrentRun = new HashMap>();
int numberOfModelsInCurrentRun = 0;
for (String className : typeMap.keySet()) {
if (isAcceptedType(className)) {
Set objectIds = typeMap.get(className);
List shuffledObjectIds = new Vector(objectIds);
Collections.shuffle(shuffledObjectIds, new Random(12348L));
if (shuffledObjectIds.size() > 500) {
shuffledObjectIds = shuffledObjectIds.subList(0, 500);
}
typesForCurrentRun.put(className, new HashSet(shuffledObjectIds));
numberOfModelsInCurrentRun += objectIds.size();
if (numberOfModelsInCurrentRun >= maxNumberOfModelsPerRun) {
logger.info("Trying to mine models for " + numberOfModelsInCurrentRun + " objects and " + typesForCurrentRun.size() + " types.");
List models = mineModelsForTypes(typesForCurrentRun);
logger.info("Mined " + models.size() + " models.");
saveModels(models, typesForCurrentRun);
numberOfModelsInCurrentRun = 0;
typesForCurrentRun.clear();
}
}
}
if (numberOfModelsInCurrentRun > 0) {
logger.info("Trying to mine models for " + numberOfModelsInCurrentRun + " models and " + typesForCurrentRun.size() + " types.");
List models = mineModelsForTypes(typesForCurrentRun);
logger.info("Mined " + models.size() + " models.");
logger.info("Saving models to directory " + resultDirectory);
saveModels(models, typesForCurrentRun);
}
}
private void saveModels(List models, Map> types) throws IOException {
Map> typeToModelMap = new HashMap>();
for (TransitiveObjectModel model: models) {
for (String className : types.keySet()) {
Set objectIds = types.get(className);
if (objectIds.contains(model.getObjectId())) {
List typeModels = typeToModelMap.get(className);
if (typeModels == null) {
typeModels = new Vector();
typeToModelMap.put(className, typeModels);
}
typeModels.add(model);
}
}
}
ObjectReaderWriter> writer = new ObjectReaderWriter>();
for (String className : typeToModelMap.keySet()) {
List typeModels = typeToModelMap.get(className);
Set modelSet = new HashSet();
modelSet.addAll(typeModels);
File resultFile = new File(resultDirectory + "/" + className.replace('/', '.') + ".ser");
if (resultFile.exists()) {
Set modelsRead = writer.read(resultFile);
modelSet.addAll(modelsRead);
}
writer.write(modelSet, resultFile);
}
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File file = new File(commandLine.getOptionValue("traceFile"));
if (!file.exists()) {
logger.error("Trace file " + file + " does not exist.");
return false;
}
file = new File(commandLine.getOptionValue("resultDirectory"));
if (!file.exists()) {
System.out.println("Result directory " + file + " does not exist.");
return false;
}
String patternString = commandLine.getOptionValue("typePattern");
try {
Pattern.compile(patternString);
} catch (Exception compilationException) {
logger.error("Unable to compile pattern " + patternString);
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(AllInterestingModelsMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("regexp").hasArg().withDescription("Regular expression for interesting types").create("typePattern"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("trace file").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("directory").hasArg().withDescription("Directory where model files are stored").create("resultDirectory"));
options.addOption(OptionBuilder.isRequired().withArgName("int").hasArg().withDescription("Maximum length of heap paths").create("heapPathLength"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/HeapPathDeepModelMiner.java 100644 0 0 20544 11177775133 27115 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.collections.Util;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.pachika.miner.ObjectSetDeepTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
import de.unisb.cs.st.adabu2.transmodels.abstraction.MissingFieldsAdder;
import de.unisb.cs.st.adabu2.transmodels.abstraction.NeverChangingFieldsRemover;
import de.unisb.cs.st.adabu2.transmodels.abstraction.OldAdabuStateAbstracter;
public class HeapPathDeepModelMiner {
private static final Logger logger = Logger.getLogger(HeapPathDeepModelMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
File outputFile = new File(cmdLine.getOptionValue("outputFile"));
File voFile = new File(cmdLine.getOptionValue("voFile"));
ObjectReaderWriter>>> reader = new ObjectReaderWriter>>>();
HashMap>> usedObjects = reader.read(voFile);
HashSet objectIds = new HashSet();
for (MethodIdentifier methodIdentifier : usedObjects.keySet()) {
Vector> allInvocationsData = usedObjects.get(methodIdentifier);
for (HashMap invocationData: allInvocationsData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
objectIds.add(value.getObjectId());
}
}
}
int heapPathLength = 2;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using maximum heap path length of " + heapPathLength);
Pattern finalizerMethodPattern = null;
if (cmdLine.hasOption("finalizerMethodPattern")) {
finalizerMethodPattern = Pattern.compile(cmdLine.getOptionValue("finalizerMethodPattern"));
}
/*objectIds.clear();
objectIds.add(166716);
objectIds.add(36470);
logger.warn("Warning: Ignoring passed visible objects. I'll only mine a model for objects " + objectIds + ".");*/
ObjectSetDeepTransitiveModelMiner miner = new ObjectSetDeepTransitiveModelMiner(traceFile, heapPathLength, objectIds);
miner.setFinalizerMethodPattern(finalizerMethodPattern);
miner.readTrace();
List models = miner.getModels();
if (cmdLine.hasOption("abstract")) {
for (int i = 0; i < models.size(); i++) {
TransitiveObjectModel objectModel = models.get(i);
MissingFieldsAdder adder = new MissingFieldsAdder(objectModel);
objectModel = adder.createAbstractModel();
NeverChangingFieldsRemover remover = new NeverChangingFieldsRemover(objectModel);
objectModel = remover.createAbstractModel();
OldAdabuStateAbstracter abstracter = new OldAdabuStateAbstracter(objectModel);
objectModel = abstracter.createAbstractModel();
models.set(i, objectModel);
}
}
HashMap>> finalModels = new HashMap>>();
for (MethodIdentifier methodIdentifier : usedObjects.keySet()) {
Vector> allInvocationsData = usedObjects.get(methodIdentifier);
Vector> allModels = new Vector>();
finalModels.put(methodIdentifier, allModels);
for (HashMap invocationData: allInvocationsData) {
HashMap methodModels = new HashMap();
allModels.add(methodModels);
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (!value.isNullReference()) {
Integer objectId = value.getObjectId();
for (TransitiveObjectModel model : models) {
if (model.getObjectId().equals(objectId)) {
methodModels.put(path, model);
break;
}
}
}
}
}
}
ObjectReaderWriter>>> writer = new ObjectReaderWriter>>>();
writer.write(finalModels, outputFile);
if (cmdLine.hasOption("verbose")) {
for (TransitiveObjectModel model : models) {
HeapPath path = getPathForObject(usedObjects, model.getObjectId());
System.out.println("Model for type " + model.getClassName() + " at path " + path + ":");
System.out.println(model.toVerboseString());
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static HeapPath getPathForObject(HashMap>> objects, Integer objectId) {
for (MethodIdentifier identifier: objects.keySet()) {
Vector> allInvocationData = objects.get(identifier);
for (HashMap invocationData : allInvocationData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (value.getObjectId().equals(objectId)) {
return path;
}
}
}
}
return null;
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
File voFile = new File(commandLine.getOptionValue("voFile"));
if (!voFile.exists()) {
System.out.println("Invocation data file " + voFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(HeapPathDeepModelMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File that contains the program trace (e.g. trace.ser)").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with serialized data about visible objects.").create("voFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File model data is written to.").create("outputFile"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("The maximum number of steps on the heap the miner follows (aka. depth) ").create("heapPathLength"));
options.addOption(OptionBuilder.withArgName("regexp").hasArg().withDescription("Regular expression for finalizer methods (currently not supported)").create("finalizerMethodPattern"));
options.addOption(OptionBuilder.withDescription("Output models to System.out").create("verbose"));
options.addOption(OptionBuilder.withDescription("Create abstract versions of the models.").create("abstract"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/HeapPathModelMiner.java 100644 0 0 16177 11177767660 26334 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.collections.Util;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
import de.unisb.cs.st.adabu2.transmodels.abstraction.MissingFieldsAdder;
import de.unisb.cs.st.adabu2.transmodels.abstraction.NeverChangingFieldsRemover;
import de.unisb.cs.st.adabu2.transmodels.abstraction.OldAdabuStateAbstracter;
public class HeapPathModelMiner {
private static final Logger logger = Logger.getLogger(HeapPathModelMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
File outputFile = new File(cmdLine.getOptionValue("outputFile"));
File voFile = new File(cmdLine.getOptionValue("voFile"));
ObjectReaderWriter>>> reader = new ObjectReaderWriter>>>();
HashMap>> usedObjects = reader.read(voFile);
HashSet objectIds = new HashSet();
for (MethodIdentifier methodIdentifier : usedObjects.keySet()) {
Vector> allInvocationsData = usedObjects.get(methodIdentifier);
for (HashMap invocationData: allInvocationsData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
objectIds.add(value.getObjectId());
}
}
}
ObjectSetTransitiveModelMiner miner = new ObjectSetTransitiveModelMiner(traceFile, 2, objectIds);
miner.readTrace();
List models = miner.getModels();
if (cmdLine.hasOption("abstract")) {
for (int i = 0; i < models.size(); i++) {
TransitiveObjectModel objectModel = models.get(i);
MissingFieldsAdder adder = new MissingFieldsAdder(objectModel);
objectModel = adder.createAbstractModel();
NeverChangingFieldsRemover remover = new NeverChangingFieldsRemover(objectModel);
objectModel = remover.createAbstractModel();
OldAdabuStateAbstracter abstracter = new OldAdabuStateAbstracter(objectModel);
objectModel = abstracter.createAbstractModel();
models.set(i, objectModel);
}
}
HashMap>> finalModels = new HashMap>>();
for (MethodIdentifier methodIdentifier : usedObjects.keySet()) {
Vector> allInvocationsData = usedObjects.get(methodIdentifier);
Vector> allModels = new Vector>();
finalModels.put(methodIdentifier, allModels);
for (HashMap invocationData: allInvocationsData) {
HashMap methodModels = new HashMap();
allModels.add(methodModels);
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (!value.isNullReference()) {
Integer objectId = value.getObjectId();
for (TransitiveObjectModel model : models) {
if (model.getObjectId().equals(objectId)) {
methodModels.put(path, model);
break;
}
}
}
}
}
}
ObjectReaderWriter>>> writer = new ObjectReaderWriter>>>();
writer.write(finalModels, outputFile);
if (cmdLine.hasOption("verbose")) {
for (TransitiveObjectModel model : models) {
HeapPath path = getPathForObject(usedObjects, model.getObjectId());
System.out.println("Model for type " + model.getClassName() + " at path " + path + ":");
System.out.println(model.toVerboseString());
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static HeapPath getPathForObject(HashMap>> objects, Integer objectId) {
for (MethodIdentifier identifier: objects.keySet()) {
Vector> allInvocationData = objects.get(identifier);
for (HashMap invocationData : allInvocationData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (value.getObjectId().equals(objectId)) {
return path;
}
}
}
}
return null;
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
File voFile = new File(commandLine.getOptionValue("voFile"));
if (!voFile.exists()) {
System.out.println("Invocation data file " + voFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(HeapPathModelMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with trace information").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with invocation data").create("voFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File invocation data is written to").create("outputFile"));
options.addOption(OptionBuilder.withDescription("Verbose output").create("verbose"));
options.addOption(OptionBuilder.withDescription("Abstract model").create("abstract"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/ObjectSetDeepModelMiner.java 100644 0 0 13240 11177767660 27306 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.collections.Util;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.pachika.miner.ObjectSetDeepTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
import de.unisb.cs.st.adabu2.transmodels.abstraction.MissingFieldsAdder;
import de.unisb.cs.st.adabu2.transmodels.abstraction.NeverChangingFieldsRemover;
import de.unisb.cs.st.adabu2.transmodels.abstraction.OldAdabuStateAbstracter;
public class ObjectSetDeepModelMiner {
private static final Logger logger = Logger.getLogger(ObjectSetDeepModelMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
int heapPathLength = 2;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using maximum heap path length of " + heapPathLength);
Pattern finalizerMethodPattern = null;
if (cmdLine.hasOption("finalizerMethodPattern")) {
finalizerMethodPattern = Pattern.compile(cmdLine.getOptionValue("finalizerMethodPattern"));
}
HashSet objectIds = new HashSet();
String[] passedIds = cmdLine.getOptionValue("objectIds").split(",");
for (String id : passedIds) {
objectIds.add(Integer.parseInt(id));
}
logger.debug("Mining models for objects " + objectIds);
ObjectSetDeepTransitiveModelMiner miner = new ObjectSetDeepTransitiveModelMiner(traceFile, heapPathLength, objectIds);
miner.setFinalizerMethodPattern(finalizerMethodPattern);
miner.readTrace();
List models = miner.getModels();
if (cmdLine.hasOption("abstract")) {
for (int i = 0; i < models.size(); i++) {
TransitiveObjectModel objectModel = models.get(i);
MissingFieldsAdder adder = new MissingFieldsAdder(objectModel);
objectModel = adder.createAbstractModel();
NeverChangingFieldsRemover remover = new NeverChangingFieldsRemover(objectModel);
objectModel = remover.createAbstractModel();
OldAdabuStateAbstracter abstracter = new OldAdabuStateAbstracter(objectModel);
objectModel = abstracter.createAbstractModel();
models.set(i, objectModel);
}
}
if (cmdLine.hasOption("verbose")) {
for (TransitiveObjectModel model : models) {
System.out.println("Model for type " + model.getClassName());
System.out.println(model.toVerboseString());
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static HeapPath getPathForObject(HashMap>> objects, Integer objectId) {
for (MethodIdentifier identifier: objects.keySet()) {
Vector> allInvocationData = objects.get(identifier);
for (HashMap invocationData : allInvocationData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (value.getObjectId().equals(objectId)) {
return path;
}
}
}
}
return null;
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(ObjectSetDeepModelMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with trace information").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("Comma-separated list of object ids").create("objectIds"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("Maximum length of heap paths").create("heapPathLength"));
options.addOption(OptionBuilder.withArgName("regexp").hasArg().withDescription("Regular expression for finalizer methods").create("finalizerMethodPattern"));
options.addOption(OptionBuilder.withDescription("Verbose output").create("verbose"));
options.addOption(OptionBuilder.withDescription("Abstract model").create("abstract"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/ObjectSetModelMiner.java 100644 0 0 12346 11177767660 26516 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.collections.Util;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.pachika.miner.ObjectSetDeepTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
import de.unisb.cs.st.adabu2.transmodels.abstraction.MissingFieldsAdder;
import de.unisb.cs.st.adabu2.transmodels.abstraction.NeverChangingFieldsRemover;
import de.unisb.cs.st.adabu2.transmodels.abstraction.OldAdabuStateAbstracter;
public class ObjectSetModelMiner {
private static final Logger logger = Logger.getLogger(ObjectSetModelMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
int heapPathLength = 2;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using maximum heap path length of " + heapPathLength);
HashSet objectIds = new HashSet();
String[] passedIds = cmdLine.getOptionValue("objectIds").split(",");
for (String id : passedIds) {
objectIds.add(Integer.parseInt(id));
}
logger.debug("Mining models for objects " + objectIds);
ObjectSetTransitiveModelMiner miner = new ObjectSetTransitiveModelMiner(traceFile, heapPathLength, objectIds);
miner.readTrace();
List models = miner.getModels();
if (cmdLine.hasOption("abstract")) {
for (int i = 0; i < models.size(); i++) {
TransitiveObjectModel objectModel = models.get(i);
MissingFieldsAdder adder = new MissingFieldsAdder(objectModel);
objectModel = adder.createAbstractModel();
NeverChangingFieldsRemover remover = new NeverChangingFieldsRemover(objectModel);
objectModel = remover.createAbstractModel();
OldAdabuStateAbstracter abstracter = new OldAdabuStateAbstracter(objectModel);
objectModel = abstracter.createAbstractModel();
models.set(i, objectModel);
}
}
if (cmdLine.hasOption("verbose")) {
for (TransitiveObjectModel model : models) {
System.out.println("Model for type " + model.getClassName());
System.out.println(model.toVerboseString());
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static HeapPath getPathForObject(HashMap>> objects, Integer objectId) {
for (MethodIdentifier identifier: objects.keySet()) {
Vector> allInvocationData = objects.get(identifier);
for (HashMap invocationData : allInvocationData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (value.getObjectId().equals(objectId)) {
return path;
}
}
}
}
return null;
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(ObjectSetModelMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with trace information").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("Comma-separated list of object ids").create("objectIds"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("Maximum length of heap paths").create("heapPathLength"));
options.addOption(OptionBuilder.withDescription("Verbose output").create("verbose"));
options.addOption(OptionBuilder.withDescription("Abstract model").create("abstract"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/ObjectsWithProtocollSeeker.java 100644 0 0 22414 11177767660 30137 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.datastructures.Graph;
import org.softevo.util.datastructures.GraphEdge;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.AbstractHeapPathElement;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.eval.models.heappath.ThisAccess;
import de.unisb.cs.st.adabu2.pachika.util.Util;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocation;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
public class ObjectsWithProtocollSeeker {
private static final Logger logger = Logger.getLogger(ObjectsWithProtocollSeeker.class);
private File modelDirectory;
private File resultDirectory;
public ObjectsWithProtocollSeeker(File modelDirectory, File resultDirectory) {
this.modelDirectory = modelDirectory;
this.resultDirectory = resultDirectory;
}
/**
* @param args
*/
public static void main(String[] args) {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File modelDirectory = new File(cmdLine.getOptionValue("modelDirectory"));
File resultDirectory = null;
ObjectsWithProtocollSeeker seeker = new ObjectsWithProtocollSeeker(modelDirectory, resultDirectory);
seeker.processModels();
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
} catch (Exception exception) {
logger.fatal("An exception occured.", exception);
}
}
public void addModelFilesRecursively(File directory, List fileList) {
File[] files = directory.listFiles();
for (File file : files) {
if (file.isDirectory()) {
addModelFilesRecursively(file, fileList);
} else if (file.getName().endsWith(".ser")) {
fileList.add(file);
}
}
}
public void processModels() throws IOException {
ObjectReaderWriter> reader = new ObjectReaderWriter>();
List files = new Vector();
addModelFilesRecursively(modelDirectory, files);
Map>> violations = new HashMap>>();
for (File file : files) {
if (file.getName().endsWith(".ser") && file.getName().indexOf('$') == -1) {
String className = file.getName().substring(0, file.getName().length() - 4).replace('.', '/');
Map> typeViolations = new HashMap>();
violations.put(className, typeViolations);
logger.info("Reading models from file " + file);
Set serializedModels = reader.read(file);
logger.info("Mining " + serializedModels.size() + " models for type " + className);
List models = Util.simplifyModels(serializedModels);
for (TransitiveObjectModel model : models) {
if (model.getModel().getNumberOfNodes() > 2) {
TransitiveObjectState stateAfterConstructorCall = getStateAfterConstructorCall(model);
if (stateAfterConstructorCall != null) {
Graph graph = model.getModel();
Vector> nodes = graph.getNodes();
for (GraphNode node : nodes) {
TransitiveObjectState currentObjectState = node.getData();
if (!currentObjectState.equals(stateAfterConstructorCall) && !currentObjectState.equals(model.getStartingState())) {
Vector> edges = node.getOutgoingEdges();
for (GraphEdge graphEdge : edges) {
MethodInvocationSet methodInvocations = graphEdge.getData();
for (MethodInvocation methodInvocation : methodInvocations) {
Set fieldsRead = methodInvocation.getValuesRead();
Map valuesRead = getValuesRead(currentObjectState, fieldsRead);
Map callViolations = getAdditionalOrViolatedPreconditions(valuesRead, stateAfterConstructorCall);
if (callViolations.size() > 0) {
Map allCallViolations = typeViolations.get(methodInvocation.getIdentifier());
if (allCallViolations == null) {
allCallViolations = new HashMap();
typeViolations.put(methodInvocation.getIdentifier(), allCallViolations);
}
allCallViolations.putAll(callViolations);
}
}
}
}
}
} else {
logger.warn("Unable to determine state after constructor call in model for object " + model.getObjectId());
}
}
}
}
}
int numberOfTypesExamined = violations.size();
int numberOfTypesWithViolations = 0;
int numberOfTypesWithViolationsOtherThanGetter = 0;
for (String typeName : violations.keySet()) {
Map> typeViolations = violations.get(typeName);
if (typeViolations.size() > 0) {
numberOfTypesWithViolations++;
}
boolean isOtherThanGetter = false;
for (MethodIdentifier identifier : typeViolations.keySet()) {
String methodName = identifier.getMethodName();
if (!methodName.startsWith("get") && !methodName.startsWith("is")) {
isOtherThanGetter = true;
}
}
if (isOtherThanGetter) {
numberOfTypesWithViolationsOtherThanGetter++;
}
}
System.out.println("Examined\t: " + numberOfTypesExamined);
System.out.println("With violations\t: " + numberOfTypesWithViolations);
System.out.println("Other than getter\t: " + numberOfTypesWithViolationsOtherThanGetter);
}
private Map getAdditionalOrViolatedPreconditions(Map valuesRead, TransitiveObjectState state) {
Map stateFields = state.getFieldValues();
Map conditions = new HashMap();
for (HeapPath path : valuesRead.keySet()) {
Value expectedValue = valuesRead.get(path);
if (stateFields.containsKey(path)) {
Value actualValue = stateFields.get(path);
if (!expectedValue.getData().equals(actualValue.getData())) {
conditions.put(path, expectedValue);
}
} else {
conditions.put(path, expectedValue);
}
}
return conditions;
}
private Map getValuesRead(TransitiveObjectState objectState, Set valuesRead) {
Map result = new HashMap();
for (HeapPath heapPath : valuesRead) {
Value value = objectState.getFieldValue(heapPath);
if (value != null) {
result.put(heapPath, value);
} else {
AbstractHeapPathElement start = heapPath.getStart();
if (start instanceof ThisAccess) {
heapPath = (HeapPath) heapPath.clone();
heapPath.removeFirstElement();
value = objectState.getFieldValue(heapPath);
if (value != null) {
result.put(heapPath, value);
} else {
logger.debug("Unable to find value for field " + heapPath + " in state " + objectState);
}
} else {
logger.debug("Unable to find value for field " + heapPath + " in state " + objectState);
}
}
}
return result;
}
public TransitiveObjectState getStateAfterConstructorCall(TransitiveObjectModel model) {
TransitiveObjectState startState = model.getStartingState();
if (startState != null) {
GraphNode startNode = model.getModel().getNodeForData(startState);
Vector> nodes = startNode.getSuccessorNodes();
if (nodes.size() == 1) {
return nodes.get(0).getData();
} else {
return null;
}
} else {
return null;
}
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File file = new File(commandLine.getOptionValue("modelDirectory"));
if (!file.exists()) {
logger.error("Model directory " + file + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(AllInterestingModelsMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("directory").hasArg().withDescription("Directory where model files are stored").create("modelDirectory"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/Pachika.java 100644 0 0 14705 11177775551 24217 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Vector;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
import org.softevo.util.source.ClassFileSource;
import org.softevo.util.source.ClassPathClassFileSource;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.pachika.instrument.FixRunner;
import de.unisb.cs.st.adabu2.pachika.instrument.JavaClass;
import de.unisb.cs.st.adabu2.pachika.instrument.ViolatedPreconditionFixStrategy;
import de.unisb.cs.st.adabu2.pachika.instrument.ViolatedPreconditionJungMethodInsertionStrategy;
import de.unisb.cs.st.adabu2.pachika.instrument.ViolatedPreconditionReturnDefaultValueStrategy;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
public class Pachika {
private static final Logger logger = Logger.getLogger(UsedObjectSetMiner.class);
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
ObjectReaderWriter>>> reader = new ObjectReaderWriter>>>();
File passingRunModelsFile = new File(cmdLine.getOptionValue("passingRunModels"));
HashMap>> passingRunModels = reader.read(passingRunModelsFile);
File failingRunModelsFile = new File(cmdLine.getOptionValue("failingRunModels"));
HashMap>> failingRunModels = reader.read(failingRunModelsFile);
String appClassPath = cmdLine.getOptionValue("appClassPath");
ClassFileSource source = new ClassPathClassFileSource(appClassPath);
ViolatedPreconditionFixStrategy strategy = new ViolatedPreconditionJungMethodInsertionStrategy();
List fixes = strategy.createFixes(passingRunModels, failingRunModels, source);
logger.info("Got " + fixes.size() + " fixes from method insertion strategy.");
strategy = new ViolatedPreconditionReturnDefaultValueStrategy();
List returnFixes = strategy.createFixes(passingRunModels, failingRunModels, source);
logger.info("Got " + returnFixes.size() + " fixes from return value insertion strategy.");
List allFixes = new Vector(fixes);
allFixes.addAll(returnFixes);
File workingDirectory = new File(cmdLine.getOptionValue("workingDirectory"));
File tempDirectory = new File(cmdLine.getOptionValue("tempDirectory"));
String compileClassPath = cmdLine.getOptionValue("compileClassPath");
String testCommand = cmdLine.getOptionValue("testCommand");
//String groovyScript = FileUtils.readFileToString(new File(cmdLine.getOptionValue("groovyScript")));
//FixRunner fixRunner = new FixRunner(groovyScript, workingDirectory, tempDirectory, fixes, compileClassPath);
FixRunner fixRunner = new FixRunner(testCommand, workingDirectory, tempDirectory, allFixes, compileClassPath);
fixRunner.processFixes();
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
} catch (Throwable exception) {
logger.fatal("An exception occured.", exception);
}
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File passingRunModelFile = new File(commandLine.getOptionValue("passingRunModels"));
if (!passingRunModelFile.exists()) {
System.out.println("Passing run model file " + passingRunModelFile + " does not exist.");
return false;
}
File failingRunModelFile = new File(commandLine.getOptionValue("failingRunModels"));
if (!failingRunModelFile.exists()) {
System.out.println("Failing run model file " + failingRunModelFile + " does not exist.");
return false;
}
File tempDirectoryFile = new File(commandLine.getOptionValue("tempDirectory"));
if (!tempDirectoryFile.exists()) {
System.out.println("Temporary directory " + tempDirectoryFile + " does not exist.");
return false;
}
File workingDirectoryFile = new File(commandLine.getOptionValue("workingDirectory"));
if (!workingDirectoryFile.exists()) {
System.out.println("Working directory " + workingDirectoryFile + " does not exist.");
return false;
}
File commandFile = new File(commandLine.getOptionValue("testCommand"));
if (!commandFile.exists()) {
System.out.println("Test command " + commandFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(UsedObjectSetMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with models from passing run.").create("passingRunModels"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with models from failing run.").create("failingRunModels"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("Command that executes the failing test.").create("testCommand"));
options.addOption(OptionBuilder.isRequired().withArgName("cp").hasArg().withDescription("Class path of the application that is to be executed.").create("appClassPath"));
options.addOption(OptionBuilder.isRequired().withArgName("cp").hasArg().withDescription("Class path for compiling fixes.").create("compileClassPath"));
options.addOption(OptionBuilder.isRequired().withArgName("dir").hasArg().withDescription("Working directory for executed processes.").create("workingDirectory"));
options.addOption(OptionBuilder.isRequired().withArgName("dir").hasArg().withDescription("Temporary directory where fixes are compiledin.").create("tempDirectory"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/SimpleUsedObjectSetMiner.java 100644 0 0 11142 11177774751 27520 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
public class SimpleUsedObjectSetMiner {
private static final Logger logger = Logger.getLogger(SimpleUsedObjectSetMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
File outputFile = new File(cmdLine.getOptionValue("outputFile"));
Pattern methodPattern = Pattern.compile(cmdLine.getOptionValue("methodPattern"));
int includes = de.unisb.cs.st.adabu2.pachika.miner.SimpleUsedObjectSetMiner.INCLUDE_ALL;
if (!cmdLine.hasOption("includeAStores")) {
includes -= de.unisb.cs.st.adabu2.pachika.miner.SimpleUsedObjectSetMiner.INCLUDE_ASTORES;
}
int heapPathLength = 1;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using heap path length " + heapPathLength);
de.unisb.cs.st.adabu2.pachika.miner.SimpleUsedObjectSetMiner miner = new de.unisb.cs.st.adabu2.pachika.miner.SimpleUsedObjectSetMiner(traceFile, methodPattern, heapPathLength, includes);
miner.readTrace();
HashMap>> invocationData = miner.getInvocationData();
ObjectReaderWriter>>> writer = new ObjectReaderWriter>>>();
writer.write(invocationData, outputFile);
if (cmdLine.hasOption("verbose")) {
for (MethodIdentifier identifier : invocationData.keySet()) {
Vector> invocations = invocationData.get(identifier);
System.out.println("Got " + invocations.size() + " invocations for method " + identifier);
for (HashMap valuesAccessed : invocations) {
for (HeapPath path : valuesAccessed.keySet()) {
Value value = valuesAccessed.get(path);
System.out.println("\t" + path + ": " + value.toString() + " " + value.getType());
}
}
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(SimpleUsedObjectSetMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File that contains the program trace (e.g. trace.ser)").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("pattern").hasArg().withDescription("Regular expression for accepted methods (see documentation for java.util.regex)").create("methodPattern"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File were serialized information about visible objects is stored into.").create("outputFile"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("The maximum number of steps on the heap the miner follows (aka. depth) ").create("heapPathLength"));
options.addOption(OptionBuilder.withDescription("Output visible objects to System.out at the end of the trace.").create("verbose"));
options.addOption(OptionBuilder.withDescription("Include objects stored in local variables.").create("includeAStores"));
return options;
}
}
././@LongLink 100644 0 0 150 11231004037 10236 L ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/TypeSetDeepTransitiveModelMiner.java adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/TypeSetDeepTransitiveModelMiner.j100644 0 0 13340 11177767660 30403 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.collections.Util;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.pachika.miner.ObjectSetDeepTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.ObjectSetTransitiveModelMiner;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
import de.unisb.cs.st.adabu2.transmodels.abstraction.MissingFieldsAdder;
import de.unisb.cs.st.adabu2.transmodels.abstraction.NeverChangingFieldsRemover;
import de.unisb.cs.st.adabu2.transmodels.abstraction.OldAdabuStateAbstracter;
public class TypeSetDeepTransitiveModelMiner {
private static final Logger logger = Logger.getLogger(TypeSetDeepTransitiveModelMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
int heapPathLength = 2;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using maximum heap path length of " + heapPathLength);
Pattern finalizerMethodPattern = null;
if (cmdLine.hasOption("finalizerMethodPattern")) {
finalizerMethodPattern = Pattern.compile(cmdLine.getOptionValue("finalizerMethodPattern"));
}
HashSet acceptedTypes = new HashSet();
String[] passedIds = cmdLine.getOptionValue("acceptedTypes").split(",");
for (String type: passedIds) {
acceptedTypes.add(type);
}
de.unisb.cs.st.adabu2.pachika.miner.TypeSetDeepTransitiveModelMiner miner = new de.unisb.cs.st.adabu2.pachika.miner.TypeSetDeepTransitiveModelMiner(traceFile, heapPathLength, finalizerMethodPattern, acceptedTypes);
miner.setFinalizerMethodPattern(finalizerMethodPattern);
miner.readTrace();
List models = miner.getModels();
if (cmdLine.hasOption("abstract")) {
for (int i = 0; i < models.size(); i++) {
TransitiveObjectModel objectModel = models.get(i);
MissingFieldsAdder adder = new MissingFieldsAdder(objectModel);
objectModel = adder.createAbstractModel();
NeverChangingFieldsRemover remover = new NeverChangingFieldsRemover(objectModel);
objectModel = remover.createAbstractModel();
OldAdabuStateAbstracter abstracter = new OldAdabuStateAbstracter(objectModel);
objectModel = abstracter.createAbstractModel();
models.set(i, objectModel);
}
}
if (cmdLine.hasOption("verbose")) {
for (TransitiveObjectModel model : models) {
System.out.println("Model for type " + model.getClassName());
System.out.println(model.toVerboseString());
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static HeapPath getPathForObject(HashMap>> objects, Integer objectId) {
for (MethodIdentifier identifier: objects.keySet()) {
Vector> allInvocationData = objects.get(identifier);
for (HashMap invocationData : allInvocationData) {
for (HeapPath path : invocationData.keySet()) {
Value value = invocationData.get(path);
if (value.getObjectId().equals(objectId)) {
return path;
}
}
}
}
return null;
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(TypeSetDeepTransitiveModelMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with trace information").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("Comma-separated list of accepted types").create("acceptedTypes"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("Maximum length of heap paths").create("heapPathLength"));
options.addOption(OptionBuilder.withArgName("regexp").hasArg().withDescription("Regular expression for finalizer methods").create("finalizerMethodPattern"));
options.addOption(OptionBuilder.withDescription("Verbose output").create("verbose"));
options.addOption(OptionBuilder.withDescription("Abstract model").create("abstract"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/cli/UsedObjectSetMiner.java 100644 0 0 10604 11177767660 26351 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.cli;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Vector;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;
import org.apache.log4j.Logger;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
public class UsedObjectSetMiner {
private static final Logger logger = Logger.getLogger(UsedObjectSetMiner.class);
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Options options = createOptions();
CommandLineParser parser = new PosixParser();
CommandLine cmdLine;
try {
cmdLine = parser.parse(options, args);
if (verifyCommandLine(cmdLine)) {
File traceFile = new File(cmdLine.getOptionValue("traceFile"));
File outputFile = new File(cmdLine.getOptionValue("outputFile"));
Pattern methodPattern = Pattern.compile(cmdLine.getOptionValue("methodPattern"));
int includes = de.unisb.cs.st.adabu2.pachika.miner.UsedObjectSetMiner.INCLUDE_ALL;
if (!cmdLine.hasOption("includeAStores")) {
includes -= de.unisb.cs.st.adabu2.pachika.miner.UsedObjectSetMiner.INCLUDE_ASTORES;
}
int heapPathLength = 2;
if (cmdLine.hasOption("heapPathLength")) {
heapPathLength = Integer.parseInt(cmdLine.getOptionValue("heapPathLength"));
}
logger.info("Using heap path length " + heapPathLength);
de.unisb.cs.st.adabu2.pachika.miner.UsedObjectSetMiner miner = new de.unisb.cs.st.adabu2.pachika.miner.UsedObjectSetMiner(traceFile, methodPattern, heapPathLength, includes);
miner.readTrace();
HashMap>> invocationData = miner.getInvocationData();
ObjectReaderWriter>>> writer = new ObjectReaderWriter>>>();
writer.write(invocationData, outputFile);
if (cmdLine.hasOption("verbose")) {
for (MethodIdentifier identifier : invocationData.keySet()) {
Vector> invocations = invocationData.get(identifier);
System.out.println("Got " + invocations.size() + " invocations for method " + identifier);
for (HashMap valuesAccessed : invocations) {
for (HeapPath path : valuesAccessed.keySet()) {
Value value = valuesAccessed.get(path);
System.out.println("\t" + path + ": " + value.toString() + " " + value.getType());
}
}
}
}
}
} catch (ParseException parseException) {
logger.fatal(parseException);
printHelp(options);
return;
}
}
private static boolean verifyCommandLine(CommandLine commandLine) {
File traceFile = new File(commandLine.getOptionValue("traceFile"));
if (!traceFile.exists()) {
System.out.println("Trace file " + traceFile + " does not exist.");
return false;
}
return true;
}
private static void printHelp(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(UsedObjectSetMiner.class.getSimpleName(), options);
}
@SuppressWarnings("static-access")
private static Options createOptions() {
Options options = new Options();
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File with trace information").create("traceFile"));
options.addOption(OptionBuilder.isRequired().withArgName("pattern").hasArg().withDescription("Regular expression for accepted methods").create("methodPattern"));
options.addOption(OptionBuilder.isRequired().withArgName("file").hasArg().withDescription("File invocation data is written to").create("outputFile"));
options.addOption(OptionBuilder.withArgName("int").hasArg().withDescription("File invocation data is written to").create("heapPathLength"));
options.addOption(OptionBuilder.withDescription("Verbose output").create("verbose"));
options.addOption(OptionBuilder.withDescription("Include objects temporarily stored in variables.").create("includeAStores"));
return options;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/AbstractModifier.java 100644 0 0 330 11177767660 27471 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import org.objectweb.asm.Opcodes;
public abstract class AbstractModifier implements IModifier, Opcodes {
@Override
public void init() throws Exception {
}
}
././@LongLink 100644 0 0 146 11231004037 10243 L ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/BasicModifierGenerator.java adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/BasicModifierGenerator.jav100644 0 0 30747 11177767660 30534 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.util.HashSet;
import java.util.List;
import java.util.Vector;
import org.apache.bcel.generic.IFNONNULL;
import org.objectweb.asm.tree.VarInsnNode;
import org.softevo.util.asm.FieldIdentifier;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MyType;
import de.unisb.cs.st.adabu2.eval.CallStack;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.AbstractHeapPathElement;
import de.unisb.cs.st.adabu2.eval.models.heappath.FieldAccess;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.eval.models.heappath.ParameterAccess;
import de.unisb.cs.st.adabu2.eval.models.heappath.StaticFieldAccess;
import de.unisb.cs.st.adabu2.eval.models.heappath.ThisAccess;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocation;
public class BasicModifierGenerator {
private List importedClasses;
private List blocks;
private String modifierClassName;
private String modifierPackageName;
private MethodIdentifier methodToInstrument;
private static final String DEFAULT_PACKAGE = "de.unisb.cs.st.adabu2.pachika.instrument";
public BasicModifierGenerator(String modifierClassName, MethodIdentifier methodToInstrument) {
this(modifierClassName, DEFAULT_PACKAGE, methodToInstrument);
}
public BasicModifierGenerator(String modifierClassName, String modifierPackageName, MethodIdentifier methodToInstrument) {
this.modifierClassName = modifierClassName;
this.modifierPackageName = modifierPackageName;
this.importedClasses = new Vector();
this.methodToInstrument = methodToInstrument;
this.blocks = new Vector();
addDefaultImports();
}
private void addDefaultImports() {
importedClasses.add(DEFAULT_PACKAGE + ".*");
importedClasses.add("org.objectweb.asm.ClassWriter");
importedClasses.add("org.objectweb.asm.tree.*");
importedClasses.add("org.softevo.util.asm.ASMTreeUtilities");
}
public void addBlock(String[] instructions, int insertPosition) {
blocks.add(new InstrumentBlock(instructions, insertPosition));
}
private void appendImports(StringBuffer code) {
for (String importClass : importedClasses) {
code.append("import " + importClass + ";\n");
}
code.append("\n");
}
public JavaClass generateClass() {
StringBuffer code = new StringBuffer();
code.append("package " + modifierPackageName + ";\n\n");
appendImports(code);
code.append("public class " + modifierClassName + " extends AbstractModifier {\n");
//start transform method
code.append("\t@Override\n" +
"\tpublic byte[] transform(String className, byte[] bytes) {\n");
//start if block
code.append("\t\tif (className.equals(\"" + methodToInstrument.getClassName() + "\")) {\n");
code.append("\t\t\tClassNode classNode = ASMTreeUtilities.getClassNode(bytes);\n");
code.append("\t\t\tMethodNode method = ASMTreeUtilities.getMethod(classNode, \"" + methodToInstrument.getMethodName() + "\", \"" + methodToInstrument.getSignature() + "\");\n");
code.append("\t\t\tInsnList instructions = method.instructions;\n");
//append position instructions for all blocks
for (int blockIndex = 0; blockIndex < blocks.size(); blockIndex++) {
InstrumentBlock block = blocks.get(blockIndex);
code.append("\t\t\tAbstractInsnNode insertPosition" + blockIndex + " = instructions.get(" + block.getInsertPosition() + ");\n");
}
for (int blockIndex = 0; blockIndex < blocks.size(); blockIndex++) {
InstrumentBlock block = blocks.get(blockIndex);
String[] instructions = block.getInstructions();
code.append("\t\t\t{\n");
code.append("\t\t\t\tInsnList insertInstructions = new InsnList();\n");
for (String instruction : instructions) {
code.append("\t\t\t\t" + instruction + "\n");
}
code.append("\t\t\t\tinstructions.insert(insertPosition" + blockIndex + ", insertInstructions);\n");
code.append("\t\t\t}\n");
}
//code.append("\t\t\tClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES + ClassWriter.COMPUTE_MAXS);\n");
code.append("\t\t\tClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);\n");
code.append("\t\t\tclassNode.accept(writer);\n");
code.append("\t\t\treturn writer.toByteArray();\n");
//end if block
code.append("\t\t}\n");
code.append("\t\treturn null;\n");
//end transform method
code.append("\t}\n");
//end class
code.append("}\n");
return new JavaClass(modifierPackageName, modifierClassName, code.toString());
}
private List loadObjectOnStack(HeapPath path) throws UnsupportedOperationException {
List instructions = new Vector();
for (AbstractHeapPathElement pathElement: path) {
if (pathElement instanceof ParameterAccess) {
ParameterAccess parameterAccess = (ParameterAccess) pathElement;
instructions.add("insertInstructions.add(new VarInsnNode(ALOAD, " + parameterAccess.getParameterIndex() + "));");
} else if (pathElement instanceof FieldAccess) {
FieldAccess fieldAccess = (FieldAccess) pathElement;
FieldIdentifier fieldIdentifier = fieldAccess.getFieldIdentifier();
String opCode;
if (fieldAccess.getFieldIdentifier().isStatic()) {
instructions.add("insertInstructions.add(new FieldInsnNode(GETSTATIC, \"" + fieldIdentifier.getClassName() + "\", \"" +
fieldIdentifier.getFieldName() + "\", \"" + fieldIdentifier.getType() + "\"));");
} else {
instructions.add("insertInstructions.add(new LdcInsnNode(\"" + fieldIdentifier.getFieldName() + "\"));");
instructions.add("insertInstructions.add(new MethodInsnNode(INVOKESTATIC, \"" + DEFAULT_PACKAGE.replace('.', '/') + "/Util\", \"getFieldValue\", \"(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;\"));");
instructions.add("insertInstructions.add(new TypeInsnNode(CHECKCAST, \"" + getClassNameFromType(fieldIdentifier.getMyType()) + "\"));");
}
} else if (pathElement instanceof StaticFieldAccess) {
//nothing to do here
} else {
throw new UnsupportedOperationException("Unhandled heap path element type " + pathElement.getClass().getSimpleName());
}
}
return instructions;
}
protected String getClassNameFromType(MyType type) {
assert (type.isComplexType());
return type.getTypeString().substring(1, type.getTypeString().length() - 1);
}
public void addReturnDefaultValueBlock(HeapPath path, Value rightValue, MethodIdentifier identifier, int insertPosition) {
MethodInvocation invocation = new MethodInvocation(identifier, new HashSet(), new HashSet(), new CallStack(-1));
addReturnDefaultValueBlock(path, rightValue, invocation, insertPosition);
}
public void addReturnDefaultValueBlock(HeapPath path, Value rightValue, MethodInvocation invocation, int insertPosition) {
List instructions = new Vector();
MyType type = path.getAccessedType();
if (!type.isComplexType()) {
throw new UnsupportedOperationException("Can only handle checks for complex types.");
}
if (invocation.getAccessedObjectPath() != null) {
HeapPath newPath = (HeapPath) path.clone();
for (AbstractHeapPathElement element: invocation.getAccessedObjectPath()) {
newPath.appendElement(element);
}
instructions.addAll(loadObjectOnStack(newPath));
} else {
instructions.addAll(loadObjectOnStack(path));
}
MyType accessedType = path.getAccessedType();
if (accessedType.isComplexType()) {
if (!rightValue.isNullReference()) {
instructions.add("LabelNode label1 = new LabelNode();");
instructions.add("insertInstructions.add(new JumpInsnNode(IFNONNULL, label1));");
List returnInstructions = getReturnDefaultValueInstructions(invocation.getIdentifier());
instructions.addAll(returnInstructions);
instructions.add("insertInstructions.add(label1);");
addBlock(instructions.toArray(new String[instructions.size()]), insertPosition);
} else {
throw new UnsupportedOperationException("Can not handle complex values other than null.");
}
} else if (accessedType.isArrayType()){
throw new UnsupportedOperationException("Can not handle array fields.");
} else {
throw new UnsupportedOperationException("Can not handle primitive fields.");
}
}
public List getReturnDefaultValueInstructions(MethodIdentifier identifier) {
List instructions = new Vector();
String returnType = identifier.getReturnType();
if (returnType.equals("V")) {
instructions.add("insertInstructions.add(new InsnNode(RETURN));");
} else if (returnType.startsWith("L") || returnType.startsWith("[")) {
instructions.add("insertInstructions.add(new InsnNode(ACONST_NULL));");
instructions.add("insertInstructions.add(new InsnNode(ARETURN));");
} else if (returnType.equals("I") || returnType.equals("B") || returnType.equals("S") || returnType.equals("C")) {
instructions.add("insertInstructions.add(new InsnNode(ICONST_0));");
instructions.add("insertInstructions.add(new InsnNode(IRETURN));");
} else if (returnType.equals("J")) {
instructions.add("insertInstructions.add(new InsnNode(LCONST_0));");
instructions.add("insertInstructions.add(new InsnNode(LRETURN));");
} else if (returnType.equals("D")) {
instructions.add("insertInstructions.add(new InsnNode(DCONST_0));");
instructions.add("insertInstructions.add(new InsnNode(DRETURN));");
} else if (returnType.equals("F")) {
instructions.add("insertInstructions.add(new InsnNode(FCONST_0));");
instructions.add("insertInstructions.add(new InsnNode(FRETURN));");
} else {
throw new UnsupportedOperationException("Unhandled return type " + returnType);
}
return instructions;
}
public void addMethodCallBlock(HeapPath path, MethodInvocation invocation, int insertPosition) {
MethodIdentifier identifier = invocation.getIdentifier();
if (identifier.getSignature().indexOf("()") == -1) {
throw new UnsupportedOperationException("Can only handle method calls that don't take parameters.");
}
List instructions = new Vector();
if (invocation.getAccessedObjectPath() != null) {
HeapPath newPath = (HeapPath) path.clone();
for (AbstractHeapPathElement element: invocation.getAccessedObjectPath()) {
newPath.appendElement(element);
}
instructions.addAll(loadObjectOnStack(newPath));
} else {
instructions.addAll(loadObjectOnStack(path));
}
String opCode;
if (identifier.isStatic()) {
opCode = "INVOKESTATIC";
} else {
opCode = "INVOKEVIRTUAL";
//opCode = "INVOKEINTERFACE";
}
instructions.add("insertInstructions.add(new TypeInsnNode(CHECKCAST, \"" + identifier.getClassName() + "\"));");
instructions.add("insertInstructions.add(new MethodInsnNode(" + opCode + ", \"" + identifier.getClassName() + "\" , \"" + identifier.getMethodName() + "\" , \"" + identifier.getSignature() + "\"));");
addBlock(instructions.toArray(new String[instructions.size()]), insertPosition);
}
private static HeapPath getAccessedObjectPath() {
FieldIdentifier fieldIdentifier = new FieldIdentifier("org/apache/mina/transport/AbstractBindTest", "two", "Lorg/apache/mina/common/IoAcceptor;", false);
FieldAccess fieldAccess = new FieldAccess(null, 0, fieldIdentifier, false);
fieldIdentifier = new FieldIdentifier("org/apache/mina/transport/AbstractBindTest", "one", "Lorg/apache/mina/common/IoAcceptor;", false);
FieldAccess secondFieldAccess = new FieldAccess(fieldAccess, 0, fieldIdentifier, false);
HeapPath path = new HeapPath(secondFieldAccess);
return path;
}
public boolean hasBlocks() {
return blocks.size() > 0;
}
public static void main(String[] args) {
MethodIdentifier methodIdentifier = new MethodIdentifier("org/apache/mina/transport/AbstractBindTest", "testAnonymousBind", "()V", 0);
MethodIdentifier callMethodIdentifer = new MethodIdentifier("org/apache/mina/common/support/BaseIoAcceptor", "bind", "()V", 0);
FieldIdentifier fieldIdentifier = new FieldIdentifier("org/apache/mina/transport/AbstractBindTest", "acceptor", "Lorg/apache/mina/common/IoAcceptor;", false);
FieldAccess fieldAccess = new FieldAccess(null, 0, fieldIdentifier, false);
HeapPath path = new HeapPath(new ThisAccess(null, methodIdentifier, 0));
path.appendElement(fieldAccess);
MethodInvocation invocation = new MethodInvocation(callMethodIdentifer, new HashSet(), new HashSet(), new CallStack(-1));
invocation.setAccessedObjectPath(getAccessedObjectPath());
BasicModifierGenerator generator = new BasicModifierGenerator("MethodCallInjector", methodIdentifier);
generator.addMethodCallBlock(path, invocation, 15);
JavaClass javaClass = generator.generateClass();
System.out.println(javaClass.getContent());
}
}
././@LongLink 100644 0 0 153 11231004037 10241 L ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/ClassVisibilityClassAdapter.java adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/ClassVisibilityClassAdapte100644 0 0 2175 11177767660 30602 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import org.objectweb.asm.ClassAdapter;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;
public class ClassVisibilityClassAdapter extends ClassAdapter implements Opcodes {
private int modifiers;
private static final int CLEAR_MASK = Integer.MAX_VALUE - ACC_PROTECTED - ACC_PRIVATE;
public ClassVisibilityClassAdapter(ClassVisitor parent) {
this(parent, ACC_PUBLIC);
}
public ClassVisibilityClassAdapter(ClassVisitor parent, int modifiers) {
super(parent);
this.modifiers = modifiers;
}
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
access = access & CLEAR_MASK;
access = access | modifiers;
super.visit(version, access, name, signature, superName, interfaces);
}
public static void main(String[] args) {
int access = ACC_ABSTRACT | ACC_PROTECTED | ACC_SYNCHRONIZED | ACC_SYNTHETIC;
System.out.println(Integer.toBinaryString(access));
access = access & CLEAR_MASK;
access = access | ACC_PUBLIC;
System.out.println(Integer.toBinaryString(access));
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/FixRunner.java 100644 0 0 11764 11177767660 26244 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Vector;
import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteException;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.io.FileUtils;
import org.apache.log4j.Logger;
public class FixRunner {
protected static final Logger logger = Logger.getLogger(FixRunner.class);
/*private GroovyShell shell;
private HashMap scriptCache;*/
protected List fixes;
protected File workingDirectory;
protected String compileClassPath;
protected File tmpDirectory;
protected String testCommand;
public FixRunner(String testCommand, File workingDirectory, File tmpDirectory, List fixes, String compileClassPath) {
this.testCommand = testCommand;
this.workingDirectory = workingDirectory;
this.tmpDirectory = tmpDirectory;
this.fixes = fixes;
this.compileClassPath = compileClassPath;
/*this.shell = new GroovyShell();
this.scriptCache = new HashMap();*/
}
public List processFixes() throws IOException {
List successfullFixes = new Vector();
int fixCounter = 1;
for (JavaClass javaClass : fixes) {
logger.debug("Checking fix: " + javaClass.getContent());
compile(javaClass);
boolean hasPassed = runTest(javaClass, fixCounter);
if (hasPassed) {
logger.info("Found a fix for the test: ");
logger.info(javaClass.getContent());
successfullFixes.add(javaClass);
}
fixCounter++;
}
return successfullFixes;
}
protected boolean runTest(JavaClass javaClass, int fixNumber) throws IOException {
String modifierClass = javaClass.getPackageName() + "." + javaClass.getClassName();
CommandLine commandLine = CommandLine.parse(testCommand);
commandLine.addArgument("-Xbootclasspath/a:" + tmpDirectory.getAbsolutePath() + ":" + compileClassPath);
commandLine.addArgument("-javaagent:/scratch2/dallmeier/bin/projects/adabu2/adabu2-pachika/target/adabu2-pachika-0.4-SNAPSHOT.jar");
commandLine.addArgument("-Dadabu2.modifier=" + modifierClass);
//commandLine.addArgument("-Dadabu2.display=true");
return runProcess(commandLine, 0, workingDirectory);
}
protected void compile(JavaClass javaClass) throws IOException {
File packageDirectory = new File(tmpDirectory.getAbsolutePath() + File.separator + javaClass.getPackageName().replace('.', '/'));
packageDirectory.mkdirs();
File classFile = new File(packageDirectory.getAbsolutePath() + File.separator + javaClass.getClassName() + ".java");
FileUtils.writeStringToFile(classFile, javaClass.getContent());
CommandLine commandLine = null;
if (System.getProperty("os.name").equalsIgnoreCase("linux")) {
commandLine = CommandLine.parse("/usr/lib/jvm/jdk1.6.0/bin/javac");
} else {
commandLine = CommandLine.parse("/scratch2/dallmeier/soylatte/bin/javac");
}
commandLine.addArguments("-cp");
commandLine.addArgument(compileClassPath + ":.");
commandLine.addArgument(javaClass.getPackageName().replace('.', '/') + "/" + javaClass.getClassName() + ".java");
runProcess(commandLine, 0, tmpDirectory);
}
protected boolean runProcess(CommandLine commandLine, int expectedExitValue, File workingDirectory) throws IOException {
logger.debug("Executing command line " + commandLine.toString());
ExecuteWatchdog watchdog = new ExecuteWatchdog(60000);
DefaultExecutor executor = new DefaultExecutor();
logger.debug("Setting working directory " + workingDirectory + ".");
executor.setWorkingDirectory(workingDirectory);
executor.setWatchdog(watchdog);
ByteArrayOutputStream out = new ByteArrayOutputStream();
executor.setExitValue(expectedExitValue);
executor.setStreamHandler(new PumpStreamHandler(out));
try {
int exitValue = executor.execute(commandLine);
String output = out.toString();
try {
Thread.sleep(500);
} catch (InterruptedException exception) {
//ignore exception
}
if (output != null) {
logger.debug("Process exit value " + exitValue);
logger.trace("Output " + output);
}
return true;
} catch (ExecuteException exception) {
int exitValue = exception.getExitValue();
String output = out.toString();
logger.error("Process threw an exception and ended with " + exitValue, exception);
logger.error("Output " + output);
return false;
}
}
/*private String runGroovyScript(String script, Binding binding) {
Script groovyScript = scriptCache.get(script);
if (groovyScript == null) {
groovyScript = shell.parse(script);
scriptCache.put(script, groovyScript);
}
groovyScript.setBinding(binding);
try {
Object value = groovyScript.run();
return binding.getVariable("result").toString();
} catch (Throwable executionException) {
logger.error("An exception occured executing the script", executionException);
return null;
}
}*/
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/IModifier.java 100644 0 0 265 11177767660 26125 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
public interface IModifier {
public void init() throws Exception;
public byte[] transform(String className, byte[] bytes);
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/InstrumentBlock.java 100644 0 0 655 11177767660 27404 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
public class InstrumentBlock {
private int insertPosition;
private String[] instructions;
public InstrumentBlock(String[] instructions, int insertPosition) {
this.instructions = instructions;
this.insertPosition = insertPosition;
}
public int getInsertPosition() {
return insertPosition;
}
public String[] getInstructions() {
return instructions;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/Instrumenter.java 100644 0 0 10231 11177767660 27007 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import org.apache.commons.io.FileUtils;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.util.TraceClassVisitor;
public class Instrumenter implements ClassFileTransformer {
public static final String PROP_CLASSNAME_MODIFIER = "adabu2.modifier";
public static final String PROP_DISPLAY = "adabu2.display";
private static Instrumenter singletonInstance;
private IModifier modifier;
private Instrumenter(IModifier modifier) {
this.modifier = modifier;
}
public static void premain(String agentArgs, Instrumentation inst) {
// check the JRE version we run on
final String javaVersion = System.getProperty("java.version");
final int secondPointPos = javaVersion.indexOf('.', javaVersion.indexOf('.')+1);
try {
if (secondPointPos != -1) {
final double javaVersionDouble = Double.valueOf(javaVersion.substring(0, secondPointPos));
if (javaVersionDouble < 1.59) {
System.out.println("This tracer requires JRE >= 1.6, you are running " + javaVersion + ".");
System.exit(-1);
}
}
} catch (final NumberFormatException e) {
// ignore (no check...)
}
if (!System.getProperties().containsKey(PROP_CLASSNAME_MODIFIER)) {
System.out.println("Property " + PROP_CLASSNAME_MODIFIER + " not set. Please specifiy the fully qualified classname of a modifier.");
System.exit(-1);
} else {
try {
Class modifierClass = Class.forName(System.getProperty(PROP_CLASSNAME_MODIFIER));
IModifier modifier = (IModifier) modifierClass.newInstance();
modifier.init();
singletonInstance = new Instrumenter(modifier);
inst.addTransformer(singletonInstance);
} catch (Exception loadException) {
System.out.println("An exception occured loading the modifier class:");
System.out.println(loadException);
loadException.printStackTrace();
System.exit(-1);
}
}
}
private byte[] changeClassVisibilityToPublic(String className, byte[] classBytes) {
ClassReader classReader = new ClassReader(classBytes);
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisibilityClassAdapter adapter = new ClassVisibilityClassAdapter(classWriter);
classReader.accept(adapter, 0);
return classWriter.toByteArray();
}
@Override
public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classBytes) throws IllegalClassFormatException {
try {
byte[] modifiedBytes = modifier.transform(className, classBytes);
if (modifiedBytes != null) {
if (System.getProperty(PROP_DISPLAY) != null) {
displayClass(modifiedBytes);
}
} else {
modifiedBytes = changeClassVisibilityToPublic(className, classBytes);
}
return modifiedBytes;
} catch (Throwable instrumentationException) {
System.out.println("An exception occured instrumenting.");
System.out.println(instrumentationException);
instrumentationException.printStackTrace();
System.exit(-1);
return null;
}
}
private static void displayClass(byte[] classBytes) {
ClassReader classReader;
TraceClassVisitor traceVisitor;
classReader = new ClassReader(classBytes);
traceVisitor = new TraceClassVisitor(new PrintWriter(System.out));
classReader.accept(traceVisitor, 0);
}
public static void main(String[] args) throws IOException, IllegalClassFormatException {
String fileName = "/Users/dallmeier/tmp/AbstractBindTest.class";
File inputFile = new File(fileName);
byte[] source = FileUtils.readFileToByteArray(inputFile);
//System.setProperty(PROP_CLASSNAME_MODIFIER, "de.unisb.cs.st.adabu2.pachika.instrument.MethodCallInjector");
Instrumenter instrumenter = new Instrumenter(new MethodCallInjector());
byte[] transformed = instrumenter.transform(null, "org/apache/mina/transport/AbstractBindTest", null, null, source);
displayClass(transformed);
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/JavaClass.java 100644 0 0 1255 11177767660 26145 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.io.Serializable;
public class JavaClass implements Serializable {
private static final long serialVersionUID = -2838681496278531389L;
private String className;
private String content;
private String packageName;
public JavaClass(String packageName, String className, String content) {
super();
this.packageName = packageName;
this.className = className;
this.content = content;
}
public String getPackageName() {
return packageName;
}
public String getClassName() {
return className;
}
public String getContent() {
return content;
}
public String toString() {
return content;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/Main.java 100644 0 0 2340 11177767660 25156 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodNode;
public class Main {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
String fileName = args[0];
File inputFile = new File(fileName);
byte[] source = FileUtils.readFileToByteArray(inputFile);
ClassReader cr = new ClassReader(source);
ClassNode cn = new ClassNode();
cr.accept(cn, ClassReader.EXPAND_FRAMES);
for (int methodCounter = 0; methodCounter < cn.methods.size(); methodCounter++) {
MethodNode methodNode = (MethodNode) cn.methods.get(methodCounter);
System.out.println(methodNode.name);
InsnList instructions = methodNode.instructions;
for (int instructionCounter = 0; instructionCounter < instructions.size(); instructionCounter++) {
AbstractInsnNode instruction = instructions.get(instructionCounter);
System.out.println("\t" + instruction.getClass().getName());
}
}
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/MethodCallInjector.java 100644 0 0 4004 11177767660 30003 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.TypeInsnNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.softevo.util.asm.ASMTreeUtilities;
public class MethodCallInjector extends AbstractModifier {
@Override
public byte[] transform(String className, byte[] bytes) {
if (className.equals("org/apache/mina/transport/AbstractBindTest")) {
ClassNode classNode = ASMTreeUtilities.getClassNode(bytes);
MethodNode method = ASMTreeUtilities.getMethod(classNode, "testAnonymousBind", "()V");
InsnList instructions = method.instructions;
AbstractInsnNode insertPosition1 = instructions.get(15);
{
InsnList instructions1 = new InsnList();
instructions1.add(new VarInsnNode(ALOAD, 0));
instructions1.add(new FieldInsnNode(GETFIELD, "org/apache/mina/transport/AbstractBindTest", "acceptor", "Lorg/apache/mina/common/IoAcceptor;"));
instructions1.add(new TypeInsnNode(CHECKCAST, "org/apache/mina/common/support/BaseIoAcceptor"));
instructions1.add(new MethodInsnNode(INVOKEVIRTUAL, "org/apache/mina/common/support/BaseIoAcceptor", "bind", "()V"));
instructions1.add(new LdcInsnNode("wurst"));
LabelNode label1 = new LabelNode();
instructions1.add(label1);
instructions1.add(new JumpInsnNode(1, label1));
instructions1.add(new InsnNode(IRETURN));
instructions.insert(insertPosition1, instructions1);
}
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES + ClassWriter.COMPUTE_MAXS);
classNode.accept(writer);
return writer.toByteArray();
}
return null;
}
}
adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/Util.java 100644 0 0 1635 11177767660 25215 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.lang.reflect.Field;
public class Util {
public static Object getFieldValue(Object fromObject, String fieldName) {
Field field = getField(fromObject.getClass(), fieldName);
if (field != null) {
field.setAccessible(true);
Object result = null;
try {
result = field.get(fromObject);
} catch (Exception e) {
}
field.setAccessible(false);
return result;
} else {
return null;
}
}
public static Field getField(Class type, String fieldName) {
try {
Field declaredField = type.getDeclaredField(fieldName);
return declaredField;
} catch (SecurityException e) {
return null;
} catch (NoSuchFieldException e) {
Class superType = type.getSuperclass();
if (superType != null) {
// we search in superclass, field may be declared there
return getField(superType, fieldName);
}
return null;
}
}
}
././@LongLink 100644 0 0 157 11231004037 10245 L ustar 0 0 adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/ViolatedPreconditionFixStrategy.java adabu2-pachika-0.5/src/main/java/de/unisb/cs/st/adabu2/pachika/instrument/ViolatedPreconditionFixStr100644 0 0 50026 11177767660 30663 0 ustar 0 0 package de.unisb.cs.st.adabu2.pachika.instrument;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.Vector;
import org.apache.log4j.Logger;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.softevo.util.asm.ASMTreeUtilities;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.datastructures.Graph;
import org.softevo.util.datastructures.GraphEdge;
import org.softevo.util.datastructures.GraphNode;
import org.softevo.util.source.ClassFile;
import org.softevo.util.source.ClassFileSource;
import de.unisb.cs.st.adabu2.eval.CallStack;
import de.unisb.cs.st.adabu2.eval.InvokedMethod;
import de.unisb.cs.st.adabu2.eval.models.Value;
import de.unisb.cs.st.adabu2.eval.models.heappath.HeapPath;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocation;
import de.unisb.cs.st.adabu2.transmodels.MethodInvocationSet;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectModel;
import de.unisb.cs.st.adabu2.transmodels.TransitiveObjectState;
public abstract class ViolatedPreconditionFixStrategy {
private Logger logger = Logger.getLogger(ViolatedPreconditionFixStrategy.class);
public List createFixes(HashMap>> passingRunData,
HashMap>> failingRunData,
ClassFileSource source) {
Map codeToFixMap = new HashMap();
Map> allMethodsTypeToModelMap = getTypeToModelMap(passingRunData);
for (MethodIdentifier methodIdentifier : failingRunData.keySet()) {
Vector> allFailingModels = failingRunData.get(methodIdentifier);
Map> typeToModelMap = null;
Map> pathToModelMap = null;
if (passingRunData.containsKey(methodIdentifier)) {
Vector> allPassingModels = passingRunData.get(methodIdentifier);
typeToModelMap = getTypeToModelMap(allPassingModels);
pathToModelMap = getPathToModelMap(allPassingModels);
} else {
pathToModelMap = new HashMap>();
typeToModelMap = allMethodsTypeToModelMap;
}
for (int invocationCounter = 0; invocationCounter < allFailingModels.size(); invocationCounter++) {
HashMap failingModels = allFailingModels.get(invocationCounter);
for (HeapPath failingModelPath: failingModels.keySet()) {
TransitiveObjectModel failingRunModel = failingModels.get(failingModelPath);
String modelType = failingRunModel.getClassName();
Set passingRunModels = pathToModelMap.get(failingModelPath);
if (passingRunModels != null) {
logger.debug("Mining models from invocations.");
processPassingRunModels(source, codeToFixMap, methodIdentifier, failingModelPath, failingRunModel,
passingRunModels);
} else {
logger.debug("No passing run model found from invocations for heap path " + failingModelPath);
}
logger.debug("Trying to use models from types.");
passingRunModels = typeToModelMap.get(modelType);
if (passingRunModels != null) {
logger.debug("Mining models from types.");
processPassingRunModels(source, codeToFixMap, methodIdentifier, failingModelPath, failingRunModel,
passingRunModels);
}
}
}
}
List fixes = new Vector(codeToFixMap.values());
return fixes;
}
private void processPassingRunModels(ClassFileSource source, Map codeToFixMap,
MethodIdentifier methodIdentifier, HeapPath failingModelPath,
TransitiveObjectModel failingRunModel,
Set passingRunModels) {
for (TransitiveObjectModel passingRunModel: passingRunModels) {
Map> passingRunPreconditions = getPreconditions(passingRunModel, failingRunModel);
Map> violations = findViolations(failingRunModel, passingRunPreconditions);
if (violations.size() > 0) {
List newFixes = calculateFixes(methodIdentifier, passingRunPreconditions, violations, failingRunModel, passingRunModel, failingModelPath, source);
if (newFixes != null) {
for (JavaClass newFix : newFixes) {
if (!codeToFixMap.containsKey(newFix.getContent())) {
codeToFixMap.put(newFix.getContent(), newFix);
}
}
}
}
}
}
private Map> getPathToModelMap(Vector> allModels) {
Map> pathToTypeMap = new HashMap>();
for (HashMap map : allModels) {
for (HeapPath path: map.keySet()) {
TransitiveObjectModel model = map.get(path);
Set pathModels = pathToTypeMap.get(path);
if (pathModels == null) {
pathModels = new HashSet();
pathToTypeMap.put(path, pathModels);
}
pathModels.add(model);
}
}
return pathToTypeMap;
}
private Map> getTypeToModelMap(HashMap>> allModels) {
HashMap> typeToModelMap = new HashMap>();
for (MethodIdentifier identifier : allModels.keySet()) {
Vector> models = allModels.get(identifier);
Map> methodModelToTypeMap = getTypeToModelMap(models);
for (String type: methodModelToTypeMap.keySet()) {
Set newModels = methodModelToTypeMap.get(type);
Set typeModels = typeToModelMap.get(type);
if (typeModels == null) {
typeModels = new HashSet();
typeToModelMap.put(type, typeModels);
}
typeModels.addAll(newModels);
}
}
return typeToModelMap;
}
private Map> getTypeToModelWithPathMap(Vector> allModels) {
Map> typeToModelMap = new HashMap>();
for (HashMap models: allModels) {
for (HeapPath path: models.keySet()) {
TransitiveObjectModel model = models.get(path);
String type = model.getClassName();
List typeModels = typeToModelMap.get(type);
if (typeModels == null) {
typeModels = new Vector();
typeToModelMap.put(type, typeModels);
}
typeModels.add(new ModelWithPath(model, path));
}
}
return typeToModelMap;
}
private Map> getTypeToModelMap(Vector> allModels) {
Map> typeToModelMap = new HashMap>();
for (HashMap models: allModels) {
for (HeapPath path: models.keySet()) {
TransitiveObjectModel model = models.get(path);
String type = model.getClassName();
Set typeModels = typeToModelMap.get(type);
if (typeModels == null) {
typeModels = new HashSet();
typeToModelMap.put(type, typeModels);
}
typeModels.add(model);
}
}
return typeToModelMap;
}
protected abstract List calculateFixes(MethodIdentifier methodToFix,
Map> passingRunPreconditions,
Map> violations,
TransitiveObjectModel failingRunModel,
TransitiveObjectModel passingRunModel,
HeapPath failingModelPath, ClassFileSource source);
public static Map>> getTransitionsThatEnsurePrecondition(Map preconditions, TransitiveObjectModel model) {
Map>> transitions = new HashMap>>();
for (HeapPath preconditionPath : preconditions.keySet()) {
List> edges = new Vector>();
Value preconditionValue = preconditions.get(preconditionPath);
Map singlePreconditionMap = new HashMap();
singlePreconditionMap.put(preconditionPath, preconditionValue);
List> matchingNodes = getMatchingNodes(singlePreconditionMap, model);
for (GraphNode graphNode : matchingNodes) {
List> incomingEdges = graphNode.getIncomingEdges();
for (GraphEdge graphEdge : incomingEdges) {
GraphNode incomingEdgeStartNode = graphEdge.getStartNode();
TransitiveObjectState incomingEdgeStartState = incomingEdgeStartNode.getData();
if (incomingEdgeStartState.containsValueForPath(preconditionPath)) {
Value value = incomingEdgeStartState.getFieldValue(preconditionPath);
if (!value.equals(preconditionValue)) {
edges.add(graphEdge);
}
} else {
edges.add(graphEdge);
}
}
}
if (!edges.isEmpty()) {
transitions.put(preconditionPath, edges);
}
}
return transitions;
}
protected static List> getMatchingNodes(Map conditions, TransitiveObjectModel model) {
Vector> nodes = new Vector>();
for (GraphNode graphNode : model.getModel().getNodes()) {
TransitiveObjectState currentState = graphNode.getData();
if (stateFullfillsConditions(currentState, conditions)) {
nodes.add(graphNode);
}
}
return nodes;
}
private static boolean stateFullfillsConditions(TransitiveObjectState state, Map conditions) {
Map currentFields = state.getFieldValues();
for (HeapPath path: conditions.keySet()) {
Value expectedValue = conditions.get(path);
if (currentFields.containsKey(path)) {
Value actualValue = currentFields.get(path);
if (!actualValue.equals(expectedValue)) {
return false;
}
} else {
return false;
}
}
return true;
}
private Map> findViolations(TransitiveObjectModel model,
Map> preconditions) {
HashMap> allViolations = new HashMap>();
for (MethodInvocation methodIdentifier : preconditions.keySet()) {
Map methodPreconditions = preconditions.get(methodIdentifier);
List violations = findViolation(model, methodIdentifier, methodPreconditions);
if (violations.size() > 0) {
allViolations.put(methodIdentifier, violations);
}
}
return allViolations;
}
private List findViolation(TransitiveObjectModel model,
MethodInvocation methodInvocation,
Map methodPreconditions) {
List violations = new Vector();
for (GraphEdge graphEdge : model.getModel().getEdges()) {
MethodInvocationSet allMethodInvocations = graphEdge.getData();
if (allMethodInvocations.containsInvocation(methodInvocation)) {
Violation violation = new Violation(methodInvocation, graphEdge);
TransitiveObjectState objectState = graphEdge.getStartNode().getData();
for (HeapPath path : methodPreconditions.keySet()) {
Value expectedValue = methodPreconditions.get(path);
Value actualValue = objectState.getFieldValue(path);
if (actualValue == null || !actualValue.equals(expectedValue)) {
violation.addViolatedPrecondition(path, expectedValue);
}
}
if (violation.getViolatedPreconditions().size() > 0) {
violations.add(violation);
}
}
}
return violations;
}
/*private Map getTypeToModelMap(HashMap models) {
HashMap typeToModelMap = new HashMap();
for (HeapPath path : models.keySet()) {
TransitiveObjectModel model = models.get(path);
typeToModelMap.put(model.getClassName(), model);
}
return typeToModelMap;
}*/
public Map> getPreconditions(TransitiveObjectModel passingRunModel, TransitiveObjectModel failingRunModel) {
Map> preconditions = new HashMap