gdb/windows-nat.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Target-vector operations for controlling windows child processes, for GDB.

  3.    Copyright (C) 1995-2015 Free Software Foundation, Inc.

  5.    Contributed by Cygnus Solutions, A Red Hat Company.

  7.    This file is part of GDB.

  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.

  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.

  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/>.  */

  22. /* Originally by Steve Chamberlain, sac@cygnus.com */

  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 "gdbcore.h"
  30. #include "command.h"
  31. #include "completer.h"
  32. #include "regcache.h"
  33. #include "top.h"
  34. #include <signal.h>
  35. #include <sys/types.h>
  36. #include <fcntl.h>
  37. #include <windows.h>
  38. #include <imagehlp.h>
  39. #include <psapi.h>
  40. #ifdef __CYGWIN__
  41. #include <wchar.h>
  42. #include <sys/cygwin.h>
  43. #include <cygwin/version.h>
  44. #endif

  46. #include "buildsym.h"
  47. #include "filenames.h"
  48. #include "symfile.h"
  49. #include "objfiles.h"
  50. #include "gdb_bfd.h"
  51. #include "gdb_obstack.h"
  52. #include "gdbthread.h"
  53. #include "gdbcmd.h"
  54. #include <unistd.h>
  55. #include "exec.h"
  56. #include "solist.h"
  57. #include "solib.h"
  58. #include "xml-support.h"

  60. #include "i386-tdep.h"
  61. #include "i387-tdep.h"

  63. #include "windows-tdep.h"
  64. #include "windows-nat.h"
  65. #include "x86-nat.h"
  66. #include "complaints.h"
  67. #include "inf-child.h"

  69. ‌#define AdjustTokenPrivileges                dyn_AdjustTokenPrivileges
  70. ‌#define DebugActiveProcessStop                dyn_DebugActiveProcessStop
  71. ‌#define DebugBreakProcess                dyn_DebugBreakProcess
  72. ‌#define DebugSetProcessKillOnExit        dyn_DebugSetProcessKillOnExit
  73. ‌#define EnumProcessModules                dyn_EnumProcessModules
  74. ‌#define GetModuleInformation                dyn_GetModuleInformation
  75. ‌#define LookupPrivilegeValueA                dyn_LookupPrivilegeValueA
  76. ‌#define OpenProcessToken                dyn_OpenProcessToken
  77. ‌#define GetConsoleFontSize                dyn_GetConsoleFontSize
  78. ‌#define GetCurrentConsoleFont                dyn_GetCurrentConsoleFont

  80. ‌static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
  81.                                             DWORD, PTOKEN_PRIVILEGES, PDWORD);
  82. ‌static BOOL WINAPI (*DebugActiveProcessStop) (DWORD);
  83. ‌static BOOL WINAPI (*DebugBreakProcess) (HANDLE);
  84. ‌static BOOL WINAPI (*DebugSetProcessKillOnExit) (BOOL);
  85. ‌static BOOL WINAPI (*EnumProcessModules) (HANDLE, HMODULE *, DWORD,
  86.                                           LPDWORD);
  87. ‌static BOOL WINAPI (*GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
  88.                                             DWORD);
  89. ‌static BOOL WINAPI (*LookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
  90. ‌static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
  91. ‌static BOOL WINAPI (*GetCurrentConsoleFont) (HANDLE, BOOL,
  92.                                              CONSOLE_FONT_INFO *);
  93. ‌static COORD WINAPI (*GetConsoleFontSize) (HANDLE, DWORD);

  95. ‌#undef STARTUPINFO
  96. ‌#undef CreateProcess
  97. ‌#undef GetModuleFileNameEx

  99. #ifndef __CYGWIN__
  100. ‌# define __PMAX        (MAX_PATH + 1)
  101. ‌  static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE, LPSTR, DWORD);
  102. ‌# define STARTUPINFO STARTUPINFOA
  103. ‌# define CreateProcess CreateProcessA
  104. ‌# define GetModuleFileNameEx_name "GetModuleFileNameExA"
  105. ‌# define bad_GetModuleFileNameEx bad_GetModuleFileNameExA
  106. #else
  107. ‌# define __PMAX        PATH_MAX
  108. /* The starting and ending address of the cygwin1.dll text segment.  */
  109. ‌  static CORE_ADDR cygwin_load_start;
  110. ‌  static CORE_ADDR cygwin_load_end;
  111. ‌#   define __USEWIDE
  112. ‌    typedef wchar_t cygwin_buf_t;
  113. ‌    static DWORD WINAPI (*GetModuleFileNameEx) (HANDLE, HMODULE,
  114.                                                 LPWSTR, DWORD);
  115. ‌#   define STARTUPINFO STARTUPINFOW
  116. ‌#   define CreateProcess CreateProcessW
  117. ‌#   define GetModuleFileNameEx_name "GetModuleFileNameExW"
  118. ‌#   define bad_GetModuleFileNameEx bad_GetModuleFileNameExW
  119. #endif

  121. ‌static int have_saved_context;        /* True if we've saved context from a
  122.                                    cygwin signal.  */
  123. ‌static CONTEXT saved_context;        /* Containes the saved context from a
  124.                                    cygwin signal.  */

  126. /* If we're not using the old Cygwin header file set, define the
  127.    following which never should have been in the generic Win32 API
  128.    headers in the first place since they were our own invention...  */
  129. #ifndef _GNU_H_WINDOWS_H
  130. enum
  131.   {
  132.     FLAG_TRACE_BIT = 0x100,
  133.     CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
  134.   };
  135. #endif

  137. #ifndef CONTEXT_EXTENDED_REGISTERS
  138. /* This macro is only defined on ia32.  It only makes sense on this target,
  139.    so define it as zero if not already defined.  */
  140. ‌#define CONTEXT_EXTENDED_REGISTERS 0
  141. #endif

  143. ‌#define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
  144.         | CONTEXT_EXTENDED_REGISTERS

  146. ‌static uintptr_t dr[8];
  147. ‌static int debug_registers_changed;
  148. ‌static int debug_registers_used;

  150. ‌static int windows_initialization_done;
  151. ‌#define DR6_CLEAR_VALUE 0xffff0ff0

  153. /* The string sent by cygwin when it processes a signal.
  154.    FIXME: This should be in a cygwin include file.  */
  155. #ifndef _CYGWIN_SIGNAL_STRING
  156. ‌#define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
  157. #endif

  159. ‌#define CHECK(x)        check (x, __FILE__,__LINE__)
  160. ‌#define DEBUG_EXEC(x)        if (debug_exec)                printf_unfiltered x
  161. ‌#define DEBUG_EVENTS(x)        if (debug_events)        printf_unfiltered x
  162. ‌#define DEBUG_MEM(x)        if (debug_memory)        printf_unfiltered x
  163. ‌#define DEBUG_EXCEPT(x)        if (debug_exceptions)        printf_unfiltered x

  165. static void windows_stop (struct target_ops *self, ptid_t);
  166. static int windows_thread_alive (struct target_ops *, ptid_t);
  167. static void windows_kill_inferior (struct target_ops *);

  169. static void cygwin_set_dr (int i, CORE_ADDR addr);
  170. static void cygwin_set_dr7 (unsigned long val);
  171. static CORE_ADDR cygwin_get_dr (int i);
  172. static unsigned long cygwin_get_dr6 (void);
  173. static unsigned long cygwin_get_dr7 (void);

  175. ‌static enum gdb_signal last_sig = GDB_SIGNAL_0;
  176. /* Set if a signal was received from the debugged process.  */

  178. /* Thread information structure used to track information that is
  179.    not available in gdb's thread structure.  */
  180. ‌typedef struct thread_info_struct
  181.   {
  182.     struct thread_info_struct *next;
  183.     DWORD id;
  184.     HANDLE h;
  185.     CORE_ADDR thread_local_base;
  186.     char *name;
  187.     int suspended;
  188.     int reload_context;
  189.     CONTEXT context;
  190.     STACKFRAME sf;
  191.   }
  192. ‌thread_info;

  194. ‌static thread_info thread_head;

  196. /* The process and thread handles for the above context.  */

  198. ‌static DEBUG_EVENT current_event;        /* The current debug event from
  199.                                            WaitForDebugEvent */
  200. ‌static HANDLE current_process_handle;        /* Currently executing process */
  201. ‌static thread_info *current_thread;        /* Info on currently selected thread */
  202. ‌static DWORD main_thread_id;                /* Thread ID of the main thread */

  204. /* Counts of things.  */
  205. ‌static int exception_count = 0;
  206. ‌static int event_count = 0;
  207. ‌static int saw_create;
  208. ‌static int open_process_used = 0;

  210. /* User options.  */
  211. ‌static int new_console = 0;
  212. #ifdef __CYGWIN__
  213. ‌static int cygwin_exceptions = 0;
  214. #endif
  215. ‌static int new_group = 1;
  216. ‌static int debug_exec = 0;                /* show execution */
  217. ‌static int debug_events = 0;                /* show events from kernel */
  218. ‌static int debug_memory = 0;                /* show target memory accesses */
  219. ‌static int debug_exceptions = 0;        /* show target exceptions */
  220. ‌static int useshell = 0;                /* use shell for subprocesses */

  222. /* This vector maps GDB's idea of a register's number into an offset
  223.    in the windows exception context vector.

  225.    It also contains the bit mask needed to load the register in question.

  227.    The contents of this table can only be computed by the units
  228.    that provide CPU-specific support for Windows native debugging.
  229.    These units should set the table by calling
  230.    windows_set_context_register_offsets.

  232.    One day we could read a reg, we could inspect the context we
  233.    already have loaded, if it doesn't have the bit set that we need,
  234.    we read that set of registers in using GetThreadContext.  If the
  235.    context already contains what we need, we just unpack it.  Then to
  236.    write a register, first we have to ensure that the context contains
  237.    the other regs of the group, and then we copy the info in and set
  238.    out bit.  */

  240. ‌static const int *mappings;

  242. /* The function to use in order to determine whether a register is
  243.    a segment register or not.  */
  244. ‌static segment_register_p_ftype *segment_register_p;

  246. /* This vector maps the target's idea of an exception (extracted
  247.    from the DEBUG_EVENT structure) to GDB's idea.  */

  249. ‌struct xlate_exception
  250.   {
  251.     int them;
  252.     enum gdb_signal us;
  253.   };

  255. static const struct xlate_exception
  256. ‌  xlate[] =
  257. {
  258.   {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV},
  259.   {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV},
  260.   {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP},
  261.   {DBG_CONTROL_C, GDB_SIGNAL_INT},
  262.   {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP},
  263.   {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE},
  264.   {-1, -1}};

  266. /* Set the MAPPINGS static global to OFFSETS.
  267.    See the description of MAPPINGS for more details.  */

  269. void
  270. ‌windows_set_context_register_offsets (const int *offsets)
  271. {
  272.   mappings = offsets;
  273. }

  275. /* See windows-nat.h.  */

  277. void
  278. ‌windows_set_segment_register_p (segment_register_p_ftype *fun)
  279. {
  280.   segment_register_p = fun;
  281. }

  283. static void
  284. ‌check (BOOL ok, const char *file, int line)
  285. {
  286.   if (!ok)
  287.     printf_filtered ("error return %s:%d was %u\n", file, line,
  288.                      (unsigned) GetLastError ());
  289. }

  291. /* Find a thread record given a thread id.  If GET_CONTEXT is not 0,
  292.    then also retrieve the context for this thread.  If GET_CONTEXT is
  293.    negative, then don't suspend the thread.  */
  294. static thread_info *
  295. ‌thread_rec (DWORD id, int get_context)
  296. {
  297.   thread_info *th;

  299.   for (th = &thread_head; (th = th->next) != NULL;)
  300.     if (th->id == id)
  301.       {
  302.         if (!th->suspended && get_context)
  303.           {
  304.             if (get_context > 0 && id != current_event.dwThreadId)
  305.               {
  306.                 if (SuspendThread (th->h) == (DWORD) -1)
  307.                   {
  308.                     DWORD err = GetLastError ();

  310.                     /* We get Access Denied (5) when trying to suspend
  311.                        threads that Windows started on behalf of the
  312.                        debuggee, usually when those threads are just
  313.                        about to exit.  */
  314.                     if (err != ERROR_ACCESS_DENIED)
  315.                       warning (_("SuspendThread (tid=0x%x) failed."
  316.                                  " (winerr %u)"),
  317.                                (unsigned) id, (unsigned) err);
  318.                     th->suspended = -1;
  319.                   }
  320.                 else
  321.                   th->suspended = 1;
  322.               }
  323.             else if (get_context < 0)
  324.               th->suspended = -1;
  325.             th->reload_context = 1;
  326.           }
  327.         return th;
  328.       }

  330.   return NULL;
  331. }

  333. /* Add a thread to the thread list.  */
  334. static thread_info *
  335. ‌windows_add_thread (ptid_t ptid, HANDLE h, void *tlb)
  336. {
  337.   thread_info *th;
  338.   DWORD id;

  340.   gdb_assert (ptid_get_tid (ptid) != 0);

  342.   id = ptid_get_tid (ptid);

  344.   if ((th = thread_rec (id, FALSE)))
  345.     return th;

  347.   th = XCNEW (thread_info);
  348.   th->id = id;
  349.   th->h = h;
  350.   th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
  351.   th->next = thread_head.next;
  352.   thread_head.next = th;
  353.   add_thread (ptid);
  354.   /* Set the debug registers for the new thread if they are used.  */
  355.   if (debug_registers_used)
  356.     {
  357.       /* Only change the value of the debug registers.  */
  358.       th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
  359.       CHECK (GetThreadContext (th->h, &th->context));
  360.       th->context.Dr0 = dr[0];
  361.       th->context.Dr1 = dr[1];
  362.       th->context.Dr2 = dr[2];
  363.       th->context.Dr3 = dr[3];
  364.       th->context.Dr6 = DR6_CLEAR_VALUE;
  365.       th->context.Dr7 = dr[7];
  366.       CHECK (SetThreadContext (th->h, &th->context));
  367.       th->context.ContextFlags = 0;
  368.     }
  369.   return th;
  370. }

  372. /* Clear out any old thread list and reintialize it to a
  373.    pristine state.  */
  374. static void
  375. ‌windows_init_thread_list (void)
  376. {
  377.   thread_info *th = &thread_head;

  379.   DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
  380.   init_thread_list ();
  381.   while (th->next != NULL)
  382.     {
  383.       thread_info *here = th->next;
  384.       th->next = here->next;
  385.       xfree (here);
  386.     }
  387.   thread_head.next = NULL;
  388. }

  390. /* Delete a thread from the list of threads.  */
  391. static void
  392. ‌windows_delete_thread (ptid_t ptid, DWORD exit_code)
  393. {
  394.   thread_info *th;
  395.   DWORD id;

  397.   gdb_assert (ptid_get_tid (ptid) != 0);

  399.   id = ptid_get_tid (ptid);

  401.   if (info_verbose)
  402.     printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
  403.   else if (print_thread_events && id != main_thread_id)
  404.     printf_unfiltered (_("[%s exited with code %u]\n"),
  405.                        target_pid_to_str (ptid), (unsigned) exit_code);
  406.   delete_thread (ptid);

  408.   for (th = &thread_head;
  409.        th->next != NULL && th->next->id != id;
  410.        th = th->next)
  411.     continue;

  413.   if (th->next != NULL)
  414.     {
  415.       thread_info *here = th->next;
  416.       th->next = here->next;
  417.       xfree (here);
  418.     }
  419. }

  421. static void
  422. ‌do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
  423. {
  424.   char *context_offset = ((char *) &current_thread->context) + mappings[r];
  425.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  426.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  427.   long l;

  429.   if (!current_thread)
  430.     return;        /* Windows sometimes uses a non-existent thread id in its
  431.                    events.  */

  433.   if (current_thread->reload_context)
  434.     {
  435. #ifdef __COPY_CONTEXT_SIZE
  436.       if (have_saved_context)
  437.         {
  438.           /* Lie about where the program actually is stopped since
  439.              cygwin has informed us that we should consider the signal
  440.              to have occurred at another location which is stored in
  441.              "saved_context.  */
  442.           memcpy (&current_thread->context, &saved_context,
  443.                   __COPY_CONTEXT_SIZE);
  444.           have_saved_context = 0;
  445.         }
  446.       else
  447. #endif
  448.         {
  449.           thread_info *th = current_thread;
  450.           th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
  451.           CHECK (GetThreadContext (th->h, &th->context));
  452.           /* Copy dr values from that thread.
  453.              But only if there were not modified since last stop.
  454.              PR gdb/2388 */
  455.           if (!debug_registers_changed)
  456.             {
  457.               dr[0] = th->context.Dr0;
  458.               dr[1] = th->context.Dr1;
  459.               dr[2] = th->context.Dr2;
  460.               dr[3] = th->context.Dr3;
  461.               dr[6] = th->context.Dr6;
  462.               dr[7] = th->context.Dr7;
  463.             }
  464.         }
  465.       current_thread->reload_context = 0;
  466.     }

  468.   if (r == I387_FISEG_REGNUM (tdep))
  469.     {
  470.       l = *((long *) context_offset) & 0xffff;
  471.       regcache_raw_supply (regcache, r, (char *) &l);
  472.     }
  473.   else if (r == I387_FOP_REGNUM (tdep))
  474.     {
  475.       l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
  476.       regcache_raw_supply (regcache, r, (char *) &l);
  477.     }
  478.   else if (segment_register_p (r))
  479.     {
  480.       /* GDB treats segment registers as 32bit registers, but they are
  481.          in fact only 16 bits long.  Make sure we do not read extra
  482.          bits from our source buffer.  */
  483.       l = *((long *) context_offset) & 0xffff;
  484.       regcache_raw_supply (regcache, r, (char *) &l);
  485.     }
  486.   else if (r >= 0)
  487.     regcache_raw_supply (regcache, r, context_offset);
  488.   else
  489.     {
  490.       for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
  491.         do_windows_fetch_inferior_registers (regcache, r);
  492.     }
  493. }

  495. static void
  496. ‌windows_fetch_inferior_registers (struct target_ops *ops,
  497.                                   struct regcache *regcache, int r)
  498. {
  499.   current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
  500.   /* Check if current_thread exists.  Windows sometimes uses a non-existent
  501.      thread id in its events.  */
  502.   if (current_thread)
  503.     do_windows_fetch_inferior_registers (regcache, r);
  504. }

  506. static void
  507. ‌do_windows_store_inferior_registers (const struct regcache *regcache, int r)
  508. {
  509.   if (!current_thread)
  510.     /* Windows sometimes uses a non-existent thread id in its events.  */;
  511.   else if (r >= 0)
  512.     regcache_raw_collect (regcache, r,
  513.                           ((char *) &current_thread->context) + mappings[r]);
  514.   else
  515.     {
  516.       for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
  517.         do_windows_store_inferior_registers (regcache, r);
  518.     }
  519. }

  521. /* Store a new register value into the current thread context.  */
  522. static void
  523. ‌windows_store_inferior_registers (struct target_ops *ops,
  524.                                   struct regcache *regcache, int r)
  525. {
  526.   current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
  527.   /* Check if current_thread exists.  Windows sometimes uses a non-existent
  528.      thread id in its events.  */
  529.   if (current_thread)
  530.     do_windows_store_inferior_registers (regcache, r);
  531. }

  533. /* Encapsulate the information required in a call to
  534.    symbol_file_add_args.  */
  535. ‌struct safe_symbol_file_add_args
  536. {
  537.   char *name;
  538.   int from_tty;
  539.   struct section_addr_info *addrs;
  540.   int mainline;
  541.   int flags;
  542.   struct ui_file *err, *out;
  543.   struct objfile *ret;
  544. };

  546. /* Maintain a linked list of "so" information.  */
  547. ‌struct lm_info
  548. {
  549.   LPVOID load_addr;
  550. };

  552. ‌‌static struct so_list solib_start, *solib_end;

  554. static struct so_list *
  555. ‌windows_make_so (const char *name, LPVOID load_addr)
  556. {
  557.   struct so_list *so;
  558.   char *p;
  559. #ifndef __CYGWIN__
  560.   char buf[__PMAX];
  561.   char cwd[__PMAX];
  562.   WIN32_FIND_DATA w32_fd;
  563.   HANDLE h = FindFirstFile(name, &w32_fd);

  565.   if (h == INVALID_HANDLE_VALUE)
  566.     strcpy (buf, name);
  567.   else
  568.     {
  569.       FindClose (h);
  570.       strcpy (buf, name);
  571.       if (GetCurrentDirectory (MAX_PATH + 1, cwd))
  572.         {
  573.           p = strrchr (buf, '\\');
  574.           if (p)
  575.             p[1] = '\0';
  576.           SetCurrentDirectory (buf);
  577.           GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
  578.           SetCurrentDirectory (cwd);
  579.         }
  580.     }
  581.   if (strcasecmp (buf, "ntdll.dll") == 0)
  582.     {
  583.       GetSystemDirectory (buf, sizeof (buf));
  584.       strcat (buf, "\\ntdll.dll");
  585.     }
  586. #else
  587.   cygwin_buf_t buf[__PMAX];

  589.   buf[0] = 0;
  590.   if (access (name, F_OK) != 0)
  591.     {
  592.       if (strcasecmp (name, "ntdll.dll") == 0)
  593. #ifdef __USEWIDE
  594.         {
  595.           GetSystemDirectoryW (buf, sizeof (buf) / sizeof (wchar_t));
  596.           wcscat (buf, L"\\ntdll.dll");
  597.         }
  598. #else
  599.         {
  600.           GetSystemDirectoryA (buf, sizeof (buf) / sizeof (wchar_t));
  601.           strcat (buf, "\\ntdll.dll");
  602.         }
  603. #endif
  604.     }
  605. #endif
  606.   so = XCNEW (struct so_list);
  607.   so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
  608.   so->lm_info->load_addr = load_addr;
  609.   strcpy (so->so_original_name, name);
  610. #ifndef __CYGWIN__
  611.   strcpy (so->so_name, buf);
  612. #else
  613.   if (buf[0])
  614.     cygwin_conv_path (CCP_WIN_W_TO_POSIX, buf, so->so_name,
  615.                       SO_NAME_MAX_PATH_SIZE);
  616.   else
  617.     {
  618.       char *rname = realpath (name, NULL);
  619.       if (rname && strlen (rname) < SO_NAME_MAX_PATH_SIZE)
  620.         {
  621.           strcpy (so->so_name, rname);
  622.           free (rname);
  623.         }
  624.       else
  625.         error (_("dll path too long"));
  626.     }
  627.   /* Record cygwin1.dll .text start/end.  */
  628.   p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
  629.   if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
  630.     {
  631.       bfd *abfd;
  632.       asection *text = NULL;
  633.       CORE_ADDR text_vma;

  635.       abfd = gdb_bfd_open (so->so_name, "pei-i386", -1);

  637.       if (!abfd)
  638.         return so;

  640.       if (bfd_check_format (abfd, bfd_object))
  641.         text = bfd_get_section_by_name (abfd, ".text");

  643.       if (!text)
  644.         {
  645.           gdb_bfd_unref (abfd);
  646.           return so;
  647.         }

  649.       /* The symbols in a dll are offset by 0x1000, which is the
  650.          offset from 0 of the first byte in an image - because of the
  651.          file header and the section alignment.  */
  652.       cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *)
  653.                                                    load_addr + 0x1000);
  654.       cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);

  656.       gdb_bfd_unref (abfd);
  657.     }
  658. #endif

  660.   return so;
  661. }

  663. static char *
  664. ‌get_image_name (HANDLE h, void *address, int unicode)
  665. {
  666. #ifdef __CYGWIN__
  667.   static char buf[__PMAX];
  668. #else
  669.   static char buf[(2 * __PMAX) + 1];
  670. #endif
  671.   DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
  672.   char *address_ptr;
  673.   int len = 0;
  674.   char b[2];
  675.   SIZE_T done;

  677.   /* Attempt to read the name of the dll that was detected.
  678.      This is documented to work only when actively debugging
  679.      a program.  It will not work for attached processes.  */
  680.   if (address == NULL)
  681.     return NULL;

  683.   /* See if we could read the address of a string, and that the
  684.      address isn't null.  */
  685.   if (!ReadProcessMemory (h, address,  &address_ptr,
  686.                           sizeof (address_ptr), &done)
  687.       || done != sizeof (address_ptr) || !address_ptr)
  688.     return NULL;

  690.   /* Find the length of the string.  */
  691.   while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
  692.          && (b[0] != 0 || b[size - 1] != 0) && done == size)
  693.     continue;

  695.   if (!unicode)
  696.     ReadProcessMemory (h, address_ptr, buf, len, &done);
  697.   else
  698.     {
  699.       WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
  700.       ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
  701.                          &done);
  702. #ifdef __CYGWIN__
  703.       wcstombs (buf, unicode_address, __PMAX);
  704. #else
  705.       WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
  706.                            0, 0);
  707. #endif
  708.     }

  710.   return buf;
  711. }

  713. /* Handle a DLL load event, and return 1.

  715.    This function assumes that this event did not occur during inferior
  716.    initialization, where their event info may be incomplete (see
  717.    do_initial_windows_stuff and windows_add_all_dlls for more info
  718.    on how we handle DLL loading during that phase).  */

  720. static int
  721. ‌handle_load_dll (void *dummy)
  722. {
  723.   LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
  724.   char *dll_name;

  726.   /* Try getting the DLL name via the lpImageName field of the event.
  727.      Note that Microsoft documents this fields as strictly optional,
  728.      in the sense that it might be NULL.  And the first DLL event in
  729.      particular is explicitly documented as "likely not pass[ed]"
  730.      (source: MSDN LOAD_DLL_DEBUG_INFO structure).  */
  731.   dll_name = get_image_name (current_process_handle,
  732.                              event->lpImageName, event->fUnicode);
  733.   if (!dll_name)
  734.     return 1;

  736.   solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
  737.   solib_end = solib_end->next;

  739.   DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name,
  740.                  host_address_to_string (solib_end->lm_info->load_addr)));

  742.   return 1;
  743. }

  745. static void
  746. ‌windows_free_so (struct so_list *so)
  747. {
  748.   if (so->lm_info)
  749.     xfree (so->lm_info);
  750.   xfree (so);
  751. }

  753. /* Handle a DLL unload event.
  754.    Return 1 if successful, or zero otherwise.

  756.    This function assumes that this event did not occur during inferior
  757.    initialization, where their event info may be incomplete (see
  758.    do_initial_windows_stuff and windows_add_all_dlls for more info
  759.    on how we handle DLL loading during that phase).  */

  761. static int
  762. ‌handle_unload_dll (void *dummy)
  763. {
  764.   LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
  765.   struct so_list *so;

  767.   for (so = &solib_start; so->next != NULL; so = so->next)
  768.     if (so->next->lm_info->load_addr == lpBaseOfDll)
  769.       {
  770.         struct so_list *sodel = so->next;

  772.         so->next = sodel->next;
  773.         if (!so->next)
  774.           solib_end = so;
  775.         DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));

  777.         windows_free_so (sodel);
  778.         return 1;
  779.       }

  781.   /* We did not find any DLL that was previously loaded at this address,
  782.      so register a complaint.  We do not report an error, because we have
  783.      observed that this may be happening under some circumstances.  For
  784.      instance, running 32bit applications on x64 Windows causes us to receive
  785.      4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these
  786.      events are apparently caused by the WOW layer, the interface between
  787.      32bit and 64bit worlds).  */
  788.   complaint (&symfile_complaints, _("dll starting at %s not found."),
  789.              host_address_to_string (lpBaseOfDll));

  791.   return 0;
  792. }

  794. /* Clear list of loaded DLLs.  */
  795. static void
  796. ‌windows_clear_solib (void)
  797. {
  798.   solib_start.next = NULL;
  799.   solib_end = &solib_start;
  800. }

  802. /* Handle DEBUG_STRING output from child process.
  803.    Cygwin prepends its messages with a "cygwin:".  Interpret this as
  804.    a Cygwin signal.  Otherwise just print the string as a warning.  */
  805. static int
  806. ‌handle_output_debug_string (struct target_waitstatus *ourstatus)
  807. {
  808.   char *s = NULL;
  809.   int retval = 0;

  811.   if (!target_read_string
  812.         ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
  813.         &s, 1024, 0)
  814.       || !s || !*s)
  815.     /* nothing to do */;
  816.   else if (strncmp (s, _CYGWIN_SIGNAL_STRING,
  817.                     sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
  818.     {
  819. #ifdef __CYGWIN__
  820.       if (strncmp (s, "cYg", 3) != 0)
  821. #endif
  822.         warning (("%s"), s);
  823.     }
  824. #ifdef __COPY_CONTEXT_SIZE
  825.   else
  826.     {
  827.       /* Got a cygwin signal marker.  A cygwin signal is followed by
  828.          the signal number itself and then optionally followed by the
  829.          thread id and address to saved context within the DLL.  If
  830.          these are supplied, then the given thread is assumed to have
  831.          issued the signal and the context from the thread is assumed
  832.          to be stored at the given address in the inferior.  Tell gdb
  833.          to treat this like a real signal.  */
  834.       char *p;
  835.       int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
  836.       int gotasig = gdb_signal_from_host (sig);

  838.       ourstatus->value.sig = gotasig;
  839.       if (gotasig)
  840.         {
  841.           LPCVOID x;
  842.           SIZE_T n;

  844.           ourstatus->kind = TARGET_WAITKIND_STOPPED;
  845.           retval = strtoul (p, &p, 0);
  846.           if (!retval)
  847.             retval = main_thread_id;
  848.           else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0))
  849.                    && ReadProcessMemory (current_process_handle, x,
  850.                                          &saved_context,
  851.                                          __COPY_CONTEXT_SIZE, &n)
  852.                    && n == __COPY_CONTEXT_SIZE)
  853.             have_saved_context = 1;
  854.           current_event.dwThreadId = retval;
  855.         }
  856.     }
  857. #endif

  859.   if (s)
  860.     xfree (s);
  861.   return retval;
  862. }

  864. static int
  865. ‌display_selector (HANDLE thread, DWORD sel)
  866. {
  867.   LDT_ENTRY info;
  868.   if (GetThreadSelectorEntry (thread, sel, &info))
  869.     {
  870.       int base, limit;
  871.       printf_filtered ("0x%03x: ", (unsigned) sel);
  872.       if (!info.HighWord.Bits.Pres)
  873.         {
  874.           puts_filtered ("Segment not present\n");
  875.           return 0;
  876.         }
  877.       base = (info.HighWord.Bits.BaseHi << 24) +
  878.              (info.HighWord.Bits.BaseMid << 16)
  879.              + info.BaseLow;
  880.       limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
  881.       if (info.HighWord.Bits.Granularity)
  882.         limit = (limit << 12) | 0xfff;
  883.       printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
  884.       if (info.HighWord.Bits.Default_Big)
  885.         puts_filtered(" 32-bit ");
  886.       else
  887.         puts_filtered(" 16-bit ");
  888.       switch ((info.HighWord.Bits.Type & 0xf) >> 1)
  889.         {
  890.         case 0:
  891.           puts_filtered ("Data (Read-Only, Exp-up");
  892.           break;
  893.         case 1:
  894.           puts_filtered ("Data (Read/Write, Exp-up");
  895.           break;
  896.         case 2:
  897.           puts_filtered ("Unused segment (");
  898.           break;
  899.         case 3:
  900.           puts_filtered ("Data (Read/Write, Exp-down");
  901.           break;
  902.         case 4:
  903.           puts_filtered ("Code (Exec-Only, N.Conf");
  904.           break;
  905.         case 5:
  906.           puts_filtered ("Code (Exec/Read, N.Conf");
  907.           break;
  908.         case 6:
  909.           puts_filtered ("Code (Exec-Only, Conf");
  910.           break;
  911.         case 7:
  912.           puts_filtered ("Code (Exec/Read, Conf");
  913.           break;
  914.         default:
  915.           printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
  916.         }
  917.       if ((info.HighWord.Bits.Type & 0x1) == 0)
  918.         puts_filtered(", N.Acc");
  919.       puts_filtered (")\n");
  920.       if ((info.HighWord.Bits.Type & 0x10) == 0)
  921.         puts_filtered("System selector ");
  922.       printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
  923.       if (info.HighWord.Bits.Granularity)
  924.         puts_filtered ("Page granular.\n");
  925.       else
  926.         puts_filtered ("Byte granular.\n");
  927.       return 1;
  928.     }
  929.   else
  930.     {
  931.       DWORD err = GetLastError ();
  932.       if (err == ERROR_NOT_SUPPORTED)
  933.         printf_filtered ("Function not supported\n");
  934.       else
  935.         printf_filtered ("Invalid selector 0x%x.\n", (unsigned) sel);
  936.       return 0;
  937.     }
  938. }

  940. static void
  941. ‌display_selectors (char * args, int from_tty)
  942. {
  943.   if (!current_thread)
  944.     {
  945.       puts_filtered ("Impossible to display selectors now.\n");
  946.       return;
  947.     }
  948.   if (!args)
  949.     {

  951.       puts_filtered ("Selector $cs\n");
  952.       display_selector (current_thread->h,
  953.         current_thread->context.SegCs);
  954.       puts_filtered ("Selector $ds\n");
  955.       display_selector (current_thread->h,
  956.         current_thread->context.SegDs);
  957.       puts_filtered ("Selector $es\n");
  958.       display_selector (current_thread->h,
  959.         current_thread->context.SegEs);
  960.       puts_filtered ("Selector $ss\n");
  961.       display_selector (current_thread->h,
  962.         current_thread->context.SegSs);
  963.       puts_filtered ("Selector $fs\n");
  964.       display_selector (current_thread->h,
  965.         current_thread->context.SegFs);
  966.       puts_filtered ("Selector $gs\n");
  967.       display_selector (current_thread->h,
  968.         current_thread->context.SegGs);
  969.     }
  970.   else
  971.     {
  972.       int sel;
  973.       sel = parse_and_eval_long (args);
  974.       printf_filtered ("Selector \"%s\"\n",args);
  975.       display_selector (current_thread->h, sel);
  976.     }
  977. }

  979. ‌#define DEBUG_EXCEPTION_SIMPLE(x)       if (debug_exceptions) \
  980.   printf_unfiltered ("gdb: Target exception %s at %s\n", x, \
  981.     host_address_to_string (\
  982.       current_event.u.Exception.ExceptionRecord.ExceptionAddress))

  984. static int
  985. ‌handle_exception (struct target_waitstatus *ourstatus)
  986. {
  987.   thread_info *th;
  988.   DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;

  990.   ourstatus->kind = TARGET_WAITKIND_STOPPED;

  992.   /* Record the context of the current thread.  */
  993.   th = thread_rec (current_event.dwThreadId, -1);

  995.   switch (code)
  996.     {
  997.     case EXCEPTION_ACCESS_VIOLATION:
  998.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
  999.       ourstatus->value.sig = GDB_SIGNAL_SEGV;
  1000. #ifdef __CYGWIN__
  1001.       {
  1002.         /* See if the access violation happened within the cygwin DLL
  1003.            itself.  Cygwin uses a kind of exception handling to deal
  1004.            with passed-in invalid addresses.  gdb should not treat
  1005.            these as real SEGVs since they will be silently handled by
  1006.            cygwin.  A real SEGV will (theoretically) be caught by
  1007.            cygwin later in the process and will be sent as a
  1008.            cygwin-specific-signal.  So, ignore SEGVs if they show up
  1009.            within the text segment of the DLL itself.  */
  1010.         const char *fn;
  1011.         CORE_ADDR addr = (CORE_ADDR) (uintptr_t)
  1012.           current_event.u.Exception.ExceptionRecord.ExceptionAddress;

  1014.         if ((!cygwin_exceptions && (addr >= cygwin_load_start
  1015.                                     && addr < cygwin_load_end))
  1016.             || (find_pc_partial_function (addr, &fn, NULL, NULL)
  1017.                 && strncmp (fn, "KERNEL32!IsBad",
  1018.                             strlen ("KERNEL32!IsBad")) == 0))
  1019.           return 0;
  1020.       }
  1021. #endif
  1022.       break;
  1023.     case STATUS_STACK_OVERFLOW:
  1024.       DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
  1025.       ourstatus->value.sig = GDB_SIGNAL_SEGV;
  1026.       break;
  1027.     case STATUS_FLOAT_DENORMAL_OPERAND:
  1028.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
  1029.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1030.       break;
  1031.     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
  1032.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
  1033.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1034.       break;
  1035.     case STATUS_FLOAT_INEXACT_RESULT:
  1036.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
  1037.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1038.       break;
  1039.     case STATUS_FLOAT_INVALID_OPERATION:
  1040.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
  1041.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1042.       break;
  1043.     case STATUS_FLOAT_OVERFLOW:
  1044.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
  1045.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1046.       break;
  1047.     case STATUS_FLOAT_STACK_CHECK:
  1048.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
  1049.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1050.       break;
  1051.     case STATUS_FLOAT_UNDERFLOW:
  1052.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
  1053.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1054.       break;
  1055.     case STATUS_FLOAT_DIVIDE_BY_ZERO:
  1056.       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
  1057.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1058.       break;
  1059.     case STATUS_INTEGER_DIVIDE_BY_ZERO:
  1060.       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
  1061.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1062.       break;
  1063.     case STATUS_INTEGER_OVERFLOW:
  1064.       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
  1065.       ourstatus->value.sig = GDB_SIGNAL_FPE;
  1066.       break;
  1067.     case EXCEPTION_BREAKPOINT:
  1068.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
  1069.       ourstatus->value.sig = GDB_SIGNAL_TRAP;
  1070.       break;
  1071.     case DBG_CONTROL_C:
  1072.       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
  1073.       ourstatus->value.sig = GDB_SIGNAL_INT;
  1074.       break;
  1075.     case DBG_CONTROL_BREAK:
  1076.       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
  1077.       ourstatus->value.sig = GDB_SIGNAL_INT;
  1078.       break;
  1079.     case EXCEPTION_SINGLE_STEP:
  1080.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
  1081.       ourstatus->value.sig = GDB_SIGNAL_TRAP;
  1082.       break;
  1083.     case EXCEPTION_ILLEGAL_INSTRUCTION:
  1084.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
  1085.       ourstatus->value.sig = GDB_SIGNAL_ILL;
  1086.       break;
  1087.     case EXCEPTION_PRIV_INSTRUCTION:
  1088.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
  1089.       ourstatus->value.sig = GDB_SIGNAL_ILL;
  1090.       break;
  1091.     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
  1092.       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
  1093.       ourstatus->value.sig = GDB_SIGNAL_ILL;
  1094.       break;
  1095.     default:
  1096.       /* Treat unhandled first chance exceptions specially.  */
  1097.       if (current_event.u.Exception.dwFirstChance)
  1098.         return -1;
  1099.       printf_unfiltered ("gdb: unknown target exception 0x%08x at %s\n",
  1100.         (unsigned) current_event.u.Exception.ExceptionRecord.ExceptionCode,
  1101.         host_address_to_string (
  1102.           current_event.u.Exception.ExceptionRecord.ExceptionAddress));
  1103.       ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
  1104.       break;
  1105.     }
  1106.   exception_count++;
  1107.   last_sig = ourstatus->value.sig;
  1108.   return 1;
  1109. }

  1111. /* Resume thread specified by ID, or all artificially suspended
  1112.    threads, if we are continuing execution.  KILLED non-zero means we
  1113.    have killed the inferior, so we should ignore weird errors due to
  1114.    threads shutting down.  */
  1115. static BOOL
  1116. ‌windows_continue (DWORD continue_status, int id, int killed)
  1117. {
  1118.   int i;
  1119.   thread_info *th;
  1120.   BOOL res;

  1122.   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=0x%x, %s);\n",
  1123.                   (unsigned) current_event.dwProcessId,
  1124.                   (unsigned) current_event.dwThreadId,
  1125.                   continue_status == DBG_CONTINUE ?
  1126.                   "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));

  1128.   for (th = &thread_head; (th = th->next) != NULL;)
  1129.     if ((id == -1 || id == (int) th->id)
  1130.         && th->suspended)
  1131.       {
  1132.         if (debug_registers_changed)
  1133.           {
  1134.             th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
  1135.             th->context.Dr0 = dr[0];
  1136.             th->context.Dr1 = dr[1];
  1137.             th->context.Dr2 = dr[2];
  1138.             th->context.Dr3 = dr[3];
  1139.             th->context.Dr6 = DR6_CLEAR_VALUE;
  1140.             th->context.Dr7 = dr[7];
  1141.           }
  1142.         if (th->context.ContextFlags)
  1143.           {
  1144.             DWORD ec = 0;

  1146.             if (GetExitCodeThread (th->h, &ec)
  1147.                 && ec == STILL_ACTIVE)
  1148.               {
  1149.                 BOOL status = SetThreadContext (th->h, &th->context);

  1151.                 if (!killed)
  1152.                   CHECK (status);
  1153.               }
  1154.             th->context.ContextFlags = 0;
  1155.           }
  1156.         if (th->suspended > 0)
  1157.           (void) ResumeThread (th->h);
  1158.         th->suspended = 0;
  1159.       }

  1161.   res = ContinueDebugEvent (current_event.dwProcessId,
  1162.                             current_event.dwThreadId,
  1163.                             continue_status);

  1165.   debug_registers_changed = 0;
  1166.   return res;
  1167. }

  1169. /* Called in pathological case where Windows fails to send a
  1170.    CREATE_PROCESS_DEBUG_EVENT after an attach.  */
  1171. static DWORD
  1172. ‌fake_create_process (void)
  1173. {
  1174.   current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
  1175.                                         current_event.dwProcessId);
  1176.   if (current_process_handle != NULL)
  1177.     open_process_used = 1;
  1178.   else
  1179.     {
  1180.       error (_("OpenProcess call failed, GetLastError = %u"),
  1181.        (unsigned) GetLastError ());
  1182.       /*  We can not debug anything in that case.  */
  1183.     }
  1184.   main_thread_id = current_event.dwThreadId;
  1185.   current_thread = windows_add_thread (
  1186.                      ptid_build (current_event.dwProcessId, 0,
  1187.                                  current_event.dwThreadId),
  1188.                      current_event.u.CreateThread.hThread,
  1189.                      current_event.u.CreateThread.lpThreadLocalBase);
  1190.   return main_thread_id;
  1191. }

  1193. static void
  1194. ‌windows_resume (struct target_ops *ops,
  1195.                 ptid_t ptid, int step, enum gdb_signal sig)
  1196. {
  1197.   thread_info *th;
  1198.   DWORD continue_status = DBG_CONTINUE;

  1200.   /* A specific PTID means `step only this thread id'.  */
  1201.   int resume_all = ptid_equal (ptid, minus_one_ptid);

  1203.   /* If we're continuing all threads, it's the current inferior that
  1204.      should be handled specially.  */
  1205.   if (resume_all)
  1206.     ptid = inferior_ptid;

  1208.   if (sig != GDB_SIGNAL_0)
  1209.     {
  1210.       if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
  1211.         {
  1212.           DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
  1213.         }
  1214.       else if (sig == last_sig)
  1215.         continue_status = DBG_EXCEPTION_NOT_HANDLED;
  1216.       else
  1217. #if 0
  1218. /* This code does not seem to work, because
  1219.   the kernel does probably not consider changes in the ExceptionRecord
  1220.   structure when passing the exception to the inferior.
  1221.   Note that this seems possible in the exception handler itself.  */
  1222.         {
  1223.           int i;
  1224.           for (i = 0; xlate[i].them != -1; i++)
  1225.             if (xlate[i].us == sig)
  1226.               {
  1227.                 current_event.u.Exception.ExceptionRecord.ExceptionCode
  1228.                   = xlate[i].them;
  1229.                 continue_status = DBG_EXCEPTION_NOT_HANDLED;
  1230.                 break;
  1231.               }
  1232.           if (continue_status == DBG_CONTINUE)
  1233.             {
  1234.               DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
  1235.             }
  1236.         }
  1237. #endif
  1238.         DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
  1239.           last_sig));
  1240.     }

  1242.   last_sig = GDB_SIGNAL_0;

  1244.   DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
  1245.                ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));

  1247.   /* Get context for currently selected thread.  */
  1248.   th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
  1249.   if (th)
  1250.     {
  1251.       if (step)
  1252.         {
  1253.           /* Single step by setting t bit.  */
  1254.           struct regcache *regcache = get_current_regcache ();
  1255.           struct gdbarch *gdbarch = get_regcache_arch (regcache);
  1256.           windows_fetch_inferior_registers (ops, regcache,
  1257.                                             gdbarch_ps_regnum (gdbarch));
  1258.           th->context.EFlags |= FLAG_TRACE_BIT;
  1259.         }

  1261.       if (th->context.ContextFlags)
  1262.         {
  1263.           if (debug_registers_changed)
  1264.             {
  1265.               th->context.Dr0 = dr[0];
  1266.               th->context.Dr1 = dr[1];
  1267.               th->context.Dr2 = dr[2];
  1268.               th->context.Dr3 = dr[3];
  1269.               th->context.Dr6 = DR6_CLEAR_VALUE;
  1270.               th->context.Dr7 = dr[7];
  1271.             }
  1272.           CHECK (SetThreadContext (th->h, &th->context));
  1273.           th->context.ContextFlags = 0;
  1274.         }
  1275.     }

  1277.   /* Allow continuing with the same signal that interrupted us.
  1278.      Otherwise complain.  */

  1280.   if (resume_all)
  1281.     windows_continue (continue_status, -1, 0);
  1282.   else
  1283.     windows_continue (continue_status, ptid_get_tid (ptid), 0);
  1284. }

  1286. /* Ctrl-C handler used when the inferior is not run in the same console.  The
  1287.    handler is in charge of interrupting the inferior using DebugBreakProcess.
  1288.    Note that this function is not available prior to Windows XP.  In this case
  1289.    we emit a warning.  */
  1290. static BOOL WINAPI
  1291. ‌ctrl_c_handler (DWORD event_type)
  1292. {
  1293.   const int attach_flag = current_inferior ()->attach_flag;

  1295.   /* Only handle Ctrl-C and Ctrl-Break events.  Ignore others.  */
  1296.   if (event_type != CTRL_C_EVENT && event_type != CTRL_BREAK_EVENT)
  1297.     return FALSE;

  1299.   /* If the inferior and the debugger share the same console, do nothing as
  1300.      the inferior has also received the Ctrl-C event.  */
  1301.   if (!new_console && !attach_flag)
  1302.     return TRUE;

  1304.   if (!DebugBreakProcess (current_process_handle))
  1305.     warning (_("Could not interrupt program.  "
  1306.                "Press Ctrl-c in the program console."));

  1308.   /* Return true to tell that Ctrl-C has been handled.  */
  1309.   return TRUE;
  1310. }

  1312. /* Get the next event from the child.  Return 1 if the event requires
  1313.    handling by WFI (or whatever).  */
  1314. static int
  1315. ‌get_windows_debug_event (struct target_ops *ops,
  1316.                          int pid, struct target_waitstatus *ourstatus)
  1317. {
  1318.   BOOL debug_event;
  1319.   DWORD continue_status, event_code;
  1320.   thread_info *th;
  1321.   static thread_info dummy_thread_info;
  1322.   int retval = 0;

  1324.   last_sig = GDB_SIGNAL_0;

  1326.   if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
  1327.     goto out;

  1329.   event_count++;
  1330.   continue_status = DBG_CONTINUE;

  1332.   event_code = current_event.dwDebugEventCode;
  1333.   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
  1334.   th = NULL;
  1335.   have_saved_context = 0;

  1337.   switch (event_code)
  1338.     {
  1339.     case CREATE_THREAD_DEBUG_EVENT:
  1340.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1341.                      (unsigned) current_event.dwProcessId,
  1342.                      (unsigned) current_event.dwThreadId,
  1343.                      "CREATE_THREAD_DEBUG_EVENT"));
  1344.       if (saw_create != 1)
  1345.         {
  1346.           struct inferior *inf;
  1347.           inf = find_inferior_pid (current_event.dwProcessId);
  1348.           if (!saw_create && inf->attach_flag)
  1349.             {
  1350.               /* Kludge around a Windows bug where first event is a create
  1351.                  thread event.  Caused when attached process does not have
  1352.                  a main thread.  */
  1353.               retval = fake_create_process ();
  1354.               if (retval)
  1355.                 saw_create++;
  1356.             }
  1357.           break;
  1358.         }
  1359.       /* Record the existence of this thread.  */
  1360.       retval = current_event.dwThreadId;
  1361.       th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
  1362.                                          current_event.dwThreadId),
  1363.                              current_event.u.CreateThread.hThread,
  1364.                              current_event.u.CreateThread.lpThreadLocalBase);

  1366.       break;

  1368.     case EXIT_THREAD_DEBUG_EVENT:
  1369.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1370.                      (unsigned) current_event.dwProcessId,
  1371.                      (unsigned) current_event.dwThreadId,
  1372.                      "EXIT_THREAD_DEBUG_EVENT"));

  1374.       if (current_event.dwThreadId != main_thread_id)
  1375.         {
  1376.           windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
  1377.                                              current_event.dwThreadId),
  1378.                                  current_event.u.ExitThread.dwExitCode);
  1379.           th = &dummy_thread_info;
  1380.         }
  1381.       break;

  1383.     case CREATE_PROCESS_DEBUG_EVENT:
  1384.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1385.                      (unsigned) current_event.dwProcessId,
  1386.                      (unsigned) current_event.dwThreadId,
  1387.                      "CREATE_PROCESS_DEBUG_EVENT"));
  1388.       CloseHandle (current_event.u.CreateProcessInfo.hFile);
  1389.       if (++saw_create != 1)
  1390.         break;

  1392.       current_process_handle = current_event.u.CreateProcessInfo.hProcess;
  1393.       if (main_thread_id)
  1394.         windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
  1395.                                            main_thread_id),
  1396.                                0);
  1397.       main_thread_id = current_event.dwThreadId;
  1398.       /* Add the main thread.  */
  1399.       th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
  1400.                                            current_event.dwThreadId),
  1401.              current_event.u.CreateProcessInfo.hThread,
  1402.              current_event.u.CreateProcessInfo.lpThreadLocalBase);
  1403.       retval = current_event.dwThreadId;
  1404.       break;

  1406.     case EXIT_PROCESS_DEBUG_EVENT:
  1407.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1408.                      (unsigned) current_event.dwProcessId,
  1409.                      (unsigned) current_event.dwThreadId,
  1410.                      "EXIT_PROCESS_DEBUG_EVENT"));
  1411.       if (!windows_initialization_done)
  1412.         {
  1413.           target_terminal_ours ();
  1414.           target_mourn_inferior ();
  1415.           error (_("During startup program exited with code 0x%x."),
  1416.                  (unsigned int) current_event.u.ExitProcess.dwExitCode);
  1417.         }
  1418.       else if (saw_create == 1)
  1419.         {
  1420.           ourstatus->kind = TARGET_WAITKIND_EXITED;
  1421.           ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
  1422.           retval = main_thread_id;
  1423.         }
  1424.       break;

  1426.     case LOAD_DLL_DEBUG_EVENT:
  1427.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1428.                      (unsigned) current_event.dwProcessId,
  1429.                      (unsigned) current_event.dwThreadId,
  1430.                      "LOAD_DLL_DEBUG_EVENT"));
  1431.       CloseHandle (current_event.u.LoadDll.hFile);
  1432.       if (saw_create != 1 || ! windows_initialization_done)
  1433.         break;
  1434.       catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
  1435.       ourstatus->kind = TARGET_WAITKIND_LOADED;
  1436.       ourstatus->value.integer = 0;
  1437.       retval = main_thread_id;
  1438.       break;

  1440.     case UNLOAD_DLL_DEBUG_EVENT:
  1441.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1442.                      (unsigned) current_event.dwProcessId,
  1443.                      (unsigned) current_event.dwThreadId,
  1444.                      "UNLOAD_DLL_DEBUG_EVENT"));
  1445.       if (saw_create != 1 || ! windows_initialization_done)
  1446.         break;
  1447.       catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
  1448.       ourstatus->kind = TARGET_WAITKIND_LOADED;
  1449.       ourstatus->value.integer = 0;
  1450.       retval = main_thread_id;
  1451.       break;

  1453.     case EXCEPTION_DEBUG_EVENT:
  1454.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1455.                      (unsigned) current_event.dwProcessId,
  1456.                      (unsigned) current_event.dwThreadId,
  1457.                      "EXCEPTION_DEBUG_EVENT"));
  1458.       if (saw_create != 1)
  1459.         break;
  1460.       switch (handle_exception (ourstatus))
  1461.         {
  1462.         case 0:
  1463.           continue_status = DBG_EXCEPTION_NOT_HANDLED;
  1464.           break;
  1465.         case 1:
  1466.           retval = current_event.dwThreadId;
  1467.           break;
  1468.         case -1:
  1469.           last_sig = 1;
  1470.           continue_status = -1;
  1471.           break;
  1472.         }
  1473.       break;

  1475.     case OUTPUT_DEBUG_STRING_EVENT:        /* Message from the kernel.  */
  1476.       DEBUG_EVENTS (("gdb: kernel event for pid=%u tid=0x%x code=%s)\n",
  1477.                      (unsigned) current_event.dwProcessId,
  1478.                      (unsigned) current_event.dwThreadId,
  1479.                      "OUTPUT_DEBUG_STRING_EVENT"));
  1480.       if (saw_create != 1)
  1481.         break;
  1482.       retval = handle_output_debug_string (ourstatus);
  1483.       break;

  1485.     default:
  1486.       if (saw_create != 1)
  1487.         break;
  1488.       printf_unfiltered ("gdb: kernel event for pid=%u tid=0x%x\n",
  1489.                          (unsigned) current_event.dwProcessId,
  1490.                          (unsigned) current_event.dwThreadId);
  1491.       printf_unfiltered ("                 unknown event code %u\n",
  1492.                          (unsigned) current_event.dwDebugEventCode);
  1493.       break;
  1494.     }

  1496.   if (!retval || saw_create != 1)
  1497.     {
  1498.       if (continue_status == -1)
  1499.         windows_resume (ops, minus_one_ptid, 0, 1);
  1500.       else
  1501.         CHECK (windows_continue (continue_status, -1, 0));
  1502.     }
  1503.   else
  1504.     {
  1505.       inferior_ptid = ptid_build (current_event.dwProcessId, 0,
  1506.                                   retval);
  1507.       current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
  1508.     }

  1510. out:
  1511.   return retval;
  1512. }

  1514. /* Wait for interesting events to occur in the target process.  */
  1515. static ptid_t
  1516. ‌windows_wait (struct target_ops *ops,
  1517.               ptid_t ptid, struct target_waitstatus *ourstatus, int options)
  1518. {
  1519.   int pid = -1;

  1521.   target_terminal_ours ();

  1523.   /* We loop when we get a non-standard exception rather than return
  1524.      with a SPURIOUS because resume can try and step or modify things,
  1525.      which needs a current_thread->h.  But some of these exceptions mark
  1526.      the birth or death of threads, which mean that the current thread
  1527.      isn't necessarily what you think it is.  */

  1529.   while (1)
  1530.     {
  1531.       int retval;

  1533.       /* If the user presses Ctrl-c while the debugger is waiting
  1534.          for an event, he expects the debugger to interrupt his program
  1535.          and to get the prompt back.  There are two possible situations:

  1537.            - The debugger and the program do not share the console, in
  1538.              which case the Ctrl-c event only reached the debugger.
  1539.              In that case, the ctrl_c handler will take care of interrupting
  1540.              the inferior.  Note that this case is working starting with
  1541.              Windows XP.  For Windows 2000, Ctrl-C should be pressed in the
  1542.              inferior console.

  1544.            - The debugger and the program share the same console, in which
  1545.              case both debugger and inferior will receive the Ctrl-c event.
  1546.              In that case the ctrl_c handler will ignore the event, as the
  1547.              Ctrl-c event generated inside the inferior will trigger the
  1548.              expected debug event.

  1550.              FIXME: brobecker/2008-05-20: If the inferior receives the
  1551.              signal first and the delay until GDB receives that signal
  1552.              is sufficiently long, GDB can sometimes receive the SIGINT
  1553.              after we have unblocked the CTRL+C handler.  This would
  1554.              lead to the debugger stopping prematurely while handling
  1555.              the new-thread event that comes with the handling of the SIGINT
  1556.              inside the inferior, and then stop again immediately when
  1557.              the user tries to resume the execution in the inferior.
  1558.              This is a classic race that we should try to fix one day.  */
  1559.       SetConsoleCtrlHandler (&ctrl_c_handler, TRUE);
  1560.       retval = get_windows_debug_event (ops, pid, ourstatus);
  1561.       SetConsoleCtrlHandler (&ctrl_c_handler, FALSE);

  1563.       if (retval)
  1564.         return ptid_build (current_event.dwProcessId, 0, retval);
  1565.       else
  1566.         {
  1567.           int detach = 0;

  1569.           if (deprecated_ui_loop_hook != NULL)
  1570.             detach = deprecated_ui_loop_hook (0);

  1572.           if (detach)
  1573.             windows_kill_inferior (ops);
  1574.         }
  1575.     }
  1576. }

  1578. /* Iterate over all DLLs currently mapped by our inferior, and
  1579.    add them to our list of solibs.  */

  1581. static void
  1582. ‌windows_add_all_dlls (void)
  1583. {
  1584.   struct so_list *so;
  1585.   HMODULE dummy_hmodule;
  1586.   DWORD cb_needed;
  1587.   HMODULE *hmodules;
  1588.   int i;

  1590.   if (EnumProcessModules (current_process_handle, &dummy_hmodule,
  1591.                           sizeof (HMODULE), &cb_needed) == 0)
  1592.     return;

  1594.   if (cb_needed < 1)
  1595.     return;

  1597.   hmodules = (HMODULE *) alloca (cb_needed);
  1598.   if (EnumProcessModules (current_process_handle, hmodules,
  1599.                           cb_needed, &cb_needed) == 0)
  1600.     return;

  1602.   for (i = 1; i < (int) (cb_needed / sizeof (HMODULE)); i++)
  1603.     {
  1604.       MODULEINFO mi;
  1605. #ifdef __USEWIDE
  1606.       wchar_t dll_name[__PMAX];
  1607.       char name[__PMAX];
  1608. #else
  1609.       char dll_name[__PMAX];
  1610.       char *name;
  1611. #endif
  1612.       if (GetModuleInformation (current_process_handle, hmodules[i],
  1613.                                 &mi, sizeof (mi)) == 0)
  1614.         continue;
  1615.       if (GetModuleFileNameEx (current_process_handle, hmodules[i],
  1616.                                dll_name, sizeof (dll_name)) == 0)
  1617.         continue;
  1618. #ifdef __USEWIDE
  1619.       wcstombs (name, dll_name, __PMAX);
  1620. #else
  1621.       name = dll_name;
  1622. #endif

  1624.       solib_end->next = windows_make_so (name, mi.lpBaseOfDll);
  1625.       solib_end = solib_end->next;
  1626.     }
  1627. }

  1629. static void
  1630. ‌do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
  1631. {
  1632.   extern int stop_after_trap;
  1633.   int i;
  1634.   struct inferior *inf;
  1635.   struct thread_info *tp;

  1637.   last_sig = GDB_SIGNAL_0;
  1638.   event_count = 0;
  1639.   exception_count = 0;
  1640.   open_process_used = 0;
  1641.   debug_registers_changed = 0;
  1642.   debug_registers_used = 0;
  1643.   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
  1644.     dr[i] = 0;
  1645. #ifdef __CYGWIN__
  1646.   cygwin_load_start = cygwin_load_end = 0;
  1647. #endif
  1648.   current_event.dwProcessId = pid;
  1649.   memset (&current_event, 0, sizeof (current_event));
  1650.   if (!target_is_pushed (ops))
  1651.     push_target (ops);
  1652.   disable_breakpoints_in_shlibs ();
  1653.   windows_clear_solib ();
  1654.   clear_proceed_status (0);
  1655.   init_wait_for_inferior ();

  1657.   inf = current_inferior ();
  1658.   inferior_appeared (inf, pid);
  1659.   inf->attach_flag = attaching;

  1661.   /* Make the new process the current inferior, so terminal handling
  1662.      can rely on it.  When attaching, we don't know about any thread
  1663.      id here, but that's OK --- nothing should be referencing the
  1664.      current thread until we report an event out of windows_wait.  */
  1665.   inferior_ptid = pid_to_ptid (pid);

  1667.   target_terminal_init ();
  1668.   target_terminal_inferior ();

  1670.   windows_initialization_done = 0;
  1671.   inf->control.stop_soon = STOP_QUIETLY;
  1672.   while (1)
  1673.     {
  1674.       stop_after_trap = 1;
  1675.       wait_for_inferior ();
  1676.       tp = inferior_thread ();
  1677.       if (tp->suspend.stop_signal != GDB_SIGNAL_TRAP)
  1678.         resume (0, tp->suspend.stop_signal);
  1679.       else
  1680.         break;
  1681.     }

  1683.   /* Now that the inferior has been started and all DLLs have been mapped,
  1684.      we can iterate over all DLLs and load them in.

  1686.      We avoid doing it any earlier because, on certain versions of Windows,
  1687.      LOAD_DLL_DEBUG_EVENTs are sometimes not complete.  In particular,
  1688.      we have seen on Windows 8.1 that the ntdll.dll load event does not
  1689.      include the DLL name, preventing us from creating an associated SO.
  1690.      A possible explanation is that ntdll.dll might be mapped before
  1691.      the SO info gets created by the Windows system -- ntdll.dll is
  1692.      the first DLL to be reported via LOAD_DLL_DEBUG_EVENT and other DLLs
  1693.      do not seem to suffer from that problem.

  1695.      Rather than try to work around this sort of issue, it is much
  1696.      simpler to just ignore DLL load/unload events during the startup
  1697.      phase, and then process them all in one batch now.  */
  1698.   windows_add_all_dlls ();

  1700.   windows_initialization_done = 1;
  1701.   inf->control.stop_soon = NO_STOP_QUIETLY;
  1702.   stop_after_trap = 0;
  1703.   return;
  1704. }

  1706. /* Try to set or remove a user privilege to the current process.  Return -1
  1707.    if that fails, the previous setting of that privilege otherwise.

  1709.    This code is copied from the Cygwin source code and rearranged to allow
  1710.    dynamically loading of the needed symbols from advapi32 which is only
  1711.    available on NT/2K/XP.  */
  1712. static int
  1713. ‌set_process_privilege (const char *privilege, BOOL enable)
  1714. {
  1715.   HANDLE token_hdl = NULL;
  1716.   LUID restore_priv;
  1717.   TOKEN_PRIVILEGES new_priv, orig_priv;
  1718.   int ret = -1;
  1719.   DWORD size;

  1721.   if (!OpenProcessToken (GetCurrentProcess (),
  1722.                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
  1723.                          &token_hdl))
  1724.     goto out;

  1726.   if (!LookupPrivilegeValueA (NULL, privilege, &restore_priv))
  1727.     goto out;

  1729.   new_priv.PrivilegeCount = 1;
  1730.   new_priv.Privileges[0].Luid = restore_priv;
  1731.   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;

  1733.   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
  1734.                               sizeof orig_priv, &orig_priv, &size))
  1735.     goto out;
  1736. #if 0
  1737.   /* Disabled, otherwise every `attach' in an unprivileged user session
  1738.      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
  1739.      windows_attach().  */
  1740.   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
  1741.      be enabled.  GetLastError () returns an correct error code, though.  */
  1742.   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
  1743.     goto out;
  1744. #endif

  1746.   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;

  1748. out:
  1749.   if (token_hdl)
  1750.     CloseHandle (token_hdl);

  1752.   return ret;
  1753. }

  1755. /* Attach to process PID, then initialize for debugging it.  */
  1756. static void
  1757. ‌windows_attach (struct target_ops *ops, const char *args, int from_tty)
  1758. {
  1759.   BOOL ok;
  1760.   DWORD pid;

  1762.   pid = parse_pid_to_attach (args);

  1764.   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
  1765.     {
  1766.       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
  1767.       printf_unfiltered ("This can cause attach to "
  1768.                          "fail on Windows NT/2K/XP\n");
  1769.     }

  1771.   windows_init_thread_list ();
  1772.   ok = DebugActiveProcess (pid);
  1773.   saw_create = 0;

  1775. #ifdef __CYGWIN__
  1776.   if (!ok)
  1777.     {
  1778.       /* Try fall back to Cygwin pid.  */
  1779.       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);

  1781.       if (pid > 0)
  1782.         ok = DebugActiveProcess (pid);
  1783.   }
  1784. #endif

  1786.   if (!ok)
  1787.     error (_("Can't attach to process."));

  1789.   DebugSetProcessKillOnExit (FALSE);

  1791.   if (from_tty)
  1792.     {
  1793.       char *exec_file = (char *) get_exec_file (0);

  1795.       if (exec_file)
  1796.         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
  1797.                            target_pid_to_str (pid_to_ptid (pid)));
  1798.       else
  1799.         printf_unfiltered ("Attaching to %s\n",
  1800.                            target_pid_to_str (pid_to_ptid (pid)));

  1802.       gdb_flush (gdb_stdout);
  1803.     }

  1805.   do_initial_windows_stuff (ops, pid, 1);
  1806.   target_terminal_ours ();
  1807. }

  1809. static void
  1810. ‌windows_detach (struct target_ops *ops, const char *args, int from_tty)
  1811. {
  1812.   int detached = 1;

  1814.   ptid_t ptid = {-1};
  1815.   windows_resume (ops, ptid, 0, GDB_SIGNAL_0);

  1817.   if (!DebugActiveProcessStop (current_event.dwProcessId))
  1818.     {
  1819.       error (_("Can't detach process %u (error %u)"),
  1820.              (unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
  1821.       detached = 0;
  1822.     }
  1823.   DebugSetProcessKillOnExit (FALSE);

  1825.   if (detached && from_tty)
  1826.     {
  1827.       char *exec_file = get_exec_file (0);
  1828.       if (exec_file == 0)
  1829.         exec_file = "";
  1830.       printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file,
  1831.                          (unsigned) current_event.dwProcessId);
  1832.       gdb_flush (gdb_stdout);
  1833.     }

  1835.   x86_cleanup_dregs ();
  1836.   inferior_ptid = null_ptid;
  1837.   detach_inferior (current_event.dwProcessId);

  1839.   inf_child_maybe_unpush_target (ops);
  1840. }

  1842. /* Try to determine the executable filename.

  1844.    EXE_NAME_RET is a pointer to a buffer whose size is EXE_NAME_MAX_LEN.

  1846.    Upon success, the filename is stored inside EXE_NAME_RET, and
  1847.    this function returns nonzero.

  1849.    Otherwise, this function returns zero and the contents of
  1850.    EXE_NAME_RET is undefined.  */

  1852. static int
  1853. ‌windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
  1854. {
  1855.   DWORD len;
  1856.   HMODULE dh_buf;
  1857.   DWORD cbNeeded;

  1859.   cbNeeded = 0;
  1860.   if (!EnumProcessModules (current_process_handle, &dh_buf,
  1861.                            sizeof (HMODULE), &cbNeeded) || !cbNeeded)
  1862.     return 0;

  1864.   /* We know the executable is always first in the list of modules,
  1865.      which we just fetched.  So no need to fetch more.  */

  1867. #ifdef __CYGWIN__
  1868.   {
  1869.     /* Cygwin prefers that the path be in /x/y/z format, so extract
  1870.        the filename into a temporary buffer first, and then convert it
  1871.        to POSIX format into the destination buffer.  */
  1872.     cygwin_buf_t *pathbuf = alloca (exe_name_max_len * sizeof (cygwin_buf_t));

  1874.     len = GetModuleFileNameEx (current_process_handle,
  1875.                                dh_buf, pathbuf, exe_name_max_len);
  1876.     if (len == 0)
  1877.       error (_("Error getting executable filename: %u."),
  1878.              (unsigned) GetLastError ());
  1879.     if (cygwin_conv_path (CCP_WIN_W_TO_POSIX, pathbuf, exe_name_ret,
  1880.                           exe_name_max_len) < 0)
  1881.       error (_("Error converting executable filename to POSIX: %d."), errno);
  1882.   }
  1883. #else
  1884.   len = GetModuleFileNameEx (current_process_handle,
  1885.                              dh_buf, exe_name_ret, exe_name_max_len);
  1886.   if (len == 0)
  1887.     error (_("Error getting executable filename: %u."),
  1888.            (unsigned) GetLastError ());
  1889. #endif

  1891.     return 1;        /* success */
  1892. }

  1894. /* The pid_to_exec_file target_ops method for this platform.  */

  1896. static char *
  1897. ‌windows_pid_to_exec_file (struct target_ops *self, int pid)
  1898. {
  1899.   static char path[__PMAX];
  1900. #ifdef __CYGWIN__
  1901.   /* Try to find exe name as symlink target of /proc/<pid>/exe.  */
  1902.   int nchars;
  1903.   char procexe[sizeof ("/proc/4294967295/exe")];

  1905.   xsnprintf (procexe, sizeof (procexe), "/proc/%u/exe", pid);
  1906.   nchars = readlink (procexe, path, sizeof(path));
  1907.   if (nchars > 0 && nchars < sizeof (path))
  1908.     {
  1909.       path[nchars] = '\0';        /* Got it */
  1910.       return path;
  1911.     }
  1912. #endif

  1914.   /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
  1915.      of gdb, or we're trying to debug a non-Cygwin windows executable.  */
  1916.   if (!windows_get_exec_module_filename (path, sizeof (path)))
  1917.     path[0] = '\0';

  1919.   return path;
  1920. }

  1922. /* Print status information about what we're accessing.  */

  1924. static void
  1925. ‌windows_files_info (struct target_ops *ignore)
  1926. {
  1927.   struct inferior *inf = current_inferior ();

  1929.   printf_unfiltered ("\tUsing the running image of %s %s.\n",
  1930.                      inf->attach_flag ? "attached" : "child",
  1931.                      target_pid_to_str (inferior_ptid));
  1932. }

  1934. /* Modify CreateProcess parameters for use of a new separate console.
  1935.    Parameters are:
  1936.    *FLAGS: DWORD parameter for general process creation flags.
  1937.    *SI: STARTUPINFO structure, for which the console window size and
  1938.    console buffer size is filled in if GDB is running in a console.
  1939.    to create the new console.
  1940.    The size of the used font is not available on all versions of
  1941.    Windows OS.  Furthermore, the current font might not be the default
  1942.    font, but this is still better than before.
  1943.    If the windows and buffer sizes are computed,
  1944.    SI->DWFLAGS is changed so that this information is used
  1945.    by CreateProcess function.  */

  1947. static void
  1948. ‌windows_set_console_info (STARTUPINFO *si, DWORD *flags)
  1949. {
  1950.   HANDLE hconsole = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
  1951.                                 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);

  1953.   if (hconsole != INVALID_HANDLE_VALUE)
  1954.     {
  1955.       CONSOLE_SCREEN_BUFFER_INFO sbinfo;
  1956.       COORD font_size;
  1957.       CONSOLE_FONT_INFO cfi;

  1959.       GetCurrentConsoleFont (hconsole, FALSE, &cfi);
  1960.       font_size = GetConsoleFontSize (hconsole, cfi.nFont);
  1961.       GetConsoleScreenBufferInfo(hconsole, &sbinfo);
  1962.       si->dwXSize = sbinfo.srWindow.Right - sbinfo.srWindow.Left + 1;
  1963.       si->dwYSize = sbinfo.srWindow.Bottom - sbinfo.srWindow.Top + 1;
  1964.       if (font_size.X)
  1965.         si->dwXSize *= font_size.X;
  1966.       else
  1967.         si->dwXSize *= 8;
  1968.       if (font_size.Y)
  1969.         si->dwYSize *= font_size.Y;
  1970.       else
  1971.         si->dwYSize *= 12;
  1972.       si->dwXCountChars = sbinfo.dwSize.X;
  1973.       si->dwYCountChars = sbinfo.dwSize.Y;
  1974.       si->dwFlags |= STARTF_USESIZE | STARTF_USECOUNTCHARS;
  1975.     }
  1976.   *flags |= CREATE_NEW_CONSOLE;
  1977. }

  1979. #ifndef __CYGWIN__
  1980. /* Function called by qsort to sort environment strings.  */

  1982. static int
  1983. ‌envvar_cmp (const void *a, const void *b)
  1984. {
  1985.   const char **p = (const char **) a;
  1986.   const char **q = (const char **) b;
  1987.   return strcasecmp (*p, *q);
  1988. }
  1989. #endif

  1991. #ifdef __CYGWIN__
  1992. static void
  1993. ‌clear_win32_environment (char **env)
  1994. {
  1995.   int i;
  1996.   size_t len;
  1997.   wchar_t *copy = NULL, *equalpos;

  1999.   for (i = 0; env[i] && *env[i]; i++)
  2000.     {
  2001.       len = mbstowcs (NULL, env[i], 0) + 1;
  2002.       copy = (wchar_t *) xrealloc (copy, len * sizeof (wchar_t));
  2003.       mbstowcs (copy, env[i], len);
  2004.       equalpos = wcschr (copy, L'=');
  2005.       if (equalpos)
  2006.         *equalpos = L'\0';
  2007.       SetEnvironmentVariableW (copy, NULL);
  2008.     }
  2009.   xfree (copy);
  2010. }
  2011. #endif

  2013. /* Start an inferior windows child process and sets inferior_ptid to its pid.
  2014.    EXEC_FILE is the file to run.
  2015.    ALLARGS is a string containing the arguments to the program.
  2016.    ENV is the environment vector to pass.  Errors reported with error().  */

  2018. static void
  2019. ‌windows_create_inferior (struct target_ops *ops, char *exec_file,
  2020.                        char *allargs, char **in_env, int from_tty)
  2021. {
  2022.   STARTUPINFO si;
  2023. #ifdef __CYGWIN__
  2024.   cygwin_buf_t real_path[__PMAX];
  2025.   cygwin_buf_t shell[__PMAX]; /* Path to shell */
  2026.   const char *sh;
  2027.   cygwin_buf_t *toexec;
  2028.   cygwin_buf_t *cygallargs;
  2029.   cygwin_buf_t *args;
  2030.   char **old_env = NULL;
  2031.   PWCHAR w32_env;
  2032.   size_t len;
  2033.   int tty;
  2034.   int ostdin, ostdout, ostderr;
  2035. #else
  2036.   char real_path[__PMAX];
  2037.   char shell[__PMAX]; /* Path to shell */
  2038.   char *toexec;
  2039.   char *args;
  2040.   size_t args_len;
  2041.   HANDLE tty;
  2042.   char *w32env;
  2043.   char *temp;
  2044.   size_t envlen;
  2045.   int i;
  2046.   size_t envsize;
  2047.   char **env;
  2048. #endif
  2049.   PROCESS_INFORMATION pi;
  2050.   BOOL ret;
  2051.   DWORD flags = 0;
  2052.   const char *inferior_io_terminal = get_inferior_io_terminal ();

  2054.   if (!exec_file)
  2055.     error (_("No executable specified, use `target exec'."));

  2057.   memset (&si, 0, sizeof (si));
  2058.   si.cb = sizeof (si);

  2060.   if (new_group)
  2061.     flags |= CREATE_NEW_PROCESS_GROUP;

  2063.   if (new_console)
  2064.     windows_set_console_info (&si, &flags);

  2066. #ifdef __CYGWIN__
  2067.   if (!useshell)
  2068.     {
  2069.       flags |= DEBUG_ONLY_THIS_PROCESS;
  2070.       if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, exec_file, real_path,
  2071.                             __PMAX * sizeof (cygwin_buf_t)) < 0)
  2072.         error (_("Error starting executable: %d"), errno);
  2073.       toexec = real_path;
  2074. #ifdef __USEWIDE
  2075.       len = mbstowcs (NULL, allargs, 0) + 1;
  2076.       if (len == (size_t) -1)
  2077.         error (_("Error starting executable: %d"), errno);
  2078.       cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
  2079.       mbstowcs (cygallargs, allargs, len);
  2080. #else
  2081.       cygallargs = allargs;
  2082. #endif
  2083.     }
  2084.   else
  2085.     {
  2086.       sh = getenv ("SHELL");
  2087.       if (!sh)
  2088.         sh = "/bin/sh";
  2089.       if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0)
  2090.               error (_("Error starting executable via shell: %d"), errno);
  2091. #ifdef __USEWIDE
  2092.       len = sizeof (L" -c 'exec  '") + mbstowcs (NULL, exec_file, 0)
  2093.             + mbstowcs (NULL, allargs, 0) + 2;
  2094.       cygallargs = (wchar_t *) alloca (len * sizeof (wchar_t));
  2095.       swprintf (cygallargs, len, L" -c 'exec %s %s'", exec_file, allargs);
  2096. #else
  2097.       len = (sizeof (" -c 'exec  '") + strlen (exec_file)
  2098.              + strlen (allargs) + 2);
  2099.       cygallargs = (char *) alloca (len);
  2100.       xsnprintf (cygallargs, len, " -c 'exec %s %s'", exec_file, allargs);
  2101. #endif
  2102.       toexec = shell;
  2103.       flags |= DEBUG_PROCESS;
  2104.     }

  2106. #ifdef __USEWIDE
  2107.   args = (cygwin_buf_t *) alloca ((wcslen (toexec) + wcslen (cygallargs) + 2)
  2108.                                   * sizeof (wchar_t));
  2109.   wcscpy (args, toexec);
  2110.   wcscat (args, L" ");
  2111.   wcscat (args, cygallargs);
  2112. #else
  2113.   args = (cygwin_buf_t *) alloca (strlen (toexec) + strlen (cygallargs) + 2);
  2114.   strcpy (args, toexec);
  2115.   strcat (args, " ");
  2116.   strcat (args, cygallargs);
  2117. #endif

  2119. #ifdef CW_CVT_ENV_TO_WINENV
  2120.   /* First try to create a direct Win32 copy of the POSIX environment. */
  2121.   w32_env = (PWCHAR) cygwin_internal (CW_CVT_ENV_TO_WINENV, in_env);
  2122.   if (w32_env != (PWCHAR) -1)
  2123.     flags |= CREATE_UNICODE_ENVIRONMENT;
  2124.   else
  2125.     /* If that fails, fall back to old method tweaking GDB's environment. */
  2126. #endif
  2127.     {
  2128.       /* Reset all Win32 environment variables to avoid leftover on next run. */
  2129.       clear_win32_environment (environ);
  2130.       /* Prepare the environment vars for CreateProcess.  */
  2131.       old_env = environ;
  2132.       environ = in_env;
  2133.       cygwin_internal (CW_SYNC_WINENV);
  2134.       w32_env = NULL;
  2135.     }

  2137.   if (!inferior_io_terminal)
  2138.     tty = ostdin = ostdout = ostderr = -1;
  2139.   else
  2140.     {
  2141.       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
  2142.       if (tty < 0)
  2143.         {
  2144.           print_sys_errmsg (inferior_io_terminal, errno);
  2145.           ostdin = ostdout = ostderr = -1;
  2146.         }
  2147.       else
  2148.         {
  2149.           ostdin = dup (0);
  2150.           ostdout = dup (1);
  2151.           ostderr = dup (2);
  2152.           dup2 (tty, 0);
  2153.           dup2 (tty, 1);
  2154.           dup2 (tty, 2);
  2155.         }
  2156.     }

  2158.   windows_init_thread_list ();
  2159.   ret = CreateProcess (0,
  2160.                        args,        /* command line */
  2161.                        NULL,        /* Security */
  2162.                        NULL,        /* thread */
  2163.                        TRUE,        /* inherit handles */
  2164.                        flags,        /* start flags */
  2165.                        w32_env,        /* environment */
  2166.                        NULL,        /* current directory */
  2167.                        &si,
  2168.                        &pi);
  2169.   if (w32_env)
  2170.     /* Just free the Win32 environment, if it could be created. */
  2171.     free (w32_env);
  2172.   else
  2173.     {
  2174.       /* Reset all environment variables to avoid leftover on next run. */
  2175.       clear_win32_environment (in_env);
  2176.       /* Restore normal GDB environment variables.  */
  2177.       environ = old_env;
  2178.       cygwin_internal (CW_SYNC_WINENV);
  2179.     }

  2181.   if (tty >= 0)
  2182.     {
  2183.       close (tty);
  2184.       dup2 (ostdin, 0);
  2185.       dup2 (ostdout, 1);
  2186.       dup2 (ostderr, 2);
  2187.       close (ostdin);
  2188.       close (ostdout);
  2189.       close (ostderr);
  2190.     }
  2191. #else
  2192.   toexec = exec_file;
  2193.   /* Build the command line, a space-separated list of tokens where
  2194.      the first token is the name of the module to be executed.
  2195.      To avoid ambiguities introduced by spaces in the module name,
  2196.      we quote it.  */
  2197.   args_len = strlen (toexec) + 2 /* quotes */ + strlen (allargs) + 2;
  2198.   args = alloca (args_len);
  2199.   xsnprintf (args, args_len, "\"%s\" %s", toexec, allargs);

  2201.   flags |= DEBUG_ONLY_THIS_PROCESS;

  2203.   if (!inferior_io_terminal)
  2204.     tty = INVALID_HANDLE_VALUE;
  2205.   else
  2206.     {
  2207.       SECURITY_ATTRIBUTES sa;
  2208.       sa.nLength = sizeof(sa);
  2209.       sa.lpSecurityDescriptor = 0;
  2210.       sa.bInheritHandle = TRUE;
  2211.       tty = CreateFileA (inferior_io_terminal, GENERIC_READ | GENERIC_WRITE,
  2212.                          0, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
  2213.       if (tty == INVALID_HANDLE_VALUE)
  2214.         warning (_("Warning: Failed to open TTY %s, error %#x."),
  2215.                  inferior_io_terminal, (unsigned) GetLastError ());
  2216.       else
  2217.         {
  2218.           si.hStdInput = tty;
  2219.           si.hStdOutput = tty;
  2220.           si.hStdError = tty;
  2221.           si.dwFlags |= STARTF_USESTDHANDLES;
  2222.         }
  2223.     }

  2225.   /* CreateProcess takes the environment list as a null terminated set of
  2226.      strings (i.e. two nulls terminate the list).  */

  2228.   /* Get total size for env strings.  */
  2229.   for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
  2230.     envlen += strlen (in_env[i]) + 1;

  2232.   envsize = sizeof (in_env[0]) * (i + 1);
  2233.   env = (char **) alloca (envsize);
  2234.   memcpy (env, in_env, envsize);
  2235.   /* Windows programs expect the environment block to be sorted.  */
  2236.   qsort (env, i, sizeof (char *), envvar_cmp);

  2238.   w32env = alloca (envlen + 1);

  2240.   /* Copy env strings into new buffer.  */
  2241.   for (temp = w32env, i = 0; env[i] && *env[i]; i++)
  2242.     {
  2243.       strcpy (temp, env[i]);
  2244.       temp += strlen (temp) + 1;
  2245.     }

  2247.   /* Final nil string to terminate new env.  */
  2248.   *temp = 0;

  2250.   windows_init_thread_list ();
  2251.   ret = CreateProcessA (0,
  2252.                         args,        /* command line */
  2253.                         NULL,        /* Security */
  2254.                         NULL,        /* thread */
  2255.                         TRUE,        /* inherit handles */
  2256.                         flags,        /* start flags */
  2257.                         w32env,        /* environment */
  2258.                         NULL,        /* current directory */
  2259.                         &si,
  2260.                         &pi);
  2261.   if (tty != INVALID_HANDLE_VALUE)
  2262.     CloseHandle (tty);
  2263. #endif

  2265.   if (!ret)
  2266.     error (_("Error creating process %s, (error %u)."),
  2267.            exec_file, (unsigned) GetLastError ());

  2269.   CloseHandle (pi.hThread);
  2270.   CloseHandle (pi.hProcess);

  2272.   if (useshell && shell[0] != '\0')
  2273.     saw_create = -1;
  2274.   else
  2275.     saw_create = 0;

  2277.   do_initial_windows_stuff (ops, pi.dwProcessId, 0);

  2279.   /* windows_continue (DBG_CONTINUE, -1, 0); */
  2280. }

  2282. static void
  2283. ‌windows_mourn_inferior (struct target_ops *ops)
  2284. {
  2285.   (void) windows_continue (DBG_CONTINUE, -1, 0);
  2286.   x86_cleanup_dregs();
  2287.   if (open_process_used)
  2288.     {
  2289.       CHECK (CloseHandle (current_process_handle));
  2290.       open_process_used = 0;
  2291.     }
  2292.   inf_child_mourn_inferior (ops);
  2293. }

  2295. /* Send a SIGINT to the process group.  This acts just like the user typed a
  2296.    ^C on the controlling terminal.  */

  2298. static void
  2299. ‌windows_stop (struct target_ops *self, ptid_t ptid)
  2300. {
  2301.   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
  2302.   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
  2303.   registers_changed ();                /* refresh register state */
  2304. }

  2306. /* Helper for windows_xfer_partial that handles memory transfers.
  2307.    Arguments are like target_xfer_partial.  */

  2309. static enum target_xfer_status
  2310. ‌windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
  2311.                      ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
  2312. {
  2313.   SIZE_T done = 0;
  2314.   BOOL success;
  2315.   DWORD lasterror = 0;

  2317.   if (writebuf != NULL)
  2318.     {
  2319.       DEBUG_MEM (("gdb: write target memory, %s bytes at %s\n",
  2320.                   pulongest (len), core_addr_to_string (memaddr)));
  2321.       success = WriteProcessMemory (current_process_handle,
  2322.                                     (LPVOID) (uintptr_t) memaddr, writebuf,
  2323.                                     len, &done);
  2324.       if (!success)
  2325.         lasterror = GetLastError ();
  2326.       FlushInstructionCache (current_process_handle,
  2327.                              (LPCVOID) (uintptr_t) memaddr, len);
  2328.     }
  2329.   else
  2330.     {
  2331.       DEBUG_MEM (("gdb: read target memory, %s bytes at %s\n",
  2332.                   pulongest (len), core_addr_to_string (memaddr)));
  2333.       success = ReadProcessMemory (current_process_handle,
  2334.                                    (LPCVOID) (uintptr_t) memaddr, readbuf,
  2335.                                    len, &done);
  2336.       if (!success)
  2337.         lasterror = GetLastError ();
  2338.     }
  2339.   *xfered_len = (ULONGEST) done;
  2340.   if (!success && lasterror == ERROR_PARTIAL_COPY && done > 0)
  2341.     return TARGET_XFER_OK;
  2342.   else
  2343.     return success ? TARGET_XFER_OK : TARGET_XFER_E_IO;
  2344. }

  2346. static void
  2347. ‌windows_kill_inferior (struct target_ops *ops)
  2348. {
  2349.   CHECK (TerminateProcess (current_process_handle, 0));

  2351.   for (;;)
  2352.     {
  2353.       if (!windows_continue (DBG_CONTINUE, -1, 1))
  2354.         break;
  2355.       if (!WaitForDebugEvent (&current_event, INFINITE))
  2356.         break;
  2357.       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
  2358.         break;
  2359.     }

  2361.   target_mourn_inferior ();        /* Or just windows_mourn_inferior?  */
  2362. }

  2364. static void
  2365. ‌windows_close (struct target_ops *self)
  2366. {
  2367.   DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
  2368.                 ptid_get_pid (inferior_ptid)));
  2369. }

  2371. /* Convert pid to printable format.  */
  2372. static char *
  2373. ‌windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
  2374. {
  2375.   static char buf[80];

  2377.   if (ptid_get_tid (ptid) != 0)
  2378.     {
  2379.       snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
  2380.                 ptid_get_pid (ptid), ptid_get_tid (ptid));
  2381.       return buf;
  2382.     }

  2384.   return normal_pid_to_str (ptid);
  2385. }

  2387. static enum target_xfer_status
  2388. ‌windows_xfer_shared_libraries (struct target_ops *ops,
  2389.                                enum target_object object, const char *annex,
  2390.                                gdb_byte *readbuf, const gdb_byte *writebuf,
  2391.                                ULONGEST offset, ULONGEST len,
  2392.                                ULONGEST *xfered_len)
  2393. {
  2394.   struct obstack obstack;
  2395.   const char *buf;
  2396.   LONGEST len_avail;
  2397.   struct so_list *so;

  2399.   if (writebuf)
  2400.     return TARGET_XFER_E_IO;

  2402.   obstack_init (&obstack);
  2403.   obstack_grow_str (&obstack, "<library-list>\n");
  2404.   for (so = solib_start.next; so; so = so->next)
  2405.     windows_xfer_shared_library (so->so_name, (CORE_ADDR)
  2406.                                  (uintptr_t) so->lm_info->load_addr,
  2407.                                  target_gdbarch (), &obstack);
  2408.   obstack_grow_str0 (&obstack, "</library-list>\n");

  2410.   buf = obstack_finish (&obstack);
  2411.   len_avail = strlen (buf);
  2412.   if (offset >= len_avail)
  2413.     len= 0;
  2414.   else
  2415.     {
  2416.       if (len > len_avail - offset)
  2417.         len = len_avail - offset;
  2418.       memcpy (readbuf, buf + offset, len);
  2419.     }

  2421.   obstack_free (&obstack, NULL);
  2422.   *xfered_len = (ULONGEST) len;
  2423.   return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
  2424. }

  2426. static enum target_xfer_status
  2427. ‌windows_xfer_partial (struct target_ops *ops, enum target_object object,
  2428.                       const char *annex, gdb_byte *readbuf,
  2429.                       const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  2430.                       ULONGEST *xfered_len)
  2431. {
  2432.   switch (object)
  2433.     {
  2434.     case TARGET_OBJECT_MEMORY:
  2435.       return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len);

  2437.     case TARGET_OBJECT_LIBRARIES:
  2438.       return windows_xfer_shared_libraries (ops, object, annex, readbuf,
  2439.                                             writebuf, offset, len, xfered_len);

  2441.     default:
  2442.       return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
  2443.                                             readbuf, writebuf, offset, len,
  2444.                                             xfered_len);
  2445.     }
  2446. }

  2448. /* Provide thread local base, i.e. Thread Information Block address.
  2449.    Returns 1 if ptid is found and sets *ADDR to thread_local_base.  */

  2451. static int
  2452. ‌windows_get_tib_address (struct target_ops *self,
  2453.                          ptid_t ptid, CORE_ADDR *addr)
  2454. {
  2455.   thread_info *th;

  2457.   th = thread_rec (ptid_get_tid (ptid), 0);
  2458.   if (th == NULL)
  2459.     return 0;

  2461.   if (addr != NULL)
  2462.     *addr = th->thread_local_base;

  2464.   return 1;
  2465. }

  2467. static ptid_t
  2468. ‌windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
  2469. {
  2470.   return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
  2471. }

  2473. static struct target_ops *
  2474. ‌windows_target (void)
  2475. {
  2476.   struct target_ops *t = inf_child_target ();

  2478.   t->to_close = windows_close;
  2479.   t->to_attach = windows_attach;
  2480.   t->to_attach_no_wait = 1;
  2481.   t->to_detach = windows_detach;
  2482.   t->to_resume = windows_resume;
  2483.   t->to_wait = windows_wait;
  2484.   t->to_fetch_registers = windows_fetch_inferior_registers;
  2485.   t->to_store_registers = windows_store_inferior_registers;
  2486.   t->to_xfer_partial = windows_xfer_partial;
  2487.   t->to_files_info = windows_files_info;
  2488.   t->to_kill = windows_kill_inferior;
  2489.   t->to_create_inferior = windows_create_inferior;
  2490.   t->to_mourn_inferior = windows_mourn_inferior;
  2491.   t->to_thread_alive = windows_thread_alive;
  2492.   t->to_pid_to_str = windows_pid_to_str;
  2493.   t->to_stop = windows_stop;
  2494.   t->to_pid_to_exec_file = windows_pid_to_exec_file;
  2495.   t->to_get_ada_task_ptid = windows_get_ada_task_ptid;
  2496.   t->to_get_tib_address = windows_get_tib_address;

  2498.   return t;
  2499. }

  2501. static void
  2502. ‌set_windows_aliases (char *argv0)
  2503. {
  2504.   add_info_alias ("dll", "sharedlibrary", 1);
  2505. }

  2507. /* -Wmissing-prototypes */
  2508. extern initialize_file_ftype _initialize_windows_nat;

  2510. void
  2511. ‌_initialize_windows_nat (void)
  2512. {
  2513.   struct target_ops *t;

  2515.   t = windows_target ();

  2517.   x86_use_watchpoints (t);

  2519.   x86_dr_low.set_control = cygwin_set_dr7;
  2520.   x86_dr_low.set_addr = cygwin_set_dr;
  2521.   x86_dr_low.get_addr = cygwin_get_dr;
  2522.   x86_dr_low.get_status = cygwin_get_dr6;
  2523.   x86_dr_low.get_control = cygwin_get_dr7;

  2525.   /* x86_dr_low.debug_register_length field is set by
  2526.      calling x86_set_debug_register_length function
  2527.      in processor windows specific native file.  */

  2529.   add_target (t);

  2531. #ifdef __CYGWIN__
  2532.   cygwin_internal (CW_SET_DOS_FILE_WARNING, 0);
  2533. #endif

  2535. #ifdef __CYGWIN__
  2536.   add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
  2537. Set use of shell to start subprocess."), _("\
  2538. Show use of shell to start subprocess."), NULL,
  2539.                            NULL,
  2540.                            NULL, /* FIXME: i18n: */
  2541.                            &setlist, &showlist);

  2543.   add_setshow_boolean_cmd ("cygwin-exceptions", class_support,
  2544.                            &cygwin_exceptions, _("\
  2545. Break when an exception is detected in the Cygwin DLL itself."), _("\
  2546. Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
  2547.                            NULL,
  2548.                            NULL, /* FIXME: i18n: */
  2549.                            &setlist, &showlist);
  2550. #endif

  2552.   add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
  2553. Set creation of new console when creating child process."), _("\
  2554. Show creation of new console when creating child process."), NULL,
  2555.                            NULL,
  2556.                            NULL, /* FIXME: i18n: */
  2557.                            &setlist, &showlist);

  2559.   add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
  2560. Set creation of new group when creating child process."), _("\
  2561. Show creation of new group when creating child process."), NULL,
  2562.                            NULL,
  2563.                            NULL, /* FIXME: i18n: */
  2564.                            &setlist, &showlist);

  2566.   add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
  2567. Set whether to display execution in child process."), _("\
  2568. Show whether to display execution in child process."), NULL,
  2569.                            NULL,
  2570.                            NULL, /* FIXME: i18n: */
  2571.                            &setlist, &showlist);

  2573.   add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
  2574. Set whether to display kernel events in child process."), _("\
  2575. Show whether to display kernel events in child process."), NULL,
  2576.                            NULL,
  2577.                            NULL, /* FIXME: i18n: */
  2578.                            &setlist, &showlist);

  2580.   add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
  2581. Set whether to display memory accesses in child process."), _("\
  2582. Show whether to display memory accesses in child process."), NULL,
  2583.                            NULL,
  2584.                            NULL, /* FIXME: i18n: */
  2585.                            &setlist, &showlist);

  2587.   add_setshow_boolean_cmd ("debugexceptions", class_support,
  2588.                            &debug_exceptions, _("\
  2589. Set whether to display kernel exceptions in child process."), _("\
  2590. Show whether to display kernel exceptions in child process."), NULL,
  2591.                            NULL,
  2592.                            NULL, /* FIXME: i18n: */
  2593.                            &setlist, &showlist);

  2595.   init_w32_command_list ();

  2597.   add_cmd ("selector", class_info, display_selectors,
  2598.            _("Display selectors infos."),
  2599.            &info_w32_cmdlist);
  2600.   deprecated_init_ui_hook = set_windows_aliases;
  2601. }

  2603. /* Hardware watchpoint support, adapted from go32-nat.c code.  */

  2605. /* Pass the address ADDR to the inferior in the I'th debug register.
  2606.    Here we just store the address in dr array, the registers will be
  2607.    actually set up when windows_continue is called.  */
  2608. static void
  2609. ‌cygwin_set_dr (int i, CORE_ADDR addr)
  2610. {
  2611.   if (i < 0 || i > 3)
  2612.     internal_error (__FILE__, __LINE__,
  2613.                     _("Invalid register %d in cygwin_set_dr.\n"), i);
  2614.   dr[i] = addr;
  2615.   debug_registers_changed = 1;
  2616.   debug_registers_used = 1;
  2617. }

  2619. /* Pass the value VAL to the inferior in the DR7 debug control
  2620.    register.  Here we just store the address in D_REGS, the watchpoint
  2621.    will be actually set up in windows_wait.  */
  2622. static void
  2623. ‌cygwin_set_dr7 (unsigned long val)
  2624. {
  2625.   dr[7] = (CORE_ADDR) val;
  2626.   debug_registers_changed = 1;
  2627.   debug_registers_used = 1;
  2628. }

  2630. /* Get the value of debug register I from the inferior.  */

  2632. static CORE_ADDR
  2633. ‌cygwin_get_dr (int i)
  2634. {
  2635.   return dr[i];
  2636. }

  2638. /* Get the value of the DR6 debug status register from the inferior.
  2639.    Here we just return the value stored in dr[6]
  2640.    by the last call to thread_rec for current_event.dwThreadId id.  */
  2641. static unsigned long
  2642. ‌cygwin_get_dr6 (void)
  2643. {
  2644.   return (unsigned long) dr[6];
  2645. }

  2647. /* Get the value of the DR7 debug status register from the inferior.
  2648.    Here we just return the value stored in dr[7] by the last call to
  2649.    thread_rec for current_event.dwThreadId id.  */

  2651. static unsigned long
  2652. ‌cygwin_get_dr7 (void)
  2653. {
  2654.   return (unsigned long) dr[7];
  2655. }

  2657. /* Determine if the thread referenced by "ptid" is alive
  2658.    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
  2659.    it means that the thread has died.  Otherwise it is assumed to be alive.  */
  2660. static int
  2661. ‌windows_thread_alive (struct target_ops *ops, ptid_t ptid)
  2662. {
  2663.   int tid;

  2665.   gdb_assert (ptid_get_tid (ptid) != 0);
  2666.   tid = ptid_get_tid (ptid);

  2668.   return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0
  2669.     ? FALSE : TRUE;
  2670. }

  2672. /* -Wmissing-prototypes */
  2673. extern initialize_file_ftype _initialize_check_for_gdb_ini;

  2675. void
  2676. ‌_initialize_check_for_gdb_ini (void)
  2677. {
  2678.   char *homedir;
  2679.   if (inhibit_gdbinit)
  2680.     return;

  2682.   homedir = getenv ("HOME");
  2683.   if (homedir)
  2684.     {
  2685.       char *p;
  2686.       char *oldini = (char *) alloca (strlen (homedir) +
  2687.                                       sizeof ("/gdb.ini"));
  2688.       strcpy (oldini, homedir);
  2689.       p = strchr (oldini, '\0');
  2690.       if (p > oldini && !IS_DIR_SEPARATOR (p[-1]))
  2691.         *p++ = '/';
  2692.       strcpy (p, "gdb.ini");
  2693.       if (access (oldini, 0) == 0)
  2694.         {
  2695.           int len = strlen (oldini);
  2696.           char *newini = alloca (len + 1);

  2698.           xsnprintf (newini, len + 1, "%.*s.gdbinit",
  2699.                      (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
  2700.           warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
  2701.         }
  2702.     }
  2703. }

  2705. /* Define dummy functions which always return error for the rare cases where
  2706.    these functions could not be found.  */
  2707. static BOOL WINAPI
  2708. ‌bad_DebugActiveProcessStop (DWORD w)
  2709. {
  2710.   return FALSE;
  2711. }
  2712. static BOOL WINAPI
  2713. ‌bad_DebugBreakProcess (HANDLE w)
  2714. {
  2715.   return FALSE;
  2716. }
  2717. static BOOL WINAPI
  2718. ‌bad_DebugSetProcessKillOnExit (BOOL w)
  2719. {
  2720.   return FALSE;
  2721. }
  2722. static BOOL WINAPI
  2723. ‌bad_EnumProcessModules (HANDLE w, HMODULE *x, DWORD y, LPDWORD z)
  2724. {
  2725.   return FALSE;
  2726. }

  2728. #ifdef __USEWIDE
  2729. static DWORD WINAPI
  2730. ‌bad_GetModuleFileNameExW (HANDLE w, HMODULE x, LPWSTR y, DWORD z)
  2731. {
  2732.   return 0;
  2733. }
  2734. #else
  2735. static DWORD WINAPI
  2736. ‌bad_GetModuleFileNameExA (HANDLE w, HMODULE x, LPSTR y, DWORD z)
  2737. {
  2738.   return 0;
  2739. }
  2740. #endif

  2742. static BOOL WINAPI
  2743. ‌bad_GetModuleInformation (HANDLE w, HMODULE x, LPMODULEINFO y, DWORD z)
  2744. {
  2745.   return FALSE;
  2746. }

  2748. static BOOL WINAPI
  2749. ‌bad_OpenProcessToken (HANDLE w, DWORD x, PHANDLE y)
  2750. {
  2751.   return FALSE;
  2752. }

  2754. static BOOL WINAPI
  2755. ‌bad_GetCurrentConsoleFont (HANDLE w, BOOL bMaxWindow, CONSOLE_FONT_INFO *f)
  2756. {
  2757.   f->nFont = 0;
  2758.   return 1;
  2759. }
  2760. static COORD WINAPI
  2761. ‌bad_GetConsoleFontSize (HANDLE w, DWORD nFont)
  2762. {
  2763.   COORD size;
  2764.   size.X = 8;
  2765.   size.Y = 12;
  2766.   return size;
  2767. }

  2769. /* -Wmissing-prototypes */
  2770. extern initialize_file_ftype _initialize_loadable;

  2772. /* Load any functions which may not be available in ancient versions
  2773.    of Windows.  */

  2775. void
  2776. ‌_initialize_loadable (void)
  2777. {
  2778.   HMODULE hm = NULL;

  2780.   hm = LoadLibrary ("kernel32.dll");
  2781.   if (hm)
  2782.     {
  2783.       DebugActiveProcessStop = (void *)
  2784.         GetProcAddress (hm, "DebugActiveProcessStop");
  2785.       DebugBreakProcess = (void *)
  2786.         GetProcAddress (hm, "DebugBreakProcess");
  2787.       DebugSetProcessKillOnExit = (void *)
  2788.         GetProcAddress (hm, "DebugSetProcessKillOnExit");
  2789.       GetConsoleFontSize = (void *)
  2790.         GetProcAddress (hm, "GetConsoleFontSize");
  2791.       GetCurrentConsoleFont = (void *)
  2792.         GetProcAddress (hm, "GetCurrentConsoleFont");
  2793.     }

  2795.   /* Set variables to dummy versions of these processes if the function
  2796.      wasn't found in kernel32.dll.  */
  2797.   if (!DebugBreakProcess)
  2798.     DebugBreakProcess = bad_DebugBreakProcess;
  2799.   if (!DebugActiveProcessStop || !DebugSetProcessKillOnExit)
  2800.     {
  2801.       DebugActiveProcessStop = bad_DebugActiveProcessStop;
  2802.       DebugSetProcessKillOnExit = bad_DebugSetProcessKillOnExit;
  2803.     }
  2804.   if (!GetConsoleFontSize)
  2805.     GetConsoleFontSize = bad_GetConsoleFontSize;
  2806.   if (!GetCurrentConsoleFont)
  2807.     GetCurrentConsoleFont = bad_GetCurrentConsoleFont;

  2809.   /* Load optional functions used for retrieving filename information
  2810.      associated with the currently debugged process or its dlls.  */
  2811.   hm = LoadLibrary ("psapi.dll");
  2812.   if (hm)
  2813.     {
  2814.       EnumProcessModules = (void *)
  2815.         GetProcAddress (hm, "EnumProcessModules");
  2816.       GetModuleInformation = (void *)
  2817.         GetProcAddress (hm, "GetModuleInformation");
  2818.       GetModuleFileNameEx = (void *)
  2819.         GetProcAddress (hm, GetModuleFileNameEx_name);
  2820.     }

  2822.   if (!EnumProcessModules || !GetModuleInformation || !GetModuleFileNameEx)
  2823.     {
  2824.       /* Set variables to dummy versions of these processes if the function
  2825.          wasn't found in psapi.dll.  */
  2826.       EnumProcessModules = bad_EnumProcessModules;
  2827.       GetModuleInformation = bad_GetModuleInformation;
  2828.       GetModuleFileNameEx = bad_GetModuleFileNameEx;
  2829.       /* This will probably fail on Windows 9x/Me.  Let the user know
  2830.          that we're missing some functionality.  */
  2831.       warning(_("\
  2832. cannot automatically find executable file or library to read symbols.\n\
  2833. Use \"file\" or \"dll\" command to load executable/libraries directly."));
  2834.     }

  2836.   hm = LoadLibrary ("advapi32.dll");
  2837.   if (hm)
  2838.     {
  2839.       OpenProcessToken = (void *) GetProcAddress (hm, "OpenProcessToken");
  2840.       LookupPrivilegeValueA = (void *)
  2841.         GetProcAddress (hm, "LookupPrivilegeValueA");
  2842.       AdjustTokenPrivileges = (void *)
  2843.         GetProcAddress (hm, "AdjustTokenPrivileges");
  2844.       /* Only need to set one of these since if OpenProcessToken fails nothing
  2845.          else is needed.  */
  2846.       if (!OpenProcessToken || !LookupPrivilegeValueA
  2847.           || !AdjustTokenPrivileges)
  2848.         OpenProcessToken = bad_OpenProcessToken;
  2849.     }
  2850. }