gdb/sparc64obsd-tdep.c

   1 /* Target-dependent code for OpenBSD/sparc64.
   2
   3    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, 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 "osabi.h"
  26 #include "regcache.h"
  27 #include "regset.h"
  28 #include "symtab.h"
  29 #include "objfiles.h"
  30 #include "trad-frame.h"
  31
  32 #include "gdb_assert.h"
  33
  34 #include "obsd-tdep.h"
  35 #include "sparc64-tdep.h"
  36 #include "solib-svr4.h"
  37 #include "bsd-uthread.h"
  38
  39 /* OpenBSD uses the traditional NetBSD core file format, even for
  40    ports that use ELF.  The core files don't use multiple register
  41    sets.  Instead, the general-purpose and floating-point registers
  42    are lumped together in a single section.  Unlike on NetBSD, OpenBSD
  43    uses a different layout for its general-purpose registers than the
  44    layout used for ptrace(2).  */
  45
  46 /* From <machine/reg.h>.  */
  47 const struct sparc_gregset sparc64obsd_core_gregset =
  48 {
  49   0 * 8,                        /* "tstate" */
  50   1 * 8,                        /* %pc */
  51   2 * 8,                        /* %npc */
  52   3 * 8,                        /* %y */
  53   -1,                           /* %fprs */
  54   -1,
  55   7 * 8,                        /* %g1 */
  56   22 * 8,                       /* %l0 */
  57   4                             /* sizeof (%y) */
  58 };
  59
  60 static void
  61 sparc64obsd_supply_gregset (const struct regset *regset,
  62                             struct regcache *regcache,
  63                             int regnum, const void *gregs, size_t len)
  64 {
  65   const char *regs = gregs;
  66
  67   sparc64_supply_gregset (&sparc64obsd_core_gregset, regcache, regnum, regs);
  68   sparc64_supply_fpregset (regcache, regnum, regs + 288);
  69 }
  70 \f
  71
  72 /* Signal trampolines.  */
  73
  74 /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
  75    in virtual memory.  The randomness makes it somewhat tricky to
  76    detect it, but fortunately we can rely on the fact that the start
  77    of the sigtramp routine is page-aligned.  We recognize the
  78    trampoline by looking for the code that invokes the sigreturn
  79    system call.  The offset where we can find that code varies from
  80    release to release.
  81
  82    By the way, the mapping mentioned above is read-only, so you cannot
  83    place a breakpoint in the signal trampoline.  */
  84
  85 /* Default page size.  */
  86 static const int sparc64obsd_page_size = 8192;
  87
  88 /* Offset for sigreturn(2).  */
  89 static const int sparc64obsd_sigreturn_offset[] = {
  90   0xf0,                         /* OpenBSD 3.8 */
  91   0xec,                         /* OpenBSD 3.6 */
  92   0xe8,                         /* OpenBSD 3.2 */
  93   -1
  94 };
  95
  96 static int
  97 sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name)
  98 {
  99   CORE_ADDR start_pc = (pc & ~(sparc64obsd_page_size - 1));
 100   unsigned long insn;
 101   const int *offset;
 102
 103   if (name)
 104     return 0;
 105
 106   for (offset = sparc64obsd_sigreturn_offset; *offset != -1; offset++)
 107     {
 108       /* Check for "restore %g0, SYS_sigreturn, %g1".  */
 109       insn = sparc_fetch_instruction (start_pc + *offset);
 110       if (insn != 0x83e82067)
 111         continue;
 112
 113       /* Check for "t ST_SYSCALL".  */
 114       insn = sparc_fetch_instruction (start_pc + *offset + 8);
 115       if (insn != 0x91d02000)
 116         continue;
 117
 118       return 1;
 119     }
 120
 121   return 0;
 122 }
 123
 124 static struct sparc_frame_cache *
 125 sparc64obsd_frame_cache (struct frame_info *this_frame, void **this_cache)
 126 {
 127   struct sparc_frame_cache *cache;
 128   CORE_ADDR addr;
 129
 130   if (*this_cache)
 131     return *this_cache;
 132
 133   cache = sparc_frame_cache (this_frame, this_cache);
 134   gdb_assert (cache == *this_cache);
 135
 136   /* If we couldn't find the frame's function, we're probably dealing
 137      with an on-stack signal trampoline.  */
 138   if (cache->pc == 0)
 139     {
 140       cache->pc = get_frame_pc (this_frame);
 141       cache->pc &= ~(sparc64obsd_page_size - 1);
 142
 143       /* Since we couldn't find the frame's function, the cache was
 144          initialized under the assumption that we're frameless.  */
 145       cache->frameless_p = 0;
 146       addr = get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
 147       if (addr & 1)
 148         addr += BIAS;
 149       cache->base = addr;
 150     }
 151
 152   /* We find the appropriate instance of `struct sigcontext' at a
 153      fixed offset in the signal frame.  */
 154   addr = cache->base + 128 + 16;
 155   cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, this_frame);
 156
 157   return cache;
 158 }
 159
 160 static void
 161 sparc64obsd_frame_this_id (struct frame_info *this_frame, void **this_cache,
 162                            struct frame_id *this_id)
 163 {
 164   struct sparc_frame_cache *cache =
 165     sparc64obsd_frame_cache (this_frame, this_cache);
 166
 167   (*this_id) = frame_id_build (cache->base, cache->pc);
 168 }
 169
 170 static struct value *
 171 sparc64obsd_frame_prev_register (struct frame_info *this_frame,
 172                                  void **this_cache, int regnum)
 173 {
 174   struct sparc_frame_cache *cache =
 175     sparc64obsd_frame_cache (this_frame, this_cache);
 176
 177   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 178 }
 179
 180 static int
 181 sparc64obsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
 182                                     struct frame_info *this_frame,
 183                                     void **this_cache)
 184 {
 185   CORE_ADDR pc = get_frame_pc (this_frame);
 186   char *name;
 187
 188   find_pc_partial_function (pc, &name, NULL, NULL);
 189   if (sparc64obsd_pc_in_sigtramp (pc, name))
 190     return 1;
 191
 192   return 0;
 193 }
 194
 195 static const struct frame_unwind sparc64obsd_frame_unwind =
 196 {
 197   SIGTRAMP_FRAME,
 198   sparc64obsd_frame_this_id,
 199   sparc64obsd_frame_prev_register,
 200   NULL,
 201   sparc64obsd_sigtramp_frame_sniffer
 202 };
 203 \f
 204 /* Kernel debugging support.  */
 205
 206 static struct sparc_frame_cache *
 207 sparc64obsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
 208 {
 209   struct sparc_frame_cache *cache;
 210   CORE_ADDR sp, trapframe_addr;
 211   int regnum;
 212
 213   if (*this_cache)
 214     return *this_cache;
 215
 216   cache = sparc_frame_cache (this_frame, this_cache);
 217   gdb_assert (cache == *this_cache);
 218
 219   sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
 220   trapframe_addr = sp + BIAS + 176;
 221
 222   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 223
 224   cache->saved_regs[SPARC64_STATE_REGNUM].addr = trapframe_addr;
 225   cache->saved_regs[SPARC64_PC_REGNUM].addr = trapframe_addr + 8;
 226   cache->saved_regs[SPARC64_NPC_REGNUM].addr = trapframe_addr + 16;
 227
 228   for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
 229     cache->saved_regs[regnum].addr =
 230       trapframe_addr + 48 + (regnum - SPARC_G0_REGNUM) * 8;
 231
 232   return cache;
 233 }
 234
 235 static void
 236 sparc64obsd_trapframe_this_id (struct frame_info *this_frame,
 237                                void **this_cache, struct frame_id *this_id)
 238 {
 239   struct sparc_frame_cache *cache =
 240     sparc64obsd_trapframe_cache (this_frame, this_cache);
 241
 242   (*this_id) = frame_id_build (cache->base, cache->pc);
 243 }
 244
 245 static struct value *
 246 sparc64obsd_trapframe_prev_register (struct frame_info *this_frame,
 247                                      void **this_cache, int regnum)
 248 {
 249   struct sparc_frame_cache *cache =
 250     sparc64obsd_trapframe_cache (this_frame, this_cache);
 251
 252   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 253 }
 254
 255 static int
 256 sparc64obsd_trapframe_sniffer (const struct frame_unwind *self,
 257                                struct frame_info *this_frame,
 258                                void **this_cache)
 259 {
 260   CORE_ADDR pc;
 261   ULONGEST pstate;
 262   char *name;
 263
 264   /* Check whether we are in privileged mode, and bail out if we're not.  */
 265   pstate = get_frame_register_unsigned (this_frame, SPARC64_PSTATE_REGNUM);
 266   if ((pstate & SPARC64_PSTATE_PRIV) == 0)
 267     return 0;
 268
 269   pc = get_frame_address_in_block (this_frame);
 270   find_pc_partial_function (pc, &name, NULL, NULL);
 271   if (name && strcmp (name, "Lslowtrap_reenter") == 0)
 272     return 1;
 273
 274   return 0;
 275 }
 276
 277 static const struct frame_unwind sparc64obsd_trapframe_unwind =
 278 {
 279   NORMAL_FRAME,
 280   sparc64obsd_trapframe_this_id,
 281   sparc64obsd_trapframe_prev_register,
 282   NULL,
 283   sparc64obsd_trapframe_sniffer
 284 };
 285 \f
 286
 287 /* Threads support.  */
 288
 289 /* Offset wthin the thread structure where we can find %fp and %i7.  */
 290 #define SPARC64OBSD_UTHREAD_FP_OFFSET   232
 291 #define SPARC64OBSD_UTHREAD_PC_OFFSET   240
 292
 293 static void
 294 sparc64obsd_supply_uthread (struct regcache *regcache,
 295                             int regnum, CORE_ADDR addr)
 296 {
 297   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 298   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 299   CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
 300   gdb_byte buf[8];
 301
 302   gdb_assert (regnum >= -1);
 303
 304   fp = read_memory_unsigned_integer (fp_addr, 8, byte_order);
 305   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 306     {
 307       store_unsigned_integer (buf, 8, byte_order, fp);
 308       regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
 309
 310       if (regnum == SPARC_SP_REGNUM)
 311         return;
 312     }
 313
 314   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM
 315       || regnum == -1)
 316     {
 317       CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
 318
 319       i7 = read_memory_unsigned_integer (i7_addr, 8, byte_order);
 320       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
 321         {
 322           store_unsigned_integer (buf, 8, byte_order, i7 + 8);
 323           regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
 324         }
 325       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
 326         {
 327           store_unsigned_integer (buf, 8, byte_order, i7 + 12);
 328           regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf);
 329         }
 330
 331       if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
 332         return;
 333     }
 334
 335   sparc_supply_rwindow (regcache, fp, regnum);
 336 }
 337
 338 static void
 339 sparc64obsd_collect_uthread(const struct regcache *regcache,
 340                             int regnum, CORE_ADDR addr)
 341 {
 342   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 343   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 344   CORE_ADDR sp;
 345   gdb_byte buf[8];
 346
 347   gdb_assert (regnum >= -1);
 348
 349   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 350     {
 351       CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
 352
 353       regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 354       write_memory (fp_addr,buf, 8);
 355     }
 356
 357   if (regnum == SPARC64_PC_REGNUM || regnum == -1)
 358     {
 359       CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
 360
 361       regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf);
 362       i7 = extract_unsigned_integer (buf, 8, byte_order) - 8;
 363       write_memory_unsigned_integer (i7_addr, 8, byte_order, i7);
 364
 365       if (regnum == SPARC64_PC_REGNUM)
 366         return;
 367     }
 368
 369   regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 370   sp = extract_unsigned_integer (buf, 8, byte_order);
 371   sparc_collect_rwindow (regcache, sp, regnum);
 372 }
 373 \f
 374
 375 static void
 376 sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 377 {
 378   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 379
 380   tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
 381   tdep->sizeof_gregset = 832;
 382
 383   /* Make sure we can single-step "new" syscalls.  */
 384   tdep->step_trap = sparcnbsd_step_trap;
 385
 386   frame_unwind_append_unwinder (gdbarch, &sparc64obsd_frame_unwind);
 387   frame_unwind_append_unwinder (gdbarch, &sparc64obsd_trapframe_unwind);
 388
 389   sparc64_init_abi (info, gdbarch);
 390
 391   /* OpenBSD/sparc64 has SVR4-style shared libraries.  */
 392   set_solib_svr4_fetch_link_map_offsets
 393     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 394   set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver);
 395
 396   /* OpenBSD provides a user-level threads implementation.  */
 397   bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread);
 398   bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread);
 399 }
 400 \f
 401
 402 /* Provide a prototype to silence -Wmissing-prototypes.  */
 403 void _initialize_sparc64obsd_tdep (void);
 404
 405 void
 406 _initialize_sparc64obsd_tdep (void)
 407 {
 408   gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
 409                           GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
 410 }