gdb/mips-fbsd-tdep.c

   1 /* Target-dependent code for FreeBSD/mips.
   2
   3    Copyright (C) 2017 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 "osabi.h"
  22 #include "regset.h"
  23 #include "trad-frame.h"
  24 #include "tramp-frame.h"
  25
  26 #include "fbsd-tdep.h"
  27 #include "mips-tdep.h"
  28 #include "mips-fbsd-tdep.h"
  29
  30 #include "solib-svr4.h"
  31
  32 /* Core file support. */
  33
  34 /* Number of registers in `struct reg' from <machine/reg.h>.  The
  35    first 38 follow the standard MIPS layout.  The 39th holds
  36    IC_INT_REG on RM7K and RM9K processors.  The 40th is a dummy for
  37    padding.  */
  38 #define MIPS_FBSD_NUM_GREGS     40
  39
  40 /* Number of registers in `struct fpreg' from <machine/reg.h>.  The
  41    first 32 hold floating point registers.  33 holds the FSR.  The
  42    34th is a dummy for padding.  */
  43 #define MIPS_FBSD_NUM_FPREGS    34
  44
  45 /* Supply a single register.  The register size might not match, so use
  46    regcache->raw_supply_integer ().  */
  47
  48 static void
  49 mips_fbsd_supply_reg (struct regcache *regcache, int regnum, const void *addr,
  50                       size_t len)
  51 {
  52   regcache->raw_supply_integer (regnum, (const gdb_byte *) addr, len, true);
  53 }
  54
  55 /* Collect a single register.  The register size might not match, so use
  56    regcache->raw_collect_integer ().  */
  57
  58 static void
  59 mips_fbsd_collect_reg (const struct regcache *regcache, int regnum, void *addr,
  60                        size_t len)
  61 {
  62   regcache->raw_collect_integer (regnum, (gdb_byte *) addr, len, true);
  63 }
  64
  65 /* Supply the floating-point registers stored in FPREGS to REGCACHE.
  66    Each floating-point register in FPREGS is REGSIZE bytes in
  67    length.  */
  68
  69 void
  70 mips_fbsd_supply_fpregs (struct regcache *regcache, int regnum,
  71                          const void *fpregs, size_t regsize)
  72 {
  73   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  74   const gdb_byte *regs = (const gdb_byte *) fpregs;
  75   int i, fp0num, fsrnum;
  76
  77   fp0num = mips_regnum (gdbarch)->fp0;
  78   fsrnum = mips_regnum (gdbarch)->fp_control_status;
  79   for (i = fp0num; i <= fsrnum; i++)
  80     if (regnum == i || regnum == -1)
  81       mips_fbsd_supply_reg (regcache, i,
  82                             regs + (i - fp0num) * regsize, regsize);
  83 }
  84
  85 /* Supply the general-purpose registers stored in GREGS to REGCACHE.
  86    Each general-purpose register in GREGS is REGSIZE bytes in
  87    length.  */
  88
  89 void
  90 mips_fbsd_supply_gregs (struct regcache *regcache, int regnum,
  91                         const void *gregs, size_t regsize)
  92 {
  93   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  94   const gdb_byte *regs = (const gdb_byte *) gregs;
  95   int i;
  96
  97   for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
  98     if (regnum == i || regnum == -1)
  99       mips_fbsd_supply_reg (regcache, i, regs + i * regsize, regsize);
 100 }
 101
 102 /* Collect the floating-point registers from REGCACHE and store them
 103    in FPREGS.  Each floating-point register in FPREGS is REGSIZE bytes
 104    in length.  */
 105
 106 void
 107 mips_fbsd_collect_fpregs (const struct regcache *regcache, int regnum,
 108                           void *fpregs, size_t regsize)
 109 {
 110   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 111   gdb_byte *regs = (gdb_byte *) fpregs;
 112   int i, fp0num, fsrnum;
 113
 114   fp0num = mips_regnum (gdbarch)->fp0;
 115   fsrnum = mips_regnum (gdbarch)->fp_control_status;
 116   for (i = fp0num; i <= fsrnum; i++)
 117     if (regnum == i || regnum == -1)
 118       mips_fbsd_collect_reg (regcache, i,
 119                              regs + (i - fp0num) * regsize, regsize);
 120 }
 121
 122 /* Collect the general-purpose registers from REGCACHE and store them
 123    in GREGS.  Each general-purpose register in GREGS is REGSIZE bytes
 124    in length.  */
 125
 126 void
 127 mips_fbsd_collect_gregs (const struct regcache *regcache, int regnum,
 128                          void *gregs, size_t regsize)
 129 {
 130   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 131   gdb_byte *regs = (gdb_byte *) gregs;
 132   int i;
 133
 134   for (i = 0; i <= mips_regnum (gdbarch)->pc; i++)
 135     if (regnum == i || regnum == -1)
 136       mips_fbsd_collect_reg (regcache, i, regs + i * regsize, regsize);
 137 }
 138
 139 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
 140    in the floating-point register set REGSET to register cache
 141    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 142
 143 static void
 144 mips_fbsd_supply_fpregset (const struct regset *regset,
 145                            struct regcache *regcache,
 146                            int regnum, const void *fpregs, size_t len)
 147 {
 148   size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
 149
 150   gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);
 151
 152   mips_fbsd_supply_fpregs (regcache, regnum, fpregs, regsize);
 153 }
 154
 155 /* Collect register REGNUM from the register cache REGCACHE and store
 156    it in the buffer specified by FPREGS and LEN in the floating-point
 157    register set REGSET.  If REGNUM is -1, do this for all registers in
 158    REGSET.  */
 159
 160 static void
 161 mips_fbsd_collect_fpregset (const struct regset *regset,
 162                             const struct regcache *regcache,
 163                             int regnum, void *fpregs, size_t len)
 164 {
 165   size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
 166
 167   gdb_assert (len >= MIPS_FBSD_NUM_FPREGS * regsize);
 168
 169   mips_fbsd_collect_fpregs (regcache, regnum, fpregs, regsize);
 170 }
 171
 172 /* Supply register REGNUM from the buffer specified by GREGS and LEN
 173    in the general-purpose register set REGSET to register cache
 174    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 175
 176 static void
 177 mips_fbsd_supply_gregset (const struct regset *regset,
 178                           struct regcache *regcache, int regnum,
 179                           const void *gregs, size_t len)
 180 {
 181   size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
 182
 183   gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);
 184
 185   mips_fbsd_supply_gregs (regcache, regnum, gregs, regsize);
 186 }
 187
 188 /* Collect register REGNUM from the register cache REGCACHE and store
 189    it in the buffer specified by GREGS and LEN in the general-purpose
 190    register set REGSET.  If REGNUM is -1, do this for all registers in
 191    REGSET.  */
 192
 193 static void
 194 mips_fbsd_collect_gregset (const struct regset *regset,
 195                            const struct regcache *regcache,
 196                            int regnum, void *gregs, size_t len)
 197 {
 198   size_t regsize = mips_abi_regsize (get_regcache_arch (regcache));
 199
 200   gdb_assert (len >= MIPS_FBSD_NUM_GREGS * regsize);
 201
 202   mips_fbsd_collect_gregs (regcache, regnum, gregs, regsize);
 203 }
 204
 205 /* FreeBSD/mips register sets.  */
 206
 207 static const struct regset mips_fbsd_gregset =
 208 {
 209   NULL,
 210   mips_fbsd_supply_gregset,
 211   mips_fbsd_collect_gregset,
 212 };
 213
 214 static const struct regset mips_fbsd_fpregset =
 215 {
 216   NULL,
 217   mips_fbsd_supply_fpregset,
 218   mips_fbsd_collect_fpregset,
 219 };
 220
 221 /* Iterate over core file register note sections.  */
 222
 223 static void
 224 mips_fbsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
 225                                         iterate_over_regset_sections_cb *cb,
 226                                         void *cb_data,
 227                                         const struct regcache *regcache)
 228 {
 229   size_t regsize = mips_abi_regsize (gdbarch);
 230
 231   cb (".reg", MIPS_FBSD_NUM_GREGS * regsize, &mips_fbsd_gregset,
 232       NULL, cb_data);
 233   cb (".reg2", MIPS_FBSD_NUM_FPREGS * regsize, &mips_fbsd_fpregset,
 234       NULL, cb_data);
 235 }
 236
 237 /* Signal trampoline support.  */
 238
 239 #define FBSD_SYS_sigreturn      417
 240
 241 #define MIPS_INST_LI_V0_SIGRETURN 0x24020000 + FBSD_SYS_sigreturn
 242 #define MIPS_INST_SYSCALL       0x0000000c
 243 #define MIPS_INST_BREAK         0x0000000d
 244
 245 #define O32_SIGFRAME_UCONTEXT_OFFSET    (16)
 246 #define O32_SIGSET_T_SIZE       (16)
 247
 248 #define O32_UCONTEXT_ONSTACK    (O32_SIGSET_T_SIZE)
 249 #define O32_UCONTEXT_PC         (O32_UCONTEXT_ONSTACK + 4)
 250 #define O32_UCONTEXT_REGS       (O32_UCONTEXT_PC + 4)
 251 #define O32_UCONTEXT_SR         (O32_UCONTEXT_REGS + 4 * 32)
 252 #define O32_UCONTEXT_LO         (O32_UCONTEXT_SR + 4)
 253 #define O32_UCONTEXT_HI         (O32_UCONTEXT_LO + 4)
 254 #define O32_UCONTEXT_FPUSED     (O32_UCONTEXT_HI + 4)
 255 #define O32_UCONTEXT_FPREGS     (O32_UCONTEXT_FPUSED + 4)
 256
 257 #define O32_UCONTEXT_REG_SIZE   4
 258
 259 static void
 260 mips_fbsd_sigframe_init (const struct tramp_frame *self,
 261                          struct frame_info *this_frame,
 262                          struct trad_frame_cache *cache,
 263                          CORE_ADDR func)
 264 {
 265   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 266   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 267   CORE_ADDR sp, ucontext_addr, addr;
 268   int regnum;
 269   gdb_byte buf[4];
 270
 271   /* We find the appropriate instance of `ucontext_t' at a
 272      fixed offset in the signal frame.  */
 273   sp = get_frame_register_signed (this_frame,
 274                                   MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
 275   ucontext_addr = sp + O32_SIGFRAME_UCONTEXT_OFFSET;
 276
 277   /* PC.  */
 278   regnum = mips_regnum (gdbarch)->pc;
 279   trad_frame_set_reg_addr (cache,
 280                            regnum + gdbarch_num_regs (gdbarch),
 281                            ucontext_addr + O32_UCONTEXT_PC);
 282
 283   /* GPRs.  */
 284   for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + O32_UCONTEXT_REGS;
 285        regnum <= MIPS_RA_REGNUM; regnum++, addr += O32_UCONTEXT_REG_SIZE)
 286     trad_frame_set_reg_addr (cache,
 287                              regnum + gdbarch_num_regs (gdbarch),
 288                              addr);
 289
 290   regnum = MIPS_PS_REGNUM;
 291   trad_frame_set_reg_addr (cache,
 292                            regnum + gdbarch_num_regs (gdbarch),
 293                            ucontext_addr + O32_UCONTEXT_SR);
 294
 295   /* HI and LO.  */
 296   regnum = mips_regnum (gdbarch)->lo;
 297   trad_frame_set_reg_addr (cache,
 298                            regnum + gdbarch_num_regs (gdbarch),
 299                            ucontext_addr + O32_UCONTEXT_LO);
 300   regnum = mips_regnum (gdbarch)->hi;
 301   trad_frame_set_reg_addr (cache,
 302                            regnum + gdbarch_num_regs (gdbarch),
 303                            ucontext_addr + O32_UCONTEXT_HI);
 304
 305   if (target_read_memory (ucontext_addr + O32_UCONTEXT_FPUSED, buf, 4) == 0
 306       && extract_unsigned_integer (buf, 4, byte_order) != 0)
 307     {
 308       for (regnum = 0, addr = ucontext_addr + O32_UCONTEXT_FPREGS;
 309            regnum < 32; regnum++, addr += O32_UCONTEXT_REG_SIZE)
 310         trad_frame_set_reg_addr (cache,
 311                                  regnum + gdbarch_fp0_regnum (gdbarch),
 312                                  addr);
 313       trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
 314                                addr);
 315     }
 316
 317   trad_frame_set_id (cache, frame_id_build (sp, func));
 318 }
 319
 320 #define MIPS_INST_ADDIU_A0_SP_O32 (0x27a40000 \
 321                                    + O32_SIGFRAME_UCONTEXT_OFFSET)
 322
 323 static const struct tramp_frame mips_fbsd_sigframe =
 324 {
 325   SIGTRAMP_FRAME,
 326   MIPS_INSN32_SIZE,
 327   {
 328     { MIPS_INST_ADDIU_A0_SP_O32, -1 },  /* addiu   a0, sp, SIGF_UC */
 329     { MIPS_INST_LI_V0_SIGRETURN, -1 },  /* li      v0, SYS_sigreturn */
 330     { MIPS_INST_SYSCALL, -1 },          /* syscall */
 331     { MIPS_INST_BREAK, -1 },            /* break */
 332     { TRAMP_SENTINEL_INSN, -1 }
 333   },
 334   mips_fbsd_sigframe_init
 335 };
 336
 337 #define N64_SIGFRAME_UCONTEXT_OFFSET    (32)
 338 #define N64_SIGSET_T_SIZE       (16)
 339
 340 #define N64_UCONTEXT_ONSTACK    (N64_SIGSET_T_SIZE)
 341 #define N64_UCONTEXT_PC         (N64_UCONTEXT_ONSTACK + 8)
 342 #define N64_UCONTEXT_REGS       (N64_UCONTEXT_PC + 8)
 343 #define N64_UCONTEXT_SR         (N64_UCONTEXT_REGS + 8 * 32)
 344 #define N64_UCONTEXT_LO         (N64_UCONTEXT_SR + 8)
 345 #define N64_UCONTEXT_HI         (N64_UCONTEXT_LO + 8)
 346 #define N64_UCONTEXT_FPUSED     (N64_UCONTEXT_HI + 8)
 347 #define N64_UCONTEXT_FPREGS     (N64_UCONTEXT_FPUSED + 8)
 348
 349 #define N64_UCONTEXT_REG_SIZE   8
 350
 351 static void
 352 mips64_fbsd_sigframe_init (const struct tramp_frame *self,
 353                            struct frame_info *this_frame,
 354                            struct trad_frame_cache *cache,
 355                            CORE_ADDR func)
 356 {
 357   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 358   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 359   CORE_ADDR sp, ucontext_addr, addr;
 360   int regnum;
 361   gdb_byte buf[4];
 362
 363   /* We find the appropriate instance of `ucontext_t' at a
 364      fixed offset in the signal frame.  */
 365   sp = get_frame_register_signed (this_frame,
 366                                   MIPS_SP_REGNUM + gdbarch_num_regs (gdbarch));
 367   ucontext_addr = sp + N64_SIGFRAME_UCONTEXT_OFFSET;
 368
 369   /* PC.  */
 370   regnum = mips_regnum (gdbarch)->pc;
 371   trad_frame_set_reg_addr (cache,
 372                            regnum + gdbarch_num_regs (gdbarch),
 373                            ucontext_addr + N64_UCONTEXT_PC);
 374
 375   /* GPRs.  */
 376   for (regnum = MIPS_ZERO_REGNUM, addr = ucontext_addr + N64_UCONTEXT_REGS;
 377        regnum <= MIPS_RA_REGNUM; regnum++, addr += N64_UCONTEXT_REG_SIZE)
 378     trad_frame_set_reg_addr (cache,
 379                              regnum + gdbarch_num_regs (gdbarch),
 380                              addr);
 381
 382   regnum = MIPS_PS_REGNUM;
 383   trad_frame_set_reg_addr (cache,
 384                            regnum + gdbarch_num_regs (gdbarch),
 385                            ucontext_addr + N64_UCONTEXT_SR);
 386
 387   /* HI and LO.  */
 388   regnum = mips_regnum (gdbarch)->lo;
 389   trad_frame_set_reg_addr (cache,
 390                            regnum + gdbarch_num_regs (gdbarch),
 391                            ucontext_addr + N64_UCONTEXT_LO);
 392   regnum = mips_regnum (gdbarch)->hi;
 393   trad_frame_set_reg_addr (cache,
 394                            regnum + gdbarch_num_regs (gdbarch),
 395                            ucontext_addr + N64_UCONTEXT_HI);
 396
 397   if (target_read_memory (ucontext_addr + N64_UCONTEXT_FPUSED, buf, 4) == 0
 398       && extract_unsigned_integer (buf, 4, byte_order) != 0)
 399     {
 400       for (regnum = 0, addr = ucontext_addr + N64_UCONTEXT_FPREGS;
 401            regnum < 32; regnum++, addr += N64_UCONTEXT_REG_SIZE)
 402         trad_frame_set_reg_addr (cache,
 403                                  regnum + gdbarch_fp0_regnum (gdbarch),
 404                                  addr);
 405       trad_frame_set_reg_addr (cache, mips_regnum (gdbarch)->fp_control_status,
 406                                addr);
 407     }
 408
 409   trad_frame_set_id (cache, frame_id_build (sp, func));
 410 }
 411
 412 #define MIPS_INST_DADDIU_A0_SP_N64 (0x67a40000 \
 413                                     + N64_SIGFRAME_UCONTEXT_OFFSET)
 414
 415 static const struct tramp_frame mips64_fbsd_sigframe =
 416 {
 417   SIGTRAMP_FRAME,
 418   MIPS_INSN32_SIZE,
 419   {
 420     { MIPS_INST_DADDIU_A0_SP_N64, -1 }, /* daddiu  a0, sp, SIGF_UC */
 421     { MIPS_INST_LI_V0_SIGRETURN, -1 },  /* li      v0, SYS_sigreturn */
 422     { MIPS_INST_SYSCALL, -1 },          /* syscall */
 423     { MIPS_INST_BREAK, -1 },            /* break */
 424     { TRAMP_SENTINEL_INSN, -1 }
 425   },
 426   mips64_fbsd_sigframe_init
 427 };
 428
 429 /* Shared library support.  */
 430
 431 /* FreeBSD/mips uses a slightly different `struct link_map' than the
 432    other FreeBSD platforms as it includes an additional `l_off'
 433    member.  */
 434
 435 static struct link_map_offsets *
 436 mips_fbsd_ilp32_fetch_link_map_offsets (void)
 437 {
 438   static struct link_map_offsets lmo;
 439   static struct link_map_offsets *lmp = NULL;
 440
 441   if (lmp == NULL)
 442     {
 443       lmp = &lmo;
 444
 445       lmo.r_version_offset = 0;
 446       lmo.r_version_size = 4;
 447       lmo.r_map_offset = 4;
 448       lmo.r_brk_offset = 8;
 449       lmo.r_ldsomap_offset = -1;
 450
 451       lmo.link_map_size = 24;
 452       lmo.l_addr_offset = 0;
 453       lmo.l_name_offset = 8;
 454       lmo.l_ld_offset = 12;
 455       lmo.l_next_offset = 16;
 456       lmo.l_prev_offset = 20;
 457     }
 458
 459   return lmp;
 460 }
 461
 462 static struct link_map_offsets *
 463 mips_fbsd_lp64_fetch_link_map_offsets (void)
 464 {
 465   static struct link_map_offsets lmo;
 466   static struct link_map_offsets *lmp = NULL;
 467
 468   if (lmp == NULL)
 469     {
 470       lmp = &lmo;
 471
 472       lmo.r_version_offset = 0;
 473       lmo.r_version_size = 4;
 474       lmo.r_map_offset = 8;
 475       lmo.r_brk_offset = 16;
 476       lmo.r_ldsomap_offset = -1;
 477
 478       lmo.link_map_size = 48;
 479       lmo.l_addr_offset = 0;
 480       lmo.l_name_offset = 16;
 481       lmo.l_ld_offset = 24;
 482       lmo.l_next_offset = 32;
 483       lmo.l_prev_offset = 40;
 484     }
 485
 486   return lmp;
 487 }
 488
 489 static void
 490 mips_fbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 491 {
 492   enum mips_abi abi = mips_abi (gdbarch);
 493
 494   /* Generic FreeBSD support.  */
 495   fbsd_init_abi (info, gdbarch);
 496
 497   set_gdbarch_software_single_step (gdbarch, mips_software_single_step);
 498
 499   switch (abi)
 500     {
 501       case MIPS_ABI_O32:
 502         tramp_frame_prepend_unwinder (gdbarch, &mips_fbsd_sigframe);
 503         break;
 504       case MIPS_ABI_N32:
 505         break;
 506       case MIPS_ABI_N64:
 507         tramp_frame_prepend_unwinder (gdbarch, &mips64_fbsd_sigframe);
 508         break;
 509     }
 510
 511   set_gdbarch_iterate_over_regset_sections
 512     (gdbarch, mips_fbsd_iterate_over_regset_sections);
 513
 514   /* FreeBSD/mips has SVR4-style shared libraries.  */
 515   set_solib_svr4_fetch_link_map_offsets
 516     (gdbarch, (gdbarch_ptr_bit (gdbarch) == 32 ?
 517                mips_fbsd_ilp32_fetch_link_map_offsets :
 518                mips_fbsd_lp64_fetch_link_map_offsets));
 519 }
 520 \f
 521
 522 /* Provide a prototype to silence -Wmissing-prototypes.  */
 523 void _initialize_mips_fbsd_tdep (void);
 524
 525 void
 526 _initialize_mips_fbsd_tdep (void)
 527 {
 528   gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_FREEBSD,
 529                           mips_fbsd_init_abi);
 530 }