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