/*

 * Copyright 2002-2004 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

package sun.jvm.hotspot.debugger.remote;

import java.rmi.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.debugger.cdbg.*;

import sun.jvm.hotspot.debugger.remote.sparc.*;

import sun.jvm.hotspot.debugger.remote.x86.*;

import sun.jvm.hotspot.debugger.remote.amd64.*;

/** An implementation of Debugger which wraps a

    RemoteDebugger, providing remote debugging via RMI.

    This implementation provides caching of the remote process's

    address space on the local machine where the user interface is

    running. */

public class RemoteDebuggerClient extends DebuggerBase implements JVMDebugger {

  private RemoteDebugger remoteDebugger;

  private RemoteThreadFactory threadFactory;

  private boolean unalignedAccessesOkay = false;

  private static final int cacheSize = 16 * 1024 * 1024; // 16 MB

  public RemoteDebuggerClient(RemoteDebugger remoteDebugger) throws DebuggerException {

    super();

    try {

      this.remoteDebugger = remoteDebugger;

      machDesc = remoteDebugger.getMachineDescription();

      utils = new DebuggerUtilities(machDesc.getAddressSize(), machDesc.isBigEndian());

      int cacheNumPages;

      int cachePageSize;

      String cpu = remoteDebugger.getCPU();

      // page size. (FIXME: should pick this up from the remoteDebugger.)

      if (cpu.equals("sparc")) {

        threadFactory = new RemoteSPARCThreadFactory(this);

        cachePageSize = 8192;

        cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);

      } else if (cpu.equals("x86")) {

        threadFactory = new RemoteX86ThreadFactory(this);

        cachePageSize = 4096;

        cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);

        unalignedAccessesOkay = true;

      } else if (cpu.equals("amd64")) {

        threadFactory = new RemoteAMD64ThreadFactory(this);

        cachePageSize = 4096;

        cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);

