gdb/sparc-sol2-tdep.c - gdb

Global variables defined

Functions defined

Source code

  1. /* Target-dependent code for Solaris SPARC.

  3.    Copyright (C) 2003-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  32. #include "sol2-tdep.h"
  33. #include "sparc-tdep.h"
  34. #include "solib-svr4.h"

  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. };

  49. ‌const struct sparc_fpregmap sparc32_sol2_fpregmap =
  50. {
  51.   0 * 4,                        /* %f0 */
  52.   33 * 4,                        /* %fsr */
  53. };

  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. }

  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. }

  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. }

  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. }

  87. ‌static const struct regset sparc32_sol2_gregset =
  88.   {
  89.     NULL,
  90.     sparc32_sol2_supply_core_gregset,
  91.     sparc32_sol2_collect_core_gregset
  92.   };

  94. ‌static const struct regset sparc32_sol2_fpregset =
  95.   {
  96.     NULL,
  97.     sparc32_sol2_supply_core_fpregset,
  98.     sparc32_sol2_collect_core_fpregset
  99.   };


  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.  */

  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. }

  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;

  134.   if (*this_cache)
  135.     return *this_cache;

  137.   cache = sparc_frame_cache (this_frame, this_cache);
  138.   gdb_assert (cache == *this_cache);

  140.   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);

  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;

  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;

  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;

  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.     }

  174.   return cache;
  175. }

  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);

  185.   (*this_id) = frame_id_build (cache->base, cache->pc);
  186. }

  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);

  196.   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
  197. }

  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;

  207.   find_pc_partial_function (pc, &name, NULL, NULL);
  208.   if (sparc_sol2_pc_in_sigtramp (pc, name))
  209.     return 1;

  211.   return 0;
  212. }

  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. };

  224. /* Unglobalize NAME.  */

  226. const 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 distrubuted
  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 seperator.  So we
  243.      simply strip everything up until the last dot.  */

  245.   if (name[0] == '$')
  246.     {
  247.       char *p = strrchr (name, '.');
  248.       if (p)
  249.         return p + 1;
  250.     }

  252.   return name;
  253. }


  256. void
  257. ‌sparc32_sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
  258. {
  259.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  261.   tdep->gregset = &sparc32_sol2_gregset;
  262.   tdep->sizeof_gregset = 152;

  264.   tdep->fpregset = &sparc32_sol2_fpregset;
  265.   tdep->sizeof_fpregset = 400;

  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);

  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);

  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);

  283.   /* ...which means that we need some special handling when doing
  284.      prologue analysis.  */
  285.   tdep->plt_entry_size = 12;

  287.   /* Solaris has kernel-assisted single-stepping support.  */
  288.   set_gdbarch_software_single_step (gdbarch, NULL);

  290.   frame_unwind_append_unwinder (gdbarch, &sparc32_sol2_sigtramp_frame_unwind);

  292.   /* How to print LWP PTIDs from core files.  */
  293.   set_gdbarch_core_pid_to_str (gdbarch, sol2_core_pid_to_str);
  294. }


  297. /* Provide a prototype to silence -Wmissing-prototypes.  */
  298. void _initialize_sparc_sol2_tdep (void);

  300. void
  301. ‌_initialize_sparc_sol2_tdep (void)
  302. {
  303.   gdbarch_register_osabi (bfd_arch_sparc, 0,
  304.                           GDB_OSABI_SOLARIS, sparc32_sol2_init_abi);
  305. }