i386-stub-win32.c File Reference

#include <stdio.h>
#include <string.h>
#include "utility/utility.h"

Include dependency graph for i386-stub-win32.c:

Go to the source code of this file.

Macros
#define	BUFMAX   400
#define	NUMREGS   16
#define	NUMREGBYTES   (NUMREGS * 4)
#define	STACKSIZE   10000
#define	SAVE_REGISTERS1()
#define	SAVE_ERRCODE()
#define	SAVE_REGISTERS2()
#define	CHECK_FAULT()
#define	CALL_HOOK()   asm("call _remcomHandler");
#define	BREAKPOINT()   asm(" int $3");

Enumerations
enum	regnames {   EAX , ECX , EDX , EBX ,   ESP , EBP , ESI , EDI ,   PC , PS , CS , SS ,   DS , ES , FS , GS }

Functions
void	putDebugChar ()
int	getDebugChar ()
void	exceptionHandler ()
void	return_to_prog ()
	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")
	asm (" movl _registers, %eax")
	asm ("ret")
	asm (" iret")
	asm ("mem_fault:")
	asm (" popl %eax")
	asm (" movl %eax, _gdb_i386errcode")
	asm (" popl %ecx")
	asm (" popl %edx")
	asm (" leave")
	asm (" pushl %edx")
	asm (" pushl %ecx")
	asm (" movl %eax, _mem_fault_routine")
	asm ("iret")
void	_catchException3 ()
	asm (".globl __catchException3")
	asm ("__catchException3:")
	asm ("pushl $3")
void	_catchException1 ()
	asm (".globl __catchException1")
	asm ("__catchException1:")
	asm ("pushl $1")
void	_catchException0 ()
	asm (".globl __catchException0")
	asm ("__catchException0:")
	asm ("pushl $0")
void	_catchException4 ()
	asm (".globl __catchException4")
	asm ("__catchException4:")
	asm ("pushl $4")
void	_catchException5 ()
	asm (".globl __catchException5")
	asm ("__catchException5:")
	asm ("pushl $5")
void	_catchException6 ()
	asm (".globl __catchException6")
	asm ("__catchException6:")
	asm ("pushl $6")
void	_catchException7 ()
	asm (".globl __catchException7")
	asm ("__catchException7:")
	asm ("pushl $7")
void	_catchException8 ()
	asm (".globl __catchException8")
	asm ("__catchException8:")
	asm ("pushl $8")
void	_catchException9 ()
	asm (".globl __catchException9")
	asm ("__catchException9:")
	asm ("pushl $9")
void	_catchException10 ()
	asm (".globl __catchException10")
	asm ("__catchException10:")
	asm ("pushl $10")
void	_catchException12 ()
	asm (".globl __catchException12")
	asm ("__catchException12:")
	asm ("pushl $12")
void	_catchException16 ()
	asm (".globl __catchException16")
	asm ("__catchException16:")
	asm ("pushl $16")
void	_catchException13 ()
	asm (".globl __catchException13")
	asm ("__catchException13:")
	asm ("pushl $13")
void	_catchException11 ()
	asm (".globl __catchException11")
	asm ("__catchException11:")
	asm ("pushl $11")
void	_catchException14 ()
	asm (".globl __catchException14")
	asm ("__catchException14:")
	asm ("pushl $14")
	asm ("_remcomHandler:")
	asm (" movl _stackPtr, %esp")
	asm (" call _handle_exception")
void	_returnFromException ()
int	hex (char ch)
char *	getpacket (void)
void	putpacket (char *buffer)
void	debug_error (char *format)
void	set_mem_err (void)
int	get_char (char *addr)
void	set_char (char *addr, int val)
char *	mem2hex (char *mem, char *buf, int count, int may_fault)
char *	hex2mem (char *buf, char *mem, int count, int may_fault)
int	computeSignal (int exceptionVector)
int	hexToInt (char **ptr, int *intValue)
void	handle_exception (int exceptionVector)
void	set_debug_traps (void)
void	breakpoint (void)

