X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmips-linux-tdep.c;h=6c0459d3b21f74120cb9c51e0c1219c58780ae36;hb=9f1b45b0da430a7a7abf9e54acbe6f2ef9d3a763;hp=c6512af7b1bdc163070e1595328dabe843ae7ec4;hpb=d0e643928fd7b43069ee249f4ce306ff2a8c6df8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c index c6512af7b1..6c0459d3b2 100644 --- a/gdb/mips-linux-tdep.c +++ b/gdb/mips-linux-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for GNU/Linux on MIPS processors. - Copyright (C) 2001-2002, 2004-2012 Free Software Foundation, Inc. + Copyright (C) 2001-2014 Free Software Foundation, Inc. This file is part of GDB. @@ -23,15 +23,15 @@ #include "solib-svr4.h" #include "osabi.h" #include "mips-tdep.h" -#include "gdb_string.h" +#include #include "gdb_assert.h" #include "frame.h" #include "regcache.h" #include "trad-frame.h" #include "tramp-frame.h" #include "gdbtypes.h" +#include "objfiles.h" #include "solib.h" -#include "solib-svr4.h" #include "solist.h" #include "symtab.h" #include "target-descriptions.h" @@ -40,9 +40,46 @@ #include "glibc-tdep.h" #include "linux-tdep.h" #include "xml-syscall.h" +#include "gdb_signals.h" static struct target_so_ops mips_svr4_so_ops; +/* This enum represents the signals' numbers on the MIPS + architecture. It just contains the signal definitions which are + different from the generic implementation. + + It is derived from the file , + from the Linux kernel tree. */ + +enum + { + MIPS_LINUX_SIGEMT = 7, + MIPS_LINUX_SIGBUS = 10, + MIPS_LINUX_SIGSYS = 12, + MIPS_LINUX_SIGUSR1 = 16, + MIPS_LINUX_SIGUSR2 = 17, + MIPS_LINUX_SIGCHLD = 18, + MIPS_LINUX_SIGCLD = MIPS_LINUX_SIGCHLD, + MIPS_LINUX_SIGPWR = 19, + MIPS_LINUX_SIGWINCH = 20, + MIPS_LINUX_SIGURG = 21, + MIPS_LINUX_SIGIO = 22, + MIPS_LINUX_SIGPOLL = MIPS_LINUX_SIGIO, + MIPS_LINUX_SIGSTOP = 23, + MIPS_LINUX_SIGTSTP = 24, + MIPS_LINUX_SIGCONT = 25, + MIPS_LINUX_SIGTTIN = 26, + MIPS_LINUX_SIGTTOU = 27, + MIPS_LINUX_SIGVTALRM = 28, + MIPS_LINUX_SIGPROF = 29, + MIPS_LINUX_SIGXCPU = 30, + MIPS_LINUX_SIGXFSZ = 31, + + MIPS_LINUX_SIGRTMIN = 32, + MIPS_LINUX_SIGRT64 = 64, + MIPS_LINUX_SIGRTMAX = 127, + }; + /* Figure out where the longjmp will land. We expect the first arg to be a pointer to the jmp_buf structure from which we extract the pc (MIPS_LINUX_JB_PC) that we will land @@ -58,12 +95,12 @@ mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) CORE_ADDR jb_addr; struct gdbarch *gdbarch = get_frame_arch (frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT]; + gdb_byte buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT]; jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM); - if (target_read_memory (jb_addr - + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE, + if (target_read_memory ((jb_addr + + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE), buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT)) return 0; @@ -85,7 +122,7 @@ supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr) enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[MAX_REGISTER_SIZE]; store_signed_integer (buf, register_size (gdbarch, regnum), byte_order, - extract_signed_integer (addr, 4, byte_order)); + extract_signed_integer (addr, 4, byte_order)); regcache_raw_supply (regcache, regnum, buf); } @@ -125,8 +162,8 @@ mips_supply_gregset (struct regcache *regcache, static void mips_supply_gregset_wrapper (const struct regset *regset, - struct regcache *regcache, - int regnum, const void *gregs, size_t len) + struct regcache *regcache, + int regnum, const void *gregs, size_t len) { gdb_assert (len == sizeof (mips_elf_gregset_t)); @@ -230,8 +267,8 @@ mips_supply_fpregset (struct regcache *regcache, static void mips_supply_fpregset_wrapper (const struct regset *regset, - struct regcache *regcache, - int regnum, const void *gregs, size_t len) + struct regcache *regcache, + int regnum, const void *gregs, size_t len) { gdb_assert (len == sizeof (mips_elf_fpregset_t)); @@ -349,11 +386,11 @@ mips64_supply_gregset (struct regcache *regcache, for (regi = MIPS64_EF_REG0 + 1; regi <= MIPS64_EF_REG31; regi++) supply_64bit_reg (regcache, regi - MIPS64_EF_REG0, - (const gdb_byte *)(regp + regi)); + (const gdb_byte *) (regp + regi)); if (mips_linux_restart_reg_p (gdbarch)) supply_64bit_reg (regcache, MIPS_RESTART_REGNUM, - (const gdb_byte *)(regp + MIPS64_EF_REG0)); + (const gdb_byte *) (regp + MIPS64_EF_REG0)); supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo, (const gdb_byte *) (regp + MIPS64_EF_LO)); @@ -375,8 +412,8 @@ mips64_supply_gregset (struct regcache *regcache, static void mips64_supply_gregset_wrapper (const struct regset *regset, - struct regcache *regcache, - int regnum, const void *gregs, size_t len) + struct regcache *regcache, + int regnum, const void *gregs, size_t len) { gdb_assert (len == sizeof (mips64_elf_gregset_t)); @@ -399,7 +436,7 @@ mips64_fill_gregset (const struct regcache *regcache, { memset (regp, 0, sizeof (mips64_elf_gregset_t)); for (regi = 1; regi < 32; regi++) - mips64_fill_gregset (regcache, gregsetp, regi); + mips64_fill_gregset (regcache, gregsetp, regi); mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo); mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi); mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc); @@ -468,7 +505,8 @@ mips64_supply_fpregset (struct regcache *regcache, if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4) for (regi = 0; regi < 32; regi++) { - const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1)); + const gdb_byte *reg_ptr + = (const gdb_byte *) (*fpregsetp + (regi & ~1)); if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1)) reg_ptr += 4; regcache_raw_supply (regcache, @@ -479,23 +517,23 @@ mips64_supply_fpregset (struct regcache *regcache, for (regi = 0; regi < 32; regi++) regcache_raw_supply (regcache, gdbarch_fp0_regnum (gdbarch) + regi, - (const char *)(*fpregsetp + regi)); + (const char *) (*fpregsetp + regi)); supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status, - (const gdb_byte *)(*fpregsetp + 32)); + (const gdb_byte *) (*fpregsetp + 32)); /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't include it - but the result of PTRACE_GETFPREGS does. The best we can do is to assume that its value is present. */ supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_implementation_revision, - (const gdb_byte *)(*fpregsetp + 32) + 4); + (const gdb_byte *) (*fpregsetp + 32) + 4); } static void mips64_supply_fpregset_wrapper (const struct regset *regset, - struct regcache *regcache, - int regnum, const void *gregs, size_t len) + struct regcache *regcache, + int regnum, const void *gregs, size_t len) { gdb_assert (len == sizeof (mips64_elf_fpregset_t)); @@ -566,8 +604,7 @@ mips64_fill_fpregset (const struct regcache *regcache, mips64_fill_fpregset (regcache, fpregsetp, mips_regnum (gdbarch)->fp_control_status); mips64_fill_fpregset (regcache, fpregsetp, - (mips_regnum (gdbarch) - ->fp_implementation_revision)); + mips_regnum (gdbarch)->fp_implementation_revision); } } @@ -583,7 +620,7 @@ mips64_fill_fpregset_wrapper (const struct regset *regset, static const struct regset * mips_linux_regset_from_core_section (struct gdbarch *gdbarch, - const char *sect_name, size_t sect_size) + const char *sect_name, size_t sect_size) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); mips_elf_gregset_t gregset; @@ -597,16 +634,16 @@ mips_linux_regset_from_core_section (struct gdbarch *gdbarch, { if (tdep->gregset == NULL) tdep->gregset = regset_alloc (gdbarch, - mips_supply_gregset_wrapper, - mips_fill_gregset_wrapper); + mips_supply_gregset_wrapper, + mips_fill_gregset_wrapper); return tdep->gregset; } else if (sect_size == sizeof (gregset64)) { if (tdep->gregset64 == NULL) tdep->gregset64 = regset_alloc (gdbarch, - mips64_supply_gregset_wrapper, - mips64_fill_gregset_wrapper); + mips64_supply_gregset_wrapper, + mips64_fill_gregset_wrapper); return tdep->gregset64; } else @@ -620,16 +657,16 @@ mips_linux_regset_from_core_section (struct gdbarch *gdbarch, { if (tdep->fpregset == NULL) tdep->fpregset = regset_alloc (gdbarch, - mips_supply_fpregset_wrapper, - mips_fill_fpregset_wrapper); + mips_supply_fpregset_wrapper, + mips_fill_fpregset_wrapper); return tdep->fpregset; } else if (sect_size == sizeof (fpregset64)) { if (tdep->fpregset64 == NULL) tdep->fpregset64 = regset_alloc (gdbarch, - mips64_supply_fpregset_wrapper, - mips64_fill_fpregset_wrapper); + mips64_supply_fpregset_wrapper, + mips64_fill_fpregset_wrapper); return tdep->fpregset64; } else @@ -665,24 +702,33 @@ mips_linux_core_read_description (struct gdbarch *gdbarch, /* Check the code at PC for a dynamic linker lazy resolution stub. - Because they aren't in the .plt section, we pattern-match on the - code generated by GNU ld. They look like this: + GNU ld for MIPS has put lazy resolution stubs into a ".MIPS.stubs" + section uniformly since version 2.15. If the pc is in that section, + then we are in such a stub. Before that ".stub" was used in 32-bit + ELF binaries, however we do not bother checking for that since we + have never had and that case should be extremely rare these days. + Instead we pattern-match on the code generated by GNU ld. They look + like this: lw t9,0x8010(gp) addu t7,ra jalr t9,ra addiu t8,zero,INDEX - (with the appropriate doubleword instructions for N64). Also - return the dynamic symbol index used in the last instruction. */ + (with the appropriate doubleword instructions for N64). As any lazy + resolution stubs in microMIPS binaries will always be in a + ".MIPS.stubs" section we only ever verify standard MIPS patterns. */ static int -mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name) +mips_linux_in_dynsym_stub (CORE_ADDR pc) { - unsigned char buf[28], *p; + gdb_byte buf[28], *p; ULONGEST insn, insn1; - int n64 = (mips_abi (target_gdbarch) == MIPS_ABI_N64); - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + int n64 = (mips_abi (target_gdbarch ()) == MIPS_ABI_N64); + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); + + if (in_mips_stubs_section (pc)) + return 1; read_memory (pc - 12, buf, 28); @@ -741,7 +787,7 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name) return 0; } - return (insn & 0xffff); + return 1; } /* Return non-zero iff PC belongs to the dynamic linker resolution @@ -755,9 +801,10 @@ mips_linux_in_dynsym_resolve_code (CORE_ADDR pc) if (svr4_in_dynsym_resolve_code (pc)) return 1; - /* Pattern match for the stub. It would be nice if there were a - more efficient way to avoid this check. */ - if (mips_linux_in_dynsym_stub (pc, NULL)) + /* Likewise for the stubs. They live in the .MIPS.stubs section these + days, so we check if the PC is within, than fall back to a pattern + match. */ + if (mips_linux_in_dynsym_stub (pc)) return 1; return 0; @@ -998,10 +1045,10 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self, for (ireg = 1; ireg < 32; ireg++) trad_frame_set_reg_addr (this_cache, - ireg + MIPS_ZERO_REGNUM - + gdbarch_num_regs (gdbarch), - regs_base + SIGCONTEXT_REGS - + ireg * SIGCONTEXT_REG_SIZE); + (ireg + MIPS_ZERO_REGNUM + + gdbarch_num_regs (gdbarch)), + (regs_base + SIGCONTEXT_REGS + + ireg * SIGCONTEXT_REG_SIZE)); /* The way that floating point registers are saved, unfortunately, depends on the architecture the kernel is built for. For the r3000 and @@ -1014,24 +1061,22 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self, for (ireg = 0; ireg < 32; ireg++) if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1)) trad_frame_set_reg_addr (this_cache, - ireg + regs->fp0 + - gdbarch_num_regs (gdbarch), - sigcontext_base + SIGCONTEXT_FPREGS + 4 - + (ireg & ~1) * SIGCONTEXT_REG_SIZE); + ireg + regs->fp0 + gdbarch_num_regs (gdbarch), + (sigcontext_base + SIGCONTEXT_FPREGS + 4 + + (ireg & ~1) * SIGCONTEXT_REG_SIZE)); else trad_frame_set_reg_addr (this_cache, - ireg + regs->fp0 - + gdbarch_num_regs (gdbarch), - sigcontext_base + SIGCONTEXT_FPREGS - + (ireg & ~1) * SIGCONTEXT_REG_SIZE); + ireg + regs->fp0 + gdbarch_num_regs (gdbarch), + (sigcontext_base + SIGCONTEXT_FPREGS + + (ireg & ~1) * SIGCONTEXT_REG_SIZE)); trad_frame_set_reg_addr (this_cache, regs->pc + gdbarch_num_regs (gdbarch), regs_base + SIGCONTEXT_PC); trad_frame_set_reg_addr (this_cache, - regs->fp_control_status - + gdbarch_num_regs (gdbarch), + (regs->fp_control_status + + gdbarch_num_regs (gdbarch)), sigcontext_base + SIGCONTEXT_FPCSR); if (regs->dspctl != -1) @@ -1191,25 +1236,24 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self, for (ireg = 1; ireg < 32; ireg++) trad_frame_set_reg_addr (this_cache, - ireg + MIPS_ZERO_REGNUM - + gdbarch_num_regs (gdbarch), - sigcontext_base + N64_SIGCONTEXT_REGS - + ireg * N64_SIGCONTEXT_REG_SIZE); + (ireg + MIPS_ZERO_REGNUM + + gdbarch_num_regs (gdbarch)), + (sigcontext_base + N64_SIGCONTEXT_REGS + + ireg * N64_SIGCONTEXT_REG_SIZE)); for (ireg = 0; ireg < 32; ireg++) trad_frame_set_reg_addr (this_cache, - ireg + regs->fp0 - + gdbarch_num_regs (gdbarch), - sigcontext_base + N64_SIGCONTEXT_FPREGS - + ireg * N64_SIGCONTEXT_REG_SIZE); + ireg + regs->fp0 + gdbarch_num_regs (gdbarch), + (sigcontext_base + N64_SIGCONTEXT_FPREGS + + ireg * N64_SIGCONTEXT_REG_SIZE)); trad_frame_set_reg_addr (this_cache, regs->pc + gdbarch_num_regs (gdbarch), sigcontext_base + N64_SIGCONTEXT_PC); trad_frame_set_reg_addr (this_cache, - regs->fp_control_status - + gdbarch_num_regs (gdbarch), + (regs->fp_control_status + + gdbarch_num_regs (gdbarch)), sigcontext_base + N64_SIGCONTEXT_FPCSR); trad_frame_set_reg_addr (this_cache, @@ -1330,6 +1374,186 @@ mips_linux_get_syscall_number (struct gdbarch *gdbarch, return ret; } +/* Implementation of `gdbarch_gdb_signal_to_target', as defined in + gdbarch.h. */ + +static int +mips_gdb_signal_to_target (struct gdbarch *gdbarch, + enum gdb_signal signal) +{ + switch (signal) + { + case GDB_SIGNAL_EMT: + return MIPS_LINUX_SIGEMT; + + case GDB_SIGNAL_BUS: + return MIPS_LINUX_SIGBUS; + + case GDB_SIGNAL_SYS: + return MIPS_LINUX_SIGSYS; + + case GDB_SIGNAL_USR1: + return MIPS_LINUX_SIGUSR1; + + case GDB_SIGNAL_USR2: + return MIPS_LINUX_SIGUSR2; + + case GDB_SIGNAL_CHLD: + return MIPS_LINUX_SIGCHLD; + + case GDB_SIGNAL_PWR: + return MIPS_LINUX_SIGPWR; + + case GDB_SIGNAL_WINCH: + return MIPS_LINUX_SIGWINCH; + + case GDB_SIGNAL_URG: + return MIPS_LINUX_SIGURG; + + case GDB_SIGNAL_IO: + return MIPS_LINUX_SIGIO; + + case GDB_SIGNAL_POLL: + return MIPS_LINUX_SIGPOLL; + + case GDB_SIGNAL_STOP: + return MIPS_LINUX_SIGSTOP; + + case GDB_SIGNAL_TSTP: + return MIPS_LINUX_SIGTSTP; + + case GDB_SIGNAL_CONT: + return MIPS_LINUX_SIGCONT; + + case GDB_SIGNAL_TTIN: + return MIPS_LINUX_SIGTTIN; + + case GDB_SIGNAL_TTOU: + return MIPS_LINUX_SIGTTOU; + + case GDB_SIGNAL_VTALRM: + return MIPS_LINUX_SIGVTALRM; + + case GDB_SIGNAL_PROF: + return MIPS_LINUX_SIGPROF; + + case GDB_SIGNAL_XCPU: + return MIPS_LINUX_SIGXCPU; + + case GDB_SIGNAL_XFSZ: + return MIPS_LINUX_SIGXFSZ; + + /* GDB_SIGNAL_REALTIME_32 is not continuous in , + therefore we have to handle it here. */ + case GDB_SIGNAL_REALTIME_32: + return MIPS_LINUX_SIGRTMIN; + } + + if (signal >= GDB_SIGNAL_REALTIME_33 + && signal <= GDB_SIGNAL_REALTIME_63) + { + int offset = signal - GDB_SIGNAL_REALTIME_33; + + return MIPS_LINUX_SIGRTMIN + 1 + offset; + } + else if (signal >= GDB_SIGNAL_REALTIME_64 + && signal <= GDB_SIGNAL_REALTIME_127) + { + int offset = signal - GDB_SIGNAL_REALTIME_64; + + return MIPS_LINUX_SIGRT64 + offset; + } + + return linux_gdb_signal_to_target (gdbarch, signal); +} + +/* Translate signals based on MIPS signal values. + Adapted from gdb/common/signals.c. */ + +static enum gdb_signal +mips_gdb_signal_from_target (struct gdbarch *gdbarch, int signal) +{ + switch (signal) + { + case MIPS_LINUX_SIGEMT: + return GDB_SIGNAL_EMT; + + case MIPS_LINUX_SIGBUS: + return GDB_SIGNAL_BUS; + + case MIPS_LINUX_SIGSYS: + return GDB_SIGNAL_SYS; + + case MIPS_LINUX_SIGUSR1: + return GDB_SIGNAL_USR1; + + case MIPS_LINUX_SIGUSR2: + return GDB_SIGNAL_USR2; + + case MIPS_LINUX_SIGCHLD: + return GDB_SIGNAL_CHLD; + + case MIPS_LINUX_SIGPWR: + return GDB_SIGNAL_PWR; + + case MIPS_LINUX_SIGWINCH: + return GDB_SIGNAL_WINCH; + + case MIPS_LINUX_SIGURG: + return GDB_SIGNAL_URG; + + /* No way to differentiate between SIGIO and SIGPOLL. + Therefore, we just handle the first one. */ + case MIPS_LINUX_SIGIO: + return GDB_SIGNAL_IO; + + case MIPS_LINUX_SIGSTOP: + return GDB_SIGNAL_STOP; + + case MIPS_LINUX_SIGTSTP: + return GDB_SIGNAL_TSTP; + + case MIPS_LINUX_SIGCONT: + return GDB_SIGNAL_CONT; + + case MIPS_LINUX_SIGTTIN: + return GDB_SIGNAL_TTIN; + + case MIPS_LINUX_SIGTTOU: + return GDB_SIGNAL_TTOU; + + case MIPS_LINUX_SIGVTALRM: + return GDB_SIGNAL_VTALRM; + + case MIPS_LINUX_SIGPROF: + return GDB_SIGNAL_PROF; + + case MIPS_LINUX_SIGXCPU: + return GDB_SIGNAL_XCPU; + + case MIPS_LINUX_SIGXFSZ: + return GDB_SIGNAL_XFSZ; + } + + if (signal >= MIPS_LINUX_SIGRTMIN && signal <= MIPS_LINUX_SIGRTMAX) + { + /* GDB_SIGNAL_REALTIME values are not contiguous, map parts of + the MIPS block to the respective GDB_SIGNAL_REALTIME blocks. */ + int offset = signal - MIPS_LINUX_SIGRTMIN; + + if (offset == 0) + return GDB_SIGNAL_REALTIME_32; + else if (offset < 32) + return (enum gdb_signal) (offset - 1 + + (int) GDB_SIGNAL_REALTIME_33); + else + return (enum gdb_signal) (offset - 32 + + (int) GDB_SIGNAL_REALTIME_64); + } + + return linux_gdb_signal_from_target (gdbarch, signal); +} + /* Initialize one of the GNU/Linux OS ABIs. */ static void @@ -1349,7 +1573,7 @@ mips_linux_init_abi (struct gdbarch_info info, { case MIPS_ABI_O32: set_gdbarch_get_longjmp_target (gdbarch, - mips_linux_get_longjmp_target); + mips_linux_get_longjmp_target); set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_ilp32_fetch_link_map_offsets); tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_sigframe); @@ -1358,7 +1582,7 @@ mips_linux_init_abi (struct gdbarch_info info, break; case MIPS_ABI_N32: set_gdbarch_get_longjmp_target (gdbarch, - mips_linux_get_longjmp_target); + mips_linux_get_longjmp_target); set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_ilp32_fetch_link_map_offsets); set_gdbarch_long_double_bit (gdbarch, 128); @@ -1372,7 +1596,7 @@ mips_linux_init_abi (struct gdbarch_info info, break; case MIPS_ABI_N64: set_gdbarch_get_longjmp_target (gdbarch, - mips64_linux_get_longjmp_target); + mips64_linux_get_longjmp_target); set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_lp64_fetch_link_map_offsets); set_gdbarch_long_double_bit (gdbarch, 128); @@ -1394,7 +1618,7 @@ mips_linux_init_abi (struct gdbarch_info info, /* Enable TLS support. */ set_gdbarch_fetch_tls_load_module_address (gdbarch, - svr4_fetch_objfile_link_map); + svr4_fetch_objfile_link_map); /* Initialize this lazily, to avoid an initialization order dependency on solib-svr4.c's _initialize routine. */ @@ -1414,6 +1638,12 @@ mips_linux_init_abi (struct gdbarch_info info, set_gdbarch_regset_from_core_section (gdbarch, mips_linux_regset_from_core_section); + set_gdbarch_gdb_signal_from_target (gdbarch, + mips_gdb_signal_from_target); + + set_gdbarch_gdb_signal_to_target (gdbarch, + mips_gdb_signal_to_target); + tdep->syscall_next_pc = mips_linux_syscall_next_pc; if (tdesc_data)