gdb/sparcobsd-tdep.c

   1 /* Target-dependent code for OpenBSD/sparc.
   2
   3    Copyright (C) 2004-2013 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 "floatformat.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "gdbcore.h"
  25 #include "osabi.h"
  26 #include "regcache.h"
  27 #include "symtab.h"
  28 #include "trad-frame.h"
  29
  30 #include "gdb_assert.h"
  31
  32 #include "obsd-tdep.h"
  33 #include "sparc-tdep.h"
  34 #include "solib-svr4.h"
  35 #include "bsd-uthread.h"
  36
  37 /* Signal trampolines.  */
  38
  39 /* The OpenBSD kernel maps the signal trampoline at some random
  40    location in user space, which means that the traditional BSD way of
  41    detecting it won't work.
  42
  43    The signal trampoline will be mapped at an address that is page
  44    aligned.  We recognize the signal trampoline by looking for the
  45    sigreturn system call.  */
  46
  47 static const int sparc32obsd_page_size = 4096;
  48
  49 static int
  50 sparc32obsd_pc_in_sigtramp (CORE_ADDR pc, const char *name)
  51 {
  52   CORE_ADDR start_pc = (pc & ~(sparc32obsd_page_size - 1));
  53   unsigned long insn;
  54
  55   if (name)
  56     return 0;
  57
  58   /* Check for "restore %g0, SYS_sigreturn, %g1".  */
  59   insn = sparc_fetch_instruction (start_pc + 0xec);
  60   if (insn != 0x83e82067)
  61     return 0;
  62
  63   /* Check for "t ST_SYSCALL".  */
  64   insn = sparc_fetch_instruction (start_pc + 0xf4);
  65   if (insn != 0x91d02000)
  66     return 0;
  67
  68   return 1;
  69 }
  70
  71 static struct sparc_frame_cache *
  72 sparc32obsd_sigtramp_frame_cache (struct frame_info *this_frame,
  73                                   void **this_cache)
  74 {
  75   struct sparc_frame_cache *cache;
  76   CORE_ADDR addr;
  77
  78   if (*this_cache)
  79     return *this_cache;
  80
  81   cache = sparc_frame_cache (this_frame, this_cache);
  82   gdb_assert (cache == *this_cache);
  83
  84   /* If we couldn't find the frame's function, we're probably dealing
  85      with an on-stack signal trampoline.  */
  86   if (cache->pc == 0)
  87     {
  88       cache->pc = get_frame_pc (this_frame);
  89       cache->pc &= ~(sparc32obsd_page_size - 1);
  90
  91       /* Since we couldn't find the frame's function, the cache was
  92          initialized under the assumption that we're frameless.  */
  93       sparc_record_save_insn (cache);
  94       addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
  95       cache->base = addr;
  96     }
  97
  98   cache->saved_regs = sparc32nbsd_sigcontext_saved_regs (this_frame);
  99
 100   return cache;
 101 }
 102
 103 static void
 104 sparc32obsd_sigtramp_frame_this_id (struct frame_info *this_frame,
 105                                     void **this_cache,
 106                                     struct frame_id *this_id)
 107 {
 108   struct sparc_frame_cache *cache =
 109     sparc32obsd_sigtramp_frame_cache (this_frame, this_cache);
 110
 111   (*this_id) = frame_id_build (cache->base, cache->pc);
 112 }
 113
 114 static struct value *
 115 sparc32obsd_sigtramp_frame_prev_register (struct frame_info *this_frame,
 116                                           void **this_cache, int regnum)
 117 {
 118   struct sparc_frame_cache *cache =
 119     sparc32obsd_sigtramp_frame_cache (this_frame, this_cache);
 120
 121   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 122 }
 123
 124 static int
 125 sparc32obsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
 126                                     struct frame_info *this_frame,
 127                                     void **this_cache)
 128 {
 129   CORE_ADDR pc = get_frame_pc (this_frame);
 130   const char *name;
 131
 132   find_pc_partial_function (pc, &name, NULL, NULL);
 133   if (sparc32obsd_pc_in_sigtramp (pc, name))
 134     return 1;
 135
 136   return 0;
 137 }
 138 static const struct frame_unwind sparc32obsd_sigtramp_frame_unwind =
 139 {
 140   SIGTRAMP_FRAME,
 141   default_frame_unwind_stop_reason,
 142   sparc32obsd_sigtramp_frame_this_id,
 143   sparc32obsd_sigtramp_frame_prev_register,
 144   NULL,
 145   sparc32obsd_sigtramp_frame_sniffer
 146 };
 147
 148 \f
 149
 150 /* Offset wthin the thread structure where we can find %fp and %i7.  */
 151 #define SPARC32OBSD_UTHREAD_FP_OFFSET   128
 152 #define SPARC32OBSD_UTHREAD_PC_OFFSET   132
 153
 154 static void
 155 sparc32obsd_supply_uthread (struct regcache *regcache,
 156                             int regnum, CORE_ADDR addr)
 157 {
 158   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 159   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 160   CORE_ADDR fp, fp_addr = addr + SPARC32OBSD_UTHREAD_FP_OFFSET;
 161   gdb_byte buf[4];
 162
 163   gdb_assert (regnum >= -1);
 164
 165   fp = read_memory_unsigned_integer (fp_addr, 4, byte_order);
 166   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 167     {
 168       store_unsigned_integer (buf, 4, byte_order, fp);
 169       regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
 170
 171       if (regnum == SPARC_SP_REGNUM)
 172         return;
 173     }
 174
 175   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM
 176       || regnum == -1)
 177     {
 178       CORE_ADDR i7, i7_addr = addr + SPARC32OBSD_UTHREAD_PC_OFFSET;
 179
 180       i7 = read_memory_unsigned_integer (i7_addr, 4, byte_order);
 181       if (regnum == SPARC32_PC_REGNUM || regnum == -1)
 182         {
 183           store_unsigned_integer (buf, 4, byte_order, i7 + 8);
 184           regcache_raw_supply (regcache, SPARC32_PC_REGNUM, buf);
 185         }
 186       if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
 187         {
 188           store_unsigned_integer (buf, 4, byte_order, i7 + 12);
 189           regcache_raw_supply (regcache, SPARC32_NPC_REGNUM, buf);
 190         }
 191
 192       if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
 193         return;
 194     }
 195
 196   sparc_supply_rwindow (regcache, fp, regnum);
 197 }
 198
 199 static void
 200 sparc32obsd_collect_uthread(const struct regcache *regcache,
 201                             int regnum, CORE_ADDR addr)
 202 {
 203   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 204   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 205   CORE_ADDR sp;
 206   gdb_byte buf[4];
 207
 208   gdb_assert (regnum >= -1);
 209
 210   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 211     {
 212       CORE_ADDR fp_addr = addr + SPARC32OBSD_UTHREAD_FP_OFFSET;
 213
 214       regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 215       write_memory (fp_addr,buf, 4);
 216     }
 217
 218   if (regnum == SPARC32_PC_REGNUM || regnum == -1)
 219     {
 220       CORE_ADDR i7, i7_addr = addr + SPARC32OBSD_UTHREAD_PC_OFFSET;
 221
 222       regcache_raw_collect (regcache, SPARC32_PC_REGNUM, buf);
 223       i7 = extract_unsigned_integer (buf, 4, byte_order) - 8;
 224       write_memory_unsigned_integer (i7_addr, 4, byte_order, i7);
 225
 226       if (regnum == SPARC32_PC_REGNUM)
 227         return;
 228     }
 229
 230   regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 231   sp = extract_unsigned_integer (buf, 4, byte_order);
 232   sparc_collect_rwindow (regcache, sp, regnum);
 233 }
 234 \f
 235
 236 static void
 237 sparc32obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 238 {
 239   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 240
 241   /* OpenBSD/sparc is very similar to NetBSD/sparc ELF.  */
 242   sparc32nbsd_elf_init_abi (info, gdbarch);
 243
 244   set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver);
 245
 246   frame_unwind_append_unwinder (gdbarch, &sparc32obsd_sigtramp_frame_unwind);
 247
 248   /* OpenBSD provides a user-level threads implementation.  */
 249   bsd_uthread_set_supply_uthread (gdbarch, sparc32obsd_supply_uthread);
 250   bsd_uthread_set_collect_uthread (gdbarch, sparc32obsd_collect_uthread);
 251 }
 252
 253 \f
 254 /* Provide a prototype to silence -Wmissing-prototypes.  */
 255 void _initialize_sparc32obsd_tdep (void);
 256
 257 void
 258 _initialize_sparc32obsd_tdep (void)
 259 {
 260   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_OPENBSD_ELF,
 261                           sparc32obsd_init_abi);
 262 }