gdb/ppc-linux-nat.c

   1 /* PPC GNU/Linux native support.
   2
   3    Copyright 1988, 1989, 1991, 1992, 1994, 1996, 2000, 2001, 2002,
   4    2003 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., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, 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
  31 #include <sys/types.h>
  32 #include <sys/param.h>
  33 #include <signal.h>
  34 #include <sys/user.h>
  35 #include <sys/ioctl.h>
  36 #include "gdb_wait.h"
  37 #include <fcntl.h>
  38 #include <sys/procfs.h>
  39 #include <sys/ptrace.h>
  40
  41 /* Prototypes for supply_gregset etc. */
  42 #include "gregset.h"
  43 #include "ppc-tdep.h"
  44
  45 #ifndef PT_READ_U
  46 #define PT_READ_U PTRACE_PEEKUSR
  47 #endif
  48 #ifndef PT_WRITE_U
  49 #define PT_WRITE_U PTRACE_POKEUSR
  50 #endif
  51
  52 /* Default the type of the ptrace transfer to int.  */
  53 #ifndef PTRACE_XFER_TYPE
  54 #define PTRACE_XFER_TYPE int
  55 #endif
  56
  57 /* Glibc's headers don't define PTRACE_GETVRREGS so we cannot use a
  58    configure time check.  Some older glibc's (for instance 2.2.1)
  59    don't have a specific powerpc version of ptrace.h, and fall back on
  60    a generic one.  In such cases, sys/ptrace.h defines
  61    PTRACE_GETFPXREGS and PTRACE_SETFPXREGS to the same numbers that
  62    ppc kernel's asm/ptrace.h defines PTRACE_GETVRREGS and
  63    PTRACE_SETVRREGS to be.  This also makes a configury check pretty
  64    much useless.  */
  65
  66 /* These definitions should really come from the glibc header files,
  67    but Glibc doesn't know about the vrregs yet.  */
  68 #ifndef PTRACE_GETVRREGS
  69 #define PTRACE_GETVRREGS 18
  70 #define PTRACE_SETVRREGS 19
  71 #endif
  72
  73 /* This oddity is because the Linux kernel defines elf_vrregset_t as
  74    an array of 33 16 bytes long elements.  I.e. it leaves out vrsave.
  75    However the PTRACE_GETVRREGS and PTRACE_SETVRREGS requests return
  76    the vrsave as an extra 4 bytes at the end.  I opted for creating a
  77    flat array of chars, so that it is easier to manipulate for gdb.
  78
  79    There are 32 vector registers 16 bytes longs, plus a VSCR register
  80    which is only 4 bytes long, but is fetched as a 16 bytes
  81    quantity. Up to here we have the elf_vrregset_t structure.
  82    Appended to this there is space for the VRSAVE register: 4 bytes.
  83    Even though this vrsave register is not included in the regset
  84    typedef, it is handled by the ptrace requests.
  85
  86    Note that GNU/Linux doesn't support little endian PPC hardware,
  87    therefore the offset at which the real value of the VSCR register
  88    is located will be always 12 bytes.
  89
  90    The layout is like this (where x is the actual value of the vscr reg): */
  91
  92 /* *INDENT-OFF* */
  93 /*
  94    |.|.|.|.|.....|.|.|.|.||.|.|.|x||.|
  95    <------->     <-------><-------><->
  96      VR0           VR31     VSCR    VRSAVE
  97 */
  98 /* *INDENT-ON* */
  99
 100 #define SIZEOF_VRREGS 33*16+4
 101
 102 typedef char gdb_vrregset_t[SIZEOF_VRREGS];
 103
 104 /* For runtime check of ptrace support for VRREGS.  */
 105 int have_ptrace_getvrregs = 1;
 106
 107 int
 108 kernel_u_size (void)
 109 {
 110   return (sizeof (struct user));
 111 }
 112
 113 /* *INDENT-OFF* */
 114 /* registers layout, as presented by the ptrace interface:
 115 PT_R0, PT_R1, PT_R2, PT_R3, PT_R4, PT_R5, PT_R6, PT_R7,
 116 PT_R8, PT_R9, PT_R10, PT_R11, PT_R12, PT_R13, PT_R14, PT_R15,
 117 PT_R16, PT_R17, PT_R18, PT_R19, PT_R20, PT_R21, PT_R22, PT_R23,
 118 PT_R24, PT_R25, PT_R26, PT_R27, PT_R28, PT_R29, PT_R30, PT_R31,
 119 PT_FPR0, PT_FPR0 + 2, PT_FPR0 + 4, PT_FPR0 + 6, PT_FPR0 + 8, PT_FPR0 + 10, PT_FPR0 + 12, PT_FPR0 + 14,
 120 PT_FPR0 + 16, PT_FPR0 + 18, PT_FPR0 + 20, PT_FPR0 + 22, PT_FPR0 + 24, PT_FPR0 + 26, PT_FPR0 + 28, PT_FPR0 + 30,
 121 PT_FPR0 + 32, PT_FPR0 + 34, PT_FPR0 + 36, PT_FPR0 + 38, PT_FPR0 + 40, PT_FPR0 + 42, PT_FPR0 + 44, PT_FPR0 + 46,
 122 PT_FPR0 + 48, PT_FPR0 + 50, PT_FPR0 + 52, PT_FPR0 + 54, PT_FPR0 + 56, PT_FPR0 + 58, PT_FPR0 + 60, PT_FPR0 + 62,
 123 PT_NIP, PT_MSR, PT_CCR, PT_LNK, PT_CTR, PT_XER, PT_MQ */
 124 /* *INDENT_ON * */
 125
 126 static int
 127 ppc_register_u_addr (int regno)
 128 {
 129   int u_addr = -1;
 130   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 131   /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
 132      interface, and not the wordsize of the program's ABI.  */
 133   int wordsize = sizeof (PTRACE_XFER_TYPE);
 134
 135   /* General purpose registers occupy 1 slot each in the buffer */
 136   if (regno >= tdep->ppc_gp0_regnum
 137       && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
 138     u_addr = ((regno - tdep->ppc_gp0_regnum + PT_R0) * wordsize);
 139
 140   /* Floating point regs: eight bytes each in both 32- and 64-bit
 141      ptrace interfaces.  Thus, two slots each in 32-bit interface, one
 142      slot each in 64-bit interface.  */
 143   if (tdep->ppc_fp0_regnum >= 0
 144       && regno >= tdep->ppc_fp0_regnum
 145       && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 146     u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8);
 147
 148   /* UISA special purpose registers: 1 slot each */
 149   if (regno == PC_REGNUM)
 150     u_addr = PT_NIP * wordsize;
 151   if (regno == tdep->ppc_lr_regnum)
 152     u_addr = PT_LNK * wordsize;
 153   if (regno == tdep->ppc_cr_regnum)
 154     u_addr = PT_CCR * wordsize;
 155   if (regno == tdep->ppc_xer_regnum)
 156     u_addr = PT_XER * wordsize;
 157   if (regno == tdep->ppc_ctr_regnum)
 158     u_addr = PT_CTR * wordsize;
 159 #ifdef PT_MQ
 160   if (regno == tdep->ppc_mq_regnum)
 161     u_addr = PT_MQ * wordsize;
 162 #endif
 163   if (regno == tdep->ppc_ps_regnum)
 164     u_addr = PT_MSR * wordsize;
 165   if (tdep->ppc_fpscr_regnum >= 0
 166       && regno == tdep->ppc_fpscr_regnum)
 167     u_addr = PT_FPSCR * wordsize;
 168
 169   return u_addr;
 170 }
 171
 172 /* The Linux kernel ptrace interface for AltiVec registers uses the
 173    registers set mechanism, as opposed to the interface for all the
 174    other registers, that stores/fetches each register individually.  */
 175 static void
 176 fetch_altivec_register (int tid, int regno)
 177 {
 178   int ret;
 179   int offset = 0;
 180   gdb_vrregset_t regs;
 181   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 182   int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 183
 184   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 185   if (ret < 0)
 186     {
 187       if (errno == EIO)
 188         {
 189           have_ptrace_getvrregs = 0;
 190           return;
 191         }
 192       perror_with_name ("Unable to fetch AltiVec register");
 193     }
 194
 195   /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
 196      long on the hardware.  We deal only with the lower 4 bytes of the
 197      vector.  VRSAVE is at the end of the array in a 4 bytes slot, so
 198      there is no need to define an offset for it.  */
 199   if (regno == (tdep->ppc_vrsave_regnum - 1))
 200     offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 201
 202   supply_register (regno,
 203                    regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
 204 }
 205
 206 static void
 207 fetch_register (int tid, int regno)
 208 {
 209   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 210   /* This isn't really an address.  But ptrace thinks of it as one.  */
 211   CORE_ADDR regaddr = ppc_register_u_addr (regno);
 212   int i;
 213   unsigned int offset;         /* Offset of registers within the u area. */
 214   char buf[MAX_REGISTER_SIZE];
 215
 216   if (altivec_register_p (regno))
 217     {
 218       /* If this is the first time through, or if it is not the first
 219          time through, and we have comfirmed that there is kernel
 220          support for such a ptrace request, then go and fetch the
 221          register.  */
 222       if (have_ptrace_getvrregs)
 223        {
 224          fetch_altivec_register (tid, regno);
 225          return;
 226        }
 227      /* If we have discovered that there is no ptrace support for
 228         AltiVec registers, fall through and return zeroes, because
 229         regaddr will be -1 in this case.  */
 230     }
 231
 232   if (regaddr == -1)
 233     {
 234       memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno));   /* Supply zeroes */
 235       supply_register (regno, buf);
 236       return;
 237     }
 238
 239   /* If the current architecture has no floating-point registers, we
 240      should never reach this point: ppc_register_u_addr should have
 241      returned -1, and we should have caught that above.  */
 242   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
 243
 244   /* Read the raw register using PTRACE_XFER_TYPE sized chunks.  On a
 245      32-bit platform, 64-bit floating-point registers will require two
 246      transfers.  */
 247   for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
 248     {
 249       errno = 0;
 250       *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
 251                                                (PTRACE_ARG3_TYPE) regaddr, 0);
 252       regaddr += sizeof (PTRACE_XFER_TYPE);
 253       if (errno != 0)
 254         {
 255           char message[128];
 256           sprintf (message, "reading register %s (#%d)",
 257                    REGISTER_NAME (regno), regno);
 258           perror_with_name (message);
 259         }
 260     }
 261
 262   /* Now supply the register.  Be careful to map between ptrace's and
 263      the current_regcache's idea of the current wordsize.  */
 264   if ((regno >= tdep->ppc_fp0_regnum
 265        && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 266       || gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
 267     /* FPs are always 64 bits.  Little endian values are always found
 268        at the left-hand end of the register.  */
 269     regcache_raw_supply (current_regcache, regno, buf);
 270   else
 271     /* Big endian register, need to fetch the right-hand end.  */
 272     regcache_raw_supply (current_regcache, regno,
 273                         (buf + sizeof (PTRACE_XFER_TYPE)
 274                          - register_size (current_gdbarch, regno)));
 275 }
 276
 277 static void
 278 supply_vrregset (gdb_vrregset_t *vrregsetp)
 279 {
 280   int i;
 281   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 282   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
 283   int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 284   int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 285
 286   for (i = 0; i < num_of_vrregs; i++)
 287     {
 288       /* The last 2 registers of this set are only 32 bit long, not
 289          128.  However an offset is necessary only for VSCR because it
 290          occupies a whole vector, while VRSAVE occupies a full 4 bytes
 291          slot.  */
 292       if (i == (num_of_vrregs - 2))
 293         supply_register (tdep->ppc_vr0_regnum + i,
 294                          *vrregsetp + i * vrregsize + offset);
 295       else
 296         supply_register (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
 297     }
 298 }
 299
 300 static void
 301 fetch_altivec_registers (int tid)
 302 {
 303   int ret;
 304   gdb_vrregset_t regs;
 305
 306   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 307   if (ret < 0)
 308     {
 309       if (errno == EIO)
 310         {
 311           have_ptrace_getvrregs = 0;
 312           return;
 313         }
 314       perror_with_name ("Unable to fetch AltiVec registers");
 315     }
 316   supply_vrregset (&regs);
 317 }
 318
 319 static void
 320 fetch_ppc_registers (int tid)
 321 {
 322   int i;
 323   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 324
 325   for (i = 0; i < ppc_num_gprs; i++)
 326     fetch_register (tid, tdep->ppc_gp0_regnum + i);
 327   if (tdep->ppc_fp0_regnum >= 0)
 328     for (i = 0; i < ppc_num_fprs; i++)
 329       fetch_register (tid, tdep->ppc_fp0_regnum + i);
 330   fetch_register (tid, PC_REGNUM);
 331   if (tdep->ppc_ps_regnum != -1)
 332     fetch_register (tid, tdep->ppc_ps_regnum);
 333   if (tdep->ppc_cr_regnum != -1)
 334     fetch_register (tid, tdep->ppc_cr_regnum);
 335   if (tdep->ppc_lr_regnum != -1)
 336     fetch_register (tid, tdep->ppc_lr_regnum);
 337   if (tdep->ppc_ctr_regnum != -1)
 338     fetch_register (tid, tdep->ppc_ctr_regnum);
 339   if (tdep->ppc_xer_regnum != -1)
 340     fetch_register (tid, tdep->ppc_xer_regnum);
 341   if (tdep->ppc_mq_regnum != -1)
 342     fetch_register (tid, tdep->ppc_mq_regnum);
 343   if (tdep->ppc_fpscr_regnum != -1)
 344     fetch_register (tid, tdep->ppc_fpscr_regnum);
 345   if (have_ptrace_getvrregs)
 346     if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
 347       fetch_altivec_registers (tid);
 348 }
 349
 350 /* Fetch registers from the child process.  Fetch all registers if
 351    regno == -1, otherwise fetch all general registers or all floating
 352    point registers depending upon the value of regno.  */
 353 void
 354 fetch_inferior_registers (int regno)
 355 {
 356   /* Overload thread id onto process id */
 357   int tid = TIDGET (inferior_ptid);
 358
 359   /* No thread id, just use process id */
 360   if (tid == 0)
 361     tid = PIDGET (inferior_ptid);
 362
 363   if (regno == -1)
 364     fetch_ppc_registers (tid);
 365   else
 366     fetch_register (tid, regno);
 367 }
 368
 369 /* Store one register. */
 370 static void
 371 store_altivec_register (int tid, int regno)
 372 {
 373   int ret;
 374   int offset = 0;
 375   gdb_vrregset_t regs;
 376   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 377   int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 378
 379   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 380   if (ret < 0)
 381     {
 382       if (errno == EIO)
 383         {
 384           have_ptrace_getvrregs = 0;
 385           return;
 386         }
 387       perror_with_name ("Unable to fetch AltiVec register");
 388     }
 389
 390   /* VSCR is fetched as a 16 bytes quantity, but it is really 4 bytes
 391      long on the hardware.  */
 392   if (regno == (tdep->ppc_vrsave_regnum - 1))
 393     offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 394
 395   regcache_collect (regno,
 396                     regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
 397
 398   ret = ptrace (PTRACE_SETVRREGS, tid, 0, &regs);
 399   if (ret < 0)
 400     perror_with_name ("Unable to store AltiVec register");
 401 }
 402
 403 static void
 404 store_register (int tid, int regno)
 405 {
 406   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 407   /* This isn't really an address.  But ptrace thinks of it as one.  */
 408   CORE_ADDR regaddr = ppc_register_u_addr (regno);
 409   int i;
 410   char buf[MAX_REGISTER_SIZE];
 411
 412   if (altivec_register_p (regno))
 413     {
 414       store_altivec_register (tid, regno);
 415       return;
 416     }
 417
 418   if (regaddr == -1)
 419     return;
 420
 421   /* If the current architecture has no floating-point registers, we
 422      should never reach this point: ppc_register_u_addr should have
 423      returned -1, and we should have caught that above.  */
 424   gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
 425
 426   /* First collect the register value from the regcache.  Be careful
 427      to to convert the regcache's wordsize into ptrace's wordsize.  */
 428   memset (buf, 0, sizeof buf);
 429   if ((regno >= tdep->ppc_fp0_regnum
 430        && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
 431       || TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
 432     /* Floats are always 64-bit.  Little endian registers are always
 433        at the left-hand end of the register cache.  */
 434     regcache_raw_collect (current_regcache, regno, buf);
 435   else
 436     /* Big-endian registers belong at the right-hand end of the
 437        buffer.  */
 438     regcache_raw_collect (current_regcache, regno,
 439                          (buf + sizeof (PTRACE_XFER_TYPE)
 440                           - register_size (current_gdbarch, regno)));
 441
 442   for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
 443     {
 444       errno = 0;
 445       ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
 446               *(PTRACE_XFER_TYPE *) & buf[i]);
 447       regaddr += sizeof (PTRACE_XFER_TYPE);
 448
 449       if (errno == EIO
 450           && regno == tdep->ppc_fpscr_regnum)
 451         {
 452           /* Some older kernel versions don't allow fpscr to be written.  */
 453           continue;
 454         }
 455
 456       if (errno != 0)
 457         {
 458           char message[128];
 459           sprintf (message, "writing register %s (#%d)",
 460                    REGISTER_NAME (regno), regno);
 461           perror_with_name (message);
 462         }
 463     }
 464 }
 465
 466 static void
 467 fill_vrregset (gdb_vrregset_t *vrregsetp)
 468 {
 469   int i;
 470   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 471   int num_of_vrregs = tdep->ppc_vrsave_regnum - tdep->ppc_vr0_regnum + 1;
 472   int vrregsize = DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
 473   int offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
 474
 475   for (i = 0; i < num_of_vrregs; i++)
 476     {
 477       /* The last 2 registers of this set are only 32 bit long, not
 478          128, but only VSCR is fetched as a 16 bytes quantity.  */
 479       if (i == (num_of_vrregs - 2))
 480         regcache_collect (tdep->ppc_vr0_regnum + i,
 481                           *vrregsetp + i * vrregsize + offset);
 482       else
 483         regcache_collect (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
 484     }
 485 }
 486
 487 static void
 488 store_altivec_registers (int tid)
 489 {
 490   int ret;
 491   gdb_vrregset_t regs;
 492
 493   ret = ptrace (PTRACE_GETVRREGS, tid, 0, &regs);
 494   if (ret < 0)
 495     {
 496       if (errno == EIO)
 497         {
 498           have_ptrace_getvrregs = 0;
 499           return;
 500         }
 501       perror_with_name ("Couldn't get AltiVec registers");
 502     }
 503
 504   fill_vrregset (&regs);
 505
 506   if (ptrace (PTRACE_SETVRREGS, tid, 0, &regs) < 0)
 507     perror_with_name ("Couldn't write AltiVec registers");
 508 }
 509
 510 static void
 511 store_ppc_registers (int tid)
 512 {
 513   int i;
 514   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 515
 516   for (i = 0; i < ppc_num_gprs; i++)
 517     store_register (tid, tdep->ppc_gp0_regnum + i);
 518   if (tdep->ppc_fp0_regnum >= 0)
 519     for (i = 0; i < ppc_num_fprs; i++)
 520       store_register (tid, tdep->ppc_fp0_regnum + i);
 521   store_register (tid, PC_REGNUM);
 522   if (tdep->ppc_ps_regnum != -1)
 523     store_register (tid, tdep->ppc_ps_regnum);
 524   if (tdep->ppc_cr_regnum != -1)
 525     store_register (tid, tdep->ppc_cr_regnum);
 526   if (tdep->ppc_lr_regnum != -1)
 527     store_register (tid, tdep->ppc_lr_regnum);
 528   if (tdep->ppc_ctr_regnum != -1)
 529     store_register (tid, tdep->ppc_ctr_regnum);
 530   if (tdep->ppc_xer_regnum != -1)
 531     store_register (tid, tdep->ppc_xer_regnum);
 532   if (tdep->ppc_mq_regnum != -1)
 533     store_register (tid, tdep->ppc_mq_regnum);
 534   if (tdep->ppc_fpscr_regnum != -1)
 535     store_register (tid, tdep->ppc_fpscr_regnum);
 536   if (have_ptrace_getvrregs)
 537     if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
 538       store_altivec_registers (tid);
 539 }
 540
 541 void
 542 store_inferior_registers (int regno)
 543 {
 544   /* Overload thread id onto process id */
 545   int tid = TIDGET (inferior_ptid);
 546
 547   /* No thread id, just use process id */
 548   if (tid == 0)
 549     tid = PIDGET (inferior_ptid);
 550
 551   if (regno >= 0)
 552     store_register (tid, regno);
 553   else
 554     store_ppc_registers (tid);
 555 }
 556
 557 void
 558 supply_gregset (gdb_gregset_t *gregsetp)
 559 {
 560   /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
 561      interface, and not the wordsize of the program's ABI.  */
 562   int wordsize = sizeof (PTRACE_XFER_TYPE);
 563   ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
 564                             sizeof (gdb_gregset_t), wordsize);
 565 }
 566
 567 static void
 568 right_fill_reg (int regnum, void *reg)
 569 {
 570   /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
 571      interface, and not the wordsize of the program's ABI.  */
 572   int wordsize = sizeof (PTRACE_XFER_TYPE);
 573   /* Right fill the register.  */
 574   regcache_raw_collect (current_regcache, regnum,
 575                         ((bfd_byte *) reg
 576                          + wordsize
 577                          - register_size (current_gdbarch, regnum)));
 578 }
 579
 580 void
 581 fill_gregset (gdb_gregset_t *gregsetp, int regno)
 582 {
 583   int regi;
 584   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 585   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 586   const int elf_ngreg = 48;
 587
 588
 589   /* Start with zeros.  */
 590   memset (regp, 0, elf_ngreg * sizeof (*regp));
 591
 592   for (regi = 0; regi < ppc_num_gprs; regi++)
 593     {
 594       if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi)
 595         right_fill_reg (tdep->ppc_gp0_regnum + regi, (regp + PT_R0 + regi));
 596     }
 597
 598   if ((regno == -1) || regno == PC_REGNUM)
 599     right_fill_reg (PC_REGNUM, regp + PT_NIP);
 600   if ((regno == -1) || regno == tdep->ppc_lr_regnum)
 601     right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
 602   if ((regno == -1) || regno == tdep->ppc_cr_regnum)
 603     regcache_collect (tdep->ppc_cr_regnum, regp + PT_CCR);
 604   if ((regno == -1) || regno == tdep->ppc_xer_regnum)
 605     regcache_collect (tdep->ppc_xer_regnum, regp + PT_XER);
 606   if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
 607     right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
 608 #ifdef PT_MQ
 609   if (((regno == -1) || regno == tdep->ppc_mq_regnum)
 610       && (tdep->ppc_mq_regnum != -1))
 611     right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
 612 #endif
 613   if ((regno == -1) || regno == tdep->ppc_ps_regnum)
 614     right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
 615 }
 616
 617 void
 618 supply_fpregset (gdb_fpregset_t * fpregsetp)
 619 {
 620   ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
 621                              sizeof (gdb_fpregset_t));
 622 }
 623
 624 /* Given a pointer to a floating point register set in /proc format
 625    (fpregset_t *), update the register specified by REGNO from gdb's
 626    idea of the current floating point register set.  If REGNO is -1,
 627    update them all.  */
 628 void
 629 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
 630 {
 631   int regi;
 632   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 633   bfd_byte *fpp = (void *) fpregsetp;
 634
 635   if (ppc_floating_point_unit_p (current_gdbarch))
 636     {
 637       for (regi = 0; regi < ppc_num_fprs; regi++)
 638         {
 639           if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
 640             regcache_collect (tdep->ppc_fp0_regnum + regi, fpp + 8 * regi);
 641         }
 642       if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
 643         right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32));
 644     }
 645 }