gdb/windows-nat.c

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