From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14727 invoked by alias); 27 Dec 2012 21:36:32 -0000 Received: (qmail 14628 invoked by uid 22791); 27 Dec 2012 21:36:32 -0000 X-SWARE-Spam-Status: No, hits=-0.6 required=5.0 tests=AWL,BAYES_50,TW_CN,TW_XF,TW_YM,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.fgznet.ch (HELO smtp.fgznet.ch) (81.92.96.47) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 27 Dec 2012 21:36:18 +0000 Received: from deuterium.andreas.nets (dhclient-91-190-14-19.flashcable.ch [91.190.14.19]) by smtp.fgznet.ch (8.13.8/8.13.8/Submit_SMTPAUTH) with ESMTP id qBRLaCkv082794 for ; Thu, 27 Dec 2012 22:36:15 +0100 (CET) (envelope-from andreast-list@fgznet.ch) Message-ID: <50DCBF4B.7000009@fgznet.ch> Date: Thu, 27 Dec 2012 21:36:00 -0000 From: Andreas Tobler User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.5; rv:16.0) Gecko/20121026 Thunderbird/16.0.2 MIME-Version: 1.0 To: gdb-patches@sourceware.org Subject: [RFC] patch to refactor ppc64 specific code from ppc-linux-tdep Content-Type: multipart/mixed; boundary="------------070805070503020507040100" X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-12/txt/msg00827.txt.bz2 This is a multi-part message in MIME format. --------------070805070503020507040100 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 1714 Hi all, in order to avoid code duplication for the FreeBSD powerpc port I started to cut off common code from ppc-linux-tdep.c into a new file to be used for FreeBSD and GNU/Linux PowerPC 64-bit. The file name is open so far. Better namings are welcome. Attached my first attempt, tested on GNU/Linux ppc64, Fedora 17 and on x86_64-*freebsd* with --eanble-targets=all. On the Linux side I do not see any regression. So far I have only covered functions which I can use on FreeBSD powerpc64. There might be others too but I do not see any for now. I'd appreciate comments, corrections. TIA, Andreas 2012-12-19 Andreas Tobler * Makefile.in (ALL_TARGET_OBS): Add new file ppc64-common-tdep.o (HFILES_NO_SRCDIR): Likewise. (ALLDEPFILES): Likewise. * configure.tgt: Add new file for powerpc-linux. * ppc64-common-tdep.h: New file. * ppc64-common-tdep.c New file. (insn_d, insn_ds, insn_xfx, read_insn) (insns_match_pattern, insn_d_field, insn_ds_field) (ppc64_desc_entry_point): Move from ppc-linux-tdep.c to here. (PPC64_STANDARD_LINKAGE1_LEN, PPC64_STANDARD_LINKAGE2_LEN) (PPC64_STANDARD_LINKAGE2_LEN): Likewise and use ARRAY_SIZE macro. (ppc64_standard_linkage1_target, ppc64_standard_linkage2_target) (ppc64_standard_linkage3_target, ppc64_skip_trampoline_code): Move from ppc-linux-tdep.c to here. (ppc64_convert_from_func_ptr_addr): Rename it from ppc64_linux_convert_from_func_ptr_addr to ppc64_convert_from_func_ptr_addr and move it from ppc-linux-tdep.c to here. * ppc-linux-tdep.c: Include ppc64-common-tdep.h. Removed above functions. (ppc_linux_init_abi): Rename ppc64_linux_convert_from_func_ptr_addr to ppc64_linux_convert_from_func_ptr_addr. --------------070805070503020507040100 Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="ppc64_common.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="ppc64_common.diff" Content-length: 35203 diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 5ded1a5..0987f00 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -563,7 +563,7 @@ ALL_TARGET_OBS = \ mt-tdep.o \ nto-tdep.o \ ppc-linux-tdep.o ppcnbsd-tdep.o ppcobsd-tdep.o ppc-sysv-tdep.o \ - rl78-tdep.o \ + ppc64-common-tdep.o rl78-tdep.o \ rs6000-aix-tdep.o rs6000-tdep.o ppc-ravenscar-thread.o \ rs6000-lynx178-tdep.o \ rx-tdep.o \ @@ -804,7 +804,8 @@ amd64-linux-tdep.h linespec.h i387-tdep.h mn10300-tdep.h \ sparc64-tdep.h monitor.h ppcobsd-tdep.h srec.h solib-pa64.h \ coff-pe-read.h parser-defs.h gdb_ptrace.h mips-linux-tdep.h \ m68k-tdep.h spu-tdep.h jv-lang.h environ.h solib-irix.h amd64-tdep.h \ -doublest.h regset.h hppa-tdep.h ppc-linux-tdep.h rs6000-tdep.h \ +doublest.h regset.h hppa-tdep.h ppc-linux-tdep.h ppc64-common-tdep.h \ +rs6000-tdep.h \ common/gdb_locale.h common/gdb_dirent.h arch-utils.h trad-frame.h gnu-nat.h \ language.h nbsd-tdep.h solib-svr4.h \ macroexp.h ui-file.h regcache.h gdb_string.h tracepoint.h i386-tdep.h \ @@ -1479,7 +1480,7 @@ ALLDEPFILES = \ solib-osf.c \ somread.c solib-som.c \ posix-hdep.c \ - ppc-sysv-tdep.c ppc-linux-nat.c ppc-linux-tdep.c \ + ppc-sysv-tdep.c ppc-linux-nat.c ppc-linux-tdep.c ppc64-common-tdep.c \ ppcnbsd-nat.c ppcnbsd-tdep.c \ ppcobsd-nat.c ppcobsd-tdep.c \ procfs.c \ diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 5b77bb2..dca490d 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -405,7 +405,8 @@ powerpc-*-aix* | rs6000-*-*) powerpc-*-linux* | powerpc64-*-linux*) # Target: PowerPC running Linux gdb_target_obs="rs6000-tdep.o ppc-linux-tdep.o ppc-sysv-tdep.o \ - solib-svr4.o solib-spu.o spu-multiarch.o \ + ppc64-common-tdep.o solib-svr4.o solib-spu.o \ + spu-multiarch.o \ glibc-tdep.o symfile-mem.o linux-tdep.o \ ravenscar-thread.o ppc-ravenscar-thread.o" gdb_sim=../sim/ppc/libsim.a diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index f88d697..f3dec40 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -37,6 +37,7 @@ #include "solist.h" #include "ppc-tdep.h" #include "ppc-linux-tdep.h" +#include "ppc64-common-tdep.h" #include "glibc-tdep.h" #include "trad-frame.h" #include "frame-unwind.h" @@ -255,277 +256,6 @@ ppc_linux_return_value (struct gdbarch *gdbarch, struct value *function, readbuf, writebuf); } -/* 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 0 (which is not a valid PPC instruction). - 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 GNU/Linux function - descriptor, return the descriptor's entry point. */ -static CORE_ADDR -ppc64_desc_entry_point (struct gdbarch *gdbarch, CORE_ADDR desc) -{ - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - /* The first word of the descriptor is the entry point. */ - return (CORE_ADDR) read_memory_unsigned_integer (desc, 8, byte_order); -} - - -/* 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_linkage1[] = - { - /* addis r12, r2, */ - { 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, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, - - /* addis r12, r12, 1 */ - { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, - - /* ld r2, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, - - /* addis r12, r12, 1 */ - { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, - - /* mtctr r11 */ - { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, - - /* ld r11, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, - - /* bctr */ - { -1, 0x4e800420, 0 }, - - { 0, 0, 0 } - }; -#define PPC64_STANDARD_LINKAGE1_LEN \ - (sizeof (ppc64_standard_linkage1) / sizeof (ppc64_standard_linkage1[0])) - -static struct insn_pattern ppc64_standard_linkage2[] = - { - /* addis r12, r2, */ - { 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, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, - - /* addi r12, r12, */ - { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 }, - - /* mtctr r11 */ - { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, - - /* ld r2, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, - - /* ld r11, (r12) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, - - /* bctr */ - { -1, 0x4e800420, 0 }, - - { 0, 0, 0 } - }; -#define PPC64_STANDARD_LINKAGE2_LEN \ - (sizeof (ppc64_standard_linkage2) / sizeof (ppc64_standard_linkage2[0])) - -static struct insn_pattern ppc64_standard_linkage3[] = - { - /* std r2, 40(r1) */ - { -1, insn_ds (62, 2, 1, 40, 0), 0 }, - - /* ld r11, (r2) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 }, - - /* addi r2, r2, */ - { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 }, - - /* mtctr r11 */ - { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, - - /* ld r11, (r2) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 }, - - /* ld r2, (r2) */ - { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 }, - - /* bctr */ - { -1, 0x4e800420, 0 }, - - { 0, 0, 0 } - }; -#define PPC64_STANDARD_LINKAGE3_LEN \ - (sizeof (ppc64_standard_linkage3) / sizeof (ppc64_standard_linkage3[0])) - - -/* 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_linkage1_target (struct frame_info *frame, - CORE_ADDR pc, unsigned int *insn) -{ - struct gdbarch *gdbarch = get_frame_arch (frame); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - /* The address of the function descriptor this linkage function - references. */ - CORE_ADDR desc - = ((CORE_ADDR) get_frame_register_unsigned (frame, - 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 (gdbarch, desc); -} - static struct core_regset_section ppc_linux_vsx_regset_sections[] = { { ".reg", 48 * 4, "general-purpose" }, @@ -574,43 +304,6 @@ static struct core_regset_section ppc64_linux_fp_regset_sections[] = { NULL, 0} }; -static CORE_ADDR -ppc64_standard_linkage2_target (struct frame_info *frame, - CORE_ADDR pc, unsigned int *insn) -{ - struct gdbarch *gdbarch = get_frame_arch (frame); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - /* The address of the function descriptor this linkage function - references. */ - CORE_ADDR desc - = ((CORE_ADDR) get_frame_register_unsigned (frame, - 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 (gdbarch, desc); -} - -static CORE_ADDR -ppc64_standard_linkage3_target (struct frame_info *frame, - CORE_ADDR pc, unsigned int *insn) -{ - struct gdbarch *gdbarch = get_frame_arch (frame); - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - /* The address of the function descriptor this linkage function - references. */ - CORE_ADDR desc - = ((CORE_ADDR) get_frame_register_unsigned (frame, - tdep->ppc_gp0_regnum + 2) - + insn_ds_field (insn[1])); - - /* The first word of the descriptor is the entry point. Return that. */ - return ppc64_desc_entry_point (gdbarch, desc); -} - /* PLT stub in executable. */ static struct insn_pattern powerpc32_plt_stub[] = { @@ -692,109 +385,6 @@ ppc_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) return target; } -/* 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 (struct frame_info *frame, CORE_ADDR pc) -{ - unsigned int ppc64_standard_linkage1_insn[PPC64_STANDARD_LINKAGE1_LEN]; - unsigned int ppc64_standard_linkage2_insn[PPC64_STANDARD_LINKAGE2_LEN]; - unsigned int ppc64_standard_linkage3_insn[PPC64_STANDARD_LINKAGE3_LEN]; - CORE_ADDR target; - - if (insns_match_pattern (pc, ppc64_standard_linkage1, - ppc64_standard_linkage1_insn)) - pc = ppc64_standard_linkage1_target (frame, pc, - ppc64_standard_linkage1_insn); - else if (insns_match_pattern (pc, ppc64_standard_linkage2, - ppc64_standard_linkage2_insn)) - pc = ppc64_standard_linkage2_target (frame, pc, - ppc64_standard_linkage2_insn); - else if (insns_match_pattern (pc, ppc64_standard_linkage3, - ppc64_standard_linkage3_insn)) - pc = ppc64_standard_linkage3_target (frame, pc, - ppc64_standard_linkage3_insn); - else - return 0; - - /* The PLT descriptor will either point to the already resolved target - address, or else to a glink stub. As the latter carry synthetic @plt - symbols, find_solib_trampoline_target should be able to resolve them. */ - target = find_solib_trampoline_target (frame, pc); - return target? target : pc; -} - - -/* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64 - GNU/Linux. - - Usually a function pointer's representation is simply the address - of the function. On GNU/Linux on the PowerPC however, a function - pointer may be a pointer to a function descriptor. - - For PPC64, a function descriptor is a TOC entry, in a data section, - which contains three words: the first word is the address of the - function, the second word is the TOC pointer (r2), and the third word - is the static chain value. - - Throughout GDB it is currently assumed that a function pointer contains - the address of the function, which is not easy to fix. In addition, the - conversion of a function address to a function pointer would - require allocation of a TOC entry in the inferior's memory space, - with all its drawbacks. To be able to call C++ virtual methods in - the inferior (which are called via function pointers), - find_function_addr uses this function to get the function address - from a function pointer. - - If ADDR points at what is clearly a function descriptor, transform - it into the address of the corresponding function, if needed. Be - conservative, otherwise GDB will do the transformation on any - random addresses such as occur when there is no symbol table. */ - -static CORE_ADDR -ppc64_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch, - CORE_ADDR addr, - struct target_ops *targ) -{ - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - struct target_section *s = target_section_by_addr (targ, addr); - - /* Check if ADDR points to a function descriptor. */ - if (s && strcmp (s->the_bfd_section->name, ".opd") == 0) - { - /* There may be relocations that need to be applied to the .opd - section. Unfortunately, this function may be called at a time - where these relocations have not yet been performed -- this can - happen for example shortly after a library has been loaded with - dlopen, but ld.so has not yet applied the relocations. - - To cope with both the case where the relocation has been applied, - and the case where it has not yet been applied, we do *not* read - the (maybe) relocated value from target memory, but we instead - read the non-relocated value from the BFD, and apply the relocation - offset manually. - - This makes the assumption that all .opd entries are always relocated - by the same offset the section itself was relocated. This should - always be the case for GNU/Linux executables and shared libraries. - Note that other kind of object files (e.g. those added via - add-symbol-files) will currently never end up here anyway, as this - function accesses *target* sections only; only the main exec and - shared libraries are ever added to the target. */ - - gdb_byte buf[8]; - int res; - - res = bfd_get_section_contents (s->bfd, s->the_bfd_section, - &buf, addr - s->addr, 8); - if (res != 0) - return extract_unsigned_integer (buf, 8, byte_order) - - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr; - } - - return addr; -} - /* Wrappers to handle Linux-only registers. */ static void @@ -1743,7 +1333,7 @@ ppc_linux_init_abi (struct gdbarch_info info, /* Handle PPC GNU/Linux 64-bit function pointers (which are really function descriptors). */ set_gdbarch_convert_from_func_ptr_addr - (gdbarch, ppc64_linux_convert_from_func_ptr_addr); + (gdbarch, ppc64_convert_from_func_ptr_addr); /* Shared library handling. */ set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code); diff --git a/gdb/ppc64-common-tdep.c b/gdb/ppc64-common-tdep.c new file mode 100644 index 0000000..ee53ce9 --- /dev/null +++ b/gdb/ppc64-common-tdep.c @@ -0,0 +1,426 @@ +/* Common target-dependent code for ppc64 GDB, the GNU debugger. + + Copyright (C) 2012 Free Software + Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "frame.h" +#include "gdbcore.h" +#include "ppc-tdep.h" +#include "ppc64-common-tdep.h" + +/* 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 hardcode BFD_ENDIAN_BIG for read_memory_unsigned_integer. */ + +static unsigned int +read_insn (CORE_ADDR pc) +{ + return read_memory_unsigned_integer (pc, 4, BFD_ENDIAN_BIG); +} + +/* 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 0 (which is not a valid PPC instruction). + 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. */ + +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. */ + +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 FreeBSD function + descriptor, return the descriptor's entry point. */ + +static CORE_ADDR +ppc64_desc_entry_point (struct gdbarch *gdbarch, CORE_ADDR desc) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + /* The first word of the descriptor is the entry point. */ + return (CORE_ADDR) read_memory_unsigned_integer (desc, 8, byte_order); +} + +/* 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_linkage1[] = + { + /* addis r12, r2, */ + { 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, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, + + /* addis r12, r12, 1 */ + { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, + + /* ld r2, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, + + /* addis r12, r12, 1 */ + { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, + + /* mtctr r11 */ + { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, + + /* ld r11, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, + + /* bctr */ + { -1, 0x4e800420, 0 }, + + { 0, 0, 0 } + }; + +#define PPC64_STANDARD_LINKAGE1_LEN ARRAY_SIZE (ppc64_standard_linkage1) + +static struct insn_pattern ppc64_standard_linkage2[] = + { + /* addis r12, r2, */ + { 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, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, + + /* addi r12, r12, */ + { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 }, + + /* mtctr r11 */ + { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, + + /* ld r2, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, + + /* ld r11, (r12) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, + + /* bctr */ + { -1, 0x4e800420, 0 }, + + { 0, 0, 0 } + }; + +#define PPC64_STANDARD_LINKAGE2_LEN ARRAY_SIZE (ppc64_standard_linkage2) + +static struct insn_pattern ppc64_standard_linkage3[] = + { + /* std r2, 40(r1) */ + { -1, insn_ds (62, 2, 1, 40, 0), 0 }, + + /* ld r11, (r2) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 }, + + /* addi r2, r2, */ + { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 }, + + /* mtctr r11 */ + { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, + + /* ld r11, (r2) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 }, + + /* ld r2, (r2) */ + { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 }, + + /* bctr */ + { -1, 0x4e800420, 0 }, + + { 0, 0, 0 } + }; + +#define PPC64_STANDARD_LINKAGE3_LEN ARRAY_SIZE (ppc64_standard_linkage3) + +/* 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_linkage1_target (struct frame_info *frame, + CORE_ADDR pc, unsigned int *insn) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + /* The address of the function descriptor this linkage function + references. */ + CORE_ADDR desc + = ((CORE_ADDR) get_frame_register_unsigned (frame, + 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 (gdbarch, desc); +} + +static CORE_ADDR +ppc64_standard_linkage2_target (struct frame_info *frame, + CORE_ADDR pc, unsigned int *insn) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + /* The address of the function descriptor this linkage function + references. */ + CORE_ADDR desc + = ((CORE_ADDR) get_frame_register_unsigned (frame, + 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 (gdbarch, desc); +} + +static CORE_ADDR +ppc64_standard_linkage3_target (struct frame_info *frame, + CORE_ADDR pc, unsigned int *insn) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + /* The address of the function descriptor this linkage function + references. */ + CORE_ADDR desc + = ((CORE_ADDR) get_frame_register_unsigned (frame, + tdep->ppc_gp0_regnum + 2) + + insn_ds_field (insn[1])); + + /* The first word of the descriptor is the entry point. Return that. */ + return ppc64_desc_entry_point (gdbarch, desc); +} + + +/* Given that we've begun executing a call trampoline at PC, return + the entry point of the function the trampoline will go to. */ + +CORE_ADDR +ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) +{ + unsigned int ppc64_standard_linkage1_insn[PPC64_STANDARD_LINKAGE1_LEN]; + unsigned int ppc64_standard_linkage2_insn[PPC64_STANDARD_LINKAGE2_LEN]; + unsigned int ppc64_standard_linkage3_insn[PPC64_STANDARD_LINKAGE3_LEN]; + CORE_ADDR target; + + if (insns_match_pattern (pc, ppc64_standard_linkage1, + ppc64_standard_linkage1_insn)) + pc = ppc64_standard_linkage1_target (frame, pc, + ppc64_standard_linkage1_insn); + else if (insns_match_pattern (pc, ppc64_standard_linkage2, + ppc64_standard_linkage2_insn)) + pc = ppc64_standard_linkage2_target (frame, pc, + ppc64_standard_linkage2_insn); + else if (insns_match_pattern (pc, ppc64_standard_linkage3, + ppc64_standard_linkage3_insn)) + pc = ppc64_standard_linkage3_target (frame, pc, + ppc64_standard_linkage3_insn); + else + return 0; + + /* The PLT descriptor will either point to the already resolved target + address, or else to a glink stub. As the latter carry synthetic @plt + symbols, find_solib_trampoline_target should be able to resolve them. */ + target = find_solib_trampoline_target (frame, pc); + return target ? target : pc; +} + +/* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64 + GNU/Linux. + + Usually a function pointer's representation is simply the address + of the function. On GNU/Linux on the PowerPC however, a function + pointer may be a pointer to a function descriptor. + + For PPC64, a function descriptor is a TOC entry, in a data section, + which contains three words: the first word is the address of the + function, the second word is the TOC pointer (r2), and the third word + is the static chain value. + + Throughout GDB it is currently assumed that a function pointer contains + the address of the function, which is not easy to fix. In addition, the + conversion of a function address to a function pointer would + require allocation of a TOC entry in the inferior's memory space, + with all its drawbacks. To be able to call C++ virtual methods in + the inferior (which are called via function pointers), + find_function_addr uses this function to get the function address + from a function pointer. + + If ADDR points at what is clearly a function descriptor, transform + it into the address of the corresponding function, if needed. Be + conservative, otherwise GDB will do the transformation on any + random addresses such as occur when there is no symbol table. */ + +CORE_ADDR +ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, + CORE_ADDR addr, + struct target_ops *targ) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + struct target_section *s = target_section_by_addr (targ, addr); + + /* Check if ADDR points to a function descriptor. */ + if (s && strcmp (s->the_bfd_section->name, ".opd") == 0) + { + /* There may be relocations that need to be applied to the .opd + section. Unfortunately, this function may be called at a time + where these relocations have not yet been performed -- this can + happen for example shortly after a library has been loaded with + dlopen, but ld.so has not yet applied the relocations. + + To cope with both the case where the relocation has been applied, + and the case where it has not yet been applied, we do *not* read + the (maybe) relocated value from target memory, but we instead + read the non-relocated value from the BFD, and apply the relocation + offset manually. + + This makes the assumption that all .opd entries are always relocated + by the same offset the section itself was relocated. This should + always be the case for GNU/Linux executables and shared libraries. + Note that other kind of object files (e.g. those added via + add-symbol-files) will currently never end up here anyway, as this + function accesses *target* sections only; only the main exec and + shared libraries are ever added to the target. */ + + gdb_byte buf[8]; + int res; + + res = bfd_get_section_contents (s->bfd, s->the_bfd_section, + &buf, addr - s->addr, 8); + if (res != 0) + return extract_unsigned_integer (buf, 8, byte_order) + - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr; + } + + return addr; +} diff --git a/gdb/ppc64-common-tdep.h b/gdb/ppc64-common-tdep.h new file mode 100644 index 0000000..57fe8de --- /dev/null +++ b/gdb/ppc64-common-tdep.h @@ -0,0 +1,49 @@ +/* Common target-dependent code for ppc64. + + Copyright (C) 2012 + Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#ifndef PPC64_COMMON_TDEP_H +#define PPC64_COMMON_TDEP_H + +/* 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. */ +}; + +struct gdbarch; +struct frame_info; +struct target_ops; + +int +insns_match_pattern (CORE_ADDR pc, struct insn_pattern *pattern, + unsigned int *insn); +CORE_ADDR +insn_d_field (unsigned int insn); + +CORE_ADDR +ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc); +CORE_ADDR +ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, + CORE_ADDR addr, struct target_ops *targ); + +#endif /* PPC64_COMMON_TDEP_H */ --------------070805070503020507040100--