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 (DWORD 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 || (DWORD) (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   DWORD 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, DWORD 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 ((DWORD) 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, (DWORD) 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                  (DWORD) 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   DWORD lpBaseOfDll = (DWORD) 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 = GetProcAddress (kernel32,
1604                                                  "DebugSetProcessKillOnExit");
1605       if (!kernel32_DebugActiveProcessStop)
1606         kernel32_DebugActiveProcessStop = GetProcAddress (kernel32,
1607                                                  "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 = GetProcAddress (advapi32, "OpenProcessToken");
1645       if (!LookupPrivilegeValue)
1646         LookupPrivilegeValue = GetProcAddress (advapi32,
1647                                                "LookupPrivilegeValueA");
1648       if (!AdjustTokenPrivileges)
1649         AdjustTokenPrivileges = GetProcAddress (advapi32,
1650                                                 "AdjustTokenPrivileges");
1651       if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1652         {
1653           advapi32 = NULL;
1654           goto out;
1655         }
1656     }
1657
1658   if (!OpenProcessToken (GetCurrentProcess (),
1659                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1660                          &token_hdl))
1661     goto out;
1662
1663   if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1664     goto out;
1665
1666   new_priv.PrivilegeCount = 1;
1667   new_priv.Privileges[0].Luid = restore_priv;
1668   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1669
1670   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1671                               sizeof orig_priv, &orig_priv, &size))
1672     goto out;
1673 #if 0
1674   /* Disabled, otherwise every `attach' in an unprivileged user session
1675      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1676      win32_attach(). */
1677   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1678      be enabled. GetLastError () returns an correct error code, though. */
1679   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1680     goto out;
1681 #endif
1682
1683   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1684
1685 out:
1686   if (token_hdl)
1687     CloseHandle (token_hdl);
1688
1689   return ret;
1690 }
1691
1692 /* Attach to process PID, then initialize for debugging it.  */
1693 static void
1694 win32_attach (struct target_ops *ops, char *args, int from_tty)
1695 {
1696   BOOL ok;
1697   DWORD pid;
1698
1699   if (!args)
1700     error_no_arg (_("process-id to attach"));
1701
1702   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1703     {
1704       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1705       printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1706     }
1707
1708   pid = strtoul (args, 0, 0);           /* Windows pid */
1709
1710   win32_init_thread_list ();
1711   ok = DebugActiveProcess (pid);
1712   saw_create = 0;
1713
1714 #ifdef __CYGWIN__
1715   if (!ok)
1716     {
1717       /* Try fall back to Cygwin pid */
1718       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1719
1720       if (pid > 0)
1721         ok = DebugActiveProcess (pid);
1722   }
1723 #endif
1724
1725   if (!ok)
1726     error (_("Can't attach to process."));
1727
1728   if (has_detach_ability ())
1729     kernel32_DebugSetProcessKillOnExit (FALSE);
1730
1731   if (from_tty)
1732     {
1733       char *exec_file = (char *) get_exec_file (0);
1734
1735       if (exec_file)
1736         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1737                            target_pid_to_str (pid_to_ptid (pid)));
1738       else
1739         printf_unfiltered ("Attaching to %s\n",
1740                            target_pid_to_str (pid_to_ptid (pid)));
1741
1742       gdb_flush (gdb_stdout);
1743     }
1744
1745   do_initial_win32_stuff (ops, pid, 1);
1746   target_terminal_ours ();
1747 }
1748
1749 static void
1750 win32_detach (struct target_ops *ops, char *args, int from_tty)
1751 {
1752   int detached = 1;
1753
1754   if (has_detach_ability ())
1755     {
1756       ptid_t ptid = {-1};
1757       win32_resume (ptid, 0, TARGET_SIGNAL_0);
1758
1759       if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId))
1760         {
1761           error (_("Can't detach process %lu (error %lu)"),
1762                  current_event.dwProcessId, GetLastError ());
1763           detached = 0;
1764         }
1765       kernel32_DebugSetProcessKillOnExit (FALSE);
1766     }
1767   if (detached && from_tty)
1768     {
1769       char *exec_file = get_exec_file (0);
1770       if (exec_file == 0)
1771         exec_file = "";
1772       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1773                          current_event.dwProcessId);
1774       gdb_flush (gdb_stdout);
1775     }
1776
1777   inferior_ptid = null_ptid;
1778   detach_inferior (current_event.dwProcessId);
1779
1780   unpush_target (ops);
1781 }
1782
1783 static char *
1784 win32_pid_to_exec_file (int pid)
1785 {
1786   static char path[MAX_PATH + 1];
1787
1788 #ifdef __CYGWIN__
1789   /* Try to find exe name as symlink target of /proc/<pid>/exe */
1790   int nchars;
1791   char procexe[sizeof ("/proc/4294967295/exe")];
1792   sprintf (procexe, "/proc/%u/exe", pid);
1793   nchars = readlink (procexe, path, sizeof(path));
1794   if (nchars > 0 && nchars < sizeof (path))
1795     {
1796       path[nchars] = '\0';      /* Got it */
1797       return path;
1798     }
1799 #endif
1800
1801   /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1802      of gdb, or we're trying to debug a non-Cygwin windows executable. */
1803   if (!get_module_name (0, path))
1804     path[0] = '\0';
1805
1806   return path;
1807 }
1808
1809 /* Print status information about what we're accessing.  */
1810
1811 static void
1812 win32_files_info (struct target_ops *ignore)
1813 {
1814   struct inferior *inf = current_inferior ();
1815
1816   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1817                      inf->attach_flag ? "attached" : "child",
1818                      target_pid_to_str (inferior_ptid));
1819 }
1820
1821 static void
1822 win32_open (char *arg, int from_tty)
1823 {
1824   error (_("Use the \"run\" command to start a Unix child process."));
1825 }
1826
1827 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1828    EXEC_FILE is the file to run.
1829    ALLARGS is a string containing the arguments to the program.
1830    ENV is the environment vector to pass.  Errors reported with error().  */
1831
1832 static void
1833 win32_create_inferior (struct target_ops *ops, char *exec_file,
1834                        char *allargs, char **in_env, int from_tty)
1835 {
1836   STARTUPINFO si;
1837   PROCESS_INFORMATION pi;
1838   BOOL ret;
1839   DWORD flags;
1840   char *args;
1841   char real_path[MAXPATHLEN];
1842   char *toexec;
1843   char shell[MAX_PATH + 1]; /* Path to shell */
1844   const char *sh;
1845   int tty;
1846   int ostdin, ostdout, ostderr;
1847   const char *inferior_io_terminal = get_inferior_io_terminal ();
1848
1849   if (!exec_file)
1850     error (_("No executable specified, use `target exec'."));
1851
1852   memset (&si, 0, sizeof (si));
1853   si.cb = sizeof (si);
1854
1855 #ifdef __CYGWIN__
1856   if (!useshell)
1857     {
1858       flags = DEBUG_ONLY_THIS_PROCESS;
1859       cygwin_conv_to_win32_path (exec_file, real_path);
1860       toexec = real_path;
1861     }
1862   else
1863     {
1864       char *newallargs;
1865       sh = getenv ("SHELL");
1866       if (!sh)
1867         sh = "/bin/sh";
1868       cygwin_conv_to_win32_path (sh, shell);
1869       newallargs = alloca (sizeof (" -c 'exec  '") + strlen (exec_file)
1870                            + strlen (allargs) + 2);
1871       sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1872       allargs = newallargs;
1873       toexec = shell;
1874       flags = DEBUG_PROCESS;
1875     }
1876 #else
1877   toexec = exec_file;
1878   flags = DEBUG_ONLY_THIS_PROCESS;
1879 #endif
1880
1881   if (new_group)
1882     flags |= CREATE_NEW_PROCESS_GROUP;
1883
1884   if (new_console)
1885     flags |= CREATE_NEW_CONSOLE;
1886
1887   args = alloca (strlen (toexec) + strlen (allargs) + 2);
1888   strcpy (args, toexec);
1889   strcat (args, " ");
1890   strcat (args, allargs);
1891
1892 #ifdef __CYGWIN__
1893   /* Prepare the environment vars for CreateProcess.  */
1894   cygwin_internal (CW_SYNC_WINENV);
1895
1896   if (!inferior_io_terminal)
1897     tty = ostdin = ostdout = ostderr = -1;
1898   else
1899     {
1900       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1901       if (tty < 0)
1902         {
1903           print_sys_errmsg (inferior_io_terminal, errno);
1904           ostdin = ostdout = ostderr = -1;
1905         }
1906       else
1907         {
1908           ostdin = dup (0);
1909           ostdout = dup (1);
1910           ostderr = dup (2);
1911           dup2 (tty, 0);
1912           dup2 (tty, 1);
1913           dup2 (tty, 2);
1914         }
1915     }
1916 #endif
1917
1918   win32_init_thread_list ();
1919   ret = CreateProcess (0,
1920                        args,    /* command line */
1921                        NULL,    /* Security */
1922                        NULL,    /* thread */
1923                        TRUE,    /* inherit handles */
1924                        flags,   /* start flags */
1925                        NULL,    /* environment */
1926                        NULL,    /* current directory */
1927                        &si,
1928                        &pi);
1929
1930 #ifdef __CYGWIN__
1931   if (tty >= 0)
1932     {
1933       close (tty);
1934       dup2 (ostdin, 0);
1935       dup2 (ostdout, 1);
1936       dup2 (ostderr, 2);
1937       close (ostdin);
1938       close (ostdout);
1939       close (ostderr);
1940     }
1941 #endif
1942
1943   if (!ret)
1944     error (_("Error creating process %s, (error %d)."),
1945            exec_file, (unsigned) GetLastError ());
1946
1947   CloseHandle (pi.hThread);
1948   CloseHandle (pi.hProcess);
1949
1950   if (useshell && shell[0] != '\0')
1951     saw_create = -1;
1952   else
1953     saw_create = 0;
1954
1955   do_initial_win32_stuff (ops, pi.dwProcessId, 0);
1956
1957   /* win32_continue (DBG_CONTINUE, -1); */
1958 }
1959
1960 static void
1961 win32_mourn_inferior (struct target_ops *ops)
1962 {
1963   (void) win32_continue (DBG_CONTINUE, -1);
1964   i386_cleanup_dregs();
1965   if (open_process_used)
1966     {
1967       CHECK (CloseHandle (current_process_handle));
1968       open_process_used = 0;
1969     }
1970   unpush_target (ops);
1971   generic_mourn_inferior ();
1972 }
1973
1974 /* Send a SIGINT to the process group.  This acts just like the user typed a
1975    ^C on the controlling terminal. */
1976
1977 static void
1978 win32_stop (ptid_t ptid)
1979 {
1980   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1981   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1982   registers_changed ();         /* refresh register state */
1983 }
1984
1985 static int
1986 win32_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1987                    int write, struct mem_attrib *mem,
1988                    struct target_ops *target)
1989 {
1990   SIZE_T done = 0;
1991   if (write)
1992     {
1993       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1994                   len, (DWORD) (uintptr_t) memaddr));
1995       if (!WriteProcessMemory (current_process_handle,
1996                                (LPVOID) (uintptr_t) memaddr, our,
1997                                len, &done))
1998         done = 0;
1999       FlushInstructionCache (current_process_handle,
2000                              (LPCVOID) (uintptr_t) memaddr, len);
2001     }
2002   else
2003     {
2004       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
2005                   len, (DWORD) (uintptr_t) memaddr));
2006       if (!ReadProcessMemory (current_process_handle,
2007                               (LPCVOID) (uintptr_t) memaddr, our,
2008                               len, &done))
2009         done = 0;
2010     }
2011   return done;
2012 }
2013
2014 static void
2015 win32_kill_inferior (void)
2016 {
2017   CHECK (TerminateProcess (current_process_handle, 0));
2018
2019   for (;;)
2020     {
2021       if (!win32_continue (DBG_CONTINUE, -1))
2022         break;
2023       if (!WaitForDebugEvent (&current_event, INFINITE))
2024         break;
2025       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
2026         break;
2027     }
2028
2029   target_mourn_inferior ();     /* or just win32_mourn_inferior? */
2030 }
2031
2032 static void
2033 win32_prepare_to_store (struct regcache *regcache)
2034 {
2035   /* Do nothing, since we can store individual regs */
2036 }
2037
2038 static int
2039 win32_can_run (void)
2040 {
2041   return 1;
2042 }
2043
2044 static void
2045 win32_close (int x)
2046 {
2047   DEBUG_EVENTS (("gdb: win32_close, inferior_ptid=%d\n",
2048                 PIDGET (inferior_ptid)));
2049 }
2050
2051 /* Convert pid to printable format. */
2052 static char *
2053 win32_pid_to_str (ptid_t ptid)
2054 {
2055   static char buf[80];
2056
2057   if (ptid_get_tid (ptid) != 0)
2058     {
2059       snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2060                 ptid_get_pid (ptid), ptid_get_tid (ptid));
2061       return buf;
2062     }
2063
2064   return normal_pid_to_str (ptid);
2065 }
2066
2067 static LONGEST
2068 win32_xfer_shared_libraries (struct target_ops *ops,
2069                              enum target_object object, const char *annex,
2070                              gdb_byte *readbuf, const gdb_byte *writebuf,
2071                              ULONGEST offset, LONGEST len)
2072 {
2073   struct obstack obstack;
2074   const char *buf;
2075   LONGEST len_avail;
2076   struct so_list *so;
2077
2078   if (writebuf)
2079     return -1;
2080
2081   obstack_init (&obstack);
2082   obstack_grow_str (&obstack, "<library-list>\n");
2083   for (so = solib_start.next; so; so = so->next)
2084     win32_xfer_shared_library (so->so_name, so->lm_info->load_addr, &obstack);
2085   obstack_grow_str0 (&obstack, "</library-list>\n");
2086
2087   buf = obstack_finish (&obstack);
2088   len_avail = strlen (buf);
2089   if (offset >= len_avail)
2090     return 0;
2091
2092   if (len > len_avail - offset)
2093     len = len_avail - offset;
2094   memcpy (readbuf, buf + offset, len);
2095
2096   obstack_free (&obstack, NULL);
2097   return len;
2098 }
2099
2100 static LONGEST
2101 win32_xfer_partial (struct target_ops *ops, enum target_object object,
2102                     const char *annex, gdb_byte *readbuf,
2103                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2104 {
2105   switch (object)
2106     {
2107     case TARGET_OBJECT_MEMORY:
2108       if (readbuf)
2109         return (*ops->deprecated_xfer_memory) (offset, readbuf,
2110                                                len, 0/*read*/, NULL, ops);
2111       if (writebuf)
2112         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2113                                                len, 1/*write*/, NULL, ops);
2114       return -1;
2115
2116     case TARGET_OBJECT_LIBRARIES:
2117       return win32_xfer_shared_libraries (ops, object, annex, readbuf,
2118                                           writebuf, offset, len);
2119
2120     default:
2121       if (ops->beneath != NULL)
2122         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2123                                               readbuf, writebuf, offset, len);
2124       return -1;
2125     }
2126 }
2127
2128 static void
2129 init_win32_ops (void)
2130 {
2131   win32_ops.to_shortname = "child";
2132   win32_ops.to_longname = "Win32 child process";
2133   win32_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2134   win32_ops.to_open = win32_open;
2135   win32_ops.to_close = win32_close;
2136   win32_ops.to_attach = win32_attach;
2137   win32_ops.to_attach_no_wait = 1;
2138   win32_ops.to_detach = win32_detach;
2139   win32_ops.to_resume = win32_resume;
2140   win32_ops.to_wait = win32_wait;
2141   win32_ops.to_fetch_registers = win32_fetch_inferior_registers;
2142   win32_ops.to_store_registers = win32_store_inferior_registers;
2143   win32_ops.to_prepare_to_store = win32_prepare_to_store;
2144   win32_ops.deprecated_xfer_memory = win32_xfer_memory;
2145   win32_ops.to_xfer_partial = win32_xfer_partial;
2146   win32_ops.to_files_info = win32_files_info;
2147   win32_ops.to_insert_breakpoint = memory_insert_breakpoint;
2148   win32_ops.to_remove_breakpoint = memory_remove_breakpoint;
2149   win32_ops.to_terminal_init = terminal_init_inferior;
2150   win32_ops.to_terminal_inferior = terminal_inferior;
2151   win32_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2152   win32_ops.to_terminal_ours = terminal_ours;
2153   win32_ops.to_terminal_save_ours = terminal_save_ours;
2154   win32_ops.to_terminal_info = child_terminal_info;
2155   win32_ops.to_kill = win32_kill_inferior;
2156   win32_ops.to_create_inferior = win32_create_inferior;
2157   win32_ops.to_mourn_inferior = win32_mourn_inferior;
2158   win32_ops.to_can_run = win32_can_run;
2159   win32_ops.to_thread_alive = win32_win32_thread_alive;
2160   win32_ops.to_pid_to_str = win32_pid_to_str;
2161   win32_ops.to_stop = win32_stop;
2162   win32_ops.to_stratum = process_stratum;
2163   win32_ops.to_has_all_memory = 1;
2164   win32_ops.to_has_memory = 1;
2165   win32_ops.to_has_stack = 1;
2166   win32_ops.to_has_registers = 1;
2167   win32_ops.to_has_execution = 1;
2168   win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
2169   win32_ops.to_magic = OPS_MAGIC;
2170 }
2171
2172 static void
2173 set_win32_aliases (char *argv0)
2174 {
2175   add_info_alias ("dll", "sharedlibrary", 1);
2176 }
2177
2178 void
2179 _initialize_win32_nat (void)
2180 {
2181   struct cmd_list_element *c;
2182
2183   init_win32_ops ();
2184
2185   c = add_com ("dll-symbols", class_files, dll_symbol_command,
2186                _("Load dll library symbols from FILE."));
2187   set_cmd_completer (c, filename_completer);
2188
2189   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2190
2191 #ifdef __CYGWIN__
2192   add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2193 Set use of shell to start subprocess."), _("\
2194 Show use of shell to start subprocess."), NULL,
2195                            NULL,
2196                            NULL, /* FIXME: i18n: */
2197                            &setlist, &showlist);
2198
2199   add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2200 Break when an exception is detected in the Cygwin DLL itself."), _("\
2201 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2202                            NULL,
2203                            NULL, /* FIXME: i18n: */
2204                            &setlist, &showlist);
2205 #endif
2206
2207   add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2208 Set creation of new console when creating child process."), _("\
2209 Show creation of new console when creating child process."), NULL,
2210                            NULL,
2211                            NULL, /* FIXME: i18n: */
2212                            &setlist, &showlist);
2213
2214   add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2215 Set creation of new group when creating child process."), _("\
2216 Show creation of new group when creating child process."), NULL,
2217                            NULL,
2218                            NULL, /* FIXME: i18n: */
2219                            &setlist, &showlist);
2220
2221   add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2222 Set whether to display execution in child process."), _("\
2223 Show whether to display execution in child process."), NULL,
2224                            NULL,
2225                            NULL, /* FIXME: i18n: */
2226                            &setlist, &showlist);
2227
2228   add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2229 Set whether to display kernel events in child process."), _("\
2230 Show whether to display kernel events in child process."), NULL,
2231                            NULL,
2232                            NULL, /* FIXME: i18n: */
2233                            &setlist, &showlist);
2234
2235   add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2236 Set whether to display memory accesses in child process."), _("\
2237 Show whether to display memory accesses in child process."), NULL,
2238                            NULL,
2239                            NULL, /* FIXME: i18n: */
2240                            &setlist, &showlist);
2241
2242   add_setshow_boolean_cmd ("debugexceptions", class_support,
2243                            &debug_exceptions, _("\
2244 Set whether to display kernel exceptions in child process."), _("\
2245 Show whether to display kernel exceptions in child process."), NULL,
2246                            NULL,
2247                            NULL, /* FIXME: i18n: */
2248                            &setlist, &showlist);
2249
2250   add_prefix_cmd ("w32", class_info, info_w32_command,
2251                   _("Print information specific to Win32 debugging."),
2252                   &info_w32_cmdlist, "info w32 ", 0, &infolist);
2253
2254   add_cmd ("selector", class_info, display_selectors,
2255            _("Display selectors infos."),
2256            &info_w32_cmdlist);
2257   add_target (&win32_ops);
2258   deprecated_init_ui_hook = set_win32_aliases;
2259 }
2260
2261 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
2262
2263 /* Pass the address ADDR to the inferior in the I'th debug register.
2264    Here we just store the address in dr array, the registers will be
2265    actually set up when win32_continue is called.  */
2266 void
2267 cygwin_set_dr (int i, CORE_ADDR addr)
2268 {
2269   if (i < 0 || i > 3)
2270     internal_error (__FILE__, __LINE__,
2271                     _("Invalid register %d in cygwin_set_dr.\n"), i);
2272   dr[i] = (unsigned) addr;
2273   debug_registers_changed = 1;
2274   debug_registers_used = 1;
2275 }
2276
2277 /* Pass the value VAL to the inferior in the DR7 debug control
2278    register.  Here we just store the address in D_REGS, the watchpoint
2279    will be actually set up in win32_wait.  */
2280 void
2281 cygwin_set_dr7 (unsigned val)
2282 {
2283   dr[7] = val;
2284   debug_registers_changed = 1;
2285   debug_registers_used = 1;
2286 }
2287
2288 /* Get the value of the DR6 debug status register from the inferior.
2289    Here we just return the value stored in dr[6]
2290    by the last call to thread_rec for current_event.dwThreadId id.  */
2291 unsigned
2292 cygwin_get_dr6 (void)
2293 {
2294   return dr[6];
2295 }
2296
2297 /* Determine if the thread referenced by "ptid" is alive
2298    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
2299    it means that the thread has died.  Otherwise it is assumed to be alive. */
2300 static int
2301 win32_win32_thread_alive (ptid_t ptid)
2302 {
2303   int tid;
2304
2305   gdb_assert (ptid_get_tid (ptid) != 0);
2306   tid = ptid_get_tid (ptid);
2307
2308   return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2309     FALSE : TRUE;
2310 }
2311
2312 void
2313 _initialize_check_for_gdb_ini (void)
2314 {
2315   char *homedir;
2316   if (inhibit_gdbinit)
2317     return;
2318
2319   homedir = getenv ("HOME");
2320   if (homedir)
2321     {
2322       char *p;
2323       char *oldini = (char *) alloca (strlen (homedir) +
2324                                       sizeof ("/gdb.ini"));
2325       strcpy (oldini, homedir);
2326       p = strchr (oldini, '\0');
2327       if (p > oldini && p[-1] != '/')
2328         *p++ = '/';
2329       strcpy (p, "gdb.ini");
2330       if (access (oldini, 0) == 0)
2331         {
2332           int len = strlen (oldini);
2333           char *newini = alloca (len + 1);
2334           sprintf (newini, "%.*s.gdbinit",
2335             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2336           warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2337         }
2338     }
2339 }
2340
2341 void
2342 _initialize_psapi (void)
2343 {
2344   /* Load optional functions used for retrieving filename information
2345      associated with the currently debugged process or its dlls. */
2346   if (!psapi_loaded)
2347     {
2348       HMODULE psapi_module_handle;
2349
2350       psapi_loaded = -1;
2351
2352       psapi_module_handle = LoadLibrary ("psapi.dll");
2353       if (psapi_module_handle)
2354         {
2355           psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2356           psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2357           psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2358
2359           if (psapi_EnumProcessModules != NULL
2360               && psapi_GetModuleInformation != NULL
2361               && psapi_GetModuleFileNameExA != NULL)
2362             psapi_loaded = 1;
2363         }
2364     }
2365
2366   /* This will probably fail on Windows 9x/Me.  Let the user know that we're
2367      missing some functionality. */
2368   if (psapi_loaded < 0)
2369     warning(_("cannot automatically find executable file or library to read symbols.  Use \"file\" or \"dll\" command to load executable/libraries directly."));
2370 }