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