gdb/windows-nat.c

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