1 /* Target-dependent code for GNU/Linux m32r. 2 3 Copyright (C) 2004-2020 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, struct frame_info *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, struct frame_info *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 struct frame_info *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 struct trad_frame_saved_reg *saved_regs; 223 }; 224 225 static struct m32r_frame_cache * 226 m32r_linux_sigtramp_frame_cache (struct frame_info *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].addr = 262 sigcontext_addr + m32r_linux_sc_reg_offset[regnum]; 263 } 264 265 return cache; 266 } 267 268 static void 269 m32r_linux_sigtramp_frame_this_id (struct frame_info *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 (struct frame_info *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 struct frame_info *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 SIGTRAMP_FRAME, 306 default_frame_unwind_stop_reason, 307 m32r_linux_sigtramp_frame_this_id, 308 m32r_linux_sigtramp_frame_prev_register, 309 NULL, 310 m32r_linux_sigtramp_frame_sniffer 311 }; 312 313 /* Mapping between the registers in `struct pt_regs' 314 format and GDB's register array layout. */ 315 316 static int m32r_pt_regs_offset[] = { 317 4 * 4, /* r0 */ 318 4 * 5, /* r1 */ 319 4 * 6, /* r2 */ 320 4 * 7, /* r3 */ 321 4 * 0, /* r4 */ 322 4 * 1, /* r5 */ 323 4 * 2, /* r6 */ 324 4 * 8, /* r7 */ 325 4 * 9, /* r8 */ 326 4 * 10, /* r9 */ 327 4 * 11, /* r10 */ 328 4 * 12, /* r11 */ 329 4 * 13, /* r12 */ 330 4 * 24, /* fp */ 331 4 * 25, /* lr */ 332 4 * 23, /* sp */ 333 4 * 19, /* psw */ 334 4 * 19, /* cbr */ 335 4 * 26, /* spi */ 336 4 * 23, /* spu */ 337 4 * 22, /* bpc */ 338 4 * 20, /* pc */ 339 4 * 16, /* accl */ 340 4 * 15 /* acch */ 341 }; 342 343 #define PSW_OFFSET (4 * 19) 344 #define BBPSW_OFFSET (4 * 21) 345 #define SPU_OFFSET (4 * 23) 346 #define SPI_OFFSET (4 * 26) 347 348 #define M32R_LINUX_GREGS_SIZE (4 * 28) 349 350 static void 351 m32r_linux_supply_gregset (const struct regset *regset, 352 struct regcache *regcache, int regnum, 353 const void *gregs, size_t size) 354 { 355 const gdb_byte *regs = (const gdb_byte *) gregs; 356 enum bfd_endian byte_order = 357 gdbarch_byte_order (regcache->arch ()); 358 ULONGEST psw, bbpsw; 359 gdb_byte buf[4]; 360 const gdb_byte *p; 361 int i; 362 363 psw = extract_unsigned_integer (regs + PSW_OFFSET, 4, byte_order); 364 bbpsw = extract_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order); 365 psw = ((0x00c1 & bbpsw) << 8) | ((0xc100 & psw) >> 8); 366 367 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++) 368 { 369 if (regnum != -1 && regnum != i) 370 continue; 371 372 switch (i) 373 { 374 case PSW_REGNUM: 375 store_unsigned_integer (buf, 4, byte_order, psw); 376 p = buf; 377 break; 378 case CBR_REGNUM: 379 store_unsigned_integer (buf, 4, byte_order, psw & 1); 380 p = buf; 381 break; 382 case M32R_SP_REGNUM: 383 p = regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET); 384 break; 385 default: 386 p = regs + m32r_pt_regs_offset[i]; 387 } 388 389 regcache->raw_supply (i, p); 390 } 391 } 392 393 static void 394 m32r_linux_collect_gregset (const struct regset *regset, 395 const struct regcache *regcache, 396 int regnum, void *gregs, size_t size) 397 { 398 gdb_byte *regs = (gdb_byte *) gregs; 399 int i; 400 enum bfd_endian byte_order = 401 gdbarch_byte_order (regcache->arch ()); 402 ULONGEST psw; 403 gdb_byte buf[4]; 404 405 regcache->raw_collect (PSW_REGNUM, buf); 406 psw = extract_unsigned_integer (buf, 4, byte_order); 407 408 for (i = 0; i < ARRAY_SIZE (m32r_pt_regs_offset); i++) 409 { 410 if (regnum != -1 && regnum != i) 411 continue; 412 413 switch (i) 414 { 415 case PSW_REGNUM: 416 store_unsigned_integer (regs + PSW_OFFSET, 4, byte_order, 417 (psw & 0xc1) << 8); 418 store_unsigned_integer (regs + BBPSW_OFFSET, 4, byte_order, 419 (psw >> 8) & 0xc1); 420 break; 421 case CBR_REGNUM: 422 break; 423 case M32R_SP_REGNUM: 424 regcache->raw_collect 425 (i, regs + ((psw & 0x80) ? SPU_OFFSET : SPI_OFFSET)); 426 break; 427 default: 428 regcache->raw_collect (i, regs + m32r_pt_regs_offset[i]); 429 } 430 } 431 } 432 433 static const struct regset m32r_linux_gregset = { 434 NULL, 435 m32r_linux_supply_gregset, m32r_linux_collect_gregset 436 }; 437 438 static void 439 m32r_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 440 iterate_over_regset_sections_cb *cb, 441 void *cb_data, 442 const struct regcache *regcache) 443 { 444 cb (".reg", M32R_LINUX_GREGS_SIZE, M32R_LINUX_GREGS_SIZE, &m32r_linux_gregset, 445 NULL, cb_data); 446 } 447 448 static void 449 m32r_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 450 { 451 452 linux_init_abi (info, gdbarch); 453 454 /* Since EVB register is not available for native debug, we reduce 455 the number of registers. */ 456 set_gdbarch_num_regs (gdbarch, M32R_NUM_REGS - 1); 457 458 frame_unwind_append_unwinder (gdbarch, &m32r_linux_sigtramp_frame_unwind); 459 460 /* GNU/Linux uses SVR4-style shared libraries. */ 461 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 462 set_solib_svr4_fetch_link_map_offsets 463 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 464 465 /* Core file support. */ 466 set_gdbarch_iterate_over_regset_sections 467 (gdbarch, m32r_linux_iterate_over_regset_sections); 468 469 /* Enable TLS support. */ 470 set_gdbarch_fetch_tls_load_module_address (gdbarch, 471 svr4_fetch_objfile_link_map); 472 } 473 474 void _initialize_m32r_linux_tdep (); 475 void 476 _initialize_m32r_linux_tdep () 477 { 478 gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX, 479 m32r_linux_init_abi); 480 } 481