gdb/windows-nat.c

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