Variables
static char	initialized
int	remote_debug
static const char	hexchars [] ="0123456789abcdef"
int	registers [NUMREGS]
int	remcomStack [STACKSIZE/sizeof(int)]
static int *	stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]
int	gdb_i386errcode
int	gdb_i386vector = -1
static char	remcomInBuffer [BUFMAX]
static char	remcomOutBuffer [BUFMAX]
static void(*volatile	mem_fault_routine )() = NULL
static volatile int	mem_err = 0

Macro Definition Documentation

BREAKPOINT

#define BREAKPOINT

(

)

asm(" int $3");

Definition at line 456 of file i386-stub-win32.c.

BUFMAX

#define BUFMAX   400

Definition at line 109 of file i386-stub-win32.c.

CALL_HOOK

CALL_HOOK

(

)

asm("call _remcomHandler");

Definition at line 260 of file i386-stub-win32.c.

CHECK_FAULT

CHECK_FAULT

(

)

Value:

  asm ("cmpl $0, _mem_fault_routine");                                     \
  asm ("jne mem_fault");

Definition at line 225 of file i386-stub-win32.c.

NUMREGBYTES

#define NUMREGBYTES   (NUMREGS * 4)

Definition at line 122 of file i386-stub-win32.c.

NUMREGS

#define NUMREGS   16

Definition at line 119 of file i386-stub-win32.c.

SAVE_ERRCODE

SAVE_ERRCODE

(

)

Value:

  asm ("popl %ebx");                                  \
  asm ("movl %ebx, _gdb_i386errcode");

Definition at line 208 of file i386-stub-win32.c.

SAVE_REGISTERS1

SAVE_REGISTERS1

(

)

Value:

  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");

Definition at line 191 of file i386-stub-win32.c.

SAVE_REGISTERS2

SAVE_REGISTERS2

(

)

Value:

  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");

Definition at line 211 of file i386-stub-win32.c.

STACKSIZE

#define STACKSIZE   10000

Definition at line 136 of file i386-stub-win32.c.

Enumeration Type Documentation

regnames

enum regnames

Enumerator
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
PC
PS
CS
SS
DS
ES
FS
GS

Definition at line 124 of file i386-stub-win32.c.

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

Function Documentation

_catchException0()

void _catchException0

(

)

Referenced by set_debug_traps().

_catchException1()

void _catchException1

(

)

Referenced by set_debug_traps().

_catchException10()

void _catchException10

(

)

Referenced by set_debug_traps().

_catchException11()

void _catchException11

(

)

Referenced by set_debug_traps().

_catchException12()

void _catchException12

(

)

Referenced by set_debug_traps().

_catchException13()

void _catchException13

(

)

Referenced by set_debug_traps().

_catchException14()

void _catchException14

(

)

Referenced by set_debug_traps().

_catchException16()

void _catchException16

(

)

Referenced by set_debug_traps().

_catchException3()

void _catchException3

(

)

Referenced by set_debug_traps().

_catchException4()

void _catchException4

(

)

Referenced by set_debug_traps().

_catchException5()

void _catchException5

(

)

Referenced by set_debug_traps().

_catchException6()

void _catchException6

(

)

Referenced by set_debug_traps().

_catchException7()

void _catchException7

(

)

Referenced by set_debug_traps().

_catchException8()

void _catchException8

(

)

Referenced by set_debug_traps().

_catchException9()

void _catchException9

(

)

Referenced by set_debug_traps().

_returnFromException()

void _returnFromException

(

)

Definition at line 445 of file i386-stub-win32.c.

{
  return_to_prog ();
}

Referenced by handle_exception().

asm() [1/78]

asm

(

" call _handle_exception"

)

asm() [2/78]

asm	(	" movl	_stackPtr,
		%esp"
	)

asm() [3/78]

asm

(

" iret"

)

asm() [4/78]

asm	(	" movl _registers+	12,
		%ebx"
	)

asm() [5/78]

asm	(	" movl _registers+	16,
		%esp"
	)

asm() [6/78]

asm	(	" movl _registers+	20,
		%ebp"
	)

asm() [7/78]

asm	(	" movl _registers+	24,
		%esi"
	)

asm() [8/78]

asm	(	" movl _registers+	28,
		%edi"
	)

asm() [9/78]

asm	(	" movl _registers+	36,
		%eax"
	)

asm() [10/78]

asm	(	" movl _registers+	4,
		%ecx"
	)

asm() [11/78]

asm	(	" movl _registers+	8,
		%edx"
	)

