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