2 * A Win32 based proxy implementing the GBD remote protocol
3 * This allows to debug Wine (and any "emulated" program) under
6 * Copyright (c) Eric Pouech 2002-2003
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 /* Protocol specification can be found here:
24 * http://sources.redhat.com/gdb/onlinedocs/gdb_32.html
28 #include "wine/port.h"
39 #ifdef HAVE_SYS_SOCKET_H
40 # include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <netinet/tcp.h>
52 /* those two are needed only for the SHOWNORMAL flag */
58 #define GDBPXY_TRC_LOWLEVEL 0x01
59 #define GDBPXY_TRC_PACKET 0x02
60 #define GDBPXY_TRC_COMMAND 0x04
61 #define GDBPXY_TRC_COMMAND_ERROR 0x08
62 #define GDBPXY_TRC_WIN32_EVENT 0x10
63 #define GDBPXY_TRC_WIN32_ERROR 0x20
64 #define GDBPXY_TRC_COMMAND_FIXME 0x80
68 int type; /* -1 means free */
81 /* split into individual packet */
89 /* generic GDB thread information */
90 DBG_THREAD* exec_thread; /* thread used in step & continue */
91 DBG_THREAD* other_thread; /* thread to be used in any other operation */
93 /* current Win32 trap env */
97 /* Win32 information */
100 struct gdb_ctx_Xpoint Xpoints[NUM_XPOINT];
101 /* Unix environment */
102 unsigned long wine_segs[3]; /* load addresses of the ELF wine exec segments (text, bss and data) */
105 extern int read_elf_info(const char* filename, unsigned long tab[]);
107 /* =============================================== *
108 * B A S I C M A N I P U L A T I O N S *
109 * =============================================== *
112 static inline int hex_from0(char ch)
114 if (ch >= '0' && ch <= '9') return ch - '0';
115 if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
116 if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
122 static inline unsigned char hex_to0(int x)
124 assert(x >= 0 && x < 16);
125 return "0123456789abcdef"[x];
128 static void hex_from(void* dst, const char* src, size_t len)
130 unsigned char *p = dst;
133 *p++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]);
138 static void hex_to(char* dst, const void* src, size_t len)
140 const unsigned char *p = src;
143 *dst++ = hex_to0(*p >> 4);
144 *dst++ = hex_to0(*p & 0x0F);
149 static unsigned char checksum(const char* ptr, int len)
154 cksum += (unsigned char)*ptr++;
158 /* =============================================== *
159 * C P U H A N D L E R S *
160 * =============================================== *
163 #define OFFSET_OF(__c,__f) ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
166 static size_t cpu_register_map[] = {
167 OFFSET_OF(CONTEXT, Eax),
168 OFFSET_OF(CONTEXT, Ecx),
169 OFFSET_OF(CONTEXT, Edx),
170 OFFSET_OF(CONTEXT, Ebx),
171 OFFSET_OF(CONTEXT, Esp),
172 OFFSET_OF(CONTEXT, Ebp),
173 OFFSET_OF(CONTEXT, Esi),
174 OFFSET_OF(CONTEXT, Edi),
175 OFFSET_OF(CONTEXT, Eip),
176 OFFSET_OF(CONTEXT, EFlags),
177 OFFSET_OF(CONTEXT, SegCs),
178 OFFSET_OF(CONTEXT, SegSs),
179 OFFSET_OF(CONTEXT, SegDs),
180 OFFSET_OF(CONTEXT, SegEs),
181 OFFSET_OF(CONTEXT, SegFs),
182 OFFSET_OF(CONTEXT, SegGs),
186 static size_t cpu_register_map[] = {
187 OFFSET_OF(CONTEXT, Gpr0),
188 OFFSET_OF(CONTEXT, Gpr1),
189 OFFSET_OF(CONTEXT, Gpr2),
190 OFFSET_OF(CONTEXT, Gpr3),
191 OFFSET_OF(CONTEXT, Gpr4),
192 OFFSET_OF(CONTEXT, Gpr5),
193 OFFSET_OF(CONTEXT, Gpr6),
194 OFFSET_OF(CONTEXT, Gpr7),
195 OFFSET_OF(CONTEXT, Gpr8),
196 OFFSET_OF(CONTEXT, Gpr9),
197 OFFSET_OF(CONTEXT, Gpr10),
198 OFFSET_OF(CONTEXT, Gpr11),
199 OFFSET_OF(CONTEXT, Gpr12),
200 OFFSET_OF(CONTEXT, Gpr13),
201 OFFSET_OF(CONTEXT, Gpr14),
202 OFFSET_OF(CONTEXT, Gpr15),
203 OFFSET_OF(CONTEXT, Gpr16),
204 OFFSET_OF(CONTEXT, Gpr17),
205 OFFSET_OF(CONTEXT, Gpr18),
206 OFFSET_OF(CONTEXT, Gpr19),
207 OFFSET_OF(CONTEXT, Gpr20),
208 OFFSET_OF(CONTEXT, Gpr21),
209 OFFSET_OF(CONTEXT, Gpr22),
210 OFFSET_OF(CONTEXT, Gpr23),
211 OFFSET_OF(CONTEXT, Gpr24),
212 OFFSET_OF(CONTEXT, Gpr25),
213 OFFSET_OF(CONTEXT, Gpr26),
214 OFFSET_OF(CONTEXT, Gpr27),
215 OFFSET_OF(CONTEXT, Gpr28),
216 OFFSET_OF(CONTEXT, Gpr29),
217 OFFSET_OF(CONTEXT, Gpr30),
218 OFFSET_OF(CONTEXT, Gpr31),
219 OFFSET_OF(CONTEXT, Fpr0),
220 OFFSET_OF(CONTEXT, Fpr1),
221 OFFSET_OF(CONTEXT, Fpr2),
222 OFFSET_OF(CONTEXT, Fpr3),
223 OFFSET_OF(CONTEXT, Fpr4),
224 OFFSET_OF(CONTEXT, Fpr5),
225 OFFSET_OF(CONTEXT, Fpr6),
226 OFFSET_OF(CONTEXT, Fpr7),
227 OFFSET_OF(CONTEXT, Fpr8),
228 OFFSET_OF(CONTEXT, Fpr9),
229 OFFSET_OF(CONTEXT, Fpr10),
230 OFFSET_OF(CONTEXT, Fpr11),
231 OFFSET_OF(CONTEXT, Fpr12),
232 OFFSET_OF(CONTEXT, Fpr13),
233 OFFSET_OF(CONTEXT, Fpr14),
234 OFFSET_OF(CONTEXT, Fpr15),
235 OFFSET_OF(CONTEXT, Fpr16),
236 OFFSET_OF(CONTEXT, Fpr17),
237 OFFSET_OF(CONTEXT, Fpr18),
238 OFFSET_OF(CONTEXT, Fpr19),
239 OFFSET_OF(CONTEXT, Fpr20),
240 OFFSET_OF(CONTEXT, Fpr21),
241 OFFSET_OF(CONTEXT, Fpr22),
242 OFFSET_OF(CONTEXT, Fpr23),
243 OFFSET_OF(CONTEXT, Fpr24),
244 OFFSET_OF(CONTEXT, Fpr25),
245 OFFSET_OF(CONTEXT, Fpr26),
246 OFFSET_OF(CONTEXT, Fpr27),
247 OFFSET_OF(CONTEXT, Fpr28),
248 OFFSET_OF(CONTEXT, Fpr29),
249 OFFSET_OF(CONTEXT, Fpr30),
250 OFFSET_OF(CONTEXT, Fpr31),
252 OFFSET_OF(CONTEXT, Iar),
253 OFFSET_OF(CONTEXT, Msr),
254 OFFSET_OF(CONTEXT, Cr),
255 OFFSET_OF(CONTEXT, Lr),
256 OFFSET_OF(CONTEXT, Ctr),
257 OFFSET_OF(CONTEXT, Xer),
258 /* FIXME: MQ is missing? OFFSET_OF(CONTEXT, Mq), */
259 /* see gdb/nlm/ppc.c */
262 # error "Define the registers map for your CPU"
267 static const size_t cpu_num_regs = (sizeof(cpu_register_map) / sizeof(cpu_register_map[0]));
269 static inline unsigned long* cpu_register(const CONTEXT* ctx, unsigned idx)
271 assert(idx < cpu_num_regs);
272 return (unsigned long*)((char*)ctx + cpu_register_map[idx]);
275 static inline BOOL cpu_enter_stepping(struct gdb_context* gdbctx)
278 gdbctx->context.EFlags |= 0x100;
282 # define MSR_SE (1<<10)
284 gdbctx->context.Msr |= MSR_SE;
287 #error "Define step mode enter for your CPU"
292 static inline BOOL cpu_leave_stepping(struct gdb_context* gdbctx)
295 /* The Win32 debug API always resets the Step bit in EFlags after
296 * a single step instruction, so we don't need to clear when the
301 gdbctx->context.Msr &= MSR_SE;
304 #error "Define step mode leave for your CPU"
310 #define DR7_CONTROL_SHIFT 16
311 #define DR7_CONTROL_SIZE 4
313 #define DR7_RW_EXECUTE (0x0)
314 #define DR7_RW_WRITE (0x1)
315 #define DR7_RW_READ (0x3)
317 #define DR7_LEN_1 (0x0)
318 #define DR7_LEN_2 (0x4)
319 #define DR7_LEN_4 (0xC)
321 #define DR7_LOCAL_ENABLE_SHIFT 0
322 #define DR7_GLOBAL_ENABLE_SHIFT 1
323 #define DR7_ENABLE_SIZE 2
325 #define DR7_LOCAL_ENABLE_MASK (0x55)
326 #define DR7_GLOBAL_ENABLE_MASK (0xAA)
328 #define DR7_CONTROL_RESERVED (0xFC00)
329 #define DR7_LOCAL_SLOWDOWN (0x100)
330 #define DR7_GLOBAL_SLOWDOWN (0x200)
332 #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
333 #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr))
335 static inline int i386_get_unused_DR(struct gdb_context* gdbctx,
338 if (!IS_DR7_SET(gdbctx->context.Dr7, 0))
340 *r = &gdbctx->context.Dr0;
343 if (!IS_DR7_SET(gdbctx->context.Dr7, 1))
345 *r = &gdbctx->context.Dr1;
348 if (!IS_DR7_SET(gdbctx->context.Dr7, 2))
350 *r = &gdbctx->context.Dr2;
353 if (!IS_DR7_SET(gdbctx->context.Dr7, 3))
355 *r = &gdbctx->context.Dr3;
362 /******************************************************************
367 * -1 if operation isn't supported by CPU
369 static inline int cpu_insert_Xpoint(struct gdb_context* gdbctx,
370 struct gdb_ctx_Xpoint* xpt, size_t len)
382 if (len != 1) return 0;
383 if (!ReadProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
386 if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
389 bits = DR7_RW_EXECUTE;
397 if ((reg = i386_get_unused_DR(gdbctx, &pr)) == -1) return 0;
398 *pr = (unsigned long)xpt->addr;
399 if (xpt->type != '1') switch (len)
401 case 4: bits |= DR7_LEN_4; break;
402 case 2: bits |= DR7_LEN_2; break;
403 case 1: bits |= DR7_LEN_1; break;
407 /* clear old values */
408 gdbctx->context.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg));
409 /* set the correct ones */
410 gdbctx->context.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg);
411 gdbctx->context.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN;
414 fprintf(stderr, "Unknown bp type %c\n", xpt->type);
418 #elif defined(__powerpc__)
425 if (len != 4) return 0;
426 if (!ReadProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0;
428 xbp = 0x7d821008; /* 7d 82 10 08 ... in big endian */
429 if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0;
432 fprintf(stderr, "Unknown/unsupported bp type %c\n", xpt->type);
437 #error "Define insert Xpoint for your CPU"
442 /******************************************************************
447 * -1 if operation isn't supported by CPU
449 static inline BOOL cpu_remove_Xpoint(struct gdb_context* gdbctx,
450 struct gdb_ctx_Xpoint* xpt, size_t len)
459 if (len != 1) return 0;
460 ch = (unsigned char)xpt->val;
461 if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &ch, 1, &sz) || sz != 1) return 0;
466 /* simply disable the entry */
467 gdbctx->context.Dr7 &= ~DR7_ENABLE_MASK(xpt->val);
470 fprintf(stderr, "Unknown bp type %c\n", xpt->type);
474 #elif defined(__powerpc__)
481 if (len != 4) return 0;
483 if (!WriteProcessMemory(gdbctx->process->handle, xpt->addr, &xbp, 4, &sz) || sz != 4) return 0;
489 fprintf(stderr, "Unknown/unsupported bp type %c\n", xpt->type);
494 #error "Define remove Xpoint for your CPU"
498 /* =============================================== *
499 * W I N 3 2 D E B U G I N T E R F A C E *
500 * =============================================== *
503 static BOOL fetch_context(struct gdb_context* gdbctx, HANDLE h, CONTEXT* ctx)
505 ctx->ContextFlags = CONTEXT_CONTROL
507 #ifdef CONTEXT_SEGMENTS
510 #ifdef CONTEXT_DEBUG_REGISTERS
511 | CONTEXT_DEBUG_REGISTERS
514 if (!GetThreadContext(h, ctx))
516 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
517 fprintf(stderr, "Can't get thread's context\n");
523 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
525 EXCEPTION_RECORD* rec = &exc->ExceptionRecord;
528 switch (rec->ExceptionCode)
530 case EXCEPTION_ACCESS_VIOLATION:
531 case EXCEPTION_PRIV_INSTRUCTION:
532 case EXCEPTION_STACK_OVERFLOW:
533 case EXCEPTION_GUARD_PAGE:
534 gdbctx->last_sig = SIGSEGV;
537 case EXCEPTION_DATATYPE_MISALIGNMENT:
538 gdbctx->last_sig = SIGBUS;
541 case EXCEPTION_SINGLE_STEP:
543 case EXCEPTION_BREAKPOINT:
544 gdbctx->last_sig = SIGTRAP;
547 case EXCEPTION_FLT_DENORMAL_OPERAND:
548 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
549 case EXCEPTION_FLT_INEXACT_RESULT:
550 case EXCEPTION_FLT_INVALID_OPERATION:
551 case EXCEPTION_FLT_OVERFLOW:
552 case EXCEPTION_FLT_STACK_CHECK:
553 case EXCEPTION_FLT_UNDERFLOW:
554 gdbctx->last_sig = SIGFPE;
557 case EXCEPTION_INT_DIVIDE_BY_ZERO:
558 case EXCEPTION_INT_OVERFLOW:
559 gdbctx->last_sig = SIGFPE;
562 case EXCEPTION_ILLEGAL_INSTRUCTION:
563 gdbctx->last_sig = SIGILL;
567 gdbctx->last_sig = SIGINT;
570 case STATUS_POSSIBLE_DEADLOCK:
571 gdbctx->last_sig = SIGALRM;
573 /* FIXME: we could also add here a O packet with additional information */
576 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
577 fprintf(stderr, "Unhandled exception code %08lx\n", rec->ExceptionCode);
578 gdbctx->last_sig = SIGABRT;
585 static void handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
589 DEBUG_CurrThread = DEBUG_GetThread(gdbctx->process, de->dwThreadId);
591 switch (de->dwDebugEventCode)
593 case CREATE_PROCESS_DEBUG_EVENT:
594 DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
595 de->u.CreateProcessInfo.hProcess,
596 de->u.CreateProcessInfo.lpImageName);
598 /* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
599 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
600 fprintf(stderr, "%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n",
601 de->dwProcessId, de->dwThreadId,
602 buffer, de->u.CreateProcessInfo.lpImageName,
603 (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress,
604 de->u.CreateProcessInfo.dwDebugInfoFileOffset,
605 de->u.CreateProcessInfo.nDebugInfoSize);
607 gdbctx->process = DEBUG_AddProcess(de->dwProcessId,
608 de->u.CreateProcessInfo.hProcess,
610 /* de->u.CreateProcessInfo.lpStartAddress; */
612 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
613 fprintf(stderr, "%08lx:%08lx: create thread I @%08lx\n",
614 de->dwProcessId, de->dwThreadId,
615 (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress);
617 assert(DEBUG_CurrThread == NULL); /* shouldn't be there */
618 DEBUG_AddThread(gdbctx->process, de->dwThreadId,
619 de->u.CreateProcessInfo.hThread,
620 de->u.CreateProcessInfo.lpStartAddress,
621 de->u.CreateProcessInfo.lpThreadLocalBase);
623 DEBUG_LoadModule32(DEBUG_CurrProcess->imageName, de->u.CreateProcessInfo.hFile,
624 de->u.CreateProcessInfo.lpBaseOfImage);
626 if (buffer[0]) /* we got a process name */
629 if (!GetBinaryTypeA( buffer, &type ))
631 /* not a Windows binary, assume it's a Unix executable then */
632 char unixname[MAX_PATH];
633 /* HACK!! should fix DEBUG_ReadExecutableDbgInfo to accept DOS filenames */
634 if (wine_get_unix_file_name( buffer, unixname, sizeof(unixname) ))
636 DEBUG_ReadExecutableDbgInfo( unixname );
641 /* if it is a Windows binary, or an invalid or missing file name,
642 * we use wine itself as the main executable */
643 DEBUG_ReadExecutableDbgInfo( "wine" );
647 case LOAD_DLL_DEBUG_EVENT:
648 assert(DEBUG_CurrThread);
649 DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
650 gdbctx->process->handle,
651 de->u.LoadDll.lpImageName);
653 /* FIXME unicode: de->u.LoadDll.fUnicode */
654 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
655 fprintf(stderr, "%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n",
656 de->dwProcessId, de->dwThreadId,
657 buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll,
658 de->u.LoadDll.dwDebugInfoFileOffset,
659 de->u.LoadDll.nDebugInfoSize);
662 DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, de->u.LoadDll.lpBaseOfDll);
663 DEBUG_CheckDelayedBP();
664 if (DBG_IVAR(BreakOnDllLoad))
666 DEBUG_Printf(DBG_CHN_MESG, "Stopping on DLL %s loading at %08lx\n",
667 buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
673 case UNLOAD_DLL_DEBUG_EVENT:
674 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
675 fprintf(stderr, "%08lx:%08lx: unload DLL @%08lx\n",
676 de->dwProcessId, de->dwThreadId, (unsigned long)de->u.UnloadDll.lpBaseOfDll);
679 case EXCEPTION_DEBUG_EVENT:
680 assert(DEBUG_CurrThread);
681 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
682 fprintf(stderr, "%08lx:%08lx: exception code=%08lx\n",
683 de->dwProcessId, de->dwThreadId,
684 de->u.Exception.ExceptionRecord.ExceptionCode);
686 if (fetch_context(gdbctx, DEBUG_CurrThread->handle, &gdbctx->context))
688 gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception);
692 case CREATE_THREAD_DEBUG_EVENT:
693 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
694 fprintf(stderr, "%08lx:%08lx: create thread D @%08lx\n",
695 de->dwProcessId, de->dwThreadId, (unsigned long)(LPVOID)de->u.CreateThread.lpStartAddress);
697 DEBUG_AddThread(gdbctx->process,
699 de->u.CreateThread.hThread,
700 de->u.CreateThread.lpStartAddress,
701 de->u.CreateThread.lpThreadLocalBase);
704 case EXIT_THREAD_DEBUG_EVENT:
705 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
706 fprintf(stderr, "%08lx:%08lx: exit thread (%ld)\n",
707 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
709 assert(DEBUG_CurrThread);
710 if (DEBUG_CurrThread == gdbctx->exec_thread) gdbctx->exec_thread = NULL;
711 if (DEBUG_CurrThread == gdbctx->other_thread) gdbctx->other_thread = NULL;
712 DEBUG_DelThread(DEBUG_CurrThread);
715 case EXIT_PROCESS_DEBUG_EVENT:
716 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
717 fprintf(stderr, "%08lx:%08lx: exit process (%ld)\n",
718 de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
720 DEBUG_DelProcess(gdbctx->process);
721 gdbctx->process = NULL;
722 /* now signal gdb that we're done */
723 gdbctx->last_sig = SIGTERM;
724 gdbctx->in_trap = TRUE;
727 case OUTPUT_DEBUG_STRING_EVENT:
728 assert(DEBUG_CurrThread);
729 DEBUG_ProcessGetString(buffer, sizeof(buffer),
730 gdbctx->process->handle,
731 de->u.DebugString.lpDebugStringData);
732 /* FIXME unicode de->u.DebugString.fUnicode ? */
733 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
734 fprintf(stderr, "%08lx:%08lx: output debug string (%s)\n",
735 de->dwProcessId, de->dwThreadId, buffer);
739 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
740 fprintf(stderr, "%08lx:%08lx: rip error=%ld type=%ld\n",
741 de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
742 de->u.RipInfo.dwType);
746 if (gdbctx->trace & GDBPXY_TRC_WIN32_EVENT)
747 fprintf(stderr, "%08lx:%08lx: unknown event (%ld)\n",
748 de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
752 static void resume_debuggee(struct gdb_context* gdbctx, unsigned long cont)
754 if (DEBUG_CurrThread)
756 if (!SetThreadContext(DEBUG_CurrThread->handle, &gdbctx->context))
757 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
758 fprintf(stderr, "Cannot set context on thread %lu\n", DEBUG_CurrThread->tid);
759 if (!ContinueDebugEvent(gdbctx->process->pid, DEBUG_CurrThread->tid, cont))
760 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
761 fprintf(stderr, "Cannot continue on %lu (%lu)\n",
762 DEBUG_CurrThread->tid, cont);
764 else if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
765 fprintf(stderr, "Cannot find last thread (%lu)\n", DEBUG_CurrThread->tid);
768 static void wait_for_debuggee(struct gdb_context* gdbctx)
772 gdbctx->in_trap = FALSE;
773 while (WaitForDebugEvent(&de, INFINITE))
775 handle_debug_event(gdbctx, &de);
776 assert(!gdbctx->process ||
777 gdbctx->process->pid == 0 ||
778 de.dwProcessId == gdbctx->process->pid);
779 assert(!DEBUG_CurrThread || de.dwThreadId == DEBUG_CurrThread->tid);
780 if (gdbctx->in_trap) break;
781 ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
785 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
787 cpu_leave_stepping(gdbctx);
788 resume_debuggee(gdbctx, DBG_CONTINUE);
790 DebugActiveProcessStop(gdbctx->process->pid);
791 DEBUG_DelProcess(gdbctx->process);
792 gdbctx->process = NULL;
795 static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len)
797 unsigned long status;
799 if (!GetExitCodeProcess(gdbctx->process->handle, &status))
801 strcpy(buffer, "Unknown process");
804 if (status == STILL_ACTIVE)
806 strcpy(buffer, "Running");
809 snprintf(buffer, len, "Terminated (%lu)", status);
811 switch (GetPriorityClass(gdbctx->process->handle))
814 #ifdef ABOVE_NORMAL_PRIORITY_CLASS
815 case ABOVE_NORMAL_PRIORITY_CLASS: strcat(buffer, ", above normal priority"); break;
817 #ifdef BELOW_NORMAL_PRIORITY_CLASS
818 case BELOW_NORMAL_PRIORITY_CLASS: strcat(buffer, ", below normal priotity"); break;
820 case HIGH_PRIORITY_CLASS: strcat(buffer, ", high priority"); break;
821 case IDLE_PRIORITY_CLASS: strcat(buffer, ", idle priority"); break;
822 case NORMAL_PRIORITY_CLASS: strcat(buffer, ", normal priority"); break;
823 case REALTIME_PRIORITY_CLASS: strcat(buffer, ", realtime priority"); break;
825 strcat(buffer, "\n");
828 static void get_thread_info(struct gdb_context* gdbctx, unsigned tid,
829 char* buffer, size_t len)
832 unsigned long status;
835 /* FIXME: use the size of buffer */
836 thd = DEBUG_GetThread(gdbctx->process, tid);
839 strcpy(buffer, "No information");
842 if (GetExitCodeThread(thd->handle, &status))
844 if (status == STILL_ACTIVE)
846 /* FIXME: this is a bit brutal... some nicer way shall be found */
847 switch (status = SuspendThread(thd->handle))
850 case 0: strcpy(buffer, "Running"); break;
851 default: snprintf(buffer, len, "Suspended (%lu)", status - 1);
853 ResumeThread(thd->handle);
856 snprintf(buffer, len, "Terminated (exit code = %lu)", status);
860 strcpy(buffer, "Unknown threadID");
862 switch (prio = GetThreadPriority(thd->handle))
864 case THREAD_PRIORITY_ERROR_RETURN: break;
865 case THREAD_PRIORITY_ABOVE_NORMAL: strcat(buffer, ", priority +1 above normal"); break;
866 case THREAD_PRIORITY_BELOW_NORMAL: strcat(buffer, ", priority -1 below normal"); break;
867 case THREAD_PRIORITY_HIGHEST: strcat(buffer, ", priority +2 above normal"); break;
868 case THREAD_PRIORITY_LOWEST: strcat(buffer, ", priority -2 below normal"); break;
869 case THREAD_PRIORITY_IDLE: strcat(buffer, ", priority idle"); break;
870 case THREAD_PRIORITY_NORMAL: strcat(buffer, ", priority normal"); break;
871 case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break;
872 default: snprintf(buffer + strlen(buffer), len - strlen(buffer), ", priority = %d", prio);
874 assert(strlen(buffer) < len);
877 /* =============================================== *
878 * P A C K E T U T I L S *
879 * =============================================== *
882 enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02,
883 packet_last_f = 0x80};
885 static void packet_reply_grow(struct gdb_context* gdbctx, size_t size)
887 if (gdbctx->out_buf_alloc < gdbctx->out_len + size)
889 gdbctx->out_buf_alloc = ((gdbctx->out_len + size) / 32 + 1) * 32;
890 gdbctx->out_buf = realloc(gdbctx->out_buf, gdbctx->out_buf_alloc);
894 static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len)
896 packet_reply_grow(gdbctx, len * 2);
897 hex_to(&gdbctx->out_buf[gdbctx->out_len], src, len);
898 gdbctx->out_len += len * 2;
901 static inline void packet_reply_hex_to_str(struct gdb_context* gdbctx, const char* src)
903 packet_reply_hex_to(gdbctx, src, strlen(src));
906 static void packet_reply_val(struct gdb_context* gdbctx, unsigned long val, int len)
910 shift = (len - 1) * 8;
911 packet_reply_grow(gdbctx, len * 2);
912 for (i = 0; i < len; i++, shift -= 8)
914 gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> (shift + 4)) & 0x0F);
915 gdbctx->out_buf[gdbctx->out_len++] = hex_to0((val >> shift ) & 0x0F);
919 static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str, int len)
921 packet_reply_grow(gdbctx, len);
922 memcpy(&gdbctx->out_buf[gdbctx->out_len], str, len);
923 gdbctx->out_len += len;
926 static inline void packet_reply_cat(struct gdb_context* gdbctx, const char* str)
928 packet_reply_add(gdbctx, str, strlen(str));
931 static inline void packet_reply_catc(struct gdb_context* gdbctx, char ch)
933 packet_reply_add(gdbctx, &ch, 1);
936 static void packet_reply_open(struct gdb_context* gdbctx)
938 assert(gdbctx->out_curr_packet == -1);
939 packet_reply_catc(gdbctx, '$');
940 gdbctx->out_curr_packet = gdbctx->out_len;
943 static void packet_reply_close(struct gdb_context* gdbctx)
948 plen = gdbctx->out_len - gdbctx->out_curr_packet;
949 packet_reply_catc(gdbctx, '#');
950 cksum = checksum(&gdbctx->out_buf[gdbctx->out_curr_packet], plen);
951 packet_reply_hex_to(gdbctx, &cksum, 1);
952 if (gdbctx->trace & GDBPXY_TRC_PACKET)
953 fprintf(stderr, "Reply : %*.*s\n",
954 plen, plen, &gdbctx->out_buf[gdbctx->out_curr_packet]);
955 gdbctx->out_curr_packet = -1;
958 static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet, int len)
960 packet_reply_open(gdbctx);
962 if (len == -1) len = strlen(packet);
963 assert(memchr(packet, '$', len) == NULL && memchr(packet, '#', len) == NULL);
965 packet_reply_add(gdbctx, packet, len);
967 packet_reply_close(gdbctx);
972 static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error)
974 packet_reply_open(gdbctx);
976 packet_reply_add(gdbctx, "E", 1);
977 packet_reply_val(gdbctx, error, 1);
979 packet_reply_close(gdbctx);
984 /* =============================================== *
985 * P A C K E T H A N D L E R S *
986 * =============================================== *
989 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
991 enum packet_return ret = packet_done;
993 packet_reply_open(gdbctx);
995 if (gdbctx->process != NULL)
1000 packet_reply_catc(gdbctx, 'T');
1001 sig = gdbctx->last_sig;
1002 packet_reply_val(gdbctx, sig, 1);
1003 packet_reply_add(gdbctx, "thread:", 7);
1004 packet_reply_val(gdbctx, DEBUG_CurrThread->tid, 4);
1005 packet_reply_catc(gdbctx, ';');
1007 for (i = 0; i < cpu_num_regs; i++)
1009 /* FIXME: this call will also grow the buffer...
1010 * unneeded, but not harmful
1012 packet_reply_val(gdbctx, i, 1);
1013 packet_reply_catc(gdbctx, ':');
1014 packet_reply_hex_to(gdbctx, cpu_register(&gdbctx->context, i), 4);
1015 packet_reply_catc(gdbctx, ';');
1020 /* Try to put an exit code
1021 * Cannot use GetExitCodeProcess, wouldn't fit in a 8 bit value, so
1022 * just indicate the end of process and exit */
1023 packet_reply_add(gdbctx, "W00", 3);
1024 /*if (!gdbctx->extended)*/ ret |= packet_last_f;
1027 packet_reply_close(gdbctx);
1033 static enum packet_return packet_extended(struct gdb_context* gdbctx)
1035 gdbctx->extended = 1;
1040 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
1042 assert(gdbctx->in_packet_len == 0);
1043 return packet_reply_status(gdbctx);
1046 static enum packet_return packet_continue(struct gdb_context* gdbctx)
1048 /* FIXME: add support for address in packet */
1049 assert(gdbctx->in_packet_len == 0);
1050 if (DEBUG_CurrThread != gdbctx->exec_thread && gdbctx->exec_thread)
1051 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1052 fprintf(stderr, "NIY: cont on %lu, while last thread is %lu\n",
1053 gdbctx->exec_thread->tid, DEBUG_CurrThread->tid);
1054 resume_debuggee(gdbctx, DBG_CONTINUE);
1055 wait_for_debuggee(gdbctx);
1056 return packet_reply_status(gdbctx);
1059 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
1063 /* FIXME: add support for address in packet */
1064 assert(gdbctx->in_packet_len == 2);
1065 if (DEBUG_CurrThread != gdbctx->exec_thread && gdbctx->exec_thread)
1066 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1067 fprintf(stderr, "NIY: cont/sig on %lu, while last thread is %lu\n",
1068 gdbctx->exec_thread->tid, DEBUG_CurrThread->tid);
1069 hex_from(&sig, gdbctx->in_packet, 1);
1070 /* cannot change signals on the fly */
1071 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1072 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1073 if (sig != gdbctx->last_sig)
1074 return packet_error;
1075 resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
1076 wait_for_debuggee(gdbctx);
1077 return packet_reply_status(gdbctx);
1080 static enum packet_return packet_detach(struct gdb_context* gdbctx)
1082 detach_debuggee(gdbctx, FALSE);
1083 return packet_ok | packet_last_f;
1086 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
1090 CONTEXT* pctx = &gdbctx->context;
1092 assert(gdbctx->in_trap);
1094 if (DEBUG_CurrThread != gdbctx->other_thread && gdbctx->other_thread)
1096 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1097 return packet_error;
1100 packet_reply_open(gdbctx);
1101 for (i = 0; i < cpu_num_regs; i++)
1103 packet_reply_hex_to(gdbctx, cpu_register(pctx, i), 4);
1105 packet_reply_close(gdbctx);
1109 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
1113 CONTEXT* pctx = &gdbctx->context;
1115 assert(gdbctx->in_trap);
1116 if (DEBUG_CurrThread != gdbctx->other_thread && gdbctx->other_thread)
1118 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1119 return packet_error;
1121 if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error;
1123 for (i = 0; i < cpu_num_regs; i++)
1124 hex_from(cpu_register(pctx, i), &gdbctx->in_packet[8 * i], 4);
1125 if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx))
1127 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
1128 fprintf(stderr, "Cannot set context on thread %lu\n", gdbctx->other_thread->tid);
1129 return packet_error;
1134 static enum packet_return packet_kill(struct gdb_context* gdbctx)
1136 detach_debuggee(gdbctx, TRUE);
1138 if (!gdbctx->extended)
1139 /* dunno whether GDB cares or not */
1143 /* assume we can't really answer something here */
1144 /* return packet_done; */
1147 static enum packet_return packet_thread(struct gdb_context* gdbctx)
1152 switch (gdbctx->in_packet[0])
1156 if (gdbctx->in_packet[1] == '-')
1157 thread = -strtol(gdbctx->in_packet + 2, &end, 16);
1159 thread = strtol(gdbctx->in_packet + 1, &end, 16);
1160 if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len)
1162 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1163 fprintf(stderr, "Cannot get threadid %*.*s\n",
1164 gdbctx->in_packet_len - 1, gdbctx->in_packet_len - 1,
1165 gdbctx->in_packet + 1);
1166 return packet_error;
1168 if (gdbctx->in_packet[0] == 'c')
1169 gdbctx->exec_thread = DEBUG_GetThread(gdbctx->process, thread);
1171 gdbctx->other_thread = DEBUG_GetThread(gdbctx->process, thread);
1174 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1175 fprintf(stderr, "Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
1176 return packet_error;
1180 static enum packet_return packet_read_memory(struct gdb_context* gdbctx)
1183 size_t len, blk_len, nread;
1185 unsigned long r = 0;
1187 assert(gdbctx->in_trap);
1188 /* FIXME:check in_packet_len for reading %p,%x */
1189 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error;
1190 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1191 fprintf(stderr, "Read mem at %p for %u bytes\n", addr, len);
1192 for (nread = 0; nread < len > 0; nread += r, addr += r)
1194 blk_len = min(sizeof(buffer), len - nread);
1195 if (!ReadProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &r) ||
1198 /* fail at first address, return error */
1199 if (nread == 0) return packet_reply_error(gdbctx, EFAULT);
1200 /* something has already been read, return partial information */
1203 if (nread == 0) packet_reply_open(gdbctx);
1204 packet_reply_hex_to(gdbctx, buffer, r);
1206 packet_reply_close(gdbctx);
1210 static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
1213 size_t len, blk_len;
1218 assert(gdbctx->in_trap);
1219 ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len);
1222 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1223 fprintf(stderr, "Cannot find ':' in %*.*s\n",
1224 gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1225 return packet_error;
1229 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2)
1231 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1232 fprintf(stderr, "Cannot scan addr,len in %s\n", gdbctx->in_packet);
1233 return packet_error;
1235 if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len)
1237 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1238 fprintf(stderr, "Wrong sizes %u <> %u\n",
1239 ptr - gdbctx->in_packet + len * 2, gdbctx->in_packet_len);
1240 return packet_error;
1242 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1243 fprintf(stderr, "Write %u bytes at %p\n", len, addr);
1246 blk_len = min(sizeof(buffer), len);
1247 hex_from(buffer, ptr, blk_len);
1251 ret = WriteProcessMemory(gdbctx->process->handle, addr, buffer, blk_len, &w);
1252 if (!ret || w != blk_len)
1259 return packet_ok; /* FIXME: error while writing ? */
1262 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
1268 CONTEXT* pctx = &gdbctx->context;
1270 assert(gdbctx->in_trap);
1272 ptr = memchr(gdbctx->in_packet, '=', gdbctx->in_packet_len);
1274 reg = strtoul(gdbctx->in_packet, &end, 16);
1275 if (end == NULL || reg > cpu_num_regs)
1277 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1278 fprintf(stderr, "Invalid register index %s\n", gdbctx->in_packet);
1279 /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
1280 * it wouldn't matter too much, and it fakes our support for all regs
1282 return (end == NULL) ? packet_error : packet_ok;
1284 if (ptr + 8 - gdbctx->in_packet != gdbctx->in_packet_len)
1286 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1287 fprintf(stderr, "Wrong sizes %u <> %u\n",
1288 ptr + 8 - gdbctx->in_packet, gdbctx->in_packet_len);
1289 return packet_error;
1291 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1292 fprintf(stderr, "Writing reg %u <= %*.*s\n",
1293 reg, gdbctx->in_packet_len - (ptr - gdbctx->in_packet),
1294 gdbctx->in_packet_len - (ptr - gdbctx->in_packet), ptr);
1296 if (DEBUG_CurrThread != gdbctx->other_thread && gdbctx->other_thread)
1298 if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
1299 return packet_error;
1302 hex_from(cpu_register(pctx, reg), ptr, 4);
1303 if (pctx != &gdbctx->context && !SetThreadContext(gdbctx->other_thread->handle, pctx))
1305 if (gdbctx->trace & GDBPXY_TRC_WIN32_ERROR)
1306 fprintf(stderr, "Cannot set context for thread %lu\n", gdbctx->other_thread->tid);
1307 return packet_error;
1313 static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent)
1321 if (!GetClassName(hWnd, clsName, sizeof(clsName)))
1322 strcpy(clsName, "-- Unknown --");
1323 if (!GetWindowText(hWnd, wndName, sizeof(wndName)))
1324 strcpy(wndName, "-- Empty --");
1326 packet_reply_open(gdbctx);
1327 packet_reply_catc(gdbctx, 'O');
1328 snprintf(buffer, sizeof(buffer),
1329 "%*s%04x%*s%-17.17s %08lx %08lx %.14s\n",
1330 indent, "", (UINT)hWnd, 13 - indent, "",
1331 clsName, GetWindowLong(hWnd, GWL_STYLE),
1332 GetWindowLong(hWnd, GWL_WNDPROC), wndName);
1333 packet_reply_hex_to_str(gdbctx, buffer);
1334 packet_reply_close(gdbctx);
1336 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
1337 packet_query_monitor_wnd_helper(gdbctx, child, indent + 1);
1338 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
1341 static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str)
1345 /* we do the output in several 'O' packets, with the last one being just OK for
1346 * marking the end of the output */
1347 packet_reply_open(gdbctx);
1348 packet_reply_catc(gdbctx, 'O');
1349 snprintf(buffer, sizeof(buffer),
1350 "%-16.16s %-17.17s %-8.8s %s\n",
1351 "hwnd", "Class Name", " Style", " WndProc Text");
1352 packet_reply_hex_to_str(gdbctx, buffer);
1353 packet_reply_close(gdbctx);
1355 /* FIXME: could also add a pmt to this command in str... */
1356 packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0);
1357 packet_reply(gdbctx, "OK", 2);
1360 static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str)
1362 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1365 PROCESSENTRY32 entry;
1368 if (snap == INVALID_HANDLE_VALUE)
1371 entry.dwSize = sizeof(entry);
1372 ok = Process32First( snap, &entry );
1374 /* we do the output in several 'O' packets, with the last one being just OK for
1375 * marking the end of the output */
1377 packet_reply_open(gdbctx);
1378 packet_reply_catc(gdbctx, 'O');
1379 snprintf(buffer, sizeof(buffer),
1380 " %-8.8s %-8.8s %-8.8s %s\n",
1381 "pid", "threads", "parent", "executable" );
1382 packet_reply_hex_to_str(gdbctx, buffer);
1383 packet_reply_close(gdbctx);
1388 if (entry.th32ProcessID == gdbctx->process->pid) deco = '>';
1389 packet_reply_open(gdbctx);
1390 packet_reply_catc(gdbctx, 'O');
1391 snprintf(buffer, sizeof(buffer),
1392 "%c%08lx %-8ld %08lx '%s'\n",
1393 deco, entry.th32ProcessID, entry.cntThreads,
1394 entry.th32ParentProcessID, entry.szExeFile);
1395 packet_reply_hex_to_str(gdbctx, buffer);
1396 packet_reply_close(gdbctx);
1397 ok = Process32Next(snap, &entry);
1400 packet_reply(gdbctx, "OK", 2);
1403 static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str)
1405 MEMORY_BASIC_INFORMATION mbi;
1412 /* we do the output in several 'O' packets, with the last one being just OK for
1413 * marking the end of the output */
1414 packet_reply_open(gdbctx);
1415 packet_reply_catc(gdbctx, 'O');
1416 packet_reply_hex_to_str(gdbctx, "Address Size State Type RWX\n");
1417 packet_reply_close(gdbctx);
1419 while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
1423 case MEM_COMMIT: state = "commit "; break;
1424 case MEM_FREE: state = "free "; break;
1425 case MEM_RESERVE: state = "reserve"; break;
1426 default: state = "??? "; break;
1428 if (mbi.State != MEM_FREE)
1432 case MEM_IMAGE: type = "image "; break;
1433 case MEM_MAPPED: type = "mapped "; break;
1434 case MEM_PRIVATE: type = "private"; break;
1435 case 0: type = " "; break;
1436 default: type = "??? "; break;
1438 memset(prot, ' ' , sizeof(prot)-1);
1439 prot[sizeof(prot)-1] = '\0';
1440 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1442 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
1444 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1446 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE))
1454 packet_reply_open(gdbctx);
1455 snprintf(buffer, sizeof(buffer),
1456 "%08lx %08lx %s %s %s\n",
1457 (DWORD)addr, mbi.RegionSize, state, type, prot);
1458 packet_reply_catc(gdbctx, 'O');
1459 packet_reply_hex_to_str(gdbctx, buffer);
1460 packet_reply_close(gdbctx);
1462 if (addr + mbi.RegionSize < addr) /* wrap around ? */
1464 addr += mbi.RegionSize;
1466 packet_reply(gdbctx, "OK", 2);
1469 static void packet_query_monitor_trace(struct gdb_context* gdbctx,
1470 int len, const char* str)
1476 snprintf(buffer, sizeof(buffer), "trace=%x\n", gdbctx->trace);
1478 else if (len >= 2 && str[0] == '=')
1480 unsigned val = atoi(&str[1]);
1481 snprintf(buffer, sizeof(buffer), "trace: %x => %x\n", gdbctx->trace, val);
1482 gdbctx->trace = val;
1486 /* FIXME: ugly but can use error packet here */
1487 packet_reply_cat(gdbctx, "E00");
1490 packet_reply_open(gdbctx);
1491 packet_reply_hex_to_str(gdbctx, buffer);
1492 packet_reply_close(gdbctx);
1496 static void packet_query_monitor_linear(struct gdb_context* gdbctx,
1497 int len, const char* str)
1504 while (len > 0 && (*str == ' ' || *str == '\t'))
1508 /* FIXME: do a better scanning (allow both decimal and hex numbers) */
1509 if (!len || sscanf(str, "%x:%x", &seg, &ofs) != 2)
1511 packet_reply_error(gdbctx, 0);
1516 if (gdbctx->context.EFlags & 0x00020000) linear = (LOWORD(seg) << 4) + ofs;
1517 /* linux system selector ? */
1518 else if (!(seg & 4) || ((seg >> 3) < 17)) linear = ofs;
1519 /* standard selector */
1520 else if (GetThreadSelectorEntry(gdbctx->process->threads->handle, seg, &le))
1521 linear = (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) +
1525 snprintf(buffer, sizeof(buffer), "0x%x", linear);
1526 packet_reply_open(gdbctx);
1527 packet_reply_hex_to_str(gdbctx, buffer);
1528 packet_reply_close(gdbctx);
1537 void (*handler)(struct gdb_context*, int, const char*);
1540 {0, "wnd", 3, packet_query_monitor_wnd},
1541 {0, "window", 6, packet_query_monitor_wnd},
1542 {0, "proc", 4, packet_query_monitor_process},
1543 {0, "process", 7, packet_query_monitor_process},
1544 {0, "mem", 3, packet_query_monitor_mem},
1545 {1, "trace", 5, packet_query_monitor_trace},
1547 {1, "linear", 6, packet_query_monitor_linear},
1552 static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx,
1553 const char* hxcmd, size_t len)
1556 struct query_detail* qd;
1558 assert((len & 1) == 0 && len < 2 * sizeof(buffer));
1560 hex_from(buffer, hxcmd, len);
1562 for (qd = &query_details[0]; qd->name != NULL; qd++)
1564 if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue;
1565 if (!qd->with_arg && len != qd->len) continue;
1567 (qd->handler)(gdbctx, len - qd->len, buffer + qd->len);
1570 return packet_reply_error(gdbctx, EINVAL);
1573 static enum packet_return packet_query(struct gdb_context* gdbctx)
1575 switch (gdbctx->in_packet[0])
1578 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1582 packet_reply_open(gdbctx);
1583 packet_reply_add(gdbctx, "m", 1);
1584 for (thd = gdbctx->process->threads; thd; thd = thd->next)
1586 packet_reply_val(gdbctx, thd->tid, 4);
1587 if (thd->next != NULL)
1588 packet_reply_add(gdbctx, ",", 1);
1590 packet_reply_close(gdbctx);
1593 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1597 packet_reply_open(gdbctx);
1598 packet_reply_catc(gdbctx, 'O');
1599 get_process_info(gdbctx, result, sizeof(result));
1600 packet_reply_hex_to_str(gdbctx, result);
1601 packet_reply_close(gdbctx);
1606 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
1608 packet_reply(gdbctx, "l", 1);
1611 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
1613 packet_reply(gdbctx, "l", 1);
1618 if (gdbctx->in_packet_len == 1)
1621 /* FIXME: doc says 16 bit val ??? */
1622 /* grab first created thread, aka last in list */
1623 assert(gdbctx->process && gdbctx->process->threads);
1624 for (thd = gdbctx->process->threads; thd->next; thd = thd->next);
1625 packet_reply_open(gdbctx);
1626 packet_reply_add(gdbctx, "QC", 2);
1627 packet_reply_val(gdbctx, thd->tid, 4);
1628 packet_reply_close(gdbctx);
1633 if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0)
1637 if (gdbctx->wine_segs[0] == 0 && gdbctx->wine_segs[1] == 0 &&
1638 gdbctx->wine_segs[2] == 0)
1639 return packet_error;
1640 snprintf(buf, sizeof(buf),
1641 "Text=%08lx;Data=%08lx;Bss=%08lx",
1642 gdbctx->wine_segs[0], gdbctx->wine_segs[1],
1643 gdbctx->wine_segs[2]);
1644 return packet_reply(gdbctx, buf, -1);
1648 if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0)
1650 return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5,
1651 gdbctx->in_packet_len - 5);
1655 if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0)
1659 if (gdbctx->in_packet_len > 15 &&
1660 strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 &&
1661 gdbctx->in_packet[15] == ',')
1667 tid = strtol(gdbctx->in_packet + 16, &end, 16);
1668 if (end == NULL) break;
1669 get_thread_info(gdbctx, tid, result, sizeof(result));
1670 packet_reply_open(gdbctx);
1671 packet_reply_hex_to_str(gdbctx, result);
1672 packet_reply_close(gdbctx);
1677 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1678 fprintf(stderr, "Unknown or malformed query %*.*s\n",
1679 gdbctx->in_packet_len, gdbctx->in_packet_len, gdbctx->in_packet);
1680 return packet_error;
1683 static enum packet_return packet_step(struct gdb_context* gdbctx)
1685 /* FIXME: add support for address in packet */
1686 assert(gdbctx->in_packet_len == 0);
1687 if (DEBUG_CurrThread != gdbctx->exec_thread && gdbctx->exec_thread)
1688 if (gdbctx->trace & GDBPXY_TRC_COMMAND_FIXME)
1689 fprintf(stderr, "NIY: step on %lu, while last thread is %lu\n",
1690 gdbctx->exec_thread->tid, DEBUG_CurrThread->tid);
1691 if (!cpu_enter_stepping(gdbctx)) return packet_error;
1692 resume_debuggee(gdbctx, DBG_CONTINUE);
1693 wait_for_debuggee(gdbctx);
1694 if (!cpu_leave_stepping(gdbctx)) return packet_error;
1695 return packet_reply_status(gdbctx);
1699 static enum packet_return packet_step_signal(struct gdb_context* gdbctx)
1703 /* FIXME: add support for address in packet */
1704 assert(gdbctx->in_packet_len == 2);
1705 if (DEBUG_CurrThread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
1706 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1707 fprintf(stderr, "NIY: step/sig on %u, while last thread is %u\n",
1708 gdbctx->exec_thread, DEBUG_CurrThread->tid);
1709 hex_from(&sig, gdbctx->in_packet, 1);
1710 /* cannot change signals on the fly */
1711 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1712 fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
1713 if (sig != gdbctx->last_sig)
1714 return packet_error;
1715 resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
1716 wait_for_debuggee(gdbctx);
1717 return packet_reply_status(gdbctx);
1721 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
1726 tid = strtol(gdbctx->in_packet, &end, 16);
1727 if (tid == -1 || tid == 0)
1728 return packet_reply_error(gdbctx, EINVAL);
1729 if (DEBUG_GetThread(gdbctx->process, tid) != NULL)
1731 return packet_reply_error(gdbctx, ESRCH);
1734 static enum packet_return packet_remove_breakpoint(struct gdb_context* gdbctx)
1738 struct gdb_ctx_Xpoint* xpt;
1740 /* FIXME: check packet_len */
1741 if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1742 gdbctx->in_packet[1] != ',' ||
1743 sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1744 return packet_error;
1745 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1746 fprintf(stderr, "Remove bp %p[%u] typ=%c\n",
1747 addr, len, gdbctx->in_packet[0]);
1748 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1750 if (xpt->addr == addr && xpt->type == gdbctx->in_packet[0])
1752 switch (cpu_remove_Xpoint(gdbctx, xpt, len))
1754 case 1: xpt->type = -1; return packet_ok;
1755 case 0: return packet_error;
1756 case -1: return packet_done;
1761 return packet_error;
1764 static enum packet_return packet_set_breakpoint(struct gdb_context* gdbctx)
1768 struct gdb_ctx_Xpoint* xpt;
1770 /* FIXME: check packet_len */
1771 if (gdbctx->in_packet[0] < '0' || gdbctx->in_packet[0] > '4' ||
1772 gdbctx->in_packet[1] != ',' ||
1773 sscanf(gdbctx->in_packet + 2, "%p,%x", &addr, &len) != 2)
1774 return packet_error;
1775 if (gdbctx->trace & GDBPXY_TRC_COMMAND)
1776 fprintf(stderr, "Set bp %p[%u] typ=%c\n",
1777 addr, len, gdbctx->in_packet[0]);
1778 /* because of packet command handling, this should be made idempotent */
1779 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1781 if (xpt->addr == addr && xpt->type == gdbctx->in_packet[0])
1782 return packet_ok; /* nothing to do */
1784 /* really set the Xpoint */
1785 for (xpt = &gdbctx->Xpoints[NUM_XPOINT - 1]; xpt >= gdbctx->Xpoints; xpt--)
1787 if (xpt->type == -1)
1790 xpt->type = gdbctx->in_packet[0];
1791 switch (cpu_insert_Xpoint(gdbctx, xpt, len))
1793 case 1: return packet_ok;
1794 case 0: return packet_error;
1795 case -1: return packet_done;
1800 /* no more entries... eech */
1801 fprintf(stderr, "Running out of spots for {break|watch}points\n");
1802 return packet_error;
1805 /* =============================================== *
1806 * P A C K E T I N F R A S T R U C T U R E *
1807 * =============================================== *
1813 enum packet_return (*handler)(struct gdb_context* gdbctx);
1816 static struct packet_entry packet_entries[] =
1818 /* {'!', packet_extended}, */
1819 {'?', packet_last_signal},
1820 {'c', packet_continue},
1821 {'C', packet_continue_signal},
1822 {'D', packet_detach},
1823 {'g', packet_read_registers},
1824 {'G', packet_write_registers},
1826 {'H', packet_thread},
1827 {'m', packet_read_memory},
1828 {'M', packet_write_memory},
1829 /* {'p', packet_read_register}, doesn't seem needed */
1830 {'P', packet_write_register},
1831 {'q', packet_query},
1833 /*{'S', packet_step_signal}, hard(er) to implement */
1834 {'T', packet_thread_alive},
1835 {'z', packet_remove_breakpoint},
1836 {'Z', packet_set_breakpoint},
1839 static BOOL extract_packets(struct gdb_context* gdbctx)
1843 unsigned char in_cksum, loc_cksum;
1845 enum packet_return ret = packet_error;
1848 while ((ret & packet_last_f) == 0)
1850 if (gdbctx->in_len && (gdbctx->trace & GDBPXY_TRC_LOWLEVEL))
1851 fprintf(stderr, "In-buf: %*.*s\n",
1852 gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
1853 ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len);
1854 if (ptr == NULL) return FALSE;
1855 if (ptr != gdbctx->in_buf)
1857 int glen = ptr - gdbctx->in_buf; /* garbage len */
1858 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1859 fprintf(stderr, "Removing garbage: %*.*s\n",
1860 glen, glen, gdbctx->in_buf);
1861 gdbctx->in_len -= glen;
1862 memmove(gdbctx->in_buf, ptr, gdbctx->in_len);
1864 end = memchr(gdbctx->in_buf + 1, '#', gdbctx->in_len);
1865 if (end == NULL) return FALSE;
1866 /* no checksum yet */
1867 if (end + 3 > gdbctx->in_buf + gdbctx->in_len) return FALSE;
1868 plen = end - gdbctx->in_buf - 1;
1869 hex_from(&in_cksum, end + 1, 1);
1870 loc_cksum = checksum(gdbctx->in_buf + 1, plen);
1871 if (loc_cksum == in_cksum)
1873 if (num_packet == 0) {
1878 write(gdbctx->sock, "+", 1);
1881 /* FIXME: should use bsearch if packet_entries was sorted */
1882 for (i = 0; i < sizeof(packet_entries)/sizeof(packet_entries[0]); i++)
1884 if (packet_entries[i].key == gdbctx->in_buf[1]) break;
1886 if (i == sizeof(packet_entries)/sizeof(packet_entries[0]))
1888 if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
1889 fprintf(stderr, "Unknown packet request %*.*s\n",
1890 plen, plen, &gdbctx->in_buf[1]);
1894 gdbctx->in_packet = gdbctx->in_buf + 2;
1895 gdbctx->in_packet_len = plen - 1;
1896 if (gdbctx->trace & GDBPXY_TRC_PACKET)
1897 fprintf(stderr, "Packet: %c%*.*s\n",
1899 gdbctx->in_packet_len, gdbctx->in_packet_len,
1901 ret = (packet_entries[i].handler)(gdbctx);
1903 switch (ret & ~packet_last_f)
1905 case packet_error: packet_reply(gdbctx, "", 0); break;
1906 case packet_ok: packet_reply(gdbctx, "OK", 2); break;
1907 case packet_done: break;
1909 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1910 fprintf(stderr, "Reply-full: %*.*s\n",
1911 gdbctx->out_len, gdbctx->out_len, gdbctx->out_buf);
1912 i = write(gdbctx->sock, gdbctx->out_buf, gdbctx->out_len);
1913 assert(i == gdbctx->out_len);
1914 /* if this fails, we'll have to use POLLOUT...
1916 gdbctx->out_len = 0;
1921 /* FIXME: if we have in our input buffer more than one packet,
1922 * it's very likely that we took too long to answer to a given packet
1923 * and gdb is sending us again the same packet
1924 * We simply drop the second packet. This will lower the risk of error,
1925 * but there's still some race conditions here
1926 * A better fix (yet not perfect) would be to have two threads:
1927 * - one managing the packets for gdb
1928 * - the second one managing the commands...
1929 * This would allow us also the reply with the '+' character (Ack of
1930 * the command) way sooner than what we do now
1932 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1933 fprintf(stderr, "Dropping packet, I was too slow to respond\n");
1938 write(gdbctx->sock, "+", 1);
1939 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1940 fprintf(stderr, "Dropping packet, invalid checksum %d <> %d\n", in_cksum, loc_cksum);
1942 gdbctx->in_len -= plen + 4;
1943 memmove(gdbctx->in_buf, end + 3, gdbctx->in_len);
1948 static int fetch_data(struct gdb_context* gdbctx)
1950 int len, in_len = gdbctx->in_len;
1952 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
1956 if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc)
1957 gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP);
1959 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1960 fprintf(stderr, "%d %d %*.*s\n",
1961 gdbctx->in_len, gdbctx->in_buf_alloc,
1962 gdbctx->in_len, gdbctx->in_len, gdbctx->in_buf);
1963 len = read(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len);
1964 if (len <= 0) break;
1965 gdbctx->in_len += len;
1966 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
1967 if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break;
1969 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1970 fprintf(stderr, "=> %d\n", gdbctx->in_len - in_len);
1971 return gdbctx->in_len - in_len;
1974 static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned flags)
1977 struct sockaddr_in s_addrs;
1978 int s_len = sizeof(s_addrs);
1979 struct pollfd pollfd;
1980 char wine_path[MAX_PATH];
1983 /* step 1: create socket for gdb connection request */
1984 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
1986 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
1987 fprintf(stderr, "Can't create socket");
1991 if (listen(sock, 1) == -1 ||
1992 getsockname(sock, (struct sockaddr*)&s_addrs, &s_len) == -1)
1995 /* step 2: find out wine executable location (as a Unix filename) */
1996 ptr = getenv("WINELOADER");
1997 strcpy(wine_path, ptr ? ptr : "wine");
1999 fprintf(stderr, "Using wine_path: %s\n", wine_path);
2000 read_elf_info(wine_path, gdbctx->wine_segs);
2002 /* step 3: fire up gdb (if requested) */
2004 fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addrs.sin_port));
2008 case -1: /* error in parent... */
2009 fprintf(stderr, "Cannot create gdb\n");
2012 default: /* in parent... success */
2014 case 0: /* in child... and alive */
2021 if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb";
2022 strcpy(buf,"/tmp/winegdb.XXXXXX");
2023 fd = mkstemps(buf,0);
2024 if (fd == -1) return FALSE;
2025 if ((f = fdopen(fd, "w+")) == NULL) return FALSE;
2026 fprintf(f, "file %s\n", wine_path);
2027 fprintf(f, "target remote localhost:%d\n", ntohs(s_addrs.sin_port));
2028 fprintf(f, "monitor trace=%d\n", GDBPXY_TRC_COMMAND_FIXME);
2029 fprintf(f, "set prompt Wine-gdb>\\ \n");
2030 /* gdb 5.1 seems to require it, won't hurt anyway */
2031 fprintf(f, "sharedlibrary\n");
2032 /* tell gdb to delete this file when done handling it... */
2033 fprintf(f, "shell rm -f \"%s\"\n", buf);
2036 execlp("xterm", "xterm", "-e", gdb_path, "-x", buf, NULL);
2038 execlp(gdb_path, gdb_path, "-x", buf, NULL);
2039 assert(0); /* never reached */
2045 /* step 4: do the process internal creation */
2046 handle_debug_event(gdbctx, de);
2048 /* step 5: wait for gdb to connect actually */
2050 pollfd.events = POLLIN;
2053 switch (poll(&pollfd, 1, -1))
2056 if (pollfd.revents & POLLIN)
2059 gdbctx->sock = accept(sock, (struct sockaddr*)&s_addrs, &s_len);
2060 if (gdbctx->sock == -1)
2062 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2063 fprintf(stderr, "Connected on %d\n", gdbctx->sock);
2064 /* don't keep our small packets too long: send them ASAP back to GDB
2065 * without this, GDB really crawls
2067 setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy));
2071 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2072 fprintf(stderr, "Poll for cnx failed (timeout)\n");
2075 if (gdbctx->trace & GDBPXY_TRC_LOWLEVEL)
2076 fprintf(stderr, "Poll for cnx failed (error)\n");
2086 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags)
2092 gdbctx->in_buf = NULL;
2093 gdbctx->in_buf_alloc = 0;
2095 gdbctx->out_buf = NULL;
2096 gdbctx->out_buf_alloc = 0;
2097 gdbctx->out_len = 0;
2098 gdbctx->out_curr_packet = -1;
2100 gdbctx->exec_thread = gdbctx->other_thread = NULL;
2101 gdbctx->last_sig = 0;
2102 gdbctx->in_trap = FALSE;
2103 gdbctx->trace = /*GDBPXY_TRC_PACKET | GDBPXY_TRC_COMMAND |*/ GDBPXY_TRC_COMMAND_ERROR | GDBPXY_TRC_COMMAND_FIXME | GDBPXY_TRC_WIN32_EVENT;
2104 gdbctx->process = NULL;
2105 for (i = 0; i < NUM_XPOINT; i++)
2106 gdbctx->Xpoints[i].type = -1;
2108 /* wait for first trap */
2109 while (WaitForDebugEvent(&de, INFINITE))
2111 if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
2113 /* this should be the first event we get,
2114 * and the only one of this type */
2115 assert(gdbctx->process == NULL && de.dwProcessId == DEBUG_CurrPid);
2116 /*gdbctx->dwProcessId = pid; */
2117 if (!gdb_startup(gdbctx, &de, flags)) return FALSE;
2118 assert(!gdbctx->in_trap);
2122 handle_debug_event(gdbctx, &de);
2123 if (gdbctx->in_trap) break;
2125 ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
2130 BOOL DEBUG_GdbRemote(unsigned flags)
2132 struct pollfd pollfd;
2133 struct gdb_context gdbctx;
2136 for (doLoop = gdb_init_context(&gdbctx, flags); doLoop;)
2138 pollfd.fd = gdbctx.sock;
2139 pollfd.events = POLLIN;
2142 switch (poll(&pollfd, 1, -1))
2146 if (pollfd.revents & (POLLHUP | POLLERR))
2148 if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
2149 fprintf(stderr, "Gdb hung up\n");
2150 /* kill also debuggee process - questionnable - */
2151 detach_debuggee(&gdbctx, TRUE);
2155 if ((pollfd.revents & POLLIN) && fetch_data(&gdbctx) > 0)
2157 if (extract_packets(&gdbctx)) doLoop = FALSE;
2161 /* timeout, should never happen (infinite timeout) */
2164 if (gdbctx.trace & GDBPXY_TRC_LOWLEVEL)
2165 fprintf(stderr, "Poll failed\n");