asm() [12/78]

asm	(	" movl	_registers,
		%eax"
	)

asm() [13/78]

asm	(	" movw _registers+	44,
		%ss"
	)

asm() [14/78]

asm	(	" movw _registers+	48,
		%ds"
	)

asm() [15/78]

asm	(	" movw _registers+	52,
		%es"
	)

asm() [16/78]

asm	(	" movw _registers+	56,
		%fs"
	)

asm() [17/78]

asm	(	" movw _registers+	60,
		%gs"
	)

asm() [18/78]

asm

(

" pushl %eax"

)

asm() [19/78]

asm

(

" leave"

)

asm() [20/78]

asm	(	" movl %	eax,
		_gdb_i386errcode"
	)

asm() [21/78]

asm	(	" movl %	eax,
		_mem_fault_routine"
	)

asm() [22/78]

asm

(

" popl %eax"

)

asm() [23/78]

asm

(

" popl %ecx"

)

asm() [24/78]

asm

(

" popl %edx"

)

asm() [25/78]

asm

(

" pushl %ecx"

)

asm() [26/78]

asm

(

" pushl %edx"

)

asm() [27/78]

asm

(

".globl __catchException0"

)

asm() [28/78]

asm

(

".globl __catchException1"

)

asm() [29/78]

asm

(

".globl __catchException10"

)

asm() [30/78]

asm

(

".globl __catchException11"

)

asm() [31/78]

asm

(

".globl __catchException12"

)

asm() [32/78]

asm

(

".globl __catchException13"

)

asm() [33/78]

asm

(

".globl __catchException14"

)

asm() [34/78]

asm

(

".globl __catchException16"

)

asm() [35/78]

asm

(

".globl __catchException3"

)

asm() [36/78]

asm

(

".globl __catchException4"

)

asm() [37/78]

asm

(

".globl __catchException5"

)

asm() [38/78]

asm

(

".globl __catchException6"

)

asm() [39/78]

asm

(

".globl __catchException7"

)

asm() [40/78]

asm

(

".globl __catchException8"

)

asm() [41/78]

asm

(

".globl __catchException9"

)

asm() [42/78]

asm

(

".globl _return_to_prog"

)

asm() [43/78]

asm

(

".text"

)

asm() [44/78]

asm

(

"__catchException0:"

)

asm() [45/78]

asm

(

"__catchException10:"

)

asm() [46/78]

asm

(

"__catchException11:"

)

asm() [47/78]

asm

(

"__catchException12:"

)

asm() [48/78]

asm

(

"__catchException13:"

)

asm() [49/78]

asm

(

"__catchException14:"

)

asm() [50/78]

asm

(

"__catchException16:"

)

asm() [51/78]

asm

(

"__catchException1:"

)

asm() [52/78]

asm

(

"__catchException3:"

)

asm() [53/78]

asm

(

"__catchException4:"

)

asm() [54/78]

asm

(

"__catchException5:"

)

asm() [55/78]

asm

(

"__catchException6:"

)

asm() [56/78]

asm

(

"__catchException7:"

)

asm() [57/78]

asm

(

"__catchException8:"

)

asm() [58/78]

asm

(

"__catchException9:"

)

asm() [59/78]

asm

(

"_remcomHandler:"

)

asm() [60/78]

asm

(

"_return_to_prog:"

)

asm() [61/78]

asm

(

"iret"

)

asm() [62/78]

asm

(

"mem_fault:"

)

asm() [63/78]

asm

(

"pushl $0"

)

asm() [64/78]

asm

(

"pushl $1"

)

asm() [65/78]

asm

(

"pushl $10"

)

asm() [66/78]

asm

(

"pushl $11"

)

asm() [67/78]

asm

(

"pushl $12"

)

asm() [68/78]

asm

(

"pushl $13"

)

asm() [69/78]

asm

(

"pushl $14"

)

asm() [70/78]

asm

(

"pushl $16"

)

asm() [71/78]

asm

(

"pushl $3"

)

asm() [72/78]

asm

(

"pushl $4"

)

asm() [73/78]

asm

(

"pushl $5"

)

asm() [74/78]

asm

(

"pushl $6"

)

asm() [75/78]

asm

(

"pushl $7"

)

