gdb/rs6000-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "infrun.h"
  24 #include "symtab.h"
  25 #include "target.h"
  26 #include "gdbcore.h"
  27 #include "gdbcmd.h"
  28 #include "objfiles.h"
  29 #include "arch-utils.h"
  30 #include "regcache.h"
  31 #include "regset.h"
  32 #include "target-float.h"
  33 #include "value.h"
  34 #include "parser-defs.h"
  35 #include "osabi.h"
  36 #include "infcall.h"
  37 #include "sim-regno.h"
  38 #include "gdb/sim-ppc.h"
  39 #include "reggroups.h"
  40 #include "dwarf2-frame.h"
  41 #include "target-descriptions.h"
  42 #include "user-regs.h"
  43 #include "record-full.h"
  44 #include "auxv.h"
  45
  46 #include "coff/internal.h"      /* for libcoff.h */
  47 #include "libcoff.h"            /* for xcoff_data */
  48 #include "coff/xcoff.h"
  49 #include "libxcoff.h"
  50
  51 #include "elf-bfd.h"
  52 #include "elf/ppc.h"
  53 #include "elf/ppc64.h"
  54
  55 #include "solib-svr4.h"
  56 #include "ppc-tdep.h"
  57 #include "ppc-ravenscar-thread.h"
  58
  59 #include "dis-asm.h"
  60
  61 #include "trad-frame.h"
  62 #include "frame-unwind.h"
  63 #include "frame-base.h"
  64
  65 #include "ax.h"
  66 #include "ax-gdb.h"
  67 #include <algorithm>
  68
  69 #include "features/rs6000/powerpc-32.c"
  70 #include "features/rs6000/powerpc-altivec32.c"
  71 #include "features/rs6000/powerpc-vsx32.c"
  72 #include "features/rs6000/powerpc-403.c"
  73 #include "features/rs6000/powerpc-403gc.c"
  74 #include "features/rs6000/powerpc-405.c"
  75 #include "features/rs6000/powerpc-505.c"
  76 #include "features/rs6000/powerpc-601.c"
  77 #include "features/rs6000/powerpc-602.c"
  78 #include "features/rs6000/powerpc-603.c"
  79 #include "features/rs6000/powerpc-604.c"
  80 #include "features/rs6000/powerpc-64.c"
  81 #include "features/rs6000/powerpc-altivec64.c"
  82 #include "features/rs6000/powerpc-vsx64.c"
  83 #include "features/rs6000/powerpc-7400.c"
  84 #include "features/rs6000/powerpc-750.c"
  85 #include "features/rs6000/powerpc-860.c"
  86 #include "features/rs6000/powerpc-e500.c"
  87 #include "features/rs6000/rs6000.c"
  88
  89 /* Determine if regnum is an SPE pseudo-register.  */
  90 #define IS_SPE_PSEUDOREG(tdep, regnum) ((tdep)->ppc_ev0_regnum >= 0 \
  91     && (regnum) >= (tdep)->ppc_ev0_regnum \
  92     && (regnum) < (tdep)->ppc_ev0_regnum + 32)
  93
  94 /* Determine if regnum is a decimal float pseudo-register.  */
  95 #define IS_DFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_dl0_regnum >= 0 \
  96     && (regnum) >= (tdep)->ppc_dl0_regnum \
  97     && (regnum) < (tdep)->ppc_dl0_regnum + 16)
  98
  99 /* Determine if regnum is a "vX" alias for the raw "vrX" vector
 100    registers.  */
 101 #define IS_V_ALIAS_PSEUDOREG(tdep, regnum) (\
 102     (tdep)->ppc_v0_alias_regnum >= 0 \
 103     && (regnum) >= (tdep)->ppc_v0_alias_regnum \
 104     && (regnum) < (tdep)->ppc_v0_alias_regnum + ppc_num_vrs)
 105
 106 /* Determine if regnum is a POWER7 VSX register.  */
 107 #define IS_VSX_PSEUDOREG(tdep, regnum) ((tdep)->ppc_vsr0_regnum >= 0 \
 108     && (regnum) >= (tdep)->ppc_vsr0_regnum \
 109     && (regnum) < (tdep)->ppc_vsr0_regnum + ppc_num_vsrs)
 110
 111 /* Determine if regnum is a POWER7 Extended FP register.  */
 112 #define IS_EFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_efpr0_regnum >= 0 \
 113     && (regnum) >= (tdep)->ppc_efpr0_regnum \
 114     && (regnum) < (tdep)->ppc_efpr0_regnum + ppc_num_efprs)
 115
 116 /* Determine if regnum is a checkpointed decimal float
 117    pseudo-register.  */
 118 #define IS_CDFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_cdl0_regnum >= 0 \
 119     && (regnum) >= (tdep)->ppc_cdl0_regnum \
 120     && (regnum) < (tdep)->ppc_cdl0_regnum + 16)
 121
 122 /* Determine if regnum is a Checkpointed POWER7 VSX register.  */
 123 #define IS_CVSX_PSEUDOREG(tdep, regnum) ((tdep)->ppc_cvsr0_regnum >= 0 \
 124     && (regnum) >= (tdep)->ppc_cvsr0_regnum \
 125     && (regnum) < (tdep)->ppc_cvsr0_regnum + ppc_num_vsrs)
 126
 127 /* Determine if regnum is a Checkpointed POWER7 Extended FP register.  */
 128 #define IS_CEFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_cefpr0_regnum >= 0 \
 129     && (regnum) >= (tdep)->ppc_cefpr0_regnum \
 130     && (regnum) < (tdep)->ppc_cefpr0_regnum + ppc_num_efprs)
 131
 132 /* Holds the current set of options to be passed to the disassembler.  */
 133 static char *powerpc_disassembler_options;
 134
 135 /* The list of available "set powerpc ..." and "show powerpc ..."
 136    commands.  */
 137 static struct cmd_list_element *setpowerpccmdlist = NULL;
 138 static struct cmd_list_element *showpowerpccmdlist = NULL;
 139
 140 static enum auto_boolean powerpc_soft_float_global = AUTO_BOOLEAN_AUTO;
 141
 142 /* The vector ABI to use.  Keep this in sync with powerpc_vector_abi.  */
 143 static const char *const powerpc_vector_strings[] =
 144 {
 145   "auto",
 146   "generic",
 147   "altivec",
 148   "spe",
 149   NULL
 150 };
 151
 152 /* A variable that can be configured by the user.  */
 153 static enum powerpc_vector_abi powerpc_vector_abi_global = POWERPC_VEC_AUTO;
 154 static const char *powerpc_vector_abi_string = "auto";
 155
 156 /* To be used by skip_prologue.  */
 157
 158 struct rs6000_framedata
 159   {
 160     int offset;                 /* total size of frame --- the distance
 161                                    by which we decrement sp to allocate
 162                                    the frame */
 163     int saved_gpr;              /* smallest # of saved gpr */
 164     unsigned int gpr_mask;      /* Each bit is an individual saved GPR.  */
 165     int saved_fpr;              /* smallest # of saved fpr */
 166     int saved_vr;               /* smallest # of saved vr */
 167     int saved_ev;               /* smallest # of saved ev */
 168     int alloca_reg;             /* alloca register number (frame ptr) */
 169     char frameless;             /* true if frameless functions.  */
 170     char nosavedpc;             /* true if pc not saved.  */
 171     char used_bl;               /* true if link register clobbered */
 172     int gpr_offset;             /* offset of saved gprs from prev sp */
 173     int fpr_offset;             /* offset of saved fprs from prev sp */
 174     int vr_offset;              /* offset of saved vrs from prev sp */
 175     int ev_offset;              /* offset of saved evs from prev sp */
 176     int lr_offset;              /* offset of saved lr */
 177     int lr_register;            /* register of saved lr, if trustworthy */
 178     int cr_offset;              /* offset of saved cr */
 179     int vrsave_offset;          /* offset of saved vrsave register */
 180   };
 181
 182
 183 /* Is REGNO a VSX register? Return 1 if so, 0 otherwise.  */
 184 int
 185 vsx_register_p (struct gdbarch *gdbarch, int regno)
 186 {
 187   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 188   if (tdep->ppc_vsr0_regnum < 0)
 189     return 0;
 190   else
 191     return (regno >= tdep->ppc_vsr0_upper_regnum && regno
 192             <= tdep->ppc_vsr0_upper_regnum + 31);
 193 }
 194
 195 /* Is REGNO an AltiVec register?  Return 1 if so, 0 otherwise.  */
 196 int
 197 altivec_register_p (struct gdbarch *gdbarch, int regno)
 198 {
 199   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 200   if (tdep->ppc_vr0_regnum < 0 || tdep->ppc_vrsave_regnum < 0)
 201     return 0;
 202   else
 203     return (regno >= tdep->ppc_vr0_regnum && regno <= tdep->ppc_vrsave_regnum);
 204 }
 205
 206
 207 /* Return true if REGNO is an SPE register, false otherwise.  */
 208 int
 209 spe_register_p (struct gdbarch *gdbarch, int regno)
 210 {
 211   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 212
 213   /* Is it a reference to EV0 -- EV31, and do we have those?  */
 214   if (IS_SPE_PSEUDOREG (tdep, regno))
 215     return 1;
 216
 217   /* Is it a reference to one of the raw upper GPR halves?  */
 218   if (tdep->ppc_ev0_upper_regnum >= 0
 219       && tdep->ppc_ev0_upper_regnum <= regno
 220       && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
 221     return 1;
 222
 223   /* Is it a reference to the 64-bit accumulator, and do we have that?  */
 224   if (tdep->ppc_acc_regnum >= 0
 225       && tdep->ppc_acc_regnum == regno)
 226     return 1;
 227
 228   /* Is it a reference to the SPE floating-point status and control register,
 229      and do we have that?  */
 230   if (tdep->ppc_spefscr_regnum >= 0
 231       && tdep->ppc_spefscr_regnum == regno)
 232     return 1;
 233
 234   return 0;
 235 }
 236
 237
 238 /* Return non-zero if the architecture described by GDBARCH has
 239    floating-point registers (f0 --- f31 and fpscr).  */
 240 int
 241 ppc_floating_point_unit_p (struct gdbarch *gdbarch)
 242 {
 243   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 244
 245   return (tdep->ppc_fp0_regnum >= 0
 246           && tdep->ppc_fpscr_regnum >= 0);
 247 }
 248
 249 /* Return non-zero if the architecture described by GDBARCH has
 250    Altivec registers (vr0 --- vr31, vrsave and vscr).  */
 251 int
 252 ppc_altivec_support_p (struct gdbarch *gdbarch)
 253 {
 254   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 255
 256   return (tdep->ppc_vr0_regnum >= 0
 257           && tdep->ppc_vrsave_regnum >= 0);
 258 }
 259
 260 /* Check that TABLE[GDB_REGNO] is not already initialized, and then
 261    set it to SIM_REGNO.
 262
 263    This is a helper function for init_sim_regno_table, constructing
 264    the table mapping GDB register numbers to sim register numbers; we
 265    initialize every element in that table to -1 before we start
 266    filling it in.  */
 267 static void
 268 set_sim_regno (int *table, int gdb_regno, int sim_regno)
 269 {
 270   /* Make sure we don't try to assign any given GDB register a sim
 271      register number more than once.  */
 272   gdb_assert (table[gdb_regno] == -1);
 273   table[gdb_regno] = sim_regno;
 274 }
 275
 276
 277 /* Initialize ARCH->tdep->sim_regno, the table mapping GDB register
 278    numbers to simulator register numbers, based on the values placed
 279    in the ARCH->tdep->ppc_foo_regnum members.  */
 280 static void
 281 init_sim_regno_table (struct gdbarch *arch)
 282 {
 283   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
 284   int total_regs = gdbarch_num_regs (arch);
 285   int *sim_regno = GDBARCH_OBSTACK_CALLOC (arch, total_regs, int);
 286   int i;
 287   static const char *const segment_regs[] = {
 288     "sr0", "sr1", "sr2", "sr3", "sr4", "sr5", "sr6", "sr7",
 289     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15"
 290   };
 291
 292   /* Presume that all registers not explicitly mentioned below are
 293      unavailable from the sim.  */
 294   for (i = 0; i < total_regs; i++)
 295     sim_regno[i] = -1;
 296
 297   /* General-purpose registers.  */
 298   for (i = 0; i < ppc_num_gprs; i++)
 299     set_sim_regno (sim_regno, tdep->ppc_gp0_regnum + i, sim_ppc_r0_regnum + i);
 300
 301   /* Floating-point registers.  */
 302   if (tdep->ppc_fp0_regnum >= 0)
 303     for (i = 0; i < ppc_num_fprs; i++)
 304       set_sim_regno (sim_regno,
 305                      tdep->ppc_fp0_regnum + i,
 306                      sim_ppc_f0_regnum + i);
 307   if (tdep->ppc_fpscr_regnum >= 0)
 308     set_sim_regno (sim_regno, tdep->ppc_fpscr_regnum, sim_ppc_fpscr_regnum);
 309
 310   set_sim_regno (sim_regno, gdbarch_pc_regnum (arch), sim_ppc_pc_regnum);
 311   set_sim_regno (sim_regno, tdep->ppc_ps_regnum, sim_ppc_ps_regnum);
 312   set_sim_regno (sim_regno, tdep->ppc_cr_regnum, sim_ppc_cr_regnum);
 313
 314   /* Segment registers.  */
 315   for (i = 0; i < ppc_num_srs; i++)
 316     {
 317       int gdb_regno;
 318
 319       gdb_regno = user_reg_map_name_to_regnum (arch, segment_regs[i], -1);
 320       if (gdb_regno >= 0)
 321         set_sim_regno (sim_regno, gdb_regno, sim_ppc_sr0_regnum + i);
 322     }
 323
 324   /* Altivec registers.  */
 325   if (tdep->ppc_vr0_regnum >= 0)
 326     {
 327       for (i = 0; i < ppc_num_vrs; i++)
 328         set_sim_regno (sim_regno,
 329                        tdep->ppc_vr0_regnum + i,
 330                        sim_ppc_vr0_regnum + i);
 331
 332       /* FIXME: jimb/2004-07-15: when we have tdep->ppc_vscr_regnum,
 333          we can treat this more like the other cases.  */
 334       set_sim_regno (sim_regno,
 335                      tdep->ppc_vr0_regnum + ppc_num_vrs,
 336                      sim_ppc_vscr_regnum);
 337     }
 338   /* vsave is a special-purpose register, so the code below handles it.  */
 339
 340   /* SPE APU (E500) registers.  */
 341   if (tdep->ppc_ev0_upper_regnum >= 0)
 342     for (i = 0; i < ppc_num_gprs; i++)
 343       set_sim_regno (sim_regno,
 344                      tdep->ppc_ev0_upper_regnum + i,
 345                      sim_ppc_rh0_regnum + i);
 346   if (tdep->ppc_acc_regnum >= 0)
 347     set_sim_regno (sim_regno, tdep->ppc_acc_regnum, sim_ppc_acc_regnum);
 348   /* spefscr is a special-purpose register, so the code below handles it.  */
 349
 350 #ifdef WITH_PPC_SIM
 351   /* Now handle all special-purpose registers.  Verify that they
 352      haven't mistakenly been assigned numbers by any of the above
 353      code.  */
 354   for (i = 0; i < sim_ppc_num_sprs; i++)
 355     {
 356       const char *spr_name = sim_spr_register_name (i);
 357       int gdb_regno = -1;
 358
 359       if (spr_name != NULL)
 360         gdb_regno = user_reg_map_name_to_regnum (arch, spr_name, -1);
 361
 362       if (gdb_regno != -1)
 363         set_sim_regno (sim_regno, gdb_regno, sim_ppc_spr0_regnum + i);
 364     }
 365 #endif
 366
 367   /* Drop the initialized array into place.  */
 368   tdep->sim_regno = sim_regno;
 369 }
 370
 371
 372 /* Given a GDB register number REG, return the corresponding SIM
 373    register number.  */
 374 static int
 375 rs6000_register_sim_regno (struct gdbarch *gdbarch, int reg)
 376 {
 377   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 378   int sim_regno;
 379
 380   if (tdep->sim_regno == NULL)
 381     init_sim_regno_table (gdbarch);
 382
 383   gdb_assert (0 <= reg && reg <= gdbarch_num_cooked_regs (gdbarch));
 384   sim_regno = tdep->sim_regno[reg];
 385
 386   if (sim_regno >= 0)
 387     return sim_regno;
 388   else
 389     return LEGACY_SIM_REGNO_IGNORE;
 390 }
 391
 392 \f
 393
 394 /* Register set support functions.  */
 395
 396 /* REGS + OFFSET contains register REGNUM in a field REGSIZE wide.
 397    Write the register to REGCACHE.  */
 398
 399 void
 400 ppc_supply_reg (struct regcache *regcache, int regnum,
 401                 const gdb_byte *regs, size_t offset, int regsize)
 402 {
 403   if (regnum != -1 && offset != -1)
 404     {
 405       if (regsize > 4)
 406         {
 407           struct gdbarch *gdbarch = regcache->arch ();
 408           int gdb_regsize = register_size (gdbarch, regnum);
 409           if (gdb_regsize < regsize
 410               && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 411             offset += regsize - gdb_regsize;
 412         }
 413       regcache->raw_supply (regnum, regs + offset);
 414     }
 415 }
 416
 417 /* Read register REGNUM from REGCACHE and store to REGS + OFFSET
 418    in a field REGSIZE wide.  Zero pad as necessary.  */
 419
 420 void
 421 ppc_collect_reg (const struct regcache *regcache, int regnum,
 422                  gdb_byte *regs, size_t offset, int regsize)
 423 {
 424   if (regnum != -1 && offset != -1)
 425     {
 426       if (regsize > 4)
 427         {
 428           struct gdbarch *gdbarch = regcache->arch ();
 429           int gdb_regsize = register_size (gdbarch, regnum);
 430           if (gdb_regsize < regsize)
 431             {
 432               if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 433                 {
 434                   memset (regs + offset, 0, regsize - gdb_regsize);
 435                   offset += regsize - gdb_regsize;
 436                 }
 437               else
 438                 memset (regs + offset + regsize - gdb_regsize, 0,
 439                         regsize - gdb_regsize);
 440             }
 441         }
 442       regcache->raw_collect (regnum, regs + offset);
 443     }
 444 }
 445
 446 static int
 447 ppc_greg_offset (struct gdbarch *gdbarch,
 448                  struct gdbarch_tdep *tdep,
 449                  const struct ppc_reg_offsets *offsets,
 450                  int regnum,
 451                  int *regsize)
 452 {
 453   *regsize = offsets->gpr_size;
 454   if (regnum >= tdep->ppc_gp0_regnum
 455       && regnum < tdep->ppc_gp0_regnum + ppc_num_gprs)
 456     return (offsets->r0_offset
 457             + (regnum - tdep->ppc_gp0_regnum) * offsets->gpr_size);
 458
 459   if (regnum == gdbarch_pc_regnum (gdbarch))
 460     return offsets->pc_offset;
 461
 462   if (regnum == tdep->ppc_ps_regnum)
 463     return offsets->ps_offset;
 464
 465   if (regnum == tdep->ppc_lr_regnum)
 466     return offsets->lr_offset;
 467
 468   if (regnum == tdep->ppc_ctr_regnum)
 469     return offsets->ctr_offset;
 470
 471   *regsize = offsets->xr_size;
 472   if (regnum == tdep->ppc_cr_regnum)
 473     return offsets->cr_offset;
 474
 475   if (regnum == tdep->ppc_xer_regnum)
 476     return offsets->xer_offset;
 477
 478   if (regnum == tdep->ppc_mq_regnum)
 479     return offsets->mq_offset;
 480
 481   return -1;
 482 }
 483
 484 static int
 485 ppc_fpreg_offset (struct gdbarch_tdep *tdep,
 486                   const struct ppc_reg_offsets *offsets,
 487                   int regnum)
 488 {
 489   if (regnum >= tdep->ppc_fp0_regnum
 490       && regnum < tdep->ppc_fp0_regnum + ppc_num_fprs)
 491     return offsets->f0_offset + (regnum - tdep->ppc_fp0_regnum) * 8;
 492
 493   if (regnum == tdep->ppc_fpscr_regnum)
 494     return offsets->fpscr_offset;
 495
 496   return -1;
 497 }
 498
 499 /* Supply register REGNUM in the general-purpose register set REGSET
 500    from the buffer specified by GREGS and LEN to register cache
 501    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 502
 503 void
 504 ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
 505                     int regnum, const void *gregs, size_t len)
 506 {
 507   struct gdbarch *gdbarch = regcache->arch ();
 508   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 509   const struct ppc_reg_offsets *offsets
 510     = (const struct ppc_reg_offsets *) regset->regmap;
 511   size_t offset;
 512   int regsize;
 513
 514   if (regnum == -1)
 515     {
 516       int i;
 517       int gpr_size = offsets->gpr_size;
 518
 519       for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
 520            i < tdep->ppc_gp0_regnum + ppc_num_gprs;
 521            i++, offset += gpr_size)
 522         ppc_supply_reg (regcache, i, (const gdb_byte *) gregs, offset,
 523                         gpr_size);
 524
 525       ppc_supply_reg (regcache, gdbarch_pc_regnum (gdbarch),
 526                       (const gdb_byte *) gregs, offsets->pc_offset, gpr_size);
 527       ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
 528                       (const gdb_byte *) gregs, offsets->ps_offset, gpr_size);
 529       ppc_supply_reg (regcache, tdep->ppc_lr_regnum,
 530                       (const gdb_byte *) gregs, offsets->lr_offset, gpr_size);
 531       ppc_supply_reg (regcache, tdep->ppc_ctr_regnum,
 532                       (const gdb_byte *) gregs, offsets->ctr_offset, gpr_size);
 533       ppc_supply_reg (regcache, tdep->ppc_cr_regnum,
 534                       (const gdb_byte *) gregs, offsets->cr_offset,
 535                       offsets->xr_size);
 536       ppc_supply_reg (regcache, tdep->ppc_xer_regnum,
 537                       (const gdb_byte *) gregs, offsets->xer_offset,
 538                       offsets->xr_size);
 539       ppc_supply_reg (regcache, tdep->ppc_mq_regnum,
 540                       (const gdb_byte *) gregs, offsets->mq_offset,
 541                       offsets->xr_size);
 542       return;
 543     }
 544
 545   offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
 546   ppc_supply_reg (regcache, regnum, (const gdb_byte *) gregs, offset, regsize);
 547 }
 548
 549 /* Supply register REGNUM in the floating-point register set REGSET
 550    from the buffer specified by FPREGS and LEN to register cache
 551    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 552
 553 void
 554 ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
 555                      int regnum, const void *fpregs, size_t len)
 556 {
 557   struct gdbarch *gdbarch = regcache->arch ();
 558   struct gdbarch_tdep *tdep;
 559   const struct ppc_reg_offsets *offsets;
 560   size_t offset;
 561
 562   if (!ppc_floating_point_unit_p (gdbarch))
 563     return;
 564
 565   tdep = gdbarch_tdep (gdbarch);
 566   offsets = (const struct ppc_reg_offsets *) regset->regmap;
 567   if (regnum == -1)
 568     {
 569       int i;
 570
 571       for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
 572            i < tdep->ppc_fp0_regnum + ppc_num_fprs;
 573            i++, offset += 8)
 574         ppc_supply_reg (regcache, i, (const gdb_byte *) fpregs, offset, 8);
 575
 576       ppc_supply_reg (regcache, tdep->ppc_fpscr_regnum,
 577                       (const gdb_byte *) fpregs, offsets->fpscr_offset,
 578                       offsets->fpscr_size);
 579       return;
 580     }
 581
 582   offset = ppc_fpreg_offset (tdep, offsets, regnum);
 583   ppc_supply_reg (regcache, regnum, (const gdb_byte *) fpregs, offset,
 584                   regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
 585 }
 586
 587 /* Collect register REGNUM in the general-purpose register set
 588    REGSET from register cache REGCACHE into the buffer specified by
 589    GREGS and LEN.  If REGNUM is -1, do this for all registers in
 590    REGSET.  */
 591
 592 void
 593 ppc_collect_gregset (const struct regset *regset,
 594                      const struct regcache *regcache,
 595                      int regnum, void *gregs, size_t len)
 596 {
 597   struct gdbarch *gdbarch = regcache->arch ();
 598   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 599   const struct ppc_reg_offsets *offsets
 600     = (const struct ppc_reg_offsets *) regset->regmap;
 601   size_t offset;
 602   int regsize;
 603
 604   if (regnum == -1)
 605     {
 606       int i;
 607       int gpr_size = offsets->gpr_size;
 608
 609       for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
 610            i < tdep->ppc_gp0_regnum + ppc_num_gprs;
 611            i++, offset += gpr_size)
 612         ppc_collect_reg (regcache, i, (gdb_byte *) gregs, offset, gpr_size);
 613
 614       ppc_collect_reg (regcache, gdbarch_pc_regnum (gdbarch),
 615                        (gdb_byte *) gregs, offsets->pc_offset, gpr_size);
 616       ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
 617                        (gdb_byte *) gregs, offsets->ps_offset, gpr_size);
 618       ppc_collect_reg (regcache, tdep->ppc_lr_regnum,
 619                        (gdb_byte *) gregs, offsets->lr_offset, gpr_size);
 620       ppc_collect_reg (regcache, tdep->ppc_ctr_regnum,
 621                        (gdb_byte *) gregs, offsets->ctr_offset, gpr_size);
 622       ppc_collect_reg (regcache, tdep->ppc_cr_regnum,
 623                        (gdb_byte *) gregs, offsets->cr_offset,
 624                        offsets->xr_size);
 625       ppc_collect_reg (regcache, tdep->ppc_xer_regnum,
 626                        (gdb_byte *) gregs, offsets->xer_offset,
 627                        offsets->xr_size);
 628       ppc_collect_reg (regcache, tdep->ppc_mq_regnum,
 629                        (gdb_byte *) gregs, offsets->mq_offset,
 630                        offsets->xr_size);
 631       return;
 632     }
 633
 634   offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
 635   ppc_collect_reg (regcache, regnum, (gdb_byte *) gregs, offset, regsize);
 636 }
 637
 638 /* Collect register REGNUM in the floating-point register set
 639    REGSET from register cache REGCACHE into the buffer specified by
 640    FPREGS and LEN.  If REGNUM is -1, do this for all registers in
 641    REGSET.  */
 642
 643 void
 644 ppc_collect_fpregset (const struct regset *regset,
 645                       const struct regcache *regcache,
 646                       int regnum, void *fpregs, size_t len)
 647 {
 648   struct gdbarch *gdbarch = regcache->arch ();
 649   struct gdbarch_tdep *tdep;
 650   const struct ppc_reg_offsets *offsets;
 651   size_t offset;
 652
 653   if (!ppc_floating_point_unit_p (gdbarch))
 654     return;
 655
 656   tdep = gdbarch_tdep (gdbarch);
 657   offsets = (const struct ppc_reg_offsets *) regset->regmap;
 658   if (regnum == -1)
 659     {
 660       int i;
 661
 662       for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
 663            i < tdep->ppc_fp0_regnum + ppc_num_fprs;
 664            i++, offset += 8)
 665         ppc_collect_reg (regcache, i, (gdb_byte *) fpregs, offset, 8);
 666
 667       ppc_collect_reg (regcache, tdep->ppc_fpscr_regnum,
 668                        (gdb_byte *) fpregs, offsets->fpscr_offset,
 669                        offsets->fpscr_size);
 670       return;
 671     }
 672
 673   offset = ppc_fpreg_offset (tdep, offsets, regnum);
 674   ppc_collect_reg (regcache, regnum, (gdb_byte *) fpregs, offset,
 675                    regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
 676 }
 677
 678 static int
 679 insn_changes_sp_or_jumps (unsigned long insn)
 680 {
 681   int opcode = (insn >> 26) & 0x03f;
 682   int sd = (insn >> 21) & 0x01f;
 683   int a = (insn >> 16) & 0x01f;
 684   int subcode = (insn >> 1) & 0x3ff;
 685
 686   /* Changes the stack pointer.  */
 687
 688   /* NOTE: There are many ways to change the value of a given register.
 689            The ways below are those used when the register is R1, the SP,
 690            in a funtion's epilogue.  */
 691
 692   if (opcode == 31 && subcode == 444 && a == 1)
 693     return 1;  /* mr R1,Rn */
 694   if (opcode == 14 && sd == 1)
 695     return 1;  /* addi R1,Rn,simm */
 696   if (opcode == 58 && sd == 1)
 697     return 1;  /* ld R1,ds(Rn) */
 698
 699   /* Transfers control.  */
 700
 701   if (opcode == 18)
 702     return 1;  /* b */
 703   if (opcode == 16)
 704     return 1;  /* bc */
 705   if (opcode == 19 && subcode == 16)
 706     return 1;  /* bclr */
 707   if (opcode == 19 && subcode == 528)
 708     return 1;  /* bcctr */
 709
 710   return 0;
 711 }
 712
 713 /* Return true if we are in the function's epilogue, i.e. after the
 714    instruction that destroyed the function's stack frame.
 715
 716    1) scan forward from the point of execution:
 717        a) If you find an instruction that modifies the stack pointer
 718           or transfers control (except a return), execution is not in
 719           an epilogue, return.
 720        b) Stop scanning if you find a return instruction or reach the
 721           end of the function or reach the hard limit for the size of
 722           an epilogue.
 723    2) scan backward from the point of execution:
 724         a) If you find an instruction that modifies the stack pointer,
 725             execution *is* in an epilogue, return.
 726         b) Stop scanning if you reach an instruction that transfers
 727            control or the beginning of the function or reach the hard
 728            limit for the size of an epilogue.  */
 729
 730 static int
 731 rs6000_in_function_epilogue_frame_p (struct frame_info *curfrm,
 732                                      struct gdbarch *gdbarch, CORE_ADDR pc)
 733 {
 734   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 735   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 736   bfd_byte insn_buf[PPC_INSN_SIZE];
 737   CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
 738   unsigned long insn;
 739
 740   /* Find the search limits based on function boundaries and hard limit.  */
 741
 742   if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
 743     return 0;
 744
 745   epilogue_start = pc - PPC_MAX_EPILOGUE_INSTRUCTIONS * PPC_INSN_SIZE;
 746   if (epilogue_start < func_start) epilogue_start = func_start;
 747
 748   epilogue_end = pc + PPC_MAX_EPILOGUE_INSTRUCTIONS * PPC_INSN_SIZE;
 749   if (epilogue_end > func_end) epilogue_end = func_end;
 750
 751   /* Scan forward until next 'blr'.  */
 752
 753   for (scan_pc = pc; scan_pc < epilogue_end; scan_pc += PPC_INSN_SIZE)
 754     {
 755       if (!safe_frame_unwind_memory (curfrm, scan_pc, insn_buf, PPC_INSN_SIZE))
 756         return 0;
 757       insn = extract_unsigned_integer (insn_buf, PPC_INSN_SIZE, byte_order);
 758       if (insn == 0x4e800020)
 759         break;
 760       /* Assume a bctr is a tail call unless it points strictly within
 761          this function.  */
 762       if (insn == 0x4e800420)
 763         {
 764           CORE_ADDR ctr = get_frame_register_unsigned (curfrm,
 765                                                        tdep->ppc_ctr_regnum);
 766           if (ctr > func_start && ctr < func_end)
 767             return 0;
 768           else
 769             break;
 770         }
 771       if (insn_changes_sp_or_jumps (insn))
 772         return 0;
 773     }
 774
 775   /* Scan backward until adjustment to stack pointer (R1).  */
 776
 777   for (scan_pc = pc - PPC_INSN_SIZE;
 778        scan_pc >= epilogue_start;
 779        scan_pc -= PPC_INSN_SIZE)
 780     {
 781       if (!safe_frame_unwind_memory (curfrm, scan_pc, insn_buf, PPC_INSN_SIZE))
 782         return 0;
 783       insn = extract_unsigned_integer (insn_buf, PPC_INSN_SIZE, byte_order);
 784       if (insn_changes_sp_or_jumps (insn))
 785         return 1;
 786     }
 787
 788   return 0;
 789 }
 790
 791 /* Implement the stack_frame_destroyed_p gdbarch method.  */
 792
 793 static int
 794 rs6000_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 795 {
 796   return rs6000_in_function_epilogue_frame_p (get_current_frame (),
 797                                               gdbarch, pc);
 798 }
 799
 800 /* Get the ith function argument for the current function.  */
 801 static CORE_ADDR
 802 rs6000_fetch_pointer_argument (struct frame_info *frame, int argi,
 803                                struct type *type)
 804 {
 805   return get_frame_register_unsigned (frame, 3 + argi);
 806 }
 807
 808 /* Sequence of bytes for breakpoint instruction.  */
 809
 810 constexpr gdb_byte big_breakpoint[] = { 0x7d, 0x82, 0x10, 0x08 };
 811 constexpr gdb_byte little_breakpoint[] = { 0x08, 0x10, 0x82, 0x7d };
 812
 813 typedef BP_MANIPULATION_ENDIAN (little_breakpoint, big_breakpoint)
 814   rs6000_breakpoint;
 815
 816 /* Instruction masks for displaced stepping.  */
 817 #define BRANCH_MASK 0xfc000000
 818 #define BP_MASK 0xFC0007FE
 819 #define B_INSN 0x48000000
 820 #define BC_INSN 0x40000000
 821 #define BXL_INSN 0x4c000000
 822 #define BP_INSN 0x7C000008
 823
 824 /* Instruction masks used during single-stepping of atomic
 825    sequences.  */
 826 #define LOAD_AND_RESERVE_MASK 0xfc0007fe
 827 #define LWARX_INSTRUCTION 0x7c000028
 828 #define LDARX_INSTRUCTION 0x7c0000A8
 829 #define LBARX_INSTRUCTION 0x7c000068
 830 #define LHARX_INSTRUCTION 0x7c0000e8
 831 #define LQARX_INSTRUCTION 0x7c000228
 832 #define STORE_CONDITIONAL_MASK 0xfc0007ff
 833 #define STWCX_INSTRUCTION 0x7c00012d
 834 #define STDCX_INSTRUCTION 0x7c0001ad
 835 #define STBCX_INSTRUCTION 0x7c00056d
 836 #define STHCX_INSTRUCTION 0x7c0005ad
 837 #define STQCX_INSTRUCTION 0x7c00016d
 838
 839 /* Check if insn is one of the Load And Reserve instructions used for atomic
 840    sequences.  */
 841 #define IS_LOAD_AND_RESERVE_INSN(insn)  ((insn & LOAD_AND_RESERVE_MASK) == LWARX_INSTRUCTION \
 842                                          || (insn & LOAD_AND_RESERVE_MASK) == LDARX_INSTRUCTION \
 843                                          || (insn & LOAD_AND_RESERVE_MASK) == LBARX_INSTRUCTION \
 844                                          || (insn & LOAD_AND_RESERVE_MASK) == LHARX_INSTRUCTION \
 845                                          || (insn & LOAD_AND_RESERVE_MASK) == LQARX_INSTRUCTION)
 846 /* Check if insn is one of the Store Conditional instructions used for atomic
 847    sequences.  */
 848 #define IS_STORE_CONDITIONAL_INSN(insn) ((insn & STORE_CONDITIONAL_MASK) == STWCX_INSTRUCTION \
 849                                          || (insn & STORE_CONDITIONAL_MASK) == STDCX_INSTRUCTION \
 850                                          || (insn & STORE_CONDITIONAL_MASK) == STBCX_INSTRUCTION \
 851                                          || (insn & STORE_CONDITIONAL_MASK) == STHCX_INSTRUCTION \
 852                                          || (insn & STORE_CONDITIONAL_MASK) == STQCX_INSTRUCTION)
 853
 854 typedef buf_displaced_step_closure ppc_displaced_step_closure;
 855
 856 /* We can't displaced step atomic sequences.  */
 857
 858 static struct displaced_step_closure *
 859 ppc_displaced_step_copy_insn (struct gdbarch *gdbarch,
 860                               CORE_ADDR from, CORE_ADDR to,
 861                               struct regcache *regs)
 862 {
 863   size_t len = gdbarch_max_insn_length (gdbarch);
 864   std::unique_ptr<ppc_displaced_step_closure> closure
 865     (new ppc_displaced_step_closure (len));
 866   gdb_byte *buf = closure->buf.data ();
 867   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 868   int insn;
 869
 870   read_memory (from, buf, len);
 871
 872   insn = extract_signed_integer (buf, PPC_INSN_SIZE, byte_order);
 873
 874   /* Assume all atomic sequences start with a Load and Reserve instruction.  */
 875   if (IS_LOAD_AND_RESERVE_INSN (insn))
 876     {
 877       if (debug_displaced)
 878         {
 879           fprintf_unfiltered (gdb_stdlog,
 880                               "displaced: can't displaced step "
 881                               "atomic sequence at %s\n",
 882                               paddress (gdbarch, from));
 883         }
 884
 885       return NULL;
 886     }
 887
 888   write_memory (to, buf, len);
 889
 890   if (debug_displaced)
 891     {
 892       fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
 893                           paddress (gdbarch, from), paddress (gdbarch, to));
 894       displaced_step_dump_bytes (gdb_stdlog, buf, len);
 895     }
 896
 897   return closure.release ();
 898 }
 899
 900 /* Fix up the state of registers and memory after having single-stepped
 901    a displaced instruction.  */
 902 static void
 903 ppc_displaced_step_fixup (struct gdbarch *gdbarch,
 904                           struct displaced_step_closure *closure_,
 905                           CORE_ADDR from, CORE_ADDR to,
 906                           struct regcache *regs)
 907 {
 908   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 909   /* Our closure is a copy of the instruction.  */
 910   ppc_displaced_step_closure *closure = (ppc_displaced_step_closure *) closure_;
 911   ULONGEST insn  = extract_unsigned_integer (closure->buf.data (),
 912                                              PPC_INSN_SIZE, byte_order);
 913   ULONGEST opcode = 0;
 914   /* Offset for non PC-relative instructions.  */
 915   LONGEST offset = PPC_INSN_SIZE;
 916
 917   opcode = insn & BRANCH_MASK;
 918
 919   if (debug_displaced)
 920     fprintf_unfiltered (gdb_stdlog,
 921                         "displaced: (ppc) fixup (%s, %s)\n",
 922                         paddress (gdbarch, from), paddress (gdbarch, to));
 923
 924
 925   /* Handle PC-relative branch instructions.  */
 926   if (opcode == B_INSN || opcode == BC_INSN || opcode == BXL_INSN)
 927     {
 928       ULONGEST current_pc;
 929
 930       /* Read the current PC value after the instruction has been executed
 931          in a displaced location.  Calculate the offset to be applied to the
 932          original PC value before the displaced stepping.  */
 933       regcache_cooked_read_unsigned (regs, gdbarch_pc_regnum (gdbarch),
 934                                       &current_pc);
 935       offset = current_pc - to;
 936
 937       if (opcode != BXL_INSN)
 938         {
 939           /* Check for AA bit indicating whether this is an absolute
 940              addressing or PC-relative (1: absolute, 0: relative).  */
 941           if (!(insn & 0x2))
 942             {
 943               /* PC-relative addressing is being used in the branch.  */
 944               if (debug_displaced)
 945                 fprintf_unfiltered
 946                   (gdb_stdlog,
 947                    "displaced: (ppc) branch instruction: %s\n"
 948                    "displaced: (ppc) adjusted PC from %s to %s\n",
 949                    paddress (gdbarch, insn), paddress (gdbarch, current_pc),
 950                    paddress (gdbarch, from + offset));
 951
 952               regcache_cooked_write_unsigned (regs,
 953                                               gdbarch_pc_regnum (gdbarch),
 954                                               from + offset);
 955             }
 956         }
 957       else
 958         {
 959           /* If we're here, it means we have a branch to LR or CTR.  If the
 960              branch was taken, the offset is probably greater than 4 (the next
 961              instruction), so it's safe to assume that an offset of 4 means we
 962              did not take the branch.  */
 963           if (offset == PPC_INSN_SIZE)
 964             regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
 965                                             from + PPC_INSN_SIZE);
 966         }
 967
 968       /* Check for LK bit indicating whether we should set the link
 969          register to point to the next instruction
 970          (1: Set, 0: Don't set).  */
 971       if (insn & 0x1)
 972         {
 973           /* Link register needs to be set to the next instruction's PC.  */
 974           regcache_cooked_write_unsigned (regs,
 975                                           gdbarch_tdep (gdbarch)->ppc_lr_regnum,
 976                                           from + PPC_INSN_SIZE);
 977           if (debug_displaced)
 978                 fprintf_unfiltered (gdb_stdlog,
 979                                     "displaced: (ppc) adjusted LR to %s\n",
 980                                     paddress (gdbarch, from + PPC_INSN_SIZE));
 981
 982         }
 983     }
 984   /* Check for breakpoints in the inferior.  If we've found one, place the PC
 985      right at the breakpoint instruction.  */
 986   else if ((insn & BP_MASK) == BP_INSN)
 987     regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch), from);
 988   else
 989   /* Handle any other instructions that do not fit in the categories above.  */
 990     regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
 991                                     from + offset);
 992 }
 993
 994 /* Always use hardware single-stepping to execute the
 995    displaced instruction.  */
 996 static int
 997 ppc_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
 998                                   struct displaced_step_closure *closure)
 999 {
1000   return 1;
1001 }
1002
1003 /* Checks for an atomic sequence of instructions beginning with a
1004    Load And Reserve instruction and ending with a Store Conditional
1005    instruction.  If such a sequence is found, attempt to step through it.
1006    A breakpoint is placed at the end of the sequence.  */
1007 std::vector<CORE_ADDR>
1008 ppc_deal_with_atomic_sequence (struct regcache *regcache)
1009 {
1010   struct gdbarch *gdbarch = regcache->arch ();
1011   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1012   CORE_ADDR pc = regcache_read_pc (regcache);
1013   CORE_ADDR breaks[2] = {CORE_ADDR_MAX, CORE_ADDR_MAX};
1014   CORE_ADDR loc = pc;
1015   CORE_ADDR closing_insn; /* Instruction that closes the atomic sequence.  */
1016   int insn = read_memory_integer (loc, PPC_INSN_SIZE, byte_order);
1017   int insn_count;
1018   int index;
1019   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */
1020   const int atomic_sequence_length = 16; /* Instruction sequence length.  */
1021   int bc_insn_count = 0; /* Conditional branch instruction count.  */
1022
1023   /* Assume all atomic sequences start with a Load And Reserve instruction.  */
1024   if (!IS_LOAD_AND_RESERVE_INSN (insn))
1025     return {};
1026
1027   /* Assume that no atomic sequence is longer than "atomic_sequence_length"
1028      instructions.  */
1029   for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
1030     {
1031       loc += PPC_INSN_SIZE;
1032       insn = read_memory_integer (loc, PPC_INSN_SIZE, byte_order);
1033
1034       /* Assume that there is at most one conditional branch in the atomic
1035          sequence.  If a conditional branch is found, put a breakpoint in
1036          its destination address.  */
1037       if ((insn & BRANCH_MASK) == BC_INSN)
1038         {
1039           int immediate = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
1040           int absolute = insn & 2;
1041
1042           if (bc_insn_count >= 1)
1043             return {}; /* More than one conditional branch found, fallback
1044                           to the standard single-step code.  */
1045
1046           if (absolute)
1047             breaks[1] = immediate;
1048           else
1049             breaks[1] = loc + immediate;
1050
1051           bc_insn_count++;
1052           last_breakpoint++;
1053         }
1054
1055       if (IS_STORE_CONDITIONAL_INSN (insn))
1056         break;
1057     }
1058
1059   /* Assume that the atomic sequence ends with a Store Conditional
1060      instruction.  */
1061   if (!IS_STORE_CONDITIONAL_INSN (insn))
1062     return {};
1063
1064   closing_insn = loc;
1065   loc += PPC_INSN_SIZE;
1066
1067   /* Insert a breakpoint right after the end of the atomic sequence.  */
1068   breaks[0] = loc;
1069
1070   /* Check for duplicated breakpoints.  Check also for a breakpoint
1071      placed (branch instruction's destination) anywhere in sequence.  */
1072   if (last_breakpoint
1073       && (breaks[1] == breaks[0]
1074           || (breaks[1] >= pc && breaks[1] <= closing_insn)))
1075     last_breakpoint = 0;
1076
1077   std::vector<CORE_ADDR> next_pcs;
1078
1079   for (index = 0; index <= last_breakpoint; index++)
1080     next_pcs.push_back (breaks[index]);
1081
1082   return next_pcs;
1083 }
1084
1085
1086 #define SIGNED_SHORT(x)                                                 \
1087   ((sizeof (short) == 2)                                                \
1088    ? ((int)(short)(x))                                                  \
1089    : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
1090
1091 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
1092
1093 /* Limit the number of skipped non-prologue instructions, as the examining
1094    of the prologue is expensive.  */
1095 static int max_skip_non_prologue_insns = 10;
1096
1097 /* Return nonzero if the given instruction OP can be part of the prologue
1098    of a function and saves a parameter on the stack.  FRAMEP should be
1099    set if one of the previous instructions in the function has set the
1100    Frame Pointer.  */
1101
1102 static int
1103 store_param_on_stack_p (unsigned long op, int framep, int *r0_contains_arg)
1104 {
1105   /* Move parameters from argument registers to temporary register.  */
1106   if ((op & 0xfc0007fe) == 0x7c000378)         /* mr(.)  Rx,Ry */
1107     {
1108       /* Rx must be scratch register r0.  */
1109       const int rx_regno = (op >> 16) & 31;
1110       /* Ry: Only r3 - r10 are used for parameter passing.  */
1111       const int ry_regno = GET_SRC_REG (op);
1112
1113       if (rx_regno == 0 && ry_regno >= 3 && ry_regno <= 10)
1114         {
1115           *r0_contains_arg = 1;
1116           return 1;
1117         }
1118       else
1119         return 0;
1120     }
1121
1122   /* Save a General Purpose Register on stack.  */
1123
1124   if ((op & 0xfc1f0003) == 0xf8010000 ||       /* std  Rx,NUM(r1) */
1125       (op & 0xfc1f0000) == 0xd8010000)         /* stfd Rx,NUM(r1) */
1126     {
1127       /* Rx: Only r3 - r10 are used for parameter passing.  */
1128       const int rx_regno = GET_SRC_REG (op);
1129
1130       return (rx_regno >= 3 && rx_regno <= 10);
1131     }
1132
1133   /* Save a General Purpose Register on stack via the Frame Pointer.  */
1134
1135   if (framep &&
1136       ((op & 0xfc1f0000) == 0x901f0000 ||     /* st rx,NUM(r31) */
1137        (op & 0xfc1f0000) == 0x981f0000 ||     /* stb Rx,NUM(r31) */
1138        (op & 0xfc1f0000) == 0xd81f0000))      /* stfd Rx,NUM(r31) */
1139     {
1140       /* Rx: Usually, only r3 - r10 are used for parameter passing.
1141          However, the compiler sometimes uses r0 to hold an argument.  */
1142       const int rx_regno = GET_SRC_REG (op);
1143
1144       return ((rx_regno >= 3 && rx_regno <= 10)
1145               || (rx_regno == 0 && *r0_contains_arg));
1146     }
1147
1148   if ((op & 0xfc1f0000) == 0xfc010000)         /* frsp, fp?,NUM(r1) */
1149     {
1150       /* Only f2 - f8 are used for parameter passing.  */
1151       const int src_regno = GET_SRC_REG (op);
1152
1153       return (src_regno >= 2 && src_regno <= 8);
1154     }
1155
1156   if (framep && ((op & 0xfc1f0000) == 0xfc1f0000))  /* frsp, fp?,NUM(r31) */
1157     {
1158       /* Only f2 - f8 are used for parameter passing.  */
1159       const int src_regno = GET_SRC_REG (op);
1160
1161       return (src_regno >= 2 && src_regno <= 8);
1162     }
1163
1164   /* Not an insn that saves a parameter on stack.  */
1165   return 0;
1166 }
1167
1168 /* Assuming that INSN is a "bl" instruction located at PC, return
1169    nonzero if the destination of the branch is a "blrl" instruction.
1170
1171    This sequence is sometimes found in certain function prologues.
1172    It allows the function to load the LR register with a value that
1173    they can use to access PIC data using PC-relative offsets.  */
1174
1175 static int
1176 bl_to_blrl_insn_p (CORE_ADDR pc, int insn, enum bfd_endian byte_order)
1177 {
1178   CORE_ADDR dest;
1179   int immediate;
1180   int absolute;
1181   int dest_insn;
1182
1183   absolute = (int) ((insn >> 1) & 1);
1184   immediate = ((insn & ~3) << 6) >> 6;
1185   if (absolute)
1186     dest = immediate;
1187   else
1188     dest = pc + immediate;
1189
1190   dest_insn = read_memory_integer (dest, 4, byte_order);
1191   if ((dest_insn & 0xfc00ffff) == 0x4c000021) /* blrl */
1192     return 1;
1193
1194   return 0;
1195 }
1196
1197 /* Return true if OP is a stw or std instruction with
1198    register operands RS and RA and any immediate offset.
1199
1200    If WITH_UPDATE is true, also return true if OP is
1201    a stwu or stdu instruction with the same operands.
1202
1203    Return false otherwise.
1204    */
1205 static bool
1206 store_insn_p (unsigned long op, unsigned long rs,
1207               unsigned long ra, bool with_update)
1208 {
1209   rs = rs << 21;
1210   ra = ra << 16;
1211
1212   if (/* std RS, SIMM(RA) */
1213       ((op & 0xffff0003) == (rs | ra | 0xf8000000)) ||
1214       /* stw RS, SIMM(RA) */
1215       ((op & 0xffff0000) == (rs | ra | 0x90000000)))
1216     return true;
1217
1218   if (with_update)
1219     {
1220       if (/* stdu RS, SIMM(RA) */
1221           ((op & 0xffff0003) == (rs | ra | 0xf8000001)) ||
1222           /* stwu RS, SIMM(RA) */
1223           ((op & 0xffff0000) == (rs | ra | 0x94000000)))
1224         return true;
1225     }
1226
1227   return false;
1228 }
1229
1230 /* Masks for decoding a branch-and-link (bl) instruction.
1231
1232    BL_MASK and BL_INSTRUCTION are used in combination with each other.
1233    The former is anded with the opcode in question; if the result of
1234    this masking operation is equal to BL_INSTRUCTION, then the opcode in
1235    question is a ``bl'' instruction.
1236
1237    BL_DISPLACMENT_MASK is anded with the opcode in order to extract
1238    the branch displacement.  */
1239
1240 #define BL_MASK 0xfc000001
1241 #define BL_INSTRUCTION 0x48000001
1242 #define BL_DISPLACEMENT_MASK 0x03fffffc
1243
1244 static unsigned long
1245 rs6000_fetch_instruction (struct gdbarch *gdbarch, const CORE_ADDR pc)
1246 {
1247   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1248   gdb_byte buf[4];
1249   unsigned long op;
1250
1251   /* Fetch the instruction and convert it to an integer.  */
1252   if (target_read_memory (pc, buf, 4))
1253     return 0;
1254   op = extract_unsigned_integer (buf, 4, byte_order);
1255
1256   return op;
1257 }
1258
1259 /* GCC generates several well-known sequences of instructions at the begining
1260    of each function prologue when compiling with -fstack-check.  If one of
1261    such sequences starts at START_PC, then return the address of the
1262    instruction immediately past this sequence.  Otherwise, return START_PC.  */
1263
1264 static CORE_ADDR
1265 rs6000_skip_stack_check (struct gdbarch *gdbarch, const CORE_ADDR start_pc)
1266 {
1267   CORE_ADDR pc = start_pc;
1268   unsigned long op = rs6000_fetch_instruction (gdbarch, pc);
1269
1270   /* First possible sequence: A small number of probes.
1271          stw 0, -<some immediate>(1)
1272          [repeat this instruction any (small) number of times].  */
1273
1274   if ((op & 0xffff0000) == 0x90010000)
1275     {
1276       while ((op & 0xffff0000) == 0x90010000)
1277         {
1278           pc = pc + 4;
1279           op = rs6000_fetch_instruction (gdbarch, pc);
1280         }
1281       return pc;
1282     }
1283
1284   /* Second sequence: A probing loop.
1285          addi 12,1,-<some immediate>
1286          lis 0,-<some immediate>
1287          [possibly ori 0,0,<some immediate>]
1288          add 0,12,0
1289          cmpw 0,12,0
1290          beq 0,<disp>
1291          addi 12,12,-<some immediate>
1292          stw 0,0(12)
1293          b <disp>
1294          [possibly one last probe: stw 0,<some immediate>(12)].  */
1295
1296   while (1)
1297     {
1298       /* addi 12,1,-<some immediate> */
1299       if ((op & 0xffff0000) != 0x39810000)
1300         break;
1301
1302       /* lis 0,-<some immediate> */
1303       pc = pc + 4;
1304       op = rs6000_fetch_instruction (gdbarch, pc);
1305       if ((op & 0xffff0000) != 0x3c000000)
1306         break;
1307
1308       pc = pc + 4;
1309       op = rs6000_fetch_instruction (gdbarch, pc);
1310       /* [possibly ori 0,0,<some immediate>] */
1311       if ((op & 0xffff0000) == 0x60000000)
1312         {
1313           pc = pc + 4;
1314           op = rs6000_fetch_instruction (gdbarch, pc);
1315         }
1316       /* add 0,12,0 */
1317       if (op != 0x7c0c0214)
1318         break;
1319
1320       /* cmpw 0,12,0 */
1321       pc = pc + 4;
1322       op = rs6000_fetch_instruction (gdbarch, pc);
1323       if (op != 0x7c0c0000)
1324         break;
1325
1326       /* beq 0,<disp> */
1327       pc = pc + 4;
1328       op = rs6000_fetch_instruction (gdbarch, pc);
1329       if ((op & 0xff9f0001) != 0x41820000)
1330         break;
1331
1332       /* addi 12,12,-<some immediate> */
1333       pc = pc + 4;
1334       op = rs6000_fetch_instruction (gdbarch, pc);
1335       if ((op & 0xffff0000) != 0x398c0000)
1336         break;
1337
1338       /* stw 0,0(12) */
1339       pc = pc + 4;
1340       op = rs6000_fetch_instruction (gdbarch, pc);
1341       if (op != 0x900c0000)
1342         break;
1343
1344       /* b <disp> */
1345       pc = pc + 4;
1346       op = rs6000_fetch_instruction (gdbarch, pc);
1347       if ((op & 0xfc000001) != 0x48000000)
1348         break;
1349
1350       /* [possibly one last probe: stw 0,<some immediate>(12)].  */
1351       pc = pc + 4;
1352       op = rs6000_fetch_instruction (gdbarch, pc);
1353       if ((op & 0xffff0000) == 0x900c0000)
1354         {
1355           pc = pc + 4;
1356           op = rs6000_fetch_instruction (gdbarch, pc);
1357         }
1358
1359       /* We found a valid stack-check sequence, return the new PC.  */
1360       return pc;
1361     }
1362
1363   /* Third sequence: No probe; instead, a comparizon between the stack size
1364      limit (saved in a run-time global variable) and the current stack
1365      pointer:
1366
1367         addi 0,1,-<some immediate>
1368         lis 12,__gnat_stack_limit@ha
1369         lwz 12,__gnat_stack_limit@l(12)
1370         twllt 0,12
1371
1372      or, with a small variant in the case of a bigger stack frame:
1373         addis 0,1,<some immediate>
1374         addic 0,0,-<some immediate>
1375         lis 12,__gnat_stack_limit@ha
1376         lwz 12,__gnat_stack_limit@l(12)
1377         twllt 0,12
1378   */
1379   while (1)
1380     {
1381       /* addi 0,1,-<some immediate> */
1382       if ((op & 0xffff0000) != 0x38010000)
1383         {
1384           /* small stack frame variant not recognized; try the
1385              big stack frame variant: */
1386
1387           /* addis 0,1,<some immediate> */
1388           if ((op & 0xffff0000) != 0x3c010000)
1389             break;
1390
1391           /* addic 0,0,-<some immediate> */
1392           pc = pc + 4;
1393           op = rs6000_fetch_instruction (gdbarch, pc);
1394           if ((op & 0xffff0000) != 0x30000000)
1395             break;
1396         }
1397
1398       /* lis 12,<some immediate> */
1399       pc = pc + 4;
1400       op = rs6000_fetch_instruction (gdbarch, pc);
1401       if ((op & 0xffff0000) != 0x3d800000)
1402         break;
1403
1404       /* lwz 12,<some immediate>(12) */
1405       pc = pc + 4;
1406       op = rs6000_fetch_instruction (gdbarch, pc);
1407       if ((op & 0xffff0000) != 0x818c0000)
1408         break;
1409
1410       /* twllt 0,12 */
1411       pc = pc + 4;
1412       op = rs6000_fetch_instruction (gdbarch, pc);
1413       if ((op & 0xfffffffe) != 0x7c406008)
1414         break;
1415
1416       /* We found a valid stack-check sequence, return the new PC.  */
1417       return pc;
1418     }
1419
1420   /* No stack check code in our prologue, return the start_pc.  */
1421   return start_pc;
1422 }
1423
1424 /* return pc value after skipping a function prologue and also return
1425    information about a function frame.
1426
1427    in struct rs6000_framedata fdata:
1428    - frameless is TRUE, if function does not have a frame.
1429    - nosavedpc is TRUE, if function does not save %pc value in its frame.
1430    - offset is the initial size of this stack frame --- the amount by
1431    which we decrement the sp to allocate the frame.
1432    - saved_gpr is the number of the first saved gpr.
1433    - saved_fpr is the number of the first saved fpr.
1434    - saved_vr is the number of the first saved vr.
1435    - saved_ev is the number of the first saved ev.
1436    - alloca_reg is the number of the register used for alloca() handling.
1437    Otherwise -1.
1438    - gpr_offset is the offset of the first saved gpr from the previous frame.
1439    - fpr_offset is the offset of the first saved fpr from the previous frame.
1440    - vr_offset is the offset of the first saved vr from the previous frame.
1441    - ev_offset is the offset of the first saved ev from the previous frame.
1442    - lr_offset is the offset of the saved lr
1443    - cr_offset is the offset of the saved cr
1444    - vrsave_offset is the offset of the saved vrsave register.  */
1445
1446 static CORE_ADDR
1447 skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR lim_pc,
1448                struct rs6000_framedata *fdata)
1449 {
1450   CORE_ADDR orig_pc = pc;
1451   CORE_ADDR last_prologue_pc = pc;
1452   CORE_ADDR li_found_pc = 0;
1453   gdb_byte buf[4];
1454   unsigned long op;
1455   long offset = 0;
1456   long alloca_reg_offset = 0;
1457   long vr_saved_offset = 0;
1458   int lr_reg = -1;
1459   int cr_reg = -1;
1460   int vr_reg = -1;
1461   int ev_reg = -1;
1462   long ev_offset = 0;
1463   int vrsave_reg = -1;
1464   int reg;
1465   int framep = 0;
1466   int minimal_toc_loaded = 0;
1467   int prev_insn_was_prologue_insn = 1;
1468   int num_skip_non_prologue_insns = 0;
1469   int r0_contains_arg = 0;
1470   const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
1471   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1472   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1473
1474   memset (fdata, 0, sizeof (struct rs6000_framedata));
1475   fdata->saved_gpr = -1;
1476   fdata->saved_fpr = -1;
1477   fdata->saved_vr = -1;
1478   fdata->saved_ev = -1;
1479   fdata->alloca_reg = -1;
1480   fdata->frameless = 1;
1481   fdata->nosavedpc = 1;
1482   fdata->lr_register = -1;
1483
1484   pc = rs6000_skip_stack_check (gdbarch, pc);
1485   if (pc >= lim_pc)
1486     pc = lim_pc;
1487
1488   for (;; pc += 4)
1489     {
1490       /* Sometimes it isn't clear if an instruction is a prologue
1491          instruction or not.  When we encounter one of these ambiguous
1492          cases, we'll set prev_insn_was_prologue_insn to 0 (false).
1493          Otherwise, we'll assume that it really is a prologue instruction.  */
1494       if (prev_insn_was_prologue_insn)
1495         last_prologue_pc = pc;
1496
1497       /* Stop scanning if we've hit the limit.  */
1498       if (pc >= lim_pc)
1499         break;
1500
1501       prev_insn_was_prologue_insn = 1;
1502
1503       /* Fetch the instruction and convert it to an integer.  */
1504       if (target_read_memory (pc, buf, 4))
1505         break;
1506       op = extract_unsigned_integer (buf, 4, byte_order);
1507
1508       if ((op & 0xfc1fffff) == 0x7c0802a6)
1509         {                       /* mflr Rx */
1510           /* Since shared library / PIC code, which needs to get its
1511              address at runtime, can appear to save more than one link
1512              register vis:
1513
1514              *INDENT-OFF*
1515              stwu r1,-304(r1)
1516              mflr r3
1517              bl 0xff570d0 (blrl)
1518              stw r30,296(r1)
1519              mflr r30
1520              stw r31,300(r1)
1521              stw r3,308(r1);
1522              ...
1523              *INDENT-ON*
1524
1525              remember just the first one, but skip over additional
1526              ones.  */
1527           if (lr_reg == -1)
1528             lr_reg = (op & 0x03e00000) >> 21;
1529           if (lr_reg == 0)
1530             r0_contains_arg = 0;
1531           continue;
1532         }
1533       else if ((op & 0xfc1fffff) == 0x7c000026)
1534         {                       /* mfcr Rx */
1535           cr_reg = (op & 0x03e00000) >> 21;
1536           if (cr_reg == 0)
1537             r0_contains_arg = 0;
1538           continue;
1539
1540         }
1541       else if ((op & 0xfc1f0000) == 0xd8010000)
1542         {                       /* stfd Rx,NUM(r1) */
1543           reg = GET_SRC_REG (op);
1544           if (fdata->saved_fpr == -1 || fdata->saved_fpr > reg)
1545             {
1546               fdata->saved_fpr = reg;
1547               fdata->fpr_offset = SIGNED_SHORT (op) + offset;
1548             }
1549           continue;
1550
1551         }
1552       else if (((op & 0xfc1f0000) == 0xbc010000) ||     /* stm Rx, NUM(r1) */
1553                (((op & 0xfc1f0000) == 0x90010000 ||     /* st rx,NUM(r1) */
1554                  (op & 0xfc1f0003) == 0xf8010000) &&    /* std rx,NUM(r1) */
1555                 (op & 0x03e00000) >= 0x01a00000))       /* rx >= r13 */
1556         {
1557
1558           reg = GET_SRC_REG (op);
1559           if ((op & 0xfc1f0000) == 0xbc010000)
1560             fdata->gpr_mask |= ~((1U << reg) - 1);
1561           else
1562             fdata->gpr_mask |= 1U << reg;
1563           if (fdata->saved_gpr == -1 || fdata->saved_gpr > reg)
1564             {
1565               fdata->saved_gpr = reg;
1566               if ((op & 0xfc1f0003) == 0xf8010000)
1567                 op &= ~3UL;
1568               fdata->gpr_offset = SIGNED_SHORT (op) + offset;
1569             }
1570           continue;
1571
1572         }
1573       else if ((op & 0xffff0000) == 0x3c4c0000
1574                || (op & 0xffff0000) == 0x3c400000
1575                || (op & 0xffff0000) == 0x38420000)
1576         {
1577           /* .  0:      addis 2,12,.TOC.-0b@ha
1578              .          addi 2,2,.TOC.-0b@l
1579              or
1580              .          lis 2,.TOC.@ha
1581              .          addi 2,2,.TOC.@l
1582              used by ELFv2 global entry points to set up r2.  */
1583           continue;
1584         }
1585       else if (op == 0x60000000)
1586         {
1587           /* nop */
1588           /* Allow nops in the prologue, but do not consider them to
1589              be part of the prologue unless followed by other prologue
1590              instructions.  */
1591           prev_insn_was_prologue_insn = 0;
1592           continue;
1593
1594         }
1595       else if ((op & 0xffff0000) == 0x3c000000)
1596         {                       /* addis 0,0,NUM, used for >= 32k frames */
1597           fdata->offset = (op & 0x0000ffff) << 16;
1598           fdata->frameless = 0;
1599           r0_contains_arg = 0;
1600           continue;
1601
1602         }
1603       else if ((op & 0xffff0000) == 0x60000000)
1604         {                       /* ori 0,0,NUM, 2nd half of >= 32k frames */
1605           fdata->offset |= (op & 0x0000ffff);
1606           fdata->frameless = 0;
1607           r0_contains_arg = 0;
1608           continue;
1609
1610         }
1611       else if (lr_reg >= 0 &&
1612                ((store_insn_p (op, lr_reg, 1, true)) ||
1613                 (framep &&
1614                  (store_insn_p (op, lr_reg,
1615                                 fdata->alloca_reg - tdep->ppc_gp0_regnum,
1616                                 false)))))
1617         {
1618           if (store_insn_p (op, lr_reg, 1, true))
1619             fdata->lr_offset = offset;
1620           else /* LR save through frame pointer. */
1621             fdata->lr_offset = alloca_reg_offset;
1622
1623           fdata->nosavedpc = 0;
1624           /* Invalidate lr_reg, but don't set it to -1.
1625              That would mean that it had never been set.  */
1626           lr_reg = -2;
1627           if ((op & 0xfc000003) == 0xf8000000 ||        /* std */
1628               (op & 0xfc000000) == 0x90000000)          /* stw */
1629             {
1630               /* Does not update r1, so add displacement to lr_offset.  */
1631               fdata->lr_offset += SIGNED_SHORT (op);
1632             }
1633           continue;
1634
1635         }
1636       else if (cr_reg >= 0 &&
1637                (store_insn_p (op, cr_reg, 1, true)))
1638         {
1639           fdata->cr_offset = offset;
1640           /* Invalidate cr_reg, but don't set it to -1.
1641              That would mean that it had never been set.  */
1642           cr_reg = -2;
1643           if ((op & 0xfc000003) == 0xf8000000 ||
1644               (op & 0xfc000000) == 0x90000000)
1645             {
1646               /* Does not update r1, so add displacement to cr_offset.  */
1647               fdata->cr_offset += SIGNED_SHORT (op);
1648             }
1649           continue;
1650
1651         }
1652       else if ((op & 0xfe80ffff) == 0x42800005 && lr_reg != -1)
1653         {
1654           /* bcl 20,xx,.+4 is used to get the current PC, with or without
1655              prediction bits.  If the LR has already been saved, we can
1656              skip it.  */
1657           continue;
1658         }
1659       else if (op == 0x48000005)
1660         {                       /* bl .+4 used in
1661                                    -mrelocatable */
1662           fdata->used_bl = 1;
1663           continue;
1664
1665         }
1666       else if (op == 0x48000004)
1667         {                       /* b .+4 (xlc) */
1668           break;
1669
1670         }
1671       else if ((op & 0xffff0000) == 0x3fc00000 ||  /* addis 30,0,foo@ha, used
1672                                                       in V.4 -mminimal-toc */
1673                (op & 0xffff0000) == 0x3bde0000)
1674         {                       /* addi 30,30,foo@l */
1675           continue;
1676
1677         }
1678       else if ((op & 0xfc000001) == 0x48000001)
1679         {                       /* bl foo,
1680                                    to save fprs???  */
1681
1682           fdata->frameless = 0;
1683
1684           /* If the return address has already been saved, we can skip
1685              calls to blrl (for PIC).  */
1686           if (lr_reg != -1 && bl_to_blrl_insn_p (pc, op, byte_order))
1687             {
1688               fdata->used_bl = 1;
1689               continue;
1690             }
1691
1692           /* Don't skip over the subroutine call if it is not within
1693              the first three instructions of the prologue and either
1694              we have no line table information or the line info tells
1695              us that the subroutine call is not part of the line
1696              associated with the prologue.  */
1697           if ((pc - orig_pc) > 8)
1698             {
1699               struct symtab_and_line prologue_sal = find_pc_line (orig_pc, 0);
1700               struct symtab_and_line this_sal = find_pc_line (pc, 0);
1701
1702               if ((prologue_sal.line == 0)
1703                   || (prologue_sal.line != this_sal.line))
1704                 break;
1705             }
1706
1707           op = read_memory_integer (pc + 4, 4, byte_order);
1708
1709           /* At this point, make sure this is not a trampoline
1710              function (a function that simply calls another functions,
1711              and nothing else).  If the next is not a nop, this branch
1712              was part of the function prologue.  */
1713
1714           if (op == 0x4def7b82 || op == 0)      /* crorc 15, 15, 15 */
1715             break;              /* Don't skip over
1716                                    this branch.  */
1717
1718           fdata->used_bl = 1;
1719           continue;
1720         }
1721       /* update stack pointer */
1722       else if ((op & 0xfc1f0000) == 0x94010000)
1723         {               /* stu rX,NUM(r1) ||  stwu rX,NUM(r1) */
1724           fdata->frameless = 0;
1725           fdata->offset = SIGNED_SHORT (op);
1726           offset = fdata->offset;
1727           continue;
1728         }
1729       else if ((op & 0xfc1f07fa) == 0x7c01016a)
1730         {               /* stwux rX,r1,rY  || stdux rX,r1,rY */
1731           /* No way to figure out what r1 is going to be.  */
1732           fdata->frameless = 0;
1733           offset = fdata->offset;
1734           continue;
1735         }
1736       else if ((op & 0xfc1f0003) == 0xf8010001)
1737         {                       /* stdu rX,NUM(r1) */
1738           fdata->frameless = 0;
1739           fdata->offset = SIGNED_SHORT (op & ~3UL);
1740           offset = fdata->offset;
1741           continue;
1742         }
1743       else if ((op & 0xffff0000) == 0x38210000)
1744         {                       /* addi r1,r1,SIMM */
1745           fdata->frameless = 0;
1746           fdata->offset += SIGNED_SHORT (op);
1747           offset = fdata->offset;
1748           continue;
1749         }
1750       /* Load up minimal toc pointer.  Do not treat an epilogue restore
1751          of r31 as a minimal TOC load.  */
1752       else if (((op >> 22) == 0x20f     ||      /* l r31,... or l r30,...  */
1753                (op >> 22) == 0x3af)             /* ld r31,... or ld r30,...  */
1754                && !framep
1755                && !minimal_toc_loaded)
1756         {
1757           minimal_toc_loaded = 1;
1758           continue;
1759
1760           /* move parameters from argument registers to local variable
1761              registers */
1762         }
1763       else if ((op & 0xfc0007fe) == 0x7c000378 &&       /* mr(.)  Rx,Ry */
1764                (((op >> 21) & 31) >= 3) &&              /* R3 >= Ry >= R10 */
1765                (((op >> 21) & 31) <= 10) &&
1766                ((long) ((op >> 16) & 31)
1767                 >= fdata->saved_gpr)) /* Rx: local var reg */
1768         {
1769           continue;
1770
1771           /* store parameters in stack */
1772         }
1773       /* Move parameters from argument registers to temporary register.  */
1774       else if (store_param_on_stack_p (op, framep, &r0_contains_arg))
1775         {
1776           continue;
1777
1778           /* Set up frame pointer */
1779         }
1780       else if (op == 0x603d0000)       /* oril r29, r1, 0x0 */
1781         {
1782           fdata->frameless = 0;
1783           framep = 1;
1784           fdata->alloca_reg = (tdep->ppc_gp0_regnum + 29);
1785           alloca_reg_offset = offset;
1786           continue;
1787
1788           /* Another way to set up the frame pointer.  */
1789         }
1790       else if (op == 0x603f0000 /* oril r31, r1, 0x0 */
1791                || op == 0x7c3f0b78)
1792         {                       /* mr r31, r1 */
1793           fdata->frameless = 0;
1794           framep = 1;
1795           fdata->alloca_reg = (tdep->ppc_gp0_regnum + 31);
1796           alloca_reg_offset = offset;
1797           continue;
1798
1799           /* Another way to set up the frame pointer.  */
1800         }
1801       else if ((op & 0xfc1fffff) == 0x38010000)
1802         {                       /* addi rX, r1, 0x0 */
1803           fdata->frameless = 0;
1804           framep = 1;
1805           fdata->alloca_reg = (tdep->ppc_gp0_regnum
1806                                + ((op & ~0x38010000) >> 21));
1807           alloca_reg_offset = offset;
1808           continue;
1809         }
1810       /* AltiVec related instructions.  */
1811       /* Store the vrsave register (spr 256) in another register for
1812          later manipulation, or load a register into the vrsave
1813          register.  2 instructions are used: mfvrsave and
1814          mtvrsave.  They are shorthand notation for mfspr Rn, SPR256
1815          and mtspr SPR256, Rn.  */
1816       /* mfspr Rn SPR256 == 011111 nnnnn 0000001000 01010100110
1817          mtspr SPR256 Rn == 011111 nnnnn 0000001000 01110100110  */
1818       else if ((op & 0xfc1fffff) == 0x7c0042a6)    /* mfvrsave Rn */
1819         {
1820           vrsave_reg = GET_SRC_REG (op);
1821           continue;
1822         }
1823       else if ((op & 0xfc1fffff) == 0x7c0043a6)     /* mtvrsave Rn */
1824         {
1825           continue;
1826         }
1827       /* Store the register where vrsave was saved to onto the stack:
1828          rS is the register where vrsave was stored in a previous
1829          instruction.  */
1830       /* 100100 sssss 00001 dddddddd dddddddd */
1831       else if ((op & 0xfc1f0000) == 0x90010000)     /* stw rS, d(r1) */
1832         {
1833           if (vrsave_reg == GET_SRC_REG (op))
1834             {
1835               fdata->vrsave_offset = SIGNED_SHORT (op) + offset;
1836               vrsave_reg = -1;
1837             }
1838           continue;
1839         }
1840       /* Compute the new value of vrsave, by modifying the register
1841          where vrsave was saved to.  */
1842       else if (((op & 0xfc000000) == 0x64000000)    /* oris Ra, Rs, UIMM */
1843                || ((op & 0xfc000000) == 0x60000000))/* ori Ra, Rs, UIMM */
1844         {
1845           continue;
1846         }
1847       /* li r0, SIMM (short for addi r0, 0, SIMM).  This is the first
1848          in a pair of insns to save the vector registers on the
1849          stack.  */
1850       /* 001110 00000 00000 iiii iiii iiii iiii  */
1851       /* 001110 01110 00000 iiii iiii iiii iiii  */
1852       else if ((op & 0xffff0000) == 0x38000000         /* li r0, SIMM */
1853                || (op & 0xffff0000) == 0x39c00000)     /* li r14, SIMM */
1854         {
1855           if ((op & 0xffff0000) == 0x38000000)
1856             r0_contains_arg = 0;
1857           li_found_pc = pc;
1858           vr_saved_offset = SIGNED_SHORT (op);
1859
1860           /* This insn by itself is not part of the prologue, unless
1861              if part of the pair of insns mentioned above.  So do not
1862              record this insn as part of the prologue yet.  */
1863           prev_insn_was_prologue_insn = 0;
1864         }
1865       /* Store vector register S at (r31+r0) aligned to 16 bytes.  */
1866       /* 011111 sssss 11111 00000 00111001110 */
1867       else if ((op & 0xfc1fffff) == 0x7c1f01ce)   /* stvx Vs, R31, R0 */
1868         {
1869           if (pc == (li_found_pc + 4))
1870             {
1871               vr_reg = GET_SRC_REG (op);
1872               /* If this is the first vector reg to be saved, or if
1873                  it has a lower number than others previously seen,
1874                  reupdate the frame info.  */
1875               if (fdata->saved_vr == -1 || fdata->saved_vr > vr_reg)
1876                 {
1877                   fdata->saved_vr = vr_reg;
1878                   fdata->vr_offset = vr_saved_offset + offset;
1879                 }
1880               vr_saved_offset = -1;
1881               vr_reg = -1;
1882               li_found_pc = 0;
1883             }
1884         }
1885       /* End AltiVec related instructions.  */
1886
1887       /* Start BookE related instructions.  */
1888       /* Store gen register S at (r31+uimm).
1889          Any register less than r13 is volatile, so we don't care.  */
1890       /* 000100 sssss 11111 iiiii 01100100001 */
1891       else if (arch_info->mach == bfd_mach_ppc_e500
1892                && (op & 0xfc1f07ff) == 0x101f0321)    /* evstdd Rs,uimm(R31) */
1893         {
1894           if ((op & 0x03e00000) >= 0x01a00000)  /* Rs >= r13 */
1895             {
1896               unsigned int imm;
1897               ev_reg = GET_SRC_REG (op);
1898               imm = (op >> 11) & 0x1f;
1899               ev_offset = imm * 8;
1900               /* If this is the first vector reg to be saved, or if
1901                  it has a lower number than others previously seen,
1902                  reupdate the frame info.  */
1903               if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1904                 {
1905                   fdata->saved_ev = ev_reg;
1906                   fdata->ev_offset = ev_offset + offset;
1907                 }
1908             }
1909           continue;
1910         }
1911       /* Store gen register rS at (r1+rB).  */
1912       /* 000100 sssss 00001 bbbbb 01100100000 */
1913       else if (arch_info->mach == bfd_mach_ppc_e500
1914                && (op & 0xffe007ff) == 0x13e00320)     /* evstddx RS,R1,Rb */
1915         {
1916           if (pc == (li_found_pc + 4))
1917             {
1918               ev_reg = GET_SRC_REG (op);
1919               /* If this is the first vector reg to be saved, or if
1920                  it has a lower number than others previously seen,
1921                  reupdate the frame info.  */
1922               /* We know the contents of rB from the previous instruction.  */
1923               if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1924                 {
1925                   fdata->saved_ev = ev_reg;
1926                   fdata->ev_offset = vr_saved_offset + offset;
1927                 }
1928               vr_saved_offset = -1;
1929               ev_reg = -1;
1930               li_found_pc = 0;
1931             }
1932           continue;
1933         }
1934       /* Store gen register r31 at (rA+uimm).  */
1935       /* 000100 11111 aaaaa iiiii 01100100001 */
1936       else if (arch_info->mach == bfd_mach_ppc_e500
1937                && (op & 0xffe007ff) == 0x13e00321)   /* evstdd R31,Ra,UIMM */
1938         {
1939           /* Wwe know that the source register is 31 already, but
1940              it can't hurt to compute it.  */
1941           ev_reg = GET_SRC_REG (op);
1942           ev_offset = ((op >> 11) & 0x1f) * 8;
1943           /* If this is the first vector reg to be saved, or if
1944              it has a lower number than others previously seen,
1945              reupdate the frame info.  */
1946           if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1947             {
1948               fdata->saved_ev = ev_reg;
1949               fdata->ev_offset = ev_offset + offset;
1950             }
1951
1952           continue;
1953         }
1954       /* Store gen register S at (r31+r0).
1955          Store param on stack when offset from SP bigger than 4 bytes.  */
1956       /* 000100 sssss 11111 00000 01100100000 */
1957       else if (arch_info->mach == bfd_mach_ppc_e500
1958                && (op & 0xfc1fffff) == 0x101f0320)     /* evstddx Rs,R31,R0 */
1959         {
1960           if (pc == (li_found_pc + 4))
1961             {
1962               if ((op & 0x03e00000) >= 0x01a00000)
1963                 {
1964                   ev_reg = GET_SRC_REG (op);
1965                   /* If this is the first vector reg to be saved, or if
1966                      it has a lower number than others previously seen,
1967                      reupdate the frame info.  */
1968                   /* We know the contents of r0 from the previous
1969                      instruction.  */
1970                   if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1971                     {
1972                       fdata->saved_ev = ev_reg;
1973                       fdata->ev_offset = vr_saved_offset + offset;
1974                     }
1975                   ev_reg = -1;
1976                 }
1977               vr_saved_offset = -1;
1978               li_found_pc = 0;
1979               continue;
1980             }
1981         }
1982       /* End BookE related instructions.  */
1983
1984       else
1985         {
1986           /* Not a recognized prologue instruction.
1987              Handle optimizer code motions into the prologue by continuing
1988              the search if we have no valid frame yet or if the return
1989              address is not yet saved in the frame.  Also skip instructions
1990              if some of the GPRs expected to be saved are not yet saved.  */
1991           if (fdata->frameless == 0 && fdata->nosavedpc == 0
1992               && fdata->saved_gpr != -1)
1993             {
1994               unsigned int all_mask = ~((1U << fdata->saved_gpr) - 1);
1995
1996               if ((fdata->gpr_mask & all_mask) == all_mask)
1997                 break;
1998             }
1999
2000           if (op == 0x4e800020          /* blr */
2001               || op == 0x4e800420)      /* bctr */
2002             /* Do not scan past epilogue in frameless functions or
2003                trampolines.  */
2004             break;
2005           if ((op & 0xf4000000) == 0x40000000) /* bxx */
2006             /* Never skip branches.  */
2007             break;
2008
2009           if (num_skip_non_prologue_insns++ > max_skip_non_prologue_insns)
2010             /* Do not scan too many insns, scanning insns is expensive with
2011                remote targets.  */
2012             break;
2013
2014           /* Continue scanning.  */
2015           prev_insn_was_prologue_insn = 0;
2016           continue;
2017         }
2018     }
2019
2020 #if 0
2021 /* I have problems with skipping over __main() that I need to address
2022  * sometime.  Previously, I used to use misc_function_vector which
2023  * didn't work as well as I wanted to be.  -MGO */
2024
2025   /* If the first thing after skipping a prolog is a branch to a function,
2026      this might be a call to an initializer in main(), introduced by gcc2.
2027      We'd like to skip over it as well.  Fortunately, xlc does some extra
2028      work before calling a function right after a prologue, thus we can
2029      single out such gcc2 behaviour.  */
2030
2031
2032   if ((op & 0xfc000001) == 0x48000001)
2033     {                           /* bl foo, an initializer function?  */
2034       op = read_memory_integer (pc + 4, 4, byte_order);
2035
2036       if (op == 0x4def7b82)
2037         {                       /* cror 0xf, 0xf, 0xf (nop) */
2038
2039           /* Check and see if we are in main.  If so, skip over this
2040              initializer function as well.  */
2041
2042           tmp = find_pc_misc_function (pc);
2043           if (tmp >= 0
2044               && strcmp (misc_function_vector[tmp].name, main_name ()) == 0)
2045             return pc + 8;
2046         }
2047     }
2048 #endif /* 0 */
2049
2050   if (pc == lim_pc && lr_reg >= 0)
2051     fdata->lr_register = lr_reg;
2052
2053   fdata->offset = -fdata->offset;
2054   return last_prologue_pc;
2055 }
2056
2057 static CORE_ADDR
2058 rs6000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
2059 {
2060   struct rs6000_framedata frame;
2061   CORE_ADDR limit_pc, func_addr, func_end_addr = 0;
2062
2063   /* See if we can determine the end of the prologue via the symbol table.
2064      If so, then return either PC, or the PC after the prologue, whichever
2065      is greater.  */
2066   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end_addr))
2067     {
2068       CORE_ADDR post_prologue_pc
2069         = skip_prologue_using_sal (gdbarch, func_addr);
2070       if (post_prologue_pc != 0)
2071         return std::max (pc, post_prologue_pc);
2072     }
2073
2074   /* Can't determine prologue from the symbol table, need to examine
2075      instructions.  */
2076
2077   /* Find an upper limit on the function prologue using the debug
2078      information.  If the debug information could not be used to provide
2079      that bound, then use an arbitrary large number as the upper bound.  */
2080   limit_pc = skip_prologue_using_sal (gdbarch, pc);
2081   if (limit_pc == 0)
2082     limit_pc = pc + 100;          /* Magic.  */
2083
2084   /* Do not allow limit_pc to be past the function end, if we know
2085      where that end is...  */
2086   if (func_end_addr && limit_pc > func_end_addr)
2087     limit_pc = func_end_addr;
2088
2089   pc = skip_prologue (gdbarch, pc, limit_pc, &frame);
2090   return pc;
2091 }
2092
2093 /* When compiling for EABI, some versions of GCC emit a call to __eabi
2094    in the prologue of main().
2095
2096    The function below examines the code pointed at by PC and checks to
2097    see if it corresponds to a call to __eabi.  If so, it returns the
2098    address of the instruction following that call.  Otherwise, it simply
2099    returns PC.  */
2100
2101 static CORE_ADDR
2102 rs6000_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
2103 {
2104   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2105   gdb_byte buf[4];
2106   unsigned long op;
2107
2108   if (target_read_memory (pc, buf, 4))
2109     return pc;
2110   op = extract_unsigned_integer (buf, 4, byte_order);
2111
2112   if ((op & BL_MASK) == BL_INSTRUCTION)
2113     {
2114       CORE_ADDR displ = op & BL_DISPLACEMENT_MASK;
2115       CORE_ADDR call_dest = pc + 4 + displ;
2116       struct bound_minimal_symbol s = lookup_minimal_symbol_by_pc (call_dest);
2117
2118       /* We check for ___eabi (three leading underscores) in addition
2119          to __eabi in case the GCC option "-fleading-underscore" was
2120          used to compile the program.  */
2121       if (s.minsym != NULL
2122           && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
2123           && (strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__eabi") == 0
2124               || strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "___eabi") == 0))
2125         pc += 4;
2126     }
2127   return pc;
2128 }
2129
2130 /* All the ABI's require 16 byte alignment.  */
2131 static CORE_ADDR
2132 rs6000_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2133 {
2134   return (addr & -16);
2135 }
2136
2137 /* Return whether handle_inferior_event() should proceed through code
2138    starting at PC in function NAME when stepping.
2139
2140    The AIX -bbigtoc linker option generates functions @FIX0, @FIX1, etc. to
2141    handle memory references that are too distant to fit in instructions
2142    generated by the compiler.  For example, if 'foo' in the following
2143    instruction:
2144
2145      lwz r9,foo(r2)
2146
2147    is greater than 32767, the linker might replace the lwz with a branch to
2148    somewhere in @FIX1 that does the load in 2 instructions and then branches
2149    back to where execution should continue.
2150
2151    GDB should silently step over @FIX code, just like AIX dbx does.
2152    Unfortunately, the linker uses the "b" instruction for the
2153    branches, meaning that the link register doesn't get set.
2154    Therefore, GDB's usual step_over_function () mechanism won't work.
2155
2156    Instead, use the gdbarch_skip_trampoline_code and
2157    gdbarch_skip_trampoline_code hooks in handle_inferior_event() to skip past
2158    @FIX code.  */
2159
2160 static int
2161 rs6000_in_solib_return_trampoline (struct gdbarch *gdbarch,
2162                                    CORE_ADDR pc, const char *name)
2163 {
2164   return name && startswith (name, "@FIX");
2165 }
2166
2167 /* Skip code that the user doesn't want to see when stepping:
2168
2169    1. Indirect function calls use a piece of trampoline code to do context
2170    switching, i.e. to set the new TOC table.  Skip such code if we are on
2171    its first instruction (as when we have single-stepped to here).
2172
2173    2. Skip shared library trampoline code (which is different from
2174    indirect function call trampolines).
2175
2176    3. Skip bigtoc fixup code.
2177
2178    Result is desired PC to step until, or NULL if we are not in
2179    code that should be skipped.  */
2180
2181 static CORE_ADDR
2182 rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
2183 {
2184   struct gdbarch *gdbarch = get_frame_arch (frame);
2185   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2186   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2187   unsigned int ii, op;
2188   int rel;
2189   CORE_ADDR solib_target_pc;
2190   struct bound_minimal_symbol msymbol;
2191
2192   static unsigned trampoline_code[] =
2193   {
2194     0x800b0000,                 /*     l   r0,0x0(r11)  */
2195     0x90410014,                 /*    st   r2,0x14(r1)  */
2196     0x7c0903a6,                 /* mtctr   r0           */
2197     0x804b0004,                 /*     l   r2,0x4(r11)  */
2198     0x816b0008,                 /*     l  r11,0x8(r11)  */
2199     0x4e800420,                 /*  bctr                */
2200     0x4e800020,                 /*    br                */
2201     0
2202   };
2203
2204   /* Check for bigtoc fixup code.  */
2205   msymbol = lookup_minimal_symbol_by_pc (pc);
2206   if (msymbol.minsym
2207       && rs6000_in_solib_return_trampoline (gdbarch, pc,
2208                                             MSYMBOL_LINKAGE_NAME (msymbol.minsym)))
2209     {
2210       /* Double-check that the third instruction from PC is relative "b".  */
2211       op = read_memory_integer (pc + 8, 4, byte_order);
2212       if ((op & 0xfc000003) == 0x48000000)
2213         {
2214           /* Extract bits 6-29 as a signed 24-bit relative word address and
2215              add it to the containing PC.  */
2216           rel = ((int)(op << 6) >> 6);
2217           return pc + 8 + rel;
2218         }
2219     }
2220
2221   /* If pc is in a shared library trampoline, return its target.  */
2222   solib_target_pc = find_solib_trampoline_target (frame, pc);
2223   if (solib_target_pc)
2224     return solib_target_pc;
2225
2226   for (ii = 0; trampoline_code[ii]; ++ii)
2227     {
2228       op = read_memory_integer (pc + (ii * 4), 4, byte_order);
2229       if (op != trampoline_code[ii])
2230         return 0;
2231     }
2232   ii = get_frame_register_unsigned (frame, 11); /* r11 holds destination
2233                                                    addr.  */
2234   pc = read_memory_unsigned_integer (ii, tdep->wordsize, byte_order);
2235   return pc;
2236 }
2237
2238 /* ISA-specific vector types.  */
2239
2240 static struct type *
2241 rs6000_builtin_type_vec64 (struct gdbarch *gdbarch)
2242 {
2243   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2244
2245   if (!tdep->ppc_builtin_type_vec64)
2246     {
2247       const struct builtin_type *bt = builtin_type (gdbarch);
2248
2249       /* The type we're building is this: */
2250 #if 0
2251       union __gdb_builtin_type_vec64
2252         {
2253           int64_t uint64;
2254           float v2_float[2];
2255           int32_t v2_int32[2];
2256           int16_t v4_int16[4];
2257           int8_t v8_int8[8];
2258         };
2259 #endif
2260
2261       struct type *t;
2262
2263       t = arch_composite_type (gdbarch,
2264                                "__ppc_builtin_type_vec64", TYPE_CODE_UNION);
2265       append_composite_type_field (t, "uint64", bt->builtin_int64);
2266       append_composite_type_field (t, "v2_float",
2267                                    init_vector_type (bt->builtin_float, 2));
2268       append_composite_type_field (t, "v2_int32",
2269                                    init_vector_type (bt->builtin_int32, 2));
2270       append_composite_type_field (t, "v4_int16",
2271                                    init_vector_type (bt->builtin_int16, 4));
2272       append_composite_type_field (t, "v8_int8",
2273                                    init_vector_type (bt->builtin_int8, 8));
2274
2275       TYPE_VECTOR (t) = 1;
2276       TYPE_NAME (t) = "ppc_builtin_type_vec64";
2277       tdep->ppc_builtin_type_vec64 = t;
2278     }
2279
2280   return tdep->ppc_builtin_type_vec64;
2281 }
2282
2283 /* Vector 128 type.  */
2284
2285 static struct type *
2286 rs6000_builtin_type_vec128 (struct gdbarch *gdbarch)
2287 {
2288   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2289
2290   if (!tdep->ppc_builtin_type_vec128)
2291     {
2292       const struct builtin_type *bt = builtin_type (gdbarch);
2293
2294       /* The type we're building is this
2295
2296          type = union __ppc_builtin_type_vec128 {
2297              uint128_t uint128;
2298              double v2_double[2];
2299              float v4_float[4];
2300              int32_t v4_int32[4];
2301              int16_t v8_int16[8];
2302              int8_t v16_int8[16];
2303          }
2304       */
2305
2306       struct type *t;
2307
2308       t = arch_composite_type (gdbarch,
2309                                "__ppc_builtin_type_vec128", TYPE_CODE_UNION);
2310       append_composite_type_field (t, "uint128", bt->builtin_uint128);
2311       append_composite_type_field (t, "v2_double",
2312                                    init_vector_type (bt->builtin_double, 2));
2313       append_composite_type_field (t, "v4_float",
2314                                    init_vector_type (bt->builtin_float, 4));
2315       append_composite_type_field (t, "v4_int32",
2316                                    init_vector_type (bt->builtin_int32, 4));
2317       append_composite_type_field (t, "v8_int16",
2318                                    init_vector_type (bt->builtin_int16, 8));
2319       append_composite_type_field (t, "v16_int8",
2320                                    init_vector_type (bt->builtin_int8, 16));
2321
2322       TYPE_VECTOR (t) = 1;
2323       TYPE_NAME (t) = "ppc_builtin_type_vec128";
2324       tdep->ppc_builtin_type_vec128 = t;
2325     }
2326
2327   return tdep->ppc_builtin_type_vec128;
2328 }
2329
2330 /* Return the name of register number REGNO, or the empty string if it
2331    is an anonymous register.  */
2332
2333 static const char *
2334 rs6000_register_name (struct gdbarch *gdbarch, int regno)
2335 {
2336   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2337
2338   /* The upper half "registers" have names in the XML description,
2339      but we present only the low GPRs and the full 64-bit registers
2340      to the user.  */
2341   if (tdep->ppc_ev0_upper_regnum >= 0
2342       && tdep->ppc_ev0_upper_regnum <= regno
2343       && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
2344     return "";
2345
2346   /* Hide the upper halves of the vs0~vs31 registers.  */
2347   if (tdep->ppc_vsr0_regnum >= 0
2348       && tdep->ppc_vsr0_upper_regnum <= regno
2349       && regno < tdep->ppc_vsr0_upper_regnum + ppc_num_gprs)
2350     return "";
2351
2352   /* Hide the upper halves of the cvs0~cvs31 registers.  */
2353   if (PPC_CVSR0_UPPER_REGNUM <= regno
2354       && regno < PPC_CVSR0_UPPER_REGNUM + ppc_num_gprs)
2355     return "";
2356
2357   /* Check if the SPE pseudo registers are available.  */
2358   if (IS_SPE_PSEUDOREG (tdep, regno))
2359     {
2360       static const char *const spe_regnames[] = {
2361         "ev0", "ev1", "ev2", "ev3", "ev4", "ev5", "ev6", "ev7",
2362         "ev8", "ev9", "ev10", "ev11", "ev12", "ev13", "ev14", "ev15",
2363         "ev16", "ev17", "ev18", "ev19", "ev20", "ev21", "ev22", "ev23",
2364         "ev24", "ev25", "ev26", "ev27", "ev28", "ev29", "ev30", "ev31",
2365       };
2366       return spe_regnames[regno - tdep->ppc_ev0_regnum];
2367     }
2368
2369   /* Check if the decimal128 pseudo-registers are available.  */
2370   if (IS_DFP_PSEUDOREG (tdep, regno))
2371     {
2372       static const char *const dfp128_regnames[] = {
2373         "dl0", "dl1", "dl2", "dl3",
2374         "dl4", "dl5", "dl6", "dl7",
2375         "dl8", "dl9", "dl10", "dl11",
2376         "dl12", "dl13", "dl14", "dl15"
2377       };
2378       return dfp128_regnames[regno - tdep->ppc_dl0_regnum];
2379     }
2380
2381   /* Check if this is a vX alias for a raw vrX vector register.  */
2382   if (IS_V_ALIAS_PSEUDOREG (tdep, regno))
2383     {
2384       static const char *const vector_alias_regnames[] = {
2385         "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
2386         "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
2387         "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
2388         "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
2389       };
2390       return vector_alias_regnames[regno - tdep->ppc_v0_alias_regnum];
2391     }
2392
2393   /* Check if this is a VSX pseudo-register.  */
2394   if (IS_VSX_PSEUDOREG (tdep, regno))
2395     {
2396       static const char *const vsx_regnames[] = {
2397         "vs0", "vs1", "vs2", "vs3", "vs4", "vs5", "vs6", "vs7",
2398         "vs8", "vs9", "vs10", "vs11", "vs12", "vs13", "vs14",
2399         "vs15", "vs16", "vs17", "vs18", "vs19", "vs20", "vs21",
2400         "vs22", "vs23", "vs24", "vs25", "vs26", "vs27", "vs28",
2401         "vs29", "vs30", "vs31", "vs32", "vs33", "vs34", "vs35",
2402         "vs36", "vs37", "vs38", "vs39", "vs40", "vs41", "vs42",
2403         "vs43", "vs44", "vs45", "vs46", "vs47", "vs48", "vs49",
2404         "vs50", "vs51", "vs52", "vs53", "vs54", "vs55", "vs56",
2405         "vs57", "vs58", "vs59", "vs60", "vs61", "vs62", "vs63"
2406       };
2407       return vsx_regnames[regno - tdep->ppc_vsr0_regnum];
2408     }
2409
2410   /* Check if the this is a Extended FP pseudo-register.  */
2411   if (IS_EFP_PSEUDOREG (tdep, regno))
2412     {
2413       static const char *const efpr_regnames[] = {
2414         "f32", "f33", "f34", "f35", "f36", "f37", "f38",
2415         "f39", "f40", "f41", "f42", "f43", "f44", "f45",
2416         "f46", "f47", "f48", "f49", "f50", "f51",
2417         "f52", "f53", "f54", "f55", "f56", "f57",
2418         "f58", "f59", "f60", "f61", "f62", "f63"
2419       };
2420       return efpr_regnames[regno - tdep->ppc_efpr0_regnum];
2421     }
2422
2423   /* Check if this is a Checkpointed DFP pseudo-register.  */
2424   if (IS_CDFP_PSEUDOREG (tdep, regno))
2425     {
2426       static const char *const cdfp128_regnames[] = {
2427         "cdl0", "cdl1", "cdl2", "cdl3",
2428         "cdl4", "cdl5", "cdl6", "cdl7",
2429         "cdl8", "cdl9", "cdl10", "cdl11",
2430         "cdl12", "cdl13", "cdl14", "cdl15"
2431       };
2432       return cdfp128_regnames[regno - tdep->ppc_cdl0_regnum];
2433     }
2434
2435   /* Check if this is a Checkpointed VSX pseudo-register.  */
2436   if (IS_CVSX_PSEUDOREG (tdep, regno))
2437     {
2438       static const char *const cvsx_regnames[] = {
2439         "cvs0", "cvs1", "cvs2", "cvs3", "cvs4", "cvs5", "cvs6", "cvs7",
2440         "cvs8", "cvs9", "cvs10", "cvs11", "cvs12", "cvs13", "cvs14",
2441         "cvs15", "cvs16", "cvs17", "cvs18", "cvs19", "cvs20", "cvs21",
2442         "cvs22", "cvs23", "cvs24", "cvs25", "cvs26", "cvs27", "cvs28",
2443         "cvs29", "cvs30", "cvs31", "cvs32", "cvs33", "cvs34", "cvs35",
2444         "cvs36", "cvs37", "cvs38", "cvs39", "cvs40", "cvs41", "cvs42",
2445         "cvs43", "cvs44", "cvs45", "cvs46", "cvs47", "cvs48", "cvs49",
2446         "cvs50", "cvs51", "cvs52", "cvs53", "cvs54", "cvs55", "cvs56",
2447         "cvs57", "cvs58", "cvs59", "cvs60", "cvs61", "cvs62", "cvs63"
2448       };
2449       return cvsx_regnames[regno - tdep->ppc_cvsr0_regnum];
2450     }
2451
2452   /* Check if the this is a Checkpointed Extended FP pseudo-register.  */
2453   if (IS_CEFP_PSEUDOREG (tdep, regno))
2454     {
2455       static const char *const cefpr_regnames[] = {
2456         "cf32", "cf33", "cf34", "cf35", "cf36", "cf37", "cf38",
2457         "cf39", "cf40", "cf41", "cf42", "cf43", "cf44", "cf45",
2458         "cf46", "cf47", "cf48", "cf49", "cf50", "cf51",
2459         "cf52", "cf53", "cf54", "cf55", "cf56", "cf57",
2460         "cf58", "cf59", "cf60", "cf61", "cf62", "cf63"
2461       };
2462       return cefpr_regnames[regno - tdep->ppc_cefpr0_regnum];
2463     }
2464
2465   return tdesc_register_name (gdbarch, regno);
2466 }
2467
2468 /* Return the GDB type object for the "standard" data type of data in
2469    register N.  */
2470
2471 static struct type *
2472 rs6000_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
2473 {
2474   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2475
2476   /* These are the e500 pseudo-registers.  */
2477   if (IS_SPE_PSEUDOREG (tdep, regnum))
2478     return rs6000_builtin_type_vec64 (gdbarch);
2479   else if (IS_DFP_PSEUDOREG (tdep, regnum)
2480            || IS_CDFP_PSEUDOREG (tdep, regnum))
2481     /* PPC decimal128 pseudo-registers.  */
2482     return builtin_type (gdbarch)->builtin_declong;
2483   else if (IS_V_ALIAS_PSEUDOREG (tdep, regnum))
2484     return gdbarch_register_type (gdbarch,
2485                                   tdep->ppc_vr0_regnum
2486                                   + (regnum
2487                                      - tdep->ppc_v0_alias_regnum));
2488   else if (IS_VSX_PSEUDOREG (tdep, regnum)
2489            || IS_CVSX_PSEUDOREG (tdep, regnum))
2490     /* POWER7 VSX pseudo-registers.  */
2491     return rs6000_builtin_type_vec128 (gdbarch);
2492   else if (IS_EFP_PSEUDOREG (tdep, regnum)
2493            || IS_CEFP_PSEUDOREG (tdep, regnum))
2494     /* POWER7 Extended FP pseudo-registers.  */
2495     return builtin_type (gdbarch)->builtin_double;
2496   else
2497     internal_error (__FILE__, __LINE__,
2498                     _("rs6000_pseudo_register_type: "
2499                       "called on unexpected register '%s' (%d)"),
2500                     gdbarch_register_name (gdbarch, regnum), regnum);
2501 }
2502
2503 /* Check if REGNUM is a member of REGGROUP.  We only need to handle
2504    the vX aliases for the vector registers by always returning false
2505    to avoid duplicated information in "info register vector/all",
2506    since the raw vrX registers will already show in these cases.  For
2507    other pseudo-registers we use the default membership function.  */
2508
2509 static int
2510 rs6000_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2511                                    struct reggroup *group)
2512 {
2513   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2514
2515   if (IS_V_ALIAS_PSEUDOREG (tdep, regnum))
2516     return 0;
2517   else
2518     return default_register_reggroup_p (gdbarch, regnum, group);
2519 }
2520
2521 /* The register format for RS/6000 floating point registers is always
2522    double, we need a conversion if the memory format is float.  */
2523
2524 static int
2525 rs6000_convert_register_p (struct gdbarch *gdbarch, int regnum,
2526                            struct type *type)
2527 {
2528   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2529
2530   return (tdep->ppc_fp0_regnum >= 0
2531           && regnum >= tdep->ppc_fp0_regnum
2532           && regnum < tdep->ppc_fp0_regnum + ppc_num_fprs
2533           && TYPE_CODE (type) == TYPE_CODE_FLT
2534           && TYPE_LENGTH (type)
2535              != TYPE_LENGTH (builtin_type (gdbarch)->builtin_double));
2536 }
2537
2538 static int
2539 rs6000_register_to_value (struct frame_info *frame,
2540                           int regnum,
2541                           struct type *type,
2542                           gdb_byte *to,
2543                           int *optimizedp, int *unavailablep)
2544 {
2545   struct gdbarch *gdbarch = get_frame_arch (frame);
2546   gdb_byte from[PPC_MAX_REGISTER_SIZE];
2547
2548   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
2549
2550   if (!get_frame_register_bytes (frame, regnum, 0,
2551                                  register_size (gdbarch, regnum),
2552                                  from, optimizedp, unavailablep))
2553     return 0;
2554
2555   target_float_convert (from, builtin_type (gdbarch)->builtin_double,
2556                         to, type);
2557   *optimizedp = *unavailablep = 0;
2558   return 1;
2559 }
2560
2561 static void
2562 rs6000_value_to_register (struct frame_info *frame,
2563                           int regnum,
2564                           struct type *type,
2565                           const gdb_byte *from)
2566 {
2567   struct gdbarch *gdbarch = get_frame_arch (frame);
2568   gdb_byte to[PPC_MAX_REGISTER_SIZE];
2569
2570   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
2571
2572   target_float_convert (from, type,
2573                         to, builtin_type (gdbarch)->builtin_double);
2574   put_frame_register (frame, regnum, to);
2575 }
2576
2577  /* The type of a function that moves the value of REG between CACHE
2578     or BUF --- in either direction.  */
2579 typedef enum register_status (*move_ev_register_func) (struct regcache *,
2580                                                        int, void *);
2581
2582 /* Move SPE vector register values between a 64-bit buffer and the two
2583    32-bit raw register halves in a regcache.  This function handles
2584    both splitting a 64-bit value into two 32-bit halves, and joining
2585    two halves into a whole 64-bit value, depending on the function
2586    passed as the MOVE argument.
2587
2588    EV_REG must be the number of an SPE evN vector register --- a
2589    pseudoregister.  REGCACHE must be a regcache, and BUFFER must be a
2590    64-bit buffer.
2591
2592    Call MOVE once for each 32-bit half of that register, passing
2593    REGCACHE, the number of the raw register corresponding to that
2594    half, and the address of the appropriate half of BUFFER.
2595
2596    For example, passing 'regcache_raw_read' as the MOVE function will
2597    fill BUFFER with the full 64-bit contents of EV_REG.  Or, passing
2598    'regcache_raw_supply' will supply the contents of BUFFER to the
2599    appropriate pair of raw registers in REGCACHE.
2600
2601    You may need to cast away some 'const' qualifiers when passing
2602    MOVE, since this function can't tell at compile-time which of
2603    REGCACHE or BUFFER is acting as the source of the data.  If C had
2604    co-variant type qualifiers, ...  */
2605
2606 static enum register_status
2607 e500_move_ev_register (move_ev_register_func move,
2608                        struct regcache *regcache, int ev_reg, void *buffer)
2609 {
2610   struct gdbarch *arch = regcache->arch ();
2611   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
2612   int reg_index;
2613   gdb_byte *byte_buffer = (gdb_byte *) buffer;
2614   enum register_status status;
2615
2616   gdb_assert (IS_SPE_PSEUDOREG (tdep, ev_reg));
2617
2618   reg_index = ev_reg - tdep->ppc_ev0_regnum;
2619
2620   if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
2621     {
2622       status = move (regcache, tdep->ppc_ev0_upper_regnum + reg_index,
2623                      byte_buffer);
2624       if (status == REG_VALID)
2625         status = move (regcache, tdep->ppc_gp0_regnum + reg_index,
2626                        byte_buffer + 4);
2627     }
2628   else
2629     {
2630       status = move (regcache, tdep->ppc_gp0_regnum + reg_index, byte_buffer);
2631       if (status == REG_VALID)
2632         status = move (regcache, tdep->ppc_ev0_upper_regnum + reg_index,
2633                        byte_buffer + 4);
2634     }
2635
2636   return status;
2637 }
2638
2639 static enum register_status
2640 do_regcache_raw_write (struct regcache *regcache, int regnum, void *buffer)
2641 {
2642   regcache->raw_write (regnum, (const gdb_byte *) buffer);
2643
2644   return REG_VALID;
2645 }
2646
2647 static enum register_status
2648 e500_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
2649                            int ev_reg, gdb_byte *buffer)
2650 {
2651   struct gdbarch *arch = regcache->arch ();
2652   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
2653   int reg_index;
2654   enum register_status status;
2655
2656   gdb_assert (IS_SPE_PSEUDOREG (tdep, ev_reg));
2657
2658   reg_index = ev_reg - tdep->ppc_ev0_regnum;
2659
2660   if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
2661     {
2662       status = regcache->raw_read (tdep->ppc_ev0_upper_regnum + reg_index,
2663                                    buffer);
2664       if (status == REG_VALID)
2665         status = regcache->raw_read (tdep->ppc_gp0_regnum + reg_index,
2666                                      buffer + 4);
2667     }
2668   else
2669     {
2670       status = regcache->raw_read (tdep->ppc_gp0_regnum + reg_index, buffer);
2671       if (status == REG_VALID)
2672         status = regcache->raw_read (tdep->ppc_ev0_upper_regnum + reg_index,
2673                                      buffer + 4);
2674     }
2675
2676   return status;
2677
2678 }
2679
2680 static void
2681 e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2682                             int reg_nr, const gdb_byte *buffer)
2683 {
2684   e500_move_ev_register (do_regcache_raw_write, regcache,
2685                          reg_nr, (void *) buffer);
2686 }
2687
2688 /* Read method for DFP pseudo-registers.  */
2689 static enum register_status
2690 dfp_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
2691                            int reg_nr, gdb_byte *buffer)
2692 {
2693   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2694   int reg_index, fp0;
2695   enum register_status status;
2696
2697   if (IS_DFP_PSEUDOREG (tdep, reg_nr))
2698     {
2699       reg_index = reg_nr - tdep->ppc_dl0_regnum;
2700       fp0 = PPC_F0_REGNUM;
2701     }
2702   else
2703     {
2704       gdb_assert (IS_CDFP_PSEUDOREG (tdep, reg_nr));
2705
2706       reg_index = reg_nr - tdep->ppc_cdl0_regnum;
2707       fp0 = PPC_CF0_REGNUM;
2708     }
2709
2710   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2711     {
2712       /* Read two FP registers to form a whole dl register.  */
2713       status = regcache->raw_read (fp0 + 2 * reg_index, buffer);
2714       if (status == REG_VALID)
2715         status = regcache->raw_read (fp0 + 2 * reg_index + 1,
2716                                      buffer + 8);
2717     }
2718   else
2719     {
2720       status = regcache->raw_read (fp0 + 2 * reg_index + 1, buffer);
2721       if (status == REG_VALID)
2722         status = regcache->raw_read (fp0 + 2 * reg_index, buffer + 8);
2723     }
2724
2725   return status;
2726 }
2727
2728 /* Write method for DFP pseudo-registers.  */
2729 static void
2730 dfp_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2731                             int reg_nr, const gdb_byte *buffer)
2732 {
2733   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2734   int reg_index, fp0;
2735
2736   if (IS_DFP_PSEUDOREG (tdep, reg_nr))
2737     {
2738       reg_index = reg_nr - tdep->ppc_dl0_regnum;
2739       fp0 = PPC_F0_REGNUM;
2740     }
2741   else
2742     {
2743       gdb_assert (IS_CDFP_PSEUDOREG (tdep, reg_nr));
2744
2745       reg_index = reg_nr - tdep->ppc_cdl0_regnum;
2746       fp0 = PPC_CF0_REGNUM;
2747     }
2748
2749   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2750     {
2751       /* Write each half of the dl register into a separate
2752          FP register.  */
2753       regcache->raw_write (fp0 + 2 * reg_index, buffer);
2754       regcache->raw_write (fp0 + 2 * reg_index + 1, buffer + 8);
2755     }
2756   else
2757     {
2758       regcache->raw_write (fp0 + 2 * reg_index + 1, buffer);
2759       regcache->raw_write (fp0 + 2 * reg_index, buffer + 8);
2760     }
2761 }
2762
2763 /* Read method for the vX aliases for the raw vrX registers.  */
2764
2765 static enum register_status
2766 v_alias_pseudo_register_read (struct gdbarch *gdbarch,
2767                               readable_regcache *regcache, int reg_nr,
2768                               gdb_byte *buffer)
2769 {
2770   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2771   gdb_assert (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr));
2772
2773   return regcache->raw_read (tdep->ppc_vr0_regnum
2774                              + (reg_nr - tdep->ppc_v0_alias_regnum),
2775                              buffer);
2776 }
2777
2778 /* Write method for the vX aliases for the raw vrX registers.  */
2779
2780 static void
2781 v_alias_pseudo_register_write (struct gdbarch *gdbarch,
2782                                struct regcache *regcache,
2783                                int reg_nr, const gdb_byte *buffer)
2784 {
2785   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2786   gdb_assert (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr));
2787
2788   regcache->raw_write (tdep->ppc_vr0_regnum
2789                        + (reg_nr - tdep->ppc_v0_alias_regnum), buffer);
2790 }
2791
2792 /* Read method for POWER7 VSX pseudo-registers.  */
2793 static enum register_status
2794 vsx_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
2795                            int reg_nr, gdb_byte *buffer)
2796 {
2797   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2798   int reg_index, vr0, fp0, vsr0_upper;
2799   enum register_status status;
2800
2801   if (IS_VSX_PSEUDOREG (tdep, reg_nr))
2802     {
2803       reg_index = reg_nr - tdep->ppc_vsr0_regnum;
2804       vr0 = PPC_VR0_REGNUM;
2805       fp0 = PPC_F0_REGNUM;
2806       vsr0_upper = PPC_VSR0_UPPER_REGNUM;
2807     }
2808   else
2809     {
2810       gdb_assert (IS_CVSX_PSEUDOREG (tdep, reg_nr));
2811
2812       reg_index = reg_nr - tdep->ppc_cvsr0_regnum;
2813       vr0 = PPC_CVR0_REGNUM;
2814       fp0 = PPC_CF0_REGNUM;
2815       vsr0_upper = PPC_CVSR0_UPPER_REGNUM;
2816     }
2817
2818   /* Read the portion that overlaps the VMX registers.  */
2819   if (reg_index > 31)
2820     status = regcache->raw_read (vr0 + reg_index - 32, buffer);
2821   else
2822     /* Read the portion that overlaps the FPR registers.  */
2823     if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2824       {
2825         status = regcache->raw_read (fp0 + reg_index, buffer);
2826         if (status == REG_VALID)
2827           status = regcache->raw_read (vsr0_upper + reg_index,
2828                                        buffer + 8);
2829       }
2830     else
2831       {
2832         status = regcache->raw_read (fp0 + reg_index, buffer + 8);
2833         if (status == REG_VALID)
2834           status = regcache->raw_read (vsr0_upper + reg_index, buffer);
2835       }
2836
2837   return status;
2838 }
2839
2840 /* Write method for POWER7 VSX pseudo-registers.  */
2841 static void
2842 vsx_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2843                             int reg_nr, const gdb_byte *buffer)
2844 {
2845   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2846   int reg_index, vr0, fp0, vsr0_upper;
2847
2848   if (IS_VSX_PSEUDOREG (tdep, reg_nr))
2849     {
2850       reg_index = reg_nr - tdep->ppc_vsr0_regnum;
2851       vr0 = PPC_VR0_REGNUM;
2852       fp0 = PPC_F0_REGNUM;
2853       vsr0_upper = PPC_VSR0_UPPER_REGNUM;
2854     }
2855   else
2856     {
2857       gdb_assert (IS_CVSX_PSEUDOREG (tdep, reg_nr));
2858
2859       reg_index = reg_nr - tdep->ppc_cvsr0_regnum;
2860       vr0 = PPC_CVR0_REGNUM;
2861       fp0 = PPC_CF0_REGNUM;
2862       vsr0_upper = PPC_CVSR0_UPPER_REGNUM;
2863     }
2864
2865   /* Write the portion that overlaps the VMX registers.  */
2866   if (reg_index > 31)
2867     regcache->raw_write (vr0 + reg_index - 32, buffer);
2868   else
2869     /* Write the portion that overlaps the FPR registers.  */
2870     if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2871       {
2872         regcache->raw_write (fp0 + reg_index, buffer);
2873         regcache->raw_write (vsr0_upper + reg_index, buffer + 8);
2874       }
2875     else
2876       {
2877         regcache->raw_write (fp0 + reg_index, buffer + 8);
2878         regcache->raw_write (vsr0_upper + reg_index, buffer);
2879       }
2880 }
2881
2882 /* Read method for POWER7 Extended FP pseudo-registers.  */
2883 static enum register_status
2884 efp_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
2885                            int reg_nr, gdb_byte *buffer)
2886 {
2887   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2888   int reg_index, vr0;
2889
2890   if (IS_EFP_PSEUDOREG (tdep, reg_nr))
2891     {
2892       reg_index = reg_nr - tdep->ppc_efpr0_regnum;
2893       vr0 = PPC_VR0_REGNUM;
2894     }
2895   else
2896     {
2897       gdb_assert (IS_CEFP_PSEUDOREG (tdep, reg_nr));
2898
2899       reg_index = reg_nr - tdep->ppc_cefpr0_regnum;
2900       vr0 = PPC_CVR0_REGNUM;
2901     }
2902
2903   int offset = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 0 : 8;
2904
2905   /* Read the portion that overlaps the VMX register.  */
2906   return regcache->raw_read_part (vr0 + reg_index, offset,
2907                                   register_size (gdbarch, reg_nr),
2908                                   buffer);
2909 }
2910
2911 /* Write method for POWER7 Extended FP pseudo-registers.  */
2912 static void
2913 efp_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2914                             int reg_nr, const gdb_byte *buffer)
2915 {
2916   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2917   int reg_index, vr0;
2918   int offset = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 0 : 8;
2919
2920   if (IS_EFP_PSEUDOREG (tdep, reg_nr))
2921     {
2922       reg_index = reg_nr - tdep->ppc_efpr0_regnum;
2923       vr0 = PPC_VR0_REGNUM;
2924     }
2925   else
2926     {
2927       gdb_assert (IS_CEFP_PSEUDOREG (tdep, reg_nr));
2928
2929       reg_index = reg_nr - tdep->ppc_cefpr0_regnum;
2930       vr0 = PPC_CVR0_REGNUM;
2931
2932       /* The call to raw_write_part fails silently if the initial read
2933          of the read-update-write sequence returns an invalid status,
2934          so we check this manually and throw an error if needed.  */
2935       regcache->raw_update (vr0 + reg_index);
2936       if (regcache->get_register_status (vr0 + reg_index) != REG_VALID)
2937         error (_("Cannot write to the checkpointed EFP register, "
2938                  "the corresponding vector register is unavailable."));
2939     }
2940
2941   /* Write the portion that overlaps the VMX register.  */
2942   regcache->raw_write_part (vr0 + reg_index, offset,
2943                             register_size (gdbarch, reg_nr), buffer);
2944 }
2945
2946 static enum register_status
2947 rs6000_pseudo_register_read (struct gdbarch *gdbarch,
2948                              readable_regcache *regcache,
2949                              int reg_nr, gdb_byte *buffer)
2950 {
2951   struct gdbarch *regcache_arch = regcache->arch ();
2952   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2953
2954   gdb_assert (regcache_arch == gdbarch);
2955
2956   if (IS_SPE_PSEUDOREG (tdep, reg_nr))
2957     return e500_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2958   else if (IS_DFP_PSEUDOREG (tdep, reg_nr)
2959            || IS_CDFP_PSEUDOREG (tdep, reg_nr))
2960     return dfp_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2961   else if (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr))
2962     return v_alias_pseudo_register_read (gdbarch, regcache, reg_nr,
2963                                          buffer);
2964   else if (IS_VSX_PSEUDOREG (tdep, reg_nr)
2965            || IS_CVSX_PSEUDOREG (tdep, reg_nr))
2966     return vsx_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2967   else if (IS_EFP_PSEUDOREG (tdep, reg_nr)
2968            || IS_CEFP_PSEUDOREG (tdep, reg_nr))
2969     return efp_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2970   else
2971     internal_error (__FILE__, __LINE__,
2972                     _("rs6000_pseudo_register_read: "
2973                     "called on unexpected register '%s' (%d)"),
2974                     gdbarch_register_name (gdbarch, reg_nr), reg_nr);
2975 }
2976
2977 static void
2978 rs6000_pseudo_register_write (struct gdbarch *gdbarch,
2979                               struct regcache *regcache,
2980                               int reg_nr, const gdb_byte *buffer)
2981 {
2982   struct gdbarch *regcache_arch = regcache->arch ();
2983   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2984
2985   gdb_assert (regcache_arch == gdbarch);
2986
2987   if (IS_SPE_PSEUDOREG (tdep, reg_nr))
2988     e500_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2989   else if (IS_DFP_PSEUDOREG (tdep, reg_nr)
2990            || IS_CDFP_PSEUDOREG (tdep, reg_nr))
2991     dfp_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2992   else if (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr))
2993     v_alias_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2994   else if (IS_VSX_PSEUDOREG (tdep, reg_nr)
2995            || IS_CVSX_PSEUDOREG (tdep, reg_nr))
2996     vsx_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2997   else if (IS_EFP_PSEUDOREG (tdep, reg_nr)
2998            || IS_CEFP_PSEUDOREG (tdep, reg_nr))
2999     efp_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
3000   else
3001     internal_error (__FILE__, __LINE__,
3002                     _("rs6000_pseudo_register_write: "
3003                     "called on unexpected register '%s' (%d)"),
3004                     gdbarch_register_name (gdbarch, reg_nr), reg_nr);
3005 }
3006
3007 /* Set the register mask in AX with the registers that form the DFP or
3008    checkpointed DFP pseudo-register REG_NR.  */
3009
3010 static void
3011 dfp_ax_pseudo_register_collect (struct gdbarch *gdbarch,
3012                                 struct agent_expr *ax, int reg_nr)
3013 {
3014   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3015   int reg_index, fp0;
3016
3017   if (IS_DFP_PSEUDOREG (tdep, reg_nr))
3018     {
3019       reg_index = reg_nr - tdep->ppc_dl0_regnum;
3020       fp0 = PPC_F0_REGNUM;
3021     }
3022   else
3023     {
3024       gdb_assert (IS_CDFP_PSEUDOREG (tdep, reg_nr));
3025
3026       reg_index = reg_nr - tdep->ppc_cdl0_regnum;
3027       fp0 = PPC_CF0_REGNUM;
3028     }
3029
3030   ax_reg_mask (ax, fp0 + 2 * reg_index);
3031   ax_reg_mask (ax, fp0 + 2 * reg_index + 1);
3032 }
3033
3034 /* Set the register mask in AX with the raw vector register that
3035    corresponds to its REG_NR alias.  */
3036
3037 static void
3038 v_alias_pseudo_register_collect (struct gdbarch *gdbarch,
3039                                  struct agent_expr *ax, int reg_nr)
3040 {
3041   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3042   gdb_assert (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr));
3043
3044   ax_reg_mask (ax, tdep->ppc_vr0_regnum
3045                + (reg_nr - tdep->ppc_v0_alias_regnum));
3046 }
3047
3048 /* Set the register mask in AX with the registers that form the VSX or
3049    checkpointed VSX pseudo-register REG_NR.  */
3050
3051 static void
3052 vsx_ax_pseudo_register_collect (struct gdbarch *gdbarch,
3053                                 struct agent_expr *ax, int reg_nr)
3054 {
3055   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3056   int reg_index, vr0, fp0, vsr0_upper;
3057
3058   if (IS_VSX_PSEUDOREG (tdep, reg_nr))
3059     {
3060       reg_index = reg_nr - tdep->ppc_vsr0_regnum;
3061       vr0 = PPC_VR0_REGNUM;
3062       fp0 = PPC_F0_REGNUM;
3063       vsr0_upper = PPC_VSR0_UPPER_REGNUM;
3064     }
3065   else
3066     {
3067       gdb_assert (IS_CVSX_PSEUDOREG (tdep, reg_nr));
3068
3069       reg_index = reg_nr - tdep->ppc_cvsr0_regnum;
3070       vr0 = PPC_CVR0_REGNUM;
3071       fp0 = PPC_CF0_REGNUM;
3072       vsr0_upper = PPC_CVSR0_UPPER_REGNUM;
3073     }
3074
3075   if (reg_index > 31)
3076     {
3077       ax_reg_mask (ax, vr0 + reg_index - 32);
3078     }
3079   else
3080     {
3081       ax_reg_mask (ax, fp0 + reg_index);
3082       ax_reg_mask (ax, vsr0_upper + reg_index);
3083     }
3084 }
3085
3086 /* Set the register mask in AX with the register that corresponds to
3087    the EFP or checkpointed EFP pseudo-register REG_NR.  */
3088
3089 static void
3090 efp_ax_pseudo_register_collect (struct gdbarch *gdbarch,
3091                                 struct agent_expr *ax, int reg_nr)
3092 {
3093   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3094   int reg_index, vr0;
3095
3096   if (IS_EFP_PSEUDOREG (tdep, reg_nr))
3097     {
3098       reg_index = reg_nr - tdep->ppc_efpr0_regnum;
3099       vr0 = PPC_VR0_REGNUM;
3100     }
3101   else
3102     {
3103       gdb_assert (IS_CEFP_PSEUDOREG (tdep, reg_nr));
3104
3105       reg_index = reg_nr - tdep->ppc_cefpr0_regnum;
3106       vr0 = PPC_CVR0_REGNUM;
3107     }
3108
3109   ax_reg_mask (ax, vr0 + reg_index);
3110 }
3111
3112 static int
3113 rs6000_ax_pseudo_register_collect (struct gdbarch *gdbarch,
3114                                    struct agent_expr *ax, int reg_nr)
3115 {
3116   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3117   if (IS_SPE_PSEUDOREG (tdep, reg_nr))
3118     {
3119       int reg_index = reg_nr - tdep->ppc_ev0_regnum;
3120       ax_reg_mask (ax, tdep->ppc_gp0_regnum + reg_index);
3121       ax_reg_mask (ax, tdep->ppc_ev0_upper_regnum + reg_index);
3122     }
3123   else if (IS_DFP_PSEUDOREG (tdep, reg_nr)
3124            || IS_CDFP_PSEUDOREG (tdep, reg_nr))
3125     {
3126       dfp_ax_pseudo_register_collect (gdbarch, ax, reg_nr);
3127     }
3128   else if (IS_V_ALIAS_PSEUDOREG (tdep, reg_nr))
3129     {
3130       v_alias_pseudo_register_collect (gdbarch, ax, reg_nr);
3131     }
3132   else if (IS_VSX_PSEUDOREG (tdep, reg_nr)
3133            || IS_CVSX_PSEUDOREG (tdep, reg_nr))
3134     {
3135       vsx_ax_pseudo_register_collect (gdbarch, ax, reg_nr);
3136     }
3137   else if (IS_EFP_PSEUDOREG (tdep, reg_nr)
3138            || IS_CEFP_PSEUDOREG (tdep, reg_nr))
3139     {
3140       efp_ax_pseudo_register_collect (gdbarch, ax, reg_nr);
3141     }
3142   else
3143     internal_error (__FILE__, __LINE__,
3144                     _("rs6000_pseudo_register_collect: "
3145                     "called on unexpected register '%s' (%d)"),
3146                     gdbarch_register_name (gdbarch, reg_nr), reg_nr);
3147   return 0;
3148 }
3149
3150
3151 static void
3152 rs6000_gen_return_address (struct gdbarch *gdbarch,
3153                            struct agent_expr *ax, struct axs_value *value,
3154                            CORE_ADDR scope)
3155 {
3156   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3157   value->type = register_type (gdbarch, tdep->ppc_lr_regnum);
3158   value->kind = axs_lvalue_register;
3159   value->u.reg = tdep->ppc_lr_regnum;
3160 }
3161
3162
3163 /* Convert a DBX STABS register number to a GDB register number.  */
3164 static int
3165 rs6000_stab_reg_to_regnum (struct gdbarch *gdbarch, int num)
3166 {
3167   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3168
3169   if (0 <= num && num <= 31)
3170     return tdep->ppc_gp0_regnum + num;
3171   else if (32 <= num && num <= 63)
3172     /* FIXME: jimb/2004-05-05: What should we do when the debug info
3173        specifies registers the architecture doesn't have?  Our
3174        callers don't check the value we return.  */
3175     return tdep->ppc_fp0_regnum + (num - 32);
3176   else if (77 <= num && num <= 108)
3177     return tdep->ppc_vr0_regnum + (num - 77);
3178   else if (1200 <= num && num < 1200 + 32)
3179     return tdep->ppc_ev0_upper_regnum + (num - 1200);
3180   else
3181     switch (num)
3182       {
3183       case 64:
3184         return tdep->ppc_mq_regnum;
3185       case 65:
3186         return tdep->ppc_lr_regnum;
3187       case 66:
3188         return tdep->ppc_ctr_regnum;
3189       case 76:
3190         return tdep->ppc_xer_regnum;
3191       case 109:
3192         return tdep->ppc_vrsave_regnum;
3193       case 110:
3194         return tdep->ppc_vrsave_regnum - 1; /* vscr */
3195       case 111:
3196         return tdep->ppc_acc_regnum;
3197       case 112:
3198         return tdep->ppc_spefscr_regnum;
3199       default:
3200         return num;
3201       }
3202 }
3203
3204
3205 /* Convert a Dwarf 2 register number to a GDB register number.  */
3206 static int
3207 rs6000_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int num)
3208 {
3209   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3210
3211   if (0 <= num && num <= 31)
3212     return tdep->ppc_gp0_regnum + num;
3213   else if (32 <= num && num <= 63)
3214     /* FIXME: jimb/2004-05-05: What should we do when the debug info
3215        specifies registers the architecture doesn't have?  Our
3216        callers don't check the value we return.  */
3217     return tdep->ppc_fp0_regnum + (num - 32);
3218   else if (1124 <= num && num < 1124 + 32)
3219     return tdep->ppc_vr0_regnum + (num - 1124);
3220   else if (1200 <= num && num < 1200 + 32)
3221     return tdep->ppc_ev0_upper_regnum + (num - 1200);
3222   else
3223     switch (num)
3224       {
3225       case 64:
3226         return tdep->ppc_cr_regnum;
3227       case 67:
3228         return tdep->ppc_vrsave_regnum - 1; /* vscr */
3229       case 99:
3230         return tdep->ppc_acc_regnum;
3231       case 100:
3232         return tdep->ppc_mq_regnum;
3233       case 101:
3234         return tdep->ppc_xer_regnum;
3235       case 108:
3236         return tdep->ppc_lr_regnum;
3237       case 109:
3238         return tdep->ppc_ctr_regnum;
3239       case 356:
3240         return tdep->ppc_vrsave_regnum;
3241       case 612:
3242         return tdep->ppc_spefscr_regnum;
3243       default:
3244         return num;
3245       }
3246 }
3247
3248 /* Translate a .eh_frame register to DWARF register, or adjust a
3249    .debug_frame register.  */
3250
3251 static int
3252 rs6000_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
3253 {
3254   /* GCC releases before 3.4 use GCC internal register numbering in
3255      .debug_frame (and .debug_info, et cetera).  The numbering is
3256      different from the standard SysV numbering for everything except
3257      for GPRs and FPRs.  We can not detect this problem in most cases
3258      - to get accurate debug info for variables living in lr, ctr, v0,
3259      et cetera, use a newer version of GCC.  But we must detect
3260      one important case - lr is in column 65 in .debug_frame output,
3261      instead of 108.
3262
3263      GCC 3.4, and the "hammer" branch, have a related problem.  They
3264      record lr register saves in .debug_frame as 108, but still record
3265      the return column as 65.  We fix that up too.
3266
3267      We can do this because 65 is assigned to fpsr, and GCC never
3268      generates debug info referring to it.  To add support for
3269      handwritten debug info that restores fpsr, we would need to add a
3270      producer version check to this.  */
3271   if (!eh_frame_p)
3272     {
3273       if (num == 65)
3274         return 108;
3275       else
3276         return num;
3277     }
3278
3279   /* .eh_frame is GCC specific.  For binary compatibility, it uses GCC
3280      internal register numbering; translate that to the standard DWARF2
3281      register numbering.  */
3282   if (0 <= num && num <= 63)    /* r0-r31,fp0-fp31 */
3283     return num;
3284   else if (68 <= num && num <= 75) /* cr0-cr8 */
3285     return num - 68 + 86;
3286   else if (77 <= num && num <= 108) /* vr0-vr31 */
3287     return num - 77 + 1124;
3288   else
3289     switch (num)
3290       {
3291       case 64: /* mq */
3292         return 100;
3293       case 65: /* lr */
3294         return 108;
3295       case 66: /* ctr */
3296         return 109;
3297       case 76: /* xer */
3298         return 101;
3299       case 109: /* vrsave */
3300         return 356;
3301       case 110: /* vscr */
3302         return 67;
3303       case 111: /* spe_acc */
3304         return 99;
3305       case 112: /* spefscr */
3306         return 612;
3307       default:
3308         return num;
3309       }
3310 }
3311 \f
3312
3313 /* Handling the various POWER/PowerPC variants.  */
3314
3315 /* Information about a particular processor variant.  */
3316
3317 struct variant
3318   {
3319     /* Name of this variant.  */
3320     const char *name;
3321
3322     /* English description of the variant.  */
3323     const char *description;
3324
3325     /* bfd_arch_info.arch corresponding to variant.  */
3326     enum bfd_architecture arch;
3327
3328     /* bfd_arch_info.mach corresponding to variant.  */
3329     unsigned long mach;
3330
3331     /* Target description for this variant.  */
3332     struct target_desc **tdesc;
3333   };
3334
3335 static struct variant variants[] =
3336 {
3337   {"powerpc", "PowerPC user-level", bfd_arch_powerpc,
3338    bfd_mach_ppc, &tdesc_powerpc_altivec32},
3339   {"power", "POWER user-level", bfd_arch_rs6000,
3340    bfd_mach_rs6k, &tdesc_rs6000},
3341   {"403", "IBM PowerPC 403", bfd_arch_powerpc,
3342    bfd_mach_ppc_403, &tdesc_powerpc_403},
3343   {"405", "IBM PowerPC 405", bfd_arch_powerpc,
3344    bfd_mach_ppc_405, &tdesc_powerpc_405},
3345   {"601", "Motorola PowerPC 601", bfd_arch_powerpc,
3346    bfd_mach_ppc_601, &tdesc_powerpc_601},
3347   {"602", "Motorola PowerPC 602", bfd_arch_powerpc,
3348    bfd_mach_ppc_602, &tdesc_powerpc_602},
3349   {"603", "Motorola/IBM PowerPC 603 or 603e", bfd_arch_powerpc,
3350    bfd_mach_ppc_603, &tdesc_powerpc_603},
3351   {"604", "Motorola PowerPC 604 or 604e", bfd_arch_powerpc,
3352    604, &tdesc_powerpc_604},
3353   {"403GC", "IBM PowerPC 403GC", bfd_arch_powerpc,
3354    bfd_mach_ppc_403gc, &tdesc_powerpc_403gc},
3355   {"505", "Motorola PowerPC 505", bfd_arch_powerpc,
3356    bfd_mach_ppc_505, &tdesc_powerpc_505},
3357   {"860", "Motorola PowerPC 860 or 850", bfd_arch_powerpc,
3358    bfd_mach_ppc_860, &tdesc_powerpc_860},
3359   {"750", "Motorola/IBM PowerPC 750 or 740", bfd_arch_powerpc,
3360    bfd_mach_ppc_750, &tdesc_powerpc_750},
3361   {"7400", "Motorola/IBM PowerPC 7400 (G4)", bfd_arch_powerpc,
3362    bfd_mach_ppc_7400, &tdesc_powerpc_7400},
3363   {"e500", "Motorola PowerPC e500", bfd_arch_powerpc,
3364    bfd_mach_ppc_e500, &tdesc_powerpc_e500},
3365
3366   /* 64-bit */
3367   {"powerpc64", "PowerPC 64-bit user-level", bfd_arch_powerpc,
3368    bfd_mach_ppc64, &tdesc_powerpc_altivec64},
3369   {"620", "Motorola PowerPC 620", bfd_arch_powerpc,
3370    bfd_mach_ppc_620, &tdesc_powerpc_64},
3371   {"630", "Motorola PowerPC 630", bfd_arch_powerpc,
3372    bfd_mach_ppc_630, &tdesc_powerpc_64},
3373   {"a35", "PowerPC A35", bfd_arch_powerpc,
3374    bfd_mach_ppc_a35, &tdesc_powerpc_64},
3375   {"rs64ii", "PowerPC rs64ii", bfd_arch_powerpc,
3376    bfd_mach_ppc_rs64ii, &tdesc_powerpc_64},
3377   {"rs64iii", "PowerPC rs64iii", bfd_arch_powerpc,
3378    bfd_mach_ppc_rs64iii, &tdesc_powerpc_64},
3379
3380   /* FIXME: I haven't checked the register sets of the following.  */
3381   {"rs1", "IBM POWER RS1", bfd_arch_rs6000,
3382    bfd_mach_rs6k_rs1, &tdesc_rs6000},
3383   {"rsc", "IBM POWER RSC", bfd_arch_rs6000,
3384    bfd_mach_rs6k_rsc, &tdesc_rs6000},
3385   {"rs2", "IBM POWER RS2", bfd_arch_rs6000,
3386    bfd_mach_rs6k_rs2, &tdesc_rs6000},
3387
3388   {0, 0, (enum bfd_architecture) 0, 0, 0}
3389 };
3390
3391 /* Return the variant corresponding to architecture ARCH and machine number
3392    MACH.  If no such variant exists, return null.  */
3393
3394 static const struct variant *
3395 find_variant_by_arch (enum bfd_architecture arch, unsigned long mach)
3396 {
3397   const struct variant *v;
3398
3399   for (v = variants; v->name; v++)
3400     if (arch == v->arch && mach == v->mach)
3401       return v;
3402
3403   return NULL;
3404 }
3405
3406 \f
3407
3408 struct rs6000_frame_cache
3409 {
3410   CORE_ADDR base;
3411   CORE_ADDR initial_sp;
3412   struct trad_frame_saved_reg *saved_regs;
3413
3414   /* Set BASE_P to true if this frame cache is properly initialized.
3415      Otherwise set to false because some registers or memory cannot
3416      collected.  */
3417   int base_p;
3418   /* Cache PC for building unavailable frame.  */
3419   CORE_ADDR pc;
3420 };
3421
3422 static struct rs6000_frame_cache *
3423 rs6000_frame_cache (struct frame_info *this_frame, void **this_cache)
3424 {
3425   struct rs6000_frame_cache *cache;
3426   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3427   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3428   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3429   struct rs6000_framedata fdata;
3430   int wordsize = tdep->wordsize;
3431   CORE_ADDR func = 0, pc = 0;
3432
3433   if ((*this_cache) != NULL)
3434     return (struct rs6000_frame_cache *) (*this_cache);
3435   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
3436   (*this_cache) = cache;
3437   cache->pc = 0;
3438   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3439
3440   try
3441     {
3442       func = get_frame_func (this_frame);
3443       cache->pc = func;
3444       pc = get_frame_pc (this_frame);
3445       skip_prologue (gdbarch, func, pc, &fdata);
3446
3447       /* Figure out the parent's stack pointer.  */
3448
3449       /* NOTE: cagney/2002-04-14: The ->frame points to the inner-most
3450          address of the current frame.  Things might be easier if the
3451          ->frame pointed to the outer-most address of the frame.  In
3452          the mean time, the address of the prev frame is used as the
3453          base address of this frame.  */
3454       cache->base = get_frame_register_unsigned
3455         (this_frame, gdbarch_sp_regnum (gdbarch));
3456     }
3457   catch (const gdb_exception_error &ex)
3458     {
3459       if (ex.error != NOT_AVAILABLE_ERROR)
3460         throw;
3461       return (struct rs6000_frame_cache *) (*this_cache);
3462     }
3463
3464   /* If the function appears to be frameless, check a couple of likely
3465      indicators that we have simply failed to find the frame setup.
3466      Two common cases of this are missing symbols (i.e.
3467      get_frame_func returns the wrong address or 0), and assembly
3468      stubs which have a fast exit path but set up a frame on the slow
3469      path.
3470
3471      If the LR appears to return to this function, then presume that
3472      we have an ABI compliant frame that we failed to find.  */
3473   if (fdata.frameless && fdata.lr_offset == 0)
3474     {
3475       CORE_ADDR saved_lr;
3476       int make_frame = 0;
3477
3478       saved_lr = get_frame_register_unsigned (this_frame, tdep->ppc_lr_regnum);
3479       if (func == 0 && saved_lr == pc)
3480         make_frame = 1;
3481       else if (func != 0)
3482         {
3483           CORE_ADDR saved_func = get_pc_function_start (saved_lr);
3484           if (func == saved_func)
3485             make_frame = 1;
3486         }
3487
3488       if (make_frame)
3489         {
3490           fdata.frameless = 0;
3491           fdata.lr_offset = tdep->lr_frame_offset;
3492         }
3493     }
3494
3495   if (!fdata.frameless)
3496     {
3497       /* Frameless really means stackless.  */
3498       ULONGEST backchain;
3499
3500       if (safe_read_memory_unsigned_integer (cache->base, wordsize,
3501                                              byte_order, &backchain))
3502         cache->base = (CORE_ADDR) backchain;
3503     }
3504
3505   trad_frame_set_value (cache->saved_regs,
3506                         gdbarch_sp_regnum (gdbarch), cache->base);
3507
3508   /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr.
3509      All fpr's from saved_fpr to fp31 are saved.  */
3510
3511   if (fdata.saved_fpr >= 0)
3512     {
3513       int i;
3514       CORE_ADDR fpr_addr = cache->base + fdata.fpr_offset;
3515
3516       /* If skip_prologue says floating-point registers were saved,
3517          but the current architecture has no floating-point registers,
3518          then that's strange.  But we have no indices to even record
3519          the addresses under, so we just ignore it.  */
3520       if (ppc_floating_point_unit_p (gdbarch))
3521         for (i = fdata.saved_fpr; i < ppc_num_fprs; i++)
3522           {
3523             cache->saved_regs[tdep->ppc_fp0_regnum + i].addr = fpr_addr;
3524             fpr_addr += 8;
3525           }
3526     }
3527
3528   /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr.
3529      All gpr's from saved_gpr to gpr31 are saved (except during the
3530      prologue).  */
3531
3532   if (fdata.saved_gpr >= 0)
3533     {
3534       int i;
3535       CORE_ADDR gpr_addr = cache->base + fdata.gpr_offset;
3536       for (i = fdata.saved_gpr; i < ppc_num_gprs; i++)
3537         {
3538           if (fdata.gpr_mask & (1U << i))
3539             cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = gpr_addr;
3540           gpr_addr += wordsize;
3541         }
3542     }
3543
3544   /* if != -1, fdata.saved_vr is the smallest number of saved_vr.
3545      All vr's from saved_vr to vr31 are saved.  */
3546   if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
3547     {
3548       if (fdata.saved_vr >= 0)
3549         {
3550           int i;
3551           CORE_ADDR vr_addr = cache->base + fdata.vr_offset;
3552           for (i = fdata.saved_vr; i < 32; i++)
3553             {
3554               cache->saved_regs[tdep->ppc_vr0_regnum + i].addr = vr_addr;
3555               vr_addr += register_size (gdbarch, tdep->ppc_vr0_regnum);
3556             }
3557         }
3558     }
3559
3560   /* if != -1, fdata.saved_ev is the smallest number of saved_ev.
3561      All vr's from saved_ev to ev31 are saved. ?????  */
3562   if (tdep->ppc_ev0_regnum != -1)
3563     {
3564       if (fdata.saved_ev >= 0)
3565         {
3566           int i;
3567           CORE_ADDR ev_addr = cache->base + fdata.ev_offset;
3568           CORE_ADDR off = (byte_order == BFD_ENDIAN_BIG ? 4 : 0);
3569
3570           for (i = fdata.saved_ev; i < ppc_num_gprs; i++)
3571             {
3572               cache->saved_regs[tdep->ppc_ev0_regnum + i].addr = ev_addr;
3573               cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = ev_addr + off;
3574               ev_addr += register_size (gdbarch, tdep->ppc_ev0_regnum);
3575             }
3576         }
3577     }
3578
3579   /* If != 0, fdata.cr_offset is the offset from the frame that
3580      holds the CR.  */
3581   if (fdata.cr_offset != 0)
3582     cache->saved_regs[tdep->ppc_cr_regnum].addr
3583       = cache->base + fdata.cr_offset;
3584
3585   /* If != 0, fdata.lr_offset is the offset from the frame that
3586      holds the LR.  */
3587   if (fdata.lr_offset != 0)
3588     cache->saved_regs[tdep->ppc_lr_regnum].addr
3589       = cache->base + fdata.lr_offset;
3590   else if (fdata.lr_register != -1)
3591     cache->saved_regs[tdep->ppc_lr_regnum].realreg = fdata.lr_register;
3592   /* The PC is found in the link register.  */
3593   cache->saved_regs[gdbarch_pc_regnum (gdbarch)] =
3594     cache->saved_regs[tdep->ppc_lr_regnum];
3595
3596   /* If != 0, fdata.vrsave_offset is the offset from the frame that
3597      holds the VRSAVE.  */
3598   if (fdata.vrsave_offset != 0)
3599     cache->saved_regs[tdep->ppc_vrsave_regnum].addr
3600       = cache->base + fdata.vrsave_offset;
3601
3602   if (fdata.alloca_reg < 0)
3603     /* If no alloca register used, then fi->frame is the value of the
3604        %sp for this frame, and it is good enough.  */
3605     cache->initial_sp
3606       = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
3607   else
3608     cache->initial_sp
3609       = get_frame_register_unsigned (this_frame, fdata.alloca_reg);
3610
3611   cache->base_p = 1;
3612   return cache;
3613 }
3614
3615 static void
3616 rs6000_frame_this_id (struct frame_info *this_frame, void **this_cache,
3617                       struct frame_id *this_id)
3618 {
3619   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3620                                                         this_cache);
3621
3622   if (!info->base_p)
3623     {
3624       (*this_id) = frame_id_build_unavailable_stack (info->pc);
3625       return;
3626     }
3627
3628   /* This marks the outermost frame.  */
3629   if (info->base == 0)
3630     return;
3631
3632   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
3633 }
3634
3635 static struct value *
3636 rs6000_frame_prev_register (struct frame_info *this_frame,
3637                             void **this_cache, int regnum)
3638 {
3639   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3640                                                         this_cache);
3641   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3642 }
3643
3644 static const struct frame_unwind rs6000_frame_unwind =
3645 {
3646   NORMAL_FRAME,
3647   default_frame_unwind_stop_reason,
3648   rs6000_frame_this_id,
3649   rs6000_frame_prev_register,
3650   NULL,
3651   default_frame_sniffer
3652 };
3653
3654 /* Allocate and initialize a frame cache for an epilogue frame.
3655    SP is restored and prev-PC is stored in LR.  */
3656
3657 static struct rs6000_frame_cache *
3658 rs6000_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
3659 {
3660   struct rs6000_frame_cache *cache;
3661   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3662   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3663
3664   if (*this_cache)
3665     return (struct rs6000_frame_cache *) *this_cache;
3666
3667   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
3668   (*this_cache) = cache;
3669   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3670
3671   try
3672     {
3673       /* At this point the stack looks as if we just entered the
3674          function, and the return address is stored in LR.  */
3675       CORE_ADDR sp, lr;
3676
3677       sp = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
3678       lr = get_frame_register_unsigned (this_frame, tdep->ppc_lr_regnum);
3679
3680       cache->base = sp;
3681       cache->initial_sp = sp;
3682
3683       trad_frame_set_value (cache->saved_regs,
3684                             gdbarch_pc_regnum (gdbarch), lr);
3685     }
3686   catch (const gdb_exception_error &ex)
3687     {
3688       if (ex.error != NOT_AVAILABLE_ERROR)
3689         throw;
3690     }
3691
3692   return cache;
3693 }
3694
3695 /* Implementation of frame_unwind.this_id, as defined in frame_unwind.h.
3696    Return the frame ID of an epilogue frame.  */
3697
3698 static void
3699 rs6000_epilogue_frame_this_id (struct frame_info *this_frame,
3700                                void **this_cache, struct frame_id *this_id)
3701 {
3702   CORE_ADDR pc;
3703   struct rs6000_frame_cache *info =
3704     rs6000_epilogue_frame_cache (this_frame, this_cache);
3705
3706   pc = get_frame_func (this_frame);
3707   if (info->base == 0)
3708     (*this_id) = frame_id_build_unavailable_stack (pc);
3709   else
3710     (*this_id) = frame_id_build (info->base, pc);
3711 }
3712
3713 /* Implementation of frame_unwind.prev_register, as defined in frame_unwind.h.
3714    Return the register value of REGNUM in previous frame.  */
3715
3716 static struct value *
3717 rs6000_epilogue_frame_prev_register (struct frame_info *this_frame,
3718                                      void **this_cache, int regnum)
3719 {
3720   struct rs6000_frame_cache *info =
3721     rs6000_epilogue_frame_cache (this_frame, this_cache);
3722   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3723 }
3724
3725 /* Implementation of frame_unwind.sniffer, as defined in frame_unwind.h.
3726    Check whether this an epilogue frame.  */
3727
3728 static int
3729 rs6000_epilogue_frame_sniffer (const struct frame_unwind *self,
3730                                struct frame_info *this_frame,
3731                                void **this_prologue_cache)
3732 {
3733   if (frame_relative_level (this_frame) == 0)
3734     return rs6000_in_function_epilogue_frame_p (this_frame,
3735                                                 get_frame_arch (this_frame),
3736                                                 get_frame_pc (this_frame));
3737   else
3738     return 0;
3739 }
3740
3741 /* Frame unwinder for epilogue frame.  This is required for reverse step-over
3742    a function without debug information.  */
3743
3744 static const struct frame_unwind rs6000_epilogue_frame_unwind =
3745 {
3746   NORMAL_FRAME,
3747   default_frame_unwind_stop_reason,
3748   rs6000_epilogue_frame_this_id, rs6000_epilogue_frame_prev_register,
3749   NULL,
3750   rs6000_epilogue_frame_sniffer
3751 };
3752 \f
3753
3754 static CORE_ADDR
3755 rs6000_frame_base_address (struct frame_info *this_frame, void **this_cache)
3756 {
3757   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3758                                                         this_cache);
3759   return info->initial_sp;
3760 }
3761
3762 static const struct frame_base rs6000_frame_base = {
3763   &rs6000_frame_unwind,
3764   rs6000_frame_base_address,
3765   rs6000_frame_base_address,
3766   rs6000_frame_base_address
3767 };
3768
3769 static const struct frame_base *
3770 rs6000_frame_base_sniffer (struct frame_info *this_frame)
3771 {
3772   return &rs6000_frame_base;
3773 }
3774
3775 /* DWARF-2 frame support.  Used to handle the detection of
3776   clobbered registers during function calls.  */
3777
3778 static void
3779 ppc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
3780                             struct dwarf2_frame_state_reg *reg,
3781                             struct frame_info *this_frame)
3782 {
3783   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3784
3785   /* PPC32 and PPC64 ABI's are the same regarding volatile and
3786      non-volatile registers.  We will use the same code for both.  */
3787
3788   /* Call-saved GP registers.  */
3789   if ((regnum >= tdep->ppc_gp0_regnum + 14
3790       && regnum <= tdep->ppc_gp0_regnum + 31)
3791       || (regnum == tdep->ppc_gp0_regnum + 1))
3792     reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3793
3794   /* Call-clobbered GP registers.  */
3795   if ((regnum >= tdep->ppc_gp0_regnum + 3
3796       && regnum <= tdep->ppc_gp0_regnum + 12)
3797       || (regnum == tdep->ppc_gp0_regnum))
3798     reg->how = DWARF2_FRAME_REG_UNDEFINED;
3799
3800   /* Deal with FP registers, if supported.  */
3801   if (tdep->ppc_fp0_regnum >= 0)
3802     {
3803       /* Call-saved FP registers.  */
3804       if ((regnum >= tdep->ppc_fp0_regnum + 14
3805           && regnum <= tdep->ppc_fp0_regnum + 31))
3806         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3807
3808       /* Call-clobbered FP registers.  */
3809       if ((regnum >= tdep->ppc_fp0_regnum
3810           && regnum <= tdep->ppc_fp0_regnum + 13))
3811         reg->how = DWARF2_FRAME_REG_UNDEFINED;
3812     }
3813
3814   /* Deal with ALTIVEC registers, if supported.  */
3815   if (tdep->ppc_vr0_regnum > 0 && tdep->ppc_vrsave_regnum > 0)
3816     {
3817       /* Call-saved Altivec registers.  */
3818       if ((regnum >= tdep->ppc_vr0_regnum + 20
3819           && regnum <= tdep->ppc_vr0_regnum + 31)
3820           || regnum == tdep->ppc_vrsave_regnum)
3821         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3822
3823       /* Call-clobbered Altivec registers.  */
3824       if ((regnum >= tdep->ppc_vr0_regnum
3825           && regnum <= tdep->ppc_vr0_regnum + 19))
3826         reg->how = DWARF2_FRAME_REG_UNDEFINED;
3827     }
3828
3829   /* Handle PC register and Stack Pointer correctly.  */
3830   if (regnum == gdbarch_pc_regnum (gdbarch))
3831     reg->how = DWARF2_FRAME_REG_RA;
3832   else if (regnum == gdbarch_sp_regnum (gdbarch))
3833     reg->how = DWARF2_FRAME_REG_CFA;
3834 }
3835
3836
3837 /* Return true if a .gnu_attributes section exists in BFD and it
3838    indicates we are using SPE extensions OR if a .PPC.EMB.apuinfo
3839    section exists in BFD and it indicates that SPE extensions are in
3840    use.  Check the .gnu.attributes section first, as the binary might be
3841    compiled for SPE, but not actually using SPE instructions.  */
3842
3843 static int
3844 bfd_uses_spe_extensions (bfd *abfd)
3845 {
3846   asection *sect;
3847   gdb_byte *contents = NULL;
3848   bfd_size_type size;
3849   gdb_byte *ptr;
3850   int success = 0;
3851
3852   if (!abfd)
3853     return 0;
3854
3855 #ifdef HAVE_ELF
3856   /* Using Tag_GNU_Power_ABI_Vector here is a bit of a hack, as the user
3857      could be using the SPE vector abi without actually using any spe
3858      bits whatsoever.  But it's close enough for now.  */
3859   int vector_abi = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_GNU,
3860                                              Tag_GNU_Power_ABI_Vector);
3861   if (vector_abi == 3)
3862     return 1;
3863 #endif
3864
3865   sect = bfd_get_section_by_name (abfd, ".PPC.EMB.apuinfo");
3866   if (!sect)
3867     return 0;
3868
3869   size = bfd_get_section_size (sect);
3870   contents = (gdb_byte *) xmalloc (size);
3871   if (!bfd_get_section_contents (abfd, sect, contents, 0, size))
3872     {
3873       xfree (contents);
3874       return 0;
3875     }
3876
3877   /* Parse the .PPC.EMB.apuinfo section.  The layout is as follows:
3878
3879      struct {
3880        uint32 name_len;
3881        uint32 data_len;
3882        uint32 type;
3883        char name[name_len rounded up to 4-byte alignment];
3884        char data[data_len];
3885      };
3886
3887      Technically, there's only supposed to be one such structure in a
3888      given apuinfo section, but the linker is not always vigilant about
3889      merging apuinfo sections from input files.  Just go ahead and parse
3890      them all, exiting early when we discover the binary uses SPE
3891      insns.
3892
3893      It's not specified in what endianness the information in this
3894      section is stored.  Assume that it's the endianness of the BFD.  */
3895   ptr = contents;
3896   while (1)
3897     {
3898       unsigned int name_len;
3899       unsigned int data_len;
3900       unsigned int type;
3901
3902       /* If we can't read the first three fields, we're done.  */
3903       if (size < 12)
3904         break;
3905
3906       name_len = bfd_get_32 (abfd, ptr);
3907       name_len = (name_len + 3) & ~3U; /* Round to 4 bytes.  */
3908       data_len = bfd_get_32 (abfd, ptr + 4);
3909       type = bfd_get_32 (abfd, ptr + 8);
3910       ptr += 12;
3911
3912       /* The name must be "APUinfo\0".  */
3913       if (name_len != 8
3914           && strcmp ((const char *) ptr, "APUinfo") != 0)
3915         break;
3916       ptr += name_len;
3917
3918       /* The type must be 2.  */
3919       if (type != 2)
3920         break;
3921
3922       /* The data is stored as a series of uint32.  The upper half of
3923          each uint32 indicates the particular APU used and the lower
3924          half indicates the revision of that APU.  We just care about
3925          the upper half.  */
3926
3927       /* Not 4-byte quantities.  */
3928       if (data_len & 3U)
3929         break;
3930
3931       while (data_len)
3932         {
3933           unsigned int apuinfo = bfd_get_32 (abfd, ptr);
3934           unsigned int apu = apuinfo >> 16;
3935           ptr += 4;
3936           data_len -= 4;
3937
3938           /* The SPE APU is 0x100; the SPEFP APU is 0x101.  Accept
3939              either.  */
3940           if (apu == 0x100 || apu == 0x101)
3941             {
3942               success = 1;
3943               data_len = 0;
3944             }
3945         }
3946
3947       if (success)
3948         break;
3949     }
3950
3951   xfree (contents);
3952   return success;
3953 }
3954
3955 /* These are macros for parsing instruction fields (I.1.6.28)  */
3956
3957 #define PPC_FIELD(value, from, len) \
3958         (((value) >> (32 - (from) - (len))) & ((1 << (len)) - 1))
3959 #define PPC_SEXT(v, bs) \
3960         ((((CORE_ADDR) (v) & (((CORE_ADDR) 1 << (bs)) - 1)) \
3961           ^ ((CORE_ADDR) 1 << ((bs) - 1))) \
3962          - ((CORE_ADDR) 1 << ((bs) - 1)))
3963 #define PPC_OP6(insn)   PPC_FIELD (insn, 0, 6)
3964 #define PPC_EXTOP(insn) PPC_FIELD (insn, 21, 10)
3965 #define PPC_RT(insn)    PPC_FIELD (insn, 6, 5)
3966 #define PPC_RS(insn)    PPC_FIELD (insn, 6, 5)
3967 #define PPC_RA(insn)    PPC_FIELD (insn, 11, 5)
3968 #define PPC_RB(insn)    PPC_FIELD (insn, 16, 5)
3969 #define PPC_NB(insn)    PPC_FIELD (insn, 16, 5)
3970 #define PPC_VRT(insn)   PPC_FIELD (insn, 6, 5)
3971 #define PPC_FRT(insn)   PPC_FIELD (insn, 6, 5)
3972 #define PPC_SPR(insn)   (PPC_FIELD (insn, 11, 5) \
3973                         | (PPC_FIELD (insn, 16, 5) << 5))
3974 #define PPC_BO(insn)    PPC_FIELD (insn, 6, 5)
3975 #define PPC_T(insn)     PPC_FIELD (insn, 6, 5)
3976 #define PPC_D(insn)     PPC_SEXT (PPC_FIELD (insn, 16, 16), 16)
3977 #define PPC_DS(insn)    PPC_SEXT (PPC_FIELD (insn, 16, 14), 14)
3978 #define PPC_DQ(insn)    PPC_SEXT (PPC_FIELD (insn, 16, 12), 12)
3979 #define PPC_BIT(insn,n) ((insn & (1 << (31 - (n)))) ? 1 : 0)
3980 #define PPC_OE(insn)    PPC_BIT (insn, 21)
3981 #define PPC_RC(insn)    PPC_BIT (insn, 31)
3982 #define PPC_Rc(insn)    PPC_BIT (insn, 21)
3983 #define PPC_LK(insn)    PPC_BIT (insn, 31)
3984 #define PPC_TX(insn)    PPC_BIT (insn, 31)
3985 #define PPC_LEV(insn)   PPC_FIELD (insn, 20, 7)
3986
3987 #define PPC_XT(insn)    ((PPC_TX (insn) << 5) | PPC_T (insn))
3988 #define PPC_XER_NB(xer) (xer & 0x7f)
3989
3990 /* Record Vector-Scalar Registers.
3991    For VSR less than 32, it's represented by an FPR and an VSR-upper register.
3992    Otherwise, it's just a VR register.  Record them accordingly.  */
3993
3994 static int
3995 ppc_record_vsr (struct regcache *regcache, struct gdbarch_tdep *tdep, int vsr)
3996 {
3997   if (vsr < 0 || vsr >= 64)
3998     return -1;
3999
4000   if (vsr >= 32)
4001     {
4002       if (tdep->ppc_vr0_regnum >= 0)
4003         record_full_arch_list_add_reg (regcache, tdep->ppc_vr0_regnum + vsr - 32);
4004     }
4005   else
4006     {
4007       if (tdep->ppc_fp0_regnum >= 0)
4008         record_full_arch_list_add_reg (regcache, tdep->ppc_fp0_regnum + vsr);
4009       if (tdep->ppc_vsr0_upper_regnum >= 0)
4010         record_full_arch_list_add_reg (regcache,
4011                                        tdep->ppc_vsr0_upper_regnum + vsr);
4012     }
4013
4014   return 0;
4015 }
4016
4017 /* Parse and record instructions primary opcode-4 at ADDR.
4018    Return 0 if successful.  */
4019
4020 static int
4021 ppc_process_record_op4 (struct gdbarch *gdbarch, struct regcache *regcache,
4022                         CORE_ADDR addr, uint32_t insn)
4023 {
4024   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4025   int ext = PPC_FIELD (insn, 21, 11);
4026   int vra = PPC_FIELD (insn, 11, 5);
4027
4028   switch (ext & 0x3f)
4029     {
4030     case 32:            /* Vector Multiply-High-Add Signed Halfword Saturate */
4031     case 33:            /* Vector Multiply-High-Round-Add Signed Halfword Saturate */
4032     case 39:            /* Vector Multiply-Sum Unsigned Halfword Saturate */
4033     case 41:            /* Vector Multiply-Sum Signed Halfword Saturate */
4034       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4035       /* FALL-THROUGH */
4036     case 42:            /* Vector Select */
4037     case 43:            /* Vector Permute */
4038     case 59:            /* Vector Permute Right-indexed */
4039     case 44:            /* Vector Shift Left Double by Octet Immediate */
4040     case 45:            /* Vector Permute and Exclusive-OR */
4041     case 60:            /* Vector Add Extended Unsigned Quadword Modulo */
4042     case 61:            /* Vector Add Extended & write Carry Unsigned Quadword */
4043     case 62:            /* Vector Subtract Extended Unsigned Quadword Modulo */
4044     case 63:            /* Vector Subtract Extended & write Carry Unsigned Quadword */
4045     case 34:            /* Vector Multiply-Low-Add Unsigned Halfword Modulo */
4046     case 35:            /* Vector Multiply-Sum Unsigned Doubleword Modulo */
4047     case 36:            /* Vector Multiply-Sum Unsigned Byte Modulo */
4048     case 37:            /* Vector Multiply-Sum Mixed Byte Modulo */
4049     case 38:            /* Vector Multiply-Sum Unsigned Halfword Modulo */
4050     case 40:            /* Vector Multiply-Sum Signed Halfword Modulo */
4051     case 46:            /* Vector Multiply-Add Single-Precision */
4052     case 47:            /* Vector Negative Multiply-Subtract Single-Precision */
4053       record_full_arch_list_add_reg (regcache,
4054                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4055       return 0;
4056
4057     case 48:            /* Multiply-Add High Doubleword */
4058     case 49:            /* Multiply-Add High Doubleword Unsigned */
4059     case 51:            /* Multiply-Add Low Doubleword */
4060       record_full_arch_list_add_reg (regcache,
4061                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4062       return 0;
4063     }
4064
4065   switch ((ext & 0x1ff))
4066     {
4067     case 385:
4068       if (vra != 0      /* Decimal Convert To Signed Quadword */
4069           && vra != 2   /* Decimal Convert From Signed Quadword */
4070           && vra != 4   /* Decimal Convert To Zoned */
4071           && vra != 5   /* Decimal Convert To National */
4072           && vra != 6   /* Decimal Convert From Zoned */
4073           && vra != 7   /* Decimal Convert From National */
4074           && vra != 31) /* Decimal Set Sign */
4075         break;
4076       /* Fall through.  */
4077                         /* 5.16 Decimal Integer Arithmetic Instructions */
4078     case 1:             /* Decimal Add Modulo */
4079     case 65:            /* Decimal Subtract Modulo */
4080
4081     case 193:           /* Decimal Shift */
4082     case 129:           /* Decimal Unsigned Shift */
4083     case 449:           /* Decimal Shift and Round */
4084
4085     case 257:           /* Decimal Truncate */
4086     case 321:           /* Decimal Unsigned Truncate */
4087
4088       /* Bit-21 should be set.  */
4089       if (!PPC_BIT (insn, 21))
4090         break;
4091
4092       record_full_arch_list_add_reg (regcache,
4093                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4094       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4095       return 0;
4096     }
4097
4098   /* Bit-21 is used for RC */
4099   switch (ext & 0x3ff)
4100     {
4101     case 6:             /* Vector Compare Equal To Unsigned Byte */
4102     case 70:            /* Vector Compare Equal To Unsigned Halfword */
4103     case 134:           /* Vector Compare Equal To Unsigned Word */
4104     case 199:           /* Vector Compare Equal To Unsigned Doubleword */
4105     case 774:           /* Vector Compare Greater Than Signed Byte */
4106     case 838:           /* Vector Compare Greater Than Signed Halfword */
4107     case 902:           /* Vector Compare Greater Than Signed Word */
4108     case 967:           /* Vector Compare Greater Than Signed Doubleword */
4109     case 518:           /* Vector Compare Greater Than Unsigned Byte */
4110     case 646:           /* Vector Compare Greater Than Unsigned Word */
4111     case 582:           /* Vector Compare Greater Than Unsigned Halfword */
4112     case 711:           /* Vector Compare Greater Than Unsigned Doubleword */
4113     case 966:           /* Vector Compare Bounds Single-Precision */
4114     case 198:           /* Vector Compare Equal To Single-Precision */
4115     case 454:           /* Vector Compare Greater Than or Equal To Single-Precision */
4116     case 710:           /* Vector Compare Greater Than Single-Precision */
4117     case 7:             /* Vector Compare Not Equal Byte */
4118     case 71:            /* Vector Compare Not Equal Halfword */
4119     case 135:           /* Vector Compare Not Equal Word */
4120     case 263:           /* Vector Compare Not Equal or Zero Byte */
4121     case 327:           /* Vector Compare Not Equal or Zero Halfword */
4122     case 391:           /* Vector Compare Not Equal or Zero Word */
4123       if (PPC_Rc (insn))
4124         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4125       record_full_arch_list_add_reg (regcache,
4126                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4127       return 0;
4128     }
4129
4130   if (ext  == 1538)
4131     {
4132       switch (vra)
4133         {
4134         case 0:         /* Vector Count Leading Zero Least-Significant Bits
4135                            Byte */
4136         case 1:         /* Vector Count Trailing Zero Least-Significant Bits
4137                            Byte */
4138           record_full_arch_list_add_reg (regcache,
4139                                          tdep->ppc_gp0_regnum + PPC_RT (insn));
4140           return 0;
4141
4142         case 6:         /* Vector Negate Word */
4143         case 7:         /* Vector Negate Doubleword */
4144         case 8:         /* Vector Parity Byte Word */
4145         case 9:         /* Vector Parity Byte Doubleword */
4146         case 10:        /* Vector Parity Byte Quadword */
4147         case 16:        /* Vector Extend Sign Byte To Word */
4148         case 17:        /* Vector Extend Sign Halfword To Word */
4149         case 24:        /* Vector Extend Sign Byte To Doubleword */
4150         case 25:        /* Vector Extend Sign Halfword To Doubleword */
4151         case 26:        /* Vector Extend Sign Word To Doubleword */
4152         case 28:        /* Vector Count Trailing Zeros Byte */
4153         case 29:        /* Vector Count Trailing Zeros Halfword */
4154         case 30:        /* Vector Count Trailing Zeros Word */
4155         case 31:        /* Vector Count Trailing Zeros Doubleword */
4156           record_full_arch_list_add_reg (regcache,
4157                                          tdep->ppc_vr0_regnum + PPC_VRT (insn));
4158           return 0;
4159         }
4160     }
4161
4162   switch (ext)
4163     {
4164     case 142:           /* Vector Pack Unsigned Halfword Unsigned Saturate */
4165     case 206:           /* Vector Pack Unsigned Word Unsigned Saturate */
4166     case 270:           /* Vector Pack Signed Halfword Unsigned Saturate */
4167     case 334:           /* Vector Pack Signed Word Unsigned Saturate */
4168     case 398:           /* Vector Pack Signed Halfword Signed Saturate */
4169     case 462:           /* Vector Pack Signed Word Signed Saturate */
4170     case 1230:          /* Vector Pack Unsigned Doubleword Unsigned Saturate */
4171     case 1358:          /* Vector Pack Signed Doubleword Unsigned Saturate */
4172     case 1486:          /* Vector Pack Signed Doubleword Signed Saturate */
4173     case 512:           /* Vector Add Unsigned Byte Saturate */
4174     case 576:           /* Vector Add Unsigned Halfword Saturate */
4175     case 640:           /* Vector Add Unsigned Word Saturate */
4176     case 768:           /* Vector Add Signed Byte Saturate */
4177     case 832:           /* Vector Add Signed Halfword Saturate */
4178     case 896:           /* Vector Add Signed Word Saturate */
4179     case 1536:          /* Vector Subtract Unsigned Byte Saturate */
4180     case 1600:          /* Vector Subtract Unsigned Halfword Saturate */
4181     case 1664:          /* Vector Subtract Unsigned Word Saturate */
4182     case 1792:          /* Vector Subtract Signed Byte Saturate */
4183     case 1856:          /* Vector Subtract Signed Halfword Saturate */
4184     case 1920:          /* Vector Subtract Signed Word Saturate */
4185
4186     case 1544:          /* Vector Sum across Quarter Unsigned Byte Saturate */
4187     case 1800:          /* Vector Sum across Quarter Signed Byte Saturate */
4188     case 1608:          /* Vector Sum across Quarter Signed Halfword Saturate */
4189     case 1672:          /* Vector Sum across Half Signed Word Saturate */
4190     case 1928:          /* Vector Sum across Signed Word Saturate */
4191     case 970:           /* Vector Convert To Signed Fixed-Point Word Saturate */
4192     case 906:           /* Vector Convert To Unsigned Fixed-Point Word Saturate */
4193       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4194       /* FALL-THROUGH */
4195     case 12:            /* Vector Merge High Byte */
4196     case 14:            /* Vector Pack Unsigned Halfword Unsigned Modulo */
4197     case 76:            /* Vector Merge High Halfword */
4198     case 78:            /* Vector Pack Unsigned Word Unsigned Modulo */
4199     case 140:           /* Vector Merge High Word */
4200     case 268:           /* Vector Merge Low Byte */
4201     case 332:           /* Vector Merge Low Halfword */
4202     case 396:           /* Vector Merge Low Word */
4203     case 526:           /* Vector Unpack High Signed Byte */
4204     case 590:           /* Vector Unpack High Signed Halfword */
4205     case 654:           /* Vector Unpack Low Signed Byte */
4206     case 718:           /* Vector Unpack Low Signed Halfword */
4207     case 782:           /* Vector Pack Pixel */
4208     case 846:           /* Vector Unpack High Pixel */
4209     case 974:           /* Vector Unpack Low Pixel */
4210     case 1102:          /* Vector Pack Unsigned Doubleword Unsigned Modulo */
4211     case 1614:          /* Vector Unpack High Signed Word */
4212     case 1676:          /* Vector Merge Odd Word */
4213     case 1742:          /* Vector Unpack Low Signed Word */
4214     case 1932:          /* Vector Merge Even Word */
4215     case 524:           /* Vector Splat Byte */
4216     case 588:           /* Vector Splat Halfword */
4217     case 652:           /* Vector Splat Word */
4218     case 780:           /* Vector Splat Immediate Signed Byte */
4219     case 844:           /* Vector Splat Immediate Signed Halfword */
4220     case 908:           /* Vector Splat Immediate Signed Word */
4221     case 452:           /* Vector Shift Left */
4222     case 708:           /* Vector Shift Right */
4223     case 1036:          /* Vector Shift Left by Octet */
4224     case 1100:          /* Vector Shift Right by Octet */
4225     case 0:             /* Vector Add Unsigned Byte Modulo */
4226     case 64:            /* Vector Add Unsigned Halfword Modulo */
4227     case 128:           /* Vector Add Unsigned Word Modulo */
4228     case 192:           /* Vector Add Unsigned Doubleword Modulo */
4229     case 256:           /* Vector Add Unsigned Quadword Modulo */
4230     case 320:           /* Vector Add & write Carry Unsigned Quadword */
4231     case 384:           /* Vector Add and Write Carry-Out Unsigned Word */
4232     case 8:             /* Vector Multiply Odd Unsigned Byte */
4233     case 72:            /* Vector Multiply Odd Unsigned Halfword */
4234     case 136:           /* Vector Multiply Odd Unsigned Word */
4235     case 264:           /* Vector Multiply Odd Signed Byte */
4236     case 328:           /* Vector Multiply Odd Signed Halfword */
4237     case 392:           /* Vector Multiply Odd Signed Word */
4238     case 520:           /* Vector Multiply Even Unsigned Byte */
4239     case 584:           /* Vector Multiply Even Unsigned Halfword */
4240     case 648:           /* Vector Multiply Even Unsigned Word */
4241     case 776:           /* Vector Multiply Even Signed Byte */
4242     case 840:           /* Vector Multiply Even Signed Halfword */
4243     case 904:           /* Vector Multiply Even Signed Word */
4244     case 137:           /* Vector Multiply Unsigned Word Modulo */
4245     case 1024:          /* Vector Subtract Unsigned Byte Modulo */
4246     case 1088:          /* Vector Subtract Unsigned Halfword Modulo */
4247     case 1152:          /* Vector Subtract Unsigned Word Modulo */
4248     case 1216:          /* Vector Subtract Unsigned Doubleword Modulo */
4249     case 1280:          /* Vector Subtract Unsigned Quadword Modulo */
4250     case 1344:          /* Vector Subtract & write Carry Unsigned Quadword */
4251     case 1408:          /* Vector Subtract and Write Carry-Out Unsigned Word */
4252     case 1282:          /* Vector Average Signed Byte */
4253     case 1346:          /* Vector Average Signed Halfword */
4254     case 1410:          /* Vector Average Signed Word */
4255     case 1026:          /* Vector Average Unsigned Byte */
4256     case 1090:          /* Vector Average Unsigned Halfword */
4257     case 1154:          /* Vector Average Unsigned Word */
4258     case 258:           /* Vector Maximum Signed Byte */
4259     case 322:           /* Vector Maximum Signed Halfword */
4260     case 386:           /* Vector Maximum Signed Word */
4261     case 450:           /* Vector Maximum Signed Doubleword */
4262     case 2:             /* Vector Maximum Unsigned Byte */
4263     case 66:            /* Vector Maximum Unsigned Halfword */
4264     case 130:           /* Vector Maximum Unsigned Word */
4265     case 194:           /* Vector Maximum Unsigned Doubleword */
4266     case 770:           /* Vector Minimum Signed Byte */
4267     case 834:           /* Vector Minimum Signed Halfword */
4268     case 898:           /* Vector Minimum Signed Word */
4269     case 962:           /* Vector Minimum Signed Doubleword */
4270     case 514:           /* Vector Minimum Unsigned Byte */
4271     case 578:           /* Vector Minimum Unsigned Halfword */
4272     case 642:           /* Vector Minimum Unsigned Word */
4273     case 706:           /* Vector Minimum Unsigned Doubleword */
4274     case 1028:          /* Vector Logical AND */
4275     case 1668:          /* Vector Logical Equivalent */
4276     case 1092:          /* Vector Logical AND with Complement */
4277     case 1412:          /* Vector Logical NAND */
4278     case 1348:          /* Vector Logical OR with Complement */
4279     case 1156:          /* Vector Logical OR */
4280     case 1284:          /* Vector Logical NOR */
4281     case 1220:          /* Vector Logical XOR */
4282     case 4:             /* Vector Rotate Left Byte */
4283     case 132:           /* Vector Rotate Left Word VX-form */
4284     case 68:            /* Vector Rotate Left Halfword */
4285     case 196:           /* Vector Rotate Left Doubleword */
4286     case 260:           /* Vector Shift Left Byte */
4287     case 388:           /* Vector Shift Left Word */
4288     case 324:           /* Vector Shift Left Halfword */
4289     case 1476:          /* Vector Shift Left Doubleword */
4290     case 516:           /* Vector Shift Right Byte */
4291     case 644:           /* Vector Shift Right Word */
4292     case 580:           /* Vector Shift Right Halfword */
4293     case 1732:          /* Vector Shift Right Doubleword */
4294     case 772:           /* Vector Shift Right Algebraic Byte */
4295     case 900:           /* Vector Shift Right Algebraic Word */
4296     case 836:           /* Vector Shift Right Algebraic Halfword */
4297     case 964:           /* Vector Shift Right Algebraic Doubleword */
4298     case 10:            /* Vector Add Single-Precision */
4299     case 74:            /* Vector Subtract Single-Precision */
4300     case 1034:          /* Vector Maximum Single-Precision */
4301     case 1098:          /* Vector Minimum Single-Precision */
4302     case 842:           /* Vector Convert From Signed Fixed-Point Word */
4303     case 778:           /* Vector Convert From Unsigned Fixed-Point Word */
4304     case 714:           /* Vector Round to Single-Precision Integer toward -Infinity */
4305     case 522:           /* Vector Round to Single-Precision Integer Nearest */
4306     case 650:           /* Vector Round to Single-Precision Integer toward +Infinity */
4307     case 586:           /* Vector Round to Single-Precision Integer toward Zero */
4308     case 394:           /* Vector 2 Raised to the Exponent Estimate Floating-Point */
4309     case 458:           /* Vector Log Base 2 Estimate Floating-Point */
4310     case 266:           /* Vector Reciprocal Estimate Single-Precision */
4311     case 330:           /* Vector Reciprocal Square Root Estimate Single-Precision */
4312     case 1288:          /* Vector AES Cipher */
4313     case 1289:          /* Vector AES Cipher Last */
4314     case 1352:          /* Vector AES Inverse Cipher */
4315     case 1353:          /* Vector AES Inverse Cipher Last */
4316     case 1480:          /* Vector AES SubBytes */
4317     case 1730:          /* Vector SHA-512 Sigma Doubleword */
4318     case 1666:          /* Vector SHA-256 Sigma Word */
4319     case 1032:          /* Vector Polynomial Multiply-Sum Byte */
4320     case 1160:          /* Vector Polynomial Multiply-Sum Word */
4321     case 1096:          /* Vector Polynomial Multiply-Sum Halfword */
4322     case 1224:          /* Vector Polynomial Multiply-Sum Doubleword */
4323     case 1292:          /* Vector Gather Bits by Bytes by Doubleword */
4324     case 1794:          /* Vector Count Leading Zeros Byte */
4325     case 1858:          /* Vector Count Leading Zeros Halfword */
4326     case 1922:          /* Vector Count Leading Zeros Word */
4327     case 1986:          /* Vector Count Leading Zeros Doubleword */
4328     case 1795:          /* Vector Population Count Byte */
4329     case 1859:          /* Vector Population Count Halfword */
4330     case 1923:          /* Vector Population Count Word */
4331     case 1987:          /* Vector Population Count Doubleword */
4332     case 1356:          /* Vector Bit Permute Quadword */
4333     case 1484:          /* Vector Bit Permute Doubleword */
4334     case 513:           /* Vector Multiply-by-10 Unsigned Quadword */
4335     case 1:             /* Vector Multiply-by-10 & write Carry Unsigned
4336                            Quadword */
4337     case 577:           /* Vector Multiply-by-10 Extended Unsigned Quadword */
4338     case 65:            /* Vector Multiply-by-10 Extended & write Carry
4339                            Unsigned Quadword */
4340     case 1027:          /* Vector Absolute Difference Unsigned Byte */
4341     case 1091:          /* Vector Absolute Difference Unsigned Halfword */
4342     case 1155:          /* Vector Absolute Difference Unsigned Word */
4343     case 1796:          /* Vector Shift Right Variable */
4344     case 1860:          /* Vector Shift Left Variable */
4345     case 133:           /* Vector Rotate Left Word then Mask Insert */
4346     case 197:           /* Vector Rotate Left Doubleword then Mask Insert */
4347     case 389:           /* Vector Rotate Left Word then AND with Mask */
4348     case 453:           /* Vector Rotate Left Doubleword then AND with Mask */
4349     case 525:           /* Vector Extract Unsigned Byte */
4350     case 589:           /* Vector Extract Unsigned Halfword */
4351     case 653:           /* Vector Extract Unsigned Word */
4352     case 717:           /* Vector Extract Doubleword */
4353     case 781:           /* Vector Insert Byte */
4354     case 845:           /* Vector Insert Halfword */
4355     case 909:           /* Vector Insert Word */
4356     case 973:           /* Vector Insert Doubleword */
4357       record_full_arch_list_add_reg (regcache,
4358                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4359       return 0;
4360
4361     case 1549:          /* Vector Extract Unsigned Byte Left-Indexed */
4362     case 1613:          /* Vector Extract Unsigned Halfword Left-Indexed */
4363     case 1677:          /* Vector Extract Unsigned Word Left-Indexed */
4364     case 1805:          /* Vector Extract Unsigned Byte Right-Indexed */
4365     case 1869:          /* Vector Extract Unsigned Halfword Right-Indexed */
4366     case 1933:          /* Vector Extract Unsigned Word Right-Indexed */
4367       record_full_arch_list_add_reg (regcache,
4368                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4369       return 0;
4370
4371     case 1604:          /* Move To Vector Status and Control Register */
4372       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4373       return 0;
4374     case 1540:          /* Move From Vector Status and Control Register */
4375       record_full_arch_list_add_reg (regcache,
4376                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4377       return 0;
4378     case 833:           /* Decimal Copy Sign */
4379       record_full_arch_list_add_reg (regcache,
4380                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4381       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4382       return 0;
4383     }
4384
4385   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
4386                       "at %s, 4-%d.\n", insn, paddress (gdbarch, addr), ext);
4387   return -1;
4388 }
4389
4390 /* Parse and record instructions of primary opcode-19 at ADDR.
4391    Return 0 if successful.  */
4392
4393 static int
4394 ppc_process_record_op19 (struct gdbarch *gdbarch, struct regcache *regcache,
4395                            CORE_ADDR addr, uint32_t insn)
4396 {
4397   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4398   int ext = PPC_EXTOP (insn);
4399
4400   switch (ext & 0x01f)
4401     {
4402     case 2:             /* Add PC Immediate Shifted */
4403       record_full_arch_list_add_reg (regcache,
4404                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4405       return 0;
4406     }
4407
4408   switch (ext)
4409     {
4410     case 0:             /* Move Condition Register Field */
4411     case 33:            /* Condition Register NOR */
4412     case 129:           /* Condition Register AND with Complement */
4413     case 193:           /* Condition Register XOR */
4414     case 225:           /* Condition Register NAND */
4415     case 257:           /* Condition Register AND */
4416     case 289:           /* Condition Register Equivalent */
4417     case 417:           /* Condition Register OR with Complement */
4418     case 449:           /* Condition Register OR */
4419       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4420       return 0;
4421
4422     case 16:            /* Branch Conditional */
4423     case 560:           /* Branch Conditional to Branch Target Address Register */
4424       if ((PPC_BO (insn) & 0x4) == 0)
4425         record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
4426       /* FALL-THROUGH */
4427     case 528:           /* Branch Conditional to Count Register */
4428       if (PPC_LK (insn))
4429         record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
4430       return 0;
4431
4432     case 150:           /* Instruction Synchronize */
4433       /* Do nothing.  */
4434       return 0;
4435     }
4436
4437   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
4438                       "at %s, 19-%d.\n", insn, paddress (gdbarch, addr), ext);
4439   return -1;
4440 }
4441
4442 /* Parse and record instructions of primary opcode-31 at ADDR.
4443    Return 0 if successful.  */
4444
4445 static int
4446 ppc_process_record_op31 (struct gdbarch *gdbarch, struct regcache *regcache,
4447                            CORE_ADDR addr, uint32_t insn)
4448 {
4449   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4450   int ext = PPC_EXTOP (insn);
4451   int tmp, nr, nb, i;
4452   CORE_ADDR at_dcsz, ea = 0;
4453   ULONGEST rb, ra, xer;
4454   int size = 0;
4455
4456   /* These instructions have OE bit.  */
4457   switch (ext & 0x1ff)
4458     {
4459     /* These write RT and XER.  Update CR if RC is set.  */
4460     case 8:             /* Subtract from carrying */
4461     case 10:            /* Add carrying */
4462     case 136:           /* Subtract from extended */
4463     case 138:           /* Add extended */
4464     case 200:           /* Subtract from zero extended */
4465     case 202:           /* Add to zero extended */
4466     case 232:           /* Subtract from minus one extended */
4467     case 234:           /* Add to minus one extended */
4468       /* CA is always altered, but SO/OV are only altered when OE=1.
4469          In any case, XER is always altered.  */
4470       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4471       if (PPC_RC (insn))
4472         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4473       record_full_arch_list_add_reg (regcache,
4474                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4475       return 0;
4476
4477     /* These write RT.  Update CR if RC is set and update XER if OE is set.  */
4478     case 40:            /* Subtract from */
4479     case 104:           /* Negate */
4480     case 233:           /* Multiply low doubleword */
4481     case 235:           /* Multiply low word */
4482     case 266:           /* Add */
4483     case 393:           /* Divide Doubleword Extended Unsigned */
4484     case 395:           /* Divide Word Extended Unsigned */
4485     case 425:           /* Divide Doubleword Extended */
4486     case 427:           /* Divide Word Extended */
4487     case 457:           /* Divide Doubleword Unsigned */
4488     case 459:           /* Divide Word Unsigned */
4489     case 489:           /* Divide Doubleword */
4490     case 491:           /* Divide Word */
4491       if (PPC_OE (insn))
4492         record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4493       /* FALL-THROUGH */
4494     case 9:             /* Multiply High Doubleword Unsigned */
4495     case 11:            /* Multiply High Word Unsigned */
4496     case 73:            /* Multiply High Doubleword */
4497     case 75:            /* Multiply High Word */
4498       if (PPC_RC (insn))
4499         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4500       record_full_arch_list_add_reg (regcache,
4501                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4502       return 0;
4503     }
4504
4505   if ((ext & 0x1f) == 15)
4506     {
4507       /* Integer Select. bit[16:20] is used for BC.  */
4508       record_full_arch_list_add_reg (regcache,
4509                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4510       return 0;
4511     }
4512
4513   if ((ext & 0xff) == 170)
4514     {
4515       /* Add Extended using alternate carry bits */
4516       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4517       record_full_arch_list_add_reg (regcache,
4518                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4519       return 0;
4520     }
4521
4522   switch (ext)
4523     {
4524     case 78:            /* Determine Leftmost Zero Byte */
4525       if (PPC_RC (insn))
4526         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4527       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4528       record_full_arch_list_add_reg (regcache,
4529                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4530       return 0;
4531
4532     /* These only write RT.  */
4533     case 19:            /* Move from condition register */
4534                         /* Move From One Condition Register Field */
4535     case 74:            /* Add and Generate Sixes */
4536     case 74 | 0x200:    /* Add and Generate Sixes (bit-21 dont-care) */
4537     case 302:           /* Move From Branch History Rolling Buffer */
4538     case 339:           /* Move From Special Purpose Register */
4539     case 371:           /* Move From Time Base [Phased-Out]  */
4540     case 309:           /* Load Doubleword Monitored Indexed  */
4541     case 128:           /* Set Boolean */
4542     case 755:           /* Deliver A Random Number */
4543       record_full_arch_list_add_reg (regcache,
4544                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4545       return 0;
4546
4547     /* These only write to RA.  */
4548     case 51:            /* Move From VSR Doubleword */
4549     case 115:           /* Move From VSR Word and Zero */
4550     case 122:           /* Population count bytes */
4551     case 378:           /* Population count words */
4552     case 506:           /* Population count doublewords */
4553     case 154:           /* Parity Word */
4554     case 186:           /* Parity Doubleword */
4555     case 252:           /* Bit Permute Doubleword */
4556     case 282:           /* Convert Declets To Binary Coded Decimal */
4557     case 314:           /* Convert Binary Coded Decimal To Declets */
4558     case 508:           /* Compare bytes */
4559     case 307:           /* Move From VSR Lower Doubleword */
4560       record_full_arch_list_add_reg (regcache,
4561                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4562       return 0;
4563
4564     /* These write CR and optional RA.  */
4565     case 792:           /* Shift Right Algebraic Word */
4566     case 794:           /* Shift Right Algebraic Doubleword */
4567     case 824:           /* Shift Right Algebraic Word Immediate */
4568     case 826:           /* Shift Right Algebraic Doubleword Immediate (413) */
4569     case 826 | 1:       /* Shift Right Algebraic Doubleword Immediate (413) */
4570       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4571       record_full_arch_list_add_reg (regcache,
4572                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4573       /* FALL-THROUGH */
4574     case 0:             /* Compare */
4575     case 32:            /* Compare logical */
4576     case 144:           /* Move To Condition Register Fields */
4577                         /* Move To One Condition Register Field */
4578     case 192:           /* Compare Ranged Byte */
4579     case 224:           /* Compare Equal Byte */
4580     case 576:           /* Move XER to CR Extended */
4581     case 902:           /* Paste (should always fail due to single-stepping and
4582                            the memory location might not be accessible, so
4583                            record only CR) */
4584       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4585       return 0;
4586
4587     /* These write to RT.  Update RA if 'update indexed.'  */
4588     case 53:            /* Load Doubleword with Update Indexed */
4589     case 119:           /* Load Byte and Zero with Update Indexed */
4590     case 311:           /* Load Halfword and Zero with Update Indexed */
4591     case 55:            /* Load Word and Zero with Update Indexed */
4592     case 375:           /* Load Halfword Algebraic with Update Indexed */
4593     case 373:           /* Load Word Algebraic with Update Indexed */
4594       record_full_arch_list_add_reg (regcache,
4595                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4596       /* FALL-THROUGH */
4597     case 21:            /* Load Doubleword Indexed */
4598     case 52:            /* Load Byte And Reserve Indexed */
4599     case 116:           /* Load Halfword And Reserve Indexed */
4600     case 20:            /* Load Word And Reserve Indexed */
4601     case 84:            /* Load Doubleword And Reserve Indexed */
4602     case 87:            /* Load Byte and Zero Indexed */
4603     case 279:           /* Load Halfword and Zero Indexed */
4604     case 23:            /* Load Word and Zero Indexed */
4605     case 343:           /* Load Halfword Algebraic Indexed */
4606     case 341:           /* Load Word Algebraic Indexed */
4607     case 790:           /* Load Halfword Byte-Reverse Indexed */
4608     case 534:           /* Load Word Byte-Reverse Indexed */
4609     case 532:           /* Load Doubleword Byte-Reverse Indexed */
4610     case 582:           /* Load Word Atomic */
4611     case 614:           /* Load Doubleword Atomic */
4612     case 265:           /* Modulo Unsigned Doubleword */
4613     case 777:           /* Modulo Signed Doubleword */
4614     case 267:           /* Modulo Unsigned Word */
4615     case 779:           /* Modulo Signed Word */
4616       record_full_arch_list_add_reg (regcache,
4617                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4618       return 0;
4619
4620     case 597:           /* Load String Word Immediate */
4621     case 533:           /* Load String Word Indexed */
4622       if (ext == 597)
4623         {
4624         nr = PPC_NB (insn);
4625         if (nr == 0)
4626           nr = 32;
4627         }
4628       else
4629         {
4630           regcache_raw_read_unsigned (regcache, tdep->ppc_xer_regnum, &xer);
4631           nr = PPC_XER_NB (xer);
4632         }
4633
4634       nr = (nr + 3) >> 2;
4635
4636       /* If n=0, the contents of register RT are undefined.  */
4637       if (nr == 0)
4638         nr = 1;
4639
4640       for (i = 0; i < nr; i++)
4641         record_full_arch_list_add_reg (regcache,
4642                                        tdep->ppc_gp0_regnum
4643                                        + ((PPC_RT (insn) + i) & 0x1f));
4644       return 0;
4645
4646     case 276:           /* Load Quadword And Reserve Indexed */
4647       tmp = tdep->ppc_gp0_regnum + (PPC_RT (insn) & ~1);
4648       record_full_arch_list_add_reg (regcache, tmp);
4649       record_full_arch_list_add_reg (regcache, tmp + 1);
4650       return 0;
4651
4652     /* These write VRT.  */
4653     case 6:             /* Load Vector for Shift Left Indexed */
4654     case 38:            /* Load Vector for Shift Right Indexed */
4655     case 7:             /* Load Vector Element Byte Indexed */
4656     case 39:            /* Load Vector Element Halfword Indexed */
4657     case 71:            /* Load Vector Element Word Indexed */
4658     case 103:           /* Load Vector Indexed */
4659     case 359:           /* Load Vector Indexed LRU */
4660       record_full_arch_list_add_reg (regcache,
4661                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4662       return 0;
4663
4664     /* These write FRT.  Update RA if 'update indexed.'  */
4665     case 567:           /* Load Floating-Point Single with Update Indexed */
4666     case 631:           /* Load Floating-Point Double with Update Indexed */
4667       record_full_arch_list_add_reg (regcache,
4668                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4669       /* FALL-THROUGH */
4670     case 535:           /* Load Floating-Point Single Indexed */
4671     case 599:           /* Load Floating-Point Double Indexed */
4672     case 855:           /* Load Floating-Point as Integer Word Algebraic Indexed */
4673     case 887:           /* Load Floating-Point as Integer Word and Zero Indexed */
4674       record_full_arch_list_add_reg (regcache,
4675                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
4676       return 0;
4677
4678     case 791:           /* Load Floating-Point Double Pair Indexed */
4679       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
4680       record_full_arch_list_add_reg (regcache, tmp);
4681       record_full_arch_list_add_reg (regcache, tmp + 1);
4682       return 0;
4683
4684     case 179:           /* Move To VSR Doubleword */
4685     case 211:           /* Move To VSR Word Algebraic */
4686     case 243:           /* Move To VSR Word and Zero */
4687     case 588:           /* Load VSX Scalar Doubleword Indexed */
4688     case 524:           /* Load VSX Scalar Single-Precision Indexed */
4689     case 76:            /* Load VSX Scalar as Integer Word Algebraic Indexed */
4690     case 12:            /* Load VSX Scalar as Integer Word and Zero Indexed */
4691     case 844:           /* Load VSX Vector Doubleword*2 Indexed */
4692     case 332:           /* Load VSX Vector Doubleword & Splat Indexed */
4693     case 780:           /* Load VSX Vector Word*4 Indexed */
4694     case 268:           /* Load VSX Vector Indexed */
4695     case 364:           /* Load VSX Vector Word & Splat Indexed */
4696     case 812:           /* Load VSX Vector Halfword*8 Indexed */
4697     case 876:           /* Load VSX Vector Byte*16 Indexed */
4698     case 269:           /* Load VSX Vector with Length */
4699     case 301:           /* Load VSX Vector Left-justified with Length */
4700     case 781:           /* Load VSX Scalar as Integer Byte & Zero Indexed */
4701     case 813:           /* Load VSX Scalar as Integer Halfword & Zero Indexed */
4702     case 403:           /* Move To VSR Word & Splat */
4703     case 435:           /* Move To VSR Double Doubleword */
4704       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
4705       return 0;
4706
4707     /* These write RA.  Update CR if RC is set.  */
4708     case 24:            /* Shift Left Word */
4709     case 26:            /* Count Leading Zeros Word */
4710     case 27:            /* Shift Left Doubleword */
4711     case 28:            /* AND */
4712     case 58:            /* Count Leading Zeros Doubleword */
4713     case 60:            /* AND with Complement */
4714     case 124:           /* NOR */
4715     case 284:           /* Equivalent */
4716     case 316:           /* XOR */
4717     case 476:           /* NAND */
4718     case 412:           /* OR with Complement */
4719     case 444:           /* OR */
4720     case 536:           /* Shift Right Word */
4721     case 539:           /* Shift Right Doubleword */
4722     case 922:           /* Extend Sign Halfword */
4723     case 954:           /* Extend Sign Byte */
4724     case 986:           /* Extend Sign Word */
4725     case 538:           /* Count Trailing Zeros Word */
4726     case 570:           /* Count Trailing Zeros Doubleword */
4727     case 890:           /* Extend-Sign Word and Shift Left Immediate (445) */
4728     case 890 | 1:       /* Extend-Sign Word and Shift Left Immediate (445) */
4729
4730       if (ext == 444 && tdep->ppc_ppr_regnum >= 0
4731           && (PPC_RS (insn) == PPC_RA (insn))
4732           && (PPC_RA (insn) == PPC_RB (insn))
4733           && !PPC_RC (insn))
4734         {
4735           /* or Rx,Rx,Rx alters PRI in PPR.  */
4736           record_full_arch_list_add_reg (regcache, tdep->ppc_ppr_regnum);
4737           return 0;
4738         }
4739
4740       if (PPC_RC (insn))
4741         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4742       record_full_arch_list_add_reg (regcache,
4743                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4744       return 0;
4745
4746     /* Store memory.  */
4747     case 181:           /* Store Doubleword with Update Indexed */
4748     case 183:           /* Store Word with Update Indexed */
4749     case 247:           /* Store Byte with Update Indexed */
4750     case 439:           /* Store Half Word with Update Indexed */
4751     case 695:           /* Store Floating-Point Single with Update Indexed */
4752     case 759:           /* Store Floating-Point Double with Update Indexed */
4753       record_full_arch_list_add_reg (regcache,
4754                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4755       /* FALL-THROUGH */
4756     case 135:           /* Store Vector Element Byte Indexed */
4757     case 167:           /* Store Vector Element Halfword Indexed */
4758     case 199:           /* Store Vector Element Word Indexed */
4759     case 231:           /* Store Vector Indexed */
4760     case 487:           /* Store Vector Indexed LRU */
4761     case 716:           /* Store VSX Scalar Doubleword Indexed */
4762     case 140:           /* Store VSX Scalar as Integer Word Indexed */
4763     case 652:           /* Store VSX Scalar Single-Precision Indexed */
4764     case 972:           /* Store VSX Vector Doubleword*2 Indexed */
4765     case 908:           /* Store VSX Vector Word*4 Indexed */
4766     case 149:           /* Store Doubleword Indexed */
4767     case 151:           /* Store Word Indexed */
4768     case 215:           /* Store Byte Indexed */
4769     case 407:           /* Store Half Word Indexed */
4770     case 694:           /* Store Byte Conditional Indexed */
4771     case 726:           /* Store Halfword Conditional Indexed */
4772     case 150:           /* Store Word Conditional Indexed */
4773     case 214:           /* Store Doubleword Conditional Indexed */
4774     case 182:           /* Store Quadword Conditional Indexed */
4775     case 662:           /* Store Word Byte-Reverse Indexed */
4776     case 918:           /* Store Halfword Byte-Reverse Indexed */
4777     case 660:           /* Store Doubleword Byte-Reverse Indexed */
4778     case 663:           /* Store Floating-Point Single Indexed */
4779     case 727:           /* Store Floating-Point Double Indexed */
4780     case 919:           /* Store Floating-Point Double Pair Indexed */
4781     case 983:           /* Store Floating-Point as Integer Word Indexed */
4782     case 396:           /* Store VSX Vector Indexed */
4783     case 940:           /* Store VSX Vector Halfword*8 Indexed */
4784     case 1004:          /* Store VSX Vector Byte*16 Indexed */
4785     case 909:           /* Store VSX Scalar as Integer Byte Indexed */
4786     case 941:           /* Store VSX Scalar as Integer Halfword Indexed */
4787       if (ext == 694 || ext == 726 || ext == 150 || ext == 214 || ext == 182)
4788         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4789
4790       ra = 0;
4791       if (PPC_RA (insn) != 0)
4792         regcache_raw_read_unsigned (regcache,
4793                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4794       regcache_raw_read_unsigned (regcache,
4795                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
4796       ea = ra + rb;
4797
4798       switch (ext)
4799         {
4800         case 183:       /* Store Word with Update Indexed */
4801         case 199:       /* Store Vector Element Word Indexed */
4802         case 140:       /* Store VSX Scalar as Integer Word Indexed */
4803         case 652:       /* Store VSX Scalar Single-Precision Indexed */
4804         case 151:       /* Store Word Indexed */
4805         case 150:       /* Store Word Conditional Indexed */
4806         case 662:       /* Store Word Byte-Reverse Indexed */
4807         case 663:       /* Store Floating-Point Single Indexed */
4808         case 695:       /* Store Floating-Point Single with Update Indexed */
4809         case 983:       /* Store Floating-Point as Integer Word Indexed */
4810           size = 4;
4811           break;
4812         case 247:       /* Store Byte with Update Indexed */
4813         case 135:       /* Store Vector Element Byte Indexed */
4814         case 215:       /* Store Byte Indexed */
4815         case 694:       /* Store Byte Conditional Indexed */
4816         case 909:       /* Store VSX Scalar as Integer Byte Indexed */
4817           size = 1;
4818           break;
4819         case 439:       /* Store Halfword with Update Indexed */
4820         case 167:       /* Store Vector Element Halfword Indexed */
4821         case 407:       /* Store Halfword Indexed */
4822         case 726:       /* Store Halfword Conditional Indexed */
4823         case 918:       /* Store Halfword Byte-Reverse Indexed */
4824         case 941:       /* Store VSX Scalar as Integer Halfword Indexed */
4825           size = 2;
4826           break;
4827         case 181:       /* Store Doubleword with Update Indexed */
4828         case 716:       /* Store VSX Scalar Doubleword Indexed */
4829         case 149:       /* Store Doubleword Indexed */
4830         case 214:       /* Store Doubleword Conditional Indexed */
4831         case 660:       /* Store Doubleword Byte-Reverse Indexed */
4832         case 727:       /* Store Floating-Point Double Indexed */
4833         case 759:       /* Store Floating-Point Double with Update Indexed */
4834           size = 8;
4835           break;
4836         case 972:       /* Store VSX Vector Doubleword*2 Indexed */
4837         case 908:       /* Store VSX Vector Word*4 Indexed */
4838         case 182:       /* Store Quadword Conditional Indexed */
4839         case 231:       /* Store Vector Indexed */
4840         case 487:       /* Store Vector Indexed LRU */
4841         case 919:       /* Store Floating-Point Double Pair Indexed */
4842         case 396:       /* Store VSX Vector Indexed */
4843         case 940:       /* Store VSX Vector Halfword*8 Indexed */
4844         case 1004:      /* Store VSX Vector Byte*16 Indexed */
4845           size = 16;
4846           break;
4847         default:
4848           gdb_assert (0);
4849         }
4850
4851       /* Align address for Store Vector instructions.  */
4852       switch (ext)
4853         {
4854         case 167:       /* Store Vector Element Halfword Indexed */
4855           addr = addr & ~0x1ULL;
4856           break;
4857
4858         case 199:       /* Store Vector Element Word Indexed */
4859           addr = addr & ~0x3ULL;
4860           break;
4861
4862         case 231:       /* Store Vector Indexed */
4863         case 487:       /* Store Vector Indexed LRU */
4864           addr = addr & ~0xfULL;
4865           break;
4866         }
4867
4868       record_full_arch_list_add_mem (addr, size);
4869       return 0;
4870
4871     case 397:           /* Store VSX Vector with Length */
4872     case 429:           /* Store VSX Vector Left-justified with Length */
4873       ra = 0;
4874       if (PPC_RA (insn) != 0)
4875         regcache_raw_read_unsigned (regcache,
4876                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4877       ea = ra;
4878       regcache_raw_read_unsigned (regcache,
4879                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
4880       /* Store up to 16 bytes.  */
4881       nb = (rb & 0xff) > 16 ? 16 : (rb & 0xff);
4882       if (nb > 0)
4883         record_full_arch_list_add_mem (ea, nb);
4884       return 0;
4885
4886     case 710:           /* Store Word Atomic */
4887     case 742:           /* Store Doubleword Atomic */
4888       ra = 0;
4889       if (PPC_RA (insn) != 0)
4890         regcache_raw_read_unsigned (regcache,
4891                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4892       ea = ra;
4893       switch (ext)
4894         {
4895         case 710:       /* Store Word Atomic */
4896           size = 8;
4897           break;
4898         case 742:       /* Store Doubleword Atomic */
4899           size = 16;
4900           break;
4901         default:
4902           gdb_assert (0);
4903         }
4904       record_full_arch_list_add_mem (ea, size);
4905       return 0;
4906
4907     case 725:           /* Store String Word Immediate */
4908       ra = 0;
4909       if (PPC_RA (insn) != 0)
4910         regcache_raw_read_unsigned (regcache,
4911                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4912       ea += ra;
4913
4914       nb = PPC_NB (insn);
4915       if (nb == 0)
4916         nb = 32;
4917
4918       record_full_arch_list_add_mem (ea, nb);
4919
4920       return 0;
4921
4922     case 661:           /* Store String Word Indexed */
4923       ra = 0;
4924       if (PPC_RA (insn) != 0)
4925         regcache_raw_read_unsigned (regcache,
4926                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4927       ea += ra;
4928
4929       regcache_raw_read_unsigned (regcache, tdep->ppc_xer_regnum, &xer);
4930       nb = PPC_XER_NB (xer);
4931
4932       if (nb != 0)
4933         {
4934           regcache_raw_read_unsigned (regcache,
4935                                       tdep->ppc_gp0_regnum + PPC_RB (insn),
4936                                       &rb);
4937           ea += rb;
4938           record_full_arch_list_add_mem (ea, nb);
4939         }
4940
4941       return 0;
4942
4943     case 467:           /* Move To Special Purpose Register */
4944       switch (PPC_SPR (insn))
4945         {
4946         case 1:                 /* XER */
4947           record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4948           return 0;
4949         case 3:                 /* DSCR */
4950           if (tdep->ppc_dscr_regnum >= 0)
4951             record_full_arch_list_add_reg (regcache, tdep->ppc_dscr_regnum);
4952           return 0;
4953         case 8:                 /* LR */
4954           record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
4955           return 0;
4956         case 9:                 /* CTR */
4957           record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
4958           return 0;
4959         case 256:               /* VRSAVE */
4960           record_full_arch_list_add_reg (regcache, tdep->ppc_vrsave_regnum);
4961           return 0;
4962         case 815:               /* TAR */
4963           if (tdep->ppc_tar_regnum >= 0)
4964             record_full_arch_list_add_reg (regcache, tdep->ppc_tar_regnum);
4965           return 0;
4966         case 896:
4967         case 898:               /* PPR */
4968           if (tdep->ppc_ppr_regnum >= 0)
4969             record_full_arch_list_add_reg (regcache, tdep->ppc_ppr_regnum);
4970           return 0;
4971         }
4972
4973       goto UNKNOWN_OP;
4974
4975     case 147:           /* Move To Split Little Endian */
4976       record_full_arch_list_add_reg (regcache, tdep->ppc_ps_regnum);
4977       return 0;
4978
4979     case 512:           /* Move to Condition Register from XER */
4980       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4981       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4982       return 0;
4983
4984     case 4:             /* Trap Word */
4985     case 68:            /* Trap Doubleword */
4986     case 430:           /* Clear BHRB */
4987     case 598:           /* Synchronize */
4988     case 62:            /* Wait for Interrupt */
4989     case 30:            /* Wait */
4990     case 22:            /* Instruction Cache Block Touch */
4991     case 854:           /* Enforce In-order Execution of I/O */
4992     case 246:           /* Data Cache Block Touch for Store */
4993     case 54:            /* Data Cache Block Store */
4994     case 86:            /* Data Cache Block Flush */
4995     case 278:           /* Data Cache Block Touch */
4996     case 758:           /* Data Cache Block Allocate */
4997     case 982:           /* Instruction Cache Block Invalidate */
4998     case 774:           /* Copy */
4999     case 838:           /* CP_Abort */
5000       return 0;
5001
5002     case 654:           /* Transaction Begin */
5003     case 686:           /* Transaction End */
5004     case 750:           /* Transaction Suspend or Resume */
5005     case 782:           /* Transaction Abort Word Conditional */
5006     case 814:           /* Transaction Abort Doubleword Conditional */
5007     case 846:           /* Transaction Abort Word Conditional Immediate */
5008     case 878:           /* Transaction Abort Doubleword Conditional Immediate */
5009     case 910:           /* Transaction Abort */
5010       record_full_arch_list_add_reg (regcache, tdep->ppc_ps_regnum);
5011       /* FALL-THROUGH */
5012     case 718:           /* Transaction Check */
5013       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5014       return 0;
5015
5016     case 1014:          /* Data Cache Block set to Zero */
5017       if (target_auxv_search (current_top_target (), AT_DCACHEBSIZE, &at_dcsz) <= 0
5018           || at_dcsz == 0)
5019         at_dcsz = 128; /* Assume 128-byte cache line size (POWER8)  */
5020
5021       ra = 0;
5022       if (PPC_RA (insn) != 0)
5023         regcache_raw_read_unsigned (regcache,
5024                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
5025       regcache_raw_read_unsigned (regcache,
5026                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
5027       ea = (ra + rb) & ~((ULONGEST) (at_dcsz - 1));
5028       record_full_arch_list_add_mem (ea, at_dcsz);
5029       return 0;
5030     }
5031
5032 UNKNOWN_OP:
5033   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5034                       "at %s, 31-%d.\n", insn, paddress (gdbarch, addr), ext);
5035   return -1;
5036 }
5037
5038 /* Parse and record instructions of primary opcode-59 at ADDR.
5039    Return 0 if successful.  */
5040
5041 static int
5042 ppc_process_record_op59 (struct gdbarch *gdbarch, struct regcache *regcache,
5043                            CORE_ADDR addr, uint32_t insn)
5044 {
5045   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5046   int ext = PPC_EXTOP (insn);
5047
5048   switch (ext & 0x1f)
5049     {
5050     case 18:            /* Floating Divide */
5051     case 20:            /* Floating Subtract */
5052     case 21:            /* Floating Add */
5053     case 22:            /* Floating Square Root */
5054     case 24:            /* Floating Reciprocal Estimate */
5055     case 25:            /* Floating Multiply */
5056     case 26:            /* Floating Reciprocal Square Root Estimate */
5057     case 28:            /* Floating Multiply-Subtract */
5058     case 29:            /* Floating Multiply-Add */
5059     case 30:            /* Floating Negative Multiply-Subtract */
5060     case 31:            /* Floating Negative Multiply-Add */
5061       record_full_arch_list_add_reg (regcache,
5062                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5063       if (PPC_RC (insn))
5064         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5065       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5066
5067       return 0;
5068     }
5069
5070   switch (ext)
5071     {
5072     case 2:             /* DFP Add */
5073     case 3:             /* DFP Quantize */
5074     case 34:            /* DFP Multiply */
5075     case 35:            /* DFP Reround */
5076     case 67:            /* DFP Quantize Immediate */
5077     case 99:            /* DFP Round To FP Integer With Inexact */
5078     case 227:           /* DFP Round To FP Integer Without Inexact */
5079     case 258:           /* DFP Convert To DFP Long! */
5080     case 290:           /* DFP Convert To Fixed */
5081     case 514:           /* DFP Subtract */
5082     case 546:           /* DFP Divide */
5083     case 770:           /* DFP Round To DFP Short! */
5084     case 802:           /* DFP Convert From Fixed */
5085     case 834:           /* DFP Encode BCD To DPD */
5086       if (PPC_RC (insn))
5087         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5088       record_full_arch_list_add_reg (regcache,
5089                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5090       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5091       return 0;
5092
5093     case 130:           /* DFP Compare Ordered */
5094     case 162:           /* DFP Test Exponent */
5095     case 194:           /* DFP Test Data Class */
5096     case 226:           /* DFP Test Data Group */
5097     case 642:           /* DFP Compare Unordered */
5098     case 674:           /* DFP Test Significance */
5099     case 675:           /* DFP Test Significance Immediate */
5100       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5101       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5102       return 0;
5103
5104     case 66:            /* DFP Shift Significand Left Immediate */
5105     case 98:            /* DFP Shift Significand Right Immediate */
5106     case 322:           /* DFP Decode DPD To BCD */
5107     case 354:           /* DFP Extract Biased Exponent */
5108     case 866:           /* DFP Insert Biased Exponent */
5109       record_full_arch_list_add_reg (regcache,
5110                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5111       if (PPC_RC (insn))
5112         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5113       return 0;
5114
5115     case 846:           /* Floating Convert From Integer Doubleword Single */
5116     case 974:           /* Floating Convert From Integer Doubleword Unsigned
5117                            Single */
5118       record_full_arch_list_add_reg (regcache,
5119                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5120       if (PPC_RC (insn))
5121         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5122       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5123
5124       return 0;
5125     }
5126
5127   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5128                       "at %s, 59-%d.\n", insn, paddress (gdbarch, addr), ext);
5129   return -1;
5130 }
5131
5132 /* Parse and record instructions of primary opcode-60 at ADDR.
5133    Return 0 if successful.  */
5134
5135 static int
5136 ppc_process_record_op60 (struct gdbarch *gdbarch, struct regcache *regcache,
5137                            CORE_ADDR addr, uint32_t insn)
5138 {
5139   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5140   int ext = PPC_EXTOP (insn);
5141
5142   switch (ext >> 2)
5143     {
5144     case 0:             /* VSX Scalar Add Single-Precision */
5145     case 32:            /* VSX Scalar Add Double-Precision */
5146     case 24:            /* VSX Scalar Divide Single-Precision */
5147     case 56:            /* VSX Scalar Divide Double-Precision */
5148     case 176:           /* VSX Scalar Copy Sign Double-Precision */
5149     case 33:            /* VSX Scalar Multiply-Add Double-Precision */
5150     case 41:            /* ditto */
5151     case 1:             /* VSX Scalar Multiply-Add Single-Precision */
5152     case 9:             /* ditto */
5153     case 160:           /* VSX Scalar Maximum Double-Precision */
5154     case 168:           /* VSX Scalar Minimum Double-Precision */
5155     case 49:            /* VSX Scalar Multiply-Subtract Double-Precision */
5156     case 57:            /* ditto */
5157     case 17:            /* VSX Scalar Multiply-Subtract Single-Precision */
5158     case 25:            /* ditto */
5159     case 48:            /* VSX Scalar Multiply Double-Precision */
5160     case 16:            /* VSX Scalar Multiply Single-Precision */
5161     case 161:           /* VSX Scalar Negative Multiply-Add Double-Precision */
5162     case 169:           /* ditto */
5163     case 129:           /* VSX Scalar Negative Multiply-Add Single-Precision */
5164     case 137:           /* ditto */
5165     case 177:           /* VSX Scalar Negative Multiply-Subtract Double-Precision */
5166     case 185:           /* ditto */
5167     case 145:           /* VSX Scalar Negative Multiply-Subtract Single-Precision */
5168     case 153:           /* ditto */
5169     case 40:            /* VSX Scalar Subtract Double-Precision */
5170     case 8:             /* VSX Scalar Subtract Single-Precision */
5171     case 96:            /* VSX Vector Add Double-Precision */
5172     case 64:            /* VSX Vector Add Single-Precision */
5173     case 120:           /* VSX Vector Divide Double-Precision */
5174     case 88:            /* VSX Vector Divide Single-Precision */
5175     case 97:            /* VSX Vector Multiply-Add Double-Precision */
5176     case 105:           /* ditto */
5177     case 65:            /* VSX Vector Multiply-Add Single-Precision */
5178     case 73:            /* ditto */
5179     case 224:           /* VSX Vector Maximum Double-Precision */
5180     case 192:           /* VSX Vector Maximum Single-Precision */
5181     case 232:           /* VSX Vector Minimum Double-Precision */
5182     case 200:           /* VSX Vector Minimum Single-Precision */
5183     case 113:           /* VSX Vector Multiply-Subtract Double-Precision */
5184     case 121:           /* ditto */
5185     case 81:            /* VSX Vector Multiply-Subtract Single-Precision */
5186     case 89:            /* ditto */
5187     case 112:           /* VSX Vector Multiply Double-Precision */
5188     case 80:            /* VSX Vector Multiply Single-Precision */
5189     case 225:           /* VSX Vector Negative Multiply-Add Double-Precision */
5190     case 233:           /* ditto */
5191     case 193:           /* VSX Vector Negative Multiply-Add Single-Precision */
5192     case 201:           /* ditto */
5193     case 241:           /* VSX Vector Negative Multiply-Subtract Double-Precision */
5194     case 249:           /* ditto */
5195     case 209:           /* VSX Vector Negative Multiply-Subtract Single-Precision */
5196     case 217:           /* ditto */
5197     case 104:           /* VSX Vector Subtract Double-Precision */
5198     case 72:            /* VSX Vector Subtract Single-Precision */
5199     case 128:           /* VSX Scalar Maximum Type-C Double-Precision */
5200     case 136:           /* VSX Scalar Minimum Type-C Double-Precision */
5201     case 144:           /* VSX Scalar Maximum Type-J Double-Precision */
5202     case 152:           /* VSX Scalar Minimum Type-J Double-Precision */
5203     case 3:             /* VSX Scalar Compare Equal Double-Precision */
5204     case 11:            /* VSX Scalar Compare Greater Than Double-Precision */
5205     case 19:            /* VSX Scalar Compare Greater Than or Equal
5206                            Double-Precision */
5207       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5208       /* FALL-THROUGH */
5209     case 240:           /* VSX Vector Copy Sign Double-Precision */
5210     case 208:           /* VSX Vector Copy Sign Single-Precision */
5211     case 130:           /* VSX Logical AND */
5212     case 138:           /* VSX Logical AND with Complement */
5213     case 186:           /* VSX Logical Equivalence */
5214     case 178:           /* VSX Logical NAND */
5215     case 170:           /* VSX Logical OR with Complement */
5216     case 162:           /* VSX Logical NOR */
5217     case 146:           /* VSX Logical OR */
5218     case 154:           /* VSX Logical XOR */
5219     case 18:            /* VSX Merge High Word */
5220     case 50:            /* VSX Merge Low Word */
5221     case 10:            /* VSX Permute Doubleword Immediate (DM=0) */
5222     case 10 | 0x20:     /* VSX Permute Doubleword Immediate (DM=1) */
5223     case 10 | 0x40:     /* VSX Permute Doubleword Immediate (DM=2) */
5224     case 10 | 0x60:     /* VSX Permute Doubleword Immediate (DM=3) */
5225     case 2:             /* VSX Shift Left Double by Word Immediate (SHW=0) */
5226     case 2 | 0x20:      /* VSX Shift Left Double by Word Immediate (SHW=1) */
5227     case 2 | 0x40:      /* VSX Shift Left Double by Word Immediate (SHW=2) */
5228     case 2 | 0x60:      /* VSX Shift Left Double by Word Immediate (SHW=3) */
5229     case 216:           /* VSX Vector Insert Exponent Single-Precision */
5230     case 248:           /* VSX Vector Insert Exponent Double-Precision */
5231     case 26:            /* VSX Vector Permute */
5232     case 58:            /* VSX Vector Permute Right-indexed */
5233     case 213:           /* VSX Vector Test Data Class Single-Precision (DC=0) */
5234     case 213 | 0x8:     /* VSX Vector Test Data Class Single-Precision (DC=1) */
5235     case 245:           /* VSX Vector Test Data Class Double-Precision (DC=0) */
5236     case 245 | 0x8:     /* VSX Vector Test Data Class Double-Precision (DC=1) */
5237       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5238       return 0;
5239
5240     case 61:            /* VSX Scalar Test for software Divide Double-Precision */
5241     case 125:           /* VSX Vector Test for software Divide Double-Precision */
5242     case 93:            /* VSX Vector Test for software Divide Single-Precision */
5243       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5244       return 0;
5245
5246     case 35:            /* VSX Scalar Compare Unordered Double-Precision */
5247     case 43:            /* VSX Scalar Compare Ordered Double-Precision */
5248     case 59:            /* VSX Scalar Compare Exponents Double-Precision */
5249       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5250       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5251       return 0;
5252     }
5253
5254   switch ((ext >> 2) & 0x7f) /* Mask out Rc-bit.  */
5255     {
5256     case 99:            /* VSX Vector Compare Equal To Double-Precision */
5257     case 67:            /* VSX Vector Compare Equal To Single-Precision */
5258     case 115:           /* VSX Vector Compare Greater Than or
5259                            Equal To Double-Precision */
5260     case 83:            /* VSX Vector Compare Greater Than or
5261                            Equal To Single-Precision */
5262     case 107:           /* VSX Vector Compare Greater Than Double-Precision */
5263     case 75:            /* VSX Vector Compare Greater Than Single-Precision */
5264       if (PPC_Rc (insn))
5265         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5266       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5267       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5268       return 0;
5269     }
5270
5271   switch (ext >> 1)
5272     {
5273     case 265:           /* VSX Scalar round Double-Precision to
5274                            Single-Precision and Convert to
5275                            Single-Precision format */
5276     case 344:           /* VSX Scalar truncate Double-Precision to
5277                            Integer and Convert to Signed Integer
5278                            Doubleword format with Saturate */
5279     case 88:            /* VSX Scalar truncate Double-Precision to
5280                            Integer and Convert to Signed Integer Word
5281                            Format with Saturate */
5282     case 328:           /* VSX Scalar truncate Double-Precision integer
5283                            and Convert to Unsigned Integer Doubleword
5284                            Format with Saturate */
5285     case 72:            /* VSX Scalar truncate Double-Precision to
5286                            Integer and Convert to Unsigned Integer Word
5287                            Format with Saturate */
5288     case 329:           /* VSX Scalar Convert Single-Precision to
5289                            Double-Precision format */
5290     case 376:           /* VSX Scalar Convert Signed Integer
5291                            Doubleword to floating-point format and
5292                            Round to Double-Precision format */
5293     case 312:           /* VSX Scalar Convert Signed Integer
5294                            Doubleword to floating-point format and
5295                            round to Single-Precision */
5296     case 360:           /* VSX Scalar Convert Unsigned Integer
5297                            Doubleword to floating-point format and
5298                            Round to Double-Precision format */
5299     case 296:           /* VSX Scalar Convert Unsigned Integer
5300                            Doubleword to floating-point format and
5301                            Round to Single-Precision */
5302     case 73:            /* VSX Scalar Round to Double-Precision Integer
5303                            Using Round to Nearest Away */
5304     case 107:           /* VSX Scalar Round to Double-Precision Integer
5305                            Exact using Current rounding mode */
5306     case 121:           /* VSX Scalar Round to Double-Precision Integer
5307                            Using Round toward -Infinity */
5308     case 105:           /* VSX Scalar Round to Double-Precision Integer
5309                            Using Round toward +Infinity */
5310     case 89:            /* VSX Scalar Round to Double-Precision Integer
5311                            Using Round toward Zero */
5312     case 90:            /* VSX Scalar Reciprocal Estimate Double-Precision */
5313     case 26:            /* VSX Scalar Reciprocal Estimate Single-Precision */
5314     case 281:           /* VSX Scalar Round to Single-Precision */
5315     case 74:            /* VSX Scalar Reciprocal Square Root Estimate
5316                            Double-Precision */
5317     case 10:            /* VSX Scalar Reciprocal Square Root Estimate
5318                            Single-Precision */
5319     case 75:            /* VSX Scalar Square Root Double-Precision */
5320     case 11:            /* VSX Scalar Square Root Single-Precision */
5321     case 393:           /* VSX Vector round Double-Precision to
5322                            Single-Precision and Convert to
5323                            Single-Precision format */
5324     case 472:           /* VSX Vector truncate Double-Precision to
5325                            Integer and Convert to Signed Integer
5326                            Doubleword format with Saturate */
5327     case 216:           /* VSX Vector truncate Double-Precision to
5328                            Integer and Convert to Signed Integer Word
5329                            Format with Saturate */
5330     case 456:           /* VSX Vector truncate Double-Precision to
5331                            Integer and Convert to Unsigned Integer
5332                            Doubleword format with Saturate */
5333     case 200:           /* VSX Vector truncate Double-Precision to
5334                            Integer and Convert to Unsigned Integer Word
5335                            Format with Saturate */
5336     case 457:           /* VSX Vector Convert Single-Precision to
5337                            Double-Precision format */
5338     case 408:           /* VSX Vector truncate Single-Precision to
5339                            Integer and Convert to Signed Integer
5340                            Doubleword format with Saturate */
5341     case 152:           /* VSX Vector truncate Single-Precision to
5342                            Integer and Convert to Signed Integer Word
5343                            Format with Saturate */
5344     case 392:           /* VSX Vector truncate Single-Precision to
5345                            Integer and Convert to Unsigned Integer
5346                            Doubleword format with Saturate */
5347     case 136:           /* VSX Vector truncate Single-Precision to
5348                            Integer and Convert to Unsigned Integer Word
5349                            Format with Saturate */
5350     case 504:           /* VSX Vector Convert and round Signed Integer
5351                            Doubleword to Double-Precision format */
5352     case 440:           /* VSX Vector Convert and round Signed Integer
5353                            Doubleword to Single-Precision format */
5354     case 248:           /* VSX Vector Convert Signed Integer Word to
5355                            Double-Precision format */
5356     case 184:           /* VSX Vector Convert and round Signed Integer
5357                            Word to Single-Precision format */
5358     case 488:           /* VSX Vector Convert and round Unsigned
5359                            Integer Doubleword to Double-Precision format */
5360     case 424:           /* VSX Vector Convert and round Unsigned
5361                            Integer Doubleword to Single-Precision format */
5362     case 232:           /* VSX Vector Convert and round Unsigned
5363                            Integer Word to Double-Precision format */
5364     case 168:           /* VSX Vector Convert and round Unsigned
5365                            Integer Word to Single-Precision format */
5366     case 201:           /* VSX Vector Round to Double-Precision
5367                            Integer using round to Nearest Away */
5368     case 235:           /* VSX Vector Round to Double-Precision
5369                            Integer Exact using Current rounding mode */
5370     case 249:           /* VSX Vector Round to Double-Precision
5371                            Integer using round toward -Infinity */
5372     case 233:           /* VSX Vector Round to Double-Precision
5373                            Integer using round toward +Infinity */
5374     case 217:           /* VSX Vector Round to Double-Precision
5375                            Integer using round toward Zero */
5376     case 218:           /* VSX Vector Reciprocal Estimate Double-Precision */
5377     case 154:           /* VSX Vector Reciprocal Estimate Single-Precision */
5378     case 137:           /* VSX Vector Round to Single-Precision Integer
5379                            Using Round to Nearest Away */
5380     case 171:           /* VSX Vector Round to Single-Precision Integer
5381                            Exact Using Current rounding mode */
5382     case 185:           /* VSX Vector Round to Single-Precision Integer
5383                            Using Round toward -Infinity */
5384     case 169:           /* VSX Vector Round to Single-Precision Integer
5385                            Using Round toward +Infinity */
5386     case 153:           /* VSX Vector Round to Single-Precision Integer
5387                            Using round toward Zero */
5388     case 202:           /* VSX Vector Reciprocal Square Root Estimate
5389                            Double-Precision */
5390     case 138:           /* VSX Vector Reciprocal Square Root Estimate
5391                            Single-Precision */
5392     case 203:           /* VSX Vector Square Root Double-Precision */
5393     case 139:           /* VSX Vector Square Root Single-Precision */
5394       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5395       /* FALL-THROUGH */
5396     case 345:           /* VSX Scalar Absolute Value Double-Precision */
5397     case 267:           /* VSX Scalar Convert Scalar Single-Precision to
5398                            Vector Single-Precision format Non-signalling */
5399     case 331:           /* VSX Scalar Convert Single-Precision to
5400                            Double-Precision format Non-signalling */
5401     case 361:           /* VSX Scalar Negative Absolute Value Double-Precision */
5402     case 377:           /* VSX Scalar Negate Double-Precision */
5403     case 473:           /* VSX Vector Absolute Value Double-Precision */
5404     case 409:           /* VSX Vector Absolute Value Single-Precision */
5405     case 489:           /* VSX Vector Negative Absolute Value Double-Precision */
5406     case 425:           /* VSX Vector Negative Absolute Value Single-Precision */
5407     case 505:           /* VSX Vector Negate Double-Precision */
5408     case 441:           /* VSX Vector Negate Single-Precision */
5409     case 164:           /* VSX Splat Word */
5410     case 165:           /* VSX Vector Extract Unsigned Word */
5411     case 181:           /* VSX Vector Insert Word */
5412       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5413       return 0;
5414
5415     case 298:           /* VSX Scalar Test Data Class Single-Precision */
5416     case 362:           /* VSX Scalar Test Data Class Double-Precision */
5417       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5418       /* FALL-THROUGH */
5419     case 106:           /* VSX Scalar Test for software Square Root
5420                            Double-Precision */
5421     case 234:           /* VSX Vector Test for software Square Root
5422                            Double-Precision */
5423     case 170:           /* VSX Vector Test for software Square Root
5424                            Single-Precision */
5425       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5426       return 0;
5427
5428     case 347:
5429       switch (PPC_FIELD (insn, 11, 5))
5430         {
5431         case 0:         /* VSX Scalar Extract Exponent Double-Precision */
5432         case 1:         /* VSX Scalar Extract Significand Double-Precision */
5433           record_full_arch_list_add_reg (regcache,
5434                                          tdep->ppc_gp0_regnum + PPC_RT (insn));
5435           return 0;
5436         case 16:        /* VSX Scalar Convert Half-Precision format to
5437                            Double-Precision format */
5438         case 17:        /* VSX Scalar round & Convert Double-Precision format
5439                            to Half-Precision format */
5440           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5441           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5442           return 0;
5443         }
5444       break;
5445
5446     case 475:
5447       switch (PPC_FIELD (insn, 11, 5))
5448         {
5449         case 24:        /* VSX Vector Convert Half-Precision format to
5450                            Single-Precision format */
5451         case 25:        /* VSX Vector round and Convert Single-Precision format
5452                            to Half-Precision format */
5453           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5454           /* FALL-THROUGH */
5455         case 0:         /* VSX Vector Extract Exponent Double-Precision */
5456         case 1:         /* VSX Vector Extract Significand Double-Precision */
5457         case 7:         /* VSX Vector Byte-Reverse Halfword */
5458         case 8:         /* VSX Vector Extract Exponent Single-Precision */
5459         case 9:         /* VSX Vector Extract Significand Single-Precision */
5460         case 15:        /* VSX Vector Byte-Reverse Word */
5461         case 23:        /* VSX Vector Byte-Reverse Doubleword */
5462         case 31:        /* VSX Vector Byte-Reverse Quadword */
5463           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5464           return 0;
5465         }
5466       break;
5467     }
5468
5469   switch (ext)
5470     {
5471     case 360:           /* VSX Vector Splat Immediate Byte */
5472       if (PPC_FIELD (insn, 11, 2) == 0)
5473         {
5474           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5475           return 0;
5476         }
5477       break;
5478     case 918:           /* VSX Scalar Insert Exponent Double-Precision */
5479       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5480       return 0;
5481     }
5482
5483   if (((ext >> 3) & 0x3) == 3)  /* VSX Select */
5484     {
5485       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5486       return 0;
5487     }
5488
5489   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5490                       "at %s, 60-%d.\n", insn, paddress (gdbarch, addr), ext);
5491   return -1;
5492 }
5493
5494 /* Parse and record instructions of primary opcode-61 at ADDR.
5495    Return 0 if successful.  */
5496
5497 static int
5498 ppc_process_record_op61 (struct gdbarch *gdbarch, struct regcache *regcache,
5499                            CORE_ADDR addr, uint32_t insn)
5500 {
5501   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5502   ULONGEST ea = 0;
5503   int size;
5504
5505   switch (insn & 0x3)
5506     {
5507     case 0:             /* Store Floating-Point Double Pair */
5508     case 2:             /* Store VSX Scalar Doubleword */
5509     case 3:             /* Store VSX Scalar Single */
5510       if (PPC_RA (insn) != 0)
5511         regcache_raw_read_unsigned (regcache,
5512                                     tdep->ppc_gp0_regnum + PPC_RA (insn),
5513                                     &ea);
5514       ea += PPC_DS (insn) << 2;
5515       switch (insn & 0x3)
5516         {
5517         case 0:         /* Store Floating-Point Double Pair */
5518           size = 16;
5519           break;
5520         case 2:         /* Store VSX Scalar Doubleword */
5521           size = 8;
5522           break;
5523         case 3:         /* Store VSX Scalar Single */
5524           size = 4;
5525           break;
5526         default:
5527           gdb_assert (0);
5528         }
5529       record_full_arch_list_add_mem (ea, size);
5530       return 0;
5531     }
5532
5533   switch (insn & 0x7)
5534     {
5535     case 1:             /* Load VSX Vector */
5536       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5537       return 0;
5538     case 5:             /* Store VSX Vector */
5539       if (PPC_RA (insn) != 0)
5540         regcache_raw_read_unsigned (regcache,
5541                                     tdep->ppc_gp0_regnum + PPC_RA (insn),
5542                                     &ea);
5543       ea += PPC_DQ (insn) << 4;
5544       record_full_arch_list_add_mem (ea, 16);
5545       return 0;
5546     }
5547
5548   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5549                       "at %s.\n", insn, paddress (gdbarch, addr));
5550   return -1;
5551 }
5552
5553 /* Parse and record instructions of primary opcode-63 at ADDR.
5554    Return 0 if successful.  */
5555
5556 static int
5557 ppc_process_record_op63 (struct gdbarch *gdbarch, struct regcache *regcache,
5558                            CORE_ADDR addr, uint32_t insn)
5559 {
5560   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5561   int ext = PPC_EXTOP (insn);
5562   int tmp;
5563
5564   switch (ext & 0x1f)
5565     {
5566     case 18:            /* Floating Divide */
5567     case 20:            /* Floating Subtract */
5568     case 21:            /* Floating Add */
5569     case 22:            /* Floating Square Root */
5570     case 24:            /* Floating Reciprocal Estimate */
5571     case 25:            /* Floating Multiply */
5572     case 26:            /* Floating Reciprocal Square Root Estimate */
5573     case 28:            /* Floating Multiply-Subtract */
5574     case 29:            /* Floating Multiply-Add */
5575     case 30:            /* Floating Negative Multiply-Subtract */
5576     case 31:            /* Floating Negative Multiply-Add */
5577       record_full_arch_list_add_reg (regcache,
5578                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5579       if (PPC_RC (insn))
5580         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5581       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5582       return 0;
5583
5584     case 23:            /* Floating Select */
5585       record_full_arch_list_add_reg (regcache,
5586                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5587       if (PPC_RC (insn))
5588         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5589       return 0;
5590     }
5591
5592   switch (ext & 0xff)
5593     {
5594     case 5:             /* VSX Scalar Round to Quad-Precision Integer */
5595     case 37:            /* VSX Scalar Round Quad-Precision to Double-Extended
5596                            Precision */
5597       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5598       ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5599       return 0;
5600     }
5601
5602   switch (ext)
5603     {
5604     case 2:             /* DFP Add Quad */
5605     case 3:             /* DFP Quantize Quad */
5606     case 34:            /* DFP Multiply Quad */
5607     case 35:            /* DFP Reround Quad */
5608     case 67:            /* DFP Quantize Immediate Quad */
5609     case 99:            /* DFP Round To FP Integer With Inexact Quad */
5610     case 227:           /* DFP Round To FP Integer Without Inexact Quad */
5611     case 258:           /* DFP Convert To DFP Extended Quad */
5612     case 514:           /* DFP Subtract Quad */
5613     case 546:           /* DFP Divide Quad */
5614     case 770:           /* DFP Round To DFP Long Quad */
5615     case 802:           /* DFP Convert From Fixed Quad */
5616     case 834:           /* DFP Encode BCD To DPD Quad */
5617       if (PPC_RC (insn))
5618         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5619       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
5620       record_full_arch_list_add_reg (regcache, tmp);
5621       record_full_arch_list_add_reg (regcache, tmp + 1);
5622       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5623       return 0;
5624
5625     case 130:           /* DFP Compare Ordered Quad */
5626     case 162:           /* DFP Test Exponent Quad */
5627     case 194:           /* DFP Test Data Class Quad */
5628     case 226:           /* DFP Test Data Group Quad */
5629     case 642:           /* DFP Compare Unordered Quad */
5630     case 674:           /* DFP Test Significance Quad */
5631     case 675:           /* DFP Test Significance Immediate Quad */
5632       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5633       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5634       return 0;
5635
5636     case 66:            /* DFP Shift Significand Left Immediate Quad */
5637     case 98:            /* DFP Shift Significand Right Immediate Quad */
5638     case 322:           /* DFP Decode DPD To BCD Quad */
5639     case 866:           /* DFP Insert Biased Exponent Quad */
5640       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
5641       record_full_arch_list_add_reg (regcache, tmp);
5642       record_full_arch_list_add_reg (regcache, tmp + 1);
5643       if (PPC_RC (insn))
5644         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5645       return 0;
5646
5647     case 290:           /* DFP Convert To Fixed Quad */
5648       record_full_arch_list_add_reg (regcache,
5649                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5650       if (PPC_RC (insn))
5651         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5652       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5653       return 0;
5654
5655     case 354:           /* DFP Extract Biased Exponent Quad */
5656       record_full_arch_list_add_reg (regcache,
5657                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5658       if (PPC_RC (insn))
5659         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5660       return 0;
5661
5662     case 12:            /* Floating Round to Single-Precision */
5663     case 14:            /* Floating Convert To Integer Word */
5664     case 15:            /* Floating Convert To Integer Word
5665                            with round toward Zero */
5666     case 142:           /* Floating Convert To Integer Word Unsigned */
5667     case 143:           /* Floating Convert To Integer Word Unsigned
5668                            with round toward Zero */
5669     case 392:           /* Floating Round to Integer Nearest */
5670     case 424:           /* Floating Round to Integer Toward Zero */
5671     case 456:           /* Floating Round to Integer Plus */
5672     case 488:           /* Floating Round to Integer Minus */
5673     case 814:           /* Floating Convert To Integer Doubleword */
5674     case 815:           /* Floating Convert To Integer Doubleword
5675                            with round toward Zero */
5676     case 846:           /* Floating Convert From Integer Doubleword */
5677     case 942:           /* Floating Convert To Integer Doubleword Unsigned */
5678     case 943:           /* Floating Convert To Integer Doubleword Unsigned
5679                            with round toward Zero */
5680     case 974:           /* Floating Convert From Integer Doubleword Unsigned */
5681       record_full_arch_list_add_reg (regcache,
5682                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5683       if (PPC_RC (insn))
5684         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5685       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5686       return 0;
5687
5688     case 583:
5689       switch (PPC_FIELD (insn, 11, 5))
5690         {
5691           case 1:       /* Move From FPSCR & Clear Enables */
5692           case 20:      /* Move From FPSCR Control & set DRN */
5693           case 21:      /* Move From FPSCR Control & set DRN Immediate */
5694           case 22:      /* Move From FPSCR Control & set RN */
5695           case 23:      /* Move From FPSCR Control & set RN Immediate */
5696             record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5697             /* Fall through.  */
5698           case 0:       /* Move From FPSCR */
5699           case 24:      /* Move From FPSCR Lightweight */
5700             if (PPC_FIELD (insn, 11, 5) == 0 && PPC_RC (insn))
5701               record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5702             record_full_arch_list_add_reg (regcache,
5703                                            tdep->ppc_fp0_regnum
5704                                            + PPC_FRT (insn));
5705             return 0;
5706         }
5707       break;
5708
5709     case 8:             /* Floating Copy Sign */
5710     case 40:            /* Floating Negate */
5711     case 72:            /* Floating Move Register */
5712     case 136:           /* Floating Negative Absolute Value */
5713     case 264:           /* Floating Absolute Value */
5714       record_full_arch_list_add_reg (regcache,
5715                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5716       if (PPC_RC (insn))
5717         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5718       return 0;
5719
5720     case 838:           /* Floating Merge Odd Word */
5721     case 966:           /* Floating Merge Even Word */
5722       record_full_arch_list_add_reg (regcache,
5723                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5724       return 0;
5725
5726     case 38:            /* Move To FPSCR Bit 1 */
5727     case 70:            /* Move To FPSCR Bit 0 */
5728     case 134:           /* Move To FPSCR Field Immediate */
5729     case 711:           /* Move To FPSCR Fields */
5730       if (PPC_RC (insn))
5731         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5732       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5733       return 0;
5734
5735     case 0:             /* Floating Compare Unordered */
5736     case 32:            /* Floating Compare Ordered */
5737     case 64:            /* Move to Condition Register from FPSCR */
5738     case 132:           /* VSX Scalar Compare Ordered Quad-Precision */
5739     case 164:           /* VSX Scalar Compare Exponents Quad-Precision */
5740     case 644:           /* VSX Scalar Compare Unordered Quad-Precision */
5741     case 708:           /* VSX Scalar Test Data Class Quad-Precision */
5742       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5743       /* FALL-THROUGH */
5744     case 128:           /* Floating Test for software Divide */
5745     case 160:           /* Floating Test for software Square Root */
5746       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5747       return 0;
5748
5749     case 4:             /* VSX Scalar Add Quad-Precision */
5750     case 36:            /* VSX Scalar Multiply Quad-Precision */
5751     case 388:           /* VSX Scalar Multiply-Add Quad-Precision */
5752     case 420:           /* VSX Scalar Multiply-Subtract Quad-Precision */
5753     case 452:           /* VSX Scalar Negative Multiply-Add Quad-Precision */
5754     case 484:           /* VSX Scalar Negative Multiply-Subtract
5755                            Quad-Precision */
5756     case 516:           /* VSX Scalar Subtract Quad-Precision */
5757     case 548:           /* VSX Scalar Divide Quad-Precision */
5758       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5759       /* FALL-THROUGH */
5760     case 100:           /* VSX Scalar Copy Sign Quad-Precision */
5761     case 868:           /* VSX Scalar Insert Exponent Quad-Precision */
5762       ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5763       return 0;
5764
5765     case 804:
5766       switch (PPC_FIELD (insn, 11, 5))
5767         {
5768         case 27:        /* VSX Scalar Square Root Quad-Precision */
5769           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5770           /* FALL-THROUGH */
5771         case 0:         /* VSX Scalar Absolute Quad-Precision */
5772         case 2:         /* VSX Scalar Extract Exponent Quad-Precision */
5773         case 8:         /* VSX Scalar Negative Absolute Quad-Precision */
5774         case 16:        /* VSX Scalar Negate Quad-Precision */
5775         case 18:        /* VSX Scalar Extract Significand Quad-Precision */
5776           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5777           return 0;
5778         }
5779       break;
5780
5781     case 836:
5782       switch (PPC_FIELD (insn, 11, 5))
5783         {
5784         case 1:         /* VSX Scalar truncate & Convert Quad-Precision format
5785                            to Unsigned Word format */
5786         case 2:         /* VSX Scalar Convert Unsigned Doubleword format to
5787                            Quad-Precision format */
5788         case 9:         /* VSX Scalar truncate & Convert Quad-Precision format
5789                            to Signed Word format */
5790         case 10:        /* VSX Scalar Convert Signed Doubleword format to
5791                            Quad-Precision format */
5792         case 17:        /* VSX Scalar truncate & Convert Quad-Precision format
5793                            to Unsigned Doubleword format */
5794         case 20:        /* VSX Scalar round & Convert Quad-Precision format to
5795                            Double-Precision format */
5796         case 22:        /* VSX Scalar Convert Double-Precision format to
5797                            Quad-Precision format */
5798         case 25:        /* VSX Scalar truncate & Convert Quad-Precision format
5799                            to Signed Doubleword format */
5800           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5801           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5802           return 0;
5803         }
5804     }
5805
5806   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5807                       "at %s, 63-%d.\n", insn, paddress (gdbarch, addr), ext);
5808   return -1;
5809 }
5810
5811 /* Parse the current instruction and record the values of the registers and
5812    memory that will be changed in current instruction to "record_arch_list".
5813    Return -1 if something wrong.  */
5814
5815 int
5816 ppc_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
5817                       CORE_ADDR addr)
5818 {
5819   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5820   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5821   uint32_t insn;
5822   int op6, tmp, i;
5823
5824   insn = read_memory_unsigned_integer (addr, 4, byte_order);
5825   op6 = PPC_OP6 (insn);
5826
5827   switch (op6)
5828     {
5829     case 2:             /* Trap Doubleword Immediate */
5830     case 3:             /* Trap Word Immediate */
5831       /* Do nothing.  */
5832       break;
5833
5834     case 4:
5835       if (ppc_process_record_op4 (gdbarch, regcache, addr, insn) != 0)
5836         return -1;
5837       break;
5838
5839     case 17:            /* System call */
5840       if (PPC_LEV (insn) != 0)
5841         goto UNKNOWN_OP;
5842
5843       if (tdep->ppc_syscall_record != NULL)
5844         {
5845           if (tdep->ppc_syscall_record (regcache) != 0)
5846             return -1;
5847         }
5848       else
5849         {
5850           printf_unfiltered (_("no syscall record support\n"));
5851           return -1;
5852         }
5853       break;
5854
5855     case 7:             /* Multiply Low Immediate */
5856       record_full_arch_list_add_reg (regcache,
5857                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5858       break;
5859
5860     case 8:             /* Subtract From Immediate Carrying */
5861       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
5862       record_full_arch_list_add_reg (regcache,
5863                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5864       break;
5865
5866     case 10:            /* Compare Logical Immediate  */
5867     case 11:            /* Compare Immediate */
5868       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5869       break;
5870
5871     case 13:            /* Add Immediate Carrying and Record */
5872       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5873       /* FALL-THROUGH */
5874     case 12:            /* Add Immediate Carrying */
5875       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
5876       /* FALL-THROUGH */
5877     case 14:            /* Add Immediate */
5878     case 15:            /* Add Immediate Shifted */
5879       record_full_arch_list_add_reg (regcache,
5880                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5881       break;
5882
5883     case 16:            /* Branch Conditional */
5884       if ((PPC_BO (insn) & 0x4) == 0)
5885         record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
5886       /* FALL-THROUGH */
5887     case 18:            /* Branch */
5888       if (PPC_LK (insn))
5889         record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
5890       break;
5891
5892     case 19:
5893       if (ppc_process_record_op19 (gdbarch, regcache, addr, insn) != 0)
5894         return -1;
5895       break;
5896
5897     case 20:            /* Rotate Left Word Immediate then Mask Insert */
5898     case 21:            /* Rotate Left Word Immediate then AND with Mask */
5899     case 23:            /* Rotate Left Word then AND with Mask */
5900     case 30:            /* Rotate Left Doubleword Immediate then Clear Left */
5901                         /* Rotate Left Doubleword Immediate then Clear Right */
5902                         /* Rotate Left Doubleword Immediate then Clear */
5903                         /* Rotate Left Doubleword then Clear Left */
5904                         /* Rotate Left Doubleword then Clear Right */
5905                         /* Rotate Left Doubleword Immediate then Mask Insert */
5906       if (PPC_RC (insn))
5907         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5908       record_full_arch_list_add_reg (regcache,
5909                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5910       break;
5911
5912     case 28:            /* AND Immediate */
5913     case 29:            /* AND Immediate Shifted */
5914       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5915       /* FALL-THROUGH */
5916     case 24:            /* OR Immediate */
5917     case 25:            /* OR Immediate Shifted */
5918     case 26:            /* XOR Immediate */
5919     case 27:            /* XOR Immediate Shifted */
5920       record_full_arch_list_add_reg (regcache,
5921                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5922       break;
5923
5924     case 31:
5925       if (ppc_process_record_op31 (gdbarch, regcache, addr, insn) != 0)
5926         return -1;
5927       break;
5928
5929     case 33:            /* Load Word and Zero with Update */
5930     case 35:            /* Load Byte and Zero with Update */
5931     case 41:            /* Load Halfword and Zero with Update */
5932     case 43:            /* Load Halfword Algebraic with Update */
5933       record_full_arch_list_add_reg (regcache,
5934                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5935       /* FALL-THROUGH */
5936     case 32:            /* Load Word and Zero */
5937     case 34:            /* Load Byte and Zero */
5938     case 40:            /* Load Halfword and Zero */
5939     case 42:            /* Load Halfword Algebraic */
5940       record_full_arch_list_add_reg (regcache,
5941                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5942       break;
5943
5944     case 46:            /* Load Multiple Word */
5945       for (i = PPC_RT (insn); i < 32; i++)
5946         record_full_arch_list_add_reg (regcache, tdep->ppc_gp0_regnum + i);
5947       break;
5948
5949     case 56:            /* Load Quadword */
5950       tmp = tdep->ppc_gp0_regnum + (PPC_RT (insn) & ~1);
5951       record_full_arch_list_add_reg (regcache, tmp);
5952       record_full_arch_list_add_reg (regcache, tmp + 1);
5953       break;
5954
5955     case 49:            /* Load Floating-Point Single with Update */
5956     case 51:            /* Load Floating-Point Double with Update */
5957       record_full_arch_list_add_reg (regcache,
5958                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5959       /* FALL-THROUGH */
5960     case 48:            /* Load Floating-Point Single */
5961     case 50:            /* Load Floating-Point Double */
5962       record_full_arch_list_add_reg (regcache,
5963                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5964       break;
5965
5966     case 47:            /* Store Multiple Word */
5967         {
5968           ULONGEST iaddr = 0;
5969
5970           if (PPC_RA (insn) != 0)
5971             regcache_raw_read_unsigned (regcache,
5972                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
5973                                         &iaddr);
5974
5975           iaddr += PPC_D (insn);
5976           record_full_arch_list_add_mem (iaddr, 4 * (32 - PPC_RS (insn)));
5977         }
5978       break;
5979
5980     case 37:            /* Store Word with Update */
5981     case 39:            /* Store Byte with Update */
5982     case 45:            /* Store Halfword with Update */
5983     case 53:            /* Store Floating-Point Single with Update */
5984     case 55:            /* Store Floating-Point Double with Update */
5985       record_full_arch_list_add_reg (regcache,
5986                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5987       /* FALL-THROUGH */
5988     case 36:            /* Store Word */
5989     case 38:            /* Store Byte */
5990     case 44:            /* Store Halfword */
5991     case 52:            /* Store Floating-Point Single */
5992     case 54:            /* Store Floating-Point Double */
5993         {
5994           ULONGEST iaddr = 0;
5995           int size = -1;
5996
5997           if (PPC_RA (insn) != 0)
5998             regcache_raw_read_unsigned (regcache,
5999                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
6000                                         &iaddr);
6001           iaddr += PPC_D (insn);
6002
6003           if (op6 == 36 || op6 == 37 || op6 == 52 || op6 == 53)
6004             size = 4;
6005           else if (op6 == 54 || op6 == 55)
6006             size = 8;
6007           else if (op6 == 44 || op6 == 45)
6008             size = 2;
6009           else if (op6 == 38 || op6 == 39)
6010             size = 1;
6011           else
6012             gdb_assert (0);
6013
6014           record_full_arch_list_add_mem (iaddr, size);
6015         }
6016       break;
6017
6018     case 57:
6019       switch (insn & 0x3)
6020         {
6021         case 0:         /* Load Floating-Point Double Pair */
6022           tmp = tdep->ppc_fp0_regnum + (PPC_RT (insn) & ~1);
6023           record_full_arch_list_add_reg (regcache, tmp);
6024           record_full_arch_list_add_reg (regcache, tmp + 1);
6025           break;
6026         case 2:         /* Load VSX Scalar Doubleword */
6027         case 3:         /* Load VSX Scalar Single */
6028           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
6029           break;
6030         default:
6031           goto UNKNOWN_OP;
6032         }
6033       break;
6034
6035     case 58:            /* Load Doubleword */
6036                         /* Load Doubleword with Update */
6037                         /* Load Word Algebraic */
6038       if (PPC_FIELD (insn, 30, 2) > 2)
6039         goto UNKNOWN_OP;
6040
6041       record_full_arch_list_add_reg (regcache,
6042                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
6043       if (PPC_BIT (insn, 31))
6044         record_full_arch_list_add_reg (regcache,
6045                                        tdep->ppc_gp0_regnum + PPC_RA (insn));
6046       break;
6047
6048     case 59:
6049       if (ppc_process_record_op59 (gdbarch, regcache, addr, insn) != 0)
6050         return -1;
6051       break;
6052
6053     case 60:
6054       if (ppc_process_record_op60 (gdbarch, regcache, addr, insn) != 0)
6055         return -1;
6056       break;
6057
6058     case 61:
6059       if (ppc_process_record_op61 (gdbarch, regcache, addr, insn) != 0)
6060         return -1;
6061       break;
6062
6063     case 62:            /* Store Doubleword */
6064                         /* Store Doubleword with Update */
6065                         /* Store Quadword with Update */
6066         {
6067           ULONGEST iaddr = 0;
6068           int size;
6069           int sub2 = PPC_FIELD (insn, 30, 2);
6070
6071           if (sub2 > 2)
6072             goto UNKNOWN_OP;
6073
6074           if (PPC_RA (insn) != 0)
6075             regcache_raw_read_unsigned (regcache,
6076                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
6077                                         &iaddr);
6078
6079           size = (sub2 == 2) ? 16 : 8;
6080
6081           iaddr += PPC_DS (insn) << 2;
6082           record_full_arch_list_add_mem (iaddr, size);
6083
6084           if (op6 == 62 && sub2 == 1)
6085             record_full_arch_list_add_reg (regcache,
6086                                            tdep->ppc_gp0_regnum +
6087                                            PPC_RA (insn));
6088
6089           break;
6090         }
6091
6092     case 63:
6093       if (ppc_process_record_op63 (gdbarch, regcache, addr, insn) != 0)
6094         return -1;
6095       break;
6096
6097     default:
6098 UNKNOWN_OP:
6099       fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
6100                           "at %s, %d.\n", insn, paddress (gdbarch, addr), op6);
6101       return -1;
6102     }
6103
6104   if (record_full_arch_list_add_reg (regcache, PPC_PC_REGNUM))
6105     return -1;
6106   if (record_full_arch_list_add_end ())
6107     return -1;
6108   return 0;
6109 }
6110
6111 /* Initialize the current architecture based on INFO.  If possible, re-use an
6112    architecture from ARCHES, which is a list of architectures already created
6113    during this debugging session.
6114
6115    Called e.g. at program startup, when reading a core file, and when reading
6116    a binary file.  */
6117
6118 static struct gdbarch *
6119 rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
6120 {
6121   struct gdbarch *gdbarch;
6122   struct gdbarch_tdep *tdep;
6123   int wordsize, from_xcoff_exec, from_elf_exec;
6124   enum bfd_architecture arch;
6125   unsigned long mach;
6126   bfd abfd;
6127   enum auto_boolean soft_float_flag = powerpc_soft_float_global;
6128   int soft_float;
6129   enum powerpc_long_double_abi long_double_abi = POWERPC_LONG_DOUBLE_AUTO;
6130   enum powerpc_vector_abi vector_abi = powerpc_vector_abi_global;
6131   enum powerpc_elf_abi elf_abi = POWERPC_ELF_AUTO;
6132   int have_fpu = 0, have_spe = 0, have_mq = 0, have_altivec = 0;
6133   int have_dfp = 0, have_vsx = 0, have_ppr = 0, have_dscr = 0;
6134   int have_tar = 0, have_ebb = 0, have_pmu = 0, have_htm_spr = 0;
6135   int have_htm_core = 0, have_htm_fpu = 0, have_htm_altivec = 0;
6136   int have_htm_vsx = 0, have_htm_ppr = 0, have_htm_dscr = 0;
6137   int have_htm_tar = 0;
6138   int tdesc_wordsize = -1;
6139   const struct target_desc *tdesc = info.target_desc;
6140   struct tdesc_arch_data *tdesc_data = NULL;
6141   int num_pseudoregs = 0;
6142   int cur_reg;
6143
6144   /* INFO may refer to a binary that is not of the PowerPC architecture,
6145      e.g. when debugging a stand-alone SPE executable on a Cell/B.E. system.
6146      In this case, we must not attempt to infer properties of the (PowerPC
6147      side) of the target system from properties of that executable.  Trust
6148      the target description instead.  */
6149   if (info.abfd
6150       && bfd_get_arch (info.abfd) != bfd_arch_powerpc
6151       && bfd_get_arch (info.abfd) != bfd_arch_rs6000)
6152     info.abfd = NULL;
6153
6154   from_xcoff_exec = info.abfd && info.abfd->format == bfd_object &&
6155     bfd_get_flavour (info.abfd) == bfd_target_xcoff_flavour;
6156
6157   from_elf_exec = info.abfd && info.abfd->format == bfd_object &&
6158     bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
6159
6160   /* Check word size.  If INFO is from a binary file, infer it from
6161      that, else choose a likely default.  */
6162   if (from_xcoff_exec)
6163     {
6164       if (bfd_xcoff_is_xcoff64 (info.abfd))
6165         wordsize = 8;
6166       else
6167         wordsize = 4;
6168     }
6169   else if (from_elf_exec)
6170     {
6171       if (elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6172         wordsize = 8;
6173       else
6174         wordsize = 4;
6175     }
6176   else if (tdesc_has_registers (tdesc))
6177     wordsize = -1;
6178   else
6179     {
6180       if (info.bfd_arch_info != NULL && info.bfd_arch_info->bits_per_word != 0)
6181         wordsize = (info.bfd_arch_info->bits_per_word
6182                     / info.bfd_arch_info->bits_per_byte);
6183       else
6184         wordsize = 4;
6185     }
6186
6187   /* Get the architecture and machine from the BFD.  */
6188   arch = info.bfd_arch_info->arch;
6189   mach = info.bfd_arch_info->mach;
6190
6191   /* For e500 executables, the apuinfo section is of help here.  Such
6192      section contains the identifier and revision number of each
6193      Application-specific Processing Unit that is present on the
6194      chip.  The content of the section is determined by the assembler
6195      which looks at each instruction and determines which unit (and
6196      which version of it) can execute it.  Grovel through the section
6197      looking for relevant e500 APUs.  */
6198
6199   if (bfd_uses_spe_extensions (info.abfd))
6200     {
6201       arch = info.bfd_arch_info->arch;
6202       mach = bfd_mach_ppc_e500;
6203       bfd_default_set_arch_mach (&abfd, arch, mach);
6204       info.bfd_arch_info = bfd_get_arch_info (&abfd);
6205     }
6206
6207   /* Find a default target description which describes our register
6208      layout, if we do not already have one.  */
6209   if (! tdesc_has_registers (tdesc))
6210     {
6211       const struct variant *v;
6212
6213       /* Choose variant.  */
6214       v = find_variant_by_arch (arch, mach);
6215       if (!v)
6216         return NULL;
6217
6218       tdesc = *v->tdesc;
6219     }
6220
6221   gdb_assert (tdesc_has_registers (tdesc));
6222
6223   /* Check any target description for validity.  */
6224   if (tdesc_has_registers (tdesc))
6225     {
6226       static const char *const gprs[] = {
6227         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6228         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6229         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
6230         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
6231       };
6232       const struct tdesc_feature *feature;
6233       int i, valid_p;
6234       static const char *const msr_names[] = { "msr", "ps" };
6235       static const char *const cr_names[] = { "cr", "cnd" };
6236       static const char *const ctr_names[] = { "ctr", "cnt" };
6237
6238       feature = tdesc_find_feature (tdesc,
6239                                     "org.gnu.gdb.power.core");
6240       if (feature == NULL)
6241         return NULL;
6242
6243       tdesc_data = tdesc_data_alloc ();
6244
6245       valid_p = 1;
6246       for (i = 0; i < ppc_num_gprs; i++)
6247         valid_p &= tdesc_numbered_register (feature, tdesc_data, i, gprs[i]);
6248       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_PC_REGNUM,
6249                                           "pc");
6250       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_LR_REGNUM,
6251                                           "lr");
6252       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_XER_REGNUM,
6253                                           "xer");
6254
6255       /* Allow alternate names for these registers, to accomodate GDB's
6256          historic naming.  */
6257       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6258                                                   PPC_MSR_REGNUM, msr_names);
6259       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6260                                                   PPC_CR_REGNUM, cr_names);
6261       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6262                                                   PPC_CTR_REGNUM, ctr_names);
6263
6264       if (!valid_p)
6265         {
6266           tdesc_data_cleanup (tdesc_data);
6267           return NULL;
6268         }
6269
6270       have_mq = tdesc_numbered_register (feature, tdesc_data, PPC_MQ_REGNUM,
6271                                          "mq");
6272
6273       tdesc_wordsize = tdesc_register_bitsize (feature, "pc") / 8;
6274       if (wordsize == -1)
6275         wordsize = tdesc_wordsize;
6276
6277       feature = tdesc_find_feature (tdesc,
6278                                     "org.gnu.gdb.power.fpu");
6279       if (feature != NULL)
6280         {
6281           static const char *const fprs[] = {
6282             "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6283             "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
6284             "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
6285             "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
6286           };
6287           valid_p = 1;
6288           for (i = 0; i < ppc_num_fprs; i++)
6289             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6290                                                 PPC_F0_REGNUM + i, fprs[i]);
6291           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6292                                               PPC_FPSCR_REGNUM, "fpscr");
6293
6294           if (!valid_p)
6295             {
6296               tdesc_data_cleanup (tdesc_data);
6297               return NULL;
6298             }
6299           have_fpu = 1;
6300
6301           /* The fpscr register was expanded in isa 2.05 to 64 bits
6302              along with the addition of the decimal floating point
6303              facility.  */
6304           if (tdesc_register_bitsize (feature, "fpscr") > 32)
6305             have_dfp = 1;
6306         }
6307       else
6308         have_fpu = 0;
6309
6310       feature = tdesc_find_feature (tdesc,
6311                                     "org.gnu.gdb.power.altivec");
6312       if (feature != NULL)
6313         {
6314           static const char *const vector_regs[] = {
6315             "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7",
6316             "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
6317             "vr16", "vr17", "vr18", "vr19", "vr20", "vr21", "vr22", "vr23",
6318             "vr24", "vr25", "vr26", "vr27", "vr28", "vr29", "vr30", "vr31"
6319           };
6320
6321           valid_p = 1;
6322           for (i = 0; i < ppc_num_gprs; i++)
6323             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6324                                                 PPC_VR0_REGNUM + i,
6325                                                 vector_regs[i]);
6326           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6327                                               PPC_VSCR_REGNUM, "vscr");
6328           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6329                                               PPC_VRSAVE_REGNUM, "vrsave");
6330
6331           if (have_spe || !valid_p)
6332             {
6333               tdesc_data_cleanup (tdesc_data);
6334               return NULL;
6335             }
6336           have_altivec = 1;
6337         }
6338       else
6339         have_altivec = 0;
6340
6341       /* Check for POWER7 VSX registers support.  */
6342       feature = tdesc_find_feature (tdesc,
6343                                     "org.gnu.gdb.power.vsx");
6344
6345       if (feature != NULL)
6346         {
6347           static const char *const vsx_regs[] = {
6348             "vs0h", "vs1h", "vs2h", "vs3h", "vs4h", "vs5h",
6349             "vs6h", "vs7h", "vs8h", "vs9h", "vs10h", "vs11h",
6350             "vs12h", "vs13h", "vs14h", "vs15h", "vs16h", "vs17h",
6351             "vs18h", "vs19h", "vs20h", "vs21h", "vs22h", "vs23h",
6352             "vs24h", "vs25h", "vs26h", "vs27h", "vs28h", "vs29h",
6353             "vs30h", "vs31h"
6354           };
6355
6356           valid_p = 1;
6357
6358           for (i = 0; i < ppc_num_vshrs; i++)
6359             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6360                                                 PPC_VSR0_UPPER_REGNUM + i,
6361                                                 vsx_regs[i]);
6362
6363           if (!valid_p || !have_fpu || !have_altivec)
6364             {
6365               tdesc_data_cleanup (tdesc_data);
6366               return NULL;
6367             }
6368
6369           have_vsx = 1;
6370         }
6371       else
6372         have_vsx = 0;
6373
6374       /* On machines supporting the SPE APU, the general-purpose registers
6375          are 64 bits long.  There are SIMD vector instructions to treat them
6376          as pairs of floats, but the rest of the instruction set treats them
6377          as 32-bit registers, and only operates on their lower halves.
6378
6379          In the GDB regcache, we treat their high and low halves as separate
6380          registers.  The low halves we present as the general-purpose
6381          registers, and then we have pseudo-registers that stitch together
6382          the upper and lower halves and present them as pseudo-registers.
6383
6384          Thus, the target description is expected to supply the upper
6385          halves separately.  */
6386
6387       feature = tdesc_find_feature (tdesc,
6388                                     "org.gnu.gdb.power.spe");
6389       if (feature != NULL)
6390         {
6391           static const char *const upper_spe[] = {
6392             "ev0h", "ev1h", "ev2h", "ev3h",
6393             "ev4h", "ev5h", "ev6h", "ev7h",
6394             "ev8h", "ev9h", "ev10h", "ev11h",
6395             "ev12h", "ev13h", "ev14h", "ev15h",
6396             "ev16h", "ev17h", "ev18h", "ev19h",
6397             "ev20h", "ev21h", "ev22h", "ev23h",
6398             "ev24h", "ev25h", "ev26h", "ev27h",
6399             "ev28h", "ev29h", "ev30h", "ev31h"
6400           };
6401
6402           valid_p = 1;
6403           for (i = 0; i < ppc_num_gprs; i++)
6404             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6405                                                 PPC_SPE_UPPER_GP0_REGNUM + i,
6406                                                 upper_spe[i]);
6407           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6408                                               PPC_SPE_ACC_REGNUM, "acc");
6409           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6410                                               PPC_SPE_FSCR_REGNUM, "spefscr");
6411
6412           if (have_mq || have_fpu || !valid_p)
6413             {
6414               tdesc_data_cleanup (tdesc_data);
6415               return NULL;
6416             }
6417           have_spe = 1;
6418         }
6419       else
6420         have_spe = 0;
6421
6422       /* Program Priority Register.  */
6423       feature = tdesc_find_feature (tdesc,
6424                                     "org.gnu.gdb.power.ppr");
6425       if (feature != NULL)
6426         {
6427           valid_p = 1;
6428           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6429                                               PPC_PPR_REGNUM, "ppr");
6430
6431           if (!valid_p)
6432             {
6433               tdesc_data_cleanup (tdesc_data);
6434               return NULL;
6435             }
6436           have_ppr = 1;
6437         }
6438       else
6439         have_ppr = 0;
6440
6441       /* Data Stream Control Register.  */
6442       feature = tdesc_find_feature (tdesc,
6443                                     "org.gnu.gdb.power.dscr");
6444       if (feature != NULL)
6445         {
6446           valid_p = 1;
6447           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6448                                               PPC_DSCR_REGNUM, "dscr");
6449
6450           if (!valid_p)
6451             {
6452               tdesc_data_cleanup (tdesc_data);
6453               return NULL;
6454             }
6455           have_dscr = 1;
6456         }
6457       else
6458         have_dscr = 0;
6459
6460       /* Target Address Register.  */
6461       feature = tdesc_find_feature (tdesc,
6462                                     "org.gnu.gdb.power.tar");
6463       if (feature != NULL)
6464         {
6465           valid_p = 1;
6466           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6467                                               PPC_TAR_REGNUM, "tar");
6468
6469           if (!valid_p)
6470             {
6471               tdesc_data_cleanup (tdesc_data);
6472               return NULL;
6473             }
6474           have_tar = 1;
6475         }
6476       else
6477         have_tar = 0;
6478
6479       /* Event-based Branching Registers.  */
6480       feature = tdesc_find_feature (tdesc,
6481                                     "org.gnu.gdb.power.ebb");
6482       if (feature != NULL)
6483         {
6484           static const char *const ebb_regs[] = {
6485             "bescr", "ebbhr", "ebbrr"
6486           };
6487
6488           valid_p = 1;
6489           for (i = 0; i < ARRAY_SIZE (ebb_regs); i++)
6490             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6491                                                 PPC_BESCR_REGNUM + i,
6492                                                 ebb_regs[i]);
6493           if (!valid_p)
6494             {
6495               tdesc_data_cleanup (tdesc_data);
6496               return NULL;
6497             }
6498           have_ebb = 1;
6499         }
6500       else
6501         have_ebb = 0;
6502
6503       /* Subset of the ISA 2.07 Performance Monitor Registers provided
6504          by Linux.  */
6505       feature = tdesc_find_feature (tdesc,
6506                                     "org.gnu.gdb.power.linux.pmu");
6507       if (feature != NULL)
6508         {
6509           valid_p = 1;
6510
6511           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6512                                               PPC_MMCR0_REGNUM,
6513                                               "mmcr0");
6514           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6515                                               PPC_MMCR2_REGNUM,
6516                                               "mmcr2");
6517           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6518                                               PPC_SIAR_REGNUM,
6519                                               "siar");
6520           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6521                                               PPC_SDAR_REGNUM,
6522                                               "sdar");
6523           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6524                                               PPC_SIER_REGNUM,
6525                                               "sier");
6526
6527           if (!valid_p)
6528             {
6529               tdesc_data_cleanup (tdesc_data);
6530               return NULL;
6531             }
6532           have_pmu = 1;
6533         }
6534       else
6535         have_pmu = 0;
6536
6537       /* Hardware Transactional Memory Registers.  */
6538       feature = tdesc_find_feature (tdesc,
6539                                     "org.gnu.gdb.power.htm.spr");
6540       if (feature != NULL)
6541         {
6542           static const char *const tm_spr_regs[] = {
6543             "tfhar", "texasr", "tfiar"
6544           };
6545
6546           valid_p = 1;
6547           for (i = 0; i < ARRAY_SIZE (tm_spr_regs); i++)
6548             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6549                                                 PPC_TFHAR_REGNUM + i,
6550                                                 tm_spr_regs[i]);
6551           if (!valid_p)
6552             {
6553               tdesc_data_cleanup (tdesc_data);
6554               return NULL;
6555             }
6556
6557           have_htm_spr = 1;
6558         }
6559       else
6560         have_htm_spr = 0;
6561
6562       feature = tdesc_find_feature (tdesc,
6563                                     "org.gnu.gdb.power.htm.core");
6564       if (feature != NULL)
6565         {
6566           static const char *const cgprs[] = {
6567             "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6568             "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14",
6569             "cr15", "cr16", "cr17", "cr18", "cr19", "cr20", "cr21",
6570             "cr22", "cr23", "cr24", "cr25", "cr26", "cr27", "cr28",
6571             "cr29", "cr30", "cr31", "ccr", "cxer", "clr", "cctr"
6572           };
6573
6574           valid_p = 1;
6575
6576           for (i = 0; i < ARRAY_SIZE (cgprs); i++)
6577             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6578                                                 PPC_CR0_REGNUM + i,
6579                                                 cgprs[i]);
6580           if (!valid_p)
6581             {
6582               tdesc_data_cleanup (tdesc_data);
6583               return NULL;
6584             }
6585
6586           have_htm_core = 1;
6587         }
6588       else
6589         have_htm_core = 0;
6590
6591       feature = tdesc_find_feature (tdesc,
6592                                     "org.gnu.gdb.power.htm.fpu");
6593       if (feature != NULL)
6594         {
6595           valid_p = 1;
6596
6597           static const char *const cfprs[] = {
6598             "cf0", "cf1", "cf2", "cf3", "cf4", "cf5", "cf6", "cf7",
6599             "cf8", "cf9", "cf10", "cf11", "cf12", "cf13", "cf14", "cf15",
6600             "cf16", "cf17", "cf18", "cf19", "cf20", "cf21", "cf22",
6601             "cf23", "cf24", "cf25", "cf26", "cf27", "cf28", "cf29",
6602             "cf30", "cf31", "cfpscr"
6603           };
6604
6605           for (i = 0; i < ARRAY_SIZE (cfprs); i++)
6606             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6607                                                 PPC_CF0_REGNUM + i,
6608                                                 cfprs[i]);
6609
6610           if (!valid_p)
6611             {
6612               tdesc_data_cleanup (tdesc_data);
6613               return NULL;
6614             }
6615           have_htm_fpu = 1;
6616         }
6617       else
6618         have_htm_fpu = 0;
6619
6620       feature = tdesc_find_feature (tdesc,
6621                                     "org.gnu.gdb.power.htm.altivec");
6622       if (feature != NULL)
6623         {
6624           valid_p = 1;
6625
6626           static const char *const cvmx[] = {
6627             "cvr0", "cvr1", "cvr2", "cvr3", "cvr4", "cvr5", "cvr6",
6628             "cvr7", "cvr8", "cvr9", "cvr10", "cvr11", "cvr12", "cvr13",
6629             "cvr14", "cvr15","cvr16", "cvr17", "cvr18", "cvr19", "cvr20",
6630             "cvr21", "cvr22", "cvr23", "cvr24", "cvr25", "cvr26",
6631             "cvr27", "cvr28", "cvr29", "cvr30", "cvr31", "cvscr",
6632             "cvrsave"
6633           };
6634
6635           for (i = 0; i < ARRAY_SIZE (cvmx); i++)
6636             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6637                                                 PPC_CVR0_REGNUM + i,
6638                                                 cvmx[i]);
6639
6640           if (!valid_p)
6641             {
6642               tdesc_data_cleanup (tdesc_data);
6643               return NULL;
6644             }
6645           have_htm_altivec = 1;
6646         }
6647       else
6648         have_htm_altivec = 0;
6649
6650       feature = tdesc_find_feature (tdesc,
6651                                     "org.gnu.gdb.power.htm.vsx");
6652       if (feature != NULL)
6653         {
6654           valid_p = 1;
6655
6656           static const char *const cvsx[] = {
6657             "cvs0h", "cvs1h", "cvs2h", "cvs3h", "cvs4h", "cvs5h",
6658             "cvs6h", "cvs7h", "cvs8h", "cvs9h", "cvs10h", "cvs11h",
6659             "cvs12h", "cvs13h", "cvs14h", "cvs15h", "cvs16h", "cvs17h",
6660             "cvs18h", "cvs19h", "cvs20h", "cvs21h", "cvs22h", "cvs23h",
6661             "cvs24h", "cvs25h", "cvs26h", "cvs27h", "cvs28h", "cvs29h",
6662             "cvs30h", "cvs31h"
6663           };
6664
6665           for (i = 0; i < ARRAY_SIZE (cvsx); i++)
6666             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6667                                                 (PPC_CVSR0_UPPER_REGNUM
6668                                                  + i),
6669                                                 cvsx[i]);
6670
6671           if (!valid_p || !have_htm_fpu || !have_htm_altivec)
6672             {
6673               tdesc_data_cleanup (tdesc_data);
6674               return NULL;
6675             }
6676           have_htm_vsx = 1;
6677         }
6678       else
6679         have_htm_vsx = 0;
6680
6681       feature = tdesc_find_feature (tdesc,
6682                                     "org.gnu.gdb.power.htm.ppr");
6683       if (feature != NULL)
6684         {
6685           valid_p = tdesc_numbered_register (feature, tdesc_data,
6686                                              PPC_CPPR_REGNUM, "cppr");
6687
6688           if (!valid_p)
6689             {
6690               tdesc_data_cleanup (tdesc_data);
6691               return NULL;
6692             }
6693           have_htm_ppr = 1;
6694         }
6695       else
6696         have_htm_ppr = 0;
6697
6698       feature = tdesc_find_feature (tdesc,
6699                                     "org.gnu.gdb.power.htm.dscr");
6700       if (feature != NULL)
6701         {
6702           valid_p = tdesc_numbered_register (feature, tdesc_data,
6703                                              PPC_CDSCR_REGNUM, "cdscr");
6704
6705           if (!valid_p)
6706             {
6707               tdesc_data_cleanup (tdesc_data);
6708               return NULL;
6709             }
6710           have_htm_dscr = 1;
6711         }
6712       else
6713         have_htm_dscr = 0;
6714
6715       feature = tdesc_find_feature (tdesc,
6716                                     "org.gnu.gdb.power.htm.tar");
6717       if (feature != NULL)
6718         {
6719           valid_p = tdesc_numbered_register (feature, tdesc_data,
6720                                              PPC_CTAR_REGNUM, "ctar");
6721
6722           if (!valid_p)
6723             {
6724               tdesc_data_cleanup (tdesc_data);
6725               return NULL;
6726             }
6727           have_htm_tar = 1;
6728         }
6729       else
6730         have_htm_tar = 0;
6731     }
6732
6733   /* If we have a 64-bit binary on a 32-bit target, complain.  Also
6734      complain for a 32-bit binary on a 64-bit target; we do not yet
6735      support that.  For instance, the 32-bit ABI routines expect
6736      32-bit GPRs.
6737
6738      As long as there isn't an explicit target description, we'll
6739      choose one based on the BFD architecture and get a word size
6740      matching the binary (probably powerpc:common or
6741      powerpc:common64).  So there is only trouble if a 64-bit target
6742      supplies a 64-bit description while debugging a 32-bit
6743      binary.  */
6744   if (tdesc_wordsize != -1 && tdesc_wordsize != wordsize)
6745     {
6746       tdesc_data_cleanup (tdesc_data);
6747       return NULL;
6748     }
6749
6750 #ifdef HAVE_ELF
6751   if (from_elf_exec)
6752     {
6753       switch (elf_elfheader (info.abfd)->e_flags & EF_PPC64_ABI)
6754         {
6755         case 1:
6756           elf_abi = POWERPC_ELF_V1;
6757           break;
6758         case 2:
6759           elf_abi = POWERPC_ELF_V2;
6760           break;
6761         default:
6762           break;
6763         }
6764     }
6765
6766   if (soft_float_flag == AUTO_BOOLEAN_AUTO && from_elf_exec)
6767     {
6768       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6769                                         Tag_GNU_Power_ABI_FP) & 3)
6770         {
6771         case 1:
6772           soft_float_flag = AUTO_BOOLEAN_FALSE;
6773           break;
6774         case 2:
6775           soft_float_flag = AUTO_BOOLEAN_TRUE;
6776           break;
6777         default:
6778           break;
6779         }
6780     }
6781
6782   if (long_double_abi == POWERPC_LONG_DOUBLE_AUTO && from_elf_exec)
6783     {
6784       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6785                                         Tag_GNU_Power_ABI_FP) >> 2)
6786         {
6787         case 1:
6788           long_double_abi = POWERPC_LONG_DOUBLE_IBM128;
6789           break;
6790         case 3:
6791           long_double_abi = POWERPC_LONG_DOUBLE_IEEE128;
6792           break;
6793         default:
6794           break;
6795         }
6796     }
6797
6798   if (vector_abi == POWERPC_VEC_AUTO && from_elf_exec)
6799     {
6800       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6801                                         Tag_GNU_Power_ABI_Vector))
6802         {
6803         case 1:
6804           vector_abi = POWERPC_VEC_GENERIC;
6805           break;
6806         case 2:
6807           vector_abi = POWERPC_VEC_ALTIVEC;
6808           break;
6809         case 3:
6810           vector_abi = POWERPC_VEC_SPE;
6811           break;
6812         default:
6813           break;
6814         }
6815     }
6816 #endif
6817
6818   /* At this point, the only supported ELF-based 64-bit little-endian
6819      operating system is GNU/Linux, and this uses the ELFv2 ABI by
6820      default.  All other supported ELF-based operating systems use the
6821      ELFv1 ABI by default.  Therefore, if the ABI marker is missing,
6822      e.g. because we run a legacy binary, or have attached to a process
6823      and have not found any associated binary file, set the default
6824      according to this heuristic.  */
6825   if (elf_abi == POWERPC_ELF_AUTO)
6826     {
6827       if (wordsize == 8 && info.byte_order == BFD_ENDIAN_LITTLE)
6828         elf_abi = POWERPC_ELF_V2;
6829       else
6830         elf_abi = POWERPC_ELF_V1;
6831     }
6832
6833   if (soft_float_flag == AUTO_BOOLEAN_TRUE)
6834     soft_float = 1;
6835   else if (soft_float_flag == AUTO_BOOLEAN_FALSE)
6836     soft_float = 0;
6837   else
6838     soft_float = !have_fpu;
6839
6840   /* If we have a hard float binary or setting but no floating point
6841      registers, downgrade to soft float anyway.  We're still somewhat
6842      useful in this scenario.  */
6843   if (!soft_float && !have_fpu)
6844     soft_float = 1;
6845
6846   /* Similarly for vector registers.  */
6847   if (vector_abi == POWERPC_VEC_ALTIVEC && !have_altivec)
6848     vector_abi = POWERPC_VEC_GENERIC;
6849
6850   if (vector_abi == POWERPC_VEC_SPE && !have_spe)
6851     vector_abi = POWERPC_VEC_GENERIC;
6852
6853   if (vector_abi == POWERPC_VEC_AUTO)
6854     {
6855       if (have_altivec)
6856         vector_abi = POWERPC_VEC_ALTIVEC;
6857       else if (have_spe)
6858         vector_abi = POWERPC_VEC_SPE;
6859       else
6860         vector_abi = POWERPC_VEC_GENERIC;
6861     }
6862
6863   /* Do not limit the vector ABI based on available hardware, since we
6864      do not yet know what hardware we'll decide we have.  Yuck!  FIXME!  */
6865
6866   /* Find a candidate among extant architectures.  */
6867   for (arches = gdbarch_list_lookup_by_info (arches, &info);
6868        arches != NULL;
6869        arches = gdbarch_list_lookup_by_info (arches->next, &info))
6870     {
6871       /* Word size in the various PowerPC bfd_arch_info structs isn't
6872          meaningful, because 64-bit CPUs can run in 32-bit mode.  So, perform
6873          separate word size check.  */
6874       tdep = gdbarch_tdep (arches->gdbarch);
6875       if (tdep && tdep->elf_abi != elf_abi)
6876         continue;
6877       if (tdep && tdep->soft_float != soft_float)
6878         continue;
6879       if (tdep && tdep->long_double_abi != long_double_abi)
6880         continue;
6881       if (tdep && tdep->vector_abi != vector_abi)
6882         continue;
6883       if (tdep && tdep->wordsize == wordsize)
6884         {
6885           if (tdesc_data != NULL)
6886             tdesc_data_cleanup (tdesc_data);
6887           return arches->gdbarch;
6888         }
6889     }
6890
6891   /* None found, create a new architecture from INFO, whose bfd_arch_info
6892      validity depends on the source:
6893        - executable             useless
6894        - rs6000_host_arch()     good
6895        - core file              good
6896        - "set arch"             trust blindly
6897        - GDB startup            useless but harmless */
6898
6899   tdep = XCNEW (struct gdbarch_tdep);
6900   tdep->wordsize = wordsize;
6901   tdep->elf_abi = elf_abi;
6902   tdep->soft_float = soft_float;
6903   tdep->long_double_abi = long_double_abi;
6904   tdep->vector_abi = vector_abi;
6905
6906   gdbarch = gdbarch_alloc (&info, tdep);
6907
6908   tdep->ppc_gp0_regnum = PPC_R0_REGNUM;
6909   tdep->ppc_toc_regnum = PPC_R0_REGNUM + 2;
6910   tdep->ppc_ps_regnum = PPC_MSR_REGNUM;
6911   tdep->ppc_cr_regnum = PPC_CR_REGNUM;
6912   tdep->ppc_lr_regnum = PPC_LR_REGNUM;
6913   tdep->ppc_ctr_regnum = PPC_CTR_REGNUM;
6914   tdep->ppc_xer_regnum = PPC_XER_REGNUM;
6915   tdep->ppc_mq_regnum = have_mq ? PPC_MQ_REGNUM : -1;
6916
6917   tdep->ppc_fp0_regnum = have_fpu ? PPC_F0_REGNUM : -1;
6918   tdep->ppc_fpscr_regnum = have_fpu ? PPC_FPSCR_REGNUM : -1;
6919   tdep->ppc_vsr0_upper_regnum = have_vsx ? PPC_VSR0_UPPER_REGNUM : -1;
6920   tdep->ppc_vr0_regnum = have_altivec ? PPC_VR0_REGNUM : -1;
6921   tdep->ppc_vrsave_regnum = have_altivec ? PPC_VRSAVE_REGNUM : -1;
6922   tdep->ppc_ev0_upper_regnum = have_spe ? PPC_SPE_UPPER_GP0_REGNUM : -1;
6923   tdep->ppc_acc_regnum = have_spe ? PPC_SPE_ACC_REGNUM : -1;
6924   tdep->ppc_spefscr_regnum = have_spe ? PPC_SPE_FSCR_REGNUM : -1;
6925   tdep->ppc_ppr_regnum = have_ppr ? PPC_PPR_REGNUM : -1;
6926   tdep->ppc_dscr_regnum = have_dscr ? PPC_DSCR_REGNUM : -1;
6927   tdep->ppc_tar_regnum = have_tar ? PPC_TAR_REGNUM : -1;
6928   tdep->have_ebb = have_ebb;
6929
6930   /* If additional pmu registers are added, care must be taken when
6931      setting new fields in the tdep below, to maintain compatibility
6932      with features that only provide some of the registers.  Currently
6933      gdb access to the pmu registers is only supported in linux, and
6934      linux only provides a subset of the pmu registers defined in the
6935      architecture.  */
6936
6937   tdep->ppc_mmcr0_regnum = have_pmu ? PPC_MMCR0_REGNUM : -1;
6938   tdep->ppc_mmcr2_regnum = have_pmu ? PPC_MMCR2_REGNUM : -1;
6939   tdep->ppc_siar_regnum = have_pmu ? PPC_SIAR_REGNUM : -1;
6940   tdep->ppc_sdar_regnum = have_pmu ? PPC_SDAR_REGNUM : -1;
6941   tdep->ppc_sier_regnum = have_pmu ? PPC_SIER_REGNUM : -1;
6942
6943   tdep->have_htm_spr = have_htm_spr;
6944   tdep->have_htm_core = have_htm_core;
6945   tdep->have_htm_fpu = have_htm_fpu;
6946   tdep->have_htm_altivec = have_htm_altivec;
6947   tdep->have_htm_vsx = have_htm_vsx;
6948   tdep->ppc_cppr_regnum = have_htm_ppr ? PPC_CPPR_REGNUM : -1;
6949   tdep->ppc_cdscr_regnum = have_htm_dscr ? PPC_CDSCR_REGNUM : -1;
6950   tdep->ppc_ctar_regnum = have_htm_tar ? PPC_CTAR_REGNUM : -1;
6951
6952   set_gdbarch_pc_regnum (gdbarch, PPC_PC_REGNUM);
6953   set_gdbarch_sp_regnum (gdbarch, PPC_R0_REGNUM + 1);
6954   set_gdbarch_fp0_regnum (gdbarch, tdep->ppc_fp0_regnum);
6955   set_gdbarch_register_sim_regno (gdbarch, rs6000_register_sim_regno);
6956
6957   /* The XML specification for PowerPC sensibly calls the MSR "msr".
6958      GDB traditionally called it "ps", though, so let GDB add an
6959      alias.  */
6960   set_gdbarch_ps_regnum (gdbarch, tdep->ppc_ps_regnum);
6961
6962   if (wordsize == 8)
6963     set_gdbarch_return_value (gdbarch, ppc64_sysv_abi_return_value);
6964   else
6965     set_gdbarch_return_value (gdbarch, ppc_sysv_abi_return_value);
6966
6967   /* Set lr_frame_offset.  */
6968   if (wordsize == 8)
6969     tdep->lr_frame_offset = 16;
6970   else
6971     tdep->lr_frame_offset = 4;
6972
6973   if (have_spe || have_dfp || have_altivec
6974       || have_vsx || have_htm_fpu || have_htm_vsx)
6975     {
6976       set_gdbarch_pseudo_register_read (gdbarch, rs6000_pseudo_register_read);
6977       set_gdbarch_pseudo_register_write (gdbarch,
6978                                          rs6000_pseudo_register_write);
6979       set_gdbarch_ax_pseudo_register_collect (gdbarch,
6980               rs6000_ax_pseudo_register_collect);
6981     }
6982
6983   set_gdbarch_gen_return_address (gdbarch, rs6000_gen_return_address);
6984
6985   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
6986
6987   set_gdbarch_num_regs (gdbarch, PPC_NUM_REGS);
6988
6989   if (have_spe)
6990     num_pseudoregs += 32;
6991   if (have_dfp)
6992     num_pseudoregs += 16;
6993   if (have_altivec)
6994     num_pseudoregs += 32;
6995   if (have_vsx)
6996     /* Include both VSX and Extended FP registers.  */
6997     num_pseudoregs += 96;
6998   if (have_htm_fpu)
6999     num_pseudoregs += 16;
7000   /* Include both checkpointed VSX and EFP registers.  */
7001   if (have_htm_vsx)
7002     num_pseudoregs += 64 + 32;
7003
7004   set_gdbarch_num_pseudo_regs (gdbarch, num_pseudoregs);
7005
7006   set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
7007   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
7008   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
7009   set_gdbarch_long_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
7010   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
7011   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
7012   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
7013   set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
7014   set_gdbarch_char_signed (gdbarch, 0);
7015
7016   set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
7017   if (wordsize == 8)
7018     /* PPC64 SYSV.  */
7019     set_gdbarch_frame_red_zone_size (gdbarch, 288);
7020
7021   set_gdbarch_convert_register_p (gdbarch, rs6000_convert_register_p);
7022   set_gdbarch_register_to_value (gdbarch, rs6000_register_to_value);
7023   set_gdbarch_value_to_register (gdbarch, rs6000_value_to_register);
7024
7025   set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum);
7026   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rs6000_dwarf2_reg_to_regnum);
7027
7028   if (wordsize == 4)
7029     set_gdbarch_push_dummy_call (gdbarch, ppc_sysv_abi_push_dummy_call);
7030   else if (wordsize == 8)
7031     set_gdbarch_push_dummy_call (gdbarch, ppc64_sysv_abi_push_dummy_call);
7032
7033   set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue);
7034   set_gdbarch_stack_frame_destroyed_p (gdbarch, rs6000_stack_frame_destroyed_p);
7035   set_gdbarch_skip_main_prologue (gdbarch, rs6000_skip_main_prologue);
7036
7037   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
7038
7039   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
7040                                        rs6000_breakpoint::kind_from_pc);
7041   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
7042                                        rs6000_breakpoint::bp_from_kind);
7043
7044   /* The value of symbols of type N_SO and N_FUN maybe null when
7045      it shouldn't be.  */
7046   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
7047
7048   /* Handles single stepping of atomic sequences.  */
7049   set_gdbarch_software_single_step (gdbarch, ppc_deal_with_atomic_sequence);
7050
7051   /* Not sure on this.  FIXMEmgo */
7052   set_gdbarch_frame_args_skip (gdbarch, 8);
7053
7054   /* Helpers for function argument information.  */
7055   set_gdbarch_fetch_pointer_argument (gdbarch, rs6000_fetch_pointer_argument);
7056
7057   /* Trampoline.  */
7058   set_gdbarch_in_solib_return_trampoline
7059     (gdbarch, rs6000_in_solib_return_trampoline);
7060   set_gdbarch_skip_trampoline_code (gdbarch, rs6000_skip_trampoline_code);
7061
7062   /* Hook in the DWARF CFI frame unwinder.  */
7063   dwarf2_append_unwinders (gdbarch);
7064   dwarf2_frame_set_adjust_regnum (gdbarch, rs6000_adjust_frame_regnum);
7065
7066   /* Frame handling.  */
7067   dwarf2_frame_set_init_reg (gdbarch, ppc_dwarf2_frame_init_reg);
7068
7069   /* Setup displaced stepping.  */
7070   set_gdbarch_displaced_step_copy_insn (gdbarch,
7071                                         ppc_displaced_step_copy_insn);
7072   set_gdbarch_displaced_step_hw_singlestep (gdbarch,
7073                                             ppc_displaced_step_hw_singlestep);
7074   set_gdbarch_displaced_step_fixup (gdbarch, ppc_displaced_step_fixup);
7075   set_gdbarch_displaced_step_location (gdbarch,
7076                                        displaced_step_at_entry_point);
7077
7078   set_gdbarch_max_insn_length (gdbarch, PPC_INSN_SIZE);
7079
7080   /* Hook in ABI-specific overrides, if they have been registered.  */
7081   info.target_desc = tdesc;
7082   info.tdesc_data = tdesc_data;
7083   gdbarch_init_osabi (info, gdbarch);
7084
7085   switch (info.osabi)
7086     {
7087     case GDB_OSABI_LINUX:
7088     case GDB_OSABI_NETBSD:
7089     case GDB_OSABI_UNKNOWN:
7090       frame_unwind_append_unwinder (gdbarch, &rs6000_epilogue_frame_unwind);
7091       frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
7092       frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
7093       break;
7094     default:
7095       set_gdbarch_believe_pcc_promotion (gdbarch, 1);
7096
7097       frame_unwind_append_unwinder (gdbarch, &rs6000_epilogue_frame_unwind);
7098       frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
7099       frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
7100     }
7101
7102   set_tdesc_pseudo_register_type (gdbarch, rs6000_pseudo_register_type);
7103   set_tdesc_pseudo_register_reggroup_p (gdbarch,
7104                                         rs6000_pseudo_register_reggroup_p);
7105   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
7106
7107   /* Override the normal target description method to make the SPE upper
7108      halves anonymous.  */
7109   set_gdbarch_register_name (gdbarch, rs6000_register_name);
7110
7111   /* Choose register numbers for all supported pseudo-registers.  */
7112   tdep->ppc_ev0_regnum = -1;
7113   tdep->ppc_dl0_regnum = -1;
7114   tdep->ppc_v0_alias_regnum = -1;
7115   tdep->ppc_vsr0_regnum = -1;
7116   tdep->ppc_efpr0_regnum = -1;
7117   tdep->ppc_cdl0_regnum = -1;
7118   tdep->ppc_cvsr0_regnum = -1;
7119   tdep->ppc_cefpr0_regnum = -1;
7120
7121   cur_reg = gdbarch_num_regs (gdbarch);
7122
7123   if (have_spe)
7124     {
7125       tdep->ppc_ev0_regnum = cur_reg;
7126       cur_reg += 32;
7127     }
7128   if (have_dfp)
7129     {
7130       tdep->ppc_dl0_regnum = cur_reg;
7131       cur_reg += 16;
7132     }
7133   if (have_altivec)
7134     {
7135       tdep->ppc_v0_alias_regnum = cur_reg;
7136       cur_reg += 32;
7137     }
7138   if (have_vsx)
7139     {
7140       tdep->ppc_vsr0_regnum = cur_reg;
7141       cur_reg += 64;
7142       tdep->ppc_efpr0_regnum = cur_reg;
7143       cur_reg += 32;
7144     }
7145   if (have_htm_fpu)
7146     {
7147       tdep->ppc_cdl0_regnum = cur_reg;
7148       cur_reg += 16;
7149     }
7150   if (have_htm_vsx)
7151     {
7152       tdep->ppc_cvsr0_regnum = cur_reg;
7153       cur_reg += 64;
7154       tdep->ppc_cefpr0_regnum = cur_reg;
7155       cur_reg += 32;
7156     }
7157
7158   gdb_assert (gdbarch_num_cooked_regs (gdbarch) == cur_reg);
7159
7160   /* Register the ravenscar_arch_ops.  */
7161   if (mach == bfd_mach_ppc_e500)
7162     register_e500_ravenscar_ops (gdbarch);
7163   else
7164     register_ppc_ravenscar_ops (gdbarch);
7165
7166   set_gdbarch_disassembler_options (gdbarch, &powerpc_disassembler_options);
7167   set_gdbarch_valid_disassembler_options (gdbarch,
7168                                           disassembler_options_powerpc ());
7169
7170   return gdbarch;
7171 }
7172
7173 static void
7174 rs6000_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
7175 {
7176   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7177
7178   if (tdep == NULL)
7179     return;
7180
7181   /* FIXME: Dump gdbarch_tdep.  */
7182 }
7183
7184 /* PowerPC-specific commands.  */
7185
7186 static void
7187 set_powerpc_command (const char *args, int from_tty)
7188 {
7189   printf_unfiltered (_("\
7190 \"set powerpc\" must be followed by an appropriate subcommand.\n"));
7191   help_list (setpowerpccmdlist, "set powerpc ", all_commands, gdb_stdout);
7192 }
7193
7194 static void
7195 show_powerpc_command (const char *args, int from_tty)
7196 {
7197   cmd_show_list (showpowerpccmdlist, from_tty, "");
7198 }
7199
7200 static void
7201 powerpc_set_soft_float (const char *args, int from_tty,
7202                         struct cmd_list_element *c)
7203 {
7204   struct gdbarch_info info;
7205
7206   /* Update the architecture.  */
7207   gdbarch_info_init (&info);
7208   if (!gdbarch_update_p (info))
7209     internal_error (__FILE__, __LINE__, _("could not update architecture"));
7210 }
7211
7212 static void
7213 powerpc_set_vector_abi (const char *args, int from_tty,
7214                         struct cmd_list_element *c)
7215 {
7216   struct gdbarch_info info;
7217   int vector_abi;
7218
7219   for (vector_abi = POWERPC_VEC_AUTO;
7220        vector_abi != POWERPC_VEC_LAST;
7221        vector_abi++)
7222     if (strcmp (powerpc_vector_abi_string,
7223                 powerpc_vector_strings[vector_abi]) == 0)
7224       {
7225         powerpc_vector_abi_global = (enum powerpc_vector_abi) vector_abi;
7226         break;
7227       }
7228
7229   if (vector_abi == POWERPC_VEC_LAST)
7230     internal_error (__FILE__, __LINE__, _("Invalid vector ABI accepted: %s."),
7231                     powerpc_vector_abi_string);
7232
7233   /* Update the architecture.  */
7234   gdbarch_info_init (&info);
7235   if (!gdbarch_update_p (info))
7236     internal_error (__FILE__, __LINE__, _("could not update architecture"));
7237 }
7238
7239 /* Show the current setting of the exact watchpoints flag.  */
7240
7241 static void
7242 show_powerpc_exact_watchpoints (struct ui_file *file, int from_tty,
7243                                 struct cmd_list_element *c,
7244                                 const char *value)
7245 {
7246   fprintf_filtered (file, _("Use of exact watchpoints is %s.\n"), value);
7247 }
7248
7249 /* Read a PPC instruction from memory.  */
7250
7251 static unsigned int
7252 read_insn (struct frame_info *frame, CORE_ADDR pc)
7253 {
7254   struct gdbarch *gdbarch = get_frame_arch (frame);
7255   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7256
7257   return read_memory_unsigned_integer (pc, 4, byte_order);
7258 }
7259
7260 /* Return non-zero if the instructions at PC match the series
7261    described in PATTERN, or zero otherwise.  PATTERN is an array of
7262    'struct ppc_insn_pattern' objects, terminated by an entry whose
7263    mask is zero.
7264
7265    When the match is successful, fill INSNS[i] with what PATTERN[i]
7266    matched.  If PATTERN[i] is optional, and the instruction wasn't
7267    present, set INSNS[i] to 0 (which is not a valid PPC instruction).
7268    INSNS should have as many elements as PATTERN, minus the terminator.
7269    Note that, if PATTERN contains optional instructions which aren't
7270    present in memory, then INSNS will have holes, so INSNS[i] isn't
7271    necessarily the i'th instruction in memory.  */
7272
7273 int
7274 ppc_insns_match_pattern (struct frame_info *frame, CORE_ADDR pc,
7275                          const struct ppc_insn_pattern *pattern,
7276                          unsigned int *insns)
7277 {
7278   int i;
7279   unsigned int insn;
7280
7281   for (i = 0, insn = 0; pattern[i].mask; i++)
7282     {
7283       if (insn == 0)
7284         insn = read_insn (frame, pc);
7285       insns[i] = 0;
7286       if ((insn & pattern[i].mask) == pattern[i].data)
7287         {
7288           insns[i] = insn;
7289           pc += 4;
7290           insn = 0;
7291         }
7292       else if (!pattern[i].optional)
7293         return 0;
7294     }
7295
7296   return 1;
7297 }
7298
7299 /* Return the 'd' field of the d-form instruction INSN, properly
7300    sign-extended.  */
7301
7302 CORE_ADDR
7303 ppc_insn_d_field (unsigned int insn)
7304 {
7305   return ((((CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000);
7306 }
7307
7308 /* Return the 'ds' field of the ds-form instruction INSN, with the two
7309    zero bits concatenated at the right, and properly
7310    sign-extended.  */
7311
7312 CORE_ADDR
7313 ppc_insn_ds_field (unsigned int insn)
7314 {
7315   return ((((CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000);
7316 }
7317
7318 /* Initialization code.  */
7319
7320 void
7321 _initialize_rs6000_tdep (void)
7322 {
7323   gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep);
7324   gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep);
7325
7326   /* Initialize the standard target descriptions.  */
7327   initialize_tdesc_powerpc_32 ();
7328   initialize_tdesc_powerpc_altivec32 ();
7329   initialize_tdesc_powerpc_vsx32 ();
7330   initialize_tdesc_powerpc_403 ();
7331   initialize_tdesc_powerpc_403gc ();
7332   initialize_tdesc_powerpc_405 ();
7333   initialize_tdesc_powerpc_505 ();
7334   initialize_tdesc_powerpc_601 ();
7335   initialize_tdesc_powerpc_602 ();
7336   initialize_tdesc_powerpc_603 ();
7337   initialize_tdesc_powerpc_604 ();
7338   initialize_tdesc_powerpc_64 ();
7339   initialize_tdesc_powerpc_altivec64 ();
7340   initialize_tdesc_powerpc_vsx64 ();
7341   initialize_tdesc_powerpc_7400 ();
7342   initialize_tdesc_powerpc_750 ();
7343   initialize_tdesc_powerpc_860 ();
7344   initialize_tdesc_powerpc_e500 ();
7345   initialize_tdesc_rs6000 ();
7346
7347   /* Add root prefix command for all "set powerpc"/"show powerpc"
7348      commands.  */
7349   add_prefix_cmd ("powerpc", no_class, set_powerpc_command,
7350                   _("Various PowerPC-specific commands."),
7351                   &setpowerpccmdlist, "set powerpc ", 0, &setlist);
7352
7353   add_prefix_cmd ("powerpc", no_class, show_powerpc_command,
7354                   _("Various PowerPC-specific commands."),
7355                   &showpowerpccmdlist, "show powerpc ", 0, &showlist);
7356
7357   /* Add a command to allow the user to force the ABI.  */
7358   add_setshow_auto_boolean_cmd ("soft-float", class_support,
7359                                 &powerpc_soft_float_global,
7360                                 _("Set whether to use a soft-float ABI."),
7361                                 _("Show whether to use a soft-float ABI."),
7362                                 NULL,
7363                                 powerpc_set_soft_float, NULL,
7364                                 &setpowerpccmdlist, &showpowerpccmdlist);
7365
7366   add_setshow_enum_cmd ("vector-abi", class_support, powerpc_vector_strings,
7367                         &powerpc_vector_abi_string,
7368                         _("Set the vector ABI."),
7369                         _("Show the vector ABI."),
7370                         NULL, powerpc_set_vector_abi, NULL,
7371                         &setpowerpccmdlist, &showpowerpccmdlist);
7372
7373   add_setshow_boolean_cmd ("exact-watchpoints", class_support,
7374                            &target_exact_watchpoints,
7375                            _("\
7376 Set whether to use just one debug register for watchpoints on scalars."),
7377                            _("\
7378 Show whether to use just one debug register for watchpoints on scalars."),
7379                            _("\
7380 If true, GDB will use only one debug register when watching a variable of\n\
7381 scalar type, thus assuming that the variable is accessed through the address\n\
7382 of its first byte."),
7383                            NULL, show_powerpc_exact_watchpoints,
7384                            &setpowerpccmdlist, &showpowerpccmdlist);
7385 }