diff options
| -rw-r--r-- | gdb/ppc-linux-tdep.c | 288 |
1 files changed, 3 insertions, 285 deletions
diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index 78c90fdb155..7080b1696aa 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -632,279 +632,6 @@ ppc_linux_svr4_fetch_link_map_offsets (void) return lmp; } - -/* Macros for matching instructions. Note that, since all the - operands are masked off before they're or-ed into the instruction, - you can use -1 to make masks. */ - -#define insn_d(opcd, rts, ra, d) \ - ((((opcd) & 0x3f) << 26) \ - | (((rts) & 0x1f) << 21) \ - | (((ra) & 0x1f) << 16) \ - | ((d) & 0xffff)) - -#define insn_ds(opcd, rts, ra, d, xo) \ - ((((opcd) & 0x3f) << 26) \ - | (((rts) & 0x1f) << 21) \ - | (((ra) & 0x1f) << 16) \ - | ((d) & 0xfffc) \ - | ((xo) & 0x3)) - -#define insn_xfx(opcd, rts, spr, xo) \ - ((((opcd) & 0x3f) << 26) \ - | (((rts) & 0x1f) << 21) \ - | (((spr) & 0x1f) << 16) \ - | (((spr) & 0x3e0) << 6) \ - | (((xo) & 0x3ff) << 1)) - -/* Read a PPC instruction from memory. PPC instructions are always - big-endian, no matter what endianness the program is running in, so - we can't use read_memory_integer or one of its friends here. */ -static unsigned int -read_insn (CORE_ADDR pc) -{ - unsigned char buf[4]; - - read_memory (pc, buf, 4); - return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; -} - - -/* An instruction to match. */ -struct insn_pattern -{ - unsigned int mask; /* mask the insn with this... */ - unsigned int data; /* ...and see if it matches this. */ - int optional; /* If non-zero, this insn may be absent. */ -}; - -/* Return non-zero if the instructions at PC match the series - described in PATTERN, or zero otherwise. PATTERN is an array of - 'struct insn_pattern' objects, terminated by an entry whose mask is - zero. - - When the match is successful, fill INSN[i] with what PATTERN[i] - matched. If PATTERN[i] is optional, and the instruction wasn't - present, set INSN[i] to -1. INSN should have as many elements as - PATTERN. Note that, if PATTERN contains optional instructions - which aren't present in memory, then INSN will have holes, so - INSN[i] isn't necessarily the i'th instruction in memory. */ -static int -insns_match_pattern (CORE_ADDR pc, - struct insn_pattern *pattern, - unsigned int *insn) -{ - int i; - - for (i = 0; pattern[i].mask; i++) - { - insn[i] = read_insn (pc); - if ((insn[i] & pattern[i].mask) == pattern[i].data) - pc += 4; - else if (pattern[i].optional) - insn[i] = 0; - else - return 0; - } - - return 1; -} - - -/* Return the 'd' field of the d-form instruction INSN, properly - sign-extended. */ -static CORE_ADDR -insn_d_field (unsigned int insn) -{ - return ((((CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000); -} - - -/* Return the 'ds' field of the ds-form instruction INSN, with the two - zero bits concatenated at the right, and properly - sign-extended. */ -static CORE_ADDR -insn_ds_field (unsigned int insn) -{ - return ((((CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000); -} - - -/* If DESC is the address of a 64-bit PowerPC Linux function - descriptor, return the descriptor's entry point. */ -static CORE_ADDR -ppc64_desc_entry_point (CORE_ADDR desc) -{ - /* The first word of the descriptor is the entry point. */ - return (CORE_ADDR) read_memory_unsigned_integer (desc, 8); -} - - -/* Pattern for the standard linkage function. These are built by - build_plt_stub in elf64-ppc.c, whose GLINK argument is always - zero. */ -static struct insn_pattern ppc64_standard_linkage[] = - { - /* addis r12, r2, <any> */ - { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 }, - - /* std r2, 40(r1) */ - { -1, insn_ds (62, 2, 1, 40, 0), 0 }, - - /* ld r11, <any>(r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, - - /* addis r12, r12, 1 <optional> */ - { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 }, - - /* ld r2, <any>(r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, - - /* addis r12, r12, 1 <optional> */ - { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 }, - - /* mtctr r11 */ - { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), - 0 }, - - /* ld r11, <any>(r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, - - /* bctr */ - { -1, 0x4e800420, 0 }, - - { 0, 0, 0 } - }; -#define PPC64_STANDARD_LINKAGE_LEN \ - (sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0])) - - -/* Recognize a 64-bit PowerPC Linux linkage function --- what GDB - calls a "solib trampoline". */ -static int -ppc64_in_solib_call_trampoline (CORE_ADDR pc, char *name) -{ - /* Detecting solib call trampolines on PPC64 Linux is a pain. - - It's not specifically solib call trampolines that are the issue. - Any call from one function to another function that uses a - different TOC requires a trampoline, to save the caller's TOC - pointer and then load the callee's TOC. An executable or shared - library may have more than one TOC, so even intra-object calls - may require a trampoline. Since executable and shared libraries - will all have their own distinct TOCs, every inter-object call is - also an inter-TOC call, and requires a trampoline --- so "solib - call trampolines" are just a special case. - - The 64-bit PowerPC Linux ABI calls these call trampolines - "linkage functions". Since they need to be near the functions - that call them, they all appear in .text, not in any special - section. The .plt section just contains an array of function - descriptors, from which the linkage functions load the callee's - entry point, TOC value, and environment pointer. So - in_plt_section is useless. The linkage functions don't have any - special linker symbols to name them, either. - - The only way I can see to recognize them is to actually look at - their code. They're generated by ppc_build_one_stub and some - other functions in bfd/elf64-ppc.c, so that should show us all - the instruction sequences we need to recognize. */ - unsigned int insn[PPC64_STANDARD_LINKAGE_LEN]; - - return insns_match_pattern (pc, ppc64_standard_linkage, insn); -} - - -/* When the dynamic linker is doing lazy symbol resolution, the first - call to a function in another object will go like this: - - - The user's function calls the linkage function: - - 100007c4: 4b ff fc d5 bl 10000498 - 100007c8: e8 41 00 28 ld r2,40(r1) - - - The linkage function loads the entry point (and other stuff) from - the function descriptor in the PLT, and jumps to it: - - 10000498: 3d 82 00 00 addis r12,r2,0 - 1000049c: f8 41 00 28 std r2,40(r1) - 100004a0: e9 6c 80 98 ld r11,-32616(r12) - 100004a4: e8 4c 80 a0 ld r2,-32608(r12) - 100004a8: 7d 69 03 a6 mtctr r11 - 100004ac: e9 6c 80 a8 ld r11,-32600(r12) - 100004b0: 4e 80 04 20 bctr - - - But since this is the first time that PLT entry has been used, it - sends control to its glink entry. That loads the number of the - PLT entry and jumps to the common glink0 code: - - 10000c98: 38 00 00 00 li r0,0 - 10000c9c: 4b ff ff dc b 10000c78 - - - The common glink0 code then transfers control to the dynamic - linker's fixup code: - - 10000c78: e8 41 00 28 ld r2,40(r1) - 10000c7c: 3d 82 00 00 addis r12,r2,0 - 10000c80: e9 6c 80 80 ld r11,-32640(r12) - 10000c84: e8 4c 80 88 ld r2,-32632(r12) - 10000c88: 7d 69 03 a6 mtctr r11 - 10000c8c: e9 6c 80 90 ld r11,-32624(r12) - 10000c90: 4e 80 04 20 bctr - - Eventually, this code will figure out how to skip all of this, - including the dynamic linker. At the moment, we just get through - the linkage function. */ - -/* If the current thread is about to execute a series of instructions - at PC matching the ppc64_standard_linkage pattern, and INSN is the result - from that pattern match, return the code address to which the - standard linkage function will send them. (This doesn't deal with - dynamic linker lazy symbol resolution stubs.) */ -static CORE_ADDR -ppc64_standard_linkage_target (CORE_ADDR pc, unsigned int *insn) -{ - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - - /* The address of the function descriptor this linkage function - references. */ - CORE_ADDR desc - = ((CORE_ADDR) read_register (tdep->ppc_gp0_regnum + 2) - + (insn_d_field (insn[0]) << 16) - + insn_ds_field (insn[2])); - - /* The first word of the descriptor is the entry point. Return that. */ - return ppc64_desc_entry_point (desc); -} - - -/* Given that we've begun executing a call trampoline at PC, return - the entry point of the function the trampoline will go to. */ -static CORE_ADDR -ppc64_skip_trampoline_code (CORE_ADDR pc) -{ - unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN]; - - if (insns_match_pattern (pc, ppc64_standard_linkage, - ppc64_standard_linkage_insn)) - return ppc64_standard_linkage_target (pc, ppc64_standard_linkage_insn); - else - return 0; -} - - -/* On 64-bit PowerPC Linux, the ELF header's e_entry field is the - address of a function descriptor for the entry point function, not - the actual entry point itself. So to find the actual address at - which execution should begin, we need to fetch the function's entry - point from that descriptor. */ -static CORE_ADDR -ppc64_call_dummy_address (void) -{ - return ppc64_desc_entry_point (entry_point_address ()); -} - - enum { ELF_NGREG = 48, ELF_NFPREG = 33, @@ -1016,22 +743,13 @@ ppc_linux_init_abi (struct gdbarch_info info, set_gdbarch_memory_remove_breakpoint (gdbarch, ppc_linux_memory_remove_breakpoint); - /* Shared library handling. */ - set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section); - set_gdbarch_skip_trampoline_code (gdbarch, - ppc_linux_skip_trampoline_code); set_solib_svr4_fetch_link_map_offsets (gdbarch, ppc_linux_svr4_fetch_link_map_offsets); } - - if (tdep->wordsize == 8) - { - set_gdbarch_call_dummy_address (gdbarch, ppc64_call_dummy_address); - set_gdbarch_in_solib_call_trampoline - (gdbarch, ppc64_in_solib_call_trampoline); - set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code); - } + /* Shared library handling. */ + set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section); + set_gdbarch_skip_trampoline_code (gdbarch, ppc_linux_skip_trampoline_code); } void |