gdb/windows-nat.c

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