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