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