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