X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmips-linux-tdep.c;h=91ef0129f3dde19a83c4ddf8839360a0b384f164;hb=40c1a0073715c1e3f93afc83edac8396eb362a98;hp=272e8d99acad5a27b5eab298cf6625ab10e112e2;hpb=232b87049a1e4d01d207db8e4ed5740314dd4025;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c index 272e8d99ac..91ef0129f3 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" @@ -44,6 +44,42 @@ 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 @@ -59,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; @@ -86,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); } @@ -126,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)); @@ -231,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)); @@ -350,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)); @@ -376,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)); @@ -400,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); @@ -469,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, @@ -480,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)); @@ -567,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); } } @@ -584,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; @@ -598,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 @@ -621,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 @@ -666,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); @@ -742,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 @@ -756,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; @@ -780,7 +826,7 @@ mips_linux_skip_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) resolver = lookup_minimal_symbol ("__dl_runtime_resolve", NULL, NULL); - if (resolver && SYMBOL_VALUE_ADDRESS (resolver) == pc) + if (resolver && MSYMBOL_VALUE_ADDRESS (resolver) == pc) return frame_unwind_caller_pc (get_current_frame ()); return glibc_skip_solib_resolver (gdbarch, pc); @@ -999,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 @@ -1015,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) @@ -1192,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, @@ -1331,94 +1374,184 @@ mips_linux_get_syscall_number (struct gdbarch *gdbarch, return ret; } -/* Translate signals based on MIPS signal values. +/* 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 signo) +mips_gdb_signal_from_target (struct gdbarch *gdbarch, int signal) { - switch (signo) + switch (signal) { - case 0: - return GDB_SIGNAL_0; - case MIPS_SIGHUP: - return GDB_SIGNAL_HUP; - case MIPS_SIGINT: - return GDB_SIGNAL_INT; - case MIPS_SIGQUIT: - return GDB_SIGNAL_QUIT; - case MIPS_SIGILL: - return GDB_SIGNAL_ILL; - case MIPS_SIGTRAP: - return GDB_SIGNAL_TRAP; - case MIPS_SIGABRT: - return GDB_SIGNAL_ABRT; - case MIPS_SIGEMT: + case MIPS_LINUX_SIGEMT: return GDB_SIGNAL_EMT; - case MIPS_SIGFPE: - return GDB_SIGNAL_FPE; - case MIPS_SIGKILL: - return GDB_SIGNAL_KILL; - case MIPS_SIGBUS: + + case MIPS_LINUX_SIGBUS: return GDB_SIGNAL_BUS; - case MIPS_SIGSEGV: - return GDB_SIGNAL_SEGV; - case MIPS_SIGSYS: + + case MIPS_LINUX_SIGSYS: return GDB_SIGNAL_SYS; - case MIPS_SIGPIPE: - return GDB_SIGNAL_PIPE; - case MIPS_SIGALRM: - return GDB_SIGNAL_ALRM; - case MIPS_SIGTERM: - return GDB_SIGNAL_TERM; - case MIPS_SIGUSR1: + + case MIPS_LINUX_SIGUSR1: return GDB_SIGNAL_USR1; - case MIPS_SIGUSR2: + + case MIPS_LINUX_SIGUSR2: return GDB_SIGNAL_USR2; - case MIPS_SIGCHLD: + + case MIPS_LINUX_SIGCHLD: return GDB_SIGNAL_CHLD; - case MIPS_SIGPWR: + + case MIPS_LINUX_SIGPWR: return GDB_SIGNAL_PWR; - case MIPS_SIGWINCH: + + case MIPS_LINUX_SIGWINCH: return GDB_SIGNAL_WINCH; - case MIPS_SIGURG: + + case MIPS_LINUX_SIGURG: return GDB_SIGNAL_URG; - case MIPS_SIGPOLL: - return GDB_SIGNAL_POLL; - case MIPS_SIGSTOP: + + /* 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_SIGTSTP: + + case MIPS_LINUX_SIGTSTP: return GDB_SIGNAL_TSTP; - case MIPS_SIGCONT: + + case MIPS_LINUX_SIGCONT: return GDB_SIGNAL_CONT; - case MIPS_SIGTTIN: + + case MIPS_LINUX_SIGTTIN: return GDB_SIGNAL_TTIN; - case MIPS_SIGTTOU: + + case MIPS_LINUX_SIGTTOU: return GDB_SIGNAL_TTOU; - case MIPS_SIGVTALRM: + + case MIPS_LINUX_SIGVTALRM: return GDB_SIGNAL_VTALRM; - case MIPS_SIGPROF: + + case MIPS_LINUX_SIGPROF: return GDB_SIGNAL_PROF; - case MIPS_SIGXCPU: + + case MIPS_LINUX_SIGXCPU: return GDB_SIGNAL_XCPU; - case MIPS_SIGXFSZ: + + case MIPS_LINUX_SIGXFSZ: return GDB_SIGNAL_XFSZ; - } + } - if (signo >= MIPS_SIGRTMIN && signo <= MIPS_SIGRTMAX) + 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. */ - signo -= MIPS_SIGRTMIN; - if (signo == 0) + int offset = signal - MIPS_LINUX_SIGRTMIN; + + if (offset == 0) return GDB_SIGNAL_REALTIME_32; - else if (signo < 32) - return ((enum gdb_signal) (signo - 1 + (int) GDB_SIGNAL_REALTIME_33)); + else if (offset < 32) + return (enum gdb_signal) (offset - 1 + + (int) GDB_SIGNAL_REALTIME_33); else - return ((enum gdb_signal) (signo - 32 + (int) GDB_SIGNAL_REALTIME_64)); + return (enum gdb_signal) (offset - 32 + + (int) GDB_SIGNAL_REALTIME_64); } - return GDB_SIGNAL_UNKNOWN; + return linux_gdb_signal_from_target (gdbarch, signal); } /* Initialize one of the GNU/Linux OS ABIs. */ @@ -1440,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); @@ -1449,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); @@ -1463,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); @@ -1485,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. */ @@ -1508,6 +1641,9 @@ mips_linux_init_abi (struct gdbarch_info info, 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)