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