gdb/frv-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
   2    for GDB.
   3
   4    Copyright (C) 2004-2013 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 "gdbcore.h"
  23 #include "target.h"
  24 #include "frame.h"
  25 #include "osabi.h"
  26 #include "regcache.h"
  27 #include "elf-bfd.h"
  28 #include "elf/frv.h"
  29 #include "frv-tdep.h"
  30 #include "trad-frame.h"
  31 #include "frame-unwind.h"
  32 #include "regset.h"
  33 #include <string.h>
  34 #include "linux-tdep.h"
  35
  36 /* Define the size (in bytes) of an FR-V instruction.  */
  37 static const int frv_instr_size = 4;
  38
  39 enum {
  40   NORMAL_SIGTRAMP = 1,
  41   RT_SIGTRAMP = 2
  42 };
  43
  44 static int
  45 frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
  46                           const char *name)
  47 {
  48   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  49   gdb_byte buf[frv_instr_size];
  50   LONGEST instr;
  51   int retval = 0;
  52
  53   if (target_read_memory (pc, buf, sizeof buf) != 0)
  54     return 0;
  55
  56   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  57
  58   if (instr == 0x8efc0077)      /* setlos #__NR_sigreturn, gr7 */
  59     retval = NORMAL_SIGTRAMP;
  60   else if (instr == 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */
  61     retval = RT_SIGTRAMP;
  62   else
  63     return 0;
  64
  65   if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
  66     return 0;
  67   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  68   if (instr != 0xc0700000)      /* tira gr0, 0 */
  69     return 0;
  70
  71   /* If we get this far, we'll return a non-zero value, either
  72      NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2).  */
  73   return retval;
  74 }
  75
  76 /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
  77    wish to decode, and REGNO, one of the frv register numbers defined
  78    in frv-tdep.h, return the address of the saved register (corresponding
  79    to REGNO) in the sigtramp frame.  Return -1 if the register is not
  80    found in the sigtramp frame.  The magic numbers in the code below
  81    were computed by examining the following kernel structs:
  82
  83    From arch/frv/kernel/signal.c:
  84
  85       struct sigframe
  86       {
  87               void (*pretcode)(void);
  88               int sig;
  89               struct sigcontext sc;
  90               unsigned long extramask[_NSIG_WORDS-1];
  91               uint32_t retcode[2];
  92       };
  93
  94       struct rt_sigframe
  95       {
  96               void (*pretcode)(void);
  97               int sig;
  98               struct siginfo *pinfo;
  99               void *puc;
 100               struct siginfo info;
 101               struct ucontext uc;
 102               uint32_t retcode[2];
 103       };
 104
 105    From include/asm-frv/ucontext.h:
 106
 107       struct ucontext {
 108               unsigned long             uc_flags;
 109               struct ucontext           *uc_link;
 110               stack_t                   uc_stack;
 111               struct sigcontext uc_mcontext;
 112               sigset_t          uc_sigmask;
 113       };
 114
 115    From include/asm-frv/signal.h:
 116
 117       typedef struct sigaltstack {
 118               void *ss_sp;
 119               int ss_flags;
 120               size_t ss_size;
 121       } stack_t;
 122
 123    From include/asm-frv/sigcontext.h:
 124
 125       struct sigcontext {
 126               struct user_context       sc_context;
 127               unsigned long             sc_oldmask;
 128       } __attribute__((aligned(8)));
 129
 130    From include/asm-frv/registers.h:
 131       struct user_int_regs
 132       {
 133               unsigned long             psr;
 134               unsigned long             isr;
 135               unsigned long             ccr;
 136               unsigned long             cccr;
 137               unsigned long             lr;
 138               unsigned long             lcr;
 139               unsigned long             pc;
 140               unsigned long             __status;
 141               unsigned long             syscallno;
 142               unsigned long             orig_gr8;
 143               unsigned long             gner[2];
 144               unsigned long long        iacc[1];
 145
 146               union {
 147                       unsigned long     tbr;
 148                       unsigned long     gr[64];
 149               };
 150       };
 151
 152       struct user_fpmedia_regs
 153       {
 154               unsigned long     fr[64];
 155               unsigned long     fner[2];
 156               unsigned long     msr[2];
 157               unsigned long     acc[8];
 158               unsigned char     accg[8];
 159               unsigned long     fsr[1];
 160       };
 161
 162       struct user_context
 163       {
 164               struct user_int_regs              i;
 165               struct user_fpmedia_regs  f;
 166
 167               void *extension;
 168       } __attribute__((aligned(8)));  */
 169
 170 static LONGEST
 171 frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
 172                                CORE_ADDR *sc_addr_cache_ptr)
 173 {
 174   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 175   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 176   CORE_ADDR sc_addr;
 177
 178   if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
 179     {
 180       sc_addr = *sc_addr_cache_ptr;
 181     }
 182   else
 183     {
 184       CORE_ADDR pc, sp;
 185       gdb_byte buf[4];
 186       int tramp_type;
 187
 188       pc = get_frame_pc (this_frame);
 189       tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);
 190
 191       get_frame_register (this_frame, sp_regnum, buf);
 192       sp = extract_unsigned_integer (buf, sizeof buf, byte_order);
 193
 194       if (tramp_type == NORMAL_SIGTRAMP)
 195         {
 196           /* For a normal sigtramp frame, the sigcontext struct starts
 197              at SP + 8.  */
 198           sc_addr = sp + 8;
 199         }
 200       else if (tramp_type == RT_SIGTRAMP)
 201         {
 202           /* For a realtime sigtramp frame, SP + 12 contains a pointer
 203              to a ucontext struct.  The ucontext struct contains a
 204              sigcontext struct starting 24 bytes in.  (The offset of
 205              uc_mcontext within struct ucontext is derived as follows:
 206              stack_t is a 12-byte struct and struct sigcontext is
 207              8-byte aligned.  This gives an offset of 8 + 12 + 4 (for
 208              padding) = 24.)  */
 209           if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
 210             {
 211               warning (_("Can't read realtime sigtramp frame."));
 212               return 0;
 213             }
 214           sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
 215           sc_addr += 24;
 216         }
 217       else
 218         internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
 219
 220       if (sc_addr_cache_ptr)
 221         *sc_addr_cache_ptr = sc_addr;
 222     }
 223
 224   switch (regno)
 225     {
 226     case psr_regnum :
 227       return sc_addr + 0;
 228     /* sc_addr + 4 has "isr", the Integer Status Register.  */
 229     case ccr_regnum :
 230       return sc_addr + 8;
 231     case cccr_regnum :
 232       return sc_addr + 12;
 233     case lr_regnum :
 234       return sc_addr + 16;
 235     case lcr_regnum :
 236       return sc_addr + 20;
 237     case pc_regnum :
 238       return sc_addr + 24;
 239     /* sc_addr + 28 is __status, the exception status.
 240        sc_addr + 32 is syscallno, the syscall number or -1.
 241        sc_addr + 36 is orig_gr8, the original syscall arg #1.
 242        sc_addr + 40 is gner[0].
 243        sc_addr + 44 is gner[1].  */
 244     case iacc0h_regnum :
 245       return sc_addr + 48;
 246     case iacc0l_regnum :
 247       return sc_addr + 52;
 248     default :
 249       if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
 250         return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
 251       else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
 252         return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
 253       else
 254         return -1;  /* not saved.  */
 255     }
 256 }
 257
 258 /* Signal trampolines.  */
 259
 260 static struct trad_frame_cache *
 261 frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
 262                                 void **this_cache)
 263 {
 264   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 265   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 266   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 267   struct trad_frame_cache *cache;
 268   CORE_ADDR addr;
 269   gdb_byte buf[4];
 270   int regnum;
 271   CORE_ADDR sc_addr_cache_val = 0;
 272   struct frame_id this_id;
 273
 274   if (*this_cache)
 275     return *this_cache;
 276
 277   cache = trad_frame_cache_zalloc (this_frame);
 278
 279   /* FIXME: cagney/2004-05-01: This is is long standing broken code.
 280      The frame ID's code address should be the start-address of the
 281      signal trampoline and not the current PC within that
 282      trampoline.  */
 283   get_frame_register (this_frame, sp_regnum, buf);
 284   addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
 285   this_id = frame_id_build (addr, get_frame_pc (this_frame));
 286   trad_frame_set_id (cache, this_id);
 287
 288   for (regnum = 0; regnum < frv_num_regs; regnum++)
 289     {
 290       LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
 291                                                         &sc_addr_cache_val);
 292       if (reg_addr != -1)
 293         trad_frame_set_reg_addr (cache, regnum, reg_addr);
 294     }
 295
 296   *this_cache = cache;
 297   return cache;
 298 }
 299
 300 static void
 301 frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
 302                                   void **this_cache,
 303                                   struct frame_id *this_id)
 304 {
 305   struct trad_frame_cache *cache
 306     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
 307   trad_frame_get_id (cache, this_id);
 308 }
 309
 310 static struct value *
 311 frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 312                                         void **this_cache, int regnum)
 313 {
 314   /* Make sure we've initialized the cache.  */
 315   struct trad_frame_cache *cache
 316     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
 317   return trad_frame_get_register (cache, this_frame, regnum);
 318 }
 319
 320 static int
 321 frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 322                                   struct frame_info *this_frame,
 323                                   void **this_cache)
 324 {
 325   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 326   CORE_ADDR pc = get_frame_pc (this_frame);
 327   const char *name;
 328
 329   find_pc_partial_function (pc, &name, NULL, NULL);
 330   if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
 331     return 1;
 332
 333   return 0;
 334 }
 335
 336 static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
 337 {
 338   SIGTRAMP_FRAME,
 339   default_frame_unwind_stop_reason,
 340   frv_linux_sigtramp_frame_this_id,
 341   frv_linux_sigtramp_frame_prev_register,
 342   NULL,
 343   frv_linux_sigtramp_frame_sniffer
 344 };
 345 \f
 346 /* The FRV kernel defines ELF_NGREG as 46.  We add 2 in order to include
 347    the loadmap addresses in the register set.  (See below for more info.)  */
 348 #define FRV_ELF_NGREG (46 + 2)
 349 typedef unsigned char frv_elf_greg_t[4];
 350 typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;
 351
 352 typedef unsigned char frv_elf_fpreg_t[4];
 353 typedef struct
 354 {
 355   frv_elf_fpreg_t fr[64];
 356   frv_elf_fpreg_t fner[2];
 357   frv_elf_fpreg_t msr[2];
 358   frv_elf_fpreg_t acc[8];
 359   unsigned char accg[8];
 360   frv_elf_fpreg_t fsr[1];
 361 } frv_elf_fpregset_t;
 362
 363 /* Constants for accessing elements of frv_elf_gregset_t.  */
 364
 365 #define FRV_PT_PSR 0
 366 #define FRV_PT_ISR 1
 367 #define FRV_PT_CCR 2
 368 #define FRV_PT_CCCR 3
 369 #define FRV_PT_LR 4
 370 #define FRV_PT_LCR 5
 371 #define FRV_PT_PC 6
 372 #define FRV_PT_GNER0 10
 373 #define FRV_PT_GNER1 11
 374 #define FRV_PT_IACC0H 12
 375 #define FRV_PT_IACC0L 13
 376
 377 /* Note: Only 32 of the GRs will be found in the corefile.  */
 378 #define FRV_PT_GR(j)    ( 14 + (j))     /* GRj for 0<=j<=63.  */
 379
 380 #define FRV_PT_TBR FRV_PT_GR(0)         /* gr0 is always 0, so TBR is stuffed
 381                                            there.  */
 382
 383 /* Technically, the loadmap addresses are not part of `pr_reg' as
 384    found in the elf_prstatus struct.  The fields which communicate the
 385    loadmap address appear (by design) immediately after `pr_reg'
 386    though, and the BFD function elf32_frv_grok_prstatus() has been
 387    implemented to include these fields in the register section that it
 388    extracts from the core file.  So, for our purposes, they may be
 389    viewed as registers.  */
 390
 391 #define FRV_PT_EXEC_FDPIC_LOADMAP 46
 392 #define FRV_PT_INTERP_FDPIC_LOADMAP 47
 393
 394
 395 /* Unpack an frv_elf_gregset_t into GDB's register cache.  */
 396
 397 static void
 398 frv_linux_supply_gregset (const struct regset *regset,
 399                           struct regcache *regcache,
 400                           int regnum, const void *gregs, size_t len)
 401 {
 402   int regi;
 403   char zerobuf[MAX_REGISTER_SIZE];
 404   const frv_elf_gregset_t *gregsetp = gregs;
 405
 406   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 407
 408   /* gr0 always contains 0.  Also, the kernel passes the TBR value in
 409      this slot.  */
 410   regcache_raw_supply (regcache, first_gpr_regnum, zerobuf);
 411
 412   for (regi = first_gpr_regnum + 1; regi <= last_gpr_regnum; regi++)
 413     {
 414       if (regi >= first_gpr_regnum + 32)
 415         regcache_raw_supply (regcache, regi, zerobuf);
 416       else
 417         regcache_raw_supply (regcache, regi,
 418                              gregsetp->reg[FRV_PT_GR (regi
 419                                                       - first_gpr_regnum)]);
 420     }
 421
 422   regcache_raw_supply (regcache, pc_regnum, gregsetp->reg[FRV_PT_PC]);
 423   regcache_raw_supply (regcache, psr_regnum, gregsetp->reg[FRV_PT_PSR]);
 424   regcache_raw_supply (regcache, ccr_regnum, gregsetp->reg[FRV_PT_CCR]);
 425   regcache_raw_supply (regcache, cccr_regnum, gregsetp->reg[FRV_PT_CCCR]);
 426   regcache_raw_supply (regcache, lr_regnum, gregsetp->reg[FRV_PT_LR]);
 427   regcache_raw_supply (regcache, lcr_regnum, gregsetp->reg[FRV_PT_LCR]);
 428   regcache_raw_supply (regcache, gner0_regnum, gregsetp->reg[FRV_PT_GNER0]);
 429   regcache_raw_supply (regcache, gner1_regnum, gregsetp->reg[FRV_PT_GNER1]);
 430   regcache_raw_supply (regcache, tbr_regnum, gregsetp->reg[FRV_PT_TBR]);
 431   regcache_raw_supply (regcache, fdpic_loadmap_exec_regnum,
 432                        gregsetp->reg[FRV_PT_EXEC_FDPIC_LOADMAP]);
 433   regcache_raw_supply (regcache, fdpic_loadmap_interp_regnum,
 434                        gregsetp->reg[FRV_PT_INTERP_FDPIC_LOADMAP]);
 435 }
 436
 437 /* Unpack an frv_elf_fpregset_t into GDB's register cache.  */
 438
 439 static void
 440 frv_linux_supply_fpregset (const struct regset *regset,
 441                            struct regcache *regcache,
 442                            int regnum, const void *gregs, size_t len)
 443 {
 444   int regi;
 445   const frv_elf_fpregset_t *fpregsetp = gregs;
 446
 447   for (regi = first_fpr_regnum; regi <= last_fpr_regnum; regi++)
 448     regcache_raw_supply (regcache, regi,
 449                          fpregsetp->fr[regi - first_fpr_regnum]);
 450
 451   regcache_raw_supply (regcache, fner0_regnum, fpregsetp->fner[0]);
 452   regcache_raw_supply (regcache, fner1_regnum, fpregsetp->fner[1]);
 453
 454   regcache_raw_supply (regcache, msr0_regnum, fpregsetp->msr[0]);
 455   regcache_raw_supply (regcache, msr1_regnum, fpregsetp->msr[1]);
 456
 457   for (regi = acc0_regnum; regi <= acc7_regnum; regi++)
 458     regcache_raw_supply (regcache, regi, fpregsetp->acc[regi - acc0_regnum]);
 459
 460   regcache_raw_supply (regcache, accg0123_regnum, fpregsetp->accg);
 461   regcache_raw_supply (regcache, accg4567_regnum, fpregsetp->accg + 4);
 462
 463   regcache_raw_supply (regcache, fsr0_regnum, fpregsetp->fsr[0]);
 464 }
 465
 466 /* FRV Linux kernel register sets.  */
 467
 468 static struct regset frv_linux_gregset =
 469 {
 470   NULL,
 471   frv_linux_supply_gregset
 472 };
 473
 474 static struct regset frv_linux_fpregset =
 475 {
 476   NULL,
 477   frv_linux_supply_fpregset
 478 };
 479
 480 static const struct regset *
 481 frv_linux_regset_from_core_section (struct gdbarch *gdbarch,
 482                                     const char *sect_name, size_t sect_size)
 483 {
 484   if (strcmp (sect_name, ".reg") == 0
 485       && sect_size >= sizeof (frv_elf_gregset_t))
 486     return &frv_linux_gregset;
 487
 488   if (strcmp (sect_name, ".reg2") == 0
 489       && sect_size >= sizeof (frv_elf_fpregset_t))
 490     return &frv_linux_fpregset;
 491
 492   return NULL;
 493 }
 494
 495 \f
 496 static void
 497 frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 498 {
 499   linux_init_abi (info, gdbarch);
 500
 501   /* Set the sigtramp frame sniffer.  */
 502   frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind);
 503
 504   set_gdbarch_regset_from_core_section (gdbarch,
 505                                         frv_linux_regset_from_core_section);
 506 }
 507
 508 static enum gdb_osabi
 509 frv_linux_elf_osabi_sniffer (bfd *abfd)
 510 {
 511   int elf_flags;
 512
 513   elf_flags = elf_elfheader (abfd)->e_flags;
 514
 515   /* Assume GNU/Linux if using the FDPIC ABI.  If/when another OS shows
 516      up that uses this ABI, we'll need to start using .note sections
 517      or some such.  */
 518   if (elf_flags & EF_FRV_FDPIC)
 519     return GDB_OSABI_LINUX;
 520   else
 521     return GDB_OSABI_UNKNOWN;
 522 }
 523
 524 /* Provide a prototype to silence -Wmissing-prototypes.  */
 525 void _initialize_frv_linux_tdep (void);
 526
 527 void
 528 _initialize_frv_linux_tdep (void)
 529 {
 530   gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
 531                           frv_linux_init_abi);
 532   gdbarch_register_osabi_sniffer (bfd_arch_frv,
 533                                   bfd_target_elf_flavour,
 534                                   frv_linux_elf_osabi_sniffer);
 535 }