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