compare traces based on their aliasing structure and symbols

Author: lexicalscope

svm-jcore/src/main/java/com/lexicalscope/svm/vm/j/code/AsmSMethodName.java

@@ -3,15 +3,21 @@
 import static com.lexicalscope.svm.vm.j.JavaConstants.*;
 import static org.objectweb.asm.Type.*;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.objectweb.asm.Type;
 
+import com.google.common.primitives.Ints;
 import com.lexicalscope.svm.vm.j.SVirtualMethodName;
 import com.lexicalscope.svm.vm.j.klass.SMethodDescriptor;
 
 public final class AsmSMethodName implements Comparable<AsmSMethodName>, SMethodDescriptor {
    private final String klassName;
    private final SVirtualMethodName virtualName;
    private final int hashCode;
+   private final int[] objectArgIndexes;
+   private final boolean returnTypeIsObject;
 
    public AsmSMethodName(
          final String klassName,
@@ -21,6 +27,23 @@ public AsmSMethodName(
       this.klassName = klassName;
       this.virtualName = new AsmSVirtualMethodName(name, desc);
       this.hashCode = klassName.hashCode() ^ virtualName.hashCode();
+      this.objectArgIndexes = indexesOfObjectArgs(desc);
+      this.returnTypeIsObject = getReturnType(desc).getSort() == Type.OBJECT;
+   }
+
+   private static int[] indexesOfObjectArgs(final String desc) {
+      final List<Integer> result = new ArrayList<>();
+      final Type[] argumentTypes = Type.getArgumentTypes(desc);
+      for (int j = 0; j < argumentTypes.length; j++) {
+         if(argumentTypes[j].getSort() == Type.OBJECT) {
+            result.add(j);
+         }
+      }
+      return Ints.toArray(result);
+   }
+
+   @Override public boolean returnIsObject() {
+      return returnTypeIsObject;
    }
 
    public AsmSMethodName(
@@ -88,6 +111,10 @@ public int argSize() {
       return getArgumentsAndReturnSizes(desc()) >> 2;
    }
 
+   @Override public int[] objectArgIndexes() {
+      return objectArgIndexes;
+   }
+
    @Override
    public int returnCount() {
       return getArgumentsAndReturnSizes(desc()) & 0x03;

svm-jcore/src/main/java/com/lexicalscope/svm/vm/j/klass/SMethodDescriptor.java

@@ -12,6 +12,8 @@ public interface SMethodDescriptor extends SMethodName {
 
    String desc();
 
+   int[] objectArgIndexes();
+   boolean returnIsObject();
    int argSize();
    int returnCount();
 

svm-partition-trace-symb/src/test/java/com/lexicalscope/svm/partition/trace/symb/TestTraceEquivalenceModuloAliasing.java

@@ -0,0 +1,54 @@
+package com.lexicalscope.svm.partition.trace.symb;
+
+import static com.lexicalscope.svm.partition.trace.TraceBuilder.trace;
+import static com.lexicalscope.svm.partition.trace.symb.SymbolicTraceMatchers.equivalentTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.not;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.lexicalscope.svm.j.instruction.symbolic.symbols.ISymbol;
+import com.lexicalscope.svm.partition.trace.TraceBuilder;
+import com.lexicalscope.svm.vm.symb.junit.Fresh;
+import com.lexicalscope.svm.vm.symb.junit.SolverRule;
+
+public class TestTraceEquivalenceModuloAliasing {
+   @Rule public final SolverRule solver = new SolverRule();
+   public static class Example { }
+
+   private @Fresh ISymbol symbol1;
+   private @Fresh ISymbol symbol2;
+
+   private final Object address1 = new Object();
+   private final Object address2 = new Object();
+   private final Object address3 = new Object();
+
+   private TraceBuilder receiverAliasesParameterV1;
+   private TraceBuilder receiverAliasesParameterV2;
+   private TraceBuilder receiverDoesNotAliasParameter;
+
+   @Before public void createTraces() {
+      receiverAliasesParameterV1 = trace()
+            .methodCall(Example.class, "call", "(Ljava/lang/Object;)V", address1, address1)
+            .methodReturn(Example.class, "call", "(Ljava/lang/Object;)V");
+
+      receiverAliasesParameterV2 = trace()
+            .methodCall(Example.class, "call", "(Ljava/lang/Object;)V", address2, address2)
+            .methodReturn(Example.class, "call", "(Ljava/lang/Object;)V");
+
+      receiverDoesNotAliasParameter = trace()
+            .methodCall(Example.class, "call", "(Ljava/lang/Object;)V", address1, address3)
+            .methodReturn(Example.class, "call", "(Ljava/lang/Object;)V");
+   }
+
+   @Test public void sameAliasingAreEquivalent() throws Exception {
+      assertThat(receiverAliasesParameterV1, equivalentTo(solver, receiverAliasesParameterV2));
+   }
+
+   @Test public void differentAliasingAreNotEquivalent() throws Exception {
+      assertThat(receiverAliasesParameterV1, not(equivalentTo(solver, receiverDoesNotAliasParameter)));
+      assertThat(receiverAliasesParameterV2, not(equivalentTo(solver, receiverDoesNotAliasParameter)));
+   }
+}

svm-partition-trace/src/main/java/com/lexicalscope/svm/partition/trace/Alias.java

@@ -0,0 +1,23 @@
+package com.lexicalscope.svm.partition.trace;
+
+public class Alias {
+   private final int index;
+
+   public Alias(final int index) {
+      this.index = index;
+   }
+
+   @Override public boolean equals(final Object obj) {
+      return obj != null
+            && obj.getClass().equals(this.getClass())
+            && ((Alias) obj).index == this.index;
+   }
+
+   @Override public int hashCode() {
+      return index;
+   }
+
+   @Override public String toString() {
+      return "Alias-" + index;
+   }
+}

svm-partition-trace/src/main/java/com/lexicalscope/svm/partition/trace/Trace.java

@@ -1,36 +1,81 @@
 package com.lexicalscope.svm.partition.trace;
 
 import static com.lexicalscope.svm.partition.trace.Trace.CallReturn.CALL;
+import static java.util.Arrays.copyOf;
 
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Joiner;
 import com.lexicalscope.svm.stack.trace.SMethodName;
+import com.lexicalscope.svm.vm.j.klass.SMethodDescriptor;
 
 public class Trace implements Iterable<Trace> {
    private final Trace previous;
-   private final SMethodName method;
+   private final SMethodDescriptor method;
    private final CallReturn callReturn;
    private final Object[] args;
+   private final Map<Object, Alias> map;
+   private final int nextAlias;
    public enum CallReturn { CALL, RETURN }
 
    public Trace() {
-      this(null, null, null, new Object[0]);
+      this(null, new HashMap<Object, Alias>(), 0, null, null, new Object[0]);
    }
 
-   private Trace(final Trace trace, final SMethodName method, final CallReturn callReturn, final Object[] args) {
+   private Trace(
+         final Trace trace,
+         final Map<Object, Alias> map,
+         final int nextAlias,
+         final SMethodDescriptor method,
+         final CallReturn callReturn,
+         final Object[] args) {
+      this.nextAlias = nextAlias;
       assert !Arrays.asList(args).contains(null);
       this.previous = trace;
+      this.map = map;
       this.method = method;
       this.callReturn = callReturn;
       this.args = args;
    }
 
-   public Trace extend(final SMethodName methodCalled, final CallReturn callReturn, final Object ... args) {
-      return new Trace(this, methodCalled, callReturn, args);
+   public Trace extend(final SMethodDescriptor methodCalled, final CallReturn callReturn, final Object ... args) {
+      final Object[] normalisedArgs = copyOf(args, args.length);
+      int newNextAlias = nextAlias;
+      Map<Object, Alias> newMap = map;
+
+      if(callReturn.equals(CallReturn.CALL)) {
+         for (final int i : methodCalled.objectArgIndexes()) {
+            Alias alias;
+            if(null == (alias = newMap.get(args[i + 1]))) {
+               // TODO[tim] do COW here
+               if(map == newMap) {
+                  newMap = new HashMap<>(map);
+               }
+               alias = new Alias(newNextAlias++);
+               newMap.put(args[i + 1], alias);
+            }
+            normalisedArgs[i + 1] = alias;
+         }
+      }
+      if(callReturn.equals(CallReturn.CALL) || methodCalled.returnIsObject()) {
+         Alias alias;
+         if(null == (alias = newMap.get(args[0]))) {
+            // TODO[tim] do COW here
+            if(map == newMap) {
+               newMap = new HashMap<>(map);
+            }
+            alias = new Alias(newNextAlias++);
+            newMap.put(args[0], alias);
+         }
+         normalisedArgs[0] = alias;
+      }
+
+      return new Trace(this, newMap, newNextAlias, methodCalled, callReturn, normalisedArgs);
    }
 
    public List<Trace> asList() {