import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
public WorkerThreadTask execute(WorkerThreadTask task) throws DebuggerException {
   synchronized (workerThread) {
      this.task = task;
      workerThread.notifyAll();
      while (this.task != null) {
         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
      if (lastException != null) {
         throw new DebuggerException(lastException);
      } else {
         return task;
      }
   }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** From the Debugger interface via JVMDebugger */
public synchronized void attach(int processID) throws DebuggerException {
    checkAttached();
    threadList = new ArrayList();
    loadObjectList = new ArrayList();
    class AttachTask implements WorkerThreadTask {
       int pid;
       public void doit(BsdDebuggerLocal debugger) {
          debugger.attach0(pid);
          debugger.attached = true;
          debugger.isCore = false;
          findABIVersion();
       }
    }

    AttachTask task = new AttachTask();
    task.pid = processID;
    workerThread.execute(task);
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
public synchronized long[] getThreadIntegerRegisterSet(long unique_thread_id)
                                        throws DebuggerException {
    requireAttach();
    if (isCore) {
        return getThreadIntegerRegisterSet0(unique_thread_id);
    } else {
        class GetThreadIntegerRegisterSetTask implements WorkerThreadTask {
            long unique_thread_id;
            long[] result;
            public void doit(BsdDebuggerLocal debugger) {
                result = debugger.getThreadIntegerRegisterSet0(unique_thread_id);
            }
        }

        GetThreadIntegerRegisterSetTask task = new GetThreadIntegerRegisterSetTask();
        task.unique_thread_id = unique_thread_id;
        workerThread.execute(task);
        return task.result;
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
public synchronized long[] getThreadIntegerRegisterSet(int lwp_id)
                                        throws DebuggerException {
    requireAttach();
    if (isCore) {
        return getThreadIntegerRegisterSet0(lwp_id);
    } else {
        class GetThreadIntegerRegisterSetTask implements WorkerThreadTask {
            int lwp_id;
            long[] result;
            public void doit(LinuxDebuggerLocal debugger) {
                result = debugger.getThreadIntegerRegisterSet0(lwp_id);
            }
        }

        GetThreadIntegerRegisterSetTask task = new GetThreadIntegerRegisterSetTask();
        task.lwp_id = lwp_id;
        workerThread.execute(task);
        return task.result;
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** From the Debugger interface via JVMDebugger */
public synchronized void attach(int processID) throws DebuggerException {
    checkAttached();
    threadList = new ArrayList();
    loadObjectList = new ArrayList();
    class AttachTask implements WorkerThreadTask {
       int pid;
       public void doit(LinuxDebuggerLocal debugger) {
          debugger.attach0(pid);
          debugger.attached = true;
          debugger.isCore = false;
          findABIVersion();
       }
    }

    AttachTask task = new AttachTask();
    task.pid = processID;
    workerThread.execute(task);
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This opens a core file on the local machine and starts a debug
  server, allowing remote machines to connect and examine this
  core file. Uses supplied uniqueID to uniquely identify a specific
  debugee */
public synchronized void startServer(String javaExecutableName,
String coreFileName,
String uniqueID) {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    if ((javaExecutableName == null) || (coreFileName == null)) {
        throw new DebuggerException("Both the core file name and Java executable name must be specified");
    }
    this.javaExecutableName = javaExecutableName;
    this.coreFileName = coreFileName;
    startupMode = CORE_FILE_MODE;
    isServer = true;
    serverID = uniqueID;
    go();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This attaches to a process running on the local machine and
  starts a debug server, allowing remote machines to connect and
  examine this process. Uses specified name to uniquely identify a
  specific debuggee on the server */
public synchronized void startServer(int processID, String uniqueID) {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    pid = processID;
    startupMode = PROCESS_MODE;
    isServer = true;
    serverID = uniqueID;
    go();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private void checkAttached() throws DebuggerException {
    if (attached) {
        if (isCore) {
            throw new DebuggerException("attached to a core dump already");
        } else {
            throw new DebuggerException("attached to a process already");
        }
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private void findABIVersion() throws DebuggerException {
    String libjvmName = isDarwin ? "libjvm.dylib" : "libjvm.so";
    String javaThreadVt = isDarwin ? "_vt_10JavaThread" : "__vt_10JavaThread";
    if (lookupByName0(libjvmName, javaThreadVt) != 0) {
        // old C++ ABI
        useGCC32ABI = false;
    } else {
        // new C++ ABI
        useGCC32ABI = true;
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private long handleGCC32ABI(long addr, String symbol) throws DebuggerException {
    if (useGCC32ABI && symbol.startsWith("_ZTV")) {
        return addr + (2 * machDesc.getAddressSize());
    } else {
        return addr;
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This opens a core file on the local machine */
public synchronized void attach(String javaExecutableName, String coreFileName)
throws DebuggerException {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    if ((javaExecutableName == null) || (coreFileName == null)) {
        throw new DebuggerException("Both the core file name and Java executable name must be specified");
    }
    this.javaExecutableName = javaExecutableName;
    this.coreFileName = coreFileName;
    startupMode = CORE_FILE_MODE;
    isServer = false;
    go();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private void findABIVersion() throws DebuggerException {
    if (lookupByName0("libjvm.so", "__vt_10JavaThread") != 0) {
        // old C++ ABI
        useGCC32ABI = false;
    } else {
        // new C++ ABI
        useGCC32ABI = true;
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
public static Remote lookup(String debugServerID) throws DebuggerException {
    // debugServerID follows the pattern [[email protected]]host[:port]
    // we have to transform this as //host[:port]/<serverNamePrefix>['_'<unique_id>]

    int index = debugServerID.indexOf('@');
    StringBuffer nameBuf = new StringBuffer("//");
    String uniqueID = null;
    if (index != -1) {
        nameBuf.append(debugServerID.substring(index + 1));
        uniqueID = debugServerID.substring(0, index);
    } else {
        nameBuf.append(debugServerID);
    }

    nameBuf.append('/');
    nameBuf.append(serverNamePrefix);
    if (uniqueID != null) {
        nameBuf.append('_');
        nameBuf.append(uniqueID);
    }

    try {
        return Naming.lookup(nameBuf.toString());
    } catch (Exception exp) {
        throw new DebuggerException(exp);
    }
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This attaches to a process running on the local machine. */
public synchronized void attach(int processID)
throws DebuggerException {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    pid = processID;
    startupMode = PROCESS_MODE;
    isServer = false;
    go();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This may only be called on the server side after startServer()
  has been called */
public synchronized boolean shutdownServer() throws DebuggerException {
    if (!isServer) {
        throw new DebuggerException("Should not call shutdownServer() for client configuration");
    }
    return detachInternal();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** This should only be called by the user on the client machine,
  not the server machine */
public synchronized boolean detach() throws DebuggerException {
    if (isServer) {
        throw new DebuggerException("Should not call detach() for server configuration");
    }
    return detachInternal();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private void connectRemoteDebugger() throws DebuggerException {
    RemoteDebugger remote =
    (RemoteDebugger) RMIHelper.lookup(debugServerID);
    debugger = new RemoteDebuggerClient(remote);
    machDesc = ((RemoteDebuggerClient) debugger).getMachineDescription();
    os = debugger.getOS();
    setupJVMLibNames(os);
    cpu = debugger.getCPU();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
private void setupDebuggerDarwin() {
    setupJVMLibNamesDarwin();

    if (cpu.equals("amd64") || cpu.equals("x86_64")) {
        machDesc = new MachineDescriptionAMD64();
    } else {
        throw new DebuggerException("Darwin only supported on x86_64. Current arch: " + cpu);
    }

    BsdDebuggerLocal dbg = new BsdDebuggerLocal(machDesc, !isServer);
    debugger = dbg;

    attachDebugger();
}
 

import sun.jvm.hotspot.debugger.DebuggerException; //导入依赖的package包/类
/** Convenience routine which should be called by per-platform
  debugger setup. Should not be called when startupMode is
  REMOTE_MODE. */
private void attachDebugger() {
    if (startupMode == PROCESS_MODE) {
        debugger.attach(pid);
    } else if (startupMode == CORE_FILE_MODE) {
        debugger.attach(javaExecutableName, coreFileName);
    } else {
        throw new DebuggerException("Should not call attach() for startupMode == " + startupMode);
    }
}