gdb/sparc-sol2-tdep.c

   1 /* Target-dependent code for Solaris SPARC.
   2
   3    Copyright (C) 2003-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "frame-unwind.h"
  23 #include "gdbcore.h"
  24 #include "symtab.h"
  25 #include "objfiles.h"
  26 #include "osabi.h"
  27 #include "regcache.h"
  28 #include "regset.h"
  29 #include "target.h"
  30 #include "trad-frame.h"
  31
  32 #include "sol2-tdep.h"
  33 #include "sparc-tdep.h"
  34 #include "solib-svr4.h"
  35
  36 /* From <sys/regset.h>.  */
  37 const struct sparc_gregmap sparc32_sol2_gregmap =
  38 {
  39   32 * 4,                       /* %psr */
  40   33 * 4,                       /* %pc */
  41   34 * 4,                       /* %npc */
  42   35 * 4,                       /* %y */
  43   36 * 4,                       /* %wim */
  44   37 * 4,                       /* %tbr */
  45   1 * 4,                        /* %g1 */
  46   16 * 4,                       /* %l0 */
  47 };
  48
  49 const struct sparc_fpregmap sparc32_sol2_fpregmap =
  50 {
  51   0 * 4,                        /* %f0 */
  52   33 * 4,                       /* %fsr */
  53 };
  54
  55 static void
  56 sparc32_sol2_supply_core_gregset (const struct regset *regset,
  57                                   struct regcache *regcache,
  58                                   int regnum, const void *gregs, size_t len)
  59 {
  60   sparc32_supply_gregset (&sparc32_sol2_gregmap, regcache, regnum, gregs);
  61 }
  62
  63 static void
  64 sparc32_sol2_collect_core_gregset (const struct regset *regset,
  65                                    const struct regcache *regcache,
  66                                    int regnum, void *gregs, size_t len)
  67 {
  68   sparc32_collect_gregset (&sparc32_sol2_gregmap, regcache, regnum, gregs);
  69 }
  70
  71 static void
  72 sparc32_sol2_supply_core_fpregset (const struct regset *regset,
  73                                    struct regcache *regcache,
  74                                    int regnum, const void *fpregs, size_t len)
  75 {
  76   sparc32_supply_fpregset (&sparc32_sol2_fpregmap, regcache, regnum, fpregs);
  77 }
  78
  79 static void
  80 sparc32_sol2_collect_core_fpregset (const struct regset *regset,
  81                                     const struct regcache *regcache,
  82                                     int regnum, void *fpregs, size_t len)
  83 {
  84   sparc32_collect_fpregset (&sparc32_sol2_fpregmap, regcache, regnum, fpregs);
  85 }
  86
  87 static const struct regset sparc32_sol2_gregset =
  88   {
  89     NULL,
  90     sparc32_sol2_supply_core_gregset,
  91     sparc32_sol2_collect_core_gregset
  92   };
  93
  94 static const struct regset sparc32_sol2_fpregset =
  95   {
  96     NULL,
  97     sparc32_sol2_supply_core_fpregset,
  98     sparc32_sol2_collect_core_fpregset
  99   };
 100 \f
 101
 102 /* The Solaris signal trampolines reside in libc.  For normal signals,
 103    the function `sigacthandler' is used.  This signal trampoline will
 104    call the signal handler using the System V calling convention,
 105    where the third argument is a pointer to an instance of
 106    `ucontext_t', which has a member `uc_mcontext' that contains the
 107    saved registers.  Incidentally, the kernel passes the `ucontext_t'
 108    pointer as the third argument of the signal trampoline too, and
 109    `sigacthandler' simply passes it on.  However, if you link your
 110    program with "-L/usr/ucblib -R/usr/ucblib -lucb", the function
 111    `ucbsigvechandler' will be used, which invokes the using the BSD
 112    convention, where the third argument is a pointer to an instance of
 113    `struct sigcontext'.  It is the `ucbsigvechandler' function that
 114    converts the `ucontext_t' to a `sigcontext', and back.  Unless the
 115    signal handler modifies the `struct sigcontext' we can safely
 116    ignore this.  */
 117
 118 int
 119 sparc_sol2_pc_in_sigtramp (CORE_ADDR pc, const char *name)
 120 {
 121   return (name && (strcmp (name, "sigacthandler") == 0
 122                    || strcmp (name, "ucbsigvechandler") == 0
 123                    || strcmp (name, "__sighndlr") == 0));
 124 }
 125
 126 static struct sparc_frame_cache *
 127 sparc32_sol2_sigtramp_frame_cache (struct frame_info *this_frame,
 128                                    void **this_cache)
 129 {
 130   struct sparc_frame_cache *cache;
 131   CORE_ADDR mcontext_addr, addr;
 132   int regnum;
 133
 134   if (*this_cache)
 135     return (struct sparc_frame_cache *) *this_cache;
 136
 137   cache = sparc_frame_cache (this_frame, this_cache);
 138   gdb_assert (cache == *this_cache);
 139
 140   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 141
 142   /* The third argument is a pointer to an instance of `ucontext_t',
 143      which has a member `uc_mcontext' that contains the saved
 144      registers.  */
 145   regnum =
 146     (cache->copied_regs_mask & 0x04) ? SPARC_I2_REGNUM : SPARC_O2_REGNUM;
 147   mcontext_addr = get_frame_register_unsigned (this_frame, regnum) + 40;
 148
 149   cache->saved_regs[SPARC32_PSR_REGNUM].addr = mcontext_addr + 0 * 4;
 150   cache->saved_regs[SPARC32_PC_REGNUM].addr = mcontext_addr + 1 * 4;
 151   cache->saved_regs[SPARC32_NPC_REGNUM].addr = mcontext_addr + 2 * 4;
 152   cache->saved_regs[SPARC32_Y_REGNUM].addr = mcontext_addr + 3 * 4;
 153
 154   /* Since %g0 is always zero, keep the identity encoding.  */
 155   for (regnum = SPARC_G1_REGNUM, addr = mcontext_addr + 4 * 4;
 156        regnum <= SPARC_O7_REGNUM; regnum++, addr += 4)
 157     cache->saved_regs[regnum].addr = addr;
 158
 159   if (get_frame_memory_unsigned (this_frame, mcontext_addr + 19 * 4, 4))
 160     {
 161       /* The register windows haven't been flushed.  */
 162       for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
 163         trad_frame_set_unknown (cache->saved_regs, regnum);
 164     }
 165   else
 166     {
 167       addr = cache->saved_regs[SPARC_SP_REGNUM].addr;
 168       addr = get_frame_memory_unsigned (this_frame, addr, 4);
 169       for (regnum = SPARC_L0_REGNUM;
 170            regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
 171         cache->saved_regs[regnum].addr = addr;
 172     }
 173
 174   return cache;
 175 }
 176
 177 static void
 178 sparc32_sol2_sigtramp_frame_this_id (struct frame_info *this_frame,
 179                                      void **this_cache,
 180                                      struct frame_id *this_id)
 181 {
 182   struct sparc_frame_cache *cache =
 183     sparc32_sol2_sigtramp_frame_cache (this_frame, this_cache);
 184
 185   (*this_id) = frame_id_build (cache->base, cache->pc);
 186 }
 187
 188 static struct value *
 189 sparc32_sol2_sigtramp_frame_prev_register (struct frame_info *this_frame,
 190                                            void **this_cache,
 191                                            int regnum)
 192 {
 193   struct sparc_frame_cache *cache =
 194     sparc32_sol2_sigtramp_frame_cache (this_frame, this_cache);
 195
 196   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 197 }
 198
 199 static int
 200 sparc32_sol2_sigtramp_frame_sniffer (const struct frame_unwind *self,
 201                                      struct frame_info *this_frame,
 202                                      void **this_cache)
 203 {
 204   CORE_ADDR pc = get_frame_pc (this_frame);
 205   const char *name;
 206
 207   find_pc_partial_function (pc, &name, NULL, NULL);
 208   if (sparc_sol2_pc_in_sigtramp (pc, name))
 209     return 1;
 210
 211   return 0;
 212 }
 213
 214 static const struct frame_unwind sparc32_sol2_sigtramp_frame_unwind =
 215 {
 216   SIGTRAMP_FRAME,
 217   default_frame_unwind_stop_reason,
 218   sparc32_sol2_sigtramp_frame_this_id,
 219   sparc32_sol2_sigtramp_frame_prev_register,
 220   NULL,
 221   sparc32_sol2_sigtramp_frame_sniffer
 222 };
 223
 224 /* Unglobalize NAME.  */
 225
 226 const char *
 227 sparc_sol2_static_transform_name (const char *name)
 228 {
 229   /* The Sun compilers (Sun ONE Studio, Forte Developer, Sun WorkShop,
 230      SunPRO) convert file static variables into global values, a
 231      process known as globalization.  In order to do this, the
 232      compiler will create a unique prefix and prepend it to each file
 233      static variable.  For static variables within a function, this
 234      globalization prefix is followed by the function name (nested
 235      static variables within a function are supposed to generate a
 236      warning message, and are left alone).  The procedure is
 237      documented in the Stabs Interface Manual, which is distributed
 238      with the compilers, although version 4.0 of the manual seems to
 239      be incorrect in some places, at least for SPARC.  The
 240      globalization prefix is encoded into an N_OPT stab, with the form
 241      "G=<prefix>".  The globalization prefix always seems to start
 242      with a dollar sign '$'; a dot '.' is used as a separator.  So we
 243      simply strip everything up until the last dot.  */
 244
 245   if (name[0] == '$')
 246     {
 247       const char *p = strrchr (name, '.');
 248       if (p)
 249         return p + 1;
 250     }
 251
 252   return name;
 253 }
 254 \f
 255
 256 void
 257 sparc32_sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 258 {
 259   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 260
 261   tdep->gregset = &sparc32_sol2_gregset;
 262   tdep->sizeof_gregset = 152;
 263
 264   tdep->fpregset = &sparc32_sol2_fpregset;
 265   tdep->sizeof_fpregset = 400;
 266
 267   /* The Sun compilers (Sun ONE Studio, Forte Developer, Sun WorkShop, SunPRO)
 268      compiler puts out 0 instead of the address in N_SO stabs.  Starting with
 269      SunPRO 3.0, the compiler does this for N_FUN stabs too.  */
 270   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
 271
 272   /* The Sun compilers also do "globalization"; see the comment in
 273      sparc_sol2_static_transform_name for more information.  */
 274   set_gdbarch_static_transform_name
 275     (gdbarch, sparc_sol2_static_transform_name);
 276
 277   /* Solaris has SVR4-style shared libraries...  */
 278   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 279   set_gdbarch_skip_solib_resolver (gdbarch, sol2_skip_solib_resolver);
 280   set_solib_svr4_fetch_link_map_offsets
 281     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 282
 283   /* ...which means that we need some special handling when doing
 284      prologue analysis.  */
 285   tdep->plt_entry_size = 12;
 286
 287   /* Solaris has kernel-assisted single-stepping support.  */
 288   set_gdbarch_software_single_step (gdbarch, NULL);
 289
 290   frame_unwind_append_unwinder (gdbarch, &sparc32_sol2_sigtramp_frame_unwind);
 291
 292   /* How to print LWP PTIDs from core files.  */
 293   set_gdbarch_core_pid_to_str (gdbarch, sol2_core_pid_to_str);
 294 }
 295
 296 void _initialize_sparc_sol2_tdep ();
 297 void
 298 _initialize_sparc_sol2_tdep ()
 299 {
 300   gdbarch_register_osabi (bfd_arch_sparc, 0,
 301                           GDB_OSABI_SOLARIS, sparc32_sol2_init_abi);
 302 }