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