i386-stub-win32.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

/****************************************************************************

				THIS SOFTWARE IS NOT COPYRIGHTED

   HP offers the following for use in the public domain.  HP makes no
   warranty with regard to the software or it's performance and the
   user accepts the software "AS IS" with all faults.

   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

****************************************************************************/

/****************************************************************************
 *	Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
 *
 *	Module name: remcom.c $
 *	Revision: 1.34 $
 *	Date: 91/03/09 12:29:49 $
 *	Contributor:	 Lake Stevens Instrument Division$
 *
 *	Description:	 low level support for gdb debugger. $
 *
 *	Considerations:  only works on target hardware $
 *
 *	Written by: 	 Glenn Engel $
 *	ModuleState:	 Experimental $
 *
 *	NOTES:			 See Below $
 *
 *	Modified for 386 by Jim Kingdon, Cygnus Support.
 *
 *	To enable debugger support, two things need to happen.	One, a
 *	call to set_debug_traps() is necessary in order to allow any breakpoints
 *	or error conditions to be properly intercepted and reported to gdb.
 *	Two, a breakpoint needs to be generated to begin communication.  This
 *	is most easily accomplished by a call to breakpoint().	Breakpoint()
 *	simulates a breakpoint by executing a trap #1.
 *
 *	The external function exceptionHandler() is
 *	used to attach a specific handler to a specific 386 vector number.
 *	It should use the same privilege level it runs at.	It should
 *	install it as an interrupt gate so that interrupts are masked
 *	while the handler runs.
 *
 *	Because gdb will sometimes write to the stack area to execute function
 *	calls, this program cannot rely on using the supervisor stack so it
 *	uses it's own stack area reserved in the int array remcomStack.
 *
 *************
 *
 *	  The following gdb commands are supported:
 *
 * command			function							   Return value
 *
 *	  g 			return the value of the CPU registers  hex data or ENN
 *	  G 			set the value of the CPU registers	   OK or ENN
 *
 *	  mAA..AA,LLLL	Read LLLL bytes at address AA..AA	   hex data or ENN
 *	  MAA..AA,LLLL: Write LLLL bytes at address AA.AA	   OK or ENN
 *
 *	  c 			Resume at current address			   SNN	 ( signal NN)
 *	  cAA..AA		Continue at address AA..AA			   SNN
 *
 *	  s 			Step one instruction				   SNN
 *	  sAA..AA		Step one instruction from AA..AA	   SNN
 *
 *	  k 			kill
 *
 *	  ? 			What was the last sigval ?			   SNN	 (signal NN)
 *
 * All commands and responses are sent with a packet which includes a
 * checksum.  A packet consists of
 *
 * $<packet info>#<checksum>.
 *
 * where
 * <packet info> :: <characters representing the command or response>
 * <checksum>	 :: < two hex digits computed as modulo 256 sum of <packetinfo>>
 *
 * When a packet is received, it is first acknowledged with either '+' or '-'.
 * '+' indicates a successful transfer.  '-' indicates a failed transfer.
 *
 * Example:
 *
 * Host:				  Reply:
 * $m0,10#2a			   +$00010203040506070809101112131415#42
 *
 ****************************************************************************/

#include <stdio.h>
#include <string.h>

#include "utility/utility.h"	// for strcpy_s()

/************************************************************************
 *
 * external low-level support routines
 */

extern void putDebugChar(); 	/* write a single character 	 */
extern int getDebugChar();		/* read and return a single char */
extern void exceptionHandler(); /* assign an exception handler	 */

/************************************************************************/
/* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
/* at least NUMREGBYTES*2 are needed for register packets */
#define BUFMAX 400

static char initialized;  /* boolean flag. != 0 means we've been initialized */

int 	remote_debug;
/*	debug >  0 prints ill-formed commands in valid packets & checksum errors */

static const char hexchars[]="0123456789abcdef";

/* Number of registers.  */
#define NUMREGS 16

/* Number of bytes of registers.  */
#define NUMREGBYTES (NUMREGS * 4)

enum regnames {EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
			   PC /* also known as eip */,
			   PS /* also known as eflags */,
			   CS, SS, DS, ES, FS, GS};

/*
 * these should not be static cuz they can be used outside this module
 */
int registers[NUMREGS];

#ifndef WIN32 //MF

#define STACKSIZE 10000
int remcomStack[STACKSIZE/sizeof(int)];
static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];

