gdb/windows-nat.c

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