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