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