arm-linux-tdep.c revision 1.1.1.10
1 /* GNU/Linux on ARM target support. 2 3 Copyright (C) 1999-2024 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 "extract-store-integer.h" 21 #include "target.h" 22 #include "value.h" 23 #include "gdbtypes.h" 24 #include "gdbcore.h" 25 #include "frame.h" 26 #include "regcache.h" 27 #include "solib-svr4.h" 28 #include "osabi.h" 29 #include "regset.h" 30 #include "trad-frame.h" 31 #include "tramp-frame.h" 32 #include "breakpoint.h" 33 #include "auxv.h" 34 #include "xml-syscall.h" 35 #include "expop.h" 36 37 #include "aarch32-tdep.h" 38 #include "arch/arm.h" 39 #include "arch/arm-get-next-pcs.h" 40 #include "arch/arm-linux.h" 41 #include "arm-tdep.h" 42 #include "arm-linux-tdep.h" 43 #include "linux-tdep.h" 44 #include "glibc-tdep.h" 45 #include "arch-utils.h" 46 #include "inferior.h" 47 #include "infrun.h" 48 #include "gdbthread.h" 49 #include "symfile.h" 50 51 #include "record-full.h" 52 #include "linux-record.h" 53 54 #include "cli/cli-utils.h" 55 #include "stap-probe.h" 56 #include "parser-defs.h" 57 #include "user-regs.h" 58 #include <ctype.h> 59 #include "elf/common.h" 60 61 /* Under ARM GNU/Linux the traditional way of performing a breakpoint 62 is to execute a particular software interrupt, rather than use a 63 particular undefined instruction to provoke a trap. Upon execution 64 of the software interrupt the kernel stops the inferior with a 65 SIGTRAP, and wakes the debugger. */ 66 67 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef }; 68 69 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 }; 70 71 /* However, the EABI syscall interface (new in Nov. 2005) does not look at 72 the operand of the swi if old-ABI compatibility is disabled. Therefore, 73 use an undefined instruction instead. This is supported as of kernel 74 version 2.5.70 (May 2003), so should be a safe assumption for EABI 75 binaries. */ 76 77 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 }; 78 79 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 }; 80 81 /* All the kernels which support Thumb support using a specific undefined 82 instruction for the Thumb breakpoint. */ 83 84 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01}; 85 86 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde}; 87 88 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks, 89 we must use a length-appropriate breakpoint for 32-bit Thumb 90 instructions. See also thumb_get_next_pc. */ 91 92 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 }; 93 94 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 }; 95 96 /* Description of the longjmp buffer. The buffer is treated as an array of 97 elements of size ARM_LINUX_JB_ELEMENT_SIZE. 98 99 The location of saved registers in this buffer (in particular the PC 100 to use after longjmp is called) varies depending on the ABI (in 101 particular the FP model) and also (possibly) the C Library. */ 102 #define ARM_LINUX_JB_ELEMENT_SIZE ARM_INT_REGISTER_SIZE 103 /* For the FPA model the PC is at offset 21 in the buffer. */ 104 #define ARM_LINUX_JB_PC_FPA 21 105 /* For glibc 2.20 and later the PC is at offset 1, see glibc commit 80a56cc3ee 106 ("ARM: Add SystemTap probes to longjmp and setjmp."). 107 For newlib and uclibc, this is not correct, we need osabi settings to deal 108 with those, see PR31854 and PR31856. Likewise for older versions of 109 glibc. */ 110 #define ARM_LINUX_JB_PC_EABI 1 111 112 /* 113 Dynamic Linking on ARM GNU/Linux 114 -------------------------------- 115 116 Note: PLT = procedure linkage table 117 GOT = global offset table 118 119 As much as possible, ELF dynamic linking defers the resolution of 120 jump/call addresses until the last minute. The technique used is 121 inspired by the i386 ELF design, and is based on the following 122 constraints. 123 124 1) The calling technique should not force a change in the assembly 125 code produced for apps; it MAY cause changes in the way assembly 126 code is produced for position independent code (i.e. shared 127 libraries). 128 129 2) The technique must be such that all executable areas must not be 130 modified; and any modified areas must not be executed. 131 132 To do this, there are three steps involved in a typical jump: 133 134 1) in the code 135 2) through the PLT 136 3) using a pointer from the GOT 137 138 When the executable or library is first loaded, each GOT entry is 139 initialized to point to the code which implements dynamic name 140 resolution and code finding. This is normally a function in the 141 program interpreter (on ARM GNU/Linux this is usually 142 ld-linux.so.2, but it does not have to be). On the first 143 invocation, the function is located and the GOT entry is replaced 144 with the real function address. Subsequent calls go through steps 145 1, 2 and 3 and end up calling the real code. 146 147 1) In the code: 148 149 b function_call 150 bl function_call 151 152 This is typical ARM code using the 26 bit relative branch or branch 153 and link instructions. The target of the instruction 154 (function_call is usually the address of the function to be called. 155 In position independent code, the target of the instruction is 156 actually an entry in the PLT when calling functions in a shared 157 library. Note that this call is identical to a normal function 158 call, only the target differs. 159 160 2) In the PLT: 161 162 The PLT is a synthetic area, created by the linker. It exists in 163 both executables and libraries. It is an array of stubs, one per 164 imported function call. It looks like this: 165 166 PLT[0]: 167 str lr, [sp, #-4]! @push the return address (lr) 168 ldr lr, [pc, #16] @load from 6 words ahead 169 add lr, pc, lr @form an address for GOT[0] 170 ldr pc, [lr, #8]! @jump to the contents of that addr 171 172 The return address (lr) is pushed on the stack and used for 173 calculations. The load on the second line loads the lr with 174 &GOT[3] - . - 20. The addition on the third leaves: 175 176 lr = (&GOT[3] - . - 20) + (. + 8) 177 lr = (&GOT[3] - 12) 178 lr = &GOT[0] 179 180 On the fourth line, the pc and lr are both updated, so that: 181 182 pc = GOT[2] 183 lr = &GOT[0] + 8 184 = &GOT[2] 185 186 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little 187 "tight", but allows us to keep all the PLT entries the same size. 188 189 PLT[n+1]: 190 ldr ip, [pc, #4] @load offset from gotoff 191 add ip, pc, ip @add the offset to the pc 192 ldr pc, [ip] @jump to that address 193 gotoff: .word GOT[n+3] - . 194 195 The load on the first line, gets an offset from the fourth word of 196 the PLT entry. The add on the second line makes ip = &GOT[n+3], 197 which contains either a pointer to PLT[0] (the fixup trampoline) or 198 a pointer to the actual code. 199 200 3) In the GOT: 201 202 The GOT contains helper pointers for both code (PLT) fixups and 203 data fixups. The first 3 entries of the GOT are special. The next 204 M entries (where M is the number of entries in the PLT) belong to 205 the PLT fixups. The next D (all remaining) entries belong to 206 various data fixups. The actual size of the GOT is 3 + M + D. 207 208 The GOT is also a synthetic area, created by the linker. It exists 209 in both executables and libraries. When the GOT is first 210 initialized , all the GOT entries relating to PLT fixups are 211 pointing to code back at PLT[0]. 212 213 The special entries in the GOT are: 214 215 GOT[0] = linked list pointer used by the dynamic loader 216 GOT[1] = pointer to the reloc table for this module 217 GOT[2] = pointer to the fixup/resolver code 218 219 The first invocation of function call comes through and uses the 220 fixup/resolver code. On the entry to the fixup/resolver code: 221 222 ip = &GOT[n+3] 223 lr = &GOT[2] 224 stack[0] = return address (lr) of the function call 225 [r0, r1, r2, r3] are still the arguments to the function call 226 227 This is enough information for the fixup/resolver code to work 228 with. Before the fixup/resolver code returns, it actually calls 229 the requested function and repairs &GOT[n+3]. */ 230 231 /* The constants below were determined by examining the following files 232 in the linux kernel sources: 233 234 arch/arm/kernel/signal.c 235 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN 236 include/asm-arm/unistd.h 237 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */ 238 239 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077 240 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad 241 242 /* For ARM EABI, the syscall number is not in the SWI instruction 243 (instead it is loaded into r7). We recognize the pattern that 244 glibc uses... alternatively, we could arrange to do this by 245 function name, but they are not always exported. */ 246 #define ARM_SET_R7_SIGRETURN 0xe3a07077 247 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad 248 #define ARM_EABI_SYSCALL 0xef000000 249 250 /* Equivalent patterns for Thumb2. */ 251 #define THUMB2_SET_R7_SIGRETURN1 0xf04f 252 #define THUMB2_SET_R7_SIGRETURN2 0x0777 253 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f 254 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad 255 #define THUMB2_EABI_SYSCALL 0xdf00 256 257 /* OABI syscall restart trampoline, used for EABI executables too 258 whenever OABI support has been enabled in the kernel. */ 259 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000 260 #define ARM_LDR_PC_SP_12 0xe49df00c 261 #define ARM_LDR_PC_SP_4 0xe49df004 262 263 /* Syscall number for sigreturn. */ 264 #define ARM_SIGRETURN 119 265 /* Syscall number for rt_sigreturn. */ 266 #define ARM_RT_SIGRETURN 173 267 268 static CORE_ADDR 269 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self); 270 271 /* Operation function pointers for get_next_pcs. */ 272 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops = { 273 arm_get_next_pcs_read_memory_unsigned_integer, 274 arm_linux_get_next_pcs_syscall_next_pc, 275 arm_get_next_pcs_addr_bits_remove, 276 arm_get_next_pcs_is_thumb, 277 arm_linux_get_next_pcs_fixup, 278 }; 279 280 static void 281 arm_linux_sigtramp_cache (const frame_info_ptr &this_frame, 282 struct trad_frame_cache *this_cache, 283 CORE_ADDR func, int regs_offset) 284 { 285 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 286 CORE_ADDR base = sp + regs_offset; 287 int i; 288 289 for (i = 0; i < 16; i++) 290 trad_frame_set_reg_addr (this_cache, i, base + i * 4); 291 292 trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4); 293 294 /* The VFP or iWMMXt registers may be saved on the stack, but there's 295 no reliable way to restore them (yet). */ 296 297 /* Save a frame ID. */ 298 trad_frame_set_id (this_cache, frame_id_build (sp, func)); 299 } 300 301 /* See arm-linux.h for stack layout details. */ 302 static void 303 arm_linux_sigreturn_init (const struct tramp_frame *self, 304 const frame_info_ptr &this_frame, 305 struct trad_frame_cache *this_cache, 306 CORE_ADDR func) 307 { 308 struct gdbarch *gdbarch = get_frame_arch (this_frame); 309 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 310 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 311 ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order); 312 313 if (uc_flags == ARM_NEW_SIGFRAME_MAGIC) 314 arm_linux_sigtramp_cache (this_frame, this_cache, func, 315 ARM_UCONTEXT_SIGCONTEXT 316 + ARM_SIGCONTEXT_R0); 317 else 318 arm_linux_sigtramp_cache (this_frame, this_cache, func, 319 ARM_SIGCONTEXT_R0); 320 } 321 322 static void 323 arm_linux_rt_sigreturn_init (const struct tramp_frame *self, 324 const frame_info_ptr &this_frame, 325 struct trad_frame_cache *this_cache, 326 CORE_ADDR func) 327 { 328 struct gdbarch *gdbarch = get_frame_arch (this_frame); 329 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 330 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 331 ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order); 332 333 if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO) 334 arm_linux_sigtramp_cache (this_frame, this_cache, func, 335 ARM_OLD_RT_SIGFRAME_UCONTEXT 336 + ARM_UCONTEXT_SIGCONTEXT 337 + ARM_SIGCONTEXT_R0); 338 else 339 arm_linux_sigtramp_cache (this_frame, this_cache, func, 340 ARM_NEW_RT_SIGFRAME_UCONTEXT 341 + ARM_UCONTEXT_SIGCONTEXT 342 + ARM_SIGCONTEXT_R0); 343 } 344 345 static void 346 arm_linux_restart_syscall_init (const struct tramp_frame *self, 347 const frame_info_ptr &this_frame, 348 struct trad_frame_cache *this_cache, 349 CORE_ADDR func) 350 { 351 struct gdbarch *gdbarch = get_frame_arch (this_frame); 352 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM); 353 CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4); 354 CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM); 355 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch); 356 int sp_offset; 357 358 /* There are two variants of this trampoline; with older kernels, the 359 stub is placed on the stack, while newer kernels use the stub from 360 the vector page. They are identical except that the older version 361 increments SP by 12 (to skip stored PC and the stub itself), while 362 the newer version increments SP only by 4 (just the stored PC). */ 363 if (self->insn[1].bytes == ARM_LDR_PC_SP_4) 364 sp_offset = 4; 365 else 366 sp_offset = 12; 367 368 /* Update Thumb bit in CPSR. */ 369 if (pc & 1) 370 cpsr |= t_bit; 371 else 372 cpsr &= ~t_bit; 373 374 /* Remove Thumb bit from PC. */ 375 pc = gdbarch_addr_bits_remove (gdbarch, pc); 376 377 /* Save previous register values. */ 378 trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset); 379 trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc); 380 trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr); 381 382 /* Save a frame ID. */ 383 trad_frame_set_id (this_cache, frame_id_build (sp, func)); 384 } 385 386 static struct tramp_frame arm_linux_sigreturn_tramp_frame = { 387 SIGTRAMP_FRAME, 388 4, 389 { 390 { ARM_LINUX_SIGRETURN_INSTR, ULONGEST_MAX }, 391 { TRAMP_SENTINEL_INSN } 392 }, 393 arm_linux_sigreturn_init 394 }; 395 396 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = { 397 SIGTRAMP_FRAME, 398 4, 399 { 400 { ARM_LINUX_RT_SIGRETURN_INSTR, ULONGEST_MAX }, 401 { TRAMP_SENTINEL_INSN } 402 }, 403 arm_linux_rt_sigreturn_init 404 }; 405 406 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = { 407 SIGTRAMP_FRAME, 408 4, 409 { 410 { ARM_SET_R7_SIGRETURN, ULONGEST_MAX }, 411 { ARM_EABI_SYSCALL, ULONGEST_MAX }, 412 { TRAMP_SENTINEL_INSN } 413 }, 414 arm_linux_sigreturn_init 415 }; 416 417 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = { 418 SIGTRAMP_FRAME, 419 4, 420 { 421 { ARM_SET_R7_RT_SIGRETURN, ULONGEST_MAX }, 422 { ARM_EABI_SYSCALL, ULONGEST_MAX }, 423 { TRAMP_SENTINEL_INSN } 424 }, 425 arm_linux_rt_sigreturn_init 426 }; 427 428 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = { 429 SIGTRAMP_FRAME, 430 2, 431 { 432 { THUMB2_SET_R7_SIGRETURN1, ULONGEST_MAX }, 433 { THUMB2_SET_R7_SIGRETURN2, ULONGEST_MAX }, 434 { THUMB2_EABI_SYSCALL, ULONGEST_MAX }, 435 { TRAMP_SENTINEL_INSN } 436 }, 437 arm_linux_sigreturn_init 438 }; 439 440 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = { 441 SIGTRAMP_FRAME, 442 2, 443 { 444 { THUMB2_SET_R7_RT_SIGRETURN1, ULONGEST_MAX }, 445 { THUMB2_SET_R7_RT_SIGRETURN2, ULONGEST_MAX }, 446 { THUMB2_EABI_SYSCALL, ULONGEST_MAX }, 447 { TRAMP_SENTINEL_INSN } 448 }, 449 arm_linux_rt_sigreturn_init 450 }; 451 452 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = { 453 NORMAL_FRAME, 454 4, 455 { 456 { ARM_OABI_SYSCALL_RESTART_SYSCALL, ULONGEST_MAX }, 457 { ARM_LDR_PC_SP_12, ULONGEST_MAX }, 458 { TRAMP_SENTINEL_INSN } 459 }, 460 arm_linux_restart_syscall_init 461 }; 462 463 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = { 464 NORMAL_FRAME, 465 4, 466 { 467 { ARM_OABI_SYSCALL_RESTART_SYSCALL, ULONGEST_MAX }, 468 { ARM_LDR_PC_SP_4, ULONGEST_MAX }, 469 { TRAMP_SENTINEL_INSN } 470 }, 471 arm_linux_restart_syscall_init 472 }; 473 474 /* Core file and register set support. */ 475 476 #define ARM_LINUX_SIZEOF_GREGSET (18 * ARM_INT_REGISTER_SIZE) 477 478 void 479 arm_linux_supply_gregset (const struct regset *regset, 480 struct regcache *regcache, 481 int regnum, const void *gregs_buf, size_t len) 482 { 483 struct gdbarch *gdbarch = regcache->arch (); 484 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 485 const gdb_byte *gregs = (const gdb_byte *) gregs_buf; 486 int regno; 487 CORE_ADDR reg_pc; 488 gdb_byte pc_buf[ARM_INT_REGISTER_SIZE]; 489 490 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) 491 if (regnum == -1 || regnum == regno) 492 regcache->raw_supply (regno, gregs + ARM_INT_REGISTER_SIZE * regno); 493 494 if (regnum == ARM_PS_REGNUM || regnum == -1) 495 { 496 if (arm_apcs_32) 497 regcache->raw_supply (ARM_PS_REGNUM, 498 gregs + ARM_INT_REGISTER_SIZE * ARM_CPSR_GREGNUM); 499 else 500 regcache->raw_supply (ARM_PS_REGNUM, 501 gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM); 502 } 503 504 if (regnum == ARM_PC_REGNUM || regnum == -1) 505 { 506 reg_pc = extract_unsigned_integer ( 507 gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM, 508 ARM_INT_REGISTER_SIZE, byte_order); 509 reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc); 510 store_unsigned_integer (pc_buf, ARM_INT_REGISTER_SIZE, byte_order, 511 reg_pc); 512 regcache->raw_supply (ARM_PC_REGNUM, pc_buf); 513 } 514 } 515 516 void 517 arm_linux_collect_gregset (const struct regset *regset, 518 const struct regcache *regcache, 519 int regnum, void *gregs_buf, size_t len) 520 { 521 gdb_byte *gregs = (gdb_byte *) gregs_buf; 522 int regno; 523 524 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) 525 if (regnum == -1 || regnum == regno) 526 regcache->raw_collect (regno, 527 gregs + ARM_INT_REGISTER_SIZE * regno); 528 529 if (regnum == ARM_PS_REGNUM || regnum == -1) 530 { 531 if (arm_apcs_32) 532 regcache->raw_collect (ARM_PS_REGNUM, 533 gregs + ARM_INT_REGISTER_SIZE * ARM_CPSR_GREGNUM); 534 else 535 regcache->raw_collect (ARM_PS_REGNUM, 536 gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM); 537 } 538 539 if (regnum == ARM_PC_REGNUM || regnum == -1) 540 regcache->raw_collect (ARM_PC_REGNUM, 541 gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM); 542 } 543 544 /* Support for register format used by the NWFPE FPA emulator. */ 545 546 #define typeNone 0x00 547 #define typeSingle 0x01 548 #define typeDouble 0x02 549 #define typeExtended 0x03 550 551 void 552 supply_nwfpe_register (struct regcache *regcache, int regno, 553 const gdb_byte *regs) 554 { 555 const gdb_byte *reg_data; 556 gdb_byte reg_tag; 557 gdb_byte buf[ARM_FP_REGISTER_SIZE]; 558 559 reg_data = regs + (regno - ARM_F0_REGNUM) * ARM_FP_REGISTER_SIZE; 560 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET]; 561 memset (buf, 0, ARM_FP_REGISTER_SIZE); 562 563 switch (reg_tag) 564 { 565 case typeSingle: 566 memcpy (buf, reg_data, 4); 567 break; 568 case typeDouble: 569 memcpy (buf, reg_data + 4, 4); 570 memcpy (buf + 4, reg_data, 4); 571 break; 572 case typeExtended: 573 /* We want sign and exponent, then least significant bits, 574 then most significant. NWFPE does sign, most, least. */ 575 memcpy (buf, reg_data, 4); 576 memcpy (buf + 4, reg_data + 8, 4); 577 memcpy (buf + 8, reg_data + 4, 4); 578 break; 579 default: 580 break; 581 } 582 583 regcache->raw_supply (regno, buf); 584 } 585 586 void 587 collect_nwfpe_register (const struct regcache *regcache, int regno, 588 gdb_byte *regs) 589 { 590 gdb_byte *reg_data; 591 gdb_byte reg_tag; 592 gdb_byte buf[ARM_FP_REGISTER_SIZE]; 593 594 regcache->raw_collect (regno, buf); 595 596 /* NOTE drow/2006-06-07: This code uses the tag already in the 597 register buffer. I've preserved that when moving the code 598 from the native file to the target file. But this doesn't 599 always make sense. */ 600 601 reg_data = regs + (regno - ARM_F0_REGNUM) * ARM_FP_REGISTER_SIZE; 602 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET]; 603 604 switch (reg_tag) 605 { 606 case typeSingle: 607 memcpy (reg_data, buf, 4); 608 break; 609 case typeDouble: 610 memcpy (reg_data, buf + 4, 4); 611 memcpy (reg_data + 4, buf, 4); 612 break; 613 case typeExtended: 614 memcpy (reg_data, buf, 4); 615 memcpy (reg_data + 4, buf + 8, 4); 616 memcpy (reg_data + 8, buf + 4, 4); 617 break; 618 default: 619 break; 620 } 621 } 622 623 void 624 arm_linux_supply_nwfpe (const struct regset *regset, 625 struct regcache *regcache, 626 int regnum, const void *regs_buf, size_t len) 627 { 628 const gdb_byte *regs = (const gdb_byte *) regs_buf; 629 int regno; 630 631 if (regnum == ARM_FPS_REGNUM || regnum == -1) 632 regcache->raw_supply (ARM_FPS_REGNUM, 633 regs + NWFPE_FPSR_OFFSET); 634 635 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) 636 if (regnum == -1 || regnum == regno) 637 supply_nwfpe_register (regcache, regno, regs); 638 } 639 640 void 641 arm_linux_collect_nwfpe (const struct regset *regset, 642 const struct regcache *regcache, 643 int regnum, void *regs_buf, size_t len) 644 { 645 gdb_byte *regs = (gdb_byte *) regs_buf; 646 int regno; 647 648 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) 649 if (regnum == -1 || regnum == regno) 650 collect_nwfpe_register (regcache, regno, regs); 651 652 if (regnum == ARM_FPS_REGNUM || regnum == -1) 653 regcache->raw_collect (ARM_FPS_REGNUM, 654 regs + ARM_INT_REGISTER_SIZE * ARM_FPS_REGNUM); 655 } 656 657 /* Support VFP register format. */ 658 659 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4) 660 661 static void 662 arm_linux_supply_vfp (const struct regset *regset, 663 struct regcache *regcache, 664 int regnum, const void *regs_buf, size_t len) 665 { 666 const gdb_byte *regs = (const gdb_byte *) regs_buf; 667 int regno; 668 669 if (regnum == ARM_FPSCR_REGNUM || regnum == -1) 670 regcache->raw_supply (ARM_FPSCR_REGNUM, regs + 32 * 8); 671 672 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++) 673 if (regnum == -1 || regnum == regno) 674 regcache->raw_supply (regno, regs + (regno - ARM_D0_REGNUM) * 8); 675 } 676 677 static void 678 arm_linux_collect_vfp (const struct regset *regset, 679 const struct regcache *regcache, 680 int regnum, void *regs_buf, size_t len) 681 { 682 gdb_byte *regs = (gdb_byte *) regs_buf; 683 int regno; 684 685 if (regnum == ARM_FPSCR_REGNUM || regnum == -1) 686 regcache->raw_collect (ARM_FPSCR_REGNUM, regs + 32 * 8); 687 688 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++) 689 if (regnum == -1 || regnum == regno) 690 regcache->raw_collect (regno, regs + (regno - ARM_D0_REGNUM) * 8); 691 } 692 693 static const struct regset arm_linux_gregset = 694 { 695 NULL, arm_linux_supply_gregset, arm_linux_collect_gregset 696 }; 697 698 static const struct regset arm_linux_fpregset = 699 { 700 NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe 701 }; 702 703 static const struct regset arm_linux_vfpregset = 704 { 705 NULL, arm_linux_supply_vfp, arm_linux_collect_vfp 706 }; 707 708 /* Iterate over core file register note sections. */ 709 710 static void 711 arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 712 iterate_over_regset_sections_cb *cb, 713 void *cb_data, 714 const struct regcache *regcache) 715 { 716 arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch); 717 718 cb (".reg", ARM_LINUX_SIZEOF_GREGSET, ARM_LINUX_SIZEOF_GREGSET, 719 &arm_linux_gregset, NULL, cb_data); 720 721 if (tdep->vfp_register_count > 0) 722 cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, ARM_LINUX_SIZEOF_VFP, 723 &arm_linux_vfpregset, "VFP floating-point", cb_data); 724 else if (tdep->have_fpa_registers) 725 cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, ARM_LINUX_SIZEOF_NWFPE, 726 &arm_linux_fpregset, "FPA floating-point", cb_data); 727 } 728 729 /* Determine target description from core file. */ 730 731 static const struct target_desc * 732 arm_linux_core_read_description (struct gdbarch *gdbarch, 733 struct target_ops *target, 734 bfd *abfd) 735 { 736 std::optional<gdb::byte_vector> auxv = target_read_auxv_raw (target); 737 CORE_ADDR arm_hwcap = linux_get_hwcap (auxv, target, gdbarch); 738 739 if (arm_hwcap & HWCAP_VFP) 740 { 741 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support 742 Neon with VFPv3-D32. */ 743 if (arm_hwcap & HWCAP_NEON) 744 return aarch32_read_description (false); 745 else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3) 746 return arm_read_description (ARM_FP_TYPE_VFPV3, false); 747 748 return arm_read_description (ARM_FP_TYPE_VFPV2, false); 749 } 750 751 return nullptr; 752 } 753 754 755 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC, 756 return 1. In addition, set IS_THUMB depending on whether we 757 will return to ARM or Thumb code. Return 0 if it is not a 758 rt_sigreturn/sigreturn syscall. */ 759 static int 760 arm_linux_sigreturn_return_addr (const frame_info_ptr &frame, 761 unsigned long svc_number, 762 CORE_ADDR *pc, int *is_thumb) 763 { 764 /* Is this a sigreturn or rt_sigreturn syscall? */ 765 if (svc_number == 119 || svc_number == 173) 766 { 767 if (get_frame_type (frame) == SIGTRAMP_FRAME) 768 { 769 ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame)); 770 CORE_ADDR cpsr 771 = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM); 772 773 *is_thumb = (cpsr & t_bit) != 0; 774 *pc = frame_unwind_caller_pc (frame); 775 return 1; 776 } 777 } 778 return 0; 779 } 780 781 /* Find the value of the next PC after a sigreturn or rt_sigreturn syscall 782 based on current processor state. In addition, set IS_THUMB depending 783 on whether we will return to ARM or Thumb code. */ 784 785 static CORE_ADDR 786 arm_linux_sigreturn_next_pc (struct regcache *regcache, 787 unsigned long svc_number, int *is_thumb) 788 { 789 ULONGEST sp; 790 unsigned long sp_data; 791 CORE_ADDR next_pc = 0; 792 struct gdbarch *gdbarch = regcache->arch (); 793 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 794 int pc_offset = 0; 795 int is_sigreturn = 0; 796 CORE_ADDR cpsr; 797 798 gdb_assert (svc_number == ARM_SIGRETURN 799 || svc_number == ARM_RT_SIGRETURN); 800 801 is_sigreturn = (svc_number == ARM_SIGRETURN); 802 regcache_cooked_read_unsigned (regcache, ARM_SP_REGNUM, &sp); 803 sp_data = read_memory_unsigned_integer (sp, 4, byte_order); 804 805 pc_offset = arm_linux_sigreturn_next_pc_offset (sp, sp_data, svc_number, 806 is_sigreturn); 807 808 next_pc = read_memory_unsigned_integer (sp + pc_offset, 4, byte_order); 809 810 /* Set IS_THUMB according the CPSR saved on the stack. */ 811 cpsr = read_memory_unsigned_integer (sp + pc_offset + 4, 4, byte_order); 812 *is_thumb = ((cpsr & arm_psr_thumb_bit (gdbarch)) != 0); 813 814 return next_pc; 815 } 816 817 /* Return true if we're at execve syscall-exit-stop. */ 818 819 static bool 820 is_execve_syscall_exit (struct regcache *regs) 821 { 822 ULONGEST reg = -1; 823 824 /* Check that lr is 0. */ 825 regcache_cooked_read_unsigned (regs, ARM_LR_REGNUM, ®); 826 if (reg != 0) 827 return false; 828 829 /* Check that r0-r8 is 0. */ 830 for (int i = 0; i <= 8; ++i) 831 { 832 reg = -1; 833 regcache_cooked_read_unsigned (regs, ARM_A1_REGNUM + i, ®); 834 if (reg != 0) 835 return false; 836 } 837 838 return true; 839 } 840 841 #define arm_sys_execve 11 842 843 /* At a ptrace syscall-stop, return the syscall number. This either 844 comes from the SWI instruction (OABI) or from r7 (EABI). 845 846 When the function fails, it should return -1. */ 847 848 static LONGEST 849 arm_linux_get_syscall_number (struct gdbarch *gdbarch, 850 thread_info *thread) 851 { 852 struct regcache *regs = get_thread_regcache (thread); 853 854 ULONGEST pc; 855 ULONGEST cpsr; 856 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch); 857 int is_thumb; 858 ULONGEST svc_number = -1; 859 860 if (is_execve_syscall_exit (regs)) 861 return arm_sys_execve; 862 863 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc); 864 regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr); 865 is_thumb = (cpsr & t_bit) != 0; 866 867 if (is_thumb) 868 { 869 regcache_cooked_read_unsigned (regs, 7, &svc_number); 870 } 871 else 872 { 873 enum bfd_endian byte_order_for_code = 874 gdbarch_byte_order_for_code (gdbarch); 875 876 /* PC gets incremented before the syscall-stop, so read the 877 previous instruction. */ 878 unsigned long this_instr; 879 { 880 ULONGEST val; 881 if (!safe_read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code, 882 &val)) 883 return -1; 884 this_instr = val; 885 } 886 unsigned long svc_operand = (0x00ffffff & this_instr); 887 888 if (svc_operand) 889 { 890 /* OABI */ 891 svc_number = svc_operand - 0x900000; 892 } 893 else 894 { 895 /* EABI */ 896 regcache_cooked_read_unsigned (regs, 7, &svc_number); 897 } 898 } 899 900 return svc_number; 901 } 902 903 static CORE_ADDR 904 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self) 905 { 906 CORE_ADDR next_pc = 0; 907 regcache *regcache 908 = gdb::checked_static_cast<struct regcache *> (self->regcache); 909 CORE_ADDR pc = regcache_read_pc (regcache); 910 int is_thumb = arm_is_thumb (regcache); 911 ULONGEST svc_number = 0; 912 913 if (is_thumb) 914 { 915 svc_number = regcache_raw_get_unsigned (self->regcache, 7); 916 next_pc = pc + 2; 917 } 918 else 919 { 920 struct gdbarch *gdbarch = regcache->arch (); 921 enum bfd_endian byte_order_for_code = 922 gdbarch_byte_order_for_code (gdbarch); 923 unsigned long this_instr = 924 read_memory_unsigned_integer (pc, 4, byte_order_for_code); 925 926 unsigned long svc_operand = (0x00ffffff & this_instr); 927 if (svc_operand) /* OABI. */ 928 { 929 svc_number = svc_operand - 0x900000; 930 } 931 else /* EABI. */ 932 { 933 svc_number = regcache_raw_get_unsigned (self->regcache, 7); 934 } 935 936 next_pc = pc + 4; 937 } 938 939 if (svc_number == ARM_SIGRETURN || svc_number == ARM_RT_SIGRETURN) 940 { 941 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so 942 update IS_THUMB. */ 943 next_pc = arm_linux_sigreturn_next_pc (regcache, svc_number, &is_thumb); 944 } 945 946 /* Addresses for calling Thumb functions have the bit 0 set. */ 947 if (is_thumb) 948 next_pc = MAKE_THUMB_ADDR (next_pc); 949 950 return next_pc; 951 } 952 953 954 /* Insert a single step breakpoint at the next executed instruction. */ 955 956 static std::vector<CORE_ADDR> 957 arm_linux_software_single_step (struct regcache *regcache) 958 { 959 struct gdbarch *gdbarch = regcache->arch (); 960 struct arm_get_next_pcs next_pcs_ctx; 961 962 /* If the target does have hardware single step, GDB doesn't have 963 to bother software single step. */ 964 if (target_can_do_single_step () == 1) 965 return {}; 966 967 arm_get_next_pcs_ctor (&next_pcs_ctx, 968 &arm_linux_get_next_pcs_ops, 969 gdbarch_byte_order (gdbarch), 970 gdbarch_byte_order_for_code (gdbarch), 971 1, 972 regcache); 973 974 std::vector<CORE_ADDR> next_pcs = arm_get_next_pcs (&next_pcs_ctx); 975 976 for (CORE_ADDR &pc_ref : next_pcs) 977 pc_ref = gdbarch_addr_bits_remove (gdbarch, pc_ref); 978 979 return next_pcs; 980 } 981 982 /* Support for displaced stepping of Linux SVC instructions. */ 983 984 static void 985 arm_linux_cleanup_svc (struct gdbarch *gdbarch, 986 struct regcache *regs, 987 arm_displaced_step_copy_insn_closure *dsc) 988 { 989 ULONGEST apparent_pc; 990 int within_scratch; 991 992 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc); 993 994 within_scratch = (apparent_pc >= dsc->scratch_base 995 && apparent_pc < (dsc->scratch_base 996 + ARM_DISPLACED_MODIFIED_INSNS * 4 + 4)); 997 998 displaced_debug_printf ("PC is apparently %.8lx after SVC step %s", 999 (unsigned long) apparent_pc, 1000 (within_scratch 1001 ? "(within scratch space)" 1002 : "(outside scratch space)")); 1003 1004 if (within_scratch) 1005 displaced_write_reg (regs, dsc, ARM_PC_REGNUM, 1006 dsc->insn_addr + dsc->insn_size, BRANCH_WRITE_PC); 1007 } 1008 1009 static int 1010 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs, 1011 arm_displaced_step_copy_insn_closure *dsc) 1012 { 1013 CORE_ADDR return_to = 0; 1014 1015 frame_info_ptr frame; 1016 unsigned int svc_number = displaced_read_reg (regs, dsc, 7); 1017 int is_sigreturn = 0; 1018 int is_thumb; 1019 1020 frame = get_current_frame (); 1021 1022 is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number, 1023 &return_to, &is_thumb); 1024 if (is_sigreturn) 1025 { 1026 struct symtab_and_line sal; 1027 1028 displaced_debug_printf ("found sigreturn/rt_sigreturn SVC call. " 1029 "PC in frame = %lx", 1030 (unsigned long) get_frame_pc (frame)); 1031 1032 displaced_debug_printf ("unwind pc = %lx. Setting momentary breakpoint.", 1033 (unsigned long) return_to); 1034 1035 gdb_assert (inferior_thread ()->control.step_resume_breakpoint 1036 == NULL); 1037 1038 sal = find_pc_line (return_to, 0); 1039 sal.pc = return_to; 1040 sal.section = find_pc_overlay (return_to); 1041 sal.explicit_pc = 1; 1042 1043 frame = get_prev_frame (frame); 1044 1045 if (frame) 1046 { 1047 inferior_thread ()->control.step_resume_breakpoint 1048 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame), 1049 bp_step_resume).release (); 1050 1051 /* We need to make sure we actually insert the momentary 1052 breakpoint set above. */ 1053 insert_breakpoints (); 1054 } 1055 else 1056 displaced_debug_printf ("couldn't find previous frame to set momentary " 1057 "breakpoint for sigreturn/rt_sigreturn"); 1058 } 1059 else 1060 displaced_debug_printf ("found SVC call"); 1061 1062 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume 1063 location, else nothing. 1064 Insn: unmodified svc. 1065 Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size 1066 else leave pc alone. */ 1067 1068 1069 dsc->cleanup = &arm_linux_cleanup_svc; 1070 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next 1071 instruction. */ 1072 dsc->wrote_to_pc = 1; 1073 1074 return 0; 1075 } 1076 1077 1078 /* The following two functions implement single-stepping over calls to Linux 1079 kernel helper routines, which perform e.g. atomic operations on architecture 1080 variants which don't support them natively. 1081 1082 When this function is called, the PC will be pointing at the kernel helper 1083 (at an address inaccessible to GDB), and r14 will point to the return 1084 address. Displaced stepping always executes code in the copy area: 1085 so, make the copy-area instruction branch back to the kernel helper (the 1086 "from" address), and make r14 point to the breakpoint in the copy area. In 1087 that way, we regain control once the kernel helper returns, and can clean 1088 up appropriately (as if we had just returned from the kernel helper as it 1089 would have been called from the non-displaced location). */ 1090 1091 static void 1092 cleanup_kernel_helper_return (struct gdbarch *gdbarch, 1093 struct regcache *regs, 1094 arm_displaced_step_copy_insn_closure *dsc) 1095 { 1096 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC); 1097 displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC); 1098 } 1099 1100 static void 1101 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from, 1102 CORE_ADDR to, struct regcache *regs, 1103 arm_displaced_step_copy_insn_closure *dsc) 1104 { 1105 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1106 1107 dsc->numinsns = 1; 1108 dsc->insn_addr = from; 1109 dsc->cleanup = &cleanup_kernel_helper_return; 1110 /* Say we wrote to the PC, else cleanup will set PC to the next 1111 instruction in the helper, which isn't helpful. */ 1112 dsc->wrote_to_pc = 1; 1113 1114 /* Preparation: tmp[0] <- r14 1115 r14 <- <scratch space>+4 1116 *(<scratch space>+8) <- from 1117 Insn: ldr pc, [r14, #4] 1118 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */ 1119 1120 dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM); 1121 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4, 1122 CANNOT_WRITE_PC); 1123 write_memory_unsigned_integer (to + 8, 4, byte_order, from); 1124 1125 dsc->modinsn[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */ 1126 } 1127 1128 /* Linux-specific displaced step instruction copying function. Detects when 1129 the program has stepped into a Linux kernel helper routine (which must be 1130 handled as a special case). */ 1131 1132 static displaced_step_copy_insn_closure_up 1133 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch, 1134 CORE_ADDR from, CORE_ADDR to, 1135 struct regcache *regs) 1136 { 1137 std::unique_ptr<arm_displaced_step_copy_insn_closure> dsc 1138 (new arm_displaced_step_copy_insn_closure); 1139 1140 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and 1141 stop at the return location. */ 1142 if (from > 0xffff0000) 1143 { 1144 displaced_debug_printf ("detected kernel helper at %.8lx", 1145 (unsigned long) from); 1146 1147 arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc.get ()); 1148 } 1149 else 1150 { 1151 /* Override the default handling of SVC instructions. */ 1152 dsc->u.svc.copy_svc_os = arm_linux_copy_svc; 1153 1154 arm_process_displaced_insn (gdbarch, from, to, regs, dsc.get ()); 1155 } 1156 1157 arm_displaced_init_closure (gdbarch, from, to, dsc.get ()); 1158 1159 /* This is a work around for a problem with g++ 4.8. */ 1160 return displaced_step_copy_insn_closure_up (dsc.release ()); 1161 } 1162 1163 /* Implementation of `gdbarch_stap_is_single_operand', as defined in 1164 gdbarch.h. */ 1165 1166 static int 1167 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s) 1168 { 1169 return (*s == '#' || *s == '$' || isdigit ((unsigned char)*s) /* Literal number. */ 1170 || *s == '[' /* Register indirection or 1171 displacement. */ 1172 || isalpha ((unsigned char)*s)); /* Register value. */ 1173 } 1174 1175 /* This routine is used to parse a special token in ARM's assembly. 1176 1177 The special tokens parsed by it are: 1178 1179 - Register displacement (e.g, [fp, #-8]) 1180 1181 It returns one if the special token has been parsed successfully, 1182 or zero if the current token is not considered special. */ 1183 1184 static expr::operation_up 1185 arm_stap_parse_special_token (struct gdbarch *gdbarch, 1186 struct stap_parse_info *p) 1187 { 1188 if (*p->arg == '[') 1189 { 1190 /* Temporary holder for lookahead. */ 1191 const char *tmp = p->arg; 1192 char *endp; 1193 /* Used to save the register name. */ 1194 const char *start; 1195 char *regname; 1196 int len, offset; 1197 int got_minus = 0; 1198 long displacement; 1199 1200 ++tmp; 1201 start = tmp; 1202 1203 /* Register name. */ 1204 while (isalnum ((unsigned char)*tmp)) 1205 ++tmp; 1206 1207 if (*tmp != ',') 1208 return {}; 1209 1210 len = tmp - start; 1211 regname = (char *) alloca (len + 2); 1212 1213 offset = 0; 1214 if (isdigit ((unsigned char)*start)) 1215 { 1216 /* If we are dealing with a register whose name begins with a 1217 digit, it means we should prefix the name with the letter 1218 `r', because GDB expects this name pattern. Otherwise (e.g., 1219 we are dealing with the register `fp'), we don't need to 1220 add such a prefix. */ 1221 regname[0] = 'r'; 1222 offset = 1; 1223 } 1224 1225 strncpy (regname + offset, start, len); 1226 len += offset; 1227 regname[len] = '\0'; 1228 1229 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1) 1230 error (_("Invalid register name `%s' on expression `%s'."), 1231 regname, p->saved_arg); 1232 1233 ++tmp; 1234 tmp = skip_spaces (tmp); 1235 if (*tmp == '#' || *tmp == '$') 1236 ++tmp; 1237 1238 if (*tmp == '-') 1239 { 1240 ++tmp; 1241 got_minus = 1; 1242 } 1243 1244 displacement = strtol (tmp, &endp, 10); 1245 tmp = endp; 1246 1247 /* Skipping last `]'. */ 1248 if (*tmp++ != ']') 1249 return {}; 1250 p->arg = tmp; 1251 1252 using namespace expr; 1253 1254 /* The displacement. */ 1255 struct type *long_type = builtin_type (gdbarch)->builtin_long; 1256 if (got_minus) 1257 displacement = -displacement; 1258 operation_up disp = make_operation<long_const_operation> (long_type, 1259 displacement); 1260 1261 /* The register name. */ 1262 operation_up reg 1263 = make_operation<register_operation> (regname); 1264 1265 operation_up sum 1266 = make_operation<add_operation> (std::move (reg), std::move (disp)); 1267 1268 /* Casting to the expected type. */ 1269 struct type *arg_ptr_type = lookup_pointer_type (p->arg_type); 1270 sum = make_operation<unop_cast_operation> (std::move (sum), 1271 arg_ptr_type); 1272 return make_operation<unop_ind_operation> (std::move (sum)); 1273 } 1274 1275 return {}; 1276 } 1277 1278 /* ARM process record-replay constructs: syscall, signal etc. */ 1279 1280 static linux_record_tdep arm_linux_record_tdep; 1281 1282 /* arm_canonicalize_syscall maps from the native arm Linux set 1283 of syscall ids into a canonical set of syscall ids used by 1284 process record. */ 1285 1286 static enum gdb_syscall 1287 arm_canonicalize_syscall (int syscall) 1288 { 1289 switch (syscall) 1290 { 1291 case 0: return gdb_sys_restart_syscall; 1292 case 1: return gdb_sys_exit; 1293 case 2: return gdb_sys_fork; 1294 case 3: return gdb_sys_read; 1295 case 4: return gdb_sys_write; 1296 case 5: return gdb_sys_open; 1297 case 6: return gdb_sys_close; 1298 case 8: return gdb_sys_creat; 1299 case 9: return gdb_sys_link; 1300 case 10: return gdb_sys_unlink; 1301 case arm_sys_execve: return gdb_sys_execve; 1302 case 12: return gdb_sys_chdir; 1303 case 13: return gdb_sys_time; 1304 case 14: return gdb_sys_mknod; 1305 case 15: return gdb_sys_chmod; 1306 case 16: return gdb_sys_lchown16; 1307 case 19: return gdb_sys_lseek; 1308 case 20: return gdb_sys_getpid; 1309 case 21: return gdb_sys_mount; 1310 case 22: return gdb_sys_oldumount; 1311 case 23: return gdb_sys_setuid16; 1312 case 24: return gdb_sys_getuid16; 1313 case 25: return gdb_sys_stime; 1314 case 26: return gdb_sys_ptrace; 1315 case 27: return gdb_sys_alarm; 1316 case 29: return gdb_sys_pause; 1317 case 30: return gdb_sys_utime; 1318 case 33: return gdb_sys_access; 1319 case 34: return gdb_sys_nice; 1320 case 36: return gdb_sys_sync; 1321 case 37: return gdb_sys_kill; 1322 case 38: return gdb_sys_rename; 1323 case 39: return gdb_sys_mkdir; 1324 case 40: return gdb_sys_rmdir; 1325 case 41: return gdb_sys_dup; 1326 case 42: return gdb_sys_pipe; 1327 case 43: return gdb_sys_times; 1328 case 45: return gdb_sys_brk; 1329 case 46: return gdb_sys_setgid16; 1330 case 47: return gdb_sys_getgid16; 1331 case 49: return gdb_sys_geteuid16; 1332 case 50: return gdb_sys_getegid16; 1333 case 51: return gdb_sys_acct; 1334 case 52: return gdb_sys_umount; 1335 case 54: return gdb_sys_ioctl; 1336 case 55: return gdb_sys_fcntl; 1337 case 57: return gdb_sys_setpgid; 1338 case 60: return gdb_sys_umask; 1339 case 61: return gdb_sys_chroot; 1340 case 62: return gdb_sys_ustat; 1341 case 63: return gdb_sys_dup2; 1342 case 64: return gdb_sys_getppid; 1343 case 65: return gdb_sys_getpgrp; 1344 case 66: return gdb_sys_setsid; 1345 case 67: return gdb_sys_sigaction; 1346 case 70: return gdb_sys_setreuid16; 1347 case 71: return gdb_sys_setregid16; 1348 case 72: return gdb_sys_sigsuspend; 1349 case 73: return gdb_sys_sigpending; 1350 case 74: return gdb_sys_sethostname; 1351 case 75: return gdb_sys_setrlimit; 1352 case 76: return gdb_sys_getrlimit; 1353 case 77: return gdb_sys_getrusage; 1354 case 78: return gdb_sys_gettimeofday; 1355 case 79: return gdb_sys_settimeofday; 1356 case 80: return gdb_sys_getgroups16; 1357 case 81: return gdb_sys_setgroups16; 1358 case 82: return gdb_sys_select; 1359 case 83: return gdb_sys_symlink; 1360 case 85: return gdb_sys_readlink; 1361 case 86: return gdb_sys_uselib; 1362 case 87: return gdb_sys_swapon; 1363 case 88: return gdb_sys_reboot; 1364 case 89: return gdb_old_readdir; 1365 case 90: return gdb_old_mmap; 1366 case 91: return gdb_sys_munmap; 1367 case 92: return gdb_sys_truncate; 1368 case 93: return gdb_sys_ftruncate; 1369 case 94: return gdb_sys_fchmod; 1370 case 95: return gdb_sys_fchown16; 1371 case 96: return gdb_sys_getpriority; 1372 case 97: return gdb_sys_setpriority; 1373 case 99: return gdb_sys_statfs; 1374 case 100: return gdb_sys_fstatfs; 1375 case 102: return gdb_sys_socketcall; 1376 case 103: return gdb_sys_syslog; 1377 case 104: return gdb_sys_setitimer; 1378 case 105: return gdb_sys_getitimer; 1379 case 106: return gdb_sys_stat; 1380 case 107: return gdb_sys_lstat; 1381 case 108: return gdb_sys_fstat; 1382 case 111: return gdb_sys_vhangup; 1383 case 113: /* sys_syscall */ 1384 return gdb_sys_no_syscall; 1385 case 114: return gdb_sys_wait4; 1386 case 115: return gdb_sys_swapoff; 1387 case 116: return gdb_sys_sysinfo; 1388 case 117: return gdb_sys_ipc; 1389 case 118: return gdb_sys_fsync; 1390 case 119: return gdb_sys_sigreturn; 1391 case 120: return gdb_sys_clone; 1392 case 121: return gdb_sys_setdomainname; 1393 case 122: return gdb_sys_uname; 1394 case 124: return gdb_sys_adjtimex; 1395 case 125: return gdb_sys_mprotect; 1396 case 126: return gdb_sys_sigprocmask; 1397 case 128: return gdb_sys_init_module; 1398 case 129: return gdb_sys_delete_module; 1399 case 131: return gdb_sys_quotactl; 1400 case 132: return gdb_sys_getpgid; 1401 case 133: return gdb_sys_fchdir; 1402 case 134: return gdb_sys_bdflush; 1403 case 135: return gdb_sys_sysfs; 1404 case 136: return gdb_sys_personality; 1405 case 138: return gdb_sys_setfsuid16; 1406 case 139: return gdb_sys_setfsgid16; 1407 case 140: return gdb_sys_llseek; 1408 case 141: return gdb_sys_getdents; 1409 case 142: return gdb_sys_select; 1410 case 143: return gdb_sys_flock; 1411 case 144: return gdb_sys_msync; 1412 case 145: return gdb_sys_readv; 1413 case 146: return gdb_sys_writev; 1414 case 147: return gdb_sys_getsid; 1415 case 148: return gdb_sys_fdatasync; 1416 case 149: return gdb_sys_sysctl; 1417 case 150: return gdb_sys_mlock; 1418 case 151: return gdb_sys_munlock; 1419 case 152: return gdb_sys_mlockall; 1420 case 153: return gdb_sys_munlockall; 1421 case 154: return gdb_sys_sched_setparam; 1422 case 155: return gdb_sys_sched_getparam; 1423 case 156: return gdb_sys_sched_setscheduler; 1424 case 157: return gdb_sys_sched_getscheduler; 1425 case 158: return gdb_sys_sched_yield; 1426 case 159: return gdb_sys_sched_get_priority_max; 1427 case 160: return gdb_sys_sched_get_priority_min; 1428 case 161: return gdb_sys_sched_rr_get_interval; 1429 case 162: return gdb_sys_nanosleep; 1430 case 163: return gdb_sys_mremap; 1431 case 164: return gdb_sys_setresuid16; 1432 case 165: return gdb_sys_getresuid16; 1433 case 168: return gdb_sys_poll; 1434 case 169: return gdb_sys_nfsservctl; 1435 case 170: return gdb_sys_setresgid; 1436 case 171: return gdb_sys_getresgid; 1437 case 172: return gdb_sys_prctl; 1438 case 173: return gdb_sys_rt_sigreturn; 1439 case 174: return gdb_sys_rt_sigaction; 1440 case 175: return gdb_sys_rt_sigprocmask; 1441 case 176: return gdb_sys_rt_sigpending; 1442 case 177: return gdb_sys_rt_sigtimedwait; 1443 case 178: return gdb_sys_rt_sigqueueinfo; 1444 case 179: return gdb_sys_rt_sigsuspend; 1445 case 180: return gdb_sys_pread64; 1446 case 181: return gdb_sys_pwrite64; 1447 case 182: return gdb_sys_chown; 1448 case 183: return gdb_sys_getcwd; 1449 case 184: return gdb_sys_capget; 1450 case 185: return gdb_sys_capset; 1451 case 186: return gdb_sys_sigaltstack; 1452 case 187: return gdb_sys_sendfile; 1453 case 190: return gdb_sys_vfork; 1454 case 191: return gdb_sys_getrlimit; 1455 case 192: return gdb_sys_mmap2; 1456 case 193: return gdb_sys_truncate64; 1457 case 194: return gdb_sys_ftruncate64; 1458 case 195: return gdb_sys_stat64; 1459 case 196: return gdb_sys_lstat64; 1460 case 197: return gdb_sys_fstat64; 1461 case 198: return gdb_sys_lchown; 1462 case 199: return gdb_sys_getuid; 1463 case 200: return gdb_sys_getgid; 1464 case 201: return gdb_sys_geteuid; 1465 case 202: return gdb_sys_getegid; 1466 case 203: return gdb_sys_setreuid; 1467 case 204: return gdb_sys_setregid; 1468 case 205: return gdb_sys_getgroups; 1469 case 206: return gdb_sys_setgroups; 1470 case 207: return gdb_sys_fchown; 1471 case 208: return gdb_sys_setresuid; 1472 case 209: return gdb_sys_getresuid; 1473 case 210: return gdb_sys_setresgid; 1474 case 211: return gdb_sys_getresgid; 1475 case 212: return gdb_sys_chown; 1476 case 213: return gdb_sys_setuid; 1477 case 214: return gdb_sys_setgid; 1478 case 215: return gdb_sys_setfsuid; 1479 case 216: return gdb_sys_setfsgid; 1480 case 217: return gdb_sys_getdents64; 1481 case 218: return gdb_sys_pivot_root; 1482 case 219: return gdb_sys_mincore; 1483 case 220: return gdb_sys_madvise; 1484 case 221: return gdb_sys_fcntl64; 1485 case 224: return gdb_sys_gettid; 1486 case 225: return gdb_sys_readahead; 1487 case 226: return gdb_sys_setxattr; 1488 case 227: return gdb_sys_lsetxattr; 1489 case 228: return gdb_sys_fsetxattr; 1490 case 229: return gdb_sys_getxattr; 1491 case 230: return gdb_sys_lgetxattr; 1492 case 231: return gdb_sys_fgetxattr; 1493 case 232: return gdb_sys_listxattr; 1494 case 233: return gdb_sys_llistxattr; 1495 case 234: return gdb_sys_flistxattr; 1496 case 235: return gdb_sys_removexattr; 1497 case 236: return gdb_sys_lremovexattr; 1498 case 237: return gdb_sys_fremovexattr; 1499 case 238: return gdb_sys_tkill; 1500 case 239: return gdb_sys_sendfile64; 1501 case 240: return gdb_sys_futex; 1502 case 241: return gdb_sys_sched_setaffinity; 1503 case 242: return gdb_sys_sched_getaffinity; 1504 case 243: return gdb_sys_io_setup; 1505 case 244: return gdb_sys_io_destroy; 1506 case 245: return gdb_sys_io_getevents; 1507 case 246: return gdb_sys_io_submit; 1508 case 247: return gdb_sys_io_cancel; 1509 case 248: return gdb_sys_exit_group; 1510 case 249: return gdb_sys_lookup_dcookie; 1511 case 250: return gdb_sys_epoll_create; 1512 case 251: return gdb_sys_epoll_ctl; 1513 case 252: return gdb_sys_epoll_wait; 1514 case 253: return gdb_sys_remap_file_pages; 1515 case 256: return gdb_sys_set_tid_address; 1516 case 257: return gdb_sys_timer_create; 1517 case 258: return gdb_sys_timer_settime; 1518 case 259: return gdb_sys_timer_gettime; 1519 case 260: return gdb_sys_timer_getoverrun; 1520 case 261: return gdb_sys_timer_delete; 1521 case 262: return gdb_sys_clock_settime; 1522 case 263: return gdb_sys_clock_gettime; 1523 case 264: return gdb_sys_clock_getres; 1524 case 265: return gdb_sys_clock_nanosleep; 1525 case 266: return gdb_sys_statfs64; 1526 case 267: return gdb_sys_fstatfs64; 1527 case 268: return gdb_sys_tgkill; 1528 case 269: return gdb_sys_utimes; 1529 /* 1530 case 270: return gdb_sys_arm_fadvise64_64; 1531 case 271: return gdb_sys_pciconfig_iobase; 1532 case 272: return gdb_sys_pciconfig_read; 1533 case 273: return gdb_sys_pciconfig_write; 1534 */ 1535 case 274: return gdb_sys_mq_open; 1536 case 275: return gdb_sys_mq_unlink; 1537 case 276: return gdb_sys_mq_timedsend; 1538 case 277: return gdb_sys_mq_timedreceive; 1539 case 278: return gdb_sys_mq_notify; 1540 case 279: return gdb_sys_mq_getsetattr; 1541 case 280: return gdb_sys_waitid; 1542 case 281: return gdb_sys_socket; 1543 case 282: return gdb_sys_bind; 1544 case 283: return gdb_sys_connect; 1545 case 284: return gdb_sys_listen; 1546 case 285: return gdb_sys_accept; 1547 case 286: return gdb_sys_getsockname; 1548 case 287: return gdb_sys_getpeername; 1549 case 288: return gdb_sys_socketpair; 1550 case 289: /* send */ return gdb_sys_no_syscall; 1551 case 290: return gdb_sys_sendto; 1552 case 291: return gdb_sys_recv; 1553 case 292: return gdb_sys_recvfrom; 1554 case 293: return gdb_sys_shutdown; 1555 case 294: return gdb_sys_setsockopt; 1556 case 295: return gdb_sys_getsockopt; 1557 case 296: return gdb_sys_sendmsg; 1558 case 297: return gdb_sys_recvmsg; 1559 case 298: return gdb_sys_semop; 1560 case 299: return gdb_sys_semget; 1561 case 300: return gdb_sys_semctl; 1562 case 301: return gdb_sys_msgsnd; 1563 case 302: return gdb_sys_msgrcv; 1564 case 303: return gdb_sys_msgget; 1565 case 304: return gdb_sys_msgctl; 1566 case 305: return gdb_sys_shmat; 1567 case 306: return gdb_sys_shmdt; 1568 case 307: return gdb_sys_shmget; 1569 case 308: return gdb_sys_shmctl; 1570 case 309: return gdb_sys_add_key; 1571 case 310: return gdb_sys_request_key; 1572 case 311: return gdb_sys_keyctl; 1573 case 312: return gdb_sys_semtimedop; 1574 case 313: /* vserver */ return gdb_sys_no_syscall; 1575 case 314: return gdb_sys_ioprio_set; 1576 case 315: return gdb_sys_ioprio_get; 1577 case 316: return gdb_sys_inotify_init; 1578 case 317: return gdb_sys_inotify_add_watch; 1579 case 318: return gdb_sys_inotify_rm_watch; 1580 case 319: return gdb_sys_mbind; 1581 case 320: return gdb_sys_get_mempolicy; 1582 case 321: return gdb_sys_set_mempolicy; 1583 case 322: return gdb_sys_openat; 1584 case 323: return gdb_sys_mkdirat; 1585 case 324: return gdb_sys_mknodat; 1586 case 325: return gdb_sys_fchownat; 1587 case 326: return gdb_sys_futimesat; 1588 case 327: return gdb_sys_fstatat64; 1589 case 328: return gdb_sys_unlinkat; 1590 case 329: return gdb_sys_renameat; 1591 case 330: return gdb_sys_linkat; 1592 case 331: return gdb_sys_symlinkat; 1593 case 332: return gdb_sys_readlinkat; 1594 case 333: return gdb_sys_fchmodat; 1595 case 334: return gdb_sys_faccessat; 1596 case 335: return gdb_sys_pselect6; 1597 case 336: return gdb_sys_ppoll; 1598 case 337: return gdb_sys_unshare; 1599 case 338: return gdb_sys_set_robust_list; 1600 case 339: return gdb_sys_get_robust_list; 1601 case 340: return gdb_sys_splice; 1602 /*case 341: return gdb_sys_arm_sync_file_range;*/ 1603 case 342: return gdb_sys_tee; 1604 case 343: return gdb_sys_vmsplice; 1605 case 344: return gdb_sys_move_pages; 1606 case 345: return gdb_sys_getcpu; 1607 case 346: return gdb_sys_epoll_pwait; 1608 case 347: return gdb_sys_kexec_load; 1609 /* 1610 case 348: return gdb_sys_utimensat; 1611 case 349: return gdb_sys_signalfd; 1612 case 350: return gdb_sys_timerfd_create; 1613 case 351: return gdb_sys_eventfd; 1614 */ 1615 case 352: return gdb_sys_fallocate; 1616 /* 1617 case 353: return gdb_sys_timerfd_settime; 1618 case 354: return gdb_sys_timerfd_gettime; 1619 case 355: return gdb_sys_signalfd4; 1620 */ 1621 case 356: return gdb_sys_eventfd2; 1622 case 357: return gdb_sys_epoll_create1; 1623 case 358: return gdb_sys_dup3; 1624 case 359: return gdb_sys_pipe2; 1625 case 360: return gdb_sys_inotify_init1; 1626 /* 1627 case 361: return gdb_sys_preadv; 1628 case 362: return gdb_sys_pwritev; 1629 case 363: return gdb_sys_rt_tgsigqueueinfo; 1630 case 364: return gdb_sys_perf_event_open; 1631 case 365: return gdb_sys_recvmmsg; 1632 case 366: return gdb_sys_accept4; 1633 case 367: return gdb_sys_fanotify_init; 1634 case 368: return gdb_sys_fanotify_mark; 1635 case 369: return gdb_sys_prlimit64; 1636 case 370: return gdb_sys_name_to_handle_at; 1637 case 371: return gdb_sys_open_by_handle_at; 1638 case 372: return gdb_sys_clock_adjtime; 1639 case 373: return gdb_sys_syncfs; 1640 case 374: return gdb_sys_sendmmsg; 1641 case 375: return gdb_sys_setns; 1642 case 376: return gdb_sys_process_vm_readv; 1643 case 377: return gdb_sys_process_vm_writev; 1644 case 378: return gdb_sys_kcmp; 1645 case 379: return gdb_sys_finit_module; 1646 */ 1647 case 384: return gdb_sys_getrandom; 1648 case 397: return gdb_sys_statx; 1649 case 403: return gdb_sys_clock_gettime64; 1650 case 983041: /* ARM_breakpoint */ return gdb_sys_no_syscall; 1651 case 983042: /* ARM_cacheflush */ return gdb_sys_no_syscall; 1652 case 983043: /* ARM_usr26 */ return gdb_sys_no_syscall; 1653 case 983044: /* ARM_usr32 */ return gdb_sys_no_syscall; 1654 case 983045: /* ARM_set_tls */ return gdb_sys_no_syscall; 1655 default: return gdb_sys_no_syscall; 1656 } 1657 } 1658 1659 /* Record all registers but PC register for process-record. */ 1660 1661 static int 1662 arm_all_but_pc_registers_record (struct regcache *regcache) 1663 { 1664 int i; 1665 1666 for (i = 0; i < ARM_PC_REGNUM; i++) 1667 { 1668 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i)) 1669 return -1; 1670 } 1671 1672 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM)) 1673 return -1; 1674 1675 return 0; 1676 } 1677 1678 /* Handler for arm system call instruction recording. */ 1679 1680 static int 1681 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number) 1682 { 1683 int ret = 0; 1684 enum gdb_syscall syscall_gdb; 1685 1686 syscall_gdb = arm_canonicalize_syscall (svc_number); 1687 1688 if (syscall_gdb == gdb_sys_no_syscall) 1689 { 1690 gdb_printf (gdb_stderr, 1691 _("Process record and replay target doesn't " 1692 "support syscall number %s\n"), 1693 plongest (svc_number)); 1694 return -1; 1695 } 1696 1697 if (syscall_gdb == gdb_sys_sigreturn 1698 || syscall_gdb == gdb_sys_rt_sigreturn) 1699 { 1700 if (arm_all_but_pc_registers_record (regcache)) 1701 return -1; 1702 return 0; 1703 } 1704 1705 ret = record_linux_system_call (syscall_gdb, regcache, 1706 &arm_linux_record_tdep); 1707 if (ret != 0) 1708 return ret; 1709 1710 /* Record the return value of the system call. */ 1711 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM)) 1712 return -1; 1713 /* Record LR. */ 1714 if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM)) 1715 return -1; 1716 /* Record CPSR. */ 1717 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM)) 1718 return -1; 1719 1720 return 0; 1721 } 1722 1723 /* Implement the skip_trampoline_code gdbarch method. */ 1724 1725 static CORE_ADDR 1726 arm_linux_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc) 1727 { 1728 CORE_ADDR target_pc = arm_skip_stub (frame, pc); 1729 1730 if (target_pc != 0) 1731 return target_pc; 1732 1733 return find_solib_trampoline_target (frame, pc); 1734 } 1735 1736 /* Implement the gcc_target_options gdbarch method. */ 1737 1738 static std::string 1739 arm_linux_gcc_target_options (struct gdbarch *gdbarch) 1740 { 1741 /* GCC doesn't know "-m32". */ 1742 return {}; 1743 } 1744 1745 static void 1746 arm_linux_init_abi (struct gdbarch_info info, 1747 struct gdbarch *gdbarch) 1748 { 1749 static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL }; 1750 static const char *const stap_register_prefixes[] = { "r", NULL }; 1751 static const char *const stap_register_indirection_prefixes[] = { "[", 1752 NULL }; 1753 static const char *const stap_register_indirection_suffixes[] = { "]", 1754 NULL }; 1755 arm_gdbarch_tdep *tdep = gdbarch_tdep<arm_gdbarch_tdep> (gdbarch); 1756 1757 linux_init_abi (info, gdbarch, 1); 1758 1759 tdep->lowest_pc = 0x8000; 1760 if (info.byte_order_for_code == BFD_ENDIAN_BIG) 1761 { 1762 if (tdep->arm_abi == ARM_ABI_AAPCS) 1763 tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint; 1764 else 1765 tdep->arm_breakpoint = arm_linux_arm_be_breakpoint; 1766 tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint; 1767 tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint; 1768 } 1769 else 1770 { 1771 if (tdep->arm_abi == ARM_ABI_AAPCS) 1772 tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint; 1773 else 1774 tdep->arm_breakpoint = arm_linux_arm_le_breakpoint; 1775 tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint; 1776 tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint; 1777 } 1778 tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint); 1779 tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint); 1780 tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint); 1781 1782 if (tdep->fp_model == ARM_FLOAT_AUTO) 1783 tdep->fp_model = ARM_FLOAT_FPA; 1784 1785 switch (tdep->fp_model) 1786 { 1787 case ARM_FLOAT_FPA: 1788 tdep->jb_pc = ARM_LINUX_JB_PC_FPA; 1789 break; 1790 case ARM_FLOAT_SOFT_FPA: 1791 case ARM_FLOAT_SOFT_VFP: 1792 case ARM_FLOAT_VFP: 1793 tdep->jb_pc = ARM_LINUX_JB_PC_EABI; 1794 break; 1795 default: 1796 internal_error 1797 (_("arm_linux_init_abi: Floating point model not supported")); 1798 break; 1799 } 1800 tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE; 1801 1802 set_solib_svr4_fetch_link_map_offsets 1803 (gdbarch, linux_ilp32_fetch_link_map_offsets); 1804 1805 /* Single stepping. */ 1806 set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step); 1807 1808 /* Shared library handling. */ 1809 set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code); 1810 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 1811 1812 /* Enable TLS support. */ 1813 set_gdbarch_fetch_tls_load_module_address (gdbarch, 1814 svr4_fetch_objfile_link_map); 1815 1816 tramp_frame_prepend_unwinder (gdbarch, 1817 &arm_linux_sigreturn_tramp_frame); 1818 tramp_frame_prepend_unwinder (gdbarch, 1819 &arm_linux_rt_sigreturn_tramp_frame); 1820 tramp_frame_prepend_unwinder (gdbarch, 1821 &arm_eabi_linux_sigreturn_tramp_frame); 1822 tramp_frame_prepend_unwinder (gdbarch, 1823 &arm_eabi_linux_rt_sigreturn_tramp_frame); 1824 tramp_frame_prepend_unwinder (gdbarch, 1825 &thumb2_eabi_linux_sigreturn_tramp_frame); 1826 tramp_frame_prepend_unwinder (gdbarch, 1827 &thumb2_eabi_linux_rt_sigreturn_tramp_frame); 1828 tramp_frame_prepend_unwinder (gdbarch, 1829 &arm_linux_restart_syscall_tramp_frame); 1830 tramp_frame_prepend_unwinder (gdbarch, 1831 &arm_kernel_linux_restart_syscall_tramp_frame); 1832 1833 /* Core file support. */ 1834 set_gdbarch_iterate_over_regset_sections 1835 (gdbarch, arm_linux_iterate_over_regset_sections); 1836 set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description); 1837 1838 /* Displaced stepping. */ 1839 set_gdbarch_displaced_step_copy_insn (gdbarch, 1840 arm_linux_displaced_step_copy_insn); 1841 set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup); 1842 1843 /* Reversible debugging, process record. */ 1844 set_gdbarch_process_record (gdbarch, arm_process_record); 1845 1846 /* SystemTap functions. */ 1847 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes); 1848 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes); 1849 set_gdbarch_stap_register_indirection_prefixes (gdbarch, 1850 stap_register_indirection_prefixes); 1851 set_gdbarch_stap_register_indirection_suffixes (gdbarch, 1852 stap_register_indirection_suffixes); 1853 set_gdbarch_stap_gdb_register_prefix (gdbarch, "r"); 1854 set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand); 1855 set_gdbarch_stap_parse_special_token (gdbarch, 1856 arm_stap_parse_special_token); 1857 1858 /* `catch syscall' */ 1859 set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml"); 1860 set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number); 1861 1862 /* Syscall record. */ 1863 tdep->arm_syscall_record = arm_linux_syscall_record; 1864 1865 /* Initialize the arm_linux_record_tdep. */ 1866 /* These values are the size of the type that will be used in a system 1867 call. They are obtained from Linux Kernel source. */ 1868 arm_linux_record_tdep.size_pointer 1869 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT; 1870 arm_linux_record_tdep.size__old_kernel_stat = 32; 1871 arm_linux_record_tdep.size_tms = 16; 1872 arm_linux_record_tdep.size_loff_t = 8; 1873 arm_linux_record_tdep.size_flock = 16; 1874 arm_linux_record_tdep.size_oldold_utsname = 45; 1875 arm_linux_record_tdep.size_ustat = 20; 1876 arm_linux_record_tdep.size_old_sigaction = 16; 1877 arm_linux_record_tdep.size_old_sigset_t = 4; 1878 arm_linux_record_tdep.size_rlimit = 8; 1879 arm_linux_record_tdep.size_rusage = 72; 1880 arm_linux_record_tdep.size_timeval = 8; 1881 arm_linux_record_tdep.size_timezone = 8; 1882 arm_linux_record_tdep.size_old_gid_t = 2; 1883 arm_linux_record_tdep.size_old_uid_t = 2; 1884 arm_linux_record_tdep.size_fd_set = 128; 1885 arm_linux_record_tdep.size_old_dirent = 268; 1886 arm_linux_record_tdep.size_statfs = 64; 1887 arm_linux_record_tdep.size_statfs64 = 84; 1888 arm_linux_record_tdep.size_sockaddr = 16; 1889 arm_linux_record_tdep.size_int 1890 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; 1891 arm_linux_record_tdep.size_long 1892 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 1893 arm_linux_record_tdep.size_ulong 1894 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 1895 arm_linux_record_tdep.size_msghdr = 28; 1896 arm_linux_record_tdep.size_itimerval = 16; 1897 arm_linux_record_tdep.size_stat = 88; 1898 arm_linux_record_tdep.size_old_utsname = 325; 1899 arm_linux_record_tdep.size_sysinfo = 64; 1900 arm_linux_record_tdep.size_msqid_ds = 88; 1901 arm_linux_record_tdep.size_shmid_ds = 84; 1902 arm_linux_record_tdep.size_new_utsname = 390; 1903 arm_linux_record_tdep.size_timex = 128; 1904 arm_linux_record_tdep.size_mem_dqinfo = 24; 1905 arm_linux_record_tdep.size_if_dqblk = 68; 1906 arm_linux_record_tdep.size_fs_quota_stat = 68; 1907 arm_linux_record_tdep.size_timespec = 8; 1908 arm_linux_record_tdep.size_pollfd = 8; 1909 arm_linux_record_tdep.size_NFS_FHSIZE = 32; 1910 arm_linux_record_tdep.size_knfsd_fh = 132; 1911 arm_linux_record_tdep.size_TASK_COMM_LEN = 16; 1912 arm_linux_record_tdep.size_sigaction = 20; 1913 arm_linux_record_tdep.size_sigset_t = 8; 1914 arm_linux_record_tdep.size_siginfo_t = 128; 1915 arm_linux_record_tdep.size_cap_user_data_t = 12; 1916 arm_linux_record_tdep.size_stack_t = 12; 1917 arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long; 1918 arm_linux_record_tdep.size_stat64 = 96; 1919 arm_linux_record_tdep.size_gid_t = 4; 1920 arm_linux_record_tdep.size_uid_t = 4; 1921 arm_linux_record_tdep.size_PAGE_SIZE = 4096; 1922 arm_linux_record_tdep.size_flock64 = 24; 1923 arm_linux_record_tdep.size_user_desc = 16; 1924 arm_linux_record_tdep.size_io_event = 32; 1925 arm_linux_record_tdep.size_iocb = 64; 1926 arm_linux_record_tdep.size_epoll_event = 12; 1927 arm_linux_record_tdep.size_itimerspec 1928 = arm_linux_record_tdep.size_timespec * 2; 1929 arm_linux_record_tdep.size_mq_attr = 32; 1930 arm_linux_record_tdep.size_termios = 36; 1931 arm_linux_record_tdep.size_termios2 = 44; 1932 arm_linux_record_tdep.size_pid_t = 4; 1933 arm_linux_record_tdep.size_winsize = 8; 1934 arm_linux_record_tdep.size_serial_struct = 60; 1935 arm_linux_record_tdep.size_serial_icounter_struct = 80; 1936 arm_linux_record_tdep.size_hayes_esp_config = 12; 1937 arm_linux_record_tdep.size_size_t = 4; 1938 arm_linux_record_tdep.size_iovec = 8; 1939 arm_linux_record_tdep.size_time_t = 4; 1940 1941 /* These values are the second argument of system call "sys_ioctl". 1942 They are obtained from Linux Kernel source. */ 1943 arm_linux_record_tdep.ioctl_TCGETS = 0x5401; 1944 arm_linux_record_tdep.ioctl_TCSETS = 0x5402; 1945 arm_linux_record_tdep.ioctl_TCSETSW = 0x5403; 1946 arm_linux_record_tdep.ioctl_TCSETSF = 0x5404; 1947 arm_linux_record_tdep.ioctl_TCGETA = 0x5405; 1948 arm_linux_record_tdep.ioctl_TCSETA = 0x5406; 1949 arm_linux_record_tdep.ioctl_TCSETAW = 0x5407; 1950 arm_linux_record_tdep.ioctl_TCSETAF = 0x5408; 1951 arm_linux_record_tdep.ioctl_TCSBRK = 0x5409; 1952 arm_linux_record_tdep.ioctl_TCXONC = 0x540a; 1953 arm_linux_record_tdep.ioctl_TCFLSH = 0x540b; 1954 arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c; 1955 arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d; 1956 arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e; 1957 arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f; 1958 arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410; 1959 arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411; 1960 arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412; 1961 arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413; 1962 arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414; 1963 arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415; 1964 arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416; 1965 arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417; 1966 arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418; 1967 arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419; 1968 arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a; 1969 arm_linux_record_tdep.ioctl_FIONREAD = 0x541b; 1970 arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD; 1971 arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c; 1972 arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d; 1973 arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e; 1974 arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f; 1975 arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420; 1976 arm_linux_record_tdep.ioctl_FIONBIO = 0x5421; 1977 arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422; 1978 arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423; 1979 arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424; 1980 arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425; 1981 arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426; 1982 arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427; 1983 arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428; 1984 arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429; 1985 arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a; 1986 arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b; 1987 arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c; 1988 arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d; 1989 arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430; 1990 arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431; 1991 arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450; 1992 arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451; 1993 arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452; 1994 arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453; 1995 arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454; 1996 arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455; 1997 arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456; 1998 arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457; 1999 arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458; 2000 arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459; 2001 arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a; 2002 arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b; 2003 arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c; 2004 arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d; 2005 arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e; 2006 arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f; 2007 arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460; 2008 2009 /* These values are the second argument of system call "sys_fcntl" 2010 and "sys_fcntl64". They are obtained from Linux Kernel source. */ 2011 arm_linux_record_tdep.fcntl_F_GETLK = 5; 2012 arm_linux_record_tdep.fcntl_F_GETLK64 = 12; 2013 arm_linux_record_tdep.fcntl_F_SETLK64 = 13; 2014 arm_linux_record_tdep.fcntl_F_SETLKW64 = 14; 2015 2016 arm_linux_record_tdep.arg1 = ARM_A1_REGNUM; 2017 arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 1; 2018 arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 2; 2019 arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3; 2020 arm_linux_record_tdep.arg5 = ARM_A1_REGNUM + 4; 2021 arm_linux_record_tdep.arg6 = ARM_A1_REGNUM + 5; 2022 arm_linux_record_tdep.arg7 = ARM_A1_REGNUM + 6; 2023 2024 set_gdbarch_gcc_target_options (gdbarch, arm_linux_gcc_target_options); 2025 } 2026 2027 void _initialize_arm_linux_tdep (); 2028 void 2029 _initialize_arm_linux_tdep () 2030 { 2031 gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX, 2032 arm_linux_init_abi); 2033 } 2034
Indexes created Tue Mar 17 00:23:13 UTC 2026