asm() [76/78]

asm

(

"pushl $8"

)

asm() [77/78]

asm

(

"pushl $9"

)

asm() [78/78]

asm

(

"ret"

)

breakpoint()

void breakpoint

(

void

)

Definition at line 1043 of file i386-stub-win32.c.

{
  if (initialized)
    BREAKPOINT ();
}

Referenced by DECLARE_INTERFACE_(), and xmlInitMemory().

computeSignal()

int computeSignal

(

int

exceptionVector

)

Definition at line 745 of file i386-stub-win32.c.

{
  int sigval;
  switch (exceptionVector)
    {
    case 0:
      sigval = 8;
      break;                    /* divide by zero */
    case 1:
      sigval = 5;
      break;                    /* debug exception */
    case 3:
      sigval = 5;
      break;                    /* breakpoint */
    case 4:
      sigval = 16;
      break;                    /* into instruction (overflow) */
    case 5:
      sigval = 16;
      break;                    /* bound instruction */
    case 6:
      sigval = 4;
      break;                    /* Invalid opcode */
    case 7:
      sigval = 8;
      break;                    /* coprocessor not available */
    case 8:
      sigval = 7;
      break;                    /* double fault */
    case 9:
      sigval = 11;
      break;                    /* coprocessor segment overrun */
    case 10:
      sigval = 11;
      break;                    /* Invalid TSS */
    case 11:
      sigval = 11;
      break;                    /* Segment not present */
    case 12:
      sigval = 11;
      break;                    /* stack exception */
    case 13:
      sigval = 11;
      break;                    /* general protection */
    case 14:
      sigval = 11;
      break;                    /* page fault */
    case 16:
      sigval = 7;
      break;                    /* coprocessor error */
    default:
      sigval = 7;               /* "software generated" */
    }
  return (sigval);
}

Referenced by handle_exception().

debug_error()

void debug_error

(

char *

format

)

Definition at line 630 of file i386-stub-win32.c.

{
  if (remote_debug)
    fprintf (stderr, format/*, parm*/);
}

Referenced by handle_exception().

exceptionHandler()

void exceptionHandler

(

)

Referenced by set_debug_traps().

get_char()

int get_char

(

char *

addr

)

Definition at line 654 of file i386-stub-win32.c.

{
  return *addr;
}

Referenced by mem2hex().

getDebugChar()

int getDebugChar

(

)

Referenced by getpacket(), and putpacket().

getpacket()

char * getpacket

(

void

)

Definition at line 530 of file i386-stub-win32.c.

{
  char *buffer = &remcomInBuffer[0];
  unsigned char checksum;
  unsigned char xmitcsum;
  int count;
  char ch;
 
  while (1)
    {
      /* wait around for the start character, ignore all other characters */
      while ((ch = getDebugChar ()) != '$')
        ;
 
    retry:
      checksum = 0;
      xmitcsum = -1;
      count = 0;
 
      /* now, read until a # or end of buffer is found */
      while (count < BUFMAX - 1)
        {
          ch = getDebugChar ();
          if (ch == '$')
            goto retry;
          if (ch == '#')
            break;
          checksum = checksum + ch;
          buffer[count] = ch;
          count = count + 1;
        }
      buffer[count] = 0;
 
      if (ch == '#')
        {
          ch = getDebugChar ();
          xmitcsum = hex (ch) << 4;
          ch = getDebugChar ();
          xmitcsum += hex (ch);
 
          if (checksum != xmitcsum)
            {
              if (remote_debug)
                {
                  fprintf (stderr,
                           "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
                           checksum, xmitcsum, buffer);
                }
              putDebugChar ('-');       /* failed checksum */
            }
          else
            {
              putDebugChar ('+');       /* successful transfer */
 
              /* if a sequence char is present, reply the sequence ID */
              if (buffer[2] == ':')
                {
                  putDebugChar (buffer[0]);
                  putDebugChar (buffer[1]);
 
                  return &buffer[3];
                }
 
              return &buffer[0];
            }
        }
    }
}

Referenced by handle_exception().

handle_exception()

void handle_exception

(

int

exceptionVector

)

Definition at line 834 of file i386-stub-win32.c.

