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 static CORE_ADDR
3408 rs6000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3409 {
3410   return frame_unwind_register_unsigned (next_frame,
3411                                          gdbarch_pc_regnum (gdbarch));
3412 }
3413
3414 static struct frame_id
3415 rs6000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
3416 {
3417   return frame_id_build (get_frame_register_unsigned
3418                           (this_frame, gdbarch_sp_regnum (gdbarch)),
3419                          get_frame_pc (this_frame));
3420 }
3421
3422 struct rs6000_frame_cache
3423 {
3424   CORE_ADDR base;
3425   CORE_ADDR initial_sp;
3426   struct trad_frame_saved_reg *saved_regs;
3427
3428   /* Set BASE_P to true if this frame cache is properly initialized.
3429      Otherwise set to false because some registers or memory cannot
3430      collected.  */
3431   int base_p;
3432   /* Cache PC for building unavailable frame.  */
3433   CORE_ADDR pc;
3434 };
3435
3436 static struct rs6000_frame_cache *
3437 rs6000_frame_cache (struct frame_info *this_frame, void **this_cache)
3438 {
3439   struct rs6000_frame_cache *cache;
3440   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3441   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3442   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3443   struct rs6000_framedata fdata;
3444   int wordsize = tdep->wordsize;
3445   CORE_ADDR func = 0, pc = 0;
3446
3447   if ((*this_cache) != NULL)
3448     return (struct rs6000_frame_cache *) (*this_cache);
3449   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
3450   (*this_cache) = cache;
3451   cache->pc = 0;
3452   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3453
3454   TRY
3455     {
3456       func = get_frame_func (this_frame);
3457       cache->pc = func;
3458       pc = get_frame_pc (this_frame);
3459       skip_prologue (gdbarch, func, pc, &fdata);
3460
3461       /* Figure out the parent's stack pointer.  */
3462
3463       /* NOTE: cagney/2002-04-14: The ->frame points to the inner-most
3464          address of the current frame.  Things might be easier if the
3465          ->frame pointed to the outer-most address of the frame.  In
3466          the mean time, the address of the prev frame is used as the
3467          base address of this frame.  */
3468       cache->base = get_frame_register_unsigned
3469         (this_frame, gdbarch_sp_regnum (gdbarch));
3470     }
3471   CATCH (ex, RETURN_MASK_ERROR)
3472     {
3473       if (ex.error != NOT_AVAILABLE_ERROR)
3474         throw_exception (ex);
3475       return (struct rs6000_frame_cache *) (*this_cache);
3476     }
3477   END_CATCH
3478
3479   /* If the function appears to be frameless, check a couple of likely
3480      indicators that we have simply failed to find the frame setup.
3481      Two common cases of this are missing symbols (i.e.
3482      get_frame_func returns the wrong address or 0), and assembly
3483      stubs which have a fast exit path but set up a frame on the slow
3484      path.
3485
3486      If the LR appears to return to this function, then presume that
3487      we have an ABI compliant frame that we failed to find.  */
3488   if (fdata.frameless && fdata.lr_offset == 0)
3489     {
3490       CORE_ADDR saved_lr;
3491       int make_frame = 0;
3492
3493       saved_lr = get_frame_register_unsigned (this_frame, tdep->ppc_lr_regnum);
3494       if (func == 0 && saved_lr == pc)
3495         make_frame = 1;
3496       else if (func != 0)
3497         {
3498           CORE_ADDR saved_func = get_pc_function_start (saved_lr);
3499           if (func == saved_func)
3500             make_frame = 1;
3501         }
3502
3503       if (make_frame)
3504         {
3505           fdata.frameless = 0;
3506           fdata.lr_offset = tdep->lr_frame_offset;
3507         }
3508     }
3509
3510   if (!fdata.frameless)
3511     {
3512       /* Frameless really means stackless.  */
3513       ULONGEST backchain;
3514
3515       if (safe_read_memory_unsigned_integer (cache->base, wordsize,
3516                                              byte_order, &backchain))
3517         cache->base = (CORE_ADDR) backchain;
3518     }
3519
3520   trad_frame_set_value (cache->saved_regs,
3521                         gdbarch_sp_regnum (gdbarch), cache->base);
3522
3523   /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr.
3524      All fpr's from saved_fpr to fp31 are saved.  */
3525
3526   if (fdata.saved_fpr >= 0)
3527     {
3528       int i;
3529       CORE_ADDR fpr_addr = cache->base + fdata.fpr_offset;
3530
3531       /* If skip_prologue says floating-point registers were saved,
3532          but the current architecture has no floating-point registers,
3533          then that's strange.  But we have no indices to even record
3534          the addresses under, so we just ignore it.  */
3535       if (ppc_floating_point_unit_p (gdbarch))
3536         for (i = fdata.saved_fpr; i < ppc_num_fprs; i++)
3537           {
3538             cache->saved_regs[tdep->ppc_fp0_regnum + i].addr = fpr_addr;
3539             fpr_addr += 8;
3540           }
3541     }
3542
3543   /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr.
3544      All gpr's from saved_gpr to gpr31 are saved (except during the
3545      prologue).  */
3546
3547   if (fdata.saved_gpr >= 0)
3548     {
3549       int i;
3550       CORE_ADDR gpr_addr = cache->base + fdata.gpr_offset;
3551       for (i = fdata.saved_gpr; i < ppc_num_gprs; i++)
3552         {
3553           if (fdata.gpr_mask & (1U << i))
3554             cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = gpr_addr;
3555           gpr_addr += wordsize;
3556         }
3557     }
3558
3559   /* if != -1, fdata.saved_vr is the smallest number of saved_vr.
3560      All vr's from saved_vr to vr31 are saved.  */
3561   if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
3562     {
3563       if (fdata.saved_vr >= 0)
3564         {
3565           int i;
3566           CORE_ADDR vr_addr = cache->base + fdata.vr_offset;
3567           for (i = fdata.saved_vr; i < 32; i++)
3568             {
3569               cache->saved_regs[tdep->ppc_vr0_regnum + i].addr = vr_addr;
3570               vr_addr += register_size (gdbarch, tdep->ppc_vr0_regnum);
3571             }
3572         }
3573     }
3574
3575   /* if != -1, fdata.saved_ev is the smallest number of saved_ev.
3576      All vr's from saved_ev to ev31 are saved. ?????  */
3577   if (tdep->ppc_ev0_regnum != -1)
3578     {
3579       if (fdata.saved_ev >= 0)
3580         {
3581           int i;
3582           CORE_ADDR ev_addr = cache->base + fdata.ev_offset;
3583           CORE_ADDR off = (byte_order == BFD_ENDIAN_BIG ? 4 : 0);
3584
3585           for (i = fdata.saved_ev; i < ppc_num_gprs; i++)
3586             {
3587               cache->saved_regs[tdep->ppc_ev0_regnum + i].addr = ev_addr;
3588               cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = ev_addr + off;
3589               ev_addr += register_size (gdbarch, tdep->ppc_ev0_regnum);
3590             }
3591         }
3592     }
3593
3594   /* If != 0, fdata.cr_offset is the offset from the frame that
3595      holds the CR.  */
3596   if (fdata.cr_offset != 0)
3597     cache->saved_regs[tdep->ppc_cr_regnum].addr
3598       = cache->base + fdata.cr_offset;
3599
3600   /* If != 0, fdata.lr_offset is the offset from the frame that
3601      holds the LR.  */
3602   if (fdata.lr_offset != 0)
3603     cache->saved_regs[tdep->ppc_lr_regnum].addr
3604       = cache->base + fdata.lr_offset;
3605   else if (fdata.lr_register != -1)
3606     cache->saved_regs[tdep->ppc_lr_regnum].realreg = fdata.lr_register;
3607   /* The PC is found in the link register.  */
3608   cache->saved_regs[gdbarch_pc_regnum (gdbarch)] =
3609     cache->saved_regs[tdep->ppc_lr_regnum];
3610
3611   /* If != 0, fdata.vrsave_offset is the offset from the frame that
3612      holds the VRSAVE.  */
3613   if (fdata.vrsave_offset != 0)
3614     cache->saved_regs[tdep->ppc_vrsave_regnum].addr
3615       = cache->base + fdata.vrsave_offset;
3616
3617   if (fdata.alloca_reg < 0)
3618     /* If no alloca register used, then fi->frame is the value of the
3619        %sp for this frame, and it is good enough.  */
3620     cache->initial_sp
3621       = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
3622   else
3623     cache->initial_sp
3624       = get_frame_register_unsigned (this_frame, fdata.alloca_reg);
3625
3626   cache->base_p = 1;
3627   return cache;
3628 }
3629
3630 static void
3631 rs6000_frame_this_id (struct frame_info *this_frame, void **this_cache,
3632                       struct frame_id *this_id)
3633 {
3634   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3635                                                         this_cache);
3636
3637   if (!info->base_p)
3638     {
3639       (*this_id) = frame_id_build_unavailable_stack (info->pc);
3640       return;
3641     }
3642
3643   /* This marks the outermost frame.  */
3644   if (info->base == 0)
3645     return;
3646
3647   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
3648 }
3649
3650 static struct value *
3651 rs6000_frame_prev_register (struct frame_info *this_frame,
3652                             void **this_cache, int regnum)
3653 {
3654   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3655                                                         this_cache);
3656   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3657 }
3658
3659 static const struct frame_unwind rs6000_frame_unwind =
3660 {
3661   NORMAL_FRAME,
3662   default_frame_unwind_stop_reason,
3663   rs6000_frame_this_id,
3664   rs6000_frame_prev_register,
3665   NULL,
3666   default_frame_sniffer
3667 };
3668
3669 /* Allocate and initialize a frame cache for an epilogue frame.
3670    SP is restored and prev-PC is stored in LR.  */
3671
3672 static struct rs6000_frame_cache *
3673 rs6000_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
3674 {
3675   struct rs6000_frame_cache *cache;
3676   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3677   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3678
3679   if (*this_cache)
3680     return (struct rs6000_frame_cache *) *this_cache;
3681
3682   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
3683   (*this_cache) = cache;
3684   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
3685
3686   TRY
3687     {
3688       /* At this point the stack looks as if we just entered the
3689          function, and the return address is stored in LR.  */
3690       CORE_ADDR sp, lr;
3691
3692       sp = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
3693       lr = get_frame_register_unsigned (this_frame, tdep->ppc_lr_regnum);
3694
3695       cache->base = sp;
3696       cache->initial_sp = sp;
3697
3698       trad_frame_set_value (cache->saved_regs,
3699                             gdbarch_pc_regnum (gdbarch), lr);
3700     }
3701   CATCH (ex, RETURN_MASK_ERROR)
3702     {
3703       if (ex.error != NOT_AVAILABLE_ERROR)
3704         throw_exception (ex);
3705     }
3706   END_CATCH
3707
3708   return cache;
3709 }
3710
3711 /* Implementation of frame_unwind.this_id, as defined in frame_unwind.h.
3712    Return the frame ID of an epilogue frame.  */
3713
3714 static void
3715 rs6000_epilogue_frame_this_id (struct frame_info *this_frame,
3716                                void **this_cache, struct frame_id *this_id)
3717 {
3718   CORE_ADDR pc;
3719   struct rs6000_frame_cache *info =
3720     rs6000_epilogue_frame_cache (this_frame, this_cache);
3721
3722   pc = get_frame_func (this_frame);
3723   if (info->base == 0)
3724     (*this_id) = frame_id_build_unavailable_stack (pc);
3725   else
3726     (*this_id) = frame_id_build (info->base, pc);
3727 }
3728
3729 /* Implementation of frame_unwind.prev_register, as defined in frame_unwind.h.
3730    Return the register value of REGNUM in previous frame.  */
3731
3732 static struct value *
3733 rs6000_epilogue_frame_prev_register (struct frame_info *this_frame,
3734                                      void **this_cache, int regnum)
3735 {
3736   struct rs6000_frame_cache *info =
3737     rs6000_epilogue_frame_cache (this_frame, this_cache);
3738   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
3739 }
3740
3741 /* Implementation of frame_unwind.sniffer, as defined in frame_unwind.h.
3742    Check whether this an epilogue frame.  */
3743
3744 static int
3745 rs6000_epilogue_frame_sniffer (const struct frame_unwind *self,
3746                                struct frame_info *this_frame,
3747                                void **this_prologue_cache)
3748 {
3749   if (frame_relative_level (this_frame) == 0)
3750     return rs6000_in_function_epilogue_frame_p (this_frame,
3751                                                 get_frame_arch (this_frame),
3752                                                 get_frame_pc (this_frame));
3753   else
3754     return 0;
3755 }
3756
3757 /* Frame unwinder for epilogue frame.  This is required for reverse step-over
3758    a function without debug information.  */
3759
3760 static const struct frame_unwind rs6000_epilogue_frame_unwind =
3761 {
3762   NORMAL_FRAME,
3763   default_frame_unwind_stop_reason,
3764   rs6000_epilogue_frame_this_id, rs6000_epilogue_frame_prev_register,
3765   NULL,
3766   rs6000_epilogue_frame_sniffer
3767 };
3768 \f
3769
3770 static CORE_ADDR
3771 rs6000_frame_base_address (struct frame_info *this_frame, void **this_cache)
3772 {
3773   struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
3774                                                         this_cache);
3775   return info->initial_sp;
3776 }
3777
3778 static const struct frame_base rs6000_frame_base = {
3779   &rs6000_frame_unwind,
3780   rs6000_frame_base_address,
3781   rs6000_frame_base_address,
3782   rs6000_frame_base_address
3783 };
3784
3785 static const struct frame_base *
3786 rs6000_frame_base_sniffer (struct frame_info *this_frame)
3787 {
3788   return &rs6000_frame_base;
3789 }
3790
3791 /* DWARF-2 frame support.  Used to handle the detection of
3792   clobbered registers during function calls.  */
3793
3794 static void
3795 ppc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
3796                             struct dwarf2_frame_state_reg *reg,
3797                             struct frame_info *this_frame)
3798 {
3799   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3800
3801   /* PPC32 and PPC64 ABI's are the same regarding volatile and
3802      non-volatile registers.  We will use the same code for both.  */
3803
3804   /* Call-saved GP registers.  */
3805   if ((regnum >= tdep->ppc_gp0_regnum + 14
3806       && regnum <= tdep->ppc_gp0_regnum + 31)
3807       || (regnum == tdep->ppc_gp0_regnum + 1))
3808     reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3809
3810   /* Call-clobbered GP registers.  */
3811   if ((regnum >= tdep->ppc_gp0_regnum + 3
3812       && regnum <= tdep->ppc_gp0_regnum + 12)
3813       || (regnum == tdep->ppc_gp0_regnum))
3814     reg->how = DWARF2_FRAME_REG_UNDEFINED;
3815
3816   /* Deal with FP registers, if supported.  */
3817   if (tdep->ppc_fp0_regnum >= 0)
3818     {
3819       /* Call-saved FP registers.  */
3820       if ((regnum >= tdep->ppc_fp0_regnum + 14
3821           && regnum <= tdep->ppc_fp0_regnum + 31))
3822         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3823
3824       /* Call-clobbered FP registers.  */
3825       if ((regnum >= tdep->ppc_fp0_regnum
3826           && regnum <= tdep->ppc_fp0_regnum + 13))
3827         reg->how = DWARF2_FRAME_REG_UNDEFINED;
3828     }
3829
3830   /* Deal with ALTIVEC registers, if supported.  */
3831   if (tdep->ppc_vr0_regnum > 0 && tdep->ppc_vrsave_regnum > 0)
3832     {
3833       /* Call-saved Altivec registers.  */
3834       if ((regnum >= tdep->ppc_vr0_regnum + 20
3835           && regnum <= tdep->ppc_vr0_regnum + 31)
3836           || regnum == tdep->ppc_vrsave_regnum)
3837         reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3838
3839       /* Call-clobbered Altivec registers.  */
3840       if ((regnum >= tdep->ppc_vr0_regnum
3841           && regnum <= tdep->ppc_vr0_regnum + 19))
3842         reg->how = DWARF2_FRAME_REG_UNDEFINED;
3843     }
3844
3845   /* Handle PC register and Stack Pointer correctly.  */
3846   if (regnum == gdbarch_pc_regnum (gdbarch))
3847     reg->how = DWARF2_FRAME_REG_RA;
3848   else if (regnum == gdbarch_sp_regnum (gdbarch))
3849     reg->how = DWARF2_FRAME_REG_CFA;
3850 }
3851
3852
3853 /* Return true if a .gnu_attributes section exists in BFD and it
3854    indicates we are using SPE extensions OR if a .PPC.EMB.apuinfo
3855    section exists in BFD and it indicates that SPE extensions are in
3856    use.  Check the .gnu.attributes section first, as the binary might be
3857    compiled for SPE, but not actually using SPE instructions.  */
3858
3859 static int
3860 bfd_uses_spe_extensions (bfd *abfd)
3861 {
3862   asection *sect;
3863   gdb_byte *contents = NULL;
3864   bfd_size_type size;
3865   gdb_byte *ptr;
3866   int success = 0;
3867
3868   if (!abfd)
3869     return 0;
3870
3871 #ifdef HAVE_ELF
3872   /* Using Tag_GNU_Power_ABI_Vector here is a bit of a hack, as the user
3873      could be using the SPE vector abi without actually using any spe
3874      bits whatsoever.  But it's close enough for now.  */
3875   int vector_abi = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_GNU,
3876                                              Tag_GNU_Power_ABI_Vector);
3877   if (vector_abi == 3)
3878     return 1;
3879 #endif
3880
3881   sect = bfd_get_section_by_name (abfd, ".PPC.EMB.apuinfo");
3882   if (!sect)
3883     return 0;
3884
3885   size = bfd_get_section_size (sect);
3886   contents = (gdb_byte *) xmalloc (size);
3887   if (!bfd_get_section_contents (abfd, sect, contents, 0, size))
3888     {
3889       xfree (contents);
3890       return 0;
3891     }
3892
3893   /* Parse the .PPC.EMB.apuinfo section.  The layout is as follows:
3894
3895      struct {
3896        uint32 name_len;
3897        uint32 data_len;
3898        uint32 type;
3899        char name[name_len rounded up to 4-byte alignment];
3900        char data[data_len];
3901      };
3902
3903      Technically, there's only supposed to be one such structure in a
3904      given apuinfo section, but the linker is not always vigilant about
3905      merging apuinfo sections from input files.  Just go ahead and parse
3906      them all, exiting early when we discover the binary uses SPE
3907      insns.
3908
3909      It's not specified in what endianness the information in this
3910      section is stored.  Assume that it's the endianness of the BFD.  */
3911   ptr = contents;
3912   while (1)
3913     {
3914       unsigned int name_len;
3915       unsigned int data_len;
3916       unsigned int type;
3917
3918       /* If we can't read the first three fields, we're done.  */
3919       if (size < 12)
3920         break;
3921
3922       name_len = bfd_get_32 (abfd, ptr);
3923       name_len = (name_len + 3) & ~3U; /* Round to 4 bytes.  */
3924       data_len = bfd_get_32 (abfd, ptr + 4);
3925       type = bfd_get_32 (abfd, ptr + 8);
3926       ptr += 12;
3927
3928       /* The name must be "APUinfo\0".  */
3929       if (name_len != 8
3930           && strcmp ((const char *) ptr, "APUinfo") != 0)
3931         break;
3932       ptr += name_len;
3933
3934       /* The type must be 2.  */
3935       if (type != 2)
3936         break;
3937
3938       /* The data is stored as a series of uint32.  The upper half of
3939          each uint32 indicates the particular APU used and the lower
3940          half indicates the revision of that APU.  We just care about
3941          the upper half.  */
3942
3943       /* Not 4-byte quantities.  */
3944       if (data_len & 3U)
3945         break;
3946
3947       while (data_len)
3948         {
3949           unsigned int apuinfo = bfd_get_32 (abfd, ptr);
3950           unsigned int apu = apuinfo >> 16;
3951           ptr += 4;
3952           data_len -= 4;
3953
3954           /* The SPE APU is 0x100; the SPEFP APU is 0x101.  Accept
3955              either.  */
3956           if (apu == 0x100 || apu == 0x101)
3957             {
3958               success = 1;
3959               data_len = 0;
3960             }
3961         }
3962
3963       if (success)
3964         break;
3965     }
3966
3967   xfree (contents);
3968   return success;
3969 }
3970
3971 /* These are macros for parsing instruction fields (I.1.6.28)  */
3972
3973 #define PPC_FIELD(value, from, len) \
3974         (((value) >> (32 - (from) - (len))) & ((1 << (len)) - 1))
3975 #define PPC_SEXT(v, bs) \
3976         ((((CORE_ADDR) (v) & (((CORE_ADDR) 1 << (bs)) - 1)) \
3977           ^ ((CORE_ADDR) 1 << ((bs) - 1))) \
3978          - ((CORE_ADDR) 1 << ((bs) - 1)))
3979 #define PPC_OP6(insn)   PPC_FIELD (insn, 0, 6)
3980 #define PPC_EXTOP(insn) PPC_FIELD (insn, 21, 10)
3981 #define PPC_RT(insn)    PPC_FIELD (insn, 6, 5)
3982 #define PPC_RS(insn)    PPC_FIELD (insn, 6, 5)
3983 #define PPC_RA(insn)    PPC_FIELD (insn, 11, 5)
3984 #define PPC_RB(insn)    PPC_FIELD (insn, 16, 5)
3985 #define PPC_NB(insn)    PPC_FIELD (insn, 16, 5)
3986 #define PPC_VRT(insn)   PPC_FIELD (insn, 6, 5)
3987 #define PPC_FRT(insn)   PPC_FIELD (insn, 6, 5)
3988 #define PPC_SPR(insn)   (PPC_FIELD (insn, 11, 5) \
3989                         | (PPC_FIELD (insn, 16, 5) << 5))
3990 #define PPC_BO(insn)    PPC_FIELD (insn, 6, 5)
3991 #define PPC_T(insn)     PPC_FIELD (insn, 6, 5)
3992 #define PPC_D(insn)     PPC_SEXT (PPC_FIELD (insn, 16, 16), 16)
3993 #define PPC_DS(insn)    PPC_SEXT (PPC_FIELD (insn, 16, 14), 14)
3994 #define PPC_DQ(insn)    PPC_SEXT (PPC_FIELD (insn, 16, 12), 12)
3995 #define PPC_BIT(insn,n) ((insn & (1 << (31 - (n)))) ? 1 : 0)
3996 #define PPC_OE(insn)    PPC_BIT (insn, 21)
3997 #define PPC_RC(insn)    PPC_BIT (insn, 31)
3998 #define PPC_Rc(insn)    PPC_BIT (insn, 21)
3999 #define PPC_LK(insn)    PPC_BIT (insn, 31)
4000 #define PPC_TX(insn)    PPC_BIT (insn, 31)
4001 #define PPC_LEV(insn)   PPC_FIELD (insn, 20, 7)
4002
4003 #define PPC_XT(insn)    ((PPC_TX (insn) << 5) | PPC_T (insn))
4004 #define PPC_XER_NB(xer) (xer & 0x7f)
4005
4006 /* Record Vector-Scalar Registers.
4007    For VSR less than 32, it's represented by an FPR and an VSR-upper register.
4008    Otherwise, it's just a VR register.  Record them accordingly.  */
4009
4010 static int
4011 ppc_record_vsr (struct regcache *regcache, struct gdbarch_tdep *tdep, int vsr)
4012 {
4013   if (vsr < 0 || vsr >= 64)
4014     return -1;
4015
4016   if (vsr >= 32)
4017     {
4018       if (tdep->ppc_vr0_regnum >= 0)
4019         record_full_arch_list_add_reg (regcache, tdep->ppc_vr0_regnum + vsr - 32);
4020     }
4021   else
4022     {
4023       if (tdep->ppc_fp0_regnum >= 0)
4024         record_full_arch_list_add_reg (regcache, tdep->ppc_fp0_regnum + vsr);
4025       if (tdep->ppc_vsr0_upper_regnum >= 0)
4026         record_full_arch_list_add_reg (regcache,
4027                                        tdep->ppc_vsr0_upper_regnum + vsr);
4028     }
4029
4030   return 0;
4031 }
4032
4033 /* Parse and record instructions primary opcode-4 at ADDR.
4034    Return 0 if successful.  */
4035
4036 static int
4037 ppc_process_record_op4 (struct gdbarch *gdbarch, struct regcache *regcache,
4038                         CORE_ADDR addr, uint32_t insn)
4039 {
4040   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4041   int ext = PPC_FIELD (insn, 21, 11);
4042   int vra = PPC_FIELD (insn, 11, 5);
4043
4044   switch (ext & 0x3f)
4045     {
4046     case 32:            /* Vector Multiply-High-Add Signed Halfword Saturate */
4047     case 33:            /* Vector Multiply-High-Round-Add Signed Halfword Saturate */
4048     case 39:            /* Vector Multiply-Sum Unsigned Halfword Saturate */
4049     case 41:            /* Vector Multiply-Sum Signed Halfword Saturate */
4050       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4051       /* FALL-THROUGH */
4052     case 42:            /* Vector Select */
4053     case 43:            /* Vector Permute */
4054     case 59:            /* Vector Permute Right-indexed */
4055     case 44:            /* Vector Shift Left Double by Octet Immediate */
4056     case 45:            /* Vector Permute and Exclusive-OR */
4057     case 60:            /* Vector Add Extended Unsigned Quadword Modulo */
4058     case 61:            /* Vector Add Extended & write Carry Unsigned Quadword */
4059     case 62:            /* Vector Subtract Extended Unsigned Quadword Modulo */
4060     case 63:            /* Vector Subtract Extended & write Carry Unsigned Quadword */
4061     case 34:            /* Vector Multiply-Low-Add Unsigned Halfword Modulo */
4062     case 35:            /* Vector Multiply-Sum Unsigned Doubleword Modulo */
4063     case 36:            /* Vector Multiply-Sum Unsigned Byte Modulo */
4064     case 37:            /* Vector Multiply-Sum Mixed Byte Modulo */
4065     case 38:            /* Vector Multiply-Sum Unsigned Halfword Modulo */
4066     case 40:            /* Vector Multiply-Sum Signed Halfword Modulo */
4067     case 46:            /* Vector Multiply-Add Single-Precision */
4068     case 47:            /* Vector Negative Multiply-Subtract Single-Precision */
4069       record_full_arch_list_add_reg (regcache,
4070                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4071       return 0;
4072
4073     case 48:            /* Multiply-Add High Doubleword */
4074     case 49:            /* Multiply-Add High Doubleword Unsigned */
4075     case 51:            /* Multiply-Add Low Doubleword */
4076       record_full_arch_list_add_reg (regcache,
4077                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4078       return 0;
4079     }
4080
4081   switch ((ext & 0x1ff))
4082     {
4083     case 385:
4084       if (vra != 0      /* Decimal Convert To Signed Quadword */
4085           && vra != 2   /* Decimal Convert From Signed Quadword */
4086           && vra != 4   /* Decimal Convert To Zoned */
4087           && vra != 5   /* Decimal Convert To National */
4088           && vra != 6   /* Decimal Convert From Zoned */
4089           && vra != 7   /* Decimal Convert From National */
4090           && vra != 31) /* Decimal Set Sign */
4091         break;
4092       /* Fall through.  */
4093                         /* 5.16 Decimal Integer Arithmetic Instructions */
4094     case 1:             /* Decimal Add Modulo */
4095     case 65:            /* Decimal Subtract Modulo */
4096
4097     case 193:           /* Decimal Shift */
4098     case 129:           /* Decimal Unsigned Shift */
4099     case 449:           /* Decimal Shift and Round */
4100
4101     case 257:           /* Decimal Truncate */
4102     case 321:           /* Decimal Unsigned Truncate */
4103
4104       /* Bit-21 should be set.  */
4105       if (!PPC_BIT (insn, 21))
4106         break;
4107
4108       record_full_arch_list_add_reg (regcache,
4109                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4110       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4111       return 0;
4112     }
4113
4114   /* Bit-21 is used for RC */
4115   switch (ext & 0x3ff)
4116     {
4117     case 6:             /* Vector Compare Equal To Unsigned Byte */
4118     case 70:            /* Vector Compare Equal To Unsigned Halfword */
4119     case 134:           /* Vector Compare Equal To Unsigned Word */
4120     case 199:           /* Vector Compare Equal To Unsigned Doubleword */
4121     case 774:           /* Vector Compare Greater Than Signed Byte */
4122     case 838:           /* Vector Compare Greater Than Signed Halfword */
4123     case 902:           /* Vector Compare Greater Than Signed Word */
4124     case 967:           /* Vector Compare Greater Than Signed Doubleword */
4125     case 518:           /* Vector Compare Greater Than Unsigned Byte */
4126     case 646:           /* Vector Compare Greater Than Unsigned Word */
4127     case 582:           /* Vector Compare Greater Than Unsigned Halfword */
4128     case 711:           /* Vector Compare Greater Than Unsigned Doubleword */
4129     case 966:           /* Vector Compare Bounds Single-Precision */
4130     case 198:           /* Vector Compare Equal To Single-Precision */
4131     case 454:           /* Vector Compare Greater Than or Equal To Single-Precision */
4132     case 710:           /* Vector Compare Greater Than Single-Precision */
4133     case 7:             /* Vector Compare Not Equal Byte */
4134     case 71:            /* Vector Compare Not Equal Halfword */
4135     case 135:           /* Vector Compare Not Equal Word */
4136     case 263:           /* Vector Compare Not Equal or Zero Byte */
4137     case 327:           /* Vector Compare Not Equal or Zero Halfword */
4138     case 391:           /* Vector Compare Not Equal or Zero Word */
4139       if (PPC_Rc (insn))
4140         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4141       record_full_arch_list_add_reg (regcache,
4142                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4143       return 0;
4144     }
4145
4146   if (ext  == 1538)
4147     {
4148       switch (vra)
4149         {
4150         case 0:         /* Vector Count Leading Zero Least-Significant Bits
4151                            Byte */
4152         case 1:         /* Vector Count Trailing Zero Least-Significant Bits
4153                            Byte */
4154           record_full_arch_list_add_reg (regcache,
4155                                          tdep->ppc_gp0_regnum + PPC_RT (insn));
4156           return 0;
4157
4158         case 6:         /* Vector Negate Word */
4159         case 7:         /* Vector Negate Doubleword */
4160         case 8:         /* Vector Parity Byte Word */
4161         case 9:         /* Vector Parity Byte Doubleword */
4162         case 10:        /* Vector Parity Byte Quadword */
4163         case 16:        /* Vector Extend Sign Byte To Word */
4164         case 17:        /* Vector Extend Sign Halfword To Word */
4165         case 24:        /* Vector Extend Sign Byte To Doubleword */
4166         case 25:        /* Vector Extend Sign Halfword To Doubleword */
4167         case 26:        /* Vector Extend Sign Word To Doubleword */
4168         case 28:        /* Vector Count Trailing Zeros Byte */
4169         case 29:        /* Vector Count Trailing Zeros Halfword */
4170         case 30:        /* Vector Count Trailing Zeros Word */
4171         case 31:        /* Vector Count Trailing Zeros Doubleword */
4172           record_full_arch_list_add_reg (regcache,
4173                                          tdep->ppc_vr0_regnum + PPC_VRT (insn));
4174           return 0;
4175         }
4176     }
4177
4178   switch (ext)
4179     {
4180     case 142:           /* Vector Pack Unsigned Halfword Unsigned Saturate */
4181     case 206:           /* Vector Pack Unsigned Word Unsigned Saturate */
4182     case 270:           /* Vector Pack Signed Halfword Unsigned Saturate */
4183     case 334:           /* Vector Pack Signed Word Unsigned Saturate */
4184     case 398:           /* Vector Pack Signed Halfword Signed Saturate */
4185     case 462:           /* Vector Pack Signed Word Signed Saturate */
4186     case 1230:          /* Vector Pack Unsigned Doubleword Unsigned Saturate */
4187     case 1358:          /* Vector Pack Signed Doubleword Unsigned Saturate */
4188     case 1486:          /* Vector Pack Signed Doubleword Signed Saturate */
4189     case 512:           /* Vector Add Unsigned Byte Saturate */
4190     case 576:           /* Vector Add Unsigned Halfword Saturate */
4191     case 640:           /* Vector Add Unsigned Word Saturate */
4192     case 768:           /* Vector Add Signed Byte Saturate */
4193     case 832:           /* Vector Add Signed Halfword Saturate */
4194     case 896:           /* Vector Add Signed Word Saturate */
4195     case 1536:          /* Vector Subtract Unsigned Byte Saturate */
4196     case 1600:          /* Vector Subtract Unsigned Halfword Saturate */
4197     case 1664:          /* Vector Subtract Unsigned Word Saturate */
4198     case 1792:          /* Vector Subtract Signed Byte Saturate */
4199     case 1856:          /* Vector Subtract Signed Halfword Saturate */
4200     case 1920:          /* Vector Subtract Signed Word Saturate */
4201
4202     case 1544:          /* Vector Sum across Quarter Unsigned Byte Saturate */
4203     case 1800:          /* Vector Sum across Quarter Signed Byte Saturate */
4204     case 1608:          /* Vector Sum across Quarter Signed Halfword Saturate */
4205     case 1672:          /* Vector Sum across Half Signed Word Saturate */
4206     case 1928:          /* Vector Sum across Signed Word Saturate */
4207     case 970:           /* Vector Convert To Signed Fixed-Point Word Saturate */
4208     case 906:           /* Vector Convert To Unsigned Fixed-Point Word Saturate */
4209       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4210       /* FALL-THROUGH */
4211     case 12:            /* Vector Merge High Byte */
4212     case 14:            /* Vector Pack Unsigned Halfword Unsigned Modulo */
4213     case 76:            /* Vector Merge High Halfword */
4214     case 78:            /* Vector Pack Unsigned Word Unsigned Modulo */
4215     case 140:           /* Vector Merge High Word */
4216     case 268:           /* Vector Merge Low Byte */
4217     case 332:           /* Vector Merge Low Halfword */
4218     case 396:           /* Vector Merge Low Word */
4219     case 526:           /* Vector Unpack High Signed Byte */
4220     case 590:           /* Vector Unpack High Signed Halfword */
4221     case 654:           /* Vector Unpack Low Signed Byte */
4222     case 718:           /* Vector Unpack Low Signed Halfword */
4223     case 782:           /* Vector Pack Pixel */
4224     case 846:           /* Vector Unpack High Pixel */
4225     case 974:           /* Vector Unpack Low Pixel */
4226     case 1102:          /* Vector Pack Unsigned Doubleword Unsigned Modulo */
4227     case 1614:          /* Vector Unpack High Signed Word */
4228     case 1676:          /* Vector Merge Odd Word */
4229     case 1742:          /* Vector Unpack Low Signed Word */
4230     case 1932:          /* Vector Merge Even Word */
4231     case 524:           /* Vector Splat Byte */
4232     case 588:           /* Vector Splat Halfword */
4233     case 652:           /* Vector Splat Word */
4234     case 780:           /* Vector Splat Immediate Signed Byte */
4235     case 844:           /* Vector Splat Immediate Signed Halfword */
4236     case 908:           /* Vector Splat Immediate Signed Word */
4237     case 452:           /* Vector Shift Left */
4238     case 708:           /* Vector Shift Right */
4239     case 1036:          /* Vector Shift Left by Octet */
4240     case 1100:          /* Vector Shift Right by Octet */
4241     case 0:             /* Vector Add Unsigned Byte Modulo */
4242     case 64:            /* Vector Add Unsigned Halfword Modulo */
4243     case 128:           /* Vector Add Unsigned Word Modulo */
4244     case 192:           /* Vector Add Unsigned Doubleword Modulo */
4245     case 256:           /* Vector Add Unsigned Quadword Modulo */
4246     case 320:           /* Vector Add & write Carry Unsigned Quadword */
4247     case 384:           /* Vector Add and Write Carry-Out Unsigned Word */
4248     case 8:             /* Vector Multiply Odd Unsigned Byte */
4249     case 72:            /* Vector Multiply Odd Unsigned Halfword */
4250     case 136:           /* Vector Multiply Odd Unsigned Word */
4251     case 264:           /* Vector Multiply Odd Signed Byte */
4252     case 328:           /* Vector Multiply Odd Signed Halfword */
4253     case 392:           /* Vector Multiply Odd Signed Word */
4254     case 520:           /* Vector Multiply Even Unsigned Byte */
4255     case 584:           /* Vector Multiply Even Unsigned Halfword */
4256     case 648:           /* Vector Multiply Even Unsigned Word */
4257     case 776:           /* Vector Multiply Even Signed Byte */
4258     case 840:           /* Vector Multiply Even Signed Halfword */
4259     case 904:           /* Vector Multiply Even Signed Word */
4260     case 137:           /* Vector Multiply Unsigned Word Modulo */
4261     case 1024:          /* Vector Subtract Unsigned Byte Modulo */
4262     case 1088:          /* Vector Subtract Unsigned Halfword Modulo */
4263     case 1152:          /* Vector Subtract Unsigned Word Modulo */
4264     case 1216:          /* Vector Subtract Unsigned Doubleword Modulo */
4265     case 1280:          /* Vector Subtract Unsigned Quadword Modulo */
4266     case 1344:          /* Vector Subtract & write Carry Unsigned Quadword */
4267     case 1408:          /* Vector Subtract and Write Carry-Out Unsigned Word */
4268     case 1282:          /* Vector Average Signed Byte */
4269     case 1346:          /* Vector Average Signed Halfword */
4270     case 1410:          /* Vector Average Signed Word */
4271     case 1026:          /* Vector Average Unsigned Byte */
4272     case 1090:          /* Vector Average Unsigned Halfword */
4273     case 1154:          /* Vector Average Unsigned Word */
4274     case 258:           /* Vector Maximum Signed Byte */
4275     case 322:           /* Vector Maximum Signed Halfword */
4276     case 386:           /* Vector Maximum Signed Word */
4277     case 450:           /* Vector Maximum Signed Doubleword */
4278     case 2:             /* Vector Maximum Unsigned Byte */
4279     case 66:            /* Vector Maximum Unsigned Halfword */
4280     case 130:           /* Vector Maximum Unsigned Word */
4281     case 194:           /* Vector Maximum Unsigned Doubleword */
4282     case 770:           /* Vector Minimum Signed Byte */
4283     case 834:           /* Vector Minimum Signed Halfword */
4284     case 898:           /* Vector Minimum Signed Word */
4285     case 962:           /* Vector Minimum Signed Doubleword */
4286     case 514:           /* Vector Minimum Unsigned Byte */
4287     case 578:           /* Vector Minimum Unsigned Halfword */
4288     case 642:           /* Vector Minimum Unsigned Word */
4289     case 706:           /* Vector Minimum Unsigned Doubleword */
4290     case 1028:          /* Vector Logical AND */
4291     case 1668:          /* Vector Logical Equivalent */
4292     case 1092:          /* Vector Logical AND with Complement */
4293     case 1412:          /* Vector Logical NAND */
4294     case 1348:          /* Vector Logical OR with Complement */
4295     case 1156:          /* Vector Logical OR */
4296     case 1284:          /* Vector Logical NOR */
4297     case 1220:          /* Vector Logical XOR */
4298     case 4:             /* Vector Rotate Left Byte */
4299     case 132:           /* Vector Rotate Left Word VX-form */
4300     case 68:            /* Vector Rotate Left Halfword */
4301     case 196:           /* Vector Rotate Left Doubleword */
4302     case 260:           /* Vector Shift Left Byte */
4303     case 388:           /* Vector Shift Left Word */
4304     case 324:           /* Vector Shift Left Halfword */
4305     case 1476:          /* Vector Shift Left Doubleword */
4306     case 516:           /* Vector Shift Right Byte */
4307     case 644:           /* Vector Shift Right Word */
4308     case 580:           /* Vector Shift Right Halfword */
4309     case 1732:          /* Vector Shift Right Doubleword */
4310     case 772:           /* Vector Shift Right Algebraic Byte */
4311     case 900:           /* Vector Shift Right Algebraic Word */
4312     case 836:           /* Vector Shift Right Algebraic Halfword */
4313     case 964:           /* Vector Shift Right Algebraic Doubleword */
4314     case 10:            /* Vector Add Single-Precision */
4315     case 74:            /* Vector Subtract Single-Precision */
4316     case 1034:          /* Vector Maximum Single-Precision */
4317     case 1098:          /* Vector Minimum Single-Precision */
4318     case 842:           /* Vector Convert From Signed Fixed-Point Word */
4319     case 778:           /* Vector Convert From Unsigned Fixed-Point Word */
4320     case 714:           /* Vector Round to Single-Precision Integer toward -Infinity */
4321     case 522:           /* Vector Round to Single-Precision Integer Nearest */
4322     case 650:           /* Vector Round to Single-Precision Integer toward +Infinity */
4323     case 586:           /* Vector Round to Single-Precision Integer toward Zero */
4324     case 394:           /* Vector 2 Raised to the Exponent Estimate Floating-Point */
4325     case 458:           /* Vector Log Base 2 Estimate Floating-Point */
4326     case 266:           /* Vector Reciprocal Estimate Single-Precision */
4327     case 330:           /* Vector Reciprocal Square Root Estimate Single-Precision */
4328     case 1288:          /* Vector AES Cipher */
4329     case 1289:          /* Vector AES Cipher Last */
4330     case 1352:          /* Vector AES Inverse Cipher */
4331     case 1353:          /* Vector AES Inverse Cipher Last */
4332     case 1480:          /* Vector AES SubBytes */
4333     case 1730:          /* Vector SHA-512 Sigma Doubleword */
4334     case 1666:          /* Vector SHA-256 Sigma Word */
4335     case 1032:          /* Vector Polynomial Multiply-Sum Byte */
4336     case 1160:          /* Vector Polynomial Multiply-Sum Word */
4337     case 1096:          /* Vector Polynomial Multiply-Sum Halfword */
4338     case 1224:          /* Vector Polynomial Multiply-Sum Doubleword */
4339     case 1292:          /* Vector Gather Bits by Bytes by Doubleword */
4340     case 1794:          /* Vector Count Leading Zeros Byte */
4341     case 1858:          /* Vector Count Leading Zeros Halfword */
4342     case 1922:          /* Vector Count Leading Zeros Word */
4343     case 1986:          /* Vector Count Leading Zeros Doubleword */
4344     case 1795:          /* Vector Population Count Byte */
4345     case 1859:          /* Vector Population Count Halfword */
4346     case 1923:          /* Vector Population Count Word */
4347     case 1987:          /* Vector Population Count Doubleword */
4348     case 1356:          /* Vector Bit Permute Quadword */
4349     case 1484:          /* Vector Bit Permute Doubleword */
4350     case 513:           /* Vector Multiply-by-10 Unsigned Quadword */
4351     case 1:             /* Vector Multiply-by-10 & write Carry Unsigned
4352                            Quadword */
4353     case 577:           /* Vector Multiply-by-10 Extended Unsigned Quadword */
4354     case 65:            /* Vector Multiply-by-10 Extended & write Carry
4355                            Unsigned Quadword */
4356     case 1027:          /* Vector Absolute Difference Unsigned Byte */
4357     case 1091:          /* Vector Absolute Difference Unsigned Halfword */
4358     case 1155:          /* Vector Absolute Difference Unsigned Word */
4359     case 1796:          /* Vector Shift Right Variable */
4360     case 1860:          /* Vector Shift Left Variable */
4361     case 133:           /* Vector Rotate Left Word then Mask Insert */
4362     case 197:           /* Vector Rotate Left Doubleword then Mask Insert */
4363     case 389:           /* Vector Rotate Left Word then AND with Mask */
4364     case 453:           /* Vector Rotate Left Doubleword then AND with Mask */
4365     case 525:           /* Vector Extract Unsigned Byte */
4366     case 589:           /* Vector Extract Unsigned Halfword */
4367     case 653:           /* Vector Extract Unsigned Word */
4368     case 717:           /* Vector Extract Doubleword */
4369     case 781:           /* Vector Insert Byte */
4370     case 845:           /* Vector Insert Halfword */
4371     case 909:           /* Vector Insert Word */
4372     case 973:           /* Vector Insert Doubleword */
4373       record_full_arch_list_add_reg (regcache,
4374                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4375       return 0;
4376
4377     case 1549:          /* Vector Extract Unsigned Byte Left-Indexed */
4378     case 1613:          /* Vector Extract Unsigned Halfword Left-Indexed */
4379     case 1677:          /* Vector Extract Unsigned Word Left-Indexed */
4380     case 1805:          /* Vector Extract Unsigned Byte Right-Indexed */
4381     case 1869:          /* Vector Extract Unsigned Halfword Right-Indexed */
4382     case 1933:          /* Vector Extract Unsigned Word Right-Indexed */
4383       record_full_arch_list_add_reg (regcache,
4384                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4385       return 0;
4386
4387     case 1604:          /* Move To Vector Status and Control Register */
4388       record_full_arch_list_add_reg (regcache, PPC_VSCR_REGNUM);
4389       return 0;
4390     case 1540:          /* Move From Vector Status and Control Register */
4391       record_full_arch_list_add_reg (regcache,
4392                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4393       return 0;
4394     case 833:           /* Decimal Copy Sign */
4395       record_full_arch_list_add_reg (regcache,
4396                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4397       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4398       return 0;
4399     }
4400
4401   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
4402                       "at %s, 4-%d.\n", insn, paddress (gdbarch, addr), ext);
4403   return -1;
4404 }
4405
4406 /* Parse and record instructions of primary opcode-19 at ADDR.
4407    Return 0 if successful.  */
4408
4409 static int
4410 ppc_process_record_op19 (struct gdbarch *gdbarch, struct regcache *regcache,
4411                            CORE_ADDR addr, uint32_t insn)
4412 {
4413   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4414   int ext = PPC_EXTOP (insn);
4415
4416   switch (ext & 0x01f)
4417     {
4418     case 2:             /* Add PC Immediate Shifted */
4419       record_full_arch_list_add_reg (regcache,
4420                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4421       return 0;
4422     }
4423
4424   switch (ext)
4425     {
4426     case 0:             /* Move Condition Register Field */
4427     case 33:            /* Condition Register NOR */
4428     case 129:           /* Condition Register AND with Complement */
4429     case 193:           /* Condition Register XOR */
4430     case 225:           /* Condition Register NAND */
4431     case 257:           /* Condition Register AND */
4432     case 289:           /* Condition Register Equivalent */
4433     case 417:           /* Condition Register OR with Complement */
4434     case 449:           /* Condition Register OR */
4435       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4436       return 0;
4437
4438     case 16:            /* Branch Conditional */
4439     case 560:           /* Branch Conditional to Branch Target Address Register */
4440       if ((PPC_BO (insn) & 0x4) == 0)
4441         record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
4442       /* FALL-THROUGH */
4443     case 528:           /* Branch Conditional to Count Register */
4444       if (PPC_LK (insn))
4445         record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
4446       return 0;
4447
4448     case 150:           /* Instruction Synchronize */
4449       /* Do nothing.  */
4450       return 0;
4451     }
4452
4453   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
4454                       "at %s, 19-%d.\n", insn, paddress (gdbarch, addr), ext);
4455   return -1;
4456 }
4457
4458 /* Parse and record instructions of primary opcode-31 at ADDR.
4459    Return 0 if successful.  */
4460
4461 static int
4462 ppc_process_record_op31 (struct gdbarch *gdbarch, struct regcache *regcache,
4463                            CORE_ADDR addr, uint32_t insn)
4464 {
4465   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4466   int ext = PPC_EXTOP (insn);
4467   int tmp, nr, nb, i;
4468   CORE_ADDR at_dcsz, ea = 0;
4469   ULONGEST rb, ra, xer;
4470   int size = 0;
4471
4472   /* These instructions have OE bit.  */
4473   switch (ext & 0x1ff)
4474     {
4475     /* These write RT and XER.  Update CR if RC is set.  */
4476     case 8:             /* Subtract from carrying */
4477     case 10:            /* Add carrying */
4478     case 136:           /* Subtract from extended */
4479     case 138:           /* Add extended */
4480     case 200:           /* Subtract from zero extended */
4481     case 202:           /* Add to zero extended */
4482     case 232:           /* Subtract from minus one extended */
4483     case 234:           /* Add to minus one extended */
4484       /* CA is always altered, but SO/OV are only altered when OE=1.
4485          In any case, XER is always altered.  */
4486       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4487       if (PPC_RC (insn))
4488         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4489       record_full_arch_list_add_reg (regcache,
4490                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4491       return 0;
4492
4493     /* These write RT.  Update CR if RC is set and update XER if OE is set.  */
4494     case 40:            /* Subtract from */
4495     case 104:           /* Negate */
4496     case 233:           /* Multiply low doubleword */
4497     case 235:           /* Multiply low word */
4498     case 266:           /* Add */
4499     case 393:           /* Divide Doubleword Extended Unsigned */
4500     case 395:           /* Divide Word Extended Unsigned */
4501     case 425:           /* Divide Doubleword Extended */
4502     case 427:           /* Divide Word Extended */
4503     case 457:           /* Divide Doubleword Unsigned */
4504     case 459:           /* Divide Word Unsigned */
4505     case 489:           /* Divide Doubleword */
4506     case 491:           /* Divide Word */
4507       if (PPC_OE (insn))
4508         record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4509       /* FALL-THROUGH */
4510     case 9:             /* Multiply High Doubleword Unsigned */
4511     case 11:            /* Multiply High Word Unsigned */
4512     case 73:            /* Multiply High Doubleword */
4513     case 75:            /* Multiply High Word */
4514       if (PPC_RC (insn))
4515         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4516       record_full_arch_list_add_reg (regcache,
4517                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4518       return 0;
4519     }
4520
4521   if ((ext & 0x1f) == 15)
4522     {
4523       /* Integer Select. bit[16:20] is used for BC.  */
4524       record_full_arch_list_add_reg (regcache,
4525                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4526       return 0;
4527     }
4528
4529   if ((ext & 0xff) == 170)
4530     {
4531       /* Add Extended using alternate carry bits */
4532       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4533       record_full_arch_list_add_reg (regcache,
4534                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4535       return 0;
4536     }
4537
4538   switch (ext)
4539     {
4540     case 78:            /* Determine Leftmost Zero Byte */
4541       if (PPC_RC (insn))
4542         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4543       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4544       record_full_arch_list_add_reg (regcache,
4545                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4546       return 0;
4547
4548     /* These only write RT.  */
4549     case 19:            /* Move from condition register */
4550                         /* Move From One Condition Register Field */
4551     case 74:            /* Add and Generate Sixes */
4552     case 74 | 0x200:    /* Add and Generate Sixes (bit-21 dont-care) */
4553     case 302:           /* Move From Branch History Rolling Buffer */
4554     case 339:           /* Move From Special Purpose Register */
4555     case 371:           /* Move From Time Base [Phased-Out]  */
4556     case 309:           /* Load Doubleword Monitored Indexed  */
4557     case 128:           /* Set Boolean */
4558     case 755:           /* Deliver A Random Number */
4559       record_full_arch_list_add_reg (regcache,
4560                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4561       return 0;
4562
4563     /* These only write to RA.  */
4564     case 51:            /* Move From VSR Doubleword */
4565     case 115:           /* Move From VSR Word and Zero */
4566     case 122:           /* Population count bytes */
4567     case 378:           /* Population count words */
4568     case 506:           /* Population count doublewords */
4569     case 154:           /* Parity Word */
4570     case 186:           /* Parity Doubleword */
4571     case 252:           /* Bit Permute Doubleword */
4572     case 282:           /* Convert Declets To Binary Coded Decimal */
4573     case 314:           /* Convert Binary Coded Decimal To Declets */
4574     case 508:           /* Compare bytes */
4575     case 307:           /* Move From VSR Lower Doubleword */
4576       record_full_arch_list_add_reg (regcache,
4577                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4578       return 0;
4579
4580     /* These write CR and optional RA.  */
4581     case 792:           /* Shift Right Algebraic Word */
4582     case 794:           /* Shift Right Algebraic Doubleword */
4583     case 824:           /* Shift Right Algebraic Word Immediate */
4584     case 826:           /* Shift Right Algebraic Doubleword Immediate (413) */
4585     case 826 | 1:       /* Shift Right Algebraic Doubleword Immediate (413) */
4586       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4587       record_full_arch_list_add_reg (regcache,
4588                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4589       /* FALL-THROUGH */
4590     case 0:             /* Compare */
4591     case 32:            /* Compare logical */
4592     case 144:           /* Move To Condition Register Fields */
4593                         /* Move To One Condition Register Field */
4594     case 192:           /* Compare Ranged Byte */
4595     case 224:           /* Compare Equal Byte */
4596     case 576:           /* Move XER to CR Extended */
4597     case 902:           /* Paste (should always fail due to single-stepping and
4598                            the memory location might not be accessible, so
4599                            record only CR) */
4600       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4601       return 0;
4602
4603     /* These write to RT.  Update RA if 'update indexed.'  */
4604     case 53:            /* Load Doubleword with Update Indexed */
4605     case 119:           /* Load Byte and Zero with Update Indexed */
4606     case 311:           /* Load Halfword and Zero with Update Indexed */
4607     case 55:            /* Load Word and Zero with Update Indexed */
4608     case 375:           /* Load Halfword Algebraic with Update Indexed */
4609     case 373:           /* Load Word Algebraic with Update Indexed */
4610       record_full_arch_list_add_reg (regcache,
4611                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4612       /* FALL-THROUGH */
4613     case 21:            /* Load Doubleword Indexed */
4614     case 52:            /* Load Byte And Reserve Indexed */
4615     case 116:           /* Load Halfword And Reserve Indexed */
4616     case 20:            /* Load Word And Reserve Indexed */
4617     case 84:            /* Load Doubleword And Reserve Indexed */
4618     case 87:            /* Load Byte and Zero Indexed */
4619     case 279:           /* Load Halfword and Zero Indexed */
4620     case 23:            /* Load Word and Zero Indexed */
4621     case 343:           /* Load Halfword Algebraic Indexed */
4622     case 341:           /* Load Word Algebraic Indexed */
4623     case 790:           /* Load Halfword Byte-Reverse Indexed */
4624     case 534:           /* Load Word Byte-Reverse Indexed */
4625     case 532:           /* Load Doubleword Byte-Reverse Indexed */
4626     case 582:           /* Load Word Atomic */
4627     case 614:           /* Load Doubleword Atomic */
4628     case 265:           /* Modulo Unsigned Doubleword */
4629     case 777:           /* Modulo Signed Doubleword */
4630     case 267:           /* Modulo Unsigned Word */
4631     case 779:           /* Modulo Signed Word */
4632       record_full_arch_list_add_reg (regcache,
4633                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
4634       return 0;
4635
4636     case 597:           /* Load String Word Immediate */
4637     case 533:           /* Load String Word Indexed */
4638       if (ext == 597)
4639         {
4640         nr = PPC_NB (insn);
4641         if (nr == 0)
4642           nr = 32;
4643         }
4644       else
4645         {
4646           regcache_raw_read_unsigned (regcache, tdep->ppc_xer_regnum, &xer);
4647           nr = PPC_XER_NB (xer);
4648         }
4649
4650       nr = (nr + 3) >> 2;
4651
4652       /* If n=0, the contents of register RT are undefined.  */
4653       if (nr == 0)
4654         nr = 1;
4655
4656       for (i = 0; i < nr; i++)
4657         record_full_arch_list_add_reg (regcache,
4658                                        tdep->ppc_gp0_regnum
4659                                        + ((PPC_RT (insn) + i) & 0x1f));
4660       return 0;
4661
4662     case 276:           /* Load Quadword And Reserve Indexed */
4663       tmp = tdep->ppc_gp0_regnum + (PPC_RT (insn) & ~1);
4664       record_full_arch_list_add_reg (regcache, tmp);
4665       record_full_arch_list_add_reg (regcache, tmp + 1);
4666       return 0;
4667
4668     /* These write VRT.  */
4669     case 6:             /* Load Vector for Shift Left Indexed */
4670     case 38:            /* Load Vector for Shift Right Indexed */
4671     case 7:             /* Load Vector Element Byte Indexed */
4672     case 39:            /* Load Vector Element Halfword Indexed */
4673     case 71:            /* Load Vector Element Word Indexed */
4674     case 103:           /* Load Vector Indexed */
4675     case 359:           /* Load Vector Indexed LRU */
4676       record_full_arch_list_add_reg (regcache,
4677                                      tdep->ppc_vr0_regnum + PPC_VRT (insn));
4678       return 0;
4679
4680     /* These write FRT.  Update RA if 'update indexed.'  */
4681     case 567:           /* Load Floating-Point Single with Update Indexed */
4682     case 631:           /* Load Floating-Point Double with Update Indexed */
4683       record_full_arch_list_add_reg (regcache,
4684                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4685       /* FALL-THROUGH */
4686     case 535:           /* Load Floating-Point Single Indexed */
4687     case 599:           /* Load Floating-Point Double Indexed */
4688     case 855:           /* Load Floating-Point as Integer Word Algebraic Indexed */
4689     case 887:           /* Load Floating-Point as Integer Word and Zero Indexed */
4690       record_full_arch_list_add_reg (regcache,
4691                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
4692       return 0;
4693
4694     case 791:           /* Load Floating-Point Double Pair Indexed */
4695       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
4696       record_full_arch_list_add_reg (regcache, tmp);
4697       record_full_arch_list_add_reg (regcache, tmp + 1);
4698       return 0;
4699
4700     case 179:           /* Move To VSR Doubleword */
4701     case 211:           /* Move To VSR Word Algebraic */
4702     case 243:           /* Move To VSR Word and Zero */
4703     case 588:           /* Load VSX Scalar Doubleword Indexed */
4704     case 524:           /* Load VSX Scalar Single-Precision Indexed */
4705     case 76:            /* Load VSX Scalar as Integer Word Algebraic Indexed */
4706     case 12:            /* Load VSX Scalar as Integer Word and Zero Indexed */
4707     case 844:           /* Load VSX Vector Doubleword*2 Indexed */
4708     case 332:           /* Load VSX Vector Doubleword & Splat Indexed */
4709     case 780:           /* Load VSX Vector Word*4 Indexed */
4710     case 268:           /* Load VSX Vector Indexed */
4711     case 364:           /* Load VSX Vector Word & Splat Indexed */
4712     case 812:           /* Load VSX Vector Halfword*8 Indexed */
4713     case 876:           /* Load VSX Vector Byte*16 Indexed */
4714     case 269:           /* Load VSX Vector with Length */
4715     case 301:           /* Load VSX Vector Left-justified with Length */
4716     case 781:           /* Load VSX Scalar as Integer Byte & Zero Indexed */
4717     case 813:           /* Load VSX Scalar as Integer Halfword & Zero Indexed */
4718     case 403:           /* Move To VSR Word & Splat */
4719     case 435:           /* Move To VSR Double Doubleword */
4720       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
4721       return 0;
4722
4723     /* These write RA.  Update CR if RC is set.  */
4724     case 24:            /* Shift Left Word */
4725     case 26:            /* Count Leading Zeros Word */
4726     case 27:            /* Shift Left Doubleword */
4727     case 28:            /* AND */
4728     case 58:            /* Count Leading Zeros Doubleword */
4729     case 60:            /* AND with Complement */
4730     case 124:           /* NOR */
4731     case 284:           /* Equivalent */
4732     case 316:           /* XOR */
4733     case 476:           /* NAND */
4734     case 412:           /* OR with Complement */
4735     case 444:           /* OR */
4736     case 536:           /* Shift Right Word */
4737     case 539:           /* Shift Right Doubleword */
4738     case 922:           /* Extend Sign Halfword */
4739     case 954:           /* Extend Sign Byte */
4740     case 986:           /* Extend Sign Word */
4741     case 538:           /* Count Trailing Zeros Word */
4742     case 570:           /* Count Trailing Zeros Doubleword */
4743     case 890:           /* Extend-Sign Word and Shift Left Immediate (445) */
4744     case 890 | 1:       /* Extend-Sign Word and Shift Left Immediate (445) */
4745
4746       if (ext == 444 && tdep->ppc_ppr_regnum >= 0
4747           && (PPC_RS (insn) == PPC_RA (insn))
4748           && (PPC_RA (insn) == PPC_RB (insn))
4749           && !PPC_RC (insn))
4750         {
4751           /* or Rx,Rx,Rx alters PRI in PPR.  */
4752           record_full_arch_list_add_reg (regcache, tdep->ppc_ppr_regnum);
4753           return 0;
4754         }
4755
4756       if (PPC_RC (insn))
4757         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4758       record_full_arch_list_add_reg (regcache,
4759                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4760       return 0;
4761
4762     /* Store memory.  */
4763     case 181:           /* Store Doubleword with Update Indexed */
4764     case 183:           /* Store Word with Update Indexed */
4765     case 247:           /* Store Byte with Update Indexed */
4766     case 439:           /* Store Half Word with Update Indexed */
4767     case 695:           /* Store Floating-Point Single with Update Indexed */
4768     case 759:           /* Store Floating-Point Double with Update Indexed */
4769       record_full_arch_list_add_reg (regcache,
4770                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
4771       /* FALL-THROUGH */
4772     case 135:           /* Store Vector Element Byte Indexed */
4773     case 167:           /* Store Vector Element Halfword Indexed */
4774     case 199:           /* Store Vector Element Word Indexed */
4775     case 231:           /* Store Vector Indexed */
4776     case 487:           /* Store Vector Indexed LRU */
4777     case 716:           /* Store VSX Scalar Doubleword Indexed */
4778     case 140:           /* Store VSX Scalar as Integer Word Indexed */
4779     case 652:           /* Store VSX Scalar Single-Precision Indexed */
4780     case 972:           /* Store VSX Vector Doubleword*2 Indexed */
4781     case 908:           /* Store VSX Vector Word*4 Indexed */
4782     case 149:           /* Store Doubleword Indexed */
4783     case 151:           /* Store Word Indexed */
4784     case 215:           /* Store Byte Indexed */
4785     case 407:           /* Store Half Word Indexed */
4786     case 694:           /* Store Byte Conditional Indexed */
4787     case 726:           /* Store Halfword Conditional Indexed */
4788     case 150:           /* Store Word Conditional Indexed */
4789     case 214:           /* Store Doubleword Conditional Indexed */
4790     case 182:           /* Store Quadword Conditional Indexed */
4791     case 662:           /* Store Word Byte-Reverse Indexed */
4792     case 918:           /* Store Halfword Byte-Reverse Indexed */
4793     case 660:           /* Store Doubleword Byte-Reverse Indexed */
4794     case 663:           /* Store Floating-Point Single Indexed */
4795     case 727:           /* Store Floating-Point Double Indexed */
4796     case 919:           /* Store Floating-Point Double Pair Indexed */
4797     case 983:           /* Store Floating-Point as Integer Word Indexed */
4798     case 396:           /* Store VSX Vector Indexed */
4799     case 940:           /* Store VSX Vector Halfword*8 Indexed */
4800     case 1004:          /* Store VSX Vector Byte*16 Indexed */
4801     case 909:           /* Store VSX Scalar as Integer Byte Indexed */
4802     case 941:           /* Store VSX Scalar as Integer Halfword Indexed */
4803       if (ext == 694 || ext == 726 || ext == 150 || ext == 214 || ext == 182)
4804         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4805
4806       ra = 0;
4807       if (PPC_RA (insn) != 0)
4808         regcache_raw_read_unsigned (regcache,
4809                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4810       regcache_raw_read_unsigned (regcache,
4811                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
4812       ea = ra + rb;
4813
4814       switch (ext)
4815         {
4816         case 183:       /* Store Word with Update Indexed */
4817         case 199:       /* Store Vector Element Word Indexed */
4818         case 140:       /* Store VSX Scalar as Integer Word Indexed */
4819         case 652:       /* Store VSX Scalar Single-Precision Indexed */
4820         case 151:       /* Store Word Indexed */
4821         case 150:       /* Store Word Conditional Indexed */
4822         case 662:       /* Store Word Byte-Reverse Indexed */
4823         case 663:       /* Store Floating-Point Single Indexed */
4824         case 695:       /* Store Floating-Point Single with Update Indexed */
4825         case 983:       /* Store Floating-Point as Integer Word Indexed */
4826           size = 4;
4827           break;
4828         case 247:       /* Store Byte with Update Indexed */
4829         case 135:       /* Store Vector Element Byte Indexed */
4830         case 215:       /* Store Byte Indexed */
4831         case 694:       /* Store Byte Conditional Indexed */
4832         case 909:       /* Store VSX Scalar as Integer Byte Indexed */
4833           size = 1;
4834           break;
4835         case 439:       /* Store Halfword with Update Indexed */
4836         case 167:       /* Store Vector Element Halfword Indexed */
4837         case 407:       /* Store Halfword Indexed */
4838         case 726:       /* Store Halfword Conditional Indexed */
4839         case 918:       /* Store Halfword Byte-Reverse Indexed */
4840         case 941:       /* Store VSX Scalar as Integer Halfword Indexed */
4841           size = 2;
4842           break;
4843         case 181:       /* Store Doubleword with Update Indexed */
4844         case 716:       /* Store VSX Scalar Doubleword Indexed */
4845         case 149:       /* Store Doubleword Indexed */
4846         case 214:       /* Store Doubleword Conditional Indexed */
4847         case 660:       /* Store Doubleword Byte-Reverse Indexed */
4848         case 727:       /* Store Floating-Point Double Indexed */
4849         case 759:       /* Store Floating-Point Double with Update Indexed */
4850           size = 8;
4851           break;
4852         case 972:       /* Store VSX Vector Doubleword*2 Indexed */
4853         case 908:       /* Store VSX Vector Word*4 Indexed */
4854         case 182:       /* Store Quadword Conditional Indexed */
4855         case 231:       /* Store Vector Indexed */
4856         case 487:       /* Store Vector Indexed LRU */
4857         case 919:       /* Store Floating-Point Double Pair Indexed */
4858         case 396:       /* Store VSX Vector Indexed */
4859         case 940:       /* Store VSX Vector Halfword*8 Indexed */
4860         case 1004:      /* Store VSX Vector Byte*16 Indexed */
4861           size = 16;
4862           break;
4863         default:
4864           gdb_assert (0);
4865         }
4866
4867       /* Align address for Store Vector instructions.  */
4868       switch (ext)
4869         {
4870         case 167:       /* Store Vector Element Halfword Indexed */
4871           addr = addr & ~0x1ULL;
4872           break;
4873
4874         case 199:       /* Store Vector Element Word Indexed */
4875           addr = addr & ~0x3ULL;
4876           break;
4877
4878         case 231:       /* Store Vector Indexed */
4879         case 487:       /* Store Vector Indexed LRU */
4880           addr = addr & ~0xfULL;
4881           break;
4882         }
4883
4884       record_full_arch_list_add_mem (addr, size);
4885       return 0;
4886
4887     case 397:           /* Store VSX Vector with Length */
4888     case 429:           /* Store VSX Vector Left-justified with Length */
4889       ra = 0;
4890       if (PPC_RA (insn) != 0)
4891         regcache_raw_read_unsigned (regcache,
4892                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4893       ea = ra;
4894       regcache_raw_read_unsigned (regcache,
4895                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
4896       /* Store up to 16 bytes.  */
4897       nb = (rb & 0xff) > 16 ? 16 : (rb & 0xff);
4898       if (nb > 0)
4899         record_full_arch_list_add_mem (ea, nb);
4900       return 0;
4901
4902     case 710:           /* Store Word Atomic */
4903     case 742:           /* Store Doubleword Atomic */
4904       ra = 0;
4905       if (PPC_RA (insn) != 0)
4906         regcache_raw_read_unsigned (regcache,
4907                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4908       ea = ra;
4909       switch (ext)
4910         {
4911         case 710:       /* Store Word Atomic */
4912           size = 8;
4913           break;
4914         case 742:       /* Store Doubleword Atomic */
4915           size = 16;
4916           break;
4917         default:
4918           gdb_assert (0);
4919         }
4920       record_full_arch_list_add_mem (ea, size);
4921       return 0;
4922
4923     case 725:           /* Store String Word Immediate */
4924       ra = 0;
4925       if (PPC_RA (insn) != 0)
4926         regcache_raw_read_unsigned (regcache,
4927                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4928       ea += ra;
4929
4930       nb = PPC_NB (insn);
4931       if (nb == 0)
4932         nb = 32;
4933
4934       record_full_arch_list_add_mem (ea, nb);
4935
4936       return 0;
4937
4938     case 661:           /* Store String Word Indexed */
4939       ra = 0;
4940       if (PPC_RA (insn) != 0)
4941         regcache_raw_read_unsigned (regcache,
4942                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
4943       ea += ra;
4944
4945       regcache_raw_read_unsigned (regcache, tdep->ppc_xer_regnum, &xer);
4946       nb = PPC_XER_NB (xer);
4947
4948       if (nb != 0)
4949         {
4950           regcache_raw_read_unsigned (regcache,
4951                                       tdep->ppc_gp0_regnum + PPC_RB (insn),
4952                                       &rb);
4953           ea += rb;
4954           record_full_arch_list_add_mem (ea, nb);
4955         }
4956
4957       return 0;
4958
4959     case 467:           /* Move To Special Purpose Register */
4960       switch (PPC_SPR (insn))
4961         {
4962         case 1:                 /* XER */
4963           record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4964           return 0;
4965         case 3:                 /* DSCR */
4966           if (tdep->ppc_dscr_regnum >= 0)
4967             record_full_arch_list_add_reg (regcache, tdep->ppc_dscr_regnum);
4968           return 0;
4969         case 8:                 /* LR */
4970           record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
4971           return 0;
4972         case 9:                 /* CTR */
4973           record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
4974           return 0;
4975         case 256:               /* VRSAVE */
4976           record_full_arch_list_add_reg (regcache, tdep->ppc_vrsave_regnum);
4977           return 0;
4978         case 815:               /* TAR */
4979           if (tdep->ppc_tar_regnum >= 0)
4980             record_full_arch_list_add_reg (regcache, tdep->ppc_tar_regnum);
4981           return 0;
4982         case 896:
4983         case 898:               /* PPR */
4984           if (tdep->ppc_ppr_regnum >= 0)
4985             record_full_arch_list_add_reg (regcache, tdep->ppc_ppr_regnum);
4986           return 0;
4987         }
4988
4989       goto UNKNOWN_OP;
4990
4991     case 147:           /* Move To Split Little Endian */
4992       record_full_arch_list_add_reg (regcache, tdep->ppc_ps_regnum);
4993       return 0;
4994
4995     case 512:           /* Move to Condition Register from XER */
4996       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
4997       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
4998       return 0;
4999
5000     case 4:             /* Trap Word */
5001     case 68:            /* Trap Doubleword */
5002     case 430:           /* Clear BHRB */
5003     case 598:           /* Synchronize */
5004     case 62:            /* Wait for Interrupt */
5005     case 30:            /* Wait */
5006     case 22:            /* Instruction Cache Block Touch */
5007     case 854:           /* Enforce In-order Execution of I/O */
5008     case 246:           /* Data Cache Block Touch for Store */
5009     case 54:            /* Data Cache Block Store */
5010     case 86:            /* Data Cache Block Flush */
5011     case 278:           /* Data Cache Block Touch */
5012     case 758:           /* Data Cache Block Allocate */
5013     case 982:           /* Instruction Cache Block Invalidate */
5014     case 774:           /* Copy */
5015     case 838:           /* CP_Abort */
5016       return 0;
5017
5018     case 654:           /* Transaction Begin */
5019     case 686:           /* Transaction End */
5020     case 750:           /* Transaction Suspend or Resume */
5021     case 782:           /* Transaction Abort Word Conditional */
5022     case 814:           /* Transaction Abort Doubleword Conditional */
5023     case 846:           /* Transaction Abort Word Conditional Immediate */
5024     case 878:           /* Transaction Abort Doubleword Conditional Immediate */
5025     case 910:           /* Transaction Abort */
5026       record_full_arch_list_add_reg (regcache, tdep->ppc_ps_regnum);
5027       /* FALL-THROUGH */
5028     case 718:           /* Transaction Check */
5029       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5030       return 0;
5031
5032     case 1014:          /* Data Cache Block set to Zero */
5033       if (target_auxv_search (current_top_target (), AT_DCACHEBSIZE, &at_dcsz) <= 0
5034           || at_dcsz == 0)
5035         at_dcsz = 128; /* Assume 128-byte cache line size (POWER8)  */
5036
5037       ra = 0;
5038       if (PPC_RA (insn) != 0)
5039         regcache_raw_read_unsigned (regcache,
5040                                     tdep->ppc_gp0_regnum + PPC_RA (insn), &ra);
5041       regcache_raw_read_unsigned (regcache,
5042                                   tdep->ppc_gp0_regnum + PPC_RB (insn), &rb);
5043       ea = (ra + rb) & ~((ULONGEST) (at_dcsz - 1));
5044       record_full_arch_list_add_mem (ea, at_dcsz);
5045       return 0;
5046     }
5047
5048 UNKNOWN_OP:
5049   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5050                       "at %s, 31-%d.\n", insn, paddress (gdbarch, addr), ext);
5051   return -1;
5052 }
5053
5054 /* Parse and record instructions of primary opcode-59 at ADDR.
5055    Return 0 if successful.  */
5056
5057 static int
5058 ppc_process_record_op59 (struct gdbarch *gdbarch, struct regcache *regcache,
5059                            CORE_ADDR addr, uint32_t insn)
5060 {
5061   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5062   int ext = PPC_EXTOP (insn);
5063
5064   switch (ext & 0x1f)
5065     {
5066     case 18:            /* Floating Divide */
5067     case 20:            /* Floating Subtract */
5068     case 21:            /* Floating Add */
5069     case 22:            /* Floating Square Root */
5070     case 24:            /* Floating Reciprocal Estimate */
5071     case 25:            /* Floating Multiply */
5072     case 26:            /* Floating Reciprocal Square Root Estimate */
5073     case 28:            /* Floating Multiply-Subtract */
5074     case 29:            /* Floating Multiply-Add */
5075     case 30:            /* Floating Negative Multiply-Subtract */
5076     case 31:            /* Floating Negative Multiply-Add */
5077       record_full_arch_list_add_reg (regcache,
5078                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5079       if (PPC_RC (insn))
5080         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5081       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5082
5083       return 0;
5084     }
5085
5086   switch (ext)
5087     {
5088     case 2:             /* DFP Add */
5089     case 3:             /* DFP Quantize */
5090     case 34:            /* DFP Multiply */
5091     case 35:            /* DFP Reround */
5092     case 67:            /* DFP Quantize Immediate */
5093     case 99:            /* DFP Round To FP Integer With Inexact */
5094     case 227:           /* DFP Round To FP Integer Without Inexact */
5095     case 258:           /* DFP Convert To DFP Long! */
5096     case 290:           /* DFP Convert To Fixed */
5097     case 514:           /* DFP Subtract */
5098     case 546:           /* DFP Divide */
5099     case 770:           /* DFP Round To DFP Short! */
5100     case 802:           /* DFP Convert From Fixed */
5101     case 834:           /* DFP Encode BCD To DPD */
5102       if (PPC_RC (insn))
5103         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5104       record_full_arch_list_add_reg (regcache,
5105                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5106       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5107       return 0;
5108
5109     case 130:           /* DFP Compare Ordered */
5110     case 162:           /* DFP Test Exponent */
5111     case 194:           /* DFP Test Data Class */
5112     case 226:           /* DFP Test Data Group */
5113     case 642:           /* DFP Compare Unordered */
5114     case 674:           /* DFP Test Significance */
5115     case 675:           /* DFP Test Significance Immediate */
5116       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5117       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5118       return 0;
5119
5120     case 66:            /* DFP Shift Significand Left Immediate */
5121     case 98:            /* DFP Shift Significand Right Immediate */
5122     case 322:           /* DFP Decode DPD To BCD */
5123     case 354:           /* DFP Extract Biased Exponent */
5124     case 866:           /* DFP Insert Biased Exponent */
5125       record_full_arch_list_add_reg (regcache,
5126                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5127       if (PPC_RC (insn))
5128         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5129       return 0;
5130
5131     case 846:           /* Floating Convert From Integer Doubleword Single */
5132     case 974:           /* Floating Convert From Integer Doubleword Unsigned
5133                            Single */
5134       record_full_arch_list_add_reg (regcache,
5135                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5136       if (PPC_RC (insn))
5137         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5138       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5139
5140       return 0;
5141     }
5142
5143   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5144                       "at %s, 59-%d.\n", insn, paddress (gdbarch, addr), ext);
5145   return -1;
5146 }
5147
5148 /* Parse and record instructions of primary opcode-60 at ADDR.
5149    Return 0 if successful.  */
5150
5151 static int
5152 ppc_process_record_op60 (struct gdbarch *gdbarch, struct regcache *regcache,
5153                            CORE_ADDR addr, uint32_t insn)
5154 {
5155   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5156   int ext = PPC_EXTOP (insn);
5157
5158   switch (ext >> 2)
5159     {
5160     case 0:             /* VSX Scalar Add Single-Precision */
5161     case 32:            /* VSX Scalar Add Double-Precision */
5162     case 24:            /* VSX Scalar Divide Single-Precision */
5163     case 56:            /* VSX Scalar Divide Double-Precision */
5164     case 176:           /* VSX Scalar Copy Sign Double-Precision */
5165     case 33:            /* VSX Scalar Multiply-Add Double-Precision */
5166     case 41:            /* ditto */
5167     case 1:             /* VSX Scalar Multiply-Add Single-Precision */
5168     case 9:             /* ditto */
5169     case 160:           /* VSX Scalar Maximum Double-Precision */
5170     case 168:           /* VSX Scalar Minimum Double-Precision */
5171     case 49:            /* VSX Scalar Multiply-Subtract Double-Precision */
5172     case 57:            /* ditto */
5173     case 17:            /* VSX Scalar Multiply-Subtract Single-Precision */
5174     case 25:            /* ditto */
5175     case 48:            /* VSX Scalar Multiply Double-Precision */
5176     case 16:            /* VSX Scalar Multiply Single-Precision */
5177     case 161:           /* VSX Scalar Negative Multiply-Add Double-Precision */
5178     case 169:           /* ditto */
5179     case 129:           /* VSX Scalar Negative Multiply-Add Single-Precision */
5180     case 137:           /* ditto */
5181     case 177:           /* VSX Scalar Negative Multiply-Subtract Double-Precision */
5182     case 185:           /* ditto */
5183     case 145:           /* VSX Scalar Negative Multiply-Subtract Single-Precision */
5184     case 153:           /* ditto */
5185     case 40:            /* VSX Scalar Subtract Double-Precision */
5186     case 8:             /* VSX Scalar Subtract Single-Precision */
5187     case 96:            /* VSX Vector Add Double-Precision */
5188     case 64:            /* VSX Vector Add Single-Precision */
5189     case 120:           /* VSX Vector Divide Double-Precision */
5190     case 88:            /* VSX Vector Divide Single-Precision */
5191     case 97:            /* VSX Vector Multiply-Add Double-Precision */
5192     case 105:           /* ditto */
5193     case 65:            /* VSX Vector Multiply-Add Single-Precision */
5194     case 73:            /* ditto */
5195     case 224:           /* VSX Vector Maximum Double-Precision */
5196     case 192:           /* VSX Vector Maximum Single-Precision */
5197     case 232:           /* VSX Vector Minimum Double-Precision */
5198     case 200:           /* VSX Vector Minimum Single-Precision */
5199     case 113:           /* VSX Vector Multiply-Subtract Double-Precision */
5200     case 121:           /* ditto */
5201     case 81:            /* VSX Vector Multiply-Subtract Single-Precision */
5202     case 89:            /* ditto */
5203     case 112:           /* VSX Vector Multiply Double-Precision */
5204     case 80:            /* VSX Vector Multiply Single-Precision */
5205     case 225:           /* VSX Vector Negative Multiply-Add Double-Precision */
5206     case 233:           /* ditto */
5207     case 193:           /* VSX Vector Negative Multiply-Add Single-Precision */
5208     case 201:           /* ditto */
5209     case 241:           /* VSX Vector Negative Multiply-Subtract Double-Precision */
5210     case 249:           /* ditto */
5211     case 209:           /* VSX Vector Negative Multiply-Subtract Single-Precision */
5212     case 217:           /* ditto */
5213     case 104:           /* VSX Vector Subtract Double-Precision */
5214     case 72:            /* VSX Vector Subtract Single-Precision */
5215     case 128:           /* VSX Scalar Maximum Type-C Double-Precision */
5216     case 136:           /* VSX Scalar Minimum Type-C Double-Precision */
5217     case 144:           /* VSX Scalar Maximum Type-J Double-Precision */
5218     case 152:           /* VSX Scalar Minimum Type-J Double-Precision */
5219     case 3:             /* VSX Scalar Compare Equal Double-Precision */
5220     case 11:            /* VSX Scalar Compare Greater Than Double-Precision */
5221     case 19:            /* VSX Scalar Compare Greater Than or Equal
5222                            Double-Precision */
5223       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5224       /* FALL-THROUGH */
5225     case 240:           /* VSX Vector Copy Sign Double-Precision */
5226     case 208:           /* VSX Vector Copy Sign Single-Precision */
5227     case 130:           /* VSX Logical AND */
5228     case 138:           /* VSX Logical AND with Complement */
5229     case 186:           /* VSX Logical Equivalence */
5230     case 178:           /* VSX Logical NAND */
5231     case 170:           /* VSX Logical OR with Complement */
5232     case 162:           /* VSX Logical NOR */
5233     case 146:           /* VSX Logical OR */
5234     case 154:           /* VSX Logical XOR */
5235     case 18:            /* VSX Merge High Word */
5236     case 50:            /* VSX Merge Low Word */
5237     case 10:            /* VSX Permute Doubleword Immediate (DM=0) */
5238     case 10 | 0x20:     /* VSX Permute Doubleword Immediate (DM=1) */
5239     case 10 | 0x40:     /* VSX Permute Doubleword Immediate (DM=2) */
5240     case 10 | 0x60:     /* VSX Permute Doubleword Immediate (DM=3) */
5241     case 2:             /* VSX Shift Left Double by Word Immediate (SHW=0) */
5242     case 2 | 0x20:      /* VSX Shift Left Double by Word Immediate (SHW=1) */
5243     case 2 | 0x40:      /* VSX Shift Left Double by Word Immediate (SHW=2) */
5244     case 2 | 0x60:      /* VSX Shift Left Double by Word Immediate (SHW=3) */
5245     case 216:           /* VSX Vector Insert Exponent Single-Precision */
5246     case 248:           /* VSX Vector Insert Exponent Double-Precision */
5247     case 26:            /* VSX Vector Permute */
5248     case 58:            /* VSX Vector Permute Right-indexed */
5249     case 213:           /* VSX Vector Test Data Class Single-Precision (DC=0) */
5250     case 213 | 0x8:     /* VSX Vector Test Data Class Single-Precision (DC=1) */
5251     case 245:           /* VSX Vector Test Data Class Double-Precision (DC=0) */
5252     case 245 | 0x8:     /* VSX Vector Test Data Class Double-Precision (DC=1) */
5253       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5254       return 0;
5255
5256     case 61:            /* VSX Scalar Test for software Divide Double-Precision */
5257     case 125:           /* VSX Vector Test for software Divide Double-Precision */
5258     case 93:            /* VSX Vector Test for software Divide Single-Precision */
5259       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5260       return 0;
5261
5262     case 35:            /* VSX Scalar Compare Unordered Double-Precision */
5263     case 43:            /* VSX Scalar Compare Ordered Double-Precision */
5264     case 59:            /* VSX Scalar Compare Exponents Double-Precision */
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       return 0;
5268     }
5269
5270   switch ((ext >> 2) & 0x7f) /* Mask out Rc-bit.  */
5271     {
5272     case 99:            /* VSX Vector Compare Equal To Double-Precision */
5273     case 67:            /* VSX Vector Compare Equal To Single-Precision */
5274     case 115:           /* VSX Vector Compare Greater Than or
5275                            Equal To Double-Precision */
5276     case 83:            /* VSX Vector Compare Greater Than or
5277                            Equal To Single-Precision */
5278     case 107:           /* VSX Vector Compare Greater Than Double-Precision */
5279     case 75:            /* VSX Vector Compare Greater Than Single-Precision */
5280       if (PPC_Rc (insn))
5281         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5282       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5283       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5284       return 0;
5285     }
5286
5287   switch (ext >> 1)
5288     {
5289     case 265:           /* VSX Scalar round Double-Precision to
5290                            Single-Precision and Convert to
5291                            Single-Precision format */
5292     case 344:           /* VSX Scalar truncate Double-Precision to
5293                            Integer and Convert to Signed Integer
5294                            Doubleword format with Saturate */
5295     case 88:            /* VSX Scalar truncate Double-Precision to
5296                            Integer and Convert to Signed Integer Word
5297                            Format with Saturate */
5298     case 328:           /* VSX Scalar truncate Double-Precision integer
5299                            and Convert to Unsigned Integer Doubleword
5300                            Format with Saturate */
5301     case 72:            /* VSX Scalar truncate Double-Precision to
5302                            Integer and Convert to Unsigned Integer Word
5303                            Format with Saturate */
5304     case 329:           /* VSX Scalar Convert Single-Precision to
5305                            Double-Precision format */
5306     case 376:           /* VSX Scalar Convert Signed Integer
5307                            Doubleword to floating-point format and
5308                            Round to Double-Precision format */
5309     case 312:           /* VSX Scalar Convert Signed Integer
5310                            Doubleword to floating-point format and
5311                            round to Single-Precision */
5312     case 360:           /* VSX Scalar Convert Unsigned Integer
5313                            Doubleword to floating-point format and
5314                            Round to Double-Precision format */
5315     case 296:           /* VSX Scalar Convert Unsigned Integer
5316                            Doubleword to floating-point format and
5317                            Round to Single-Precision */
5318     case 73:            /* VSX Scalar Round to Double-Precision Integer
5319                            Using Round to Nearest Away */
5320     case 107:           /* VSX Scalar Round to Double-Precision Integer
5321                            Exact using Current rounding mode */
5322     case 121:           /* VSX Scalar Round to Double-Precision Integer
5323                            Using Round toward -Infinity */
5324     case 105:           /* VSX Scalar Round to Double-Precision Integer
5325                            Using Round toward +Infinity */
5326     case 89:            /* VSX Scalar Round to Double-Precision Integer
5327                            Using Round toward Zero */
5328     case 90:            /* VSX Scalar Reciprocal Estimate Double-Precision */
5329     case 26:            /* VSX Scalar Reciprocal Estimate Single-Precision */
5330     case 281:           /* VSX Scalar Round to Single-Precision */
5331     case 74:            /* VSX Scalar Reciprocal Square Root Estimate
5332                            Double-Precision */
5333     case 10:            /* VSX Scalar Reciprocal Square Root Estimate
5334                            Single-Precision */
5335     case 75:            /* VSX Scalar Square Root Double-Precision */
5336     case 11:            /* VSX Scalar Square Root Single-Precision */
5337     case 393:           /* VSX Vector round Double-Precision to
5338                            Single-Precision and Convert to
5339                            Single-Precision format */
5340     case 472:           /* VSX Vector truncate Double-Precision to
5341                            Integer and Convert to Signed Integer
5342                            Doubleword format with Saturate */
5343     case 216:           /* VSX Vector truncate Double-Precision to
5344                            Integer and Convert to Signed Integer Word
5345                            Format with Saturate */
5346     case 456:           /* VSX Vector truncate Double-Precision to
5347                            Integer and Convert to Unsigned Integer
5348                            Doubleword format with Saturate */
5349     case 200:           /* VSX Vector truncate Double-Precision to
5350                            Integer and Convert to Unsigned Integer Word
5351                            Format with Saturate */
5352     case 457:           /* VSX Vector Convert Single-Precision to
5353                            Double-Precision format */
5354     case 408:           /* VSX Vector truncate Single-Precision to
5355                            Integer and Convert to Signed Integer
5356                            Doubleword format with Saturate */
5357     case 152:           /* VSX Vector truncate Single-Precision to
5358                            Integer and Convert to Signed Integer Word
5359                            Format with Saturate */
5360     case 392:           /* VSX Vector truncate Single-Precision to
5361                            Integer and Convert to Unsigned Integer
5362                            Doubleword format with Saturate */
5363     case 136:           /* VSX Vector truncate Single-Precision to
5364                            Integer and Convert to Unsigned Integer Word
5365                            Format with Saturate */
5366     case 504:           /* VSX Vector Convert and round Signed Integer
5367                            Doubleword to Double-Precision format */
5368     case 440:           /* VSX Vector Convert and round Signed Integer
5369                            Doubleword to Single-Precision format */
5370     case 248:           /* VSX Vector Convert Signed Integer Word to
5371                            Double-Precision format */
5372     case 184:           /* VSX Vector Convert and round Signed Integer
5373                            Word to Single-Precision format */
5374     case 488:           /* VSX Vector Convert and round Unsigned
5375                            Integer Doubleword to Double-Precision format */
5376     case 424:           /* VSX Vector Convert and round Unsigned
5377                            Integer Doubleword to Single-Precision format */
5378     case 232:           /* VSX Vector Convert and round Unsigned
5379                            Integer Word to Double-Precision format */
5380     case 168:           /* VSX Vector Convert and round Unsigned
5381                            Integer Word to Single-Precision format */
5382     case 201:           /* VSX Vector Round to Double-Precision
5383                            Integer using round to Nearest Away */
5384     case 235:           /* VSX Vector Round to Double-Precision
5385                            Integer Exact using Current rounding mode */
5386     case 249:           /* VSX Vector Round to Double-Precision
5387                            Integer using round toward -Infinity */
5388     case 233:           /* VSX Vector Round to Double-Precision
5389                            Integer using round toward +Infinity */
5390     case 217:           /* VSX Vector Round to Double-Precision
5391                            Integer using round toward Zero */
5392     case 218:           /* VSX Vector Reciprocal Estimate Double-Precision */
5393     case 154:           /* VSX Vector Reciprocal Estimate Single-Precision */
5394     case 137:           /* VSX Vector Round to Single-Precision Integer
5395                            Using Round to Nearest Away */
5396     case 171:           /* VSX Vector Round to Single-Precision Integer
5397                            Exact Using Current rounding mode */
5398     case 185:           /* VSX Vector Round to Single-Precision Integer
5399                            Using Round toward -Infinity */
5400     case 169:           /* VSX Vector Round to Single-Precision Integer
5401                            Using Round toward +Infinity */
5402     case 153:           /* VSX Vector Round to Single-Precision Integer
5403                            Using round toward Zero */
5404     case 202:           /* VSX Vector Reciprocal Square Root Estimate
5405                            Double-Precision */
5406     case 138:           /* VSX Vector Reciprocal Square Root Estimate
5407                            Single-Precision */
5408     case 203:           /* VSX Vector Square Root Double-Precision */
5409     case 139:           /* VSX Vector Square Root Single-Precision */
5410       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5411       /* FALL-THROUGH */
5412     case 345:           /* VSX Scalar Absolute Value Double-Precision */
5413     case 267:           /* VSX Scalar Convert Scalar Single-Precision to
5414                            Vector Single-Precision format Non-signalling */
5415     case 331:           /* VSX Scalar Convert Single-Precision to
5416                            Double-Precision format Non-signalling */
5417     case 361:           /* VSX Scalar Negative Absolute Value Double-Precision */
5418     case 377:           /* VSX Scalar Negate Double-Precision */
5419     case 473:           /* VSX Vector Absolute Value Double-Precision */
5420     case 409:           /* VSX Vector Absolute Value Single-Precision */
5421     case 489:           /* VSX Vector Negative Absolute Value Double-Precision */
5422     case 425:           /* VSX Vector Negative Absolute Value Single-Precision */
5423     case 505:           /* VSX Vector Negate Double-Precision */
5424     case 441:           /* VSX Vector Negate Single-Precision */
5425     case 164:           /* VSX Splat Word */
5426     case 165:           /* VSX Vector Extract Unsigned Word */
5427     case 181:           /* VSX Vector Insert Word */
5428       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5429       return 0;
5430
5431     case 298:           /* VSX Scalar Test Data Class Single-Precision */
5432     case 362:           /* VSX Scalar Test Data Class Double-Precision */
5433       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5434       /* FALL-THROUGH */
5435     case 106:           /* VSX Scalar Test for software Square Root
5436                            Double-Precision */
5437     case 234:           /* VSX Vector Test for software Square Root
5438                            Double-Precision */
5439     case 170:           /* VSX Vector Test for software Square Root
5440                            Single-Precision */
5441       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5442       return 0;
5443
5444     case 347:
5445       switch (PPC_FIELD (insn, 11, 5))
5446         {
5447         case 0:         /* VSX Scalar Extract Exponent Double-Precision */
5448         case 1:         /* VSX Scalar Extract Significand Double-Precision */
5449           record_full_arch_list_add_reg (regcache,
5450                                          tdep->ppc_gp0_regnum + PPC_RT (insn));
5451           return 0;
5452         case 16:        /* VSX Scalar Convert Half-Precision format to
5453                            Double-Precision format */
5454         case 17:        /* VSX Scalar round & Convert Double-Precision format
5455                            to Half-Precision format */
5456           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5457           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5458           return 0;
5459         }
5460       break;
5461
5462     case 475:
5463       switch (PPC_FIELD (insn, 11, 5))
5464         {
5465         case 24:        /* VSX Vector Convert Half-Precision format to
5466                            Single-Precision format */
5467         case 25:        /* VSX Vector round and Convert Single-Precision format
5468                            to Half-Precision format */
5469           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5470           /* FALL-THROUGH */
5471         case 0:         /* VSX Vector Extract Exponent Double-Precision */
5472         case 1:         /* VSX Vector Extract Significand Double-Precision */
5473         case 7:         /* VSX Vector Byte-Reverse Halfword */
5474         case 8:         /* VSX Vector Extract Exponent Single-Precision */
5475         case 9:         /* VSX Vector Extract Significand Single-Precision */
5476         case 15:        /* VSX Vector Byte-Reverse Word */
5477         case 23:        /* VSX Vector Byte-Reverse Doubleword */
5478         case 31:        /* VSX Vector Byte-Reverse Quadword */
5479           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5480           return 0;
5481         }
5482       break;
5483     }
5484
5485   switch (ext)
5486     {
5487     case 360:           /* VSX Vector Splat Immediate Byte */
5488       if (PPC_FIELD (insn, 11, 2) == 0)
5489         {
5490           ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5491           return 0;
5492         }
5493       break;
5494     case 918:           /* VSX Scalar Insert Exponent Double-Precision */
5495       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5496       return 0;
5497     }
5498
5499   if (((ext >> 3) & 0x3) == 3)  /* VSX Select */
5500     {
5501       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5502       return 0;
5503     }
5504
5505   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5506                       "at %s, 60-%d.\n", insn, paddress (gdbarch, addr), ext);
5507   return -1;
5508 }
5509
5510 /* Parse and record instructions of primary opcode-61 at ADDR.
5511    Return 0 if successful.  */
5512
5513 static int
5514 ppc_process_record_op61 (struct gdbarch *gdbarch, struct regcache *regcache,
5515                            CORE_ADDR addr, uint32_t insn)
5516 {
5517   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5518   ULONGEST ea = 0;
5519   int size;
5520
5521   switch (insn & 0x3)
5522     {
5523     case 0:             /* Store Floating-Point Double Pair */
5524     case 2:             /* Store VSX Scalar Doubleword */
5525     case 3:             /* Store VSX Scalar Single */
5526       if (PPC_RA (insn) != 0)
5527         regcache_raw_read_unsigned (regcache,
5528                                     tdep->ppc_gp0_regnum + PPC_RA (insn),
5529                                     &ea);
5530       ea += PPC_DS (insn) << 2;
5531       switch (insn & 0x3)
5532         {
5533         case 0:         /* Store Floating-Point Double Pair */
5534           size = 16;
5535           break;
5536         case 2:         /* Store VSX Scalar Doubleword */
5537           size = 8;
5538           break;
5539         case 3:         /* Store VSX Scalar Single */
5540           size = 4;
5541           break;
5542         default:
5543           gdb_assert (0);
5544         }
5545       record_full_arch_list_add_mem (ea, size);
5546       return 0;
5547     }
5548
5549   switch (insn & 0x7)
5550     {
5551     case 1:             /* Load VSX Vector */
5552       ppc_record_vsr (regcache, tdep, PPC_XT (insn));
5553       return 0;
5554     case 5:             /* Store VSX Vector */
5555       if (PPC_RA (insn) != 0)
5556         regcache_raw_read_unsigned (regcache,
5557                                     tdep->ppc_gp0_regnum + PPC_RA (insn),
5558                                     &ea);
5559       ea += PPC_DQ (insn) << 4;
5560       record_full_arch_list_add_mem (ea, 16);
5561       return 0;
5562     }
5563
5564   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5565                       "at %s.\n", insn, paddress (gdbarch, addr));
5566   return -1;
5567 }
5568
5569 /* Parse and record instructions of primary opcode-63 at ADDR.
5570    Return 0 if successful.  */
5571
5572 static int
5573 ppc_process_record_op63 (struct gdbarch *gdbarch, struct regcache *regcache,
5574                            CORE_ADDR addr, uint32_t insn)
5575 {
5576   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5577   int ext = PPC_EXTOP (insn);
5578   int tmp;
5579
5580   switch (ext & 0x1f)
5581     {
5582     case 18:            /* Floating Divide */
5583     case 20:            /* Floating Subtract */
5584     case 21:            /* Floating Add */
5585     case 22:            /* Floating Square Root */
5586     case 24:            /* Floating Reciprocal Estimate */
5587     case 25:            /* Floating Multiply */
5588     case 26:            /* Floating Reciprocal Square Root Estimate */
5589     case 28:            /* Floating Multiply-Subtract */
5590     case 29:            /* Floating Multiply-Add */
5591     case 30:            /* Floating Negative Multiply-Subtract */
5592     case 31:            /* Floating Negative Multiply-Add */
5593       record_full_arch_list_add_reg (regcache,
5594                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5595       if (PPC_RC (insn))
5596         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5597       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5598       return 0;
5599
5600     case 23:            /* Floating Select */
5601       record_full_arch_list_add_reg (regcache,
5602                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5603       if (PPC_RC (insn))
5604         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5605       return 0;
5606     }
5607
5608   switch (ext & 0xff)
5609     {
5610     case 5:             /* VSX Scalar Round to Quad-Precision Integer */
5611     case 37:            /* VSX Scalar Round Quad-Precision to Double-Extended
5612                            Precision */
5613       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5614       ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5615       return 0;
5616     }
5617
5618   switch (ext)
5619     {
5620     case 2:             /* DFP Add Quad */
5621     case 3:             /* DFP Quantize Quad */
5622     case 34:            /* DFP Multiply Quad */
5623     case 35:            /* DFP Reround Quad */
5624     case 67:            /* DFP Quantize Immediate Quad */
5625     case 99:            /* DFP Round To FP Integer With Inexact Quad */
5626     case 227:           /* DFP Round To FP Integer Without Inexact Quad */
5627     case 258:           /* DFP Convert To DFP Extended Quad */
5628     case 514:           /* DFP Subtract Quad */
5629     case 546:           /* DFP Divide Quad */
5630     case 770:           /* DFP Round To DFP Long Quad */
5631     case 802:           /* DFP Convert From Fixed Quad */
5632     case 834:           /* DFP Encode BCD To DPD Quad */
5633       if (PPC_RC (insn))
5634         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5635       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
5636       record_full_arch_list_add_reg (regcache, tmp);
5637       record_full_arch_list_add_reg (regcache, tmp + 1);
5638       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5639       return 0;
5640
5641     case 130:           /* DFP Compare Ordered Quad */
5642     case 162:           /* DFP Test Exponent Quad */
5643     case 194:           /* DFP Test Data Class Quad */
5644     case 226:           /* DFP Test Data Group Quad */
5645     case 642:           /* DFP Compare Unordered Quad */
5646     case 674:           /* DFP Test Significance Quad */
5647     case 675:           /* DFP Test Significance Immediate Quad */
5648       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5649       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5650       return 0;
5651
5652     case 66:            /* DFP Shift Significand Left Immediate Quad */
5653     case 98:            /* DFP Shift Significand Right Immediate Quad */
5654     case 322:           /* DFP Decode DPD To BCD Quad */
5655     case 866:           /* DFP Insert Biased Exponent Quad */
5656       tmp = tdep->ppc_fp0_regnum + (PPC_FRT (insn) & ~1);
5657       record_full_arch_list_add_reg (regcache, tmp);
5658       record_full_arch_list_add_reg (regcache, tmp + 1);
5659       if (PPC_RC (insn))
5660         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5661       return 0;
5662
5663     case 290:           /* DFP Convert To Fixed Quad */
5664       record_full_arch_list_add_reg (regcache,
5665                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5666       if (PPC_RC (insn))
5667         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5668       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5669       return 0;
5670
5671     case 354:           /* DFP Extract Biased Exponent Quad */
5672       record_full_arch_list_add_reg (regcache,
5673                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5674       if (PPC_RC (insn))
5675         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5676       return 0;
5677
5678     case 12:            /* Floating Round to Single-Precision */
5679     case 14:            /* Floating Convert To Integer Word */
5680     case 15:            /* Floating Convert To Integer Word
5681                            with round toward Zero */
5682     case 142:           /* Floating Convert To Integer Word Unsigned */
5683     case 143:           /* Floating Convert To Integer Word Unsigned
5684                            with round toward Zero */
5685     case 392:           /* Floating Round to Integer Nearest */
5686     case 424:           /* Floating Round to Integer Toward Zero */
5687     case 456:           /* Floating Round to Integer Plus */
5688     case 488:           /* Floating Round to Integer Minus */
5689     case 814:           /* Floating Convert To Integer Doubleword */
5690     case 815:           /* Floating Convert To Integer Doubleword
5691                            with round toward Zero */
5692     case 846:           /* Floating Convert From Integer Doubleword */
5693     case 942:           /* Floating Convert To Integer Doubleword Unsigned */
5694     case 943:           /* Floating Convert To Integer Doubleword Unsigned
5695                            with round toward Zero */
5696     case 974:           /* Floating Convert From Integer Doubleword Unsigned */
5697       record_full_arch_list_add_reg (regcache,
5698                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5699       if (PPC_RC (insn))
5700         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5701       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5702       return 0;
5703
5704     case 583:
5705       switch (PPC_FIELD (insn, 11, 5))
5706         {
5707           case 1:       /* Move From FPSCR & Clear Enables */
5708           case 20:      /* Move From FPSCR Control & set DRN */
5709           case 21:      /* Move From FPSCR Control & set DRN Immediate */
5710           case 22:      /* Move From FPSCR Control & set RN */
5711           case 23:      /* Move From FPSCR Control & set RN Immediate */
5712             record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5713             /* Fall through.  */
5714           case 0:       /* Move From FPSCR */
5715           case 24:      /* Move From FPSCR Lightweight */
5716             if (PPC_FIELD (insn, 11, 5) == 0 && PPC_RC (insn))
5717               record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5718             record_full_arch_list_add_reg (regcache,
5719                                            tdep->ppc_fp0_regnum
5720                                            + PPC_FRT (insn));
5721             return 0;
5722         }
5723       break;
5724
5725     case 8:             /* Floating Copy Sign */
5726     case 40:            /* Floating Negate */
5727     case 72:            /* Floating Move Register */
5728     case 136:           /* Floating Negative Absolute Value */
5729     case 264:           /* Floating Absolute Value */
5730       record_full_arch_list_add_reg (regcache,
5731                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5732       if (PPC_RC (insn))
5733         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5734       return 0;
5735
5736     case 838:           /* Floating Merge Odd Word */
5737     case 966:           /* Floating Merge Even Word */
5738       record_full_arch_list_add_reg (regcache,
5739                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5740       return 0;
5741
5742     case 38:            /* Move To FPSCR Bit 1 */
5743     case 70:            /* Move To FPSCR Bit 0 */
5744     case 134:           /* Move To FPSCR Field Immediate */
5745     case 711:           /* Move To FPSCR Fields */
5746       if (PPC_RC (insn))
5747         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5748       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5749       return 0;
5750
5751     case 0:             /* Floating Compare Unordered */
5752     case 32:            /* Floating Compare Ordered */
5753     case 64:            /* Move to Condition Register from FPSCR */
5754     case 132:           /* VSX Scalar Compare Ordered Quad-Precision */
5755     case 164:           /* VSX Scalar Compare Exponents Quad-Precision */
5756     case 644:           /* VSX Scalar Compare Unordered Quad-Precision */
5757     case 708:           /* VSX Scalar Test Data Class Quad-Precision */
5758       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5759       /* FALL-THROUGH */
5760     case 128:           /* Floating Test for software Divide */
5761     case 160:           /* Floating Test for software Square Root */
5762       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5763       return 0;
5764
5765     case 4:             /* VSX Scalar Add Quad-Precision */
5766     case 36:            /* VSX Scalar Multiply Quad-Precision */
5767     case 388:           /* VSX Scalar Multiply-Add Quad-Precision */
5768     case 420:           /* VSX Scalar Multiply-Subtract Quad-Precision */
5769     case 452:           /* VSX Scalar Negative Multiply-Add Quad-Precision */
5770     case 484:           /* VSX Scalar Negative Multiply-Subtract
5771                            Quad-Precision */
5772     case 516:           /* VSX Scalar Subtract Quad-Precision */
5773     case 548:           /* VSX Scalar Divide Quad-Precision */
5774       record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5775       /* FALL-THROUGH */
5776     case 100:           /* VSX Scalar Copy Sign Quad-Precision */
5777     case 868:           /* VSX Scalar Insert Exponent Quad-Precision */
5778       ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5779       return 0;
5780
5781     case 804:
5782       switch (PPC_FIELD (insn, 11, 5))
5783         {
5784         case 27:        /* VSX Scalar Square Root Quad-Precision */
5785           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5786           /* FALL-THROUGH */
5787         case 0:         /* VSX Scalar Absolute Quad-Precision */
5788         case 2:         /* VSX Scalar Extract Exponent Quad-Precision */
5789         case 8:         /* VSX Scalar Negative Absolute Quad-Precision */
5790         case 16:        /* VSX Scalar Negate Quad-Precision */
5791         case 18:        /* VSX Scalar Extract Significand Quad-Precision */
5792           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5793           return 0;
5794         }
5795       break;
5796
5797     case 836:
5798       switch (PPC_FIELD (insn, 11, 5))
5799         {
5800         case 1:         /* VSX Scalar truncate & Convert Quad-Precision format
5801                            to Unsigned Word format */
5802         case 2:         /* VSX Scalar Convert Unsigned Doubleword format to
5803                            Quad-Precision format */
5804         case 9:         /* VSX Scalar truncate & Convert Quad-Precision format
5805                            to Signed Word format */
5806         case 10:        /* VSX Scalar Convert Signed Doubleword format to
5807                            Quad-Precision format */
5808         case 17:        /* VSX Scalar truncate & Convert Quad-Precision format
5809                            to Unsigned Doubleword format */
5810         case 20:        /* VSX Scalar round & Convert Quad-Precision format to
5811                            Double-Precision format */
5812         case 22:        /* VSX Scalar Convert Double-Precision format to
5813                            Quad-Precision format */
5814         case 25:        /* VSX Scalar truncate & Convert Quad-Precision format
5815                            to Signed Doubleword format */
5816           record_full_arch_list_add_reg (regcache, tdep->ppc_fpscr_regnum);
5817           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
5818           return 0;
5819         }
5820     }
5821
5822   fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
5823                       "at %s, 63-%d.\n", insn, paddress (gdbarch, addr), ext);
5824   return -1;
5825 }
5826
5827 /* Parse the current instruction and record the values of the registers and
5828    memory that will be changed in current instruction to "record_arch_list".
5829    Return -1 if something wrong.  */
5830
5831 int
5832 ppc_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
5833                       CORE_ADDR addr)
5834 {
5835   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
5836   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5837   uint32_t insn;
5838   int op6, tmp, i;
5839
5840   insn = read_memory_unsigned_integer (addr, 4, byte_order);
5841   op6 = PPC_OP6 (insn);
5842
5843   switch (op6)
5844     {
5845     case 2:             /* Trap Doubleword Immediate */
5846     case 3:             /* Trap Word Immediate */
5847       /* Do nothing.  */
5848       break;
5849
5850     case 4:
5851       if (ppc_process_record_op4 (gdbarch, regcache, addr, insn) != 0)
5852         return -1;
5853       break;
5854
5855     case 17:            /* System call */
5856       if (PPC_LEV (insn) != 0)
5857         goto UNKNOWN_OP;
5858
5859       if (tdep->ppc_syscall_record != NULL)
5860         {
5861           if (tdep->ppc_syscall_record (regcache) != 0)
5862             return -1;
5863         }
5864       else
5865         {
5866           printf_unfiltered (_("no syscall record support\n"));
5867           return -1;
5868         }
5869       break;
5870
5871     case 7:             /* Multiply Low Immediate */
5872       record_full_arch_list_add_reg (regcache,
5873                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5874       break;
5875
5876     case 8:             /* Subtract From Immediate Carrying */
5877       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
5878       record_full_arch_list_add_reg (regcache,
5879                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5880       break;
5881
5882     case 10:            /* Compare Logical Immediate  */
5883     case 11:            /* Compare Immediate */
5884       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5885       break;
5886
5887     case 13:            /* Add Immediate Carrying and Record */
5888       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5889       /* FALL-THROUGH */
5890     case 12:            /* Add Immediate Carrying */
5891       record_full_arch_list_add_reg (regcache, tdep->ppc_xer_regnum);
5892       /* FALL-THROUGH */
5893     case 14:            /* Add Immediate */
5894     case 15:            /* Add Immediate Shifted */
5895       record_full_arch_list_add_reg (regcache,
5896                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5897       break;
5898
5899     case 16:            /* Branch Conditional */
5900       if ((PPC_BO (insn) & 0x4) == 0)
5901         record_full_arch_list_add_reg (regcache, tdep->ppc_ctr_regnum);
5902       /* FALL-THROUGH */
5903     case 18:            /* Branch */
5904       if (PPC_LK (insn))
5905         record_full_arch_list_add_reg (regcache, tdep->ppc_lr_regnum);
5906       break;
5907
5908     case 19:
5909       if (ppc_process_record_op19 (gdbarch, regcache, addr, insn) != 0)
5910         return -1;
5911       break;
5912
5913     case 20:            /* Rotate Left Word Immediate then Mask Insert */
5914     case 21:            /* Rotate Left Word Immediate then AND with Mask */
5915     case 23:            /* Rotate Left Word then AND with Mask */
5916     case 30:            /* Rotate Left Doubleword Immediate then Clear Left */
5917                         /* Rotate Left Doubleword Immediate then Clear Right */
5918                         /* Rotate Left Doubleword Immediate then Clear */
5919                         /* Rotate Left Doubleword then Clear Left */
5920                         /* Rotate Left Doubleword then Clear Right */
5921                         /* Rotate Left Doubleword Immediate then Mask Insert */
5922       if (PPC_RC (insn))
5923         record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5924       record_full_arch_list_add_reg (regcache,
5925                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5926       break;
5927
5928     case 28:            /* AND Immediate */
5929     case 29:            /* AND Immediate Shifted */
5930       record_full_arch_list_add_reg (regcache, tdep->ppc_cr_regnum);
5931       /* FALL-THROUGH */
5932     case 24:            /* OR Immediate */
5933     case 25:            /* OR Immediate Shifted */
5934     case 26:            /* XOR Immediate */
5935     case 27:            /* XOR Immediate Shifted */
5936       record_full_arch_list_add_reg (regcache,
5937                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5938       break;
5939
5940     case 31:
5941       if (ppc_process_record_op31 (gdbarch, regcache, addr, insn) != 0)
5942         return -1;
5943       break;
5944
5945     case 33:            /* Load Word and Zero with Update */
5946     case 35:            /* Load Byte and Zero with Update */
5947     case 41:            /* Load Halfword and Zero with Update */
5948     case 43:            /* Load Halfword Algebraic with Update */
5949       record_full_arch_list_add_reg (regcache,
5950                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5951       /* FALL-THROUGH */
5952     case 32:            /* Load Word and Zero */
5953     case 34:            /* Load Byte and Zero */
5954     case 40:            /* Load Halfword and Zero */
5955     case 42:            /* Load Halfword Algebraic */
5956       record_full_arch_list_add_reg (regcache,
5957                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
5958       break;
5959
5960     case 46:            /* Load Multiple Word */
5961       for (i = PPC_RT (insn); i < 32; i++)
5962         record_full_arch_list_add_reg (regcache, tdep->ppc_gp0_regnum + i);
5963       break;
5964
5965     case 56:            /* Load Quadword */
5966       tmp = tdep->ppc_gp0_regnum + (PPC_RT (insn) & ~1);
5967       record_full_arch_list_add_reg (regcache, tmp);
5968       record_full_arch_list_add_reg (regcache, tmp + 1);
5969       break;
5970
5971     case 49:            /* Load Floating-Point Single with Update */
5972     case 51:            /* Load Floating-Point Double with Update */
5973       record_full_arch_list_add_reg (regcache,
5974                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
5975       /* FALL-THROUGH */
5976     case 48:            /* Load Floating-Point Single */
5977     case 50:            /* Load Floating-Point Double */
5978       record_full_arch_list_add_reg (regcache,
5979                                      tdep->ppc_fp0_regnum + PPC_FRT (insn));
5980       break;
5981
5982     case 47:            /* Store Multiple Word */
5983         {
5984           ULONGEST iaddr = 0;
5985
5986           if (PPC_RA (insn) != 0)
5987             regcache_raw_read_unsigned (regcache,
5988                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
5989                                         &iaddr);
5990
5991           iaddr += PPC_D (insn);
5992           record_full_arch_list_add_mem (iaddr, 4 * (32 - PPC_RS (insn)));
5993         }
5994       break;
5995
5996     case 37:            /* Store Word with Update */
5997     case 39:            /* Store Byte with Update */
5998     case 45:            /* Store Halfword with Update */
5999     case 53:            /* Store Floating-Point Single with Update */
6000     case 55:            /* Store Floating-Point Double with Update */
6001       record_full_arch_list_add_reg (regcache,
6002                                      tdep->ppc_gp0_regnum + PPC_RA (insn));
6003       /* FALL-THROUGH */
6004     case 36:            /* Store Word */
6005     case 38:            /* Store Byte */
6006     case 44:            /* Store Halfword */
6007     case 52:            /* Store Floating-Point Single */
6008     case 54:            /* Store Floating-Point Double */
6009         {
6010           ULONGEST iaddr = 0;
6011           int size = -1;
6012
6013           if (PPC_RA (insn) != 0)
6014             regcache_raw_read_unsigned (regcache,
6015                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
6016                                         &iaddr);
6017           iaddr += PPC_D (insn);
6018
6019           if (op6 == 36 || op6 == 37 || op6 == 52 || op6 == 53)
6020             size = 4;
6021           else if (op6 == 54 || op6 == 55)
6022             size = 8;
6023           else if (op6 == 44 || op6 == 45)
6024             size = 2;
6025           else if (op6 == 38 || op6 == 39)
6026             size = 1;
6027           else
6028             gdb_assert (0);
6029
6030           record_full_arch_list_add_mem (iaddr, size);
6031         }
6032       break;
6033
6034     case 57:
6035       switch (insn & 0x3)
6036         {
6037         case 0:         /* Load Floating-Point Double Pair */
6038           tmp = tdep->ppc_fp0_regnum + (PPC_RT (insn) & ~1);
6039           record_full_arch_list_add_reg (regcache, tmp);
6040           record_full_arch_list_add_reg (regcache, tmp + 1);
6041           break;
6042         case 2:         /* Load VSX Scalar Doubleword */
6043         case 3:         /* Load VSX Scalar Single */
6044           ppc_record_vsr (regcache, tdep, PPC_VRT (insn) + 32);
6045           break;
6046         default:
6047           goto UNKNOWN_OP;
6048         }
6049       break;
6050
6051     case 58:            /* Load Doubleword */
6052                         /* Load Doubleword with Update */
6053                         /* Load Word Algebraic */
6054       if (PPC_FIELD (insn, 30, 2) > 2)
6055         goto UNKNOWN_OP;
6056
6057       record_full_arch_list_add_reg (regcache,
6058                                      tdep->ppc_gp0_regnum + PPC_RT (insn));
6059       if (PPC_BIT (insn, 31))
6060         record_full_arch_list_add_reg (regcache,
6061                                        tdep->ppc_gp0_regnum + PPC_RA (insn));
6062       break;
6063
6064     case 59:
6065       if (ppc_process_record_op59 (gdbarch, regcache, addr, insn) != 0)
6066         return -1;
6067       break;
6068
6069     case 60:
6070       if (ppc_process_record_op60 (gdbarch, regcache, addr, insn) != 0)
6071         return -1;
6072       break;
6073
6074     case 61:
6075       if (ppc_process_record_op61 (gdbarch, regcache, addr, insn) != 0)
6076         return -1;
6077       break;
6078
6079     case 62:            /* Store Doubleword */
6080                         /* Store Doubleword with Update */
6081                         /* Store Quadword with Update */
6082         {
6083           ULONGEST iaddr = 0;
6084           int size;
6085           int sub2 = PPC_FIELD (insn, 30, 2);
6086
6087           if (sub2 > 2)
6088             goto UNKNOWN_OP;
6089
6090           if (PPC_RA (insn) != 0)
6091             regcache_raw_read_unsigned (regcache,
6092                                         tdep->ppc_gp0_regnum + PPC_RA (insn),
6093                                         &iaddr);
6094
6095           size = (sub2 == 2) ? 16 : 8;
6096
6097           iaddr += PPC_DS (insn) << 2;
6098           record_full_arch_list_add_mem (iaddr, size);
6099
6100           if (op6 == 62 && sub2 == 1)
6101             record_full_arch_list_add_reg (regcache,
6102                                            tdep->ppc_gp0_regnum +
6103                                            PPC_RA (insn));
6104
6105           break;
6106         }
6107
6108     case 63:
6109       if (ppc_process_record_op63 (gdbarch, regcache, addr, insn) != 0)
6110         return -1;
6111       break;
6112
6113     default:
6114 UNKNOWN_OP:
6115       fprintf_unfiltered (gdb_stdlog, "Warning: Don't know how to record %08x "
6116                           "at %s, %d.\n", insn, paddress (gdbarch, addr), op6);
6117       return -1;
6118     }
6119
6120   if (record_full_arch_list_add_reg (regcache, PPC_PC_REGNUM))
6121     return -1;
6122   if (record_full_arch_list_add_end ())
6123     return -1;
6124   return 0;
6125 }
6126
6127 /* Initialize the current architecture based on INFO.  If possible, re-use an
6128    architecture from ARCHES, which is a list of architectures already created
6129    during this debugging session.
6130
6131    Called e.g. at program startup, when reading a core file, and when reading
6132    a binary file.  */
6133
6134 static struct gdbarch *
6135 rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
6136 {
6137   struct gdbarch *gdbarch;
6138   struct gdbarch_tdep *tdep;
6139   int wordsize, from_xcoff_exec, from_elf_exec;
6140   enum bfd_architecture arch;
6141   unsigned long mach;
6142   bfd abfd;
6143   enum auto_boolean soft_float_flag = powerpc_soft_float_global;
6144   int soft_float;
6145   enum powerpc_long_double_abi long_double_abi = POWERPC_LONG_DOUBLE_AUTO;
6146   enum powerpc_vector_abi vector_abi = powerpc_vector_abi_global;
6147   enum powerpc_elf_abi elf_abi = POWERPC_ELF_AUTO;
6148   int have_fpu = 0, have_spe = 0, have_mq = 0, have_altivec = 0;
6149   int have_dfp = 0, have_vsx = 0, have_ppr = 0, have_dscr = 0;
6150   int have_tar = 0, have_ebb = 0, have_pmu = 0, have_htm_spr = 0;
6151   int have_htm_core = 0, have_htm_fpu = 0, have_htm_altivec = 0;
6152   int have_htm_vsx = 0, have_htm_ppr = 0, have_htm_dscr = 0;
6153   int have_htm_tar = 0;
6154   int tdesc_wordsize = -1;
6155   const struct target_desc *tdesc = info.target_desc;
6156   struct tdesc_arch_data *tdesc_data = NULL;
6157   int num_pseudoregs = 0;
6158   int cur_reg;
6159
6160   /* INFO may refer to a binary that is not of the PowerPC architecture,
6161      e.g. when debugging a stand-alone SPE executable on a Cell/B.E. system.
6162      In this case, we must not attempt to infer properties of the (PowerPC
6163      side) of the target system from properties of that executable.  Trust
6164      the target description instead.  */
6165   if (info.abfd
6166       && bfd_get_arch (info.abfd) != bfd_arch_powerpc
6167       && bfd_get_arch (info.abfd) != bfd_arch_rs6000)
6168     info.abfd = NULL;
6169
6170   from_xcoff_exec = info.abfd && info.abfd->format == bfd_object &&
6171     bfd_get_flavour (info.abfd) == bfd_target_xcoff_flavour;
6172
6173   from_elf_exec = info.abfd && info.abfd->format == bfd_object &&
6174     bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
6175
6176   /* Check word size.  If INFO is from a binary file, infer it from
6177      that, else choose a likely default.  */
6178   if (from_xcoff_exec)
6179     {
6180       if (bfd_xcoff_is_xcoff64 (info.abfd))
6181         wordsize = 8;
6182       else
6183         wordsize = 4;
6184     }
6185   else if (from_elf_exec)
6186     {
6187       if (elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6188         wordsize = 8;
6189       else
6190         wordsize = 4;
6191     }
6192   else if (tdesc_has_registers (tdesc))
6193     wordsize = -1;
6194   else
6195     {
6196       if (info.bfd_arch_info != NULL && info.bfd_arch_info->bits_per_word != 0)
6197         wordsize = (info.bfd_arch_info->bits_per_word
6198                     / info.bfd_arch_info->bits_per_byte);
6199       else
6200         wordsize = 4;
6201     }
6202
6203   /* Get the architecture and machine from the BFD.  */
6204   arch = info.bfd_arch_info->arch;
6205   mach = info.bfd_arch_info->mach;
6206
6207   /* For e500 executables, the apuinfo section is of help here.  Such
6208      section contains the identifier and revision number of each
6209      Application-specific Processing Unit that is present on the
6210      chip.  The content of the section is determined by the assembler
6211      which looks at each instruction and determines which unit (and
6212      which version of it) can execute it.  Grovel through the section
6213      looking for relevant e500 APUs.  */
6214
6215   if (bfd_uses_spe_extensions (info.abfd))
6216     {
6217       arch = info.bfd_arch_info->arch;
6218       mach = bfd_mach_ppc_e500;
6219       bfd_default_set_arch_mach (&abfd, arch, mach);
6220       info.bfd_arch_info = bfd_get_arch_info (&abfd);
6221     }
6222
6223   /* Find a default target description which describes our register
6224      layout, if we do not already have one.  */
6225   if (! tdesc_has_registers (tdesc))
6226     {
6227       const struct variant *v;
6228
6229       /* Choose variant.  */
6230       v = find_variant_by_arch (arch, mach);
6231       if (!v)
6232         return NULL;
6233
6234       tdesc = *v->tdesc;
6235     }
6236
6237   gdb_assert (tdesc_has_registers (tdesc));
6238
6239   /* Check any target description for validity.  */
6240   if (tdesc_has_registers (tdesc))
6241     {
6242       static const char *const gprs[] = {
6243         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6244         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6245         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
6246         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
6247       };
6248       const struct tdesc_feature *feature;
6249       int i, valid_p;
6250       static const char *const msr_names[] = { "msr", "ps" };
6251       static const char *const cr_names[] = { "cr", "cnd" };
6252       static const char *const ctr_names[] = { "ctr", "cnt" };
6253
6254       feature = tdesc_find_feature (tdesc,
6255                                     "org.gnu.gdb.power.core");
6256       if (feature == NULL)
6257         return NULL;
6258
6259       tdesc_data = tdesc_data_alloc ();
6260
6261       valid_p = 1;
6262       for (i = 0; i < ppc_num_gprs; i++)
6263         valid_p &= tdesc_numbered_register (feature, tdesc_data, i, gprs[i]);
6264       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_PC_REGNUM,
6265                                           "pc");
6266       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_LR_REGNUM,
6267                                           "lr");
6268       valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_XER_REGNUM,
6269                                           "xer");
6270
6271       /* Allow alternate names for these registers, to accomodate GDB's
6272          historic naming.  */
6273       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6274                                                   PPC_MSR_REGNUM, msr_names);
6275       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6276                                                   PPC_CR_REGNUM, cr_names);
6277       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
6278                                                   PPC_CTR_REGNUM, ctr_names);
6279
6280       if (!valid_p)
6281         {
6282           tdesc_data_cleanup (tdesc_data);
6283           return NULL;
6284         }
6285
6286       have_mq = tdesc_numbered_register (feature, tdesc_data, PPC_MQ_REGNUM,
6287                                          "mq");
6288
6289       tdesc_wordsize = tdesc_register_bitsize (feature, "pc") / 8;
6290       if (wordsize == -1)
6291         wordsize = tdesc_wordsize;
6292
6293       feature = tdesc_find_feature (tdesc,
6294                                     "org.gnu.gdb.power.fpu");
6295       if (feature != NULL)
6296         {
6297           static const char *const fprs[] = {
6298             "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
6299             "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
6300             "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
6301             "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
6302           };
6303           valid_p = 1;
6304           for (i = 0; i < ppc_num_fprs; i++)
6305             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6306                                                 PPC_F0_REGNUM + i, fprs[i]);
6307           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6308                                               PPC_FPSCR_REGNUM, "fpscr");
6309
6310           if (!valid_p)
6311             {
6312               tdesc_data_cleanup (tdesc_data);
6313               return NULL;
6314             }
6315           have_fpu = 1;
6316
6317           /* The fpscr register was expanded in isa 2.05 to 64 bits
6318              along with the addition of the decimal floating point
6319              facility.  */
6320           if (tdesc_register_bitsize (feature, "fpscr") > 32)
6321             have_dfp = 1;
6322         }
6323       else
6324         have_fpu = 0;
6325
6326       feature = tdesc_find_feature (tdesc,
6327                                     "org.gnu.gdb.power.altivec");
6328       if (feature != NULL)
6329         {
6330           static const char *const vector_regs[] = {
6331             "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7",
6332             "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
6333             "vr16", "vr17", "vr18", "vr19", "vr20", "vr21", "vr22", "vr23",
6334             "vr24", "vr25", "vr26", "vr27", "vr28", "vr29", "vr30", "vr31"
6335           };
6336
6337           valid_p = 1;
6338           for (i = 0; i < ppc_num_gprs; i++)
6339             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6340                                                 PPC_VR0_REGNUM + i,
6341                                                 vector_regs[i]);
6342           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6343                                               PPC_VSCR_REGNUM, "vscr");
6344           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6345                                               PPC_VRSAVE_REGNUM, "vrsave");
6346
6347           if (have_spe || !valid_p)
6348             {
6349               tdesc_data_cleanup (tdesc_data);
6350               return NULL;
6351             }
6352           have_altivec = 1;
6353         }
6354       else
6355         have_altivec = 0;
6356
6357       /* Check for POWER7 VSX registers support.  */
6358       feature = tdesc_find_feature (tdesc,
6359                                     "org.gnu.gdb.power.vsx");
6360
6361       if (feature != NULL)
6362         {
6363           static const char *const vsx_regs[] = {
6364             "vs0h", "vs1h", "vs2h", "vs3h", "vs4h", "vs5h",
6365             "vs6h", "vs7h", "vs8h", "vs9h", "vs10h", "vs11h",
6366             "vs12h", "vs13h", "vs14h", "vs15h", "vs16h", "vs17h",
6367             "vs18h", "vs19h", "vs20h", "vs21h", "vs22h", "vs23h",
6368             "vs24h", "vs25h", "vs26h", "vs27h", "vs28h", "vs29h",
6369             "vs30h", "vs31h"
6370           };
6371
6372           valid_p = 1;
6373
6374           for (i = 0; i < ppc_num_vshrs; i++)
6375             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6376                                                 PPC_VSR0_UPPER_REGNUM + i,
6377                                                 vsx_regs[i]);
6378
6379           if (!valid_p || !have_fpu || !have_altivec)
6380             {
6381               tdesc_data_cleanup (tdesc_data);
6382               return NULL;
6383             }
6384
6385           have_vsx = 1;
6386         }
6387       else
6388         have_vsx = 0;
6389
6390       /* On machines supporting the SPE APU, the general-purpose registers
6391          are 64 bits long.  There are SIMD vector instructions to treat them
6392          as pairs of floats, but the rest of the instruction set treats them
6393          as 32-bit registers, and only operates on their lower halves.
6394
6395          In the GDB regcache, we treat their high and low halves as separate
6396          registers.  The low halves we present as the general-purpose
6397          registers, and then we have pseudo-registers that stitch together
6398          the upper and lower halves and present them as pseudo-registers.
6399
6400          Thus, the target description is expected to supply the upper
6401          halves separately.  */
6402
6403       feature = tdesc_find_feature (tdesc,
6404                                     "org.gnu.gdb.power.spe");
6405       if (feature != NULL)
6406         {
6407           static const char *const upper_spe[] = {
6408             "ev0h", "ev1h", "ev2h", "ev3h",
6409             "ev4h", "ev5h", "ev6h", "ev7h",
6410             "ev8h", "ev9h", "ev10h", "ev11h",
6411             "ev12h", "ev13h", "ev14h", "ev15h",
6412             "ev16h", "ev17h", "ev18h", "ev19h",
6413             "ev20h", "ev21h", "ev22h", "ev23h",
6414             "ev24h", "ev25h", "ev26h", "ev27h",
6415             "ev28h", "ev29h", "ev30h", "ev31h"
6416           };
6417
6418           valid_p = 1;
6419           for (i = 0; i < ppc_num_gprs; i++)
6420             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6421                                                 PPC_SPE_UPPER_GP0_REGNUM + i,
6422                                                 upper_spe[i]);
6423           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6424                                               PPC_SPE_ACC_REGNUM, "acc");
6425           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6426                                               PPC_SPE_FSCR_REGNUM, "spefscr");
6427
6428           if (have_mq || have_fpu || !valid_p)
6429             {
6430               tdesc_data_cleanup (tdesc_data);
6431               return NULL;
6432             }
6433           have_spe = 1;
6434         }
6435       else
6436         have_spe = 0;
6437
6438       /* Program Priority Register.  */
6439       feature = tdesc_find_feature (tdesc,
6440                                     "org.gnu.gdb.power.ppr");
6441       if (feature != NULL)
6442         {
6443           valid_p = 1;
6444           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6445                                               PPC_PPR_REGNUM, "ppr");
6446
6447           if (!valid_p)
6448             {
6449               tdesc_data_cleanup (tdesc_data);
6450               return NULL;
6451             }
6452           have_ppr = 1;
6453         }
6454       else
6455         have_ppr = 0;
6456
6457       /* Data Stream Control Register.  */
6458       feature = tdesc_find_feature (tdesc,
6459                                     "org.gnu.gdb.power.dscr");
6460       if (feature != NULL)
6461         {
6462           valid_p = 1;
6463           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6464                                               PPC_DSCR_REGNUM, "dscr");
6465
6466           if (!valid_p)
6467             {
6468               tdesc_data_cleanup (tdesc_data);
6469               return NULL;
6470             }
6471           have_dscr = 1;
6472         }
6473       else
6474         have_dscr = 0;
6475
6476       /* Target Address Register.  */
6477       feature = tdesc_find_feature (tdesc,
6478                                     "org.gnu.gdb.power.tar");
6479       if (feature != NULL)
6480         {
6481           valid_p = 1;
6482           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6483                                               PPC_TAR_REGNUM, "tar");
6484
6485           if (!valid_p)
6486             {
6487               tdesc_data_cleanup (tdesc_data);
6488               return NULL;
6489             }
6490           have_tar = 1;
6491         }
6492       else
6493         have_tar = 0;
6494
6495       /* Event-based Branching Registers.  */
6496       feature = tdesc_find_feature (tdesc,
6497                                     "org.gnu.gdb.power.ebb");
6498       if (feature != NULL)
6499         {
6500           static const char *const ebb_regs[] = {
6501             "bescr", "ebbhr", "ebbrr"
6502           };
6503
6504           valid_p = 1;
6505           for (i = 0; i < ARRAY_SIZE (ebb_regs); i++)
6506             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6507                                                 PPC_BESCR_REGNUM + i,
6508                                                 ebb_regs[i]);
6509           if (!valid_p)
6510             {
6511               tdesc_data_cleanup (tdesc_data);
6512               return NULL;
6513             }
6514           have_ebb = 1;
6515         }
6516       else
6517         have_ebb = 0;
6518
6519       /* Subset of the ISA 2.07 Performance Monitor Registers provided
6520          by Linux.  */
6521       feature = tdesc_find_feature (tdesc,
6522                                     "org.gnu.gdb.power.linux.pmu");
6523       if (feature != NULL)
6524         {
6525           valid_p = 1;
6526
6527           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6528                                               PPC_MMCR0_REGNUM,
6529                                               "mmcr0");
6530           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6531                                               PPC_MMCR2_REGNUM,
6532                                               "mmcr2");
6533           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6534                                               PPC_SIAR_REGNUM,
6535                                               "siar");
6536           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6537                                               PPC_SDAR_REGNUM,
6538                                               "sdar");
6539           valid_p &= tdesc_numbered_register (feature, tdesc_data,
6540                                               PPC_SIER_REGNUM,
6541                                               "sier");
6542
6543           if (!valid_p)
6544             {
6545               tdesc_data_cleanup (tdesc_data);
6546               return NULL;
6547             }
6548           have_pmu = 1;
6549         }
6550       else
6551         have_pmu = 0;
6552
6553       /* Hardware Transactional Memory Registers.  */
6554       feature = tdesc_find_feature (tdesc,
6555                                     "org.gnu.gdb.power.htm.spr");
6556       if (feature != NULL)
6557         {
6558           static const char *const tm_spr_regs[] = {
6559             "tfhar", "texasr", "tfiar"
6560           };
6561
6562           valid_p = 1;
6563           for (i = 0; i < ARRAY_SIZE (tm_spr_regs); i++)
6564             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6565                                                 PPC_TFHAR_REGNUM + i,
6566                                                 tm_spr_regs[i]);
6567           if (!valid_p)
6568             {
6569               tdesc_data_cleanup (tdesc_data);
6570               return NULL;
6571             }
6572
6573           have_htm_spr = 1;
6574         }
6575       else
6576         have_htm_spr = 0;
6577
6578       feature = tdesc_find_feature (tdesc,
6579                                     "org.gnu.gdb.power.htm.core");
6580       if (feature != NULL)
6581         {
6582           static const char *const cgprs[] = {
6583             "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6584             "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14",
6585             "cr15", "cr16", "cr17", "cr18", "cr19", "cr20", "cr21",
6586             "cr22", "cr23", "cr24", "cr25", "cr26", "cr27", "cr28",
6587             "cr29", "cr30", "cr31", "ccr", "cxer", "clr", "cctr"
6588           };
6589
6590           valid_p = 1;
6591
6592           for (i = 0; i < ARRAY_SIZE (cgprs); i++)
6593             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6594                                                 PPC_CR0_REGNUM + i,
6595                                                 cgprs[i]);
6596           if (!valid_p)
6597             {
6598               tdesc_data_cleanup (tdesc_data);
6599               return NULL;
6600             }
6601
6602           have_htm_core = 1;
6603         }
6604       else
6605         have_htm_core = 0;
6606
6607       feature = tdesc_find_feature (tdesc,
6608                                     "org.gnu.gdb.power.htm.fpu");
6609       if (feature != NULL)
6610         {
6611           valid_p = 1;
6612
6613           static const char *const cfprs[] = {
6614             "cf0", "cf1", "cf2", "cf3", "cf4", "cf5", "cf6", "cf7",
6615             "cf8", "cf9", "cf10", "cf11", "cf12", "cf13", "cf14", "cf15",
6616             "cf16", "cf17", "cf18", "cf19", "cf20", "cf21", "cf22",
6617             "cf23", "cf24", "cf25", "cf26", "cf27", "cf28", "cf29",
6618             "cf30", "cf31", "cfpscr"
6619           };
6620
6621           for (i = 0; i < ARRAY_SIZE (cfprs); i++)
6622             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6623                                                 PPC_CF0_REGNUM + i,
6624                                                 cfprs[i]);
6625
6626           if (!valid_p)
6627             {
6628               tdesc_data_cleanup (tdesc_data);
6629               return NULL;
6630             }
6631           have_htm_fpu = 1;
6632         }
6633       else
6634         have_htm_fpu = 0;
6635
6636       feature = tdesc_find_feature (tdesc,
6637                                     "org.gnu.gdb.power.htm.altivec");
6638       if (feature != NULL)
6639         {
6640           valid_p = 1;
6641
6642           static const char *const cvmx[] = {
6643             "cvr0", "cvr1", "cvr2", "cvr3", "cvr4", "cvr5", "cvr6",
6644             "cvr7", "cvr8", "cvr9", "cvr10", "cvr11", "cvr12", "cvr13",
6645             "cvr14", "cvr15","cvr16", "cvr17", "cvr18", "cvr19", "cvr20",
6646             "cvr21", "cvr22", "cvr23", "cvr24", "cvr25", "cvr26",
6647             "cvr27", "cvr28", "cvr29", "cvr30", "cvr31", "cvscr",
6648             "cvrsave"
6649           };
6650
6651           for (i = 0; i < ARRAY_SIZE (cvmx); i++)
6652             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6653                                                 PPC_CVR0_REGNUM + i,
6654                                                 cvmx[i]);
6655
6656           if (!valid_p)
6657             {
6658               tdesc_data_cleanup (tdesc_data);
6659               return NULL;
6660             }
6661           have_htm_altivec = 1;
6662         }
6663       else
6664         have_htm_altivec = 0;
6665
6666       feature = tdesc_find_feature (tdesc,
6667                                     "org.gnu.gdb.power.htm.vsx");
6668       if (feature != NULL)
6669         {
6670           valid_p = 1;
6671
6672           static const char *const cvsx[] = {
6673             "cvs0h", "cvs1h", "cvs2h", "cvs3h", "cvs4h", "cvs5h",
6674             "cvs6h", "cvs7h", "cvs8h", "cvs9h", "cvs10h", "cvs11h",
6675             "cvs12h", "cvs13h", "cvs14h", "cvs15h", "cvs16h", "cvs17h",
6676             "cvs18h", "cvs19h", "cvs20h", "cvs21h", "cvs22h", "cvs23h",
6677             "cvs24h", "cvs25h", "cvs26h", "cvs27h", "cvs28h", "cvs29h",
6678             "cvs30h", "cvs31h"
6679           };
6680
6681           for (i = 0; i < ARRAY_SIZE (cvsx); i++)
6682             valid_p &= tdesc_numbered_register (feature, tdesc_data,
6683                                                 (PPC_CVSR0_UPPER_REGNUM
6684                                                  + i),
6685                                                 cvsx[i]);
6686
6687           if (!valid_p || !have_htm_fpu || !have_htm_altivec)
6688             {
6689               tdesc_data_cleanup (tdesc_data);
6690               return NULL;
6691             }
6692           have_htm_vsx = 1;
6693         }
6694       else
6695         have_htm_vsx = 0;
6696
6697       feature = tdesc_find_feature (tdesc,
6698                                     "org.gnu.gdb.power.htm.ppr");
6699       if (feature != NULL)
6700         {
6701           valid_p = tdesc_numbered_register (feature, tdesc_data,
6702                                              PPC_CPPR_REGNUM, "cppr");
6703
6704           if (!valid_p)
6705             {
6706               tdesc_data_cleanup (tdesc_data);
6707               return NULL;
6708             }
6709           have_htm_ppr = 1;
6710         }
6711       else
6712         have_htm_ppr = 0;
6713
6714       feature = tdesc_find_feature (tdesc,
6715                                     "org.gnu.gdb.power.htm.dscr");
6716       if (feature != NULL)
6717         {
6718           valid_p = tdesc_numbered_register (feature, tdesc_data,
6719                                              PPC_CDSCR_REGNUM, "cdscr");
6720
6721           if (!valid_p)
6722             {
6723               tdesc_data_cleanup (tdesc_data);
6724               return NULL;
6725             }
6726           have_htm_dscr = 1;
6727         }
6728       else
6729         have_htm_dscr = 0;
6730
6731       feature = tdesc_find_feature (tdesc,
6732                                     "org.gnu.gdb.power.htm.tar");
6733       if (feature != NULL)
6734         {
6735           valid_p = tdesc_numbered_register (feature, tdesc_data,
6736                                              PPC_CTAR_REGNUM, "ctar");
6737
6738           if (!valid_p)
6739             {
6740               tdesc_data_cleanup (tdesc_data);
6741               return NULL;
6742             }
6743           have_htm_tar = 1;
6744         }
6745       else
6746         have_htm_tar = 0;
6747     }
6748
6749   /* If we have a 64-bit binary on a 32-bit target, complain.  Also
6750      complain for a 32-bit binary on a 64-bit target; we do not yet
6751      support that.  For instance, the 32-bit ABI routines expect
6752      32-bit GPRs.
6753
6754      As long as there isn't an explicit target description, we'll
6755      choose one based on the BFD architecture and get a word size
6756      matching the binary (probably powerpc:common or
6757      powerpc:common64).  So there is only trouble if a 64-bit target
6758      supplies a 64-bit description while debugging a 32-bit
6759      binary.  */
6760   if (tdesc_wordsize != -1 && tdesc_wordsize != wordsize)
6761     {
6762       tdesc_data_cleanup (tdesc_data);
6763       return NULL;
6764     }
6765
6766 #ifdef HAVE_ELF
6767   if (from_elf_exec)
6768     {
6769       switch (elf_elfheader (info.abfd)->e_flags & EF_PPC64_ABI)
6770         {
6771         case 1:
6772           elf_abi = POWERPC_ELF_V1;
6773           break;
6774         case 2:
6775           elf_abi = POWERPC_ELF_V2;
6776           break;
6777         default:
6778           break;
6779         }
6780     }
6781
6782   if (soft_float_flag == AUTO_BOOLEAN_AUTO && from_elf_exec)
6783     {
6784       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6785                                         Tag_GNU_Power_ABI_FP) & 3)
6786         {
6787         case 1:
6788           soft_float_flag = AUTO_BOOLEAN_FALSE;
6789           break;
6790         case 2:
6791           soft_float_flag = AUTO_BOOLEAN_TRUE;
6792           break;
6793         default:
6794           break;
6795         }
6796     }
6797
6798   if (long_double_abi == POWERPC_LONG_DOUBLE_AUTO && from_elf_exec)
6799     {
6800       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6801                                         Tag_GNU_Power_ABI_FP) >> 2)
6802         {
6803         case 1:
6804           long_double_abi = POWERPC_LONG_DOUBLE_IBM128;
6805           break;
6806         case 3:
6807           long_double_abi = POWERPC_LONG_DOUBLE_IEEE128;
6808           break;
6809         default:
6810           break;
6811         }
6812     }
6813
6814   if (vector_abi == POWERPC_VEC_AUTO && from_elf_exec)
6815     {
6816       switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
6817                                         Tag_GNU_Power_ABI_Vector))
6818         {
6819         case 1:
6820           vector_abi = POWERPC_VEC_GENERIC;
6821           break;
6822         case 2:
6823           vector_abi = POWERPC_VEC_ALTIVEC;
6824           break;
6825         case 3:
6826           vector_abi = POWERPC_VEC_SPE;
6827           break;
6828         default:
6829           break;
6830         }
6831     }
6832 #endif
6833
6834   /* At this point, the only supported ELF-based 64-bit little-endian
6835      operating system is GNU/Linux, and this uses the ELFv2 ABI by
6836      default.  All other supported ELF-based operating systems use the
6837      ELFv1 ABI by default.  Therefore, if the ABI marker is missing,
6838      e.g. because we run a legacy binary, or have attached to a process
6839      and have not found any associated binary file, set the default
6840      according to this heuristic.  */
6841   if (elf_abi == POWERPC_ELF_AUTO)
6842     {
6843       if (wordsize == 8 && info.byte_order == BFD_ENDIAN_LITTLE)
6844         elf_abi = POWERPC_ELF_V2;
6845       else
6846         elf_abi = POWERPC_ELF_V1;
6847     }
6848
6849   if (soft_float_flag == AUTO_BOOLEAN_TRUE)
6850     soft_float = 1;
6851   else if (soft_float_flag == AUTO_BOOLEAN_FALSE)
6852     soft_float = 0;
6853   else
6854     soft_float = !have_fpu;
6855
6856   /* If we have a hard float binary or setting but no floating point
6857      registers, downgrade to soft float anyway.  We're still somewhat
6858      useful in this scenario.  */
6859   if (!soft_float && !have_fpu)
6860     soft_float = 1;
6861
6862   /* Similarly for vector registers.  */
6863   if (vector_abi == POWERPC_VEC_ALTIVEC && !have_altivec)
6864     vector_abi = POWERPC_VEC_GENERIC;
6865
6866   if (vector_abi == POWERPC_VEC_SPE && !have_spe)
6867     vector_abi = POWERPC_VEC_GENERIC;
6868
6869   if (vector_abi == POWERPC_VEC_AUTO)
6870     {
6871       if (have_altivec)
6872         vector_abi = POWERPC_VEC_ALTIVEC;
6873       else if (have_spe)
6874         vector_abi = POWERPC_VEC_SPE;
6875       else
6876         vector_abi = POWERPC_VEC_GENERIC;
6877     }
6878
6879   /* Do not limit the vector ABI based on available hardware, since we
6880      do not yet know what hardware we'll decide we have.  Yuck!  FIXME!  */
6881
6882   /* Find a candidate among extant architectures.  */
6883   for (arches = gdbarch_list_lookup_by_info (arches, &info);
6884        arches != NULL;
6885        arches = gdbarch_list_lookup_by_info (arches->next, &info))
6886     {
6887       /* Word size in the various PowerPC bfd_arch_info structs isn't
6888          meaningful, because 64-bit CPUs can run in 32-bit mode.  So, perform
6889          separate word size check.  */
6890       tdep = gdbarch_tdep (arches->gdbarch);
6891       if (tdep && tdep->elf_abi != elf_abi)
6892         continue;
6893       if (tdep && tdep->soft_float != soft_float)
6894         continue;
6895       if (tdep && tdep->long_double_abi != long_double_abi)
6896         continue;
6897       if (tdep && tdep->vector_abi != vector_abi)
6898         continue;
6899       if (tdep && tdep->wordsize == wordsize)
6900         {
6901           if (tdesc_data != NULL)
6902             tdesc_data_cleanup (tdesc_data);
6903           return arches->gdbarch;
6904         }
6905     }
6906
6907   /* None found, create a new architecture from INFO, whose bfd_arch_info
6908      validity depends on the source:
6909        - executable             useless
6910        - rs6000_host_arch()     good
6911        - core file              good
6912        - "set arch"             trust blindly
6913        - GDB startup            useless but harmless */
6914
6915   tdep = XCNEW (struct gdbarch_tdep);
6916   tdep->wordsize = wordsize;
6917   tdep->elf_abi = elf_abi;
6918   tdep->soft_float = soft_float;
6919   tdep->long_double_abi = long_double_abi;
6920   tdep->vector_abi = vector_abi;
6921
6922   gdbarch = gdbarch_alloc (&info, tdep);
6923
6924   tdep->ppc_gp0_regnum = PPC_R0_REGNUM;
6925   tdep->ppc_toc_regnum = PPC_R0_REGNUM + 2;
6926   tdep->ppc_ps_regnum = PPC_MSR_REGNUM;
6927   tdep->ppc_cr_regnum = PPC_CR_REGNUM;
6928   tdep->ppc_lr_regnum = PPC_LR_REGNUM;
6929   tdep->ppc_ctr_regnum = PPC_CTR_REGNUM;
6930   tdep->ppc_xer_regnum = PPC_XER_REGNUM;
6931   tdep->ppc_mq_regnum = have_mq ? PPC_MQ_REGNUM : -1;
6932
6933   tdep->ppc_fp0_regnum = have_fpu ? PPC_F0_REGNUM : -1;
6934   tdep->ppc_fpscr_regnum = have_fpu ? PPC_FPSCR_REGNUM : -1;
6935   tdep->ppc_vsr0_upper_regnum = have_vsx ? PPC_VSR0_UPPER_REGNUM : -1;
6936   tdep->ppc_vr0_regnum = have_altivec ? PPC_VR0_REGNUM : -1;
6937   tdep->ppc_vrsave_regnum = have_altivec ? PPC_VRSAVE_REGNUM : -1;
6938   tdep->ppc_ev0_upper_regnum = have_spe ? PPC_SPE_UPPER_GP0_REGNUM : -1;
6939   tdep->ppc_acc_regnum = have_spe ? PPC_SPE_ACC_REGNUM : -1;
6940   tdep->ppc_spefscr_regnum = have_spe ? PPC_SPE_FSCR_REGNUM : -1;
6941   tdep->ppc_ppr_regnum = have_ppr ? PPC_PPR_REGNUM : -1;
6942   tdep->ppc_dscr_regnum = have_dscr ? PPC_DSCR_REGNUM : -1;
6943   tdep->ppc_tar_regnum = have_tar ? PPC_TAR_REGNUM : -1;
6944   tdep->have_ebb = have_ebb;
6945
6946   /* If additional pmu registers are added, care must be taken when
6947      setting new fields in the tdep below, to maintain compatibility
6948      with features that only provide some of the registers.  Currently
6949      gdb access to the pmu registers is only supported in linux, and
6950      linux only provides a subset of the pmu registers defined in the
6951      architecture.  */
6952
6953   tdep->ppc_mmcr0_regnum = have_pmu ? PPC_MMCR0_REGNUM : -1;
6954   tdep->ppc_mmcr2_regnum = have_pmu ? PPC_MMCR2_REGNUM : -1;
6955   tdep->ppc_siar_regnum = have_pmu ? PPC_SIAR_REGNUM : -1;
6956   tdep->ppc_sdar_regnum = have_pmu ? PPC_SDAR_REGNUM : -1;
6957   tdep->ppc_sier_regnum = have_pmu ? PPC_SIER_REGNUM : -1;
6958
6959   tdep->have_htm_spr = have_htm_spr;
6960   tdep->have_htm_core = have_htm_core;
6961   tdep->have_htm_fpu = have_htm_fpu;
6962   tdep->have_htm_altivec = have_htm_altivec;
6963   tdep->have_htm_vsx = have_htm_vsx;
6964   tdep->ppc_cppr_regnum = have_htm_ppr ? PPC_CPPR_REGNUM : -1;
6965   tdep->ppc_cdscr_regnum = have_htm_dscr ? PPC_CDSCR_REGNUM : -1;
6966   tdep->ppc_ctar_regnum = have_htm_tar ? PPC_CTAR_REGNUM : -1;
6967
6968   set_gdbarch_pc_regnum (gdbarch, PPC_PC_REGNUM);
6969   set_gdbarch_sp_regnum (gdbarch, PPC_R0_REGNUM + 1);
6970   set_gdbarch_fp0_regnum (gdbarch, tdep->ppc_fp0_regnum);
6971   set_gdbarch_register_sim_regno (gdbarch, rs6000_register_sim_regno);
6972
6973   /* The XML specification for PowerPC sensibly calls the MSR "msr".
6974      GDB traditionally called it "ps", though, so let GDB add an
6975      alias.  */
6976   set_gdbarch_ps_regnum (gdbarch, tdep->ppc_ps_regnum);
6977
6978   if (wordsize == 8)
6979     set_gdbarch_return_value (gdbarch, ppc64_sysv_abi_return_value);
6980   else
6981     set_gdbarch_return_value (gdbarch, ppc_sysv_abi_return_value);
6982
6983   /* Set lr_frame_offset.  */
6984   if (wordsize == 8)
6985     tdep->lr_frame_offset = 16;
6986   else
6987     tdep->lr_frame_offset = 4;
6988
6989   if (have_spe || have_dfp || have_altivec
6990       || have_vsx || have_htm_fpu || have_htm_vsx)
6991     {
6992       set_gdbarch_pseudo_register_read (gdbarch, rs6000_pseudo_register_read);
6993       set_gdbarch_pseudo_register_write (gdbarch,
6994                                          rs6000_pseudo_register_write);
6995       set_gdbarch_ax_pseudo_register_collect (gdbarch,
6996               rs6000_ax_pseudo_register_collect);
6997     }
6998
6999   set_gdbarch_gen_return_address (gdbarch, rs6000_gen_return_address);
7000
7001   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
7002
7003   set_gdbarch_num_regs (gdbarch, PPC_NUM_REGS);
7004
7005   if (have_spe)
7006     num_pseudoregs += 32;
7007   if (have_dfp)
7008     num_pseudoregs += 16;
7009   if (have_altivec)
7010     num_pseudoregs += 32;
7011   if (have_vsx)
7012     /* Include both VSX and Extended FP registers.  */
7013     num_pseudoregs += 96;
7014   if (have_htm_fpu)
7015     num_pseudoregs += 16;
7016   /* Include both checkpointed VSX and EFP registers.  */
7017   if (have_htm_vsx)
7018     num_pseudoregs += 64 + 32;
7019
7020   set_gdbarch_num_pseudo_regs (gdbarch, num_pseudoregs);
7021
7022   set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
7023   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
7024   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
7025   set_gdbarch_long_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
7026   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
7027   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
7028   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
7029   set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
7030   set_gdbarch_char_signed (gdbarch, 0);
7031
7032   set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
7033   if (wordsize == 8)
7034     /* PPC64 SYSV.  */
7035     set_gdbarch_frame_red_zone_size (gdbarch, 288);
7036
7037   set_gdbarch_convert_register_p (gdbarch, rs6000_convert_register_p);
7038   set_gdbarch_register_to_value (gdbarch, rs6000_register_to_value);
7039   set_gdbarch_value_to_register (gdbarch, rs6000_value_to_register);
7040
7041   set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum);
7042   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rs6000_dwarf2_reg_to_regnum);
7043
7044   if (wordsize == 4)
7045     set_gdbarch_push_dummy_call (gdbarch, ppc_sysv_abi_push_dummy_call);
7046   else if (wordsize == 8)
7047     set_gdbarch_push_dummy_call (gdbarch, ppc64_sysv_abi_push_dummy_call);
7048
7049   set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue);
7050   set_gdbarch_stack_frame_destroyed_p (gdbarch, rs6000_stack_frame_destroyed_p);
7051   set_gdbarch_skip_main_prologue (gdbarch, rs6000_skip_main_prologue);
7052
7053   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
7054
7055   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
7056                                        rs6000_breakpoint::kind_from_pc);
7057   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
7058                                        rs6000_breakpoint::bp_from_kind);
7059
7060   /* The value of symbols of type N_SO and N_FUN maybe null when
7061      it shouldn't be.  */
7062   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
7063
7064   /* Handles single stepping of atomic sequences.  */
7065   set_gdbarch_software_single_step (gdbarch, ppc_deal_with_atomic_sequence);
7066
7067   /* Not sure on this.  FIXMEmgo */
7068   set_gdbarch_frame_args_skip (gdbarch, 8);
7069
7070   /* Helpers for function argument information.  */
7071   set_gdbarch_fetch_pointer_argument (gdbarch, rs6000_fetch_pointer_argument);
7072
7073   /* Trampoline.  */
7074   set_gdbarch_in_solib_return_trampoline
7075     (gdbarch, rs6000_in_solib_return_trampoline);
7076   set_gdbarch_skip_trampoline_code (gdbarch, rs6000_skip_trampoline_code);
7077
7078   /* Hook in the DWARF CFI frame unwinder.  */
7079   dwarf2_append_unwinders (gdbarch);
7080   dwarf2_frame_set_adjust_regnum (gdbarch, rs6000_adjust_frame_regnum);
7081
7082   /* Frame handling.  */
7083   dwarf2_frame_set_init_reg (gdbarch, ppc_dwarf2_frame_init_reg);
7084
7085   /* Setup displaced stepping.  */
7086   set_gdbarch_displaced_step_copy_insn (gdbarch,
7087                                         ppc_displaced_step_copy_insn);
7088   set_gdbarch_displaced_step_hw_singlestep (gdbarch,
7089                                             ppc_displaced_step_hw_singlestep);
7090   set_gdbarch_displaced_step_fixup (gdbarch, ppc_displaced_step_fixup);
7091   set_gdbarch_displaced_step_location (gdbarch,
7092                                        displaced_step_at_entry_point);
7093
7094   set_gdbarch_max_insn_length (gdbarch, PPC_INSN_SIZE);
7095
7096   /* Hook in ABI-specific overrides, if they have been registered.  */
7097   info.target_desc = tdesc;
7098   info.tdesc_data = tdesc_data;
7099   gdbarch_init_osabi (info, gdbarch);
7100
7101   switch (info.osabi)
7102     {
7103     case GDB_OSABI_LINUX:
7104     case GDB_OSABI_NETBSD:
7105     case GDB_OSABI_UNKNOWN:
7106       set_gdbarch_unwind_pc (gdbarch, rs6000_unwind_pc);
7107       frame_unwind_append_unwinder (gdbarch, &rs6000_epilogue_frame_unwind);
7108       frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
7109       set_gdbarch_dummy_id (gdbarch, rs6000_dummy_id);
7110       frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
7111       break;
7112     default:
7113       set_gdbarch_believe_pcc_promotion (gdbarch, 1);
7114
7115       set_gdbarch_unwind_pc (gdbarch, rs6000_unwind_pc);
7116       frame_unwind_append_unwinder (gdbarch, &rs6000_epilogue_frame_unwind);
7117       frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
7118       set_gdbarch_dummy_id (gdbarch, rs6000_dummy_id);
7119       frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
7120     }
7121
7122   set_tdesc_pseudo_register_type (gdbarch, rs6000_pseudo_register_type);
7123   set_tdesc_pseudo_register_reggroup_p (gdbarch,
7124                                         rs6000_pseudo_register_reggroup_p);
7125   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
7126
7127   /* Override the normal target description method to make the SPE upper
7128      halves anonymous.  */
7129   set_gdbarch_register_name (gdbarch, rs6000_register_name);
7130
7131   /* Choose register numbers for all supported pseudo-registers.  */
7132   tdep->ppc_ev0_regnum = -1;
7133   tdep->ppc_dl0_regnum = -1;
7134   tdep->ppc_v0_alias_regnum = -1;
7135   tdep->ppc_vsr0_regnum = -1;
7136   tdep->ppc_efpr0_regnum = -1;
7137   tdep->ppc_cdl0_regnum = -1;
7138   tdep->ppc_cvsr0_regnum = -1;
7139   tdep->ppc_cefpr0_regnum = -1;
7140
7141   cur_reg = gdbarch_num_regs (gdbarch);
7142
7143   if (have_spe)
7144     {
7145       tdep->ppc_ev0_regnum = cur_reg;
7146       cur_reg += 32;
7147     }
7148   if (have_dfp)
7149     {
7150       tdep->ppc_dl0_regnum = cur_reg;
7151       cur_reg += 16;
7152     }
7153   if (have_altivec)
7154     {
7155       tdep->ppc_v0_alias_regnum = cur_reg;
7156       cur_reg += 32;
7157     }
7158   if (have_vsx)
7159     {
7160       tdep->ppc_vsr0_regnum = cur_reg;
7161       cur_reg += 64;
7162       tdep->ppc_efpr0_regnum = cur_reg;
7163       cur_reg += 32;
7164     }
7165   if (have_htm_fpu)
7166     {
7167       tdep->ppc_cdl0_regnum = cur_reg;
7168       cur_reg += 16;
7169     }
7170   if (have_htm_vsx)
7171     {
7172       tdep->ppc_cvsr0_regnum = cur_reg;
7173       cur_reg += 64;
7174       tdep->ppc_cefpr0_regnum = cur_reg;
7175       cur_reg += 32;
7176     }
7177
7178   gdb_assert (gdbarch_num_cooked_regs (gdbarch) == cur_reg);
7179
7180   /* Register the ravenscar_arch_ops.  */
7181   if (mach == bfd_mach_ppc_e500)
7182     register_e500_ravenscar_ops (gdbarch);
7183   else
7184     register_ppc_ravenscar_ops (gdbarch);
7185
7186   set_gdbarch_disassembler_options (gdbarch, &powerpc_disassembler_options);
7187   set_gdbarch_valid_disassembler_options (gdbarch,
7188                                           disassembler_options_powerpc ());
7189
7190   return gdbarch;
7191 }
7192
7193 static void
7194 rs6000_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
7195 {
7196   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7197
7198   if (tdep == NULL)
7199     return;
7200
7201   /* FIXME: Dump gdbarch_tdep.  */
7202 }
7203
7204 /* PowerPC-specific commands.  */
7205
7206 static void
7207 set_powerpc_command (const char *args, int from_tty)
7208 {
7209   printf_unfiltered (_("\
7210 \"set powerpc\" must be followed by an appropriate subcommand.\n"));
7211   help_list (setpowerpccmdlist, "set powerpc ", all_commands, gdb_stdout);
7212 }
7213
7214 static void
7215 show_powerpc_command (const char *args, int from_tty)
7216 {
7217   cmd_show_list (showpowerpccmdlist, from_tty, "");
7218 }
7219
7220 static void
7221 powerpc_set_soft_float (const char *args, int from_tty,
7222                         struct cmd_list_element *c)
7223 {
7224   struct gdbarch_info info;
7225
7226   /* Update the architecture.  */
7227   gdbarch_info_init (&info);
7228   if (!gdbarch_update_p (info))
7229     internal_error (__FILE__, __LINE__, _("could not update architecture"));
7230 }
7231
7232 static void
7233 powerpc_set_vector_abi (const char *args, int from_tty,
7234                         struct cmd_list_element *c)
7235 {
7236   struct gdbarch_info info;
7237   int vector_abi;
7238
7239   for (vector_abi = POWERPC_VEC_AUTO;
7240        vector_abi != POWERPC_VEC_LAST;
7241        vector_abi++)
7242     if (strcmp (powerpc_vector_abi_string,
7243                 powerpc_vector_strings[vector_abi]) == 0)
7244       {
7245         powerpc_vector_abi_global = (enum powerpc_vector_abi) vector_abi;
7246         break;
7247       }
7248
7249   if (vector_abi == POWERPC_VEC_LAST)
7250     internal_error (__FILE__, __LINE__, _("Invalid vector ABI accepted: %s."),
7251                     powerpc_vector_abi_string);
7252
7253   /* Update the architecture.  */
7254   gdbarch_info_init (&info);
7255   if (!gdbarch_update_p (info))
7256     internal_error (__FILE__, __LINE__, _("could not update architecture"));
7257 }
7258
7259 /* Show the current setting of the exact watchpoints flag.  */
7260
7261 static void
7262 show_powerpc_exact_watchpoints (struct ui_file *file, int from_tty,
7263                                 struct cmd_list_element *c,
7264                                 const char *value)
7265 {
7266   fprintf_filtered (file, _("Use of exact watchpoints is %s.\n"), value);
7267 }
7268
7269 /* Read a PPC instruction from memory.  */
7270
7271 static unsigned int
7272 read_insn (struct frame_info *frame, CORE_ADDR pc)
7273 {
7274   struct gdbarch *gdbarch = get_frame_arch (frame);
7275   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7276
7277   return read_memory_unsigned_integer (pc, 4, byte_order);
7278 }
7279
7280 /* Return non-zero if the instructions at PC match the series
7281    described in PATTERN, or zero otherwise.  PATTERN is an array of
7282    'struct ppc_insn_pattern' objects, terminated by an entry whose
7283    mask is zero.
7284
7285    When the match is successful, fill INSNS[i] with what PATTERN[i]
7286    matched.  If PATTERN[i] is optional, and the instruction wasn't
7287    present, set INSNS[i] to 0 (which is not a valid PPC instruction).
7288    INSNS should have as many elements as PATTERN, minus the terminator.
7289    Note that, if PATTERN contains optional instructions which aren't
7290    present in memory, then INSNS will have holes, so INSNS[i] isn't
7291    necessarily the i'th instruction in memory.  */
7292
7293 int
7294 ppc_insns_match_pattern (struct frame_info *frame, CORE_ADDR pc,
7295                          const struct ppc_insn_pattern *pattern,
7296                          unsigned int *insns)
7297 {
7298   int i;
7299   unsigned int insn;
7300
7301   for (i = 0, insn = 0; pattern[i].mask; i++)
7302     {
7303       if (insn == 0)
7304         insn = read_insn (frame, pc);
7305       insns[i] = 0;
7306       if ((insn & pattern[i].mask) == pattern[i].data)
7307         {
7308           insns[i] = insn;
7309           pc += 4;
7310           insn = 0;
7311         }
7312       else if (!pattern[i].optional)
7313         return 0;
7314     }
7315
7316   return 1;
7317 }
7318
7319 /* Return the 'd' field of the d-form instruction INSN, properly
7320    sign-extended.  */
7321
7322 CORE_ADDR
7323 ppc_insn_d_field (unsigned int insn)
7324 {
7325   return ((((CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000);
7326 }
7327
7328 /* Return the 'ds' field of the ds-form instruction INSN, with the two
7329    zero bits concatenated at the right, and properly
7330    sign-extended.  */
7331
7332 CORE_ADDR
7333 ppc_insn_ds_field (unsigned int insn)
7334 {
7335   return ((((CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000);
7336 }
7337
7338 /* Initialization code.  */
7339
7340 void
7341 _initialize_rs6000_tdep (void)
7342 {
7343   gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep);
7344   gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep);
7345
7346   /* Initialize the standard target descriptions.  */
7347   initialize_tdesc_powerpc_32 ();
7348   initialize_tdesc_powerpc_altivec32 ();
7349   initialize_tdesc_powerpc_vsx32 ();
7350   initialize_tdesc_powerpc_403 ();
7351   initialize_tdesc_powerpc_403gc ();
7352   initialize_tdesc_powerpc_405 ();
7353   initialize_tdesc_powerpc_505 ();
7354   initialize_tdesc_powerpc_601 ();
7355   initialize_tdesc_powerpc_602 ();
7356   initialize_tdesc_powerpc_603 ();
7357   initialize_tdesc_powerpc_604 ();
7358   initialize_tdesc_powerpc_64 ();
7359   initialize_tdesc_powerpc_altivec64 ();
7360   initialize_tdesc_powerpc_vsx64 ();
7361   initialize_tdesc_powerpc_7400 ();
7362   initialize_tdesc_powerpc_750 ();
7363   initialize_tdesc_powerpc_860 ();
7364   initialize_tdesc_powerpc_e500 ();
7365   initialize_tdesc_rs6000 ();
7366
7367   /* Add root prefix command for all "set powerpc"/"show powerpc"
7368      commands.  */
7369   add_prefix_cmd ("powerpc", no_class, set_powerpc_command,
7370                   _("Various PowerPC-specific commands."),
7371                   &setpowerpccmdlist, "set powerpc ", 0, &setlist);
7372
7373   add_prefix_cmd ("powerpc", no_class, show_powerpc_command,
7374                   _("Various PowerPC-specific commands."),
7375                   &showpowerpccmdlist, "show powerpc ", 0, &showlist);
7376
7377   /* Add a command to allow the user to force the ABI.  */
7378   add_setshow_auto_boolean_cmd ("soft-float", class_support,
7379                                 &powerpc_soft_float_global,
7380                                 _("Set whether to use a soft-float ABI."),
7381                                 _("Show whether to use a soft-float ABI."),
7382                                 NULL,
7383                                 powerpc_set_soft_float, NULL,
7384                                 &setpowerpccmdlist, &showpowerpccmdlist);
7385
7386   add_setshow_enum_cmd ("vector-abi", class_support, powerpc_vector_strings,
7387                         &powerpc_vector_abi_string,
7388                         _("Set the vector ABI."),
7389                         _("Show the vector ABI."),
7390                         NULL, powerpc_set_vector_abi, NULL,
7391                         &setpowerpccmdlist, &showpowerpccmdlist);
7392
7393   add_setshow_boolean_cmd ("exact-watchpoints", class_support,
7394                            &target_exact_watchpoints,
7395                            _("\
7396 Set whether to use just one debug register for watchpoints on scalars."),
7397                            _("\
7398 Show whether to use just one debug register for watchpoints on scalars."),
7399                            _("\
7400 If true, GDB will use only one debug register when watching a variable of\n\
7401 scalar type, thus assuming that the variable is accessed through the address\n\
7402 of its first byte."),
7403                            NULL, show_powerpc_exact_watchpoints,
7404                            &setpowerpccmdlist, &showpowerpccmdlist);
7405 }