/***************************  ASSEMBLY CODE MACROS *************************/
/*																		   */

extern void
return_to_prog ();

/* Restore the program's registers (including the stack pointer, which
   means we get the right stack and don't have to worry about popping our
   return address and any stack frames and so on) and return.  */
asm(".text");
asm(".globl _return_to_prog");
asm("_return_to_prog:");
asm("        movw _registers+44, %ss");
asm("        movl _registers+16, %esp");
asm("        movl _registers+4, %ecx");
asm("        movl _registers+8, %edx");
asm("        movl _registers+12, %ebx");
asm("        movl _registers+20, %ebp");
asm("        movl _registers+24, %esi");
asm("        movl _registers+28, %edi");
asm("        movw _registers+48, %ds");
asm("        movw _registers+52, %es");
asm("        movw _registers+56, %fs");
asm("        movw _registers+60, %gs");
asm("        movl _registers+36, %eax");
asm("        pushl %eax");	/* saved eflags */
asm("        movl _registers+40, %eax");
asm("        pushl %eax");	/* saved cs */
asm("        movl _registers+32, %eax");
asm("        pushl %eax");	/* saved eip */
asm("        movl _registers, %eax");

asm("ret"); 	//MF

/* use iret to restore pc and flags together so
   that trace flag works right.  */
asm("        iret");


#ifdef WIN32 //MF
asm(".data"); //MF
#endif

/* Put the error code here just in case the user cares.  */
int gdb_i386errcode;
/* Likewise, the vector number here (since GDB only gets the signal
   number through the usual means, and that's not very specific).  */
int gdb_i386vector = -1;

/* GDB stores segment registers in 32-bit words (that's just the way
   m-i386v.h is written).  So zero the appropriate areas in registers.	*/
#define SAVE_REGISTERS1() \
  asm ("movl %eax, _registers");										  \
  asm ("movl %ecx, _registers+4");											 \
  asm ("movl %edx, _registers+8");											 \
  asm ("movl %ebx, _registers+12"); 										 \
  asm ("movl %ebp, _registers+20"); 										 \
  asm ("movl %esi, _registers+24"); 										 \
  asm ("movl %edi, _registers+28"); 										 \
  asm ("movw $0, %ax"); 													 \
  asm ("movw %ds, _registers+48");											 \
  asm ("movw %ax, _registers+50");											 \
  asm ("movw %es, _registers+52");											 \
  asm ("movw %ax, _registers+54");											 \
  asm ("movw %fs, _registers+56");											 \
  asm ("movw %ax, _registers+58");											 \
  asm ("movw %gs, _registers+60");											 \
  asm ("movw %ax, _registers+62");
#define SAVE_ERRCODE() \
  asm ("popl %ebx");								  \
  asm ("movl %ebx, _gdb_i386errcode");
#define SAVE_REGISTERS2() \
  asm ("popl %ebx"); /* old eip */											 \
  asm ("movl %ebx, _registers+32"); 										 \
  asm ("popl %ebx");	 /* old cs */										 \
  asm ("movl %ebx, _registers+40"); 										 \
  asm ("movw %ax, _registers+42");											 \
  asm ("popl %ebx");	 /* old eflags */									 \
  asm ("movl %ebx, _registers+36"); 										 \
  /* Now that we've done the pops, we can save the stack pointer.");  */   \
  asm ("movw %ss, _registers+44");											 \
  asm ("movw %ax, _registers+46");											 \
  asm ("movl %esp, _registers+16");

/* See if mem_fault_routine is set, if so just IRET to that address.  */
#define CHECK_FAULT() \
  asm ("cmpl $0, _mem_fault_routine");									   \
  asm ("jne mem_fault");

asm (".text");
asm ("mem_fault:");
/* OK to clobber temp registers; we're just going to end up in set_mem_err.  */
/* Pop error code from the stack and save it.  */
asm ("     popl %eax");
asm ("     movl %eax, _gdb_i386errcode");

asm ("     popl %eax"); /* eip */
/* We don't want to return there, we want to return to the function
   pointed to by mem_fault_routine instead.  */
asm ("     movl _mem_fault_routine, %eax");
asm ("     popl %ecx"); /* cs (low 16 bits; junk in hi 16 bits).  */
asm ("     popl %edx"); /* eflags */

/* Remove this stack frame; when we do the iret, we will be going to
   the start of a function, so we want the stack to look just like it
   would after a "call" instruction.  */
