?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedbg: Enhance printing of variables or fields.
[wine.git] / programs / winedbg / gdbproxy.c
blob6b523b30337fcff3dea7998c6d05a5c58efc1ba6
1 /*
2 * A Win32 based proxy implementing the GBD remote protocol.
3 * This makes it possible to debug Wine (and any "emulated"
4 * program) under Linux using GDB.
5 *
6 * Copyright (c) Eric Pouech 2002-2004
7 *
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.
12 *
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.
17 *
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 /* Protocol specification can be found here:
24 * http://sources.redhat.com/gdb/onlinedocs/gdb/Maintenance-Commands.html
25 */
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29
30 #include <assert.h>
31 #include <fcntl.h>
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35
36 #include "debugger.h"
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winsock2.h"
41 #include "tlhelp32.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
45
46 struct gdb_xpoint
47 {
48 struct list entry;
49 int pid;
50 int tid;
51 enum be_xpoint_type type;
52 void *addr;
53 int size;
54 unsigned int value;
55 };
56
57 struct reply_buffer
58 {
59 unsigned char* base;
60 size_t len;
61 size_t alloc;
62 };
63
64 #define QX_NAME_SIZE 32
65 #define QX_ANNEX_SIZE MAX_PATH
66
67 struct gdb_context
68 {
69 /* gdb information */
70 SOCKET sock;
71 /* incoming buffer */
72 char* in_buf;
73 int in_buf_alloc;
74 int in_len;
75 /* split into individual packet */
76 char* in_packet;
77 int in_packet_len;
78 /* outgoing buffer */
79 struct reply_buffer out_buf;
80 int out_curr_packet;
81 /* generic GDB thread information */
82 int exec_tid; /* tid used in step & continue */
83 int other_tid; /* tid to be used in any other operation */
84 struct list xpoint_list;
85 /* current Win32 trap env */
86 DEBUG_EVENT de;
87 DWORD de_reply;
88 /* Win32 information */
89 struct dbg_process* process;
90 /* Unix environment */
91 ULONG_PTR wine_segs[3]; /* load addresses of the ELF wine exec segments (text, bss and data) */
92 BOOL no_ack_mode;
93 int qxfer_object_idx;
94 char qxfer_object_annex[QX_ANNEX_SIZE];
95 struct reply_buffer qxfer_buffer;
96 };
97
98 /* assume standard signal and errno values */
99 enum host_error
100 {
101 HOST_EPERM = 1,
102 HOST_ENOENT = 2,
103 HOST_ESRCH = 3,
104 HOST_ENOMEM = 12,
105 HOST_EFAULT = 14,
106 HOST_EINVAL = 22,
107 };
108
109 enum host_signal
110 {
111 HOST_SIGINT = 2,
112 HOST_SIGILL = 4,
113 HOST_SIGTRAP = 5,
114 HOST_SIGABRT = 6,
115 HOST_SIGFPE = 8,
116 HOST_SIGBUS = 10,
117 HOST_SIGSEGV = 11,
118 HOST_SIGALRM = 14,
119 HOST_SIGTERM = 15,
120 };
121
122 static void gdbctx_delete_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
123 dbg_ctx_t *ctx, struct gdb_xpoint *x)
124 {
125 struct dbg_process *process = gdbctx->process;
126 struct backend_cpu *cpu = process->be_cpu;
127
128 if (!cpu->remove_Xpoint(process->handle, process->process_io, ctx, x->type, x->addr, x->value, x->size))
129 ERR("%04lx:%04lx: Couldn't remove breakpoint at:%p/%x type:%d\n", process->pid, thread ? thread->tid : ~0, x->addr, x->size, x->type);
130
131 list_remove(&x->entry);
132 free(x);
133 }
134
135 static void gdbctx_insert_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
136 dbg_ctx_t *ctx, enum be_xpoint_type type, void *addr, int size)
137 {
138 struct dbg_process *process = thread->process;
139 struct backend_cpu *cpu = process->be_cpu;
140 struct gdb_xpoint *x;
141 unsigned int value;
142
143 if (!cpu->insert_Xpoint(process->handle, process->process_io, ctx, type, addr, &value, size))
144 {
145 ERR("%04lx:%04lx: Couldn't insert breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
146 return;
147 }
148
149 if (!(x = malloc(sizeof(struct gdb_xpoint))))
150 {
151 ERR("%04lx:%04lx: Couldn't allocate memory for breakpoint at:%p/%x type:%d\n", process->pid, thread->tid, addr, size, type);
152 return;
153 }
154
155 x->pid = process->pid;
156 x->tid = thread->tid;
157 x->type = type;
158 x->addr = addr;
159 x->size = size;
160 x->value = value;
161 list_add_head(&gdbctx->xpoint_list, &x->entry);
162 }
163
164 static struct gdb_xpoint *gdb_find_xpoint(struct gdb_context *gdbctx, struct dbg_thread *thread,
165 enum be_xpoint_type type, void *addr, int size)
166 {
167 struct gdb_xpoint *x;
168
169 LIST_FOR_EACH_ENTRY(x, &gdbctx->xpoint_list, struct gdb_xpoint, entry)
170 {
171 if (thread && (x->pid != thread->process->pid || x->tid != thread->tid))
172 continue;
173 if (x->type == type && x->addr == addr && x->size == size)
174 return x;
175 }
176
177 return NULL;
178 }
179
180 static BOOL tgt_process_gdbproxy_read(HANDLE hProcess, const void* addr,
181 void* buffer, SIZE_T len, SIZE_T* rlen)
182 {
183 return ReadProcessMemory( hProcess, addr, buffer, len, rlen );
184 }
185
186 static BOOL tgt_process_gdbproxy_write(HANDLE hProcess, void* addr,
187 const void* buffer, SIZE_T len, SIZE_T* wlen)
188 {
189 return WriteProcessMemory( hProcess, addr, buffer, len, wlen );
190 }
191
192 static struct be_process_io be_process_gdbproxy_io =
193 {
194 NULL, /* we shouldn't use close_process() in gdbproxy */
195 tgt_process_gdbproxy_read,
196 tgt_process_gdbproxy_write
197 };
198
199 /* =============================================== *
200 * B A S I C M A N I P U L A T I O N S *
201 * =============================================== *
202 */
203
204 static inline int hex_from0(char ch)
205 {
206 if (ch >= '0' && ch <= '9') return ch - '0';
207 if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
208 if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
209
210 assert(0);
211 return 0;
212 }
213
214 static inline unsigned char hex_to0(int x)
215 {
216 assert(x >= 0 && x < 16);
217 return "0123456789abcdef"[x];
218 }
219
220 static void hex_from(void* dst, const char* src, size_t len)
221 {
222 unsigned char *p = dst;
223 while (len--)
224 {
225 *p++ = (hex_from0(src[0]) << 4) | hex_from0(src[1]);
226 src += 2;
227 }
228 }
229
230 static void hex_to(char* dst, const void* src, size_t len)
231 {
232 const unsigned char *p = src;
233 while (len--)
234 {
235 *dst++ = hex_to0(*p >> 4);
236 *dst++ = hex_to0(*p & 0x0F);
237 p++;
238 }
239 }
240
241 static void reply_buffer_clear(struct reply_buffer* reply)
242 {
243 reply->len = 0;
244 }
245
246 static void reply_buffer_grow(struct reply_buffer* reply, size_t size)
247 {
248 size_t required_alloc = reply->len + size;
249
250 if (reply->alloc < required_alloc)
251 {
252 reply->alloc = reply->alloc * 3 / 2;
253 if (reply->alloc < required_alloc)
254 reply->alloc = required_alloc;
255
256 reply->base = realloc(reply->base, reply->alloc);
257 }
258 }
259
260 static void reply_buffer_append(struct reply_buffer* reply, const void* data, size_t size)
261 {
262 reply_buffer_grow(reply, size);
263 memcpy(reply->base + reply->len, data, size);
264 reply->len += size;
265 }
266
267 static inline void reply_buffer_append_str(struct reply_buffer* reply, const char* str)
268 {
269 reply_buffer_append(reply, str, strlen(str));
270 }
271
272 static inline void reply_buffer_append_wstr(struct reply_buffer* reply, const WCHAR* wstr)
273 {
274 char* str;
275 int len;
276
277 len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
278 str = malloc(len);
279 if (str && WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL))
280 reply_buffer_append_str(reply, str);
281 free(str);
282 }
283
284 static inline void reply_buffer_append_hex(struct reply_buffer* reply, const void* src, size_t len)
285 {
286 reply_buffer_grow(reply, len * 2);
287 hex_to((char *)reply->base + reply->len, src, len);
288 reply->len += len * 2;
289 }
290
291 static inline void reply_buffer_append_uinthex(struct reply_buffer* reply, ULONG_PTR val, int len)
292 {
293 char buf[sizeof(ULONG_PTR) * 2], *ptr;
294
295 assert(len <= sizeof(ULONG_PTR));
296
297 ptr = buf + len * 2;
298 while (ptr != buf)
299 {
300 *--ptr = hex_to0(val & 0x0F);
301 val >>= 4;
302 }
303
304 reply_buffer_append(reply, ptr, len * 2);
305 }
306
307 static const unsigned char xml_special_chars_lookup_table[16] = {
308 /* The characters should be sorted by its value modulo table length. */
309
310 0x00, /* NUL */
311 0,
312 0x22, /* ": 0010|0010 */
313 0, 0, 0,
314 0x26, /* &: 0010|0110 */
315 0x27, /* ': 0010|0111 */
316 0, 0, 0, 0,
317 0x3C, /* <: 0011|1100 */
318 0,
319 0x3E, /* >: 0011|1110 */
320 0
321 };
322
323 static inline BOOL is_nul_or_xml_special_char(unsigned char val)
324 {
325 const size_t length = ARRAY_SIZE(xml_special_chars_lookup_table);
326 return xml_special_chars_lookup_table[val % length] == val;
327 }
328
329 static void reply_buffer_append_xmlstr(struct reply_buffer* reply, const char* str)
330 {
331 const char *ptr = str, *curr;
332
333 for (;;)
334 {
335 curr = ptr;
336
337 while (!is_nul_or_xml_special_char((unsigned char)*ptr))
338 ptr++;
339
340 reply_buffer_append(reply, curr, ptr - curr);
341
342 switch (*ptr++)
343 {
344 case '"': reply_buffer_append_str(reply, "&quot;"); break;
345 case '&': reply_buffer_append_str(reply, "&amp;"); break;
346 case '\'': reply_buffer_append_str(reply, "&apos;"); break;
347 case '<': reply_buffer_append_str(reply, "&lt;"); break;
348 case '>': reply_buffer_append_str(reply, "&gt;"); break;
349 case '\0':
350 default:
351 return;
352 }
353 }
354 }
355
356 static unsigned char checksum(const void* data, int len)
357 {
358 unsigned cksum = 0;
359 const unsigned char* ptr = data;
360
361 while (len-- > 0)
362 cksum += *ptr++;
363 return cksum;
364 }
365
366 static inline void* cpu_register_ptr(struct gdb_context *gdbctx,
367 dbg_ctx_t *ctx, unsigned idx)
368 {
369 assert(idx < gdbctx->process->be_cpu->gdb_num_regs);
370 return (char*)ctx + gdbctx->process->be_cpu->gdb_register_map[idx].offset;
371 }
372
373 static inline DWORD64 cpu_register(struct gdb_context *gdbctx,
374 dbg_ctx_t *ctx, unsigned idx)
375 {
376 switch (gdbctx->process->be_cpu->gdb_register_map[idx].length)
377 {
378 case 1: return *(BYTE*)cpu_register_ptr(gdbctx, ctx, idx);
379 case 2: return *(WORD*)cpu_register_ptr(gdbctx, ctx, idx);
380 case 4: return *(DWORD*)cpu_register_ptr(gdbctx, ctx, idx);
381 case 8: return *(DWORD64*)cpu_register_ptr(gdbctx, ctx, idx);
382 default:
383 ERR("got unexpected size: %u\n",
384 (unsigned)gdbctx->process->be_cpu->gdb_register_map[idx].length);
385 assert(0);
386 return 0;
387 }
388 }
389
390 static inline void cpu_register_hex_from(struct gdb_context *gdbctx,
391 dbg_ctx_t* ctx, unsigned idx, const char **phex)
392 {
393 const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map;
394 hex_from(cpu_register_ptr(gdbctx, ctx, idx), *phex, cpu_register_map[idx].length);
395 }
396
397 /* =============================================== *
398 * W I N 3 2 D E B U G I N T E R F A C E *
399 * =============================================== *
400 */
401
402 static struct dbg_thread* dbg_thread_from_tid(struct gdb_context* gdbctx, int tid)
403 {
404 struct dbg_process *process = gdbctx->process;
405 struct dbg_thread *thread;
406
407 if (!process) return NULL;
408
409 if (tid == 0) tid = gdbctx->de.dwThreadId;
410 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
411 {
412 if (tid > 0 && thread->tid != tid) continue;
413 return thread;
414 }
415
416 return NULL;
417 }
418
419 static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable)
420 {
421 struct backend_cpu *backend;
422 dbg_ctx_t ctx;
423
424 if (!thread) return;
425 if (!thread->process) return;
426 if (!(backend = thread->process->be_cpu)) return;
427
428 if (!backend->get_context(thread->handle, &ctx))
429 {
430 ERR("get_context failed for thread %04lx:%04lx\n", thread->process->pid, thread->tid);
431 return;
432 }
433 backend->single_step(&ctx, enable);
434 if (!backend->set_context(thread->handle, &ctx))
435 ERR("set_context failed for thread %04lx:%04lx\n", thread->process->pid, thread->tid);
436 }
437
438 static unsigned char signal_from_debug_event(DEBUG_EVENT* de)
439 {
440 DWORD ec;
441
442 if (de->dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
443 return HOST_SIGTERM;
444 if (de->dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
445 return HOST_SIGTRAP;
446
447 ec = de->u.Exception.ExceptionRecord.ExceptionCode;
448 switch (ec)
449 {
450 case EXCEPTION_ACCESS_VIOLATION:
451 case EXCEPTION_PRIV_INSTRUCTION:
452 case EXCEPTION_STACK_OVERFLOW:
453 case EXCEPTION_GUARD_PAGE:
454 return HOST_SIGSEGV;
455 case EXCEPTION_DATATYPE_MISALIGNMENT:
456 return HOST_SIGBUS;
457 case EXCEPTION_SINGLE_STEP:
458 case EXCEPTION_BREAKPOINT:
459 return HOST_SIGTRAP;
460 case EXCEPTION_FLT_DENORMAL_OPERAND:
461 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
462 case EXCEPTION_FLT_INEXACT_RESULT:
463 case EXCEPTION_FLT_INVALID_OPERATION:
464 case EXCEPTION_FLT_OVERFLOW:
465 case EXCEPTION_FLT_STACK_CHECK:
466 case EXCEPTION_FLT_UNDERFLOW:
467 return HOST_SIGFPE;
468 case EXCEPTION_INT_DIVIDE_BY_ZERO:
469 case EXCEPTION_INT_OVERFLOW:
470 return HOST_SIGFPE;
471 case EXCEPTION_ILLEGAL_INSTRUCTION:
472 return HOST_SIGILL;
473 case CONTROL_C_EXIT:
474 return HOST_SIGINT;
475 case STATUS_POSSIBLE_DEADLOCK:
476 return HOST_SIGALRM;
477 /* should not be here */
478 case EXCEPTION_INVALID_HANDLE:
479 case EXCEPTION_WINE_NAME_THREAD:
480 return HOST_SIGTRAP;
481 default:
482 ERR("Unknown exception code 0x%08lx\n", ec);
483 return HOST_SIGABRT;
484 }
485 }
486
487 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
488 {
489 EXCEPTION_RECORD* rec = &exc->ExceptionRecord;
490
491 switch (rec->ExceptionCode)
492 {
493 case EXCEPTION_WINE_NAME_THREAD:
494 {
495 const THREADNAME_INFO *threadname = (const THREADNAME_INFO *)rec->ExceptionInformation;
496 struct dbg_thread *thread;
497 char name[9];
498 SIZE_T read;
499
500 if (threadname->dwType != 0x1000)
501 return FALSE;
502 if (threadname->dwThreadID == -1)
503 thread = dbg_get_thread(gdbctx->process, gdbctx->de.dwThreadId);
504 else
505 thread = dbg_get_thread(gdbctx->process, threadname->dwThreadID);
506 if (thread)
507 {
508 if (gdbctx->process->process_io->read( gdbctx->process->handle,
509 threadname->szName, name, sizeof(name), &read) && read == sizeof(name))
510 {
511 fprintf(stderr, "Thread ID=%04lx renamed to \"%.9s\"\n",
512 threadname->dwThreadID, name);
513 }
514 }
515 else
516 ERR("Cannot set name of thread %04lx\n", threadname->dwThreadID);
517 return TRUE;
518 }
519 case EXCEPTION_INVALID_HANDLE:
520 return TRUE;
521 default:
522 return FALSE;
523 }
524 }
525
526 static BOOL handle_debug_event(struct gdb_context* gdbctx, BOOL stop_on_dll_load_unload)
527 {
528 DEBUG_EVENT *de = &gdbctx->de;
529 struct dbg_thread *thread;
530
531 union {
532 char bufferA[256];
533 WCHAR buffer[256];
534 } u;
535 DWORD size;
536
537 gdbctx->exec_tid = de->dwThreadId;
538 gdbctx->other_tid = de->dwThreadId;
539 gdbctx->de_reply = DBG_REPLY_LATER;
540
541 switch (de->dwDebugEventCode)
542 {
543 case CREATE_PROCESS_DEBUG_EVENT:
544 gdbctx->process = dbg_add_process(&be_process_gdbproxy_io, de->dwProcessId,
545 de->u.CreateProcessInfo.hProcess);
546 if (!gdbctx->process)
547 return TRUE;
548
549 size = ARRAY_SIZE(u.buffer);
550 QueryFullProcessImageNameW( gdbctx->process->handle, 0, u.buffer, &size );
551 dbg_set_process_name(gdbctx->process, u.buffer);
552
553 fprintf(stderr, "%04lx:%04lx: create process '%ls'/%p @%p (%lu<%lu>)\n",
554 de->dwProcessId, de->dwThreadId,
555 u.buffer,
556 de->u.CreateProcessInfo.lpImageName,
557 de->u.CreateProcessInfo.lpStartAddress,
558 de->u.CreateProcessInfo.dwDebugInfoFileOffset,
559 de->u.CreateProcessInfo.nDebugInfoSize);
560
561 /* de->u.CreateProcessInfo.lpStartAddress; */
562 if (!dbg_init(gdbctx->process->handle, u.buffer, TRUE))
563 ERR("Couldn't initiate DbgHelp\n");
564
565 fprintf(stderr, "%04lx:%04lx: create thread I @%p\n", de->dwProcessId,
566 de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
567
568 dbg_load_module(gdbctx->process->handle, de->u.CreateProcessInfo.hFile, u.buffer,
569 (DWORD_PTR)de->u.CreateProcessInfo.lpBaseOfImage, 0);
570
571 dbg_add_thread(gdbctx->process, de->dwThreadId,
572 de->u.CreateProcessInfo.hThread,
573 de->u.CreateProcessInfo.lpThreadLocalBase);
574 return TRUE;
575
576 case LOAD_DLL_DEBUG_EVENT:
577 fetch_module_name( de->u.LoadDll.lpImageName, de->u.LoadDll.lpBaseOfDll,
578 u.buffer, ARRAY_SIZE(u.buffer) );
579 fprintf(stderr, "%04lx:%04lx: loads DLL %ls @%p (%lu<%lu>)\n",
580 de->dwProcessId, de->dwThreadId,
581 u.buffer,
582 de->u.LoadDll.lpBaseOfDll,
583 de->u.LoadDll.dwDebugInfoFileOffset,
584 de->u.LoadDll.nDebugInfoSize);
585 dbg_load_module(gdbctx->process->handle, de->u.LoadDll.hFile, u.buffer,
586 (DWORD_PTR)de->u.LoadDll.lpBaseOfDll, 0);
587 if (stop_on_dll_load_unload)
588 break;
589 return TRUE;
590
591 case UNLOAD_DLL_DEBUG_EVENT:
592 fprintf(stderr, "%08lx:%08lx: unload DLL @%p\n",
593 de->dwProcessId, de->dwThreadId, de->u.UnloadDll.lpBaseOfDll);
594 SymUnloadModule(gdbctx->process->handle,
595 (DWORD_PTR)de->u.UnloadDll.lpBaseOfDll);
596 if (stop_on_dll_load_unload)
597 break;
598 return TRUE;
599
600 case EXCEPTION_DEBUG_EVENT:
601 TRACE("%08lx:%08lx: exception code=0x%08lx\n", de->dwProcessId,
602 de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode);
603
604 if (handle_exception(gdbctx, &de->u.Exception))
605 return TRUE;
606 break;
607
608 case CREATE_THREAD_DEBUG_EVENT:
609 fprintf(stderr, "%08lx:%08lx: create thread D @%p\n", de->dwProcessId,
610 de->dwThreadId, de->u.CreateThread.lpStartAddress);
611
612 dbg_add_thread(gdbctx->process,
613 de->dwThreadId,
614 de->u.CreateThread.hThread,
615 de->u.CreateThread.lpThreadLocalBase);
616 return TRUE;
617
618 case EXIT_THREAD_DEBUG_EVENT:
619 fprintf(stderr, "%08lx:%08lx: exit thread (%lu)\n",
620 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
621 if ((thread = dbg_get_thread(gdbctx->process, de->dwThreadId)))
622 dbg_del_thread(thread);
623 return TRUE;
624
625 case EXIT_PROCESS_DEBUG_EVENT:
626 fprintf(stderr, "%08lx:%08lx: exit process (%lu)\n",
627 de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);
628
629 dbg_del_process(gdbctx->process);
630 gdbctx->process = NULL;
631 return FALSE;
632
633 case OUTPUT_DEBUG_STRING_EVENT:
634 memory_get_string(gdbctx->process,
635 de->u.DebugString.lpDebugStringData, TRUE,
636 de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
637 fprintf(stderr, "%08lx:%08lx: output debug string (%s)\n",
638 de->dwProcessId, de->dwThreadId, debugstr_a(u.bufferA));
639 return TRUE;
640
641 case RIP_EVENT:
642 fprintf(stderr, "%08lx:%08lx: rip error=%lu type=%lu\n", de->dwProcessId,
643 de->dwThreadId, de->u.RipInfo.dwError, de->u.RipInfo.dwType);
644 return TRUE;
645
646 default:
647 FIXME("%08lx:%08lx: unknown event (%lu)\n",
648 de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
649 }
650
651 LIST_FOR_EACH_ENTRY(thread, &gdbctx->process->threads, struct dbg_thread, entry)
652 {
653 if (!thread->suspended) SuspendThread(thread->handle);
654 thread->suspended = TRUE;
655 }
656
657 return FALSE;
658 }
659
660 static void handle_step_or_continue(struct gdb_context* gdbctx, int tid, BOOL step, int sig)
661 {
662 struct dbg_process *process = gdbctx->process;
663 struct dbg_thread *thread;
664
665 if (tid == 0) tid = gdbctx->de.dwThreadId;
666 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
667 {
668 if (tid != -1 && thread->tid != tid) continue;
669 if (!thread->suspended) continue;
670 thread->suspended = FALSE;
671
672 if (process->pid == gdbctx->de.dwProcessId && thread->tid == gdbctx->de.dwThreadId)
673 gdbctx->de_reply = (sig == -1 ? DBG_CONTINUE : DBG_EXCEPTION_NOT_HANDLED);
674
675 dbg_thread_set_single_step(thread, step);
676 ResumeThread(thread->handle);
677 }
678 }
679
680 static BOOL check_for_interrupt(struct gdb_context* gdbctx)
681 {
682 char pkt;
683 fd_set read_fds;
684 struct timeval tv = { 0, 0 };
685
686 FD_ZERO( &read_fds );
687 FD_SET( gdbctx->sock, &read_fds );
688
689 if (select( 0, &read_fds, NULL, NULL, &tv ) > 0)
690 {
691 if (recv(gdbctx->sock, &pkt, 1, 0) != 1) {
692 ERR("read failed\n");
693 return FALSE;
694 }
695 if (pkt != '\003') {
696 ERR("Unexpected break packet %#02x\n", pkt);
697 return FALSE;
698 }
699 return TRUE;
700 }
701 return FALSE;
702 }
703
704 static void wait_for_debuggee(struct gdb_context* gdbctx)
705 {
706 if (gdbctx->de.dwDebugEventCode)
707 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, gdbctx->de_reply);
708
709 for (;;)
710 {
711 if (!WaitForDebugEvent(&gdbctx->de, 10))
712 {
713 if (GetLastError() == ERROR_SEM_TIMEOUT)
714 {
715 if (check_for_interrupt(gdbctx)) {
716 if (!DebugBreakProcess(gdbctx->process->handle)) {
717 ERR("Failed to break into debuggee\n");
718 break;
719 }
720 WaitForDebugEvent(&gdbctx->de, INFINITE);
721 } else {
722 continue;
723 }
724 } else {
725 break;
726 }
727 }
728 if (!handle_debug_event(gdbctx, TRUE))
729 break;
730 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
731 }
732 }
733
734 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
735 {
736 handle_step_or_continue(gdbctx, -1, FALSE, -1);
737
738 if (gdbctx->de.dwDebugEventCode)
739 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
740
741 if (!kill)
742 DebugActiveProcessStop(gdbctx->process->pid);
743 dbg_del_process(gdbctx->process);
744 gdbctx->process = NULL;
745 }
746
747 static void get_process_info(struct gdb_context* gdbctx, char* buffer, size_t len)
748 {
749 DWORD status;
750
751 if (!GetExitCodeProcess(gdbctx->process->handle, &status))
752 {
753 strcpy(buffer, "Unknown process");
754 return;
755 }
756 if (status == STILL_ACTIVE)
757 {
758 strcpy(buffer, "Running");
759 }
760 else
761 snprintf(buffer, len, "Terminated (%lu)", status);
762
763 switch (GetPriorityClass(gdbctx->process->handle))
764 {
765 case 0: break;
766 case ABOVE_NORMAL_PRIORITY_CLASS: strcat(buffer, ", above normal priority"); break;
767 case BELOW_NORMAL_PRIORITY_CLASS: strcat(buffer, ", below normal priority"); break;
768 case HIGH_PRIORITY_CLASS: strcat(buffer, ", high priority"); break;
769 case IDLE_PRIORITY_CLASS: strcat(buffer, ", idle priority"); break;
770 case NORMAL_PRIORITY_CLASS: strcat(buffer, ", normal priority"); break;
771 case REALTIME_PRIORITY_CLASS: strcat(buffer, ", realtime priority"); break;
772 }
773 strcat(buffer, "\n");
774 }
775
776 static void get_thread_info(struct gdb_context* gdbctx, unsigned tid,
777 char* buffer, size_t len)
778 {
779 struct dbg_thread* thd;
780 DWORD status;
781 int prio;
782
783 /* FIXME: use the size of buffer */
784 thd = dbg_get_thread(gdbctx->process, tid);
785 if (thd == NULL)
786 {
787 strcpy(buffer, "No information");
788 return;
789 }
790 if (GetExitCodeThread(thd->handle, &status))
791 {
792 if (status == STILL_ACTIVE)
793 {
794 /* FIXME: this is a bit brutal... some nicer way shall be found */
795 switch (status = SuspendThread(thd->handle))
796 {
797 case -1: break;
798 case 0: strcpy(buffer, "Running"); break;
799 default: snprintf(buffer, len, "Suspended (%lu)", status - 1);
800 }
801 ResumeThread(thd->handle);
802 }
803 else
804 snprintf(buffer, len, "Terminated (exit code = %lu)", status);
805 }
806 else
807 {
808 strcpy(buffer, "Unknown threadID");
809 }
810 switch (prio = GetThreadPriority(thd->handle))
811 {
812 case THREAD_PRIORITY_ERROR_RETURN: break;
813 case THREAD_PRIORITY_ABOVE_NORMAL: strcat(buffer, ", priority +1 above normal"); break;
814 case THREAD_PRIORITY_BELOW_NORMAL: strcat(buffer, ", priority -1 below normal"); break;
815 case THREAD_PRIORITY_HIGHEST: strcat(buffer, ", priority +2 above normal"); break;
816 case THREAD_PRIORITY_LOWEST: strcat(buffer, ", priority -2 below normal"); break;
817 case THREAD_PRIORITY_IDLE: strcat(buffer, ", priority idle"); break;
818 case THREAD_PRIORITY_NORMAL: strcat(buffer, ", priority normal"); break;
819 case THREAD_PRIORITY_TIME_CRITICAL: strcat(buffer, ", priority time-critical"); break;
820 default: snprintf(buffer + strlen(buffer), len - strlen(buffer), ", priority = %d", prio);
821 }
822 assert(strlen(buffer) < len);
823 }
824
825 /* =============================================== *
826 * P A C K E T U T I L S *
827 * =============================================== *
828 */
829
830 static int addr_width(struct gdb_context* gdbctx)
831 {
832 int sz = (gdbctx && gdbctx->process && gdbctx->process->be_cpu) ?
833 gdbctx->process->be_cpu->pointer_size : (int)sizeof(void*);
834 return sz * 2;
835 }
836
837 enum packet_return {packet_error = 0x00, packet_ok = 0x01, packet_done = 0x02,
838 packet_send_buffer = 0x03, packet_last_f = 0x80};
839
840 static void packet_reply_hex_to(struct gdb_context* gdbctx, const void* src, int len)
841 {
842 reply_buffer_append_hex(&gdbctx->out_buf, src, len);
843 }
844
845 static inline void packet_reply_hex_to_str(struct gdb_context* gdbctx, const char* src)
846 {
847 packet_reply_hex_to(gdbctx, src, strlen(src));
848 }
849
850 static void packet_reply_val(struct gdb_context* gdbctx, ULONG_PTR val, int len)
851 {
852 reply_buffer_append_uinthex(&gdbctx->out_buf, val, len);
853 }
854
855 static const unsigned char gdb_special_chars_lookup_table[4] = {
856 /* The characters should be indexed by its value modulo table length. */
857
858 0x24, /* $: 001001|00 */
859 0x7D, /* }: 011111|01 */
860 0x2A, /* *: 001010|10 */
861 0x23 /* #: 001000|11 */
862 };
863
864 static inline BOOL is_gdb_special_char(unsigned char val)
865 {
866 /* A note on the GDB special character scanning code:
867 *
868 * We cannot use strcspn() since we plan to transmit binary data in
869 * packet reply, which can contain NULL (0x00) bytes. We also don't want
870 * to slow down memory dump transfers. Therefore, we use a tiny lookup
871 * table that contains all the four special characters to speed up scanning.
872 */
873 const size_t length = ARRAY_SIZE(gdb_special_chars_lookup_table);
874 return gdb_special_chars_lookup_table[val % length] == val;
875 }
876
877 static void packet_reply_add_data(struct gdb_context* gdbctx, const void* data, size_t len)
878 {
879 const unsigned char *ptr = data, *end = ptr + len, *curr;
880 unsigned char esc_seq[2];
881
882 while (ptr != end)
883 {
884 curr = ptr;
885
886 while (ptr != end && !is_gdb_special_char(*ptr))
887 ptr++;
888
889 reply_buffer_append(&gdbctx->out_buf, curr, ptr - curr);
890 if (ptr == end) break;
891
892 esc_seq[0] = 0x7D;
893 esc_seq[1] = 0x20 ^ *ptr++;
894 reply_buffer_append(&gdbctx->out_buf, esc_seq, 2);
895 }
896 }
897
898 static inline void packet_reply_add(struct gdb_context* gdbctx, const char* str)
899 {
900 packet_reply_add_data(gdbctx, str, strlen(str));
901 }
902
903 static void packet_reply_open(struct gdb_context* gdbctx)
904 {
905 assert(gdbctx->out_curr_packet == -1);
906 reply_buffer_append(&gdbctx->out_buf, "$", 1);
907 gdbctx->out_curr_packet = gdbctx->out_buf.len;
908 }
909
910 static void packet_reply_close(struct gdb_context* gdbctx)
911 {
912 unsigned char cksum;
913 int plen;
914
915 plen = gdbctx->out_buf.len - gdbctx->out_curr_packet;
916 reply_buffer_append(&gdbctx->out_buf, "#", 1);
917 cksum = checksum(gdbctx->out_buf.base + gdbctx->out_curr_packet, plen);
918 packet_reply_hex_to(gdbctx, &cksum, 1);
919 gdbctx->out_curr_packet = -1;
920 }
921
922 static enum packet_return packet_reply(struct gdb_context* gdbctx, const char* packet)
923 {
924 packet_reply_open(gdbctx);
925
926 packet_reply_add(gdbctx, packet);
927
928 packet_reply_close(gdbctx);
929
930 return packet_done;
931 }
932
933 static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int error)
934 {
935 packet_reply_open(gdbctx);
936
937 packet_reply_add(gdbctx, "E");
938 packet_reply_val(gdbctx, error, 1);
939
940 packet_reply_close(gdbctx);
941
942 return packet_done;
943 }
944
945 static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_ctx_t* ctx, unsigned idx)
946 {
947 const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map;
948 packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, ctx, idx), cpu_register_map[idx].length);
949 }
950
951 static void packet_reply_xfer(struct gdb_context* gdbctx, size_t off, size_t len, BOOL* more_p)
952 {
953 BOOL more;
954 size_t data_len, trunc_len;
955
956 packet_reply_open(gdbctx);
957 data_len = gdbctx->qxfer_buffer.len;
958
959 /* check if off + len would overflow */
960 more = off < data_len && off + len < data_len;
961 if (more)
962 packet_reply_add(gdbctx, "m");
963 else
964 packet_reply_add(gdbctx, "l");
965
966 if (off < data_len)
967 {
968 trunc_len = min(len, data_len - off);
969 packet_reply_add_data(gdbctx, gdbctx->qxfer_buffer.base + off, trunc_len);
970 }
971
972 packet_reply_close(gdbctx);
973
974 *more_p = more;
975 }
976
977 /* =============================================== *
978 * P A C K E T H A N D L E R S *
979 * =============================================== *
980 */
981
982 static void packet_reply_status_xpoints(struct gdb_context* gdbctx, struct dbg_thread *thread,
983 dbg_ctx_t *ctx)
984 {
985 struct dbg_process *process = thread->process;
986 struct backend_cpu *cpu = process->be_cpu;
987 struct gdb_xpoint *x;
988
989 LIST_FOR_EACH_ENTRY(x, &gdbctx->xpoint_list, struct gdb_xpoint, entry)
990 {
991 if (x->pid != process->pid || x->tid != thread->tid)
992 continue;
993 if (!cpu->is_watchpoint_set(ctx, x->value))
994 continue;
995 if (x->type == be_xpoint_watch_write)
996 {
997 packet_reply_add(gdbctx, "watch:");
998 packet_reply_val(gdbctx, (ULONG_PTR)x->addr, sizeof(x->addr));
999 packet_reply_add(gdbctx, ";");
1000 }
1001 if (x->type == be_xpoint_watch_read)
1002 {
1003 packet_reply_add(gdbctx, "rwatch:");
1004 packet_reply_val(gdbctx, (ULONG_PTR)x->addr, sizeof(x->addr));
1005 packet_reply_add(gdbctx, ";");
1006 }
1007 }
1008 }
1009
1010 static void packet_reply_begin_stop_reply(struct gdb_context* gdbctx, unsigned char signal)
1011 {
1012 packet_reply_add(gdbctx, "T");
1013 packet_reply_val(gdbctx, signal, 1);
1014
1015 /* We should always report the current thread ID for all stop replies.
1016 * Otherwise, GDB complains with the following message:
1017 *
1018 * Warning: multi-threaded target stopped without sending a thread-id,
1019 * using first non-exited thread
1020 */
1021 packet_reply_add(gdbctx, "thread:");
1022 packet_reply_val(gdbctx, gdbctx->de.dwThreadId, 4);
1023 packet_reply_add(gdbctx, ";");
1024 }
1025
1026 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
1027 {
1028 struct dbg_process *process = gdbctx->process;
1029 struct dbg_thread *thread;
1030 struct backend_cpu *backend;
1031 dbg_ctx_t ctx;
1032 size_t i;
1033
1034 switch (gdbctx->de.dwDebugEventCode)
1035 {
1036 default:
1037 if (!process) return packet_error;
1038 if (!(backend = process->be_cpu)) return packet_error;
1039 if (!(thread = dbg_get_thread(process, gdbctx->de.dwThreadId)) ||
1040 !backend->get_context(thread->handle, &ctx))
1041 return packet_error;
1042
1043 packet_reply_open(gdbctx);
1044 packet_reply_begin_stop_reply(gdbctx, signal_from_debug_event(&gdbctx->de));
1045 packet_reply_status_xpoints(gdbctx, thread, &ctx);
1046
1047 for (i = 0; i < backend->gdb_num_regs; i++)
1048 {
1049 packet_reply_val(gdbctx, i, 1);
1050 packet_reply_add(gdbctx, ":");
1051 packet_reply_register_hex_to(gdbctx, &ctx, i);
1052 packet_reply_add(gdbctx, ";");
1053 }
1054
1055 packet_reply_close(gdbctx);
1056 return packet_done;
1057
1058 case EXIT_PROCESS_DEBUG_EVENT:
1059 packet_reply_open(gdbctx);
1060 packet_reply_add(gdbctx, "W");
1061 packet_reply_val(gdbctx, gdbctx->de.u.ExitProcess.dwExitCode, 4);
1062 packet_reply_close(gdbctx);
1063 return packet_done | packet_last_f;
1064
1065 case LOAD_DLL_DEBUG_EVENT:
1066 case UNLOAD_DLL_DEBUG_EVENT:
1067 packet_reply_open(gdbctx);
1068 packet_reply_begin_stop_reply(gdbctx, HOST_SIGTRAP);
1069 packet_reply_add(gdbctx, "library:;");
1070 packet_reply_close(gdbctx);
1071 return packet_done;
1072 }
1073 }
1074
1075 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
1076 {
1077 assert(gdbctx->in_packet_len == 0);
1078 return packet_reply_status(gdbctx);
1079 }
1080
1081 static enum packet_return packet_continue(struct gdb_context* gdbctx)
1082 {
1083 void *addr;
1084
1085 if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
1086 FIXME("Continue at address %p not supported\n", addr);
1087
1088 handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, -1);
1089
1090 wait_for_debuggee(gdbctx);
1091 return packet_reply_status(gdbctx);
1092 }
1093
1094 static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
1095 {
1096 char *buf = gdbctx->in_packet, *end = gdbctx->in_packet + gdbctx->in_packet_len;
1097
1098 if (gdbctx->in_packet[4] == '?')
1099 {
1100 packet_reply_open(gdbctx);
1101 packet_reply_add(gdbctx, "vCont");
1102 packet_reply_add(gdbctx, ";c");
1103 packet_reply_add(gdbctx, ";C");
1104 packet_reply_add(gdbctx, ";s");
1105 packet_reply_add(gdbctx, ";S");
1106 packet_reply_close(gdbctx);
1107 return packet_done;
1108 }
1109
1110 while (buf < end && (buf = memchr(buf + 1, ';', end - buf - 1)))
1111 {
1112 int tid = -1, sig = -1;
1113 int action, n;
1114
1115 switch ((action = buf[1]))
1116 {
1117 default:
1118 return packet_error;
1119 case 'c':
1120 case 's':
1121 buf += 2;
1122 break;
1123 case 'C':
1124 case 'S':
1125 if (sscanf(buf, ";%*c%2x", &sig) <= 0 ||
1126 sig != signal_from_debug_event(&gdbctx->de))
1127 return packet_error;
1128 buf += 4;
1129 break;
1130 }
1131
1132 if (buf > end)
1133 return packet_error;
1134 if (buf < end && *buf == ':' && (n = sscanf(buf, ":%x", &tid)) <= 0)
1135 return packet_error;
1136
1137 handle_step_or_continue(gdbctx, tid, action == 's' || action == 'S', sig);
1138 }
1139
1140 wait_for_debuggee(gdbctx);
1141 return packet_reply_status(gdbctx);
1142 }
1143
1144 static enum packet_return packet_verbose(struct gdb_context* gdbctx)
1145 {
1146 if (gdbctx->in_packet_len >= 4 && !memcmp(gdbctx->in_packet, "Cont", 4))
1147 {
1148 return packet_verbose_cont(gdbctx);
1149 }
1150
1151 if (gdbctx->in_packet_len == 14 && !memcmp(gdbctx->in_packet, "MustReplyEmpty", 14))
1152 return packet_reply(gdbctx, "");
1153
1154 return packet_error;
1155 }
1156
1157 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
1158 {
1159 void *addr;
1160 int sig, n;
1161
1162 if ((n = sscanf(gdbctx->in_packet, "%x;%p", &sig, &addr)) == 2)
1163 FIXME("Continue at address %p not supported\n", addr);
1164 if (n < 1) return packet_error;
1165
1166 if (sig != signal_from_debug_event(&gdbctx->de))
1167 {
1168 ERR("Changing signals is not supported.\n");
1169 return packet_error;
1170 }
1171
1172 handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, sig);
1173
1174 wait_for_debuggee(gdbctx);
1175 return packet_reply_status(gdbctx);
1176 }
1177
1178 static enum packet_return packet_delete_breakpoint(struct gdb_context* gdbctx)
1179 {
1180 struct dbg_process *process = gdbctx->process;
1181 struct dbg_thread *thread;
1182 struct backend_cpu *cpu;
1183 struct gdb_xpoint *x;
1184 dbg_ctx_t ctx;
1185 char type;
1186 void *addr;
1187 int size;
1188
1189 if (!process) return packet_error;
1190 if (!(cpu = process->be_cpu)) return packet_error;
1191
1192 if (sscanf(gdbctx->in_packet, "%c,%p,%x", &type, &addr, &size) < 3)
1193 return packet_error;
1194
1195 if (type == '0')
1196 return packet_error;
1197
1198 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1199 {
1200 if (!cpu->get_context(thread->handle, &ctx))
1201 continue;
1202 if ((type == '1') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_exec, addr, size)))
1203 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1204 if ((type == '2' || type == '4') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_read, addr, size)))
1205 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1206 if ((type == '3' || type == '4') && (x = gdb_find_xpoint(gdbctx, thread, be_xpoint_watch_write, addr, size)))
1207 gdbctx_delete_xpoint(gdbctx, thread, &ctx, x);
1208 cpu->set_context(thread->handle, &ctx);
1209 }
1210
1211 while ((type == '1') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_exec, addr, size)))
1212 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1213 while ((type == '2' || type == '4') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_read, addr, size)))
1214 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1215 while ((type == '3' || type == '4') && (x = gdb_find_xpoint(gdbctx, NULL, be_xpoint_watch_write, addr, size)))
1216 gdbctx_delete_xpoint(gdbctx, NULL, NULL, x);
1217
1218 return packet_ok;
1219 }
1220
1221 static enum packet_return packet_insert_breakpoint(struct gdb_context* gdbctx)
1222 {
1223 struct dbg_process *process = gdbctx->process;
1224 struct dbg_thread *thread;
1225 struct backend_cpu *cpu;
1226 dbg_ctx_t ctx;
1227 char type;
1228 void *addr;
1229 int size;
1230
1231 if (!process) return packet_error;
1232 if (!(cpu = process->be_cpu)) return packet_error;
1233
1234 if (memchr(gdbctx->in_packet, ';', gdbctx->in_packet_len))
1235 {
1236 FIXME("breakpoint commands not supported\n");
1237 return packet_error;
1238 }
1239
1240 if (sscanf(gdbctx->in_packet, "%c,%p,%x", &type, &addr, &size) < 3)
1241 return packet_error;
1242
1243 if (type == '0')
1244 return packet_error;
1245
1246 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1247 {
1248 if (!cpu->get_context(thread->handle, &ctx))
1249 continue;
1250 if (type == '1')
1251 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_exec, addr, size);
1252 if (type == '2' || type == '4')
1253 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_read, addr, size);
1254 if (type == '3' || type == '4')
1255 gdbctx_insert_xpoint(gdbctx, thread, &ctx, be_xpoint_watch_write, addr, size);
1256 cpu->set_context(thread->handle, &ctx);
1257 }
1258
1259 return packet_ok;
1260 }
1261
1262 static enum packet_return packet_detach(struct gdb_context* gdbctx)
1263 {
1264 detach_debuggee(gdbctx, FALSE);
1265 return packet_ok | packet_last_f;
1266 }
1267
1268 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
1269 {
1270 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1271 struct backend_cpu *backend;
1272 dbg_ctx_t ctx;
1273 size_t i;
1274
1275 if (!thread) return packet_error;
1276 if (!thread->process) return packet_error;
1277 if (!(backend = thread->process->be_cpu)) return packet_error;
1278
1279 if (!backend->get_context(thread->handle, &ctx))
1280 return packet_error;
1281
1282 packet_reply_open(gdbctx);
1283 for (i = 0; i < backend->gdb_num_regs; i++)
1284 packet_reply_register_hex_to(gdbctx, &ctx, i);
1285
1286 packet_reply_close(gdbctx);
1287 return packet_done;
1288 }
1289
1290 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
1291 {
1292 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1293 struct backend_cpu *backend;
1294 dbg_ctx_t ctx;
1295 const char *ptr;
1296 size_t i;
1297
1298 if (!thread) return packet_error;
1299 if (!thread->process) return packet_error;
1300 if (!(backend = thread->process->be_cpu)) return packet_error;
1301
1302 if (!backend->get_context(thread->handle, &ctx))
1303 return packet_error;
1304
1305 if (gdbctx->in_packet_len < backend->gdb_num_regs * 2)
1306 return packet_error;
1307
1308 ptr = gdbctx->in_packet;
1309 for (i = 0; i < backend->gdb_num_regs; i++)
1310 cpu_register_hex_from(gdbctx, &ctx, i, &ptr);
1311
1312 if (!backend->set_context(thread->handle, &ctx))
1313 {
1314 ERR("Failed to set context for tid %04lx, error %lu\n", thread->tid, GetLastError());
1315 return packet_error;
1316 }
1317
1318 return packet_ok;
1319 }
1320
1321 static enum packet_return packet_kill(struct gdb_context* gdbctx)
1322 {
1323 detach_debuggee(gdbctx, TRUE);
1324 return packet_ok | packet_last_f;
1325 }
1326
1327 static enum packet_return packet_thread(struct gdb_context* gdbctx)
1328 {
1329 switch (gdbctx->in_packet[0])
1330 {
1331 case 'c':
1332 if (sscanf(gdbctx->in_packet, "c%x", &gdbctx->exec_tid) == 1)
1333 return packet_ok;
1334 return packet_error;
1335 case 'g':
1336 if (sscanf(gdbctx->in_packet, "g%x", &gdbctx->other_tid) == 1)
1337 return packet_ok;
1338 return packet_error;
1339 default:
1340 FIXME("Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
1341 return packet_error;
1342 }
1343 }
1344
1345 static enum packet_return packet_read_memory(struct gdb_context* gdbctx)
1346 {
1347 char *addr;
1348 unsigned int len, blk_len, nread;
1349 char buffer[32];
1350 SIZE_T r = 0;
1351
1352 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2) return packet_error;
1353 if (len <= 0) return packet_error;
1354 TRACE("Read %u bytes at %p\n", len, addr);
1355 for (nread = 0; nread < len; nread += r, addr += r)
1356 {
1357 blk_len = min(sizeof(buffer), len - nread);
1358 if (!gdbctx->process->process_io->read(gdbctx->process->handle, addr,
1359 buffer, blk_len, &r) || r == 0)
1360 {
1361 /* fail at first address, return error */
1362 if (nread == 0) return packet_reply_error(gdbctx, HOST_EFAULT );
1363 /* something has already been read, return partial information */
1364 break;
1365 }
1366 if (nread == 0) packet_reply_open(gdbctx);
1367 packet_reply_hex_to(gdbctx, buffer, r);
1368 }
1369 packet_reply_close(gdbctx);
1370 return packet_done;
1371 }
1372
1373 static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
1374 {
1375 char* addr;
1376 unsigned int len, blk_len;
1377 char* ptr;
1378 char buffer[32];
1379 SIZE_T w;
1380
1381 ptr = memchr(gdbctx->in_packet, ':', gdbctx->in_packet_len);
1382 if (ptr == NULL)
1383 {
1384 ERR("Cannot find ':' in %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
1385 return packet_error;
1386 }
1387 *ptr++ = '\0';
1388
1389 if (sscanf(gdbctx->in_packet, "%p,%x", &addr, &len) != 2)
1390 {
1391 ERR("Failed to parse %s\n", debugstr_a(gdbctx->in_packet));
1392 return packet_error;
1393 }
1394 if (ptr - gdbctx->in_packet + len * 2 != gdbctx->in_packet_len)
1395 {
1396 ERR("Length %u does not match packet length %u\n",
1397 (int)(ptr - gdbctx->in_packet) + len * 2, gdbctx->in_packet_len);
1398 return packet_error;
1399 }
1400 TRACE("Write %u bytes at %p\n", len, addr);
1401 while (len > 0)
1402 {
1403 blk_len = min(sizeof(buffer), len);
1404 hex_from(buffer, ptr, blk_len);
1405 if (!gdbctx->process->process_io->write(gdbctx->process->handle, addr, buffer, blk_len, &w) ||
1406 w != blk_len)
1407 break;
1408 addr += blk_len;
1409 len -= blk_len;
1410 ptr += blk_len;
1411 }
1412 return packet_ok; /* FIXME: error while writing ? */
1413 }
1414
1415 static enum packet_return packet_read_register(struct gdb_context* gdbctx)
1416 {
1417 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1418 struct backend_cpu *backend;
1419 dbg_ctx_t ctx;
1420 size_t reg;
1421
1422 if (!thread) return packet_error;
1423 if (!thread->process) return packet_error;
1424 if (!(backend = thread->process->be_cpu)) return packet_error;
1425
1426 if (!backend->get_context(thread->handle, &ctx))
1427 return packet_error;
1428
1429 if (sscanf(gdbctx->in_packet, "%Ix", &reg) != 1)
1430 return packet_error;
1431 if (reg >= backend->gdb_num_regs)
1432 {
1433 WARN("Unhandled register %Iu\n", reg);
1434 return packet_error;
1435 }
1436
1437 TRACE("%Iu => %I64x\n", reg, cpu_register(gdbctx, &ctx, reg));
1438
1439 packet_reply_open(gdbctx);
1440 packet_reply_register_hex_to(gdbctx, &ctx, reg);
1441 packet_reply_close(gdbctx);
1442 return packet_done;
1443 }
1444
1445 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
1446 {
1447 struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
1448 struct backend_cpu *backend;
1449 dbg_ctx_t ctx;
1450 size_t reg;
1451 char *ptr;
1452
1453 if (!thread) return packet_error;
1454 if (!thread->process) return packet_error;
1455 if (!(backend = thread->process->be_cpu)) return packet_error;
1456
1457 if (!backend->get_context(thread->handle, &ctx))
1458 return packet_error;
1459
1460 if (!(ptr = strchr(gdbctx->in_packet, '=')))
1461 return packet_error;
1462 *ptr++ = '\0';
1463
1464 if (sscanf(gdbctx->in_packet, "%Ix", &reg) != 1)
1465 return packet_error;
1466 if (reg >= backend->gdb_num_regs)
1467 {
1468 /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
1469 * it wouldn't matter too much, and it fakes our support for all regs
1470 */
1471 WARN("Unhandled register %Iu\n", reg);
1472 return packet_ok;
1473 }
1474
1475 TRACE("%Iu <= %s\n", reg, debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet))));
1476
1477 cpu_register_hex_from(gdbctx, &ctx, reg, (const char**)&ptr);
1478 if (!backend->set_context(thread->handle, &ctx))
1479 {
1480 ERR("Failed to set context for tid %04lx, error %lu\n", thread->tid, GetLastError());
1481 return packet_error;
1482 }
1483
1484 return packet_ok;
1485 }
1486
1487 static void packet_query_monitor_wnd_helper(struct gdb_context* gdbctx, HWND hWnd, int indent)
1488 {
1489 char buffer[128];
1490 char clsName[128];
1491 char wndName[128];
1492 HWND child;
1493
1494 do {
1495 if (!GetClassNameA(hWnd, clsName, sizeof(clsName)))
1496 strcpy(clsName, "-- Unknown --");
1497 if (!GetWindowTextA(hWnd, wndName, sizeof(wndName)))
1498 strcpy(wndName, "-- Empty --");
1499
1500 packet_reply_open(gdbctx);
1501 packet_reply_add(gdbctx, "O");
1502 snprintf(buffer, sizeof(buffer),
1503 "%*s%04Ix%*s%-17.17s %08lx %0*Ix %.14s\n",
1504 indent, "", (ULONG_PTR)hWnd, 13 - indent, "",
1505 clsName, GetWindowLongW(hWnd, GWL_STYLE),
1506 addr_width(gdbctx), (ULONG_PTR)GetWindowLongPtrW(hWnd, GWLP_WNDPROC),
1507 wndName);
1508 packet_reply_hex_to_str(gdbctx, buffer);
1509 packet_reply_close(gdbctx);
1510
1511 if ((child = GetWindow(hWnd, GW_CHILD)) != 0)
1512 packet_query_monitor_wnd_helper(gdbctx, child, indent + 1);
1513 } while ((hWnd = GetWindow(hWnd, GW_HWNDNEXT)) != 0);
1514 }
1515
1516 static void packet_query_monitor_wnd(struct gdb_context* gdbctx, int len, const char* str)
1517 {
1518 char buffer[128];
1519
1520 /* we do the output in several 'O' packets, with the last one being just OK for
1521 * marking the end of the output */
1522 packet_reply_open(gdbctx);
1523 packet_reply_add(gdbctx, "O");
1524 snprintf(buffer, sizeof(buffer),
1525 "%-16.16s %-17.17s %-8.8s %s\n",
1526 "hwnd", "Class Name", " Style", " WndProc Text");
1527 packet_reply_hex_to_str(gdbctx, buffer);
1528 packet_reply_close(gdbctx);
1529
1530 /* FIXME: could also add a pmt to this command in str... */
1531 packet_query_monitor_wnd_helper(gdbctx, GetDesktopWindow(), 0);
1532 packet_reply(gdbctx, "OK");
1533 }
1534
1535 static void packet_query_monitor_process(struct gdb_context* gdbctx, int len, const char* str)
1536 {
1537 HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1538 char buffer[31+MAX_PATH];
1539 char deco;
1540 PROCESSENTRY32 entry;
1541 BOOL ok;
1542
1543 if (snap == INVALID_HANDLE_VALUE)
1544 return;
1545
1546 entry.dwSize = sizeof(entry);
1547 ok = Process32First(snap, &entry);
1548
1549 /* we do the output in several 'O' packets, with the last one being just OK for
1550 * marking the end of the output */
1551
1552 packet_reply_open(gdbctx);
1553 packet_reply_add(gdbctx, "O");
1554 snprintf(buffer, sizeof(buffer),
1555 " %-8.8s %-8.8s %-8.8s %s\n",
1556 "pid", "threads", "parent", "executable");
1557 packet_reply_hex_to_str(gdbctx, buffer);
1558 packet_reply_close(gdbctx);
1559
1560 while (ok)
1561 {
1562 deco = ' ';
1563 if (entry.th32ProcessID == gdbctx->process->pid) deco = '>';
1564 packet_reply_open(gdbctx);
1565 packet_reply_add(gdbctx, "O");
1566 snprintf(buffer, sizeof(buffer),
1567 "%c%08lx %-8ld %08lx '%s'\n",
1568 deco, entry.th32ProcessID, entry.cntThreads,
1569 entry.th32ParentProcessID, entry.szExeFile);
1570 packet_reply_hex_to_str(gdbctx, buffer);
1571 packet_reply_close(gdbctx);
1572 ok = Process32Next(snap, &entry);
1573 }
1574 CloseHandle(snap);
1575 packet_reply(gdbctx, "OK");
1576 }
1577
1578 static void packet_query_monitor_mem(struct gdb_context* gdbctx, int len, const char* str)
1579 {
1580 MEMORY_BASIC_INFORMATION mbi;
1581 char* addr = 0;
1582 const char* state;
1583 const char* type;
1584 char prot[3+1];
1585 char buffer[128];
1586
1587 /* we do the output in several 'O' packets, with the last one being just OK for
1588 * marking the end of the output */
1589 packet_reply_open(gdbctx);
1590 packet_reply_add(gdbctx, "O");
1591 packet_reply_hex_to_str(gdbctx, "Address Size State Type RWX\n");
1592 packet_reply_close(gdbctx);
1593
1594 while (VirtualQueryEx(gdbctx->process->handle, addr, &mbi, sizeof(mbi)) >= sizeof(mbi))
1595 {
1596 switch (mbi.State)
1597 {
1598 case MEM_COMMIT: state = "commit "; break;
1599 case MEM_FREE: state = "free "; break;
1600 case MEM_RESERVE: state = "reserve"; break;
1601 default: state = "??? "; break;
1602 }
1603 if (mbi.State != MEM_FREE)
1604 {
1605 switch (mbi.Type)
1606 {
1607 case MEM_IMAGE: type = "image "; break;
1608 case MEM_MAPPED: type = "mapped "; break;
1609 case MEM_PRIVATE: type = "private"; break;
1610 case 0: type = " "; break;
1611 default: type = "??? "; break;
1612 }
1613 memset(prot, ' ' , sizeof(prot)-1);
1614 prot[sizeof(prot)-1] = '\0';
1615 if (mbi.AllocationProtect & (PAGE_READONLY|PAGE_READWRITE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1616 prot[0] = 'R';
1617 if (mbi.AllocationProtect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE))
1618 prot[1] = 'W';
1619 if (mbi.AllocationProtect & (PAGE_WRITECOPY|PAGE_EXECUTE_WRITECOPY))
1620 prot[1] = 'C';
1621 if (mbi.AllocationProtect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY))
1622 prot[2] = 'X';
1623 }
1624 else
1625 {
1626 type = "";
1627 prot[0] = '\0';
1628 }
1629 packet_reply_open(gdbctx);
1630 snprintf(buffer, sizeof(buffer), "%0*Ix %0*Ix %s %s %s\n",
1631 addr_width(gdbctx), (DWORD_PTR)addr,
1632 addr_width(gdbctx), mbi.RegionSize, state, type, prot);
1633 packet_reply_add(gdbctx, "O");
1634 packet_reply_hex_to_str(gdbctx, buffer);
1635 packet_reply_close(gdbctx);
1636
1637 if (addr + mbi.RegionSize < addr) /* wrap around ? */
1638 break;
1639 addr += mbi.RegionSize;
1640 }
1641 packet_reply(gdbctx, "OK");
1642 }
1643
1644 struct query_detail
1645 {
1646 int with_arg;
1647 const char* name;
1648 size_t len;
1649 void (*handler)(struct gdb_context*, int, const char*);
1650 } query_details[] =
1651 {
1652 {0, "wnd", 3, packet_query_monitor_wnd},
1653 {0, "window", 6, packet_query_monitor_wnd},
1654 {0, "proc", 4, packet_query_monitor_process},
1655 {0, "process", 7, packet_query_monitor_process},
1656 {0, "mem", 3, packet_query_monitor_mem},
1657 {0, NULL, 0, NULL},
1658 };
1659
1660 static enum packet_return packet_query_remote_command(struct gdb_context* gdbctx,
1661 const char* hxcmd, size_t len)
1662 {
1663 char buffer[128];
1664 struct query_detail* qd;
1665
1666 assert((len & 1) == 0 && len < 2 * sizeof(buffer));
1667 len /= 2;
1668 hex_from(buffer, hxcmd, len);
1669
1670 for (qd = query_details; qd->name != NULL; qd++)
1671 {
1672 if (len < qd->len || strncmp(buffer, qd->name, qd->len) != 0) continue;
1673 if (!qd->with_arg && len != qd->len) continue;
1674
1675 (qd->handler)(gdbctx, len - qd->len, buffer + qd->len);
1676 return packet_done;
1677 }
1678 return packet_reply_error(gdbctx, HOST_EINVAL );
1679 }
1680
1681 static BOOL CALLBACK packet_query_libraries_cb(PCSTR mod_name, DWORD64 base, PVOID ctx)
1682 {
1683 struct gdb_context* gdbctx = ctx;
1684 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1685 MEMORY_BASIC_INFORMATION mbi;
1686 IMAGE_SECTION_HEADER *sec;
1687 IMAGE_DOS_HEADER *dos = NULL;
1688 IMAGE_NT_HEADERS *nth = NULL;
1689 IMAGEHLP_MODULE64 mod;
1690 SIZE_T size, i;
1691 BOOL is_wow64;
1692 char buffer[0x400];
1693
1694 mod.SizeOfStruct = sizeof(mod);
1695 SymGetModuleInfo64(gdbctx->process->handle, base, &mod);
1696
1697 reply_buffer_append_str(reply, "<library name=\"");
1698 if (strcmp(mod.LoadedImageName, "[vdso].so") == 0)
1699 reply_buffer_append_xmlstr(reply, "linux-vdso.so.1");
1700 else if (mod.LoadedImageName[0] == '/')
1701 reply_buffer_append_xmlstr(reply, mod.LoadedImageName);
1702 else
1703 {
1704 UNICODE_STRING nt_name;
1705 ANSI_STRING ansi_name;
1706 char *unix_path, *tmp;
1707
1708 RtlInitAnsiString(&ansi_name, mod.LoadedImageName);
1709 RtlAnsiStringToUnicodeString(&nt_name, &ansi_name, TRUE);
1710
1711 if ((unix_path = wine_get_unix_file_name(nt_name.Buffer)))
1712 {
1713 if (IsWow64Process(gdbctx->process->handle, &is_wow64) &&
1714 is_wow64 && (tmp = strstr(unix_path, "system32")))
1715 memcpy(tmp, "syswow64", 8);
1716 reply_buffer_append_xmlstr(reply, unix_path);
1717 }
1718 else
1719 reply_buffer_append_xmlstr(reply, mod.LoadedImageName);
1720
1721 HeapFree(GetProcessHeap(), 0, unix_path);
1722 RtlFreeUnicodeString(&nt_name);
1723 }
1724 reply_buffer_append_str(reply, "\">");
1725
1726 size = sizeof(buffer);
1727 if (VirtualQueryEx(gdbctx->process->handle, (void *)(UINT_PTR)mod.BaseOfImage, &mbi, sizeof(mbi)) >= sizeof(mbi) &&
1728 mbi.Type == MEM_IMAGE && mbi.State != MEM_FREE)
1729 {
1730 if (ReadProcessMemory(gdbctx->process->handle, (void *)(UINT_PTR)mod.BaseOfImage, buffer, size, &size) &&
1731 size >= sizeof(IMAGE_DOS_HEADER))
1732 dos = (IMAGE_DOS_HEADER *)buffer;
1733
1734 if (dos && dos->e_magic == IMAGE_DOS_SIGNATURE && dos->e_lfanew < size)
1735 nth = (IMAGE_NT_HEADERS *)(buffer + dos->e_lfanew);
1736
1737 if (nth && memcmp(&nth->Signature, "PE\0\0", 4))
1738 nth = NULL;
1739 }
1740
1741 if (!nth) memset(buffer, 0, sizeof(buffer));
1742
1743 /* if the module is not PE we have cleared buffer with 0, this makes
1744 * the following computation valid in all cases. */
1745 dos = (IMAGE_DOS_HEADER *)buffer;
1746 nth = (IMAGE_NT_HEADERS *)(buffer + dos->e_lfanew);
1747 if (IsWow64Process(gdbctx->process->handle, &is_wow64) && is_wow64)
1748 sec = IMAGE_FIRST_SECTION((IMAGE_NT_HEADERS32 *)nth);
1749 else
1750 sec = IMAGE_FIRST_SECTION((IMAGE_NT_HEADERS64 *)nth);
1751
1752 for (i = 0; i < max(nth->FileHeader.NumberOfSections, 1); ++i)
1753 {
1754 if ((char *)(sec + i) >= buffer + size) break;
1755 reply_buffer_append_str(reply, "<segment address=\"0x");
1756 reply_buffer_append_uinthex(reply, mod.BaseOfImage + sec[i].VirtualAddress, sizeof(ULONG_PTR));
1757 reply_buffer_append_str(reply, "\"/>");
1758 }
1759
1760 reply_buffer_append_str(reply, "</library>");
1761
1762 return TRUE;
1763 }
1764
1765 static enum packet_return packet_query_libraries(struct gdb_context* gdbctx)
1766 {
1767 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1768 BOOL opt;
1769
1770 if (!gdbctx->process) return packet_error;
1771
1772 if (gdbctx->qxfer_object_annex[0])
1773 return packet_reply_error(gdbctx, 0);
1774
1775 /* this will resynchronize builtin dbghelp's internal ELF module list */
1776 SymLoadModule(gdbctx->process->handle, 0, 0, 0, 0, 0);
1777
1778 reply_buffer_append_str(reply, "<library-list>");
1779 opt = SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, TRUE);
1780 SymEnumerateModules64(gdbctx->process->handle, packet_query_libraries_cb, gdbctx);
1781 SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
1782 reply_buffer_append_str(reply, "</library-list>");
1783
1784 return packet_send_buffer;
1785 }
1786
1787 static enum packet_return packet_query_threads(struct gdb_context* gdbctx)
1788 {
1789 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1790 struct dbg_process* process = gdbctx->process;
1791 struct dbg_thread* thread;
1792 WCHAR* description;
1793
1794 if (!process) return packet_error;
1795
1796 if (gdbctx->qxfer_object_annex[0])
1797 return packet_reply_error(gdbctx, 0);
1798
1799 reply_buffer_append_str(reply, "<threads>");
1800 LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
1801 {
1802 reply_buffer_append_str(reply, "<thread ");
1803 reply_buffer_append_str(reply, "id=\"");
1804 reply_buffer_append_uinthex(reply, thread->tid, 4);
1805 reply_buffer_append_str(reply, "\" name=\"");
1806 if ((description = fetch_thread_description(thread->tid)))
1807 {
1808 reply_buffer_append_wstr(reply, description);
1809 LocalFree(description);
1810 }
1811 else if (strlen(thread->name))
1812 {
1813 reply_buffer_append_str(reply, thread->name);
1814 }
1815 else
1816 {
1817 char tid[5];
1818 snprintf(tid, sizeof(tid), "%04lx", thread->tid);
1819 reply_buffer_append_str(reply, tid);
1820 }
1821 reply_buffer_append_str(reply, "\"/>");
1822 }
1823 reply_buffer_append_str(reply, "</threads>");
1824
1825 return packet_send_buffer;
1826 }
1827
1828 static void packet_query_target_xml(struct gdb_context* gdbctx, struct reply_buffer* reply, struct backend_cpu* cpu)
1829 {
1830 const char* feature_prefix = NULL;
1831 const char* feature = NULL;
1832 char buffer[256];
1833 int i;
1834
1835 reply_buffer_append_str(reply, "<target>");
1836 switch (cpu->machine)
1837 {
1838 case IMAGE_FILE_MACHINE_AMD64:
1839 reply_buffer_append_str(reply, "<architecture>i386:x86-64</architecture>");
1840 feature_prefix = "org.gnu.gdb.i386.";
1841 break;
1842 case IMAGE_FILE_MACHINE_I386:
1843 reply_buffer_append_str(reply, "<architecture>i386</architecture>");
1844 feature_prefix = "org.gnu.gdb.i386.";
1845 break;
1846 case IMAGE_FILE_MACHINE_ARMNT:
1847 reply_buffer_append_str(reply, "<architecture>arm</architecture>");
1848 feature_prefix = "org.gnu.gdb.arm.";
1849 break;
1850 case IMAGE_FILE_MACHINE_ARM64:
1851 reply_buffer_append_str(reply, "<architecture>aarch64</architecture>");
1852 feature_prefix = "org.gnu.gdb.aarch64.";
1853 break;
1854 }
1855
1856 for (i = 0; i < cpu->gdb_num_regs; ++i)
1857 {
1858 if (cpu->gdb_register_map[i].feature)
1859 {
1860 if (feature) reply_buffer_append_str(reply, "</feature>");
1861 feature = cpu->gdb_register_map[i].feature;
1862
1863 reply_buffer_append_str(reply, "<feature name=\"");
1864 if (feature_prefix) reply_buffer_append_xmlstr(reply, feature_prefix);
1865 reply_buffer_append_xmlstr(reply, feature);
1866 reply_buffer_append_str(reply, "\">");
1867
1868 if (strcmp(feature_prefix, "org.gnu.gdb.i386.") == 0 &&
1869 strcmp(feature, "core") == 0)
1870 reply_buffer_append_str(reply, "<flags id=\"i386_eflags\" size=\"4\">"
1871 "<field name=\"CF\" start=\"0\" end=\"0\"/>"
1872 "<field name=\"\" start=\"1\" end=\"1\"/>"
1873 "<field name=\"PF\" start=\"2\" end=\"2\"/>"
1874 "<field name=\"AF\" start=\"4\" end=\"4\"/>"
1875 "<field name=\"ZF\" start=\"6\" end=\"6\"/>"
1876 "<field name=\"SF\" start=\"7\" end=\"7\"/>"
1877 "<field name=\"TF\" start=\"8\" end=\"8\"/>"
1878 "<field name=\"IF\" start=\"9\" end=\"9\"/>"
1879 "<field name=\"DF\" start=\"10\" end=\"10\"/>"
1880 "<field name=\"OF\" start=\"11\" end=\"11\"/>"
1881 "<field name=\"NT\" start=\"14\" end=\"14\"/>"
1882 "<field name=\"RF\" start=\"16\" end=\"16\"/>"
1883 "<field name=\"VM\" start=\"17\" end=\"17\"/>"
1884 "<field name=\"AC\" start=\"18\" end=\"18\"/>"
1885 "<field name=\"VIF\" start=\"19\" end=\"19\"/>"
1886 "<field name=\"VIP\" start=\"20\" end=\"20\"/>"
1887 "<field name=\"ID\" start=\"21\" end=\"21\"/>"
1888 "</flags>");
1889
1890 if (strcmp(feature_prefix, "org.gnu.gdb.i386.") == 0 &&
1891 strcmp(feature, "sse") == 0)
1892 reply_buffer_append_str(reply, "<vector id=\"v4f\" type=\"ieee_single\" count=\"4\"/>"
1893 "<vector id=\"v2d\" type=\"ieee_double\" count=\"2\"/>"
1894 "<vector id=\"v16i8\" type=\"int8\" count=\"16\"/>"
1895 "<vector id=\"v8i16\" type=\"int16\" count=\"8\"/>"
1896 "<vector id=\"v4i32\" type=\"int32\" count=\"4\"/>"
1897 "<vector id=\"v2i64\" type=\"int64\" count=\"2\"/>"
1898 "<union id=\"vec128\">"
1899 "<field name=\"v4_float\" type=\"v4f\"/>"
1900 "<field name=\"v2_double\" type=\"v2d\"/>"
1901 "<field name=\"v16_int8\" type=\"v16i8\"/>"
1902 "<field name=\"v8_int16\" type=\"v8i16\"/>"
1903 "<field name=\"v4_int32\" type=\"v4i32\"/>"
1904 "<field name=\"v2_int64\" type=\"v2i64\"/>"
1905 "<field name=\"uint128\" type=\"uint128\"/>"
1906 "</union>"
1907 "<flags id=\"i386_mxcsr\" size=\"4\">"
1908 "<field name=\"IE\" start=\"0\" end=\"0\"/>"
1909 "<field name=\"DE\" start=\"1\" end=\"1\"/>"
1910 "<field name=\"ZE\" start=\"2\" end=\"2\"/>"
1911 "<field name=\"OE\" start=\"3\" end=\"3\"/>"
1912 "<field name=\"UE\" start=\"4\" end=\"4\"/>"
1913 "<field name=\"PE\" start=\"5\" end=\"5\"/>"
1914 "<field name=\"DAZ\" start=\"6\" end=\"6\"/>"
1915 "<field name=\"IM\" start=\"7\" end=\"7\"/>"
1916 "<field name=\"DM\" start=\"8\" end=\"8\"/>"
1917 "<field name=\"ZM\" start=\"9\" end=\"9\"/>"
1918 "<field name=\"OM\" start=\"10\" end=\"10\"/>"
1919 "<field name=\"UM\" start=\"11\" end=\"11\"/>"
1920 "<field name=\"PM\" start=\"12\" end=\"12\"/>"
1921 "<field name=\"FZ\" start=\"15\" end=\"15\"/>"
1922 "</flags>");
1923 }
1924
1925 snprintf(buffer, ARRAY_SIZE(buffer), "<reg name=\"%s\" bitsize=\"%Iu\"",
1926 cpu->gdb_register_map[i].name, 8 * cpu->gdb_register_map[i].length);
1927 reply_buffer_append_str(reply, buffer);
1928
1929 if (cpu->gdb_register_map[i].type)
1930 {
1931 reply_buffer_append_str(reply, " type=\"");
1932 reply_buffer_append_xmlstr(reply, cpu->gdb_register_map[i].type);
1933 reply_buffer_append_str(reply, "\"");
1934 }
1935
1936 reply_buffer_append_str(reply, "/>");
1937 }
1938
1939 if (feature) reply_buffer_append_str(reply, "</feature>");
1940 reply_buffer_append_str(reply, "</target>");
1941 }
1942
1943 static enum packet_return packet_query_features(struct gdb_context* gdbctx)
1944 {
1945 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1946 struct dbg_process* process = gdbctx->process;
1947
1948 if (!process) return packet_error;
1949
1950 if (strncmp(gdbctx->qxfer_object_annex, "target.xml", QX_ANNEX_SIZE) == 0)
1951 {
1952 struct backend_cpu *cpu = process->be_cpu;
1953 if (!cpu) return packet_error;
1954
1955 packet_query_target_xml(gdbctx, reply, cpu);
1956
1957 return packet_send_buffer;
1958 }
1959
1960 return packet_reply_error(gdbctx, 0);
1961 }
1962
1963 static enum packet_return packet_query_exec_file(struct gdb_context* gdbctx)
1964 {
1965 struct reply_buffer* reply = &gdbctx->qxfer_buffer;
1966 struct dbg_process* process = gdbctx->process;
1967 char *unix_path;
1968 BOOL is_wow64;
1969 char *tmp;
1970
1971 if (!process) return packet_error;
1972
1973 if (gdbctx->qxfer_object_annex[0] || !process->imageName)
1974 return packet_reply_error(gdbctx, HOST_EPERM);
1975
1976 if (!(unix_path = wine_get_unix_file_name(process->imageName)))
1977 return packet_reply_error(gdbctx, GetLastError() == ERROR_NOT_ENOUGH_MEMORY ? HOST_ENOMEM : HOST_ENOENT);
1978
1979 if (IsWow64Process(process->handle, &is_wow64) &&
1980 is_wow64 && (tmp = strstr(unix_path, "system32")))
1981 memcpy(tmp, "syswow64", 8);
1982
1983 reply_buffer_append_str(reply, unix_path);
1984
1985 HeapFree(GetProcessHeap(), 0, unix_path);
1986
1987 return packet_send_buffer;
1988 }
1989
1990 struct qxfer
1991 {
1992 const char* name;
1993 enum packet_return (*handler)(struct gdb_context* gdbctx);
1994 } qxfer_handlers[] =
1995 {
1996 {"libraries", packet_query_libraries},
1997 {"threads" , packet_query_threads },
1998 {"features" , packet_query_features },
1999 {"exec-file", packet_query_exec_file},
2000 };
2001
2002 static enum packet_return packet_query(struct gdb_context* gdbctx)
2003 {
2004 char object_name[QX_NAME_SIZE], annex[QX_ANNEX_SIZE];
2005 unsigned int off, len;
2006
2007 switch (gdbctx->in_packet[0])
2008 {
2009 case 'f':
2010 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
2011 {
2012 struct dbg_thread* thd;
2013
2014 packet_reply_open(gdbctx);
2015 packet_reply_add(gdbctx, "m");
2016 LIST_FOR_EACH_ENTRY(thd, &gdbctx->process->threads, struct dbg_thread, entry)
2017 {
2018 packet_reply_val(gdbctx, thd->tid, 4);
2019 if (list_next(&gdbctx->process->threads, &thd->entry) != NULL)
2020 packet_reply_add(gdbctx, ",");
2021 }
2022 packet_reply_close(gdbctx);
2023 return packet_done;
2024 }
2025 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
2026 {
2027 char result[128];
2028
2029 packet_reply_open(gdbctx);
2030 packet_reply_add(gdbctx, "O");
2031 get_process_info(gdbctx, result, sizeof(result));
2032 packet_reply_hex_to_str(gdbctx, result);
2033 packet_reply_close(gdbctx);
2034 return packet_done;
2035 }
2036 break;
2037 case 's':
2038 if (strncmp(gdbctx->in_packet + 1, "ThreadInfo", gdbctx->in_packet_len - 1) == 0)
2039 {
2040 packet_reply(gdbctx, "l");
2041 return packet_done;
2042 }
2043 else if (strncmp(gdbctx->in_packet + 1, "ProcessInfo", gdbctx->in_packet_len - 1) == 0)
2044 {
2045 packet_reply(gdbctx, "l");
2046 return packet_done;
2047 }
2048 break;
2049 case 'A':
2050 if (strncmp(gdbctx->in_packet, "Attached", gdbctx->in_packet_len) == 0)
2051 return packet_reply(gdbctx, "1");
2052 break;
2053 case 'C':
2054 if (gdbctx->in_packet_len == 1)
2055 {
2056 struct dbg_thread* thd;
2057 /* FIXME: doc says 16 bit val ??? */
2058 /* grab first created thread, aka last in list */
2059 assert(gdbctx->process && !list_empty(&gdbctx->process->threads));
2060 thd = LIST_ENTRY(list_tail(&gdbctx->process->threads), struct dbg_thread, entry);
2061 packet_reply_open(gdbctx);
2062 packet_reply_add(gdbctx, "QC");
2063 packet_reply_val(gdbctx, thd->tid, 4);
2064 packet_reply_close(gdbctx);
2065 return packet_done;
2066 }
2067 break;
2068 case 'G':
2069 if (gdbctx->in_packet_len > 10 &&
2070 strncmp(gdbctx->in_packet, "GetTIBAddr", 10) == 0 &&
2071 gdbctx->in_packet[10] == ':')
2072 {
2073 unsigned tid;
2074 char* end;
2075 struct dbg_thread* thd;
2076
2077 tid = strtol(gdbctx->in_packet + 11, &end, 16);
2078 if (end == NULL) break;
2079
2080 thd = dbg_get_thread(gdbctx->process, tid);
2081 if (thd == NULL)
2082 return packet_reply_error(gdbctx, HOST_EINVAL);
2083 packet_reply_open(gdbctx);
2084 packet_reply_val(gdbctx, (ULONG_PTR)thd->teb, sizeof(thd->teb));
2085 packet_reply_close(gdbctx);
2086 return packet_done;
2087 }
2088 break;
2089 case 'O':
2090 if (strncmp(gdbctx->in_packet, "Offsets", gdbctx->in_packet_len) == 0)
2091 {
2092 char buf[64];
2093
2094 snprintf(buf, sizeof(buf),
2095 "Text=%08Ix;Data=%08Ix;Bss=%08Ix",
2096 gdbctx->wine_segs[0], gdbctx->wine_segs[1],
2097 gdbctx->wine_segs[2]);
2098 return packet_reply(gdbctx, buf);
2099 }
2100 break;
2101 case 'R':
2102 if (gdbctx->in_packet_len > 5 && strncmp(gdbctx->in_packet, "Rcmd,", 5) == 0)
2103 {
2104 return packet_query_remote_command(gdbctx, gdbctx->in_packet + 5,
2105 gdbctx->in_packet_len - 5);
2106 }
2107 break;
2108 case 'S':
2109 if (strncmp(gdbctx->in_packet, "Symbol::", gdbctx->in_packet_len) == 0)
2110 return packet_ok;
2111 if (strncmp(gdbctx->in_packet, "Supported", 9) == 0)
2112 {
2113 size_t i;
2114
2115 packet_reply_open(gdbctx);
2116 packet_reply_add(gdbctx, "QStartNoAckMode+;");
2117 for (i = 0; i < ARRAY_SIZE(qxfer_handlers); i++)
2118 {
2119 packet_reply_add(gdbctx, "qXfer:");
2120 packet_reply_add(gdbctx, qxfer_handlers[i].name);
2121 packet_reply_add(gdbctx, ":read+;");
2122 }
2123 packet_reply_close(gdbctx);
2124 return packet_done;
2125 }
2126 break;
2127 case 'T':
2128 if (gdbctx->in_packet_len > 15 &&
2129 strncmp(gdbctx->in_packet, "ThreadExtraInfo", 15) == 0 &&
2130 gdbctx->in_packet[15] == ',')
2131 {
2132 unsigned tid;
2133 char* end;
2134 char result[128];
2135
2136 tid = strtol(gdbctx->in_packet + 16, &end, 16);
2137 if (end == NULL) break;
2138 get_thread_info(gdbctx, tid, result, sizeof(result));
2139 packet_reply_open(gdbctx);
2140 packet_reply_hex_to_str(gdbctx, result);
2141 packet_reply_close(gdbctx);
2142 return packet_done;
2143 }
2144 if (strncmp(gdbctx->in_packet, "TStatus", 7) == 0)
2145 {
2146 /* Tracepoints not supported */
2147 packet_reply_open(gdbctx);
2148 packet_reply_close(gdbctx);
2149 return packet_done;
2150 }
2151 break;
2152 case 'X':
2153 annex[0] = '\0';
2154 if (sscanf(gdbctx->in_packet, "Xfer:%31[^:]:read::%x,%x", object_name, &off, &len) == 3 ||
2155 sscanf(gdbctx->in_packet, "Xfer:%31[^:]:read:%255[^:]:%x,%x", object_name, annex, &off, &len) == 4)
2156 {
2157 enum packet_return result;
2158 int i;
2159 BOOL more;
2160
2161 for (i = 0; i < ARRAY_SIZE(qxfer_handlers); i++)
2162 {
2163 if (strcmp(qxfer_handlers[i].name, object_name) == 0)
2164 break;
2165 }
2166
2167 if (i >= ARRAY_SIZE(qxfer_handlers))
2168 {
2169 ERR("unhandled qXfer %s read %s %u,%u\n", debugstr_a(object_name), debugstr_a(annex), off, len);
2170 return packet_error;
2171 }
2172
2173 TRACE("qXfer %s read %s %u,%u\n", debugstr_a(object_name), debugstr_a(annex), off, len);
2174
2175 if (off > 0 &&
2176 gdbctx->qxfer_buffer.len > 0 &&
2177 gdbctx->qxfer_object_idx == i &&
2178 strcmp(gdbctx->qxfer_object_annex, annex) == 0)
2179 {
2180 result = packet_send_buffer;
2181 TRACE("qXfer read result = %d (cached)\n", result);
2182 }
2183 else
2184 {
2185 reply_buffer_clear(&gdbctx->qxfer_buffer);
2186
2187 gdbctx->qxfer_object_idx = i;
2188 strcpy(gdbctx->qxfer_object_annex, annex);
2189
2190 result = (*qxfer_handlers[i].handler)(gdbctx);
2191 TRACE("qXfer read result = %d\n", result);
2192 }
2193
2194 more = FALSE;
2195 if ((result & ~packet_last_f) == packet_send_buffer)
2196 {
2197 packet_reply_xfer(gdbctx, off, len, &more);
2198 result = (result & packet_last_f) | packet_done;
2199 }
2200
2201 if (!more)
2202 {
2203 gdbctx->qxfer_object_idx = -1;
2204 gdbctx->qxfer_object_annex[0] = '\0';
2205 reply_buffer_clear(&gdbctx->qxfer_buffer);
2206 }
2207
2208 return result;
2209 }
2210 break;
2211 }
2212 ERR("Unhandled query %s\n", debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
2213 return packet_error;
2214 }
2215
2216 static enum packet_return packet_set(struct gdb_context* gdbctx)
2217 {
2218 if (strncmp(gdbctx->in_packet, "StartNoAckMode", 14) == 0)
2219 {
2220 gdbctx->no_ack_mode = TRUE;
2221 return packet_ok;
2222 }
2223
2224 return packet_error;
2225 }
2226
2227 static enum packet_return packet_step(struct gdb_context* gdbctx)
2228 {
2229 void *addr;
2230
2231 if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
2232 FIXME("Continue at address %p not supported\n", addr);
2233
2234 handle_step_or_continue(gdbctx, gdbctx->exec_tid, TRUE, -1);
2235
2236 wait_for_debuggee(gdbctx);
2237 return packet_reply_status(gdbctx);
2238 }
2239
2240 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
2241 {
2242 char* end;
2243 unsigned tid;
2244
2245 tid = strtol(gdbctx->in_packet, &end, 16);
2246 if (tid == -1 || tid == 0)
2247 return packet_reply_error(gdbctx, HOST_EINVAL );
2248 if (dbg_get_thread(gdbctx->process, tid) != NULL)
2249 return packet_ok;
2250 return packet_reply_error(gdbctx, HOST_ESRCH );
2251 }
2252
2253 /* =============================================== *
2254 * P A C K E T I N F R A S T R U C T U R E *
2255 * =============================================== *
2256 */
2257
2258 struct packet_entry
2259 {
2260 char key;
2261 enum packet_return (*handler)(struct gdb_context* gdbctx);
2262 };
2263
2264 static struct packet_entry packet_entries[] =
2265 {
2266 {'?', packet_last_signal},
2267 {'c', packet_continue},
2268 {'C', packet_continue_signal},
2269 {'D', packet_detach},
2270 {'g', packet_read_registers},
2271 {'G', packet_write_registers},
2272 {'k', packet_kill},
2273 {'H', packet_thread},
2274 {'m', packet_read_memory},
2275 {'M', packet_write_memory},
2276 {'p', packet_read_register},
2277 {'P', packet_write_register},
2278 {'q', packet_query},
2279 {'Q', packet_set},
2280 {'s', packet_step},
2281 {'T', packet_thread_alive},
2282 {'v', packet_verbose},
2283 {'z', packet_delete_breakpoint},
2284 {'Z', packet_insert_breakpoint},
2285 };
2286
2287 static BOOL extract_packets(struct gdb_context* gdbctx)
2288 {
2289 char *ptr, *sum = gdbctx->in_buf, *end = gdbctx->in_buf + gdbctx->in_len;
2290 enum packet_return ret = packet_error;
2291 unsigned int cksum;
2292 int i, len;
2293
2294 /* ptr points to the beginning ('$') of the current packet
2295 * sum points to the beginning ('#') of the current packet checksum ("#xx")
2296 * len is the length of the current packet data (sum - ptr - 1)
2297 * end points to the end of the received data buffer
2298 */
2299
2300 while (!gdbctx->no_ack_mode &&
2301 (ptr = memchr(sum, '$', end - sum)) &&
2302 (sum = memchr(ptr, '#', end - ptr)) &&
2303 (end - sum >= 3) && sscanf(sum, "#%02x", &cksum) == 1)
2304 {
2305 len = sum - ptr - 1;
2306 sum += 3;
2307
2308 if (cksum == checksum(ptr + 1, len))
2309 {
2310 TRACE("Acking: %s\n", debugstr_an(ptr, sum - ptr));
2311 send(gdbctx->sock, "+", 1, 0);
2312 }
2313 else
2314 {
2315 ERR("Nacking: %s (checksum: %d != %d)\n", debugstr_an(ptr, sum - ptr),
2316 cksum, checksum(ptr + 1, len));
2317 send(gdbctx->sock, "-", 1, 0);
2318 }
2319 }
2320
2321 while ((ret & packet_last_f) == 0 &&
2322 (ptr = memchr(gdbctx->in_buf, '$', gdbctx->in_len)) &&
2323 (sum = memchr(ptr, '#', end - ptr)) &&
2324 (end - sum >= 3) && sscanf(sum, "#%02x", &cksum) == 1)
2325 {
2326 if (ptr != gdbctx->in_buf)
2327 WARN("Ignoring: %s\n", debugstr_an(gdbctx->in_buf, ptr - gdbctx->in_buf));
2328
2329 len = sum - ptr - 1;
2330 sum += 3;
2331
2332 if (cksum == checksum(ptr + 1, len))
2333 {
2334 TRACE("Handling: %s\n", debugstr_an(ptr, sum - ptr));
2335
2336 ret = packet_error;
2337 gdbctx->in_packet = ptr + 2;
2338 gdbctx->in_packet_len = len - 1;
2339 gdbctx->in_packet[gdbctx->in_packet_len] = '\0';
2340
2341 for (i = 0; i < ARRAY_SIZE(packet_entries); i++)
2342 if (packet_entries[i].key == ptr[1])
2343 break;
2344
2345 if (i == ARRAY_SIZE(packet_entries))
2346 WARN("Unhandled: %s\n", debugstr_an(ptr + 1, len));
2347 else if (((ret = (packet_entries[i].handler)(gdbctx)) & ~packet_last_f) == packet_error)
2348 WARN("Failed: %s\n", debugstr_an(ptr + 1, len));
2349
2350 switch (ret & ~packet_last_f)
2351 {
2352 case packet_error: packet_reply(gdbctx, ""); break;
2353 case packet_ok: packet_reply(gdbctx, "OK"); break;
2354 case packet_done: break;
2355 }
2356
2357 TRACE("Reply: %s\n", debugstr_an((char *)gdbctx->out_buf.base, gdbctx->out_buf.len));
2358 i = send(gdbctx->sock, (char *)gdbctx->out_buf.base, gdbctx->out_buf.len, 0);
2359 assert(i == gdbctx->out_buf.len);
2360 reply_buffer_clear(&gdbctx->out_buf);
2361 }
2362 else
2363 WARN("Ignoring: %s (checksum: %d != %d)\n", debugstr_an(ptr, sum - ptr),
2364 cksum, checksum(ptr + 1, len));
2365
2366 gdbctx->in_len = end - sum;
2367 memmove(gdbctx->in_buf, sum, end - sum);
2368 end = gdbctx->in_buf + gdbctx->in_len;
2369 }
2370
2371 return (ret & packet_last_f);
2372 }
2373
2374 static int fetch_data(struct gdb_context* gdbctx)
2375 {
2376 int len, in_len = gdbctx->in_len;
2377
2378 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2379 for (;;)
2380 {
2381 #define STEP 128
2382 if (gdbctx->in_len + STEP > gdbctx->in_buf_alloc)
2383 gdbctx->in_buf = realloc(gdbctx->in_buf, gdbctx->in_buf_alloc += STEP);
2384 #undef STEP
2385 len = recv(gdbctx->sock, gdbctx->in_buf + gdbctx->in_len, gdbctx->in_buf_alloc - gdbctx->in_len - 1, 0);
2386 if (len <= 0) break;
2387 gdbctx->in_len += len;
2388 assert(gdbctx->in_len <= gdbctx->in_buf_alloc);
2389 if (len < gdbctx->in_buf_alloc - gdbctx->in_len) break;
2390 }
2391
2392 gdbctx->in_buf[gdbctx->in_len] = '\0';
2393 return gdbctx->in_len - in_len;
2394 }
2395
2396 #define FLAG_NO_START 1
2397 #define FLAG_WITH_XTERM 2
2398
2399 static BOOL gdb_exec(unsigned port, unsigned flags)
2400 {
2401 WCHAR tmp[MAX_PATH], buf[MAX_PATH];
2402 const char *argv[6];
2403 char *unix_tmp;
2404 const char *gdb_path;
2405 FILE* f;
2406
2407 if (!(gdb_path = getenv("WINE_GDB"))) gdb_path = "gdb";
2408 GetTempPathW( MAX_PATH, buf );
2409 GetTempFileNameW( buf, L"gdb", 0, tmp );
2410 if ((f = _wfopen( tmp, L"w+" )) == NULL) return FALSE;
2411 unix_tmp = wine_get_unix_file_name( tmp );
2412 fprintf(f, "target remote localhost:%d\n", ntohs(port));
2413 fprintf(f, "set prompt Wine-gdb>\\ \n");
2414 /* gdb 5.1 seems to require it, won't hurt anyway */
2415 fprintf(f, "sharedlibrary\n");
2416 /* This is needed (but not a decent & final fix)
2417 * Without this, gdb would skip our inter-DLL relay code (because
2418 * we don't have any line number information for the relay code)
2419 * With this, we will stop on first instruction of the stub, and
2420 * reusing step, will get us through the relay stub at the actual
2421 * function we're looking at.
2422 */
2423 fprintf(f, "set step-mode on\n");
2424 /* tell gdb to delete this file when done handling it... */
2425 fprintf(f, "shell rm -f \"%s\"\n", unix_tmp);
2426 fclose(f);
2427 argv[0] = "xterm";
2428 argv[1] = "-e";
2429 argv[2] = gdb_path;
2430 argv[3] = "-x";
2431 argv[4] = unix_tmp;
2432 argv[5] = NULL;
2433 if (flags & FLAG_WITH_XTERM)
2434 __wine_unix_spawnvp( (char **)argv, FALSE );
2435 else
2436 __wine_unix_spawnvp( (char **)argv + 2, FALSE );
2437 HeapFree( GetProcessHeap(), 0, unix_tmp );
2438 return TRUE;
2439 }
2440
2441 static BOOL gdb_startup(struct gdb_context* gdbctx, unsigned flags, unsigned port)
2442 {
2443 SOCKET sock;
2444 BOOL reuseaddr = TRUE;
2445 struct sockaddr_in s_addrs = {0};
2446 int s_len = sizeof(s_addrs);
2447 fd_set read_fds;
2448 WSADATA data;
2449 BOOL ret = FALSE;
2450
2451 WSAStartup( MAKEWORD(2, 2), &data );
2452
2453 /* step 1: create socket for gdb connection request */
2454 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
2455 {
2456 ERR("Failed to create socket: %u\n", WSAGetLastError());
2457 return FALSE;
2458 }
2459
2460 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&reuseaddr, sizeof(reuseaddr));
2461
2462 s_addrs.sin_family = AF_INET;
2463 s_addrs.sin_addr.S_un.S_addr = INADDR_ANY;
2464 s_addrs.sin_port = htons(port);
2465 if (bind(sock, (struct sockaddr *)&s_addrs, sizeof(s_addrs)) == -1)
2466 goto cleanup;
2467
2468 if (listen(sock, 1) == -1 || getsockname(sock, (struct sockaddr *)&s_addrs, &s_len) == -1)
2469 goto cleanup;
2470
2471 /* step 2: do the process internal creation */
2472 handle_debug_event(gdbctx, FALSE);
2473
2474 /* step 3: fire up gdb (if requested) */
2475 if (flags & FLAG_NO_START)
2476 fprintf(stderr, "target remote localhost:%d\n", ntohs(s_addrs.sin_port));
2477 else
2478 gdb_exec(s_addrs.sin_port, flags);
2479
2480 /* step 4: wait for gdb to connect actually */
2481 FD_ZERO( &read_fds );
2482 FD_SET( sock, &read_fds );
2483
2484 if (select( 0, &read_fds, NULL, NULL, NULL ) > 0)
2485 {
2486 int dummy = 1;
2487
2488 gdbctx->sock = accept(sock, (struct sockaddr *)&s_addrs, &s_len);
2489 if (gdbctx->sock != INVALID_SOCKET)
2490 {
2491 ret = TRUE;
2492 TRACE("connected on %Iu\n", gdbctx->sock);
2493 /* don't keep our small packets too long: send them ASAP back to GDB
2494 * without this, GDB really crawls
2495 */
2496 setsockopt(gdbctx->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&dummy, sizeof(dummy));
2497 }
2498 }
2499 else ERR("Failed to connect to gdb: %u\n", WSAGetLastError());
2500
2501 cleanup:
2502 closesocket(sock);
2503 return ret;
2504 }
2505
2506 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigned port)
2507 {
2508 int i;
2509
2510 gdbctx->sock = INVALID_SOCKET;
2511 gdbctx->in_buf = NULL;
2512 gdbctx->in_buf_alloc = 0;
2513 gdbctx->in_len = 0;
2514 memset(&gdbctx->out_buf, 0, sizeof(gdbctx->out_buf));
2515 gdbctx->out_curr_packet = -1;
2516
2517 gdbctx->exec_tid = -1;
2518 gdbctx->other_tid = -1;
2519 list_init(&gdbctx->xpoint_list);
2520 gdbctx->process = NULL;
2521 gdbctx->no_ack_mode = FALSE;
2522 for (i = 0; i < ARRAY_SIZE(gdbctx->wine_segs); i++)
2523 gdbctx->wine_segs[i] = 0;
2524
2525 gdbctx->qxfer_object_idx = -1;
2526 memset(gdbctx->qxfer_object_annex, 0, sizeof(gdbctx->qxfer_object_annex));
2527 memset(&gdbctx->qxfer_buffer, 0, sizeof(gdbctx->qxfer_buffer));
2528
2529 /* wait for first trap */
2530 while (WaitForDebugEvent(&gdbctx->de, INFINITE))
2531 {
2532 if (gdbctx->de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
2533 {
2534 /* this should be the first event we get,
2535 * and the only one of this type */
2536 assert(gdbctx->process == NULL && gdbctx->de.dwProcessId == dbg_curr_pid);
2537 /* gdbctx->dwProcessId = pid; */
2538 if (!gdb_startup(gdbctx, flags, port)) return FALSE;
2539 }
2540 else if (!handle_debug_event(gdbctx, FALSE))
2541 break;
2542 ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
2543 }
2544 return TRUE;
2545 }
2546
2547 static int gdb_remote(unsigned flags, unsigned port)
2548 {
2549 struct gdb_context gdbctx;
2550
2551 if (!gdb_init_context(&gdbctx, flags, port)) return 0;
2552 /* don't handle ctrl-c, but let gdb do the job */
2553 SetConsoleCtrlHandler(NULL, TRUE);
2554 for (;;)
2555 {
2556 fd_set read_fds, err_fds;
2557
2558 FD_ZERO( &read_fds );
2559 FD_ZERO( &err_fds );
2560 FD_SET( gdbctx.sock, &read_fds );
2561 FD_SET( gdbctx.sock, &err_fds );
2562
2563 if (select( 0, &read_fds, NULL, &err_fds, NULL ) == -1) break;
2564
2565 if (FD_ISSET( gdbctx.sock, &err_fds ))
2566 {
2567 ERR("gdb hung up\n");
2568 /* kill also debuggee process - questionnable - */
2569 detach_debuggee(&gdbctx, TRUE);
2570 break;
2571 }
2572 if (FD_ISSET( gdbctx.sock, &read_fds ))
2573 {
2574 if (fetch_data(&gdbctx) > 0)
2575 {
2576 if (extract_packets(&gdbctx)) break;
2577 }
2578 }
2579 }
2580 return 0;
2581 }
2582
2583 int gdb_main(int argc, char* argv[])
2584 {
2585 unsigned gdb_flags = 0, port = 0;
2586 char *port_end;
2587
2588 argc--; argv++;
2589 while (argc > 0 && argv[0][0] == '-')
2590 {
2591 if (strcmp(argv[0], "--no-start") == 0)
2592 {
2593 gdb_flags |= FLAG_NO_START;
2594 argc--; argv++;
2595 continue;
2596 }
2597 if (strcmp(argv[0], "--with-xterm") == 0)
2598 {
2599 gdb_flags |= FLAG_WITH_XTERM;
2600 argc--; argv++;
2601 continue;
2602 }
2603 if (strcmp(argv[0], "--port") == 0 && argc > 1)
2604 {
2605 port = strtoul(argv[1], &port_end, 10);
2606 if (*port_end)
2607 {
2608 fprintf(stderr, "Invalid port: %s\n", argv[1]);
2609 return -1;
2610 }
2611 argc -= 2; argv += 2;
2612 continue;
2613 }
2614 return -1;
2615 }
2616 if (dbg_active_attach(argc, argv) == start_ok ||
2617 dbg_active_launch(argc, argv) == start_ok)
2618 return gdb_remote(gdb_flags, port);
2619
2620 return -1;
2621 }
Windows API implementation