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