1 /* GNU/Linux/Nios II specific low level interface, for the remote server for 2 GDB. 3 Copyright (C) 2008-2024 Free Software Foundation, Inc. 4 5 Contributed by Mentor Graphics, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "linux-low.h" 23 #include "elf/common.h" 24 #include "nat/gdb_ptrace.h" 25 #include <endian.h> 26 #include "gdb_proc_service.h" 27 #include <asm/ptrace.h> 28 29 #ifndef PTRACE_GET_THREAD_AREA 30 #define PTRACE_GET_THREAD_AREA 25 31 #endif 32 33 /* Linux target op definitions for the NIOS II architecture. */ 34 35 class nios2_target : public linux_process_target 36 { 37 public: 38 39 const regs_info *get_regs_info () override; 40 41 const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override; 42 43 protected: 44 45 void low_arch_setup () override; 46 47 bool low_cannot_fetch_register (int regno) override; 48 49 bool low_cannot_store_register (int regno) override; 50 51 bool low_supports_breakpoints () override; 52 53 CORE_ADDR low_get_pc (regcache *regcache) override; 54 55 void low_set_pc (regcache *regcache, CORE_ADDR newpc) override; 56 57 bool low_breakpoint_at (CORE_ADDR pc) override; 58 }; 59 60 /* The singleton target ops object. */ 61 62 static nios2_target the_nios2_target; 63 64 bool 65 nios2_target::low_supports_breakpoints () 66 { 67 return true; 68 } 69 70 CORE_ADDR 71 nios2_target::low_get_pc (regcache *regcache) 72 { 73 return linux_get_pc_32bit (regcache); 74 } 75 76 void 77 nios2_target::low_set_pc (regcache *regcache, CORE_ADDR pc) 78 { 79 linux_set_pc_32bit (regcache, pc); 80 } 81 82 /* The following definition must agree with the number of registers 83 defined in "struct user_regs" in GLIBC 84 (sysdeps/unix/sysv/linux/nios2/sys/user.h), and also with 85 NIOS2_NUM_REGS in GDB proper. */ 86 87 #define nios2_num_regs 49 88 89 /* Defined in auto-generated file nios2-linux.c. */ 90 91 void init_registers_nios2_linux (void); 92 extern const struct target_desc *tdesc_nios2_linux; 93 94 /* This union is used to convert between int and byte buffer 95 representations of register contents. */ 96 97 union nios2_register 98 { 99 unsigned char buf[4]; 100 int reg32; 101 }; 102 103 /* Return the ptrace ``address'' of register REGNO. */ 104 105 static int nios2_regmap[] = { 106 -1, 1, 2, 3, 4, 5, 6, 7, 107 8, 9, 10, 11, 12, 13, 14, 15, 108 16, 17, 18, 19, 20, 21, 22, 23, 109 24, 25, 26, 27, 28, 29, 30, 31, 110 32, 33, 34, 35, 36, 37, 38, 39, 111 40, 41, 42, 43, 44, 45, 46, 47, 112 48, 113 0 114 }; 115 116 /* Implement the low_arch_setup linux target ops method. */ 117 118 void 119 nios2_target::low_arch_setup () 120 { 121 current_process ()->tdesc = tdesc_nios2_linux; 122 } 123 124 /* Implement the low_cannot_fetch_register linux target ops method. */ 125 126 bool 127 nios2_target::low_cannot_fetch_register (int regno) 128 { 129 return (nios2_regmap[regno] == -1); 130 } 131 132 /* Implement the low_cannot_store_register linux target ops method. */ 133 134 bool 135 nios2_target::low_cannot_store_register (int regno) 136 { 137 return (nios2_regmap[regno] == -1); 138 } 139 140 /* Breakpoint support. Also see comments on nios2_breakpoint_from_pc 141 in nios2-tdep.c. */ 142 143 #if defined(__nios2_arch__) && __nios2_arch__ == 2 144 #define NIOS2_BREAKPOINT 0xb7fd0020 145 #define CDX_BREAKPOINT 0xd7c9 146 #else 147 #define NIOS2_BREAKPOINT 0x003b6ffa 148 #endif 149 150 /* We only register the 4-byte breakpoint, even on R2 targets which also 151 support 2-byte breakpoints. Since there is no supports_z_point_type 152 function provided, gdbserver never inserts software breakpoints itself 153 and instead relies on GDB to insert the breakpoint of the correct length 154 via a memory write. */ 155 static const unsigned int nios2_breakpoint = NIOS2_BREAKPOINT; 156 #define nios2_breakpoint_len 4 157 158 /* Implementation of target ops method "sw_breakpoint_from_kind". */ 159 160 const gdb_byte * 161 nios2_target::sw_breakpoint_from_kind (int kind, int *size) 162 { 163 *size = nios2_breakpoint_len; 164 return (const gdb_byte *) &nios2_breakpoint; 165 } 166 167 /* Implement the low_breakpoint_at linux target ops method. */ 168 169 bool 170 nios2_target::low_breakpoint_at (CORE_ADDR where) 171 { 172 unsigned int insn; 173 174 /* For R2, first check for the 2-byte CDX trap.n breakpoint encoding. */ 175 #if defined(__nios2_arch__) && __nios2_arch__ == 2 176 read_memory (where, (unsigned char *) &insn, 2); 177 if (insn == CDX_BREAKPOINT) 178 return true; 179 #endif 180 181 read_memory (where, (unsigned char *) &insn, 4); 182 if (insn == nios2_breakpoint) 183 return true; 184 return false; 185 } 186 187 /* Fetch the thread-local storage pointer for libthread_db. */ 188 189 ps_err_e 190 ps_get_thread_area (struct ps_prochandle *ph, 191 lwpid_t lwpid, int idx, void **base) 192 { 193 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0) 194 return PS_ERR; 195 196 /* IDX is the bias from the thread pointer to the beginning of the 197 thread descriptor. It has to be subtracted due to implementation 198 quirks in libthread_db. */ 199 *base = (void *) ((char *) *base - idx); 200 201 return PS_OK; 202 } 203 204 /* Helper functions to collect/supply a single register REGNO. */ 205 206 static void 207 nios2_collect_register (struct regcache *regcache, int regno, 208 union nios2_register *reg) 209 { 210 union nios2_register tmp_reg; 211 212 collect_register (regcache, regno, &tmp_reg.reg32); 213 reg->reg32 = tmp_reg.reg32; 214 } 215 216 static void 217 nios2_supply_register (struct regcache *regcache, int regno, 218 const union nios2_register *reg) 219 { 220 supply_register (regcache, regno, reg->buf); 221 } 222 223 /* We have only a single register set on Nios II. */ 224 225 static void 226 nios2_fill_gregset (struct regcache *regcache, void *buf) 227 { 228 union nios2_register *regset = (union nios2_register *) buf; 229 int i; 230 231 for (i = 1; i < nios2_num_regs; i++) 232 nios2_collect_register (regcache, i, regset + i); 233 } 234 235 static void 236 nios2_store_gregset (struct regcache *regcache, const void *buf) 237 { 238 const union nios2_register *regset = (union nios2_register *) buf; 239 int i; 240 241 for (i = 0; i < nios2_num_regs; i++) 242 nios2_supply_register (regcache, i, regset + i); 243 } 244 245 static struct regset_info nios2_regsets[] = 246 { 247 { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS, 248 nios2_num_regs * 4, GENERAL_REGS, 249 nios2_fill_gregset, nios2_store_gregset }, 250 NULL_REGSET 251 }; 252 253 static struct regsets_info nios2_regsets_info = 254 { 255 nios2_regsets, /* regsets */ 256 0, /* num_regsets */ 257 NULL, /* disabled_regsets */ 258 }; 259 260 static struct usrregs_info nios2_usrregs_info = 261 { 262 nios2_num_regs, 263 nios2_regmap, 264 }; 265 266 static struct regs_info myregs_info = 267 { 268 NULL, /* regset_bitmap */ 269 &nios2_usrregs_info, 270 &nios2_regsets_info 271 }; 272 273 const regs_info * 274 nios2_target::get_regs_info () 275 { 276 return &myregs_info; 277 } 278 279 /* The linux target ops object. */ 280 281 linux_process_target *the_linux_target = &the_nios2_target; 282 283 void 284 initialize_low_arch (void) 285 { 286 init_registers_nios2_linux (); 287 288 initialize_regsets_info (&nios2_regsets_info); 289 } 290