1 /* Target-dependent code for GNU/Linux m32r. 2 3 Copyright (C) 2004-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbcore.h" 22 #include "frame.h" 23 #include "value.h" 24 #include "regcache.h" 25 #include "inferior.h" 26 #include "osabi.h" 27 #include "reggroups.h" 28 #include "regset.h" 29 30 #include "glibc-tdep.h" 31 #include "solib-svr4.h" 32 #include "symtab.h" 33 34 #include "trad-frame.h" 35 #include "frame-unwind.h" 36 37 #include "m32r-tdep.h" 38 #include "linux-tdep.h" 39 #include "gdbarch.h" 40 41 42 43 /* Recognizing signal handler frames. */ 44 45 /* GNU/Linux has two flavors of signals. Normal signal handlers, and 46 "realtime" (RT) signals. The RT signals can provide additional 47 information to the signal handler if the SA_SIGINFO flag is set 48 when establishing a signal handler using `sigaction'. It is not 49 unlikely that future versions of GNU/Linux will support SA_SIGINFO 50 for normal signals too. */ 51 52 /* When the m32r Linux kernel calls a signal handler and the 53 SA_RESTORER flag isn't set, the return address points to a bit of 54 code on the stack. This function returns whether the PC appears to 55 be within this bit of code. 56 57 The instruction sequence for normal signals is 58 ldi r7, #__NR_sigreturn 59 trap #2 60 or 0x67 0x77 0x10 0xf2. 61 62 Checking for the code sequence should be somewhat reliable, because 63 the effect is to call the system call sigreturn. This is unlikely 64 to occur anywhere other than in a signal trampoline. 65 66 It kind of sucks that we have to read memory from the process in 67 order to identify a signal trampoline, but there doesn't seem to be 68 any other way. Therefore we only do the memory reads if no 69 function name could be identified, which should be the case since 70 the code is on the stack. 71 72 Detection of signal trampolines for handlers that set the 73 SA_RESTORER flag is in general not possible. Unfortunately this is 74 what the GNU C Library has been doing for quite some time now. 75 However, as of version 2.1.2, the GNU C Library uses signal 76 trampolines (named __restore and __restore_rt) that are identical 77 to the ones used by the kernel. Therefore, these trampolines are 78 supported too. */ 79 80 static const gdb_byte linux_sigtramp_code[] = { 81 0x67, 0x77, 0x10, 0xf2, 82 }; 83 84 /* If PC is in a sigtramp routine, return the address of the start of 85 the routine. Otherwise, return 0. */ 86 87 static CORE_ADDR 88 m32r_linux_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame) 89 { 90 gdb_byte buf[4]; 91 92 /* We only recognize a signal trampoline if PC is at the start of 93 one of the instructions. We optimize for finding the PC at the 94 start of the instruction sequence, as will be the case when the 95 trampoline is not the first frame on the stack. We assume that 96 in the case where the PC is not at the start of the instruction 97 sequence, there will be a few trailing readable bytes on the 98 stack. */ 99 100 if (pc % 2 != 0) 101 { 102 if (!safe_frame_unwind_memory (this_frame, pc, {buf, 2})) 103 return 0; 104 105 if (memcmp (buf, linux_sigtramp_code, 2) == 0) 106 pc -= 2; 107 else 108 return 0; 109 } 110 111 if (!safe_frame_unwind_memory (this_frame, pc, {buf, 4})) 112 return 0; 113 114 if (memcmp (buf, linux_sigtramp_code, 4) != 0) 115 return 0; 116 117 return pc; 118 } 119 120 /* This function does the same for RT signals. Here the instruction 121 sequence is 122 ldi r7, #__NR_rt_sigreturn 123 trap #2 124 or 0x97 0xf0 0x00 0xad 0x10 0xf2 0xf0 0x00. 125 126 The effect is to call the system call rt_sigreturn. */ 127 128 static const gdb_byte linux_rt_sigtramp_code[] = { 129 0x97, 0xf0, 0x00, 0xad, 0x10, 0xf2, 0xf0, 0x00, 130 }; 131 132 /* If PC is in a RT sigtramp routine, return the address of the start 133 of the routine. Otherwise, return 0. */ 134 135 static CORE_ADDR 136 m32r_linux_rt_sigtramp_start (CORE_ADDR pc, frame_info_ptr this_frame) 137 { 138 gdb_byte buf[4]; 139 140 /* We only recognize a signal trampoline if PC is at the start of 141 one of the instructions. We optimize for finding the PC at the 142 start of the instruction sequence, as will be the case when the 143 trampoline is not the first frame on the stack. We assume that 144 in the case where the PC is not at the start of the instruction 145 sequence, there will be a few trailing readable bytes on the 146 stack. */ 147 148 if (pc % 2 != 0) 149 return 0; 150 151 if (!safe_frame_unwind_memory (this_frame, pc, {buf, 4})) 152 return 0; 153 154 if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0) 155 { 156 if (!safe_frame_unwind_memory (this_frame, pc + 4, {buf, 4})) 157 return 0; 158 159 if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0) 160 return pc; 161 } 162 else if (memcmp (buf, linux_rt_sigtramp_code + 4, 4) == 0) 163 { 164 if (!safe_frame_unwind_memory (this_frame, pc - 4, {buf, 4})) 165 return 0; 166 167 if (memcmp (buf, linux_rt_sigtramp_code, 4) == 0) 168 return pc - 4; 169 } 170 171 return 0; 172 } 173 174 static int 175 m32r_linux_pc_in_sigtramp (CORE_ADDR pc, const char *name, 176 frame_info_ptr this_frame) 177 { 178 /* If we have NAME, we can optimize the search. The trampolines are 179 named __restore and __restore_rt. However, they aren't dynamically 180 exported from the shared C library, so the trampoline may appear to 181 be part of the preceding function. This should always be sigaction, 182 __sigaction, or __libc_sigaction (all aliases to the same function). */ 183 if (name == NULL || strstr (name, "sigaction") != NULL) 184 return (m32r_linux_sigtramp_start (pc, this_frame) != 0 185 || m32r_linux_rt_sigtramp_start (pc, this_frame) != 0); 186 187 return (strcmp ("__restore", name) == 0 188 || strcmp ("__restore_rt", name) == 0); 189 } 190 191 /* From <asm/sigcontext.h>. */ 192 static int m32r_linux_sc_reg_offset[] = { 193 4 * 4, /* r0 */ 194 5 * 4, /* r1 */ 195 6 * 4, /* r2 */ 196 7 * 4, /* r3 */ 197 0 * 4, /* r4 */ 198 1 * 4, /* r5 */ 199 2 * 4, /* r6 */ 200 8 * 4, /* r7 */ 201 9 * 4, /* r8 */ 202 10 * 4, /* r9 */ 203 11 * 4, /* r10 */ 204 12 * 4, /* r11 */ 205 13 * 4, /* r12 */ 206 21 * 4, /* fp */ 207 22 * 4, /* lr */ 208 -1 * 4, /* sp */ 209 16 * 4, /* psw */ 210 -1 * 4, /* cbr */ 211 23 * 4, /* spi */ 212 20 * 4, /* spu */ 213 19 * 4, /* bpc */ 214 17 * 4, /* pc */ 215 15 * 4, /* accl */ 216 14 * 4 /* acch */ 217 }; 218 219 struct m32r_frame_cache 220 { 221 CORE_ADDR base, pc; 222 trad_frame_saved_reg *saved_regs; 223 }; 224 225 static struct m32r_frame_cache * 226 m32r_linux_sigtramp_frame_cache (frame_info_ptr this_frame, 227 void **this_cache) 228 { 229 struct m32r_frame_cache *cache; 230 CORE_ADDR sigcontext_addr, addr; 231 int regnum; 232 233 if ((*this_cache) != NULL) 234 return (struct m32r_frame_cache *) (*this_cache); 235 cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache); 236 (*this_cache) = cache; 237 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame); 238 239 cache->base = get_frame_register_unsigned (this_frame, M32R_SP_REGNUM); 240 sigcontext_addr = cache->base + 4; 241 242 cache->pc = get_frame_pc (this_frame); 243 addr = m32r_linux_sigtramp_start (cache->pc, this_frame); 244 if (addr == 0) 245 { 246 /* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR 247 accordingly. */ 248 addr = m32r_linux_rt_sigtramp_start (cache->pc, this_frame); 249 if (addr) 250 sigcontext_addr += 128; 251 else 252 addr = get_frame_func (this_frame); 253 } 254 cache->pc = addr; 255 256 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame); 257 258 for (regnum = 0; regnum < sizeof (m32r_linux_sc_reg_offset) / 4; regnum++) 259 { 260 if (m32r_linux_sc_reg_offset[regnum] >= 0) 261 cache->saved_regs[regnum].set_addr (sigcontext_addr 262 + m32r_linux_sc_reg_offset[regnum]); 263 } 264 265 return cache; 266 } 267 268 static void 269 m32r_linux_sigtramp_frame_this_id (frame_info_ptr this_frame, 270 void **this_cache, 271 struct frame_id *this_id) 272 { 273 struct m32r_frame_cache *cache = 274 m32r_linux_sigtramp_frame_cache (this_frame, this_cache); 275 276 (*this_id) = frame_id_build (cache->base, cache->pc); 277 } 278 279 static struct value * 280 m32r_linux_sigtramp_frame_prev_register (frame_info_ptr this_frame, 281 void **this_cache, int regnum) 282 { 283 struct m32r_frame_cache *cache = 284 m32r_linux_sigtramp_frame_cache (this_frame, this_cache); 285 286 return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum); 287 } 288 289 static int 290 m32r_linux_sigtramp_frame_sniffer (const struct frame_unwind *self, 291 frame_info_ptr this_frame, 292 void **this_cache) 293 { 294 CORE_ADDR pc = get_frame_pc (this_frame); 295 const char *name; 296 297 find_pc_partial_function (pc, &name, NULL, NULL); 298 if (m32r_linux_pc_in_sigtramp (pc, name, this_frame)) 299 return 1; 300 301 return 0; 302 } 303 304 static const struct frame_unwind m32r_linux_sigtramp_frame_unwind = { 305 "m32r linux sigtramp", 306 SIGTRAMP_FRAME, 307 default_frame_unwind_stop_reason, 308 m32r_linux_sigtramp_frame_this_id, 309 m32r_linux_sigtramp_frame_prev_register, 310 NULL, 311 m32r_linux_sigtramp_frame_sniffer 312 }; 313 314 /* Mapping between the registers in `struct pt_regs' 315 format and GDB's register array layout. */ 316 317 static int m32r_pt_regs_offset[] = { 318 4 * 4, /* r0 */ 319 4 * 5, /* r1 */ 320 4 * 6, /* r2 */ 321 4 * 7, /* r3 */ 322 4 * 0, /* r4 */ 323 4 * 1, /* r5 */ 324 4 * 2, /* r6 */ 325 4 * 8, /* r7 */ 326 4 * 9, /* r8 */ 327 4 * 10, /* r9 */ 328 4 * 11, /* r10 */ 329 4 * 12, /* r11 */ 330 4 * 13, /* r12 */ 331 4 * 24, /* fp */ 332 4 * 25, /* lr */ 333 4 * 23, /* sp */ 334 4 * 19, /* psw */ 335 4 * 19, /* cbr */ 336 4 * 26, /* spi */ 337 4 * 23, /* spu */ 338 4 * 22, /* bpc */ 339 4 * 20, /* pc */ 340 4 * 16, /* accl */ 341 4 * 15 /* acch */ 342 }; 343 344 #define PSW_OFFSET (4 * 19) 345 #define BBPSW_OFFSET (4 * 21) 346 #define SPU_OFFSET (4 * 23) 347 #define SPI_OFFSET (4 * 26) 348 349 #define M32R_LINUX_GREGS_SIZE (4 * 28) 350 351 static void 352 m32r_linux_supply_gregset (const struct regset *regset, 353 struct regcache *regcache, int regnum, 354 const void *gregs, size_t size) 355 { 356 const gdb_byte *regs = (const gdb_byte *) gregs; 357 enum bfd_endian byte_order = 358 gdbarch_byte_order (regcache->arch ()); 359 ULONGEST psw, bbpsw; 360 gdb_byte buf[4]; 361 const gdb_byte *p; 362 int i; 363 364 psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order); 365 bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order); 366 psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8); 367 368 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++) 369 { 370 if (regnum != -1 && regnum != i) 371 continue; 372 373 switch (i) 374 { 375 case PSW_REGNUM: 376 store_unsigned_integer (buf, 4, byte_order, psw); 377 p = buf; 378 break; 379 case CBR_REGNUM: 380 store_unsigned_integer (buf, 4, byte_order, psw & 1); 381 p = buf; 382 break; 383 case M32R_SP_REGNUM: 384 p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET); 385 break; 386 default: 387 p = regs + m32r_pt_regs_offset[i]; 388 } 389 390 regcache->raw_supply (i, p); 391 } 392 } 393 394 static void 395 m32r_linux_collect_gregset (const struct regset *regset, 396 const struct regcache *regcache, 397 int regnum, void *gregs, size_t size) 398 { 399 gdb_byte *regs = (gdb_byte *) gregs; 400 int i; 401 enum bfd_endian byte_order = 402 gdbarch_byte_order (regcache->arch ()); 403 ULONGEST psw; 404 gdb_byte buf[4]; 405 406 regcache->raw_collect (PSW_REGNUM, buf); 407 psw = extract_unsigned_integer (buf, 4, byte_order); 408 409 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++) 410 { 411 if (regnum != -1 && regnum != i) 412 continue; 413 414 switch (i) 415 { 416 case PSW_REGNUM: 417 store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order, 418 (psw & 0xc1) << 8); 419 store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order, 420 (psw >> 8) & 0xc1); 421 break; 422 case CBR_REGNUM: 423 break; 424 case M32R_SP_REGNUM: 425 regcache->raw_collect 426 (i, regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET)); 427 break; 428 default: 429 regcache->raw_collect (i, regs + m32r_pt_regs_offset[i]); 430 } 431 } 432 } 433 434 static const struct regset m32r_linux_gregset = { 435 NULL, 436 m32r_linux_supply_gregset, m32r_linux_collect_gregset 437 }; 438 439 static void 440 m32r_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 441 iterate_over_regset_sections_cb *cb, 442 void *cb_data, 443 const struct regcache *regcache) 444 { 445 cb (".reg", M32R_LINUX_GREGS_SIZE, M32R_LINUX_GREGS_SIZE, &m32r_linux_gregset, 446 NULL, cb_data); 447 } 448 449 static void 450 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 451 { 452 453 linux_init_abi (info, gdbarch, 0); 454 455 /* Since EVB register is not available for native debug, we reduce 456 the number of registers. */ 457 set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1); 458 459 frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind); 460 461 /* GNU/Linux uses SVR4-style shared libraries. */ 462 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 463 set_solib_svr4_fetch_link_map_offsets 464 (gdbarch, linux_ilp32_fetch_link_map_offsets); 465 466 /* Core file support. */ 467 set_gdbarch_iterate_over_regset_sections 468 (gdbarch, m32r_linux_iterate_over_regset_sections); 469 470 /* Enable TLS support. */ 471 set_gdbarch_fetch_tls_load_module_address (gdbarch, 472 svr4_fetch_objfile_link_map); 473 } 474 475 void _initialize_m32r_linux_tdep (); 476 void 477 _initialize_m32r_linux_tdep () 478 { 479 gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX, 480 m32r_linux_init_abi); 481 } 482