gdb/ppcobsd-tdep.c

   1 /* Target-dependent code for OpenBSD/powerpc.
   2
   3    Copyright (C) 2004, 2005, 2006, 2007 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 "frame.h"
  25 #include "frame-unwind.h"
  26 #include "gdbtypes.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,
 215                                          gdbarch_sp_regnum (current_gdbarch));
 216   addr = base + sigcontext_offset + 2 * tdep->wordsize;
 217   for (i = 0; i < ppc_num_gprs; i++, addr += tdep->wordsize)
 218     {
 219       int regnum = i + tdep->ppc_gp0_regnum;
 220       trad_frame_set_reg_addr (cache, regnum, addr);
 221     }
 222   trad_frame_set_reg_addr (cache, tdep->ppc_lr_regnum, addr);
 223   addr += tdep->wordsize;
 224   trad_frame_set_reg_addr (cache, tdep->ppc_cr_regnum, addr);
 225   addr += tdep->wordsize;
 226   trad_frame_set_reg_addr (cache, tdep->ppc_xer_regnum, addr);
 227   addr += tdep->wordsize;
 228   trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, addr);
 229   addr += tdep->wordsize;
 230   trad_frame_set_reg_addr (cache, gdbarch_pc_regnum (current_gdbarch), addr);
 231   /* SRR0? */
 232   addr += tdep->wordsize;
 233
 234   /* Construct the frame ID using the function start.  */
 235   trad_frame_set_id (cache, frame_id_build (base, func));
 236
 237   return cache;
 238 }
 239
 240 static void
 241 ppcobsd_sigtramp_frame_this_id (struct frame_info *next_frame,
 242                                 void **this_cache, struct frame_id *this_id)
 243 {
 244   struct trad_frame_cache *cache =
 245     ppcobsd_sigtramp_frame_cache (next_frame, this_cache);
 246
 247   trad_frame_get_id (cache, this_id);
 248 }
 249
 250 static void
 251 ppcobsd_sigtramp_frame_prev_register (struct frame_info *next_frame,
 252                                       void **this_cache, int regnum,
 253                                       int *optimizedp, enum lval_type *lvalp,
 254                                       CORE_ADDR *addrp, int *realnump,
 255                                       gdb_byte *valuep)
 256 {
 257   struct trad_frame_cache *cache =
 258     ppcobsd_sigtramp_frame_cache (next_frame, this_cache);
 259
 260   trad_frame_get_register (cache, next_frame, regnum,
 261                            optimizedp, lvalp, addrp, realnump, valuep);
 262 }
 263
 264 static const struct frame_unwind ppcobsd_sigtramp_frame_unwind = {
 265   SIGTRAMP_FRAME,
 266   ppcobsd_sigtramp_frame_this_id,
 267   ppcobsd_sigtramp_frame_prev_register
 268 };
 269
 270 static const struct frame_unwind *
 271 ppcobsd_sigtramp_frame_sniffer (struct frame_info *next_frame)
 272 {
 273   if (ppcobsd_sigtramp_p (next_frame))
 274     return &ppcobsd_sigtramp_frame_unwind;
 275
 276   return NULL;
 277 }
 278 \f
 279
 280 static void
 281 ppcobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 282 {
 283   /* OpenBSD doesn't support the 128-bit `long double' from the psABI.  */
 284   set_gdbarch_long_double_bit (gdbarch, 64);
 285   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 286
 287   /* OpenBSD currently uses a broken GCC.  */
 288   set_gdbarch_return_value (gdbarch, ppc_sysv_abi_broken_return_value);
 289
 290   /* OpenBSD uses SVR4-style shared libraries.  */
 291   set_solib_svr4_fetch_link_map_offsets
 292     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 293
 294   set_gdbarch_regset_from_core_section
 295     (gdbarch, ppcobsd_regset_from_core_section);
 296
 297   frame_unwind_append_sniffer (gdbarch, ppcobsd_sigtramp_frame_sniffer);
 298 }
 299 \f
 300
 301 /* OpenBSD uses uses the traditional NetBSD core file format, even for
 302    ports that use ELF.  */
 303 #define GDB_OSABI_NETBSD_CORE GDB_OSABI_OPENBSD_ELF
 304
 305 static enum gdb_osabi
 306 ppcobsd_core_osabi_sniffer (bfd *abfd)
 307 {
 308   if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
 309     return GDB_OSABI_NETBSD_CORE;
 310
 311   return GDB_OSABI_UNKNOWN;
 312 }
 313 \f
 314
 315 /* Provide a prototype to silence -Wmissing-prototypes.  */
 316 void _initialize_ppcobsd_tdep (void);
 317
 318 void
 319 _initialize_ppcobsd_tdep (void)
 320 {
 321   /* BFD doesn't set a flavour for NetBSD style a.out core files.  */
 322   gdbarch_register_osabi_sniffer (bfd_arch_powerpc, bfd_target_unknown_flavour,
 323                                   ppcobsd_core_osabi_sniffer);
 324
 325   gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_OPENBSD_ELF,
 326                           ppcobsd_init_abi);
 327   gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_OPENBSD_ELF,
 328                           ppcobsd_init_abi);
 329
 330   /* Avoid initializing the register offsets again if they were
 331      already initailized by ppcobsd-nat.c.  */
 332   if (ppcobsd_reg_offsets.pc_offset == 0)
 333     {
 334       /* General-purpose registers.  */
 335       ppcobsd_reg_offsets.r0_offset = 0;
 336       ppcobsd_reg_offsets.pc_offset = 384;
 337       ppcobsd_reg_offsets.ps_offset = 388;
 338       ppcobsd_reg_offsets.cr_offset = 392;
 339       ppcobsd_reg_offsets.lr_offset = 396;
 340       ppcobsd_reg_offsets.ctr_offset = 400;
 341       ppcobsd_reg_offsets.xer_offset = 404;
 342       ppcobsd_reg_offsets.mq_offset = 408;
 343
 344       /* Floating-point registers.  */
 345       ppcobsd_reg_offsets.f0_offset = 128;
 346       ppcobsd_reg_offsets.fpscr_offset = -1;
 347
 348       /* AltiVec registers.  */
 349       ppcobsd_reg_offsets.vr0_offset = 0;
 350       ppcobsd_reg_offsets.vscr_offset = 512;
 351       ppcobsd_reg_offsets.vrsave_offset = 520;
 352     }
 353
 354   if (ppcobsd_fpreg_offsets.fpscr_offset == 0)
 355     {
 356       /* Floating-point registers.  */
 357       ppcobsd_reg_offsets.f0_offset = 0;
 358       ppcobsd_reg_offsets.fpscr_offset = 256;
 359     }
 360 }