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