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;
1462
1463       /* Ignore CTRL+C signals while waiting for a debug event.
1464          FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1465          the inferior is running, both the inferior and GDB receive the
1466          associated signal.  If the inferior receives the signal first
1467          and the delay until GDB receives that signal is sufficiently long,
1468          GDB can sometimes receive the SIGINT after we have unblocked
1469          the CTRL+C handler.  This would lead to the debugger to stop
1470          prematurely while handling the new-thread event that comes
1471          with the handling of the SIGINT inside the inferior, and then
1472          stop again immediately when the user tries to resume the execution
1473          in the inferior.  This is a classic race, and it would be nice
1474          to find a better solution to that problem.  But in the meantime,
1475          the current approach already greatly mitigate this issue.  */
1476       SetConsoleCtrlHandler (NULL, TRUE);
1477       retval = get_win32_debug_event (pid, ourstatus);
1478       SetConsoleCtrlHandler (NULL, FALSE);
1479
1480       if (retval)
1481         return pid_to_ptid (retval);
1482       else
1483         {
1484           int detach = 0;
1485
1486           if (deprecated_ui_loop_hook != NULL)
1487             detach = deprecated_ui_loop_hook (0);
1488
1489           if (detach)
1490             win32_kill_inferior ();
1491         }
1492     }
1493 }
1494
1495 static void
1496 do_initial_win32_stuff (DWORD pid)
1497 {
1498   extern int stop_after_trap;
1499   int i;
1500
1501   last_sig = TARGET_SIGNAL_0;
1502   event_count = 0;
1503   exception_count = 0;
1504   open_process_used = 0;
1505   debug_registers_changed = 0;
1506   debug_registers_used = 0;
1507   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1508     dr[i] = 0;
1509 #ifdef __CYGWIN__
1510   cygwin_load_start = cygwin_load_end = 0;
1511 #endif
1512   current_event.dwProcessId = pid;
1513   memset (&current_event, 0, sizeof (current_event));
1514   push_target (&win32_ops);
1515   disable_breakpoints_in_shlibs ();
1516   win32_clear_solib ();
1517   clear_proceed_status ();
1518   init_wait_for_inferior ();
1519
1520   terminal_init_inferior_with_pgrp (pid);
1521   target_terminal_inferior ();
1522
1523   while (1)
1524     {
1525       stop_after_trap = 1;
1526       wait_for_inferior (0);
1527       if (stop_signal != TARGET_SIGNAL_TRAP)
1528         resume (0, stop_signal);
1529       else
1530         break;
1531     }
1532   stop_after_trap = 0;
1533   return;
1534 }
1535
1536 /* Since Windows XP, detaching from a process is supported by Windows.
1537    The following code tries loading the appropriate functions dynamically.
1538    If loading these functions succeeds use them to actually detach from
1539    the inferior process, otherwise behave as usual, pretending that
1540    detach has worked. */
1541 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1542 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1543
1544 static int
1545 has_detach_ability (void)
1546 {
1547   static HMODULE kernel32 = NULL;
1548
1549   if (!kernel32)
1550     kernel32 = LoadLibrary ("kernel32.dll");
1551   if (kernel32)
1552     {
1553       if (!DebugSetProcessKillOnExit)
1554         DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1555                                                  "DebugSetProcessKillOnExit");
1556       if (!DebugActiveProcessStop)
1557         DebugActiveProcessStop = GetProcAddress (kernel32,
1558                                                  "DebugActiveProcessStop");
1559       if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1560         return 1;
1561     }
1562   return 0;
1563 }
1564
1565 /* Try to set or remove a user privilege to the current process.  Return -1
1566    if that fails, the previous setting of that privilege otherwise.
1567
1568    This code is copied from the Cygwin source code and rearranged to allow
1569    dynamically loading of the needed symbols from advapi32 which is only
1570    available on NT/2K/XP. */
1571 static int
1572 set_process_privilege (const char *privilege, BOOL enable)
1573 {
1574   static HMODULE advapi32 = NULL;
1575   static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1576   static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1577   static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1578                                               DWORD, PTOKEN_PRIVILEGES, PDWORD);
1579
1580   HANDLE token_hdl = NULL;
1581   LUID restore_priv;
1582   TOKEN_PRIVILEGES new_priv, orig_priv;
1583   int ret = -1;
1584   DWORD size;
1585
1586   if (GetVersion () >= 0x80000000)  /* No security availbale on 9x/Me */
1587     return 0;
1588
1589   if (!advapi32)
1590     {
1591       if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1592         goto out;
1593       if (!OpenProcessToken)
1594         OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1595       if (!LookupPrivilegeValue)
1596         LookupPrivilegeValue = GetProcAddress (advapi32,
1597                                                "LookupPrivilegeValueA");
1598       if (!AdjustTokenPrivileges)
1599         AdjustTokenPrivileges = GetProcAddress (advapi32,
1600                                                 "AdjustTokenPrivileges");
1601       if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1602         {
1603           advapi32 = NULL;
1604           goto out;
1605         }
1606     }
1607
1608   if (!OpenProcessToken (GetCurrentProcess (),
1609                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1610                          &token_hdl))
1611     goto out;
1612
1613   if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1614     goto out;
1615
1616   new_priv.PrivilegeCount = 1;
1617   new_priv.Privileges[0].Luid = restore_priv;
1618   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1619
1620   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1621                               sizeof orig_priv, &orig_priv, &size))
1622     goto out;
1623 #if 0
1624   /* Disabled, otherwise every `attach' in an unprivileged user session
1625      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1626      win32_attach(). */
1627   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1628      be enabled. GetLastError () returns an correct error code, though. */
1629   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1630     goto out;
1631 #endif
1632
1633   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1634
1635 out:
1636   if (token_hdl)
1637     CloseHandle (token_hdl);
1638
1639   return ret;
1640 }
1641
1642 /* Attach to process PID, then initialize for debugging it.  */
1643 static void
1644 win32_attach (char *args, int from_tty)
1645 {
1646   BOOL ok;
1647   DWORD pid;
1648
1649   if (!args)
1650     error_no_arg (_("process-id to attach"));
1651
1652   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1653     {
1654       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1655       printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1656     }
1657
1658   pid = strtoul (args, 0, 0);           /* Windows pid */
1659
1660   win32_init_thread_list ();
1661   ok = DebugActiveProcess (pid);
1662   saw_create = 0;
1663
1664 #ifdef __CYGWIN__
1665   if (!ok)
1666     {
1667       /* Try fall back to Cygwin pid */
1668       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1669
1670       if (pid > 0)
1671         ok = DebugActiveProcess (pid);
1672   }
1673 #endif
1674
1675   if (!ok)
1676     error (_("Can't attach to process."));
1677
1678   if (has_detach_ability ())
1679     DebugSetProcessKillOnExit (FALSE);
1680
1681   attach_flag = 1;
1682
1683   if (from_tty)
1684     {
1685       char *exec_file = (char *) get_exec_file (0);
1686
1687       if (exec_file)
1688         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1689                            target_pid_to_str (pid_to_ptid (pid)));
1690       else
1691         printf_unfiltered ("Attaching to %s\n",
1692                            target_pid_to_str (pid_to_ptid (pid)));
1693
1694       gdb_flush (gdb_stdout);
1695     }
1696
1697   do_initial_win32_stuff (pid);
1698   target_terminal_ours ();
1699 }
1700
1701 static void
1702 win32_detach (char *args, int from_tty)
1703 {
1704   int detached = 1;
1705
1706   if (has_detach_ability ())
1707     {
1708       ptid_t ptid = {-1};
1709       win32_resume (ptid, 0, TARGET_SIGNAL_0);
1710
1711       if (!DebugActiveProcessStop (current_event.dwProcessId))
1712         {
1713           error (_("Can't detach process %lu (error %lu)"),
1714                  current_event.dwProcessId, GetLastError ());
1715           detached = 0;
1716         }
1717       DebugSetProcessKillOnExit (FALSE);
1718     }
1719   if (detached && from_tty)
1720     {
1721       char *exec_file = get_exec_file (0);
1722       if (exec_file == 0)
1723         exec_file = "";
1724       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1725                          current_event.dwProcessId);
1726       gdb_flush (gdb_stdout);
1727     }
1728   inferior_ptid = null_ptid;
1729   unpush_target (&win32_ops);
1730 }
1731
1732 static char *
1733 win32_pid_to_exec_file (int pid)
1734 {
1735   static char path[MAX_PATH + 1];
1736
1737 #ifdef __CYGWIN__
1738   /* Try to find exe name as symlink target of /proc/<pid>/exe */
1739   int nchars;
1740   char procexe[sizeof ("/proc/4294967295/exe")];
1741   sprintf (procexe, "/proc/%lu/exe", current_event.dwProcessId);
1742   nchars = readlink (procexe, path, sizeof(path));
1743   if (nchars > 0 && nchars < sizeof (path))
1744     {
1745       path[nchars] = '\0';      /* Got it */
1746       return path;
1747     }
1748 #endif
1749
1750   /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1751      of gdb, or we're trying to debug a non-Cygwin windows executable. */
1752   if (!get_module_name (0, path))
1753     path[0] = '\0';
1754
1755   return path;
1756 }
1757
1758 /* Print status information about what we're accessing.  */
1759
1760 static void
1761 win32_files_info (struct target_ops *ignore)
1762 {
1763   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1764       attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1765 }
1766
1767 static void
1768 win32_open (char *arg, int from_tty)
1769 {
1770   error (_("Use the \"run\" command to start a Unix child process."));
1771 }
1772
1773 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1774    EXEC_FILE is the file to run.
1775    ALLARGS is a string containing the arguments to the program.
1776    ENV is the environment vector to pass.  Errors reported with error().  */
1777
1778 static void
1779 win32_create_inferior (char *exec_file, char *allargs, char **in_env,
1780                        int from_tty)
1781 {
1782   STARTUPINFO si;
1783   PROCESS_INFORMATION pi;
1784   BOOL ret;
1785   DWORD flags;
1786   char *args;
1787   char real_path[MAXPATHLEN];
1788   char *toexec;
1789   char shell[MAX_PATH + 1]; /* Path to shell */
1790   const char *sh;
1791   int tty;
1792   int ostdin, ostdout, ostderr;
1793   const char *inferior_io_terminal = get_inferior_io_terminal ();
1794
1795   if (!exec_file)
1796     error (_("No executable specified, use `target exec'."));
1797
1798   memset (&si, 0, sizeof (si));
1799   si.cb = sizeof (si);
1800
1801 #ifdef __CYGWIN__
1802   if (!useshell)
1803     {
1804       flags = DEBUG_ONLY_THIS_PROCESS;
1805       cygwin_conv_to_win32_path (exec_file, real_path);
1806       toexec = real_path;
1807     }
1808   else
1809     {
1810       char *newallargs;
1811       sh = getenv ("SHELL");
1812       if (!sh)
1813         sh = "/bin/sh";
1814       cygwin_conv_to_win32_path (sh, shell);
1815       newallargs = alloca (sizeof (" -c 'exec  '") + strlen (exec_file)
1816                            + strlen (allargs) + 2);
1817       sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1818       allargs = newallargs;
1819       toexec = shell;
1820       flags = DEBUG_PROCESS;
1821     }
1822 #else
1823   toexec = exec_file;
1824   flags = DEBUG_ONLY_THIS_PROCESS;
1825 #endif
1826
1827   if (new_group)
1828     flags |= CREATE_NEW_PROCESS_GROUP;
1829
1830   if (new_console)
1831     flags |= CREATE_NEW_CONSOLE;
1832
1833   attach_flag = 0;
1834
1835   args = alloca (strlen (toexec) + strlen (allargs) + 2);
1836   strcpy (args, toexec);
1837   strcat (args, " ");
1838   strcat (args, allargs);
1839
1840 #ifdef __CYGWIN__
1841   /* Prepare the environment vars for CreateProcess.  */
1842   cygwin_internal (CW_SYNC_WINENV);
1843
1844   if (!inferior_io_terminal)
1845     tty = ostdin = ostdout = ostderr = -1;
1846   else
1847     {
1848       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1849       if (tty < 0)
1850         {
1851           print_sys_errmsg (inferior_io_terminal, errno);
1852           ostdin = ostdout = ostderr = -1;
1853         }
1854       else
1855         {
1856           ostdin = dup (0);
1857           ostdout = dup (1);
1858           ostderr = dup (2);
1859           dup2 (tty, 0);
1860           dup2 (tty, 1);
1861           dup2 (tty, 2);
1862         }
1863     }
1864 #endif
1865
1866   win32_init_thread_list ();
1867   ret = CreateProcess (0,
1868                        args,    /* command line */
1869                        NULL,    /* Security */
1870                        NULL,    /* thread */
1871                        TRUE,    /* inherit handles */
1872                        flags,   /* start flags */
1873                        NULL,    /* environment */
1874                        NULL,    /* current directory */
1875                        &si,
1876                        &pi);
1877
1878 #ifdef __CYGWIN__
1879   if (tty >= 0)
1880     {
1881       close (tty);
1882       dup2 (ostdin, 0);
1883       dup2 (ostdout, 1);
1884       dup2 (ostderr, 2);
1885       close (ostdin);
1886       close (ostdout);
1887       close (ostderr);
1888     }
1889 #endif
1890
1891   if (!ret)
1892     error (_("Error creating process %s, (error %d)."),
1893            exec_file, (unsigned) GetLastError ());
1894
1895   CloseHandle (pi.hThread);
1896   CloseHandle (pi.hProcess);
1897
1898   if (useshell && shell[0] != '\0')
1899     saw_create = -1;
1900   else
1901     saw_create = 0;
1902
1903   do_initial_win32_stuff (pi.dwProcessId);
1904
1905   /* win32_continue (DBG_CONTINUE, -1); */
1906 }
1907
1908 static void
1909 win32_mourn_inferior (void)
1910 {
1911   (void) win32_continue (DBG_CONTINUE, -1);
1912   i386_cleanup_dregs();
1913   if (open_process_used)
1914     {
1915       CHECK (CloseHandle (current_process_handle));
1916       open_process_used = 0;
1917     }
1918   unpush_target (&win32_ops);
1919   generic_mourn_inferior ();
1920 }
1921
1922 /* Send a SIGINT to the process group.  This acts just like the user typed a
1923    ^C on the controlling terminal. */
1924
1925 static void
1926 win32_stop (void)
1927 {
1928   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1929   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1930   registers_changed ();         /* refresh register state */
1931 }
1932
1933 static int
1934 win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1935                    int write, struct mem_attrib *mem,
1936                    struct target_ops *target)
1937 {
1938   DWORD done = 0;
1939   if (write)
1940     {
1941       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1942                   len, (DWORD) (uintptr_t) memaddr));
1943       if (!WriteProcessMemory (current_process_handle,
1944                                (LPVOID) (uintptr_t) memaddr, our,
1945                                len, &done))
1946         done = 0;
1947       FlushInstructionCache (current_process_handle,
1948                              (LPCVOID) (uintptr_t) memaddr, len);
1949     }
1950   else
1951     {
1952       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1953                   len, (DWORD) (uintptr_t) memaddr));
1954       if (!ReadProcessMemory (current_process_handle,
1955                               (LPCVOID) (uintptr_t) memaddr, our,
1956                               len, &done))
1957         done = 0;
1958     }
1959   return done;
1960 }
1961
1962 static void
1963 win32_kill_inferior (void)
1964 {
1965   CHECK (TerminateProcess (current_process_handle, 0));
1966
1967   for (;;)
1968     {
1969       if (!win32_continue (DBG_CONTINUE, -1))
1970         break;
1971       if (!WaitForDebugEvent (&current_event, INFINITE))
1972         break;
1973       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1974         break;
1975     }
1976
1977   target_mourn_inferior ();     /* or just win32_mourn_inferior? */
1978 }
1979
1980 static void
1981 win32_prepare_to_store (struct regcache *regcache)
1982 {
1983   /* Do nothing, since we can store individual regs */
1984 }
1985
1986 static int
1987 win32_can_run (void)
1988 {
1989   return 1;
1990 }
1991
1992 static void
1993 win32_close (int x)
1994 {
1995   DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
1996                 PIDGET (inferior_ptid)));
1997 }
1998
1999 /* Convert pid to printable format. */
2000 static char *
2001 win32_pid_to_str (ptid_t ptid)
2002 {
2003   static char buf[80];
2004   int pid = PIDGET (ptid);
2005
2006   if ((DWORD) pid == current_event.dwProcessId)
2007     sprintf (buf, "process %d", pid);
2008   else
2009     sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
2010   return buf;
2011 }
2012
2013 static LONGEST
2014 win32_xfer_shared_libraries (struct target_ops *ops,
2015                              enum target_object object, const char *annex,
2016                              gdb_byte *readbuf, const gdb_byte *writebuf,
2017                              ULONGEST offset, LONGEST len)
2018 {
2019   struct obstack obstack;
2020   const char *buf;
2021   LONGEST len_avail;
2022   struct so_list *so;
2023
2024   if (writebuf)
2025     return -1;
2026
2027   obstack_init (&obstack);
2028   obstack_grow_str (&obstack, "<library-list>\n");
2029   for (so = solib_start.next; so; so = so->next)
2030     win32_xfer_shared_library (so->so_name, so->lm_info->load_addr, &obstack);
2031   obstack_grow_str0 (&obstack, "</library-list>\n");
2032
2033   buf = obstack_finish (&obstack);
2034   len_avail = strlen (buf);
2035   if (offset >= len_avail)
2036     return 0;
2037
2038   if (len > len_avail - offset)
2039     len = len_avail - offset;
2040   memcpy (readbuf, buf + offset, len);
2041
2042   obstack_free (&obstack, NULL);
2043   return len;
2044 }
2045
2046 static LONGEST
2047 win32_xfer_partial (struct target_ops *ops, enum target_object object,
2048                     const char *annex, gdb_byte *readbuf,
2049                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2050 {
2051   switch (object)
2052     {
2053     case TARGET_OBJECT_MEMORY:
2054       if (readbuf)
2055         return (*ops->deprecated_xfer_memory) (offset, readbuf,
2056                                                len, 0/*read*/, NULL, ops);
2057       if (writebuf)
2058         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2059                                                len, 1/*write*/, NULL, ops);
2060       return -1;
2061
2062     case TARGET_OBJECT_LIBRARIES:
2063       return win32_xfer_shared_libraries (ops, object, annex, readbuf,
2064                                           writebuf, offset, len);
2065
2066     default:
2067       if (ops->beneath != NULL)
2068         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2069                                               readbuf, writebuf, offset, len);
2070       return -1;
2071     }
2072 }
2073
2074 static void
2075 init_win32_ops (void)
2076 {
2077   win32_ops.to_shortname = "child";
2078   win32_ops.to_longname = "Win32 child process";
2079   win32_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2080   win32_ops.to_open = win32_open;
2081   win32_ops.to_close = win32_close;
2082   win32_ops.to_attach = win32_attach;
2083   win32_ops.to_detach = win32_detach;
2084   win32_ops.to_resume = win32_resume;
2085   win32_ops.to_wait = win32_wait;
2086   win32_ops.to_fetch_registers = win32_fetch_inferior_registers;
2087   win32_ops.to_store_registers = win32_store_inferior_registers;
2088   win32_ops.to_prepare_to_store = win32_prepare_to_store;
2089   win32_ops.deprecated_xfer_memory = win32_xfer_memory;
2090   win32_ops.to_xfer_partial = win32_xfer_partial;
2091   win32_ops.to_files_info = win32_files_info;
2092   win32_ops.to_insert_breakpoint = memory_insert_breakpoint;
2093   win32_ops.to_remove_breakpoint = memory_remove_breakpoint;
2094   win32_ops.to_terminal_init = terminal_init_inferior;
2095   win32_ops.to_terminal_inferior = terminal_inferior;
2096   win32_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2097   win32_ops.to_terminal_ours = terminal_ours;
2098   win32_ops.to_terminal_save_ours = terminal_save_ours;
2099   win32_ops.to_terminal_info = child_terminal_info;
2100   win32_ops.to_kill = win32_kill_inferior;
2101   win32_ops.to_create_inferior = win32_create_inferior;
2102   win32_ops.to_mourn_inferior = win32_mourn_inferior;
2103   win32_ops.to_can_run = win32_can_run;
2104   win32_ops.to_thread_alive = win32_win32_thread_alive;
2105   win32_ops.to_pid_to_str = win32_pid_to_str;
2106   win32_ops.to_stop = win32_stop;
2107   win32_ops.to_stratum = process_stratum;
2108   win32_ops.to_has_all_memory = 1;
2109   win32_ops.to_has_memory = 1;
2110   win32_ops.to_has_stack = 1;
2111   win32_ops.to_has_registers = 1;
2112   win32_ops.to_has_execution = 1;
2113   win32_ops.to_magic = OPS_MAGIC;
2114   win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
2115 }
2116
2117 static void
2118 set_win32_aliases (char *argv0)
2119 {
2120   add_info_alias ("dll", "sharedlibrary", 1);
2121 }
2122
2123 void
2124 _initialize_win32_nat (void)
2125 {
2126   struct cmd_list_element *c;
2127
2128   init_win32_ops ();
2129
2130   c = add_com ("dll-symbols", class_files, dll_symbol_command,
2131                _("Load dll library symbols from FILE."));
2132   set_cmd_completer (c, filename_completer);
2133
2134   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2135
2136 #ifdef __CYGWIN__
2137   add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2138 Set use of shell to start subprocess."), _("\
2139 Show use of shell to start subprocess."), NULL,
2140                            NULL,
2141                            NULL, /* FIXME: i18n: */
2142                            &setlist, &showlist);
2143
2144   add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2145 Break when an exception is detected in the Cygwin DLL itself."), _("\
2146 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2147                            NULL,
2148                            NULL, /* FIXME: i18n: */
2149                            &setlist, &showlist);
2150 #endif
2151
2152   add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2153 Set creation of new console when creating child process."), _("\
2154 Show creation of new console when creating child process."), NULL,
2155                            NULL,
2156                            NULL, /* FIXME: i18n: */
2157                            &setlist, &showlist);
2158
2159   add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2160 Set creation of new group when creating child process."), _("\
2161 Show creation of new group when creating child process."), NULL,
2162                            NULL,
2163                            NULL, /* FIXME: i18n: */
2164                            &setlist, &showlist);
2165
2166   add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2167 Set whether to display execution in child process."), _("\
2168 Show whether to display execution in child process."), NULL,
2169                            NULL,
2170                            NULL, /* FIXME: i18n: */
2171                            &setlist, &showlist);
2172
2173   add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2174 Set whether to display kernel events in child process."), _("\
2175 Show whether to display kernel events in child process."), NULL,
2176                            NULL,
2177                            NULL, /* FIXME: i18n: */
2178                            &setlist, &showlist);
2179
2180   add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2181 Set whether to display memory accesses in child process."), _("\
2182 Show whether to display memory accesses in child process."), NULL,
2183                            NULL,
2184                            NULL, /* FIXME: i18n: */
2185                            &setlist, &showlist);
2186
2187   add_setshow_boolean_cmd ("debugexceptions", class_support,
2188                            &debug_exceptions, _("\
2189 Set whether to display kernel exceptions in child process."), _("\
2190 Show whether to display kernel exceptions in child process."), NULL,
2191                            NULL,
2192                            NULL, /* FIXME: i18n: */
2193                            &setlist, &showlist);
2194
2195   add_prefix_cmd ("w32", class_info, info_w32_command,
2196                   _("Print information specific to Win32 debugging."),
2197                   &info_w32_cmdlist, "info w32 ", 0, &infolist);
2198
2199   add_cmd ("selector", class_info, display_selectors,
2200            _("Display selectors infos."),
2201            &info_w32_cmdlist);
2202   add_target (&win32_ops);
2203   deprecated_init_ui_hook = set_win32_aliases;
2204 }
2205
2206 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
2207
2208 /* Pass the address ADDR to the inferior in the I'th debug register.
2209    Here we just store the address in dr array, the registers will be
2210    actually set up when win32_continue is called.  */
2211 void
2212 cygwin_set_dr (int i, CORE_ADDR addr)
2213 {
2214   if (i < 0 || i > 3)
2215     internal_error (__FILE__, __LINE__,
2216                     _("Invalid register %d in cygwin_set_dr.\n"), i);
2217   dr[i] = (unsigned) addr;
2218   debug_registers_changed = 1;
2219   debug_registers_used = 1;
2220 }
2221
2222 /* Pass the value VAL to the inferior in the DR7 debug control
2223    register.  Here we just store the address in D_REGS, the watchpoint
2224    will be actually set up in win32_wait.  */
2225 void
2226 cygwin_set_dr7 (unsigned val)
2227 {
2228   dr[7] = val;
2229   debug_registers_changed = 1;
2230   debug_registers_used = 1;
2231 }
2232
2233 /* Get the value of the DR6 debug status register from the inferior.
2234    Here we just return the value stored in dr[6]
2235    by the last call to thread_rec for current_event.dwThreadId id.  */
2236 unsigned
2237 cygwin_get_dr6 (void)
2238 {
2239   return dr[6];
2240 }
2241
2242 /* Determine if the thread referenced by "pid" is alive
2243    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
2244    it means that the pid has died.  Otherwise it is assumed to be alive. */
2245 static int
2246 win32_win32_thread_alive (ptid_t ptid)
2247 {
2248   int pid = PIDGET (ptid);
2249
2250   return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2251     FALSE : TRUE;
2252 }
2253
2254 void
2255 _initialize_check_for_gdb_ini (void)
2256 {
2257   char *homedir;
2258   if (inhibit_gdbinit)
2259     return;
2260
2261   homedir = getenv ("HOME");
2262   if (homedir)
2263     {
2264       char *p;
2265       char *oldini = (char *) alloca (strlen (homedir) +
2266                                       sizeof ("/gdb.ini"));
2267       strcpy (oldini, homedir);
2268       p = strchr (oldini, '\0');
2269       if (p > oldini && p[-1] != '/')
2270         *p++ = '/';
2271       strcpy (p, "gdb.ini");
2272       if (access (oldini, 0) == 0)
2273         {
2274           int len = strlen (oldini);
2275           char *newini = alloca (len + 1);
2276           sprintf (newini, "%.*s.gdbinit",
2277             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2278           warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2279         }
2280     }
2281 }
2282
2283 void
2284 _initialize_psapi (void)
2285 {
2286   /* Load optional functions used for retrieving filename information
2287      associated with the currently debugged process or its dlls. */
2288   if (!psapi_loaded)
2289     {
2290       HMODULE psapi_module_handle;
2291
2292       psapi_loaded = -1;
2293
2294       psapi_module_handle = LoadLibrary ("psapi.dll");
2295       if (psapi_module_handle)
2296         {
2297           psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2298           psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2299           psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2300
2301           if (psapi_EnumProcessModules != NULL
2302               && psapi_GetModuleInformation != NULL
2303               && psapi_GetModuleFileNameExA != NULL)
2304             psapi_loaded = 1;
2305         }
2306     }
2307
2308   /* This will probably fail on Windows 9x/Me.  Let the user know that we're
2309      missing some functionality. */
2310   if (psapi_loaded < 0)
2311     warning(_("cannot automatically find executable file or library to read symbols.  Use \"file\" or \"dll\" command to load executable/libraries directly."));
2312 }