gdbserver/win32-low.h

   1 /* Internal interfaces for the Win32 specific target code for gdbserver.
   2    Copyright (C) 2007-2022 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 GDBSERVER_WIN32_LOW_H
  20 #define GDBSERVER_WIN32_LOW_H
  21
  22 #include <windows.h>
  23 #include "nat/windows-nat.h"
  24
  25 struct target_desc;
  26
  27 /* The inferior's target description.  This is a global because the
  28    Windows ports support neither bi-arch nor multi-process.  */
  29 extern const struct target_desc *win32_tdesc;
  30 #ifdef __x86_64__
  31 extern const struct target_desc *wow64_win32_tdesc;
  32 #endif
  33
  34 struct win32_target_ops
  35 {
  36   /* Architecture-specific setup.  */
  37   void (*arch_setup) (void);
  38
  39   /* The number of target registers.  */
  40   int (*num_regs) (void);
  41
  42   /* Perform initializations on startup.  */
  43   void (*initial_stuff) (void);
  44
  45   /* Fetch the context from the inferior.  */
  46   void (*get_thread_context) (windows_nat::windows_thread_info *th);
  47
  48   /* Called just before resuming the thread.  */
  49   void (*prepare_to_resume) (windows_nat::windows_thread_info *th);
  50
  51   /* Called when a thread was added.  */
  52   void (*thread_added) (windows_nat::windows_thread_info *th);
  53
  54   /* Fetch register from gdbserver regcache data.  */
  55   void (*fetch_inferior_register) (struct regcache *regcache,
  56                                    windows_nat::windows_thread_info *th,
  57                                    int r);
  58
  59   /* Store a new register value into the thread context of TH.  */
  60   void (*store_inferior_register) (struct regcache *regcache,
  61                                    windows_nat::windows_thread_info *th,
  62                                    int r);
  63
  64   void (*single_step) (windows_nat::windows_thread_info *th);
  65
  66   const unsigned char *breakpoint;
  67   int breakpoint_len;
  68
  69   /* Amount by which to decrement the PC after a breakpoint is
  70      hit.  */
  71   int decr_pc_after_break;
  72
  73   /* Get the PC register from REGCACHE.  */
  74   CORE_ADDR (*get_pc) (struct regcache *regcache);
  75   /* Set the PC register in REGCACHE.  */
  76   void (*set_pc) (struct regcache *regcache, CORE_ADDR newpc);
  77
  78   /* Breakpoint/Watchpoint related functions.  See target.h for comments.  */
  79   int (*supports_z_point_type) (char z_type);
  80   int (*insert_point) (enum raw_bkpt_type type, CORE_ADDR addr,
  81                        int size, struct raw_breakpoint *bp);
  82   int (*remove_point) (enum raw_bkpt_type type, CORE_ADDR addr,
  83                        int size, struct raw_breakpoint *bp);
  84   int (*stopped_by_watchpoint) (void);
  85   CORE_ADDR (*stopped_data_address) (void);
  86 };
  87
  88 extern struct win32_target_ops the_low_target;
  89
  90 /* Target ops definitions for a Win32 target.  */
  91
  92 class win32_process_target : public process_stratum_target
  93 {
  94 public:
  95
  96   int create_inferior (const char *program,
  97                        const std::vector<char *> &program_args) override;
  98
  99   int attach (unsigned long pid) override;
 100
 101   int kill (process_info *proc) override;
 102
 103   int detach (process_info *proc) override;
 104
 105   void mourn (process_info *proc) override;
 106
 107   void join (int pid) override;
 108
 109   bool thread_alive (ptid_t pid) override;
 110
 111   void resume (thread_resume *resume_info, size_t n) override;
 112
 113   ptid_t wait (ptid_t ptid, target_waitstatus *status,
 114                target_wait_flags options) override;
 115
 116   void fetch_registers (regcache *regcache, int regno) override;
 117
 118   void store_registers (regcache *regcache, int regno) override;
 119
 120   int read_memory (CORE_ADDR memaddr, unsigned char *myaddr,
 121                    int len) override;
 122
 123   int write_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
 124                     int len) override;
 125
 126   void request_interrupt () override;
 127
 128   bool supports_z_point_type (char z_type) override;
 129
 130   int insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
 131                     int size, raw_breakpoint *bp) override;
 132
 133   int remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
 134                     int size, raw_breakpoint *bp) override;
 135
 136   bool supports_hardware_single_step () override;
 137
 138   bool stopped_by_watchpoint () override;
 139
 140   CORE_ADDR stopped_data_address () override;
 141
 142   bool supports_qxfer_siginfo () override;
 143
 144   int qxfer_siginfo (const char *annex, unsigned char *readbuf,
 145                      unsigned const char *writebuf,
 146                      CORE_ADDR offset, int len) override;
 147
 148   bool supports_get_tib_address () override;
 149
 150   int get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
 151
 152   const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override;
 153
 154   CORE_ADDR read_pc (regcache *regcache) override;
 155
 156   void write_pc (regcache *regcache, CORE_ADDR pc) override;
 157
 158   bool stopped_by_sw_breakpoint () override;
 159
 160   bool supports_stopped_by_sw_breakpoint () override;
 161
 162   const char *thread_name (ptid_t thread) override;
 163
 164   bool supports_pid_to_exec_file () override
 165   { return true; }
 166
 167   const char *pid_to_exec_file (int pid) override;
 168
 169   bool supports_disable_randomization () override
 170   {
 171     return windows_nat::disable_randomization_available ();
 172   }
 173 };
 174
 175 struct gdbserver_windows_process : public windows_nat::windows_process_info
 176 {
 177   windows_nat::windows_thread_info *thread_rec
 178        (ptid_t ptid,
 179         windows_nat::thread_disposition_type disposition) override;
 180   int handle_output_debug_string (struct target_waitstatus *ourstatus) override;
 181   void handle_load_dll (const char *dll_name, LPVOID base) override;
 182   void handle_unload_dll () override;
 183   bool handle_access_violation (const EXCEPTION_RECORD *rec) override;
 184
 185   int attaching = 0;
 186
 187   /* A status that hasn't been reported to the core yet, and so
 188      win32_wait should return it next, instead of fetching the next
 189      debug event off the win32 API.  */
 190   struct target_waitstatus cached_status;
 191
 192   /* Non zero if an interrupt request is to be satisfied by suspending
 193      all threads.  */
 194   int soft_interrupt_requested = 0;
 195
 196   /* Non zero if the inferior is stopped in a simulated breakpoint done
 197      by suspending all the threads.  */
 198   int faked_breakpoint = 0;
 199
 200   /* True if current_process_handle needs to be closed.  */
 201   bool open_process_used = false;
 202
 203   /* Zero during the child initialization phase, and nonzero
 204      otherwise.  */
 205   int child_initialization_done = 0;
 206 };
 207
 208 /* The sole Windows process.  */
 209 extern gdbserver_windows_process windows_process;
 210
 211 /* Retrieve the context for this thread, if not already retrieved.  */
 212 extern void win32_require_context (windows_nat::windows_thread_info *th);
 213
 214 /* Map the Windows error number in ERROR to a locale-dependent error
 215    message string and return a pointer to it.  Typically, the values
 216    for ERROR come from GetLastError.
 217
 218    The string pointed to shall not be modified by the application,
 219    but may be overwritten by a subsequent call to strwinerror
 220
 221    The strwinerror function does not change the current setting
 222    of GetLastError.  */
 223 extern char * strwinerror (DWORD error);
 224
 225 #endif /* GDBSERVER_WIN32_LOW_H */