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