#include <stdio.h>
#include <string.h>
#include "utility/utility.h"
Go to the source code of this file.
Defines | |
#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 $0, %eax") | |
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 | |
int | remote_debug |
int | registers [NUMREGS] |
int | remcomStack [STACKSIZE/sizeof(int)] |
int | gdb_i386errcode |
int | gdb_i386vector = -1 |
#define BREAKPOINT | ( | ) | asm(" int $3"); |
Definition at line 456 of file i386-stub-win32.c.
Referenced by breakpoint(), and handle_exception().
#define BUFMAX 400 |
Definition at line 109 of file i386-stub-win32.c.
Referenced by getpacket(), and handle_exception().
CALL_HOOK | ( | ) | asm("call _remcomHandler"); |
Definition at line 260 of file i386-stub-win32.c.
CHECK_FAULT | ( | ) |
asm ("cmpl $0, _mem_fault_routine"); \ asm ("jne mem_fault");
Definition at line 225 of file i386-stub-win32.c.
#define NUMREGBYTES (NUMREGS * 4) |
Definition at line 122 of file i386-stub-win32.c.
Referenced by handle_exception().
#define NUMREGS 16 |
Definition at line 119 of file i386-stub-win32.c.
Referenced by handle_exception().
SAVE_ERRCODE | ( | ) |
asm ("popl %ebx"); \ asm ("movl %ebx, _gdb_i386errcode");
Definition at line 208 of file i386-stub-win32.c.
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");
Definition at line 191 of file i386-stub-win32.c.
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");
Definition at line 211 of file i386-stub-win32.c.
#define STACKSIZE 10000 |
Definition at line 136 of file i386-stub-win32.c.
Referenced by set_debug_traps().
enum regnames |
void _catchException0 | ( | ) |
void _catchException1 | ( | ) |
void _catchException10 | ( | ) |
void _catchException11 | ( | ) |
void _catchException12 | ( | ) |
void _catchException13 | ( | ) |
void _catchException14 | ( | ) |
void _catchException16 | ( | ) |
void _catchException3 | ( | ) |
void _catchException4 | ( | ) |
void _catchException5 | ( | ) |
void _catchException6 | ( | ) |
void _catchException7 | ( | ) |
void _catchException8 | ( | ) |
void _catchException9 | ( | ) |
void _returnFromException | ( | ) |
Definition at line 445 of file i386-stub-win32.c.
References return_to_prog().
Referenced by handle_exception().
{ return_to_prog (); }
asm | ( | " call _handle_exception" | ) |
asm | ( | " movw _registers+ | 48, |
%ds" | |||
) |
asm | ( | " pushl %ecx" | ) |
asm | ( | "pushl $14" | ) |
asm | ( | "__catchException14:" | ) |
asm | ( | ".globl __catchException14" | ) |
asm | ( | ".globl __catchException8" | ) |
asm | ( | "pushl $11" | ) |
asm | ( | "__catchException11:" | ) |
asm | ( | ".globl __catchException11" | ) |
asm | ( | " movl $ | 0, |
%eax" | |||
) |
asm | ( | "pushl $13" | ) |
asm | ( | "__catchException13:" | ) |
asm | ( | ".globl __catchException13" | ) |
asm | ( | "__catchException8:" | ) |
asm | ( | "pushl $16" | ) |
asm | ( | "__catchException16:" | ) |
asm | ( | "pushl $8" | ) |
asm | ( | " movw _registers+ | 44, |
%ss" | |||
) |
asm | ( | "pushl $12" | ) |
asm | ( | "__catchException12:" | ) |
asm | ( | ".globl __catchException12" | ) |
asm | ( | " movw _registers+ | 52, |
%es" | |||
) |
asm | ( | "pushl $10" | ) |
asm | ( | "__catchException10:" | ) |
asm | ( | " movl % | eax, |
_mem_fault_routine" | |||
) |
asm | ( | ".globl __catchException9" | ) |
asm | ( | "iret" | ) |
asm | ( | "__catchException9:" | ) |
asm | ( | "pushl $9" | ) |
asm | ( | " movl _registers+ | 16, |
%esp" | |||
) |
asm | ( | " movw _registers+ | 56, |
%fs" | |||
) |
asm | ( | ".globl __catchException10" | ) |
asm | ( | ".globl __catchException3" | ) |
asm | ( | " movw _registers+ | 60, |
%gs" | |||
) |
asm | ( | "pushl $7" | ) |
asm | ( | "__catchException7:" | ) |
asm | ( | ".globl __catchException7" | ) |
asm | ( | "__catchException3:" | ) |
asm | ( | "pushl $6" | ) |
asm | ( | "__catchException6:" | ) |
asm | ( | ".globl __catchException6" | ) |
asm | ( | "pushl $3" | ) |
asm | ( | "pushl $5" | ) |
asm | ( | "__catchException5:" | ) |
asm | ( | ".globl __catchException5" | ) |
asm | ( | " popl %eax" | ) |
asm | ( | "pushl $4" | ) |
asm | ( | "__catchException4:" | ) |
asm | ( | " iret" | ) |
asm | ( | " movl _registers+ | 4, |
%ecx" | |||
) |
asm | ( | "pushl $0" | ) |
asm | ( | "__catchException0:" | ) |
asm | ( | ".globl __catchException0" | ) |
asm | ( | " movl | _registers, |
%eax" | |||
) |
asm | ( | "pushl $1" | ) |
asm | ( | "__catchException1:" | ) |
asm | ( | " movl _registers+ | 36, |
%eax" | |||
) |
asm | ( | ".globl __catchException16" | ) |
asm | ( | ".globl __catchException1" | ) |
asm | ( | " pushl %eax" | ) |
asm | ( | ".text" | ) |
asm | ( | " movl _registers+ | 8, |
%edx" | |||
) |
asm | ( | "ret" | ) |
asm | ( | ".globl __catchException4" | ) |
asm | ( | " movl _registers+ | 12, |
%ebx" | |||
) |
asm | ( | "_remcomHandler:" | ) |
asm | ( | " pushl %edx" | ) |
asm | ( | " leave" | ) |
asm | ( | " popl %edx" | ) |
asm | ( | " popl %ecx" | ) |
asm | ( | " movl % | eax, |
_gdb_i386errcode" | |||
) |
asm | ( | " movl _registers+ | 20, |
%ebp" | |||
) |
asm | ( | " movl | _stackPtr, |
%esp" | |||
) |
asm | ( | "mem_fault:" | ) |
asm | ( | ".globl _return_to_prog" | ) |
asm | ( | "_return_to_prog:" | ) |
asm | ( | " movl _registers+ | 24, |
%esi" | |||
) |
asm | ( | " movl _registers+ | 28, |
%edi" | |||
) |
void breakpoint | ( | void | ) |
Definition at line 1046 of file i386-stub-win32.c.
References BREAKPOINT.
{ if (initialized) BREAKPOINT (); }
int computeSignal | ( | int | exceptionVector ) |
Definition at line 745 of file i386-stub-win32.c.
Referenced by handle_exception().
{ 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); }
void debug_error | ( | char * | format ) |
Definition at line 630 of file i386-stub-win32.c.
References remote_debug.
Referenced by handle_exception().
{ if (remote_debug) fprintf (stderr, format/*, parm*/); }
void exceptionHandler | ( | ) |
int get_char | ( | char * | addr ) |
Definition at line 654 of file i386-stub-win32.c.
Referenced by mem2hex().
{
return *addr;
}
int getDebugChar | ( | ) |
char* getpacket | ( | void | ) |
Definition at line 530 of file i386-stub-win32.c.
References BUFMAX, getDebugChar(), hex(), putDebugChar(), and remote_debug.
Referenced by handle_exception().
{ 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) { 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]; } } } }
void handle_exception | ( | int | exceptionVector ) |
Definition at line 834 of file i386-stub-win32.c.
References _returnFromException(), BREAKPOINT, BUFMAX, computeSignal(), debug_error(), EBP, ESP, gdb_i386vector, getpacket(), hex2mem(), hexToInt(), mem2hex(), NUMREGBYTES, NUMREGS, PC, PS, putpacket(), registers, remote_debug, and strcpy_s.
{ int sigval, stepping; int addr, length; char *ptr; int newPC; #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 *)®isters[ESP], ptr, 4, 0); /* SP */ *ptr++ = ';'; *ptr++ = hexchars[EBP]; *ptr++ = ':'; ptr = mem2hex((char *)®isters[EBP], ptr, 4, 0); /* FP */ *ptr++ = ';'; *ptr++ = hexchars[PC]; *ptr++ = ':'; ptr = mem2hex((char *)®isters[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, ®no) && *ptr++ == '=') if (regno >= 0 && regno < NUMREGS) { hex2mem (ptr, (char *) ®isters[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; newPC = registers[PC]; /* 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); } }
int hex | ( | char | ch ) |
Definition at line 512 of file i386-stub-win32.c.
Referenced by getpacket(), hex2mem(), and hexToInt().
{ 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); }
char* hex2mem | ( | char * | buf, |
char * | mem, | ||
int | count, | ||
int | may_fault | ||
) |
Definition at line 705 of file i386-stub-win32.c.
References hex(), set_char(), and set_mem_err().
Referenced by handle_exception().
{ 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); }
int hexToInt | ( | char ** | ptr, |
int * | intValue | ||
) |
Definition at line 806 of file i386-stub-win32.c.
References hex().
Referenced by handle_exception().
{ 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); }
char* mem2hex | ( | char * | mem, |
char * | buf, | ||
int | count, | ||
int | may_fault | ||
) |
Definition at line 670 of file i386-stub-win32.c.
References get_char(), and set_mem_err().
Referenced by handle_exception().
{ 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); }
void putDebugChar | ( | ) |
void putpacket | ( | char * | buffer ) |
Definition at line 602 of file i386-stub-win32.c.
References getDebugChar(), and putDebugChar().
Referenced by handle_exception().
{ 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 () != '+'); }
void return_to_prog | ( | ) |
void set_char | ( | char * | addr, |
int | val | ||
) |
Definition at line 660 of file i386-stub-win32.c.
Referenced by hex2mem().
{ *addr = val; }
void set_debug_traps | ( | void | ) |
Definition at line 1015 of file i386-stub-win32.c.
References _catchException0(), _catchException1(), _catchException10(), _catchException11(), _catchException12(), _catchException13(), _catchException14(), _catchException16(), _catchException3(), _catchException4(), _catchException5(), _catchException6(), _catchException7(), _catchException8(), _catchException9(), exceptionHandler(), remcomStack, and STACKSIZE.
{ #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; }
void set_mem_err | ( | void | ) |
Definition at line 644 of file i386-stub-win32.c.
Referenced by hex2mem(), and mem2hex().
{ mem_err = 1; }
int gdb_i386errcode |
Definition at line 184 of file i386-stub-win32.c.
int gdb_i386vector = -1 |
Definition at line 187 of file i386-stub-win32.c.
Referenced by handle_exception().
int registers[NUMREGS] |
Definition at line 132 of file i386-stub-win32.c.
Referenced by handle_exception().
int remcomStack[STACKSIZE/sizeof(int)] |
Definition at line 137 of file i386-stub-win32.c.
Referenced by set_debug_traps().
int remote_debug |
Definition at line 113 of file i386-stub-win32.c.
Referenced by debug_error(), getpacket(), and handle_exception().
ROS Explorer Source Code Documentation
generated on 02.01.2013 by ![]() |