gdb/nat/windows-nat.h

   1 /* Internal interfaces for the Windows code
   2    Copyright (C) 1995-2020 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifndef NAT_WINDOWS_NAT_H
  20 #define NAT_WINDOWS_NAT_H
  21
  22 #include <windows.h>
  23 #include <vector>
  24
  25 #include "target/waitstatus.h"
  26
  27 namespace windows_nat
  28 {
  29
  30 /* Thread information structure used to track extra information about
  31    each thread.  */
  32 struct windows_thread_info
  33 {
  34   windows_thread_info (DWORD tid_, HANDLE h_, CORE_ADDR tlb)
  35     : tid (tid_),
  36       h (h_),
  37       thread_local_base (tlb)
  38   {
  39   }
  40
  41   ~windows_thread_info ();
  42
  43   DISABLE_COPY_AND_ASSIGN (windows_thread_info);
  44
  45   /* Ensure that this thread has been suspended.  */
  46   void suspend ();
  47
  48   /* Resume the thread if it has been suspended.  */
  49   void resume ();
  50
  51   /* The Win32 thread identifier.  */
  52   DWORD tid;
  53
  54   /* The handle to the thread.  */
  55   HANDLE h;
  56
  57   /* Thread Information Block address.  */
  58   CORE_ADDR thread_local_base;
  59
  60   /* This keeps track of whether SuspendThread was called on this
  61      thread.  -1 means there was a failure or that the thread was
  62      explicitly not suspended, 1 means it was called, and 0 means it
  63      was not.  */
  64   int suspended = 0;
  65
  66 #ifdef _WIN32_WCE
  67   /* The context as retrieved right after suspending the thread. */
  68   CONTEXT base_context {};
  69 #endif
  70
  71   /* The context of the thread, including any manipulations.  */
  72   union
  73   {
  74     CONTEXT context {};
  75 #ifdef __x86_64__
  76     WOW64_CONTEXT wow64_context;
  77 #endif
  78   };
  79
  80   /* Whether debug registers changed since we last set CONTEXT back to
  81      the thread.  */
  82   bool debug_registers_changed = false;
  83
  84   /* Nonzero if CONTEXT is invalidated and must be re-read from the
  85      inferior thread.  */
  86   bool reload_context = false;
  87
  88   /* True if this thread is currently stopped at a software
  89      breakpoint.  This is used to offset the PC when needed.  */
  90   bool stopped_at_software_breakpoint = false;
  91
  92   /* The name of the thread, allocated by xmalloc.  */
  93   gdb::unique_xmalloc_ptr<char> name;
  94 };
  95
  96
  97 /* Possible values to pass to 'thread_rec'.  */
  98 enum thread_disposition_type
  99 {
 100   /* Do not invalidate the thread's context, and do not suspend the
 101      thread.  */
 102   DONT_INVALIDATE_CONTEXT,
 103   /* Invalidate the context, but do not suspend the thread.  */
 104   DONT_SUSPEND,
 105   /* Invalidate the context and suspend the thread.  */
 106   INVALIDATE_CONTEXT
 107 };
 108
 109 /* Find a thread record given a thread id.  THREAD_DISPOSITION
 110    controls whether the thread is suspended, and whether the context
 111    is invalidated.
 112
 113    This function must be supplied by the embedding application.  */
 114 extern windows_thread_info *thread_rec (ptid_t ptid,
 115                                         thread_disposition_type disposition);
 116
 117 /* Currently executing process */
 118 extern HANDLE current_process_handle;
 119 extern DWORD current_process_id;
 120 extern DWORD main_thread_id;
 121 extern enum gdb_signal last_sig;
 122
 123 /* The current debug event from WaitForDebugEvent or from a pending
 124    stop.  */
 125 extern DEBUG_EVENT current_event;
 126
 127 /* The most recent event from WaitForDebugEvent.  Unlike
 128    current_event, this is guaranteed never to come from a pending
 129    stop.  This is important because only data from the most recent
 130    event from WaitForDebugEvent can be used when calling
 131    ContinueDebugEvent.  */
 132 extern DEBUG_EVENT last_wait_event;
 133
 134 /* Info on currently selected thread */
 135 extern windows_thread_info *current_windows_thread;
 136
 137 /* The ID of the thread for which we anticipate a stop event.
 138    Normally this is -1, meaning we'll accept an event in any
 139    thread.  */
 140 extern DWORD desired_stop_thread_id;
 141
 142 /* A single pending stop.  See "pending_stops" for more
 143    information.  */
 144 struct pending_stop
 145 {
 146   /* The thread id.  */
 147   DWORD thread_id;
 148
 149   /* The target waitstatus we computed.  */
 150   target_waitstatus status;
 151
 152   /* The event.  A few fields of this can be referenced after a stop,
 153      and it seemed simplest to store the entire event.  */
 154   DEBUG_EVENT event;
 155 };
 156
 157 /* A vector of pending stops.  Sometimes, Windows will report a stop
 158    on a thread that has been ostensibly suspended.  We believe what
 159    happens here is that two threads hit a breakpoint simultaneously,
 160    and the Windows kernel queues the stop events.  However, this can
 161    result in the strange effect of trying to single step thread A --
 162    leaving all other threads suspended -- and then seeing a stop in
 163    thread B.  To handle this scenario, we queue all such "pending"
 164    stops here, and then process them once the step has completed.  See
 165    PR gdb/22992.  */
 166 extern std::vector<pending_stop> pending_stops;
 167
 168 /* Contents of $_siginfo */
 169 extern EXCEPTION_RECORD siginfo_er;
 170
 171 /* Return the name of the DLL referenced by H at ADDRESS.  UNICODE
 172    determines what sort of string is read from the inferior.  Returns
 173    the name of the DLL, or NULL on error.  If a name is returned, it
 174    is stored in a static buffer which is valid until the next call to
 175    get_image_name.  */
 176 extern const char *get_image_name (HANDLE h, void *address, int unicode);
 177
 178 }
 179
 180 #endif