1 /*
   2  * Copyright (c) 2000, 2017, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 package sun.jvm.hotspot;
  26 
  27 import java.rmi.RemoteException;
  28 import java.lang.reflect.Constructor;
  29 import java.lang.reflect.InvocationTargetException;
  30 
  31 import sun.jvm.hotspot.debugger.Debugger;
  32 import sun.jvm.hotspot.debugger.DebuggerException;
  33 import sun.jvm.hotspot.debugger.JVMDebugger;
  34 import sun.jvm.hotspot.debugger.MachineDescription;
  35 import sun.jvm.hotspot.debugger.MachineDescriptionAMD64;
  36 import sun.jvm.hotspot.debugger.MachineDescriptionPPC64;
  37 import sun.jvm.hotspot.debugger.MachineDescriptionAArch64;
  38 import sun.jvm.hotspot.debugger.MachineDescriptionArm;
  39 import sun.jvm.hotspot.debugger.MachineDescriptionIntelX86;
  40 import sun.jvm.hotspot.debugger.MachineDescriptionSPARC32Bit;
  41 import sun.jvm.hotspot.debugger.MachineDescriptionSPARC64Bit;
  42 import sun.jvm.hotspot.debugger.NoSuchSymbolException;
  43 import sun.jvm.hotspot.debugger.bsd.BsdDebuggerLocal;
  44 import sun.jvm.hotspot.debugger.linux.LinuxDebuggerLocal;
  45 import sun.jvm.hotspot.debugger.proc.ProcDebuggerLocal;
  46 import sun.jvm.hotspot.debugger.remote.RemoteDebugger;
  47 import sun.jvm.hotspot.debugger.remote.RemoteDebuggerClient;
  48 import sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer;
  49 import sun.jvm.hotspot.debugger.windbg.WindbgDebuggerLocal;
  50 import sun.jvm.hotspot.runtime.VM;
  51 import sun.jvm.hotspot.types.TypeDataBase;
  52 import sun.jvm.hotspot.utilities.PlatformInfo;
  53 import sun.jvm.hotspot.utilities.UnsupportedPlatformException;
  54 
  55 /** <P> This class wraps much of the basic functionality and is the
  56  * highest-level factory for VM data structures. It makes it simple
  57  * to start up the debugging system. </P>
  58  *
  59  * <P> FIXME: especially with the addition of remote debugging, this
  60  * has turned into a mess; needs rethinking. </P>
  61  */
  62 
  63 public class HotSpotAgent {
  64     private JVMDebugger debugger;
  65     private MachineDescription machDesc;
  66     private TypeDataBase db;
  67 
  68     private String os;
  69     private String cpu;
  70 
  71     // The system can work in several ways:
  72     //  - Attaching to local process
  73     //  - Attaching to local core file
  74     //  - Connecting to remote debug server
  75     //  - Starting debug server for process
  76     //  - Starting debug server for core file
  77 
  78     // These are options for the "client" side of things
  79     private static final int PROCESS_MODE   = 0;
  80     private static final int CORE_FILE_MODE = 1;
  81     private static final int REMOTE_MODE    = 2;
  82     private int startupMode;
  83 
  84     // This indicates whether we are really starting a server or not
  85     private boolean isServer;
  86 
  87     // All possible required information for connecting
  88     private int pid;
  89     private String javaExecutableName;
  90     private String coreFileName;
  91     private String debugServerID;
  92 
  93     // All needed information for server side
  94     private String serverID;
  95 
  96     private String[] jvmLibNames;
  97 
  98     static void showUsage() {
  99     }
 100 
 101     public HotSpotAgent() {
 102         // for non-server add shutdown hook to clean-up debugger in case
 103         // of forced exit. For remote server, shutdown hook is added by
 104         // DebugServer.
 105         Runtime.getRuntime().addShutdownHook(new java.lang.Thread(
 106         new Runnable() {
 107             public void run() {
 108                 synchronized (HotSpotAgent.this) {
 109                     if (!isServer) {
 110                         detach();
 111                     }
 112                 }
 113             }
 114         }));
 115     }
 116 
 117     //--------------------------------------------------------------------------------
 118     // Accessors (once the system is set up)
 119     //
 120 
 121     public synchronized Debugger getDebugger() {
 122         return debugger;
 123     }
 124 
 125     public synchronized TypeDataBase getTypeDataBase() {
 126         return db;
 127     }
 128 
 129     //--------------------------------------------------------------------------------
 130     // Client-side operations
 131     //
 132 
 133     /** This attaches to a process running on the local machine. */
 134     public synchronized void attach(int processID)
 135     throws DebuggerException {
 136         if (debugger != null) {
 137             throw new DebuggerException("Already attached");
 138         }
 139         pid = processID;
 140         startupMode = PROCESS_MODE;
 141         isServer = false;
 142         go();
 143     }
 144 
 145     /** This opens a core file on the local machine */
 146     public synchronized void attach(String javaExecutableName, String coreFileName)
 147     throws DebuggerException {
 148         if (debugger != null) {
 149             throw new DebuggerException("Already attached");
 150         }
 151         if ((javaExecutableName == null) || (coreFileName == null)) {
 152             throw new DebuggerException("Both the core file name and Java executable name must be specified");
 153         }
 154         this.javaExecutableName = javaExecutableName;
 155         this.coreFileName = coreFileName;
 156         startupMode = CORE_FILE_MODE;
 157         isServer = false;
 158         go();
 159     }
 160 
 161     /** This uses a JVMDebugger that is already attached to the core or process */
 162     public synchronized void attach(JVMDebugger d)
 163     throws DebuggerException {
 164         debugger = d;
 165         isServer = false;
 166         go();
 167     }
 168 
 169     /** This attaches to a "debug server" on a remote machine; this
 170       remote server has already attached to a process or opened a
 171       core file and is waiting for RMI calls on the Debugger object to
 172       come in. */
 173     public synchronized void attach(String remoteServerID)
 174     throws DebuggerException {
 175         if (debugger != null) {
 176             throw new DebuggerException("Already attached to a process");
 177         }
 178         if (remoteServerID == null) {
 179             throw new DebuggerException("Debug server id must be specified");
 180         }
 181 
 182         debugServerID = remoteServerID;
 183         startupMode = REMOTE_MODE;
 184         isServer = false;
 185         go();
 186     }
 187 
 188     /** This should only be called by the user on the client machine,
 189       not the server machine */
 190     public synchronized boolean detach() throws DebuggerException {
 191         if (isServer) {
 192             throw new DebuggerException("Should not call detach() for server configuration");
 193         }
 194         return detachInternal();
 195     }
 196 
 197     //--------------------------------------------------------------------------------
 198     // Server-side operations
 199     //
 200 
 201     /** This attaches to a process running on the local machine and
 202       starts a debug server, allowing remote machines to connect and
 203       examine this process. Uses specified name to uniquely identify a
 204       specific debuggee on the server */
 205     public synchronized void startServer(int processID, String uniqueID) {
 206         if (debugger != null) {
 207             throw new DebuggerException("Already attached");
 208         }
 209         pid = processID;
 210         startupMode = PROCESS_MODE;
 211         isServer = true;
 212         serverID = uniqueID;
 213         go();
 214     }
 215 
 216     /** This attaches to a process running on the local machine and
 217       starts a debug server, allowing remote machines to connect and
 218       examine this process. */
 219     public synchronized void startServer(int processID)
 220     throws DebuggerException {
 221         startServer(processID, null);
 222     }
 223 
 224     /** This opens a core file on the local machine and starts a debug
 225       server, allowing remote machines to connect and examine this
 226       core file. Uses supplied uniqueID to uniquely identify a specific
 227       debugee */
 228     public synchronized void startServer(String javaExecutableName,
 229     String coreFileName,
 230     String uniqueID) {
 231         if (debugger != null) {
 232             throw new DebuggerException("Already attached");
 233         }
 234         if ((javaExecutableName == null) || (coreFileName == null)) {
 235             throw new DebuggerException("Both the core file name and Java executable name must be specified");
 236         }
 237         this.javaExecutableName = javaExecutableName;
 238         this.coreFileName = coreFileName;
 239         startupMode = CORE_FILE_MODE;
 240         isServer = true;
 241         serverID = uniqueID;
 242         go();
 243     }
 244 
 245     /** This opens a core file on the local machine and starts a debug
 246       server, allowing remote machines to connect and examine this
 247       core file. */
 248     public synchronized void startServer(String javaExecutableName, String coreFileName)
 249     throws DebuggerException {
 250         startServer(javaExecutableName, coreFileName, null);
 251     }
 252 
 253     /** This may only be called on the server side after startServer()
 254       has been called */
 255     public synchronized boolean shutdownServer() throws DebuggerException {
 256         if (!isServer) {
 257             throw new DebuggerException("Should not call shutdownServer() for client configuration");
 258         }
 259         return detachInternal();
 260     }
 261 
 262 
 263     //--------------------------------------------------------------------------------
 264     // Internals only below this point
 265     //
 266 
 267     private boolean detachInternal() {
 268         if (debugger == null) {
 269             return false;
 270         }
 271         boolean retval = true;
 272         if (!isServer) {
 273             VM.shutdown();
 274         }
 275         // We must not call detach() if we are a client and are connected
 276         // to a remote debugger
 277         Debugger dbg = null;
 278         DebuggerException ex = null;
 279         if (isServer) {
 280             try {
 281                 RMIHelper.unbind(serverID);
 282             }
 283             catch (DebuggerException de) {
 284                 ex = de;
 285             }
 286             dbg = debugger;
 287         } else {
 288             if (startupMode != REMOTE_MODE) {
 289                 dbg = debugger;
 290             }
 291         }
 292         if (dbg != null) {
 293             retval = dbg.detach();
 294         }
 295 
 296         debugger = null;
 297         machDesc = null;
 298         db = null;
 299         if (ex != null) {
 300             throw(ex);
 301         }
 302         return retval;
 303     }
 304 
 305     private void go() {
 306         setupDebugger();
 307         setupVM();
 308     }
 309 
 310     private void setupDebugger() {
 311         if (startupMode != REMOTE_MODE) {
 312             //
 313             // Local mode (client attaching to local process or setting up
 314             // server, but not client attaching to server)
 315             //
 316 
 317             // Handle existing or alternate JVMDebugger:
 318             // these will set os, cpu independently of our PlatformInfo implementation.
 319             String alternateDebugger = System.getProperty("sa.altDebugger");
 320             if (debugger != null) {
 321                 setupDebuggerExisting();
 322 
 323             } else if (alternateDebugger != null) {
 324                 setupDebuggerAlternate(alternateDebugger);
 325 
 326             } else {
 327                 // Otherwise, os, cpu are those of our current platform:
 328                 try {
 329                     os  = PlatformInfo.getOS();
 330                     cpu = PlatformInfo.getCPU();
 331                 } catch (UnsupportedPlatformException e) {
 332                    throw new DebuggerException(e);
 333                 }
 334                 if (os.equals("solaris")) {
 335                     setupDebuggerSolaris();
 336                 } else if (os.equals("win32")) {
 337                     setupDebuggerWin32();
 338                 } else if (os.equals("linux")) {
 339                     setupDebuggerLinux();
 340                 } else if (os.equals("bsd")) {
 341                     setupDebuggerBsd();
 342                 } else if (os.equals("darwin")) {
 343                     setupDebuggerDarwin();
 344                 } else {
 345                     // Add support for more operating systems here
 346                     throw new DebuggerException("Operating system " + os + " not yet supported");
 347                 }
 348             }
 349 
 350             if (isServer) {
 351                 RemoteDebuggerServer remote = null;
 352                 try {
 353                     remote = new RemoteDebuggerServer(debugger);
 354                 }
 355                 catch (RemoteException rem) {
 356                     throw new DebuggerException(rem);
 357                 }
 358                 RMIHelper.rebind(serverID, remote);
 359             }
 360         } else {
 361             //
 362             // Remote mode (client attaching to server)
 363             //
 364 
 365             // Create and install a security manager
 366 
 367             // FIXME: currently commented out because we were having
 368             // security problems since we're "in the sun.* hierarchy" here.
 369             // Perhaps a permissive policy file would work around this. In
 370             // the long run, will probably have to move into com.sun.*.
 371 
 372             //    if (System.getSecurityManager() == null) {
 373             //      System.setSecurityManager(new RMISecurityManager());
 374             //    }
 375 
 376             connectRemoteDebugger();
 377         }
 378     }
 379 
 380     private void setupVM() {
 381         // We need to instantiate a HotSpotTypeDataBase on both the client
 382         // and server machine. On the server it is only currently used to
 383         // configure the Java primitive type sizes (which we should
 384         // consider making constant). On the client it is used to
 385         // configure the VM.
 386 
 387         try {
 388             if (os.equals("solaris")) {
 389                 db = new HotSpotTypeDataBase(machDesc,
 390                 new HotSpotSolarisVtblAccess(debugger, jvmLibNames),
 391                 debugger, jvmLibNames);
 392             } else if (os.equals("win32")) {
 393                 db = new HotSpotTypeDataBase(machDesc,
 394                 new Win32VtblAccess(debugger, jvmLibNames),
 395                 debugger, jvmLibNames);
 396             } else if (os.equals("linux")) {
 397                 db = new HotSpotTypeDataBase(machDesc,
 398                 new LinuxVtblAccess(debugger, jvmLibNames),
 399                 debugger, jvmLibNames);
 400             } else if (os.equals("bsd")) {
 401                 db = new HotSpotTypeDataBase(machDesc,
 402                 new BsdVtblAccess(debugger, jvmLibNames),
 403                 debugger, jvmLibNames);
 404             } else if (os.equals("darwin")) {
 405                 db = new HotSpotTypeDataBase(machDesc,
 406                 new BsdVtblAccess(debugger, jvmLibNames),
 407                 debugger, jvmLibNames);
 408             } else {
 409                 throw new DebuggerException("OS \"" + os + "\" not yet supported (no VtblAccess yet)");
 410             }
 411         }
 412         catch (NoSuchSymbolException e) {
 413             throw new DebuggerException("Doesn't appear to be a HotSpot VM (could not find symbol \"" +
 414             e.getSymbol() + "\" in remote process)");
 415         }
 416 
 417         if (startupMode != REMOTE_MODE) {
 418             // Configure the debugger with the primitive type sizes just obtained from the VM
 419             debugger.configureJavaPrimitiveTypeSizes(db.getJBooleanType().getSize(),
 420             db.getJByteType().getSize(),
 421             db.getJCharType().getSize(),
 422             db.getJDoubleType().getSize(),
 423             db.getJFloatType().getSize(),
 424             db.getJIntType().getSize(),
 425             db.getJLongType().getSize(),
 426             db.getJShortType().getSize());
 427         }
 428 
 429         if (!isServer) {
 430             // Do not initialize the VM on the server (unnecessary, since it's
 431             // instantiated on the client)
 432             try {
 433                 VM.initialize(db, debugger);
 434             } catch (DebuggerException e) {
 435                 throw (e);
 436             } catch (Exception e) {
 437                 throw new DebuggerException(e);
 438             }
 439         }
 440     }
 441 
 442     //--------------------------------------------------------------------------------
 443     // OS-specific debugger setup/connect routines
 444     //
 445 
 446     // Use the existing JVMDebugger, as passed to our constructor.
 447     // Retrieve os and cpu from that debugger, not the current platform.
 448     private void setupDebuggerExisting() {
 449 
 450         os = debugger.getOS();
 451         cpu = debugger.getCPU();
 452         setupJVMLibNames(os);
 453         machDesc = debugger.getMachineDescription();
 454     }
 455 
 456     // Given a classname, load an alternate implementation of JVMDebugger.
 457     private void setupDebuggerAlternate(String alternateName) {
 458 
 459         try {
 460             Class c = Class.forName(alternateName);
 461             Constructor cons = c.getConstructor();
 462             debugger = (JVMDebugger) cons.newInstance();
 463             attachDebugger();
 464             setupDebuggerExisting();
 465 
 466         } catch (ClassNotFoundException cnfe) {
 467             throw new DebuggerException("Cannot find alternate SA Debugger: '" + alternateName + "'");
 468         } catch (NoSuchMethodException nsme) {
 469             throw new DebuggerException("Alternate SA Debugger: '" + alternateName + "' has missing constructor.");
 470         } catch (InstantiationException ie) {
 471             throw new DebuggerException("Alternate SA Debugger: '" + alternateName + "' fails to initialise: ", ie);
 472         } catch (IllegalAccessException iae) {
 473             throw new DebuggerException("Alternate SA Debugger: '" + alternateName + "' fails to initialise: ", iae);
 474         } catch (InvocationTargetException iae) {
 475             throw new DebuggerException("Alternate SA Debugger: '" + alternateName + "' fails to initialise: ", iae);
 476         }
 477 
 478         System.err.println("Loaded alternate HotSpot SA Debugger: " + alternateName);
 479     }
 480 
 481     //
 482     // Solaris
 483     //
 484 
 485     private void setupDebuggerSolaris() {
 486         setupJVMLibNamesSolaris();
 487         ProcDebuggerLocal dbg = new ProcDebuggerLocal(null, true);
 488         debugger = dbg;
 489         attachDebugger();
 490 
 491         // Set up CPU-dependent stuff
 492         if (cpu.equals("x86")) {
 493             machDesc = new MachineDescriptionIntelX86();
 494         } else if (cpu.equals("sparc")) {
 495             int addressSize = dbg.getRemoteProcessAddressSize();
 496             if (addressSize == -1) {
 497                 throw new DebuggerException("Error occurred while trying to determine the remote process's " +
 498                                             "address size");
 499             }
 500 
 501             if (addressSize == 32) {
 502                 machDesc = new MachineDescriptionSPARC32Bit();
 503             } else if (addressSize == 64) {
 504                 machDesc = new MachineDescriptionSPARC64Bit();
 505             } else {
 506                 throw new DebuggerException("Address size " + addressSize + " is not supported on SPARC");
 507             }
 508         } else if (cpu.equals("amd64")) {
 509             machDesc = new MachineDescriptionAMD64();
 510         } else {
 511             throw new DebuggerException("Solaris only supported on sparc/sparcv9/x86/amd64");
 512         }
 513 
 514         dbg.setMachineDescription(machDesc);
 515         return;
 516     }
 517 
 518     private void connectRemoteDebugger() throws DebuggerException {
 519         RemoteDebugger remote =
 520         (RemoteDebugger) RMIHelper.lookup(debugServerID);
 521         debugger = new RemoteDebuggerClient(remote);
 522         machDesc = ((RemoteDebuggerClient) debugger).getMachineDescription();
 523         os = debugger.getOS();
 524         setupJVMLibNames(os);
 525         cpu = debugger.getCPU();
 526     }
 527 
 528     private void setupJVMLibNames(String os) {
 529         if (os.equals("solaris")) {
 530             setupJVMLibNamesSolaris();
 531         } else if (os.equals("win32")) {
 532             setupJVMLibNamesWin32();
 533         } else if (os.equals("linux")) {
 534             setupJVMLibNamesLinux();
 535         } else if (os.equals("bsd")) {
 536             setupJVMLibNamesBsd();
 537         } else if (os.equals("darwin")) {
 538             setupJVMLibNamesDarwin();
 539         } else {
 540             throw new RuntimeException("Unknown OS type");
 541         }
 542     }
 543 
 544     private void setupJVMLibNamesSolaris() {
 545         jvmLibNames = new String[] { "libjvm.so" };
 546     }
 547 
 548     //
 549     // Win32
 550     //
 551 
 552     private void setupDebuggerWin32() {
 553         setupJVMLibNamesWin32();
 554 
 555         if (cpu.equals("x86")) {
 556             machDesc = new MachineDescriptionIntelX86();
 557         } else if (cpu.equals("amd64")) {
 558             machDesc = new MachineDescriptionAMD64();
 559         } else {
 560             throw new DebuggerException("Win32 supported under x86 and amd64 only");
 561         }
 562 
 563         // Note we do not use a cache for the local debugger in server
 564         // mode; it will be taken care of on the client side (once remote
 565         // debugging is implemented).
 566 
 567         debugger = new WindbgDebuggerLocal(machDesc, !isServer);
 568 
 569         attachDebugger();
 570 
 571         // FIXME: add support for server mode
 572     }
 573 
 574     private void setupJVMLibNamesWin32() {
 575         jvmLibNames = new String[] { "jvm.dll" };
 576     }
 577 
 578     //
 579     // Linux
 580     //
 581 
 582     private void setupDebuggerLinux() {
 583         setupJVMLibNamesLinux();
 584 
 585         if (cpu.equals("x86")) {
 586             machDesc = new MachineDescriptionIntelX86();
 587         } else if (cpu.equals("amd64")) {
 588             machDesc = new MachineDescriptionAMD64();
 589         } else if (cpu.equals("ppc64")) {
 590             machDesc = new MachineDescriptionPPC64();
 591         } else if (cpu.equals("aarch64")) {
 592             machDesc = new MachineDescriptionAArch64();
 593         } else if (cpu.equals("arm")) {
 594             machDesc = new MachineDescriptionArm();
 595         } else if (cpu.equals("sparc")) {
 596             if (LinuxDebuggerLocal.getAddressSize()==8) {
 597                     machDesc = new MachineDescriptionSPARC64Bit();
 598             } else {
 599                     machDesc = new MachineDescriptionSPARC32Bit();
 600             }
 601         } else {
 602           try {
 603             machDesc = (MachineDescription)
 604               Class.forName("sun.jvm.hotspot.debugger.MachineDescription" +
 605                             cpu.toUpperCase()).newInstance();
 606           } catch (Exception e) {
 607             throw new DebuggerException("Linux not supported on machine type " + cpu);
 608           }
 609         }
 610 
 611         LinuxDebuggerLocal dbg =
 612         new LinuxDebuggerLocal(machDesc, !isServer);
 613         debugger = dbg;
 614 
 615         attachDebugger();
 616     }
 617 
 618     private void setupJVMLibNamesLinux() {
 619         jvmLibNames = new String[] { "libjvm.so" };
 620     }
 621 
 622     //
 623     // BSD
 624     //
 625 
 626     private void setupDebuggerBsd() {
 627         setupJVMLibNamesBsd();
 628 
 629         if (cpu.equals("x86")) {
 630             machDesc = new MachineDescriptionIntelX86();
 631         } else if (cpu.equals("amd64") || cpu.equals("x86_64")) {
 632             machDesc = new MachineDescriptionAMD64();
 633         } else {
 634             throw new DebuggerException("BSD only supported on x86/x86_64. Current arch: " + cpu);
 635         }
 636 
 637         BsdDebuggerLocal dbg = new BsdDebuggerLocal(machDesc, !isServer);
 638         debugger = dbg;
 639 
 640         attachDebugger();
 641     }
 642 
 643     private void setupJVMLibNamesBsd() {
 644         jvmLibNames = new String[] { "libjvm.so" };
 645     }
 646 
 647     //
 648     // Darwin
 649     //
 650 
 651     private void setupDebuggerDarwin() {
 652         setupJVMLibNamesDarwin();
 653 
 654         if (cpu.equals("amd64") || cpu.equals("x86_64")) {
 655             machDesc = new MachineDescriptionAMD64();
 656         } else {
 657             throw new DebuggerException("Darwin only supported on x86_64. Current arch: " + cpu);
 658         }
 659 
 660         BsdDebuggerLocal dbg = new BsdDebuggerLocal(machDesc, !isServer);
 661         debugger = dbg;
 662 
 663         attachDebugger();
 664     }
 665 
 666     private void setupJVMLibNamesDarwin() {
 667         jvmLibNames = new String[] { "libjvm.dylib" };
 668     }
 669 
 670     /** Convenience routine which should be called by per-platform
 671       debugger setup. Should not be called when startupMode is
 672       REMOTE_MODE. */
 673     private void attachDebugger() {
 674         if (startupMode == PROCESS_MODE) {
 675             debugger.attach(pid);
 676         } else if (startupMode == CORE_FILE_MODE) {
 677             debugger.attach(javaExecutableName, coreFileName);
 678         } else {
 679             throw new DebuggerException("Should not call attach() for startupMode == " + startupMode);
 680         }
 681     }
 682 }