Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/HSDB.java @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | 55fb97c4c58d |
| children | 4ca6dc0799b6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
11054
diff
changeset
|
2 * Copyright (c) 2000, 2013, 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:
1385
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1385
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:
1385
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 package sun.jvm.hotspot; | |
| 26 | |
| 27 import java.io.*; | |
| 28 import java.awt.*; | |
| 29 import java.awt.event.*; | |
| 30 import java.math.*; | |
| 31 import javax.swing.*; | |
| 32 import javax.swing.tree.*; | |
| 33 import java.util.*; | |
| 34 | |
| 35 import sun.jvm.hotspot.code.*; | |
| 36 import sun.jvm.hotspot.compiler.*; | |
| 37 import sun.jvm.hotspot.debugger.*; | |
| 38 import sun.jvm.hotspot.gc_implementation.parallelScavenge.*; | |
| 39 import sun.jvm.hotspot.gc_interface.*; | |
| 40 import sun.jvm.hotspot.interpreter.*; | |
| 41 import sun.jvm.hotspot.memory.*; | |
| 42 import sun.jvm.hotspot.oops.*; | |
| 43 import sun.jvm.hotspot.runtime.*; | |
| 44 import sun.jvm.hotspot.ui.*; | |
| 45 import sun.jvm.hotspot.ui.tree.*; | |
| 46 import sun.jvm.hotspot.ui.classbrowser.*; | |
| 47 import sun.jvm.hotspot.utilities.*; | |
| 48 | |
| 49 /** The top-level HotSpot Debugger. FIXME: make this an embeddable | |
| 50 component! (Among other things, figure out what to do with the | |
| 51 menu bar...) */ | |
| 52 | |
| 53 public class HSDB implements ObjectHistogramPanel.Listener, SAListener { | |
| 54 public static void main(String[] args) { | |
| 55 new HSDB(args).run(); | |
| 56 } | |
| 57 | |
| 58 //-------------------------------------------------------------------------------- | |
| 59 // Internals only below this point | |
| 60 // | |
| 61 private HotSpotAgent agent; | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
62 private JVMDebugger jvmDebugger; |
| 0 | 63 private JDesktopPane desktop; |
| 64 private boolean attached; | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
65 private boolean argError; |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
66 private JFrame frame; |
| 0 | 67 /** List <JMenuItem> */ |
| 68 private java.util.List attachMenuItems; | |
| 69 /** List <JMenuItem> */ | |
| 70 private java.util.List detachMenuItems; | |
| 71 private JMenu toolsMenu; | |
| 72 private JMenuItem showDbgConsoleMenuItem; | |
| 73 private JMenuItem computeRevPtrsMenuItem; | |
| 74 private JInternalFrame attachWaitDialog; | |
| 75 private JInternalFrame threadsFrame; | |
| 76 private JInternalFrame consoleFrame; | |
| 77 private WorkerThread workerThread; | |
| 78 // These had to be made data members because they are referenced in inner classes. | |
| 79 private String pidText; | |
| 80 private int pid; | |
| 81 private String execPath; | |
| 82 private String coreFilename; | |
| 83 | |
| 84 private void doUsage() { | |
| 85 System.out.println("Usage: java HSDB [[pid] | [path-to-java-executable [path-to-corefile]] | help ]"); | |
| 86 System.out.println(" pid: attach to the process whose id is 'pid'"); | |
| 87 System.out.println(" path-to-java-executable: Debug a core file produced by this program"); | |
| 88 System.out.println(" path-to-corefile: Debug this corefile. The default is 'core'"); | |
| 89 System.out.println(" If no arguments are specified, you can select what to do from the GUI.\n"); | |
| 90 HotSpotAgent.showUsage(); | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
91 argError = true; |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
92 } |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
93 |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
94 public HSDB(JVMDebugger d) { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
95 jvmDebugger = d; |
| 0 | 96 } |
| 97 | |
| 98 private HSDB(String[] args) { | |
| 99 switch (args.length) { | |
| 100 case (0): | |
| 101 break; | |
| 102 | |
| 103 case (1): | |
| 104 if (args[0].equals("help") || args[0].equals("-help")) { | |
| 105 doUsage(); | |
| 106 } | |
| 107 // If all numbers, it is a PID to attach to | |
| 108 // Else, it is a pathname to a .../bin/java for a core file. | |
| 109 try { | |
| 110 int unused = Integer.parseInt(args[0]); | |
| 111 // If we get here, we have a PID and not a core file name | |
| 112 pidText = args[0]; | |
| 113 } catch (NumberFormatException e) { | |
| 114 execPath = args[0]; | |
| 115 coreFilename = "core"; | |
| 116 } | |
| 117 break; | |
| 118 | |
| 119 case (2): | |
| 120 execPath = args[0]; | |
| 121 coreFilename = args[1]; | |
| 122 break; | |
| 123 | |
| 124 default: | |
| 125 System.out.println("HSDB Error: Too many options specified"); | |
| 126 doUsage(); | |
| 127 } | |
| 128 } | |
| 129 | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
130 // close this tool without calling System.exit |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
131 protected void closeUI() { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
132 workerThread.shutdown(); |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
133 frame.dispose(); |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
134 } |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
135 |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
136 public void run() { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
137 // Don't start the UI if there were bad arguments. |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
138 if (argError) { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
139 return; |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
140 } |
| 0 | 141 |
| 142 agent = new HotSpotAgent(); | |
| 143 workerThread = new WorkerThread(); | |
| 144 attachMenuItems = new java.util.ArrayList(); | |
| 145 detachMenuItems = new java.util.ArrayList(); | |
| 146 | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
147 frame = new JFrame("HSDB - HotSpot Debugger"); |
| 0 | 148 frame.setSize(800, 600); |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
149 frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); |
| 0 | 150 |
| 151 JMenuBar menuBar = new JMenuBar(); | |
| 152 | |
| 153 // | |
| 154 // File menu | |
| 155 // | |
| 156 | |
| 157 JMenu menu = new JMenu("File"); | |
| 158 menu.setMnemonic(KeyEvent.VK_F); | |
| 159 JMenuItem item; | |
| 160 item = createMenuItem("Attach to HotSpot process...", | |
| 161 new ActionListener() { | |
| 162 public void actionPerformed(ActionEvent e) { | |
| 163 showAttachDialog(); | |
| 164 } | |
| 165 }); | |
| 166 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, ActionEvent.ALT_MASK)); | |
| 167 item.setMnemonic(KeyEvent.VK_A); | |
| 168 menu.add(item); | |
| 169 attachMenuItems.add(item); | |
| 170 | |
| 171 item = createMenuItem("Open HotSpot core file...", | |
| 172 new ActionListener() { | |
| 173 public void actionPerformed(ActionEvent e) { | |
| 174 showOpenCoreFileDialog(); | |
| 175 } | |
| 176 }); | |
| 177 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, ActionEvent.ALT_MASK)); | |
| 178 item.setMnemonic(KeyEvent.VK_O); | |
| 179 menu.add(item); | |
| 180 attachMenuItems.add(item); | |
| 181 | |
| 182 item = createMenuItem("Connect to debug server...", | |
| 183 new ActionListener() { | |
| 184 public void actionPerformed(ActionEvent e) { | |
| 185 showConnectDialog(); | |
| 186 } | |
| 187 }); | |
| 188 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, ActionEvent.ALT_MASK)); | |
| 189 item.setMnemonic(KeyEvent.VK_S); | |
| 190 menu.add(item); | |
| 191 attachMenuItems.add(item); | |
| 192 | |
| 193 item = createMenuItem("Detach", | |
| 194 new ActionListener() { | |
| 195 public void actionPerformed(ActionEvent e) { | |
| 196 detach(); | |
| 197 } | |
| 198 }); | |
| 199 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_D, ActionEvent.ALT_MASK)); | |
| 200 item.setMnemonic(KeyEvent.VK_S); | |
| 201 menu.add(item); | |
| 202 detachMenuItems.add(item); | |
| 203 | |
| 204 // Disable detach menu items at first | |
| 205 setMenuItemsEnabled(detachMenuItems, false); | |
| 206 | |
| 207 menu.addSeparator(); | |
| 208 | |
| 209 item = createMenuItem("Exit", | |
| 210 new ActionListener() { | |
| 211 public void actionPerformed(ActionEvent e) { | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
212 closeUI(); |
| 0 | 213 } |
| 214 }); | |
| 215 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.ALT_MASK)); | |
| 216 item.setMnemonic(KeyEvent.VK_X); | |
| 217 menu.add(item); | |
| 218 menuBar.add(menu); | |
| 219 | |
| 220 // | |
| 221 // Tools menu | |
| 222 // | |
| 223 | |
| 224 toolsMenu = new JMenu("Tools"); | |
| 225 toolsMenu.setMnemonic(KeyEvent.VK_T); | |
| 226 | |
| 227 item = createMenuItem("Class Browser", | |
| 228 new ActionListener() { | |
| 229 public void actionPerformed(ActionEvent e) { | |
| 230 showClassBrowser(); | |
| 231 } | |
| 232 }); | |
| 233 item.setMnemonic(KeyEvent.VK_B); | |
| 234 | |
| 235 toolsMenu.add(item); | |
| 236 | |
| 237 item = createMenuItem("Code Viewer", | |
| 238 new ActionListener() { | |
| 239 public void actionPerformed(ActionEvent e) { | |
| 240 showCodeViewer(); | |
| 241 } | |
| 242 }); | |
| 243 item.setMnemonic(KeyEvent.VK_C); | |
| 244 | |
| 245 toolsMenu.add(item); | |
| 246 | |
| 247 | |
| 248 item = createMenuItem("Compute Reverse Ptrs", | |
| 249 new ActionListener() { | |
| 250 public void actionPerformed(ActionEvent e) { | |
| 251 fireComputeReversePtrs(); | |
| 252 } | |
| 253 }); | |
| 254 computeRevPtrsMenuItem = item; | |
| 255 item.setMnemonic(KeyEvent.VK_M); | |
| 256 toolsMenu.add(item); | |
| 257 | |
| 258 item = createMenuItem("Deadlock Detection", | |
| 259 new ActionListener() { | |
| 260 public void actionPerformed(ActionEvent e) { | |
| 261 showDeadlockDetectionPanel(); | |
| 262 } | |
| 263 }); | |
| 264 item.setMnemonic(KeyEvent.VK_D); | |
| 265 toolsMenu.add(item); | |
| 266 | |
| 267 item = createMenuItem("Find Object by Query", | |
| 268 new ActionListener() { | |
| 269 public void actionPerformed(ActionEvent e) { | |
| 270 showFindByQueryPanel(); | |
| 271 } | |
| 272 }); | |
| 273 item.setMnemonic(KeyEvent.VK_Q); | |
| 274 toolsMenu.add(item); | |
| 275 | |
| 276 | |
| 277 item = createMenuItem("Find Pointer", | |
| 278 new ActionListener() { | |
| 279 public void actionPerformed(ActionEvent e) { | |
| 280 showFindPanel(); | |
| 281 } | |
| 282 }); | |
| 283 item.setMnemonic(KeyEvent.VK_P); | |
| 284 toolsMenu.add(item); | |
| 285 | |
| 286 item = createMenuItem("Find Value In Heap", | |
| 287 new ActionListener() { | |
| 288 public void actionPerformed(ActionEvent e) { | |
| 289 showFindInHeapPanel(); | |
| 290 } | |
| 291 }); | |
| 292 item.setMnemonic(KeyEvent.VK_V); | |
| 293 toolsMenu.add(item); | |
| 294 | |
| 295 item = createMenuItem("Find Value In Code Cache", | |
| 296 new ActionListener() { | |
| 297 public void actionPerformed(ActionEvent e) { | |
| 298 showFindInCodeCachePanel(); | |
| 299 } | |
| 300 }); | |
| 301 item.setMnemonic(KeyEvent.VK_A); | |
| 302 toolsMenu.add(item); | |
| 303 | |
| 304 item = createMenuItem("Heap Parameters", | |
| 305 new ActionListener() { | |
| 306 public void actionPerformed(ActionEvent e) { | |
| 307 showHeapParametersPanel(); | |
| 308 } | |
| 309 }); | |
| 310 item.setMnemonic(KeyEvent.VK_H); | |
| 311 toolsMenu.add(item); | |
| 312 | |
| 313 item = createMenuItem("Inspector", | |
| 314 new ActionListener() { | |
| 315 public void actionPerformed(ActionEvent e) { | |
| 316 showInspector(null); | |
| 317 } | |
| 318 }); | |
| 319 item.setMnemonic(KeyEvent.VK_R); | |
| 320 item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, ActionEvent.ALT_MASK)); | |
| 321 toolsMenu.add(item); | |
| 322 | |
| 323 item = createMenuItem("Memory Viewer", | |
| 324 new ActionListener() { | |
| 325 public void actionPerformed(ActionEvent e) { | |
| 326 showMemoryViewer(); | |
| 327 } | |
| 328 }); | |
| 329 item.setMnemonic(KeyEvent.VK_M); | |
| 330 toolsMenu.add(item); | |
| 331 | |
| 332 item = createMenuItem("Monitor Cache Dump", | |
| 333 new ActionListener() { | |
| 334 public void actionPerformed(ActionEvent e) { | |
| 335 showMonitorCacheDumpPanel(); | |
| 336 } | |
| 337 }); | |
| 338 item.setMnemonic(KeyEvent.VK_D); | |
| 339 toolsMenu.add(item); | |
| 340 | |
| 341 item = createMenuItem("Object Histogram", | |
| 342 new ActionListener() { | |
| 343 public void actionPerformed(ActionEvent e) { | |
| 344 showObjectHistogram(); | |
| 345 } | |
| 346 }); | |
| 347 item.setMnemonic(KeyEvent.VK_O); | |
| 348 toolsMenu.add(item); | |
| 349 | |
| 350 item = createMenuItem("Show System Properties", | |
| 351 new ActionListener() { | |
| 352 public void actionPerformed(ActionEvent e) { | |
| 353 showSystemProperties(); | |
| 354 } | |
| 355 }); | |
| 356 item.setMnemonic(KeyEvent.VK_S); | |
| 357 toolsMenu.add(item); | |
| 358 | |
| 359 item = createMenuItem("Show VM Version", | |
| 360 new ActionListener() { | |
| 361 public void actionPerformed(ActionEvent e) { | |
| 362 showVMVersion(); | |
| 363 } | |
| 364 }); | |
| 365 item.setMnemonic(KeyEvent.VK_M); | |
| 366 toolsMenu.add(item); | |
| 367 | |
| 368 item = createMenuItem("Show -XX flags", | |
| 369 new ActionListener() { | |
| 370 public void actionPerformed(ActionEvent e) { | |
| 371 showCommandLineFlags(); | |
| 372 } | |
| 373 }); | |
| 374 item.setMnemonic(KeyEvent.VK_X); | |
| 375 toolsMenu.add(item); | |
| 376 | |
| 377 toolsMenu.setEnabled(false); | |
| 378 menuBar.add(toolsMenu); | |
| 379 | |
| 380 // | |
| 381 // Windows menu | |
| 382 // | |
| 383 | |
| 384 JMenu windowsMenu = new JMenu("Windows"); | |
| 385 windowsMenu.setMnemonic(KeyEvent.VK_W); | |
| 386 item = createMenuItem("Console", | |
| 387 new ActionListener() { | |
| 388 public void actionPerformed(ActionEvent e) { | |
| 389 showConsole(); | |
| 390 } | |
| 391 }); | |
| 392 item.setMnemonic(KeyEvent.VK_C); | |
| 393 windowsMenu.add(item); | |
| 394 showDbgConsoleMenuItem = createMenuItem("Debugger Console", | |
| 395 new ActionListener() { | |
| 396 public void actionPerformed(ActionEvent e) { | |
| 397 showDebuggerConsole(); | |
| 398 } | |
| 399 }); | |
| 400 showDbgConsoleMenuItem.setMnemonic(KeyEvent.VK_D); | |
| 401 windowsMenu.add(showDbgConsoleMenuItem); | |
| 402 showDbgConsoleMenuItem.setEnabled(false); | |
| 403 | |
| 404 menuBar.add(windowsMenu); | |
| 405 | |
| 406 | |
| 407 frame.setJMenuBar(menuBar); | |
| 408 | |
| 409 desktop = new JDesktopPane(); | |
| 410 frame.getContentPane().add(desktop); | |
| 411 GraphicsUtilities.reshapeToAspectRatio(frame, 4.0f/3.0f, 0.75f, Toolkit.getDefaultToolkit().getScreenSize()); | |
| 412 GraphicsUtilities.centerInContainer(frame, Toolkit.getDefaultToolkit().getScreenSize()); | |
|
152
c70a245cad3a
6670684: 4/5 SA command universe did not print out CMS space information
dcubed
parents:
0
diff
changeset
|
413 frame.setVisible(true); |
| 0 | 414 |
| 415 Runtime.getRuntime().addShutdownHook(new java.lang.Thread() { | |
| 416 public void run() { | |
| 417 detachDebugger(); | |
| 418 } | |
| 419 }); | |
| 420 | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
421 // If jvmDebugger is already set, we have been given a JVMDebugger. |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
422 // Otherwise, if pidText != null we are supposed to attach to it. |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
423 // Finally, if execPath != null, it is the path of a jdk/bin/java |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
424 // and coreFilename is the pathname of a core file we are |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
425 // supposed to attach to. |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
426 |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
427 if (jvmDebugger != null) { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
428 attach(jvmDebugger); |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
429 } else if (pidText != null) { |
| 0 | 430 attach(pidText); |
| 431 } else if (execPath != null) { | |
| 432 attach(execPath, coreFilename); | |
| 433 } | |
| 434 } | |
| 435 | |
| 436 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
| 437 private void showAttachDialog() { | |
| 438 // FIXME: create filtered text field which only accepts numbers | |
| 439 setMenuItemsEnabled(attachMenuItems, false); | |
| 440 final JInternalFrame attachDialog = new JInternalFrame("Attach to HotSpot process"); | |
| 441 attachDialog.getContentPane().setLayout(new BorderLayout()); | |
| 442 | |
| 443 JPanel panel = new JPanel(); | |
| 444 panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS)); | |
| 445 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 446 attachDialog.setBackground(panel.getBackground()); | |
| 447 | |
| 448 panel.add(new JLabel("Enter process ID:")); | |
| 449 final JTextField pidTextField = new JTextField(10); | |
| 450 ActionListener attacher = new ActionListener() { | |
| 451 public void actionPerformed(ActionEvent e) { | |
| 452 attachDialog.setVisible(false); | |
| 453 desktop.remove(attachDialog); | |
| 454 workerThread.invokeLater(new Runnable() { | |
| 455 public void run() { | |
| 456 attach(pidTextField.getText()); | |
| 457 } | |
| 458 }); | |
| 459 } | |
| 460 }; | |
| 461 | |
| 462 pidTextField.addActionListener(attacher); | |
| 463 panel.add(pidTextField); | |
| 464 attachDialog.getContentPane().add(panel, BorderLayout.NORTH); | |
| 465 | |
| 466 Box vbox = Box.createVerticalBox(); | |
| 467 panel = new JPanel(); | |
| 468 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
| 469 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
| 470 JTextArea ta = new JTextArea( | |
| 471 "Enter the process ID of a currently-running HotSpot process. On " + | |
| 472 "Solaris and most Unix operating systems, this can be determined by " + | |
| 473 "typing \"ps -u <your username> | grep java\"; the process ID is the " + | |
| 474 "first number which appears on the resulting line. On Windows, the " + | |
| 475 "process ID is present in the Task Manager, which can be brought up " + | |
| 476 "while logged on to the desktop by pressing Ctrl-Alt-Delete."); | |
| 477 ta.setLineWrap(true); | |
| 478 ta.setWrapStyleWord(true); | |
| 479 ta.setEditable(false); | |
| 480 ta.setBackground(panel.getBackground()); | |
| 481 panel.add(ta); | |
| 482 vbox.add(panel); | |
| 483 | |
| 484 Box hbox = Box.createHorizontalBox(); | |
| 485 hbox.add(Box.createGlue()); | |
| 486 JButton button = new JButton("OK"); | |
| 487 button.addActionListener(attacher); | |
| 488 hbox.add(button); | |
| 489 hbox.add(Box.createHorizontalStrut(20)); | |
| 490 button = new JButton("Cancel"); | |
| 491 button.addActionListener(new ActionListener() { | |
| 492 public void actionPerformed(ActionEvent e) { | |
| 493 attachDialog.setVisible(false); | |
| 494 desktop.remove(attachDialog); | |
| 495 setMenuItemsEnabled(attachMenuItems, true); | |
| 496 } | |
| 497 }); | |
| 498 hbox.add(button); | |
| 499 hbox.add(Box.createGlue()); | |
| 500 panel = new JPanel(); | |
| 501 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 502 panel.add(hbox); | |
| 503 vbox.add(panel); | |
| 504 | |
| 505 attachDialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
| 506 | |
| 507 desktop.add(attachDialog); | |
| 508 attachDialog.setSize(400, 300); | |
| 509 GraphicsUtilities.centerInContainer(attachDialog); | |
| 510 attachDialog.show(); | |
| 511 pidTextField.requestFocus(); | |
| 512 } | |
| 513 | |
| 514 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
| 515 private void showOpenCoreFileDialog() { | |
| 516 setMenuItemsEnabled(attachMenuItems, false); | |
| 517 final JInternalFrame dialog = new JInternalFrame("Open Core File"); | |
| 518 dialog.getContentPane().setLayout(new BorderLayout()); | |
| 519 | |
| 520 JPanel panel = new JPanel(); | |
| 521 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
| 522 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 523 dialog.setBackground(panel.getBackground()); | |
| 524 | |
| 525 Box hbox = Box.createHorizontalBox(); | |
| 526 Box vbox = Box.createVerticalBox(); | |
| 527 vbox.add(new JLabel("Path to core file:")); | |
| 528 vbox.add(new JLabel("Path to Java executable:")); | |
| 529 hbox.add(vbox); | |
| 530 | |
| 531 vbox = Box.createVerticalBox(); | |
| 532 final JTextField corePathField = new JTextField(40); | |
| 533 final JTextField execPathField = new JTextField(40); | |
| 534 vbox.add(corePathField); | |
| 535 vbox.add(execPathField); | |
| 536 hbox.add(vbox); | |
| 537 | |
| 538 final JButton browseCorePath = new JButton("Browse .."); | |
| 539 final JButton browseExecPath = new JButton("Browse .."); | |
| 540 browseCorePath.addActionListener(new ActionListener() { | |
| 541 public void actionPerformed(ActionEvent e) { | |
| 542 JFileChooser fileChooser = new JFileChooser(new File(".")); | |
| 543 int retVal = fileChooser.showOpenDialog(dialog); | |
| 544 if (retVal == JFileChooser.APPROVE_OPTION) { | |
| 545 corePathField.setText(fileChooser.getSelectedFile().getPath()); | |
| 546 } | |
| 547 } | |
| 548 }); | |
| 549 browseExecPath.addActionListener(new ActionListener() { | |
| 550 public void actionPerformed(ActionEvent e) { | |
| 551 JFileChooser fileChooser = new JFileChooser(new File(".")); | |
| 552 int retVal = fileChooser.showOpenDialog(dialog); | |
| 553 if (retVal == JFileChooser.APPROVE_OPTION) { | |
| 554 execPathField.setText(fileChooser.getSelectedFile().getPath()); | |
| 555 } | |
| 556 } | |
| 557 }); | |
| 558 vbox = Box.createVerticalBox(); | |
| 559 vbox.add(browseCorePath); | |
| 560 vbox.add(browseExecPath); | |
| 561 hbox.add(vbox); | |
| 562 | |
| 563 panel.add(hbox); | |
| 564 dialog.getContentPane().add(panel, BorderLayout.NORTH); | |
| 565 | |
| 566 ActionListener attacher = new ActionListener() { | |
| 567 public void actionPerformed(ActionEvent e) { | |
| 568 dialog.setVisible(false); | |
| 569 desktop.remove(dialog); | |
| 570 workerThread.invokeLater(new Runnable() { | |
| 571 public void run() { | |
| 572 attach(execPathField.getText(), corePathField.getText()); | |
| 573 } | |
| 574 }); | |
| 575 } | |
| 576 }; | |
| 577 corePathField.addActionListener(attacher); | |
| 578 execPathField.addActionListener(attacher); | |
| 579 | |
| 580 vbox = Box.createVerticalBox(); | |
| 581 panel = new JPanel(); | |
| 582 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
| 583 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
| 584 JTextArea ta = new JTextArea( | |
| 585 "Enter the full path names to the core file from a HotSpot process " + | |
| 586 "and the Java executable from which it came. The latter is typically " + | |
| 587 "located in the JDK/JRE directory under the directory " + | |
| 588 "jre/bin/<arch>/native_threads."); | |
| 589 ta.setLineWrap(true); | |
| 590 ta.setWrapStyleWord(true); | |
| 591 ta.setEditable(false); | |
| 592 ta.setBackground(panel.getBackground()); | |
| 593 panel.add(ta); | |
| 594 vbox.add(panel); | |
| 595 | |
| 596 hbox = Box.createHorizontalBox(); | |
| 597 hbox.add(Box.createGlue()); | |
| 598 JButton button = new JButton("OK"); | |
| 599 button.addActionListener(attacher); | |
| 600 hbox.add(button); | |
| 601 hbox.add(Box.createHorizontalStrut(20)); | |
| 602 button = new JButton("Cancel"); | |
| 603 button.addActionListener(new ActionListener() { | |
| 604 public void actionPerformed(ActionEvent e) { | |
| 605 dialog.setVisible(false); | |
| 606 desktop.remove(dialog); | |
| 607 setMenuItemsEnabled(attachMenuItems, true); | |
| 608 } | |
| 609 }); | |
| 610 hbox.add(button); | |
| 611 hbox.add(Box.createGlue()); | |
| 612 panel = new JPanel(); | |
| 613 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 614 panel.add(hbox); | |
| 615 vbox.add(panel); | |
| 616 | |
| 617 dialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
| 618 | |
| 619 desktop.add(dialog); | |
| 620 dialog.setSize(500, 300); | |
| 621 GraphicsUtilities.centerInContainer(dialog); | |
| 622 dialog.show(); | |
| 623 corePathField.requestFocus(); | |
| 624 } | |
| 625 | |
| 626 // FIXME: merge showAttachDialog, showOpenCoreFileDialog, showConnectDialog | |
| 627 private void showConnectDialog() { | |
| 628 // FIXME: create filtered text field which only accepts numbers | |
| 629 setMenuItemsEnabled(attachMenuItems, false); | |
| 630 final JInternalFrame dialog = new JInternalFrame("Connect to HotSpot Debug Server"); | |
| 631 dialog.getContentPane().setLayout(new BorderLayout()); | |
| 632 | |
| 633 JPanel panel = new JPanel(); | |
| 634 panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS)); | |
| 635 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 636 dialog.setBackground(panel.getBackground()); | |
| 637 | |
| 638 panel.add(new JLabel("Enter machine name:")); | |
| 639 final JTextField pidTextField = new JTextField(40); | |
| 640 ActionListener attacher = new ActionListener() { | |
| 641 public void actionPerformed(ActionEvent e) { | |
| 642 dialog.setVisible(false); | |
| 643 desktop.remove(dialog); | |
| 644 workerThread.invokeLater(new Runnable() { | |
| 645 public void run() { | |
| 646 connect(pidTextField.getText()); | |
| 647 } | |
| 648 }); | |
| 649 } | |
| 650 }; | |
| 651 | |
| 652 pidTextField.addActionListener(attacher); | |
| 653 panel.add(pidTextField); | |
| 654 dialog.getContentPane().add(panel, BorderLayout.NORTH); | |
| 655 | |
| 656 Box vbox = Box.createVerticalBox(); | |
| 657 panel = new JPanel(); | |
| 658 panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); | |
| 659 panel.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8)); | |
| 660 JTextArea ta = new JTextArea( | |
| 661 "Enter the name of a machine on which the HotSpot \"Debug Server\" is " + | |
| 662 "running and is attached to a process or core file."); | |
| 663 ta.setLineWrap(true); | |
| 664 ta.setWrapStyleWord(true); | |
| 665 ta.setEditable(false); | |
| 666 ta.setBackground(panel.getBackground()); | |
| 667 panel.add(ta); | |
| 668 vbox.add(panel); | |
| 669 | |
| 670 Box hbox = Box.createHorizontalBox(); | |
| 671 hbox.add(Box.createGlue()); | |
| 672 JButton button = new JButton("OK"); | |
| 673 button.addActionListener(attacher); | |
| 674 hbox.add(button); | |
| 675 hbox.add(Box.createHorizontalStrut(20)); | |
| 676 button = new JButton("Cancel"); | |
| 677 button.addActionListener(new ActionListener() { | |
| 678 public void actionPerformed(ActionEvent e) { | |
| 679 dialog.setVisible(false); | |
| 680 desktop.remove(dialog); | |
| 681 setMenuItemsEnabled(attachMenuItems, true); | |
| 682 } | |
| 683 }); | |
| 684 hbox.add(button); | |
| 685 hbox.add(Box.createGlue()); | |
| 686 panel = new JPanel(); | |
| 687 panel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5)); | |
| 688 panel.add(hbox); | |
| 689 vbox.add(panel); | |
| 690 | |
| 691 dialog.getContentPane().add(vbox, BorderLayout.SOUTH); | |
| 692 | |
| 693 desktop.add(dialog); | |
| 694 dialog.setSize(400, 300); | |
| 695 GraphicsUtilities.centerInContainer(dialog); | |
| 696 dialog.show(); | |
| 697 pidTextField.requestFocus(); | |
| 698 } | |
| 699 | |
| 700 public void showThreadOopInspector(JavaThread thread) { | |
| 701 showInspector(new OopTreeNodeAdapter(thread.getThreadObj(), null)); | |
| 702 } | |
| 703 | |
| 704 public void showInspector(SimpleTreeNode adapter) { | |
| 705 showPanel("Inspector", new Inspector(adapter), 1.0f, 0.65f); | |
| 706 } | |
| 707 | |
| 708 public void showLiveness(Oop oop, LivenessPathList liveness) { | |
| 709 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
| 710 PrintStream tty = new PrintStream(bos); | |
| 711 int numPaths = liveness.size(); | |
| 712 for (int i = 0; i < numPaths; i++) { | |
| 713 tty.println("Path " + (i + 1) + " of " + numPaths + ":"); | |
| 714 liveness.get(i).printOn(tty); | |
| 715 } | |
| 716 JTextArea ta = new JTextArea(bos.toString()); | |
| 717 ta.setLineWrap(true); | |
| 718 ta.setWrapStyleWord(true); | |
| 719 ta.setEditable(false); | |
| 720 | |
| 721 JPanel panel = new JPanel(); | |
| 722 panel.setLayout(new BorderLayout()); | |
| 723 | |
| 724 JScrollPane scroller = new JScrollPane(); | |
| 725 scroller.getViewport().add(ta); | |
| 726 | |
| 727 panel.add(scroller, BorderLayout.CENTER); | |
| 728 | |
| 729 bos = new ByteArrayOutputStream(); | |
| 730 tty = new PrintStream(bos); | |
| 731 tty.print("Liveness result for "); | |
| 732 Oop.printOopValueOn(oop, tty); | |
| 733 | |
| 734 JInternalFrame frame = new JInternalFrame(bos.toString()); | |
| 735 frame.setResizable(true); | |
| 736 frame.setClosable(true); | |
| 737 frame.setIconifiable(true); | |
| 738 frame.getContentPane().setLayout(new BorderLayout()); | |
| 739 frame.getContentPane().add(panel, BorderLayout.CENTER); | |
| 740 frame.pack(); | |
| 741 desktop.add(frame); | |
| 742 GraphicsUtilities.reshapeToAspectRatio(frame, 0.5f / 0.2f, 0.5f, frame.getParent().getSize()); | |
| 743 frame.show(); | |
| 744 } | |
| 745 | |
| 746 private void fireComputeReversePtrs() { | |
| 747 // Possible this might have been computed elsewhere | |
| 748 if (VM.getVM().getRevPtrs() != null) { | |
| 749 computeRevPtrsMenuItem.setEnabled(false); | |
| 750 return; | |
| 751 } | |
| 752 | |
| 753 workerThread.invokeLater(new Runnable() { | |
| 754 public void run() { | |
| 755 HeapProgress progress = new HeapProgress("Reverse Pointers Analysis"); | |
| 756 try { | |
| 757 ReversePtrsAnalysis analysis = new ReversePtrsAnalysis(); | |
| 758 analysis.setHeapProgressThunk(progress); | |
| 759 analysis.run(); | |
| 760 computeRevPtrsMenuItem.setEnabled(false); | |
| 761 } catch (OutOfMemoryError e) { | |
| 762 final String errMsg = formatMessage(e.toString(), 80); | |
| 763 SwingUtilities.invokeLater(new Runnable() { | |
| 764 public void run() { | |
| 765 JOptionPane.showInternalMessageDialog(desktop, | |
| 766 "Error computing reverse pointers:" + errMsg, | |
| 767 "Error", | |
| 768 JOptionPane.WARNING_MESSAGE); | |
| 769 } | |
| 770 }); | |
| 771 } finally { | |
| 772 // make sure the progress bar goes away | |
| 773 progress.heapIterationComplete(); | |
| 774 } | |
| 775 } | |
| 776 }); | |
| 777 } | |
| 778 | |
| 779 // Simple struct containing signal information | |
| 780 class SignalInfo { | |
| 781 public int sigNum; | |
| 782 public String sigName; | |
| 783 } | |
| 784 | |
| 785 // Need to have mutable vframe as well as visible memory panel | |
| 786 abstract class StackWalker implements Runnable { | |
| 787 protected JavaVFrame vf; | |
| 788 protected AnnotatedMemoryPanel annoPanel; | |
| 789 | |
| 790 StackWalker(JavaVFrame vf, AnnotatedMemoryPanel annoPanel) { | |
| 791 this.vf = vf; | |
| 792 this.annoPanel = annoPanel; | |
| 793 } | |
| 794 } | |
| 795 | |
| 796 public void showThreadStackMemory(final JavaThread thread) { | |
| 797 // dumpStack(thread); | |
| 798 JavaVFrame vframe = getLastJavaVFrame(thread); | |
| 799 if (vframe == null) { | |
| 800 JOptionPane.showInternalMessageDialog(desktop, | |
| 801 "Thread \"" + thread.getThreadName() + | |
| 802 "\" has no Java frames on its stack", | |
| 803 "Show Stack Memory", | |
| 804 JOptionPane.INFORMATION_MESSAGE); | |
| 805 return; | |
| 806 } | |
| 807 | |
| 808 JInternalFrame stackFrame = new JInternalFrame("Stack Memory for " + thread.getThreadName()); | |
| 809 stackFrame.getContentPane().setLayout(new BorderLayout()); | |
| 810 stackFrame.setResizable(true); | |
| 811 stackFrame.setClosable(true); | |
| 812 stackFrame.setIconifiable(true); | |
| 813 final long addressSize = agent.getTypeDataBase().getAddressSize(); | |
| 814 boolean is64Bit = (addressSize == 8); | |
| 815 // This is somewhat of a hack to guess a thread's stack limits since the | |
| 816 // JavaThread doesn't support this functionality. However it is nice in that | |
| 817 // it locks us into the active region of the thread's stack and not its | |
| 818 // theoretical limits. | |
| 819 // | |
| 820 sun.jvm.hotspot.runtime.Frame tmpFrame = thread.getCurrentFrameGuess(); | |
| 821 Address sp = tmpFrame.getSP(); | |
| 822 Address starting = sp; | |
| 823 Address maxSP = starting; | |
| 824 Address minSP = starting; | |
| 825 RegisterMap tmpMap = thread.newRegisterMap(false); | |
| 826 while ((tmpFrame != null) && (!tmpFrame.isFirstFrame())) { | |
| 827 tmpFrame = tmpFrame.sender(tmpMap); | |
| 828 if (tmpFrame != null) { | |
| 829 sp = tmpFrame.getSP(); | |
| 830 if (sp != null) { | |
| 831 maxSP = AddressOps.max(maxSP, sp); | |
| 832 minSP = AddressOps.min(minSP, sp); | |
| 833 } | |
| 834 } | |
| 835 | |
| 836 } | |
| 837 // It is useful to be able to see say +/- 8K on the current stack range | |
| 838 AnnotatedMemoryPanel annoMemPanel = new AnnotatedMemoryPanel(agent.getDebugger(), is64Bit, starting, | |
| 839 minSP.addOffsetTo(-8192), | |
| 840 maxSP.addOffsetTo( 8192)); | |
| 841 | |
| 842 stackFrame.getContentPane().add(annoMemPanel, BorderLayout.CENTER); | |
| 843 desktop.add(stackFrame); | |
| 844 GraphicsUtilities.reshapeToAspectRatio(stackFrame, 4.0f / 3.0f, 0.85f, stackFrame.getParent().getSize()); | |
| 845 stackFrame.show(); | |
| 846 | |
| 847 // Stackmap computation for interpreted frames is expensive; do | |
| 848 // all stackwalking work in another thread for better GUI | |
| 849 // responsiveness | |
| 850 workerThread.invokeLater(new StackWalker(vframe, annoMemPanel) { | |
| 851 public void run() { | |
| 852 Address startAddr = null; | |
| 853 | |
| 854 // As this is a debugger, we want to provide potential crash | |
| 855 // information to the user, i.e., by marking signal handler frames | |
| 856 // on the stack. Since this system is currently targeted at | |
| 857 // annotating the Java frames (interpreted or compiled) on the | |
| 858 // stack and not, for example, "external" frames (note the current | |
| 859 // absence of a PC-to-symbol lookup mechanism at the Debugger | |
| 860 // level), we want to mark any Java frames which were interrupted | |
| 861 // by a signal. We do this by making two passes over the stack, | |
| 862 // one which finds signal handler frames and puts the parent | |
| 863 // frames in a table and one which finds Java frames and if they | |
| 864 // are in the table indicates that they were interrupted by a signal. | |
| 865 | |
| 866 Map interruptedFrameMap = new HashMap(); | |
| 867 { | |
| 868 sun.jvm.hotspot.runtime.Frame tmpFrame = thread.getCurrentFrameGuess(); | |
| 869 RegisterMap tmpMap = thread.newRegisterMap(false); | |
| 870 while ((tmpFrame != null) && (!tmpFrame.isFirstFrame())) { | |
| 871 if (tmpFrame.isSignalHandlerFrameDbg()) { | |
| 872 // Add some information to the map that we can extract later | |
| 873 sun.jvm.hotspot.runtime.Frame interruptedFrame = tmpFrame.sender(tmpMap); | |
| 874 SignalInfo info = new SignalInfo(); | |
| 875 info.sigNum = tmpFrame.getSignalNumberDbg(); | |
| 876 info.sigName = tmpFrame.getSignalNameDbg(); | |
| 877 interruptedFrameMap.put(interruptedFrame, info); | |
| 878 } | |
| 879 tmpFrame = tmpFrame.sender(tmpMap); | |
| 880 } | |
| 881 } | |
| 882 | |
| 883 while (vf != null) { | |
| 884 String anno = null; | |
| 885 JavaVFrame curVFrame = vf; | |
| 886 sun.jvm.hotspot.runtime.Frame curFrame = curVFrame.getFrame(); | |
| 887 Method interpreterFrameMethod = null; | |
| 888 | |
| 889 if (curVFrame.isInterpretedFrame()) { | |
| 890 anno = "Interpreted frame"; | |
| 891 } else { | |
| 892 anno = "Compiled frame"; | |
| 893 if (curVFrame.isDeoptimized()) { | |
| 894 anno += " (deoptimized)"; | |
| 895 } | |
| 896 } | |
| 897 if (curVFrame.mayBeImpreciseDbg()) { | |
| 898 anno += "; information may be imprecise"; | |
| 899 } | |
| 900 | |
| 901 if (curVFrame.isInterpretedFrame()) { | |
| 902 // Find the codelet | |
| 903 InterpreterCodelet codelet = VM.getVM().getInterpreter().getCodeletContaining(curFrame.getPC()); | |
| 904 String description = null; | |
| 905 if (codelet != null) { | |
| 906 description = codelet.getDescription(); | |
| 907 } | |
| 908 if (description == null) { | |
| 909 anno += "\n(Unknown interpreter codelet)"; | |
| 910 } else { | |
| 911 anno += "\nExecuting in codelet \"" + description + "\" at PC = " + curFrame.getPC(); | |
| 912 } | |
| 913 } else if (curVFrame.isCompiledFrame()) { | |
| 914 anno += "\nExecuting at PC = " + curFrame.getPC(); | |
| 915 } | |
| 916 | |
| 917 if (startAddr == null) { | |
| 918 startAddr = curFrame.getSP(); | |
| 919 } | |
| 920 | |
| 921 // FIXME: some compiled frames with empty oop map sets have been | |
| 922 // found (for example, Vector's inner Enumeration class, method | |
| 923 // "hasMoreElements"). Not sure yet why these cases are showing | |
| 924 // up -- should be possible (though unlikely) for safepoint code | |
| 925 // to patch the return instruction of these methods and then | |
| 926 // later attempt to get an oop map for that instruction. For | |
| 927 // now, we warn if we find such a method. | |
| 928 boolean shouldSkipOopMaps = false; | |
| 929 if (curVFrame.isCompiledFrame()) { | |
| 930 CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC()); | |
| 931 OopMapSet maps = cb.getOopMaps(); | |
| 932 if ((maps == null) || (maps.getSize() == 0)) { | |
| 933 shouldSkipOopMaps = true; | |
| 934 } | |
| 935 } | |
| 936 | |
| 937 // Add signal information to annotation if necessary | |
| 938 SignalInfo sigInfo = (SignalInfo) interruptedFrameMap.get(curFrame); | |
| 939 if (sigInfo != null) { | |
| 940 // This frame took a signal and we need to report it. | |
| 941 anno = (anno + "\n*** INTERRUPTED BY SIGNAL " + Integer.toString(sigInfo.sigNum) + | |
| 942 " (" + sigInfo.sigName + ")"); | |
| 943 } | |
| 944 | |
| 945 JavaVFrame nextVFrame = curVFrame; | |
| 946 sun.jvm.hotspot.runtime.Frame nextFrame = curFrame; | |
| 947 do { | |
| 948 curVFrame = nextVFrame; | |
| 949 curFrame = nextFrame; | |
| 950 | |
| 951 try { | |
| 952 Method method = curVFrame.getMethod(); | |
| 953 if (interpreterFrameMethod == null && curVFrame.isInterpretedFrame()) { | |
| 954 interpreterFrameMethod = method; | |
| 955 } | |
| 956 int bci = curVFrame.getBCI(); | |
| 957 String lineNumberAnno = ""; | |
| 958 if (method.hasLineNumberTable()) { | |
| 959 if ((bci == DebugInformationRecorder.SYNCHRONIZATION_ENTRY_BCI) || | |
| 960 (bci >= 0 && bci < method.getCodeSize())) { | |
| 961 lineNumberAnno = ", line " + method.getLineNumberFromBCI(bci); | |
| 962 } else { | |
| 963 lineNumberAnno = " (INVALID BCI)"; | |
| 964 } | |
| 965 } | |
| 966 anno += "\n" + method.getMethodHolder().getName().asString() + "." + | |
| 967 method.getName().asString() + method.getSignature().asString() + | |
| 968 "\n@bci " + bci + lineNumberAnno; | |
| 969 } catch (Exception e) { | |
| 970 anno += "\n(ERROR while iterating vframes for frame " + curFrame + ")"; | |
| 971 } | |
| 972 | |
| 973 nextVFrame = curVFrame.javaSender(); | |
| 974 if (nextVFrame != null) { | |
| 975 nextFrame = nextVFrame.getFrame(); | |
| 976 } | |
| 977 } while (nextVFrame != null && nextFrame.equals(curFrame)); | |
| 978 | |
| 979 if (shouldSkipOopMaps) { | |
| 980 anno = anno + "\nNOTE: null or empty OopMapSet found for this CodeBlob"; | |
| 981 } | |
| 982 | |
| 983 if (curFrame.getFP() != null) { | |
| 984 annoPanel.addAnnotation(new Annotation(curFrame.getSP(), | |
| 985 curFrame.getFP(), | |
| 986 anno)); | |
| 987 } else { | |
| 988 if (VM.getVM().getCPU().equals("x86") || VM.getVM().getCPU().equals("amd64")) { | |
| 989 // For C2, which has null frame pointers on x86/amd64 | |
| 990 CodeBlob cb = VM.getVM().getCodeCache().findBlob(curFrame.getPC()); | |
| 991 Address sp = curFrame.getSP(); | |
| 992 if (Assert.ASSERTS_ENABLED) { | |
| 993 Assert.that(cb.getFrameSize() > 0, "CodeBlob must have non-zero frame size"); | |
| 994 } | |
| 995 annoPanel.addAnnotation(new Annotation(sp, | |
| 996 sp.addOffsetTo(cb.getFrameSize()), | |
| 997 anno)); | |
| 998 } else { | |
| 999 Assert.that(VM.getVM().getCPU().equals("ia64"), "only ia64 should reach here"); | |
| 1000 } | |
| 1001 } | |
| 1002 | |
| 1003 // Add interpreter frame annotations | |
| 1004 if (curFrame.isInterpretedFrame()) { | |
| 1005 annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameExpressionStack(), | |
| 1006 curFrame.addressOfInterpreterFrameTOS(), | |
| 1007 "Interpreter expression stack")); | |
| 1385 | 1008 Address monBegin = curFrame.interpreterFrameMonitorBegin().address(); |
| 1009 Address monEnd = curFrame.interpreterFrameMonitorEnd().address(); | |
| 1010 if (!monBegin.equals(monEnd)) { | |
| 1011 annoPanel.addAnnotation(new Annotation(monBegin, monEnd, | |
| 1012 "BasicObjectLocks")); | |
| 1013 } | |
| 0 | 1014 if (interpreterFrameMethod != null) { |
| 1015 // The offset is just to get the right stack slots highlighted in the output | |
| 1016 int offset = 1; | |
| 1017 annoPanel.addAnnotation(new Annotation(curFrame.addressOfInterpreterFrameLocal(offset), | |
| 1018 curFrame.addressOfInterpreterFrameLocal((int) interpreterFrameMethod.getMaxLocals() + offset), | |
| 1019 "Interpreter locals area for frame with SP = " + curFrame.getSP())); | |
| 1020 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3908
diff
changeset
|
1021 String methodAnno = "Interpreter frame Method*"; |
| 0 | 1022 if (interpreterFrameMethod == null) { |
| 1023 methodAnno += " (BAD OOP)"; | |
| 1024 } | |
| 1025 Address a = curFrame.addressOfInterpreterFrameMethod(); | |
| 1026 annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(addressSize), methodAnno)); | |
| 1027 a = curFrame.addressOfInterpreterFrameCPCache(); | |
| 1028 annoPanel.addAnnotation(new Annotation(a, a.addOffsetTo(addressSize), "Interpreter constant pool cache")); | |
| 1029 } | |
| 1030 | |
| 1031 RegisterMap rm = (RegisterMap) vf.getRegisterMap().clone(); | |
| 1032 if (!shouldSkipOopMaps) { | |
| 1033 try { | |
| 1034 curFrame.oopsDo(new AddressVisitor() { | |
| 1035 public void visitAddress(Address addr) { | |
| 1036 if (Assert.ASSERTS_ENABLED) { | |
| 1037 Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null, | |
| 1038 "Address " + addr + "should have been aligned"); | |
| 1039 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1040 OopHandle handle = addr.getOopHandleAt(0); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1041 addAnnotation(addr, handle); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1042 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1043 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1044 public void visitCompOopAddress(Address addr) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1045 if (Assert.ASSERTS_ENABLED) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1046 Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1047 "Address " + addr + "should have been aligned"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1048 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1049 OopHandle handle = addr.getCompOopHandleAt(0); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1050 addAnnotation(addr, handle); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1051 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1052 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1053 public void addAnnotation(Address addr, OopHandle handle) { |
| 0 | 1054 // Check contents |
| 1055 String anno = "null oop"; | |
| 1056 if (handle != null) { | |
| 1057 // Find location | |
| 1058 CollectedHeap collHeap = VM.getVM().getUniverse().heap(); | |
| 1059 boolean bad = true; | |
| 1060 anno = "BAD OOP"; | |
| 1061 if (collHeap instanceof GenCollectedHeap) { | |
| 1062 GenCollectedHeap heap = (GenCollectedHeap) collHeap; | |
| 1063 for (int i = 0; i < heap.nGens(); i++) { | |
| 1064 if (heap.getGen(i).isIn(handle)) { | |
| 1065 if (i == 0) { | |
| 1066 anno = "NewGen "; | |
| 1067 } else if (i == 1) { | |
| 1068 anno = "OldGen "; | |
| 1069 } else { | |
| 1070 anno = "Gen " + i + " "; | |
| 1071 } | |
| 1072 bad = false; | |
| 1073 break; | |
| 1074 } | |
| 1075 } | |
| 1076 | |
| 1077 } else if (collHeap instanceof ParallelScavengeHeap) { | |
| 1078 ParallelScavengeHeap heap = (ParallelScavengeHeap) collHeap; | |
| 1079 if (heap.youngGen().isIn(handle)) { | |
| 1080 anno = "PSYoungGen "; | |
| 1081 bad = false; | |
| 1082 } else if (heap.oldGen().isIn(handle)) { | |
| 1083 anno = "PSOldGen "; | |
| 1084 bad = false; | |
| 1085 } | |
| 1086 } else { | |
| 1087 // Optimistically assume the oop isn't bad | |
| 1088 anno = "[Unknown generation] "; | |
| 1089 bad = false; | |
| 1090 } | |
| 1091 | |
| 1092 if (!bad) { | |
| 1093 try { | |
| 1094 Oop oop = VM.getVM().getObjectHeap().newOop(handle); | |
| 1095 if (oop instanceof Instance) { | |
| 1096 // Java-level objects always have workable names | |
| 1097 anno = anno + oop.getKlass().getName().asString(); | |
| 1098 } else { | |
| 1099 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
| 1100 Oop.printOopValueOn(oop, new PrintStream(bos)); | |
| 1101 anno = anno + bos.toString(); | |
| 1102 } | |
| 1103 } | |
| 1104 catch (AddressException e) { | |
| 1105 anno += "CORRUPT OOP"; | |
| 1106 } | |
| 1107 catch (NullPointerException e) { | |
| 1108 anno += "CORRUPT OOP (null pointer)"; | |
| 1109 } | |
| 1110 } | |
| 1111 } | |
| 1112 | |
| 1113 annoPanel.addAnnotation(new Annotation(addr, addr.addOffsetTo(addressSize), anno)); | |
| 1114 } | |
| 1115 }, rm); | |
| 1116 } catch (Exception e) { | |
| 1117 System.err.println("Error while performing oopsDo for frame " + curFrame); | |
| 1118 e.printStackTrace(); | |
| 1119 } | |
| 1120 } | |
| 1121 | |
| 1122 vf = nextVFrame; | |
| 1123 } | |
| 1124 | |
| 1125 // This used to paint as we walked the frames. This caused the display to be refreshed | |
| 1126 // enough to be annoying on remote displays. It also would cause the annotations to | |
| 1127 // be displayed in varying order which caused some annotations to overwrite others | |
| 1128 // depending on the races between painting and adding annotations. This latter problem | |
| 1129 // still exists to some degree but moving this code here definitely seems to reduce it | |
| 1130 annoPanel.makeVisible(startAddr); | |
| 1131 annoPanel.repaint(); | |
| 1132 } | |
| 1133 }); | |
| 1134 } | |
| 1135 | |
|
11054
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1136 // Attach to existing JVMDebugger, which should be already attached to a core/process. |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1137 private void attach(JVMDebugger d) { |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1138 attached = true; |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1139 showThreadsDialog(); |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1140 } |
|
38ea2efa32a7
8010278: SA: provide mechanism for using an alternative SA debugger back-end.
kevinw
parents:
6725
diff
changeset
|
1141 |
| 0 | 1142 /** NOTE we are in a different thread here than either the main |
| 1143 thread or the Swing/AWT event handler thread, so we must be very | |
| 1144 careful when creating or removing widgets */ | |
| 1145 private void attach(String pidText) { | |
| 1146 try { | |
| 1147 this.pidText = pidText; | |
| 1148 pid = Integer.parseInt(pidText); | |
| 1149 } | |
| 1150 catch (NumberFormatException e) { | |
| 1151 SwingUtilities.invokeLater(new Runnable() { | |
| 1152 public void run() { | |
| 1153 setMenuItemsEnabled(attachMenuItems, true); | |
| 1154 JOptionPane.showInternalMessageDialog(desktop, | |
| 1155 "Unable to parse process ID \"" + HSDB.this.pidText + "\".\nPlease enter a number.", | |
| 1156 "Parse error", | |
| 1157 JOptionPane.WARNING_MESSAGE); | |
| 1158 } | |
| 1159 }); | |
| 1160 return; | |
| 1161 } | |
| 1162 | |
| 1163 // Try to attach to this process | |
| 1164 Runnable remover = new Runnable() { | |
| 1165 public void run() { | |
| 1166 attachWaitDialog.setVisible(false); | |
| 1167 desktop.remove(attachWaitDialog); | |
| 1168 attachWaitDialog = null; | |
| 1169 } | |
| 1170 }; | |
| 1171 | |
| 1172 try { | |
| 1173 SwingUtilities.invokeLater(new Runnable() { | |
| 1174 public void run() { | |
| 1175 JOptionPane pane = new JOptionPane("Attaching to process " + pid + ", please wait...", JOptionPane.INFORMATION_MESSAGE); | |
| 1176 pane.setOptions(new Object[] {}); | |
| 1177 attachWaitDialog = pane.createInternalFrame(desktop, "Attaching to Process"); | |
| 1178 attachWaitDialog.show(); | |
| 1179 } | |
| 1180 }); | |
| 1181 | |
| 1182 // FIXME: display exec'd debugger's output messages during this | |
| 1183 // lengthy call | |
| 1184 agent.attach(pid); | |
| 1185 if (agent.getDebugger().hasConsole()) { | |
| 1186 showDbgConsoleMenuItem.setEnabled(true); | |
| 1187 } | |
| 1188 attached = true; | |
| 1189 SwingUtilities.invokeLater(remover); | |
| 1190 } | |
| 1191 catch (DebuggerException e) { | |
| 1192 SwingUtilities.invokeLater(remover); | |
| 1193 final String errMsg = formatMessage(e.getMessage(), 80); | |
| 1194 SwingUtilities.invokeLater(new Runnable() { | |
| 1195 public void run() { | |
| 1196 setMenuItemsEnabled(attachMenuItems, true); | |
| 1197 JOptionPane.showInternalMessageDialog(desktop, | |
| 1198 "Unable to connect to process ID " + pid + ":\n\n" + errMsg, | |
| 1199 "Unable to Connect", | |
| 1200 JOptionPane.WARNING_MESSAGE); | |
| 1201 } | |
| 1202 }); | |
| 1203 agent.detach(); | |
| 1204 return; | |
| 1205 } | |
| 1206 | |
| 1207 // OK, the VM should be available. Create the Threads dialog. | |
| 1208 showThreadsDialog(); | |
| 1209 } | |
| 1210 | |
| 1211 /** NOTE we are in a different thread here than either the main | |
| 1212 thread or the Swing/AWT event handler thread, so we must be very | |
| 1213 careful when creating or removing widgets */ | |
| 1214 private void attach(final String executablePath, final String corePath) { | |
| 1215 // Try to open this core file | |
| 1216 Runnable remover = new Runnable() { | |
| 1217 public void run() { | |
| 1218 attachWaitDialog.setVisible(false); | |
| 1219 desktop.remove(attachWaitDialog); | |
| 1220 attachWaitDialog = null; | |
| 1221 } | |
| 1222 }; | |
| 1223 | |
| 1224 try { | |
| 1225 SwingUtilities.invokeLater(new Runnable() { | |
| 1226 public void run() { | |
| 1227 JOptionPane pane = new JOptionPane("Opening core file, please wait...", JOptionPane.INFORMATION_MESSAGE); | |
| 1228 pane.setOptions(new Object[] {}); | |
| 1229 attachWaitDialog = pane.createInternalFrame(desktop, "Opening Core File"); | |
| 1230 attachWaitDialog.show(); | |
| 1231 } | |
| 1232 }); | |
| 1233 | |
| 1234 // FIXME: display exec'd debugger's output messages during this | |
| 1235 // lengthy call | |
| 1236 agent.attach(executablePath, corePath); | |
| 1237 if (agent.getDebugger().hasConsole()) { | |
| 1238 showDbgConsoleMenuItem.setEnabled(true); | |
| 1239 } | |
| 1240 attached = true; | |
| 1241 SwingUtilities.invokeLater(remover); | |
| 1242 } | |
| 1243 catch (DebuggerException e) { | |
| 1244 SwingUtilities.invokeLater(remover); | |
| 1245 final String errMsg = formatMessage(e.getMessage(), 80); | |
| 1246 SwingUtilities.invokeLater(new Runnable() { | |
| 1247 public void run() { | |
| 1248 setMenuItemsEnabled(attachMenuItems, true); | |
| 1249 JOptionPane.showInternalMessageDialog(desktop, | |
| 1250 "Unable to open core file\n" + corePath + ":\n\n" + errMsg, | |
| 1251 "Unable to Open Core File", | |
| 1252 JOptionPane.WARNING_MESSAGE); | |
| 1253 } | |
| 1254 }); | |
| 1255 agent.detach(); | |
| 1256 return; | |
| 1257 } | |
| 1258 | |
| 1259 // OK, the VM should be available. Create the Threads dialog. | |
| 1260 showThreadsDialog(); | |
| 1261 } | |
| 1262 | |
| 1263 /** NOTE we are in a different thread here than either the main | |
| 1264 thread or the Swing/AWT event handler thread, so we must be very | |
| 1265 careful when creating or removing widgets */ | |
| 1266 private void connect(final String remoteMachineName) { | |
| 1267 // Try to open this core file | |
| 1268 Runnable remover = new Runnable() { | |
| 1269 public void run() { | |
| 1270 attachWaitDialog.setVisible(false); | |
| 1271 desktop.remove(attachWaitDialog); | |
| 1272 attachWaitDialog = null; | |
| 1273 } | |
| 1274 }; | |
| 1275 | |
| 1276 try { | |
| 1277 SwingUtilities.invokeLater(new Runnable() { | |
| 1278 public void run() { | |
| 1279 JOptionPane pane = new JOptionPane("Connecting to debug server, please wait...", JOptionPane.INFORMATION_MESSAGE); | |
| 1280 pane.setOptions(new Object[] {}); | |
| 1281 attachWaitDialog = pane.createInternalFrame(desktop, "Connecting to Debug Server"); | |
| 1282 attachWaitDialog.show(); | |
| 1283 } | |
| 1284 }); | |
| 1285 | |
| 1286 agent.attach(remoteMachineName); | |
| 1287 if (agent.getDebugger().hasConsole()) { | |
| 1288 showDbgConsoleMenuItem.setEnabled(true); | |
| 1289 } | |
| 1290 attached = true; | |
| 1291 SwingUtilities.invokeLater(remover); | |
| 1292 } | |
| 1293 catch (DebuggerException e) { | |
| 1294 SwingUtilities.invokeLater(remover); | |
| 1295 final String errMsg = formatMessage(e.getMessage(), 80); | |
| 1296 SwingUtilities.invokeLater(new Runnable() { | |
| 1297 public void run() { | |
| 1298 setMenuItemsEnabled(attachMenuItems, true); | |
| 1299 JOptionPane.showInternalMessageDialog(desktop, | |
| 1300 "Unable to connect to machine \"" + remoteMachineName + "\":\n\n" + errMsg, | |
| 1301 "Unable to Connect", | |
| 1302 JOptionPane.WARNING_MESSAGE); | |
| 1303 } | |
| 1304 }); | |
| 1305 agent.detach(); | |
| 1306 return; | |
| 1307 } | |
| 1308 | |
| 1309 // OK, the VM should be available. Create the Threads dialog. | |
| 1310 showThreadsDialog(); | |
| 1311 } | |
| 1312 | |
| 1313 private void detachDebugger() { | |
| 1314 if (!attached) { | |
| 1315 return; | |
| 1316 } | |
| 1317 agent.detach(); | |
| 1318 attached = false; | |
| 1319 } | |
| 1320 | |
| 1321 private void detach() { | |
| 1322 detachDebugger(); | |
| 1323 attachWaitDialog = null; | |
| 1324 threadsFrame = null; | |
| 1325 consoleFrame = null; | |
| 1326 setMenuItemsEnabled(attachMenuItems, true); | |
| 1327 setMenuItemsEnabled(detachMenuItems, false); | |
| 1328 toolsMenu.setEnabled(false); | |
| 1329 showDbgConsoleMenuItem.setEnabled(false); | |
| 1330 // FIXME: is this sufficient, or will I have to do anything else | |
| 1331 // to the components to kill them off? What about WorkerThreads? | |
| 1332 desktop.removeAll(); | |
| 1333 desktop.invalidate(); | |
| 1334 desktop.validate(); | |
| 1335 desktop.repaint(); | |
| 1336 } | |
| 1337 | |
| 1338 /** NOTE that this is called from another thread than the main or | |
| 1339 Swing thread and we have to be careful about synchronization */ | |
| 1340 private void showThreadsDialog() { | |
| 1341 SwingUtilities.invokeLater(new Runnable() { | |
| 1342 public void run() { | |
| 1343 threadsFrame = new JInternalFrame("Java Threads"); | |
| 1344 threadsFrame.setResizable(true); | |
| 1345 threadsFrame.setIconifiable(true); | |
| 1346 JavaThreadsPanel threadsPanel = new JavaThreadsPanel(); | |
| 1347 threadsPanel.addPanelListener(HSDB.this); | |
| 1348 threadsFrame.getContentPane().add(threadsPanel); | |
| 1349 threadsFrame.setSize(500, 300); | |
| 1350 threadsFrame.pack(); | |
| 1351 desktop.add(threadsFrame); | |
| 1352 GraphicsUtilities.moveToInContainer(threadsFrame, 0.75f, 0.25f, 0, 20); | |
| 1353 threadsFrame.show(); | |
| 1354 setMenuItemsEnabled(attachMenuItems, false); | |
| 1355 setMenuItemsEnabled(detachMenuItems, true); | |
| 1356 toolsMenu.setEnabled(true); | |
| 1357 VM.registerVMInitializedObserver(new Observer() { | |
| 1358 public void update(Observable o, Object data) { | |
| 1359 computeRevPtrsMenuItem.setEnabled(true); | |
| 1360 } | |
| 1361 }); | |
| 1362 } | |
| 1363 }); | |
| 1364 } | |
| 1365 | |
| 1366 private void showObjectHistogram() { | |
| 1367 sun.jvm.hotspot.oops.ObjectHistogram histo = new sun.jvm.hotspot.oops.ObjectHistogram(); | |
| 1368 ObjectHistogramCleanupThunk cleanup = | |
| 1369 new ObjectHistogramCleanupThunk(histo); | |
| 1370 doHeapIteration("Object Histogram", | |
| 1371 "Generating histogram...", | |
| 1372 histo, | |
| 1373 cleanup); | |
| 1374 } | |
| 1375 | |
| 1376 class ObjectHistogramCleanupThunk implements CleanupThunk { | |
| 1377 sun.jvm.hotspot.oops.ObjectHistogram histo; | |
| 1378 | |
| 1379 ObjectHistogramCleanupThunk(sun.jvm.hotspot.oops.ObjectHistogram histo) { | |
| 1380 this.histo = histo; | |
| 1381 } | |
| 1382 | |
| 1383 public void heapIterationComplete() { | |
| 1384 SwingUtilities.invokeLater(new Runnable() { | |
| 1385 public void run() { | |
| 1386 JInternalFrame histoFrame = new JInternalFrame("Object Histogram"); | |
| 1387 histoFrame.setResizable(true); | |
| 1388 histoFrame.setClosable(true); | |
| 1389 histoFrame.setIconifiable(true); | |
| 1390 histoFrame.getContentPane().setLayout(new BorderLayout()); | |
| 1391 ObjectHistogramPanel panel = new ObjectHistogramPanel(histo); | |
| 1392 panel.addPanelListener(HSDB.this); | |
| 1393 histoFrame.getContentPane().add(panel); | |
| 1394 desktop.add(histoFrame); | |
| 1395 GraphicsUtilities.reshapeToAspectRatio(histoFrame, 4.0f / 3.0f, 0.6f, | |
| 1396 histoFrame.getParent().getSize()); | |
| 1397 GraphicsUtilities.centerInContainer(histoFrame); | |
| 1398 histoFrame.show(); | |
| 1399 } | |
| 1400 }); | |
| 1401 } | |
| 1402 } | |
| 1403 | |
| 1404 public void showObjectsOfType(Klass type) { | |
| 1405 FindObjectByType finder = new FindObjectByType(type); | |
| 1406 FindObjectByTypeCleanupThunk cleanup = | |
| 1407 new FindObjectByTypeCleanupThunk(finder); | |
| 1408 ByteArrayOutputStream bos = new ByteArrayOutputStream(); | |
| 1409 type.printValueOn(new PrintStream(bos)); | |
| 1410 String typeName = bos.toString(); | |
| 1411 doHeapIteration("Show Objects Of Type", | |
| 1412 "Finding instances of \"" + typeName + "\"", | |
| 1413 finder, | |
| 1414 cleanup); | |
| 1415 } | |
| 1416 | |
| 1417 class FindObjectByTypeCleanupThunk implements CleanupThunk { | |
| 1418 FindObjectByType finder; | |
| 1419 | |
| 1420 FindObjectByTypeCleanupThunk(FindObjectByType finder) { | |
| 1421 this.finder = finder; | |
| 1422 } | |
| 1423 | |
| 1424 public void heapIterationComplete() { | |
| 1425 SwingUtilities.invokeLater(new Runnable() { | |
| 1426 public void run() { | |
| 1427 JInternalFrame finderFrame = new JInternalFrame("Show Objects of Type"); | |
| 1428 finderFrame.getContentPane().setLayout(new BorderLayout()); | |
| 1429 finderFrame.setResizable(true); | |
| 1430 finderFrame.setClosable(true); | |
| 1431 finderFrame.setIconifiable(true); | |
| 1432 ObjectListPanel panel = new ObjectListPanel(finder.getResults(), | |
| 1433 new HeapProgress("Reverse Pointers Analysis")); | |
| 1434 panel.addPanelListener(HSDB.this); | |
| 1435 finderFrame.getContentPane().add(panel); | |
| 1436 desktop.add(finderFrame); | |
| 1437 GraphicsUtilities.reshapeToAspectRatio(finderFrame, 4.0f / 3.0f, 0.6f, | |
| 1438 finderFrame.getParent().getSize()); | |
| 1439 GraphicsUtilities.centerInContainer(finderFrame); | |
| 1440 finderFrame.show(); | |
| 1441 } | |
| 1442 }); | |
| 1443 } | |
| 1444 } | |
| 1445 | |
| 1446 private void showDebuggerConsole() { | |
| 1447 if (consoleFrame == null) { | |
| 1448 consoleFrame = new JInternalFrame("Debugger Console"); | |
| 1449 consoleFrame.setResizable(true); | |
| 1450 consoleFrame.setClosable(true); | |
| 1451 consoleFrame.setIconifiable(true); | |
| 1452 consoleFrame.getContentPane().setLayout(new BorderLayout()); | |
| 1453 consoleFrame.getContentPane().add(new DebuggerConsolePanel(agent.getDebugger()), BorderLayout.CENTER); | |
| 1454 GraphicsUtilities.reshapeToAspectRatio(consoleFrame, 5.0f, 0.9f, desktop.getSize()); | |
| 1455 } | |
| 1456 if (consoleFrame.getParent() == null) { | |
| 1457 desktop.add(consoleFrame); | |
| 1458 } | |
| 1459 consoleFrame.setVisible(true); | |
| 1460 consoleFrame.show(); | |
| 1461 consoleFrame.getContentPane().getComponent(0).requestFocus(); | |
| 1462 } | |
| 1463 | |
| 1464 private void showConsole() { | |
| 1465 CommandProcessor.DebuggerInterface di = new CommandProcessor.DebuggerInterface() { | |
| 1466 public HotSpotAgent getAgent() { | |
| 1467 return agent; | |
| 1468 } | |
| 1469 public boolean isAttached() { | |
| 1470 return attached; | |
| 1471 } | |
| 1472 public void attach(String pid) { | |
| 1473 attach(pid); | |
| 1474 } | |
| 1475 public void attach(String java, String core) { | |
| 1476 } | |
| 1477 public void detach() { | |
| 1478 detachDebugger(); | |
| 1479 } | |
| 1480 public void reattach() { | |
| 1481 if (attached) { | |
| 1482 detachDebugger(); | |
| 1483 } | |
| 1484 if (pidText != null) { | |
| 1485 attach(pidText); | |
| 1486 } else { | |
| 1487 attach(execPath, coreFilename); | |
| 1488 } | |
| 1489 } | |
| 1490 }; | |
| 1491 | |
| 1492 showPanel("Command Line", new CommandProcessorPanel(new CommandProcessor(di, null, null, null))); | |
| 1493 } | |
| 1494 | |
| 1495 private void showFindByQueryPanel() { | |
| 1496 showPanel("Find Object by Query", new FindByQueryPanel()); | |
| 1497 } | |
| 1498 | |
| 1499 private void showFindPanel() { | |
| 1500 showPanel("Find Pointer", new FindPanel()); | |
| 1501 } | |
| 1502 | |
| 1503 private void showFindInHeapPanel() { | |
| 1504 showPanel("Find Address In Heap", new FindInHeapPanel()); | |
| 1505 } | |
| 1506 | |
| 1507 private void showFindInCodeCachePanel() { | |
| 1508 showPanel("Find Address In Code Cache", new FindInCodeCachePanel()); | |
| 1509 } | |
| 1510 | |
| 1511 private void showHeapParametersPanel() { | |
| 1512 showPanel("Heap Parameters", new HeapParametersPanel()); | |
| 1513 } | |
| 1514 | |
| 1515 public void showThreadInfo(final JavaThread thread) { | |
| 1516 showPanel("Info for " + thread.getThreadName(), new ThreadInfoPanel(thread)); | |
| 1517 } | |
| 1518 | |
| 1519 public void showJavaStackTrace(final JavaThread thread) { | |
| 1520 JavaStackTracePanel jstp = new JavaStackTracePanel(); | |
| 1521 showPanel("Java stack trace for " + thread.getThreadName(), jstp); | |
| 1522 jstp.setJavaThread(thread); | |
| 1523 } | |
| 1524 | |
| 1525 private void showDeadlockDetectionPanel() { | |
| 1526 showPanel("Deadlock Detection", new DeadlockDetectionPanel()); | |
| 1527 } | |
| 1528 | |
| 1529 private void showMonitorCacheDumpPanel() { | |
| 1530 showPanel("Monitor Cache Dump", new MonitorCacheDumpPanel()); | |
| 1531 } | |
| 1532 | |
| 1533 public void showClassBrowser() { | |
| 1534 final JInternalFrame progressFrame = new JInternalFrame("Class Browser"); | |
| 1535 progressFrame.setResizable(true); | |
| 1536 progressFrame.setClosable(true); | |
| 1537 progressFrame.setIconifiable(true); | |
| 1538 progressFrame.getContentPane().setLayout(new BorderLayout()); | |
| 1539 final ProgressBarPanel bar = new ProgressBarPanel("Generating class list .."); | |
| 1540 bar.setIndeterminate(true); | |
| 1541 progressFrame.getContentPane().add(bar, BorderLayout.CENTER); | |
| 1542 desktop.add(progressFrame); | |
| 1543 progressFrame.pack(); | |
| 1544 GraphicsUtilities.centerInContainer(progressFrame); | |
| 1545 progressFrame.show(); | |
| 1546 | |
| 1547 workerThread.invokeLater(new Runnable() { | |
| 1548 public void run() { | |
| 1549 HTMLGenerator htmlGen = new HTMLGenerator(); | |
| 1550 InstanceKlass[] klasses = SystemDictionaryHelper.getAllInstanceKlasses(); | |
| 1551 final String htmlText = htmlGen.genHTMLForKlassNames(klasses); | |
| 1552 SwingUtilities.invokeLater(new Runnable() { | |
| 1553 public void run() { | |
| 1554 JInternalFrame cbFrame = new JInternalFrame("Class Browser"); | |
| 1555 cbFrame.getContentPane().setLayout(new BorderLayout()); | |
| 1556 cbFrame.setResizable(true); | |
| 1557 cbFrame.setClosable(true); | |
| 1558 cbFrame.setIconifiable(true); | |
| 1559 ClassBrowserPanel cbPanel = new ClassBrowserPanel(); | |
| 1560 cbFrame.getContentPane().add(cbPanel, BorderLayout.CENTER); | |
| 1561 desktop.remove(progressFrame); | |
| 1562 desktop.repaint(); | |
| 1563 desktop.add(cbFrame); | |
| 1564 GraphicsUtilities.reshapeToAspectRatio(cbFrame, 1.25f, 0.85f, | |
| 1565 cbFrame.getParent().getSize()); | |
| 1566 cbFrame.show(); | |
| 1567 cbPanel.setClassesText(htmlText); | |
| 1568 } | |
| 1569 }); | |
| 1570 } | |
| 1571 }); | |
| 1572 } | |
| 1573 | |
| 1574 public void showCodeViewer() { | |
| 1575 showPanel("Code Viewer", new CodeViewerPanel(), 1.25f, 0.85f); | |
| 1576 } | |
| 1577 | |
| 1578 public void showCodeViewer(final Address address) { | |
| 1579 final CodeViewerPanel panel = new CodeViewerPanel(); | |
| 1580 showPanel("Code Viewer", panel, 1.25f, 0.85f); | |
| 1581 SwingUtilities.invokeLater(new Runnable() { | |
| 1582 public void run() { | |
| 1583 panel.viewAddress(address); | |
| 1584 } | |
| 1585 }); | |
| 1586 | |
| 1587 } | |
| 1588 | |
| 1589 public void showMemoryViewer() { | |
| 1590 showPanel("Memory Viewer", new MemoryViewer(agent.getDebugger(), agent.getTypeDataBase().getAddressSize() == 8)); | |
| 1591 } | |
| 1592 | |
| 1593 public void showCommandLineFlags() { | |
| 1594 showPanel("Command Line Flags", new VMFlagsPanel()); | |
| 1595 } | |
| 1596 | |
| 1597 public void showVMVersion() { | |
| 1598 showPanel("VM Version Info", new VMVersionInfoPanel()); | |
| 1599 } | |
| 1600 | |
| 1601 public void showSystemProperties() { | |
| 1602 showPanel("System Properties", new SysPropsPanel()); | |
| 1603 } | |
| 1604 | |
| 1605 private void showPanel(String name, JPanel panel) { | |
| 1606 showPanel(name, panel, 5.0f / 3.0f, 0.4f); | |
| 1607 } | |
| 1608 | |
| 1609 private void showPanel(String name, JPanel panel, float aspectRatio, float fillRatio) { | |
| 1610 JInternalFrame frame = new JInternalFrame(name); | |
| 1611 frame.getContentPane().setLayout(new BorderLayout()); | |
| 1612 frame.setResizable(true); | |
| 1613 frame.setClosable(true); | |
| 1614 frame.setIconifiable(true); | |
| 1615 frame.setMaximizable(true); | |
| 1616 frame.getContentPane().add(panel, BorderLayout.CENTER); | |
| 1617 desktop.add(frame); | |
| 1618 GraphicsUtilities.reshapeToAspectRatio(frame, aspectRatio, fillRatio, frame.getParent().getSize()); | |
| 1619 GraphicsUtilities.randomLocation(frame); | |
| 1620 frame.show(); | |
| 1621 if (panel instanceof SAPanel) { | |
| 1622 ((SAPanel)panel).addPanelListener(this); | |
| 1623 } | |
| 1624 } | |
| 1625 | |
| 1626 //-------------------------------------------------------------------------------- | |
| 1627 // Framework for heap iteration with progress bar | |
| 1628 // | |
| 1629 | |
| 1630 interface CleanupThunk { | |
| 1631 public void heapIterationComplete(); | |
| 1632 } | |
| 1633 | |
| 1634 class HeapProgress implements HeapProgressThunk { | |
| 1635 private JInternalFrame frame; | |
| 1636 private ProgressBarPanel bar; | |
| 1637 private String windowTitle; | |
| 1638 private String progressBarTitle; | |
| 1639 private CleanupThunk cleanup; | |
| 1640 | |
| 1641 HeapProgress(String windowTitle) { | |
| 1642 this(windowTitle, "Percentage of heap visited", null); | |
| 1643 } | |
| 1644 | |
| 1645 HeapProgress(String windowTitle, String progressBarTitle) { | |
| 1646 this(windowTitle, progressBarTitle, null); | |
| 1647 } | |
| 1648 | |
| 1649 HeapProgress(String windowTitle, String progressBarTitle, CleanupThunk cleanup) { | |
| 1650 this.windowTitle = windowTitle; | |
| 1651 this.progressBarTitle = progressBarTitle; | |
| 1652 this.cleanup = cleanup; | |
| 1653 } | |
| 1654 | |
| 1655 public void heapIterationFractionUpdate(final double fractionOfHeapVisited) { | |
| 1656 if (frame == null) { | |
| 1657 SwingUtilities.invokeLater(new Runnable() { | |
| 1658 public void run() { | |
| 1659 frame = new JInternalFrame(windowTitle); | |
| 1660 frame.setResizable(true); | |
| 1661 frame.setIconifiable(true); | |
| 1662 frame.getContentPane().setLayout(new BorderLayout()); | |
| 1663 bar = new ProgressBarPanel(progressBarTitle); | |
| 1664 frame.getContentPane().add(bar, BorderLayout.CENTER); | |
| 1665 desktop.add(frame); | |
| 1666 frame.pack(); | |
| 1667 GraphicsUtilities.constrainToSize(frame, frame.getParent().getSize()); | |
| 1668 GraphicsUtilities.centerInContainer(frame); | |
| 1669 frame.show(); | |
| 1670 } | |
| 1671 }); | |
| 1672 } | |
| 1673 | |
| 1674 SwingUtilities.invokeLater(new Runnable() { | |
| 1675 public void run() { | |
| 1676 bar.setValue(fractionOfHeapVisited); | |
| 1677 } | |
| 1678 }); | |
| 1679 } | |
| 1680 | |
| 1681 public void heapIterationComplete() { | |
| 1682 SwingUtilities.invokeLater(new Runnable() { | |
| 1683 public void run() { | |
| 1684 desktop.remove(frame); | |
| 1685 desktop.repaint(); | |
| 1686 if (VM.getVM().getRevPtrs() != null) { | |
| 1687 // Ended up computing reverse pointers as a side-effect | |
| 1688 computeRevPtrsMenuItem.setEnabled(false); | |
| 1689 } | |
| 1690 } | |
| 1691 }); | |
| 1692 | |
| 1693 if (cleanup != null) { | |
| 1694 cleanup.heapIterationComplete(); | |
| 1695 } | |
| 1696 } | |
| 1697 } | |
| 1698 | |
| 1699 class VisitHeap implements Runnable { | |
| 1700 HeapVisitor visitor; | |
| 1701 | |
| 1702 VisitHeap(HeapVisitor visitor) { | |
| 1703 this.visitor = visitor; | |
| 1704 } | |
| 1705 | |
| 1706 public void run() { | |
| 1707 VM.getVM().getObjectHeap().iterate(visitor); | |
| 1708 } | |
| 1709 } | |
| 1710 | |
| 1711 private void doHeapIteration(String frameTitle, | |
| 1712 String progressBarText, | |
| 1713 HeapVisitor visitor, | |
| 1714 CleanupThunk cleanup) { | |
| 1715 sun.jvm.hotspot.oops.ObjectHistogram histo = new sun.jvm.hotspot.oops.ObjectHistogram(); | |
| 1716 HeapProgress progress = new HeapProgress(frameTitle, | |
| 1717 progressBarText, | |
| 1718 cleanup); | |
| 1719 HeapVisitor progVisitor = new ProgressiveHeapVisitor(visitor, progress); | |
| 1720 workerThread.invokeLater(new VisitHeap(progVisitor)); | |
| 1721 } | |
| 1722 | |
| 1723 //-------------------------------------------------------------------------------- | |
| 1724 // Stack trace helper | |
| 1725 // | |
| 1726 | |
| 1727 private static JavaVFrame getLastJavaVFrame(JavaThread cur) { | |
| 1728 RegisterMap regMap = cur.newRegisterMap(true); | |
| 1729 sun.jvm.hotspot.runtime.Frame f = cur.getCurrentFrameGuess(); | |
| 1730 if (f == null) return null; | |
| 1731 boolean imprecise = true; | |
| 1732 if (f.isInterpretedFrame() && !f.isInterpretedFrameValid()) { | |
| 1733 System.err.println("Correcting for invalid interpreter frame"); | |
| 1734 f = f.sender(regMap); | |
| 1735 imprecise = false; | |
| 1736 } | |
| 1737 VFrame vf = VFrame.newVFrame(f, regMap, cur, true, imprecise); | |
| 1738 if (vf == null) { | |
| 1739 System.err.println(" (Unable to create vframe for topmost frame guess)"); | |
| 1740 return null; | |
| 1741 } | |
| 1742 if (vf.isJavaFrame()) { | |
| 1743 return (JavaVFrame) vf; | |
| 1744 } | |
| 1745 return (JavaVFrame) vf.javaSender(); | |
| 1746 } | |
| 1747 | |
| 1748 // Internal routine for debugging | |
| 1749 private static void dumpStack(JavaThread cur) { | |
| 1750 RegisterMap regMap = cur.newRegisterMap(true); | |
| 1751 sun.jvm.hotspot.runtime.Frame f = cur.getCurrentFrameGuess(); | |
| 1752 PrintStream tty = System.err; | |
| 1753 while (f != null) { | |
| 1754 tty.print("Found "); | |
| 1755 if (f.isInterpretedFrame()) { tty.print("interpreted"); } | |
| 1756 else if (f.isCompiledFrame()) { tty.print("compiled"); } | |
| 1757 else if (f.isEntryFrame()) { tty.print("entry"); } | |
| 1758 else if (f.isNativeFrame()) { tty.print("native"); } | |
|
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
1552
diff
changeset
|
1759 else if (f.isRuntimeFrame()) { tty.print("runtime"); } |
| 0 | 1760 else { tty.print("external"); } |
| 1761 tty.print(" frame with PC = " + f.getPC() + ", SP = " + f.getSP() + ", FP = " + f.getFP()); | |
| 1762 if (f.isSignalHandlerFrameDbg()) { | |
| 1763 tty.print(" (SIGNAL HANDLER)"); | |
| 1764 } | |
| 1765 tty.println(); | |
| 1766 | |
| 1767 if (!f.isFirstFrame()) { | |
| 1768 f = f.sender(regMap); | |
| 1769 } else { | |
| 1770 f = null; | |
| 1771 } | |
| 1772 } | |
| 1773 } | |
| 1774 | |
| 1775 //-------------------------------------------------------------------------------- | |
| 1776 // Component utilities | |
| 1777 // | |
| 1778 | |
| 1779 private static JMenuItem createMenuItem(String name, ActionListener l) { | |
| 1780 JMenuItem item = new JMenuItem(name); | |
| 1781 item.addActionListener(l); | |
| 1782 return item; | |
| 1783 } | |
| 1784 | |
| 1785 /** Punctuates the given string with \n's where necessary to not | |
| 1786 exceed the given number of characters per line. Strips | |
| 1787 extraneous whitespace. */ | |
| 1788 private String formatMessage(String message, int charsPerLine) { | |
| 1789 StringBuffer buf = new StringBuffer(message.length()); | |
| 1790 StringTokenizer tokenizer = new StringTokenizer(message); | |
| 1791 int curLineLength = 0; | |
| 1792 while (tokenizer.hasMoreTokens()) { | |
| 1793 String tok = tokenizer.nextToken(); | |
| 1794 if (curLineLength + tok.length() > charsPerLine) { | |
| 1795 buf.append('\n'); | |
| 1796 curLineLength = 0; | |
| 1797 } else { | |
| 1798 if (curLineLength != 0) { | |
| 1799 buf.append(' '); | |
| 1800 ++curLineLength; | |
| 1801 } | |
| 1802 } | |
| 1803 buf.append(tok); | |
| 1804 curLineLength += tok.length(); | |
| 1805 } | |
| 1806 return buf.toString(); | |
| 1807 } | |
| 1808 | |
| 1809 private void setMenuItemsEnabled(java.util.List items, boolean enabled) { | |
| 1810 for (Iterator iter = items.iterator(); iter.hasNext(); ) { | |
| 1811 ((JMenuItem) iter.next()).setEnabled(enabled); | |
| 1812 } | |
| 1813 } | |
| 1814 } |