{
  int sigval, stepping;
  int addr, length;
  char *ptr;
 
#ifndef WIN32 //MF
  gdb_i386vector = exceptionVector;
#endif
 
  if (remote_debug)
    {
      printf ("vector=%d, sr=0x%x, pc=0x%x\n",
              exceptionVector, registers[PS], registers[PC]);
    }
 
  /* reply to host that an exception has occurred */
  sigval = computeSignal (exceptionVector);
 
  ptr = remcomOutBuffer;
 
  *ptr++ = 'T';                 /* notify gdb with signo, PC, FP and SP */
  *ptr++ = hexchars[sigval >> 4];
  *ptr++ = hexchars[sigval & 0xf];
 
  *ptr++ = hexchars[ESP];
  *ptr++ = ':';
  ptr = mem2hex((char *)&registers[ESP], ptr, 4, 0);    /* SP */
  *ptr++ = ';';
 
  *ptr++ = hexchars[EBP];
  *ptr++ = ':';
  ptr = mem2hex((char *)&registers[EBP], ptr, 4, 0);    /* FP */
  *ptr++ = ';';
 
  *ptr++ = hexchars[PC];
  *ptr++ = ':';
  ptr = mem2hex((char *)&registers[PC], ptr, 4, 0);     /* PC */
  *ptr++ = ';';
 
  *ptr = '\0';
 
  putpacket (remcomOutBuffer);
 
  stepping = 0;
 
  while (1 == 1)
    {
      remcomOutBuffer[0] = 0;
      ptr = getpacket ();
 
      switch (*ptr++)
        {
        case '?':
          remcomOutBuffer[0] = 'S';
          remcomOutBuffer[1] = hexchars[sigval >> 4];
          remcomOutBuffer[2] = hexchars[sigval % 16];
          remcomOutBuffer[3] = 0;
          break;
        case 'd':
          remote_debug = !(remote_debug);       /* toggle debug flag */
          break;
        case 'g':               /* return the value of the CPU registers */
          mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES, 0);
          break;
        case 'G':               /* set the value of the CPU registers - return OK */
          hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
          strcpy_s(remcomOutBuffer, BUFMAX, "OK");
          break;
        case 'P':               /* set the value of a single CPU register - return OK */
          {
            int regno;
 
            if (hexToInt (&ptr, &regno) && *ptr++ == '=')
              if (regno >= 0 && regno < NUMREGS)
                {
                  hex2mem (ptr, (char *) &registers[regno], 4, 0);
                  strcpy_s(remcomOutBuffer, BUFMAX, "OK");
                  break;
                }
 
            strcpy_s(remcomOutBuffer, BUFMAX, "E01");
            break;
          }
 
          /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
        case 'm':
          /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
          if (hexToInt (&ptr, &addr))
            if (*(ptr++) == ',')
              if (hexToInt (&ptr, &length))
                {
                  ptr = 0;
                  mem_err = 0;
                  mem2hex ((char *) addr, remcomOutBuffer, length, 1);
                  if (mem_err)
                    {
                      strcpy_s(remcomOutBuffer, BUFMAX, "E03");
                      debug_error ("memory fault");
                    }
                }
 
          if (ptr)
            {
              strcpy_s(remcomOutBuffer, BUFMAX, "E01");
            }
          break;
 
          /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
        case 'M':
          /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
          if (hexToInt (&ptr, &addr))
            if (*(ptr++) == ',')
              if (hexToInt (&ptr, &length))
                if (*(ptr++) == ':')
                  {
                    mem_err = 0;
                    hex2mem (ptr, (char *) addr, length, 1);
 
                    if (mem_err)
                      {
                        strcpy_s(remcomOutBuffer, BUFMAX, "E03");
                        debug_error ("memory fault");
                      }
                    else
                      {
                        strcpy_s(remcomOutBuffer, BUFMAX, "OK");
                      }
 
                    ptr = 0;
                  }
          if (ptr)
            {
              strcpy_s(remcomOutBuffer, BUFMAX, "E02");
            }
          break;
 
          /* cAA..AA    Continue at address AA..AA(optional) */
          /* sAA..AA   Step one instruction from AA..AA(optional) */
        case 's':
          stepping = 1;
        case 'c':
          /* try to read optional parameter, pc unchanged if no parm */
          if (hexToInt (&ptr, &addr))
            registers[PC] = addr;
 
          /* clear the trace bit */
          registers[PS] &= 0xfffffeff;
 
          /* set the trace bit if we're stepping */
          if (stepping)
            registers[PS] |= 0x100;
 
#ifdef WIN32 //MF
          return;
#else
          _returnFromException ();      /* this is a jump */
#endif
          break;
 
          /* kill the program */
        case 'k':               /* do nothing */
#if 0
          /* Huh? This doesn't look like "nothing".
             m68k-stub.c and sparc-stub.c don't have it.  */
          BREAKPOINT ();
#endif
          break;
        }                       /* switch */
 
      /* reply to the request */
      putpacket (remcomOutBuffer);
    }
}

