Mercurial > hg > truffle
annotate agent/test/jdi/TestScaffold.java @ 3011:f00918f35c7f
inlining and runtime interface related changes:
added codeSize() and compilerStorage() to RiMethod
HotSpotMethodResolved uses reflective methods instead of vmIds and survives compilations
HotSpotResolvedType.isInitialized not represented as field (can change)
inlining stores graphs into method objects and reuses them
| author | Lukas Stadler <lukas.stadler@jku.at> |
|---|---|
| date | Thu, 16 Jun 2011 20:36:17 +0200 |
| parents | c18cbe5936b8 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 import com.sun.jdi.*; | |
| 26 import com.sun.jdi.request.*; | |
| 27 import com.sun.jdi.event.*; | |
| 28 import java.util.*; | |
| 29 import java.io.*; | |
| 30 | |
| 31 /** | |
| 32 * Framework used by all JDI regression tests | |
| 33 */ | |
| 34 abstract public class TestScaffold extends TargetAdapter { | |
| 35 private boolean shouldTrace = false; | |
| 36 private VMConnection connection; | |
| 37 private VirtualMachine vm; | |
| 38 private EventRequestManager requestManager; | |
| 39 private List listeners = Collections.synchronizedList(new LinkedList()); | |
| 40 | |
| 41 /** | |
| 42 * We create a VMDeathRequest, SUSPEND_ALL, to sync the BE and FE. | |
| 43 */ | |
| 44 //private VMDeathRequest ourVMDeathRequest = null; | |
| 45 Object ourVMDeathRequest = null; | |
| 46 | |
| 47 /** | |
| 48 * We create an ExceptionRequest, SUSPEND_NONE so that we can | |
| 49 * catch it and output a msg if an exception occurs in the | |
| 50 * debuggee. | |
| 51 */ | |
| 52 private ExceptionRequest ourExceptionRequest = null; | |
| 53 | |
| 54 /** | |
| 55 * If we do catch an uncaught exception, we set this true | |
| 56 * so the testcase can find out if it wants to. | |
| 57 */ | |
| 58 private boolean exceptionCaught = false; | |
| 59 ThreadReference vmStartThread = null; | |
| 60 boolean vmDied = false; | |
| 61 boolean vmDisconnected = false; | |
| 62 final String[] args; | |
| 63 protected boolean testFailed = false; | |
| 64 | |
| 65 static private class ArgInfo { | |
| 66 String targetVMArgs = ""; | |
| 67 String targetAppCommandLine = ""; | |
| 68 String connectorSpec = "com.sun.jdi.CommandLineLaunch:"; | |
| 69 int traceFlags = 0; | |
| 70 } | |
| 71 | |
| 72 /** | |
| 73 * An easy way to sleep for awhile | |
| 74 */ | |
| 75 public void mySleep(int millis) { | |
| 76 try { | |
| 77 Thread.sleep(millis); | |
| 78 } catch (InterruptedException ee) { | |
| 79 } | |
| 80 } | |
| 81 | |
| 82 boolean getExceptionCaught() { | |
| 83 return exceptionCaught; | |
| 84 } | |
| 85 | |
| 86 void setExceptionCaught(boolean value) { | |
| 87 exceptionCaught = value; | |
| 88 } | |
| 89 | |
| 90 /** | |
| 91 * Return true if eventSet contains the VMDeathEvent for the request in | |
| 92 * the ourVMDeathRequest ivar. | |
| 93 */ | |
| 94 private boolean containsOurVMDeathRequest(EventSet eventSet) { | |
| 95 if (ourVMDeathRequest != null) { | |
| 96 Iterator myIter = eventSet.iterator(); | |
| 97 while (myIter.hasNext()) { | |
| 98 Event myEvent = (Event)myIter.next(); | |
| 99 if (!(myEvent instanceof VMDeathEvent)) { | |
| 100 // We assume that an EventSet contains only VMDeathEvents | |
| 101 // or no VMDeathEvents. | |
| 102 break; | |
| 103 } | |
| 104 if (ourVMDeathRequest.equals(myEvent.request())) { | |
| 105 return true; | |
| 106 } | |
| 107 } | |
| 108 } | |
| 109 return false; | |
| 110 } | |
| 111 | |
| 112 /************************************************************************ | |
| 113 * The following methods override those in our base class, TargetAdapter. | |
| 114 *************************************************************************/ | |
| 115 | |
| 116 /** | |
| 117 * Events handled directly by scaffold always resume (well, almost always) | |
| 118 */ | |
| 119 public void eventSetComplete(EventSet set) { | |
| 120 // The listener in connect(..) resumes after receiving our | |
| 121 // special VMDeathEvent. We can't also do the resume | |
| 122 // here or we will probably get a VMDisconnectedException | |
| 123 if (!containsOurVMDeathRequest(set)) { | |
| 124 traceln("TS: set.resume() called"); | |
| 125 set.resume(); | |
| 126 } | |
| 127 } | |
| 128 | |
| 129 /** | |
| 130 * This method sets up default requests. | |
| 131 * Testcases can override this to change default behavior. | |
| 132 */ | |
| 133 protected void createDefaultEventRequests() { | |
| 134 createDefaultVMDeathRequest(); | |
| 135 createDefaultExceptionRequest(); | |
| 136 } | |
| 137 | |
| 138 /** | |
| 139 * We want the BE to stop when it issues a VMDeathEvent in order to | |
| 140 * give the FE time to complete handling events that occured before | |
| 141 * the VMDeath. When we get the VMDeathEvent for this request in | |
| 142 * the listener in connect(), we will do a resume. | |
| 143 * If a testcase wants to do something special with VMDeathEvent's, | |
| 144 * then it should override this method with an empty method or | |
| 145 * whatever in order to suppress the automatic resume. The testcase | |
| 146 * will then be responsible for the handling of VMDeathEvents. It | |
| 147 * has to be sure that it does a resume if it gets a VMDeathEvent | |
| 148 * with SUSPEND_ALL, and it has to be sure that it doesn't do a | |
| 149 * resume after getting a VMDeath with SUSPEND_NONE (the automatically | |
| 150 * generated VMDeathEvent.) | |
| 151 */ | |
| 152 protected void createDefaultVMDeathRequest() { | |
| 153 // ourVMDeathRequest = requestManager.createVMDeathRequest(); | |
| 154 // ourVMDeathRequest.setSuspendPolicy(EventRequest.SUSPEND_ALL); | |
| 155 // ourVMDeathRequest.enable(); | |
| 156 } | |
| 157 | |
| 158 /** | |
| 159 * This will allow us to print a warning if a debuggee gets an | |
| 160 * unexpected exception. The unexpected exception will be handled in | |
| 161 * the exceptionThrown method in the listener created in the connect() | |
| 162 * method. | |
| 163 * If a testcase does not want an uncaught exception to cause a | |
| 164 * msg, it must override this method. | |
| 165 */ | |
| 166 protected void createDefaultExceptionRequest() { | |
| 167 ourExceptionRequest = requestManager.createExceptionRequest(null, | |
| 168 false, true); | |
| 169 | |
| 170 // We can't afford to make this be other than SUSPEND_NONE. Otherwise, | |
| 171 // it would have to be resumed. If our connect() listener resumes it, | |
| 172 // what about the case where the EventSet contains other events with | |
| 173 // SUSPEND_ALL and there are other listeners who expect the BE to still | |
| 174 // be suspended when their handlers get called? | |
| 175 ourExceptionRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE); | |
| 176 ourExceptionRequest.enable(); | |
| 177 } | |
| 178 | |
| 179 private class EventHandler implements Runnable { | |
| 180 EventHandler() { | |
| 181 Thread thread = new Thread(this); | |
| 182 thread.setDaemon(true); | |
| 183 thread.start(); | |
| 184 } | |
| 185 | |
| 186 private void notifyEvent(TargetListener listener, Event event) { | |
| 187 if (event instanceof BreakpointEvent) { | |
| 188 listener.breakpointReached((BreakpointEvent)event); | |
| 189 } else if (event instanceof ExceptionEvent) { | |
| 190 listener.exceptionThrown((ExceptionEvent)event); | |
| 191 } else if (event instanceof StepEvent) { | |
| 192 listener.stepCompleted((StepEvent)event); | |
| 193 } else if (event instanceof ClassPrepareEvent) { | |
| 194 listener.classPrepared((ClassPrepareEvent)event); | |
| 195 } else if (event instanceof ClassUnloadEvent) { | |
| 196 listener.classUnloaded((ClassUnloadEvent)event); | |
| 197 } else if (event instanceof MethodEntryEvent) { | |
| 198 listener.methodEntered((MethodEntryEvent)event); | |
| 199 } else if (event instanceof MethodExitEvent) { | |
| 200 listener.methodExited((MethodExitEvent)event); | |
| 201 } else if (event instanceof AccessWatchpointEvent) { | |
| 202 listener.fieldAccessed((AccessWatchpointEvent)event); | |
| 203 } else if (event instanceof ModificationWatchpointEvent) { | |
| 204 listener.fieldModified((ModificationWatchpointEvent)event); | |
| 205 } else if (event instanceof ThreadStartEvent) { | |
| 206 listener.threadStarted((ThreadStartEvent)event); | |
| 207 } else if (event instanceof ThreadDeathEvent) { | |
| 208 listener.threadDied((ThreadDeathEvent)event); | |
| 209 } else if (event instanceof VMStartEvent) { | |
| 210 listener.vmStarted((VMStartEvent)event); | |
| 211 } else if (event instanceof VMDeathEvent) { | |
| 212 listener.vmDied((VMDeathEvent)event); | |
| 213 } else if (event instanceof VMDisconnectEvent) { | |
| 214 listener.vmDisconnected((VMDisconnectEvent)event); | |
| 215 } else { | |
| 216 throw new InternalError("Unknown event type: " + event.getClass()); | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 private void traceSuspendPolicy(int policy) { | |
| 221 if (shouldTrace) { | |
| 222 switch (policy) { | |
| 223 case EventRequest.SUSPEND_NONE: | |
| 224 traceln("TS: eventHandler: suspend = SUSPEND_NONE"); | |
| 225 break; | |
| 226 case EventRequest.SUSPEND_ALL: | |
| 227 traceln("TS: eventHandler: suspend = SUSPEND_ALL"); | |
| 228 break; | |
| 229 case EventRequest.SUSPEND_EVENT_THREAD: | |
| 230 traceln("TS: eventHandler: suspend = SUSPEND_EVENT_THREAD"); | |
| 231 break; | |
| 232 } | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 public void run() { | |
| 237 boolean connected = true; | |
| 238 do { | |
| 239 try { | |
| 240 EventSet set = vm.eventQueue().remove(); | |
| 241 traceSuspendPolicy(set.suspendPolicy()); | |
| 242 synchronized (listeners) { | |
| 243 ListIterator iter = listeners.listIterator(); | |
| 244 while (iter.hasNext()) { | |
| 245 TargetListener listener = (TargetListener)iter.next(); | |
| 246 traceln("TS: eventHandler: listener = " + listener); | |
| 247 listener.eventSetReceived(set); | |
| 248 if (listener.shouldRemoveListener()) { | |
| 249 iter.remove(); | |
| 250 } else { | |
| 251 Iterator jter = set.iterator(); | |
| 252 while (jter.hasNext()) { | |
| 253 Event event = (Event)jter.next(); | |
| 254 traceln("TS: eventHandler: event = " + event.getClass()); | |
| 255 | |
| 256 if (event instanceof VMDisconnectEvent) { | |
| 257 connected = false; | |
| 258 } | |
| 259 listener.eventReceived(event); | |
| 260 if (listener.shouldRemoveListener()) { | |
| 261 iter.remove(); | |
| 262 break; | |
| 263 } | |
| 264 notifyEvent(listener, event); | |
| 265 if (listener.shouldRemoveListener()) { | |
| 266 iter.remove(); | |
| 267 break; | |
| 268 } | |
| 269 } | |
| 270 traceln("TS: eventHandler: end of events loop"); | |
| 271 if (!listener.shouldRemoveListener()) { | |
| 272 traceln("TS: eventHandler: calling ESC"); | |
| 273 listener.eventSetComplete(set); | |
| 274 if (listener.shouldRemoveListener()) { | |
| 275 iter.remove(); | |
| 276 } | |
| 277 } | |
| 278 } | |
| 279 traceln("TS: eventHandler: end of listeners loop"); | |
| 280 } | |
| 281 } | |
| 282 } catch (InterruptedException e) { | |
| 283 traceln("TS: eventHandler: InterruptedException"); | |
| 284 } catch (Exception e) { | |
| 285 failure("FAILED: Exception occured in eventHandler: " + e); | |
| 286 e.printStackTrace(); | |
| 287 connected = false; | |
| 288 synchronized(TestScaffold.this) { | |
| 289 // This will make the waiters such as waitForVMDisconnect | |
| 290 // exit their wait loops. | |
| 291 vmDisconnected = true; | |
| 292 TestScaffold.this.notifyAll(); | |
| 293 } | |
| 294 } | |
| 295 traceln("TS: eventHandler: End of outerloop"); | |
| 296 } while (connected); | |
| 297 traceln("TS: eventHandler: finished"); | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 /** | |
| 302 * Constructor | |
| 303 */ | |
| 304 public TestScaffold(String[] args) { | |
| 305 this.args = args; | |
| 306 } | |
| 307 | |
| 308 public void enableScaffoldTrace() { | |
| 309 this.shouldTrace = true; | |
| 310 } | |
| 311 | |
| 312 public void disableScaffoldTrace() { | |
| 313 this.shouldTrace = false; | |
| 314 } | |
| 315 | |
| 316 | |
| 317 protected void startUp(String targetName) { | |
| 318 List argList = new ArrayList(Arrays.asList(args)); | |
| 319 argList.add(targetName); | |
| 320 println("run args: " + argList); | |
| 321 connect((String[]) argList.toArray(args)); | |
| 322 waitForVMStart(); | |
| 323 } | |
| 324 | |
| 325 protected BreakpointEvent startToMain(String targetName) { | |
| 326 startUp(targetName); | |
| 327 traceln("TS: back from startUp"); | |
| 328 BreakpointEvent bpr = resumeTo(targetName, "main", "([Ljava/lang/String;)V"); | |
| 329 waitForInput(); | |
| 330 return bpr; | |
| 331 } | |
| 332 | |
| 333 protected void waitForInput() { | |
| 334 if (System.getProperty("jpda.wait") != null) { | |
| 335 try { | |
| 336 System.err.println("Press <enter> to continue"); | |
| 337 System.in.read(); | |
| 338 System.err.println("running..."); | |
| 339 | |
| 340 } catch(Exception e) { | |
| 341 } | |
| 342 } | |
| 343 } | |
| 344 | |
| 345 /* | |
| 346 * Test cases should implement tests in runTests and should | |
| 347 * initiate testing by calling run(). | |
| 348 */ | |
| 349 abstract protected void runTests() throws Exception; | |
| 350 | |
| 351 final public void startTests() throws Exception { | |
| 352 try { | |
| 353 runTests(); | |
| 354 } finally { | |
| 355 shutdown(); | |
| 356 } | |
| 357 } | |
| 358 | |
| 359 protected void println(String str) { | |
| 360 System.err.println(str); | |
| 361 } | |
| 362 | |
| 363 protected void print(String str) { | |
| 364 System.err.print(str); | |
| 365 } | |
| 366 | |
| 367 protected void traceln(String str) { | |
| 368 if (shouldTrace) { | |
| 369 println(str); | |
| 370 } | |
| 371 } | |
| 372 | |
| 373 protected void failure(String str) { | |
| 374 println(str); | |
| 375 testFailed = true; | |
| 376 } | |
| 377 | |
| 378 private ArgInfo parseArgs(String args[]) { | |
| 379 ArgInfo argInfo = new ArgInfo(); | |
| 380 for (int i = 0; i < args.length; i++) { | |
| 381 if (args[i].equals("-connect")) { | |
| 382 i++; | |
| 383 argInfo.connectorSpec = args[i]; | |
| 384 } else if (args[i].equals("-trace")) { | |
| 385 i++; | |
| 386 argInfo.traceFlags = Integer.decode(args[i]).intValue(); | |
| 387 } else if (args[i].startsWith("-J")) { | |
| 388 argInfo.targetVMArgs += (args[i].substring(2) + ' '); | |
| 389 | |
| 390 /* | |
| 391 * classpath can span two arguments so we need to handle | |
| 392 * it specially. | |
| 393 */ | |
| 394 if (args[i].equals("-J-classpath")) { | |
| 395 i++; | |
| 396 argInfo.targetVMArgs += (args[i] + ' '); | |
| 397 } | |
| 398 } else { | |
| 399 argInfo.targetAppCommandLine += (args[i] + ' '); | |
| 400 } | |
| 401 } | |
| 402 return argInfo; | |
| 403 } | |
| 404 | |
| 405 /** | |
| 406 * This is called to connect to a debuggee VM. It starts the VM and | |
| 407 * installs a listener to catch VMStartEvent, our default events, and | |
| 408 * VMDisconnectedEvent. When these events appear, that is remembered | |
| 409 * and waiters are notified. | |
| 410 * This is normally called in the main thread of the test case. | |
| 411 * It starts up an EventHandler thread that gets events coming in | |
| 412 * from the debuggee and distributes them to listeners. That thread | |
| 413 * keeps running until a VMDisconnectedEvent occurs or some exception | |
| 414 * occurs during its processing. | |
| 415 * | |
| 416 * The 'listenUntilVMDisconnect' method adds 'this' as a listener. | |
| 417 * This means that 'this's vmDied method will get called. This has a | |
| 418 * default impl in TargetAdapter.java which can be overridden in the | |
| 419 * testcase. | |
| 420 * | |
| 421 * waitForRequestedEvent also adds an adaptor listener that listens | |
| 422 * for the particular event it is supposed to wait for (and it also | |
| 423 * catches VMDisconnectEvents.) This listener is removed once | |
| 424 * its eventReceived method is called. | |
| 425 * waitForRequestedEvent is called by most of the methods to do bkpts, | |
| 426 * etc. | |
| 427 */ | |
| 428 public void connect(String args[]) { | |
| 429 ArgInfo argInfo = parseArgs(args); | |
| 430 | |
| 431 argInfo.targetVMArgs += VMConnection.getDebuggeeVMOptions(); | |
| 432 connection = new VMConnection(argInfo.connectorSpec, | |
| 433 argInfo.traceFlags); | |
| 434 | |
| 435 addListener(new TargetAdapter() { | |
| 436 public void eventSetComplete(EventSet set) { | |
| 437 if (TestScaffold.this.containsOurVMDeathRequest(set)) { | |
| 438 traceln("TS: connect: set.resume() called"); | |
| 439 set.resume(); | |
| 440 | |
| 441 // Note that we want to do the above resume before | |
| 442 // waking up any sleepers. | |
| 443 synchronized(TestScaffold.this) { | |
| 444 TestScaffold.this.notifyAll(); | |
| 445 } | |
| 446 } | |
| 447 } | |
| 448 | |
| 449 public void vmStarted(VMStartEvent event) { | |
| 450 synchronized(TestScaffold.this) { | |
| 451 vmStartThread = event.thread(); | |
| 452 TestScaffold.this.notifyAll(); | |
| 453 } | |
| 454 } | |
| 455 /** | |
| 456 * By default, we catch uncaught exceptions and print a msg. | |
| 457 * The testcase must override the createDefaultExceptionRequest | |
| 458 * method if it doesn't want this behavior. | |
| 459 */ | |
| 460 public void exceptionThrown(ExceptionEvent event) { | |
| 461 if (TestScaffold.this.ourExceptionRequest != null && | |
| 462 TestScaffold.this.ourExceptionRequest.equals( | |
| 463 event.request())) { | |
| 464 println("Note: Unexpected Debuggee Exception: " + | |
| 465 event.exception().referenceType().name() + | |
| 466 " at line " + event.location().lineNumber()); | |
| 467 TestScaffold.this.exceptionCaught = true; | |
| 468 } | |
| 469 } | |
| 470 | |
| 471 public void vmDied(VMDeathEvent event) { | |
| 472 vmDied = true; | |
| 473 traceln("TS: vmDied called"); | |
| 474 } | |
| 475 | |
| 476 public void vmDisconnected(VMDisconnectEvent event) { | |
| 477 synchronized(TestScaffold.this) { | |
| 478 vmDisconnected = true; | |
| 479 TestScaffold.this.notifyAll(); | |
| 480 } | |
| 481 } | |
| 482 }); | |
| 483 if (connection.connector().name().equals("com.sun.jdi.CommandLineLaunch")) { | |
| 484 if (argInfo.targetVMArgs.length() > 0) { | |
| 485 if (connection.connectorArg("options").length() > 0) { | |
| 486 throw new IllegalArgumentException("VM options in two places"); | |
| 487 } | |
| 488 connection.setConnectorArg("options", argInfo.targetVMArgs); | |
| 489 } | |
| 490 if (argInfo.targetAppCommandLine.length() > 0) { | |
| 491 if (connection.connectorArg("main").length() > 0) { | |
| 492 throw new IllegalArgumentException("Command line in two places"); | |
| 493 } | |
| 494 connection.setConnectorArg("main", argInfo.targetAppCommandLine); | |
| 495 } | |
| 496 } | |
| 497 | |
| 498 vm = connection.open(); | |
| 499 requestManager = vm.eventRequestManager(); | |
| 500 createDefaultEventRequests(); | |
| 501 new EventHandler(); | |
| 502 } | |
| 503 | |
| 504 | |
| 505 public VirtualMachine vm() { | |
| 506 return vm; | |
| 507 } | |
| 508 | |
| 509 public EventRequestManager eventRequestManager() { | |
| 510 return requestManager; | |
| 511 } | |
| 512 | |
| 513 public void addListener(TargetListener listener) { | |
| 514 traceln("TS: Adding listener " + listener); | |
| 515 listeners.add(listener); | |
| 516 } | |
| 517 | |
| 518 public void removeListener(TargetListener listener) { | |
| 519 traceln("TS: Removing listener " + listener); | |
| 520 listeners.remove(listener); | |
| 521 } | |
| 522 | |
| 523 | |
| 524 protected void listenUntilVMDisconnect() { | |
| 525 try { | |
| 526 addListener (this); | |
| 527 } catch (Exception ex){ | |
| 528 ex.printStackTrace(); | |
| 529 testFailed = true; | |
| 530 } finally { | |
| 531 // Allow application to complete and shut down | |
| 532 resumeToVMDisconnect(); | |
| 533 } | |
| 534 } | |
| 535 | |
| 536 public synchronized ThreadReference waitForVMStart() { | |
| 537 while ((vmStartThread == null) && !vmDisconnected) { | |
| 538 try { | |
| 539 wait(); | |
| 540 } catch (InterruptedException e) { | |
| 541 } | |
| 542 } | |
| 543 | |
| 544 if (vmStartThread == null) { | |
| 545 throw new VMDisconnectedException(); | |
| 546 } | |
| 547 | |
| 548 return vmStartThread; | |
| 549 } | |
| 550 | |
| 551 public synchronized void waitForVMDisconnect() { | |
| 552 traceln("TS: waitForVMDisconnect"); | |
| 553 while (!vmDisconnected) { | |
| 554 try { | |
| 555 wait(); | |
| 556 } catch (InterruptedException e) { | |
| 557 } | |
| 558 } | |
| 559 traceln("TS: waitForVMDisconnect: done"); | |
| 560 } | |
| 561 | |
| 562 public Event waitForRequestedEvent(final EventRequest request) { | |
| 563 class EventNotification { | |
| 564 Event event; | |
| 565 boolean disconnected = false; | |
| 566 } | |
| 567 final EventNotification en = new EventNotification(); | |
| 568 | |
| 569 TargetAdapter adapter = new TargetAdapter() { | |
| 570 public void eventReceived(Event event) { | |
| 571 if (request.equals(event.request())) { | |
| 572 traceln("TS:Listener2: got requested event"); | |
| 573 synchronized (en) { | |
| 574 en.event = event; | |
| 575 en.notifyAll(); | |
| 576 } | |
| 577 removeThisListener(); | |
| 578 } else if (event instanceof VMDisconnectEvent) { | |
| 579 traceln("TS:Listener2: got VMDisconnectEvent"); | |
| 580 synchronized (en) { | |
| 581 en.disconnected = true; | |
| 582 en.notifyAll(); | |
| 583 } | |
| 584 removeThisListener(); | |
| 585 } | |
| 586 } | |
| 587 }; | |
| 588 | |
| 589 addListener(adapter); | |
| 590 | |
| 591 try { | |
| 592 synchronized (en) { | |
| 593 traceln("TS: waitForRequestedEvent: vm.resume called"); | |
| 594 vm.resume(); | |
| 595 | |
| 596 while (!en.disconnected && (en.event == null)) { | |
| 597 en.wait(); | |
| 598 } | |
| 599 } | |
| 600 } catch (InterruptedException e) { | |
| 601 return null; | |
| 602 } | |
| 603 | |
| 604 if (en.disconnected) { | |
| 605 throw new RuntimeException("VM Disconnected before requested event occurred"); | |
| 606 } | |
| 607 return en.event; | |
| 608 } | |
| 609 | |
| 610 private StepEvent doStep(ThreadReference thread, int gran, int depth) { | |
| 611 final StepRequest sr = | |
| 612 requestManager.createStepRequest(thread, gran, depth); | |
| 613 | |
| 614 sr.addClassExclusionFilter("java.*"); | |
| 615 sr.addClassExclusionFilter("sun.*"); | |
| 616 sr.addClassExclusionFilter("com.sun.*"); | |
| 617 sr.addCountFilter(1); | |
| 618 sr.enable(); | |
| 619 StepEvent retEvent = (StepEvent)waitForRequestedEvent(sr); | |
| 620 requestManager.deleteEventRequest(sr); | |
| 621 return retEvent; | |
| 622 } | |
| 623 | |
| 624 public StepEvent stepIntoInstruction(ThreadReference thread) { | |
| 625 return doStep(thread, StepRequest.STEP_MIN, StepRequest.STEP_INTO); | |
| 626 } | |
| 627 | |
| 628 public StepEvent stepIntoLine(ThreadReference thread) { | |
| 629 return doStep(thread, StepRequest.STEP_LINE, StepRequest.STEP_INTO); | |
| 630 } | |
| 631 | |
| 632 public StepEvent stepOverInstruction(ThreadReference thread) { | |
| 633 return doStep(thread, StepRequest.STEP_MIN, StepRequest.STEP_OVER); | |
| 634 } | |
| 635 | |
| 636 public StepEvent stepOverLine(ThreadReference thread) { | |
| 637 return doStep(thread, StepRequest.STEP_LINE, StepRequest.STEP_OVER); | |
| 638 } | |
| 639 | |
| 640 public StepEvent stepOut(ThreadReference thread) { | |
| 641 return doStep(thread, StepRequest.STEP_LINE, StepRequest.STEP_OUT); | |
| 642 } | |
| 643 | |
| 644 public BreakpointEvent resumeTo(Location loc) { | |
| 645 final BreakpointRequest request = | |
| 646 requestManager.createBreakpointRequest(loc); | |
| 647 request.addCountFilter(1); | |
| 648 request.enable(); | |
| 649 return (BreakpointEvent)waitForRequestedEvent(request); | |
| 650 } | |
| 651 | |
| 652 public ReferenceType findReferenceType(String name) { | |
| 653 List rts = vm.classesByName(name); | |
| 654 Iterator iter = rts.iterator(); | |
| 655 while (iter.hasNext()) { | |
| 656 ReferenceType rt = (ReferenceType)iter.next(); | |
| 657 if (rt.name().equals(name)) { | |
| 658 return rt; | |
| 659 } | |
| 660 } | |
| 661 return null; | |
| 662 } | |
| 663 | |
| 664 public Method findMethod(ReferenceType rt, String name, String signature) { | |
| 665 List methods = rt.methods(); | |
| 666 Iterator iter = methods.iterator(); | |
| 667 while (iter.hasNext()) { | |
| 668 Method method = (Method)iter.next(); | |
| 669 if (method.name().equals(name) && | |
| 670 method.signature().equals(signature)) { | |
| 671 return method; | |
| 672 } | |
| 673 } | |
| 674 return null; | |
| 675 } | |
| 676 | |
| 677 public Location findLocation(ReferenceType rt, int lineNumber) | |
| 678 throws AbsentInformationException { | |
| 679 List locs = rt.locationsOfLine(lineNumber); | |
| 680 if (locs.size() == 0) { | |
| 681 throw new IllegalArgumentException("Bad line number"); | |
| 682 } else if (locs.size() > 1) { | |
| 683 throw new IllegalArgumentException("Line number has multiple locations"); | |
| 684 } | |
| 685 | |
| 686 return (Location)locs.get(0); | |
| 687 } | |
| 688 | |
| 689 public BreakpointEvent resumeTo(String clsName, String methodName, | |
| 690 String methodSignature) { | |
| 691 ReferenceType rt = findReferenceType(clsName); | |
| 692 if (rt == null) { | |
| 693 rt = resumeToPrepareOf(clsName).referenceType(); | |
| 694 } | |
| 695 | |
| 696 Method method = findMethod(rt, methodName, methodSignature); | |
| 697 if (method == null) { | |
| 698 throw new IllegalArgumentException("Bad method name/signature"); | |
| 699 } | |
| 700 | |
| 701 return resumeTo(method.location()); | |
| 702 } | |
| 703 | |
| 704 public BreakpointEvent resumeTo(String clsName, int lineNumber) throws AbsentInformationException { | |
| 705 ReferenceType rt = findReferenceType(clsName); | |
| 706 if (rt == null) { | |
| 707 rt = resumeToPrepareOf(clsName).referenceType(); | |
| 708 } | |
| 709 | |
| 710 return resumeTo(findLocation(rt, lineNumber)); | |
| 711 } | |
| 712 | |
| 713 public ClassPrepareEvent resumeToPrepareOf(String className) { | |
| 714 final ClassPrepareRequest request = | |
| 715 requestManager.createClassPrepareRequest(); | |
| 716 request.addClassFilter(className); | |
| 717 request.addCountFilter(1); | |
| 718 request.enable(); | |
| 719 return (ClassPrepareEvent)waitForRequestedEvent(request); | |
| 720 } | |
| 721 | |
| 722 public void resumeToVMDisconnect() { | |
| 723 try { | |
| 724 traceln("TS: resumeToVMDisconnect: vm.resume called"); | |
| 725 vm.resume(); | |
| 726 } catch (VMDisconnectedException e) { | |
| 727 // clean up below | |
| 728 } | |
| 729 waitForVMDisconnect(); | |
| 730 } | |
| 731 | |
| 732 public void shutdown() { | |
| 733 shutdown(null); | |
| 734 } | |
| 735 | |
| 736 public void shutdown(String message) { | |
| 737 traceln("TS: shutdown: vmDied= " + vmDied + | |
| 738 ", vmDisconnected= " + vmDisconnected + | |
| 739 ", connection = " + connection); | |
| 740 | |
| 741 if ((connection != null)) { | |
| 742 try { | |
| 743 connection.disposeVM(); | |
| 744 } catch (VMDisconnectedException e) { | |
| 745 // Shutting down after the VM has gone away. This is | |
| 746 // not an error, and we just ignore it. | |
| 747 } | |
| 748 } else { | |
| 749 traceln("TS: shutdown: disposeVM not called"); | |
| 750 } | |
| 751 if (message != null) { | |
| 752 println(message); | |
| 753 } | |
| 754 | |
| 755 vmDied = true; | |
| 756 vmDisconnected = true; | |
| 757 } | |
| 758 } |