gdb/windows-nat.c

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