hex()

int hex

(

char

ch

)

Definition at line 512 of file i386-stub-win32.c.

{
  if ((ch >= 'a') && (ch <= 'f'))
    return (ch - 'a' + 10);
  if ((ch >= '0') && (ch <= '9'))
    return (ch - '0');
  if ((ch >= 'A') && (ch <= 'F'))
    return (ch - 'A' + 10);
  return (-1);
}

Referenced by copyfont(), decode_url(), default_dbgstr_an(), RequestHandler::dump_one_line(), dump_shell_namespace(), dumpmem(), escape_string(), export_hex_data_type(), getpacket(), hash_dib(), hex(), hex2mem(), hex_to_address(), hex_to_tid(), HEXEDIT_PaintLines(), hexToInt(), NumPutGetTest::inhex(), loose_hex_to_rgb(), ME_StreamOutHexData(), NumPutGetTest::num_get_integer(), NumPutGetTest::num_put_integer(), print_operand_value(), PROPVAR_HexToNum(), test__strtoi64(), test__wcstoi64(), test_basic_import(), test_basic_import_unicode(), test_export(), test_import(), test_unicode_import(), test_value_deletion(), test_value_deletion_unicode(), wine_dbgstr_an(), wine_debugstr_an(), and xmlParseReference().

hex2mem()

char * hex2mem	(	char *	buf,
		char *	mem,
		int	count,
		int	may_fault
	)

Definition at line 705 of file i386-stub-win32.c.

{
  int i;
  unsigned char ch;
 
#ifdef WIN32 //MF
   // MinGW does not support structured exception handling, so let's
   // go safe and make memory writable by default
  DWORD old_protect;
 
  VirtualProtect(mem, count, PAGE_EXECUTE_READWRITE, &old_protect);
#else
  if (may_fault)
    mem_fault_routine = set_mem_err;
#endif
 
  for (i = 0; i < count; i++)
    {
      ch = hex (*buf++) << 4;
      ch = ch + hex (*buf++);
      set_char (mem++, ch);
      if (may_fault && mem_err)
        return (mem);
    }
 
#ifndef WIN32 //MF
  if (may_fault)
    mem_fault_routine = NULL;
#endif
 
  return (mem);
}

Referenced by handle_exception().

hexToInt()

int hexToInt	(	char **	ptr,
		int *	intValue
	)

Definition at line 806 of file i386-stub-win32.c.

{
  int numChars = 0;
  int hexValue;
 
  *intValue = 0;
 
  while (**ptr)
    {
      hexValue = hex (**ptr);
      if (hexValue >= 0)
        {
          *intValue = (*intValue << 4) | hexValue;
          numChars++;
        }
      else
        break;
 
      (*ptr)++;
    }
 
  return (numChars);
}

Referenced by handle_exception().

mem2hex()

char * mem2hex	(	char *	mem,
		char *	buf,
		int	count,
		int	may_fault
	)

Definition at line 670 of file i386-stub-win32.c.

{
  int i;
  unsigned char ch;
 
#ifdef WIN32 //MF
  if (IsBadReadPtr(mem, count))
    return mem;
#else
  if (may_fault)
    mem_fault_routine = set_mem_err;
#endif
  for (i = 0; i < count; i++)
    {
      ch = get_char (mem++);
      if (may_fault && mem_err)
        return (buf);
      *buf++ = hexchars[ch >> 4];
      *buf++ = hexchars[ch % 16];
    }
  *buf = 0;
#ifndef WIN32 //MF
  if (may_fault)
    mem_fault_routine = NULL;
#endif
  return (buf);
}

