gdb/sparcnbsd-tdep.c

   1 /* Target-dependent code for NetBSD/sparc.
   2
   3    Copyright 2002, 2003, 2004 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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "floatformat.h"
  25 #include "frame.h"
  26 #include "frame-unwind.h"
  27 #include "gdbcore.h"
  28 #include "osabi.h"
  29 #include "regcache.h"
  30 #include "regset.h"
  31 #include "solib-svr4.h"
  32 #include "symtab.h"
  33 #include "trad-frame.h"
  34
  35 #include "gdb_assert.h"
  36 #include "gdb_string.h"
  37
  38 #include "sparc-tdep.h"
  39 #include "nbsd-tdep.h"
  40
  41 const struct sparc_gregset sparc32nbsd_gregset =
  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 /* Unlike other NetBSD implementations, the SPARC port historically
  54    used .reg and .reg2 (see bfd/netbsd-core.c), and as such, we can
  55    share one routine for a.out and ELF core files.  */
  56
  57 static void
  58 sparc32nbsd_supply_gregset (const struct regset *regset,
  59                             struct regcache *regcache,
  60                             int regnum, const void *gregs, size_t len)
  61 {
  62   sparc32_supply_gregset (regset->descr, regcache, regnum, gregs);
  63 }
  64
  65 static void
  66 sparc32nbsd_supply_fpregset (const struct regset *regset,
  67                              struct regcache *regcache,
  68                              int regnum, const void *fpregs, size_t len)
  69 {
  70   sparc32_supply_fpregset (regcache, regnum, fpregs);
  71 }
  72
  73 \f
  74 /* Signal trampolines.  */
  75
  76 /* The following variables describe the location of an on-stack signal
  77    trampoline.  The current values correspond to the memory layout for
  78    NetBSD 1.3 and up.  These shouldn't be necessary for NetBSD 2.0 and
  79    up, since NetBSD uses signal trampolines provided by libc now.  */
  80
  81 static const CORE_ADDR sparc32nbsd_sigtramp_start = 0xeffffef0;
  82 static const CORE_ADDR sparc32nbsd_sigtramp_end = 0xeffffff0;
  83
  84 static int
  85 sparc32nbsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
  86 {
  87   if (pc >= sparc32nbsd_sigtramp_start && pc < sparc32nbsd_sigtramp_end)
  88     return 1;
  89
  90   return nbsd_pc_in_sigtramp (pc, name);
  91 }
  92
  93 struct trad_frame_saved_reg *
  94 sparc32nbsd_sigcontext_saved_regs (struct frame_info *next_frame)
  95 {
  96   struct trad_frame_saved_reg *saved_regs;
  97   CORE_ADDR addr, sigcontext_addr;
  98   int regnum, delta;
  99   ULONGEST psr;
 100
 101   saved_regs = trad_frame_alloc_saved_regs (next_frame);
 102
 103   /* We find the appropriate instance of `struct sigcontext' at a
 104      fixed offset in the signal frame.  */
 105   addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
 106   sigcontext_addr = addr + 64 + 16;
 107
 108   /* The registers are saved in bits and pieces scattered all over the
 109      place.  The code below records their location on the assumption
 110      that the part of the signal trampoline that saves the state has
 111      been executed.  */
 112
 113   saved_regs[SPARC_SP_REGNUM].addr = sigcontext_addr + 8;
 114   saved_regs[SPARC32_PC_REGNUM].addr = sigcontext_addr + 12;
 115   saved_regs[SPARC32_NPC_REGNUM].addr = sigcontext_addr + 16;
 116   saved_regs[SPARC32_PSR_REGNUM].addr = sigcontext_addr + 20;
 117   saved_regs[SPARC_G1_REGNUM].addr = sigcontext_addr + 24;
 118   saved_regs[SPARC_O0_REGNUM].addr = sigcontext_addr + 28;
 119
 120   /* The remaining `global' registers and %y are saved in the `local'
 121      registers.  */
 122   delta = SPARC_L0_REGNUM - SPARC_G0_REGNUM;
 123   for (regnum = SPARC_G2_REGNUM; regnum <= SPARC_G7_REGNUM; regnum++)
 124     saved_regs[regnum].realreg = regnum + delta;
 125   saved_regs[SPARC32_Y_REGNUM].realreg = SPARC_L1_REGNUM;
 126
 127   /* The remaining `out' registers can be found in the current frame's
 128      `in' registers.  */
 129   delta = SPARC_I0_REGNUM - SPARC_O0_REGNUM;
 130   for (regnum = SPARC_O1_REGNUM; regnum <= SPARC_O5_REGNUM; regnum++)
 131     saved_regs[regnum].realreg = regnum + delta;
 132   saved_regs[SPARC_O7_REGNUM].realreg = SPARC_I7_REGNUM;
 133
 134   /* The `local' and `in' registers have been saved in the register
 135      save area.  */
 136   addr = saved_regs[SPARC_SP_REGNUM].addr;
 137   addr = get_frame_memory_unsigned (next_frame, addr, 4);
 138   for (regnum = SPARC_L0_REGNUM;
 139        regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
 140     saved_regs[regnum].addr = addr;
 141
 142   /* The floating-point registers are only saved if the EF bit in %prs
 143      has been set.  */
 144
 145 #define PSR_EF  0x00001000
 146
 147   addr = saved_regs[SPARC32_PSR_REGNUM].addr;
 148   psr = get_frame_memory_unsigned (next_frame, addr, 4);
 149   if (psr & PSR_EF)
 150     {
 151       CORE_ADDR sp;
 152
 153       sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
 154       saved_regs[SPARC32_FSR_REGNUM].addr = sp + 96;
 155       for (regnum = SPARC_F0_REGNUM, addr = sp + 96 + 8;
 156            regnum <= SPARC_F31_REGNUM; regnum++, addr += 4)
 157         saved_regs[regnum].addr = addr;
 158     }
 159
 160   return saved_regs;
 161 }
 162
 163 static struct sparc_frame_cache *
 164 sparc32nbsd_sigcontext_frame_cache (struct frame_info *next_frame,
 165                                     void **this_cache)
 166 {
 167   struct sparc_frame_cache *cache;
 168   CORE_ADDR addr;
 169
 170   if (*this_cache)
 171     return *this_cache;
 172
 173   cache = sparc_frame_cache (next_frame, this_cache);
 174   gdb_assert (cache == *this_cache);
 175
 176   /* If we couldn't find the frame's function, we're probably dealing
 177      with an on-stack signal trampoline.  */
 178   if (cache->pc == 0)
 179     {
 180       cache->pc = sparc32nbsd_sigtramp_start;
 181
 182       /* Since we couldn't find the frame's function, the cache was
 183          initialized under the assumption that we're frameless.  */
 184       cache->frameless_p = 0;
 185       addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM);
 186       cache->base = addr;
 187     }
 188
 189   cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (next_frame);
 190
 191   return cache;
 192 }
 193
 194 static void
 195 sparc32nbsd_sigcontext_frame_this_id (struct frame_info *next_frame,
 196                                       void **this_cache,
 197                                       struct frame_id *this_id)
 198 {
 199   struct sparc_frame_cache *cache =
 200     sparc32nbsd_sigcontext_frame_cache (next_frame, this_cache);
 201
 202   (*this_id) = frame_id_build (cache->base, cache->pc);
 203 }
 204
 205 static void
 206 sparc32nbsd_sigcontext_frame_prev_register (struct frame_info *next_frame,
 207                                             void **this_cache,
 208                                             int regnum, int *optimizedp,
 209                                             enum lval_type *lvalp,
 210                                             CORE_ADDR *addrp,
 211                                             int *realnump, void *valuep)
 212 {
 213   struct sparc_frame_cache *cache =
 214     sparc32nbsd_sigcontext_frame_cache (next_frame, this_cache);
 215
 216   trad_frame_prev_register (next_frame, cache->saved_regs, regnum,
 217                             optimizedp, lvalp, addrp, realnump, valuep);
 218 }
 219
 220 static const struct frame_unwind sparc32nbsd_sigcontext_frame_unwind =
 221 {
 222   SIGTRAMP_FRAME,
 223   sparc32nbsd_sigcontext_frame_this_id,
 224   sparc32nbsd_sigcontext_frame_prev_register
 225 };
 226
 227 static const struct frame_unwind *
 228 sparc32nbsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
 229 {
 230   CORE_ADDR pc = frame_pc_unwind (next_frame);
 231   char *name;
 232
 233   find_pc_partial_function (pc, &name, NULL, NULL);
 234   if (sparc32nbsd_pc_in_sigtramp (pc, name))
 235     {
 236       if (name == NULL || strncmp (name, "__sigtramp_sigcontext", 21))
 237         return &sparc32nbsd_sigcontext_frame_unwind;
 238     }
 239
 240   return NULL;
 241 }
 242 \f
 243
 244 /* Return non-zero if we are in a shared library trampoline code stub.  */
 245
 246 static int
 247 sparcnbsd_aout_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 248 {
 249   return (name && !strcmp (name, "_DYNAMIC"));
 250 }
 251
 252 static void
 253 sparc32nbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 254 {
 255   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 256
 257   /* NetBSD doesn't support the 128-bit `long double' from the psABI.  */
 258   set_gdbarch_long_double_bit (gdbarch, 64);
 259   set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
 260
 261   tdep->gregset = XMALLOC (struct regset);
 262   tdep->gregset->descr = &sparc32nbsd_gregset;
 263   tdep->gregset->supply_regset = sparc32nbsd_supply_gregset;
 264
 265   tdep->fpregset = XMALLOC (struct regset);
 266   tdep->fpregset->supply_regset = sparc32nbsd_supply_fpregset;
 267
 268   set_gdbarch_pc_in_sigtramp (gdbarch, sparc32nbsd_pc_in_sigtramp);
 269   frame_unwind_append_sniffer (gdbarch, sparc32nbsd_sigtramp_frame_sniffer);
 270 }
 271
 272 static void
 273 sparc32nbsd_aout_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 274 {
 275   sparc32nbsd_init_abi (info, gdbarch);
 276
 277   set_gdbarch_in_solib_call_trampoline
 278     (gdbarch, sparcnbsd_aout_in_solib_call_trampoline);
 279 }
 280
 281 static void
 282 sparc32nbsd_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 283 {
 284   sparc32nbsd_init_abi (info, gdbarch);
 285
 286   set_solib_svr4_fetch_link_map_offsets
 287     (gdbarch, nbsd_ilp32_solib_svr4_fetch_link_map_offsets);
 288 }
 289
 290 static enum gdb_osabi
 291 sparcnbsd_aout_osabi_sniffer (bfd *abfd)
 292 {
 293   if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)
 294     return GDB_OSABI_NETBSD_AOUT;
 295
 296   return GDB_OSABI_UNKNOWN;
 297 }
 298
 299 /* OpenBSD uses the traditional NetBSD core file format, even for
 300    ports that use ELF.  Therefore, if the default OS ABI is OpenBSD
 301    ELF, we return that instead of NetBSD a.out.  This is mainly for
 302    the benfit of OpenBSD/sparc64, which inherits the sniffer below
 303    since we include this file for an OpenBSD/sparc64 target.  For
 304    OpenBSD/sparc, the NetBSD a.out OS ABI is probably similar enough
 305    to both the OpenBSD a.out and the OpenBSD ELF OS ABI.  */
 306 #if defined (GDB_OSABI_DEFAULT) && (GDB_OSABI_DEFAULT == GDB_OSABI_OPENBSD_ELF)
 307 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
 308 #else
 309 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_NETBSD_AOUT
 310 #endif
 311
 312 static enum gdb_osabi
 313 sparcnbsd_core_osabi_sniffer (bfd *abfd)
 314 {
 315   if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
 316     return GDB_OSABI_NETBSD_CORE;
 317
 318   return GDB_OSABI_UNKNOWN;
 319 }
 320
 321 \f
 322 /* Provide a prototype to silence -Wmissing-prototypes.  */
 323 void _initialize_sparcnbsd_tdep (void);
 324
 325 void
 326 _initialize_sparnbsd_tdep (void)
 327 {
 328   gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,
 329                                   sparcnbsd_aout_osabi_sniffer);
 330
 331   /* BFD doesn't set the architecture for NetBSD style a.out core
 332      files.  */
 333   gdbarch_register_osabi_sniffer (bfd_arch_unknown, bfd_target_unknown_flavour,
 334                                   sparcnbsd_core_osabi_sniffer);
 335
 336   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_AOUT,
 337                           sparc32nbsd_aout_init_abi);
 338   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD_ELF,
 339                           sparc32nbsd_elf_init_abi);
 340 }