GDB (xrefs)

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