X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fppc-linux-tdep.c;h=1aaac0bd45a176919a996ae58d14c6cdfe3dab65;hb=85e747d2499c43ff4003d348304f3d8f573d5cad;hp=279c17c465c920d2155de58fc300b790ed19c386;hpb=6974274f54a973c0479eb15335073512f0b26c3f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c index 279c17c465..1aaac0bd45 100644 --- a/gdb/ppc-linux-tdep.c +++ b/gdb/ppc-linux-tdep.c @@ -1,13 +1,14 @@ /* Target-dependent code for GDB, the GNU debugger. - Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + 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 2 of the License, or + 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, @@ -16,9 +17,7 @@ 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, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "frame.h" @@ -32,416 +31,34 @@ #include "regcache.h" #include "value.h" #include "osabi.h" - +#include "regset.h" #include "solib-svr4.h" +#include "solib-spu.h" #include "ppc-tdep.h" +#include "ppc-linux-tdep.h" +#include "trad-frame.h" +#include "frame-unwind.h" +#include "tramp-frame.h" +#include "observer.h" +#include "auxv.h" +#include "elf/common.h" + +#include "features/rs6000/powerpc-32l.c" +#include "features/rs6000/powerpc-altivec32l.c" +#include "features/rs6000/powerpc-cell32l.c" +#include "features/rs6000/powerpc-vsx32l.c" +#include "features/rs6000/powerpc-isa205-32l.c" +#include "features/rs6000/powerpc-isa205-altivec32l.c" +#include "features/rs6000/powerpc-isa205-vsx32l.c" +#include "features/rs6000/powerpc-64l.c" +#include "features/rs6000/powerpc-altivec64l.c" +#include "features/rs6000/powerpc-cell64l.c" +#include "features/rs6000/powerpc-vsx64l.c" +#include "features/rs6000/powerpc-isa205-64l.c" +#include "features/rs6000/powerpc-isa205-altivec64l.c" +#include "features/rs6000/powerpc-isa205-vsx64l.c" +#include "features/rs6000/powerpc-e500l.c" -/* The following instructions are used in the signal trampoline code - on GNU/Linux PPC. The kernel used to use magic syscalls 0x6666 and - 0x7777 but now uses the sigreturn syscalls. We check for both. */ -#define INSTR_LI_R0_0x6666 0x38006666 -#define INSTR_LI_R0_0x7777 0x38007777 -#define INSTR_LI_R0_NR_sigreturn 0x38000077 -#define INSTR_LI_R0_NR_rt_sigreturn 0x380000AC - -#define INSTR_SC 0x44000002 - -/* Since the *-tdep.c files are platform independent (i.e, they may be - used to build cross platform debuggers), we can't include system - headers. Therefore, details concerning the sigcontext structure - must be painstakingly rerecorded. What's worse, if these details - ever change in the header files, they'll have to be changed here - as well. */ - -/* __SIGNAL_FRAMESIZE from */ -#define PPC_LINUX_SIGNAL_FRAMESIZE 64 - -/* From , offsetof(struct sigcontext_struct, regs) == 0x1c */ -#define PPC_LINUX_REGS_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x1c) - -/* From , - offsetof(struct sigcontext_struct, handler) == 0x14 */ -#define PPC_LINUX_HANDLER_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x14) - -/* From , values for PT_NIP, PT_R1, and PT_LNK */ -#define PPC_LINUX_PT_R0 0 -#define PPC_LINUX_PT_R1 1 -#define PPC_LINUX_PT_R2 2 -#define PPC_LINUX_PT_R3 3 -#define PPC_LINUX_PT_R4 4 -#define PPC_LINUX_PT_R5 5 -#define PPC_LINUX_PT_R6 6 -#define PPC_LINUX_PT_R7 7 -#define PPC_LINUX_PT_R8 8 -#define PPC_LINUX_PT_R9 9 -#define PPC_LINUX_PT_R10 10 -#define PPC_LINUX_PT_R11 11 -#define PPC_LINUX_PT_R12 12 -#define PPC_LINUX_PT_R13 13 -#define PPC_LINUX_PT_R14 14 -#define PPC_LINUX_PT_R15 15 -#define PPC_LINUX_PT_R16 16 -#define PPC_LINUX_PT_R17 17 -#define PPC_LINUX_PT_R18 18 -#define PPC_LINUX_PT_R19 19 -#define PPC_LINUX_PT_R20 20 -#define PPC_LINUX_PT_R21 21 -#define PPC_LINUX_PT_R22 22 -#define PPC_LINUX_PT_R23 23 -#define PPC_LINUX_PT_R24 24 -#define PPC_LINUX_PT_R25 25 -#define PPC_LINUX_PT_R26 26 -#define PPC_LINUX_PT_R27 27 -#define PPC_LINUX_PT_R28 28 -#define PPC_LINUX_PT_R29 29 -#define PPC_LINUX_PT_R30 30 -#define PPC_LINUX_PT_R31 31 -#define PPC_LINUX_PT_NIP 32 -#define PPC_LINUX_PT_MSR 33 -#define PPC_LINUX_PT_CTR 35 -#define PPC_LINUX_PT_LNK 36 -#define PPC_LINUX_PT_XER 37 -#define PPC_LINUX_PT_CCR 38 -#define PPC_LINUX_PT_MQ 39 -#define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */ -#define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31) -#define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1) - -static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc); - -/* Determine if pc is in a signal trampoline... - - Ha! That's not what this does at all. wait_for_inferior in - infrun.c calls PC_IN_SIGTRAMP in order to detect entry into a - signal trampoline just after delivery of a signal. But on - GNU/Linux, signal trampolines are used for the return path only. - The kernel sets things up so that the signal handler is called - directly. - - If we use in_sigtramp2() in place of in_sigtramp() (see below) - we'll (often) end up with stop_pc in the trampoline and prev_pc in - the (now exited) handler. The code there will cause a temporary - breakpoint to be set on prev_pc which is not very likely to get hit - again. - - If this is confusing, think of it this way... the code in - wait_for_inferior() needs to be able to detect entry into a signal - trampoline just after a signal is delivered, not after the handler - has been run. - - So, we define in_sigtramp() below to return 1 if the following is - true: - - 1) The previous frame is a real signal trampoline. - - - and - - - 2) pc is at the first or second instruction of the corresponding - handler. - - Why the second instruction? It seems that wait_for_inferior() - never sees the first instruction when single stepping. When a - signal is delivered while stepping, the next instruction that - would've been stepped over isn't, instead a signal is delivered and - the first instruction of the handler is stepped over instead. That - puts us on the second instruction. (I added the test for the - first instruction long after the fact, just in case the observed - behavior is ever fixed.) - - PC_IN_SIGTRAMP is called from blockframe.c as well in order to set - the frame's type (if a SIGTRAMP_FRAME). Because of our strange - definition of in_sigtramp below, we can't rely on the frame's type - getting set correctly from within blockframe.c. This is why we - take pains to set it in init_extra_frame_info(). - - NOTE: cagney/2002-11-10: I suspect the real problem here is that - the get_prev_frame() only initializes the frame's type after the - call to INIT_FRAME_INFO. get_prev_frame() should be fixed, this - code shouldn't be working its way around a bug :-(. */ - -int -ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name) -{ - CORE_ADDR lr; - CORE_ADDR sp; - CORE_ADDR tramp_sp; - char buf[4]; - CORE_ADDR handler; - - lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum); - if (!ppc_linux_at_sigtramp_return_path (lr)) - return 0; - - sp = read_register (SP_REGNUM); - - if (target_read_memory (sp, buf, sizeof (buf)) != 0) - return 0; - - tramp_sp = extract_unsigned_integer (buf, 4); - - if (target_read_memory (tramp_sp + PPC_LINUX_HANDLER_PTR_OFFSET, buf, - sizeof (buf)) != 0) - return 0; - - handler = extract_unsigned_integer (buf, 4); - - return (pc == handler || pc == handler + 4); -} - -static inline int -insn_is_sigreturn (unsigned long pcinsn) -{ - switch(pcinsn) - { - case INSTR_LI_R0_0x6666: - case INSTR_LI_R0_0x7777: - case INSTR_LI_R0_NR_sigreturn: - case INSTR_LI_R0_NR_rt_sigreturn: - return 1; - default: - return 0; - } -} - -/* - * The signal handler trampoline is on the stack and consists of exactly - * two instructions. The easiest and most accurate way of determining - * whether the pc is in one of these trampolines is by inspecting the - * instructions. It'd be faster though if we could find a way to do this - * via some simple address comparisons. - */ -static int -ppc_linux_at_sigtramp_return_path (CORE_ADDR pc) -{ - char buf[12]; - unsigned long pcinsn; - if (target_read_memory (pc - 4, buf, sizeof (buf)) != 0) - return 0; - - /* extract the instruction at the pc */ - pcinsn = extract_unsigned_integer (buf + 4, 4); - - return ( - (insn_is_sigreturn (pcinsn) - && extract_unsigned_integer (buf + 8, 4) == INSTR_SC) - || - (pcinsn == INSTR_SC - && insn_is_sigreturn (extract_unsigned_integer (buf, 4)))); -} - -static CORE_ADDR -ppc_linux_skip_trampoline_code (CORE_ADDR pc) -{ - char buf[4]; - struct obj_section *sect; - struct objfile *objfile; - unsigned long insn; - CORE_ADDR plt_start = 0; - CORE_ADDR symtab = 0; - CORE_ADDR strtab = 0; - int num_slots = -1; - int reloc_index = -1; - CORE_ADDR plt_table; - CORE_ADDR reloc; - CORE_ADDR sym; - long symidx; - char symname[1024]; - struct minimal_symbol *msymbol; - - /* Find the section pc is in; return if not in .plt */ - sect = find_pc_section (pc); - if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0) - return 0; - - objfile = sect->objfile; - - /* Pick up the instruction at pc. It had better be of the - form - li r11, IDX - - where IDX is an index into the plt_table. */ - - if (target_read_memory (pc, buf, 4) != 0) - return 0; - insn = extract_unsigned_integer (buf, 4); - - if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ ) - return 0; - - reloc_index = (insn << 16) >> 16; - - /* Find the objfile that pc is in and obtain the information - necessary for finding the symbol name. */ - for (sect = objfile->sections; sect < objfile->sections_end; ++sect) - { - const char *secname = sect->the_bfd_section->name; - if (strcmp (secname, ".plt") == 0) - plt_start = sect->addr; - else if (strcmp (secname, ".rela.plt") == 0) - num_slots = ((int) sect->endaddr - (int) sect->addr) / 12; - else if (strcmp (secname, ".dynsym") == 0) - symtab = sect->addr; - else if (strcmp (secname, ".dynstr") == 0) - strtab = sect->addr; - } - - /* Make sure we have all the information we need. */ - if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0) - return 0; - - /* Compute the value of the plt table */ - plt_table = plt_start + 72 + 8 * num_slots; - - /* Get address of the relocation entry (Elf32_Rela) */ - if (target_read_memory (plt_table + reloc_index, buf, 4) != 0) - return 0; - reloc = extract_unsigned_integer (buf, 4); - - sect = find_pc_section (reloc); - if (!sect) - return 0; - - if (strcmp (sect->the_bfd_section->name, ".text") == 0) - return reloc; - - /* Now get the r_info field which is the relocation type and symbol - index. */ - if (target_read_memory (reloc + 4, buf, 4) != 0) - return 0; - symidx = extract_unsigned_integer (buf, 4); - - /* Shift out the relocation type leaving just the symbol index */ - /* symidx = ELF32_R_SYM(symidx); */ - symidx = symidx >> 8; - - /* compute the address of the symbol */ - sym = symtab + symidx * 4; - - /* Fetch the string table index */ - if (target_read_memory (sym, buf, 4) != 0) - return 0; - symidx = extract_unsigned_integer (buf, 4); - - /* Fetch the string; we don't know how long it is. Is it possible - that the following will fail because we're trying to fetch too - much? */ - if (target_read_memory (strtab + symidx, symname, sizeof (symname)) != 0) - return 0; - - /* This might not work right if we have multiple symbols with the - same name; the only way to really get it right is to perform - the same sort of lookup as the dynamic linker. */ - msymbol = lookup_minimal_symbol_text (symname, NULL, NULL); - if (!msymbol) - return 0; - - return SYMBOL_VALUE_ADDRESS (msymbol); -} - -/* The rs6000 version of FRAME_SAVED_PC will almost work for us. The - signal handler details are different, so we'll handle those here - and call the rs6000 version to do the rest. */ -CORE_ADDR -ppc_linux_frame_saved_pc (struct frame_info *fi) -{ - if ((get_frame_type (fi) == SIGTRAMP_FRAME)) - { - CORE_ADDR regs_addr = - read_memory_integer (get_frame_base (fi) - + PPC_LINUX_REGS_PTR_OFFSET, 4); - /* return the NIP in the regs array */ - return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_NIP, 4); - } - else if (get_next_frame (fi) - && (get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME)) - { - CORE_ADDR regs_addr = - read_memory_integer (get_frame_base (get_next_frame (fi)) - + PPC_LINUX_REGS_PTR_OFFSET, 4); - /* return LNK in the regs array */ - return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_LNK, 4); - } - else - return rs6000_frame_saved_pc (fi); -} - -void -ppc_linux_init_extra_frame_info (int fromleaf, struct frame_info *fi) -{ - rs6000_init_extra_frame_info (fromleaf, fi); - - if (get_next_frame (fi) != 0) - { - /* We're called from get_prev_frame_info; check to see if - this is a signal frame by looking to see if the pc points - at trampoline code */ - if (ppc_linux_at_sigtramp_return_path (get_frame_pc (fi))) - deprecated_set_frame_type (fi, SIGTRAMP_FRAME); - else - /* FIXME: cagney/2002-11-10: Is this double bogus? What - happens if the frame has previously been marked as a dummy? */ - deprecated_set_frame_type (fi, NORMAL_FRAME); - } -} - -int -ppc_linux_frameless_function_invocation (struct frame_info *fi) -{ - /* We'll find the wrong thing if we let - rs6000_frameless_function_invocation () search for a signal trampoline */ - if (ppc_linux_at_sigtramp_return_path (get_frame_pc (fi))) - return 0; - else - return rs6000_frameless_function_invocation (fi); -} - -void -ppc_linux_frame_init_saved_regs (struct frame_info *fi) -{ - if ((get_frame_type (fi) == SIGTRAMP_FRAME)) - { - CORE_ADDR regs_addr; - int i; - if (get_frame_saved_regs (fi)) - return; - - frame_saved_regs_zalloc (fi); - - regs_addr = - read_memory_integer (get_frame_base (fi) - + PPC_LINUX_REGS_PTR_OFFSET, 4); - get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] = - regs_addr + 4 * PPC_LINUX_PT_MSR; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] = - regs_addr + 4 * PPC_LINUX_PT_CCR; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] = - regs_addr + 4 * PPC_LINUX_PT_LNK; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] = - regs_addr + 4 * PPC_LINUX_PT_CTR; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] = - regs_addr + 4 * PPC_LINUX_PT_XER; - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] = - regs_addr + 4 * PPC_LINUX_PT_MQ; - for (i = 0; i < 32; i++) - get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] = - regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i; - for (i = 0; i < 32; i++) - get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i; - } - else - rs6000_frame_init_saved_regs (fi); -} - -CORE_ADDR -ppc_linux_frame_chain (struct frame_info *thisframe) -{ - /* Kernel properly constructs the frame chain for the handler */ - if ((get_frame_type (thisframe) == SIGTRAMP_FRAME)) - return read_memory_integer (get_frame_base (thisframe), 4); - else - return rs6000_frame_chain (thisframe); -} /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint in much the same fashion as memory_remove_breakpoint in mem-break.c, @@ -567,195 +184,1102 @@ ppc_linux_frame_chain (struct frame_info *thisframe) else in the event that some other platform has similar needs with regard to removing breakpoints in some potentially self modifying code. */ -int -ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) +static int +ppc_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { + CORE_ADDR addr = bp_tgt->placed_address; const unsigned char *bp; int val; int bplen; - char old_contents[BREAKPOINT_MAX]; + gdb_byte old_contents[BREAKPOINT_MAX]; + struct cleanup *cleanup; /* Determine appropriate breakpoint contents and size for this address. */ - bp = BREAKPOINT_FROM_PC (&addr, &bplen); + bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen); if (bp == NULL) - error ("Software breakpoints not implemented for this target."); + error (_("Software breakpoints not implemented for this target.")); + /* Make sure we see the memory breakpoints. */ + cleanup = make_show_memory_breakpoints_cleanup (1); val = target_read_memory (addr, old_contents, bplen); /* If our breakpoint is no longer at the address, this means that the program modified the code on us, so it is wrong to put back the old value */ if (val == 0 && memcmp (bp, old_contents, bplen) == 0) - val = target_write_memory (addr, contents_cache, bplen); + val = target_write_memory (addr, bp_tgt->shadow_contents, bplen); + do_cleanups (cleanup); return val; } -/* Fetch (and possibly build) an appropriate link_map_offsets - structure for GNU/Linux PPC targets using the struct offsets - defined in link.h (but without actual reference to that file). +/* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather + than the 32 bit SYSV R4 ABI structure return convention - all + structures, no matter their size, are put in memory. Vectors, + which were added later, do get returned in a register though. */ + +static enum return_value_convention +ppc_linux_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *valtype, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) +{ + if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT + || TYPE_CODE (valtype) == TYPE_CODE_UNION) + && !((TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 8) + && TYPE_VECTOR (valtype))) + return RETURN_VALUE_STRUCT_CONVENTION; + else + return ppc_sysv_abi_return_value (gdbarch, func_type, valtype, regcache, + readbuf, writebuf); +} - This makes it possible to access GNU/Linux PPC shared libraries - from a GDB that was not built on an GNU/Linux PPC host (for cross - debugging). */ +/* 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]; -struct link_map_offsets * -ppc_linux_svr4_fetch_link_map_offsets (void) + 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) { - static struct link_map_offsets lmo; - static struct link_map_offsets *lmp = NULL; + int i; - if (lmp == NULL) + for (i = 0; pattern[i].mask; i++) { - lmp = &lmo; + 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; +} - lmo.r_debug_size = 8; /* The actual size is 20 bytes, but - this is all we need. */ - lmo.r_map_offset = 4; - lmo.r_map_size = 4; - lmo.link_map_size = 20; /* The actual size is 560 bytes, but - this is all we need. */ - lmo.l_addr_offset = 0; - lmo.l_addr_size = 4; +/* 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); +} - lmo.l_name_offset = 4; - lmo.l_name_size = 4; - lmo.l_next_offset = 12; - lmo.l_next_size = 4; +/* 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); +} - lmo.l_prev_offset = 16; - lmo.l_prev_size = 4; - } - return lmp; +/* 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); } -enum { - ELF_NGREG = 48, - ELF_NFPREG = 33, - ELF_NVRREG = 33 + +/* 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), 0 }, + + /* 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), 0 }, + + /* 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), 0 }, + + /* 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", 268 }, + { ".reg2", 264 }, + { ".reg-ppc-vmx", 544 }, + { ".reg-ppc-vsx", 256 }, + { NULL, 0} }; -enum { - ELF_GREGSET_SIZE = (ELF_NGREG * 4), - ELF_FPREGSET_SIZE = (ELF_NFPREG * 8) +static struct core_regset_section ppc_linux_vmx_regset_sections[] = +{ + { ".reg", 268 }, + { ".reg2", 264 }, + { ".reg-ppc-vmx", 544 }, + { NULL, 0} }; -void -ppc_linux_supply_gregset (char *buf) -{ - int regi; - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - - for (regi = 0; regi < 32; regi++) - supply_register (regi, buf + 4 * regi); - - supply_register (PC_REGNUM, buf + 4 * PPC_LINUX_PT_NIP); - supply_register (tdep->ppc_lr_regnum, buf + 4 * PPC_LINUX_PT_LNK); - supply_register (tdep->ppc_cr_regnum, buf + 4 * PPC_LINUX_PT_CCR); - supply_register (tdep->ppc_xer_regnum, buf + 4 * PPC_LINUX_PT_XER); - supply_register (tdep->ppc_ctr_regnum, buf + 4 * PPC_LINUX_PT_CTR); - if (tdep->ppc_mq_regnum != -1) - supply_register (tdep->ppc_mq_regnum, buf + 4 * PPC_LINUX_PT_MQ); - supply_register (tdep->ppc_ps_regnum, buf + 4 * PPC_LINUX_PT_MSR); +static struct core_regset_section ppc_linux_fp_regset_sections[] = +{ + { ".reg", 268 }, + { ".reg2", 264 }, + { 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); } -void -ppc_linux_supply_fpregset (char *buf) +static CORE_ADDR +ppc64_standard_linkage3_target (struct frame_info *frame, + CORE_ADDR pc, unsigned int *insn) { - int regi; - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - for (regi = 0; regi < 32; regi++) - supply_register (FP0_REGNUM + regi, buf + 8 * regi); + /* 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 FPSCR is stored in the low order word of the last doubleword in the - fpregset. */ - supply_register (tdep->ppc_fpscr_regnum, buf + 8 * 32 + 4); + /* The first word of the descriptor is the entry point. Return that. */ + return ppc64_desc_entry_point (gdbarch, desc); } -/* - Use a local version of this function to get the correct types for regsets. -*/ + +/* 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 -fetch_core_registers (char *core_reg_sect, - unsigned core_reg_size, - int which, - CORE_ADDR reg_addr) +ppc_linux_supply_gregset (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *gregs, size_t len) { - if (which == 0) + const struct ppc_reg_offsets *offsets = regset->descr; + + ppc_supply_gregset (regset, regcache, regnum, gregs, len); + + if (ppc_linux_trap_reg_p (get_regcache_arch (regcache))) { - if (core_reg_size == ELF_GREGSET_SIZE) - ppc_linux_supply_gregset (core_reg_sect); - else - warning ("wrong size gregset struct in core file"); + /* "orig_r3" is stored 2 slots after "pc". */ + if (regnum == -1 || regnum == PPC_ORIG_R3_REGNUM) + ppc_supply_reg (regcache, PPC_ORIG_R3_REGNUM, gregs, + offsets->pc_offset + 2 * offsets->gpr_size, + offsets->gpr_size); + + /* "trap" is stored 8 slots after "pc". */ + if (regnum == -1 || regnum == PPC_TRAP_REGNUM) + ppc_supply_reg (regcache, PPC_TRAP_REGNUM, gregs, + offsets->pc_offset + 8 * offsets->gpr_size, + offsets->gpr_size); } - else if (which == 2) +} + +static void +ppc_linux_collect_gregset (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *gregs, size_t len) +{ + const struct ppc_reg_offsets *offsets = regset->descr; + + /* Clear areas in the linux gregset not written elsewhere. */ + if (regnum == -1) + memset (gregs, 0, len); + + ppc_collect_gregset (regset, regcache, regnum, gregs, len); + + if (ppc_linux_trap_reg_p (get_regcache_arch (regcache))) + { + /* "orig_r3" is stored 2 slots after "pc". */ + if (regnum == -1 || regnum == PPC_ORIG_R3_REGNUM) + ppc_collect_reg (regcache, PPC_ORIG_R3_REGNUM, gregs, + offsets->pc_offset + 2 * offsets->gpr_size, + offsets->gpr_size); + + /* "trap" is stored 8 slots after "pc". */ + if (regnum == -1 || regnum == PPC_TRAP_REGNUM) + ppc_collect_reg (regcache, PPC_TRAP_REGNUM, gregs, + offsets->pc_offset + 8 * offsets->gpr_size, + offsets->gpr_size); + } +} + +/* Regset descriptions. */ +static const struct ppc_reg_offsets ppc32_linux_reg_offsets = + { + /* General-purpose registers. */ + /* .r0_offset = */ 0, + /* .gpr_size = */ 4, + /* .xr_size = */ 4, + /* .pc_offset = */ 128, + /* .ps_offset = */ 132, + /* .cr_offset = */ 152, + /* .lr_offset = */ 144, + /* .ctr_offset = */ 140, + /* .xer_offset = */ 148, + /* .mq_offset = */ 156, + + /* Floating-point registers. */ + /* .f0_offset = */ 0, + /* .fpscr_offset = */ 256, + /* .fpscr_size = */ 8, + + /* AltiVec registers. */ + /* .vr0_offset = */ 0, + /* .vscr_offset = */ 512 + 12, + /* .vrsave_offset = */ 528 + }; + +static const struct ppc_reg_offsets ppc64_linux_reg_offsets = + { + /* General-purpose registers. */ + /* .r0_offset = */ 0, + /* .gpr_size = */ 8, + /* .xr_size = */ 8, + /* .pc_offset = */ 256, + /* .ps_offset = */ 264, + /* .cr_offset = */ 304, + /* .lr_offset = */ 288, + /* .ctr_offset = */ 280, + /* .xer_offset = */ 296, + /* .mq_offset = */ 312, + + /* Floating-point registers. */ + /* .f0_offset = */ 0, + /* .fpscr_offset = */ 256, + /* .fpscr_size = */ 8, + + /* AltiVec registers. */ + /* .vr0_offset = */ 0, + /* .vscr_offset = */ 512 + 12, + /* .vrsave_offset = */ 528 + }; + +static const struct regset ppc32_linux_gregset = { + &ppc32_linux_reg_offsets, + ppc_linux_supply_gregset, + ppc_linux_collect_gregset, + NULL +}; + +static const struct regset ppc64_linux_gregset = { + &ppc64_linux_reg_offsets, + ppc_linux_supply_gregset, + ppc_linux_collect_gregset, + NULL +}; + +static const struct regset ppc32_linux_fpregset = { + &ppc32_linux_reg_offsets, + ppc_supply_fpregset, + ppc_collect_fpregset, + NULL +}; + +static const struct regset ppc32_linux_vrregset = { + &ppc32_linux_reg_offsets, + ppc_supply_vrregset, + ppc_collect_vrregset, + NULL +}; + +static const struct regset ppc32_linux_vsxregset = { + &ppc32_linux_reg_offsets, + ppc_supply_vsxregset, + ppc_collect_vsxregset, + NULL +}; + +const struct regset * +ppc_linux_gregset (int wordsize) +{ + return wordsize == 8 ? &ppc64_linux_gregset : &ppc32_linux_gregset; +} + +const struct regset * +ppc_linux_fpregset (void) +{ + return &ppc32_linux_fpregset; +} + +static const struct regset * +ppc_linux_regset_from_core_section (struct gdbarch *core_arch, + const char *sect_name, size_t sect_size) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch); + if (strcmp (sect_name, ".reg") == 0) { - if (core_reg_size == ELF_FPREGSET_SIZE) - ppc_linux_supply_fpregset (core_reg_sect); + if (tdep->wordsize == 4) + return &ppc32_linux_gregset; else - warning ("wrong size fpregset struct in core file"); + return &ppc64_linux_gregset; + } + if (strcmp (sect_name, ".reg2") == 0) + return &ppc32_linux_fpregset; + if (strcmp (sect_name, ".reg-ppc-vmx") == 0) + return &ppc32_linux_vrregset; + if (strcmp (sect_name, ".reg-ppc-vsx") == 0) + return &ppc32_linux_vsxregset; + return NULL; +} + +static void +ppc_linux_sigtramp_cache (struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func, LONGEST offset, + int bias) +{ + CORE_ADDR base; + CORE_ADDR regs; + CORE_ADDR gpregs; + CORE_ADDR fpregs; + int i; + struct gdbarch *gdbarch = get_frame_arch (this_frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + base = get_frame_register_unsigned (this_frame, + gdbarch_sp_regnum (gdbarch)); + if (bias > 0 && get_frame_pc (this_frame) != func) + /* See below, some signal trampolines increment the stack as their + first instruction, need to compensate for that. */ + base -= bias; + + /* Find the address of the register buffer pointer. */ + regs = base + offset; + /* Use that to find the address of the corresponding register + buffers. */ + gpregs = read_memory_unsigned_integer (regs, tdep->wordsize, byte_order); + fpregs = gpregs + 48 * tdep->wordsize; + + /* General purpose. */ + for (i = 0; i < 32; i++) + { + int regnum = i + tdep->ppc_gp0_regnum; + trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize); + } + trad_frame_set_reg_addr (this_cache, + gdbarch_pc_regnum (gdbarch), + gpregs + 32 * tdep->wordsize); + trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum, + gpregs + 35 * tdep->wordsize); + trad_frame_set_reg_addr (this_cache, tdep->ppc_lr_regnum, + gpregs + 36 * tdep->wordsize); + trad_frame_set_reg_addr (this_cache, tdep->ppc_xer_regnum, + gpregs + 37 * tdep->wordsize); + trad_frame_set_reg_addr (this_cache, tdep->ppc_cr_regnum, + gpregs + 38 * tdep->wordsize); + + if (ppc_linux_trap_reg_p (gdbarch)) + { + trad_frame_set_reg_addr (this_cache, PPC_ORIG_R3_REGNUM, + gpregs + 34 * tdep->wordsize); + trad_frame_set_reg_addr (this_cache, PPC_TRAP_REGNUM, + gpregs + 40 * tdep->wordsize); } + + if (ppc_floating_point_unit_p (gdbarch)) + { + /* Floating point registers. */ + for (i = 0; i < 32; i++) + { + int regnum = i + gdbarch_fp0_regnum (gdbarch); + trad_frame_set_reg_addr (this_cache, regnum, + fpregs + i * tdep->wordsize); + } + trad_frame_set_reg_addr (this_cache, tdep->ppc_fpscr_regnum, + fpregs + 32 * tdep->wordsize); + } + trad_frame_set_id (this_cache, frame_id_build (base, func)); +} + +static void +ppc32_linux_sigaction_cache_init (const struct tramp_frame *self, + struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func) +{ + ppc_linux_sigtramp_cache (this_frame, this_cache, func, + 0xd0 /* Offset to ucontext_t. */ + + 0x30 /* Offset to .reg. */, + 0); } -/* Register that we are able to handle ELF file formats using standard - procfs "regset" structures. */ +static void +ppc64_linux_sigaction_cache_init (const struct tramp_frame *self, + struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func) +{ + ppc_linux_sigtramp_cache (this_frame, this_cache, func, + 0x80 /* Offset to ucontext_t. */ + + 0xe0 /* Offset to .reg. */, + 128); +} -static struct core_fns ppc_linux_regset_core_fns = +static void +ppc32_linux_sighandler_cache_init (const struct tramp_frame *self, + struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func) +{ + ppc_linux_sigtramp_cache (this_frame, this_cache, func, + 0x40 /* Offset to ucontext_t. */ + + 0x1c /* Offset to .reg. */, + 0); +} + +static void +ppc64_linux_sighandler_cache_init (const struct tramp_frame *self, + struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func) { - bfd_target_elf_flavour, /* core_flavour */ - default_check_format, /* check_format */ - default_core_sniffer, /* core_sniffer */ - fetch_core_registers, /* core_read_registers */ - NULL /* next */ + ppc_linux_sigtramp_cache (this_frame, this_cache, func, + 0x80 /* Offset to struct sigcontext. */ + + 0x38 /* Offset to .reg. */, + 128); +} + +static struct tramp_frame ppc32_linux_sigaction_tramp_frame = { + SIGTRAMP_FRAME, + 4, + { + { 0x380000ac, -1 }, /* li r0, 172 */ + { 0x44000002, -1 }, /* sc */ + { TRAMP_SENTINEL_INSN }, + }, + ppc32_linux_sigaction_cache_init +}; +static struct tramp_frame ppc64_linux_sigaction_tramp_frame = { + SIGTRAMP_FRAME, + 4, + { + { 0x38210080, -1 }, /* addi r1,r1,128 */ + { 0x380000ac, -1 }, /* li r0, 172 */ + { 0x44000002, -1 }, /* sc */ + { TRAMP_SENTINEL_INSN }, + }, + ppc64_linux_sigaction_cache_init +}; +static struct tramp_frame ppc32_linux_sighandler_tramp_frame = { + SIGTRAMP_FRAME, + 4, + { + { 0x38000077, -1 }, /* li r0,119 */ + { 0x44000002, -1 }, /* sc */ + { TRAMP_SENTINEL_INSN }, + }, + ppc32_linux_sighandler_cache_init +}; +static struct tramp_frame ppc64_linux_sighandler_tramp_frame = { + SIGTRAMP_FRAME, + 4, + { + { 0x38210080, -1 }, /* addi r1,r1,128 */ + { 0x38000077, -1 }, /* li r0,119 */ + { 0x44000002, -1 }, /* sc */ + { TRAMP_SENTINEL_INSN }, + }, + ppc64_linux_sighandler_cache_init }; + +/* Address to use for displaced stepping. When debugging a stand-alone + SPU executable, entry_point_address () will point to an SPU local-store + address and is thus not usable as displaced stepping location. We use + the auxiliary vector to determine the PowerPC-side entry point address + instead. */ + +static CORE_ADDR ppc_linux_entry_point_addr = 0; + +static void +ppc_linux_inferior_created (struct target_ops *target, int from_tty) +{ + ppc_linux_entry_point_addr = 0; +} + +static CORE_ADDR +ppc_linux_displaced_step_location (struct gdbarch *gdbarch) +{ + if (ppc_linux_entry_point_addr == 0) + { + CORE_ADDR addr; + + /* Determine entry point from target auxiliary vector. */ + if (target_auxv_search (¤t_target, AT_ENTRY, &addr) <= 0) + error (_("Cannot find AT_ENTRY auxiliary vector entry.")); + + /* Make certain that the address points at real code, and not a + function descriptor. */ + addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, + ¤t_target); + + /* Inferior calls also use the entry point as a breakpoint location. + We don't want displaced stepping to interfere with those + breakpoints, so leave space. */ + ppc_linux_entry_point_addr = addr + 2 * PPC_INSN_SIZE; + } + + return ppc_linux_entry_point_addr; +} + + +/* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */ +int +ppc_linux_trap_reg_p (struct gdbarch *gdbarch) +{ + /* If we do not have a target description with registers, then + the special registers will not be included in the register set. */ + if (!tdesc_has_registers (gdbarch_target_desc (gdbarch))) + return 0; + + /* If we do, then it is safe to check the size. */ + return register_size (gdbarch, PPC_ORIG_R3_REGNUM) > 0 + && register_size (gdbarch, PPC_TRAP_REGNUM) > 0; +} + +static void +ppc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + + regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc); + + /* Set special TRAP register to -1 to prevent the kernel from + messing with the PC we just installed, if we happen to be + within an interrupted system call that the kernel wants to + restart. + + Note that after we return from the dummy call, the TRAP and + ORIG_R3 registers will be automatically restored, and the + kernel continues to restart the system call at this point. */ + if (ppc_linux_trap_reg_p (gdbarch)) + regcache_cooked_write_unsigned (regcache, PPC_TRAP_REGNUM, -1); +} + +static int +ppc_linux_spu_section (bfd *abfd, asection *asect, void *user_data) +{ + return strncmp (bfd_section_name (abfd, asect), "SPU/", 4) == 0; +} + +static const struct target_desc * +ppc_linux_core_read_description (struct gdbarch *gdbarch, + struct target_ops *target, + bfd *abfd) +{ + asection *cell = bfd_sections_find_if (abfd, ppc_linux_spu_section, NULL); + asection *altivec = bfd_get_section_by_name (abfd, ".reg-ppc-vmx"); + asection *vsx = bfd_get_section_by_name (abfd, ".reg-ppc-vsx"); + asection *section = bfd_get_section_by_name (abfd, ".reg"); + if (! section) + return NULL; + + switch (bfd_section_size (abfd, section)) + { + case 48 * 4: + if (cell) + return tdesc_powerpc_cell32l; + else if (vsx) + return tdesc_powerpc_vsx32l; + else if (altivec) + return tdesc_powerpc_altivec32l; + else + return tdesc_powerpc_32l; + + case 48 * 8: + if (cell) + return tdesc_powerpc_cell64l; + else if (vsx) + return tdesc_powerpc_vsx64l; + else if (altivec) + return tdesc_powerpc_altivec64l; + else + return tdesc_powerpc_64l; + + default: + return NULL; + } +} + static void ppc_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info; + + /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where + 128-bit, they are IBM long double, not IEEE quad long double as + in the System V ABI PowerPC Processor Supplement. We can safely + let them default to 128-bit, since the debug info will give the + size of type actually used in each case. */ + set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT); + set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double); - /* Until November 2001, gcc was not complying to the SYSV ABI for - returning structures less than or equal to 8 bytes in size. It was - returning everything in memory. When this was corrected, it wasn't - fixed for native platforms. */ - set_gdbarch_use_struct_convention (gdbarch, - ppc_sysv_abi_broken_use_struct_convention); + /* Handle inferior calls during interrupted system calls. */ + set_gdbarch_write_pc (gdbarch, ppc_linux_write_pc); if (tdep->wordsize == 4) { - /* Note: kevinb/2002-04-12: See note in rs6000_gdbarch_init regarding - *_push_arguments(). The same remarks hold for the methods below. */ - set_gdbarch_frameless_function_invocation (gdbarch, - ppc_linux_frameless_function_invocation); - set_gdbarch_deprecated_frame_chain (gdbarch, ppc_linux_frame_chain); - set_gdbarch_deprecated_frame_saved_pc (gdbarch, ppc_linux_frame_saved_pc); - - set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, - ppc_linux_frame_init_saved_regs); - set_gdbarch_deprecated_init_extra_frame_info (gdbarch, - ppc_linux_init_extra_frame_info); + /* Until November 2001, gcc did not comply with the 32 bit SysV + R4 ABI requirement that structures less than or equal to 8 + bytes should be returned in registers. Instead GCC was using + the the AIX/PowerOpen ABI - everything returned in memory + (well ignoring vectors that is). When this was corrected, it + wasn't fixed for GNU/Linux native platform. Use the + PowerOpen struct convention. */ + set_gdbarch_return_value (gdbarch, ppc_linux_return_value); set_gdbarch_memory_remove_breakpoint (gdbarch, ppc_linux_memory_remove_breakpoint); + + /* Shared library handling. */ + set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); + set_solib_svr4_fetch_link_map_offsets + (gdbarch, svr4_ilp32_fetch_link_map_offsets); + + /* Trampolines. */ + tramp_frame_prepend_unwinder (gdbarch, &ppc32_linux_sigaction_tramp_frame); + tramp_frame_prepend_unwinder (gdbarch, &ppc32_linux_sighandler_tramp_frame); + + /* BFD target for core files. */ + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) + set_gdbarch_gcore_bfd_target (gdbarch, "elf32-powerpcle"); + else + set_gdbarch_gcore_bfd_target (gdbarch, "elf32-powerpc"); + } + + if (tdep->wordsize == 8) + { + /* 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); + + /* Shared library handling. */ + set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code); set_solib_svr4_fetch_link_map_offsets - (gdbarch, ppc_linux_svr4_fetch_link_map_offsets); + (gdbarch, svr4_lp64_fetch_link_map_offsets); + + /* Trampolines. */ + tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sigaction_tramp_frame); + tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sighandler_tramp_frame); + + /* BFD target for core files. */ + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) + set_gdbarch_gcore_bfd_target (gdbarch, "elf64-powerpcle"); + else + set_gdbarch_gcore_bfd_target (gdbarch, "elf64-powerpc"); + } + set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section); + set_gdbarch_core_read_description (gdbarch, ppc_linux_core_read_description); + + /* Supported register sections. */ + if (tdesc_find_feature (info.target_desc, + "org.gnu.gdb.power.vsx")) + set_gdbarch_core_regset_sections (gdbarch, ppc_linux_vsx_regset_sections); + else if (tdesc_find_feature (info.target_desc, + "org.gnu.gdb.power.altivec")) + set_gdbarch_core_regset_sections (gdbarch, ppc_linux_vmx_regset_sections); + else + set_gdbarch_core_regset_sections (gdbarch, ppc_linux_fp_regset_sections); + + /* Enable TLS support. */ + set_gdbarch_fetch_tls_load_module_address (gdbarch, + svr4_fetch_objfile_link_map); + + if (tdesc_data) + { + const struct tdesc_feature *feature; + + /* If we have target-described registers, then we can safely + reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM + (whether they are described or not). */ + gdb_assert (gdbarch_num_regs (gdbarch) <= PPC_ORIG_R3_REGNUM); + set_gdbarch_num_regs (gdbarch, PPC_TRAP_REGNUM + 1); + + /* If they are present, then assign them to the reserved number. */ + feature = tdesc_find_feature (info.target_desc, + "org.gnu.gdb.power.linux"); + if (feature != NULL) + { + tdesc_numbered_register (feature, tdesc_data, + PPC_ORIG_R3_REGNUM, "orig_r3"); + tdesc_numbered_register (feature, tdesc_data, + PPC_TRAP_REGNUM, "trap"); + } } - /* Shared library handling. */ - set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section); - set_gdbarch_skip_trampoline_code (gdbarch, ppc_linux_skip_trampoline_code); + /* Enable Cell/B.E. if supported by the target. */ + if (tdesc_compatible_p (info.target_desc, + bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu))) + { + /* Cell/B.E. multi-architecture support. */ + set_spu_solib_ops (gdbarch); + + /* The default displaced_step_at_entry_point doesn't work for + SPU stand-alone executables. */ + set_gdbarch_displaced_step_location (gdbarch, + ppc_linux_displaced_step_location); + } } +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_ppc_linux_tdep; + void _initialize_ppc_linux_tdep (void) { - gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_LINUX, - ppc_linux_init_abi); - add_core_fns (&ppc_linux_regset_core_fns); + /* Register for all sub-familes of the POWER/PowerPC: 32-bit and + 64-bit PowerPC, and the older rs6k. */ + gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc, GDB_OSABI_LINUX, + ppc_linux_init_abi); + gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc64, GDB_OSABI_LINUX, + ppc_linux_init_abi); + gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX, + ppc_linux_init_abi); + + /* Attach to inferior_created observer. */ + observer_attach_inferior_created (ppc_linux_inferior_created); + + /* Initialize the Linux target descriptions. */ + initialize_tdesc_powerpc_32l (); + initialize_tdesc_powerpc_altivec32l (); + initialize_tdesc_powerpc_cell32l (); + initialize_tdesc_powerpc_vsx32l (); + initialize_tdesc_powerpc_isa205_32l (); + initialize_tdesc_powerpc_isa205_altivec32l (); + initialize_tdesc_powerpc_isa205_vsx32l (); + initialize_tdesc_powerpc_64l (); + initialize_tdesc_powerpc_altivec64l (); + initialize_tdesc_powerpc_cell64l (); + initialize_tdesc_powerpc_vsx64l (); + initialize_tdesc_powerpc_isa205_64l (); + initialize_tdesc_powerpc_isa205_altivec64l (); + initialize_tdesc_powerpc_isa205_vsx64l (); + initialize_tdesc_powerpc_e500l (); }