public static F3Event wrap(F3VirtualMachine f3vm, Event evt) { if (evt == null) { return null; } if (evt instanceof AccessWatchpointEvent) { return new F3AccessWatchpointEvent(f3vm, (AccessWatchpointEvent)evt); } else if (evt instanceof BreakpointEvent) { return new F3BreakpointEvent(f3vm, (BreakpointEvent)evt); } else if (evt instanceof ClassPrepareEvent) { return new F3ClassPrepareEvent(f3vm, (ClassPrepareEvent)evt); } else if (evt instanceof ClassUnloadEvent) { return new F3ClassUnloadEvent(f3vm, (ClassUnloadEvent)evt); } else if (evt instanceof ExceptionEvent) { return new F3ExceptionEvent(f3vm, (ExceptionEvent)evt); } else if (evt instanceof MethodEntryEvent) { return new F3MethodEntryEvent(f3vm, (MethodEntryEvent)evt); } else if (evt instanceof MethodExitEvent) { return new F3MethodExitEvent(f3vm, (MethodExitEvent)evt); } else if (evt instanceof ModificationWatchpointEvent) { return new F3ModificationWatchpointEvent(f3vm, (ModificationWatchpointEvent)evt); } else if (evt instanceof MonitorContendedEnterEvent) { return new F3MonitorContendedEnterEvent(f3vm, (MonitorContendedEnterEvent)evt); } else if (evt instanceof MonitorContendedEnteredEvent) { return new F3MonitorContendedEnteredEvent(f3vm, (MonitorContendedEnteredEvent)evt); } else if (evt instanceof MonitorWaitEvent) { return new F3MonitorWaitEvent(f3vm, (MonitorWaitEvent)evt); } else if (evt instanceof MonitorWaitedEvent) { return new F3MonitorWaitedEvent(f3vm, (MonitorWaitedEvent)evt); } else if (evt instanceof StepEvent) { return new F3StepEvent(f3vm, (StepEvent)evt); } else if (evt instanceof ThreadDeathEvent) { return new F3ThreadDeathEvent(f3vm, (ThreadDeathEvent)evt); } else if (evt instanceof ThreadStartEvent) { return new F3ThreadStartEvent(f3vm, (ThreadStartEvent)evt); } else if (evt instanceof VMDeathEvent) { return new F3VMDeathEvent(f3vm, (VMDeathEvent)evt); } else if (evt instanceof VMDisconnectEvent) { return new F3VMDisconnectEvent(f3vm, (VMDisconnectEvent)evt); } else if (evt instanceof VMStartEvent) { return new F3VMStartEvent(f3vm, (VMStartEvent)evt); } else if (evt instanceof WatchpointEvent) { return new F3WatchpointEvent(f3vm, (WatchpointEvent)evt); } else if (evt instanceof LocatableEvent) { return new F3LocatableEvent(f3vm, (LocatableEvent)evt); } else { return new F3Event(f3vm, evt); } }
@Override public void jdiModificationWatchpoint(final ModificationWatchpointEvent event) { if (!override && !owner.isStarted()) { return; } try { delegate.handleFieldWrite(event); } catch (final Throwable e) { JiveDebugPlugin.log(e); } }
/** * Processes modification event for the given watch point by storing the new * values and caller information, and then by registered listeners * * @param event * the modification event. It provides information about the * current / new values and the affected instance, as well as the * caller (thread, method, etc.). * @param watchPoint * the watch point to which the event belongs. * @param target * the debug target in which the event occurred */ public void processWatchEvent(WatchpointEvent event, AbstractBreakpoint watchPoint, IJavaDebugTarget target) { if (!watchPoint.isTrackingActive()) { return; } long currTime = System.currentTimeMillis(); ObjectReference instance = event.object(); VariableHistory history = (VariableHistory)getHistory(instance, watchPoint, target); boolean notifyInstanceAdded = history.getAllValues().size() == 0; boolean eventModificationEvent = event instanceof ModificationWatchpointEvent; Value value = eventModificationEvent ? ((ModificationWatchpointEvent) event) .valueToBe() : ((WatchpointEvent)event).valueCurrent(); history.addValue(value, currTime, event.thread(), eventModificationEvent); for (IBreakpointListener listener : listeners) { if (notifyInstanceAdded) { listener.notifyInstanceAdded(watchPoint, instance, target); } listener.notifyBreakpointHit(watchPoint, instance, target); } }
public void processBreakpointEvent(ObjectReference instance, BreakpointEvent event, Breakpoint breakpoint, JDIDebugTarget target) { if (!breakpoint.isTrackingActive()) { return; } long currTime = System.currentTimeMillis(); LineBreakpointHistory history = (LineBreakpointHistory)getHistory(instance, breakpoint, target); boolean notifyInstanceAdded = history.getAllValues().size() == 0; boolean eventModificationEvent = event instanceof ModificationWatchpointEvent; history.addValue(currTime, event.thread()); for (IBreakpointListener listener : listeners) { if (notifyInstanceAdded) { listener.notifyInstanceAdded(breakpoint, instance, target); } listener.notifyBreakpointHit(breakpoint, instance, target); } }
/** * Checks the type of WatchpointEvent and validates type of field-being-watched * @param wpEvent */ private void checkWatchPointEvent(WatchpointEvent wpEvent) { if (wpEvent instanceof AccessWatchpointEvent) { Assert.assertTrue(((AccessWatchpointEvent)wpEvent).valueCurrent().type().name().equals("float")); Assert.assertTrue(wpEvent.getClass().toString().equals("class org.f3.jdi.event.F3AccessWatchpointEvent")); } else if (wpEvent instanceof ModificationWatchpointEvent) { Assert.assertTrue(((ModificationWatchpointEvent)wpEvent).valueCurrent().type().name().equals("float")); Assert.assertTrue(wpEvent.getClass().toString().equals("class org.f3.jdi.event.F3ModificationWatchpointEvent")); } }
@Override public boolean handleEvent(final Event event, final JDIDebugTarget target, final boolean suspendVote, final EventSet eventSet) { if (owner.isActive()) { owner.jdiHandler().jdiModificationWatchpoint((ModificationWatchpointEvent) event); } return true; }
/** * Field reads/writes are registered only for non-filtered classes. */ void handleFieldWrite(final ModificationWatchpointEvent event) throws IncompatibleThreadStateException, AbsentInformationException { final StackFrame frame = determineStackFrame(event); handleNewObject(frame, event.thread()); // dispatch a new object for the array value, if appropriate if (manager().generateArrayEvents() && event.valueToBe() instanceof ArrayReference) { // dispatch a new array event and the respective cell assignments handleNewArray((ArrayReference) event.valueToBe(), event.location(), frame); } dispatcher().dispatchFieldWriteEvent(event); }
/** * Notification of a field modification in the target VM. * * @param event * * @see <a href="">http://docs.oracle.com/javase/7/docs/jdk/api/jpda/jdi/index.html</a> */ @Override public void jdiModificationWatchpoint(final ModificationWatchpointEvent event) { final Method method = event.location().method(); if (method.isSynthetic() || method.isBridge() || method.name().contains("$")) { return; } final Field field = event.field(); if (field.isSynthetic() || field.name().contains("$")) { return; } // this.currentEvent = event; this.currentThread = event.thread(); // final long fId = registry.getFieldId(field); // final long oId = registry.getObjectId(event.object()); // final long vId = registry.getValueId(event.valueToBe()); // final long[] eventId = registry.encode(EventHandlerLite.KIND_FIELD_WRITE); // System.out.format(EventHandlerLite.ENCODED_FIELD_WRITE, eventId[0], eventId[1], oId, fId, vId); // System.out.print(registry.decode(eventId)); System.out.print(registry.decodeObject(oId)); System.out.print(registry.decodeField(fId)); System.out.println(registry.decodeValue(vId)); // this.currentEvent = null; this.currentThread = null; }
public static void main(String[] args) throws IOException, InterruptedException { //VirtualMachine vm = launchTarget(sb.toString()); VirtualMachine vm = launchTarget(CLASS_NAME); System.out.println("Vm launched"); // process events EventQueue eventQueue = vm.eventQueue(); // resume the vm Process process = vm.process(); // Copy target's output and error to our output and error. Thread outThread = new StreamRedirectThread("out reader", process.getInputStream()); Thread errThread = new StreamRedirectThread("error reader", process.getErrorStream()); errThread.start(); outThread.start(); boolean connected = true; int watched = 0; while (connected) { EventSet eventSet = eventQueue.remove(); for (Event event : eventSet) { System.out.println("FieldMonitor-main receives: "+event); if (event instanceof VMStartEvent) { addClassWatch(vm); } else if (event instanceof VMDeathEvent || event instanceof VMDisconnectEvent) { // exit connected = false; } else if (event instanceof ClassPrepareEvent) { // watch field on loaded class System.out.println("ClassPrepareEvent"); ClassPrepareEvent classPrepEvent = (ClassPrepareEvent) event; ReferenceType refType = classPrepEvent .referenceType(); addFieldWatch(vm, refType); } else if (event instanceof ModificationWatchpointEvent) { watched++; System.out.println("sleep for 500 ms"); Thread.sleep(500); ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event; System.out.println("old=" + modEvent.valueCurrent()); System.out.println("new=" + modEvent.valueToBe()); } } System.out.println("resume..."); eventSet.resume(); } // Shutdown begins when event thread terminates try { errThread.join(); // Make sure output is forwarded outThread.join(); } catch (InterruptedException exc) { // we don't interrupt } if (watched != 11) { // init + 10 modifications in TestPostFieldModification class throw new Error("Expected to receive 11 times ModificationWatchpointEvent, but got "+watched); } }
public F3ModificationWatchpointEvent(F3VirtualMachine f3vm, ModificationWatchpointEvent underlying) { super(f3vm, underlying); }
@Override protected ModificationWatchpointEvent underlying() { return (ModificationWatchpointEvent) super.underlying(); }
public VisitableModificationWatchpointEvent( ModificationWatchpointEvent event) { this.event = event; }
@Override public void visit(ModificationWatchpointEvent event) { }
@Override public void dispatchFieldWriteEvent(final ModificationWatchpointEvent event) { dispatchEvent(adapter().createFieldWriteEvent(event)); }
@Override public boolean handleEvent(Event event, JDIDebugTarget target, boolean suspendVote, EventSet eventSet) { /*if (event instanceof WatchpointEvent) System.out.println(event + " on " + FieldLVal.makeFieldLVal(((WatchpointEvent)event).object(), ((WatchpointEvent)event).field()).toString()); else if (event instanceof com.sun.jdi.event.ClassPrepareEvent) System.out.println("Prep " + ((com.sun.jdi.event.ClassPrepareEvent)event).referenceType().name()); else System.out.println(event);*/ synchronized (SideEffectHandler.this) { if (effectsMap == null) // We're not currently tracking side effects. return true; if (event instanceof WatchpointEvent) { WatchpointEvent watchEvent = (WatchpointEvent)event; //System.out.println(event + " on " + FieldLVal.makeFieldLVal(watchEvent.object(), watchEvent.field()).toString()); ObjectReference obj = watchEvent.object(); if (obj != null && obj.uniqueID() > maxID) { //System.out.println("Ignoring new object " + obj.toString()); return true; } if (watchEvent instanceof ModificationWatchpointEvent) { ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent)watchEvent; if (!modEvent.location().method().isStaticInitializer()) // If the field is modified in a static initializer, it must be the initialization of a static field of a newly-loaded class, which we don't want to revert. recordEffect(FieldLVal.makeFieldLVal(obj, modEvent.field()), modEvent.valueCurrent(), modEvent.valueToBe()); return true; } else if (watchEvent instanceof AccessWatchpointEvent) { AccessWatchpointEvent readEvent = (AccessWatchpointEvent)watchEvent; Value oldVal = readEvent.valueCurrent(); if (oldVal instanceof ArrayReference) { FieldLVal lval = FieldLVal.makeFieldLVal(obj, readEvent.field()); backupArray(lval, oldVal); if (canDisable && !changedFields.contains(lval) && Utils.incrementMap(accessCounts, this) >= 10) { // Disabling is slow, so we only do it for frequently-accessed fields. try { disabledWatchpoints.add(this); setEnabled(false); } catch (CoreException e) { throw new RuntimeException(e); } } } /*else System.out.println("Ignoring read on non-array Object");*/ return true; } } return super.handleEvent(event, target, suspendVote, eventSet); } }
/** * Visit a {@code ModificationWatchpointEvent}. * * @param event Event to visit */ void visit(ModificationWatchpointEvent event);
/** * Creates and dispatches a field write event. */ public void dispatchFieldWriteEvent(ModificationWatchpointEvent event);
/** * Notification of a field modification in the target VM. */ void jdiModificationWatchpoint(ModificationWatchpointEvent event);
