1 /*
   2  * Copyright (c) 2000, 2008, 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.debugger.win32;
  26 
  27 import java.util.List;
  28 import sun.jvm.hotspot.debugger.*;
  29 import sun.jvm.hotspot.debugger.cdbg.*;
  30 
  31 /** An extension of the JVMDebugger interface with a few additions to
  32     support 32-bit vs. 64-bit debugging as well as features required
  33     by the architecture-specific subpackages. */
  34 
  35 public interface Win32Debugger extends JVMDebugger {
  36   public String       addressValueToString(long address) throws DebuggerException;
  37   public boolean      readJBoolean(long address) throws DebuggerException;
  38   public byte         readJByte(long address) throws DebuggerException;
  39   public char         readJChar(long address) throws DebuggerException;
  40   public double       readJDouble(long address) throws DebuggerException;
  41   public float        readJFloat(long address) throws DebuggerException;
  42   public int          readJInt(long address) throws DebuggerException;
  43   public long         readJLong(long address) throws DebuggerException;
  44   public short        readJShort(long address) throws DebuggerException;
  45   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
  46     throws DebuggerException;
  47   public Win32Address readAddress(long address) throws DebuggerException;
  48   public Win32Address readCompOopAddress(long address) throws DebuggerException;
  49   public Win32OopHandle readOopHandle(long address) throws DebuggerException;
  50   public Win32OopHandle readCompOopHandle(long address) throws DebuggerException;
  51   public void         writeJBoolean(long address, boolean value) throws DebuggerException;
  52   public void         writeJByte(long address, byte value) throws DebuggerException;
  53   public void         writeJChar(long address, char value) throws DebuggerException;
  54   public void         writeJDouble(long address, double value) throws DebuggerException;
  55   public void         writeJFloat(long address, float value) throws DebuggerException;
  56   public void         writeJInt(long address, int value) throws DebuggerException;
  57   public void         writeJLong(long address, long value) throws DebuggerException;
  58   public void         writeJShort(long address, short value) throws DebuggerException;
  59   public void         writeCInteger(long address, long numBytes, long value) throws DebuggerException;
  60   public void         writeAddress(long address, Win32Address value) throws DebuggerException;
  61   public void         writeOopHandle(long address, Win32OopHandle value) throws DebuggerException;
  62 
  63   // On Windows the int is actually the value of a HANDLE which
  64   // currently must be read from the target process; that is, the
  65   // target process must maintain its own thread list, each element of
  66   // which holds a HANDLE to its underlying OS thread. FIXME: should
  67   // add access to the OS-level thread list, but there are too many
  68   // limitations imposed by Windows to usefully do so; see
  69   // src/os/win32/agent/README-commands.txt, command "duphandle".
  70   //
  71   // The returned array of register contents is guaranteed to be in
  72   // the same order as in the DbxDebugger for Solaris/x86; that is,
  73   // the indices match those in debugger/x86/X86ThreadContext.java.
  74   public long[]       getThreadIntegerRegisterSet(int threadHandleValue,
  75                                                   boolean mustDuplicateHandle) throws DebuggerException;
  76   // Implmentation of setContext
  77   public void         setThreadIntegerRegisterSet(int threadHandleValue,
  78                                                   boolean mustDuplicateHandle,
  79                                                   long[] contents) throws DebuggerException;
  80 
  81   public Address      newAddress(long value) throws DebuggerException;
  82 
  83   // Routine supporting the ThreadProxy implementation, in particular
  84   // the ability to get a thread ID from a thread handle via
  85   // examination of the Thread Information Block. Fetch the LDT entry
  86   // for a given selector.
  87   public Win32LDTEntry getThreadSelectorEntry(int threadHandleValue,
  88                                               boolean mustDuplicateHandle,
  89                                               int selector) throws DebuggerException;
  90 
  91   // Support for the CDebugger interface. Retrieves the thread list of
  92   // the target process as a List of ThreadProxy objects.
  93   public List/*<ThreadProxy>*/ getThreadList() throws DebuggerException;
  94 
  95   // Support for the CDebugger interface. Retrieves a List of the
  96   // loadobjects in the target process.
  97   public List/*<LoadObject>*/ getLoadObjectList() throws DebuggerException;
  98 
  99   // Support for the ProcessControl interface
 100   public void writeBytesToProcess(long startAddress, long numBytes, byte[] data) throws UnmappedAddressException, DebuggerException;
 101   public void suspend() throws DebuggerException;
 102   public void resume() throws DebuggerException;
 103   public boolean isSuspended() throws DebuggerException;
 104   public void setBreakpoint(Address addr) throws DebuggerException;
 105   public void clearBreakpoint(Address addr) throws DebuggerException;
 106   public boolean isBreakpointSet(Address addr) throws DebuggerException;
 107   // FIXME: do not want to expose complicated data structures (like
 108   // the DebugEvent) in this interface due to serialization issues
 109   public DebugEvent debugEventPoll() throws DebuggerException;
 110   public void debugEventContinue() throws DebuggerException;
 111 
 112   // NOTE: this interface implicitly contains the following methods:
 113   // From the Debugger interface via JVMDebugger
 114   //   public void attach(int processID) throws DebuggerException;
 115   //   public void attach(String executableName, String coreFileName) throws DebuggerException;
 116   //   public boolean detach();
 117   //   public Address parseAddress(String addressString) throws NumberFormatException;
 118   //   public long getAddressValue(Address addr) throws DebuggerException;
 119   //   public String getOS();
 120   //   public String getCPU();
 121   // From the SymbolLookup interface via Debugger and JVMDebugger
 122   //   public Address lookup(String objectName, String symbol);
 123   //   public OopHandle lookupOop(String objectName, String symbol);
 124   // From the JVMDebugger interface
 125   //   public void configureJavaPrimitiveTypeSizes(long jbooleanSize,
 126   //                                               long jbyteSize,
 127   //                                               long jcharSize,
 128   //                                               long jdoubleSize,
 129   //                                               long jfloatSize,
 130   //                                               long jintSize,
 131   //                                               long jlongSize,
 132   //                                               long jshortSize);
 133   // From the ThreadAccess interface via Debugger and JVMDebugger
 134   //   public ThreadProxy getThreadForIdentifierAddress(Address addr);
 135 }