gdb/ppcobsd-tdep.c

   1 /* Target-dependent code for OpenBSD/powerpc.
   2
   3    Copyright (C) 2004, 2005, 2006 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 2 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, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "floatformat.h"
  25 #include "frame.h"
  26 #include "frame-unwind.h"
  27 #include "osabi.h"
  28 #include "regcache.h"
  29 #include "regset.h"
  30 #include "symtab.h"
  31 #include "trad-frame.h"
  32
  33 #include "gdb_assert.h"
  34 #include "gdb_string.h"
  35
  36 #include "ppc-tdep.h"
  37 #include "ppcobsd-tdep.h"
  38 #include "solib-svr4.h"
  39
  40 /* Register offsets from <machine/reg.h>.  */
  41 struct ppc_reg_offsets ppcobsd_reg_offsets;
  42 struct ppc_reg_offsets ppcobsd_fpreg_offsets;
  43 \f
  44
  45 /* Core file support.  */
  46
  47 /* Supply register REGNUM in the general-purpose register set REGSET
  48    from the buffer specified by GREGS and LEN to register cache
  49    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  50
  51 void
  52 ppcobsd_supply_gregset (const struct regset *regset,
  53                         struct regcache *regcache, int regnum,
  54                         const void *gregs, size_t len)
  55 {
  56   /* FIXME: jimb/2004-05-05: Some PPC variants don't have floating
  57      point registers.  Traditionally, GDB's register set has still
  58      listed the floating point registers for such machines, so this
  59      code is harmless.  However, the new E500 port actually omits the
  60      floating point registers entirely from the register set --- they
  61      don't even have register numbers assigned to them.
  62
  63      It's not clear to me how best to update this code, so this assert
  64      will alert the first person to encounter the OpenBSD/E500
  65      combination to the problem.  */
  66   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
  67
  68   ppc_supply_gregset (regset, regcache, regnum, gregs, len);
  69   ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
  70 }
  71
  72 /* Collect register REGNUM in the general-purpose register set
  73    REGSET. from register cache REGCACHE into the buffer specified by
  74    GREGS and LEN.  If REGNUM is -1, do this for all registers in
  75    REGSET.  */
  76
  77 void
  78 ppcobsd_collect_gregset (const struct regset *regset,
  79                          const struct regcache *regcache, int regnum,
  80                          void *gregs, size_t len)
  81 {
  82   /* FIXME: jimb/2004-05-05: Some PPC variants don't have floating
  83      point registers.  Traditionally, GDB's register set has still
  84      listed the floating point registers for such machines, so this
  85      code is harmless.  However, the new E500 port actually omits the
  86      floating point registers entirely from the register set --- they
  87      don't even have register numbers assigned to them.
  88
  89      It's not clear to me how best to update this code, so this assert
  90      will alert the first person to encounter the OpenBSD/E500
  91      combination to the problem.  */
  92   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
  93
  94   ppc_collect_gregset (regset, regcache, regnum, gregs, len);
  95   ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
  96 }
  97
  98 /* OpenBSD/powerpc register set.  */
  99
 100 struct regset ppcobsd_gregset =
 101 {
 102   &ppcobsd_reg_offsets,
 103   ppcobsd_supply_gregset
 104 };
 105
 106 struct regset ppcobsd_fpregset =
 107 {
 108   &ppcobsd_fpreg_offsets,
 109   ppc_supply_fpregset
 110 };
 111
 112 /* Return the appropriate register set for the core section identified
 113    by SECT_NAME and SECT_SIZE.  */
 114
 115 static const struct regset *
 116 ppcobsd_regset_from_core_section (struct gdbarch *gdbarch,
 117                                   const char *sect_name, size_t sect_size)
 118 {
 119   if (strcmp (sect_name, ".reg") == 0 && sect_size >= 412)
 120     return &ppcobsd_gregset;
 121
 122   return NULL;
 123 }
 124 \f
 125
 126 /* Signal trampolines.  */
 127
 128 /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
 129    in virtual memory.  The randomness makes it somewhat tricky to
 130    detect it, but fortunately we can rely on the fact that the start
 131    of the sigtramp routine is page-aligned.  We recognize the
 132    trampoline by looking for the code that invokes the sigreturn
 133    system call.  The offset where we can find that code varies from
 134    release to release.
 135
 136    By the way, the mapping mentioned above is read-only, so you cannot
 137    place a breakpoint in the signal trampoline.  */
 138
 139 /* Default page size.  */
 140 static const int ppcobsd_page_size = 4096;
 141
 142 /* Offset for sigreturn(2).  */
 143 static const int ppcobsd_sigreturn_offset[] = {
 144   0x98,                         /* OpenBSD 3.8 */
 145   0x0c,                         /* OpenBSD 3.2 */
 146   -1
 147 };
 148
 149 static int
 150 ppcobsd_sigtramp_p (struct frame_info *next_frame)
 151 {
 152   CORE_ADDR pc = frame_pc_unwind (next_frame);
 153   CORE_ADDR start_pc = (pc & ~(ppcobsd_page_size - 1));
 154   const int *offset;
 155   char *name;
 156
 157   find_pc_partial_function (pc, &name, NULL, NULL);
 158   if (name)
 159     return 0;
 160
 161   for (offset = ppcobsd_sigreturn_offset; *offset != -1; offset++)
 162     {
 163       gdb_byte buf[2 * PPC_INSN_SIZE];
 164       unsigned long insn;
 165
 166       if (!safe_frame_unwind_memory (next_frame, start_pc + *offset,
 167                                      buf, sizeof buf))
 168         continue;
 169
 170       /* Check for "li r0,SYS_sigreturn".  */
 171       insn = extract_unsigned_integer (buf, PPC_INSN_SIZE);
 172       if (insn != 0x38000067)
 173         continue;
 174
 175       /* Check for "sc".  */
 176       insn = extract_unsigned_integer (buf + PPC_INSN_SIZE, PPC_INSN_SIZE);
 177       if (insn != 0x44000002)
 178         continue;
 179
 180       return 1;
 181     }
 182
 183   return 0;
 184 }
 185
 186 static struct trad_frame_cache *
 187 ppcobsd_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache)
 188 {
 189   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 190   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 191   struct trad_frame_cache *cache;
 192   CORE_ADDR addr, base, func;
 193   gdb_byte buf[PPC_INSN_SIZE];
 194   unsigned long insn, sigcontext_offset;
 195   int i;
 196
 197   if (*this_cache)
 198     return *this_cache;
 199
 200   cache = trad_frame_cache_zalloc (next_frame);
 201   *this_cache = cache;
 202
 203   func = frame_pc_unwind (next_frame);
 204   func &= ~(ppcobsd_page_size - 1);
 205   if (!safe_frame_unwind_memory (next_frame, func, buf, sizeof buf))
 206     return cache;
 207
 208   /* Calculate the offset where we can find `struct sigcontext'.  We
 209      base our calculation on the amount of stack space reserved by the
 210      first instruction of the signal trampoline.  */
 211   insn = extract_unsigned_integer (buf, PPC_INSN_SIZE);
 212   sigcontext_offset = (0x10000 - (insn & 0x0000ffff)) + 8;
 213
 214   base = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
 215   addr = base + sigcontext_offset + 2 * tdep->wordsize;
 216   for (i = 0; i < ppc_num_gprs; i++, addr += tdep->wordsize)
 217     {
 218       int regnum = i + tdep->ppc_gp0_regnum;
 219       trad_frame_set_reg_addr (cache, regnum, addr);
 220     }
 221   trad_frame_set_reg_addr (cache, tdep->ppc_lr_regnum, addr);
 222   addr += tdep->wordsize;
 223   trad_frame_set_reg_addr (cache, tdep->ppc_cr_regnum, addr);
 224   addr += tdep->wordsize;
 225   trad_frame_set_reg_addr (cache, tdep->ppc_xer_regnum, addr);
 226   addr += tdep->wordsize;
 227   trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, addr);
 228   addr += tdep->wordsize;
 229   trad_frame_set_reg_addr (cache, PC_REGNUM, addr); /* SRR0? */
 230   addr += tdep->wordsize;
 231
 232   /* Construct the frame ID using the function start.  */
 233   trad_frame_set_id (cache, frame_id_build (base, func));
 234
 235   return cache;
 236 }
 237
 238 static void
 239 ppcobsd_sigtramp_frame_this_id (struct frame_info *next_frame,
 240                                 void **this_cache, struct frame_id *this_id)
 241 {
 242   struct trad_frame_cache *cache =
 243     ppcobsd_sigtramp_frame_cache (next_frame, this_cache);
 244
 245   trad_frame_get_id (cache, this_id);
 246 }
 247
 248 static void
 249 ppcobsd_sigtramp_frame_prev_register (struct frame_info *next_frame,
 250                                       void **this_cache, int regnum,
 251                                       int *optimizedp, enum lval_type *lvalp,
 252                                       CORE_ADDR *addrp, int *realnump,
 253                                       gdb_byte *valuep)
 254 {
 255   struct trad_frame_cache *cache =
 256     ppcobsd_sigtramp_frame_cache (next_frame, this_cache);
 257
 258   trad_frame_get_register (cache, next_frame, regnum,
 259                            optimizedp, lvalp, addrp, realnump, valuep);
 260 }
 261
 262 static const struct frame_unwind ppcobsd_sigtramp_frame_unwind = {
 263   SIGTRAMP_FRAME,
 264   ppcobsd_sigtramp_frame_this_id,
 265   ppcobsd_sigtramp_frame_prev_register
 266 };
 267
 268 static const struct frame_unwind *
 269 ppcobsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
 270 {
 271   if (ppcobsd_sigtramp_p (next_frame))
 272     return &ppcobsd_sigtramp_frame_unwind;
 273
 274   return NULL;
 275 }
 276 \f
 277
 278 static void
 279 ppcobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 280 {
 281   /* OpenBSD doesn't support the 128-bit `long double' from the psABI.  */
 282   set_gdbarch_long_double_bit (gdbarch, 64);
 283   set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
 284
 285   /* OpenBSD currently uses a broken GCC.  */
 286   set_gdbarch_return_value (gdbarch, ppc_sysv_abi_broken_return_value);
 287
 288   /* OpenBSD uses SVR4-style shared libraries.  */
 289   set_solib_svr4_fetch_link_map_offsets
 290     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 291
 292   set_gdbarch_regset_from_core_section
 293     (gdbarch, ppcobsd_regset_from_core_section);
 294
 295   frame_unwind_append_sniffer (gdbarch, ppcobsd_sigtramp_frame_sniffer);
 296 }
 297 \f
 298
 299 /* OpenBSD uses uses the traditional NetBSD core file format, even for
 300    ports that use ELF.  */
 301 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
 302
 303 static enum gdb_osabi
 304 ppcobsd_core_osabi_sniffer (bfd *abfd)
 305 {
 306   if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
 307     return GDB_OSABI_NETBSD_CORE;
 308
 309   return GDB_OSABI_UNKNOWN;
 310 }
 311 \f
 312
 313 /* Provide a prototype to silence -Wmissing-prototypes.  */
 314 void _initialize_ppcobsd_tdep (void);
 315
 316 void
 317 _initialize_ppcobsd_tdep (void)
 318 {
 319   /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
 320   gdbarch_register_osabi_sniffer (bfd_arch_powerpc, bfd_target_unknown_flavour,
 321                                   ppcobsd_core_osabi_sniffer);
 322
 323   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_OPENBSD_ELF,
 324                           ppcobsd_init_abi);
 325   gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_OPENBSD_ELF,
 326                           ppcobsd_init_abi);
 327
 328   /* Avoid initializing the register offsets again if they were
 329      already initailized by ppcobsd-nat.c.  */
 330   if (ppcobsd_reg_offsets.pc_offset == 0)
 331     {
 332       /* General-purpose registers.  */
 333       ppcobsd_reg_offsets.r0_offset = 0;
 334       ppcobsd_reg_offsets.pc_offset = 384;
 335       ppcobsd_reg_offsets.ps_offset = 388;
 336       ppcobsd_reg_offsets.cr_offset = 392;
 337       ppcobsd_reg_offsets.lr_offset = 396;
 338       ppcobsd_reg_offsets.ctr_offset = 400;
 339       ppcobsd_reg_offsets.xer_offset = 404;
 340       ppcobsd_reg_offsets.mq_offset = 408;
 341
 342       /* Floating-point registers.  */
 343       ppcobsd_reg_offsets.f0_offset = 128;
 344       ppcobsd_reg_offsets.fpscr_offset = -1;
 345
 346       /* AltiVec registers.  */
 347       ppcobsd_reg_offsets.vr0_offset = 0;
 348       ppcobsd_reg_offsets.vscr_offset = 512;
 349       ppcobsd_reg_offsets.vrsave_offset = 520;
 350     }
 351
 352   if (ppcobsd_fpreg_offsets.fpscr_offset == 0)
 353     {
 354       /* Floating-point registers.  */
 355       ppcobsd_reg_offsets.f0_offset = 0;
 356       ppcobsd_reg_offsets.fpscr_offset = 256;
 357     }
 358 }