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