gdb/ppcobsd-tdep.c

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