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 }