diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java index 93202bd..b1178ed 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/DebuggingControlAction.java @@ -34,7 +34,7 @@ import org.eclipse.ui.PartInitException; import org.ntlab.reverseDebugger.ObjectFlowAliases; import org.ntlab.reverseDebugger.OnlineTraceAnalyzer; -import org.ntlab.reverseDebugger.OnlineTraceAnalyzerCaller; +import org.ntlab.reverseDebugger.OnlineTraceAnalyzerCallTester; import com.sun.jdi.AbsentInformationException; import com.sun.jdi.BooleanValue; @@ -174,12 +174,14 @@ // st.countMethodExecutionTest(vm, thread); // �݌v�ύX�ɂ��ꎟ��͗p�̃R�[�h(�^�[�Q�b�g����VM��Ŏ��s����OnlineTraceAnalyzer�N���X�֘A�̃��\�b�h)���Ăяo�����߂̉��R�[�h - OnlineTraceAnalyzerCaller analyzerCaller = new OnlineTraceAnalyzerCaller(); - analyzerCaller.test1(vm, thread); + OnlineTraceAnalyzerCallTester analyzerCallTester = new OnlineTraceAnalyzerCallTester(); + analyzerCallTester.test1(vm, thread); } /** * �I�����C����͒���traceCollector��TraceJSON#getObjectFlow()���Ăяo�����̃R�[�h + * 2018/9/16�NjL �����炩��objectFlow���Ăяo���K�v�͂Ȃ��Ȃ������߂����s�v�ȃR�[�h�ƍl���Ă悢 + * �݌v�ύX���s�������ߌĂяo���ƃG���[���������邩������Ȃ�(�����s�v�ȃR�[�h�̂��߃e�X�g���Ă��Ȃ�) * @param vm * @param thread * @param threadInstance @@ -196,8 +198,10 @@ int statementsSize = ((IntegerValue)callInstanceMethod(vm, thread, methodName, (ObjectReference)statements)).value(); // �f�o�b�K�Ŏ~�߂Ă���n�_�ɊY�����郁�\�b�h���s����, �X�^�[�g�ƂȂ���̃G�C���A�X�̃��X�g���擾���ĕ\������ - String packageName = "org.ntlab.traceCollector.tracer.trace"; - String className = "TraceJSON"; +// String packageName = "org.ntlab.traceCollector.tracer.trace"; +// String className = "TraceJSON"; + String packageName = "org.ntlab.reverseDebugger"; + String className = "OnlineTraceAnalyzer"; methodName = "findAllStartAlias"; Value startAliasList = callStaticMethod(vm, thread, packageName, className, methodName, methodExecution); methodName = "size"; diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/SpeedTester.java b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/SpeedTester.java index 4c63c6b..657938f 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/SpeedTester.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/debuggingControl/SpeedTester.java @@ -14,6 +14,7 @@ public class SpeedTester { private static final String TRACE = "org.ntlab.traceCollector.tracer.trace"; + private static final String ANALYZER = "org.ntlab.reverseDebugger"; public void countMethodExecutionTest(VirtualMachine vm, ThreadReference thread) { MethodCaller mc = new MethodCaller(vm, thread); @@ -73,7 +74,9 @@ throws InvalidTypeException, ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { VirtualMachine vm = mc.getVm(); String methodName = "countMethodExecutionInTraceCollector"; - return ((IntegerValue)mc.callStaticMethod(TRACE, "TraceJSON", methodName, mc.getObj(), +// return ((IntegerValue)mc.callStaticMethod(TRACE, "TraceJSON", methodName, mc.getObj(), +// vm.mirrorOf(targetSignture), vm.mirrorOf(count), vm.mirrorOf(indent))).value(); + return ((IntegerValue)mc.callStaticMethod(ANALYZER, "OnlineTraceAnalyzer", methodName, mc.getObj(), vm.mirrorOf(targetSignture), vm.mirrorOf(count), vm.mirrorOf(indent))).value(); } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/Alias.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/Alias.java new file mode 100644 index 0000000..b50e6a9 --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/Alias.java @@ -0,0 +1,215 @@ +package org.ntlab.reverseDebugger; + +import java.util.ArrayList; + +import org.ntlab.traceCollector.tracer.trace.ArrayAccess; +import org.ntlab.traceCollector.tracer.trace.ArrayCreate; +import org.ntlab.traceCollector.tracer.trace.ArrayUpdate; +import org.ntlab.traceCollector.tracer.trace.FieldAccess; +import org.ntlab.traceCollector.tracer.trace.FieldUpdate; +import org.ntlab.traceCollector.tracer.trace.MethodExecution; +import org.ntlab.traceCollector.tracer.trace.MethodInvocation; +import org.ntlab.traceCollector.tracer.trace.ObjectReference; +import org.ntlab.traceCollector.tracer.trace.Statement; +import org.ntlab.traceCollector.tracer.trace.Trace; +import org.ntlab.traceCollector.tracer.trace.TracePoint; + +/** + * �I�u�W�F�N�g�̎Q�Ə��(�G�C���A�X)��\���N���X + * @author Isitani + * + */ +public class Alias { + private String objectId; + private TracePoint occurrencePoint; // ���Y�I�u�W�F�N�g�̎Q�Ƃ��s���Ă�����s�ӏ��ɑΉ�����TracePoint + /** + * ���Y�I�u�W�F�N�g�̎Q�Ƃ�TracePoint�ɂ����Ăǂ��Ɍ���Ă��邩��\��
+ * 0 �t�B�[���h�A�N�Z�X���̃R���e�i �������� ���\�b�h�Ăяo�����̃��V�[�o
+ * 1, 2, 3 �c�c n �t�B�[���h�A�N�Z�X���̃t�B�[���h(1) �������� ���\�b�h�Ăяo������n�Ԗڂ̎����� (1���珇�Ԃ�)
+ * -1 ���\�b�h�Ăяo�����̖߂�l
+ *
+ * ��1: d = a.m(b, c);
+ *
+ * ��1�̎��s���ɂ�����, a�̓��\�b�h�Ăяo���̃��V�[�o�Ȃ̂�0, b�̓��\�b�h�Ăяo����1�Ԗڂ̎������Ȃ̂�1,
+ * c�̓��\�b�h�Ăяo����2�Ԗڂ̎������Ȃ̂�2, a.m(b, c)�̖߂�l��-1 �ƂȂ�.
+ *
+ * ��2: d = a.f;
+ * ��2�̎��s���ɂ�����, a�̓t�B�[���h�̃R���e�i�Ȃ̂�0, b�̓t�B�[���h�Ȃ̂�1 �ƂȂ�. + * + */ + private int occurrenceExp; + public static final int OCCURRENCE_EXP_CONTAINER = 0; + public static final int OCCURRENCE_EXP_RECEIVER = 0; + public static final int OCCURRENCE_EXP_FIELD = 1; + public static final int OCCURRENCE_EXP_ARRAY = 1; + public static final int OCCURRENCE_EXP_FIRST_ARG = 1; + public static final int OCCURRENCE_EXP_RETURN = -1; + + public Alias(String objectId, TracePoint occurrencePoint, int occurrenceExp) { + this.objectId = objectId; + this.occurrencePoint = occurrencePoint; + this.occurrenceExp = occurrenceExp; + } + + public String getObjectId() { + return objectId; + } + + public TracePoint getOccurrencePoint() { + return occurrencePoint; + } + + public int getOccurrenceExp() { + return occurrenceExp; + } + + public MethodExecution getMethodExecution() { + return occurrencePoint.getMethodExecution(); + } + + public String getMethodExecutionClassName() { + MethodExecution methodExecution = occurrencePoint.getMethodExecution(); + return Trace.getDeclaringType(methodExecution.getSignature(), methodExecution.isConstructor()); + } + + public String getMethodSignature() { + return occurrencePoint.getMethodExecution().getCallerSideSignature(); + } + + public int getLineNo() { + Statement statement = occurrencePoint.getStatement(); + return statement.getLineNo(); + } + + public String getStatementType() { + Statement statement = occurrencePoint.getStatement(); + String statementType = ""; + if (statement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)statement; + statementType = "FieldAccess"; + } else if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + statementType = "FieldUpdate"; + } else if (statement instanceof ArrayAccess) { + ArrayAccess aa = (ArrayAccess)statement; + statementType = "ArrayAccess"; + } else if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + statementType = "ArrayUpdate"; + } else if (statement instanceof ArrayCreate) { + ArrayCreate ac = (ArrayCreate)statement; + statementType = "ArrayCreate"; + } else if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + statementType = "MethodInvocation"; + } + return statementType; + } + + public String getStatementSignature() { + Statement statement = occurrencePoint.getStatement(); + String statementSignature = ""; + if (statement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)statement; + statementSignature = fa.getFieldName(); + } else if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + statementSignature = fu.getFieldName(); + } else if (statement instanceof ArrayAccess) { + ArrayAccess aa = (ArrayAccess)statement; + statementSignature = aa.getArrayClassName() + "[" + aa.getIndex() + "]"; + } else if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + statementSignature = au.getArrayClassName() + "[" + au.getIndex() + "]"; + } else if (statement instanceof ArrayCreate) { + ArrayCreate ac = (ArrayCreate)statement; + statementSignature = ac.getArrayClassName(); + } else if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + statementSignature = me.getCallerSideSignature(); + } + return statementSignature; + } + + public String getClassName() { + Statement statement = occurrencePoint.getStatement(); + String className = ""; + if (statement instanceof FieldAccess) { + if (occurrenceExp == OCCURRENCE_EXP_CONTAINER) { + className = ((FieldAccess) statement).getContainerClassName(); + } else if (occurrenceExp == OCCURRENCE_EXP_FIELD) { + className = ((FieldAccess) statement).getValueClassName(); + } + } else if (statement instanceof FieldUpdate) { + if (occurrenceExp == OCCURRENCE_EXP_CONTAINER) { + className = ((FieldUpdate) statement).getContainerClassName(); + } else if (occurrenceExp == OCCURRENCE_EXP_FIELD) { + className = ((FieldUpdate) statement).getValueClassName(); + } + } else if (statement instanceof ArrayAccess) { + className = ((ArrayAccess) statement).getValueClassName(); + } else if (statement instanceof ArrayUpdate) { + className = ((ArrayUpdate) statement).getValueClassName(); + } else if (statement instanceof ArrayCreate) { + className = ((ArrayCreate) statement).getArrayClassName(); + } else if (statement instanceof MethodInvocation) { + MethodExecution me = ((MethodInvocation)statement).getCalledMethodExecution(); + if (occurrenceExp == OCCURRENCE_EXP_RETURN) { + className = me.getReturnValue().getActualType(); + } else if (occurrenceExp == OCCURRENCE_EXP_RECEIVER) { + className = me.getThisClassName(); + } else { + int index = occurrenceExp - OCCURRENCE_EXP_FIRST_ARG; + ArrayList args = me.getArguments(); + if (index >= 0 && index < args.size()) { + className = me.getArguments().get(index).getActualType(); + } + } + } + return className; + } + + public String getOccurrenceText() { + String statementType = getStatementType(); + switch (statementType) { + case "FieldAccess": + case "FieldUpdate": + return (occurrenceExp == 0) ? "container" : "field"; + case "ArrayAccess": + case "ArrayUpdate": + return (occurrenceExp == 0) ? "arrayObject" : "arrayValue"; + case "ArrayCreate": + return "return"; + case "MethodInvocation": + if (occurrenceExp <= 0) { + return (occurrenceExp == 0) ? "receiver" : "return"; + } + final String[] ORDER_TEXT = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th", "th", "th", "th", "th"}; // 0-13�ɑΉ� + final String ARG = " arg"; + if (occurrenceExp % 100 >= ORDER_TEXT.length) { + return occurrenceExp + ORDER_TEXT[occurrenceExp % 10] + ARG; // ��2����14�ȏ�Ȃ�, ��1���̐����ɑΉ������� + } else if (occurrenceExp % 100 >= 0) { + return occurrenceExp + ORDER_TEXT[occurrenceExp % 100] + ARG; // ��2����0�ȏ�13�ȉ��Ȃ�, ��2���̐����ɑΉ������� + } + } + return String.valueOf(occurrenceExp); + } + +// @Override +// public String toString() { +// Statement statement = occurrencePoint.getStatement(); +// String className = getClassName(); +// String methodSignature = getMethodSignature(); +// String statementType = getStatementType(); +// String statementSigunarure = getStatementSignature(); +// String indent = " "; +// StringBuilder str = new StringBuilder(); +// str.append("objId: " + objectId + " (class = " + className + ")" + "\n"); +// str.append("tp: " + occurrencePoint + "\n"); +// str.append(indent + "signature: " + methodSignature + "\n"); +// str.append(indent + "lineNo: " + statement.getLineNo() + "\n"); +// str.append(indent + "statementType: " + statementType + " -> " + statementSigunarure + "\n"); +// str.append("occurrenceExp: " + occurrenceExp + "\n"); +// return str.toString(); +// } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ObjectFlowAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ObjectFlowAliases.java index c52babc..df84f3c 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ObjectFlowAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ObjectFlowAliases.java @@ -17,6 +17,7 @@ public class ObjectFlowAliases { private List> objectFlowAliases = new ArrayList<>(); private static final String TRACE = "org.ntlab.traceCollector.tracer.trace"; + private static final String ANALYZER = "org.ntlab.reverseDebugger"; public void reset() { objectFlowAliases.clear(); @@ -54,7 +55,8 @@ objectFlowAliases.clear(); try { // �I�������G�C���A�X���N�_�ɃI�u�W�F�N�g�t���[���Ăяo���Č��ʂ����X�g�Ŏ󂯎�� - ObjectReference aliasListsReference = (ObjectReference)seedAlias.callStaticMethod(TRACE, "TraceJSON", "getObjectFlow", seedAlias.getObj()); +// ObjectReference aliasListsReference = (ObjectReference)seedAlias.callStaticMethod(TRACE, "TraceJSON", "getObjectFlow", seedAlias.getObj()); + ObjectReference aliasListsReference = (ObjectReference)seedAlias.callStaticMethod(ANALYZER, "OnlineTraceAnalyzer", "getObjectFlow", seedAlias.getObj()); // �擾�������X�g�̒��g�����[�v�ʼn񂵂Ȃ�����o��, �Ǘ��p�̃��X�g�ɋl�ߒ��� int aliasListsSize = ((IntegerValue)mc.setObj(aliasListsReference).callInstanceMethod("size")).value(); diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzer.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzer.java index 7efdeb1..935ab76 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzer.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzer.java @@ -1,9 +1,238 @@ package org.ntlab.reverseDebugger; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +// import org.ntlab.traceCollector.tracer.trace.Alias; +import org.ntlab.traceCollector.tracer.trace.ArrayAccess; +import org.ntlab.traceCollector.tracer.trace.ArrayCreate; +import org.ntlab.traceCollector.tracer.trace.ArrayUpdate; +import org.ntlab.traceCollector.tracer.trace.FieldAccess; +import org.ntlab.traceCollector.tracer.trace.FieldUpdate; +import org.ntlab.traceCollector.tracer.trace.MethodExecution; +import org.ntlab.traceCollector.tracer.trace.MethodInvocation; +import org.ntlab.traceCollector.tracer.trace.ObjectReference; +import org.ntlab.traceCollector.tracer.trace.Statement; +import org.ntlab.traceCollector.tracer.trace.TraceJSON; +import org.ntlab.traceCollector.tracer.trace.TracePoint; + public class OnlineTraceAnalyzer { public void test2() { System.out.println("OnlineTraceAnalyzer#test2()���Ă΂ꂽ��!"); + TraceJSON.test(); System.out.println("OnlineTraceAnalyzer#test2()���甲�����!"); } + + public static ArrayList findAllStartAlias(MethodExecution me) { + System.out.println("OnlineTraceAnalyzer#findAllStartAlias(MethodExecution)���Ă΂ꂽ��!"); + ArrayList startAliasList = new ArrayList<>(); + List statements = me.getStatements(); + String[] primitives = {"byte", "short", "int", "long", "float", "double", "char", "boolean"}; + List primitiveList = Arrays.asList(primitives); + for (int i = 0; i < statements.size(); i++) { + TracePoint tp = me.getTracePoint(i); + Statement statement = statements.get(i); + if (statement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)statement; + String objId = fa.getContainerObjId(); + if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getContainerClassName()))) { + startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER)); + } + objId = fa.getValueObjId(); + if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getValueClassName()))) { + startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD)); + } + } else if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + String objId = fu.getContainerObjId(); + if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getContainerClassName()))) { + startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER)); + } + objId = fu.getValueObjId(); + if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getValueClassName()))) { + startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD)); + } + } else if (statement instanceof ArrayAccess) { + ArrayAccess aa = (ArrayAccess)statement; + String valueObjId = aa.getValueObjectId(); + if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(aa.getValueClassName()))) { + startAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY)); + } + } else if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + String valueObjId = au.getValueObjectId(); + if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(au.getValueClassName()))) { + startAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY)); + } + } else if (statement instanceof ArrayCreate) { + ArrayCreate ac = (ArrayCreate)statement; + String arrayObjId = ac.getArrayObjectId(); + if (arrayObjId != null && !(arrayObjId.equals("0")) && !(primitiveList.contains(ac.getArrayClassName()))) { + startAliasList.add(new Alias(arrayObjId, tp, Alias.OCCURRENCE_EXP_RETURN)); + } + } else if (statement instanceof MethodInvocation) { + MethodExecution calledMe = ((MethodInvocation)statement).getCalledMethodExecution(); + String thisObjId = calledMe.getThisObjId(); + if (thisObjId != null && !(thisObjId.equals("0"))) { + startAliasList.add(new Alias(thisObjId, tp, Alias.OCCURRENCE_EXP_RECEIVER)); + } + List args = calledMe.getArguments(); + for (int j = 0; j < args.size(); j++) { + ObjectReference arg = args.get(j); + String argValueId = arg.getId(); + if (argValueId != null && !(argValueId.equals("0")) && !(primitiveList.contains(arg.getActualType()))) { + startAliasList.add(new Alias(argValueId, tp, (j + Alias.OCCURRENCE_EXP_FIRST_ARG))); + } + } + ObjectReference returnValue = calledMe.getReturnValue(); + if (returnValue != null) { + String returnValueId = returnValue.getId(); + if (returnValueId != null && !(returnValueId.equals("0") && !(primitiveList.contains(returnValue.getActualType())))) { + startAliasList.add(new Alias(returnValueId, tp, Alias.OCCURRENCE_EXP_RETURN)); + } + } + } + } + for (Alias startAlias : startAliasList) { + System.out.println(startAlias); + } + return startAliasList; + } + + private static TracePoint getRecentlyFieldUpdate(TracePoint tp) { + System.out.println("OnlineTraceAnalyzer#getRecentlyFieldUpdate(TracePoint)���Ă΂ꂽ��!"); + Statement statement = tp.getStatement(); + if (statement instanceof FieldAccess) { + FieldAccess fa = (FieldAccess)statement; + return TraceJSON.getFieldUpdateTracePoint(fa.getContainerObjId(), fa.getFieldName(), tp); + } + return null; + } + + private static TracePoint getRecentlyArrayUpdate(TracePoint tp) { + System.out.println("OnlineTraceAnalyzer#getRecentlyArrayUpdate(TracePoint)���Ă΂ꂽ��!"); + Statement statement = tp.getStatement(); + if (statement instanceof ArrayAccess) { + ArrayAccess aa = (ArrayAccess)statement; + return TraceJSON.getArrayUpdateTracePoint(aa.getArrayObjectId(), aa.getIndex(), tp); + } + return null; + } + + public static ArrayList> getObjectFlow(Alias startAlias) { + System.out.println("OnlineTraceAnalyzer#getObjectFlow(Alias)���Ă΂ꂽ��!"); + ArrayList> aliasLists = new ArrayList<>(); + ArrayList aliasList = new ArrayList<>(); + aliasLists.add(aliasList); +// aliasList.add(alias); + String objId = startAlias.getObjectId(); + TracePoint tp = startAlias.getOccurrencePoint().duplicate(); + ArrayList> resultLists = getObjectFlow(aliasLists, objId, tp, 0); +// for (int i = 0; i < resultLists.size(); i++) { +// ArrayList resultList = resultLists.get(i); +// System.out.println("---------------------------------------------------------"); // �m�F�p +// for (Alias alias : resultList) System.out.println(alias); // �m�F�p +// int lastAliasOccurrenceEXP = resultList.get(resultList.size() - 1).getOccurrenceExp(); +// if (lastAliasOccurrenceEXP != Alias.OCCURRENCE_EXP_RETURN) { +// resultLists.remove(resultList); // �����̃G�C���A�X���z�񐶐���R���X�g���N�^�Ăяo���ł͂Ȃ����X�g���폜���� +// } +// } + for (List resultList : resultLists) { + for (Alias resultAlias : resultList) { + System.out.println(resultAlias); + } + } + return resultLists; + } + + private static ArrayList> getObjectFlow(ArrayList> aliasLists, + String objId, TracePoint tp, int side) { + System.out.println("OnlineTraceAnalyzer#getObjectFlow(ArrayList, String, TracePoint, int)���Ă΂ꂽ��!"); + ArrayList aliasList = aliasLists.get(aliasLists.size() - 1); // ����getObjectFlow���\�b�h���s���Ō��‚������G�C���A�X�����Ă������X�g + do { + Statement statement = tp.getStatement(); + if (statement instanceof FieldAccess) { + // �t�B�[���h�Q�Ƃ̏ꍇ + FieldAccess fa = (FieldAccess)statement; + if (fa.getValueObjId().equals(objId)) { + // ���Y�n�_�ł̃G�C���A�X�����X�g�ɒlj��������, �t�B�[���h�ŏI�X�V�ɔ�ԃp�^�[���Ƃ��̂܂ܑk��p�^�[���Ƃŕ��� + aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_FIELD)); + aliasList = new ArrayList<>(aliasList); // ���X�g���̂��f�B�[�v�R�s�[���Ă���(�t�B�[���h�ŏI�X�V�ɔ�ԍċA�����I�����, ���̂܂ܑk��p�^�[���ŗp����) + TracePoint fieldUpdateTp = getRecentlyFieldUpdate(tp); + aliasLists = getObjectFlow(aliasLists, objId, fieldUpdateTp, 0); + aliasLists.add(aliasList); // �ċA�����ɓ���O�Ƀf�B�[�v�R�s�[���Ă������X�g���Ō���ɒlj� (�ȍ~�̑k��ɂ���Č��‚����G�C���A�X�͂��̃��X�g�ɓ������) + } + } else if (statement instanceof ArrayAccess) { + // �z��v�f�Q�Ƃ̏ꍇ + ArrayAccess aa = (ArrayAccess)statement; + if (aa.getValueObjectId().equals(objId)) { + aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_ARRAY)); + aliasList = new ArrayList<>(aliasList); + TracePoint arrayUpdateTp = getRecentlyArrayUpdate(tp); + aliasLists = getObjectFlow(aliasLists, objId, arrayUpdateTp, 0); + aliasLists.add(aliasList); + } + } else if (statement instanceof ArrayCreate) { + // �z�񐶐��̏ꍇ + ArrayCreate ac = (ArrayCreate)statement; + if (ac.getArrayObjectId().equals(objId)) { + aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN)); // �z�񐶐��� new �^��[] �̖߂�l + return aliasLists; // �z�񐶐��ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂� + } + } else if (statement instanceof MethodInvocation) { + // ���\�b�h�Ăяo���̏ꍇ + MethodExecution calledMethodExecution = ((MethodInvocation)statement).getCalledMethodExecution(); + ObjectReference returnValue = calledMethodExecution.getReturnValue(); + if (returnValue.getId().equals(objId)) { + // �߂�l�ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ + aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN)); + if (calledMethodExecution.isConstructor()) { + return aliasLists; // �R���X�g���N�^�Ăяo���ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂� + } + TracePoint exitTp = calledMethodExecution.getExitPoint(); // �Ăяo�����\�b�h���s�̍ŏI�X�e�[�g�����g���w��tp���擾 + aliasLists = getObjectFlow(aliasLists, objId, exitTp, side + 1); // �Ăяo����̃��\�b�h���s�ɐ��� + aliasList = aliasLists.get(aliasLists.size() - 1); + } + } + } while (tp.stepBackOver()); // �Ăяo�����ɖ߂邩����ȏ�H��Ȃ��Ȃ�܂Ń��[�v + if (!tp.isValid()) { + return aliasLists; // ����ȏチ�\�b�h���s��k��Ȃ��ꍇ(main���\�b�h�̂���ɑO�Ȃ�)�͂��̎��_�ŏI�� + } + // --- ���̎��_�� tracePoint�� �Ăяo�������w���Ă��� (���O�܂ők���Ă������\�b�h���s�ɂ‚��Ẵ��\�b�h�Ăяo�����w���Ă���) --- + MethodExecution calledMethodExecution = ((MethodInvocation)tp.getStatement()).getCalledMethodExecution(); + ArrayList args = calledMethodExecution.getArguments(); + for (int i = 0; i < args.size(); i++) { + if (args.get(i).getId().equals(objId)) { + // ���\�b�h�Ăяo���̎������ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ + aliasList.add(new Alias(objId, tp.duplicate(), (i + Alias.OCCURRENCE_EXP_FIRST_ARG))); + if (side == 0) { + // �T���J�n���\�b�h���s�܂��̓t�B�[���h��z��v�f�̍ŏI�X�V�T���Ŕ�񂾐�̃��\�b�h���s����, �X�^�b�N�g���[�X�ł��ǂ��S���\�b�h���s�̏ꍇ + TracePoint previousTp = tp.duplicate(); + previousTp.stepBackOver(); + aliasLists = getObjectFlow(aliasLists, objId, previousTp, 0); // �Ăяo�����̃��\�b�h���s�ɖ߂� + } + } + } + return aliasLists; + } + + public static int countMethodExecutionInTraceCollector(List methodExecutions, String targetSignature, int count, String indent) { + System.out.println("OnlineTraceAnalyzer#countMethodExecutionInTraceCollector(List, String, int, String)���Ă΂ꂽ��!"); + if (methodExecutions == null || methodExecutions.isEmpty()) { + return count; + } + for (int i = 0; i < methodExecutions.size(); i++) { + MethodExecution me = methodExecutions.get(i); + String signature = me.getSignature(); +// System.out.println(indent + signature); + if (targetSignature.equals(signature)) { + count++; + } + List children = me.getChildren(); + count = countMethodExecutionInTraceCollector(children, targetSignature, count, indent + "--------"); + } + return count; + } } diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCallTester.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCallTester.java new file mode 100644 index 0000000..8662ced --- /dev/null +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCallTester.java @@ -0,0 +1,31 @@ +package org.ntlab.reverseDebugger; + +import org.ntlab.debuggingControl.MethodCaller; + +import com.sun.jdi.ClassNotLoadedException; +import com.sun.jdi.IncompatibleThreadStateException; +import com.sun.jdi.InvalidTypeException; +import com.sun.jdi.InvocationException; +import com.sun.jdi.ThreadReference; +import com.sun.jdi.VirtualMachine; + +/** + * �^�[�Q�b�g����VM��ɂ��邱�̃v���W�F�N�g���̃N���X�̃��\�b�h(���OnlineTraceAnalyzer�N���X�Ƃ��̃��\�b�h)�� + * reverseDebugger����VM��ɂ��邱�̃v���W�F�N�g���̃N���X�̃��\�b�h���s����Ăяo���e�X�g�p�N���X + * @author student + * + */ +public class OnlineTraceAnalyzerCallTester { + + public void test1(VirtualMachine vm, ThreadReference thread) { + System.out.println("OnlineTraceAnalyzerCaller#test1()���Ă΂ꂽ��!"); + MethodCaller mc = new MethodCaller(vm, thread); + try { + mc.callStaticMethod("org.ntlab.reverseDebugger", "OnlineTraceAnalyzer", "test2"); + } catch (InvalidTypeException | ClassNotLoadedException + | InvocationException | IncompatibleThreadStateException e) { + e.printStackTrace(); + } + System.out.println("OnlineTraceAnalyzerCaller#test1()���甲�����!"); + } +} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCaller.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCaller.java deleted file mode 100644 index bd23aff..0000000 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/OnlineTraceAnalyzerCaller.java +++ /dev/null @@ -1,31 +0,0 @@ -package org.ntlab.reverseDebugger; - -import org.ntlab.debuggingControl.MethodCaller; - -import com.sun.jdi.ClassNotLoadedException; -import com.sun.jdi.IncompatibleThreadStateException; -import com.sun.jdi.InvalidTypeException; -import com.sun.jdi.InvocationException; -import com.sun.jdi.ThreadReference; -import com.sun.jdi.VirtualMachine; - -/** - * �^�[�Q�b�g����VM��ɂ��邱�̃v���W�F�N�g���̃N���X�̃��\�b�h(���OnlineTraceAnalyzer�N���X�Ƃ��̃��\�b�h)�� - * reverseDebugger����VM��ɂ��邱�̃v���W�F�N�g���̃N���X�̃��\�b�h���s����Ăяo�����߂̉˂����ƂȂ�N���X - * @author student - * - */ -public class OnlineTraceAnalyzerCaller { - - public void test1(VirtualMachine vm, ThreadReference thread) { - System.out.println("OnlineTraceAnalyzerCaller#test1()���Ă΂ꂽ��!"); - MethodCaller mc = new MethodCaller(vm, thread); - try { - mc.callStaticMethod("org.ntlab.reverseDebugger", "OnlineTraceAnalyzer", "test2"); - } catch (InvalidTypeException | ClassNotLoadedException - | InvocationException | IncompatibleThreadStateException e) { - e.printStackTrace(); - } - System.out.println("OnlineTraceAnalyzerCaller#test1()���甲�����!"); - } -} diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ReverseDebuggerLaunchConfiguration.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ReverseDebuggerLaunchConfiguration.java index b1814ac..60cd0fe 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ReverseDebuggerLaunchConfiguration.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/ReverseDebuggerLaunchConfiguration.java @@ -6,18 +6,13 @@ import org.ntlab.traceCollector.IAdditionalLaunchConfiguration; public class ReverseDebuggerLaunchConfiguration implements IAdditionalLaunchConfiguration { - public static final String TEST_PATH = "org/ntlab/reverseDebugger/ReverseDebuggerLaunchConfiguration.class"; public static final String ANALYZER_PATH = "org/ntlab/reverseDebugger/OnlineTraceAnalyzer.class"; @Override public String[] getAdditionalClasspath() { try { -// String tracerClassPath = FileLocator.resolve(this.getClass().getClassLoader().getResource(TEST_PATH)).getPath(); String tracerClassPath = FileLocator.resolve(this.getClass().getClassLoader().getResource(ANALYZER_PATH)).getPath(); - System.out.println(tracerClassPath); -// String classPath = tracerClassPath.substring(1, tracerClassPath.length() - TEST_PATH.length()); String classPath = tracerClassPath.substring(1, tracerClassPath.length() - ANALYZER_PATH.length()); - System.out.println(classPath); return new String[]{classPath}; } catch (IOException e) { e.printStackTrace(); diff --git a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/SeedAliases.java b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/SeedAliases.java index 35b7e57..6157dfb 100644 --- a/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/SeedAliases.java +++ b/org.ntlab.reverseDebugger/src/org/ntlab/reverseDebugger/SeedAliases.java @@ -33,7 +33,8 @@ public class SeedAliases { private MethodCaller debuggerStopMethodExecution = null; private List seedAliases = new ArrayList<>(); - private final String TRACER = "org.ntlab.traceCollector.tracer.trace"; + private static final String TRACER = "org.ntlab.traceCollector.tracer.trace"; + private static final String ANALYZER = "org.ntlab.reverseDebugger"; public SeedAliases() { initSeedAliases(); @@ -145,7 +146,8 @@ ClassNotLoadedException, InvocationException, IncompatibleThreadStateException { MethodCaller mc = new MethodCaller(vm, thread); seedAliases.clear(); - ObjectReference seedAliasList = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "findAllStartAlias", methodExecution); +// ObjectReference seedAliasList = (ObjectReference)mc.callStaticMethod(TRACER, "TraceJSON", "findAllStartAlias", methodExecution); + ObjectReference seedAliasList = (ObjectReference)mc.callStaticMethod(ANALYZER, "OnlineTraceAnalyzer", "findAllStartAlias", methodExecution); int seedAliasListSize = ((IntegerValue)mc.setObj(seedAliasList).callInstanceMethod("size")).value(); for (int i = 0; i < seedAliasListSize; i++) { ObjectReference seedAlias = (ObjectReference)mc.setObj(seedAliasList).callInstanceMethod("get", vm.mirrorOf(i));