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