gdb/frv-linux-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
  2.    for GDB.

  4.    Copyright (C) 2004-2015 Free Software Foundation, Inc.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "linux-tdep.h"

  35. /* Define the size (in bytes) of an FR-V instruction.  */
  36. ‌static const int frv_instr_size = 4;

  38. enum {
  39.   NORMAL_SIGTRAMP = 1,
  40.   RT_SIGTRAMP = 2
  41. };

  43. static int
  44. ‌frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
  45.                           const char *name)
  46. {
  47.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  48.   gdb_byte buf[frv_instr_size];
  49.   LONGEST instr;
  50.   int retval = 0;

  52.   if (target_read_memory (pc, buf, sizeof buf) != 0)
  53.     return 0;

  55.   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);

  57.   if (instr == 0x8efc0077)        /* setlos #__NR_sigreturn, gr7 */
  58.     retval = NORMAL_SIGTRAMP;
  59.   else if (instr == 0x8efc00ad)        /* setlos #__NR_rt_sigreturn, gr7 */
  60.     retval = RT_SIGTRAMP;
  61.   else
  62.     return 0;

  64.   if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
  65.     return 0;
  66.   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  67.   if (instr != 0xc0700000)        /* tira        gr0, 0 */
  68.     return 0;

  70.   /* If we get this far, we'll return a non-zero value, either
  71.      NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2).  */
  72.   return retval;
  73. }

  75. /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
  76.    wish to decode, and REGNO, one of the frv register numbers defined
  77.    in frv-tdep.h, return the address of the saved register (corresponding
  78.    to REGNO) in the sigtramp frame.  Return -1 if the register is not
  79.    found in the sigtramp frame.  The magic numbers in the code below
  80.    were computed by examining the following kernel structs:

  82.    From arch/frv/kernel/signal.c:

  84.       struct sigframe
  85.       {
  86.               void (*pretcode)(void);
  87.               int sig;
  88.               struct sigcontext sc;
  89.               unsigned long extramask[_NSIG_WORDS-1];
  90.               uint32_t retcode[2];
  91.       };

  93.       struct rt_sigframe
  94.       {
  95.               void (*pretcode)(void);
  96.               int sig;
  97.               struct siginfo *pinfo;
  98.               void *puc;
  99.               struct siginfo info;
  100.               struct ucontext uc;
  101.               uint32_t retcode[2];
  102.       };

  104.    From include/asm-frv/ucontext.h:

  106.       struct ucontext {
  107.               unsigned long                uc_flags;
  108.               struct ucontext                *uc_link;
  109.               stack_t                        uc_stack;
  110.               struct sigcontext        uc_mcontext;
  111.               sigset_t                uc_sigmask;
  112.       };

  114.    From include/asm-frv/signal.h:

  116.       typedef struct sigaltstack {
  117.               void *ss_sp;
  118.               int ss_flags;
  119.               size_t ss_size;
  120.       } stack_t;

  122.    From include/asm-frv/sigcontext.h:

  124.       struct sigcontext {
  125.               struct user_context        sc_context;
  126.               unsigned long                sc_oldmask;
  127.       } __attribute__((aligned(8)));

  129.    From include/asm-frv/registers.h:
  130.       struct user_int_regs
  131.       {
  132.               unsigned long                psr;
  133.               unsigned long                isr;
  134.               unsigned long                ccr;
  135.               unsigned long                cccr;
  136.               unsigned long                lr;
  137.               unsigned long                lcr;
  138.               unsigned long                pc;
  139.               unsigned long                __status;
  140.               unsigned long                syscallno;
  141.               unsigned long                orig_gr8;
  142.               unsigned long                gner[2];
  143.               unsigned long long        iacc[1];

  145.               union {
  146.                       unsigned long        tbr;
  147.                       unsigned long        gr[64];
  148.               };
  149.       };

  151.       struct user_fpmedia_regs
  152.       {
  153.               unsigned long        fr[64];
  154.               unsigned long        fner[2];
  155.               unsigned long        msr[2];
  156.               unsigned long        acc[8];
  157.               unsigned char        accg[8];
  158.               unsigned long        fsr[1];
  159.       };

  161.       struct user_context
  162.       {
  163.               struct user_int_regs                i;
  164.               struct user_fpmedia_regs        f;

  166.               void *extension;
  167.       } __attribute__((aligned(8)));  */

  169. static LONGEST
  170. ‌frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
  171.                                CORE_ADDR *sc_addr_cache_ptr)
  172. {
  173.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  174.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  175.   CORE_ADDR sc_addr;

  177.   if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
  178.     {
  179.       sc_addr = *sc_addr_cache_ptr;
  180.     }
  181.   else
  182.     {
  183.       CORE_ADDR pc, sp;
  184.       gdb_byte buf[4];
  185.       int tramp_type;

  187.       pc = get_frame_pc (this_frame);
  188.       tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);

  190.       get_frame_register (this_frame, sp_regnum, buf);
  191.       sp = extract_unsigned_integer (buf, sizeof buf, byte_order);

  193.       if (tramp_type == NORMAL_SIGTRAMP)
  194.         {
  195.           /* For a normal sigtramp frame, the sigcontext struct starts
  196.              at SP + 8.  */
  197.           sc_addr = sp + 8;
  198.         }
  199.       else if (tramp_type == RT_SIGTRAMP)
  200.         {
  201.           /* For a realtime sigtramp frame, SP + 12 contains a pointer
  202.               to a ucontext struct.  The ucontext struct contains a
  203.               sigcontext struct starting 24 bytes in.  (The offset of
  204.               uc_mcontext within struct ucontext is derived as follows:
  205.               stack_t is a 12-byte struct and struct sigcontext is
  206.               8-byte aligned.  This gives an offset of 8 + 12 + 4 (for
  207.               padding) = 24.)  */
  208.           if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
  209.             {
  210.               warning (_("Can't read realtime sigtramp frame."));
  211.               return 0;
  212.             }
  213.           sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  214.            sc_addr += 24;
  215.         }
  216.       else
  217.         internal_error (__FILE__, __LINE__, _("not a signal trampoline"));

  219.       if (sc_addr_cache_ptr)
  220.         *sc_addr_cache_ptr = sc_addr;
  221.     }

  223.   switch (regno)
  224.     {
  225.     case psr_regnum :
  226.       return sc_addr + 0;
  227.     /* sc_addr + 4 has "isr", the Integer Status Register.  */
  228.     case ccr_regnum :
  229.       return sc_addr + 8;
  230.     case cccr_regnum :
  231.       return sc_addr + 12;
  232.     case lr_regnum :
  233.       return sc_addr + 16;
  234.     case lcr_regnum :
  235.       return sc_addr + 20;
  236.     case pc_regnum :
  237.       return sc_addr + 24;
  238.     /* sc_addr + 28 is __status, the exception status.
  239.        sc_addr + 32 is syscallno, the syscall number or -1.
  240.        sc_addr + 36 is orig_gr8, the original syscall arg #1.
  241.        sc_addr + 40 is gner[0].
  242.        sc_addr + 44 is gner[1].  */
  243.     case iacc0h_regnum :
  244.       return sc_addr + 48;
  245.     case iacc0l_regnum :
  246.       return sc_addr + 52;
  247.     default :
  248.       if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
  249.         return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
  250.       else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
  251.         return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
  252.       else
  253.         return -1;  /* not saved.  */
  254.     }
  255. }

  257. /* Signal trampolines.  */

  259. static struct trad_frame_cache *
  260. ‌frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
  261.                                 void **this_cache)
  262. {
  263.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  264.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  265.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  266.   struct trad_frame_cache *cache;
  267.   CORE_ADDR addr;
  268.   gdb_byte buf[4];
  269.   int regnum;
  270.   CORE_ADDR sc_addr_cache_val = 0;
  271.   struct frame_id this_id;

  273.   if (*this_cache)
  274.     return *this_cache;

  276.   cache = trad_frame_cache_zalloc (this_frame);

  278.   /* FIXME: cagney/2004-05-01: This is is long standing broken code.
  279.      The frame ID's code address should be the start-address of the
  280.      signal trampoline and not the current PC within that
  281.      trampoline.  */
  282.   get_frame_register (this_frame, sp_regnum, buf);
  283.   addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
  284.   this_id = frame_id_build (addr, get_frame_pc (this_frame));
  285.   trad_frame_set_id (cache, this_id);

  287.   for (regnum = 0; regnum < frv_num_regs; regnum++)
  288.     {
  289.       LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
  290.                                                         &sc_addr_cache_val);
  291.       if (reg_addr != -1)
  292.         trad_frame_set_reg_addr (cache, regnum, reg_addr);
  293.     }

  295.   *this_cache = cache;
  296.   return cache;
  297. }

  299. static void
  300. ‌frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
  301.                                   void **this_cache,
  302.                                   struct frame_id *this_id)
  303. {
  304.   struct trad_frame_cache *cache
  305.     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
  306.   trad_frame_get_id (cache, this_id);
  307. }

  309. static struct value *
  310. ‌frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
  311.                                         void **this_cache, int regnum)
  312. {
  313.   /* Make sure we've initialized the cache.  */
  314.   struct trad_frame_cache *cache
  315.     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
  316.   return trad_frame_get_register (cache, this_frame, regnum);
  317. }

  319. static int
  320. ‌frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
  321.                                   struct frame_info *this_frame,
  322.                                   void **this_cache)
  323. {
  324.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  325.   CORE_ADDR pc = get_frame_pc (this_frame);
  326.   const char *name;

  328.   find_pc_partial_function (pc, &name, NULL, NULL);
  329.   if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
  330.     return 1;

  332.   return 0;
  333. }

  335. ‌static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
  336. {
  337.   SIGTRAMP_FRAME,
  338.   default_frame_unwind_stop_reason,
  339.   frv_linux_sigtramp_frame_this_id,
  340.   frv_linux_sigtramp_frame_prev_register,
  341.   NULL,
  342.   frv_linux_sigtramp_frame_sniffer
  343. };

  345. /* The FRV kernel defines ELF_NGREG as 46.  We add 2 in order to include
  346.    the loadmap addresses in the register set.  (See below for more info.)  */
  347. ‌#define FRV_ELF_NGREG (46 + 2)
  348. ‌typedef unsigned char frv_elf_greg_t[4];
  349. ‌typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;

  351. ‌typedef unsigned char frv_elf_fpreg_t[4];
  352. typedef struct
  353. {
  354.   frv_elf_fpreg_t fr[64];
  355.   frv_elf_fpreg_t fner[2];
  356.   frv_elf_fpreg_t msr[2];
  357.   frv_elf_fpreg_t acc[8];
  358.   unsigned char accg[8];
  359.   frv_elf_fpreg_t fsr[1];
  360. ‌} frv_elf_fpregset_t;

  362. /* Register maps.  */

  364. ‌static const struct regcache_map_entry frv_linux_gregmap[] =
  365.   {
  366.     { 1, psr_regnum, 4 },
  367.     { 1, REGCACHE_MAP_SKIP, 4 }, /* isr */
  368.     { 1, ccr_regnum, 4 },
  369.     { 1, cccr_regnum, 4 },
  370.     { 1, lr_regnum, 4 },
  371.     { 1, lcr_regnum, 4 },
  372.     { 1, pc_regnum, 4 },
  373.     { 1, REGCACHE_MAP_SKIP, 4 }, /* __status */
  374.     { 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */
  375.     { 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */
  376.     { 1, gner0_regnum, 4 },
  377.     { 1, gner1_regnum, 4 },
  378.     { 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */
  379.     { 1, tbr_regnum, 4 },
  380.     { 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */

  382.     /* Technically, the loadmap addresses are not part of `pr_reg' as
  383.        found in the elf_prstatus struct.  The fields which communicate
  384.        the loadmap address appear (by design) immediately after
  385.        `pr_reg' though, and the BFD function elf32_frv_grok_prstatus()
  386.        has been implemented to include these fields in the register
  387.        section that it extracts from the core file.  So, for our
  388.        purposes, they may be viewed as registers.  */

  390.     { 1, fdpic_loadmap_exec_regnum, 4 },
  391.     { 1, fdpic_loadmap_interp_regnum, 4 },
  392.     { 0 }
  393.   };

  395. ‌static const struct regcache_map_entry frv_linux_fpregmap[] =
  396.   {
  397.     { 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */
  398.     { 1, fner0_regnum, 4 },
  399.     { 1, fner1_regnum, 4 },
  400.     { 1, msr0_regnum, 4 },
  401.     { 1, msr1_regnum, 4 },
  402.     { 8, acc0_regnum, 4 },        /* acc0 ... acc7 */
  403.     { 1, accg0123_regnum, 4 },
  404.     { 1, accg4567_regnum, 4 },
  405.     { 1, fsr0_regnum, 4 },
  406.     { 0 }
  407.   };

  409. /* Unpack an frv_elf_gregset_t into GDB's register cache.  */

  411. static void
  412. ‌frv_linux_supply_gregset (const struct regset *regset,
  413.                           struct regcache *regcache,
  414.                           int regnum, const void *gregs, size_t len)
  415. {
  416.   int regi;
  417.   char zerobuf[MAX_REGISTER_SIZE];

  419.   memset (zerobuf, 0, MAX_REGISTER_SIZE);

  421.   /* gr0 always contains 0.  Also, the kernel passes the TBR value in
  422.      this slot.  */
  423.   regcache_raw_supply (regcache, first_gpr_regnum, zerobuf);

  425.   /* Fill gr32, ..., gr63 with zeros. */
  426.   for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++)
  427.     regcache_raw_supply (regcache, regi, zerobuf);

  429.   regcache_supply_regset (regset, regcache, regnum, gregs, len);
  430. }

  432. /* FRV Linux kernel register sets.  */

  434. ‌static const struct regset frv_linux_gregset =
  435. {
  436.   frv_linux_gregmap,
  437.   frv_linux_supply_gregset, regcache_collect_regset
  438. };

  440. ‌static const struct regset frv_linux_fpregset =
  441. {
  442.   frv_linux_fpregmap,
  443.   regcache_supply_regset, regcache_collect_regset
  444. };

  446. static void
  447. ‌frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
  448.                                         iterate_over_regset_sections_cb *cb,
  449.                                         void *cb_data,
  450.                                         const struct regcache *regcache)
  451. {
  452.   cb (".reg", sizeof (frv_elf_gregset_t), &frv_linux_gregset,
  453.       NULL, cb_data);
  454.   cb (".reg2", sizeof (frv_elf_fpregset_t), &frv_linux_fpregset,
  455.       NULL, cb_data);
  456. }


  459. static void
  460. ‌frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
  461. {
  462.   linux_init_abi (info, gdbarch);

  464.   /* Set the sigtramp frame sniffer.  */
  465.   frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind);

  467.   set_gdbarch_iterate_over_regset_sections
  468.     (gdbarch, frv_linux_iterate_over_regset_sections);
  469. }

  471. static enum gdb_osabi
  472. ‌frv_linux_elf_osabi_sniffer (bfd *abfd)
  473. {
  474.   int elf_flags;

  476.   elf_flags = elf_elfheader (abfd)->e_flags;

  478.   /* Assume GNU/Linux if using the FDPIC ABI.  If/when another OS shows
  479.      up that uses this ABI, we'll need to start using .note sections
  480.      or some such.  */
  481.   if (elf_flags & EF_FRV_FDPIC)
  482.     return GDB_OSABI_LINUX;
  483.   else
  484.     return GDB_OSABI_UNKNOWN;
  485. }

  487. /* Provide a prototype to silence -Wmissing-prototypes.  */
  488. void _initialize_frv_linux_tdep (void);

  490. void
  491. ‌_initialize_frv_linux_tdep (void)
  492. {
  493.   gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
  494.                           frv_linux_init_abi);
  495.   gdbarch_register_osabi_sniffer (bfd_arch_frv,
  496.                                   bfd_target_elf_flavour,
  497.                                   frv_linux_elf_osabi_sniffer);
  498. }