1 /* Target-vector operations for controlling windows child processes, for GDB. 2 3 Copyright (C) 1995-2020 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Solutions, A Red Hat Company. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* Originally by Steve Chamberlain, sac@cygnus.com */ 23 24 #include "defs.h" 25 #include "frame.h" /* required by inferior.h */ 26 #include "inferior.h" 27 #include "infrun.h" 28 #include "target.h" 29 #include "gdbcore.h" 30 #include "command.h" 31 #include "completer.h" 32 #include "regcache.h" 33 #include "top.h" 34 #include <signal.h> 35 #include <sys/types.h> 36 #include <fcntl.h> 37 #include <windows.h> 38 #include <imagehlp.h> 39 #include <psapi.h> 40 #ifdef __CYGWIN__ 41 #include <wchar.h> 42 #include <sys/cygwin.h> 43 #include <cygwin/version.h> 44 #endif 45 #include <algorithm> 46 #include <vector> 47 48 #include "filenames.h" 49 #include "symfile.h" 50 #include "objfiles.h" 51 #include "gdb_bfd.h" 52 #include "gdb_obstack.h" 53 #include "gdbthread.h" 54 #include "gdbcmd.h" 55 #include <unistd.h> 56 #include "exec.h" 57 #include "solist.h" 58 #include "solib.h" 59 #include "xml-support.h" 60 #include "inttypes.h" 61 62 #include "i386-tdep.h" 63 #include "i387-tdep.h" 64 65 #include "windows-tdep.h" 66 #include "windows-nat.h" 67 #include "x86-nat.h" 68 #include "complaints.h" 69 #include "inf-child.h" 70 #include "gdbsupport/gdb_tilde_expand.h" 71 #include "gdbsupport/pathstuff.h" 72 #include "gdbsupport/gdb_wait.h" 73 #include "nat/windows-nat.h" 74 75 using namespace windows_nat; 76 77 #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges 78 #define DebugActiveProcessStop dyn_DebugActiveProcessStop 79 #define DebugBreakProcess dyn_DebugBreakProcess 80 #define DebugSetProcessKillOnExit dyn_DebugSetProcessKillOnExit 81 #define EnumProcessModules dyn_EnumProcessModules 82 #define EnumProcessModulesEx dyn_EnumProcessModulesEx 83 #define GetModuleInformation dyn_GetModuleInformation 84 #define LookupPrivilegeValueA dyn_LookupPrivilegeValueA 85 #define OpenProcessToken dyn_OpenProcessToken 86 #define GetConsoleFontSize dyn_GetConsoleFontSize 87 #define GetCurrentConsoleFont dyn_GetCurrentConsoleFont 88 #define Wow64SuspendThread dyn_Wow64SuspendThread 89 #define Wow64GetThreadContext dyn_Wow64GetThreadContext 90 #define Wow64SetThreadContext dyn_Wow64SetThreadContext 91 #define Wow64GetThreadSelectorEntry dyn_Wow64GetThreadSelectorEntry 92 93 typedef BOOL WINAPI (AdjustTokenPrivileges_ftype) (HANDLE, BOOL, 94 PTOKEN_PRIVILEGES, 95 DWORD, PTOKEN_PRIVILEGES, 96 PDWORD); 97 static AdjustTokenPrivileges_ftype *AdjustTokenPrivileges; 98 99 typedef BOOL WINAPI (DebugActiveProcessStop_ftype) (DWORD); 100 static DebugActiveProcessStop_ftype *DebugActiveProcessStop; 101 102 typedef BOOL WINAPI (DebugBreakProcess_ftype) (HANDLE); 103 static DebugBreakProcess_ftype *DebugBreakProcess; 104 105 typedef BOOL WINAPI (DebugSetProcessKillOnExit_ftype) (BOOL); 106 static DebugSetProcessKillOnExit_ftype *DebugSetProcessKillOnExit; 107 108 typedef BOOL WINAPI (EnumProcessModules_ftype) (HANDLE, HMODULE *, DWORD, 109 LPDWORD); 110 static EnumProcessModules_ftype *EnumProcessModules; 111 112 #ifdef __x86_64__ 113 typedef BOOL WINAPI (EnumProcessModulesEx_ftype) (HANDLE, HMODULE *, DWORD, 114 LPDWORD, DWORD); 115 static EnumProcessModulesEx_ftype *EnumProcessModulesEx; 116 #endif 117 118 typedef BOOL WINAPI (GetModuleInformation_ftype) (HANDLE, HMODULE, 119 LPMODULEINFO, DWORD); 120 static GetModuleInformation_ftype *GetModuleInformation; 121 122 typedef BOOL WINAPI (LookupPrivilegeValueA_ftype) (LPCSTR, LPCSTR, PLUID); 123 static LookupPrivilegeValueA_ftype *LookupPrivilegeValueA; 124 125 typedef BOOL WINAPI (OpenProcessToken_ftype) (HANDLE, DWORD, PHANDLE); 126 static OpenProcessToken_ftype *OpenProcessToken; 127 128 typedef BOOL WINAPI (GetCurrentConsoleFont_ftype) (HANDLE, BOOL, 129 CONSOLE_FONT_INFO *); 130 static GetCurrentConsoleFont_ftype *GetCurrentConsoleFont; 131 132 typedef COORD WINAPI (GetConsoleFontSize_ftype) (HANDLE, DWORD); 133 static GetConsoleFontSize_ftype *GetConsoleFontSize; 134 135 #ifdef __x86_64__ 136 typedef DWORD WINAPI (Wow64SuspendThread_ftype) (HANDLE); 137 static Wow64SuspendThread_ftype *Wow64SuspendThread; 138 139 typedef BOOL WINAPI (Wow64GetThreadContext_ftype) (HANDLE, PWOW64_CONTEXT); 140 static Wow64GetThreadContext_ftype *Wow64GetThreadContext; 141 142 typedef BOOL WINAPI (Wow64SetThreadContext_ftype) (HANDLE, 143 const WOW64_CONTEXT *); 144 static Wow64SetThreadContext_ftype *Wow64SetThreadContext; 145 146 typedef BOOL WINAPI (Wow64GetThreadSelectorEntry_ftype) (HANDLE, DWORD, 147 PLDT_ENTRY); 148 static Wow64GetThreadSelectorEntry_ftype *Wow64GetThreadSelectorEntry; 149 #endif 150 151 #undef STARTUPINFO 152 #undef CreateProcess 153 #undef GetModuleFileNameEx 154 155 #ifndef __CYGWIN__ 156 # define __PMAX (MAX_PATH + 1) 157 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, LPSTR, DWORD); 158 static GetModuleFileNameEx_ftype *GetModuleFileNameEx; 159 # define STARTUPINFO STARTUPINFOA 160 # define CreateProcess CreateProcessA 161 # define GetModuleFileNameEx_name "GetModuleFileNameExA" 162 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExA 163 #else 164 # define __PMAX PATH_MAX 165 /* The starting and ending address of the cygwin1.dll text segment. */ 166 static CORE_ADDR cygwin_load_start; 167 static CORE_ADDR cygwin_load_end; 168 # define __USEWIDE 169 typedef wchar_t cygwin_buf_t; 170 typedef DWORD WINAPI (GetModuleFileNameEx_ftype) (HANDLE, HMODULE, 171 LPWSTR, DWORD); 172 static GetModuleFileNameEx_ftype *GetModuleFileNameEx; 173 # define STARTUPINFO STARTUPINFOW 174 # define CreateProcess CreateProcessW 175 # define GetModuleFileNameEx_name "GetModuleFileNameExW" 176 # define bad_GetModuleFileNameEx bad_GetModuleFileNameExW 177 #endif 178 179 static int have_saved_context; /* True if we've saved context from a 180 cygwin signal. */ 181 #ifdef __CYGWIN__ 182 static CONTEXT saved_context; /* Contains the saved context from a 183 cygwin signal. */ 184 #endif 185 186 /* If we're not using the old Cygwin header file set, define the 187 following which never should have been in the generic Win32 API 188 headers in the first place since they were our own invention... */ 189 #ifndef _GNU_H_WINDOWS_H 190 enum 191 { 192 FLAG_TRACE_BIT = 0x100, 193 }; 194 #endif 195 196 #ifndef CONTEXT_EXTENDED_REGISTERS 197 /* This macro is only defined on ia32. It only makes sense on this target, 198 so define it as zero if not already defined. */ 199 #define CONTEXT_EXTENDED_REGISTERS 0 200 #endif 201 202 #define CONTEXT_DEBUGGER_DR CONTEXT_FULL | CONTEXT_FLOATING_POINT \ 203 | CONTEXT_SEGMENTS | CONTEXT_DEBUG_REGISTERS \ 204 | CONTEXT_EXTENDED_REGISTERS 205 206 static uintptr_t dr[8]; 207 static int debug_registers_changed; 208 static int debug_registers_used; 209 210 static int windows_initialization_done; 211 #define DR6_CLEAR_VALUE 0xffff0ff0 212 213 /* The string sent by cygwin when it processes a signal. 214 FIXME: This should be in a cygwin include file. */ 215 #ifndef _CYGWIN_SIGNAL_STRING 216 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f" 217 #endif 218 219 #define CHECK(x) check (x, __FILE__,__LINE__) 220 #define DEBUG_EXEC(x) if (debug_exec) debug_printf x 221 #define DEBUG_EVENTS(x) if (debug_events) debug_printf x 222 #define DEBUG_MEM(x) if (debug_memory) debug_printf x 223 #define DEBUG_EXCEPT(x) if (debug_exceptions) debug_printf x 224 225 static void cygwin_set_dr (int i, CORE_ADDR addr); 226 static void cygwin_set_dr7 (unsigned long val); 227 static CORE_ADDR cygwin_get_dr (int i); 228 static unsigned long cygwin_get_dr6 (void); 229 static unsigned long cygwin_get_dr7 (void); 230 231 static std::vector<windows_thread_info *> thread_list; 232 233 /* Counts of things. */ 234 static int saw_create; 235 static int open_process_used = 0; 236 #ifdef __x86_64__ 237 static bool wow64_process = false; 238 #endif 239 240 /* User options. */ 241 static bool new_console = false; 242 #ifdef __CYGWIN__ 243 static bool cygwin_exceptions = false; 244 #endif 245 static bool new_group = true; 246 static bool debug_exec = false; /* show execution */ 247 static bool debug_events = false; /* show events from kernel */ 248 static bool debug_memory = false; /* show target memory accesses */ 249 static bool debug_exceptions = false; /* show target exceptions */ 250 static bool useshell = false; /* use shell for subprocesses */ 251 252 /* This vector maps GDB's idea of a register's number into an offset 253 in the windows exception context vector. 254 255 It also contains the bit mask needed to load the register in question. 256 257 The contents of this table can only be computed by the units 258 that provide CPU-specific support for Windows native debugging. 259 These units should set the table by calling 260 windows_set_context_register_offsets. 261 262 One day we could read a reg, we could inspect the context we 263 already have loaded, if it doesn't have the bit set that we need, 264 we read that set of registers in using GetThreadContext. If the 265 context already contains what we need, we just unpack it. Then to 266 write a register, first we have to ensure that the context contains 267 the other regs of the group, and then we copy the info in and set 268 out bit. */ 269 270 static const int *mappings; 271 272 /* The function to use in order to determine whether a register is 273 a segment register or not. */ 274 static segment_register_p_ftype *segment_register_p; 275 276 /* See windows_nat_target::resume to understand why this is commented 277 out. */ 278 #if 0 279 /* This vector maps the target's idea of an exception (extracted 280 from the DEBUG_EVENT structure) to GDB's idea. */ 281 282 struct xlate_exception 283 { 284 DWORD them; 285 enum gdb_signal us; 286 }; 287 288 static const struct xlate_exception xlate[] = 289 { 290 {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV}, 291 {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV}, 292 {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP}, 293 {DBG_CONTROL_C, GDB_SIGNAL_INT}, 294 {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP}, 295 {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE} 296 }; 297 298 #endif /* 0 */ 299 300 struct windows_nat_target final : public x86_nat_target<inf_child_target> 301 { 302 void close () override; 303 304 void attach (const char *, int) override; 305 306 bool attach_no_wait () override 307 { return true; } 308 309 void detach (inferior *, int) override; 310 311 void resume (ptid_t, int , enum gdb_signal) override; 312 313 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 314 315 void fetch_registers (struct regcache *, int) override; 316 void store_registers (struct regcache *, int) override; 317 318 bool stopped_by_sw_breakpoint () override 319 { 320 windows_thread_info *th 321 = thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT); 322 return th->stopped_at_software_breakpoint; 323 } 324 325 bool supports_stopped_by_sw_breakpoint () override 326 { 327 return true; 328 } 329 330 enum target_xfer_status xfer_partial (enum target_object object, 331 const char *annex, 332 gdb_byte *readbuf, 333 const gdb_byte *writebuf, 334 ULONGEST offset, ULONGEST len, 335 ULONGEST *xfered_len) override; 336 337 void files_info () override; 338 339 void kill () override; 340 341 void create_inferior (const char *, const std::string &, 342 char **, int) override; 343 344 void mourn_inferior () override; 345 346 bool thread_alive (ptid_t ptid) override; 347 348 std::string pid_to_str (ptid_t) override; 349 350 void interrupt () override; 351 352 char *pid_to_exec_file (int pid) override; 353 354 ptid_t get_ada_task_ptid (long lwp, long thread) override; 355 356 bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override; 357 358 const char *thread_name (struct thread_info *) override; 359 360 int get_windows_debug_event (int pid, struct target_waitstatus *ourstatus); 361 362 void do_initial_windows_stuff (DWORD pid, bool attaching); 363 }; 364 365 static windows_nat_target the_windows_nat_target; 366 367 /* Set the MAPPINGS static global to OFFSETS. 368 See the description of MAPPINGS for more details. */ 369 370 static void 371 windows_set_context_register_offsets (const int *offsets) 372 { 373 mappings = offsets; 374 } 375 376 /* Set the function that should be used by this module to determine 377 whether a given register is a segment register or not. */ 378 379 static void 380 windows_set_segment_register_p (segment_register_p_ftype *fun) 381 { 382 segment_register_p = fun; 383 } 384 385 static void 386 check (BOOL ok, const char *file, int line) 387 { 388 if (!ok) 389 printf_filtered ("error return %s:%d was %u\n", file, line, 390 (unsigned) GetLastError ()); 391 } 392 393 /* See nat/windows-nat.h. */ 394 395 windows_thread_info * 396 windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition) 397 { 398 for (windows_thread_info *th : thread_list) 399 if (th->tid == ptid.lwp ()) 400 { 401 if (!th->suspended) 402 { 403 switch (disposition) 404 { 405 case DONT_INVALIDATE_CONTEXT: 406 /* Nothing. */ 407 break; 408 case INVALIDATE_CONTEXT: 409 if (ptid.lwp () != current_event.dwThreadId) 410 th->suspend (); 411 th->reload_context = true; 412 break; 413 case DONT_SUSPEND: 414 th->reload_context = true; 415 th->suspended = -1; 416 break; 417 } 418 } 419 return th; 420 } 421 422 return NULL; 423 } 424 425 /* Add a thread to the thread list. 426 427 PTID is the ptid of the thread to be added. 428 H is its Windows handle. 429 TLB is its thread local base. 430 MAIN_THREAD_P should be true if the thread to be added is 431 the main thread, false otherwise. */ 432 433 static windows_thread_info * 434 windows_add_thread (ptid_t ptid, HANDLE h, void *tlb, bool main_thread_p) 435 { 436 windows_thread_info *th; 437 438 gdb_assert (ptid.lwp () != 0); 439 440 if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT))) 441 return th; 442 443 CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb; 444 #ifdef __x86_64__ 445 /* For WOW64 processes, this is actually the pointer to the 64bit TIB, 446 and the 32bit TIB is exactly 2 pages after it. */ 447 if (wow64_process) 448 base += 0x2000; 449 #endif 450 th = new windows_thread_info (ptid.lwp (), h, base); 451 thread_list.push_back (th); 452 453 /* Add this new thread to the list of threads. 454 455 To be consistent with what's done on other platforms, we add 456 the main thread silently (in reality, this thread is really 457 more of a process to the user than a thread). */ 458 if (main_thread_p) 459 add_thread_silent (&the_windows_nat_target, ptid); 460 else 461 add_thread (&the_windows_nat_target, ptid); 462 463 /* Set the debug registers for the new thread if they are used. */ 464 if (debug_registers_used) 465 { 466 #ifdef __x86_64__ 467 if (wow64_process) 468 { 469 /* Only change the value of the debug registers. */ 470 th->wow64_context.ContextFlags = CONTEXT_DEBUG_REGISTERS; 471 CHECK (Wow64GetThreadContext (th->h, &th->wow64_context)); 472 th->wow64_context.Dr0 = dr[0]; 473 th->wow64_context.Dr1 = dr[1]; 474 th->wow64_context.Dr2 = dr[2]; 475 th->wow64_context.Dr3 = dr[3]; 476 th->wow64_context.Dr6 = DR6_CLEAR_VALUE; 477 th->wow64_context.Dr7 = dr[7]; 478 CHECK (Wow64SetThreadContext (th->h, &th->wow64_context)); 479 th->wow64_context.ContextFlags = 0; 480 } 481 else 482 #endif 483 { 484 /* Only change the value of the debug registers. */ 485 th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS; 486 CHECK (GetThreadContext (th->h, &th->context)); 487 th->context.Dr0 = dr[0]; 488 th->context.Dr1 = dr[1]; 489 th->context.Dr2 = dr[2]; 490 th->context.Dr3 = dr[3]; 491 th->context.Dr6 = DR6_CLEAR_VALUE; 492 th->context.Dr7 = dr[7]; 493 CHECK (SetThreadContext (th->h, &th->context)); 494 th->context.ContextFlags = 0; 495 } 496 } 497 return th; 498 } 499 500 /* Clear out any old thread list and reinitialize it to a 501 pristine state. */ 502 static void 503 windows_init_thread_list (void) 504 { 505 DEBUG_EVENTS (("gdb: windows_init_thread_list\n")); 506 init_thread_list (); 507 508 for (windows_thread_info *here : thread_list) 509 delete here; 510 511 thread_list.clear (); 512 } 513 514 /* Delete a thread from the list of threads. 515 516 PTID is the ptid of the thread to be deleted. 517 EXIT_CODE is the thread's exit code. 518 MAIN_THREAD_P should be true if the thread to be deleted is 519 the main thread, false otherwise. */ 520 521 static void 522 windows_delete_thread (ptid_t ptid, DWORD exit_code, bool main_thread_p) 523 { 524 DWORD id; 525 526 gdb_assert (ptid.lwp () != 0); 527 528 id = ptid.lwp (); 529 530 /* Emit a notification about the thread being deleted. 531 532 Note that no notification was printed when the main thread 533 was created, and thus, unless in verbose mode, we should be 534 symmetrical, and avoid that notification for the main thread 535 here as well. */ 536 537 if (info_verbose) 538 printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid).c_str ()); 539 else if (print_thread_events && !main_thread_p) 540 printf_unfiltered (_("[%s exited with code %u]\n"), 541 target_pid_to_str (ptid).c_str (), 542 (unsigned) exit_code); 543 544 delete_thread (find_thread_ptid (&the_windows_nat_target, ptid)); 545 546 auto iter = std::find_if (thread_list.begin (), thread_list.end (), 547 [=] (windows_thread_info *th) 548 { 549 return th->tid == id; 550 }); 551 552 if (iter != thread_list.end ()) 553 { 554 delete *iter; 555 thread_list.erase (iter); 556 } 557 } 558 559 /* Fetches register number R from the given windows_thread_info, 560 and supplies its value to the given regcache. 561 562 This function assumes that R is non-negative. A failed assertion 563 is raised if that is not true. 564 565 This function assumes that TH->RELOAD_CONTEXT is not set, meaning 566 that the windows_thread_info has an up-to-date context. A failed 567 assertion is raised if that assumption is violated. */ 568 569 static void 570 windows_fetch_one_register (struct regcache *regcache, 571 windows_thread_info *th, int r) 572 { 573 gdb_assert (r >= 0); 574 gdb_assert (!th->reload_context); 575 576 char *context_ptr = (char *) &th->context; 577 #ifdef __x86_64__ 578 if (wow64_process) 579 context_ptr = (char *) &th->wow64_context; 580 #endif 581 582 char *context_offset = context_ptr + mappings[r]; 583 struct gdbarch *gdbarch = regcache->arch (); 584 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 585 586 gdb_assert (!gdbarch_read_pc_p (gdbarch)); 587 gdb_assert (gdbarch_pc_regnum (gdbarch) >= 0); 588 gdb_assert (!gdbarch_write_pc_p (gdbarch)); 589 590 if (r == I387_FISEG_REGNUM (tdep)) 591 { 592 long l = *((long *) context_offset) & 0xffff; 593 regcache->raw_supply (r, (char *) &l); 594 } 595 else if (r == I387_FOP_REGNUM (tdep)) 596 { 597 long l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1); 598 regcache->raw_supply (r, (char *) &l); 599 } 600 else if (segment_register_p (r)) 601 { 602 /* GDB treats segment registers as 32bit registers, but they are 603 in fact only 16 bits long. Make sure we do not read extra 604 bits from our source buffer. */ 605 long l = *((long *) context_offset) & 0xffff; 606 regcache->raw_supply (r, (char *) &l); 607 } 608 else 609 { 610 if (th->stopped_at_software_breakpoint 611 && !th->pc_adjusted 612 && r == gdbarch_pc_regnum (gdbarch)) 613 { 614 int size = register_size (gdbarch, r); 615 if (size == 4) 616 { 617 uint32_t value; 618 memcpy (&value, context_offset, size); 619 value -= gdbarch_decr_pc_after_break (gdbarch); 620 memcpy (context_offset, &value, size); 621 } 622 else 623 { 624 gdb_assert (size == 8); 625 uint64_t value; 626 memcpy (&value, context_offset, size); 627 value -= gdbarch_decr_pc_after_break (gdbarch); 628 memcpy (context_offset, &value, size); 629 } 630 /* Make sure we only rewrite the PC a single time. */ 631 th->pc_adjusted = true; 632 } 633 regcache->raw_supply (r, context_offset); 634 } 635 } 636 637 void 638 windows_nat_target::fetch_registers (struct regcache *regcache, int r) 639 { 640 windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT); 641 642 /* Check if TH exists. Windows sometimes uses a non-existent 643 thread id in its events. */ 644 if (th == NULL) 645 return; 646 647 if (th->reload_context) 648 { 649 #ifdef __CYGWIN__ 650 if (have_saved_context) 651 { 652 /* Lie about where the program actually is stopped since 653 cygwin has informed us that we should consider the signal 654 to have occurred at another location which is stored in 655 "saved_context. */ 656 memcpy (&th->context, &saved_context, 657 __COPY_CONTEXT_SIZE); 658 have_saved_context = 0; 659 } 660 else 661 #endif 662 #ifdef __x86_64__ 663 if (wow64_process) 664 { 665 th->wow64_context.ContextFlags = CONTEXT_DEBUGGER_DR; 666 CHECK (Wow64GetThreadContext (th->h, &th->wow64_context)); 667 /* Copy dr values from that thread. 668 But only if there were not modified since last stop. 669 PR gdb/2388 */ 670 if (!debug_registers_changed) 671 { 672 dr[0] = th->wow64_context.Dr0; 673 dr[1] = th->wow64_context.Dr1; 674 dr[2] = th->wow64_context.Dr2; 675 dr[3] = th->wow64_context.Dr3; 676 dr[6] = th->wow64_context.Dr6; 677 dr[7] = th->wow64_context.Dr7; 678 } 679 } 680 else 681 #endif 682 { 683 th->context.ContextFlags = CONTEXT_DEBUGGER_DR; 684 CHECK (GetThreadContext (th->h, &th->context)); 685 /* Copy dr values from that thread. 686 But only if there were not modified since last stop. 687 PR gdb/2388 */ 688 if (!debug_registers_changed) 689 { 690 dr[0] = th->context.Dr0; 691 dr[1] = th->context.Dr1; 692 dr[2] = th->context.Dr2; 693 dr[3] = th->context.Dr3; 694 dr[6] = th->context.Dr6; 695 dr[7] = th->context.Dr7; 696 } 697 } 698 th->reload_context = false; 699 } 700 701 if (r < 0) 702 for (r = 0; r < gdbarch_num_regs (regcache->arch()); r++) 703 windows_fetch_one_register (regcache, th, r); 704 else 705 windows_fetch_one_register (regcache, th, r); 706 } 707 708 /* Collect the register number R from the given regcache, and store 709 its value into the corresponding area of the given thread's context. 710 711 This function assumes that R is non-negative. A failed assertion 712 assertion is raised if that is not true. */ 713 714 static void 715 windows_store_one_register (const struct regcache *regcache, 716 windows_thread_info *th, int r) 717 { 718 gdb_assert (r >= 0); 719 720 char *context_ptr = (char *) &th->context; 721 #ifdef __x86_64__ 722 if (wow64_process) 723 context_ptr = (char *) &th->wow64_context; 724 #endif 725 726 regcache->raw_collect (r, context_ptr + mappings[r]); 727 } 728 729 /* Store a new register value into the context of the thread tied to 730 REGCACHE. */ 731 732 void 733 windows_nat_target::store_registers (struct regcache *regcache, int r) 734 { 735 windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT); 736 737 /* Check if TH exists. Windows sometimes uses a non-existent 738 thread id in its events. */ 739 if (th == NULL) 740 return; 741 742 if (r < 0) 743 for (r = 0; r < gdbarch_num_regs (regcache->arch ()); r++) 744 windows_store_one_register (regcache, th, r); 745 else 746 windows_store_one_register (regcache, th, r); 747 } 748 749 /* Maintain a linked list of "so" information. */ 750 struct lm_info_windows : public lm_info_base 751 { 752 LPVOID load_addr = 0; 753 CORE_ADDR text_offset = 0; 754 }; 755 756 static struct so_list solib_start, *solib_end; 757 758 static struct so_list * 759 windows_make_so (const char *name, LPVOID load_addr) 760 { 761 struct so_list *so; 762 char *p; 763 #ifndef __CYGWIN__ 764 char buf[__PMAX]; 765 char cwd[__PMAX]; 766 WIN32_FIND_DATA w32_fd; 767 HANDLE h = FindFirstFile(name, &w32_fd); 768 769 if (h == INVALID_HANDLE_VALUE) 770 strcpy (buf, name); 771 else 772 { 773 FindClose (h); 774 strcpy (buf, name); 775 if (GetCurrentDirectory (MAX_PATH + 1, cwd)) 776 { 777 p = strrchr (buf, '\\'); 778 if (p) 779 p[1] = '\0'; 780 SetCurrentDirectory (buf); 781 GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p); 782 SetCurrentDirectory (cwd); 783 } 784 } 785 if (strcasecmp (buf, "ntdll.dll") == 0) 786 { 787 GetSystemDirectory (buf, sizeof (buf)); 788 strcat (buf, "\\ntdll.dll"); 789 } 790 #else 791 cygwin_buf_t buf[__PMAX]; 792 793 buf[0] = 0; 794 if (access (name, F_OK) != 0) 795 { 796 if (strcasecmp (name, "ntdll.dll") == 0) 797 #ifdef __USEWIDE 798 { 799 GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t)); 800 wcscat (buf, L"\\ntdll.dll"); 801 } 802 #else 803 { 804 GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t)); 805 strcat (buf, "\\ntdll.dll"); 806 } 807 #endif 808 } 809 #endif 810 so = XCNEW (struct so_list); 811 lm_info_windows *li = new lm_info_windows; 812 so->lm_info = li; 813 li->load_addr = load_addr; 814 strcpy (so->so_original_name, name); 815 #ifndef __CYGWIN__ 816 strcpy (so->so_name, buf); 817 #else 818 if (buf[0]) 819 cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name, 820 SO_NAME_MAX_PATH_SIZE); 821 else 822 { 823 char *rname = realpath (name, NULL); 824 if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE) 825 { 826 strcpy (so->so_name, rname); 827 free (rname); 828 } 829 else 830 { 831 warning (_("dll path for \"%s\" too long or inaccessible"), name); 832 strcpy (so->so_name, so->so_original_name); 833 } 834 } 835 /* Record cygwin1.dll .text start/end. */ 836 p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1); 837 if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0) 838 { 839 asection *text = NULL; 840 841 gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386")); 842 843 if (abfd == NULL) 844 return so; 845 846 if (bfd_check_format (abfd.get (), bfd_object)) 847 text = bfd_get_section_by_name (abfd.get (), ".text"); 848 849 if (!text) 850 return so; 851 852 /* The symbols in a dll are offset by 0x1000, which is the 853 offset from 0 of the first byte in an image - because of the 854 file header and the section alignment. */ 855 cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) 856 load_addr + 0x1000); 857 cygwin_load_end = cygwin_load_start + bfd_section_size (text); 858 } 859 #endif 860 861 return so; 862 } 863 864 /* See nat/windows-nat.h. */ 865 866 void 867 windows_nat::handle_load_dll () 868 { 869 LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll; 870 const char *dll_name; 871 872 /* Try getting the DLL name via the lpImageName field of the event. 873 Note that Microsoft documents this fields as strictly optional, 874 in the sense that it might be NULL. And the first DLL event in 875 particular is explicitly documented as "likely not pass[ed]" 876 (source: MSDN LOAD_DLL_DEBUG_INFO structure). */ 877 dll_name = get_image_name (current_process_handle, 878 event->lpImageName, event->fUnicode); 879 if (!dll_name) 880 return; 881 882 solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll); 883 solib_end = solib_end->next; 884 885 lm_info_windows *li = (lm_info_windows *) solib_end->lm_info; 886 887 DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name, 888 host_address_to_string (li->load_addr))); 889 } 890 891 static void 892 windows_free_so (struct so_list *so) 893 { 894 lm_info_windows *li = (lm_info_windows *) so->lm_info; 895 896 delete li; 897 xfree (so); 898 } 899 900 /* See nat/windows-nat.h. */ 901 902 void 903 windows_nat::handle_unload_dll () 904 { 905 LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll; 906 struct so_list *so; 907 908 for (so = &solib_start; so->next != NULL; so = so->next) 909 { 910 lm_info_windows *li_next = (lm_info_windows *) so->next->lm_info; 911 912 if (li_next->load_addr == lpBaseOfDll) 913 { 914 struct so_list *sodel = so->next; 915 916 so->next = sodel->next; 917 if (!so->next) 918 solib_end = so; 919 DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name)); 920 921 windows_free_so (sodel); 922 return; 923 } 924 } 925 926 /* We did not find any DLL that was previously loaded at this address, 927 so register a complaint. We do not report an error, because we have 928 observed that this may be happening under some circumstances. For 929 instance, running 32bit applications on x64 Windows causes us to receive 930 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these 931 events are apparently caused by the WOW layer, the interface between 932 32bit and 64bit worlds). */ 933 complaint (_("dll starting at %s not found."), 934 host_address_to_string (lpBaseOfDll)); 935 } 936 937 /* Call FUNC wrapped in a TRY/CATCH that swallows all GDB 938 exceptions. */ 939 940 static void 941 catch_errors (void (*func) ()) 942 { 943 try 944 { 945 func (); 946 } 947 catch (const gdb_exception &ex) 948 { 949 exception_print (gdb_stderr, ex); 950 } 951 } 952 953 /* Clear list of loaded DLLs. */ 954 static void 955 windows_clear_solib (void) 956 { 957 struct so_list *so; 958 959 for (so = solib_start.next; so; so = solib_start.next) 960 { 961 solib_start.next = so->next; 962 windows_free_so (so); 963 } 964 965 solib_end = &solib_start; 966 } 967 968 static void 969 signal_event_command (const char *args, int from_tty) 970 { 971 uintptr_t event_id = 0; 972 char *endargs = NULL; 973 974 if (args == NULL) 975 error (_("signal-event requires an argument (integer event id)")); 976 977 event_id = strtoumax (args, &endargs, 10); 978 979 if ((errno == ERANGE) || (event_id == 0) || (event_id > UINTPTR_MAX) || 980 ((HANDLE) event_id == INVALID_HANDLE_VALUE)) 981 error (_("Failed to convert `%s' to event id"), args); 982 983 SetEvent ((HANDLE) event_id); 984 CloseHandle ((HANDLE) event_id); 985 } 986 987 /* See nat/windows-nat.h. */ 988 989 int 990 windows_nat::handle_output_debug_string (struct target_waitstatus *ourstatus) 991 { 992 int retval = 0; 993 994 gdb::unique_xmalloc_ptr<char> s 995 = (target_read_string 996 ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData, 997 1024)); 998 if (s == nullptr || !*(s.get ())) 999 /* nothing to do */; 1000 else if (!startswith (s.get (), _CYGWIN_SIGNAL_STRING)) 1001 { 1002 #ifdef __CYGWIN__ 1003 if (!startswith (s.get (), "cYg")) 1004 #endif 1005 { 1006 char *p = strchr (s.get (), '\0'); 1007 1008 if (p > s.get () && *--p == '\n') 1009 *p = '\0'; 1010 warning (("%s"), s.get ()); 1011 } 1012 } 1013 #ifdef __CYGWIN__ 1014 else 1015 { 1016 /* Got a cygwin signal marker. A cygwin signal is followed by 1017 the signal number itself and then optionally followed by the 1018 thread id and address to saved context within the DLL. If 1019 these are supplied, then the given thread is assumed to have 1020 issued the signal and the context from the thread is assumed 1021 to be stored at the given address in the inferior. Tell gdb 1022 to treat this like a real signal. */ 1023 char *p; 1024 int sig = strtol (s.get () + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0); 1025 gdb_signal gotasig = gdb_signal_from_host (sig); 1026 1027 ourstatus->value.sig = gotasig; 1028 if (gotasig) 1029 { 1030 LPCVOID x; 1031 SIZE_T n; 1032 1033 ourstatus->kind = TARGET_WAITKIND_STOPPED; 1034 retval = strtoul (p, &p, 0); 1035 if (!retval) 1036 retval = current_event.dwThreadId; 1037 else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0)) 1038 && ReadProcessMemory (current_process_handle, x, 1039 &saved_context, 1040 __COPY_CONTEXT_SIZE, &n) 1041 && n == __COPY_CONTEXT_SIZE) 1042 have_saved_context = 1; 1043 } 1044 } 1045 #endif 1046 1047 return retval; 1048 } 1049 1050 static int 1051 display_selector (HANDLE thread, DWORD sel) 1052 { 1053 LDT_ENTRY info; 1054 BOOL ret; 1055 #ifdef __x86_64__ 1056 if (wow64_process) 1057 ret = Wow64GetThreadSelectorEntry (thread, sel, &info); 1058 else 1059 #endif 1060 ret = GetThreadSelectorEntry (thread, sel, &info); 1061 if (ret) 1062 { 1063 int base, limit; 1064 printf_filtered ("0x%03x: ", (unsigned) sel); 1065 if (!info.HighWord.Bits.Pres) 1066 { 1067 puts_filtered ("Segment not present\n"); 1068 return 0; 1069 } 1070 base = (info.HighWord.Bits.BaseHi << 24) + 1071 (info.HighWord.Bits.BaseMid << 16) 1072 + info.BaseLow; 1073 limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow; 1074 if (info.HighWord.Bits.Granularity) 1075 limit = (limit << 12) | 0xfff; 1076 printf_filtered ("base=0x%08x limit=0x%08x", base, limit); 1077 if (info.HighWord.Bits.Default_Big) 1078 puts_filtered(" 32-bit "); 1079 else 1080 puts_filtered(" 16-bit "); 1081 switch ((info.HighWord.Bits.Type & 0xf) >> 1) 1082 { 1083 case 0: 1084 puts_filtered ("Data (Read-Only, Exp-up"); 1085 break; 1086 case 1: 1087 puts_filtered ("Data (Read/Write, Exp-up"); 1088 break; 1089 case 2: 1090 puts_filtered ("Unused segment ("); 1091 break; 1092 case 3: 1093 puts_filtered ("Data (Read/Write, Exp-down"); 1094 break; 1095 case 4: 1096 puts_filtered ("Code (Exec-Only, N.Conf"); 1097 break; 1098 case 5: 1099 puts_filtered ("Code (Exec/Read, N.Conf"); 1100 break; 1101 case 6: 1102 puts_filtered ("Code (Exec-Only, Conf"); 1103 break; 1104 case 7: 1105 puts_filtered ("Code (Exec/Read, Conf"); 1106 break; 1107 default: 1108 printf_filtered ("Unknown type 0x%lx", 1109 (unsigned long) info.HighWord.Bits.Type); 1110 } 1111 if ((info.HighWord.Bits.Type & 0x1) == 0) 1112 puts_filtered(", N.Acc"); 1113 puts_filtered (")\n"); 1114 if ((info.HighWord.Bits.Type & 0x10) == 0) 1115 puts_filtered("System selector "); 1116 printf_filtered ("Priviledge level = %ld. ", 1117 (unsigned long) info.HighWord.Bits.Dpl); 1118 if (info.HighWord.Bits.Granularity) 1119 puts_filtered ("Page granular.\n"); 1120 else 1121 puts_filtered ("Byte granular.\n"); 1122 return 1; 1123 } 1124 else 1125 { 1126 DWORD err = GetLastError (); 1127 if (err == ERROR_NOT_SUPPORTED) 1128 printf_filtered ("Function not supported\n"); 1129 else 1130 printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel); 1131 return 0; 1132 } 1133 } 1134 1135 static void 1136 display_selectors (const char * args, int from_tty) 1137 { 1138 if (inferior_ptid == null_ptid) 1139 { 1140 puts_filtered ("Impossible to display selectors now.\n"); 1141 return; 1142 } 1143 1144 windows_thread_info *current_windows_thread 1145 = thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT); 1146 1147 if (!args) 1148 { 1149 #ifdef __x86_64__ 1150 if (wow64_process) 1151 { 1152 puts_filtered ("Selector $cs\n"); 1153 display_selector (current_windows_thread->h, 1154 current_windows_thread->wow64_context.SegCs); 1155 puts_filtered ("Selector $ds\n"); 1156 display_selector (current_windows_thread->h, 1157 current_windows_thread->wow64_context.SegDs); 1158 puts_filtered ("Selector $es\n"); 1159 display_selector (current_windows_thread->h, 1160 current_windows_thread->wow64_context.SegEs); 1161 puts_filtered ("Selector $ss\n"); 1162 display_selector (current_windows_thread->h, 1163 current_windows_thread->wow64_context.SegSs); 1164 puts_filtered ("Selector $fs\n"); 1165 display_selector (current_windows_thread->h, 1166 current_windows_thread->wow64_context.SegFs); 1167 puts_filtered ("Selector $gs\n"); 1168 display_selector (current_windows_thread->h, 1169 current_windows_thread->wow64_context.SegGs); 1170 } 1171 else 1172 #endif 1173 { 1174 puts_filtered ("Selector $cs\n"); 1175 display_selector (current_windows_thread->h, 1176 current_windows_thread->context.SegCs); 1177 puts_filtered ("Selector $ds\n"); 1178 display_selector (current_windows_thread->h, 1179 current_windows_thread->context.SegDs); 1180 puts_filtered ("Selector $es\n"); 1181 display_selector (current_windows_thread->h, 1182 current_windows_thread->context.SegEs); 1183 puts_filtered ("Selector $ss\n"); 1184 display_selector (current_windows_thread->h, 1185 current_windows_thread->context.SegSs); 1186 puts_filtered ("Selector $fs\n"); 1187 display_selector (current_windows_thread->h, 1188 current_windows_thread->context.SegFs); 1189 puts_filtered ("Selector $gs\n"); 1190 display_selector (current_windows_thread->h, 1191 current_windows_thread->context.SegGs); 1192 } 1193 } 1194 else 1195 { 1196 int sel; 1197 sel = parse_and_eval_long (args); 1198 printf_filtered ("Selector \"%s\"\n",args); 1199 display_selector (current_windows_thread->h, sel); 1200 } 1201 } 1202 1203 /* See nat/windows-nat.h. */ 1204 1205 bool 1206 windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec) 1207 { 1208 if (rec->NumberParameters >= 3 1209 && (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000) 1210 { 1211 DWORD named_thread_id; 1212 windows_thread_info *named_thread; 1213 CORE_ADDR thread_name_target; 1214 1215 thread_name_target = rec->ExceptionInformation[1]; 1216 named_thread_id = (DWORD) (0xffffffff & rec->ExceptionInformation[2]); 1217 1218 if (named_thread_id == (DWORD) -1) 1219 named_thread_id = current_event.dwThreadId; 1220 1221 named_thread = thread_rec (ptid_t (current_event.dwProcessId, 1222 named_thread_id, 0), 1223 DONT_INVALIDATE_CONTEXT); 1224 if (named_thread != NULL) 1225 { 1226 int thread_name_len; 1227 gdb::unique_xmalloc_ptr<char> thread_name 1228 = target_read_string (thread_name_target, 1025, &thread_name_len); 1229 if (thread_name_len > 0) 1230 { 1231 thread_name.get ()[thread_name_len - 1] = '\0'; 1232 named_thread->name = std::move (thread_name); 1233 } 1234 } 1235 1236 return true; 1237 } 1238 1239 return false; 1240 } 1241 1242 /* See nat/windows-nat.h. */ 1243 1244 bool 1245 windows_nat::handle_access_violation (const EXCEPTION_RECORD *rec) 1246 { 1247 #ifdef __CYGWIN__ 1248 /* See if the access violation happened within the cygwin DLL 1249 itself. Cygwin uses a kind of exception handling to deal with 1250 passed-in invalid addresses. gdb should not treat these as real 1251 SEGVs since they will be silently handled by cygwin. A real SEGV 1252 will (theoretically) be caught by cygwin later in the process and 1253 will be sent as a cygwin-specific-signal. So, ignore SEGVs if 1254 they show up within the text segment of the DLL itself. */ 1255 const char *fn; 1256 CORE_ADDR addr = (CORE_ADDR) (uintptr_t) rec->ExceptionAddress; 1257 1258 if ((!cygwin_exceptions && (addr >= cygwin_load_start 1259 && addr < cygwin_load_end)) 1260 || (find_pc_partial_function (addr, &fn, NULL, NULL) 1261 && startswith (fn, "KERNEL32!IsBad"))) 1262 return true; 1263 #endif 1264 return false; 1265 } 1266 1267 /* Resume thread specified by ID, or all artificially suspended 1268 threads, if we are continuing execution. KILLED non-zero means we 1269 have killed the inferior, so we should ignore weird errors due to 1270 threads shutting down. */ 1271 static BOOL 1272 windows_continue (DWORD continue_status, int id, int killed) 1273 { 1274 BOOL res; 1275 1276 desired_stop_thread_id = id; 1277 1278 if (matching_pending_stop (debug_events)) 1279 return TRUE; 1280 1281 for (windows_thread_info *th : thread_list) 1282 if (id == -1 || id == (int) th->tid) 1283 { 1284 if (!th->suspended) 1285 continue; 1286 #ifdef __x86_64__ 1287 if (wow64_process) 1288 { 1289 if (debug_registers_changed) 1290 { 1291 th->wow64_context.ContextFlags |= CONTEXT_DEBUG_REGISTERS; 1292 th->wow64_context.Dr0 = dr[0]; 1293 th->wow64_context.Dr1 = dr[1]; 1294 th->wow64_context.Dr2 = dr[2]; 1295 th->wow64_context.Dr3 = dr[3]; 1296 th->wow64_context.Dr6 = DR6_CLEAR_VALUE; 1297 th->wow64_context.Dr7 = dr[7]; 1298 } 1299 if (th->wow64_context.ContextFlags) 1300 { 1301 DWORD ec = 0; 1302 1303 if (GetExitCodeThread (th->h, &ec) 1304 && ec == STILL_ACTIVE) 1305 { 1306 BOOL status = Wow64SetThreadContext (th->h, 1307 &th->wow64_context); 1308 1309 if (!killed) 1310 CHECK (status); 1311 } 1312 th->wow64_context.ContextFlags = 0; 1313 } 1314 } 1315 else 1316 #endif 1317 { 1318 if (debug_registers_changed) 1319 { 1320 th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS; 1321 th->context.Dr0 = dr[0]; 1322 th->context.Dr1 = dr[1]; 1323 th->context.Dr2 = dr[2]; 1324 th->context.Dr3 = dr[3]; 1325 th->context.Dr6 = DR6_CLEAR_VALUE; 1326 th->context.Dr7 = dr[7]; 1327 } 1328 if (th->context.ContextFlags) 1329 { 1330 DWORD ec = 0; 1331 1332 if (GetExitCodeThread (th->h, &ec) 1333 && ec == STILL_ACTIVE) 1334 { 1335 BOOL status = SetThreadContext (th->h, &th->context); 1336 1337 if (!killed) 1338 CHECK (status); 1339 } 1340 th->context.ContextFlags = 0; 1341 } 1342 } 1343 th->resume (); 1344 } 1345 else 1346 { 1347 /* When single-stepping a specific thread, other threads must 1348 be suspended. */ 1349 th->suspend (); 1350 } 1351 1352 res = continue_last_debug_event (continue_status, debug_events); 1353 1354 if (!res) 1355 error (_("Failed to resume program execution" 1356 " (ContinueDebugEvent failed, error %u)"), 1357 (unsigned int) GetLastError ()); 1358 1359 debug_registers_changed = 0; 1360 return res; 1361 } 1362 1363 /* Called in pathological case where Windows fails to send a 1364 CREATE_PROCESS_DEBUG_EVENT after an attach. */ 1365 static DWORD 1366 fake_create_process (void) 1367 { 1368 current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE, 1369 current_event.dwProcessId); 1370 if (current_process_handle != NULL) 1371 open_process_used = 1; 1372 else 1373 { 1374 error (_("OpenProcess call failed, GetLastError = %u"), 1375 (unsigned) GetLastError ()); 1376 /* We can not debug anything in that case. */ 1377 } 1378 windows_add_thread (ptid_t (current_event.dwProcessId, 0, 1379 current_event.dwThreadId), 1380 current_event.u.CreateThread.hThread, 1381 current_event.u.CreateThread.lpThreadLocalBase, 1382 true /* main_thread_p */); 1383 return current_event.dwThreadId; 1384 } 1385 1386 void 1387 windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig) 1388 { 1389 windows_thread_info *th; 1390 DWORD continue_status = DBG_CONTINUE; 1391 1392 /* A specific PTID means `step only this thread id'. */ 1393 int resume_all = ptid == minus_one_ptid; 1394 1395 /* If we're continuing all threads, it's the current inferior that 1396 should be handled specially. */ 1397 if (resume_all) 1398 ptid = inferior_ptid; 1399 1400 if (sig != GDB_SIGNAL_0) 1401 { 1402 if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) 1403 { 1404 DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig)); 1405 } 1406 else if (sig == last_sig) 1407 continue_status = DBG_EXCEPTION_NOT_HANDLED; 1408 else 1409 #if 0 1410 /* This code does not seem to work, because 1411 the kernel does probably not consider changes in the ExceptionRecord 1412 structure when passing the exception to the inferior. 1413 Note that this seems possible in the exception handler itself. */ 1414 { 1415 for (const xlate_exception &x : xlate) 1416 if (x.us == sig) 1417 { 1418 current_event.u.Exception.ExceptionRecord.ExceptionCode 1419 = x.them; 1420 continue_status = DBG_EXCEPTION_NOT_HANDLED; 1421 break; 1422 } 1423 if (continue_status == DBG_CONTINUE) 1424 { 1425 DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig)); 1426 } 1427 } 1428 #endif 1429 DEBUG_EXCEPT(("Can only continue with received signal %d.\n", 1430 last_sig)); 1431 } 1432 1433 last_sig = GDB_SIGNAL_0; 1434 1435 DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n", 1436 ptid.pid (), (unsigned) ptid.lwp (), step, sig)); 1437 1438 /* Get context for currently selected thread. */ 1439 th = thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT); 1440 if (th) 1441 { 1442 #ifdef __x86_64__ 1443 if (wow64_process) 1444 { 1445 if (step) 1446 { 1447 /* Single step by setting t bit. */ 1448 struct regcache *regcache = get_current_regcache (); 1449 struct gdbarch *gdbarch = regcache->arch (); 1450 fetch_registers (regcache, gdbarch_ps_regnum (gdbarch)); 1451 th->wow64_context.EFlags |= FLAG_TRACE_BIT; 1452 } 1453 1454 if (th->wow64_context.ContextFlags) 1455 { 1456 if (debug_registers_changed) 1457 { 1458 th->wow64_context.Dr0 = dr[0]; 1459 th->wow64_context.Dr1 = dr[1]; 1460 th->wow64_context.Dr2 = dr[2]; 1461 th->wow64_context.Dr3 = dr[3]; 1462 th->wow64_context.Dr6 = DR6_CLEAR_VALUE; 1463 th->wow64_context.Dr7 = dr[7]; 1464 } 1465 CHECK (Wow64SetThreadContext (th->h, &th->wow64_context)); 1466 th->wow64_context.ContextFlags = 0; 1467 } 1468 } 1469 else 1470 #endif 1471 { 1472 if (step) 1473 { 1474 /* Single step by setting t bit. */ 1475 struct regcache *regcache = get_current_regcache (); 1476 struct gdbarch *gdbarch = regcache->arch (); 1477 fetch_registers (regcache, gdbarch_ps_regnum (gdbarch)); 1478 th->context.EFlags |= FLAG_TRACE_BIT; 1479 } 1480 1481 if (th->context.ContextFlags) 1482 { 1483 if (debug_registers_changed) 1484 { 1485 th->context.Dr0 = dr[0]; 1486 th->context.Dr1 = dr[1]; 1487 th->context.Dr2 = dr[2]; 1488 th->context.Dr3 = dr[3]; 1489 th->context.Dr6 = DR6_CLEAR_VALUE; 1490 th->context.Dr7 = dr[7]; 1491 } 1492 CHECK (SetThreadContext (th->h, &th->context)); 1493 th->context.ContextFlags = 0; 1494 } 1495 } 1496 } 1497 1498 /* Allow continuing with the same signal that interrupted us. 1499 Otherwise complain. */ 1500 1501 if (resume_all) 1502 windows_continue (continue_status, -1, 0); 1503 else 1504 windows_continue (continue_status, ptid.lwp (), 0); 1505 } 1506 1507 /* Ctrl-C handler used when the inferior is not run in the same console. The 1508 handler is in charge of interrupting the inferior using DebugBreakProcess. 1509 Note that this function is not available prior to Windows XP. In this case 1510 we emit a warning. */ 1511 static BOOL WINAPI 1512 ctrl_c_handler (DWORD event_type) 1513 { 1514 const int attach_flag = current_inferior ()->attach_flag; 1515 1516 /* Only handle Ctrl-C and Ctrl-Break events. Ignore others. */ 1517 if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT) 1518 return FALSE; 1519 1520 /* If the inferior and the debugger share the same console, do nothing as 1521 the inferior has also received the Ctrl-C event. */ 1522 if (!new_console && !attach_flag) 1523 return TRUE; 1524 1525 if (!DebugBreakProcess (current_process_handle)) 1526 warning (_("Could not interrupt program. " 1527 "Press Ctrl-c in the program console.")); 1528 1529 /* Return true to tell that Ctrl-C has been handled. */ 1530 return TRUE; 1531 } 1532 1533 /* Get the next event from the child. Returns a non-zero thread id if the event 1534 requires handling by WFI (or whatever). */ 1535 1536 int 1537 windows_nat_target::get_windows_debug_event (int pid, 1538 struct target_waitstatus *ourstatus) 1539 { 1540 BOOL debug_event; 1541 DWORD continue_status, event_code; 1542 DWORD thread_id = 0; 1543 1544 /* If there is a relevant pending stop, report it now. See the 1545 comment by the definition of "pending_stops" for details on why 1546 this is needed. */ 1547 gdb::optional<pending_stop> stop = fetch_pending_stop (debug_events); 1548 if (stop.has_value ()) 1549 { 1550 thread_id = stop->thread_id; 1551 *ourstatus = stop->status; 1552 1553 ptid_t ptid (current_event.dwProcessId, thread_id); 1554 windows_thread_info *th = thread_rec (ptid, INVALIDATE_CONTEXT); 1555 th->reload_context = 1; 1556 1557 return thread_id; 1558 } 1559 1560 last_sig = GDB_SIGNAL_0; 1561 1562 if (!(debug_event = wait_for_debug_event (¤t_event, 1000))) 1563 goto out; 1564 1565 continue_status = DBG_CONTINUE; 1566 1567 event_code = current_event.dwDebugEventCode; 1568 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 1569 have_saved_context = 0; 1570 1571 switch (event_code) 1572 { 1573 case CREATE_THREAD_DEBUG_EVENT: 1574 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1575 (unsigned) current_event.dwProcessId, 1576 (unsigned) current_event.dwThreadId, 1577 "CREATE_THREAD_DEBUG_EVENT")); 1578 if (saw_create != 1) 1579 { 1580 inferior *inf = find_inferior_pid (this, current_event.dwProcessId); 1581 if (!saw_create && inf->attach_flag) 1582 { 1583 /* Kludge around a Windows bug where first event is a create 1584 thread event. Caused when attached process does not have 1585 a main thread. */ 1586 thread_id = fake_create_process (); 1587 if (thread_id) 1588 saw_create++; 1589 } 1590 break; 1591 } 1592 /* Record the existence of this thread. */ 1593 thread_id = current_event.dwThreadId; 1594 windows_add_thread 1595 (ptid_t (current_event.dwProcessId, current_event.dwThreadId, 0), 1596 current_event.u.CreateThread.hThread, 1597 current_event.u.CreateThread.lpThreadLocalBase, 1598 false /* main_thread_p */); 1599 1600 break; 1601 1602 case EXIT_THREAD_DEBUG_EVENT: 1603 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1604 (unsigned) current_event.dwProcessId, 1605 (unsigned) current_event.dwThreadId, 1606 "EXIT_THREAD_DEBUG_EVENT")); 1607 windows_delete_thread (ptid_t (current_event.dwProcessId, 1608 current_event.dwThreadId, 0), 1609 current_event.u.ExitThread.dwExitCode, 1610 false /* main_thread_p */); 1611 break; 1612 1613 case CREATE_PROCESS_DEBUG_EVENT: 1614 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1615 (unsigned) current_event.dwProcessId, 1616 (unsigned) current_event.dwThreadId, 1617 "CREATE_PROCESS_DEBUG_EVENT")); 1618 CloseHandle (current_event.u.CreateProcessInfo.hFile); 1619 if (++saw_create != 1) 1620 break; 1621 1622 current_process_handle = current_event.u.CreateProcessInfo.hProcess; 1623 /* Add the main thread. */ 1624 windows_add_thread 1625 (ptid_t (current_event.dwProcessId, 1626 current_event.dwThreadId, 0), 1627 current_event.u.CreateProcessInfo.hThread, 1628 current_event.u.CreateProcessInfo.lpThreadLocalBase, 1629 true /* main_thread_p */); 1630 thread_id = current_event.dwThreadId; 1631 break; 1632 1633 case EXIT_PROCESS_DEBUG_EVENT: 1634 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1635 (unsigned) current_event.dwProcessId, 1636 (unsigned) current_event.dwThreadId, 1637 "EXIT_PROCESS_DEBUG_EVENT")); 1638 if (!windows_initialization_done) 1639 { 1640 target_terminal::ours (); 1641 target_mourn_inferior (inferior_ptid); 1642 error (_("During startup program exited with code 0x%x."), 1643 (unsigned int) current_event.u.ExitProcess.dwExitCode); 1644 } 1645 else if (saw_create == 1) 1646 { 1647 windows_delete_thread (ptid_t (current_event.dwProcessId, 1648 current_event.dwThreadId, 0), 1649 0, true /* main_thread_p */); 1650 DWORD exit_status = current_event.u.ExitProcess.dwExitCode; 1651 /* If the exit status looks like a fatal exception, but we 1652 don't recognize the exception's code, make the original 1653 exit status value available, to avoid losing 1654 information. */ 1655 int exit_signal 1656 = WIFSIGNALED (exit_status) ? WTERMSIG (exit_status) : -1; 1657 if (exit_signal == -1) 1658 { 1659 ourstatus->kind = TARGET_WAITKIND_EXITED; 1660 ourstatus->value.integer = exit_status; 1661 } 1662 else 1663 { 1664 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 1665 ourstatus->value.sig = gdb_signal_from_host (exit_signal); 1666 } 1667 thread_id = current_event.dwThreadId; 1668 } 1669 break; 1670 1671 case LOAD_DLL_DEBUG_EVENT: 1672 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1673 (unsigned) current_event.dwProcessId, 1674 (unsigned) current_event.dwThreadId, 1675 "LOAD_DLL_DEBUG_EVENT")); 1676 CloseHandle (current_event.u.LoadDll.hFile); 1677 if (saw_create != 1 || ! windows_initialization_done) 1678 break; 1679 catch_errors (handle_load_dll); 1680 ourstatus->kind = TARGET_WAITKIND_LOADED; 1681 ourstatus->value.integer = 0; 1682 thread_id = current_event.dwThreadId; 1683 break; 1684 1685 case UNLOAD_DLL_DEBUG_EVENT: 1686 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1687 (unsigned) current_event.dwProcessId, 1688 (unsigned) current_event.dwThreadId, 1689 "UNLOAD_DLL_DEBUG_EVENT")); 1690 if (saw_create != 1 || ! windows_initialization_done) 1691 break; 1692 catch_errors (handle_unload_dll); 1693 ourstatus->kind = TARGET_WAITKIND_LOADED; 1694 ourstatus->value.integer = 0; 1695 thread_id = current_event.dwThreadId; 1696 break; 1697 1698 case EXCEPTION_DEBUG_EVENT: 1699 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1700 (unsigned) current_event.dwProcessId, 1701 (unsigned) current_event.dwThreadId, 1702 "EXCEPTION_DEBUG_EVENT")); 1703 if (saw_create != 1) 1704 break; 1705 switch (handle_exception (ourstatus, debug_exceptions)) 1706 { 1707 case HANDLE_EXCEPTION_UNHANDLED: 1708 default: 1709 continue_status = DBG_EXCEPTION_NOT_HANDLED; 1710 break; 1711 case HANDLE_EXCEPTION_HANDLED: 1712 thread_id = current_event.dwThreadId; 1713 break; 1714 case HANDLE_EXCEPTION_IGNORED: 1715 continue_status = DBG_CONTINUE; 1716 break; 1717 } 1718 break; 1719 1720 case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */ 1721 DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n", 1722 (unsigned) current_event.dwProcessId, 1723 (unsigned) current_event.dwThreadId, 1724 "OUTPUT_DEBUG_STRING_EVENT")); 1725 if (saw_create != 1) 1726 break; 1727 thread_id = handle_output_debug_string (ourstatus); 1728 break; 1729 1730 default: 1731 if (saw_create != 1) 1732 break; 1733 printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n", 1734 (unsigned) current_event.dwProcessId, 1735 (unsigned) current_event.dwThreadId); 1736 printf_unfiltered (" unknown event code %u\n", 1737 (unsigned) current_event.dwDebugEventCode); 1738 break; 1739 } 1740 1741 if (!thread_id || saw_create != 1) 1742 { 1743 CHECK (windows_continue (continue_status, desired_stop_thread_id, 0)); 1744 } 1745 else if (desired_stop_thread_id != -1 && desired_stop_thread_id != thread_id) 1746 { 1747 /* Pending stop. See the comment by the definition of 1748 "pending_stops" for details on why this is needed. */ 1749 DEBUG_EVENTS (("get_windows_debug_event - " 1750 "unexpected stop in 0x%x (expecting 0x%x)\n", 1751 thread_id, desired_stop_thread_id)); 1752 1753 if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT 1754 && ((current_event.u.Exception.ExceptionRecord.ExceptionCode 1755 == EXCEPTION_BREAKPOINT) 1756 || (current_event.u.Exception.ExceptionRecord.ExceptionCode 1757 == STATUS_WX86_BREAKPOINT)) 1758 && windows_initialization_done) 1759 { 1760 ptid_t ptid = ptid_t (current_event.dwProcessId, thread_id, 0); 1761 windows_thread_info *th = thread_rec (ptid, INVALIDATE_CONTEXT); 1762 th->stopped_at_software_breakpoint = true; 1763 th->pc_adjusted = false; 1764 } 1765 pending_stops.push_back ({thread_id, *ourstatus, current_event}); 1766 thread_id = 0; 1767 CHECK (windows_continue (continue_status, desired_stop_thread_id, 0)); 1768 } 1769 1770 out: 1771 return thread_id; 1772 } 1773 1774 /* Wait for interesting events to occur in the target process. */ 1775 ptid_t 1776 windows_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 1777 int options) 1778 { 1779 int pid = -1; 1780 1781 /* We loop when we get a non-standard exception rather than return 1782 with a SPURIOUS because resume can try and step or modify things, 1783 which needs a current_thread->h. But some of these exceptions mark 1784 the birth or death of threads, which mean that the current thread 1785 isn't necessarily what you think it is. */ 1786 1787 while (1) 1788 { 1789 int retval; 1790 1791 /* If the user presses Ctrl-c while the debugger is waiting 1792 for an event, he expects the debugger to interrupt his program 1793 and to get the prompt back. There are two possible situations: 1794 1795 - The debugger and the program do not share the console, in 1796 which case the Ctrl-c event only reached the debugger. 1797 In that case, the ctrl_c handler will take care of interrupting 1798 the inferior. Note that this case is working starting with 1799 Windows XP. For Windows 2000, Ctrl-C should be pressed in the 1800 inferior console. 1801 1802 - The debugger and the program share the same console, in which 1803 case both debugger and inferior will receive the Ctrl-c event. 1804 In that case the ctrl_c handler will ignore the event, as the 1805 Ctrl-c event generated inside the inferior will trigger the 1806 expected debug event. 1807 1808 FIXME: brobecker/2008-05-20: If the inferior receives the 1809 signal first and the delay until GDB receives that signal 1810 is sufficiently long, GDB can sometimes receive the SIGINT 1811 after we have unblocked the CTRL+C handler. This would 1812 lead to the debugger stopping prematurely while handling 1813 the new-thread event that comes with the handling of the SIGINT 1814 inside the inferior, and then stop again immediately when 1815 the user tries to resume the execution in the inferior. 1816 This is a classic race that we should try to fix one day. */ 1817 SetConsoleCtrlHandler (&ctrl_c_handler, TRUE); 1818 retval = get_windows_debug_event (pid, ourstatus); 1819 SetConsoleCtrlHandler (&ctrl_c_handler, FALSE); 1820 1821 if (retval) 1822 { 1823 ptid_t result = ptid_t (current_event.dwProcessId, retval, 0); 1824 1825 if (ourstatus->kind != TARGET_WAITKIND_EXITED 1826 && ourstatus->kind != TARGET_WAITKIND_SIGNALLED) 1827 { 1828 windows_thread_info *th = thread_rec (result, INVALIDATE_CONTEXT); 1829 1830 if (th != nullptr) 1831 { 1832 th->stopped_at_software_breakpoint = false; 1833 if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT 1834 && ((current_event.u.Exception.ExceptionRecord.ExceptionCode 1835 == EXCEPTION_BREAKPOINT) 1836 || (current_event.u.Exception.ExceptionRecord.ExceptionCode 1837 == STATUS_WX86_BREAKPOINT)) 1838 && windows_initialization_done) 1839 { 1840 th->stopped_at_software_breakpoint = true; 1841 th->pc_adjusted = false; 1842 } 1843 } 1844 } 1845 1846 return result; 1847 } 1848 else 1849 { 1850 int detach = 0; 1851 1852 if (deprecated_ui_loop_hook != NULL) 1853 detach = deprecated_ui_loop_hook (0); 1854 1855 if (detach) 1856 kill (); 1857 } 1858 } 1859 } 1860 1861 /* Iterate over all DLLs currently mapped by our inferior, and 1862 add them to our list of solibs. */ 1863 1864 static void 1865 windows_add_all_dlls (void) 1866 { 1867 HMODULE dummy_hmodule; 1868 DWORD cb_needed; 1869 HMODULE *hmodules; 1870 int i; 1871 1872 #ifdef __x86_64__ 1873 if (wow64_process) 1874 { 1875 if (EnumProcessModulesEx (current_process_handle, &dummy_hmodule, 1876 sizeof (HMODULE), &cb_needed, 1877 LIST_MODULES_32BIT) == 0) 1878 return; 1879 } 1880 else 1881 #endif 1882 { 1883 if (EnumProcessModules (current_process_handle, &dummy_hmodule, 1884 sizeof (HMODULE), &cb_needed) == 0) 1885 return; 1886 } 1887 1888 if (cb_needed < 1) 1889 return; 1890 1891 hmodules = (HMODULE *) alloca (cb_needed); 1892 #ifdef __x86_64__ 1893 if (wow64_process) 1894 { 1895 if (EnumProcessModulesEx (current_process_handle, hmodules, 1896 cb_needed, &cb_needed, 1897 LIST_MODULES_32BIT) == 0) 1898 return; 1899 } 1900 else 1901 #endif 1902 { 1903 if (EnumProcessModules (current_process_handle, hmodules, 1904 cb_needed, &cb_needed) == 0) 1905 return; 1906 } 1907 1908 char system_dir[__PMAX]; 1909 char syswow_dir[__PMAX]; 1910 size_t system_dir_len = 0; 1911 bool convert_syswow_dir = false; 1912 #ifdef __x86_64__ 1913 if (wow64_process) 1914 #endif 1915 { 1916 /* This fails on 32bit Windows because it has no SysWOW64 directory, 1917 and in this case a path conversion isn't necessary. */ 1918 UINT len = GetSystemWow64DirectoryA (syswow_dir, sizeof (syswow_dir)); 1919 if (len > 0) 1920 { 1921 /* Check that we have passed a large enough buffer. */ 1922 gdb_assert (len < sizeof (syswow_dir)); 1923 1924 len = GetSystemDirectoryA (system_dir, sizeof (system_dir)); 1925 /* Error check. */ 1926 gdb_assert (len != 0); 1927 /* Check that we have passed a large enough buffer. */ 1928 gdb_assert (len < sizeof (system_dir)); 1929 1930 strcat (system_dir, "\\"); 1931 strcat (syswow_dir, "\\"); 1932 system_dir_len = strlen (system_dir); 1933 1934 convert_syswow_dir = true; 1935 } 1936 1937 } 1938 for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++) 1939 { 1940 MODULEINFO mi; 1941 #ifdef __USEWIDE 1942 wchar_t dll_name[__PMAX]; 1943 char dll_name_mb[__PMAX]; 1944 #else 1945 char dll_name[__PMAX]; 1946 #endif 1947 const char *name; 1948 if (GetModuleInformation (current_process_handle, hmodules[i], 1949 &mi, sizeof (mi)) == 0) 1950 continue; 1951 if (GetModuleFileNameEx (current_process_handle, hmodules[i], 1952 dll_name, sizeof (dll_name)) == 0) 1953 continue; 1954 #ifdef __USEWIDE 1955 wcstombs (dll_name_mb, dll_name, __PMAX); 1956 name = dll_name_mb; 1957 #else 1958 name = dll_name; 1959 #endif 1960 /* Convert the DLL path of 32bit processes returned by 1961 GetModuleFileNameEx from the 64bit system directory to the 1962 32bit syswow64 directory if necessary. */ 1963 std::string syswow_dll_path; 1964 if (convert_syswow_dir 1965 && strncasecmp (name, system_dir, system_dir_len) == 0 1966 && strchr (name + system_dir_len, '\\') == nullptr) 1967 { 1968 syswow_dll_path = syswow_dir; 1969 syswow_dll_path += name + system_dir_len; 1970 name = syswow_dll_path.c_str(); 1971 } 1972 1973 solib_end->next = windows_make_so (name, mi.lpBaseOfDll); 1974 solib_end = solib_end->next; 1975 } 1976 } 1977 1978 void 1979 windows_nat_target::do_initial_windows_stuff (DWORD pid, bool attaching) 1980 { 1981 int i; 1982 struct inferior *inf; 1983 1984 last_sig = GDB_SIGNAL_0; 1985 open_process_used = 0; 1986 debug_registers_changed = 0; 1987 debug_registers_used = 0; 1988 for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++) 1989 dr[i] = 0; 1990 #ifdef __CYGWIN__ 1991 cygwin_load_start = cygwin_load_end = 0; 1992 #endif 1993 current_event.dwProcessId = pid; 1994 memset (¤t_event, 0, sizeof (current_event)); 1995 if (!target_is_pushed (this)) 1996 push_target (this); 1997 disable_breakpoints_in_shlibs (); 1998 windows_clear_solib (); 1999 clear_proceed_status (0); 2000 init_wait_for_inferior (); 2001 2002 #ifdef __x86_64__ 2003 ignore_first_breakpoint = !attaching && wow64_process; 2004 2005 if (!wow64_process) 2006 { 2007 windows_set_context_register_offsets (amd64_mappings); 2008 windows_set_segment_register_p (amd64_windows_segment_register_p); 2009 } 2010 else 2011 #endif 2012 { 2013 windows_set_context_register_offsets (i386_mappings); 2014 windows_set_segment_register_p (i386_windows_segment_register_p); 2015 } 2016 2017 inf = current_inferior (); 2018 inferior_appeared (inf, pid); 2019 inf->attach_flag = attaching; 2020 2021 target_terminal::init (); 2022 target_terminal::inferior (); 2023 2024 windows_initialization_done = 0; 2025 2026 ptid_t last_ptid; 2027 2028 while (1) 2029 { 2030 struct target_waitstatus status; 2031 2032 last_ptid = this->wait (minus_one_ptid, &status, 0); 2033 2034 /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread 2035 events. */ 2036 if (status.kind != TARGET_WAITKIND_LOADED 2037 && status.kind != TARGET_WAITKIND_SPURIOUS) 2038 break; 2039 2040 this->resume (minus_one_ptid, 0, GDB_SIGNAL_0); 2041 } 2042 2043 switch_to_thread (find_thread_ptid (this, last_ptid)); 2044 2045 /* Now that the inferior has been started and all DLLs have been mapped, 2046 we can iterate over all DLLs and load them in. 2047 2048 We avoid doing it any earlier because, on certain versions of Windows, 2049 LOAD_DLL_DEBUG_EVENTs are sometimes not complete. In particular, 2050 we have seen on Windows 8.1 that the ntdll.dll load event does not 2051 include the DLL name, preventing us from creating an associated SO. 2052 A possible explanation is that ntdll.dll might be mapped before 2053 the SO info gets created by the Windows system -- ntdll.dll is 2054 the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs 2055 do not seem to suffer from that problem. 2056 2057 Rather than try to work around this sort of issue, it is much 2058 simpler to just ignore DLL load/unload events during the startup 2059 phase, and then process them all in one batch now. */ 2060 windows_add_all_dlls (); 2061 2062 windows_initialization_done = 1; 2063 return; 2064 } 2065 2066 /* Try to set or remove a user privilege to the current process. Return -1 2067 if that fails, the previous setting of that privilege otherwise. 2068 2069 This code is copied from the Cygwin source code and rearranged to allow 2070 dynamically loading of the needed symbols from advapi32 which is only 2071 available on NT/2K/XP. */ 2072 static int 2073 set_process_privilege (const char *privilege, BOOL enable) 2074 { 2075 HANDLE token_hdl = NULL; 2076 LUID restore_priv; 2077 TOKEN_PRIVILEGES new_priv, orig_priv; 2078 int ret = -1; 2079 DWORD size; 2080 2081 if (!OpenProcessToken (GetCurrentProcess (), 2082 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, 2083 &token_hdl)) 2084 goto out; 2085 2086 if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv)) 2087 goto out; 2088 2089 new_priv.PrivilegeCount = 1; 2090 new_priv.Privileges[0].Luid = restore_priv; 2091 new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0; 2092 2093 if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv, 2094 sizeof orig_priv, &orig_priv, &size)) 2095 goto out; 2096 #if 0 2097 /* Disabled, otherwise every `attach' in an unprivileged user session 2098 would raise the "Failed to get SE_DEBUG_NAME privilege" warning in 2099 windows_attach(). */ 2100 /* AdjustTokenPrivileges returns TRUE even if the privilege could not 2101 be enabled. GetLastError () returns an correct error code, though. */ 2102 if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED) 2103 goto out; 2104 #endif 2105 2106 ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0; 2107 2108 out: 2109 if (token_hdl) 2110 CloseHandle (token_hdl); 2111 2112 return ret; 2113 } 2114 2115 /* Attach to process PID, then initialize for debugging it. */ 2116 2117 void 2118 windows_nat_target::attach (const char *args, int from_tty) 2119 { 2120 BOOL ok; 2121 DWORD pid; 2122 2123 pid = parse_pid_to_attach (args); 2124 2125 if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0) 2126 { 2127 printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n"); 2128 printf_unfiltered ("This can cause attach to " 2129 "fail on Windows NT/2K/XP\n"); 2130 } 2131 2132 windows_init_thread_list (); 2133 ok = DebugActiveProcess (pid); 2134 saw_create = 0; 2135 2136 #ifdef __CYGWIN__ 2137 if (!ok) 2138 { 2139 /* Try fall back to Cygwin pid. */ 2140 pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid); 2141 2142 if (pid > 0) 2143 ok = DebugActiveProcess (pid); 2144 } 2145 #endif 2146 2147 if (!ok) 2148 error (_("Can't attach to process %u (error %u)"), 2149 (unsigned) pid, (unsigned) GetLastError ()); 2150 2151 DebugSetProcessKillOnExit (FALSE); 2152 2153 if (from_tty) 2154 { 2155 const char *exec_file = get_exec_file (0); 2156 2157 if (exec_file) 2158 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, 2159 target_pid_to_str (ptid_t (pid)).c_str ()); 2160 else 2161 printf_unfiltered ("Attaching to %s\n", 2162 target_pid_to_str (ptid_t (pid)).c_str ()); 2163 } 2164 2165 #ifdef __x86_64__ 2166 HANDLE h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, pid); 2167 if (h != NULL) 2168 { 2169 BOOL wow64; 2170 if (IsWow64Process (h, &wow64)) 2171 wow64_process = wow64; 2172 CloseHandle (h); 2173 } 2174 #endif 2175 2176 do_initial_windows_stuff (pid, 1); 2177 target_terminal::ours (); 2178 } 2179 2180 void 2181 windows_nat_target::detach (inferior *inf, int from_tty) 2182 { 2183 int detached = 1; 2184 2185 ptid_t ptid = minus_one_ptid; 2186 resume (ptid, 0, GDB_SIGNAL_0); 2187 2188 if (!DebugActiveProcessStop (current_event.dwProcessId)) 2189 { 2190 error (_("Can't detach process %u (error %u)"), 2191 (unsigned) current_event.dwProcessId, (unsigned) GetLastError ()); 2192 detached = 0; 2193 } 2194 DebugSetProcessKillOnExit (FALSE); 2195 2196 if (detached && from_tty) 2197 { 2198 const char *exec_file = get_exec_file (0); 2199 if (exec_file == 0) 2200 exec_file = ""; 2201 printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file, 2202 (unsigned) current_event.dwProcessId); 2203 } 2204 2205 x86_cleanup_dregs (); 2206 switch_to_no_thread (); 2207 detach_inferior (inf); 2208 2209 maybe_unpush_target (); 2210 } 2211 2212 /* Try to determine the executable filename. 2213 2214 EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN. 2215 2216 Upon success, the filename is stored inside EXE_NAME_RET, and 2217 this function returns nonzero. 2218 2219 Otherwise, this function returns zero and the contents of 2220 EXE_NAME_RET is undefined. */ 2221 2222 static int 2223 windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len) 2224 { 2225 DWORD len; 2226 HMODULE dh_buf; 2227 DWORD cbNeeded; 2228 2229 cbNeeded = 0; 2230 #ifdef __x86_64__ 2231 if (wow64_process) 2232 { 2233 if (!EnumProcessModulesEx (current_process_handle, &dh_buf, 2234 sizeof (HMODULE), &cbNeeded, 2235 LIST_MODULES_32BIT) || !cbNeeded) 2236 return 0; 2237 } 2238 else 2239 #endif 2240 { 2241 if (!EnumProcessModules (current_process_handle, &dh_buf, 2242 sizeof (HMODULE), &cbNeeded) || !cbNeeded) 2243 return 0; 2244 } 2245 2246 /* We know the executable is always first in the list of modules, 2247 which we just fetched. So no need to fetch more. */ 2248 2249 #ifdef __CYGWIN__ 2250 { 2251 /* Cygwin prefers that the path be in /x/y/z format, so extract 2252 the filename into a temporary buffer first, and then convert it 2253 to POSIX format into the destination buffer. */ 2254 cygwin_buf_t *pathbuf = (cygwin_buf_t *) alloca (exe_name_max_len * sizeof (cygwin_buf_t)); 2255 2256 len = GetModuleFileNameEx (current_process_handle, 2257 dh_buf, pathbuf, exe_name_max_len); 2258 if (len == 0) 2259 error (_("Error getting executable filename: %u."), 2260 (unsigned) GetLastError ()); 2261 if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret, 2262 exe_name_max_len) < 0) 2263 error (_("Error converting executable filename to POSIX: %d."), errno); 2264 } 2265 #else 2266 len = GetModuleFileNameEx (current_process_handle, 2267 dh_buf, exe_name_ret, exe_name_max_len); 2268 if (len == 0) 2269 error (_("Error getting executable filename: %u."), 2270 (unsigned) GetLastError ()); 2271 #endif 2272 2273 return 1; /* success */ 2274 } 2275 2276 /* The pid_to_exec_file target_ops method for this platform. */ 2277 2278 char * 2279 windows_nat_target::pid_to_exec_file (int pid) 2280 { 2281 static char path[__PMAX]; 2282 #ifdef __CYGWIN__ 2283 /* Try to find exe name as symlink target of /proc/<pid>/exe. */ 2284 int nchars; 2285 char procexe[sizeof ("/proc/4294967295/exe")]; 2286 2287 xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid); 2288 nchars = readlink (procexe, path, sizeof(path)); 2289 if (nchars > 0 && nchars < sizeof (path)) 2290 { 2291 path[nchars] = '\0'; /* Got it */ 2292 return path; 2293 } 2294 #endif 2295 2296 /* If we get here then either Cygwin is hosed, this isn't a Cygwin version 2297 of gdb, or we're trying to debug a non-Cygwin windows executable. */ 2298 if (!windows_get_exec_module_filename (path, sizeof (path))) 2299 path[0] = '\0'; 2300 2301 return path; 2302 } 2303 2304 /* Print status information about what we're accessing. */ 2305 2306 void 2307 windows_nat_target::files_info () 2308 { 2309 struct inferior *inf = current_inferior (); 2310 2311 printf_unfiltered ("\tUsing the running image of %s %s.\n", 2312 inf->attach_flag ? "attached" : "child", 2313 target_pid_to_str (inferior_ptid).c_str ()); 2314 } 2315 2316 /* Modify CreateProcess parameters for use of a new separate console. 2317 Parameters are: 2318 *FLAGS: DWORD parameter for general process creation flags. 2319 *SI: STARTUPINFO structure, for which the console window size and 2320 console buffer size is filled in if GDB is running in a console. 2321 to create the new console. 2322 The size of the used font is not available on all versions of 2323 Windows OS. Furthermore, the current font might not be the default 2324 font, but this is still better than before. 2325 If the windows and buffer sizes are computed, 2326 SI->DWFLAGS is changed so that this information is used 2327 by CreateProcess function. */ 2328 2329 static void 2330 windows_set_console_info (STARTUPINFO *si, DWORD *flags) 2331 { 2332 HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE, 2333 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); 2334 2335 if (hconsole != INVALID_HANDLE_VALUE) 2336 { 2337 CONSOLE_SCREEN_BUFFER_INFO sbinfo; 2338 COORD font_size; 2339 CONSOLE_FONT_INFO cfi; 2340 2341 GetCurrentConsoleFont (hconsole, FALSE, &cfi); 2342 font_size = GetConsoleFontSize (hconsole, cfi.nFont); 2343 GetConsoleScreenBufferInfo(hconsole, &sbinfo); 2344 si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1; 2345 si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1; 2346 if (font_size.X) 2347 si->dwXSize *= font_size.X; 2348 else 2349 si->dwXSize *= 8; 2350 if (font_size.Y) 2351 si->dwYSize *= font_size.Y; 2352 else 2353 si->dwYSize *= 12; 2354 si->dwXCountChars = sbinfo.dwSize.X; 2355 si->dwYCountChars = sbinfo.dwSize.Y; 2356 si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS; 2357 } 2358 *flags |= CREATE_NEW_CONSOLE; 2359 } 2360 2361 #ifndef __CYGWIN__ 2362 /* Function called by qsort to sort environment strings. */ 2363 2364 static int 2365 envvar_cmp (const void *a, const void *b) 2366 { 2367 const char **p = (const char **) a; 2368 const char **q = (const char **) b; 2369 return strcasecmp (*p, *q); 2370 } 2371 #endif 2372 2373 #ifdef __CYGWIN__ 2374 static void 2375 clear_win32_environment (char **env) 2376 { 2377 int i; 2378 size_t len; 2379 wchar_t *copy = NULL, *equalpos; 2380 2381 for (i = 0; env[i] && *env[i]; i++) 2382 { 2383 len = mbstowcs (NULL, env[i], 0) + 1; 2384 copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t)); 2385 mbstowcs (copy, env[i], len); 2386 equalpos = wcschr (copy, L'='); 2387 if (equalpos) 2388 *equalpos = L'\0'; 2389 SetEnvironmentVariableW (copy, NULL); 2390 } 2391 xfree (copy); 2392 } 2393 #endif 2394 2395 #ifndef __CYGWIN__ 2396 2397 /* Redirection of inferior I/O streams for native MS-Windows programs. 2398 Unlike on Unix, where this is handled by invoking the inferior via 2399 the shell, on MS-Windows we need to emulate the cmd.exe shell. 2400 2401 The official documentation of the cmd.exe redirection features is here: 2402 2403 http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx 2404 2405 (That page talks about Windows XP, but there's no newer 2406 documentation, so we assume later versions of cmd.exe didn't change 2407 anything.) 2408 2409 Caveat: the documentation on that page seems to include a few lies. 2410 For example, it describes strange constructs 1<&2 and 2<&1, which 2411 seem to work only when 1>&2 resp. 2>&1 would make sense, and so I 2412 think the cmd.exe parser of the redirection symbols simply doesn't 2413 care about the < vs > distinction in these cases. Therefore, the 2414 supported features are explicitly documented below. 2415 2416 The emulation below aims at supporting all the valid use cases 2417 supported by cmd.exe, which include: 2418 2419 < FILE redirect standard input from FILE 2420 0< FILE redirect standard input from FILE 2421 <&N redirect standard input from file descriptor N 2422 0<&N redirect standard input from file descriptor N 2423 > FILE redirect standard output to FILE 2424 >> FILE append standard output to FILE 2425 1>> FILE append standard output to FILE 2426 >&N redirect standard output to file descriptor N 2427 1>&N redirect standard output to file descriptor N 2428 >>&N append standard output to file descriptor N 2429 1>>&N append standard output to file descriptor N 2430 2> FILE redirect standard error to FILE 2431 2>> FILE append standard error to FILE 2432 2>&N redirect standard error to file descriptor N 2433 2>>&N append standard error to file descriptor N 2434 2435 Note that using N > 2 in the above construct is supported, but 2436 requires that the corresponding file descriptor be open by some 2437 means elsewhere or outside GDB. Also note that using ">&0" or 2438 "<&2" will generally fail, because the file descriptor redirected 2439 from is normally open in an incompatible mode (e.g., FD 0 is open 2440 for reading only). IOW, use of such tricks is not recommended; 2441 you are on your own. 2442 2443 We do NOT support redirection of file descriptors above 2, as in 2444 "3>SOME-FILE", because MinGW compiled programs don't (supporting 2445 that needs special handling in the startup code that MinGW 2446 doesn't have). Pipes are also not supported. 2447 2448 As for invalid use cases, where the redirection contains some 2449 error, the emulation below will detect that and produce some 2450 error and/or failure. But the behavior in those cases is not 2451 bug-for-bug compatible with what cmd.exe does in those cases. 2452 That's because what cmd.exe does then is not well defined, and 2453 seems to be a side effect of the cmd.exe parsing of the command 2454 line more than anything else. For example, try redirecting to an 2455 invalid file name, as in "> foo:bar". 2456 2457 There are also minor syntactic deviations from what cmd.exe does 2458 in some corner cases. For example, it doesn't support the likes 2459 of "> &foo" to mean redirect to file named literally "&foo"; we 2460 do support that here, because that, too, sounds like some issue 2461 with the cmd.exe parser. Another nicety is that we support 2462 redirection targets that use file names with forward slashes, 2463 something cmd.exe doesn't -- this comes in handy since GDB 2464 file-name completion can be used when typing the command line for 2465 the inferior. */ 2466 2467 /* Support routines for redirecting standard handles of the inferior. */ 2468 2469 /* Parse a single redirection spec, open/duplicate the specified 2470 file/fd, and assign the appropriate value to one of the 3 standard 2471 file descriptors. */ 2472 static int 2473 redir_open (const char *redir_string, int *inp, int *out, int *err) 2474 { 2475 int *fd, ref_fd = -2; 2476 int mode; 2477 const char *fname = redir_string + 1; 2478 int rc = *redir_string; 2479 2480 switch (rc) 2481 { 2482 case '0': 2483 fname++; 2484 /* FALLTHROUGH */ 2485 case '<': 2486 fd = inp; 2487 mode = O_RDONLY; 2488 break; 2489 case '1': case '2': 2490 fname++; 2491 /* FALLTHROUGH */ 2492 case '>': 2493 fd = (rc == '2') ? err : out; 2494 mode = O_WRONLY | O_CREAT; 2495 if (*fname == '>') 2496 { 2497 fname++; 2498 mode |= O_APPEND; 2499 } 2500 else 2501 mode |= O_TRUNC; 2502 break; 2503 default: 2504 return -1; 2505 } 2506 2507 if (*fname == '&' && '0' <= fname[1] && fname[1] <= '9') 2508 { 2509 /* A reference to a file descriptor. */ 2510 char *fdtail; 2511 ref_fd = (int) strtol (fname + 1, &fdtail, 10); 2512 if (fdtail > fname + 1 && *fdtail == '\0') 2513 { 2514 /* Don't allow redirection when open modes are incompatible. */ 2515 if ((ref_fd == 0 && (fd == out || fd == err)) 2516 || ((ref_fd == 1 || ref_fd == 2) && fd == inp)) 2517 { 2518 errno = EPERM; 2519 return -1; 2520 } 2521 if (ref_fd == 0) 2522 ref_fd = *inp; 2523 else if (ref_fd == 1) 2524 ref_fd = *out; 2525 else if (ref_fd == 2) 2526 ref_fd = *err; 2527 } 2528 else 2529 { 2530 errno = EBADF; 2531 return -1; 2532 } 2533 } 2534 else 2535 fname++; /* skip the separator space */ 2536 /* If the descriptor is already open, close it. This allows 2537 multiple specs of redirections for the same stream, which is 2538 somewhat nonsensical, but still valid and supported by cmd.exe. 2539 (But cmd.exe only opens a single file in this case, the one 2540 specified by the last redirection spec on the command line.) */ 2541 if (*fd >= 0) 2542 _close (*fd); 2543 if (ref_fd == -2) 2544 { 2545 *fd = _open (fname, mode, _S_IREAD | _S_IWRITE); 2546 if (*fd < 0) 2547 return -1; 2548 } 2549 else if (ref_fd == -1) 2550 *fd = -1; /* reset to default destination */ 2551 else 2552 { 2553 *fd = _dup (ref_fd); 2554 if (*fd < 0) 2555 return -1; 2556 } 2557 /* _open just sets a flag for O_APPEND, which won't be passed to the 2558 inferior, so we need to actually move the file pointer. */ 2559 if ((mode & O_APPEND) != 0) 2560 _lseek (*fd, 0L, SEEK_END); 2561 return 0; 2562 } 2563 2564 /* Canonicalize a single redirection spec and set up the corresponding 2565 file descriptor as specified. */ 2566 static int 2567 redir_set_redirection (const char *s, int *inp, int *out, int *err) 2568 { 2569 char buf[__PMAX + 2 + 5]; /* extra space for quotes & redirection string */ 2570 char *d = buf; 2571 const char *start = s; 2572 int quote = 0; 2573 2574 *d++ = *s++; /* copy the 1st character, < or > or a digit */ 2575 if ((*start == '>' || *start == '1' || *start == '2') 2576 && *s == '>') 2577 { 2578 *d++ = *s++; 2579 if (*s == '>' && *start != '>') 2580 *d++ = *s++; 2581 } 2582 else if (*start == '0' && *s == '<') 2583 *d++ = *s++; 2584 /* cmd.exe recognizes "&N" only immediately after the redirection symbol. */ 2585 if (*s != '&') 2586 { 2587 while (isspace (*s)) /* skip whitespace before file name */ 2588 s++; 2589 *d++ = ' '; /* separate file name with a single space */ 2590 } 2591 2592 /* Copy the file name. */ 2593 while (*s) 2594 { 2595 /* Remove quoting characters from the file name in buf[]. */ 2596 if (*s == '"') /* could support '..' quoting here */ 2597 { 2598 if (!quote) 2599 quote = *s++; 2600 else if (*s == quote) 2601 { 2602 quote = 0; 2603 s++; 2604 } 2605 else 2606 *d++ = *s++; 2607 } 2608 else if (*s == '\\') 2609 { 2610 if (s[1] == '"') /* could support '..' here */ 2611 s++; 2612 *d++ = *s++; 2613 } 2614 else if (isspace (*s) && !quote) 2615 break; 2616 else 2617 *d++ = *s++; 2618 if (d - buf >= sizeof (buf) - 1) 2619 { 2620 errno = ENAMETOOLONG; 2621 return 0; 2622 } 2623 } 2624 *d = '\0'; 2625 2626 /* Windows doesn't allow redirection characters in file names, so we 2627 can bail out early if they use them, or if there's no target file 2628 name after the redirection symbol. */ 2629 if (d[-1] == '>' || d[-1] == '<') 2630 { 2631 errno = ENOENT; 2632 return 0; 2633 } 2634 if (redir_open (buf, inp, out, err) == 0) 2635 return s - start; 2636 return 0; 2637 } 2638 2639 /* Parse the command line for redirection specs and prepare the file 2640 descriptors for the 3 standard streams accordingly. */ 2641 static bool 2642 redirect_inferior_handles (const char *cmd_orig, char *cmd, 2643 int *inp, int *out, int *err) 2644 { 2645 const char *s = cmd_orig; 2646 char *d = cmd; 2647 int quote = 0; 2648 bool retval = false; 2649 2650 while (isspace (*s)) 2651 *d++ = *s++; 2652 2653 while (*s) 2654 { 2655 if (*s == '"') /* could also support '..' quoting here */ 2656 { 2657 if (!quote) 2658 quote = *s; 2659 else if (*s == quote) 2660 quote = 0; 2661 } 2662 else if (*s == '\\') 2663 { 2664 if (s[1] == '"') /* escaped quote char */ 2665 s++; 2666 } 2667 else if (!quote) 2668 { 2669 /* Process a single redirection candidate. */ 2670 if (*s == '<' || *s == '>' 2671 || ((*s == '1' || *s == '2') && s[1] == '>') 2672 || (*s == '0' && s[1] == '<')) 2673 { 2674 int skip = redir_set_redirection (s, inp, out, err); 2675 2676 if (skip <= 0) 2677 return false; 2678 retval = true; 2679 s += skip; 2680 } 2681 } 2682 if (*s) 2683 *d++ = *s++; 2684 } 2685 *d = '\0'; 2686 return retval; 2687 } 2688 #endif /* !__CYGWIN__ */ 2689 2690 /* Start an inferior windows child process and sets inferior_ptid to its pid. 2691 EXEC_FILE is the file to run. 2692 ALLARGS is a string containing the arguments to the program. 2693 ENV is the environment vector to pass. Errors reported with error(). */ 2694 2695 void 2696 windows_nat_target::create_inferior (const char *exec_file, 2697 const std::string &origallargs, 2698 char **in_env, int from_tty) 2699 { 2700 STARTUPINFO si; 2701 #ifdef __CYGWIN__ 2702 cygwin_buf_t real_path[__PMAX]; 2703 cygwin_buf_t shell[__PMAX]; /* Path to shell */ 2704 cygwin_buf_t infcwd[__PMAX]; 2705 const char *sh; 2706 cygwin_buf_t *toexec; 2707 cygwin_buf_t *cygallargs; 2708 cygwin_buf_t *args; 2709 char **old_env = NULL; 2710 PWCHAR w32_env; 2711 size_t len; 2712 int tty; 2713 int ostdin, ostdout, ostderr; 2714 #else /* !__CYGWIN__ */ 2715 char shell[__PMAX]; /* Path to shell */ 2716 const char *toexec; 2717 char *args, *allargs_copy; 2718 size_t args_len, allargs_len; 2719 int fd_inp = -1, fd_out = -1, fd_err = -1; 2720 HANDLE tty = INVALID_HANDLE_VALUE; 2721 bool redirected = false; 2722 char *w32env; 2723 char *temp; 2724 size_t envlen; 2725 int i; 2726 size_t envsize; 2727 char **env; 2728 #endif /* !__CYGWIN__ */ 2729 const char *allargs = origallargs.c_str (); 2730 PROCESS_INFORMATION pi; 2731 BOOL ret; 2732 DWORD flags = 0; 2733 const char *inferior_tty = current_inferior ()->tty (); 2734 2735 if (!exec_file) 2736 error (_("No executable specified, use `target exec'.")); 2737 2738 const char *inferior_cwd = get_inferior_cwd (); 2739 std::string expanded_infcwd; 2740 if (inferior_cwd != NULL) 2741 { 2742 expanded_infcwd = gdb_tilde_expand (inferior_cwd); 2743 /* Mirror slashes on inferior's cwd. */ 2744 std::replace (expanded_infcwd.begin (), expanded_infcwd.end (), 2745 '/', '\\'); 2746 inferior_cwd = expanded_infcwd.c_str (); 2747 } 2748 2749 memset (&si, 0, sizeof (si)); 2750 si.cb = sizeof (si); 2751 2752 if (new_group) 2753 flags |= CREATE_NEW_PROCESS_GROUP; 2754 2755 if (new_console) 2756 windows_set_console_info (&si, &flags); 2757 2758 #ifdef __CYGWIN__ 2759 if (!useshell) 2760 { 2761 flags |= DEBUG_ONLY_THIS_PROCESS; 2762 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path, 2763 __PMAX * sizeof (cygwin_buf_t)) < 0) 2764 error (_("Error starting executable: %d"), errno); 2765 toexec = real_path; 2766 #ifdef __USEWIDE 2767 len = mbstowcs (NULL, allargs, 0) + 1; 2768 if (len == (size_t) -1) 2769 error (_("Error starting executable: %d"), errno); 2770 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t)); 2771 mbstowcs (cygallargs, allargs, len); 2772 #else /* !__USEWIDE */ 2773 cygallargs = allargs; 2774 #endif 2775 } 2776 else 2777 { 2778 sh = get_shell (); 2779 if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0) 2780 error (_("Error starting executable via shell: %d"), errno); 2781 #ifdef __USEWIDE 2782 len = sizeof (L" -c 'exec '") + mbstowcs (NULL, exec_file, 0) 2783 + mbstowcs (NULL, allargs, 0) + 2; 2784 cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t)); 2785 swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs); 2786 #else /* !__USEWIDE */ 2787 len = (sizeof (" -c 'exec '") + strlen (exec_file) 2788 + strlen (allargs) + 2); 2789 cygallargs = (char *) alloca (len); 2790 xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs); 2791 #endif /* __USEWIDE */ 2792 toexec = shell; 2793 flags |= DEBUG_PROCESS; 2794 } 2795 2796 if (inferior_cwd != NULL 2797 && cygwin_conv_path (CCP_POSIX_TO_WIN_W, inferior_cwd, 2798 infcwd, strlen (inferior_cwd)) < 0) 2799 error (_("Error converting inferior cwd: %d"), errno); 2800 2801 #ifdef __USEWIDE 2802 args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2) 2803 * sizeof (wchar_t)); 2804 wcscpy (args, toexec); 2805 wcscat (args, L" "); 2806 wcscat (args, cygallargs); 2807 #else /* !__USEWIDE */ 2808 args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2); 2809 strcpy (args, toexec); 2810 strcat (args, " "); 2811 strcat (args, cygallargs); 2812 #endif /* !__USEWIDE */ 2813 2814 #ifdef CW_CVT_ENV_TO_WINENV 2815 /* First try to create a direct Win32 copy of the POSIX environment. */ 2816 w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env); 2817 if (w32_env != (PWCHAR) -1) 2818 flags |= CREATE_UNICODE_ENVIRONMENT; 2819 else 2820 /* If that fails, fall back to old method tweaking GDB's environment. */ 2821 #endif /* CW_CVT_ENV_TO_WINENV */ 2822 { 2823 /* Reset all Win32 environment variables to avoid leftover on next run. */ 2824 clear_win32_environment (environ); 2825 /* Prepare the environment vars for CreateProcess. */ 2826 old_env = environ; 2827 environ = in_env; 2828 cygwin_internal (CW_SYNC_WINENV); 2829 w32_env = NULL; 2830 } 2831 2832 if (inferior_tty == nullptr) 2833 tty = ostdin = ostdout = ostderr = -1; 2834 else 2835 { 2836 tty = open (inferior_tty, O_RDWR | O_NOCTTY); 2837 if (tty < 0) 2838 { 2839 print_sys_errmsg (inferior_tty, errno); 2840 ostdin = ostdout = ostderr = -1; 2841 } 2842 else 2843 { 2844 ostdin = dup (0); 2845 ostdout = dup (1); 2846 ostderr = dup (2); 2847 dup2 (tty, 0); 2848 dup2 (tty, 1); 2849 dup2 (tty, 2); 2850 } 2851 } 2852 2853 windows_init_thread_list (); 2854 ret = CreateProcess (0, 2855 args, /* command line */ 2856 NULL, /* Security */ 2857 NULL, /* thread */ 2858 TRUE, /* inherit handles */ 2859 flags, /* start flags */ 2860 w32_env, /* environment */ 2861 inferior_cwd != NULL ? infcwd : NULL, /* current 2862 directory */ 2863 &si, 2864 &pi); 2865 if (w32_env) 2866 /* Just free the Win32 environment, if it could be created. */ 2867 free (w32_env); 2868 else 2869 { 2870 /* Reset all environment variables to avoid leftover on next run. */ 2871 clear_win32_environment (in_env); 2872 /* Restore normal GDB environment variables. */ 2873 environ = old_env; 2874 cygwin_internal (CW_SYNC_WINENV); 2875 } 2876 2877 if (tty >= 0) 2878 { 2879 ::close (tty); 2880 dup2 (ostdin, 0); 2881 dup2 (ostdout, 1); 2882 dup2 (ostderr, 2); 2883 ::close (ostdin); 2884 ::close (ostdout); 2885 ::close (ostderr); 2886 } 2887 #else /* !__CYGWIN__ */ 2888 allargs_len = strlen (allargs); 2889 allargs_copy = strcpy ((char *) alloca (allargs_len + 1), allargs); 2890 if (strpbrk (allargs_copy, "<>") != NULL) 2891 { 2892 int e = errno; 2893 errno = 0; 2894 redirected = 2895 redirect_inferior_handles (allargs, allargs_copy, 2896 &fd_inp, &fd_out, &fd_err); 2897 if (errno) 2898 warning (_("Error in redirection: %s."), safe_strerror (errno)); 2899 else 2900 errno = e; 2901 allargs_len = strlen (allargs_copy); 2902 } 2903 /* If not all the standard streams are redirected by the command 2904 line, use INFERIOR_TTY for those which aren't. */ 2905 if (inferior_tty != nullptr 2906 && !(fd_inp >= 0 && fd_out >= 0 && fd_err >= 0)) 2907 { 2908 SECURITY_ATTRIBUTES sa; 2909 sa.nLength = sizeof(sa); 2910 sa.lpSecurityDescriptor = 0; 2911 sa.bInheritHandle = TRUE; 2912 tty = CreateFileA (inferior_tty, GENERIC_READ | GENERIC_WRITE, 2913 0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); 2914 if (tty == INVALID_HANDLE_VALUE) 2915 warning (_("Warning: Failed to open TTY %s, error %#x."), 2916 inferior_tty, (unsigned) GetLastError ()); 2917 } 2918 if (redirected || tty != INVALID_HANDLE_VALUE) 2919 { 2920 if (fd_inp >= 0) 2921 si.hStdInput = (HANDLE) _get_osfhandle (fd_inp); 2922 else if (tty != INVALID_HANDLE_VALUE) 2923 si.hStdInput = tty; 2924 else 2925 si.hStdInput = GetStdHandle (STD_INPUT_HANDLE); 2926 if (fd_out >= 0) 2927 si.hStdOutput = (HANDLE) _get_osfhandle (fd_out); 2928 else if (tty != INVALID_HANDLE_VALUE) 2929 si.hStdOutput = tty; 2930 else 2931 si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE); 2932 if (fd_err >= 0) 2933 si.hStdError = (HANDLE) _get_osfhandle (fd_err); 2934 else if (tty != INVALID_HANDLE_VALUE) 2935 si.hStdError = tty; 2936 else 2937 si.hStdError = GetStdHandle (STD_ERROR_HANDLE); 2938 si.dwFlags |= STARTF_USESTDHANDLES; 2939 } 2940 2941 toexec = exec_file; 2942 /* Build the command line, a space-separated list of tokens where 2943 the first token is the name of the module to be executed. 2944 To avoid ambiguities introduced by spaces in the module name, 2945 we quote it. */ 2946 args_len = strlen (toexec) + 2 /* quotes */ + allargs_len + 2; 2947 args = (char *) alloca (args_len); 2948 xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs_copy); 2949 2950 flags |= DEBUG_ONLY_THIS_PROCESS; 2951 2952 /* CreateProcess takes the environment list as a null terminated set of 2953 strings (i.e. two nulls terminate the list). */ 2954 2955 /* Get total size for env strings. */ 2956 for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++) 2957 envlen += strlen (in_env[i]) + 1; 2958 2959 envsize = sizeof (in_env[0]) * (i + 1); 2960 env = (char **) alloca (envsize); 2961 memcpy (env, in_env, envsize); 2962 /* Windows programs expect the environment block to be sorted. */ 2963 qsort (env, i, sizeof (char *), envvar_cmp); 2964 2965 w32env = (char *) alloca (envlen + 1); 2966 2967 /* Copy env strings into new buffer. */ 2968 for (temp = w32env, i = 0; env[i] && *env[i]; i++) 2969 { 2970 strcpy (temp, env[i]); 2971 temp += strlen (temp) + 1; 2972 } 2973 2974 /* Final nil string to terminate new env. */ 2975 *temp = 0; 2976 2977 windows_init_thread_list (); 2978 ret = CreateProcessA (0, 2979 args, /* command line */ 2980 NULL, /* Security */ 2981 NULL, /* thread */ 2982 TRUE, /* inherit handles */ 2983 flags, /* start flags */ 2984 w32env, /* environment */ 2985 inferior_cwd, /* current directory */ 2986 &si, 2987 &pi); 2988 if (tty != INVALID_HANDLE_VALUE) 2989 CloseHandle (tty); 2990 if (fd_inp >= 0) 2991 _close (fd_inp); 2992 if (fd_out >= 0) 2993 _close (fd_out); 2994 if (fd_err >= 0) 2995 _close (fd_err); 2996 #endif /* !__CYGWIN__ */ 2997 2998 if (!ret) 2999 error (_("Error creating process %s, (error %u)."), 3000 exec_file, (unsigned) GetLastError ()); 3001 3002 #ifdef __x86_64__ 3003 BOOL wow64; 3004 if (IsWow64Process (pi.hProcess, &wow64)) 3005 wow64_process = wow64; 3006 #endif 3007 3008 CloseHandle (pi.hThread); 3009 CloseHandle (pi.hProcess); 3010 3011 if (useshell && shell[0] != '\0') 3012 saw_create = -1; 3013 else 3014 saw_create = 0; 3015 3016 do_initial_windows_stuff (pi.dwProcessId, 0); 3017 3018 /* windows_continue (DBG_CONTINUE, -1, 0); */ 3019 } 3020 3021 void 3022 windows_nat_target::mourn_inferior () 3023 { 3024 (void) windows_continue (DBG_CONTINUE, -1, 0); 3025 x86_cleanup_dregs(); 3026 if (open_process_used) 3027 { 3028 CHECK (CloseHandle (current_process_handle)); 3029 open_process_used = 0; 3030 } 3031 siginfo_er.ExceptionCode = 0; 3032 inf_child_target::mourn_inferior (); 3033 } 3034 3035 /* Send a SIGINT to the process group. This acts just like the user typed a 3036 ^C on the controlling terminal. */ 3037 3038 void 3039 windows_nat_target::interrupt () 3040 { 3041 DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n")); 3042 CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId)); 3043 registers_changed (); /* refresh register state */ 3044 } 3045 3046 /* Helper for windows_xfer_partial that handles memory transfers. 3047 Arguments are like target_xfer_partial. */ 3048 3049 static enum target_xfer_status 3050 windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, 3051 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len) 3052 { 3053 SIZE_T done = 0; 3054 BOOL success; 3055 DWORD lasterror = 0; 3056 3057 if (writebuf != NULL) 3058 { 3059 DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n", 3060 pulongest (len), core_addr_to_string (memaddr))); 3061 success = WriteProcessMemory (current_process_handle, 3062 (LPVOID) (uintptr_t) memaddr, writebuf, 3063 len, &done); 3064 if (!success) 3065 lasterror = GetLastError (); 3066 FlushInstructionCache (current_process_handle, 3067 (LPCVOID) (uintptr_t) memaddr, len); 3068 } 3069 else 3070 { 3071 DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n", 3072 pulongest (len), core_addr_to_string (memaddr))); 3073 success = ReadProcessMemory (current_process_handle, 3074 (LPCVOID) (uintptr_t) memaddr, readbuf, 3075 len, &done); 3076 if (!success) 3077 lasterror = GetLastError (); 3078 } 3079 *xfered_len = (ULONGEST) done; 3080 if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0) 3081 return TARGET_XFER_OK; 3082 else 3083 return success ? TARGET_XFER_OK : TARGET_XFER_E_IO; 3084 } 3085 3086 void 3087 windows_nat_target::kill () 3088 { 3089 CHECK (TerminateProcess (current_process_handle, 0)); 3090 3091 for (;;) 3092 { 3093 if (!windows_continue (DBG_CONTINUE, -1, 1)) 3094 break; 3095 if (!wait_for_debug_event (¤t_event, INFINITE)) 3096 break; 3097 if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) 3098 break; 3099 } 3100 3101 target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */ 3102 } 3103 3104 void 3105 windows_nat_target::close () 3106 { 3107 DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n", 3108 inferior_ptid.pid ())); 3109 } 3110 3111 /* Convert pid to printable format. */ 3112 std::string 3113 windows_nat_target::pid_to_str (ptid_t ptid) 3114 { 3115 if (ptid.lwp () != 0) 3116 return string_printf ("Thread %d.0x%lx", ptid.pid (), ptid.lwp ()); 3117 3118 return normal_pid_to_str (ptid); 3119 } 3120 3121 static enum target_xfer_status 3122 windows_xfer_shared_libraries (struct target_ops *ops, 3123 enum target_object object, const char *annex, 3124 gdb_byte *readbuf, const gdb_byte *writebuf, 3125 ULONGEST offset, ULONGEST len, 3126 ULONGEST *xfered_len) 3127 { 3128 struct obstack obstack; 3129 const char *buf; 3130 LONGEST len_avail; 3131 struct so_list *so; 3132 3133 if (writebuf) 3134 return TARGET_XFER_E_IO; 3135 3136 obstack_init (&obstack); 3137 obstack_grow_str (&obstack, "<library-list>\n"); 3138 for (so = solib_start.next; so; so = so->next) 3139 { 3140 lm_info_windows *li = (lm_info_windows *) so->lm_info; 3141 3142 windows_xfer_shared_library (so->so_name, (CORE_ADDR) 3143 (uintptr_t) li->load_addr, 3144 &li->text_offset, 3145 target_gdbarch (), &obstack); 3146 } 3147 obstack_grow_str0 (&obstack, "</library-list>\n"); 3148 3149 buf = (const char *) obstack_finish (&obstack); 3150 len_avail = strlen (buf); 3151 if (offset >= len_avail) 3152 len= 0; 3153 else 3154 { 3155 if (len > len_avail - offset) 3156 len = len_avail - offset; 3157 memcpy (readbuf, buf + offset, len); 3158 } 3159 3160 obstack_free (&obstack, NULL); 3161 *xfered_len = (ULONGEST) len; 3162 return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF; 3163 } 3164 3165 /* Helper for windows_nat_target::xfer_partial that handles signal info. */ 3166 3167 static enum target_xfer_status 3168 windows_xfer_siginfo (gdb_byte *readbuf, ULONGEST offset, ULONGEST len, 3169 ULONGEST *xfered_len) 3170 { 3171 char *buf = (char *) &siginfo_er; 3172 size_t bufsize = sizeof (siginfo_er); 3173 3174 #ifdef __x86_64__ 3175 EXCEPTION_RECORD32 er32; 3176 if (wow64_process) 3177 { 3178 buf = (char *) &er32; 3179 bufsize = sizeof (er32); 3180 3181 er32.ExceptionCode = siginfo_er.ExceptionCode; 3182 er32.ExceptionFlags = siginfo_er.ExceptionFlags; 3183 er32.ExceptionRecord = (uintptr_t) siginfo_er.ExceptionRecord; 3184 er32.ExceptionAddress = (uintptr_t) siginfo_er.ExceptionAddress; 3185 er32.NumberParameters = siginfo_er.NumberParameters; 3186 int i; 3187 for (i = 0; i < EXCEPTION_MAXIMUM_PARAMETERS; i++) 3188 er32.ExceptionInformation[i] = siginfo_er.ExceptionInformation[i]; 3189 } 3190 #endif 3191 3192 if (siginfo_er.ExceptionCode == 0) 3193 return TARGET_XFER_E_IO; 3194 3195 if (readbuf == nullptr) 3196 return TARGET_XFER_E_IO; 3197 3198 if (offset > bufsize) 3199 return TARGET_XFER_E_IO; 3200 3201 if (offset + len > bufsize) 3202 len = bufsize - offset; 3203 3204 memcpy (readbuf, buf + offset, len); 3205 *xfered_len = len; 3206 3207 return TARGET_XFER_OK; 3208 } 3209 3210 enum target_xfer_status 3211 windows_nat_target::xfer_partial (enum target_object object, 3212 const char *annex, gdb_byte *readbuf, 3213 const gdb_byte *writebuf, ULONGEST offset, 3214 ULONGEST len, ULONGEST *xfered_len) 3215 { 3216 switch (object) 3217 { 3218 case TARGET_OBJECT_MEMORY: 3219 return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len); 3220 3221 case TARGET_OBJECT_LIBRARIES: 3222 return windows_xfer_shared_libraries (this, object, annex, readbuf, 3223 writebuf, offset, len, xfered_len); 3224 3225 case TARGET_OBJECT_SIGNAL_INFO: 3226 return windows_xfer_siginfo (readbuf, offset, len, xfered_len); 3227 3228 default: 3229 if (beneath () == NULL) 3230 { 3231 /* This can happen when requesting the transfer of unsupported 3232 objects before a program has been started (and therefore 3233 with the current_target having no target beneath). */ 3234 return TARGET_XFER_E_IO; 3235 } 3236 return beneath ()->xfer_partial (object, annex, 3237 readbuf, writebuf, offset, len, 3238 xfered_len); 3239 } 3240 } 3241 3242 /* Provide thread local base, i.e. Thread Information Block address. 3243 Returns 1 if ptid is found and sets *ADDR to thread_local_base. */ 3244 3245 bool 3246 windows_nat_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) 3247 { 3248 windows_thread_info *th; 3249 3250 th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT); 3251 if (th == NULL) 3252 return false; 3253 3254 if (addr != NULL) 3255 *addr = th->thread_local_base; 3256 3257 return true; 3258 } 3259 3260 ptid_t 3261 windows_nat_target::get_ada_task_ptid (long lwp, long thread) 3262 { 3263 return ptid_t (inferior_ptid.pid (), lwp, 0); 3264 } 3265 3266 /* Implementation of the to_thread_name method. */ 3267 3268 const char * 3269 windows_nat_target::thread_name (struct thread_info *thr) 3270 { 3271 return thread_rec (thr->ptid, DONT_INVALIDATE_CONTEXT)->name.get (); 3272 } 3273 3274 3275 void _initialize_windows_nat (); 3276 void 3277 _initialize_windows_nat () 3278 { 3279 x86_dr_low.set_control = cygwin_set_dr7; 3280 x86_dr_low.set_addr = cygwin_set_dr; 3281 x86_dr_low.get_addr = cygwin_get_dr; 3282 x86_dr_low.get_status = cygwin_get_dr6; 3283 x86_dr_low.get_control = cygwin_get_dr7; 3284 3285 /* x86_dr_low.debug_register_length field is set by 3286 calling x86_set_debug_register_length function 3287 in processor windows specific native file. */ 3288 3289 add_inf_child_target (&the_windows_nat_target); 3290 3291 #ifdef __CYGWIN__ 3292 cygwin_internal (CW_SET_DOS_FILE_WARNING, 0); 3293 #endif 3294 3295 add_com ("signal-event", class_run, signal_event_command, _("\ 3296 Signal a crashed process with event ID, to allow its debugging.\n\ 3297 This command is needed in support of setting up GDB as JIT debugger on \ 3298 MS-Windows. The command should be invoked from the GDB command line using \ 3299 the '-ex' command-line option. The ID of the event that blocks the \ 3300 crashed process will be supplied by the Windows JIT debugging mechanism.")); 3301 3302 #ifdef __CYGWIN__ 3303 add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\ 3304 Set use of shell to start subprocess."), _("\ 3305 Show use of shell to start subprocess."), NULL, 3306 NULL, 3307 NULL, /* FIXME: i18n: */ 3308 &setlist, &showlist); 3309 3310 add_setshow_boolean_cmd ("cygwin-exceptions", class_support, 3311 &cygwin_exceptions, _("\ 3312 Break when an exception is detected in the Cygwin DLL itself."), _("\ 3313 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL, 3314 NULL, 3315 NULL, /* FIXME: i18n: */ 3316 &setlist, &showlist); 3317 #endif 3318 3319 add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\ 3320 Set creation of new console when creating child process."), _("\ 3321 Show creation of new console when creating child process."), NULL, 3322 NULL, 3323 NULL, /* FIXME: i18n: */ 3324 &setlist, &showlist); 3325 3326 add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\ 3327 Set creation of new group when creating child process."), _("\ 3328 Show creation of new group when creating child process."), NULL, 3329 NULL, 3330 NULL, /* FIXME: i18n: */ 3331 &setlist, &showlist); 3332 3333 add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\ 3334 Set whether to display execution in child process."), _("\ 3335 Show whether to display execution in child process."), NULL, 3336 NULL, 3337 NULL, /* FIXME: i18n: */ 3338 &setlist, &showlist); 3339 3340 add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\ 3341 Set whether to display kernel events in child process."), _("\ 3342 Show whether to display kernel events in child process."), NULL, 3343 NULL, 3344 NULL, /* FIXME: i18n: */ 3345 &setlist, &showlist); 3346 3347 add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\ 3348 Set whether to display memory accesses in child process."), _("\ 3349 Show whether to display memory accesses in child process."), NULL, 3350 NULL, 3351 NULL, /* FIXME: i18n: */ 3352 &setlist, &showlist); 3353 3354 add_setshow_boolean_cmd ("debugexceptions", class_support, 3355 &debug_exceptions, _("\ 3356 Set whether to display kernel exceptions in child process."), _("\ 3357 Show whether to display kernel exceptions in child process."), NULL, 3358 NULL, 3359 NULL, /* FIXME: i18n: */ 3360 &setlist, &showlist); 3361 3362 init_w32_command_list (); 3363 3364 add_cmd ("selector", class_info, display_selectors, 3365 _("Display selectors infos."), 3366 &info_w32_cmdlist); 3367 } 3368 3369 /* Hardware watchpoint support, adapted from go32-nat.c code. */ 3370 3371 /* Pass the address ADDR to the inferior in the I'th debug register. 3372 Here we just store the address in dr array, the registers will be 3373 actually set up when windows_continue is called. */ 3374 static void 3375 cygwin_set_dr (int i, CORE_ADDR addr) 3376 { 3377 if (i < 0 || i > 3) 3378 internal_error (__FILE__, __LINE__, 3379 _("Invalid register %d in cygwin_set_dr.\n"), i); 3380 dr[i] = addr; 3381 debug_registers_changed = 1; 3382 debug_registers_used = 1; 3383 } 3384 3385 /* Pass the value VAL to the inferior in the DR7 debug control 3386 register. Here we just store the address in D_REGS, the watchpoint 3387 will be actually set up in windows_wait. */ 3388 static void 3389 cygwin_set_dr7 (unsigned long val) 3390 { 3391 dr[7] = (CORE_ADDR) val; 3392 debug_registers_changed = 1; 3393 debug_registers_used = 1; 3394 } 3395 3396 /* Get the value of debug register I from the inferior. */ 3397 3398 static CORE_ADDR 3399 cygwin_get_dr (int i) 3400 { 3401 return dr[i]; 3402 } 3403 3404 /* Get the value of the DR6 debug status register from the inferior. 3405 Here we just return the value stored in dr[6] 3406 by the last call to thread_rec for current_event.dwThreadId id. */ 3407 static unsigned long 3408 cygwin_get_dr6 (void) 3409 { 3410 return (unsigned long) dr[6]; 3411 } 3412 3413 /* Get the value of the DR7 debug status register from the inferior. 3414 Here we just return the value stored in dr[7] by the last call to 3415 thread_rec for current_event.dwThreadId id. */ 3416 3417 static unsigned long 3418 cygwin_get_dr7 (void) 3419 { 3420 return (unsigned long) dr[7]; 3421 } 3422 3423 /* Determine if the thread referenced by "ptid" is alive 3424 by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0 3425 it means that the thread has died. Otherwise it is assumed to be alive. */ 3426 3427 bool 3428 windows_nat_target::thread_alive (ptid_t ptid) 3429 { 3430 gdb_assert (ptid.lwp () != 0); 3431 3432 return (WaitForSingleObject (thread_rec (ptid, DONT_INVALIDATE_CONTEXT)->h, 0) 3433 != WAIT_OBJECT_0); 3434 } 3435 3436 void _initialize_check_for_gdb_ini (); 3437 void 3438 _initialize_check_for_gdb_ini () 3439 { 3440 char *homedir; 3441 if (inhibit_gdbinit) 3442 return; 3443 3444 homedir = getenv ("HOME"); 3445 if (homedir) 3446 { 3447 char *p; 3448 char *oldini = (char *) alloca (strlen (homedir) + 3449 sizeof ("gdb.ini") + 1); 3450 strcpy (oldini, homedir); 3451 p = strchr (oldini, '\0'); 3452 if (p > oldini && !IS_DIR_SEPARATOR (p[-1])) 3453 *p++ = '/'; 3454 strcpy (p, "gdb.ini"); 3455 if (access (oldini, 0) == 0) 3456 { 3457 int len = strlen (oldini); 3458 char *newini = (char *) alloca (len + 2); 3459 3460 xsnprintf (newini, len + 2, "%.*s.gdbinit", 3461 (int) (len - (sizeof ("gdb.ini") - 1)), oldini); 3462 warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini); 3463 } 3464 } 3465 } 3466 3467 /* Define dummy functions which always return error for the rare cases where 3468 these functions could not be found. */ 3469 static BOOL WINAPI 3470 bad_DebugActiveProcessStop (DWORD w) 3471 { 3472 return FALSE; 3473 } 3474 static BOOL WINAPI 3475 bad_DebugBreakProcess (HANDLE w) 3476 { 3477 return FALSE; 3478 } 3479 static BOOL WINAPI 3480 bad_DebugSetProcessKillOnExit (BOOL w) 3481 { 3482 return FALSE; 3483 } 3484 static BOOL WINAPI 3485 bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z) 3486 { 3487 return FALSE; 3488 } 3489 3490 #ifdef __USEWIDE 3491 static DWORD WINAPI 3492 bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z) 3493 { 3494 return 0; 3495 } 3496 #else 3497 static DWORD WINAPI 3498 bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z) 3499 { 3500 return 0; 3501 } 3502 #endif 3503 3504 static BOOL WINAPI 3505 bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z) 3506 { 3507 return FALSE; 3508 } 3509 3510 static BOOL WINAPI 3511 bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y) 3512 { 3513 return FALSE; 3514 } 3515 3516 static BOOL WINAPI 3517 bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f) 3518 { 3519 f->nFont = 0; 3520 return 1; 3521 } 3522 static COORD WINAPI 3523 bad_GetConsoleFontSize (HANDLE w, DWORD nFont) 3524 { 3525 COORD size; 3526 size.X = 8; 3527 size.Y = 12; 3528 return size; 3529 } 3530 3531 /* Load any functions which may not be available in ancient versions 3532 of Windows. */ 3533 3534 void _initialize_loadable (); 3535 void 3536 _initialize_loadable () 3537 { 3538 HMODULE hm = NULL; 3539 3540 #define GPA(m, func) \ 3541 func = (func ## _ftype *) GetProcAddress (m, #func) 3542 3543 hm = LoadLibrary ("kernel32.dll"); 3544 if (hm) 3545 { 3546 GPA (hm, DebugActiveProcessStop); 3547 GPA (hm, DebugBreakProcess); 3548 GPA (hm, DebugSetProcessKillOnExit); 3549 GPA (hm, GetConsoleFontSize); 3550 GPA (hm, DebugActiveProcessStop); 3551 GPA (hm, GetCurrentConsoleFont); 3552 #ifdef __x86_64__ 3553 GPA (hm, Wow64SuspendThread); 3554 GPA (hm, Wow64GetThreadContext); 3555 GPA (hm, Wow64SetThreadContext); 3556 GPA (hm, Wow64GetThreadSelectorEntry); 3557 #endif 3558 } 3559 3560 /* Set variables to dummy versions of these processes if the function 3561 wasn't found in kernel32.dll. */ 3562 if (!DebugBreakProcess) 3563 DebugBreakProcess = bad_DebugBreakProcess; 3564 if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit) 3565 { 3566 DebugActiveProcessStop = bad_DebugActiveProcessStop; 3567 DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit; 3568 } 3569 if (!GetConsoleFontSize) 3570 GetConsoleFontSize = bad_GetConsoleFontSize; 3571 if (!GetCurrentConsoleFont) 3572 GetCurrentConsoleFont = bad_GetCurrentConsoleFont; 3573 3574 /* Load optional functions used for retrieving filename information 3575 associated with the currently debugged process or its dlls. */ 3576 hm = LoadLibrary ("psapi.dll"); 3577 if (hm) 3578 { 3579 GPA (hm, EnumProcessModules); 3580 #ifdef __x86_64__ 3581 GPA (hm, EnumProcessModulesEx); 3582 #endif 3583 GPA (hm, GetModuleInformation); 3584 GetModuleFileNameEx = (GetModuleFileNameEx_ftype *) 3585 GetProcAddress (hm, GetModuleFileNameEx_name); 3586 } 3587 3588 if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx) 3589 { 3590 /* Set variables to dummy versions of these processes if the function 3591 wasn't found in psapi.dll. */ 3592 EnumProcessModules = bad_EnumProcessModules; 3593 GetModuleInformation = bad_GetModuleInformation; 3594 GetModuleFileNameEx = bad_GetModuleFileNameEx; 3595 /* This will probably fail on Windows 9x/Me. Let the user know 3596 that we're missing some functionality. */ 3597 warning(_("\ 3598 cannot automatically find executable file or library to read symbols.\n\ 3599 Use \"file\" or \"dll\" command to load executable/libraries directly.")); 3600 } 3601 3602 hm = LoadLibrary ("advapi32.dll"); 3603 if (hm) 3604 { 3605 GPA (hm, OpenProcessToken); 3606 GPA (hm, LookupPrivilegeValueA); 3607 GPA (hm, AdjustTokenPrivileges); 3608 /* Only need to set one of these since if OpenProcessToken fails nothing 3609 else is needed. */ 3610 if (!OpenProcessToken || !LookupPrivilegeValueA 3611 || !AdjustTokenPrivileges) 3612 OpenProcessToken = bad_OpenProcessToken; 3613 } 3614 3615 #undef GPA 3616 } 3617