gdb/windows-nat.c

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