gdb/sparc-netbsd-tdep.c

   1 /* Target-dependent code for NetBSD/sparc.
   2
   3    Copyright (C) 2002-2023 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 #include "gdbarch.h"
  33
  34 #include "sparc-tdep.h"
  35 #include "netbsd-tdep.h"
  36
  37 /* Macros to extract fields from SPARC instructions.  */
  38 #define X_RS1(i) (((i) >> 14) & 0x1f)
  39 #define X_RS2(i) ((i) & 0x1f)
  40 #define X_I(i) (((i) >> 13) & 1)
  41
  42 const struct sparc_gregmap sparc32nbsd_gregmap =
  43 {
  44   0 * 4,                        /* %psr */
  45   1 * 4,                        /* %pc */
  46   2 * 4,                        /* %npc */
  47   3 * 4,                        /* %y */
  48   -1,                           /* %wim */
  49   -1,                           /* %tbr */
  50   5 * 4,                        /* %g1 */
  51   -1                            /* %l0 */
  52 };
  53
  54 static void
  55 sparc32nbsd_supply_gregset (const struct regset *regset,
  56                             struct regcache *regcache,
  57                             int regnum, const void *gregs, size_t len)
  58 {
  59   sparc32_supply_gregset (&sparc32nbsd_gregmap, regcache, regnum, gregs);
  60
  61   /* Traditional NetBSD core files don't use multiple register sets.
  62      Instead, the general-purpose and floating-point registers are
  63      lumped together in a single section.  */
  64   if (len >= 212)
  65     sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum,
  66                              (const char *) gregs + 80);
  67 }
  68
  69 static void
  70 sparc32nbsd_supply_fpregset (const struct regset *regset,
  71                              struct regcache *regcache,
  72                              int regnum, const void *fpregs, size_t len)
  73 {
  74   sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
  75 }
  76
  77 \f
  78 /* Signal trampolines.  */
  79
  80 /* The following variables describe the location of an on-stack signal
  81    trampoline.  The current values correspond to the memory layout for
  82    NetBSD 1.3 and up.  These shouldn't be necessary for NetBSD 2.0 and
  83    up, since NetBSD uses signal trampolines provided by libc now.  */
  84
  85 static const CORE_ADDR sparc32nbsd_sigtramp_start = 0xeffffef0;
  86 static const CORE_ADDR sparc32nbsd_sigtramp_end = 0xeffffff0;
  87
  88 static int
  89 sparc32nbsd_pc_in_sigtramp (CORE_ADDR pc, const char *name)
  90 {
  91   if (pc >= sparc32nbsd_sigtramp_start && pc < sparc32nbsd_sigtramp_end)
  92     return 1;
  93
  94   return nbsd_pc_in_sigtramp (pc, name);
  95 }
  96
  97 trad_frame_saved_reg *
  98 sparc32nbsd_sigcontext_saved_regs (frame_info_ptr this_frame)
  99 {
 100   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 101   trad_frame_saved_reg *saved_regs;
 102   CORE_ADDR addr, sigcontext_addr;
 103   int regnum, delta;
 104   ULONGEST psr;
 105
 106   saved_regs = trad_frame_alloc_saved_regs (this_frame);
 107
 108   /* We find the appropriate instance of `struct sigcontext' at a
 109      fixed offset in the signal frame.  */
 110   addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
 111   sigcontext_addr = addr + 64 + 16;
 112
 113   /* The registers are saved in bits and pieces scattered all over the
 114      place.  The code below records their location on the assumption
 115      that the part of the signal trampoline that saves the state has
 116      been executed.  */
 117
 118   saved_regs[SPARC_SP_REGNUM].set_addr (sigcontext_addr + 8);
 119   saved_regs[SPARC32_PC_REGNUM].set_addr (sigcontext_addr + 12);
 120   saved_regs[SPARC32_NPC_REGNUM].set_addr (sigcontext_addr + 16);
 121   saved_regs[SPARC32_PSR_REGNUM].set_addr (sigcontext_addr + 20);
 122   saved_regs[SPARC_G1_REGNUM].set_addr (sigcontext_addr + 24);
 123   saved_regs[SPARC_O0_REGNUM].set_addr (sigcontext_addr + 28);
 124
 125   /* The remaining `global' registers and %y are saved in the `local'
 126      registers.  */
 127   delta = SPARC_L0_REGNUM - SPARC_G0_REGNUM;
 128   for (regnum = SPARC_G2_REGNUM; regnum <= SPARC_G7_REGNUM; regnum++)
 129     saved_regs[regnum].set_realreg (regnum + delta);
 130   saved_regs[SPARC32_Y_REGNUM].set_realreg (SPARC_L1_REGNUM);
 131
 132   /* The remaining `out' registers can be found in the current frame's
 133      `in' registers.  */
 134   delta = SPARC_I0_REGNUM - SPARC_O0_REGNUM;
 135   for (regnum = SPARC_O1_REGNUM; regnum <= SPARC_O5_REGNUM; regnum++)
 136     saved_regs[regnum].set_realreg (regnum + delta);
 137   saved_regs[SPARC_O7_REGNUM].set_realreg (SPARC_I7_REGNUM);
 138
 139   /* The `local' and `in' registers have been saved in the register
 140      save area.  */
 141   addr = saved_regs[SPARC_SP_REGNUM].addr ();
 142   addr = get_frame_memory_unsigned (this_frame, addr, 4);
 143   for (regnum = SPARC_L0_REGNUM;
 144        regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
 145     saved_regs[regnum].set_addr (addr);
 146
 147   /* Handle StackGhost.  */
 148   {
 149     ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
 150
 151     if (wcookie != 0)
 152       {
 153         ULONGEST i7;
 154
 155         addr = saved_regs[SPARC_I7_REGNUM].addr ();
 156         i7 = get_frame_memory_unsigned (this_frame, addr, 4);
 157         saved_regs[SPARC_I7_REGNUM].set_value (i7 ^ wcookie);
 158       }
 159   }
 160
 161   /* The floating-point registers are only saved if the EF bit in %prs
 162      has been set.  */
 163
 164 #define PSR_EF  0x00001000
 165
 166   addr = saved_regs[SPARC32_PSR_REGNUM].addr ();
 167   psr = get_frame_memory_unsigned (this_frame, addr, 4);
 168   if (psr & PSR_EF)
 169     {
 170       CORE_ADDR sp;
 171
 172       sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
 173       saved_regs[SPARC32_FSR_REGNUM].set_addr (sp + 96);
 174       for (regnum = SPARC_F0_REGNUM, addr = sp + 96 + 8;
 175            regnum <= SPARC_F31_REGNUM; regnum++, addr += 4)
 176         saved_regs[regnum].set_addr (addr);
 177     }
 178
 179   return saved_regs;
 180 }
 181
 182 static struct sparc_frame_cache *
 183 sparc32nbsd_sigcontext_frame_cache (frame_info_ptr this_frame,
 184                                     void **this_cache)
 185 {
 186   struct sparc_frame_cache *cache;
 187   CORE_ADDR addr;
 188
 189   if (*this_cache)
 190     return (struct sparc_frame_cache *) *this_cache;
 191
 192   cache = sparc_frame_cache (this_frame, this_cache);
 193   gdb_assert (cache == *this_cache);
 194
 195   /* If we couldn't find the frame's function, we're probably dealing
 196      with an on-stack signal trampoline.  */
 197   if (cache->pc == 0)
 198     {
 199       cache->pc = sparc32nbsd_sigtramp_start;
 200
 201       /* Since we couldn't find the frame's function, the cache was
 202          initialized under the assumption that we're frameless.  */
 203       sparc_record_save_insn (cache);
 204       addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
 205       cache->base = addr;
 206     }
 207
 208   cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (this_frame);
 209
 210   return cache;
 211 }
 212
 213 static void
 214 sparc32nbsd_sigcontext_frame_this_id (frame_info_ptr this_frame,
 215                                       void **this_cache,
 216                                       struct frame_id *this_id)
 217 {
 218   struct sparc_frame_cache *cache =
 219     sparc32nbsd_sigcontext_frame_cache (this_frame, this_cache);
 220
 221   (*this_id) = frame_id_build (cache->base, cache->pc);
 222 }
 223
 224 static struct value *
 225 sparc32nbsd_sigcontext_frame_prev_register (frame_info_ptr this_frame,
 226                                             void **this_cache, int regnum)
 227 {
 228   struct sparc_frame_cache *cache =
 229     sparc32nbsd_sigcontext_frame_cache (this_frame, this_cache);
 230
 231   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 232 }
 233
 234 static int
 235 sparc32nbsd_sigcontext_frame_sniffer (const struct frame_unwind *self,
 236                                       frame_info_ptr this_frame,
 237                                       void **this_cache)
 238 {
 239   CORE_ADDR pc = get_frame_pc (this_frame);
 240   const char *name;
 241
 242   find_pc_partial_function (pc, &name, NULL, NULL);
 243   if (sparc32nbsd_pc_in_sigtramp (pc, name))
 244     {
 245       if (name == NULL || !startswith (name, "__sigtramp_sigcontext"))
 246         return 1;
 247     }
 248
 249   return 0;
 250 }
 251
 252 static const struct frame_unwind sparc32nbsd_sigcontext_frame_unwind =
 253 {
 254   "sparc32 netbsd sigcontext",
 255   SIGTRAMP_FRAME,
 256   default_frame_unwind_stop_reason,
 257   sparc32nbsd_sigcontext_frame_this_id,
 258   sparc32nbsd_sigcontext_frame_prev_register,
 259   NULL,
 260   sparc32nbsd_sigcontext_frame_sniffer
 261 };
 262 \f
 263 /* Return the address of a system call's alternative return
 264    address.  */
 265
 266 CORE_ADDR
 267 sparcnbsd_step_trap (frame_info_ptr frame, unsigned long insn)
 268 {
 269   if ((X_I (insn) == 0 && X_RS1 (insn) == 0 && X_RS2 (insn) == 0)
 270       || (X_I (insn) == 1 && X_RS1 (insn) == 0 && (insn & 0x7f) == 0))
 271     {
 272       /* "New" system call.  */
 273       ULONGEST number = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
 274
 275       if (number & 0x400)
 276         return get_frame_register_unsigned (frame, SPARC_G2_REGNUM);
 277       if (number & 0x800)
 278         return get_frame_register_unsigned (frame, SPARC_G7_REGNUM);
 279     }
 280
 281   return 0;
 282 }
 283 \f
 284
 285 static const struct regset sparc32nbsd_gregset =
 286   {
 287     NULL, sparc32nbsd_supply_gregset, NULL
 288   };
 289
 290 static const struct regset sparc32nbsd_fpregset =
 291   {
 292     NULL, sparc32nbsd_supply_fpregset, NULL
 293   };
 294
 295 void
 296 sparc32nbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 297 {
 298   sparc_gdbarch_tdep *tdep = gdbarch_tdep<sparc_gdbarch_tdep> (gdbarch);
 299
 300   nbsd_init_abi (info, gdbarch);
 301
 302   /* NetBSD doesn't support the 128-bit `long double' from the psABI.  */
 303   set_gdbarch_long_double_bit (gdbarch, 64);
 304   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 305
 306   tdep->gregset = &sparc32nbsd_gregset;
 307   tdep->sizeof_gregset = 20 * 4;
 308
 309   tdep->fpregset = &sparc32nbsd_fpregset;
 310   tdep->sizeof_fpregset = 33 * 4;
 311
 312   /* Make sure we can single-step "new" syscalls.  */
 313   tdep->step_trap = sparcnbsd_step_trap;
 314
 315   frame_unwind_append_unwinder (gdbarch, &sparc32nbsd_sigcontext_frame_unwind);
 316
 317   set_solib_svr4_fetch_link_map_offsets
 318     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 319 }
 320
 321 void _initialize_sparcnbsd_tdep ();
 322 void
 323 _initialize_sparcnbsd_tdep ()
 324 {
 325   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD,
 326                           sparc32nbsd_init_abi);
 327 }