| /* |
| * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package vm.mlvm.share.jdi; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import nsk.share.jdi.Binder; |
| import nsk.share.jdi.Debugee; |
| import vm.mlvm.share.Env; |
| import vm.mlvm.share.MlvmTest; |
| import vm.mlvm.share.jpda.StratumUtils; |
| import vm.share.options.Option; |
| |
| import com.sun.jdi.AbsentInformationException; |
| import com.sun.jdi.IncompatibleThreadStateException; |
| import com.sun.jdi.LocalVariable; |
| import com.sun.jdi.Location; |
| import com.sun.jdi.Method; |
| import com.sun.jdi.ReferenceType; |
| import com.sun.jdi.StackFrame; |
| import com.sun.jdi.ThreadReference; |
| import com.sun.jdi.Value; |
| import com.sun.jdi.VirtualMachine; |
| import com.sun.jdi.event.BreakpointEvent; |
| import com.sun.jdi.event.ClassPrepareEvent; |
| import com.sun.jdi.event.Event; |
| import com.sun.jdi.event.EventIterator; |
| import com.sun.jdi.event.EventQueue; |
| import com.sun.jdi.event.EventSet; |
| import com.sun.jdi.event.StepEvent; |
| import com.sun.jdi.event.VMDisconnectEvent; |
| import com.sun.jdi.request.BreakpointRequest; |
| import com.sun.jdi.request.ClassPrepareRequest; |
| import com.sun.jdi.request.EventRequest; |
| import com.sun.jdi.request.EventRequestManager; |
| import com.sun.jdi.request.StepRequest; |
| |
| /** |
| * Option value syntax: |
| * |
| * <pre> |
| * breakpoints := breakpoint breakpoints? |
| * breakpoint := implicitOpt? methodName options? stratum? subBreakpoints? |
| * |
| * implicitOpt := "~" |
| * |
| * methodName := STRING |
| * methodName := className "." STRING |
| * className := STRING |
| * |
| * options := |
| * options := ":" option options |
| * option := lineOption | requiredHitsOption | stepsToTraceOption |
| * lineOption := "L" INTEGER // Line number |
| * requiredHitsOption := "H" INTEGER | "H*" // Required number of hits |
| * stepsToTraceOption := "S" INTEGER // Steps to trace when this breakpoint is hit |
| * |
| * stratum := "/" stratumName "=" stratumSourceName ":" stratumSourceLine // Also check stratum information when this breakpoint is hit |
| * stratumName := STRING |
| * stratumSourceName := STRING |
| * stratumSourceLine := INTEGER |
| * |
| * subBreakpoints := "=>(" breakpoints ")" // subBreakpoints are only set when its main breakpoint is hit. |
| * </pre> |
| */ |
| |
| public abstract class JDIBreakpointTest extends MlvmTest { |
| |
| @Option(name="debugger.debuggeeClass", default_value="", description="Debuggee class name") |
| public String _debuggeeClass = "DEBUGGEE-CLASS-NOT-DEFINED"; |
| |
| @Option(name="debugger.terminateWhenAllBPHit", default_value="", description="Hang up in specified point") |
| public boolean _terminateWhenAllBreakpointsHit; |
| |
| protected static int _jdiEventWaitTimeout = 3000; |
| |
| private static final int MAX_EVENT_COUNT = 50000; |
| |
| private static final int SHORT_STACK_TRACE_FRAMES_NUM = 2; |
| |
| protected VirtualMachine _vm; |
| protected EventQueue _eventQueue; |
| |
| private abstract static class BreakpointListIterator { |
| List<BreakpointInfo> _biList; |
| |
| public BreakpointListIterator(List<BreakpointInfo> biList) { |
| _biList = biList; |
| } |
| |
| public Object go() throws Throwable { |
| return iterate(_biList); |
| } |
| |
| public Object iterate(List<BreakpointInfo> biList) throws Throwable { |
| for ( BreakpointInfo bi : biList ) { |
| Object result = apply(bi); |
| if ( result != null ) |
| return result; |
| |
| if ( bi.subBreakpoints != null ) { |
| result = iterate(bi.subBreakpoints); |
| if ( result != null ) |
| return result; |
| } |
| } |
| |
| return null; |
| } |
| |
| protected abstract Object apply(BreakpointInfo bi) throws Throwable; |
| } |
| |
| protected String getDebuggeeClassName() throws Throwable { |
| String debuggeeClass = _debuggeeClass.trim(); |
| if ( debuggeeClass == null || debuggeeClass.isEmpty() ) |
| throw new Exception("Please specify debuggee class name"); |
| |
| return debuggeeClass; |
| } |
| |
| protected abstract List<BreakpointInfo> getBreakpoints(String debuggeeClassName); |
| |
| protected boolean getTerminateWhenAllBPHit() { |
| return _terminateWhenAllBreakpointsHit; |
| } |
| |
| protected void breakpointEventHook(BreakpointEvent bpe) {} |
| protected void stepEventHook(StepEvent se) {} |
| protected void classPrepareEventHook(ClassPrepareEvent cpe) {} |
| protected void eventHook(Event e) {} |
| |
| @Override |
| public boolean run() throws Throwable { |
| JDIBreakpointTest._jdiEventWaitTimeout = getArgumentParser().getWaitTime() * 60000; |
| |
| boolean terminateWhenAllBPHit = getTerminateWhenAllBPHit(); |
| |
| final String debuggeeClass = getDebuggeeClassName(); |
| |
| Binder binder = new Binder((ArgumentHandler) getArgumentParser(), getLog()); |
| |
| Debugee debuggee = binder.bindToDebugee(debuggeeClass); |
| if (debuggee == null) |
| throw new Exception("Can't launch debuggee"); |
| |
| debuggee.redirectOutput(getLog()); |
| |
| _vm = debuggee.VM(); |
| _eventQueue = _vm.eventQueue(); |
| EventRequestManager erm = _vm.eventRequestManager(); |
| |
| // Breakpoints |
| |
| final List<BreakpointInfo> breakpoints = getBreakpoints(debuggeeClass); |
| |
| final HashMap<String, ClassPrepareRequest> bpClassNames = new HashMap<String, ClassPrepareRequest>(); |
| |
| new BreakpointListIterator(breakpoints) { |
| @Override protected Object apply(BreakpointInfo bi) { |
| if ( bi.className.isEmpty() ) |
| bi.className = debuggeeClass; |
| bpClassNames.put(bi.className, null); |
| return null; |
| } |
| }.go(); |
| |
| for (String className : bpClassNames.keySet()) { |
| Env.traceNormal("Requesting ClassPrepareEvent for [" + className + "]"); |
| |
| ClassPrepareRequest cpReq = erm.createClassPrepareRequest(); |
| cpReq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD); |
| cpReq.addClassFilter(className); |
| cpReq.enable(); |
| |
| bpClassNames.put(className, cpReq); |
| } |
| |
| _vm.resume(); |
| |
| StepRequest currentStepReq = null; |
| int stepsToTrace = 0; |
| int stepCount = 0; |
| boolean stop = false; |
| |
| EVENT_LOOP: while (!stop) { |
| EventIterator ei = getNextEvent(); |
| |
| Map<Location, ThreadReference> currentLocations = new HashMap<Location, ThreadReference>(); |
| |
| while (ei.hasNext()) { |
| Event e = ei.next(); |
| Env.traceVerbose("Got JDI event: " + e); |
| eventHook(e); |
| if (e instanceof VMDisconnectEvent) |
| break EVENT_LOOP; |
| |
| ThreadReference thread = null; |
| Location location = null; |
| boolean fullStackTrace = false; |
| |
| if (e instanceof ClassPrepareEvent) { |
| ClassPrepareEvent cpe = (ClassPrepareEvent) e; |
| classPrepareEventHook(cpe); |
| |
| ReferenceType classRef = cpe.referenceType(); |
| |
| setBreakpoints(erm, breakpoints, classRef); |
| |
| } else if (e instanceof BreakpointEvent) { |
| |
| BreakpointEvent bpe = (BreakpointEvent) e; |
| breakpointEventHook(bpe); |
| thread = bpe.thread(); |
| location = bpe.location(); |
| fullStackTrace = true; |
| |
| } else if (e instanceof StepEvent) { |
| |
| StepEvent se = (StepEvent) e; |
| stepEventHook(se); |
| thread = se.thread(); |
| location = se.location(); |
| } |
| |
| if (thread != null) { |
| try { |
| Env.traceDebug("Event thread suspends: " + thread.suspendCount()); |
| if (thread.suspendCount() > 0) |
| Env.traceDebug("Stack trace:" + getStackTraceStr(thread.frames(), fullStackTrace)); |
| |
| currentLocations.put(location, thread); |
| |
| } catch (IncompatibleThreadStateException ex) { |
| Env.traceNormal("Exception: ", ex); |
| } |
| } |
| |
| if (++stepCount > MAX_EVENT_COUNT) { |
| Env.display("Maximum number of events reached (" |
| + MAX_EVENT_COUNT + ") for this test. Exiting."); |
| stop = true; |
| } |
| } |
| |
| for (Map.Entry<Location, ThreadReference> e : currentLocations.entrySet()) { |
| final Location location = e.getKey(); |
| final ThreadReference thread = e.getValue(); |
| |
| BreakpointInfo bpInfo = (BreakpointInfo) new BreakpointListIterator(breakpoints) { |
| @Override protected Object apply(BreakpointInfo bi) throws Throwable { |
| if ( location.method().name().equals(bi.methodName) && location.codeIndex() == bi.bci ) |
| return bi; |
| else |
| return null; |
| } |
| }.go(); |
| |
| int s = 0; |
| |
| if (bpInfo != null) { |
| Env.traceNormal("Execution hit our breakpoint: [" + bpInfo.methodName + ":" + bpInfo.methodLine + "] on step " + stepCount); |
| |
| bpInfo.hits++; |
| s = bpInfo.stepsToTrace; |
| |
| if (bpInfo.stratumInfo != null) { |
| if ( ! StratumUtils.checkStratum(location, bpInfo.stratumInfo) ) |
| markTestFailed("Stratum " + bpInfo.stratumInfo + " mismatch"); |
| } |
| |
| if ( bpInfo.subBreakpoints != null ) { |
| Env.traceNormal("Enabling sub-breakpoints"); |
| for ( BreakpointInfo subBP : bpInfo.subBreakpoints ) { |
| if ( subBP.type == BreakpointInfo.Type.IMPLICIT ) |
| continue; |
| |
| if ( subBP.bpReq == null ) { |
| Env.complain("Breakpoint " + subBP + " was not set. Skipping."); |
| continue; |
| } |
| |
| if ( subBP.bpReq.isEnabled() ) { |
| Env.traceVerbose("Breakpoint " + subBP + " is already enabled. Skipping."); |
| continue; |
| } |
| |
| subBP.bpReq.enable(); |
| } |
| } |
| |
| if ( terminateWhenAllBPHit && areAllBreakpointsHit(breakpoints) ) { |
| Env.traceNormal("All breakpoints are hit. Terminating."); |
| stop = true; |
| s = 0; |
| } |
| } |
| |
| if (s > 0) { |
| Env.traceVerbose("Stepping " + s + " step or breakpoint events from here"); |
| stepsToTrace = s; |
| |
| if (currentStepReq == null) { |
| currentStepReq = erm.createStepRequest(thread, StepRequest.STEP_LINE, StepRequest.STEP_INTO); |
| currentStepReq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD); |
| currentStepReq.enable(); |
| } |
| } else { |
| if (currentStepReq != null && --stepsToTrace <= 0) { |
| Env.traceVerbose("Continue without stepping"); |
| erm.deleteEventRequest(currentStepReq); |
| currentStepReq = null; |
| } |
| } |
| } |
| |
| Env.traceDebug("Resuming execution"); |
| _vm.resume(); |
| } |
| |
| new BreakpointListIterator(breakpoints) { |
| @Override protected Object apply(BreakpointInfo bi) { |
| if (!bi.isHit()) { |
| markTestFailed("Breakpoint for method " |
| + bi.methodName |
| + ": required hits " |
| + (bi.requiredHits == null ? "> 0" : (" = " + bi.requiredHits)) |
| + "; actual hits = " + bi.hits); |
| } else { |
| Env.display("Breakpoint for method " + bi.methodName + " was hit " + bi.hits + " times. OK."); |
| } |
| |
| return null; |
| } |
| }.go(); |
| |
| if (!debuggee.terminated()) |
| debuggee.endDebugee(); |
| |
| debuggee.waitFor(); |
| return true; |
| } |
| |
| private void setBreakpoints( |
| final EventRequestManager erm, |
| final List<BreakpointInfo> breakpoints, |
| final ReferenceType classRef) |
| throws Throwable { |
| |
| Env.traceNormal("Setting breakpoints for class [" + classRef + "]"); |
| |
| new BreakpointListIterator(breakpoints) { |
| @Override |
| protected Object apply(BreakpointInfo bpInfo) throws Throwable { |
| if ( bpInfo.className.equals(classRef.name()) ) { |
| |
| List<Method> methods = classRef.methodsByName(bpInfo.methodName); |
| if (methods.size() == 0) |
| throw new Exception("No method named [" + bpInfo.methodName + "]"); |
| |
| Method method = (Method) methods.get(0); |
| List<Location> allLineLocations = method.allLineLocations(); |
| |
| Env.traceVerbose("Method [" + method.name() + "] locations: " + Arrays.toString(allLineLocations.toArray())); |
| |
| if (bpInfo.methodLine > allLineLocations.size()) |
| throw new Exception("TEST BUG: no breakpoint line " + bpInfo.methodLine); |
| |
| Location lineLocation = (Location) allLineLocations.get(bpInfo.methodLine); |
| bpInfo.bci = lineLocation.codeIndex(); |
| bpInfo.hits = 0; |
| |
| if ( bpInfo.type == BreakpointInfo.Type.EXPLICIT ) { |
| BreakpointRequest bpReq = erm.createBreakpointRequest(lineLocation); |
| // bpReq.addThreadFilter(mainThread); |
| bpReq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD); |
| |
| if ( ! bpInfo.isConditional ) |
| bpReq.enable(); |
| |
| bpInfo.bpReq = bpReq; |
| Env.traceNormal("Breakpoint request for [" + method.name() + "]: " + bpReq); |
| } else { |
| Env.traceNormal("Implicit breakpoint " + "[" + bpInfo.methodName + ":" + bpInfo.methodLine + "]"); |
| } |
| |
| } |
| |
| return null; |
| } |
| }.go(); |
| } |
| |
| private static boolean areAllBreakpointsHit(List<BreakpointInfo> breakpoints) throws Throwable { |
| return null == new BreakpointListIterator(breakpoints) { |
| @Override |
| protected Object apply(BreakpointInfo bi) throws Throwable { |
| return bi.isHit() ? null : bi; |
| } |
| }.go(); |
| } |
| |
| public static String getStackTraceStr(List<StackFrame> frames, boolean full) |
| throws AbsentInformationException { |
| StringBuffer buf = new StringBuffer(); |
| |
| int frameNum = 0; |
| for (StackFrame f : frames) { |
| Location l = f.location(); |
| |
| buf.append(String.format("#%-4d", frameNum)) |
| .append(l.method()) |
| .append("\n source: ") |
| .append(l.sourcePath()) |
| .append(":") |
| .append(l.lineNumber()) |
| .append("; bci=") |
| .append(l.codeIndex()) |
| .append("\n class: ") |
| .append(l.declaringType()) |
| .append("\n strata: ") |
| .append(StratumUtils.getStrataStr(f)) |
| .append("\n locals: "); |
| |
| try { |
| for (Map.Entry<LocalVariable, Value> m : f.getValues(f.visibleVariables()).entrySet()) { |
| LocalVariable lv = m.getKey(); |
| buf.append("\n "); |
| |
| if (lv.isArgument()) { |
| buf.append("[arg] "); |
| } |
| buf.append(lv.name()) |
| .append(" (") |
| .append(lv.typeName()) |
| .append(") = [") |
| .append(m.getValue()) |
| .append("]; "); |
| } |
| } catch (AbsentInformationException e) { |
| buf.append("NO INFORMATION") |
| .append("\n arguments: "); |
| |
| List<Value> argumentValues = f.getArgumentValues(); |
| |
| if (argumentValues == null || argumentValues.size() == 0) { |
| buf.append("none"); |
| } else { |
| int n = 0; |
| for (Value v : argumentValues) { |
| buf.append("\n arg"); |
| |
| if (v == null) { |
| buf.append(n) |
| .append(" [null]"); |
| } else { |
| buf.append(n) |
| .append(" (") |
| .append(v.type()) |
| .append(") = [") |
| .append(v) |
| .append("]; "); |
| } |
| n++; |
| } |
| } |
| } |
| |
| buf.append("\n\n"); |
| |
| ++frameNum; |
| if (!full && frameNum >= SHORT_STACK_TRACE_FRAMES_NUM) { |
| buf.append("...\n"); |
| break; |
| } |
| } |
| return buf.toString(); |
| } |
| |
| protected EventIterator getNextEvent() throws Throwable { |
| EventSet eventSet = _eventQueue.remove(_jdiEventWaitTimeout); |
| if (eventSet == null) |
| throw new Exception("Timed out while waiting for an event"); |
| |
| return eventSet.eventIterator(); |
| } |
| |
| } |
