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