gdb/sparcnbsd-tdep.c

   1 /* Target-dependent code for NetBSD/sparc.
   2
   3    Copyright (C) 2002-2015 Free Software Foundation, Inc.
   4    Contributed by Wasabi Systems, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "gdbcore.h"
  25 #include "gdbtypes.h"
  26 #include "osabi.h"
  27 #include "regcache.h"
  28 #include "regset.h"
  29 #include "solib-svr4.h"
  30 #include "symtab.h"
  31 #include "trad-frame.h"
  32
  33 #include "sparc-tdep.h"
  34 #include "nbsd-tdep.h"
  35
  36 /* Macros to extract fields from SPARC instructions.  */
  37 #define X_RS1(i) (((i) >> 14) & 0x1f)
  38 #define X_RS2(i) ((i) & 0x1f)
  39 #define X_I(i) (((i) >> 13) & 1)
  40
  41 const struct sparc_gregmap sparc32nbsd_gregmap =
  42 {
  43   0 * 4,                        /* %psr */
  44   1 * 4,                        /* %pc */
  45   2 * 4,                        /* %npc */
  46   3 * 4,                        /* %y */
  47   -1,                           /* %wim */
  48   -1,                           /* %tbr */
  49   5 * 4,                        /* %g1 */
  50   -1                            /* %l0 */
  51 };
  52
  53 static void
  54 sparc32nbsd_supply_gregset (const struct regset *regset,
  55                             struct regcache *regcache,
  56                             int regnum, const void *gregs, size_t len)
  57 {
  58   sparc32_supply_gregset (&sparc32nbsd_gregmap, regcache, regnum, gregs);
  59
  60   /* Traditional NetBSD core files don't use multiple register sets.
  61      Instead, the general-purpose and floating-point registers are
  62      lumped together in a single section.  */
  63   if (len >= 212)
  64     sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum,
  65                              (const char *) gregs + 80);
  66 }
  67
  68 static void
  69 sparc32nbsd_supply_fpregset (const struct regset *regset,
  70                              struct regcache *regcache,
  71                              int regnum, const void *fpregs, size_t len)
  72 {
  73   sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
  74 }
  75
  76 \f
  77 /* Signal trampolines.  */
  78
  79 /* The following variables describe the location of an on-stack signal
  80    trampoline.  The current values correspond to the memory layout for
  81    NetBSD 1.3 and up.  These shouldn't be necessary for NetBSD 2.0 and
  82    up, since NetBSD uses signal trampolines provided by libc now.  */
  83
  84 static const CORE_ADDR sparc32nbsd_sigtramp_start = 0xeffffef0;
  85 static const CORE_ADDR sparc32nbsd_sigtramp_end = 0xeffffff0;
  86
  87 static int
  88 sparc32nbsd_pc_in_sigtramp (CORE_ADDR pc, const char *name)
  89 {
  90   if (pc >= sparc32nbsd_sigtramp_start && pc < sparc32nbsd_sigtramp_end)
  91     return 1;
  92
  93   return nbsd_pc_in_sigtramp (pc, name);
  94 }
  95
  96 struct trad_frame_saved_reg *
  97 sparc32nbsd_sigcontext_saved_regs (struct frame_info *this_frame)
  98 {
  99   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 100   struct trad_frame_saved_reg *saved_regs;
 101   CORE_ADDR addr, sigcontext_addr;
 102   int regnum, delta;
 103   ULONGEST psr;
 104
 105   saved_regs = trad_frame_alloc_saved_regs (this_frame);
 106
 107   /* We find the appropriate instance of `struct sigcontext' at a
 108      fixed offset in the signal frame.  */
 109   addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
 110   sigcontext_addr = addr + 64 + 16;
 111
 112   /* The registers are saved in bits and pieces scattered all over the
 113      place.  The code below records their location on the assumption
 114      that the part of the signal trampoline that saves the state has
 115      been executed.  */
 116
 117   saved_regs[SPARC_SP_REGNUM].addr = sigcontext_addr + 8;
 118   saved_regs[SPARC32_PC_REGNUM].addr = sigcontext_addr + 12;
 119   saved_regs[SPARC32_NPC_REGNUM].addr = sigcontext_addr + 16;
 120   saved_regs[SPARC32_PSR_REGNUM].addr = sigcontext_addr + 20;
 121   saved_regs[SPARC_G1_REGNUM].addr = sigcontext_addr + 24;
 122   saved_regs[SPARC_O0_REGNUM].addr = sigcontext_addr + 28;
 123
 124   /* The remaining `global' registers and %y are saved in the `local'
 125      registers.  */
 126   delta = SPARC_L0_REGNUM - SPARC_G0_REGNUM;
 127   for (regnum = SPARC_G2_REGNUM; regnum <= SPARC_G7_REGNUM; regnum++)
 128     saved_regs[regnum].realreg = regnum + delta;
 129   saved_regs[SPARC32_Y_REGNUM].realreg = SPARC_L1_REGNUM;
 130
 131   /* The remaining `out' registers can be found in the current frame's
 132      `in' registers.  */
 133   delta = SPARC_I0_REGNUM - SPARC_O0_REGNUM;
 134   for (regnum = SPARC_O1_REGNUM; regnum <= SPARC_O5_REGNUM; regnum++)
 135     saved_regs[regnum].realreg = regnum + delta;
 136   saved_regs[SPARC_O7_REGNUM].realreg = SPARC_I7_REGNUM;
 137
 138   /* The `local' and `in' registers have been saved in the register
 139      save area.  */
 140   addr = saved_regs[SPARC_SP_REGNUM].addr;
 141   addr = get_frame_memory_unsigned (this_frame, addr, 4);
 142   for (regnum = SPARC_L0_REGNUM;
 143        regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
 144     saved_regs[regnum].addr = addr;
 145
 146   /* Handle StackGhost.  */
 147   {
 148     ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
 149
 150     if (wcookie != 0)
 151       {
 152         ULONGEST i7;
 153
 154         addr = saved_regs[SPARC_I7_REGNUM].addr;
 155         i7 = get_frame_memory_unsigned (this_frame, addr, 4);
 156         trad_frame_set_value (saved_regs, SPARC_I7_REGNUM, i7 ^ wcookie);
 157       }
 158   }
 159
 160   /* The floating-point registers are only saved if the EF bit in %prs
 161      has been set.  */
 162
 163 #define PSR_EF  0x00001000
 164
 165   addr = saved_regs[SPARC32_PSR_REGNUM].addr;
 166   psr = get_frame_memory_unsigned (this_frame, addr, 4);
 167   if (psr & PSR_EF)
 168     {
 169       CORE_ADDR sp;
 170
 171       sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
 172       saved_regs[SPARC32_FSR_REGNUM].addr = sp + 96;
 173       for (regnum = SPARC_F0_REGNUM, addr = sp + 96 + 8;
 174            regnum <= SPARC_F31_REGNUM; regnum++, addr += 4)
 175         saved_regs[regnum].addr = addr;
 176     }
 177
 178   return saved_regs;
 179 }
 180
 181 static struct sparc_frame_cache *
 182 sparc32nbsd_sigcontext_frame_cache (struct frame_info *this_frame,
 183                                     void **this_cache)
 184 {
 185   struct sparc_frame_cache *cache;
 186   CORE_ADDR addr;
 187
 188   if (*this_cache)
 189     return *this_cache;
 190
 191   cache = sparc_frame_cache (this_frame, this_cache);
 192   gdb_assert (cache == *this_cache);
 193
 194   /* If we couldn't find the frame's function, we're probably dealing
 195      with an on-stack signal trampoline.  */
 196   if (cache->pc == 0)
 197     {
 198       cache->pc = sparc32nbsd_sigtramp_start;
 199
 200       /* Since we couldn't find the frame's function, the cache was
 201          initialized under the assumption that we're frameless.  */
 202       sparc_record_save_insn (cache);
 203       addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
 204       cache->base = addr;
 205     }
 206
 207   cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (this_frame);
 208
 209   return cache;
 210 }
 211
 212 static void
 213 sparc32nbsd_sigcontext_frame_this_id (struct frame_info *this_frame,
 214                                       void **this_cache,
 215                                       struct frame_id *this_id)
 216 {
 217   struct sparc_frame_cache *cache =
 218     sparc32nbsd_sigcontext_frame_cache (this_frame, this_cache);
 219
 220   (*this_id) = frame_id_build (cache->base, cache->pc);
 221 }
 222
 223 static struct value *
 224 sparc32nbsd_sigcontext_frame_prev_register (struct frame_info *this_frame,
 225                                             void **this_cache, int regnum)
 226 {
 227   struct sparc_frame_cache *cache =
 228     sparc32nbsd_sigcontext_frame_cache (this_frame, this_cache);
 229
 230   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 231 }
 232
 233 static int
 234 sparc32nbsd_sigcontext_frame_sniffer (const struct frame_unwind *self,
 235                                       struct frame_info *this_frame,
 236                                       void **this_cache)
 237 {
 238   CORE_ADDR pc = get_frame_pc (this_frame);
 239   const char *name;
 240
 241   find_pc_partial_function (pc, &name, NULL, NULL);
 242   if (sparc32nbsd_pc_in_sigtramp (pc, name))
 243     {
 244       if (name == NULL || strncmp (name, "__sigtramp_sigcontext", 21))
 245         return 1;
 246     }
 247
 248   return 0;
 249 }
 250
 251 static const struct frame_unwind sparc32nbsd_sigcontext_frame_unwind =
 252 {
 253   SIGTRAMP_FRAME,
 254   default_frame_unwind_stop_reason,
 255   sparc32nbsd_sigcontext_frame_this_id,
 256   sparc32nbsd_sigcontext_frame_prev_register,
 257   NULL,
 258   sparc32nbsd_sigcontext_frame_sniffer
 259 };
 260 \f
 261 /* Return the address of a system call's alternative return
 262    address.  */
 263
 264 CORE_ADDR
 265 sparcnbsd_step_trap (struct frame_info *frame, unsigned long insn)
 266 {
 267   if ((X_I (insn) == 0 && X_RS1 (insn) == 0 && X_RS2 (insn) == 0)
 268       || (X_I (insn) == 1 && X_RS1 (insn) == 0 && (insn & 0x7f) == 0))
 269     {
 270       /* "New" system call.  */
 271       ULONGEST number = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
 272
 273       if (number & 0x400)
 274         return get_frame_register_unsigned (frame, SPARC_G2_REGNUM);
 275       if (number & 0x800)
 276         return get_frame_register_unsigned (frame, SPARC_G7_REGNUM);
 277     }
 278
 279   return 0;
 280 }
 281 \f
 282
 283 static const struct regset sparc32nbsd_gregset =
 284   {
 285     NULL, sparc32nbsd_supply_gregset, NULL
 286   };
 287
 288 static const struct regset sparc32nbsd_fpregset =
 289   {
 290     NULL, sparc32nbsd_supply_fpregset, NULL
 291   };
 292
 293 static void
 294 sparc32nbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 295 {
 296   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 297
 298   /* NetBSD doesn't support the 128-bit `long double' from the psABI.  */
 299   set_gdbarch_long_double_bit (gdbarch, 64);
 300   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 301
 302   tdep->gregset = &sparc32nbsd_gregset;
 303   tdep->sizeof_gregset = 20 * 4;
 304
 305   tdep->fpregset = &sparc32nbsd_fpregset;
 306   tdep->sizeof_fpregset = 33 * 4;
 307
 308   /* Make sure we can single-step "new" syscalls.  */
 309   tdep->step_trap = sparcnbsd_step_trap;
 310
 311   frame_unwind_append_unwinder (gdbarch, &sparc32nbsd_sigcontext_frame_unwind);
 312 }
 313
 314 static void
 315 sparc32nbsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 316 {
 317   sparc32nbsd_init_abi (info, gdbarch);
 318 }
 319
 320 void
 321 sparc32nbsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 322 {
 323   sparc32nbsd_init_abi (info, gdbarch);
 324
 325   set_solib_svr4_fetch_link_map_offsets
 326     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 327 }
 328
 329 static enum gdb_osabi
 330 sparcnbsd_aout_osabi_sniffer (bfd *abfd)
 331 {
 332   if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)
 333     return GDB_OSABI_NETBSD_AOUT;
 334
 335   return GDB_OSABI_UNKNOWN;
 336 }
 337
 338 /* OpenBSD uses the traditional NetBSD core file format, even for
 339    ports that use ELF.  Therefore, if the default OS ABI is OpenBSD
 340    ELF, we return that instead of NetBSD a.out.  This is mainly for
 341    the benfit of OpenBSD/sparc64, which inherits the sniffer below
 342    since we include this file for an OpenBSD/sparc64 target.  For
 343    OpenBSD/sparc, the NetBSD a.out OS ABI is probably similar enough
 344    to both the OpenBSD a.out and the OpenBSD ELF OS ABI.  */
 345 #if defined (GDB_OSABI_DEFAULT) && (GDB_OSABI_DEFAULT == GDB_OSABI_OPENBSD_ELF)
 346 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
 347 #else
 348 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_NETBSD_AOUT
 349 #endif
 350
 351 static enum gdb_osabi
 352 sparcnbsd_core_osabi_sniffer (bfd *abfd)
 353 {
 354   if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
 355     return GDB_OSABI_NETBSD_CORE;
 356
 357   return GDB_OSABI_UNKNOWN;
 358 }
 359
 360 \f
 361 /* Provide a prototype to silence -Wmissing-prototypes.  */
 362 void _initialize_sparcnbsd_tdep (void);
 363
 364 void
 365 _initialize_sparcnbsd_tdep (void)
 366 {
 367   gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,
 368                                   sparcnbsd_aout_osabi_sniffer);
 369
 370   /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
 371   gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_unknown_flavour,
 372                                   sparcnbsd_core_osabi_sniffer);
 373
 374   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_AOUT,
 375                           sparc32nbsd_aout_init_abi);
 376   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_ELF,
 377                           sparc32nbsd_elf_init_abi);
 378 }