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