Referenced by handle_exception().

putDebugChar()

void putDebugChar

(

)

Referenced by getpacket(), and putpacket().

putpacket()

void putpacket

(

char *

buffer

)

Definition at line 602 of file i386-stub-win32.c.

{
  unsigned char checksum;
  int count;
  char ch;
 
  /*  $<packet info>#<checksum>. */
  do
    {
      putDebugChar ('$');
      checksum = 0;
      count = 0;
 
      while ((ch = buffer[count]) != 0)
        {
          putDebugChar (ch);
          checksum += ch;
          count += 1;
        }
 
      putDebugChar ('#');
      putDebugChar (hexchars[checksum >> 4]);
      putDebugChar (hexchars[checksum % 16]);
 
    }
  while (getDebugChar () != '+');
}

Referenced by handle_exception().

return_to_prog()

void return_to_prog

(

)

Referenced by _returnFromException().

set_char()

void set_char	(	char *	addr,
		int	val
	)

Definition at line 660 of file i386-stub-win32.c.

{
  *addr = val;
}

Referenced by hex2mem().

set_debug_traps()

void set_debug_traps

(

void

)

Definition at line 1012 of file i386-stub-win32.c.

{
#ifndef WIN32 //MF
  stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 
  exceptionHandler (0, _catchException0);
  exceptionHandler (1, _catchException1);
  exceptionHandler (3, _catchException3);
  exceptionHandler (4, _catchException4);
  exceptionHandler (5, _catchException5);
  exceptionHandler (6, _catchException6);
  exceptionHandler (7, _catchException7);
  exceptionHandler (8, _catchException8);
  exceptionHandler (9, _catchException9);
  exceptionHandler (10, _catchException10);
  exceptionHandler (11, _catchException11);
  exceptionHandler (12, _catchException12);
  exceptionHandler (13, _catchException13);
  exceptionHandler (14, _catchException14);
  exceptionHandler (16, _catchException16);
#endif // WIN32
 
  initialized = 1;
}

set_mem_err()

void set_mem_err

(

void

)

Definition at line 644 of file i386-stub-win32.c.

{
  mem_err = 1;
}

Referenced by hex2mem(), and mem2hex().

Variable Documentation

gdb_i386errcode

int gdb_i386errcode

Definition at line 184 of file i386-stub-win32.c.

gdb_i386vector

int gdb_i386vector = -1

Definition at line 187 of file i386-stub-win32.c.

Referenced by handle_exception().

hexchars

const char hexchars[] ="0123456789abcdef"

static

Definition at line 116 of file i386-stub-win32.c.

Referenced by handle_exception(), mem2hex(), and putpacket().

initialized

char initialized

static

Definition at line 111 of file i386-stub-win32.c.

Referenced by breakpoint(), and set_debug_traps().

mem_err

volatile int mem_err = 0

static

Definition at line 641 of file i386-stub-win32.c.

Referenced by handle_exception(), hex2mem(), mem2hex(), and set_mem_err().

mem_fault_routine

void(*volatile mem_fault_routine) () ( ) = NULL

static

Definition at line 637 of file i386-stub-win32.c.

Referenced by hex2mem(), and mem2hex().

registers

int registers[NUMREGS]

Definition at line 132 of file i386-stub-win32.c.

Referenced by dwarfargvalue(), dwarfcomputecfa(), dwarfgetarg(), dwarfregunwind(), handle_exception(), and RosSymGetAddressInformation().

remcomInBuffer

char remcomInBuffer[BUFMAX]

static

Definition at line 524 of file i386-stub-win32.c.

Referenced by getpacket().

remcomOutBuffer

char remcomOutBuffer[BUFMAX]

static

Definition at line 525 of file i386-stub-win32.c.

Referenced by handle_exception().

remcomStack

int remcomStack[STACKSIZE/sizeof(int)]

Definition at line 137 of file i386-stub-win32.c.

Referenced by set_debug_traps().

remote_debug

int remote_debug

Definition at line 113 of file i386-stub-win32.c.

Referenced by debug_error(), getpacket(), and handle_exception().

stackPtr

int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1]

static

Definition at line 138 of file i386-stub-win32.c.

Referenced by set_debug_traps().