gdb/hppa-linux-nat.c

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