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