gdb/ppc-linux-nat.c

   1 /* PPC GNU/Linux native support.
   2
   3    Copyright (C) 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002, 2003,
   4    2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   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.
  12
  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.
  17
  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/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "gdbcore.h"
  26 #include "regcache.h"
  27 #include "gdb_assert.h"
  28 #include "target.h"
  29 #include "linux-nat.h"
  30
  31 #include <stdint.h>
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34 #include <signal.h>
  35 #include <sys/user.h>
  36 #include <sys/ioctl.h>
  37 #include "gdb_wait.h"
  38 #include <fcntl.h>
  39 #include <sys/procfs.h>
  40 #include <sys/ptrace.h>
  41
  42 /* Prototypes for supply_gregset etc. */
  43 #include "gregset.h"
  44 #include "ppc-tdep.h"
  45
  46 /* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a
  47    configure time check.  Some older glibc's (for instance 2.2.1)
  48    don't have a specific powerpc version of ptrace.h, and fall back on
  49    a generic one.  In such cases, sys/ptrace.h defines
  50    PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that
  51    ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and
  52    PTRACE_SETVRREGS to be.  This also makes a configury check pretty
  53    much useless.  */
  54
  55 /* These definitions should really come from the glibc header files,
  56    but Glibc doesn't know about the vrregs yet.  */
  57 #ifndef PTRACE_GETVRREGS
  58 #define PTRACE_GETVRREGS 18
  59 #define PTRACE_SETVRREGS 19
  60 #endif
  61
  62
  63 /* Similarly for the ptrace requests for getting / setting the SPE
  64    registers (ev0 -- ev31, acc, and spefscr).  See the description of
  65    gdb_evrregset_t for details.  */
  66 #ifndef PTRACE_GETEVRREGS
  67 #define PTRACE_GETEVRREGS 20
  68 #define PTRACE_SETEVRREGS 21
  69 #endif
  70
  71 /* Similarly for the hardware watchpoint support.  */
  72 #ifndef PTRACE_GET_DEBUGREG
  73 #define PTRACE_GET_DEBUGREG    25
  74 #endif
  75 #ifndef PTRACE_SET_DEBUGREG
  76 #define PTRACE_SET_DEBUGREG    26
  77 #endif
  78 #ifndef PTRACE_GETSIGINFO
  79 #define PTRACE_GETSIGINFO    0x4202
  80 #endif
  81
  82 /* This oddity is because the Linux kernel defines elf_vrregset_t as
  83    an array of 33 16 bytes long elements.  I.e. it leaves out vrsave.
  84    However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return
  85    the vrsave as an extra 4 bytes at the end.  I opted for creating a
  86    flat array of chars, so that it is easier to manipulate for gdb.
  87
  88    There are 32 vector registers 16 bytes longs, plus a VSCR register
  89    which is only 4 bytes long, but is fetched as a 16 bytes
  90    quantity. Up to here we have the elf_vrregset_t structure.
  91    Appended to this there is space for the VRSAVE register: 4 bytes.
  92    Even though this vrsave register is not included in the regset
  93    typedef, it is handled by the ptrace requests.
  94
  95    Note that GNU/Linux doesn't support little endian PPC hardware,
  96    therefore the offset at which the real value of the VSCR register
  97    is located will be always 12 bytes.
  98
  99    The layout is like this (where x is the actual value of the vscr reg): */
 100
 101 /* *INDENT-OFF* */
 102 /*
 103    |.|.|.|.|.....|.|.|.|.||.|.|.|x||.|
 104    <------->     <-------><-------><->
 105      VR0           VR31     VSCR    VRSAVE
 106 */
 107 /* *INDENT-ON* */
 108
 109 #define SIZEOF_VRREGS 33*16+4
 110
 111 typedef char gdb_vrregset_t[SIZEOF_VRREGS];
 112
 113
 114 /* On PPC processors that support the the Signal Processing Extension
 115    (SPE) APU, the general-purpose registers are 64 bits long.
 116    However, the ordinary Linux kernel PTRACE_PEEKUSER / PTRACE_POKEUSER
 117    ptrace calls only access the lower half of each register, to allow
 118    them to behave the same way they do on non-SPE systems.  There's a
 119    separate pair of calls, PTRACE_GETEVRREGS / PTRACE_SETEVRREGS, that
 120    read and write the top halves of all the general-purpose registers
 121    at once, along with some SPE-specific registers.
 122
 123    GDB itself continues to claim the general-purpose registers are 32
 124    bits long.  It has unnamed raw registers that hold the upper halves
 125    of the gprs, and the the full 64-bit SIMD views of the registers,
 126    'ev0' -- 'ev31', are pseudo-registers that splice the top and
 127    bottom halves together.
 128
 129    This is the structure filled in by PTRACE_GETEVRREGS and written to
 130    the inferior's registers by PTRACE_SETEVRREGS.  */
 131 struct gdb_evrregset_t
 132 {
 133   unsigned long evr[32];
 134   unsigned long long acc;
 135   unsigned long spefscr;
 136 };
 137
 138
 139 /* Non-zero if our kernel may support the PTRACE_GETVRREGS and
 140    PTRACE_SETVRREGS requests, for reading and writing the Altivec
 141    registers.  Zero if we've tried one of them and gotten an
 142    error.  */
 143 int have_ptrace_getvrregs = 1;
 144
 145 /* Non-zero if our kernel may support the PTRACE_GETEVRREGS and
 146    PTRACE_SETEVRREGS requests, for reading and writing the SPE
 147    registers.  Zero if we've tried one of them and gotten an
 148    error.  */
 149 int have_ptrace_getsetevrregs = 1;
 150
 151 /* *INDENT-OFF* */
 152 /* registers layout, as presented by the ptrace interface:
 153 PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
 154 PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_R13, PT_R14, PT_R15,
 155 PT_R16, PT_R17, PT_R18, PT_R19, PT_R20, PT_R21, PT_R22, PT_R23,
 156 PT_R24, PT_R25, PT_R26, PT_R27, PT_R28, PT_R29, PT_R30, PT_R31,
 157 PT_FPR0, PT_FPR0 + 2, PT_FPR0 + 4, PT_FPR0 + 6, PT_FPR0 + 8, PT_FPR0 + 10, PT_FPR0 + 12, PT_FPR0 + 14,
 158 PT_FPR0 + 16, PT_FPR0 + 18, PT_FPR0 + 20, PT_FPR0 + 22, PT_FPR0 + 24, PT_FPR0 + 26, PT_FPR0 + 28, PT_FPR0 + 30,
 159 PT_FPR0 + 32, PT_FPR0 + 34, PT_FPR0 + 36, PT_FPR0 + 38, PT_FPR0 + 40, PT_FPR0 + 42, PT_FPR0 + 44, PT_FPR0 + 46,
 160 PT_FPR0 + 48, PT_FPR0 + 50, PT_FPR0 + 52, PT_FPR0 + 54, PT_FPR0 + 56, PT_FPR0 + 58, PT_FPR0 + 60, PT_FPR0 + 62,
 161 PT_NIP, PT_MSR, PT_CCR, PT_LNK, PT_CTR, PT_XER, PT_MQ */
 162 /* *INDENT_ON * */
 163
 164 static int
 165 ppc_register_u_addr (int regno)
 166 {
 167   int u_addr = -1;
 168   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 169   /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
 170      interface, and not the wordsize of the program's ABI.  */
 171   int wordsize = sizeof (long);
 172
 173   /* General purpose registers occupy 1 slot each in the buffer */
 174   if (regno >= tdep->ppc_gp0_regnum
 175       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
 176     u_addr = ((regno - tdep->ppc_gp0_regnum + PT_R0) * wordsize);
 177
 178   /* Floating point regs: eight bytes each in both 32- and 64-bit
 179      ptrace interfaces.  Thus, two slots each in 32-bit interface, one
 180      slot each in 64-bit interface.  */
 181   if (tdep->ppc_fp0_regnum >= 0
 182       && regno >= tdep->ppc_fp0_regnum
 183       && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 184     u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8);
 185
 186   /* UISA special purpose registers: 1 slot each */
 187   if (regno == gdbarch_pc_regnum (current_gdbarch))
 188     u_addr = PT_NIP * wordsize;
 189   if (regno == tdep->ppc_lr_regnum)
 190     u_addr = PT_LNK * wordsize;
 191   if (regno == tdep->ppc_cr_regnum)
 192     u_addr = PT_CCR * wordsize;
 193   if (regno == tdep->ppc_xer_regnum)
 194     u_addr = PT_XER * wordsize;
 195   if (regno == tdep->ppc_ctr_regnum)
 196     u_addr = PT_CTR * wordsize;
 197 #ifdef PT_MQ
 198   if (regno == tdep->ppc_mq_regnum)
 199     u_addr = PT_MQ * wordsize;
 200 #endif
 201   if (regno == tdep->ppc_ps_regnum)
 202     u_addr = PT_MSR * wordsize;
 203   if (tdep->ppc_fpscr_regnum >= 0
 204       && regno == tdep->ppc_fpscr_regnum)
 205     {
 206       /* NOTE: cagney/2005-02-08: On some 64-bit GNU/Linux systems the
 207          kernel headers incorrectly contained the 32-bit definition of
 208          PT_FPSCR.  For the 32-bit definition, floating-point
 209          registers occupy two 32-bit "slots", and the FPSCR lives in
 210          the secondhalf of such a slot-pair (hence +1).  For 64-bit,
 211          the FPSCR instead occupies the full 64-bit 2-word-slot and
 212          hence no adjustment is necessary.  Hack around this.  */
 213       if (wordsize == 8 && PT_FPSCR == (48 + 32 + 1))
 214         u_addr = (48 + 32) * wordsize;
 215       else
 216         u_addr = PT_FPSCR * wordsize;
 217     }
 218   return u_addr;
 219 }
 220
 221 /* The Linux kernel ptrace interface for AltiVec registers uses the
 222    registers set mechanism, as opposed to the interface for all the
 223    other registers, that stores/fetches each register individually.  */
 224 static void
 225 fetch_altivec_register (struct regcache *regcache, int tid, int regno)
 226 {
 227   int ret;
 228   int offset = 0;
 229   gdb_vrregset_t regs;
 230   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 231   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 232   int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum);
 233
 234   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 235   if (ret < 0)
 236     {
 237       if (errno == EIO)
 238         {
 239           have_ptrace_getvrregs = 0;
 240           return;
 241         }
 242       perror_with_name (_("Unable to fetch AltiVec register"));
 243     }
 244
 245   /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
 246      long on the hardware.  We deal only with the lower 4 bytes of the
 247      vector.  VRSAVE is at the end of the array in a 4 bytes slot, so
 248      there is no need to define an offset for it.  */
 249   if (regno == (tdep->ppc_vrsave_regnum - 1))
 250     offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum);
 251
 252   regcache_raw_supply (regcache, regno,
 253                        regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
 254 }
 255
 256 /* Fetch the top 32 bits of TID's general-purpose registers and the
 257    SPE-specific registers, and place the results in EVRREGSET.  If we
 258    don't support PTRACE_GETEVRREGS, then just fill EVRREGSET with
 259    zeros.
 260
 261    All the logic to deal with whether or not the PTRACE_GETEVRREGS and
 262    PTRACE_SETEVRREGS requests are supported is isolated here, and in
 263    set_spe_registers.  */
 264 static void
 265 get_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
 266 {
 267   if (have_ptrace_getsetevrregs)
 268     {
 269       if (ptrace (PTRACE_GETEVRREGS, tid, 0, evrregset) >= 0)
 270         return;
 271       else
 272         {
 273           /* EIO means that the PTRACE_GETEVRREGS request isn't supported;
 274              we just return zeros.  */
 275           if (errno == EIO)
 276             have_ptrace_getsetevrregs = 0;
 277           else
 278             /* Anything else needs to be reported.  */
 279             perror_with_name (_("Unable to fetch SPE registers"));
 280         }
 281     }
 282
 283   memset (evrregset, 0, sizeof (*evrregset));
 284 }
 285
 286 /* Supply values from TID for SPE-specific raw registers: the upper
 287    halves of the GPRs, the accumulator, and the spefscr.  REGNO must
 288    be the number of an upper half register, acc, spefscr, or -1 to
 289    supply the values of all registers.  */
 290 static void
 291 fetch_spe_register (struct regcache *regcache, int tid, int regno)
 292 {
 293   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 294   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 295   struct gdb_evrregset_t evrregs;
 296
 297   gdb_assert (sizeof (evrregs.evr[0])
 298               == register_size (gdbarch, tdep->ppc_ev0_upper_regnum));
 299   gdb_assert (sizeof (evrregs.acc)
 300               == register_size (gdbarch, tdep->ppc_acc_regnum));
 301   gdb_assert (sizeof (evrregs.spefscr)
 302               == register_size (gdbarch, tdep->ppc_spefscr_regnum));
 303
 304   get_spe_registers (tid, &evrregs);
 305
 306   if (regno == -1)
 307     {
 308       int i;
 309
 310       for (i = 0; i < ppc_num_gprs; i++)
 311         regcache_raw_supply (regcache, tdep->ppc_ev0_upper_regnum + i,
 312                              &evrregs.evr[i]);
 313     }
 314   else if (tdep->ppc_ev0_upper_regnum <= regno
 315            && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
 316     regcache_raw_supply (regcache, regno,
 317                          &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
 318
 319   if (regno == -1
 320       || regno == tdep->ppc_acc_regnum)
 321     regcache_raw_supply (regcache, tdep->ppc_acc_regnum, &evrregs.acc);
 322
 323   if (regno == -1
 324       || regno == tdep->ppc_spefscr_regnum)
 325     regcache_raw_supply (regcache, tdep->ppc_spefscr_regnum,
 326                          &evrregs.spefscr);
 327 }
 328
 329 static void
 330 fetch_register (struct regcache *regcache, int tid, int regno)
 331 {
 332   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 333   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 334   /* This isn't really an address.  But ptrace thinks of it as one.  */
 335   CORE_ADDR regaddr = ppc_register_u_addr (regno);
 336   int bytes_transferred;
 337   unsigned int offset;         /* Offset of registers within the u area. */
 338   char buf[MAX_REGISTER_SIZE];
 339
 340   if (altivec_register_p (regno))
 341     {
 342       /* If this is the first time through, or if it is not the first
 343          time through, and we have comfirmed that there is kernel
 344          support for such a ptrace request, then go and fetch the
 345          register.  */
 346       if (have_ptrace_getvrregs)
 347        {
 348          fetch_altivec_register (regcache, tid, regno);
 349          return;
 350        }
 351      /* If we have discovered that there is no ptrace support for
 352         AltiVec registers, fall through and return zeroes, because
 353         regaddr will be -1 in this case.  */
 354     }
 355   else if (spe_register_p (regno))
 356     {
 357       fetch_spe_register (regcache, tid, regno);
 358       return;
 359     }
 360
 361   if (regaddr == -1)
 362     {
 363       memset (buf, '\0', register_size (gdbarch, regno));   /* Supply zeroes */
 364       regcache_raw_supply (regcache, regno, buf);
 365       return;
 366     }
 367
 368   /* Read the raw register using sizeof(long) sized chunks.  On a
 369      32-bit platform, 64-bit floating-point registers will require two
 370      transfers.  */
 371   for (bytes_transferred = 0;
 372        bytes_transferred < register_size (gdbarch, regno);
 373        bytes_transferred += sizeof (long))
 374     {
 375       errno = 0;
 376       *(long *) &buf[bytes_transferred]
 377         = ptrace (PTRACE_PEEKUSER, tid, (PTRACE_TYPE_ARG3) regaddr, 0);
 378       regaddr += sizeof (long);
 379       if (errno != 0)
 380         {
 381           char message[128];
 382           sprintf (message, "reading register %s (#%d)",
 383                    gdbarch_register_name (gdbarch, regno), regno);
 384           perror_with_name (message);
 385         }
 386     }
 387
 388   /* Now supply the register.  Keep in mind that the regcache's idea
 389      of the register's size may not be a multiple of sizeof
 390      (long).  */
 391   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
 392     {
 393       /* Little-endian values are always found at the left end of the
 394          bytes transferred.  */
 395       regcache_raw_supply (regcache, regno, buf);
 396     }
 397   else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 398     {
 399       /* Big-endian values are found at the right end of the bytes
 400          transferred.  */
 401       size_t padding = (bytes_transferred - register_size (gdbarch, regno));
 402       regcache_raw_supply (regcache, regno, buf + padding);
 403     }
 404   else
 405     internal_error (__FILE__, __LINE__,
 406                     _("fetch_register: unexpected byte order: %d"),
 407                     gdbarch_byte_order (gdbarch));
 408 }
 409
 410 static void
 411 supply_vrregset (struct regcache *regcache, gdb_vrregset_t *vrregsetp)
 412 {
 413   int i;
 414   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 415   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 416   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
 417   int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum);
 418   int offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum);
 419
 420   for (i = 0; i < num_of_vrregs; i++)
 421     {
 422       /* The last 2 registers of this set are only 32 bit long, not
 423          128.  However an offset is necessary only for VSCR because it
 424          occupies a whole vector, while VRSAVE occupies a full 4 bytes
 425          slot.  */
 426       if (i == (num_of_vrregs - 2))
 427         regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i,
 428                              *vrregsetp + i * vrregsize + offset);
 429       else
 430         regcache_raw_supply (regcache, tdep->ppc_vr0_regnum + i,
 431                              *vrregsetp + i * vrregsize);
 432     }
 433 }
 434
 435 static void
 436 fetch_altivec_registers (struct regcache *regcache, int tid)
 437 {
 438   int ret;
 439   gdb_vrregset_t regs;
 440
 441   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 442   if (ret < 0)
 443     {
 444       if (errno == EIO)
 445         {
 446           have_ptrace_getvrregs = 0;
 447           return;
 448         }
 449       perror_with_name (_("Unable to fetch AltiVec registers"));
 450     }
 451   supply_vrregset (regcache, &regs);
 452 }
 453
 454 static void
 455 fetch_ppc_registers (struct regcache *regcache, int tid)
 456 {
 457   int i;
 458   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 459   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 460
 461   for (i = 0; i < ppc_num_gprs; i++)
 462     fetch_register (regcache, tid, tdep->ppc_gp0_regnum + i);
 463   if (tdep->ppc_fp0_regnum >= 0)
 464     for (i = 0; i < ppc_num_fprs; i++)
 465       fetch_register (regcache, tid, tdep->ppc_fp0_regnum + i);
 466   fetch_register (regcache, tid, gdbarch_pc_regnum (gdbarch));
 467   if (tdep->ppc_ps_regnum != -1)
 468     fetch_register (regcache, tid, tdep->ppc_ps_regnum);
 469   if (tdep->ppc_cr_regnum != -1)
 470     fetch_register (regcache, tid, tdep->ppc_cr_regnum);
 471   if (tdep->ppc_lr_regnum != -1)
 472     fetch_register (regcache, tid, tdep->ppc_lr_regnum);
 473   if (tdep->ppc_ctr_regnum != -1)
 474     fetch_register (regcache, tid, tdep->ppc_ctr_regnum);
 475   if (tdep->ppc_xer_regnum != -1)
 476     fetch_register (regcache, tid, tdep->ppc_xer_regnum);
 477   if (tdep->ppc_mq_regnum != -1)
 478     fetch_register (regcache, tid, tdep->ppc_mq_regnum);
 479   if (tdep->ppc_fpscr_regnum != -1)
 480     fetch_register (regcache, tid, tdep->ppc_fpscr_regnum);
 481   if (have_ptrace_getvrregs)
 482     if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
 483       fetch_altivec_registers (regcache, tid);
 484   if (tdep->ppc_ev0_upper_regnum >= 0)
 485     fetch_spe_register (regcache, tid, -1);
 486 }
 487
 488 /* Fetch registers from the child process.  Fetch all registers if
 489    regno == -1, otherwise fetch all general registers or all floating
 490    point registers depending upon the value of regno.  */
 491 static void
 492 ppc_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
 493 {
 494   /* Overload thread id onto process id */
 495   int tid = TIDGET (inferior_ptid);
 496
 497   /* No thread id, just use process id */
 498   if (tid == 0)
 499     tid = PIDGET (inferior_ptid);
 500
 501   if (regno == -1)
 502     fetch_ppc_registers (regcache, tid);
 503   else
 504     fetch_register (regcache, tid, regno);
 505 }
 506
 507 /* Store one register. */
 508 static void
 509 store_altivec_register (const struct regcache *regcache, int tid, int regno)
 510 {
 511   int ret;
 512   int offset = 0;
 513   gdb_vrregset_t regs;
 514   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 515   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 516   int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum);
 517
 518   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 519   if (ret < 0)
 520     {
 521       if (errno == EIO)
 522         {
 523           have_ptrace_getvrregs = 0;
 524           return;
 525         }
 526       perror_with_name (_("Unable to fetch AltiVec register"));
 527     }
 528
 529   /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
 530      long on the hardware.  */
 531   if (regno == (tdep->ppc_vrsave_regnum - 1))
 532     offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum);
 533
 534   regcache_raw_collect (regcache, regno,
 535                         regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
 536
 537   ret = ptrace (PTRACE_SETVRREGS, tid, 0, &regs);
 538   if (ret < 0)
 539     perror_with_name (_("Unable to store AltiVec register"));
 540 }
 541
 542 /* Assuming TID referrs to an SPE process, set the top halves of TID's
 543    general-purpose registers and its SPE-specific registers to the
 544    values in EVRREGSET.  If we don't support PTRACE_SETEVRREGS, do
 545    nothing.
 546
 547    All the logic to deal with whether or not the PTRACE_GETEVRREGS and
 548    PTRACE_SETEVRREGS requests are supported is isolated here, and in
 549    get_spe_registers.  */
 550 static void
 551 set_spe_registers (int tid, struct gdb_evrregset_t *evrregset)
 552 {
 553   if (have_ptrace_getsetevrregs)
 554     {
 555       if (ptrace (PTRACE_SETEVRREGS, tid, 0, evrregset) >= 0)
 556         return;
 557       else
 558         {
 559           /* EIO means that the PTRACE_SETEVRREGS request isn't
 560              supported; we fail silently, and don't try the call
 561              again.  */
 562           if (errno == EIO)
 563             have_ptrace_getsetevrregs = 0;
 564           else
 565             /* Anything else needs to be reported.  */
 566             perror_with_name (_("Unable to set SPE registers"));
 567         }
 568     }
 569 }
 570
 571 /* Write GDB's value for the SPE-specific raw register REGNO to TID.
 572    If REGNO is -1, write the values of all the SPE-specific
 573    registers.  */
 574 static void
 575 store_spe_register (const struct regcache *regcache, int tid, int regno)
 576 {
 577   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 578   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 579   struct gdb_evrregset_t evrregs;
 580
 581   gdb_assert (sizeof (evrregs.evr[0])
 582               == register_size (gdbarch, tdep->ppc_ev0_upper_regnum));
 583   gdb_assert (sizeof (evrregs.acc)
 584               == register_size (gdbarch, tdep->ppc_acc_regnum));
 585   gdb_assert (sizeof (evrregs.spefscr)
 586               == register_size (gdbarch, tdep->ppc_spefscr_regnum));
 587
 588   if (regno == -1)
 589     /* Since we're going to write out every register, the code below
 590        should store to every field of evrregs; if that doesn't happen,
 591        make it obvious by initializing it with suspicious values.  */
 592     memset (&evrregs, 42, sizeof (evrregs));
 593   else
 594     /* We can only read and write the entire EVR register set at a
 595        time, so to write just a single register, we do a
 596        read-modify-write maneuver.  */
 597     get_spe_registers (tid, &evrregs);
 598
 599   if (regno == -1)
 600     {
 601       int i;
 602
 603       for (i = 0; i < ppc_num_gprs; i++)
 604         regcache_raw_collect (regcache,
 605                               tdep->ppc_ev0_upper_regnum + i,
 606                               &evrregs.evr[i]);
 607     }
 608   else if (tdep->ppc_ev0_upper_regnum <= regno
 609            && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
 610     regcache_raw_collect (regcache, regno,
 611                           &evrregs.evr[regno - tdep->ppc_ev0_upper_regnum]);
 612
 613   if (regno == -1
 614       || regno == tdep->ppc_acc_regnum)
 615     regcache_raw_collect (regcache,
 616                           tdep->ppc_acc_regnum,
 617                           &evrregs.acc);
 618
 619   if (regno == -1
 620       || regno == tdep->ppc_spefscr_regnum)
 621     regcache_raw_collect (regcache,
 622                           tdep->ppc_spefscr_regnum,
 623                           &evrregs.spefscr);
 624
 625   /* Write back the modified register set.  */
 626   set_spe_registers (tid, &evrregs);
 627 }
 628
 629 static void
 630 store_register (const struct regcache *regcache, int tid, int regno)
 631 {
 632   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 633   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 634   /* This isn't really an address.  But ptrace thinks of it as one.  */
 635   CORE_ADDR regaddr = ppc_register_u_addr (regno);
 636   int i;
 637   size_t bytes_to_transfer;
 638   char buf[MAX_REGISTER_SIZE];
 639
 640   if (altivec_register_p (regno))
 641     {
 642       store_altivec_register (regcache, tid, regno);
 643       return;
 644     }
 645   else if (spe_register_p (regno))
 646     {
 647       store_spe_register (regcache, tid, regno);
 648       return;
 649     }
 650
 651   if (regaddr == -1)
 652     return;
 653
 654   /* First collect the register.  Keep in mind that the regcache's
 655      idea of the register's size may not be a multiple of sizeof
 656      (long).  */
 657   memset (buf, 0, sizeof buf);
 658   bytes_to_transfer = align_up (register_size (gdbarch, regno), sizeof (long));
 659   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
 660     {
 661       /* Little-endian values always sit at the left end of the buffer.  */
 662       regcache_raw_collect (regcache, regno, buf);
 663     }
 664   else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 665     {
 666       /* Big-endian values sit at the right end of the buffer.  */
 667       size_t padding = (bytes_to_transfer - register_size (gdbarch, regno));
 668       regcache_raw_collect (regcache, regno, buf + padding);
 669     }
 670
 671   for (i = 0; i < bytes_to_transfer; i += sizeof (long))
 672     {
 673       errno = 0;
 674       ptrace (PTRACE_POKEUSER, tid, (PTRACE_TYPE_ARG3) regaddr,
 675               *(long *) &buf[i]);
 676       regaddr += sizeof (long);
 677
 678       if (errno == EIO
 679           && regno == tdep->ppc_fpscr_regnum)
 680         {
 681           /* Some older kernel versions don't allow fpscr to be written.  */
 682           continue;
 683         }
 684
 685       if (errno != 0)
 686         {
 687           char message[128];
 688           sprintf (message, "writing register %s (#%d)",
 689                    gdbarch_register_name (gdbarch, regno), regno);
 690           perror_with_name (message);
 691         }
 692     }
 693 }
 694
 695 static void
 696 fill_vrregset (const struct regcache *regcache, gdb_vrregset_t *vrregsetp)
 697 {
 698   int i;
 699   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 700   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 701   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
 702   int vrregsize = register_size (gdbarch, tdep->ppc_vr0_regnum);
 703   int offset = vrregsize - register_size (gdbarch, tdep->ppc_vrsave_regnum);
 704
 705   for (i = 0; i < num_of_vrregs; i++)
 706     {
 707       /* The last 2 registers of this set are only 32 bit long, not
 708          128, but only VSCR is fetched as a 16 bytes quantity.  */
 709       if (i == (num_of_vrregs - 2))
 710         regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i,
 711                               *vrregsetp + i * vrregsize + offset);
 712       else
 713         regcache_raw_collect (regcache, tdep->ppc_vr0_regnum + i,
 714                               *vrregsetp + i * vrregsize);
 715     }
 716 }
 717
 718 static void
 719 store_altivec_registers (const struct regcache *regcache, int tid)
 720 {
 721   int ret;
 722   gdb_vrregset_t regs;
 723
 724   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 725   if (ret < 0)
 726     {
 727       if (errno == EIO)
 728         {
 729           have_ptrace_getvrregs = 0;
 730           return;
 731         }
 732       perror_with_name (_("Couldn't get AltiVec registers"));
 733     }
 734
 735   fill_vrregset (regcache, &regs);
 736
 737   if (ptrace (PTRACE_SETVRREGS, tid, 0, &regs) < 0)
 738     perror_with_name (_("Couldn't write AltiVec registers"));
 739 }
 740
 741 static void
 742 store_ppc_registers (const struct regcache *regcache, int tid)
 743 {
 744   int i;
 745   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 746   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 747
 748   for (i = 0; i < ppc_num_gprs; i++)
 749     store_register (regcache, tid, tdep->ppc_gp0_regnum + i);
 750   if (tdep->ppc_fp0_regnum >= 0)
 751     for (i = 0; i < ppc_num_fprs; i++)
 752       store_register (regcache, tid, tdep->ppc_fp0_regnum + i);
 753   store_register (regcache, tid, gdbarch_pc_regnum (gdbarch));
 754   if (tdep->ppc_ps_regnum != -1)
 755     store_register (regcache, tid, tdep->ppc_ps_regnum);
 756   if (tdep->ppc_cr_regnum != -1)
 757     store_register (regcache, tid, tdep->ppc_cr_regnum);
 758   if (tdep->ppc_lr_regnum != -1)
 759     store_register (regcache, tid, tdep->ppc_lr_regnum);
 760   if (tdep->ppc_ctr_regnum != -1)
 761     store_register (regcache, tid, tdep->ppc_ctr_regnum);
 762   if (tdep->ppc_xer_regnum != -1)
 763     store_register (regcache, tid, tdep->ppc_xer_regnum);
 764   if (tdep->ppc_mq_regnum != -1)
 765     store_register (regcache, tid, tdep->ppc_mq_regnum);
 766   if (tdep->ppc_fpscr_regnum != -1)
 767     store_register (regcache, tid, tdep->ppc_fpscr_regnum);
 768   if (have_ptrace_getvrregs)
 769     if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
 770       store_altivec_registers (regcache, tid);
 771   if (tdep->ppc_ev0_upper_regnum >= 0)
 772     store_spe_register (regcache, tid, -1);
 773 }
 774
 775 static int
 776 ppc_linux_check_watch_resources (int type, int cnt, int ot)
 777 {
 778   int tid;
 779   ptid_t ptid = inferior_ptid;
 780
 781   /* DABR (data address breakpoint register) is optional for PPC variants.
 782      Some variants have one DABR, others have none.  So CNT can't be larger
 783      than 1.  */
 784   if (cnt > 1)
 785     return 0;
 786
 787   /* We need to know whether ptrace supports PTRACE_SET_DEBUGREG and whether
 788      the target has DABR.  If either answer is no, the ptrace call will
 789      return -1.  Fail in that case.  */
 790   tid = TIDGET (ptid);
 791   if (tid == 0)
 792     tid = PIDGET (ptid);
 793
 794   if (ptrace (PTRACE_SET_DEBUGREG, tid, 0, 0) == -1)
 795     return 0;
 796   return 1;
 797 }
 798
 799 static int
 800 ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 801 {
 802   /* Handle sub-8-byte quantities.  */
 803   if (len <= 0)
 804     return 0;
 805
 806   /* addr+len must fall in the 8 byte watchable region.  */
 807   if ((addr + len) > (addr & ~7) + 8)
 808     return 0;
 809
 810   return 1;
 811 }
 812
 813 /* The cached DABR value, to install in new threads.  */
 814 static long saved_dabr_value;
 815
 816 /* Set a watchpoint of type TYPE at address ADDR.  */
 817 static int
 818 ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw)
 819 {
 820   struct lwp_info *lp;
 821   ptid_t ptid;
 822   long dabr_value;
 823
 824   dabr_value = addr & ~7;
 825   switch (rw)
 826     {
 827     case hw_read:
 828       /* Set read and translate bits.  */
 829       dabr_value |= 5;
 830       break;
 831     case hw_write:
 832       /* Set write and translate bits.  */
 833       dabr_value |= 6;
 834       break;
 835     case hw_access:
 836       /* Set read, write and translate bits.  */
 837       dabr_value |= 7;
 838       break;
 839     }
 840
 841   saved_dabr_value = dabr_value;
 842
 843   ALL_LWPS (lp, ptid)
 844     if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (ptid), 0, saved_dabr_value) < 0)
 845       return -1;
 846
 847   return 0;
 848 }
 849
 850 static int
 851 ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw)
 852 {
 853   struct lwp_info *lp;
 854   ptid_t ptid;
 855   long dabr_value = 0;
 856
 857   saved_dabr_value = 0;
 858   ALL_LWPS (lp, ptid)
 859     if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (ptid), 0, saved_dabr_value) < 0)
 860       return -1;
 861   return 0;
 862 }
 863
 864 static void
 865 ppc_linux_new_thread (ptid_t ptid)
 866 {
 867   ptrace (PTRACE_SET_DEBUGREG, TIDGET (ptid), 0, saved_dabr_value);
 868 }
 869
 870 static int
 871 ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 872 {
 873   struct siginfo *siginfo_p;
 874
 875   siginfo_p = linux_nat_get_siginfo (inferior_ptid);
 876
 877   if (siginfo_p->si_signo != SIGTRAP
 878       || (siginfo_p->si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
 879     return 0;
 880
 881   *addr_p = (CORE_ADDR) (uintptr_t) siginfo_p->si_addr;
 882   return 1;
 883 }
 884
 885 static int
 886 ppc_linux_stopped_by_watchpoint (void)
 887 {
 888   CORE_ADDR addr;
 889   return ppc_linux_stopped_data_address (&current_target, &addr);
 890 }
 891
 892 static void
 893 ppc_linux_store_inferior_registers (struct regcache *regcache, int regno)
 894 {
 895   /* Overload thread id onto process id */
 896   int tid = TIDGET (inferior_ptid);
 897
 898   /* No thread id, just use process id */
 899   if (tid == 0)
 900     tid = PIDGET (inferior_ptid);
 901
 902   if (regno >= 0)
 903     store_register (regcache, tid, regno);
 904   else
 905     store_ppc_registers (regcache, tid);
 906 }
 907
 908 /* Functions for transferring registers between a gregset_t or fpregset_t
 909    (see sys/ucontext.h) and gdb's regcache.  The word size is that used
 910    by the ptrace interface, not the current program's ABI.  eg. If a
 911    powerpc64-linux gdb is being used to debug a powerpc32-linux app, we
 912    read or write 64-bit gregsets.  This is to suit the host libthread_db.  */
 913
 914 void
 915 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 916 {
 917   const struct regset *regset = ppc_linux_gregset (sizeof (long));
 918
 919   ppc_supply_gregset (regset, regcache, -1, gregsetp, sizeof (*gregsetp));
 920 }
 921
 922 void
 923 fill_gregset (const struct regcache *regcache,
 924               gdb_gregset_t *gregsetp, int regno)
 925 {
 926   const struct regset *regset = ppc_linux_gregset (sizeof (long));
 927
 928   if (regno == -1)
 929     memset (gregsetp, 0, sizeof (*gregsetp));
 930   ppc_collect_gregset (regset, regcache, regno, gregsetp, sizeof (*gregsetp));
 931 }
 932
 933 void
 934 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp)
 935 {
 936   const struct regset *regset = ppc_linux_fpregset ();
 937
 938   ppc_supply_fpregset (regset, regcache, -1,
 939                        fpregsetp, sizeof (*fpregsetp));
 940 }
 941
 942 void
 943 fill_fpregset (const struct regcache *regcache,
 944                gdb_fpregset_t *fpregsetp, int regno)
 945 {
 946   const struct regset *regset = ppc_linux_fpregset ();
 947
 948   ppc_collect_fpregset (regset, regcache, regno,
 949                         fpregsetp, sizeof (*fpregsetp));
 950 }
 951
 952 static const struct target_desc *
 953 ppc_linux_read_description (struct target_ops *ops)
 954 {
 955   if (have_ptrace_getsetevrregs)
 956     {
 957       struct gdb_evrregset_t evrregset;
 958       int tid = TIDGET (inferior_ptid);
 959
 960       if (tid == 0)
 961         tid = PIDGET (inferior_ptid);
 962
 963       if (ptrace (PTRACE_GETEVRREGS, tid, 0, &evrregset) >= 0)
 964         return tdesc_powerpc_e500;
 965       else
 966         {
 967           /* EIO means that the PTRACE_GETEVRREGS request isn't supported.  */
 968           if (errno == EIO)
 969             return NULL;
 970           else
 971             /* Anything else needs to be reported.  */
 972             perror_with_name (_("Unable to fetch SPE registers"));
 973         }
 974     }
 975
 976   return NULL;
 977 }
 978
 979 void _initialize_ppc_linux_nat (void);
 980
 981 void
 982 _initialize_ppc_linux_nat (void)
 983 {
 984   struct target_ops *t;
 985
 986   /* Fill in the generic GNU/Linux methods.  */
 987   t = linux_target ();
 988
 989   /* Add our register access methods.  */
 990   t->to_fetch_registers = ppc_linux_fetch_inferior_registers;
 991   t->to_store_registers = ppc_linux_store_inferior_registers;
 992
 993   /* Add our watchpoint methods.  */
 994   t->to_can_use_hw_breakpoint = ppc_linux_check_watch_resources;
 995   t->to_region_ok_for_hw_watchpoint = ppc_linux_region_ok_for_hw_watchpoint;
 996   t->to_insert_watchpoint = ppc_linux_insert_watchpoint;
 997   t->to_remove_watchpoint = ppc_linux_remove_watchpoint;
 998   t->to_stopped_by_watchpoint = ppc_linux_stopped_by_watchpoint;
 999   t->to_stopped_data_address = ppc_linux_stopped_data_address;
1000
1001   t->to_read_description = ppc_linux_read_description;
1002
1003   /* Register the target.  */
1004   linux_nat_add_target (t);
1005   linux_nat_set_new_thread (t, ppc_linux_new_thread);
1006 }