1/* Low level interface to Windows debugging, for gdbserver. 2 Copyright (C) 2006, 2007 Free Software Foundation, Inc. 3 4 Contributed by Leo Zayas. Based on "win32-nat.c" from GDB. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program 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 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21#include "server.h" 22#include "regcache.h" 23#include "gdb/signals.h" 24#include "mem-break.h" 25#include "win32-low.h" 26 27#include <windows.h> 28#include <winnt.h> 29#include <imagehlp.h> 30#include <tlhelp32.h> 31#include <psapi.h> 32#include <sys/param.h> 33#include <malloc.h> 34#include <process.h> 35 36#ifndef USE_WIN32API 37#include <sys/cygwin.h> 38#endif 39 40#define LOG 0 41 42#define OUTMSG(X) do { printf X; fflush (stdout); } while (0) 43#if LOG 44#define OUTMSG2(X) do { printf X; fflush (stdout); } while (0) 45#else 46#define OUTMSG2(X) do ; while (0) 47#endif 48 49#ifndef _T 50#define _T(x) TEXT (x) 51#endif 52 53#ifndef COUNTOF 54#define COUNTOF(STR) (sizeof (STR) / sizeof ((STR)[0])) 55#endif 56 57#ifdef _WIN32_WCE 58# define GETPROCADDRESS(DLL, PROC) \ 59 ((winapi_ ## PROC) GetProcAddress (DLL, TEXT (#PROC))) 60#else 61# define GETPROCADDRESS(DLL, PROC) \ 62 ((winapi_ ## PROC) GetProcAddress (DLL, #PROC)) 63#endif 64 65int using_threads = 1; 66 67/* Globals. */ 68static HANDLE current_process_handle = NULL; 69static DWORD current_process_id = 0; 70static enum target_signal last_sig = TARGET_SIGNAL_0; 71 72/* The current debug event from WaitForDebugEvent. */ 73static DEBUG_EVENT current_event; 74 75#define NUM_REGS (the_low_target.num_regs) 76 77typedef BOOL WINAPI (*winapi_DebugActiveProcessStop) (DWORD dwProcessId); 78typedef BOOL WINAPI (*winapi_DebugSetProcessKillOnExit) (BOOL KillOnExit); 79typedef BOOL WINAPI (*winapi_DebugBreakProcess) (HANDLE); 80typedef BOOL WINAPI (*winapi_GenerateConsoleCtrlEvent) (DWORD, DWORD); 81 82static DWORD main_thread_id = 0; 83 84static void win32_resume (struct thread_resume *resume_info); 85 86/* Get the thread ID from the current selected inferior (the current 87 thread). */ 88static DWORD 89current_inferior_tid (void) 90{ 91 win32_thread_info *th = inferior_target_data (current_inferior); 92 return th->tid; 93} 94 95/* Find a thread record given a thread id. If GET_CONTEXT is set then 96 also retrieve the context for this thread. */ 97static win32_thread_info * 98thread_rec (DWORD id, int get_context) 99{ 100 struct thread_info *thread; 101 win32_thread_info *th; 102 103 thread = (struct thread_info *) find_inferior_id (&all_threads, id); 104 if (thread == NULL) 105 return NULL; 106 107 th = inferior_target_data (thread); 108 if (!th->suspend_count && get_context) 109 { 110 if (id != current_event.dwThreadId) 111 th->suspend_count = SuspendThread (th->h) + 1; 112 113 (*the_low_target.get_thread_context) (th, ¤t_event); 114 } 115 116 return th; 117} 118 119/* Add a thread to the thread list. */ 120static win32_thread_info * 121child_add_thread (DWORD tid, HANDLE h) 122{ 123 win32_thread_info *th; 124 125 if ((th = thread_rec (tid, FALSE))) 126 return th; 127 128 th = (win32_thread_info *) malloc (sizeof (*th)); 129 memset (th, 0, sizeof (*th)); 130 th->tid = tid; 131 th->h = h; 132 133 add_thread (tid, th, (unsigned int) tid); 134 set_inferior_regcache_data ((struct thread_info *) 135 find_inferior_id (&all_threads, tid), 136 new_register_cache ()); 137 138 if (the_low_target.thread_added != NULL) 139 (*the_low_target.thread_added) (th); 140 141 return th; 142} 143 144/* Delete a thread from the list of threads. */ 145static void 146delete_thread_info (struct inferior_list_entry *thread) 147{ 148 win32_thread_info *th = inferior_target_data ((struct thread_info *) thread); 149 150 remove_thread ((struct thread_info *) thread); 151 CloseHandle (th->h); 152 free (th); 153} 154 155/* Delete a thread from the list of threads. */ 156static void 157child_delete_thread (DWORD id) 158{ 159 struct inferior_list_entry *thread; 160 161 /* If the last thread is exiting, just return. */ 162 if (all_threads.head == all_threads.tail) 163 return; 164 165 thread = find_inferior_id (&all_threads, id); 166 if (thread == NULL) 167 return; 168 169 delete_thread_info (thread); 170} 171 172/* Transfer memory from/to the debugged process. */ 173static int 174child_xfer_memory (CORE_ADDR memaddr, char *our, int len, 175 int write, struct target_ops *target) 176{ 177 SIZE_T done; 178 long addr = (long) memaddr; 179 180 if (write) 181 { 182 WriteProcessMemory (current_process_handle, (LPVOID) addr, 183 (LPCVOID) our, len, &done); 184 FlushInstructionCache (current_process_handle, (LPCVOID) addr, len); 185 } 186 else 187 { 188 ReadProcessMemory (current_process_handle, (LPCVOID) addr, (LPVOID) our, 189 len, &done); 190 } 191 return done; 192} 193 194/* Generally, what has the program done? */ 195enum target_waitkind 196{ 197 /* The program has exited. The exit status is in value.integer. */ 198 TARGET_WAITKIND_EXITED, 199 200 /* The program has stopped with a signal. Which signal is in 201 value.sig. */ 202 TARGET_WAITKIND_STOPPED, 203 204 /* The program is letting us know that it dynamically loaded 205 or unloaded something. */ 206 TARGET_WAITKIND_LOADED, 207 208 /* The program has exec'ed a new executable file. The new file's 209 pathname is pointed to by value.execd_pathname. */ 210 TARGET_WAITKIND_EXECD, 211 212 /* Nothing interesting happened, but we stopped anyway. We take the 213 chance to check if GDB requested an interrupt. */ 214 TARGET_WAITKIND_SPURIOUS, 215}; 216 217struct target_waitstatus 218{ 219 enum target_waitkind kind; 220 221 /* Forked child pid, execd pathname, exit status or signal number. */ 222 union 223 { 224 int integer; 225 enum target_signal sig; 226 int related_pid; 227 char *execd_pathname; 228 int syscall_id; 229 } 230 value; 231}; 232 233/* Clear out any old thread list and reinitialize it to a pristine 234 state. */ 235static void 236child_init_thread_list (void) 237{ 238 for_each_inferior (&all_threads, delete_thread_info); 239} 240 241static void 242do_initial_child_stuff (DWORD pid) 243{ 244 last_sig = TARGET_SIGNAL_0; 245 246 memset (¤t_event, 0, sizeof (current_event)); 247 248 child_init_thread_list (); 249 250 if (the_low_target.initial_stuff != NULL) 251 (*the_low_target.initial_stuff) (); 252} 253 254/* Resume all artificially suspended threads if we are continuing 255 execution. */ 256static int 257continue_one_thread (struct inferior_list_entry *this_thread, void *id_ptr) 258{ 259 struct thread_info *thread = (struct thread_info *) this_thread; 260 int thread_id = * (int *) id_ptr; 261 win32_thread_info *th = inferior_target_data (thread); 262 int i; 263 264 if ((thread_id == -1 || thread_id == th->tid) 265 && th->suspend_count) 266 { 267 if (th->context.ContextFlags) 268 { 269 (*the_low_target.set_thread_context) (th, ¤t_event); 270 th->context.ContextFlags = 0; 271 } 272 273 for (i = 0; i < th->suspend_count; i++) 274 (void) ResumeThread (th->h); 275 th->suspend_count = 0; 276 } 277 278 return 0; 279} 280 281static BOOL 282child_continue (DWORD continue_status, int thread_id) 283{ 284 BOOL res; 285 286 res = ContinueDebugEvent (current_event.dwProcessId, 287 current_event.dwThreadId, continue_status); 288 if (res) 289 find_inferior (&all_threads, continue_one_thread, &thread_id); 290 291 return res; 292} 293 294/* Fetch register(s) from the current thread context. */ 295static void 296child_fetch_inferior_registers (int r) 297{ 298 int regno; 299 win32_thread_info *th = thread_rec (current_inferior_tid (), TRUE); 300 if (r == -1 || r == 0 || r > NUM_REGS) 301 child_fetch_inferior_registers (NUM_REGS); 302 else 303 for (regno = 0; regno < r; regno++) 304 (*the_low_target.fetch_inferior_register) (th, regno); 305} 306 307/* Store a new register value into the current thread context. We don't 308 change the program's context until later, when we resume it. */ 309static void 310child_store_inferior_registers (int r) 311{ 312 int regno; 313 win32_thread_info *th = thread_rec (current_inferior_tid (), TRUE); 314 if (r == -1 || r == 0 || r > NUM_REGS) 315 child_store_inferior_registers (NUM_REGS); 316 else 317 for (regno = 0; regno < r; regno++) 318 (*the_low_target.store_inferior_register) (th, regno); 319} 320 321/* Map the Windows error number in ERROR to a locale-dependent error 322 message string and return a pointer to it. Typically, the values 323 for ERROR come from GetLastError. 324 325 The string pointed to shall not be modified by the application, 326 but may be overwritten by a subsequent call to strwinerror 327 328 The strwinerror function does not change the current setting 329 of GetLastError. */ 330 331char * 332strwinerror (DWORD error) 333{ 334 static char buf[1024]; 335 TCHAR *msgbuf; 336 DWORD lasterr = GetLastError (); 337 DWORD chars = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM 338 | FORMAT_MESSAGE_ALLOCATE_BUFFER, 339 NULL, 340 error, 341 0, /* Default language */ 342 (LPVOID)&msgbuf, 343 0, 344 NULL); 345 if (chars != 0) 346 { 347 /* If there is an \r\n appended, zap it. */ 348 if (chars >= 2 349 && msgbuf[chars - 2] == '\r' 350 && msgbuf[chars - 1] == '\n') 351 { 352 chars -= 2; 353 msgbuf[chars] = 0; 354 } 355 356 if (chars > ((COUNTOF (buf)) - 1)) 357 { 358 chars = COUNTOF (buf) - 1; 359 msgbuf [chars] = 0; 360 } 361 362#ifdef UNICODE 363 wcstombs (buf, msgbuf, chars + 1); 364#else 365 strncpy (buf, msgbuf, chars + 1); 366#endif 367 LocalFree (msgbuf); 368 } 369 else 370 sprintf (buf, "unknown win32 error (%ld)", error); 371 372 SetLastError (lasterr); 373 return buf; 374} 375 376static BOOL 377create_process (const char *program, char *args, 378 DWORD flags, PROCESS_INFORMATION *pi) 379{ 380 BOOL ret; 381 382#ifdef _WIN32_WCE 383 wchar_t *p, *wprogram, *wargs; 384 size_t argslen; 385 386 wprogram = alloca ((strlen (program) + 1) * sizeof (wchar_t)); 387 mbstowcs (wprogram, program, strlen (program) + 1); 388 389 for (p = wprogram; *p; ++p) 390 if (L'/' == *p) 391 *p = L'\\'; 392 393 argslen = strlen (args); 394 wargs = alloca ((argslen + 1) * sizeof (wchar_t)); 395 mbstowcs (wargs, args, argslen + 1); 396 397 ret = CreateProcessW (wprogram, /* image name */ 398 wargs, /* command line */ 399 NULL, /* security, not supported */ 400 NULL, /* thread, not supported */ 401 FALSE, /* inherit handles, not supported */ 402 flags, /* start flags */ 403 NULL, /* environment, not supported */ 404 NULL, /* current directory, not supported */ 405 NULL, /* start info, not supported */ 406 pi); /* proc info */ 407#else 408 STARTUPINFOA si = { sizeof (STARTUPINFOA) }; 409 410 ret = CreateProcessA (program, /* image name */ 411 args, /* command line */ 412 NULL, /* security */ 413 NULL, /* thread */ 414 TRUE, /* inherit handles */ 415 flags, /* start flags */ 416 NULL, /* environment */ 417 NULL, /* current directory */ 418 &si, /* start info */ 419 pi); /* proc info */ 420#endif 421 422 return ret; 423} 424 425/* Start a new process. 426 PROGRAM is a path to the program to execute. 427 ARGS is a standard NULL-terminated array of arguments, 428 to be passed to the inferior as ``argv''. 429 Returns the new PID on success, -1 on failure. Registers the new 430 process with the process list. */ 431static int 432win32_create_inferior (char *program, char **program_args) 433{ 434#ifndef USE_WIN32API 435 char real_path[MAXPATHLEN]; 436 char *orig_path, *new_path, *path_ptr; 437#endif 438 BOOL ret; 439 DWORD flags; 440 char *args; 441 int argslen; 442 int argc; 443 PROCESS_INFORMATION pi; 444 DWORD err; 445 446 if (!program) 447 error ("No executable specified, specify executable to debug.\n"); 448 449 flags = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS; 450 451#ifndef USE_WIN32API 452 orig_path = NULL; 453 path_ptr = getenv ("PATH"); 454 if (path_ptr) 455 { 456 orig_path = alloca (strlen (path_ptr) + 1); 457 new_path = alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr)); 458 strcpy (orig_path, path_ptr); 459 cygwin_posix_to_win32_path_list (path_ptr, new_path); 460 setenv ("PATH", new_path, 1); 461 } 462 cygwin_conv_to_win32_path (program, real_path); 463 program = real_path; 464#endif 465 466 argslen = 1; 467 for (argc = 1; program_args[argc]; argc++) 468 argslen += strlen (program_args[argc]) + 1; 469 args = alloca (argslen); 470 args[0] = '\0'; 471 for (argc = 1; program_args[argc]; argc++) 472 { 473 /* FIXME: Can we do better about quoting? How does Cygwin 474 handle this? */ 475 strcat (args, " "); 476 strcat (args, program_args[argc]); 477 } 478 OUTMSG2 (("Command line is \"%s\"\n", args)); 479 480#ifdef CREATE_NEW_PROCESS_GROUP 481 flags |= CREATE_NEW_PROCESS_GROUP; 482#endif 483 484 ret = create_process (program, args, flags, &pi); 485 err = GetLastError (); 486 if (!ret && err == ERROR_FILE_NOT_FOUND) 487 { 488 char *exename = alloca (strlen (program) + 5); 489 strcat (strcpy (exename, program), ".exe"); 490 ret = create_process (exename, args, flags, &pi); 491 err = GetLastError (); 492 } 493 494#ifndef USE_WIN32API 495 if (orig_path) 496 setenv ("PATH", orig_path, 1); 497#endif 498 499 if (!ret) 500 { 501 error ("Error creating process \"%s%s\", (error %d): %s\n", 502 program, args, (int) err, strwinerror (err)); 503 } 504 else 505 { 506 OUTMSG2 (("Process created: %s\n", (char *) args)); 507 } 508 509#ifndef _WIN32_WCE 510 /* On Windows CE this handle can't be closed. The OS reuses 511 it in the debug events, while the 9x/NT versions of Windows 512 probably use a DuplicateHandle'd one. */ 513 CloseHandle (pi.hThread); 514#endif 515 516 current_process_handle = pi.hProcess; 517 current_process_id = pi.dwProcessId; 518 519 do_initial_child_stuff (current_process_id); 520 521 return current_process_id; 522} 523 524/* Attach to a running process. 525 PID is the process ID to attach to, specified by the user 526 or a higher layer. */ 527static int 528win32_attach (unsigned long pid) 529{ 530 winapi_DebugActiveProcessStop DebugActiveProcessStop = NULL; 531 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL; 532#ifdef _WIN32_WCE 533 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL")); 534#else 535 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL")); 536#endif 537 DebugActiveProcessStop = GETPROCADDRESS (dll, DebugActiveProcessStop); 538 DebugSetProcessKillOnExit = GETPROCADDRESS (dll, DebugSetProcessKillOnExit); 539 540 if (DebugActiveProcess (pid)) 541 { 542 if (DebugSetProcessKillOnExit != NULL) 543 DebugSetProcessKillOnExit (FALSE); 544 545 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pid); 546 547 if (current_process_handle != NULL) 548 { 549 current_process_id = pid; 550 do_initial_child_stuff (pid); 551 return 0; 552 } 553 if (DebugActiveProcessStop != NULL) 554 DebugActiveProcessStop (current_process_id); 555 } 556 557 error ("Attach to process failed."); 558} 559 560/* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */ 561static void 562handle_output_debug_string (struct target_waitstatus *ourstatus) 563{ 564#define READ_BUFFER_LEN 1024 565 CORE_ADDR addr; 566 char s[READ_BUFFER_LEN + 1] = { 0 }; 567 DWORD nbytes = current_event.u.DebugString.nDebugStringLength; 568 569 if (nbytes == 0) 570 return; 571 572 if (nbytes > READ_BUFFER_LEN) 573 nbytes = READ_BUFFER_LEN; 574 575 addr = (CORE_ADDR) (size_t) current_event.u.DebugString.lpDebugStringData; 576 577 if (current_event.u.DebugString.fUnicode) 578 { 579 /* The event tells us how many bytes, not chars, even 580 in Unicode. */ 581 WCHAR buffer[(READ_BUFFER_LEN + 1) / sizeof (WCHAR)] = { 0 }; 582 if (read_inferior_memory (addr, (unsigned char *) buffer, nbytes) != 0) 583 return; 584 wcstombs (s, buffer, (nbytes + 1) / sizeof (WCHAR)); 585 } 586 else 587 { 588 if (read_inferior_memory (addr, (unsigned char *) s, nbytes) != 0) 589 return; 590 } 591 592 if (strncmp (s, "cYg", 3) != 0) 593 { 594 if (!server_waiting) 595 { 596 OUTMSG2(("%s", s)); 597 return; 598 } 599 600 monitor_output (s); 601 } 602#undef READ_BUFFER_LEN 603} 604 605/* Kill all inferiors. */ 606static void 607win32_kill (void) 608{ 609 win32_thread_info *current_thread; 610 611 if (current_process_handle == NULL) 612 return; 613 614 TerminateProcess (current_process_handle, 0); 615 for (;;) 616 { 617 if (!child_continue (DBG_CONTINUE, -1)) 618 break; 619 if (!WaitForDebugEvent (¤t_event, INFINITE)) 620 break; 621 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) 622 break; 623 else if (current_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT) 624 { 625 struct target_waitstatus our_status = { 0 }; 626 handle_output_debug_string (&our_status); 627 } 628 } 629 630 CloseHandle (current_process_handle); 631 632 current_thread = inferior_target_data (current_inferior); 633 if (current_thread && current_thread->h) 634 { 635 /* This may fail in an attached process, so don't check. */ 636 (void) CloseHandle (current_thread->h); 637 } 638} 639 640/* Detach from all inferiors. */ 641static int 642win32_detach (void) 643{ 644 HANDLE h; 645 646 winapi_DebugActiveProcessStop DebugActiveProcessStop = NULL; 647 winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL; 648#ifdef _WIN32_WCE 649 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL")); 650#else 651 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL")); 652#endif 653 DebugActiveProcessStop = GETPROCADDRESS (dll, DebugActiveProcessStop); 654 DebugSetProcessKillOnExit = GETPROCADDRESS (dll, DebugSetProcessKillOnExit); 655 656 if (DebugSetProcessKillOnExit == NULL 657 || DebugActiveProcessStop == NULL) 658 return -1; 659 660 /* We need a new handle, since DebugActiveProcessStop 661 closes all the ones that came through the events. */ 662 if ((h = OpenProcess (PROCESS_ALL_ACCESS, 663 FALSE, 664 current_process_id)) == NULL) 665 { 666 /* The process died. */ 667 return -1; 668 } 669 670 { 671 struct thread_resume resume; 672 resume.thread = -1; 673 resume.step = 0; 674 resume.sig = 0; 675 resume.leave_stopped = 0; 676 win32_resume (&resume); 677 } 678 679 if (!DebugActiveProcessStop (current_process_id)) 680 { 681 CloseHandle (h); 682 return -1; 683 } 684 DebugSetProcessKillOnExit (FALSE); 685 686 current_process_handle = h; 687 return 0; 688} 689 690/* Wait for inferiors to end. */ 691static void 692win32_join (void) 693{ 694 if (current_process_id == 0 695 || current_process_handle == NULL) 696 return; 697 698 WaitForSingleObject (current_process_handle, INFINITE); 699 CloseHandle (current_process_handle); 700 701 current_process_handle = NULL; 702 current_process_id = 0; 703} 704 705/* Return 1 iff the thread with thread ID TID is alive. */ 706static int 707win32_thread_alive (unsigned long tid) 708{ 709 int res; 710 711 /* Our thread list is reliable; don't bother to poll target 712 threads. */ 713 if (find_inferior_id (&all_threads, tid) != NULL) 714 res = 1; 715 else 716 res = 0; 717 return res; 718} 719 720/* Resume the inferior process. RESUME_INFO describes how we want 721 to resume. */ 722static void 723win32_resume (struct thread_resume *resume_info) 724{ 725 DWORD tid; 726 enum target_signal sig; 727 int step; 728 win32_thread_info *th; 729 DWORD continue_status = DBG_CONTINUE; 730 731 /* This handles the very limited set of resume packets that GDB can 732 currently produce. */ 733 734 if (resume_info[0].thread == -1) 735 tid = -1; 736 else if (resume_info[1].thread == -1 && !resume_info[1].leave_stopped) 737 tid = -1; 738 else 739 /* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make 740 the Windows resume code do the right thing for thread switching. */ 741 tid = current_event.dwThreadId; 742 743 if (resume_info[0].thread != -1) 744 { 745 sig = resume_info[0].sig; 746 step = resume_info[0].step; 747 } 748 else 749 { 750 sig = 0; 751 step = 0; 752 } 753 754 if (sig != TARGET_SIGNAL_0) 755 { 756 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) 757 { 758 OUTMSG (("Cannot continue with signal %d here.\n", sig)); 759 } 760 else if (sig == last_sig) 761 continue_status = DBG_EXCEPTION_NOT_HANDLED; 762 else 763 OUTMSG (("Can only continue with recieved signal %d.\n", last_sig)); 764 } 765 766 last_sig = TARGET_SIGNAL_0; 767 768 /* Get context for the currently selected thread. */ 769 th = thread_rec (current_event.dwThreadId, FALSE); 770 if (th) 771 { 772 if (th->context.ContextFlags) 773 { 774 /* Move register values from the inferior into the thread 775 context structure. */ 776 regcache_invalidate (); 777 778 if (step) 779 { 780 if (the_low_target.single_step != NULL) 781 (*the_low_target.single_step) (th); 782 else 783 error ("Single stepping is not supported " 784 "in this configuration.\n"); 785 } 786 787 (*the_low_target.set_thread_context) (th, ¤t_event); 788 th->context.ContextFlags = 0; 789 } 790 } 791 792 /* Allow continuing with the same signal that interrupted us. 793 Otherwise complain. */ 794 795 child_continue (continue_status, tid); 796} 797 798static void 799win32_add_one_solib (const char *name, CORE_ADDR load_addr) 800{ 801 char buf[MAX_PATH + 1]; 802 char buf2[MAX_PATH + 1]; 803 804#ifdef _WIN32_WCE 805 WIN32_FIND_DATA w32_fd; 806 WCHAR wname[MAX_PATH + 1]; 807 mbstowcs (wname, name, MAX_PATH); 808 HANDLE h = FindFirstFile (wname, &w32_fd); 809#else 810 WIN32_FIND_DATAA w32_fd; 811 HANDLE h = FindFirstFileA (name, &w32_fd); 812#endif 813 814 if (h == INVALID_HANDLE_VALUE) 815 strcpy (buf, name); 816 else 817 { 818 FindClose (h); 819 strcpy (buf, name); 820#ifndef _WIN32_WCE 821 { 822 char cwd[MAX_PATH + 1]; 823 char *p; 824 if (GetCurrentDirectoryA (MAX_PATH + 1, cwd)) 825 { 826 p = strrchr (buf, '\\'); 827 if (p) 828 p[1] = '\0'; 829 SetCurrentDirectoryA (buf); 830 GetFullPathNameA (w32_fd.cFileName, MAX_PATH, buf, &p); 831 SetCurrentDirectoryA (cwd); 832 } 833 } 834#endif 835 } 836 837#ifdef __CYGWIN__ 838 cygwin_conv_to_posix_path (buf, buf2); 839#else 840 strcpy (buf2, buf); 841#endif 842 843 loaded_dll (buf2, load_addr); 844} 845 846static char * 847get_image_name (HANDLE h, void *address, int unicode) 848{ 849 static char buf[(2 * MAX_PATH) + 1]; 850 DWORD size = unicode ? sizeof (WCHAR) : sizeof (char); 851 char *address_ptr; 852 int len = 0; 853 char b[2]; 854 DWORD done; 855 856 /* Attempt to read the name of the dll that was detected. 857 This is documented to work only when actively debugging 858 a program. It will not work for attached processes. */ 859 if (address == NULL) 860 return NULL; 861 862#ifdef _WIN32_WCE 863 /* Windows CE reports the address of the image name, 864 instead of an address of a pointer into the image name. */ 865 address_ptr = address; 866#else 867 /* See if we could read the address of a string, and that the 868 address isn't null. */ 869 if (!ReadProcessMemory (h, address, &address_ptr, 870 sizeof (address_ptr), &done) 871 || done != sizeof (address_ptr) 872 || !address_ptr) 873 return NULL; 874#endif 875 876 /* Find the length of the string */ 877 while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done) 878 && (b[0] != 0 || b[size - 1] != 0) && done == size) 879 continue; 880 881 if (!unicode) 882 ReadProcessMemory (h, address_ptr, buf, len, &done); 883 else 884 { 885 WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR)); 886 ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR), 887 &done); 888 889 WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0); 890 } 891 892 return buf; 893} 894 895typedef BOOL (WINAPI *winapi_EnumProcessModules) (HANDLE, HMODULE *, 896 DWORD, LPDWORD); 897typedef BOOL (WINAPI *winapi_GetModuleInformation) (HANDLE, HMODULE, 898 LPMODULEINFO, DWORD); 899typedef DWORD (WINAPI *winapi_GetModuleFileNameExA) (HANDLE, HMODULE, 900 LPSTR, DWORD); 901 902static winapi_EnumProcessModules win32_EnumProcessModules; 903static winapi_GetModuleInformation win32_GetModuleInformation; 904static winapi_GetModuleFileNameExA win32_GetModuleFileNameExA; 905 906static BOOL 907load_psapi (void) 908{ 909 static int psapi_loaded = 0; 910 static HMODULE dll = NULL; 911 912 if (!psapi_loaded) 913 { 914 psapi_loaded = 1; 915 dll = LoadLibrary (TEXT("psapi.dll")); 916 if (!dll) 917 return FALSE; 918 win32_EnumProcessModules = 919 GETPROCADDRESS (dll, EnumProcessModules); 920 win32_GetModuleInformation = 921 GETPROCADDRESS (dll, GetModuleInformation); 922 win32_GetModuleFileNameExA = 923 GETPROCADDRESS (dll, GetModuleFileNameExA); 924 } 925 926 return (win32_EnumProcessModules != NULL 927 && win32_GetModuleInformation != NULL 928 && win32_GetModuleFileNameExA != NULL); 929} 930 931static int 932psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret) 933{ 934 DWORD len; 935 MODULEINFO mi; 936 size_t i; 937 HMODULE dh_buf[1]; 938 HMODULE *DllHandle = dh_buf; 939 DWORD cbNeeded; 940 BOOL ok; 941 942 if (!load_psapi ()) 943 goto failed; 944 945 cbNeeded = 0; 946 ok = (*win32_EnumProcessModules) (current_process_handle, 947 DllHandle, 948 sizeof (HMODULE), 949 &cbNeeded); 950 951 if (!ok || !cbNeeded) 952 goto failed; 953 954 DllHandle = (HMODULE *) alloca (cbNeeded); 955 if (!DllHandle) 956 goto failed; 957 958 ok = (*win32_EnumProcessModules) (current_process_handle, 959 DllHandle, 960 cbNeeded, 961 &cbNeeded); 962 if (!ok) 963 goto failed; 964 965 for (i = 0; i < ((size_t) cbNeeded / sizeof (HMODULE)); i++) 966 { 967 if (!(*win32_GetModuleInformation) (current_process_handle, 968 DllHandle[i], 969 &mi, 970 sizeof (mi))) 971 { 972 DWORD err = GetLastError (); 973 error ("Can't get module info: (error %d): %s\n", 974 (int) err, strwinerror (err)); 975 } 976 977 if ((DWORD) (mi.lpBaseOfDll) == BaseAddress) 978 { 979 len = (*win32_GetModuleFileNameExA) (current_process_handle, 980 DllHandle[i], 981 dll_name_ret, 982 MAX_PATH); 983 if (len == 0) 984 { 985 DWORD err = GetLastError (); 986 error ("Error getting dll name: (error %d): %s\n", 987 (int) err, strwinerror (err)); 988 } 989 return 1; 990 } 991 } 992 993failed: 994 dll_name_ret[0] = '\0'; 995 return 0; 996} 997 998typedef HANDLE (WINAPI *winapi_CreateToolhelp32Snapshot) (DWORD, DWORD); 999typedef BOOL (WINAPI *winapi_Module32First) (HANDLE, LPMODULEENTRY32); 1000typedef BOOL (WINAPI *winapi_Module32Next) (HANDLE, LPMODULEENTRY32); 1001 1002static winapi_CreateToolhelp32Snapshot win32_CreateToolhelp32Snapshot; 1003static winapi_Module32First win32_Module32First; 1004static winapi_Module32Next win32_Module32Next; 1005#ifdef _WIN32_WCE 1006typedef BOOL (WINAPI *winapi_CloseToolhelp32Snapshot) (HANDLE); 1007static winapi_CloseToolhelp32Snapshot win32_CloseToolhelp32Snapshot; 1008#endif 1009 1010static BOOL 1011load_toolhelp (void) 1012{ 1013 static int toolhelp_loaded = 0; 1014 static HMODULE dll = NULL; 1015 1016 if (!toolhelp_loaded) 1017 { 1018 toolhelp_loaded = 1; 1019#ifndef _WIN32_WCE 1020 dll = GetModuleHandle (_T("KERNEL32.DLL")); 1021#else 1022 dll = LoadLibrary (L"TOOLHELP.DLL"); 1023#endif 1024 if (!dll) 1025 return FALSE; 1026 1027 win32_CreateToolhelp32Snapshot = 1028 GETPROCADDRESS (dll, CreateToolhelp32Snapshot); 1029 win32_Module32First = GETPROCADDRESS (dll, Module32First); 1030 win32_Module32Next = GETPROCADDRESS (dll, Module32Next); 1031#ifdef _WIN32_WCE 1032 win32_CloseToolhelp32Snapshot = 1033 GETPROCADDRESS (dll, CloseToolhelp32Snapshot); 1034#endif 1035 } 1036 1037 return (win32_CreateToolhelp32Snapshot != NULL 1038 && win32_Module32First != NULL 1039 && win32_Module32Next != NULL 1040#ifdef _WIN32_WCE 1041 && win32_CloseToolhelp32Snapshot != NULL 1042#endif 1043 ); 1044} 1045 1046static int 1047toolhelp_get_dll_name (DWORD BaseAddress, char *dll_name_ret) 1048{ 1049 HANDLE snapshot_module; 1050 MODULEENTRY32 modEntry = { sizeof (MODULEENTRY32) }; 1051 int found = 0; 1052 1053 if (!load_toolhelp ()) 1054 return 0; 1055 1056 snapshot_module = win32_CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 1057 current_event.dwProcessId); 1058 if (snapshot_module == INVALID_HANDLE_VALUE) 1059 return 0; 1060 1061 /* Ignore the first module, which is the exe. */ 1062 if (win32_Module32First (snapshot_module, &modEntry)) 1063 while (win32_Module32Next (snapshot_module, &modEntry)) 1064 if ((DWORD) modEntry.modBaseAddr == BaseAddress) 1065 { 1066#ifdef UNICODE 1067 wcstombs (dll_name_ret, modEntry.szExePath, MAX_PATH + 1); 1068#else 1069 strcpy (dll_name_ret, modEntry.szExePath); 1070#endif 1071 found = 1; 1072 break; 1073 } 1074 1075#ifdef _WIN32_WCE 1076 win32_CloseToolhelp32Snapshot (snapshot_module); 1077#else 1078 CloseHandle (snapshot_module); 1079#endif 1080 return found; 1081} 1082 1083static void 1084handle_load_dll (void) 1085{ 1086 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll; 1087 char dll_buf[MAX_PATH + 1]; 1088 char *dll_name = NULL; 1089 DWORD load_addr; 1090 1091 dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0'; 1092 1093 /* Windows does not report the image name of the dlls in the debug 1094 event on attaches. We resort to iterating over the list of 1095 loaded dlls looking for a match by image base. */ 1096 if (!psapi_get_dll_name ((DWORD) event->lpBaseOfDll, dll_buf)) 1097 { 1098 if (!server_waiting) 1099 /* On some versions of Windows and Windows CE, we can't create 1100 toolhelp snapshots while the inferior is stopped in a 1101 LOAD_DLL_DEBUG_EVENT due to a dll load, but we can while 1102 Windows is reporting the already loaded dlls. */ 1103 toolhelp_get_dll_name ((DWORD) event->lpBaseOfDll, dll_buf); 1104 } 1105 1106 dll_name = dll_buf; 1107 1108 if (*dll_name == '\0') 1109 dll_name = get_image_name (current_process_handle, 1110 event->lpImageName, event->fUnicode); 1111 if (!dll_name) 1112 return; 1113 1114 /* The symbols in a dll are offset by 0x1000, which is the 1115 the offset from 0 of the first byte in an image - because 1116 of the file header and the section alignment. */ 1117 1118 load_addr = (DWORD) event->lpBaseOfDll + 0x1000; 1119 win32_add_one_solib (dll_name, load_addr); 1120} 1121 1122static void 1123handle_unload_dll (void) 1124{ 1125 CORE_ADDR load_addr = 1126 (CORE_ADDR) (DWORD) current_event.u.UnloadDll.lpBaseOfDll; 1127 load_addr += 0x1000; 1128 unloaded_dll (NULL, load_addr); 1129} 1130 1131static void 1132handle_exception (struct target_waitstatus *ourstatus) 1133{ 1134 DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode; 1135 1136 ourstatus->kind = TARGET_WAITKIND_STOPPED; 1137 1138 switch (code) 1139 { 1140 case EXCEPTION_ACCESS_VIOLATION: 1141 OUTMSG2 (("EXCEPTION_ACCESS_VIOLATION")); 1142 ourstatus->value.sig = TARGET_SIGNAL_SEGV; 1143 break; 1144 case STATUS_STACK_OVERFLOW: 1145 OUTMSG2 (("STATUS_STACK_OVERFLOW")); 1146 ourstatus->value.sig = TARGET_SIGNAL_SEGV; 1147 break; 1148 case STATUS_FLOAT_DENORMAL_OPERAND: 1149 OUTMSG2 (("STATUS_FLOAT_DENORMAL_OPERAND")); 1150 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1151 break; 1152 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 1153 OUTMSG2 (("EXCEPTION_ARRAY_BOUNDS_EXCEEDED")); 1154 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1155 break; 1156 case STATUS_FLOAT_INEXACT_RESULT: 1157 OUTMSG2 (("STATUS_FLOAT_INEXACT_RESULT")); 1158 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1159 break; 1160 case STATUS_FLOAT_INVALID_OPERATION: 1161 OUTMSG2 (("STATUS_FLOAT_INVALID_OPERATION")); 1162 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1163 break; 1164 case STATUS_FLOAT_OVERFLOW: 1165 OUTMSG2 (("STATUS_FLOAT_OVERFLOW")); 1166 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1167 break; 1168 case STATUS_FLOAT_STACK_CHECK: 1169 OUTMSG2 (("STATUS_FLOAT_STACK_CHECK")); 1170 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1171 break; 1172 case STATUS_FLOAT_UNDERFLOW: 1173 OUTMSG2 (("STATUS_FLOAT_UNDERFLOW")); 1174 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1175 break; 1176 case STATUS_FLOAT_DIVIDE_BY_ZERO: 1177 OUTMSG2 (("STATUS_FLOAT_DIVIDE_BY_ZERO")); 1178 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1179 break; 1180 case STATUS_INTEGER_DIVIDE_BY_ZERO: 1181 OUTMSG2 (("STATUS_INTEGER_DIVIDE_BY_ZERO")); 1182 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1183 break; 1184 case STATUS_INTEGER_OVERFLOW: 1185 OUTMSG2 (("STATUS_INTEGER_OVERFLOW")); 1186 ourstatus->value.sig = TARGET_SIGNAL_FPE; 1187 break; 1188 case EXCEPTION_BREAKPOINT: 1189 OUTMSG2 (("EXCEPTION_BREAKPOINT")); 1190 ourstatus->value.sig = TARGET_SIGNAL_TRAP; 1191#ifdef _WIN32_WCE 1192 /* Remove the initial breakpoint. */ 1193 check_breakpoints ((CORE_ADDR) (long) current_event 1194 .u.Exception.ExceptionRecord.ExceptionAddress); 1195#endif 1196 break; 1197 case DBG_CONTROL_C: 1198 OUTMSG2 (("DBG_CONTROL_C")); 1199 ourstatus->value.sig = TARGET_SIGNAL_INT; 1200 break; 1201 case DBG_CONTROL_BREAK: 1202 OUTMSG2 (("DBG_CONTROL_BREAK")); 1203 ourstatus->value.sig = TARGET_SIGNAL_INT; 1204 break; 1205 case EXCEPTION_SINGLE_STEP: 1206 OUTMSG2 (("EXCEPTION_SINGLE_STEP")); 1207 ourstatus->value.sig = TARGET_SIGNAL_TRAP; 1208 break; 1209 case EXCEPTION_ILLEGAL_INSTRUCTION: 1210 OUTMSG2 (("EXCEPTION_ILLEGAL_INSTRUCTION")); 1211 ourstatus->value.sig = TARGET_SIGNAL_ILL; 1212 break; 1213 case EXCEPTION_PRIV_INSTRUCTION: 1214 OUTMSG2 (("EXCEPTION_PRIV_INSTRUCTION")); 1215 ourstatus->value.sig = TARGET_SIGNAL_ILL; 1216 break; 1217 case EXCEPTION_NONCONTINUABLE_EXCEPTION: 1218 OUTMSG2 (("EXCEPTION_NONCONTINUABLE_EXCEPTION")); 1219 ourstatus->value.sig = TARGET_SIGNAL_ILL; 1220 break; 1221 default: 1222 if (current_event.u.Exception.dwFirstChance) 1223 { 1224 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 1225 return; 1226 } 1227 OUTMSG2 (("gdbserver: unknown target exception 0x%08lx at 0x%08lx", 1228 current_event.u.Exception.ExceptionRecord.ExceptionCode, 1229 (DWORD) current_event.u.Exception.ExceptionRecord. 1230 ExceptionAddress)); 1231 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; 1232 break; 1233 } 1234 OUTMSG2 (("\n")); 1235 last_sig = ourstatus->value.sig; 1236} 1237 1238/* Get the next event from the child. */ 1239static void 1240get_child_debug_event (struct target_waitstatus *ourstatus) 1241{ 1242 BOOL debug_event; 1243 1244 last_sig = TARGET_SIGNAL_0; 1245 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 1246 1247 /* Keep the wait time low enough for confortable remote interruption, 1248 but high enough so gdbserver doesn't become a bottleneck. */ 1249 if (!(debug_event = WaitForDebugEvent (¤t_event, 250))) 1250 return; 1251 1252 current_inferior = 1253 (struct thread_info *) find_inferior_id (&all_threads, 1254 current_event.dwThreadId); 1255 1256 switch (current_event.dwDebugEventCode) 1257 { 1258 case CREATE_THREAD_DEBUG_EVENT: 1259 OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT " 1260 "for pid=%d tid=%x)\n", 1261 (unsigned) current_event.dwProcessId, 1262 (unsigned) current_event.dwThreadId)); 1263 1264 /* Record the existence of this thread. */ 1265 child_add_thread (current_event.dwThreadId, 1266 current_event.u.CreateThread.hThread); 1267 break; 1268 1269 case EXIT_THREAD_DEBUG_EVENT: 1270 OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT " 1271 "for pid=%d tid=%x\n", 1272 (unsigned) current_event.dwProcessId, 1273 (unsigned) current_event.dwThreadId)); 1274 child_delete_thread (current_event.dwThreadId); 1275 break; 1276 1277 case CREATE_PROCESS_DEBUG_EVENT: 1278 OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT " 1279 "for pid=%d tid=%x\n", 1280 (unsigned) current_event.dwProcessId, 1281 (unsigned) current_event.dwThreadId)); 1282 CloseHandle (current_event.u.CreateProcessInfo.hFile); 1283 1284 current_process_handle = current_event.u.CreateProcessInfo.hProcess; 1285 main_thread_id = current_event.dwThreadId; 1286 1287 ourstatus->kind = TARGET_WAITKIND_EXECD; 1288 ourstatus->value.execd_pathname = "Main executable"; 1289 1290 /* Add the main thread. */ 1291 child_add_thread (main_thread_id, 1292 current_event.u.CreateProcessInfo.hThread); 1293 1294 ourstatus->value.related_pid = current_event.dwThreadId; 1295#ifdef _WIN32_WCE 1296 /* Windows CE doesn't set the initial breakpoint automatically 1297 like the desktop versions of Windows do. We add it explicitly 1298 here. It will be removed as soon as it is hit. */ 1299 set_breakpoint_at ((CORE_ADDR) (long) current_event.u 1300 .CreateProcessInfo.lpStartAddress, 1301 delete_breakpoint_at); 1302#endif 1303 break; 1304 1305 case EXIT_PROCESS_DEBUG_EVENT: 1306 OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT " 1307 "for pid=%d tid=%x\n", 1308 (unsigned) current_event.dwProcessId, 1309 (unsigned) current_event.dwThreadId)); 1310 ourstatus->kind = TARGET_WAITKIND_EXITED; 1311 ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode; 1312 CloseHandle (current_process_handle); 1313 current_process_handle = NULL; 1314 break; 1315 1316 case LOAD_DLL_DEBUG_EVENT: 1317 OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT " 1318 "for pid=%d tid=%x\n", 1319 (unsigned) current_event.dwProcessId, 1320 (unsigned) current_event.dwThreadId)); 1321 CloseHandle (current_event.u.LoadDll.hFile); 1322 handle_load_dll (); 1323 1324 ourstatus->kind = TARGET_WAITKIND_LOADED; 1325 ourstatus->value.sig = TARGET_SIGNAL_TRAP; 1326 break; 1327 1328 case UNLOAD_DLL_DEBUG_EVENT: 1329 OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT " 1330 "for pid=%d tid=%x\n", 1331 (unsigned) current_event.dwProcessId, 1332 (unsigned) current_event.dwThreadId)); 1333 handle_unload_dll (); 1334 ourstatus->kind = TARGET_WAITKIND_LOADED; 1335 ourstatus->value.sig = TARGET_SIGNAL_TRAP; 1336 break; 1337 1338 case EXCEPTION_DEBUG_EVENT: 1339 OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT " 1340 "for pid=%d tid=%x\n", 1341 (unsigned) current_event.dwProcessId, 1342 (unsigned) current_event.dwThreadId)); 1343 handle_exception (ourstatus); 1344 break; 1345 1346 case OUTPUT_DEBUG_STRING_EVENT: 1347 /* A message from the kernel (or Cygwin). */ 1348 OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT " 1349 "for pid=%d tid=%x\n", 1350 (unsigned) current_event.dwProcessId, 1351 (unsigned) current_event.dwThreadId)); 1352 handle_output_debug_string (ourstatus); 1353 break; 1354 1355 default: 1356 OUTMSG2 (("gdbserver: kernel event unknown " 1357 "for pid=%d tid=%x code=%ld\n", 1358 (unsigned) current_event.dwProcessId, 1359 (unsigned) current_event.dwThreadId, 1360 current_event.dwDebugEventCode)); 1361 break; 1362 } 1363 1364 current_inferior = 1365 (struct thread_info *) find_inferior_id (&all_threads, 1366 current_event.dwThreadId); 1367} 1368 1369/* Wait for the inferior process to change state. 1370 STATUS will be filled in with a response code to send to GDB. 1371 Returns the signal which caused the process to stop. */ 1372static unsigned char 1373win32_wait (char *status) 1374{ 1375 struct target_waitstatus our_status; 1376 1377 *status = 'T'; 1378 1379 while (1) 1380 { 1381 /* Check if GDB sent us an interrupt request. */ 1382 check_remote_input_interrupt_request (); 1383 1384 get_child_debug_event (&our_status); 1385 1386 switch (our_status.kind) 1387 { 1388 case TARGET_WAITKIND_EXITED: 1389 OUTMSG2 (("Child exited with retcode = %x\n", 1390 our_status.value.integer)); 1391 1392 *status = 'W'; 1393 1394 child_fetch_inferior_registers (-1); 1395 1396 return our_status.value.integer; 1397 case TARGET_WAITKIND_STOPPED: 1398 case TARGET_WAITKIND_LOADED: 1399 OUTMSG2 (("Child Stopped with signal = %d \n", 1400 our_status.value.sig)); 1401 1402 *status = 'T'; 1403 1404 child_fetch_inferior_registers (-1); 1405 1406 if (our_status.kind == TARGET_WAITKIND_LOADED 1407 && !server_waiting) 1408 { 1409 /* When gdb connects, we want to be stopped at the 1410 initial breakpoint, not in some dll load event. */ 1411 child_continue (DBG_CONTINUE, -1); 1412 break; 1413 } 1414 1415 return our_status.value.sig; 1416 default: 1417 OUTMSG (("Ignoring unknown internal event, %d\n", our_status.kind)); 1418 /* fall-through */ 1419 case TARGET_WAITKIND_SPURIOUS: 1420 case TARGET_WAITKIND_EXECD: 1421 /* do nothing, just continue */ 1422 child_continue (DBG_CONTINUE, -1); 1423 break; 1424 } 1425 } 1426} 1427 1428/* Fetch registers from the inferior process. 1429 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */ 1430static void 1431win32_fetch_inferior_registers (int regno) 1432{ 1433 child_fetch_inferior_registers (regno); 1434} 1435 1436/* Store registers to the inferior process. 1437 If REGNO is -1, store all registers; otherwise, store at least REGNO. */ 1438static void 1439win32_store_inferior_registers (int regno) 1440{ 1441 child_store_inferior_registers (regno); 1442} 1443 1444/* Read memory from the inferior process. This should generally be 1445 called through read_inferior_memory, which handles breakpoint shadowing. 1446 Read LEN bytes at MEMADDR into a buffer at MYADDR. */ 1447static int 1448win32_read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) 1449{ 1450 return child_xfer_memory (memaddr, (char *) myaddr, len, 0, 0) != len; 1451} 1452 1453/* Write memory to the inferior process. This should generally be 1454 called through write_inferior_memory, which handles breakpoint shadowing. 1455 Write LEN bytes from the buffer at MYADDR to MEMADDR. 1456 Returns 0 on success and errno on failure. */ 1457static int 1458win32_write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr, 1459 int len) 1460{ 1461 return child_xfer_memory (memaddr, (char *) myaddr, len, 1, 0) != len; 1462} 1463 1464/* Send an interrupt request to the inferior process. */ 1465static void 1466win32_request_interrupt (void) 1467{ 1468 winapi_DebugBreakProcess DebugBreakProcess; 1469 winapi_GenerateConsoleCtrlEvent GenerateConsoleCtrlEvent; 1470 1471#ifdef _WIN32_WCE 1472 HMODULE dll = GetModuleHandle (_T("COREDLL.DLL")); 1473#else 1474 HMODULE dll = GetModuleHandle (_T("KERNEL32.DLL")); 1475#endif 1476 1477 GenerateConsoleCtrlEvent = GETPROCADDRESS (dll, GenerateConsoleCtrlEvent); 1478 1479 if (GenerateConsoleCtrlEvent != NULL 1480 && GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, current_process_id)) 1481 return; 1482 1483 /* GenerateConsoleCtrlEvent can fail if process id being debugged is 1484 not a process group id. 1485 Fallback to XP/Vista 'DebugBreakProcess', which generates a 1486 breakpoint exception in the interior process. */ 1487 1488 DebugBreakProcess = GETPROCADDRESS (dll, DebugBreakProcess); 1489 1490 if (DebugBreakProcess != NULL 1491 && DebugBreakProcess (current_process_handle)) 1492 return; 1493 1494 OUTMSG (("Could not interrupt process.\n")); 1495} 1496 1497static const char * 1498win32_arch_string (void) 1499{ 1500 return the_low_target.arch_string; 1501} 1502 1503static struct target_ops win32_target_ops = { 1504 win32_create_inferior, 1505 win32_attach, 1506 win32_kill, 1507 win32_detach, 1508 win32_join, 1509 win32_thread_alive, 1510 win32_resume, 1511 win32_wait, 1512 win32_fetch_inferior_registers, 1513 win32_store_inferior_registers, 1514 win32_read_inferior_memory, 1515 win32_write_inferior_memory, 1516 NULL, 1517 win32_request_interrupt, 1518 NULL, 1519 NULL, 1520 NULL, 1521 NULL, 1522 NULL, 1523 NULL, 1524 NULL, 1525 win32_arch_string 1526}; 1527 1528/* Initialize the Win32 backend. */ 1529void 1530initialize_low (void) 1531{ 1532 set_target_ops (&win32_target_ops); 1533 if (the_low_target.breakpoint != NULL) 1534 set_breakpoint_data (the_low_target.breakpoint, 1535 the_low_target.breakpoint_len); 1536 init_registers (); 1537} 1538