gdb/sparc64obsd-tdep.c

   1 /* Target-dependent code for OpenBSD/sparc64.
   2
   3    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
   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   CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
 298   gdb_byte buf[8];
 299
 300   gdb_assert (regnum >= -1);
 301
 302   fp = read_memory_unsigned_integer (fp_addr, 8);
 303   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 304     {
 305       store_unsigned_integer (buf, 8, fp);
 306       regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf);
 307
 308       if (regnum == SPARC_SP_REGNUM)
 309         return;
 310     }
 311
 312   if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM
 313       || regnum == -1)
 314     {
 315       CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
 316
 317       i7 = read_memory_unsigned_integer (i7_addr, 8);
 318       if (regnum == SPARC64_PC_REGNUM || regnum == -1)
 319         {
 320           store_unsigned_integer (buf, 8, i7 + 8);
 321           regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf);
 322         }
 323       if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
 324         {
 325           store_unsigned_integer (buf, 8, i7 + 12);
 326           regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf);
 327         }
 328
 329       if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
 330         return;
 331     }
 332
 333   sparc_supply_rwindow (regcache, fp, regnum);
 334 }
 335
 336 static void
 337 sparc64obsd_collect_uthread(const struct regcache *regcache,
 338                             int regnum, CORE_ADDR addr)
 339 {
 340   CORE_ADDR sp;
 341   gdb_byte buf[8];
 342
 343   gdb_assert (regnum >= -1);
 344
 345   if (regnum == SPARC_SP_REGNUM || regnum == -1)
 346     {
 347       CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;
 348
 349       regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 350       write_memory (fp_addr,buf, 8);
 351     }
 352
 353   if (regnum == SPARC64_PC_REGNUM || regnum == -1)
 354     {
 355       CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;
 356
 357       regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf);
 358       i7 = extract_unsigned_integer (buf, 8) - 8;
 359       write_memory_unsigned_integer (i7_addr, 8, i7);
 360
 361       if (regnum == SPARC64_PC_REGNUM)
 362         return;
 363     }
 364
 365   regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);
 366   sp = extract_unsigned_integer (buf, 8);
 367   sparc_collect_rwindow (regcache, sp, regnum);
 368 }
 369 \f
 370
 371 static void
 372 sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 373 {
 374   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 375
 376   tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL);
 377   tdep->sizeof_gregset = 832;
 378
 379   /* Make sure we can single-step "new" syscalls.  */
 380   tdep->step_trap = sparcnbsd_step_trap;
 381
 382   frame_unwind_append_unwinder (gdbarch, &sparc64obsd_frame_unwind);
 383   frame_unwind_append_unwinder (gdbarch, &sparc64obsd_trapframe_unwind);
 384
 385   sparc64_init_abi (info, gdbarch);
 386
 387   /* OpenBSD/sparc64 has SVR4-style shared libraries.  */
 388   set_solib_svr4_fetch_link_map_offsets
 389     (gdbarch, svr4_lp64_fetch_link_map_offsets);
 390   set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver);
 391
 392   /* OpenBSD provides a user-level threads implementation.  */
 393   bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread);
 394   bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread);
 395 }
 396 \f
 397
 398 /* Provide a prototype to silence -Wmissing-prototypes.  */
 399 void _initialize_sparc64obsd_tdep (void);
 400
 401 void
 402 _initialize_sparc64obsd_tdep (void)
 403 {
 404   gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
 405                           GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi);
 406 }