gdb/win32-nat.c

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