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