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