gdb/windows-nat.c

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