asm ("     leave");

/* Push the stuff that iret wants.	*/
asm ("     pushl %edx"); /* eflags */
asm ("     pushl %ecx"); /* cs */
asm ("     pushl %eax"); /* eip */

/* Zero mem_fault_routine.	*/
asm ("     movl $0, %eax");
asm ("     movl %eax, _mem_fault_routine");

asm ("iret");


#define CALL_HOOK() asm("call _remcomHandler");

/* This function is called when a i386 exception occurs.  It saves
 * all the cpu regs in the _registers array, munges the stack a bit,
 * and invokes an exception handler (remcom_handler).
 *
 * stack on entry:						 stack on exit:
 *	 old eflags 						 vector number
 *	 old cs (zero-filled to 32 bits)
 *	 old eip
 *
 */
extern void _catchException3();
asm(".text");
asm(".globl __catchException3");
asm("__catchException3:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $3");
CALL_HOOK();

/* Same thing for exception 1.	*/
extern void _catchException1();
asm(".text");
asm(".globl __catchException1");
asm("__catchException1:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $1");
CALL_HOOK();

/* Same thing for exception 0.	*/
extern void _catchException0();
asm(".text");
asm(".globl __catchException0");
asm("__catchException0:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $0");
CALL_HOOK();

/* Same thing for exception 4.	*/
extern void _catchException4();
asm(".text");
asm(".globl __catchException4");
asm("__catchException4:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $4");
CALL_HOOK();

/* Same thing for exception 5.	*/
extern void _catchException5();
asm(".text");
asm(".globl __catchException5");
asm("__catchException5:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $5");
CALL_HOOK();

/* Same thing for exception 6.	*/
extern void _catchException6();
asm(".text");
asm(".globl __catchException6");
asm("__catchException6:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $6");
CALL_HOOK();

/* Same thing for exception 7.	*/
extern void _catchException7();
asm(".text");
asm(".globl __catchException7");
asm("__catchException7:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $7");
CALL_HOOK();

/* Same thing for exception 8.	*/
extern void _catchException8();
asm(".text");
asm(".globl __catchException8");
asm("__catchException8:");
SAVE_REGISTERS1();
SAVE_ERRCODE();
SAVE_REGISTERS2();
asm ("pushl $8");
CALL_HOOK();

/* Same thing for exception 9.	*/
extern void _catchException9();
asm(".text");
asm(".globl __catchException9");
asm("__catchException9:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $9");
CALL_HOOK();

/* Same thing for exception 10.  */
extern void _catchException10();
asm(".text");
asm(".globl __catchException10");
asm("__catchException10:");
SAVE_REGISTERS1();
SAVE_ERRCODE();
SAVE_REGISTERS2();
asm ("pushl $10");
CALL_HOOK();

/* Same thing for exception 12.  */
extern void _catchException12();
asm(".text");
asm(".globl __catchException12");
asm("__catchException12:");
SAVE_REGISTERS1();
SAVE_ERRCODE();
SAVE_REGISTERS2();
asm ("pushl $12");
CALL_HOOK();

/* Same thing for exception 16.  */
extern void _catchException16();
asm(".text");
asm(".globl __catchException16");
asm("__catchException16:");
SAVE_REGISTERS1();
SAVE_REGISTERS2();
asm ("pushl $16");
CALL_HOOK();

/* For 13, 11, and 14 we have to deal with the CHECK_FAULT stuff.  */

/* Same thing for exception 13.  */
extern void _catchException13 ();
asm (".text");
asm (".globl __catchException13");
asm ("__catchException13:");
CHECK_FAULT();
SAVE_REGISTERS1();
SAVE_ERRCODE();
SAVE_REGISTERS2();
asm ("pushl $13");
CALL_HOOK();

/* Same thing for exception 11.  */
extern void _catchException11 ();
asm (".text");
asm (".globl __catchException11");
asm ("__catchException11:");
CHECK_FAULT();
SAVE_REGISTERS1();
SAVE_ERRCODE();
SAVE_REGISTERS2();
asm ("pushl $11");
CALL_HOOK();

/* Same thing for exception 14.  */
extern void _catchException14 ();
asm (".text");
asm (".globl __catchException14");
asm ("__catchException14:");
CHECK_FAULT();
SAVE_REGISTERS1();
SAVE_ERRCODE();