1 /* GNU/Linux on ARM target support. 2 3 Copyright (C) 1999-2015 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 "target.h" 22 #include "value.h" 23 #include "gdbtypes.h" 24 #include "floatformat.h" 25 #include "gdbcore.h" 26 #include "frame.h" 27 #include "regcache.h" 28 #include "doublest.h" 29 #include "solib-svr4.h" 30 #include "osabi.h" 31 #include "regset.h" 32 #include "trad-frame.h" 33 #include "tramp-frame.h" 34 #include "breakpoint.h" 35 #include "auxv.h" 36 #include "xml-syscall.h" 37 38 #include "arm-tdep.h" 39 #include "arm-linux-tdep.h" 40 #include "linux-tdep.h" 41 #include "glibc-tdep.h" 42 #include "arch-utils.h" 43 #include "inferior.h" 44 #include "infrun.h" 45 #include "gdbthread.h" 46 #include "symfile.h" 47 48 #include "record-full.h" 49 #include "linux-record.h" 50 51 #include "cli/cli-utils.h" 52 #include "stap-probe.h" 53 #include "parser-defs.h" 54 #include "user-regs.h" 55 #include <ctype.h> 56 #include "elf/common.h" 57 extern int arm_apcs_32; 58 59 /* Under ARM GNU/Linux the traditional way of performing a breakpoint 60 is to execute a particular software interrupt, rather than use a 61 particular undefined instruction to provoke a trap. Upon exection 62 of the software interrupt the kernel stops the inferior with a 63 SIGTRAP, and wakes the debugger. */ 64 65 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef }; 66 67 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 }; 68 69 /* However, the EABI syscall interface (new in Nov. 2005) does not look at 70 the operand of the swi if old-ABI compatibility is disabled. Therefore, 71 use an undefined instruction instead. This is supported as of kernel 72 version 2.5.70 (May 2003), so should be a safe assumption for EABI 73 binaries. */ 74 75 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 }; 76 77 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 }; 78 79 /* All the kernels which support Thumb support using a specific undefined 80 instruction for the Thumb breakpoint. */ 81 82 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01}; 83 84 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde}; 85 86 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks, 87 we must use a length-appropriate breakpoint for 32-bit Thumb 88 instructions. See also thumb_get_next_pc. */ 89 90 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 }; 91 92 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 }; 93 94 /* Description of the longjmp buffer. The buffer is treated as an array of 95 elements of size ARM_LINUX_JB_ELEMENT_SIZE. 96 97 The location of saved registers in this buffer (in particular the PC 98 to use after longjmp is called) varies depending on the ABI (in 99 particular the FP model) and also (possibly) the C Library. 100 101 For glibc, eglibc, and uclibc the following holds: If the FP model is 102 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the 103 buffer. This is also true for the SoftFPA model. However, for the FPA 104 model the PC is at offset 21 in the buffer. */ 105 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE 106 #define ARM_LINUX_JB_PC_FPA 21 107 #define ARM_LINUX_JB_PC_EABI 9 108 109 /* 110 Dynamic Linking on ARM GNU/Linux 111 -------------------------------- 112 113 Note: PLT = procedure linkage table 114 GOT = global offset table 115 116 As much as possible, ELF dynamic linking defers the resolution of 117 jump/call addresses until the last minute. The technique used is 118 inspired by the i386 ELF design, and is based on the following 119 constraints. 120 121 1) The calling technique should not force a change in the assembly 122 code produced for apps; it MAY cause changes in the way assembly 123 code is produced for position independent code (i.e. shared 124 libraries). 125 126 2) The technique must be such that all executable areas must not be 127 modified; and any modified areas must not be executed. 128 129 To do this, there are three steps involved in a typical jump: 130 131 1) in the code 132 2) through the PLT 133 3) using a pointer from the GOT 134 135 When the executable or library is first loaded, each GOT entry is 136 initialized to point to the code which implements dynamic name 137 resolution and code finding. This is normally a function in the 138 program interpreter (on ARM GNU/Linux this is usually 139 ld-linux.so.2, but it does not have to be). On the first 140 invocation, the function is located and the GOT entry is replaced 141 with the real function address. Subsequent calls go through steps 142 1, 2 and 3 and end up calling the real code. 143 144 1) In the code: 145 146 b function_call 147 bl function_call 148 149 This is typical ARM code using the 26 bit relative branch or branch 150 and link instructions. The target of the instruction 151 (function_call is usually the address of the function to be called. 152 In position independent code, the target of the instruction is 153 actually an entry in the PLT when calling functions in a shared 154 library. Note that this call is identical to a normal function 155 call, only the target differs. 156 157 2) In the PLT: 158 159 The PLT is a synthetic area, created by the linker. It exists in 160 both executables and libraries. It is an array of stubs, one per 161 imported function call. It looks like this: 162 163 PLT[0]: 164 str lr, [sp, #-4]! @push the return address (lr) 165 ldr lr, [pc, #16] @load from 6 words ahead 166 add lr, pc, lr @form an address for GOT[0] 167 ldr pc, [lr, #8]! @jump to the contents of that addr 168 169 The return address (lr) is pushed on the stack and used for 170 calculations. The load on the second line loads the lr with 171 &GOT[3] - . - 20. The addition on the third leaves: 172 173 lr = (&GOT[3] - . - 20) + (. + 8) 174 lr = (&GOT[3] - 12) 175 lr = &GOT[0] 176 177 On the fourth line, the pc and lr are both updated, so that: 178 179 pc = GOT[2] 180 lr = &GOT[0] + 8 181 = &GOT[2] 182 183 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little 184 "tight", but allows us to keep all the PLT entries the same size. 185 186 PLT[n+1]: 187 ldr ip, [pc, #4] @load offset from gotoff 188 add ip, pc, ip @add the offset to the pc 189 ldr pc, [ip] @jump to that address 190 gotoff: .word GOT[n+3] - . 191 192 The load on the first line, gets an offset from the fourth word of 193 the PLT entry. The add on the second line makes ip = &GOT[n+3], 194 which contains either a pointer to PLT[0] (the fixup trampoline) or 195 a pointer to the actual code. 196 197 3) In the GOT: 198 199 The GOT contains helper pointers for both code (PLT) fixups and 200 data fixups. The first 3 entries of the GOT are special. The next 201 M entries (where M is the number of entries in the PLT) belong to 202 the PLT fixups. The next D (all remaining) entries belong to 203 various data fixups. The actual size of the GOT is 3 + M + D. 204 205 The GOT is also a synthetic area, created by the linker. It exists 206 in both executables and libraries. When the GOT is first 207 initialized , all the GOT entries relating to PLT fixups are 208 pointing to code back at PLT[0]. 209 210 The special entries in the GOT are: 211 212 GOT[0] = linked list pointer used by the dynamic loader 213 GOT[1] = pointer to the reloc table for this module 214 GOT[2] = pointer to the fixup/resolver code 215 216 The first invocation of function call comes through and uses the 217 fixup/resolver code. On the entry to the fixup/resolver code: 218 219 ip = &GOT[n+3] 220 lr = &GOT[2] 221 stack[0] = return address (lr) of the function call 222 [r0, r1, r2, r3] are still the arguments to the function call 223 224 This is enough information for the fixup/resolver code to work 225 with. Before the fixup/resolver code returns, it actually calls 226 the requested function and repairs &GOT[n+3]. */ 227 228 /* The constants below were determined by examining the following files 229 in the linux kernel sources: 230 231 arch/arm/kernel/signal.c 232 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN 233 include/asm-arm/unistd.h 234 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */ 235 236 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077 237 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad 238 239 /* For ARM EABI, the syscall number is not in the SWI instruction 240 (instead it is loaded into r7). We recognize the pattern that 241 glibc uses... alternatively, we could arrange to do this by 242 function name, but they are not always exported. */ 243 #define ARM_SET_R7_SIGRETURN 0xe3a07077 244 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad 245 #define ARM_EABI_SYSCALL 0xef000000 246 247 /* Equivalent patterns for Thumb2. */ 248 #define THUMB2_SET_R7_SIGRETURN1 0xf04f 249 #define THUMB2_SET_R7_SIGRETURN2 0x0777 250 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f 251 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad 252 #define THUMB2_EABI_SYSCALL 0xdf00 253 254 /* OABI syscall restart trampoline, used for EABI executables too 255 whenever OABI support has been enabled in the kernel. */ 256 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000 257 #define ARM_LDR_PC_SP_12 0xe49df00c 258 #define ARM_LDR_PC_SP_4 0xe49df004 259 260 static void 261 arm_linux_sigtramp_cache (struct frame_info *this_frame, 262 struct trad_frame_cache *this_cache, 263 CORE_ADDR func, int regs_offset) 264 { 265 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 266 CORE_ADDR base = sp + regs_offset; 267 int i; 268 269 for (i = 0; i < 16; i++) 270 trad_frame_set_reg_addr (this_cache, i, base + i * 4); 271 272 trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4); 273 274 /* The VFP or iWMMXt registers may be saved on the stack, but there's 275 no reliable way to restore them (yet). */ 276 277 /* Save a frame ID. */ 278 trad_frame_set_id (this_cache, frame_id_build (sp, func)); 279 } 280 281 /* There are a couple of different possible stack layouts that 282 we need to support. 283 284 Before version 2.6.18, the kernel used completely independent 285 layouts for non-RT and RT signals. For non-RT signals the stack 286 began directly with a struct sigcontext. For RT signals the stack 287 began with two redundant pointers (to the siginfo and ucontext), 288 and then the siginfo and ucontext. 289 290 As of version 2.6.18, the non-RT signal frame layout starts with 291 a ucontext and the RT signal frame starts with a siginfo and then 292 a ucontext. Also, the ucontext now has a designated save area 293 for coprocessor registers. 294 295 For RT signals, it's easy to tell the difference: we look for 296 pinfo, the pointer to the siginfo. If it has the expected 297 value, we have an old layout. If it doesn't, we have the new 298 layout. 299 300 For non-RT signals, it's a bit harder. We need something in one 301 layout or the other with a recognizable offset and value. We can't 302 use the return trampoline, because ARM usually uses SA_RESTORER, 303 in which case the stack return trampoline is not filled in. 304 We can't use the saved stack pointer, because sigaltstack might 305 be in use. So for now we guess the new layout... */ 306 307 /* There are three words (trap_no, error_code, oldmask) in 308 struct sigcontext before r0. */ 309 #define ARM_SIGCONTEXT_R0 0xc 310 311 /* There are five words (uc_flags, uc_link, and three for uc_stack) 312 in the ucontext_t before the sigcontext. */ 313 #define ARM_UCONTEXT_SIGCONTEXT 0x14 314 315 /* There are three elements in an rt_sigframe before the ucontext: 316 pinfo, puc, and info. The first two are pointers and the third 317 is a struct siginfo, with size 128 bytes. We could follow puc 318 to the ucontext, but it's simpler to skip the whole thing. */ 319 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8 320 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88 321 322 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80 323 324 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a 325 326 static void 327 arm_linux_sigreturn_init (const struct tramp_frame *self, 328 struct frame_info *this_frame, 329 struct trad_frame_cache *this_cache, 330 CORE_ADDR func) 331 { 332 struct gdbarch *gdbarch = get_frame_arch (this_frame); 333 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 334 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 335 ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order); 336 337 if (uc_flags == ARM_NEW_SIGFRAME_MAGIC) 338 arm_linux_sigtramp_cache (this_frame, this_cache, func, 339 ARM_UCONTEXT_SIGCONTEXT 340 + ARM_SIGCONTEXT_R0); 341 else 342 arm_linux_sigtramp_cache (this_frame, this_cache, func, 343 ARM_SIGCONTEXT_R0); 344 } 345 346 static void 347 arm_linux_rt_sigreturn_init (const struct tramp_frame *self, 348 struct frame_info *this_frame, 349 struct trad_frame_cache *this_cache, 350 CORE_ADDR func) 351 { 352 struct gdbarch *gdbarch = get_frame_arch (this_frame); 353 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 354 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 355 ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order); 356 357 if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO) 358 arm_linux_sigtramp_cache (this_frame, this_cache, func, 359 ARM_OLD_RT_SIGFRAME_UCONTEXT 360 + ARM_UCONTEXT_SIGCONTEXT 361 + ARM_SIGCONTEXT_R0); 362 else 363 arm_linux_sigtramp_cache (this_frame, this_cache, func, 364 ARM_NEW_RT_SIGFRAME_UCONTEXT 365 + ARM_UCONTEXT_SIGCONTEXT 366 + ARM_SIGCONTEXT_R0); 367 } 368 369 static void 370 arm_linux_restart_syscall_init (const struct tramp_frame *self, 371 struct frame_info *this_frame, 372 struct trad_frame_cache *this_cache, 373 CORE_ADDR func) 374 { 375 struct gdbarch *gdbarch = get_frame_arch (this_frame); 376 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 377 CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4); 378 CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM); 379 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch); 380 int sp_offset; 381 382 /* There are two variants of this trampoline; with older kernels, the 383 stub is placed on the stack, while newer kernels use the stub from 384 the vector page. They are identical except that the older version 385 increments SP by 12 (to skip stored PC and the stub itself), while 386 the newer version increments SP only by 4 (just the stored PC). */ 387 if (self->insn[1].bytes == ARM_LDR_PC_SP_4) 388 sp_offset = 4; 389 else 390 sp_offset = 12; 391 392 /* Update Thumb bit in CPSR. */ 393 if (pc & 1) 394 cpsr |= t_bit; 395 else 396 cpsr &= ~t_bit; 397 398 /* Remove Thumb bit from PC. */ 399 pc = gdbarch_addr_bits_remove (gdbarch, pc); 400 401 /* Save previous register values. */ 402 trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset); 403 trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc); 404 trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr); 405 406 /* Save a frame ID. */ 407 trad_frame_set_id (this_cache, frame_id_build (sp, func)); 408 } 409 410 static struct tramp_frame arm_linux_sigreturn_tramp_frame = { 411 SIGTRAMP_FRAME, 412 4, 413 { 414 { ARM_LINUX_SIGRETURN_INSTR, -1 }, 415 { TRAMP_SENTINEL_INSN } 416 }, 417 arm_linux_sigreturn_init 418 }; 419 420 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = { 421 SIGTRAMP_FRAME, 422 4, 423 { 424 { ARM_LINUX_RT_SIGRETURN_INSTR, -1 }, 425 { TRAMP_SENTINEL_INSN } 426 }, 427 arm_linux_rt_sigreturn_init 428 }; 429 430 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = { 431 SIGTRAMP_FRAME, 432 4, 433 { 434 { ARM_SET_R7_SIGRETURN, -1 }, 435 { ARM_EABI_SYSCALL, -1 }, 436 { TRAMP_SENTINEL_INSN } 437 }, 438 arm_linux_sigreturn_init 439 }; 440 441 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = { 442 SIGTRAMP_FRAME, 443 4, 444 { 445 { ARM_SET_R7_RT_SIGRETURN, -1 }, 446 { ARM_EABI_SYSCALL, -1 }, 447 { TRAMP_SENTINEL_INSN } 448 }, 449 arm_linux_rt_sigreturn_init 450 }; 451 452 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = { 453 SIGTRAMP_FRAME, 454 2, 455 { 456 { THUMB2_SET_R7_SIGRETURN1, -1 }, 457 { THUMB2_SET_R7_SIGRETURN2, -1 }, 458 { THUMB2_EABI_SYSCALL, -1 }, 459 { TRAMP_SENTINEL_INSN } 460 }, 461 arm_linux_sigreturn_init 462 }; 463 464 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = { 465 SIGTRAMP_FRAME, 466 2, 467 { 468 { THUMB2_SET_R7_RT_SIGRETURN1, -1 }, 469 { THUMB2_SET_R7_RT_SIGRETURN2, -1 }, 470 { THUMB2_EABI_SYSCALL, -1 }, 471 { TRAMP_SENTINEL_INSN } 472 }, 473 arm_linux_rt_sigreturn_init 474 }; 475 476 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = { 477 NORMAL_FRAME, 478 4, 479 { 480 { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 }, 481 { ARM_LDR_PC_SP_12, -1 }, 482 { TRAMP_SENTINEL_INSN } 483 }, 484 arm_linux_restart_syscall_init 485 }; 486 487 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = { 488 NORMAL_FRAME, 489 4, 490 { 491 { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 }, 492 { ARM_LDR_PC_SP_4, -1 }, 493 { TRAMP_SENTINEL_INSN } 494 }, 495 arm_linux_restart_syscall_init 496 }; 497 498 /* Core file and register set support. */ 499 500 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE) 501 502 void 503 arm_linux_supply_gregset (const struct regset *regset, 504 struct regcache *regcache, 505 int regnum, const void *gregs_buf, size_t len) 506 { 507 struct gdbarch *gdbarch = get_regcache_arch (regcache); 508 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 509 const gdb_byte *gregs = gregs_buf; 510 int regno; 511 CORE_ADDR reg_pc; 512 gdb_byte pc_buf[INT_REGISTER_SIZE]; 513 514 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) 515 if (regnum == -1 || regnum == regno) 516 regcache_raw_supply (regcache, regno, 517 gregs + INT_REGISTER_SIZE * regno); 518 519 if (regnum == ARM_PS_REGNUM || regnum == -1) 520 { 521 if (arm_apcs_32) 522 regcache_raw_supply (regcache, ARM_PS_REGNUM, 523 gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM); 524 else 525 regcache_raw_supply (regcache, ARM_PS_REGNUM, 526 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM); 527 } 528 529 if (regnum == ARM_PC_REGNUM || regnum == -1) 530 { 531 reg_pc = extract_unsigned_integer (gregs 532 + INT_REGISTER_SIZE * ARM_PC_REGNUM, 533 INT_REGISTER_SIZE, byte_order); 534 reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc); 535 store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc); 536 regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf); 537 } 538 } 539 540 void 541 arm_linux_collect_gregset (const struct regset *regset, 542 const struct regcache *regcache, 543 int regnum, void *gregs_buf, size_t len) 544 { 545 gdb_byte *gregs = gregs_buf; 546 int regno; 547 548 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) 549 if (regnum == -1 || regnum == regno) 550 regcache_raw_collect (regcache, regno, 551 gregs + INT_REGISTER_SIZE * regno); 552 553 if (regnum == ARM_PS_REGNUM || regnum == -1) 554 { 555 if (arm_apcs_32) 556 regcache_raw_collect (regcache, ARM_PS_REGNUM, 557 gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM); 558 else 559 regcache_raw_collect (regcache, ARM_PS_REGNUM, 560 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM); 561 } 562 563 if (regnum == ARM_PC_REGNUM || regnum == -1) 564 regcache_raw_collect (regcache, ARM_PC_REGNUM, 565 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM); 566 } 567 568 /* Support for register format used by the NWFPE FPA emulator. */ 569 570 #define typeNone 0x00 571 #define typeSingle 0x01 572 #define typeDouble 0x02 573 #define typeExtended 0x03 574 575 void 576 supply_nwfpe_register (struct regcache *regcache, int regno, 577 const gdb_byte *regs) 578 { 579 const gdb_byte *reg_data; 580 gdb_byte reg_tag; 581 gdb_byte buf[FP_REGISTER_SIZE]; 582 583 reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE; 584 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET]; 585 memset (buf, 0, FP_REGISTER_SIZE); 586 587 switch (reg_tag) 588 { 589 case typeSingle: 590 memcpy (buf, reg_data, 4); 591 break; 592 case typeDouble: 593 memcpy (buf, reg_data + 4, 4); 594 memcpy (buf + 4, reg_data, 4); 595 break; 596 case typeExtended: 597 /* We want sign and exponent, then least significant bits, 598 then most significant. NWFPE does sign, most, least. */ 599 memcpy (buf, reg_data, 4); 600 memcpy (buf + 4, reg_data + 8, 4); 601 memcpy (buf + 8, reg_data + 4, 4); 602 break; 603 default: 604 break; 605 } 606 607 regcache_raw_supply (regcache, regno, buf); 608 } 609 610 void 611 collect_nwfpe_register (const struct regcache *regcache, int regno, 612 gdb_byte *regs) 613 { 614 gdb_byte *reg_data; 615 gdb_byte reg_tag; 616 gdb_byte buf[FP_REGISTER_SIZE]; 617 618 regcache_raw_collect (regcache, regno, buf); 619 620 /* NOTE drow/2006-06-07: This code uses the tag already in the 621 register buffer. I've preserved that when moving the code 622 from the native file to the target file. But this doesn't 623 always make sense. */ 624 625 reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE; 626 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET]; 627 628 switch (reg_tag) 629 { 630 case typeSingle: 631 memcpy (reg_data, buf, 4); 632 break; 633 case typeDouble: 634 memcpy (reg_data, buf + 4, 4); 635 memcpy (reg_data + 4, buf, 4); 636 break; 637 case typeExtended: 638 memcpy (reg_data, buf, 4); 639 memcpy (reg_data + 4, buf + 8, 4); 640 memcpy (reg_data + 8, buf + 4, 4); 641 break; 642 default: 643 break; 644 } 645 } 646 647 void 648 arm_linux_supply_nwfpe (const struct regset *regset, 649 struct regcache *regcache, 650 int regnum, const void *regs_buf, size_t len) 651 { 652 const gdb_byte *regs = regs_buf; 653 int regno; 654 655 if (regnum == ARM_FPS_REGNUM || regnum == -1) 656 regcache_raw_supply (regcache, ARM_FPS_REGNUM, 657 regs + NWFPE_FPSR_OFFSET); 658 659 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) 660 if (regnum == -1 || regnum == regno) 661 supply_nwfpe_register (regcache, regno, regs); 662 } 663 664 void 665 arm_linux_collect_nwfpe (const struct regset *regset, 666 const struct regcache *regcache, 667 int regnum, void *regs_buf, size_t len) 668 { 669 gdb_byte *regs = regs_buf; 670 int regno; 671 672 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) 673 if (regnum == -1 || regnum == regno) 674 collect_nwfpe_register (regcache, regno, regs); 675 676 if (regnum == ARM_FPS_REGNUM || regnum == -1) 677 regcache_raw_collect (regcache, ARM_FPS_REGNUM, 678 regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM); 679 } 680 681 /* Support VFP register format. */ 682 683 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4) 684 685 static void 686 arm_linux_supply_vfp (const struct regset *regset, 687 struct regcache *regcache, 688 int regnum, const void *regs_buf, size_t len) 689 { 690 const gdb_byte *regs = regs_buf; 691 int regno; 692 693 if (regnum == ARM_FPSCR_REGNUM || regnum == -1) 694 regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8); 695 696 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++) 697 if (regnum == -1 || regnum == regno) 698 regcache_raw_supply (regcache, regno, 699 regs + (regno - ARM_D0_REGNUM) * 8); 700 } 701 702 static void 703 arm_linux_collect_vfp (const struct regset *regset, 704 const struct regcache *regcache, 705 int regnum, void *regs_buf, size_t len) 706 { 707 gdb_byte *regs = regs_buf; 708 int regno; 709 710 if (regnum == ARM_FPSCR_REGNUM || regnum == -1) 711 regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8); 712 713 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++) 714 if (regnum == -1 || regnum == regno) 715 regcache_raw_collect (regcache, regno, 716 regs + (regno - ARM_D0_REGNUM) * 8); 717 } 718 719 static const struct regset arm_linux_gregset = 720 { 721 NULL, arm_linux_supply_gregset, arm_linux_collect_gregset 722 }; 723 724 static const struct regset arm_linux_fpregset = 725 { 726 NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe 727 }; 728 729 static const struct regset arm_linux_vfpregset = 730 { 731 NULL, arm_linux_supply_vfp, arm_linux_collect_vfp 732 }; 733 734 /* Iterate over core file register note sections. */ 735 736 static void 737 arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 738 iterate_over_regset_sections_cb *cb, 739 void *cb_data, 740 const struct regcache *regcache) 741 { 742 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 743 744 cb (".reg", ARM_LINUX_SIZEOF_GREGSET, &arm_linux_gregset, NULL, cb_data); 745 746 if (tdep->have_vfp_registers) 747 cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, &arm_linux_vfpregset, 748 "VFP floating-point", cb_data); 749 else if (tdep->have_fpa_registers) 750 cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, &arm_linux_fpregset, 751 "FPA floating-point", cb_data); 752 } 753 754 /* Determine target description from core file. */ 755 756 static const struct target_desc * 757 arm_linux_core_read_description (struct gdbarch *gdbarch, 758 struct target_ops *target, 759 bfd *abfd) 760 { 761 CORE_ADDR arm_hwcap = 0; 762 763 if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1) 764 return NULL; 765 766 if (arm_hwcap & HWCAP_VFP) 767 { 768 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support 769 Neon with VFPv3-D32. */ 770 if (arm_hwcap & HWCAP_NEON) 771 return tdesc_arm_with_neon; 772 else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3) 773 return tdesc_arm_with_vfpv3; 774 else 775 return tdesc_arm_with_vfpv2; 776 } 777 778 return NULL; 779 } 780 781 782 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC, 783 return 1. In addition, set IS_THUMB depending on whether we 784 will return to ARM or Thumb code. Return 0 if it is not a 785 rt_sigreturn/sigreturn syscall. */ 786 static int 787 arm_linux_sigreturn_return_addr (struct frame_info *frame, 788 unsigned long svc_number, 789 CORE_ADDR *pc, int *is_thumb) 790 { 791 /* Is this a sigreturn or rt_sigreturn syscall? */ 792 if (svc_number == 119 || svc_number == 173) 793 { 794 if (get_frame_type (frame) == SIGTRAMP_FRAME) 795 { 796 ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame)); 797 CORE_ADDR cpsr 798 = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM); 799 800 *is_thumb = (cpsr & t_bit) != 0; 801 *pc = frame_unwind_caller_pc (frame); 802 return 1; 803 } 804 } 805 return 0; 806 } 807 808 /* At a ptrace syscall-stop, return the syscall number. This either 809 comes from the SWI instruction (OABI) or from r7 (EABI). 810 811 When the function fails, it should return -1. */ 812 813 static LONGEST 814 arm_linux_get_syscall_number (struct gdbarch *gdbarch, 815 ptid_t ptid) 816 { 817 struct regcache *regs = get_thread_regcache (ptid); 818 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 819 820 ULONGEST pc; 821 ULONGEST cpsr; 822 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch); 823 int is_thumb; 824 ULONGEST svc_number = -1; 825 826 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc); 827 regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr); 828 is_thumb = (cpsr & t_bit) != 0; 829 830 if (is_thumb) 831 { 832 regcache_cooked_read_unsigned (regs, 7, &svc_number); 833 } 834 else 835 { 836 enum bfd_endian byte_order_for_code = 837 gdbarch_byte_order_for_code (gdbarch); 838 839 /* PC gets incremented before the syscall-stop, so read the 840 previous instruction. */ 841 unsigned long this_instr = 842 read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code); 843 844 unsigned long svc_operand = (0x00ffffff & this_instr); 845 846 if (svc_operand) 847 { 848 /* OABI */ 849 svc_number = svc_operand - 0x900000; 850 } 851 else 852 { 853 /* EABI */ 854 regcache_cooked_read_unsigned (regs, 7, &svc_number); 855 } 856 } 857 858 return svc_number; 859 } 860 861 /* When FRAME is at a syscall instruction, return the PC of the next 862 instruction to be executed. */ 863 864 static CORE_ADDR 865 arm_linux_syscall_next_pc (struct frame_info *frame) 866 { 867 CORE_ADDR pc = get_frame_pc (frame); 868 CORE_ADDR return_addr = 0; 869 int is_thumb = arm_frame_is_thumb (frame); 870 ULONGEST svc_number = 0; 871 872 if (is_thumb) 873 { 874 svc_number = get_frame_register_unsigned (frame, 7); 875 return_addr = pc + 2; 876 } 877 else 878 { 879 struct gdbarch *gdbarch = get_frame_arch (frame); 880 enum bfd_endian byte_order_for_code = 881 gdbarch_byte_order_for_code (gdbarch); 882 unsigned long this_instr = 883 read_memory_unsigned_integer (pc, 4, byte_order_for_code); 884 885 unsigned long svc_operand = (0x00ffffff & this_instr); 886 if (svc_operand) /* OABI. */ 887 { 888 svc_number = svc_operand - 0x900000; 889 } 890 else /* EABI. */ 891 { 892 svc_number = get_frame_register_unsigned (frame, 7); 893 } 894 895 return_addr = pc + 4; 896 } 897 898 arm_linux_sigreturn_return_addr (frame, svc_number, &return_addr, &is_thumb); 899 900 /* Addresses for calling Thumb functions have the bit 0 set. */ 901 if (is_thumb) 902 return_addr |= 1; 903 904 return return_addr; 905 } 906 907 908 /* Insert a single step breakpoint at the next executed instruction. */ 909 910 static int 911 arm_linux_software_single_step (struct frame_info *frame) 912 { 913 struct gdbarch *gdbarch = get_frame_arch (frame); 914 struct address_space *aspace = get_frame_address_space (frame); 915 CORE_ADDR next_pc; 916 917 if (arm_deal_with_atomic_sequence (frame)) 918 return 1; 919 920 next_pc = arm_get_next_pc (frame, get_frame_pc (frame)); 921 922 /* The Linux kernel offers some user-mode helpers in a high page. We can 923 not read this page (as of 2.6.23), and even if we could then we couldn't 924 set breakpoints in it, and even if we could then the atomic operations 925 would fail when interrupted. They are all called as functions and return 926 to the address in LR, so step to there instead. */ 927 if (next_pc > 0xffff0000) 928 next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM); 929 930 arm_insert_single_step_breakpoint (gdbarch, aspace, next_pc); 931 932 return 1; 933 } 934 935 /* Support for displaced stepping of Linux SVC instructions. */ 936 937 static void 938 arm_linux_cleanup_svc (struct gdbarch *gdbarch, 939 struct regcache *regs, 940 struct displaced_step_closure *dsc) 941 { 942 CORE_ADDR from = dsc->insn_addr; 943 ULONGEST apparent_pc; 944 int within_scratch; 945 946 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc); 947 948 within_scratch = (apparent_pc >= dsc->scratch_base 949 && apparent_pc < (dsc->scratch_base 950 + DISPLACED_MODIFIED_INSNS * 4 + 4)); 951 952 if (debug_displaced) 953 { 954 fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after " 955 "SVC step ", (unsigned long) apparent_pc); 956 if (within_scratch) 957 fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n"); 958 else 959 fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n"); 960 } 961 962 if (within_scratch) 963 displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC); 964 } 965 966 static int 967 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs, 968 struct displaced_step_closure *dsc) 969 { 970 CORE_ADDR return_to = 0; 971 972 struct frame_info *frame; 973 unsigned int svc_number = displaced_read_reg (regs, dsc, 7); 974 int is_sigreturn = 0; 975 int is_thumb; 976 977 frame = get_current_frame (); 978 979 is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number, 980 &return_to, &is_thumb); 981 if (is_sigreturn) 982 { 983 struct symtab_and_line sal; 984 985 if (debug_displaced) 986 fprintf_unfiltered (gdb_stdlog, "displaced: found " 987 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n", 988 (unsigned long) get_frame_pc (frame)); 989 990 if (debug_displaced) 991 fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. " 992 "Setting momentary breakpoint.\n", (unsigned long) return_to); 993 994 gdb_assert (inferior_thread ()->control.step_resume_breakpoint 995 == NULL); 996 997 sal = find_pc_line (return_to, 0); 998 sal.pc = return_to; 999 sal.section = find_pc_overlay (return_to); 1000 sal.explicit_pc = 1; 1001 1002 frame = get_prev_frame (frame); 1003 1004 if (frame) 1005 { 1006 inferior_thread ()->control.step_resume_breakpoint 1007 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame), 1008 bp_step_resume); 1009 1010 /* set_momentary_breakpoint invalidates FRAME. */ 1011 frame = NULL; 1012 1013 /* We need to make sure we actually insert the momentary 1014 breakpoint set above. */ 1015 insert_breakpoints (); 1016 } 1017 else if (debug_displaced) 1018 fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous " 1019 "frame to set momentary breakpoint for " 1020 "sigreturn/rt_sigreturn\n"); 1021 } 1022 else if (debug_displaced) 1023 fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn " 1024 "SVC call not in signal trampoline frame\n"); 1025 1026 1027 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume 1028 location, else nothing. 1029 Insn: unmodified svc. 1030 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4 1031 else leave pc alone. */ 1032 1033 1034 dsc->cleanup = &arm_linux_cleanup_svc; 1035 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next 1036 instruction. */ 1037 dsc->wrote_to_pc = 1; 1038 1039 return 0; 1040 } 1041 1042 1043 /* The following two functions implement single-stepping over calls to Linux 1044 kernel helper routines, which perform e.g. atomic operations on architecture 1045 variants which don't support them natively. 1046 1047 When this function is called, the PC will be pointing at the kernel helper 1048 (at an address inaccessible to GDB), and r14 will point to the return 1049 address. Displaced stepping always executes code in the copy area: 1050 so, make the copy-area instruction branch back to the kernel helper (the 1051 "from" address), and make r14 point to the breakpoint in the copy area. In 1052 that way, we regain control once the kernel helper returns, and can clean 1053 up appropriately (as if we had just returned from the kernel helper as it 1054 would have been called from the non-displaced location). */ 1055 1056 static void 1057 cleanup_kernel_helper_return (struct gdbarch *gdbarch, 1058 struct regcache *regs, 1059 struct displaced_step_closure *dsc) 1060 { 1061 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC); 1062 displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC); 1063 } 1064 1065 static void 1066 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from, 1067 CORE_ADDR to, struct regcache *regs, 1068 struct displaced_step_closure *dsc) 1069 { 1070 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1071 1072 dsc->numinsns = 1; 1073 dsc->insn_addr = from; 1074 dsc->cleanup = &cleanup_kernel_helper_return; 1075 /* Say we wrote to the PC, else cleanup will set PC to the next 1076 instruction in the helper, which isn't helpful. */ 1077 dsc->wrote_to_pc = 1; 1078 1079 /* Preparation: tmp[0] <- r14 1080 r14 <- <scratch space>+4 1081 *(<scratch space>+8) <- from 1082 Insn: ldr pc, [r14, #4] 1083 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */ 1084 1085 dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM); 1086 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4, 1087 CANNOT_WRITE_PC); 1088 write_memory_unsigned_integer (to + 8, 4, byte_order, from); 1089 1090 dsc->modinsn[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */ 1091 } 1092 1093 /* Linux-specific displaced step instruction copying function. Detects when 1094 the program has stepped into a Linux kernel helper routine (which must be 1095 handled as a special case), falling back to arm_displaced_step_copy_insn() 1096 if it hasn't. */ 1097 1098 static struct displaced_step_closure * 1099 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch, 1100 CORE_ADDR from, CORE_ADDR to, 1101 struct regcache *regs) 1102 { 1103 struct displaced_step_closure *dsc 1104 = xmalloc (sizeof (struct displaced_step_closure)); 1105 1106 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and 1107 stop at the return location. */ 1108 if (from > 0xffff0000) 1109 { 1110 if (debug_displaced) 1111 fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper " 1112 "at %.8lx\n", (unsigned long) from); 1113 1114 arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc); 1115 } 1116 else 1117 { 1118 /* Override the default handling of SVC instructions. */ 1119 dsc->u.svc.copy_svc_os = arm_linux_copy_svc; 1120 1121 arm_process_displaced_insn (gdbarch, from, to, regs, dsc); 1122 } 1123 1124 arm_displaced_init_closure (gdbarch, from, to, dsc); 1125 1126 return dsc; 1127 } 1128 1129 /* Implementation of `gdbarch_stap_is_single_operand', as defined in 1130 gdbarch.h. */ 1131 1132 static int 1133 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s) 1134 { 1135 return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number. */ 1136 || *s == '[' /* Register indirection or 1137 displacement. */ 1138 || isalpha (*s)); /* Register value. */ 1139 } 1140 1141 /* This routine is used to parse a special token in ARM's assembly. 1142 1143 The special tokens parsed by it are: 1144 1145 - Register displacement (e.g, [fp, #-8]) 1146 1147 It returns one if the special token has been parsed successfully, 1148 or zero if the current token is not considered special. */ 1149 1150 static int 1151 arm_stap_parse_special_token (struct gdbarch *gdbarch, 1152 struct stap_parse_info *p) 1153 { 1154 if (*p->arg == '[') 1155 { 1156 /* Temporary holder for lookahead. */ 1157 const char *tmp = p->arg; 1158 char *endp; 1159 /* Used to save the register name. */ 1160 const char *start; 1161 char *regname; 1162 int len, offset; 1163 int got_minus = 0; 1164 long displacement; 1165 struct stoken str; 1166 1167 ++tmp; 1168 start = tmp; 1169 1170 /* Register name. */ 1171 while (isalnum (*tmp)) 1172 ++tmp; 1173 1174 if (*tmp != ',') 1175 return 0; 1176 1177 len = tmp - start; 1178 regname = alloca (len + 2); 1179 1180 offset = 0; 1181 if (isdigit (*start)) 1182 { 1183 /* If we are dealing with a register whose name begins with a 1184 digit, it means we should prefix the name with the letter 1185 `r', because GDB expects this name pattern. Otherwise (e.g., 1186 we are dealing with the register `fp'), we don't need to 1187 add such a prefix. */ 1188 regname[0] = 'r'; 1189 offset = 1; 1190 } 1191 1192 strncpy (regname + offset, start, len); 1193 len += offset; 1194 regname[len] = '\0'; 1195 1196 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1) 1197 error (_("Invalid register name `%s' on expression `%s'."), 1198 regname, p->saved_arg); 1199 1200 ++tmp; 1201 tmp = skip_spaces_const (tmp); 1202 if (*tmp == '#' || *tmp == '$') 1203 ++tmp; 1204 1205 if (*tmp == '-') 1206 { 1207 ++tmp; 1208 got_minus = 1; 1209 } 1210 1211 displacement = strtol (tmp, &endp, 10); 1212 tmp = endp; 1213 1214 /* Skipping last `]'. */ 1215 if (*tmp++ != ']') 1216 return 0; 1217 1218 /* The displacement. */ 1219 write_exp_elt_opcode (&p->pstate, OP_LONG); 1220 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long); 1221 write_exp_elt_longcst (&p->pstate, displacement); 1222 write_exp_elt_opcode (&p->pstate, OP_LONG); 1223 if (got_minus) 1224 write_exp_elt_opcode (&p->pstate, UNOP_NEG); 1225 1226 /* The register name. */ 1227 write_exp_elt_opcode (&p->pstate, OP_REGISTER); 1228 str.ptr = regname; 1229 str.length = len; 1230 write_exp_string (&p->pstate, str); 1231 write_exp_elt_opcode (&p->pstate, OP_REGISTER); 1232 1233 write_exp_elt_opcode (&p->pstate, BINOP_ADD); 1234 1235 /* Casting to the expected type. */ 1236 write_exp_elt_opcode (&p->pstate, UNOP_CAST); 1237 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type)); 1238 write_exp_elt_opcode (&p->pstate, UNOP_CAST); 1239 1240 write_exp_elt_opcode (&p->pstate, UNOP_IND); 1241 1242 p->arg = tmp; 1243 } 1244 else 1245 return 0; 1246 1247 return 1; 1248 } 1249 1250 /* ARM process record-replay constructs: syscall, signal etc. */ 1251 1252 struct linux_record_tdep arm_linux_record_tdep; 1253 1254 /* arm_canonicalize_syscall maps from the native arm Linux set 1255 of syscall ids into a canonical set of syscall ids used by 1256 process record. */ 1257 1258 static enum gdb_syscall 1259 arm_canonicalize_syscall (int syscall) 1260 { 1261 enum { sys_process_vm_writev = 377 }; 1262 1263 if (syscall <= gdb_sys_sched_getaffinity) 1264 return syscall; 1265 else if (syscall >= 243 && syscall <= 247) 1266 return syscall + 2; 1267 else if (syscall >= 248 && syscall <= 253) 1268 return syscall + 4; 1269 1270 return -1; 1271 } 1272 1273 /* Record all registers but PC register for process-record. */ 1274 1275 static int 1276 arm_all_but_pc_registers_record (struct regcache *regcache) 1277 { 1278 int i; 1279 1280 for (i = 0; i < ARM_PC_REGNUM; i++) 1281 { 1282 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i)) 1283 return -1; 1284 } 1285 1286 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM)) 1287 return -1; 1288 1289 return 0; 1290 } 1291 1292 /* Handler for arm system call instruction recording. */ 1293 1294 static int 1295 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number) 1296 { 1297 int ret = 0; 1298 enum gdb_syscall syscall_gdb; 1299 1300 syscall_gdb = arm_canonicalize_syscall (svc_number); 1301 1302 if (syscall_gdb < 0) 1303 { 1304 printf_unfiltered (_("Process record and replay target doesn't " 1305 "support syscall number %s\n"), 1306 plongest (svc_number)); 1307 return -1; 1308 } 1309 1310 if (syscall_gdb == gdb_sys_sigreturn 1311 || syscall_gdb == gdb_sys_rt_sigreturn) 1312 { 1313 if (arm_all_but_pc_registers_record (regcache)) 1314 return -1; 1315 return 0; 1316 } 1317 1318 ret = record_linux_system_call (syscall_gdb, regcache, 1319 &arm_linux_record_tdep); 1320 if (ret != 0) 1321 return ret; 1322 1323 /* Record the return value of the system call. */ 1324 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM)) 1325 return -1; 1326 /* Record LR. */ 1327 if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM)) 1328 return -1; 1329 /* Record CPSR. */ 1330 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM)) 1331 return -1; 1332 1333 return 0; 1334 } 1335 1336 /* Implement the skip_trampoline_code gdbarch method. */ 1337 1338 static CORE_ADDR 1339 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) 1340 { 1341 CORE_ADDR target_pc = arm_skip_stub (frame, pc); 1342 1343 if (target_pc != 0) 1344 return target_pc; 1345 1346 return find_solib_trampoline_target (frame, pc); 1347 } 1348 1349 static void 1350 arm_linux_init_abi (struct gdbarch_info info, 1351 struct gdbarch *gdbarch) 1352 { 1353 static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL }; 1354 static const char *const stap_register_prefixes[] = { "r", NULL }; 1355 static const char *const stap_register_indirection_prefixes[] = { "[", 1356 NULL }; 1357 static const char *const stap_register_indirection_suffixes[] = { "]", 1358 NULL }; 1359 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1360 1361 linux_init_abi (info, gdbarch); 1362 1363 tdep->lowest_pc = 0x8000; 1364 if (info.byte_order_for_code == BFD_ENDIAN_BIG) 1365 { 1366 if (tdep->arm_abi == ARM_ABI_AAPCS) 1367 tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint; 1368 else 1369 tdep->arm_breakpoint = arm_linux_arm_be_breakpoint; 1370 tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint; 1371 tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint; 1372 } 1373 else 1374 { 1375 if (tdep->arm_abi == ARM_ABI_AAPCS) 1376 tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint; 1377 else 1378 tdep->arm_breakpoint = arm_linux_arm_le_breakpoint; 1379 tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint; 1380 tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint; 1381 } 1382 tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint); 1383 tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint); 1384 tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint); 1385 1386 if (tdep->fp_model == ARM_FLOAT_AUTO) 1387 tdep->fp_model = ARM_FLOAT_FPA; 1388 1389 switch (tdep->fp_model) 1390 { 1391 case ARM_FLOAT_FPA: 1392 tdep->jb_pc = ARM_LINUX_JB_PC_FPA; 1393 break; 1394 case ARM_FLOAT_SOFT_FPA: 1395 case ARM_FLOAT_SOFT_VFP: 1396 case ARM_FLOAT_VFP: 1397 tdep->jb_pc = ARM_LINUX_JB_PC_EABI; 1398 break; 1399 default: 1400 internal_error 1401 (__FILE__, __LINE__, 1402 _("arm_linux_init_abi: Floating point model not supported")); 1403 break; 1404 } 1405 tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE; 1406 1407 set_solib_svr4_fetch_link_map_offsets 1408 (gdbarch, svr4_ilp32_fetch_link_map_offsets); 1409 1410 /* Single stepping. */ 1411 set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step); 1412 1413 /* Shared library handling. */ 1414 set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code); 1415 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 1416 1417 /* Enable TLS support. */ 1418 set_gdbarch_fetch_tls_load_module_address (gdbarch, 1419 svr4_fetch_objfile_link_map); 1420 1421 tramp_frame_prepend_unwinder (gdbarch, 1422 &arm_linux_sigreturn_tramp_frame); 1423 tramp_frame_prepend_unwinder (gdbarch, 1424 &arm_linux_rt_sigreturn_tramp_frame); 1425 tramp_frame_prepend_unwinder (gdbarch, 1426 &arm_eabi_linux_sigreturn_tramp_frame); 1427 tramp_frame_prepend_unwinder (gdbarch, 1428 &arm_eabi_linux_rt_sigreturn_tramp_frame); 1429 tramp_frame_prepend_unwinder (gdbarch, 1430 &thumb2_eabi_linux_sigreturn_tramp_frame); 1431 tramp_frame_prepend_unwinder (gdbarch, 1432 &thumb2_eabi_linux_rt_sigreturn_tramp_frame); 1433 tramp_frame_prepend_unwinder (gdbarch, 1434 &arm_linux_restart_syscall_tramp_frame); 1435 tramp_frame_prepend_unwinder (gdbarch, 1436 &arm_kernel_linux_restart_syscall_tramp_frame); 1437 1438 /* Core file support. */ 1439 set_gdbarch_iterate_over_regset_sections 1440 (gdbarch, arm_linux_iterate_over_regset_sections); 1441 set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description); 1442 1443 set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type); 1444 1445 /* Displaced stepping. */ 1446 set_gdbarch_displaced_step_copy_insn (gdbarch, 1447 arm_linux_displaced_step_copy_insn); 1448 set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup); 1449 set_gdbarch_displaced_step_free_closure (gdbarch, 1450 simple_displaced_step_free_closure); 1451 set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point); 1452 1453 /* Reversible debugging, process record. */ 1454 set_gdbarch_process_record (gdbarch, arm_process_record); 1455 1456 /* SystemTap functions. */ 1457 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes); 1458 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes); 1459 set_gdbarch_stap_register_indirection_prefixes (gdbarch, 1460 stap_register_indirection_prefixes); 1461 set_gdbarch_stap_register_indirection_suffixes (gdbarch, 1462 stap_register_indirection_suffixes); 1463 set_gdbarch_stap_gdb_register_prefix (gdbarch, "r"); 1464 set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand); 1465 set_gdbarch_stap_parse_special_token (gdbarch, 1466 arm_stap_parse_special_token); 1467 1468 tdep->syscall_next_pc = arm_linux_syscall_next_pc; 1469 1470 /* `catch syscall' */ 1471 set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml"); 1472 set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number); 1473 1474 /* Syscall record. */ 1475 tdep->arm_syscall_record = arm_linux_syscall_record; 1476 1477 /* Initialize the arm_linux_record_tdep. */ 1478 /* These values are the size of the type that will be used in a system 1479 call. They are obtained from Linux Kernel source. */ 1480 arm_linux_record_tdep.size_pointer 1481 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT; 1482 arm_linux_record_tdep.size__old_kernel_stat = 32; 1483 arm_linux_record_tdep.size_tms = 16; 1484 arm_linux_record_tdep.size_loff_t = 8; 1485 arm_linux_record_tdep.size_flock = 16; 1486 arm_linux_record_tdep.size_oldold_utsname = 45; 1487 arm_linux_record_tdep.size_ustat = 20; 1488 arm_linux_record_tdep.size_old_sigaction = 140; 1489 arm_linux_record_tdep.size_old_sigset_t = 128; 1490 arm_linux_record_tdep.size_rlimit = 8; 1491 arm_linux_record_tdep.size_rusage = 72; 1492 arm_linux_record_tdep.size_timeval = 8; 1493 arm_linux_record_tdep.size_timezone = 8; 1494 arm_linux_record_tdep.size_old_gid_t = 2; 1495 arm_linux_record_tdep.size_old_uid_t = 2; 1496 arm_linux_record_tdep.size_fd_set = 128; 1497 arm_linux_record_tdep.size_dirent = 268; 1498 arm_linux_record_tdep.size_dirent64 = 276; 1499 arm_linux_record_tdep.size_statfs = 64; 1500 arm_linux_record_tdep.size_statfs64 = 84; 1501 arm_linux_record_tdep.size_sockaddr = 16; 1502 arm_linux_record_tdep.size_int 1503 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; 1504 arm_linux_record_tdep.size_long 1505 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 1506 arm_linux_record_tdep.size_ulong 1507 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 1508 arm_linux_record_tdep.size_msghdr = 28; 1509 arm_linux_record_tdep.size_itimerval = 16; 1510 arm_linux_record_tdep.size_stat = 88; 1511 arm_linux_record_tdep.size_old_utsname = 325; 1512 arm_linux_record_tdep.size_sysinfo = 64; 1513 arm_linux_record_tdep.size_msqid_ds = 88; 1514 arm_linux_record_tdep.size_shmid_ds = 84; 1515 arm_linux_record_tdep.size_new_utsname = 390; 1516 arm_linux_record_tdep.size_timex = 128; 1517 arm_linux_record_tdep.size_mem_dqinfo = 24; 1518 arm_linux_record_tdep.size_if_dqblk = 68; 1519 arm_linux_record_tdep.size_fs_quota_stat = 68; 1520 arm_linux_record_tdep.size_timespec = 8; 1521 arm_linux_record_tdep.size_pollfd = 8; 1522 arm_linux_record_tdep.size_NFS_FHSIZE = 32; 1523 arm_linux_record_tdep.size_knfsd_fh = 132; 1524 arm_linux_record_tdep.size_TASK_COMM_LEN = 16; 1525 arm_linux_record_tdep.size_sigaction = 140; 1526 arm_linux_record_tdep.size_sigset_t = 8; 1527 arm_linux_record_tdep.size_siginfo_t = 128; 1528 arm_linux_record_tdep.size_cap_user_data_t = 12; 1529 arm_linux_record_tdep.size_stack_t = 12; 1530 arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long; 1531 arm_linux_record_tdep.size_stat64 = 96; 1532 arm_linux_record_tdep.size_gid_t = 2; 1533 arm_linux_record_tdep.size_uid_t = 2; 1534 arm_linux_record_tdep.size_PAGE_SIZE = 4096; 1535 arm_linux_record_tdep.size_flock64 = 24; 1536 arm_linux_record_tdep.size_user_desc = 16; 1537 arm_linux_record_tdep.size_io_event = 32; 1538 arm_linux_record_tdep.size_iocb = 64; 1539 arm_linux_record_tdep.size_epoll_event = 12; 1540 arm_linux_record_tdep.size_itimerspec 1541 = arm_linux_record_tdep.size_timespec * 2; 1542 arm_linux_record_tdep.size_mq_attr = 32; 1543 arm_linux_record_tdep.size_siginfo = 128; 1544 arm_linux_record_tdep.size_termios = 36; 1545 arm_linux_record_tdep.size_termios2 = 44; 1546 arm_linux_record_tdep.size_pid_t = 4; 1547 arm_linux_record_tdep.size_winsize = 8; 1548 arm_linux_record_tdep.size_serial_struct = 60; 1549 arm_linux_record_tdep.size_serial_icounter_struct = 80; 1550 arm_linux_record_tdep.size_hayes_esp_config = 12; 1551 arm_linux_record_tdep.size_size_t = 4; 1552 arm_linux_record_tdep.size_iovec = 8; 1553 1554 /* These values are the second argument of system call "sys_ioctl". 1555 They are obtained from Linux Kernel source. */ 1556 arm_linux_record_tdep.ioctl_TCGETS = 0x5401; 1557 arm_linux_record_tdep.ioctl_TCSETS = 0x5402; 1558 arm_linux_record_tdep.ioctl_TCSETSW = 0x5403; 1559 arm_linux_record_tdep.ioctl_TCSETSF = 0x5404; 1560 arm_linux_record_tdep.ioctl_TCGETA = 0x5405; 1561 arm_linux_record_tdep.ioctl_TCSETA = 0x5406; 1562 arm_linux_record_tdep.ioctl_TCSETAW = 0x5407; 1563 arm_linux_record_tdep.ioctl_TCSETAF = 0x5408; 1564 arm_linux_record_tdep.ioctl_TCSBRK = 0x5409; 1565 arm_linux_record_tdep.ioctl_TCXONC = 0x540a; 1566 arm_linux_record_tdep.ioctl_TCFLSH = 0x540b; 1567 arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c; 1568 arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d; 1569 arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e; 1570 arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f; 1571 arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410; 1572 arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411; 1573 arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412; 1574 arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413; 1575 arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414; 1576 arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415; 1577 arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416; 1578 arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417; 1579 arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418; 1580 arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419; 1581 arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a; 1582 arm_linux_record_tdep.ioctl_FIONREAD = 0x541b; 1583 arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD; 1584 arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c; 1585 arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d; 1586 arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e; 1587 arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f; 1588 arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420; 1589 arm_linux_record_tdep.ioctl_FIONBIO = 0x5421; 1590 arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422; 1591 arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423; 1592 arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424; 1593 arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425; 1594 arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426; 1595 arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427; 1596 arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428; 1597 arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429; 1598 arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a; 1599 arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b; 1600 arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c; 1601 arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d; 1602 arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430; 1603 arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431; 1604 arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450; 1605 arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451; 1606 arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452; 1607 arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453; 1608 arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454; 1609 arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455; 1610 arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456; 1611 arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457; 1612 arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458; 1613 arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459; 1614 arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a; 1615 arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b; 1616 arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c; 1617 arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d; 1618 arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e; 1619 arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f; 1620 arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460; 1621 1622 /* These values are the second argument of system call "sys_fcntl" 1623 and "sys_fcntl64". They are obtained from Linux Kernel source. */ 1624 arm_linux_record_tdep.fcntl_F_GETLK = 5; 1625 arm_linux_record_tdep.fcntl_F_GETLK64 = 12; 1626 arm_linux_record_tdep.fcntl_F_SETLK64 = 13; 1627 arm_linux_record_tdep.fcntl_F_SETLKW64 = 14; 1628 1629 arm_linux_record_tdep.arg1 = ARM_A1_REGNUM + 1; 1630 arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 2; 1631 arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 3; 1632 arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3; 1633 } 1634 1635 /* Provide a prototype to silence -Wmissing-prototypes. */ 1636 extern initialize_file_ftype _initialize_arm_linux_tdep; 1637 1638 void 1639 _initialize_arm_linux_tdep (void) 1640 { 1641 gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX, 1642 arm_linux_init_abi); 1643 } 1644