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 uintptr_t 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 (struct target_ops *);
 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 (ops);
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 #ifdef __CYGWIN__
1819   int tty;
1820   int ostdin, ostdout, ostderr;
1821 #else
1822   HANDLE tty;
1823 #endif
1824   const char *inferior_io_terminal = get_inferior_io_terminal ();
1825
1826   if (!exec_file)
1827     error (_("No executable specified, use `target exec'."));
1828
1829   memset (&si, 0, sizeof (si));
1830   si.cb = sizeof (si);
1831
1832 #ifdef __CYGWIN__
1833   if (!useshell)
1834     {
1835       flags = DEBUG_ONLY_THIS_PROCESS;
1836       cygwin_conv_to_win32_path (exec_file, real_path);
1837       toexec = real_path;
1838     }
1839   else
1840     {
1841       char *newallargs;
1842       sh = getenv ("SHELL");
1843       if (!sh)
1844         sh = "/bin/sh";
1845       cygwin_conv_to_win32_path (sh, shell);
1846       newallargs = alloca (sizeof (" -c 'exec  '") + strlen (exec_file)
1847                            + strlen (allargs) + 2);
1848       sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1849       allargs = newallargs;
1850       toexec = shell;
1851       flags = DEBUG_PROCESS;
1852     }
1853 #else
1854   toexec = exec_file;
1855   flags = DEBUG_ONLY_THIS_PROCESS;
1856 #endif
1857
1858   if (new_group)
1859     flags |= CREATE_NEW_PROCESS_GROUP;
1860
1861   if (new_console)
1862     flags |= CREATE_NEW_CONSOLE;
1863
1864   args = alloca (strlen (toexec) + strlen (allargs) + 2);
1865   strcpy (args, toexec);
1866   strcat (args, " ");
1867   strcat (args, allargs);
1868
1869 #ifdef __CYGWIN__
1870   /* Prepare the environment vars for CreateProcess.  */
1871   cygwin_internal (CW_SYNC_WINENV);
1872
1873   if (!inferior_io_terminal)
1874     tty = ostdin = ostdout = ostderr = -1;
1875   else
1876     {
1877       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1878       if (tty < 0)
1879         {
1880           print_sys_errmsg (inferior_io_terminal, errno);
1881           ostdin = ostdout = ostderr = -1;
1882         }
1883       else
1884         {
1885           ostdin = dup (0);
1886           ostdout = dup (1);
1887           ostderr = dup (2);
1888           dup2 (tty, 0);
1889           dup2 (tty, 1);
1890           dup2 (tty, 2);
1891         }
1892     }
1893 #else
1894   if (!inferior_io_terminal)
1895     tty = INVALID_HANDLE_VALUE;
1896   else
1897     {
1898       SECURITY_ATTRIBUTES sa;
1899       sa.nLength = sizeof(sa);
1900       sa.lpSecurityDescriptor = 0;
1901       sa.bInheritHandle = TRUE;
1902       tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
1903                          0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
1904       if (tty == INVALID_HANDLE_VALUE)
1905         warning (_("Warning: Failed to open TTY %s, error %#x."),
1906                  inferior_io_terminal, (unsigned) GetLastError ());
1907       else
1908         {
1909           si.hStdInput = tty;
1910           si.hStdOutput = tty;
1911           si.hStdError = tty;
1912           si.dwFlags |= STARTF_USESTDHANDLES;
1913         }
1914     }
1915 #endif
1916
1917   windows_init_thread_list ();
1918   ret = CreateProcess (0,
1919                        args,    /* command line */
1920                        NULL,    /* Security */
1921                        NULL,    /* thread */
1922                        TRUE,    /* inherit handles */
1923                        flags,   /* start flags */
1924                        NULL,    /* environment */
1925                        NULL,    /* current directory */
1926                        &si,
1927                        &pi);
1928
1929 #ifdef __CYGWIN__
1930   if (tty >= 0)
1931     {
1932       close (tty);
1933       dup2 (ostdin, 0);
1934       dup2 (ostdout, 1);
1935       dup2 (ostderr, 2);
1936       close (ostdin);
1937       close (ostdout);
1938       close (ostderr);
1939     }
1940 #else
1941   if (tty != INVALID_HANDLE_VALUE)
1942     CloseHandle (tty);
1943 #endif
1944
1945   if (!ret)
1946     error (_("Error creating process %s, (error %d)."),
1947            exec_file, (unsigned) GetLastError ());
1948
1949   CloseHandle (pi.hThread);
1950   CloseHandle (pi.hProcess);
1951
1952   if (useshell && shell[0] != '\0')
1953     saw_create = -1;
1954   else
1955     saw_create = 0;
1956
1957   do_initial_windows_stuff (ops, pi.dwProcessId, 0);
1958
1959   /* windows_continue (DBG_CONTINUE, -1); */
1960 }
1961
1962 static void
1963 windows_mourn_inferior (struct target_ops *ops)
1964 {
1965   (void) windows_continue (DBG_CONTINUE, -1);
1966   i386_cleanup_dregs();
1967   if (open_process_used)
1968     {
1969       CHECK (CloseHandle (current_process_handle));
1970       open_process_used = 0;
1971     }
1972   unpush_target (ops);
1973   generic_mourn_inferior ();
1974 }
1975
1976 /* Send a SIGINT to the process group.  This acts just like the user typed a
1977    ^C on the controlling terminal. */
1978
1979 static void
1980 windows_stop (ptid_t ptid)
1981 {
1982   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1983   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1984   registers_changed ();         /* refresh register state */
1985 }
1986
1987 static int
1988 windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1989                    int write, struct mem_attrib *mem,
1990                    struct target_ops *target)
1991 {
1992   SIZE_T done = 0;
1993   if (write)
1994     {
1995       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1996                   len, (DWORD) (uintptr_t) memaddr));
1997       if (!WriteProcessMemory (current_process_handle,
1998                                (LPVOID) (uintptr_t) memaddr, our,
1999                                len, &done))
2000         done = 0;
2001       FlushInstructionCache (current_process_handle,
2002                              (LPCVOID) (uintptr_t) memaddr, len);
2003     }
2004   else
2005     {
2006       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2007                   len, (DWORD) (uintptr_t) memaddr));
2008       if (!ReadProcessMemory (current_process_handle,
2009                               (LPCVOID) (uintptr_t) memaddr, our,
2010                               len, &done))
2011         done = 0;
2012     }
2013   return done;
2014 }
2015
2016 static void
2017 windows_kill_inferior (struct target_ops *ops)
2018 {
2019   CHECK (TerminateProcess (current_process_handle, 0));
2020
2021   for (;;)
2022     {
2023       if (!windows_continue (DBG_CONTINUE, -1))
2024         break;
2025       if (!WaitForDebugEvent (&current_event, INFINITE))
2026         break;
2027       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2028         break;
2029     }
2030
2031   target_mourn_inferior ();     /* or just windows_mourn_inferior? */
2032 }
2033
2034 static void
2035 windows_prepare_to_store (struct regcache *regcache)
2036 {
2037   /* Do nothing, since we can store individual regs */
2038 }
2039
2040 static int
2041 windows_can_run (void)
2042 {
2043   return 1;
2044 }
2045
2046 static void
2047 windows_close (int x)
2048 {
2049   DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2050                 PIDGET (inferior_ptid)));
2051 }
2052
2053 /* Convert pid to printable format. */
2054 static char *
2055 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2056 {
2057   static char buf[80];
2058
2059   if (ptid_get_tid (ptid) != 0)
2060     {
2061       snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2062                 ptid_get_pid (ptid), ptid_get_tid (ptid));
2063       return buf;
2064     }
2065
2066   return normal_pid_to_str (ptid);
2067 }
2068
2069 static LONGEST
2070 windows_xfer_shared_libraries (struct target_ops *ops,
2071                              enum target_object object, const char *annex,
2072                              gdb_byte *readbuf, const gdb_byte *writebuf,
2073                              ULONGEST offset, LONGEST len)
2074 {
2075   struct obstack obstack;
2076   const char *buf;
2077   LONGEST len_avail;
2078   struct so_list *so;
2079
2080   if (writebuf)
2081     return -1;
2082
2083   obstack_init (&obstack);
2084   obstack_grow_str (&obstack, "<library-list>\n");
2085   for (so = solib_start.next; so; so = so->next)
2086     windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
2087                                  &obstack);
2088   obstack_grow_str0 (&obstack, "</library-list>\n");
2089
2090   buf = obstack_finish (&obstack);
2091   len_avail = strlen (buf);
2092   if (offset >= len_avail)
2093     return 0;
2094
2095   if (len > len_avail - offset)
2096     len = len_avail - offset;
2097   memcpy (readbuf, buf + offset, len);
2098
2099   obstack_free (&obstack, NULL);
2100   return len;
2101 }
2102
2103 static LONGEST
2104 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2105                     const char *annex, gdb_byte *readbuf,
2106                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2107 {
2108   switch (object)
2109     {
2110     case TARGET_OBJECT_MEMORY:
2111       if (readbuf)
2112         return (*ops->deprecated_xfer_memory) (offset, readbuf,
2113                                                len, 0/*read*/, NULL, ops);
2114       if (writebuf)
2115         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2116                                                len, 1/*write*/, NULL, ops);
2117       return -1;
2118
2119     case TARGET_OBJECT_LIBRARIES:
2120       return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2121                                           writebuf, offset, len);
2122
2123     default:
2124       if (ops->beneath != NULL)
2125         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2126                                               readbuf, writebuf, offset, len);
2127       return -1;
2128     }
2129 }
2130
2131 static void
2132 init_windows_ops (void)
2133 {
2134   windows_ops.to_shortname = "child";
2135   windows_ops.to_longname = "Win32 child process";
2136   windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2137   windows_ops.to_open = windows_open;
2138   windows_ops.to_close = windows_close;
2139   windows_ops.to_attach = windows_attach;
2140   windows_ops.to_attach_no_wait = 1;
2141   windows_ops.to_detach = windows_detach;
2142   windows_ops.to_resume = windows_resume;
2143   windows_ops.to_wait = windows_wait;
2144   windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2145   windows_ops.to_store_registers = windows_store_inferior_registers;
2146   windows_ops.to_prepare_to_store = windows_prepare_to_store;
2147   windows_ops.deprecated_xfer_memory = windows_xfer_memory;
2148   windows_ops.to_xfer_partial = windows_xfer_partial;
2149   windows_ops.to_files_info = windows_files_info;
2150   windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2151   windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2152   windows_ops.to_terminal_init = terminal_init_inferior;
2153   windows_ops.to_terminal_inferior = terminal_inferior;
2154   windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2155   windows_ops.to_terminal_ours = terminal_ours;
2156   windows_ops.to_terminal_save_ours = terminal_save_ours;
2157   windows_ops.to_terminal_info = child_terminal_info;
2158   windows_ops.to_kill = windows_kill_inferior;
2159   windows_ops.to_create_inferior = windows_create_inferior;
2160   windows_ops.to_mourn_inferior = windows_mourn_inferior;
2161   windows_ops.to_can_run = windows_can_run;
2162   windows_ops.to_thread_alive = windows_thread_alive;
2163   windows_ops.to_pid_to_str = windows_pid_to_str;
2164   windows_ops.to_stop = windows_stop;
2165   windows_ops.to_stratum = process_stratum;
2166   windows_ops.to_has_all_memory = 1;
2167   windows_ops.to_has_memory = 1;
2168   windows_ops.to_has_stack = 1;
2169   windows_ops.to_has_registers = 1;
2170   windows_ops.to_has_execution = 1;
2171   windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2172   i386_use_watchpoints (&windows_ops);
2173
2174   windows_ops.to_magic = OPS_MAGIC;
2175 }
2176
2177 static void
2178 set_windows_aliases (char *argv0)
2179 {
2180   add_info_alias ("dll", "sharedlibrary", 1);
2181 }
2182
2183 void
2184 _initialize_windows_nat (void)
2185 {
2186   struct cmd_list_element *c;
2187
2188   init_windows_ops ();
2189
2190   c = add_com ("dll-symbols", class_files, dll_symbol_command,
2191                _("Load dll library symbols from FILE."));
2192   set_cmd_completer (c, filename_completer);
2193
2194   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2195
2196 #ifdef __CYGWIN__
2197   add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2198 Set use of shell to start subprocess."), _("\
2199 Show use of shell to start subprocess."), NULL,
2200                            NULL,
2201                            NULL, /* FIXME: i18n: */
2202                            &setlist, &showlist);
2203
2204   add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2205 Break when an exception is detected in the Cygwin DLL itself."), _("\
2206 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2207                            NULL,
2208                            NULL, /* FIXME: i18n: */
2209                            &setlist, &showlist);
2210 #endif
2211
2212   add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2213 Set creation of new console when creating child process."), _("\
2214 Show creation of new console when creating child process."), NULL,
2215                            NULL,
2216                            NULL, /* FIXME: i18n: */
2217                            &setlist, &showlist);
2218
2219   add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2220 Set creation of new group when creating child process."), _("\
2221 Show creation of new group when creating child process."), NULL,
2222                            NULL,
2223                            NULL, /* FIXME: i18n: */
2224                            &setlist, &showlist);
2225
2226   add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2227 Set whether to display execution in child process."), _("\
2228 Show whether to display execution in child process."), NULL,
2229                            NULL,
2230                            NULL, /* FIXME: i18n: */
2231                            &setlist, &showlist);
2232
2233   add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2234 Set whether to display kernel events in child process."), _("\
2235 Show whether to display kernel events in child process."), NULL,
2236                            NULL,
2237                            NULL, /* FIXME: i18n: */
2238                            &setlist, &showlist);
2239
2240   add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2241 Set whether to display memory accesses in child process."), _("\
2242 Show whether to display memory accesses in child process."), NULL,
2243                            NULL,
2244                            NULL, /* FIXME: i18n: */
2245                            &setlist, &showlist);
2246
2247   add_setshow_boolean_cmd ("debugexceptions", class_support,
2248                            &debug_exceptions, _("\
2249 Set whether to display kernel exceptions in child process."), _("\
2250 Show whether to display kernel exceptions in child process."), NULL,
2251                            NULL,
2252                            NULL, /* FIXME: i18n: */
2253                            &setlist, &showlist);
2254
2255   add_prefix_cmd ("w32", class_info, info_w32_command,
2256                   _("Print information specific to Win32 debugging."),
2257                   &info_w32_cmdlist, "info w32 ", 0, &infolist);
2258
2259   add_cmd ("selector", class_info, display_selectors,
2260            _("Display selectors infos."),
2261            &info_w32_cmdlist);
2262   add_target (&windows_ops);
2263   deprecated_init_ui_hook = set_windows_aliases;
2264 }
2265
2266 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
2267
2268 /* Pass the address ADDR to the inferior in the I'th debug register.
2269    Here we just store the address in dr array, the registers will be
2270    actually set up when windows_continue is called.  */
2271 void
2272 cygwin_set_dr (int i, CORE_ADDR addr)
2273 {
2274   if (i < 0 || i > 3)
2275     internal_error (__FILE__, __LINE__,
2276                     _("Invalid register %d in cygwin_set_dr.\n"), i);
2277   dr[i] = addr;
2278   debug_registers_changed = 1;
2279   debug_registers_used = 1;
2280 }
2281
2282 /* Pass the value VAL to the inferior in the DR7 debug control
2283    register.  Here we just store the address in D_REGS, the watchpoint
2284    will be actually set up in windows_wait.  */
2285 void
2286 cygwin_set_dr7 (unsigned val)
2287 {
2288   dr[7] = val;
2289   debug_registers_changed = 1;
2290   debug_registers_used = 1;
2291 }
2292
2293 /* Get the value of the DR6 debug status register from the inferior.
2294    Here we just return the value stored in dr[6]
2295    by the last call to thread_rec for current_event.dwThreadId id.  */
2296 unsigned
2297 cygwin_get_dr6 (void)
2298 {
2299   return dr[6];
2300 }
2301
2302 /* Determine if the thread referenced by "ptid" is alive
2303    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
2304    it means that the thread has died.  Otherwise it is assumed to be alive. */
2305 static int
2306 windows_thread_alive (struct target_ops *ops, ptid_t ptid)
2307 {
2308   int tid;
2309
2310   gdb_assert (ptid_get_tid (ptid) != 0);
2311   tid = ptid_get_tid (ptid);
2312
2313   return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2314     FALSE : TRUE;
2315 }
2316
2317 void
2318 _initialize_check_for_gdb_ini (void)
2319 {
2320   char *homedir;
2321   if (inhibit_gdbinit)
2322     return;
2323
2324   homedir = getenv ("HOME");
2325   if (homedir)
2326     {
2327       char *p;
2328       char *oldini = (char *) alloca (strlen (homedir) +
2329                                       sizeof ("/gdb.ini"));
2330       strcpy (oldini, homedir);
2331       p = strchr (oldini, '\0');
2332       if (p > oldini && p[-1] != '/')
2333         *p++ = '/';
2334       strcpy (p, "gdb.ini");
2335       if (access (oldini, 0) == 0)
2336         {
2337           int len = strlen (oldini);
2338           char *newini = alloca (len + 1);
2339           sprintf (newini, "%.*s.gdbinit",
2340             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2341           warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2342         }
2343     }
2344 }
2345
2346 void
2347 _initialize_psapi (void)
2348 {
2349   /* Load optional functions used for retrieving filename information
2350      associated with the currently debugged process or its dlls. */
2351   if (!psapi_loaded)
2352     {
2353       HMODULE psapi_module_handle;
2354
2355       psapi_loaded = -1;
2356
2357       psapi_module_handle = LoadLibrary ("psapi.dll");
2358       if (psapi_module_handle)
2359         {
2360           psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2361           psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2362           psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2363
2364           if (psapi_EnumProcessModules != NULL
2365               && psapi_GetModuleInformation != NULL
2366               && psapi_GetModuleFileNameExA != NULL)
2367             psapi_loaded = 1;
2368         }
2369     }
2370
2371   /* This will probably fail on Windows 9x/Me.  Let the user know that we're
2372      missing some functionality. */
2373   if (psapi_loaded < 0)
2374     warning(_("cannot automatically find executable file or library to read symbols.  Use \"file\" or \"dll\" command to load executable/libraries directly."));
2375 }