gdb/hppa-hpux-nat.c - gdb

Functions defined

Macros defined

Source code

  1. /* Native-dependent code for PA-RISC HP-UX.

  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 "inferior.h"
  22. #include "regcache.h"
  23. #include "target.h"

  25. #include <sys/ptrace.h>
  26. #include <sys/utsname.h>
  27. #include <machine/save_state.h>

  29. #ifdef HAVE_TTRACE
  30. #include <sys/ttrace.h>
  31. #endif

  33. #include "hppa-tdep.h"
  34. #include "solib-som.h"
  35. #include "inf-ptrace.h"
  36. #include "inf-ttrace.h"

  38. /* Return the offset of register REGNUM within `struct save_state'.
  39.    The offset returns depends on the flags in the "flags" register and
  40.    the register size (32-bit or 64-bit).  These are taken from
  41.    REGCACHE.  */

  43. static LONGEST
  44. ‌hppa_hpux_save_state_offset (struct regcache *regcache, int regnum)
  45. {
  46.   LONGEST offset;

  48.   if (regnum == HPPA_FLAGS_REGNUM)
  49.     return ssoff (ss_flags);

  51.   if (HPPA_R0_REGNUM < regnum && regnum < HPPA_FP0_REGNUM)
  52.     {
  53.       struct gdbarch *arch = get_regcache_arch (regcache);
  54.       size_t size = register_size (arch, HPPA_R1_REGNUM);
  55.       ULONGEST flags;

  57.       gdb_assert (size == 4 || size == 8);

  59.       regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
  60.       if (flags & SS_WIDEREGS)
  61.         offset = ssoff (ss_wide) + (8 - size) + (regnum - HPPA_R0_REGNUM) * 8;
  62.       else
  63.         offset = ssoff (ss_narrow) + (regnum - HPPA_R1_REGNUM) * 4;
  64.     }
  65.   else
  66.     {
  67.       struct gdbarch *arch = get_regcache_arch (regcache);
  68.       size_t size = register_size (arch, HPPA_FP0_REGNUM);

  70.       gdb_assert (size == 4 || size == 8);
  71.       gdb_assert (regnum >= HPPA_FP0_REGNUM);
  72.       offset = ssoff(ss_fpblock) + (regnum - HPPA_FP0_REGNUM) * size;
  73.     }

  75.   gdb_assert (offset < sizeof (save_state_t));
  76.   return offset;
  77. }

  79. /* Just in case a future version of PA-RISC HP-UX won't have ptrace(2)
  80.    at all.  */
  81. #ifndef PTRACE_TYPE_RET
  82. ‌#define PTRACE_TYPE_RET void
  83. #endif

  85. static void
  86. ‌hppa_hpux_fetch_register (struct regcache *regcache, int regnum)
  87. {
  88.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  89.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  90.   CORE_ADDR addr;
  91.   size_t size;
  92.   PTRACE_TYPE_RET *buf;
  93.   pid_t pid;
  94.   int i;

  96.   pid = ptid_get_pid (inferior_ptid);

  98.   /* This isn't really an address, but ptrace thinks of it as one.  */
  99.   addr = hppa_hpux_save_state_offset (regcache, regnum);
  100.   size = register_size (gdbarch, regnum);

  102.   gdb_assert (size == 4 || size == 8);
  103.   buf = alloca (size);

  105. #ifdef HAVE_TTRACE
  106.   {
  107.     lwpid_t lwp = ptid_get_lwp (inferior_ptid);

  109.     if (ttrace (TT_LWP_RUREGS, pid, lwp, addr, size, (uintptr_t)buf) == -1)
  110.       error (_("Couldn't read register %s (#%d): %s"),
  111.              gdbarch_register_name (gdbarch, regnum),
  112.              regnum, safe_strerror (errno));
  113.   }
  114. #else
  115.   {
  116.     int i;

  118.     /* Read the register contents from the inferior a chuck at the time.  */
  119.     for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
  120.       {
  121.         errno = 0;
  122.         buf[i] = ptrace (PT_RUREGS, pid, (PTRACE_TYPE_ARG3) addr, 0, 0);
  123.         if (errno != 0)
  124.           error (_("Couldn't read register %s (#%d): %s"),
  125.                  gdbarch_register_name (gdbarch, regnum),
  126.                  regnum, safe_strerror (errno));

  128.         addr += sizeof (PTRACE_TYPE_RET);
  129.       }
  130.   }
  131. #endif

  133.   /* Take care with the "flags" register.  It's stored as an `int' in
  134.      `struct save_state', even for 64-bit code.  */
  135.   if (regnum == HPPA_FLAGS_REGNUM && size == 8)
  136.     {
  137.       ULONGEST flags;
  138.       flags = extract_unsigned_integer ((gdb_byte *)buf, 4, byte_order);
  139.       store_unsigned_integer ((gdb_byte *)buf, 8, byte_order, flags);
  140.     }

  142.   regcache_raw_supply (regcache, regnum, buf);
  143. }

  145. static void
  146. ‌hppa_hpux_fetch_inferior_registers (struct target_ops *ops,
  147.                                     struct regcache *regcache, int regnum)
  148. {
  149.   if (regnum == -1)
  150.     for (regnum = 0;
  151.          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
  152.          regnum++)
  153.       hppa_hpux_fetch_register (regcache, regnum);
  154.   else
  155.     hppa_hpux_fetch_register (regcache, regnum);
  156. }

  158. /* Store register REGNUM into the inferior.  */

  160. static void
  161. ‌hppa_hpux_store_register (struct regcache *regcache, int regnum)
  162. {
  163.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  164.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  165.   CORE_ADDR addr;
  166.   size_t size;
  167.   PTRACE_TYPE_RET *buf;
  168.   pid_t pid;

  170.   pid = ptid_get_pid (inferior_ptid);

  172.   /* This isn't really an address, but ptrace thinks of it as one.  */
  173.   addr = hppa_hpux_save_state_offset (regcache, regnum);
  174.   size = register_size (gdbarch, regnum);

  176.   gdb_assert (size == 4 || size == 8);
  177.   buf = alloca (size);

  179.   regcache_raw_collect (regcache, regnum, buf);

  181.   /* Take care with the "flags" register.  It's stored as an `int' in
  182.      `struct save_state', even for 64-bit code.  */
  183.   if (regnum == HPPA_FLAGS_REGNUM && size == 8)
  184.     {
  185.       ULONGEST flags;
  186.       flags = extract_unsigned_integer ((gdb_byte *)buf, 8, byte_order);
  187.       store_unsigned_integer ((gdb_byte *)buf, 4, byte_order, flags);
  188.       size = 4;
  189.     }

  191. #ifdef HAVE_TTRACE
  192.   {
  193.     lwpid_t lwp = ptid_get_lwp (inferior_ptid);

  195.     if (ttrace (TT_LWP_WUREGS, pid, lwp, addr, size, (uintptr_t)buf) == -1)
  196.       error (_("Couldn't write register %s (#%d): %s"),
  197.              gdbarch_register_name (gdbarch, regnum),
  198.              regnum, safe_strerror (errno));
  199.   }
  200. #else
  201.   {
  202.     int i;

  204.     /* Write the register contents into the inferior a chunk at the time.  */
  205.     for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
  206.       {
  207.         errno = 0;
  208.         ptrace (PT_WUREGS, pid, (PTRACE_TYPE_ARG3) addr, buf[i], 0);
  209.         if (errno != 0)
  210.           error (_("Couldn't write register %s (#%d): %s"),
  211.                  gdbarch_register_name (gdbarch, regnum),
  212.                  regnum, safe_strerror (errno));

  214.         addr += sizeof (PTRACE_TYPE_RET);
  215.       }
  216.   }
  217. #endif
  218. }

  220. /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
  221.    this for all registers (including the floating point registers).  */

  223. static void
  224. ‌hppa_hpux_store_inferior_registers (struct target_ops *ops,
  225.                                     struct regcache *regcache, int regnum)
  226. {
  227.   if (regnum == -1)
  228.     for (regnum = 0;
  229.          regnum < gdbarch_num_regs (get_regcache_arch (regcache));
  230.          regnum++)
  231.       hppa_hpux_store_register (regcache, regnum);
  232.   else
  233.     hppa_hpux_store_register (regcache, regnum);
  234. }

  236. /* Set hpux_major_release variable to the value retrieved from a call to
  237.    uname function.  */

  239. static void
  240. ‌set_hpux_major_release (void)
  241. {
  242.   struct utsname x;
  243.   char *p;

  245.   uname (&x);
  246.   p = strchr (x.release, '.');
  247.   if (p)
  248.     hpux_major_release = atoi (p + 1);
  249. }



  253. /* Prevent warning from -Wmissing-prototypes.  */
  254. void _initialize_hppa_hpux_nat (void);

  256. void
  257. ‌_initialize_hppa_hpux_nat (void)
  258. {
  259.   struct target_ops *t;

  261.   set_hpux_major_release ();

  263. #ifdef HAVE_TTRACE
  264.   t = inf_ttrace_target ();
  265. #else
  266.   t = inf_ptrace_target ();
  267. #endif

  269.   t->to_fetch_registers = hppa_hpux_fetch_inferior_registers;
  270.   t->to_store_registers = hppa_hpux_store_inferior_registers;

  272.   add_target (t);
  273. }