        unalignedAccessesOkay = true;

      } else {

        throw new DebuggerException("Thread access for CPU architecture " + cpu + " not yet supported");

      }

      // Cache portion of the remote process's address space.

      initCache(cachePageSize, cacheNumPages);

      jbooleanSize = remoteDebugger.getJBooleanSize();

      jbyteSize    = remoteDebugger.getJByteSize();

      jcharSize    = remoteDebugger.getJCharSize();

      jdoubleSize  = remoteDebugger.getJDoubleSize();

      jfloatSize   = remoteDebugger.getJFloatSize();

      jintSize     = remoteDebugger.getJIntSize();

      jlongSize    = remoteDebugger.getJLongSize();

      jshortSize   = remoteDebugger.getJShortSize();

      javaPrimitiveTypesConfigured = true;

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public long[] getThreadIntegerRegisterSet(Address addr) {

    try {

      return remoteDebugger.getThreadIntegerRegisterSet(getAddressValue(addr), true);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public long[] getThreadIntegerRegisterSet(long id) {

    try {

      return remoteDebugger.getThreadIntegerRegisterSet(id, false);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  /** Unimplemented in this class (remote remoteDebugger should already be attached) */

  public boolean hasProcessList() throws DebuggerException {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  /** Unimplemented in this class (remote remoteDebugger should already be attached) */

  public List getProcessList() throws DebuggerException {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  /** Unimplemented in this class (remote remoteDebugger should already be attached) */

  public void attach(int processID) throws DebuggerException {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  /** Unimplemented in this class (remote remoteDebugger should already be attached) */

  public void attach(String executableName, String coreFileName) throws DebuggerException {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  /** Unimplemented in this class (remote remoteDebugger can not be detached) */

  public boolean detach() {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  public Address parseAddress(String addressString) throws NumberFormatException {

    long addr = utils.scanAddress(addressString);

    if (addr == 0) {

      return null;

    }

    return new RemoteAddress(this, addr);

  }

  public String getOS() throws DebuggerException {

    try {

      return remoteDebugger.getOS();

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public String getCPU() {

    try {

      return remoteDebugger.getCPU();

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public boolean hasConsole() throws DebuggerException {

    try {

       return remoteDebugger.hasConsole();

    } catch (RemoteException e) {

       throw new DebuggerException(e);

    }

  }

  public String consoleExecuteCommand(String cmd) throws DebuggerException {

    try {

      return remoteDebugger.consoleExecuteCommand(cmd);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public String getConsolePrompt() throws DebuggerException {

    try {

      return remoteDebugger.getConsolePrompt();

    } catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public CDebugger getCDebugger() throws DebuggerException {

    return null;

  }

  //--------------------------------------------------------------------------------

  // Implementation of SymbolLookup interface

  public Address lookup(String objectName, String symbol) {

    try {

      long addr = remoteDebugger.lookupInProcess(objectName, symbol);

      if (addr == 0) {

        return null;

      }

      return new RemoteAddress(this, addr);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public OopHandle lookupOop(String objectName, String symbol) {

    try {

      long addr = remoteDebugger.lookupInProcess(objectName, symbol);

      if (addr == 0) {

        return null;

      }

      return new RemoteOopHandle(this, addr);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  /** Need to override this to relax alignment checks on x86. */

  public long readCInteger(long address, long numBytes, boolean isUnsigned)

    throws UnmappedAddressException, UnalignedAddressException {

    if (!unalignedAccessesOkay) {

      utils.checkAlignment(address, numBytes);

    } else {

      // Only slightly relaxed semantics -- this is a hack, but is

      // necessary on x86 where it seems the compiler is

      // putting some global 64-bit data on 32-bit boundaries

      if (numBytes == 8) {

        utils.checkAlignment(address, 4);

      } else {

        utils.checkAlignment(address, numBytes);

      }

    }

    byte[] data = readBytes(address, numBytes);

    return utils.dataToCInteger(data, isUnsigned);

  }

  // Overridden from DebuggerBase because we need to relax alignment

  // constraints on x86

  public long readJLong(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    // FIXME: allow this to be configurable. Undesirable to add a

    // dependency on the runtime package here, though, since this

    // package should be strictly underneath it.

    if (unalignedAccessesOkay) {

      utils.checkAlignment(address, jintSize);

    } else {

      utils.checkAlignment(address, jlongSize);

    }

    byte[] data = readBytes(address, jlongSize);

    return utils.dataToJLong(data, jlongSize);

  }

  //--------------------------------------------------------------------------------

  // Implementation of JVMDebugger interface

  //

  /** Unimplemented in this class (remote remoteDebugger should already be configured) */

  public void configureJavaPrimitiveTypeSizes(long jbooleanSize,

                                              long jbyteSize,

                                              long jcharSize,

                                              long jdoubleSize,

                                              long jfloatSize,

                                              long jintSize,

                                              long jlongSize,

                                              long jshortSize) {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  public void setMachineDescription(MachineDescription machDesc) {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  public int getRemoteProcessAddressSize() {

    throw new DebuggerException("Should not be called on RemoteDebuggerClient");

  }

  public String addressValueToString(long addr) {

    return utils.addressValueToString(addr);

  }

  public long getAddressValue(Address addr) throws DebuggerException {

    if (addr == null) return 0;

    return ((RemoteAddress) addr).getValue();

  }

  public Address newAddress(long value) {

    if (value == 0) return null;

    return new RemoteAddress(this, value);

  }

  RemoteAddress readAddress(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    long value = readAddressValue(address);

    return (value == 0 ? null : new RemoteAddress(this, value));

  }

  RemoteOopHandle readOopHandle(long address)

    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {

    long value = readAddressValue(address);

    return (value == 0 ? null : new RemoteOopHandle(this, value));

  }

  boolean areThreadsEqual(Address addr1, Address addr2) {

    try {

       return remoteDebugger.areThreadsEqual(getAddressValue(addr1), true,

                                             getAddressValue(addr2), true);

    } catch (RemoteException e) {

    }

    return false;

  }

  boolean areThreadsEqual(long id1, long id2) {

    try {

       return remoteDebugger.areThreadsEqual(id1, false, id2, false);

    } catch (RemoteException e) {

    }

    return false;

  }

  boolean areThreadsEqual(Address addr1, long id2) {

    try {

       return remoteDebugger.areThreadsEqual(getAddressValue(addr1), true, id2, false);

    } catch (RemoteException e) {

    }

    return false;

  }

  boolean areThreadsEqual(long id1, Address addr2) {

    try {

       return remoteDebugger.areThreadsEqual(id1, false, getAddressValue(addr2), true);

    } catch (RemoteException e) {

    }

    return false;

  }

  int getThreadHashCode(Address a) {

    try {

       return remoteDebugger.getThreadHashCode(getAddressValue(a), true);

    } catch (RemoteException e) {

    }

    return a.hashCode();

  }

  int getThreadHashCode(long id) {

    try {

       return remoteDebugger.getThreadHashCode(id, false);

    } catch (RemoteException e) {

    }

    return (int) id;

  }

  public ThreadProxy getThreadForIdentifierAddress(Address addr) {

     return threadFactory.createThreadWrapper(addr);

  }

  public ThreadProxy getThreadForThreadId(long id) {

     return threadFactory.createThreadWrapper(id);

  }

  public MachineDescription getMachineDescription() throws DebuggerException {

     return machDesc;

  }

  /** This reads bytes from the remote process. */

  public ReadResult readBytesFromProcess(long address, long numBytes) {

    try {

      return remoteDebugger.readBytesFromProcess(address, numBytes);

    }

    catch (RemoteException e) {

      throw new DebuggerException(e);

    }

  }

  public void writeBytesToProcess(long a, long b, byte[] c) {

     throw new DebuggerException("Unimplemented!");

  }

}