gdb/hppa-linux-nat.c

   1 /* Functions specific to running GDB native on HPPA running GNU/Linux.
   2
   3    Copyright (C) 2004-2018 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 "gdbcore.h"
  22 #include "regcache.h"
  23 #include "inferior.h"
  24 #include "target.h"
  25 #include "linux-nat.h"
  26 #include "inf-ptrace.h"
  27
  28 #include <sys/procfs.h>
  29 #include "nat/gdb_ptrace.h"
  30 #include <linux/version.h>
  31
  32 #include <asm/ptrace.h>
  33 #include "hppa-linux-offsets.h"
  34
  35 #include "hppa-tdep.h"
  36
  37 class hppa_linux_nat_target final : public linux_nat_target
  38 {
  39 public:
  40   /* Add our register access methods.  */
  41   void fetch_registers (struct regcache *, int) override;
  42   void store_registers (struct regcache *, int) override;
  43 };
  44
  45 static hppa_linux_nat_target the_hppa_linux_nat_target;
  46
  47 /* Prototypes for supply_gregset etc.  */
  48 #include "gregset.h"
  49
  50 /* These must match the order of the register names.
  51
  52    Some sort of lookup table is needed because the offsets associated
  53    with the registers are all over the board.  */
  54
  55 static const int u_offsets[] =
  56   {
  57     /* general registers */
  58     -1,
  59     PT_GR1,
  60     PT_GR2,
  61     PT_GR3,
  62     PT_GR4,
  63     PT_GR5,
  64     PT_GR6,
  65     PT_GR7,
  66     PT_GR8,
  67     PT_GR9,
  68     PT_GR10,
  69     PT_GR11,
  70     PT_GR12,
  71     PT_GR13,
  72     PT_GR14,
  73     PT_GR15,
  74     PT_GR16,
  75     PT_GR17,
  76     PT_GR18,
  77     PT_GR19,
  78     PT_GR20,
  79     PT_GR21,
  80     PT_GR22,
  81     PT_GR23,
  82     PT_GR24,
  83     PT_GR25,
  84     PT_GR26,
  85     PT_GR27,
  86     PT_GR28,
  87     PT_GR29,
  88     PT_GR30,
  89     PT_GR31,
  90
  91     PT_SAR,
  92     PT_IAOQ0,
  93     PT_IASQ0,
  94     PT_IAOQ1,
  95     PT_IASQ1,
  96     -1, /* eiem */
  97     PT_IIR,
  98     PT_ISR,
  99     PT_IOR,
 100     PT_PSW,
 101     -1, /* goto */
 102
 103     PT_SR4,
 104     PT_SR0,
 105     PT_SR1,
 106     PT_SR2,
 107     PT_SR3,
 108     PT_SR5,
 109     PT_SR6,
 110     PT_SR7,
 111
 112     -1, /* cr0 */
 113     -1, /* pid0 */
 114     -1, /* pid1 */
 115     -1, /* ccr */
 116     -1, /* pid2 */
 117     -1, /* pid3 */
 118     -1, /* cr24 */
 119     -1, /* cr25 */
 120     -1, /* cr26 */
 121     PT_CR27,
 122     -1, /* cr28 */
 123     -1, /* cr29 */
 124     -1, /* cr30 */
 125
 126     /* Floating point regs.  */
 127     PT_FR0,  PT_FR0 + 4,
 128     PT_FR1,  PT_FR1 + 4,
 129     PT_FR2,  PT_FR2 + 4,
 130     PT_FR3,  PT_FR3 + 4,
 131     PT_FR4,  PT_FR4 + 4,
 132     PT_FR5,  PT_FR5 + 4,
 133     PT_FR6,  PT_FR6 + 4,
 134     PT_FR7,  PT_FR7 + 4,
 135     PT_FR8,  PT_FR8 + 4,
 136     PT_FR9,  PT_FR9 + 4,
 137     PT_FR10, PT_FR10 + 4,
 138     PT_FR11, PT_FR11 + 4,
 139     PT_FR12, PT_FR12 + 4,
 140     PT_FR13, PT_FR13 + 4,
 141     PT_FR14, PT_FR14 + 4,
 142     PT_FR15, PT_FR15 + 4,
 143     PT_FR16, PT_FR16 + 4,
 144     PT_FR17, PT_FR17 + 4,
 145     PT_FR18, PT_FR18 + 4,
 146     PT_FR19, PT_FR19 + 4,
 147     PT_FR20, PT_FR20 + 4,
 148     PT_FR21, PT_FR21 + 4,
 149     PT_FR22, PT_FR22 + 4,
 150     PT_FR23, PT_FR23 + 4,
 151     PT_FR24, PT_FR24 + 4,
 152     PT_FR25, PT_FR25 + 4,
 153     PT_FR26, PT_FR26 + 4,
 154     PT_FR27, PT_FR27 + 4,
 155     PT_FR28, PT_FR28 + 4,
 156     PT_FR29, PT_FR29 + 4,
 157     PT_FR30, PT_FR30 + 4,
 158     PT_FR31, PT_FR31 + 4,
 159   };
 160
 161 static CORE_ADDR
 162 hppa_linux_register_addr (int regno, CORE_ADDR blockend)
 163 {
 164   CORE_ADDR addr;
 165
 166   if ((unsigned) regno >= ARRAY_SIZE (u_offsets))
 167     error (_("Invalid register number %d."), regno);
 168
 169   if (u_offsets[regno] == -1)
 170     addr = 0;
 171   else
 172     {
 173       addr = (CORE_ADDR) u_offsets[regno];
 174     }
 175
 176   return addr;
 177 }
 178
 179 /*
 180  * Registers saved in a coredump:
 181  * gr0..gr31
 182  * sr0..sr7
 183  * iaoq0..iaoq1
 184  * iasq0..iasq1
 185  * sar, iir, isr, ior, ipsw
 186  * cr0, cr24..cr31
 187  * cr8,9,12,13
 188  * cr10, cr15
 189  */
 190 #define GR_REGNUM(_n)   (HPPA_R0_REGNUM+_n)
 191 #define TR_REGNUM(_n)   (HPPA_TR0_REGNUM+_n)
 192 static const int greg_map[] =
 193   {
 194     GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
 195     GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
 196     GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
 197     GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
 198     GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
 199     GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
 200     GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
 201     GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
 202
 203     HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
 204     HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
 205
 206     HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
 207     HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
 208
 209     HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
 210     HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
 211
 212     TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
 213     TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
 214
 215     HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
 216     HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
 217   };
 218
 219
 220
 221 /* Fetch one register.  */
 222
 223 static void
 224 fetch_register (struct regcache *regcache, int regno)
 225 {
 226   struct gdbarch *gdbarch = regcache->arch ();
 227   pid_t tid;
 228   int val;
 229
 230   if (gdbarch_cannot_fetch_register (gdbarch, regno))
 231     {
 232       regcache->raw_supply (regno, NULL);
 233       return;
 234     }
 235
 236   tid = get_ptrace_pid (regcache->ptid ());
 237
 238   errno = 0;
 239   val = ptrace (PTRACE_PEEKUSER, tid, hppa_linux_register_addr (regno, 0), 0);
 240   if (errno != 0)
 241     error (_("Couldn't read register %s (#%d): %s."),
 242            gdbarch_register_name (gdbarch, regno),
 243            regno, safe_strerror (errno));
 244
 245   regcache->raw_supply (regno, &val);
 246 }
 247
 248 /* Store one register.  */
 249
 250 static void
 251 store_register (const struct regcache *regcache, int regno)
 252 {
 253   struct gdbarch *gdbarch = regcache->arch ();
 254   pid_t tid;
 255   int val;
 256
 257   if (gdbarch_cannot_store_register (gdbarch, regno))
 258     return;
 259
 260   tid = get_ptrace_pid (regcache->ptid ());
 261
 262   errno = 0;
 263   regcache->raw_collect (regno, &val);
 264   ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val);
 265   if (errno != 0)
 266     error (_("Couldn't write register %s (#%d): %s."),
 267            gdbarch_register_name (gdbarch, regno),
 268            regno, safe_strerror (errno));
 269 }
 270
 271 /* Fetch registers from the child process.  Fetch all registers if
 272    regno == -1, otherwise fetch all general registers or all floating
 273    point registers depending upon the value of regno.  */
 274
 275 void
 276 hppa_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
 277 {
 278   if (-1 == regno)
 279     {
 280       for (regno = 0;
 281            regno < gdbarch_num_regs (regcache->arch ());
 282            regno++)
 283         fetch_register (regcache, regno);
 284     }
 285   else
 286     {
 287       fetch_register (regcache, regno);
 288     }
 289 }
 290
 291 /* Store registers back into the inferior.  Store all registers if
 292    regno == -1, otherwise store all general registers or all floating
 293    point registers depending upon the value of regno.  */
 294
 295 void
 296 hppa_linux_nat_target::store_registers (struct regcache *regcache, int regno)
 297 {
 298   if (-1 == regno)
 299     {
 300       for (regno = 0;
 301            regno < gdbarch_num_regs (regcache->arch ());
 302            regno++)
 303         store_register (regcache, regno);
 304     }
 305   else
 306     {
 307       store_register (regcache, regno);
 308     }
 309 }
 310
 311 /* Fill GDB's register array with the general-purpose register values
 312    in *gregsetp.  */
 313
 314 void
 315 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 316 {
 317   int i;
 318   const greg_t *regp = (const elf_greg_t *) gregsetp;
 319
 320   for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
 321     {
 322       int regno = greg_map[i];
 323       regcache->raw_supply (regno, regp);
 324     }
 325 }
 326
 327 /* Fill register regno (if it is a general-purpose register) in
 328    *gregsetp with the appropriate value from GDB's register array.
 329    If regno is -1, do this for all registers.  */
 330
 331 void
 332 fill_gregset (const struct regcache *regcache,
 333               gdb_gregset_t *gregsetp, int regno)
 334 {
 335   int i;
 336
 337   for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++)
 338     {
 339       int mregno = greg_map[i];
 340
 341       if (regno == -1 || regno == mregno)
 342         regcache->raw_collect (mregno, &(*gregsetp)[i]);
 343     }
 344 }
 345
 346 /*  Given a pointer to a floating point register set in /proc format
 347    (fpregset_t *), unpack the register contents and supply them as gdb's
 348    idea of the current floating point register values.  */
 349
 350 void
 351 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 352 {
 353   int regi;
 354   const char *from;
 355
 356   for (regi = 0; regi <= 31; regi++)
 357     {
 358       from = (const char *) &((*fpregsetp)[regi]);
 359       regcache->raw_supply (2*regi + HPPA_FP0_REGNUM, from);
 360       regcache->raw_supply (2*regi + HPPA_FP0_REGNUM + 1, from + 4);
 361     }
 362 }
 363
 364 /*  Given a pointer to a floating point register set in /proc format
 365    (fpregset_t *), update the register specified by REGNO from gdb's idea
 366    of the current floating point register set.  If REGNO is -1, update
 367    them all.  */
 368
 369 void
 370 fill_fpregset (const struct regcache *regcache,
 371                gdb_fpregset_t *fpregsetp, int regno)
 372 {
 373   int i;
 374
 375   for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32 * 2; i++)
 376    {
 377       /* Gross.  fpregset_t is double, registers[x] has single
 378          precision reg.  */
 379       char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]);
 380       if ((i - HPPA_FP0_REGNUM) & 1)
 381         to += 4;
 382       regcache->raw_collect (i, to);
 383    }
 384 }
 385
 386 void
 387 _initialize_hppa_linux_nat (void)
 388 {
 389   /* Register the target.  */
 390   linux_target = &the_hppa_linux_nat_target;
 391   add_inf_child_target (&the_hppa_linux_nat_target);
 392 }