gdb/hppa-linux-nat.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Functions specific to running GDB native on HPPA running GNU/Linux.

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

  5.    This file is part of GDB.

  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.

  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.

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

  20. #include "defs.h"
  21. #include "gdbcore.h"
  22. #include "regcache.h"
  23. #include "inferior.h"
  24. #include "target.h"
  25. #include "linux-nat.h"

  27. #include <sys/procfs.h>
  28. #include <sys/ptrace.h>
  29. #include <linux/version.h>

  31. #include <asm/ptrace.h>
  32. #include "hppa-linux-offsets.h"

  34. #include "hppa-tdep.h"

  36. /* Prototypes for supply_gregset etc.  */
  37. #include "gregset.h"

  39. /* These must match the order of the register names.

  41.    Some sort of lookup table is needed because the offsets associated
  42.    with the registers are all over the board.  */

  44. ‌static const int u_offsets[] =
  45.   {
  46.     /* general registers */
  47.     -1,
  48.     PT_GR1,
  49.     PT_GR2,
  50.     PT_GR3,
  51.     PT_GR4,
  52.     PT_GR5,
  53.     PT_GR6,
  54.     PT_GR7,
  55.     PT_GR8,
  56.     PT_GR9,
  57.     PT_GR10,
  58.     PT_GR11,
  59.     PT_GR12,
  60.     PT_GR13,
  61.     PT_GR14,
  62.     PT_GR15,
  63.     PT_GR16,
  64.     PT_GR17,
  65.     PT_GR18,
  66.     PT_GR19,
  67.     PT_GR20,
  68.     PT_GR21,
  69.     PT_GR22,
  70.     PT_GR23,
  71.     PT_GR24,
  72.     PT_GR25,
  73.     PT_GR26,
  74.     PT_GR27,
  75.     PT_GR28,
  76.     PT_GR29,
  77.     PT_GR30,
  78.     PT_GR31,

  80.     PT_SAR,
  81.     PT_IAOQ0,
  82.     PT_IASQ0,
  83.     PT_IAOQ1,
  84.     PT_IASQ1,
  85.     -1, /* eiem */
  86.     PT_IIR,
  87.     PT_ISR,
  88.     PT_IOR,
  89.     PT_PSW,
  90.     -1, /* goto */

  92.     PT_SR4,
  93.     PT_SR0,
  94.     PT_SR1,
  95.     PT_SR2,
  96.     PT_SR3,
  97.     PT_SR5,
  98.     PT_SR6,
  99.     PT_SR7,

  101.     -1, /* cr0 */
  102.     -1, /* pid0 */
  103.     -1, /* pid1 */
  104.     -1, /* ccr */
  105.     -1, /* pid2 */
  106.     -1, /* pid3 */
  107.     -1, /* cr24 */
  108.     -1, /* cr25 */
  109.     -1, /* cr26 */
  110.     PT_CR27,
  111.     -1, /* cr28 */
  112.     -1, /* cr29 */
  113.     -1, /* cr30 */

  115.     /* Floating point regs.  */
  116.     PT_FR0,  PT_FR0 + 4,
  117.     PT_FR1,  PT_FR1 + 4,
  118.     PT_FR2,  PT_FR2 + 4,
  119.     PT_FR3,  PT_FR3 + 4,
  120.     PT_FR4,  PT_FR4 + 4,
  121.     PT_FR5,  PT_FR5 + 4,
  122.     PT_FR6,  PT_FR6 + 4,
  123.     PT_FR7,  PT_FR7 + 4,
  124.     PT_FR8,  PT_FR8 + 4,
  125.     PT_FR9,  PT_FR9 + 4,
  126.     PT_FR10, PT_FR10 + 4,
  127.     PT_FR11, PT_FR11 + 4,
  128.     PT_FR12, PT_FR12 + 4,
  129.     PT_FR13, PT_FR13 + 4,
  130.     PT_FR14, PT_FR14 + 4,
  131.     PT_FR15, PT_FR15 + 4,
  132.     PT_FR16, PT_FR16 + 4,
  133.     PT_FR17, PT_FR17 + 4,
  134.     PT_FR18, PT_FR18 + 4,
  135.     PT_FR19, PT_FR19 + 4,
  136.     PT_FR20, PT_FR20 + 4,
  137.     PT_FR21, PT_FR21 + 4,
  138.     PT_FR22, PT_FR22 + 4,
  139.     PT_FR23, PT_FR23 + 4,
  140.     PT_FR24, PT_FR24 + 4,
  141.     PT_FR25, PT_FR25 + 4,
  142.     PT_FR26, PT_FR26 + 4,
  143.     PT_FR27, PT_FR27 + 4,
  144.     PT_FR28, PT_FR28 + 4,
  145.     PT_FR29, PT_FR29 + 4,
  146.     PT_FR30, PT_FR30 + 4,
  147.     PT_FR31, PT_FR31 + 4,
  148.   };

  150. static CORE_ADDR
  151. ‌hppa_linux_register_addr (int regno, CORE_ADDR blockend)
  152. {
  153.   CORE_ADDR addr;

  155.   if ((unsigned) regno >= ARRAY_SIZE (u_offsets))
  156.     error (_("Invalid register number %d."), regno);

  158.   if (u_offsets[regno] == -1)
  159.     addr = 0;
  160.   else
  161.     {
  162.       addr = (CORE_ADDR) u_offsets[regno];
  163.     }

  165.   return addr;
  166. }

  168. /*
  169. * Registers saved in a coredump:
  170. * gr0..gr31
  171. * sr0..sr7
  172. * iaoq0..iaoq1
  173. * iasq0..iasq1
  174. * sar, iir, isr, ior, ipsw
  175. * cr0, cr24..cr31
  176. * cr8,9,12,13
  177. * cr10, cr15
  178. */
  179. ‌#define GR_REGNUM(_n)        (HPPA_R0_REGNUM+_n)
  180. ‌#define TR_REGNUM(_n)        (HPPA_TR0_REGNUM+_n)
  181. ‌static const int greg_map[] =
  182.   {
  183.     GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
  184.     GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
  185.     GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
  186.     GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
  187.     GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
  188.     GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
  189.     GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
  190.     GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),

  192.     HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
  193.     HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,

  195.     HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
  196.     HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,

  198.     HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
  199.     HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,

  201.     TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
  202.     TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),

  204.     HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
  205.     HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
  206.   };



  210. /* Fetch one register.  */

  212. static void
  213. ‌fetch_register (struct regcache *regcache, int regno)
  214. {
  215.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  216.   int tid;
  217.   int val;

  219.   if (gdbarch_cannot_fetch_register (gdbarch, regno))
  220.     {
  221.       regcache_raw_supply (regcache, regno, NULL);
  222.       return;
  223.     }

  225.   /* GNU/Linux LWP ID's are process ID's.  */
  226.   tid = ptid_get_lwp (inferior_ptid);
  227.   if (tid == 0)
  228.     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */

  230.   errno = 0;
  231.   val = ptrace (PTRACE_PEEKUSER, tid, hppa_linux_register_addr (regno, 0), 0);
  232.   if (errno != 0)
  233.     error (_("Couldn't read register %s (#%d): %s."),
  234.            gdbarch_register_name (gdbarch, regno),
  235.            regno, safe_strerror (errno));

  237.   regcache_raw_supply (regcache, regno, &val);
  238. }

  240. /* Store one register.  */

  242. static void
  243. ‌store_register (const struct regcache *regcache, int regno)
  244. {
  245.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  246.   int tid;
  247.   int val;

  249.   if (gdbarch_cannot_store_register (gdbarch, regno))
  250.     return;

  252.   /* GNU/Linux LWP ID's are process ID's.  */
  253.   tid = ptid_get_lwp (inferior_ptid);
  254.   if (tid == 0)
  255.     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */

  257.   errno = 0;
  258.   regcache_raw_collect (regcache, regno, &val);
  259.   ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val);
  260.   if (errno != 0)
  261.     error (_("Couldn't write register %s (#%d): %s."),
  262.            gdbarch_register_name (gdbarch, regno),
  263.            regno, safe_strerror (errno));
  264. }

  266. /* Fetch registers from the child process.  Fetch all registers if
  267.    regno == -1, otherwise fetch all general registers or all floating
  268.    point registers depending upon the value of regno.  */

  270. static void
  271. ‌hppa_linux_fetch_inferior_registers (struct target_ops *ops,
  272.                                      struct regcache *regcache, int regno)
  273. {
  274.   if (-1 == regno)
  275.     {
  276.       for (regno = 0;
  277.            regno < gdbarch_num_regs (get_regcache_arch (regcache));
  278.            regno++)
  279.         fetch_register (regcache, regno);
  280.     }
  281.   else
  282.     {
  283.       fetch_register (regcache, regno);
  284.     }
  285. }

  287. /* Store registers back into the inferior.  Store all registers if
  288.    regno == -1, otherwise store all general registers or all floating
  289.    point registers depending upon the value of regno.  */

  291. static void
  292. ‌hppa_linux_store_inferior_registers (struct target_ops *ops,
  293.                                      struct regcache *regcache, int regno)
  294. {
  295.   if (-1 == regno)
  296.     {
  297.       for (regno = 0;
  298.            regno < gdbarch_num_regs (get_regcache_arch (regcache));
  299.            regno++)
  300.         store_register (regcache, regno);
  301.     }
  302.   else
  303.     {
  304.       store_register (regcache, regno);
  305.     }
  306. }

  308. /* Fill GDB's register array with the general-purpose register values
  309.    in *gregsetp.  */

  311. void
  312. ‌supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
  313. {
  314.   int i;
  315.   const greg_t *regp = (const elf_greg_t *) gregsetp;

  317.   for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
  318.     {
  319.       int regno = greg_map[i];
  320.       regcache_raw_supply (regcache, regno, regp);
  321.     }
  322. }

  324. /* Fill register regno (if it is a general-purpose register) in
  325.    *gregsetp with the appropriate value from GDB's register array.
  326.    If regno is -1, do this for all registers.  */

  328. void
  329. ‌fill_gregset (const struct regcache *regcache,
  330.               gdb_gregset_t *gregsetp, int regno)
  331. {
  332.   int i;

  334.   for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++)
  335.     {
  336.       int mregno = greg_map[i];

  338.       if (regno == -1 || regno == mregno)
  339.         {
  340.           regcache_raw_collect(regcache, mregno, &(*gregsetp)[i]);
  341.         }
  342.     }
  343. }

  345. /*  Given a pointer to a floating point register set in /proc format
  346.    (fpregset_t *), unpack the register contents and supply them as gdb's
  347.    idea of the current floating point register values.  */

  349. void
  350. ‌supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
  351. {
  352.   int regi;
  353.   const char *from;

  355.   for (regi = 0; regi <= 31; regi++)
  356.     {
  357.       from = (const char *) &((*fpregsetp)[regi]);
  358.       regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM, from);
  359.       regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM + 1, from + 4);
  360.     }
  361. }

  363. /*  Given a pointer to a floating point register set in /proc format
  364.    (fpregset_t *), update the register specified by REGNO from gdb's idea
  365.    of the current floating point register set.  If REGNO is -1, update
  366.    them all.  */

  368. void
  369. ‌fill_fpregset (const struct regcache *regcache,
  370.                gdb_fpregset_t *fpregsetp, int regno)
  371. {
  372.   int i;

  374.   for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32 * 2; i++)
  375.    {
  376.       /* Gross.  fpregset_t is double, registers[x] has single
  377.          precision reg.  */
  378.       char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]);
  379.       if ((i - HPPA_FP0_REGNUM) & 1)
  380.         to += 4;
  381.       regcache_raw_collect (regcache, i, to);
  382.    }
  383. }

  385. void _initialize_hppa_linux_nat (void);

  387. void
  388. ‌_initialize_hppa_linux_nat (void)
  389. {
  390.   struct target_ops *t;

  392.   /* Fill in the generic GNU/Linux methods.  */
  393.   t = linux_target ();

  395.   /* Add our register access methods.  */
  396.   t->to_fetch_registers = hppa_linux_fetch_inferior_registers;
  397.   t->to_store_registers = hppa_linux_store_inferior_registers;

  399.   /* Register the target.  */
  400.   linux_nat_add_target (t);
  401. }