Mercurial > hg > truffle
diff test/runtime/7158988/TestPostFieldModification.java @ 5995:19e197e2a1af
7158988: jvm crashes while debugging on x86_32 and x86_64
Summary: Object pointer is pushed more than once on stack, where GC doesn't expect it.
Reviewed-by: coleenp, kvn
Contributed-by: axel.siebenborn@sap.com
author | coleenp |
---|---|
date | Thu, 05 Apr 2012 12:17:52 -0400 |
parents | |
children | 27dab8a7c762 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/runtime/7158988/TestPostFieldModification.java Thu Apr 05 12:17:52 2012 -0400 @@ -0,0 +1,249 @@ +/* + * Copyright 2012 SAP AG. 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. + */ + +/* + * @test FieldMonitor.java + * @bug 7158988 + * @summary verify jvm does not crash while debugging + * @run shell TestFieldMonitor.sh + * @author axel.siebenborn@sap.com + */ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.Reader; +import java.io.Writer; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import com.sun.jdi.Bootstrap; +import com.sun.jdi.Field; +import com.sun.jdi.ReferenceType; +import com.sun.jdi.VirtualMachine; +import com.sun.jdi.connect.Connector; +import com.sun.jdi.connect.IllegalConnectorArgumentsException; +import com.sun.jdi.connect.LaunchingConnector; +import com.sun.jdi.connect.VMStartException; +import com.sun.jdi.event.ClassPrepareEvent; +import com.sun.jdi.event.Event; +import com.sun.jdi.event.EventQueue; +import com.sun.jdi.event.EventSet; +import com.sun.jdi.event.ModificationWatchpointEvent; +import com.sun.jdi.event.VMDeathEvent; +import com.sun.jdi.event.VMDisconnectEvent; +import com.sun.jdi.request.ClassPrepareRequest; +import com.sun.jdi.request.EventRequest; +import com.sun.jdi.request.EventRequestManager; +import com.sun.jdi.request.ModificationWatchpointRequest; + +public class FieldMonitor { + + public static final String CLASS_NAME = "TestPostFieldModification"; + public static final String FIELD_NAME = "value"; + public static final String ARGUMENTS = "-Xshare:off -XX:+PrintGC"; + + public static void main(String[] args) + throws IOException, InterruptedException { + + StringBuffer sb = new StringBuffer(); + + for (int i=0; i < args.length; i++) { + sb.append(' '); + sb.append(args[i]); + } + //VirtualMachine vm = launchTarget(sb.toString()); + VirtualMachine vm = launchTarget(CLASS_NAME); + + System.out.println("Vm launched"); + // set watch field on already loaded classes + List<ReferenceType> referenceTypes = vm + .classesByName(CLASS_NAME); + for (ReferenceType refType : referenceTypes) { + addFieldWatch(vm, refType); + } + // watch for loaded classes + addClassWatch(vm); + + // 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(); + + + vm.resume(); + boolean connected = true; + while (connected) { + EventSet eventSet = eventQueue.remove(); + for (Event event : eventSet) { + 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) { + System.out.println("sleep for 500 ms"); + Thread.sleep(500); + System.out.println("resume..."); + + ModificationWatchpointEvent modEvent = (ModificationWatchpointEvent) event; + System.out.println("old=" + + modEvent.valueCurrent()); + System.out.println("new=" + modEvent.valueToBe()); + System.out.println(); + } + } + 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 + } + } + + /** + * Find a com.sun.jdi.CommandLineLaunch connector + */ + static LaunchingConnector findLaunchingConnector() { + List <Connector> connectors = Bootstrap.virtualMachineManager().allConnectors(); + Iterator <Connector> iter = connectors.iterator(); + while (iter.hasNext()) { + Connector connector = iter.next(); + if (connector.name().equals("com.sun.jdi.CommandLineLaunch")) { + return (LaunchingConnector)connector; + } + } + throw new Error("No launching connector"); + } + /** + * Return the launching connector's arguments. + */ + static Map <String,Connector.Argument> connectorArguments(LaunchingConnector connector, String mainArgs) { + Map<String,Connector.Argument> arguments = connector.defaultArguments(); + for (String key : arguments.keySet()) { + System.out.println(key); + } + + Connector.Argument mainArg = (Connector.Argument)arguments.get("main"); + if (mainArg == null) { + throw new Error("Bad launching connector"); + } + mainArg.setValue(mainArgs); + + Connector.Argument optionsArg = (Connector.Argument)arguments.get("options"); + if (optionsArg == null) { + throw new Error("Bad launching connector"); + } + optionsArg.setValue(ARGUMENTS); + return arguments; + } + + static VirtualMachine launchTarget(String mainArgs) { + LaunchingConnector connector = findLaunchingConnector(); + Map arguments = connectorArguments(connector, mainArgs); + try { + return (VirtualMachine) connector.launch(arguments); + } catch (IOException exc) { + throw new Error("Unable to launch target VM: " + exc); + } catch (IllegalConnectorArgumentsException exc) { + throw new Error("Internal error: " + exc); + } catch (VMStartException exc) { + throw new Error("Target VM failed to initialize: " + + exc.getMessage()); + } +} + + + private static void addClassWatch(VirtualMachine vm) { + EventRequestManager erm = vm.eventRequestManager(); + ClassPrepareRequest classPrepareRequest = erm + .createClassPrepareRequest(); + classPrepareRequest.addClassFilter(CLASS_NAME); + classPrepareRequest.setEnabled(true); + } + + + private static void addFieldWatch(VirtualMachine vm, + ReferenceType refType) { + EventRequestManager erm = vm.eventRequestManager(); + Field field = refType.fieldByName(FIELD_NAME); + ModificationWatchpointRequest modificationWatchpointRequest = erm + .createModificationWatchpointRequest(field); + modificationWatchpointRequest.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD); + modificationWatchpointRequest.setEnabled(true); + } +} + +class StreamRedirectThread extends Thread { + + private final BufferedReader in; + + private static final int BUFFER_SIZE = 2048; + + /** + * Set up for copy. + * @param name Name of the thread + * @param in Stream to copy from + * @param out Stream to copy to + */ + StreamRedirectThread(String name, InputStream in) { + super(name); + this.in = new BufferedReader(new InputStreamReader(in)); + } + + /** + * Copy. + */ + public void run() { + try { + String line; + while ((line = in.readLine ()) != null) { + System.out.println ("testvm: " + line); + } + System.out.flush(); + } catch(IOException exc) { + System.err.println("Child I/O Transfer - " + exc); + } + } +}