1 /* Internal interfaces for the Win32 specific target code for gdbserver. 2 Copyright (C) 2007-2024 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 #endif /* GDBSERVER_WIN32_LOW_H */ 215