gdb/alphanbsd-tdep.c

   1 /* Target-dependent code for NetBSD/alpha.
   2
   3    Copyright (C) 2002-2014 Free Software Foundation, Inc.
   4
   5    Contributed by Wasabi Systems, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "gdbcore.h"
  25 #include "osabi.h"
  26 #include "regcache.h"
  27 #include "regset.h"
  28 #include "value.h"
  29
  30 #include <string.h>
  31
  32 #include "alpha-tdep.h"
  33 #include "alphabsd-tdep.h"
  34 #include "nbsd-tdep.h"
  35 #include "solib-svr4.h"
  36 #include "target.h"
  37
  38 /* Core file support.  */
  39
  40 /* Even though NetBSD/alpha used ELF since day one, it used the
  41    traditional a.out-style core dump format before NetBSD 1.6.  */
  42
  43 /* Sizeof `struct reg' in <machine/reg.h>.  */
  44 #define ALPHANBSD_SIZEOF_GREGS  (32 * 8)
  45
  46 /* Sizeof `struct fpreg' in <machine/reg.h.  */
  47 #define ALPHANBSD_SIZEOF_FPREGS ((32 * 8) + 8)
  48
  49 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
  50    in the floating-point register set REGSET to register cache
  51    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  52
  53 static void
  54 alphanbsd_supply_fpregset (const struct regset *regset,
  55                            struct regcache *regcache,
  56                            int regnum, const void *fpregs, size_t len)
  57 {
  58   const gdb_byte *regs = fpregs;
  59   int i;
  60
  61   gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS);
  62
  63   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
  64     {
  65       if (regnum == i || regnum == -1)
  66         regcache_raw_supply (regcache, i, regs + (i - ALPHA_FP0_REGNUM) * 8);
  67     }
  68
  69   if (regnum == ALPHA_FPCR_REGNUM || regnum == -1)
  70     regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 32 * 8);
  71 }
  72
  73 /* Supply register REGNUM from the buffer specified by GREGS and LEN
  74    in the general-purpose register set REGSET to register cache
  75    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  76
  77 static void
  78 alphanbsd_supply_gregset (const struct regset *regset,
  79                           struct regcache *regcache,
  80                           int regnum, const void *gregs, size_t len)
  81 {
  82   const gdb_byte *regs = gregs;
  83   int i;
  84
  85   gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);
  86
  87   for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
  88     {
  89       if (regnum == i || regnum == -1)
  90         regcache_raw_supply (regcache, i, regs + i * 8);
  91     }
  92
  93   if (regnum == ALPHA_PC_REGNUM || regnum == -1)
  94     regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
  95 }
  96
  97 /* Supply register REGNUM from the buffer specified by GREGS and LEN
  98    in the general-purpose register set REGSET to register cache
  99    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 100
 101 static void
 102 alphanbsd_aout_supply_gregset (const struct regset *regset,
 103                                struct regcache *regcache,
 104                                int regnum, const void *gregs, size_t len)
 105 {
 106   const gdb_byte *regs = gregs;
 107   int i;
 108
 109   /* Table to map a GDB register number to a trapframe register index.  */
 110   static const int regmap[] =
 111   {
 112      0,   1,   2,   3,
 113      4,   5,   6,   7,
 114      8,   9,  10,  11,
 115     12,  13,  14,  15,
 116     30,  31,  32,  16,
 117     17,  18,  19,  20,
 118     21,  22,  23,  24,
 119     25,  29,  26
 120   };
 121
 122   gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);
 123
 124   for (i = 0; i < ARRAY_SIZE(regmap); i++)
 125     {
 126       if (regnum == i || regnum == -1)
 127         regcache_raw_supply (regcache, i, regs + regmap[i] * 8);
 128     }
 129
 130   if (regnum == ALPHA_PC_REGNUM || regnum == -1)
 131     regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
 132
 133   if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
 134     {
 135       regs += ALPHANBSD_SIZEOF_GREGS;
 136       len -= ALPHANBSD_SIZEOF_GREGS;
 137       alphanbsd_supply_fpregset (regset, regcache, regnum, regs, len);
 138     }
 139 }
 140
 141 /* NetBSD/alpha register sets.  */
 142
 143 static const struct regset alphanbsd_gregset =
 144 {
 145   NULL,
 146   alphanbsd_supply_gregset
 147 };
 148
 149 static const struct regset alphanbsd_fpregset =
 150 {
 151   NULL,
 152   alphanbsd_supply_fpregset
 153 };
 154
 155 static const struct regset alphanbsd_aout_gregset =
 156 {
 157   NULL,
 158   alphanbsd_aout_supply_gregset
 159 };
 160
 161 /* Return the appropriate register set for the core section identified
 162    by SECT_NAME and SECT_SIZE.  */
 163
 164 const struct regset *
 165 alphanbsd_regset_from_core_section (struct gdbarch *gdbarch,
 166                                     const char *sect_name, size_t sect_size)
 167 {
 168   if (strcmp (sect_name, ".reg") == 0 && sect_size >= ALPHANBSD_SIZEOF_GREGS)
 169     {
 170       if (sect_size >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
 171         return &alphanbsd_aout_gregset;
 172       else
 173         return &alphanbsd_gregset;
 174     }
 175
 176   if (strcmp (sect_name, ".reg2") == 0 && sect_size >= ALPHANBSD_SIZEOF_FPREGS)
 177     return &alphanbsd_fpregset;
 178
 179   return NULL;
 180 }
 181 \f
 182
 183 /* Signal trampolines.  */
 184
 185 /* Under NetBSD/alpha, signal handler invocations can be identified by the
 186    designated code sequence that is used to return from a signal handler.
 187    In particular, the return address of a signal handler points to the
 188    following code sequence:
 189
 190         ldq     a0, 0(sp)
 191         lda     sp, 16(sp)
 192         lda     v0, 295(zero)   # __sigreturn14
 193         call_pal callsys
 194
 195    Each instruction has a unique encoding, so we simply attempt to match
 196    the instruction the PC is pointing to with any of the above instructions.
 197    If there is a hit, we know the offset to the start of the designated
 198    sequence and can then check whether we really are executing in the
 199    signal trampoline.  If not, -1 is returned, otherwise the offset from the
 200    start of the return sequence is returned.  */
 201 static const gdb_byte sigtramp_retcode[] =
 202 {
 203   0x00, 0x00, 0x1e, 0xa6,       /* ldq a0, 0(sp) */
 204   0x10, 0x00, 0xde, 0x23,       /* lda sp, 16(sp) */
 205   0x27, 0x01, 0x1f, 0x20,       /* lda v0, 295(zero) */
 206   0x83, 0x00, 0x00, 0x00,       /* call_pal callsys */
 207 };
 208 #define RETCODE_NWORDS          4
 209 #define RETCODE_SIZE            (RETCODE_NWORDS * 4)
 210
 211 static LONGEST
 212 alphanbsd_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc)
 213 {
 214   gdb_byte ret[RETCODE_SIZE], w[4];
 215   LONGEST off;
 216   int i;
 217
 218   if (target_read_memory (pc, w, 4) != 0)
 219     return -1;
 220
 221   for (i = 0; i < RETCODE_NWORDS; i++)
 222     {
 223       if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
 224         break;
 225     }
 226   if (i == RETCODE_NWORDS)
 227     return (-1);
 228
 229   off = i * 4;
 230   pc -= off;
 231
 232   if (target_read_memory (pc, ret, sizeof (ret)) != 0)
 233     return -1;
 234
 235   if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
 236     return off;
 237
 238   return -1;
 239 }
 240
 241 static int
 242 alphanbsd_pc_in_sigtramp (struct gdbarch *gdbarch,
 243                           CORE_ADDR pc, const char *func_name)
 244 {
 245   return (nbsd_pc_in_sigtramp (pc, func_name)
 246           || alphanbsd_sigtramp_offset (gdbarch, pc) >= 0);
 247 }
 248
 249 static CORE_ADDR
 250 alphanbsd_sigcontext_addr (struct frame_info *frame)
 251 {
 252   /* FIXME: This is not correct for all versions of NetBSD/alpha.
 253      We will probably need to disassemble the trampoline to figure
 254      out which trampoline frame type we have.  */
 255   if (!get_next_frame (frame))
 256     return 0;
 257   return get_frame_base (get_next_frame (frame));
 258 }
 259 \f
 260
 261 static void
 262 alphanbsd_init_abi (struct gdbarch_info info,
 263                     struct gdbarch *gdbarch)
 264 {
 265   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 266
 267   /* Hook into the DWARF CFI frame unwinder.  */
 268   alpha_dwarf2_init_abi (info, gdbarch);
 269
 270   /* Hook into the MDEBUG frame unwinder.  */
 271   alpha_mdebug_init_abi (info, gdbarch);
 272
 273   /* NetBSD/alpha does not provide single step support via ptrace(2); we
 274      must use software single-stepping.  */
 275   set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);
 276
 277   /* NetBSD/alpha has SVR4-style shared libraries.  */
 278   set_solib_svr4_fetch_link_map_offsets
 279     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 280
 281   tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset;
 282   tdep->pc_in_sigtramp = alphanbsd_pc_in_sigtramp;
 283   tdep->sigcontext_addr = alphanbsd_sigcontext_addr;
 284
 285   tdep->jb_pc = 2;
 286   tdep->jb_elt_size = 8;
 287
 288   set_gdbarch_regset_from_core_section
 289     (gdbarch, alphanbsd_regset_from_core_section);
 290 }
 291 \f
 292
 293 static enum gdb_osabi
 294 alphanbsd_core_osabi_sniffer (bfd *abfd)
 295 {
 296   if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
 297     return GDB_OSABI_NETBSD_ELF;
 298
 299   return GDB_OSABI_UNKNOWN;
 300 }
 301 \f
 302
 303 /* Provide a prototype to silence -Wmissing-prototypes.  */
 304 void _initialize_alphanbsd_tdep (void);
 305
 306 void
 307 _initialize_alphanbsd_tdep (void)
 308 {
 309   /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
 310   gdbarch_register_osabi_sniffer (bfd_arch_alpha, bfd_target_unknown_flavour,
 311                                   alphanbsd_core_osabi_sniffer);
 312
 313   gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_ELF,
 314                           alphanbsd_init_abi);
 315 }