gdb/windows-nat.c

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