1 /*
2 * Copyright 2002-2006 Sun Microsystems, Inc. All Rights Reserved.
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 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 package sun.jvm.hotspot.bugspot;
26
27 import java.io.PrintStream;
28 import java.net.*;
29 import java.rmi.*;
30 import sun.jvm.hotspot.*;
31 import sun.jvm.hotspot.debugger.*;
32 import sun.jvm.hotspot.debugger.proc.*;
33 import sun.jvm.hotspot.debugger.cdbg.*;
34 import sun.jvm.hotspot.debugger.win32.*;
35 import sun.jvm.hotspot.debugger.windbg.*;
36 import sun.jvm.hotspot.debugger.linux.*;
37 import sun.jvm.hotspot.debugger.sparc.*;
38 import sun.jvm.hotspot.debugger.remote.*;
39 import sun.jvm.hotspot.livejvm.*;
40 import sun.jvm.hotspot.memory.*;
41 import sun.jvm.hotspot.oops.*;
42 import sun.jvm.hotspot.runtime.*;
43 import sun.jvm.hotspot.types.*;
44 import sun.jvm.hotspot.utilities.*;
45
46 /** <P> This class wraps the basic functionality for connecting to the
47 * target process or debug server. It makes it simple to start up the
48 * debugging system. </P>
49 *
50 * <P> This agent (as compared to the HotSpotAgent) can connect to
51 * and interact with arbitrary processes. If the target process
52 * happens to be a HotSpot JVM, the Java debugging features of the
53 * Serviceability Agent are enabled. Further, if the Serviceability
54 * Agent's JVMDI module is loaded into the target VM, interaction
55 * with the live Java program is possible, specifically the catching
56 * of exceptions and setting of breakpoints. </P>
57 *
58 * <P> The BugSpot debugger requires that the underlying Debugger
59 * support C/C++ debugging via the CDebugger interface. </P>
60 *
61 * <P> FIXME: especially with the addition of remote debugging, this
62 * has turned into a mess; needs rethinking. </P> */
63
64 public class BugSpotAgent {
65
66 private JVMDebugger debugger;
67 private MachineDescription machDesc;
68 private TypeDataBase db;
69
70 private String os;
71 private String cpu;
72 private String fileSep;
73
74 // The system can work in several ways:
75 // - Attaching to local process
76 // - Attaching to local core file
77 // - Connecting to remote debug server
78 // - Starting debug server for process
79 // - Starting debug server for core file
80
81 // These are options for the "client" side of things
82 private static final int PROCESS_MODE = 0;
83 private static final int CORE_FILE_MODE = 1;
84 private static final int REMOTE_MODE = 2;
85 private int startupMode;
86
87 // This indicates whether we are really starting a server or not
88 private boolean isServer;
89
90 // All possible required information for connecting
91 private int pid;
92 private String executableName;
93 private String coreFileName;
94 private String debugServerID;
95
96 // All needed information for server side
97 private String serverID;
98
99 // Indicates whether we are attached to a HotSpot JVM or not
100 private boolean javaMode;
101
102 // Indicates whether we have process control over a live HotSpot JVM
103 // or not; non-null if so.
104 private ServiceabilityAgentJVMDIModule jvmdi;
105 // While handling C breakpoints interactivity with the Java program
106 // is forbidden. Too many invariants are broken while the target is
107 // stopped at a C breakpoint to risk making JVMDI calls.
108 private boolean javaInteractionDisabled;
109
110 private String[] jvmLibNames;
111 private String[] saLibNames;
112
113 // FIXME: make these configurable, i.e., via a dotfile; also
114 // consider searching within the JDK from which this Java executable
115 // comes to find them
116 private static final String defaultDbxPathPrefix = "/net/jano.eng/export/disk05/hotspot/sa";
117 private static final String defaultDbxSvcAgentDSOPathPrefix = "/net/jano.eng/export/disk05/hotspot/sa";
118
119 private static final boolean DEBUG;
120 static {
121 DEBUG = System.getProperty("sun.jvm.hotspot.bugspot.BugSpotAgent.DEBUG")
122 != null;
123 }
124
125 static void debugPrintln(String str) {
126 if (DEBUG) {
127 System.err.println(str);
128 }
129 }
130
131 static void showUsage() {
132 System.out.println(" You can also pass these -D options to java to specify where to find dbx and the \n" +
133 " Serviceability Agent plugin for dbx:");
134 System.out.println(" -DdbxPathName=<path-to-dbx-executable>\n" +
135 " Default is derived from dbxPathPrefix");
136 System.out.println(" or");
137 System.out.println(" -DdbxPathPrefix=<xxx>\n" +
138 " where xxx is the path name of a dir structure that contains:\n" +
139 " <os>/<arch>/bin/dbx\n" +
140 " The default is " + defaultDbxPathPrefix);
141 System.out.println(" and");
142 System.out.println(" -DdbxSvcAgentDSOPathName=<path-to-dbx-serviceability-agent-module>\n" +
143 " Default is determined from dbxSvcAgentDSOPathPrefix");
144 System.out.println(" or");
145 System.out.println(" -DdbxSvcAgentDSOPathPrefix=<xxx>\n" +
146 " where xxx is the pathname of a dir structure that contains:\n" +
147 " <os>/<arch>/bin/lib/libsvc_agent_dbx.so\n" +
148 " The default is " + defaultDbxSvcAgentDSOPathPrefix);
149 }
150
151 public BugSpotAgent() {
152 // for non-server add shutdown hook to clean-up debugger in case
153 // of forced exit. For remote server, shutdown hook is added by
154 // DebugServer.
155 Runtime.getRuntime().addShutdownHook(new java.lang.Thread(
156 new Runnable() {
157 public void run() {
158 synchronized (BugSpotAgent.this) {
159 if (!isServer) {
160 detach();
161 }
162 }
163 }
164 }));
165 }
166
167 //--------------------------------------------------------------------------------
168 // Accessors (once the system is set up)
169 //
170
171 public synchronized Debugger getDebugger() {
172 return debugger;
173 }
174
175 public synchronized CDebugger getCDebugger() {
176 return getDebugger().getCDebugger();
177 }
178
179 public synchronized ProcessControl getProcessControl() {
180 return getCDebugger().getProcessControl();
181 }
182
183 public synchronized TypeDataBase getTypeDataBase() {
184 return db;
185 }
186
187 /** Indicates whether the target process is suspended
188 completely. Equivalent to getProcessControl().isSuspended(). */
189 public synchronized boolean isSuspended() throws DebuggerException {
190 return getProcessControl().isSuspended();
191 }
192
193 /** Suspends the target process completely. Equivalent to
194 getProcessControl().suspend(). */
195 public synchronized void suspend() throws DebuggerException {
196 getProcessControl().suspend();
197 }
198
199 /** Resumes the target process completely. Equivalent to
200 getProcessControl().suspend(). */
201 public synchronized void resume() throws DebuggerException {
202 getProcessControl().resume();
203 }
204
205 /** Indicates whether we are attached to a Java HotSpot virtual
206 machine */
207 public synchronized boolean isJavaMode() {
208 return javaMode;
209 }
210
211 /** Temporarily disables interaction with the target process via
212 JVMDI. This is done while the target process is stopped at a C
213 breakpoint. Can be called even if the JVMDI agent has not been
214 initialized. */
215 public synchronized void disableJavaInteraction() {
216 javaInteractionDisabled = true;
217 }
218
219 /** Re-enables interaction with the target process via JVMDI. This
220 is done while the target process is continued past a C
221 braekpoint. Can be called even if the JVMDI agent has not been
222 initialized. */
223 public synchronized void enableJavaInteraction() {
224 javaInteractionDisabled = false;
225 }
226
227 /** Indicates whether Java interaction has been disabled */
228 public synchronized boolean isJavaInteractionDisabled() {
229 return javaInteractionDisabled;
230 }
231
232 /** Indicates whether we can talk to the Serviceability Agent's
233 JVMDI module to be able to set breakpoints */
234 public synchronized boolean canInteractWithJava() {
235 return (jvmdi != null) && !javaInteractionDisabled;
236 }
237
238 /** Suspends all Java threads in the target process. Can only be
239 called if we are attached to a HotSpot JVM and can connect to
240 the SA's JVMDI module. Must not be called when the target
241 process has been suspended with suspend(). */
242 public synchronized void suspendJava() throws DebuggerException {
243 if (!canInteractWithJava()) {
244 throw new DebuggerException("Could not connect to SA's JVMDI module");
245 }
246 if (jvmdi.isSuspended()) {
247 throw new DebuggerException("Target process already suspended via JVMDI");
248 }
249 jvmdi.suspend();
250 }
251
252 /** Resumes all Java threads in the target process. Can only be
253 called if we are attached to a HotSpot JVM and can connect to
254 the SA's JVMDI module. Must not be called when the target
255 process has been suspended with suspend(). */
256 public synchronized void resumeJava() throws DebuggerException {
257 if (!canInteractWithJava()) {
258 throw new DebuggerException("Could not connect to SA's JVMDI module");
259 }
260 if (!jvmdi.isSuspended()) {
261 throw new DebuggerException("Target process already resumed via JVMDI");
262 }
263 jvmdi.resume();
264 }
265
266 /** Indicates whether the target process has been suspended at the
267 Java language level via the SA's JVMDI module */
268 public synchronized boolean isJavaSuspended() throws DebuggerException {
269 return jvmdi.isSuspended();
270 }
271
272 /** Toggle a Java breakpoint at the given location. */
273 public synchronized ServiceabilityAgentJVMDIModule.BreakpointToggleResult
274 toggleJavaBreakpoint(String srcFileName,
275 String pkgName,
276 int lineNo) {
277 if (!canInteractWithJava()) {
278 throw new DebuggerException("Could not connect to SA's JVMDI module; can not toggle Java breakpoints");
279 }
280 return jvmdi.toggleBreakpoint(srcFileName, pkgName, lineNo);
281 }
282
283 /** Access to JVMDI module's eventPending */
284 public synchronized boolean javaEventPending() throws DebuggerException {
285 if (!canInteractWithJava()) {
286 throw new DebuggerException("Could not connect to SA's JVMDI module; can not poll for Java debug events");
287 }
288 return jvmdi.eventPending();
289 }
290
291 /** Access to JVMDI module's eventPoll */
292 public synchronized Event javaEventPoll() throws DebuggerException {
293 if (!canInteractWithJava()) {
294 throw new DebuggerException("Could not connect to SA's JVMDI module; can not poll for Java debug events");
295 }
296 return jvmdi.eventPoll();
297 }
298
299 /** Access to JVMDI module's eventContinue */
300 public synchronized void javaEventContinue() throws DebuggerException {
301 if (!canInteractWithJava()) {
302 throw new DebuggerException("Could not connect to SA's JVMDI module; can not continue past Java debug events");
303 }
304 jvmdi.eventContinue();
305 }
306
307
308 // FIXME: add other accessors. For example, suspension and
309 // resumption should be done through this interface, as well as
310 // interaction with the live Java process such as breakpoint setting.
311 // Probably should not expose the ServiceabilityAgentJVMDIModule
312 // from this interface.
313
314 //--------------------------------------------------------------------------------
315 // Client-side operations
316 //
317
318 /** This attaches to a process running on the local machine. */
319 public synchronized void attach(int processID)
320 throws DebuggerException {
321 if (debugger != null) {
322 throw new DebuggerException("Already attached");
323 }
324 pid = processID;
325 startupMode = PROCESS_MODE;
326 isServer = false;
327 go();
328 }
329
330 /** This opens a core file on the local machine */
331 public synchronized void attach(String executableName, String coreFileName)
332 throws DebuggerException {
333 if (debugger != null) {
334 throw new DebuggerException("Already attached");
335 }
336 if ((executableName == null) || (coreFileName == null)) {
337 throw new DebuggerException("Both the core file name and executable name must be specified");
338 }
339 this.executableName = executableName;
340 this.coreFileName = coreFileName;
341 startupMode = CORE_FILE_MODE;
342 isServer = false;
343 go();
344 }
345
346 /** This attaches to a "debug server" on a remote machine; this
347 remote server has already attached to a process or opened a
348 core file and is waiting for RMI calls on the Debugger object to
349 come in. */
350 public synchronized void attach(String remoteServerID)
351 throws DebuggerException {
352 if (debugger != null) {
353 throw new DebuggerException("Already attached to a process");
354 }
355 if (remoteServerID == null) {
356 throw new DebuggerException("Debug server id must be specified");
357 }
358
359 debugServerID = remoteServerID;
360 startupMode = REMOTE_MODE;
361 isServer = false;
362 go();
363 }
364
365 /** This should only be called by the user on the client machine,
366 not the server machine */
367 public synchronized boolean detach() throws DebuggerException {
368 if (isServer) {
369 throw new DebuggerException("Should not call detach() for server configuration");
370 }
371 return detachInternal();
372 }
373
374 //--------------------------------------------------------------------------------
375 // Server-side operations
376 //
377
378 /** This attaches to a process running on the local machine and
379 starts a debug server, allowing remote machines to connect and
380 examine this process. uniqueID is used to uniquely identify the
381 debuggee */
382 public synchronized void startServer(int processID, String uniqueID)
383 throws DebuggerException {
384 if (debugger != null) {
385 throw new DebuggerException("Already attached");
386 }
387 pid = processID;
388 startupMode = PROCESS_MODE;
389 isServer = true;
390 serverID = uniqueID;
391 go();
392 }
393
394 /** This attaches to a process running on the local machine and
395 starts a debug server, allowing remote machines to connect and
396 examine this process. */
397 public synchronized void startServer(int processID)
398 throws DebuggerException {
399 startServer(processID, null);
400 }
401
402 /** This opens a core file on the local machine and starts a debug
403 server, allowing remote machines to connect and examine this
404 core file. uniqueID is used to uniquely identify the
405 debuggee */
406 public synchronized void startServer(String executableName, String coreFileName,
407 String uniqueID)
408 throws DebuggerException {
409 if (debugger != null) {
410 throw new DebuggerException("Already attached");
411 }
412 if ((executableName == null) || (coreFileName == null)) {
413 throw new DebuggerException("Both the core file name and Java executable name must be specified");
414 }
415 this.executableName = executableName;
416 this.coreFileName = coreFileName;
417 startupMode = CORE_FILE_MODE;
418 isServer = true;
419 serverID = uniqueID;
420 go();
421 }
422
423 /** This opens a core file on the local machine and starts a debug
424 server, allowing remote machines to connect and examine this
425 core file.*/
426 public synchronized void startServer(String executableName, String coreFileName)
427 throws DebuggerException {
428 startServer(executableName, coreFileName, null);
429 }
430
431 /** This may only be called on the server side after startServer()
432 has been called */
433 public synchronized boolean shutdownServer() throws DebuggerException {
434 if (!isServer) {
435 throw new DebuggerException("Should not call shutdownServer() for client configuration");
436 }
437 return detachInternal();
438 }
439
440
441 //--------------------------------------------------------------------------------
442 // Internals only below this point
443 //
444
445 private boolean detachInternal() {
446 if (debugger == null) {
447 return false;
448 }
449 if (canInteractWithJava()) {
450 jvmdi.detach();
451 jvmdi = null;
452 }
453 boolean retval = true;
454 if (!isServer) {
455 VM.shutdown();
456 }
457 // We must not call detach() if we are a client and are connected
458 // to a remote debugger
459 Debugger dbg = null;
460 DebuggerException ex = null;
461 if (isServer) {
462 try {
463 RMIHelper.unbind(serverID);
464 }
465 catch (DebuggerException de) {
466 ex = de;
467 }
468 dbg = debugger;
469 } else {
470 if (startupMode != REMOTE_MODE) {
471 dbg = debugger;
472 }
473 }
474 if (dbg != null) {
475 retval = dbg.detach();
476 }
477
478 debugger = null;
479 machDesc = null;
480 db = null;
481 if (ex != null) {
482 throw(ex);
483 }
484 return retval;
485 }
486
487 private void go() {
488 setupDebugger();
489 javaMode = setupVM();
490 }
491
492 private void setupDebugger() {
493 if (startupMode != REMOTE_MODE) {
494 //
495 // Local mode (client attaching to local process or setting up
496 // server, but not client attaching to server)
497 //
498
499 try {
500 os = PlatformInfo.getOS();
501 cpu = PlatformInfo.getCPU();
502 }
503 catch (UnsupportedPlatformException e) {
504 throw new DebuggerException(e);
505 }
506 fileSep = System.getProperty("file.separator");
507
508 if (os.equals("solaris")) {
509 setupDebuggerSolaris();
510 } else if (os.equals("win32")) {
511 setupDebuggerWin32();
512 } else if (os.equals("linux")) {
513 setupDebuggerLinux();
514 } else {
515 // Add support for more operating systems here
516 throw new DebuggerException("Operating system " + os + " not yet supported");
517 }
518 if (isServer) {
519 RemoteDebuggerServer remote = null;
520 try {
521 remote = new RemoteDebuggerServer(debugger);
522 }
523 catch (RemoteException rem) {
524 throw new DebuggerException(rem);
525 }
526 RMIHelper.rebind(serverID, remote);
527 }
528 } else {
529 //
530 // Remote mode (client attaching to server)
531 //
532
533 // Create and install a security manager
534
535 // FIXME: currently commented out because we were having
536 // security problems since we're "in the sun.* hierarchy" here.
537 // Perhaps a permissive policy file would work around this. In
538 // the long run, will probably have to move into com.sun.*.
539
540 // if (System.getSecurityManager() == null) {
541 // System.setSecurityManager(new RMISecurityManager());
542 // }
543
544 connectRemoteDebugger();
545 }
546 }
547
548 private boolean setupVM() {
549 // We need to instantiate a HotSpotTypeDataBase on both the client
550 // and server machine. On the server it is only currently used to
551 // configure the Java primitive type sizes (which we should
552 // consider making constant). On the client it is used to
553 // configure the VM.
554
555 try {
556 if (os.equals("solaris")) {
557 db = new HotSpotTypeDataBase(machDesc, new HotSpotSolarisVtblAccess(debugger, jvmLibNames),
558 debugger, jvmLibNames);
559 } else if (os.equals("win32")) {
560 db = new HotSpotTypeDataBase(machDesc, new Win32VtblAccess(debugger, jvmLibNames),
561 debugger, jvmLibNames);
562 } else if (os.equals("linux")) {
563 db = new HotSpotTypeDataBase(machDesc, new LinuxVtblAccess(debugger, jvmLibNames),
564 debugger, jvmLibNames);
565 } else {
566 throw new DebuggerException("OS \"" + os + "\" not yet supported (no VtblAccess implemented yet)");
567 }
568 }
569 catch (NoSuchSymbolException e) {
570 e.printStackTrace();
571 return false;
572 }
573
574 if (startupMode != REMOTE_MODE) {
575 // Configure the debugger with the primitive type sizes just obtained from the VM
576 debugger.configureJavaPrimitiveTypeSizes(db.getJBooleanType().getSize(),
577 db.getJByteType().getSize(),
578 db.getJCharType().getSize(),
579 db.getJDoubleType().getSize(),
580 db.getJFloatType().getSize(),
581 db.getJIntType().getSize(),
582 db.getJLongType().getSize(),
583 db.getJShortType().getSize());
584 }
585
586 if (!isServer) {
587 // Do not initialize the VM on the server (unnecessary, since it's
588 // instantiated on the client)
589 VM.initialize(db, debugger);
590 }
591
592 try {
593 jvmdi = new ServiceabilityAgentJVMDIModule(debugger, saLibNames);
594 if (jvmdi.canAttach()) {
595 jvmdi.attach();
596 jvmdi.setCommandTimeout(6000);
597 debugPrintln("Attached to Serviceability Agent's JVMDI module.");
598 // Jog VM to suspended point with JVMDI module
599 resume();
600 suspendJava();
601 suspend();
602 debugPrintln("Suspended all Java threads.");
603 } else {
604 debugPrintln("Could not locate SA's JVMDI module; skipping attachment");
605 jvmdi = null;
606 }
607 } catch (Exception e) {
608 e.printStackTrace();
609 jvmdi = null;
610 }
611
612 return true;
613 }
614
615 //--------------------------------------------------------------------------------
616 // OS-specific debugger setup/connect routines
617 //
618
619 //
620 // Solaris
621 //
622
623 private void setupDebuggerSolaris() {
624 setupJVMLibNamesSolaris();
625 ProcDebuggerLocal dbg = new ProcDebuggerLocal(null, true);
626 debugger = dbg;
627 attachDebugger();
628
629 // Set up CPU-dependent stuff
630 if (cpu.equals("x86")) {
631 machDesc = new MachineDescriptionIntelX86();
632 } else if (cpu.equals("sparc")) {
633 int addressSize = dbg.getRemoteProcessAddressSize();
634 if (addressSize == -1) {
635 throw new DebuggerException("Error occurred while trying to determine the remote process's address size");
636 }
637
638 if (addressSize == 32) {
639 machDesc = new MachineDescriptionSPARC32Bit();
640 } else if (addressSize == 64) {
641 machDesc = new MachineDescriptionSPARC64Bit();
642 } else {
643 throw new DebuggerException("Address size " + addressSize + " is not supported on SPARC");
644 }
645 } else if (cpu.equals("amd64")) {
646 machDesc = new MachineDescriptionAMD64();
647 } else {
648 throw new DebuggerException("Solaris only supported on sparc/sparcv9/x86/amd64");
649 }
650
651 dbg.setMachineDescription(machDesc);
652 }
653
654 private void connectRemoteDebugger() throws DebuggerException {
655 RemoteDebugger remote =
656 (RemoteDebugger) RMIHelper.lookup(debugServerID);
657 debugger = new RemoteDebuggerClient(remote);
658 machDesc = ((RemoteDebuggerClient) debugger).getMachineDescription();
659 os = debugger.getOS();
660 if (os.equals("solaris")) {
661 setupJVMLibNamesSolaris();
662 } else if (os.equals("win32")) {
663 setupJVMLibNamesWin32();
664 } else if (os.equals("linux")) {
665 setupJVMLibNamesLinux();
666 } else {
667 throw new RuntimeException("Unknown OS type");
668 }
669
670 cpu = debugger.getCPU();
671 }
672
673 private void setupJVMLibNamesSolaris() {
674 jvmLibNames = new String[] { "libjvm.so", "libjvm_g.so", "gamma_g" };
675 saLibNames = new String[] { "libsa.so", "libsa_g.so" };
676 }
677
678 //
679 // Win32
680 //
681
682 private void setupDebuggerWin32() {
683 setupJVMLibNamesWin32();
684
685 if (cpu.equals("x86")) {
686 machDesc = new MachineDescriptionIntelX86();
687 } else if (cpu.equals("amd64")) {
688 machDesc = new MachineDescriptionAMD64();
689 } else if (cpu.equals("ia64")) {
690 machDesc = new MachineDescriptionIA64();
691 } else {
692 throw new DebuggerException("Win32 supported under x86, amd64 and ia64 only");
693 }
694
695 // Note we do not use a cache for the local debugger in server
696 // mode; it will be taken care of on the client side (once remote
697 // debugging is implemented).
698
699 if (System.getProperty("sun.jvm.hotspot.debugger.useWindbgDebugger") != null) {
700 debugger = new WindbgDebuggerLocal(machDesc, !isServer);
701 } else {
702 debugger = new Win32DebuggerLocal(machDesc, !isServer);
703 }
704
705 attachDebugger();
706 }
707
708 private void setupJVMLibNamesWin32() {
709 jvmLibNames = new String[] { "jvm.dll", "jvm_g.dll" };
710 saLibNames = new String[] { "sa.dll", "sa_g.dll" };
711 }
712
713 //
714 // Linux
715 //
716
717 private void setupDebuggerLinux() {
718 setupJVMLibNamesLinux();
719
720 if (cpu.equals("x86")) {
721 machDesc = new MachineDescriptionIntelX86();
722 } else if (cpu.equals("ia64")) {
723 machDesc = new MachineDescriptionIA64();
724 } else if (cpu.equals("amd64")) {
725 machDesc = new MachineDescriptionAMD64();
726 } else if (cpu.equals("sparc")) {
727 if (LinuxDebuggerLocal.getAddressSize()==8) {
728 machDesc = new MachineDescriptionSPARC64Bit();
729 } else {
730 machDesc = new MachineDescriptionSPARC32Bit();
731 }
732 } else {
733 throw new DebuggerException("Linux only supported on x86/ia64/amd64/sparc/sparc64");
734 }
735
736 // Note we do not use a cache for the local debugger in server
737 // mode; it will be taken care of on the client side (once remote
738 // debugging is implemented).
739
740 debugger = new LinuxDebuggerLocal(machDesc, !isServer);
741 attachDebugger();
742 }
743
744 private void setupJVMLibNamesLinux() {
745 // same as solaris
746 setupJVMLibNamesSolaris();
747 }
748
749 /** Convenience routine which should be called by per-platform
750 debugger setup. Should not be called when startupMode is
751 REMOTE_MODE. */
752 private void attachDebugger() {
753 if (startupMode == PROCESS_MODE) {
754 debugger.attach(pid);
755 } else if (startupMode == CORE_FILE_MODE) {
756 debugger.attach(executableName, coreFileName);
757 } else {
758 throw new DebuggerException("Should not call attach() for startupMode == " + startupMode);
759 }
760 }
761 }