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