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