
/*---------------------------------------------------------------*/
/*--- begin                                   host_ppc_defs.c ---*/
/*---------------------------------------------------------------*/

/*
   This file is part of Valgrind, a dynamic binary instrumentation
   framework.

   Copyright (C) 2004-2013 OpenWorks LLP
      info@open-works.net

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.

   The GNU General Public License is contained in the file COPYING.

   Neither the names of the U.S. Department of Energy nor the
   University of California nor the names of its contributors may be
   used to endorse or promote products derived from this software
   without prior written permission.
*/

#include "libvex_basictypes.h"
#include "libvex.h"
#include "libvex_trc_values.h"

#include "main_util.h"
#include "host_generic_regs.h"
#include "host_ppc_defs.h"


/* --------- Registers. --------- */

void ppHRegPPC ( HReg reg ) 
{
   Int r;
   static const HChar* ireg32_names[32] 
      = { "%r0",  "%r1",  "%r2",  "%r3",
          "%r4",  "%r5",  "%r6",  "%r7",
          "%r8",  "%r9",  "%r10", "%r11",
          "%r12", "%r13", "%r14", "%r15",
          "%r16", "%r17", "%r18", "%r19",
          "%r20", "%r21", "%r22", "%r23",
          "%r24", "%r25", "%r26", "%r27",
          "%r28", "%r29", "%r30", "%r31" };
   /* Be generic for all virtual regs. */
   if (hregIsVirtual(reg)) {
      ppHReg(reg);
      return;
   }
   /* But specific for real regs. */
   switch (hregClass(reg)) {
   case HRcInt64:
      r = hregNumber(reg);
      vassert(r >= 0 && r < 32);
      vex_printf("%s", ireg32_names[r]);
      return;
   case HRcInt32:
      r = hregNumber(reg);
      vassert(r >= 0 && r < 32);
      vex_printf("%s", ireg32_names[r]);
      return;
   case HRcFlt64:
      r = hregNumber(reg);
      vassert(r >= 0 && r < 32);
      vex_printf("%%fr%d", r);
      return;
   case HRcVec128:
      r = hregNumber(reg);
      vassert(r >= 0 && r < 32);
      vex_printf("%%v%d", r);
      return;
   default:
      vpanic("ppHRegPPC");
   }
}


#define MkHRegGPR(_n, _mode64) \
   mkHReg(_n, _mode64 ? HRcInt64 : HRcInt32, False)

HReg hregPPC_GPR0  ( Bool mode64 ) { return MkHRegGPR( 0, mode64); }
HReg hregPPC_GPR1  ( Bool mode64 ) { return MkHRegGPR( 1, mode64); }
HReg hregPPC_GPR2  ( Bool mode64 ) { return MkHRegGPR( 2, mode64); }
HReg hregPPC_GPR3  ( Bool mode64 ) { return MkHRegGPR( 3, mode64); }
HReg hregPPC_GPR4  ( Bool mode64 ) { return MkHRegGPR( 4, mode64); }
HReg hregPPC_GPR5  ( Bool mode64 ) { return MkHRegGPR( 5, mode64); }
HReg hregPPC_GPR6  ( Bool mode64 ) { return MkHRegGPR( 6, mode64); }
HReg hregPPC_GPR7  ( Bool mode64 ) { return MkHRegGPR( 7, mode64); }
HReg hregPPC_GPR8  ( Bool mode64 ) { return MkHRegGPR( 8, mode64); }
HReg hregPPC_GPR9  ( Bool mode64 ) { return MkHRegGPR( 9, mode64); }
HReg hregPPC_GPR10 ( Bool mode64 ) { return MkHRegGPR(10, mode64); }
HReg hregPPC_GPR11 ( Bool mode64 ) { return MkHRegGPR(11, mode64); }
HReg hregPPC_GPR12 ( Bool mode64 ) { return MkHRegGPR(12, mode64); }
HReg hregPPC_GPR13 ( Bool mode64 ) { return MkHRegGPR(13, mode64); }
HReg hregPPC_GPR14 ( Bool mode64 ) { return MkHRegGPR(14, mode64); }
HReg hregPPC_GPR15 ( Bool mode64 ) { return MkHRegGPR(15, mode64); }
HReg hregPPC_GPR16 ( Bool mode64 ) { return MkHRegGPR(16, mode64); }
HReg hregPPC_GPR17 ( Bool mode64 ) { return MkHRegGPR(17, mode64); }
HReg hregPPC_GPR18 ( Bool mode64 ) { return MkHRegGPR(18, mode64); }
HReg hregPPC_GPR19 ( Bool mode64 ) { return MkHRegGPR(19, mode64); }
HReg hregPPC_GPR20 ( Bool mode64 ) { return MkHRegGPR(20, mode64); }
HReg hregPPC_GPR21 ( Bool mode64 ) { return MkHRegGPR(21, mode64); }
HReg hregPPC_GPR22 ( Bool mode64 ) { return MkHRegGPR(22, mode64); }
HReg hregPPC_GPR23 ( Bool mode64 ) { return MkHRegGPR(23, mode64); }
HReg hregPPC_GPR24 ( Bool mode64 ) { return MkHRegGPR(24, mode64); }
HReg hregPPC_GPR25 ( Bool mode64 ) { return MkHRegGPR(25, mode64); }
HReg hregPPC_GPR26 ( Bool mode64 ) { return MkHRegGPR(26, mode64); }
HReg hregPPC_GPR27 ( Bool mode64 ) { return MkHRegGPR(27, mode64); }
HReg hregPPC_GPR28 ( Bool mode64 ) { return MkHRegGPR(28, mode64); }
HReg hregPPC_GPR29 ( Bool mode64 ) { return MkHRegGPR(29, mode64); }
HReg hregPPC_GPR30 ( Bool mode64 ) { return MkHRegGPR(30, mode64); }
HReg hregPPC_GPR31 ( Bool mode64 ) { return MkHRegGPR(31, mode64); }

#undef MK_INT_HREG

HReg hregPPC_FPR0  ( void ) { return mkHReg( 0, HRcFlt64, False); }
HReg hregPPC_FPR1  ( void ) { return mkHReg( 1, HRcFlt64, False); }
HReg hregPPC_FPR2  ( void ) { return mkHReg( 2, HRcFlt64, False); }
HReg hregPPC_FPR3  ( void ) { return mkHReg( 3, HRcFlt64, False); }
HReg hregPPC_FPR4  ( void ) { return mkHReg( 4, HRcFlt64, False); }
HReg hregPPC_FPR5  ( void ) { return mkHReg( 5, HRcFlt64, False); }
HReg hregPPC_FPR6  ( void ) { return mkHReg( 6, HRcFlt64, False); }
HReg hregPPC_FPR7  ( void ) { return mkHReg( 7, HRcFlt64, False); }
HReg hregPPC_FPR8  ( void ) { return mkHReg( 8, HRcFlt64, False); }
HReg hregPPC_FPR9  ( void ) { return mkHReg( 9, HRcFlt64, False); }
HReg hregPPC_FPR10 ( void ) { return mkHReg(10, HRcFlt64, False); }
HReg hregPPC_FPR11 ( void ) { return mkHReg(11, HRcFlt64, False); }
HReg hregPPC_FPR12 ( void ) { return mkHReg(12, HRcFlt64, False); }
HReg hregPPC_FPR13 ( void ) { return mkHReg(13, HRcFlt64, False); }
HReg hregPPC_FPR14 ( void ) { return mkHReg(14, HRcFlt64, False); }
HReg hregPPC_FPR15 ( void ) { return mkHReg(15, HRcFlt64, False); }
HReg hregPPC_FPR16 ( void ) { return mkHReg(16, HRcFlt64, False); }
HReg hregPPC_FPR17 ( void ) { return mkHReg(17, HRcFlt64, False); }
HReg hregPPC_FPR18 ( void ) { return mkHReg(18, HRcFlt64, False); }
HReg hregPPC_FPR19 ( void ) { return mkHReg(19, HRcFlt64, False); }
HReg hregPPC_FPR20 ( void ) { return mkHReg(20, HRcFlt64, False); }
HReg hregPPC_FPR21 ( void ) { return mkHReg(21, HRcFlt64, False); }
HReg hregPPC_FPR22 ( void ) { return mkHReg(22, HRcFlt64, False); }
HReg hregPPC_FPR23 ( void ) { return mkHReg(23, HRcFlt64, False); }
HReg hregPPC_FPR24 ( void ) { return mkHReg(24, HRcFlt64, False); }
HReg hregPPC_FPR25 ( void ) { return mkHReg(25, HRcFlt64, False); }
HReg hregPPC_FPR26 ( void ) { return mkHReg(26, HRcFlt64, False); }
HReg hregPPC_FPR27 ( void ) { return mkHReg(27, HRcFlt64, False); }
HReg hregPPC_FPR28 ( void ) { return mkHReg(28, HRcFlt64, False); }
HReg hregPPC_FPR29 ( void ) { return mkHReg(29, HRcFlt64, False); }
HReg hregPPC_FPR30 ( void ) { return mkHReg(30, HRcFlt64, False); }
HReg hregPPC_FPR31 ( void ) { return mkHReg(31, HRcFlt64, False); }

HReg hregPPC_VR0  ( void ) { return mkHReg( 0, HRcVec128, False); }
HReg hregPPC_VR1  ( void ) { return mkHReg( 1, HRcVec128, False); }
HReg hregPPC_VR2  ( void ) { return mkHReg( 2, HRcVec128, False); }
HReg hregPPC_VR3  ( void ) { return mkHReg( 3, HRcVec128, False); }
HReg hregPPC_VR4  ( void ) { return mkHReg( 4, HRcVec128, False); }
HReg hregPPC_VR5  ( void ) { return mkHReg( 5, HRcVec128, False); }
HReg hregPPC_VR6  ( void ) { return mkHReg( 6, HRcVec128, False); }
HReg hregPPC_VR7  ( void ) { return mkHReg( 7, HRcVec128, False); }
HReg hregPPC_VR8  ( void ) { return mkHReg( 8, HRcVec128, False); }
HReg hregPPC_VR9  ( void ) { return mkHReg( 9, HRcVec128, False); }
HReg hregPPC_VR10 ( void ) { return mkHReg(10, HRcVec128, False); }
HReg hregPPC_VR11 ( void ) { return mkHReg(11, HRcVec128, False); }
HReg hregPPC_VR12 ( void ) { return mkHReg(12, HRcVec128, False); }
HReg hregPPC_VR13 ( void ) { return mkHReg(13, HRcVec128, False); }
HReg hregPPC_VR14 ( void ) { return mkHReg(14, HRcVec128, False); }
HReg hregPPC_VR15 ( void ) { return mkHReg(15, HRcVec128, False); }
HReg hregPPC_VR16 ( void ) { return mkHReg(16, HRcVec128, False); }
HReg hregPPC_VR17 ( void ) { return mkHReg(17, HRcVec128, False); }
HReg hregPPC_VR18 ( void ) { return mkHReg(18, HRcVec128, False); }
HReg hregPPC_VR19 ( void ) { return mkHReg(19, HRcVec128, False); }
HReg hregPPC_VR20 ( void ) { return mkHReg(20, HRcVec128, False); }
HReg hregPPC_VR21 ( void ) { return mkHReg(21, HRcVec128, False); }
HReg hregPPC_VR22 ( void ) { return mkHReg(22, HRcVec128, False); }
HReg hregPPC_VR23 ( void ) { return mkHReg(23, HRcVec128, False); }
HReg hregPPC_VR24 ( void ) { return mkHReg(24, HRcVec128, False); }
HReg hregPPC_VR25 ( void ) { return mkHReg(25, HRcVec128, False); }
HReg hregPPC_VR26 ( void ) { return mkHReg(26, HRcVec128, False); }
HReg hregPPC_VR27 ( void ) { return mkHReg(27, HRcVec128, False); }
HReg hregPPC_VR28 ( void ) { return mkHReg(28, HRcVec128, False); }
HReg hregPPC_VR29 ( void ) { return mkHReg(29, HRcVec128, False); }
HReg hregPPC_VR30 ( void ) { return mkHReg(30, HRcVec128, False); }
HReg hregPPC_VR31 ( void ) { return mkHReg(31, HRcVec128, False); }

void getAllocableRegs_PPC ( Int* nregs, HReg** arr, Bool mode64 )
{
   UInt i=0;
   if (mode64)
      *nregs = (32-9) + (32-24) + (32-24);
   else
      *nregs = (32-7) + (32-24) + (32-24);
   *arr = LibVEX_Alloc(*nregs * sizeof(HReg));
   // GPR0 = scratch reg where poss. - some ops interpret as value zero
   // GPR1 = stack pointer
   // GPR2 = TOC pointer
   (*arr)[i++] = hregPPC_GPR3(mode64);
   (*arr)[i++] = hregPPC_GPR4(mode64);
   (*arr)[i++] = hregPPC_GPR5(mode64);
   (*arr)[i++] = hregPPC_GPR6(mode64);
   (*arr)[i++] = hregPPC_GPR7(mode64);
   (*arr)[i++] = hregPPC_GPR8(mode64);
   (*arr)[i++] = hregPPC_GPR9(mode64);
   (*arr)[i++] = hregPPC_GPR10(mode64);
   if (!mode64) {
      /* in mode64: 
         r11 used for calls by ptr / env ptr for some langs
         r12 used for exception handling and global linkage code */
      (*arr)[i++] = hregPPC_GPR11(mode64);
      (*arr)[i++] = hregPPC_GPR12(mode64);
   }
   // GPR13 = thread specific pointer
   // GPR14 and above are callee save.  Yay.
   (*arr)[i++] = hregPPC_GPR14(mode64);
   (*arr)[i++] = hregPPC_GPR15(mode64);
   (*arr)[i++] = hregPPC_GPR16(mode64);
   (*arr)[i++] = hregPPC_GPR17(mode64);
   (*arr)[i++] = hregPPC_GPR18(mode64);
   (*arr)[i++] = hregPPC_GPR19(mode64);
   (*arr)[i++] = hregPPC_GPR20(mode64);
   (*arr)[i++] = hregPPC_GPR21(mode64);
   (*arr)[i++] = hregPPC_GPR22(mode64);
   (*arr)[i++] = hregPPC_GPR23(mode64);
   (*arr)[i++] = hregPPC_GPR24(mode64);
   (*arr)[i++] = hregPPC_GPR25(mode64);
   (*arr)[i++] = hregPPC_GPR26(mode64);
   (*arr)[i++] = hregPPC_GPR27(mode64);
   (*arr)[i++] = hregPPC_GPR28(mode64);
   // GPR29 is reserved for the dispatcher
   // GPR30 is reserved as AltiVec spill reg temporary
   // GPR31 is reserved for the GuestStatePtr

   /* Don't waste the reg-allocs's time trawling through zillions of
      FP registers - they mostly will never be used.  We'll tolerate
      the occasional extra spill instead. */
   /* For both ppc32-linux and ppc64-linux, f14-f31 are callee save.
      So use them. */
   (*arr)[i++] = hregPPC_FPR14();
   (*arr)[i++] = hregPPC_FPR15();
   (*arr)[i++] = hregPPC_FPR16();
   (*arr)[i++] = hregPPC_FPR17();
   (*arr)[i++] = hregPPC_FPR18();
   (*arr)[i++] = hregPPC_FPR19();
   (*arr)[i++] = hregPPC_FPR20();
   (*arr)[i++] = hregPPC_FPR21();

   /* Same deal re Altivec */
   /* For both ppc32-linux and ppc64-linux, v20-v31 are callee save.
      So use them. */
   /* NB, vr29 is used as a scratch temporary -- do not allocate */
   (*arr)[i++] = hregPPC_VR20();
   (*arr)[i++] = hregPPC_VR21();
   (*arr)[i++] = hregPPC_VR22();
   (*arr)[i++] = hregPPC_VR23();
   (*arr)[i++] = hregPPC_VR24();
   (*arr)[i++] = hregPPC_VR25();
   (*arr)[i++] = hregPPC_VR26();
   (*arr)[i++] = hregPPC_VR27();

   vassert(i == *nregs);
}


/* --------- Condition codes, Intel encoding. --------- */

const HChar* showPPCCondCode ( PPCCondCode cond )
{
   if (cond.test == Pct_ALWAYS) return "always";

   switch (cond.flag) {
   case Pcf_7SO:
      return (cond.test == Pct_TRUE) ? "cr7.so=1" : "cr7.so=0";
   case Pcf_7EQ:
      return (cond.test == Pct_TRUE) ? "cr7.eq=1" : "cr7.eq=0";
   case Pcf_7GT:
      return (cond.test == Pct_TRUE) ? "cr7.gt=1" : "cr7.gt=0";
   case Pcf_7LT:
      return (cond.test == Pct_TRUE) ? "cr7.lt=1" : "cr7.lt=0";
   case Pcf_NONE:
      return "no-flag";
   default: vpanic("ppPPCCondCode");
   }
}

/* construct condition code */
PPCCondCode mk_PPCCondCode ( PPCCondTest test, PPCCondFlag flag )
{
   PPCCondCode cc;
   cc.flag = flag;
   cc.test = test;
   if (test == Pct_ALWAYS) { 
      vassert(flag == Pcf_NONE);
   } else {
      vassert(flag != Pcf_NONE);
   }
   return cc;
}

/* false->true, true->false */
PPCCondTest invertCondTest ( PPCCondTest ct )
{
   vassert(ct != Pct_ALWAYS);
   return (ct == Pct_TRUE) ? Pct_FALSE : Pct_TRUE;
}


/* --------- PPCAMode: memory address expressions. --------- */

PPCAMode* PPCAMode_IR ( Int idx, HReg base ) {
   PPCAMode* am = LibVEX_Alloc(sizeof(PPCAMode));
   vassert(idx >= -0x8000 && idx < 0x8000);
   am->tag = Pam_IR;
   am->Pam.IR.base = base;
   am->Pam.IR.index = idx;
   return am;
}
PPCAMode* PPCAMode_RR ( HReg idx, HReg base ) {
   PPCAMode* am = LibVEX_Alloc(sizeof(PPCAMode));
   am->tag = Pam_RR;
   am->Pam.RR.base = base;
   am->Pam.RR.index = idx;
   return am;
}

PPCAMode* dopyPPCAMode ( PPCAMode* am ) {
   switch (am->tag) {
   case Pam_IR: 
      return PPCAMode_IR( am->Pam.IR.index, am->Pam.IR.base );
   case Pam_RR: 
      return PPCAMode_RR( am->Pam.RR.index, am->Pam.RR.base );
   default:
      vpanic("dopyPPCAMode");
   }
}

void ppPPCAMode ( PPCAMode* am ) {
   switch (am->tag) {
   case Pam_IR: 
      if (am->Pam.IR.index == 0)
         vex_printf("0(");
      else
         vex_printf("%d(", (Int)am->Pam.IR.index);
      ppHRegPPC(am->Pam.IR.base);
      vex_printf(")");
      return;
   case Pam_RR:
      ppHRegPPC(am->Pam.RR.base);
      vex_printf(",");
      ppHRegPPC(am->Pam.RR.index);
      return;
   default:
      vpanic("ppPPCAMode");
   }
}

static void addRegUsage_PPCAMode ( HRegUsage* u, PPCAMode* am ) {
   switch (am->tag) {
   case Pam_IR: 
      addHRegUse(u, HRmRead, am->Pam.IR.base);
      return;
   case Pam_RR:
      addHRegUse(u, HRmRead, am->Pam.RR.base);
      addHRegUse(u, HRmRead, am->Pam.RR.index);
      return;
   default:
      vpanic("addRegUsage_PPCAMode");
   }
}

static void mapRegs_PPCAMode ( HRegRemap* m, PPCAMode* am ) {
   switch (am->tag) {
   case Pam_IR: 
      am->Pam.IR.base = lookupHRegRemap(m, am->Pam.IR.base);
      return;
   case Pam_RR:
      am->Pam.RR.base = lookupHRegRemap(m, am->Pam.RR.base);
      am->Pam.RR.index = lookupHRegRemap(m, am->Pam.RR.index);
      return;
   default:
      vpanic("mapRegs_PPCAMode");
   }
}

/* --------- Operand, which can be a reg or a u16/s16. --------- */

PPCRH* PPCRH_Imm ( Bool syned, UShort imm16 ) {
   PPCRH* op         = LibVEX_Alloc(sizeof(PPCRH));
   op->tag           = Prh_Imm;
   op->Prh.Imm.syned = syned;
   op->Prh.Imm.imm16 = imm16;
   /* If this is a signed value, ensure it's not -32768, so that we
      are guaranteed always to be able to negate if needed. */
   if (syned)
      vassert(imm16 != 0x8000);
   vassert(syned == True || syned == False);
   return op;
}
PPCRH* PPCRH_Reg ( HReg reg ) {
   PPCRH* op       = LibVEX_Alloc(sizeof(PPCRH));
   op->tag         = Prh_Reg;
   op->Prh.Reg.reg = reg;
   return op;
}

void ppPPCRH ( PPCRH* op ) {
   switch (op->tag) {
   case Prh_Imm: 
      if (op->Prh.Imm.syned)
         vex_printf("%d", (Int)(Short)op->Prh.Imm.imm16);
      else
         vex_printf("%u", (UInt)(UShort)op->Prh.Imm.imm16);
      return;
   case Prh_Reg: 
      ppHRegPPC(op->Prh.Reg.reg);
      return;
   default: 
      vpanic("ppPPCRH");
   }
}

/* An PPCRH can only be used in a "read" context (what would it mean
   to write or modify a literal?) and so we enumerate its registers
   accordingly. */
static void addRegUsage_PPCRH ( HRegUsage* u, PPCRH* op ) {
   switch (op->tag) {
   case Prh_Imm: 
      return;
   case Prh_Reg: 
      addHRegUse(u, HRmRead, op->Prh.Reg.reg);
      return;
   default: 
      vpanic("addRegUsage_PPCRH");
   }
}

static void mapRegs_PPCRH ( HRegRemap* m, PPCRH* op ) {
   switch (op->tag) {
   case Prh_Imm: 
      return;
   case Prh_Reg: 
      op->Prh.Reg.reg = lookupHRegRemap(m, op->Prh.Reg.reg);
      return;
   default: 
      vpanic("mapRegs_PPCRH");
   }
}


/* --------- Operand, which can be a reg or a u32/64. --------- */

PPCRI* PPCRI_Imm ( ULong imm64 ) {
   PPCRI* op   = LibVEX_Alloc(sizeof(PPCRI));
   op->tag     = Pri_Imm;
   op->Pri.Imm = imm64;
   return op;
}
PPCRI* PPCRI_Reg ( HReg reg ) {
   PPCRI* op   = LibVEX_Alloc(sizeof(PPCRI));
   op->tag     = Pri_Reg;
   op->Pri.Reg = reg;
   return op;
}

void ppPPCRI ( PPCRI* dst ) {
   switch (dst->tag) {
      case Pri_Imm: 
         vex_printf("0x%llx", dst->Pri.Imm);
         break;
      case Pri_Reg: 
         ppHRegPPC(dst->Pri.Reg);
         break;
      default: 
         vpanic("ppPPCRI");
   }
}

/* An PPCRI can only be used in a "read" context (what would it
   mean to write or modify a literal?) and so we enumerate its
   registers accordingly. */
static void addRegUsage_PPCRI ( HRegUsage* u, PPCRI* dst ) {
   switch (dst->tag) {
      case Pri_Imm: 
         return;
      case Pri_Reg: 
         addHRegUse(u, HRmRead, dst->Pri.Reg);
         return;
      default: 
         vpanic("addRegUsage_PPCRI");
   }
}

static void mapRegs_PPCRI ( HRegRemap* m, PPCRI* dst ) {
   switch (dst->tag) {
      case Pri_Imm: 
         return;
      case Pri_Reg: 
         dst->Pri.Reg = lookupHRegRemap(m, dst->Pri.Reg);
         return;
      default: 
         vpanic("mapRegs_PPCRI");
   }
}


/* --------- Operand, which can be a vector reg or a simm5. --------- */

PPCVI5s* PPCVI5s_Imm ( Char simm5 ) {
   PPCVI5s* op   = LibVEX_Alloc(sizeof(PPCVI5s));
   op->tag       = Pvi_Imm;
   op->Pvi.Imm5s = simm5;
   vassert(simm5 >= -16 && simm5 <= 15);
   return op;
}
PPCVI5s* PPCVI5s_Reg ( HReg reg ) {
   PPCVI5s* op = LibVEX_Alloc(sizeof(PPCVI5s));
   op->tag     = Pvi_Reg;
   op->Pvi.Reg = reg;
   vassert(hregClass(reg) == HRcVec128);
   return op;
}

void ppPPCVI5s ( PPCVI5s* src ) {
   switch (src->tag) {
      case Pvi_Imm: 
         vex_printf("%d", (Int)src->Pvi.Imm5s);
         break;
      case Pvi_Reg: 
         ppHRegPPC(src->Pvi.Reg);
         break;
      default: 
         vpanic("ppPPCVI5s");
   }
}

/* An PPCVI5s can only be used in a "read" context (what would it
   mean to write or modify a literal?) and so we enumerate its
   registers accordingly. */
static void addRegUsage_PPCVI5s ( HRegUsage* u, PPCVI5s* dst ) {
   switch (dst->tag) {
      case Pvi_Imm: 
         return;
      case Pvi_Reg: 
         addHRegUse(u, HRmRead, dst->Pvi.Reg);
         return;
      default: 
         vpanic("addRegUsage_PPCVI5s");
   }
}

static void mapRegs_PPCVI5s ( HRegRemap* m, PPCVI5s* dst ) {
   switch (dst->tag) {
      case Pvi_Imm: 
         return;
      case Pvi_Reg: 
         dst->Pvi.Reg = lookupHRegRemap(m, dst->Pvi.Reg);
         return;
      default: 
         vpanic("mapRegs_PPCVI5s");
   }
}


/* --------- Instructions. --------- */

const HChar* showPPCUnaryOp ( PPCUnaryOp op ) {
   switch (op) {
   case Pun_NOT:   return "not";
   case Pun_NEG:   return "neg";
   case Pun_CLZ32: return "cntlzw";
   case Pun_CLZ64: return "cntlzd";
   case Pun_EXTSW: return "extsw";
   default: vpanic("showPPCUnaryOp");
   }
}

const HChar* showPPCAluOp ( PPCAluOp op, Bool immR ) {
   switch (op) {
      case Palu_ADD: return immR ? "addi"  : "add";
      case Palu_SUB: return immR ? "subi"  : "sub";
      case Palu_AND: return immR ? "andi." : "and";
      case Palu_OR:  return immR ? "ori"   : "or";
      case Palu_XOR: return immR ? "xori"  : "xor";
      default: vpanic("showPPCAluOp");
   }
}

const HChar* showPPCShftOp ( PPCShftOp op, Bool immR, Bool sz32 ) {
   switch (op) {
      case Pshft_SHL: return sz32 ? (immR ? "slwi"  : "slw") : 
                                    (immR ? "sldi"  : "sld");
      case Pshft_SHR: return sz32 ? (immR ? "srwi"  : "srw") :
                                    (immR ? "srdi"  : "srd");
      case Pshft_SAR: return sz32 ? (immR ? "srawi" : "sraw") :
                                    (immR ? "sradi" : "srad");
      default: vpanic("showPPCShftOp");
   }
}

const HChar* showPPCFpOp ( PPCFpOp op ) {
   switch (op) {
      case Pfp_ADDD:   return "fadd";
      case Pfp_SUBD:   return "fsub";
      case Pfp_MULD:   return "fmul";
      case Pfp_DIVD:   return "fdiv";
      case Pfp_MADDD:  return "fmadd";
      case Pfp_MSUBD:  return "fmsub";
      case Pfp_MADDS:  return "fmadds";
      case Pfp_MSUBS:  return "fmsubs";
      case Pfp_ADDS:   return "fadds";
      case Pfp_SUBS:   return "fsubs";
      case Pfp_MULS:   return "fmuls";
      case Pfp_DIVS:   return "fdivs";
      case Pfp_SQRT:   return "fsqrt";
      case Pfp_ABS:    return "fabs";
      case Pfp_NEG:    return "fneg";
      case Pfp_MOV:    return "fmr";
      case Pfp_RES:    return "fres";
      case Pfp_RSQRTE: return "frsqrte";
      case Pfp_FRIM:   return "frim";
      case Pfp_FRIN:   return "frin";
      case Pfp_FRIP:   return "frip";
      case Pfp_FRIZ:   return "friz";
      case Pfp_DFPADD:     return "dadd";
      case Pfp_DFPADDQ:    return "daddq";
      case Pfp_DFPSUB:     return "dsub";
      case Pfp_DFPSUBQ:    return "dsubq";
      case Pfp_DFPMUL:     return "dmul";
      case Pfp_DFPMULQ:    return "dmulq";
      case Pfp_DFPDIV:     return "ddivd";
      case Pfp_DFPDIVQ:    return "ddivq";
      case Pfp_DCTDP:      return "dctdp";
      case Pfp_DRSP:       return "drsp";
      case Pfp_DCTFIX:     return "dctfix";
      case Pfp_DCFFIX:     return "dcffix";
      case Pfp_DCTQPQ:     return "dctqpq";
      case Pfp_DCFFIXQ:    return "dcffixq";
      case Pfp_DQUA:       return "dqua";
      case Pfp_DQUAQ:      return "dquaq";
      case Pfp_DXEX:       return "dxex";
      case Pfp_DXEXQ:      return "dxexq";
      case Pfp_DIEX:       return "diex";
      case Pfp_DIEXQ:      return "diexq";
      case Pfp_RRDTR:      return "rrdtr";
      default: vpanic("showPPCFpOp");
   }
}

const HChar* showPPCAvOp ( PPCAvOp op ) {
   switch (op) {

   /* Unary */
   case Pav_MOV:       return "vmr";      /* Mov */
     
   case Pav_AND:       return "vand";     /* Bitwise */
   case Pav_OR:        return "vor";
   case Pav_XOR:       return "vxor";
   case Pav_NOT:       return "vnot";

   case Pav_UNPCKH8S:  return "vupkhsb";  /* Unpack */
   case Pav_UNPCKH16S: return "vupkhsh";
   case Pav_UNPCKL8S:  return "vupklsb";
   case Pav_UNPCKL16S: return "vupklsh";
   case Pav_UNPCKHPIX: return "vupkhpx";
   case Pav_UNPCKLPIX: return "vupklpx";

   /* Integer binary */
   case Pav_ADDU:      return "vaddu_m";  // b,h,w,dw
   case Pav_QADDU:     return "vaddu_s";  // b,h,w,dw
   case Pav_QADDS:     return "vadds_s";  // b,h,w,dw
     
   case Pav_SUBU:      return "vsubu_m";  // b,h,w,dw
   case Pav_QSUBU:     return "vsubu_s";  // b,h,w,dw
   case Pav_QSUBS:     return "vsubs_s";  // b,h,w,dw
     
   case Pav_MULU:      return "vmulu";    // w
   case Pav_OMULU:     return "vmulou";   // b,h,w
   case Pav_OMULS:     return "vmulos";   // b,h,w
   case Pav_EMULU:     return "vmuleu";   // b,h,w
   case Pav_EMULS:     return "vmules";   // b,h,w
  
   case Pav_AVGU:      return "vavgu";    // b,h,w
   case Pav_AVGS:      return "vavgs";    // b,h,w
     
   case Pav_MAXU:      return "vmaxu";    // b,h,w
   case Pav_MAXS:      return "vmaxs";    // b,h,w
     
   case Pav_MINU:      return "vminu";    // b,h,w
   case Pav_MINS:      return "vmins";    // b,h,w
     
   /* Compare (always affects CR field 6) */
   case Pav_CMPEQU:    return "vcmpequ";  // b,h,w
   case Pav_CMPGTU:    return "vcmpgtu";  // b,h,w
   case Pav_CMPGTS:    return "vcmpgts";  // b,h,w

   /* Shift */
   case Pav_SHL:       return "vsl";      // ' ',b,h,w,dw
   case Pav_SHR:       return "vsr";      // ' ',b,h,w,dw
   case Pav_SAR:       return "vsra";     // b,h,w,dw
   case Pav_ROTL:      return "vrl";      // b,h,w,dw

   /* Pack */
   case Pav_PACKUU:    return "vpku_um";  // h,w,dw
   case Pav_QPACKUU:   return "vpku_us";  // h,w
   case Pav_QPACKSU:   return "vpks_us";  // h,w
   case Pav_QPACKSS:   return "vpks_ss";  // h,w
   case Pav_PACKPXL:   return "vpkpx";

   /* Merge */
   case Pav_MRGHI:     return "vmrgh";    // b,h,w
   case Pav_MRGLO:     return "vmrgl";    // b,h,w

   /* Concatenation */
   case Pav_CATODD:     return "vmrgow";    // w
   case Pav_CATEVEN:    return "vmrgew";    // w

   /* SHA */
   case Pav_SHA256:     return "vshasigmaw"; // w
   case Pav_SHA512:     return "vshasigmaw"; // dw

   /* BCD */
   case Pav_BCDAdd:     return "bcdadd.";  // qw
   case Pav_BCDSub:     return "bcdsub.";  // qw

   /* Polynomial arith */
   case Pav_POLYMULADD: return "vpmsum";   // b, h, w, d

   /* Cipher */
   case Pav_CIPHERV128:  case Pav_CIPHERLV128:
   case Pav_NCIPHERV128: case Pav_NCIPHERLV128:
   case Pav_CIPHERSUBV128: return "v_cipher_";  // qw

   /* zero count */
   case Pav_ZEROCNTBYTE: case Pav_ZEROCNTWORD:
   case Pav_ZEROCNTHALF: case Pav_ZEROCNTDBL:
      return "vclz_";                           // b, h, w, d

   /* vector gather (byte-by-byte bit matrix transpose) */
   case Pav_BITMTXXPOSE:
      return "vgbbd";

   default: vpanic("showPPCAvOp");
   }
}

const HChar* showPPCAvFpOp ( PPCAvFpOp op ) {
   switch (op) {
   /* Floating Point Binary */
   case Pavfp_ADDF:      return "vaddfp";
   case Pavfp_SUBF:      return "vsubfp";
   case Pavfp_MULF:      return "vmaddfp";
   case Pavfp_MAXF:      return "vmaxfp";
   case Pavfp_MINF:      return "vminfp";
   case Pavfp_CMPEQF:    return "vcmpeqfp";
   case Pavfp_CMPGTF:    return "vcmpgtfp";
   case Pavfp_CMPGEF:    return "vcmpgefp";
     
   /* Floating Point Unary */
   case Pavfp_RCPF:      return "vrefp";
   case Pavfp_RSQRTF:    return "vrsqrtefp";
   case Pavfp_CVTU2F:    return "vcfux";
   case Pavfp_CVTS2F:    return "vcfsx";
   case Pavfp_QCVTF2U:   return "vctuxs";
   case Pavfp_QCVTF2S:   return "vctsxs";
   case Pavfp_ROUNDM:    return "vrfim";
   case Pavfp_ROUNDP:    return "vrfip";
   case Pavfp_ROUNDN:    return "vrfin";
   case Pavfp_ROUNDZ:    return "vrfiz";

   default: vpanic("showPPCAvFpOp");
   }
}

PPCInstr* PPCInstr_LI ( HReg dst, ULong imm64, Bool mode64 )
{
   PPCInstr* i     = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag          = Pin_LI;
   i->Pin.LI.dst   = dst;
   i->Pin.LI.imm64 = imm64;
   if (!mode64)
      vassert( (Long)imm64 == (Long)(Int)(UInt)imm64 );
   return i;
}
PPCInstr* PPCInstr_Alu ( PPCAluOp op, HReg dst, 
                         HReg srcL, PPCRH* srcR ) {
   PPCInstr* i     = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag          = Pin_Alu;
   i->Pin.Alu.op   = op;
   i->Pin.Alu.dst  = dst;
   i->Pin.Alu.srcL = srcL;
   i->Pin.Alu.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_Shft ( PPCShftOp op, Bool sz32, 
                          HReg dst, HReg srcL, PPCRH* srcR ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_Shft;
   i->Pin.Shft.op   = op;
   i->Pin.Shft.sz32 = sz32;
   i->Pin.Shft.dst  = dst;
   i->Pin.Shft.srcL = srcL;
   i->Pin.Shft.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AddSubC ( Bool isAdd, Bool setC,
                             HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_AddSubC;
   i->Pin.AddSubC.isAdd = isAdd;
   i->Pin.AddSubC.setC  = setC;
   i->Pin.AddSubC.dst   = dst;
   i->Pin.AddSubC.srcL  = srcL;
   i->Pin.AddSubC.srcR  = srcR;
   return i;
}
PPCInstr* PPCInstr_Cmp ( Bool syned, Bool sz32, 
                         UInt crfD, HReg srcL, PPCRH* srcR ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_Cmp;
   i->Pin.Cmp.syned = syned;
   i->Pin.Cmp.sz32  = sz32;
   i->Pin.Cmp.crfD  = crfD;
   i->Pin.Cmp.srcL  = srcL;
   i->Pin.Cmp.srcR  = srcR;
   return i;
}
PPCInstr* PPCInstr_Unary ( PPCUnaryOp op, HReg dst, HReg src ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_Unary;
   i->Pin.Unary.op  = op;
   i->Pin.Unary.dst = dst;
   i->Pin.Unary.src = src;
   return i;
}
PPCInstr* PPCInstr_MulL ( Bool syned, Bool hi, Bool sz32, 
                          HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_MulL;
   i->Pin.MulL.syned = syned;
   i->Pin.MulL.hi    = hi;
   i->Pin.MulL.sz32  = sz32;
   i->Pin.MulL.dst   = dst;
   i->Pin.MulL.srcL  = srcL;
   i->Pin.MulL.srcR  = srcR;
   /* if doing the low word, the signedness is irrelevant, but tie it
      down anyway. */
   if (!hi) vassert(!syned);
   return i;
}
PPCInstr* PPCInstr_Div ( Bool extended, Bool syned, Bool sz32,
                         HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_Div;
   i->Pin.Div.extended = extended;
   i->Pin.Div.syned = syned;
   i->Pin.Div.sz32  = sz32;
   i->Pin.Div.dst   = dst;
   i->Pin.Div.srcL  = srcL;
   i->Pin.Div.srcR  = srcR;
   return i;
}
PPCInstr* PPCInstr_Call ( PPCCondCode cond, 
                          Addr64 target, UInt argiregs, RetLoc rloc ) {
   UInt mask;
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_Call;
   i->Pin.Call.cond     = cond;
   i->Pin.Call.target   = target;
   i->Pin.Call.argiregs = argiregs;
   i->Pin.Call.rloc     = rloc;
   /* Only r3 .. r10 inclusive may be used as arg regs. Hence: */
   mask = (1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<8)|(1<<9)|(1<<10);
   vassert(0 == (argiregs & ~mask));
   vassert(is_sane_RetLoc(rloc));
   return i;
}
PPCInstr* PPCInstr_XDirect ( Addr64 dstGA, PPCAMode* amCIA,
                             PPCCondCode cond, Bool toFastEP ) {
   PPCInstr* i             = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                  = Pin_XDirect;
   i->Pin.XDirect.dstGA    = dstGA;
   i->Pin.XDirect.amCIA    = amCIA;
   i->Pin.XDirect.cond     = cond;
   i->Pin.XDirect.toFastEP = toFastEP;
   return i;
}
PPCInstr* PPCInstr_XIndir ( HReg dstGA, PPCAMode* amCIA,
                            PPCCondCode cond ) {
   PPCInstr* i         = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag              = Pin_XIndir;
   i->Pin.XIndir.dstGA = dstGA;
   i->Pin.XIndir.amCIA = amCIA;
   i->Pin.XIndir.cond  = cond;
   return i;
}
PPCInstr* PPCInstr_XAssisted ( HReg dstGA, PPCAMode* amCIA,
                               PPCCondCode cond, IRJumpKind jk ) {
   PPCInstr* i            = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                 = Pin_XAssisted;
   i->Pin.XAssisted.dstGA = dstGA;
   i->Pin.XAssisted.amCIA = amCIA;
   i->Pin.XAssisted.cond  = cond;
   i->Pin.XAssisted.jk    = jk;
   return i;
}
PPCInstr* PPCInstr_CMov  ( PPCCondCode cond, 
                           HReg dst, PPCRI* src ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_CMov;
   i->Pin.CMov.cond = cond;
   i->Pin.CMov.src  = src;
   i->Pin.CMov.dst  = dst;
   vassert(cond.test != Pct_ALWAYS);
   return i;
}
PPCInstr* PPCInstr_Load ( UChar sz,
                          HReg dst, PPCAMode* src, Bool mode64 ) {
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_Load;
   i->Pin.Load.sz    = sz;
   i->Pin.Load.src   = src;
   i->Pin.Load.dst   = dst;
   vassert(sz == 1 || sz == 2 || sz == 4 || sz == 8);
   if (sz == 8) vassert(mode64);
   return i;
}
PPCInstr* PPCInstr_LoadL ( UChar sz,
                           HReg dst, HReg src, Bool mode64 )
{
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_LoadL;
   i->Pin.LoadL.sz   = sz;
   i->Pin.LoadL.src  = src;
   i->Pin.LoadL.dst  = dst;
   vassert(sz == 4 || sz == 8);
   if (sz == 8) vassert(mode64);
   return i;
}
PPCInstr* PPCInstr_Store ( UChar sz, PPCAMode* dst, HReg src,
                           Bool mode64 ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_Store;
   i->Pin.Store.sz  = sz;
   i->Pin.Store.src = src;
   i->Pin.Store.dst = dst;
   vassert(sz == 1 || sz == 2 || sz == 4 || sz == 8);
   if (sz == 8) vassert(mode64);
   return i;
}
PPCInstr* PPCInstr_StoreC ( UChar sz, HReg dst, HReg src, Bool mode64 ) {
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_StoreC;
   i->Pin.StoreC.sz  = sz;
   i->Pin.StoreC.src = src;
   i->Pin.StoreC.dst = dst;
   vassert(sz == 4 || sz == 8);
   if (sz == 8) vassert(mode64);
   return i;
}
PPCInstr* PPCInstr_Set ( PPCCondCode cond, HReg dst ) {
   PPCInstr* i     = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag          = Pin_Set;
   i->Pin.Set.cond = cond;
   i->Pin.Set.dst  = dst;
   return i;
}
PPCInstr* PPCInstr_MfCR ( HReg dst )
{
   PPCInstr* i     = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag          = Pin_MfCR;
   i->Pin.MfCR.dst = dst;
   return i;
}
PPCInstr* PPCInstr_MFence ( void )
{
   PPCInstr* i = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag      = Pin_MFence;
   return i;
}

PPCInstr* PPCInstr_FpUnary ( PPCFpOp op, HReg dst, HReg src ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_FpUnary;
   i->Pin.FpUnary.op  = op;
   i->Pin.FpUnary.dst = dst;
   i->Pin.FpUnary.src = src;
   return i;
}
PPCInstr* PPCInstr_FpBinary ( PPCFpOp op, HReg dst,
                              HReg srcL, HReg srcR ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_FpBinary;
   i->Pin.FpBinary.op   = op;
   i->Pin.FpBinary.dst  = dst;
   i->Pin.FpBinary.srcL = srcL;
   i->Pin.FpBinary.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_FpMulAcc ( PPCFpOp op, HReg dst, HReg srcML, 
                                          HReg srcMR, HReg srcAcc )
{
   PPCInstr* i            = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                 = Pin_FpMulAcc;
   i->Pin.FpMulAcc.op     = op;
   i->Pin.FpMulAcc.dst    = dst;
   i->Pin.FpMulAcc.srcML  = srcML;
   i->Pin.FpMulAcc.srcMR  = srcMR;
   i->Pin.FpMulAcc.srcAcc = srcAcc;
   return i;
}
PPCInstr* PPCInstr_FpLdSt ( Bool isLoad, UChar sz,
                            HReg reg, PPCAMode* addr ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_FpLdSt;
   i->Pin.FpLdSt.isLoad = isLoad;
   i->Pin.FpLdSt.sz     = sz;
   i->Pin.FpLdSt.reg    = reg;
   i->Pin.FpLdSt.addr   = addr;
   vassert(sz == 4 || sz == 8);
   return i;
}
PPCInstr* PPCInstr_FpSTFIW ( HReg addr, HReg data )
{
   PPCInstr* i         = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag              = Pin_FpSTFIW;
   i->Pin.FpSTFIW.addr = addr;
   i->Pin.FpSTFIW.data = data;
   return i;
}
PPCInstr* PPCInstr_FpRSP ( HReg dst, HReg src ) {
   PPCInstr* i      = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag           = Pin_FpRSP;
   i->Pin.FpRSP.dst = dst;
   i->Pin.FpRSP.src = src;
   return i;
}
PPCInstr* PPCInstr_Dfp64Unary(PPCFpOp op, HReg dst, HReg src) {
   PPCInstr* i = LibVEX_Alloc( sizeof(PPCInstr) );
   i->tag = Pin_Dfp64Unary;
   i->Pin.Dfp64Unary.op = op;
   i->Pin.Dfp64Unary.dst = dst;
   i->Pin.Dfp64Unary.src = src;
   return i;
}
PPCInstr* PPCInstr_Dfp64Binary(PPCFpOp op, HReg dst, HReg srcL, HReg srcR) {
   PPCInstr* i = LibVEX_Alloc( sizeof(PPCInstr) );
   i->tag = Pin_Dfp64Binary;
   i->Pin.Dfp64Binary.op = op;
   i->Pin.Dfp64Binary.dst = dst;
   i->Pin.Dfp64Binary.srcL = srcL;
   i->Pin.Dfp64Binary.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_DfpShift ( PPCFpOp op, HReg dst, HReg src, PPCRI* shift ) {
   PPCInstr* i            = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                 = Pin_DfpShift;
   i->Pin.DfpShift.op     = op;
   i->Pin.DfpShift.shift  = shift;
   i->Pin.DfpShift.src    = src;
   i->Pin.DfpShift.dst    = dst;
   return i;
}
PPCInstr* PPCInstr_Dfp128Unary(PPCFpOp op, HReg dst_hi, HReg dst_lo,
                                HReg src_hi, HReg src_lo) {
   PPCInstr* i = LibVEX_Alloc( sizeof(PPCInstr) );
   i->tag = Pin_Dfp128Unary;
   i->Pin.Dfp128Unary.op = op;
   i->Pin.Dfp128Unary.dst_hi = dst_hi;
   i->Pin.Dfp128Unary.dst_lo = dst_lo;
   i->Pin.Dfp128Unary.src_hi = src_hi;
   i->Pin.Dfp128Unary.src_lo = src_lo;
   return i;
}
PPCInstr* PPCInstr_Dfp128Binary(PPCFpOp op, HReg dst_hi, HReg dst_lo,
                                HReg srcR_hi, HReg srcR_lo) {
   /* dst is used to pass the srcL argument and return the result */
   PPCInstr* i = LibVEX_Alloc( sizeof(PPCInstr) );
   i->tag = Pin_Dfp128Binary;
   i->Pin.Dfp128Binary.op = op;
   i->Pin.Dfp128Binary.dst_hi = dst_hi;
   i->Pin.Dfp128Binary.dst_lo = dst_lo;
   i->Pin.Dfp128Binary.srcR_hi = srcR_hi;
   i->Pin.Dfp128Binary.srcR_lo = srcR_lo;
   return i;
}
PPCInstr* PPCInstr_DfpShift128 ( PPCFpOp op, HReg dst_hi, HReg dst_lo, 
                                 HReg src_hi, HReg src_lo,
                                 PPCRI* shift ) {
   PPCInstr* i               = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                    = Pin_DfpShift128;
   i->Pin.DfpShift128.op     = op;
   i->Pin.DfpShift128.shift  = shift;
   i->Pin.DfpShift128.src_hi = src_hi;
   i->Pin.DfpShift128.src_lo = src_lo;
   i->Pin.DfpShift128.dst_hi = dst_hi;
   i->Pin.DfpShift128.dst_lo = dst_lo;
   return i;
}
PPCInstr* PPCInstr_DfpRound ( HReg dst, HReg src, PPCRI* r_rmc ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_DfpRound;
   i->Pin.DfpRound.dst   = dst;
   i->Pin.DfpRound.src   = src;
   i->Pin.DfpRound.r_rmc = r_rmc;
   return i;
}
PPCInstr* PPCInstr_DfpRound128 ( HReg dst_hi, HReg dst_lo, HReg src_hi, 
                                 HReg src_lo, PPCRI* r_rmc ) {
   PPCInstr* i               = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                    = Pin_DfpRound128;
   i->Pin.DfpRound128.dst_hi = dst_hi;
   i->Pin.DfpRound128.dst_lo = dst_lo;
   i->Pin.DfpRound128.src_hi = src_hi;
   i->Pin.DfpRound128.src_lo = src_lo;
   i->Pin.DfpRound128.r_rmc  = r_rmc;
   return i;
}
PPCInstr* PPCInstr_DfpQuantize ( PPCFpOp op, HReg dst, HReg srcL, HReg srcR,
                                 PPCRI* rmc ) {
   PPCInstr* i             = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                  = Pin_DfpQuantize;
   i->Pin.DfpQuantize.op   = op;
   i->Pin.DfpQuantize.dst  = dst;
   i->Pin.DfpQuantize.srcL = srcL;
   i->Pin.DfpQuantize.srcR = srcR;
   i->Pin.DfpQuantize.rmc  = rmc;
   return i;
}
PPCInstr* PPCInstr_DfpQuantize128 ( PPCFpOp op, HReg dst_hi, HReg dst_lo,
                                    HReg src_hi, HReg src_lo, PPCRI* rmc ) {
   /* dst is used to pass left operand in and return result */
   PPCInstr* i                  = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                       = Pin_DfpQuantize128;
   i->Pin.DfpQuantize128.op     = op;
   i->Pin.DfpQuantize128.dst_hi = dst_hi;
   i->Pin.DfpQuantize128.dst_lo = dst_lo;
   i->Pin.DfpQuantize128.src_hi = src_hi;
   i->Pin.DfpQuantize128.src_lo = src_lo;
   i->Pin.DfpQuantize128.rmc    = rmc;
   return i;
}
PPCInstr* PPCInstr_DfpD128toD64 ( PPCFpOp op, HReg dst,
                                  HReg src_hi, HReg src_lo ) {
   PPCInstr* i                = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                     = Pin_DfpD128toD64;
   i->Pin.DfpD128toD64.op     = op;
   i->Pin.DfpD128toD64.src_hi = src_hi;
   i->Pin.DfpD128toD64.src_lo = src_lo;
   i->Pin.DfpD128toD64.dst    = dst;
   return i;
}
PPCInstr* PPCInstr_DfpI64StoD128 ( PPCFpOp op, HReg dst_hi,
                                   HReg dst_lo, HReg src ) {
   PPCInstr* i                 = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                      = Pin_DfpI64StoD128;
   i->Pin.DfpI64StoD128.op     = op;
   i->Pin.DfpI64StoD128.src    = src;
   i->Pin.DfpI64StoD128.dst_hi = dst_hi;
   i->Pin.DfpI64StoD128.dst_lo = dst_lo;
   return i;
}
PPCInstr* PPCInstr_ExtractExpD128 ( PPCFpOp op, HReg dst,
                                    HReg src_hi, HReg src_lo ) {
   /* dst is used to pass the srcL argument */                             
   PPCInstr* i                  = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                       = Pin_ExtractExpD128;
   i->Pin.ExtractExpD128.op     = op;
   i->Pin.ExtractExpD128.dst    = dst;
   i->Pin.ExtractExpD128.src_hi = src_hi;
   i->Pin.ExtractExpD128.src_lo = src_lo;
   return i;
}
PPCInstr* PPCInstr_InsertExpD128 ( PPCFpOp op, HReg dst_hi, HReg dst_lo,   
                                   HReg srcL, HReg srcR_hi, HReg srcR_lo ) {
   /* dst is used to pass the srcL argument */                             
   PPCInstr* i                  = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                       = Pin_InsertExpD128;
   i->Pin.InsertExpD128.op      = op;
   i->Pin.InsertExpD128.dst_hi  = dst_hi;
   i->Pin.InsertExpD128.dst_lo  = dst_lo;
   i->Pin.InsertExpD128.srcL    = srcL;
   i->Pin.InsertExpD128.srcR_hi = srcR_hi;
   i->Pin.InsertExpD128.srcR_lo = srcR_lo;
   return i;
}
PPCInstr* PPCInstr_Dfp64Cmp (/* UInt crfD,*/ HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_Dfp64Cmp;
   i->Pin.Dfp64Cmp.dst = dst;
   i->Pin.Dfp64Cmp.srcL = srcL;
   i->Pin.Dfp64Cmp.srcR = srcR;
   return i;                                                   
}
PPCInstr* PPCInstr_Dfp128Cmp ( HReg dst, HReg srcL_hi, HReg srcL_lo,
                               HReg srcR_hi, HReg srcR_lo ) {
   PPCInstr* i               = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                    = Pin_Dfp128Cmp;
   i->Pin.Dfp128Cmp.dst      = dst;
   i->Pin.Dfp128Cmp.srcL_hi  = srcL_hi;
   i->Pin.Dfp128Cmp.srcL_lo  = srcL_lo;
   i->Pin.Dfp128Cmp.srcR_hi  = srcR_hi;
   i->Pin.Dfp128Cmp.srcR_lo  = srcR_lo;
   return i;                                                   
}
PPCInstr* PPCInstr_EvCheck ( PPCAMode* amCounter,
                             PPCAMode* amFailAddr ) {
   PPCInstr* i               = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                    = Pin_EvCheck;
   i->Pin.EvCheck.amCounter  = amCounter;
   i->Pin.EvCheck.amFailAddr = amFailAddr;
   return i;
}
PPCInstr* PPCInstr_ProfInc ( void ) {
   PPCInstr* i = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag      = Pin_ProfInc;
   return i;
}

/*
Valid combo | fromI | int32 | syned | flt64 |
--------------------------------------------
            |  n       n       n       n    |
--------------------------------------------
 F64->I64U  |  n       n       n       y    |
--------------------------------------------
            |  n       n       y       n    |
--------------------------------------------
 F64->I64S  |  n       n       y       y    |
--------------------------------------------
            |  n       y       n       n    |
--------------------------------------------
 F64->I32U  |  n       y       n       y    |
--------------------------------------------
            |  n       y       y       n    |
--------------------------------------------
 F64->I32S  |  n       y       y       y    |
--------------------------------------------
 I64U->F32  |  y       n       n       n    |
--------------------------------------------
 I64U->F64  |  y       n       n       y    |
--------------------------------------------
            |  y       n       y       n    |
--------------------------------------------
 I64S->F64  |  y       n       y       y    |
--------------------------------------------
            |  y       y       n       n    |
--------------------------------------------
            |  y       y       n       y    |
--------------------------------------------
            |  y       y       y       n    |
--------------------------------------------
            |  y       y       y       y    |
--------------------------------------------
*/
PPCInstr* PPCInstr_FpCftI ( Bool fromI, Bool int32, Bool syned,
                            Bool flt64, HReg dst, HReg src ) {
   Bool tmp = fromI | int32 | syned | flt64;
   vassert(tmp == True || tmp == False); // iow, no high bits set
   UShort conversion = 0;
   conversion = (fromI << 3) | (int32 << 2) | (syned << 1) | flt64;
   switch (conversion) {
      // Supported conversion operations
      case 1: case 3: case 5: case 7:
      case 8: case 9: case 11:
         break;
      default:
         vpanic("PPCInstr_FpCftI(ppc_host)");
   }
   PPCInstr* i         = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag              = Pin_FpCftI;
   i->Pin.FpCftI.fromI = fromI;
   i->Pin.FpCftI.int32 = int32;
   i->Pin.FpCftI.syned = syned;
   i->Pin.FpCftI.flt64 = flt64;
   i->Pin.FpCftI.dst   = dst;
   i->Pin.FpCftI.src   = src;
   return i;
}
PPCInstr* PPCInstr_FpCMov ( PPCCondCode cond, HReg dst, HReg src ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_FpCMov;
   i->Pin.FpCMov.cond = cond;
   i->Pin.FpCMov.dst  = dst;
   i->Pin.FpCMov.src  = src;
   vassert(cond.test != Pct_ALWAYS);
   return i;
}
PPCInstr* PPCInstr_FpLdFPSCR ( HReg src, Bool dfp_rm ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_FpLdFPSCR;
   i->Pin.FpLdFPSCR.src = src;
   i->Pin.FpLdFPSCR.dfp_rm = dfp_rm ? 1 : 0;
   return i;
}
PPCInstr* PPCInstr_FpCmp ( HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_FpCmp;
   i->Pin.FpCmp.dst  = dst;
   i->Pin.FpCmp.srcL = srcL;
   i->Pin.FpCmp.srcR = srcR;
   return i;
}

/* Read/Write Link Register */
PPCInstr* PPCInstr_RdWrLR ( Bool wrLR, HReg gpr ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_RdWrLR;
   i->Pin.RdWrLR.wrLR = wrLR;
   i->Pin.RdWrLR.gpr  = gpr;
   return i;
}

/* AltiVec */
PPCInstr* PPCInstr_AvLdSt ( Bool isLoad, UChar sz,
                            HReg reg, PPCAMode* addr ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_AvLdSt;
   i->Pin.AvLdSt.isLoad = isLoad;
   i->Pin.AvLdSt.sz     = sz;
   i->Pin.AvLdSt.reg    = reg;
   i->Pin.AvLdSt.addr   = addr;
   return i;
}
PPCInstr* PPCInstr_AvUnary ( PPCAvOp op, HReg dst, HReg src ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_AvUnary;
   i->Pin.AvUnary.op  = op;
   i->Pin.AvUnary.dst = dst;
   i->Pin.AvUnary.src = src;
   return i;
}
PPCInstr* PPCInstr_AvBinary ( PPCAvOp op, HReg dst,
                              HReg srcL, HReg srcR ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_AvBinary;
   i->Pin.AvBinary.op   = op;
   i->Pin.AvBinary.dst  = dst;
   i->Pin.AvBinary.srcL = srcL;
   i->Pin.AvBinary.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvBin8x16 ( PPCAvOp op, HReg dst,
                               HReg srcL, HReg srcR ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_AvBin8x16;
   i->Pin.AvBin8x16.op   = op;
   i->Pin.AvBin8x16.dst  = dst;
   i->Pin.AvBin8x16.srcL = srcL;
   i->Pin.AvBin8x16.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvBin16x8 ( PPCAvOp op, HReg dst,
                               HReg srcL, HReg srcR ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_AvBin16x8;
   i->Pin.AvBin16x8.op   = op;
   i->Pin.AvBin16x8.dst  = dst;
   i->Pin.AvBin16x8.srcL = srcL;
   i->Pin.AvBin16x8.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvBin32x4 ( PPCAvOp op, HReg dst,
                               HReg srcL, HReg srcR ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_AvBin32x4;
   i->Pin.AvBin32x4.op   = op;
   i->Pin.AvBin32x4.dst  = dst;
   i->Pin.AvBin32x4.srcL = srcL;
   i->Pin.AvBin32x4.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvBin64x2 ( PPCAvOp op, HReg dst,
                               HReg srcL, HReg srcR ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_AvBin64x2;
   i->Pin.AvBin64x2.op   = op;
   i->Pin.AvBin64x2.dst  = dst;
   i->Pin.AvBin64x2.srcL = srcL;
   i->Pin.AvBin64x2.srcR = srcR;
   return i;
}

PPCInstr* PPCInstr_AvBin32Fx4 ( PPCAvFpOp op, HReg dst,
                                HReg srcL, HReg srcR ) {
   PPCInstr* i            = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                 = Pin_AvBin32Fx4;
   i->Pin.AvBin32Fx4.op   = op;
   i->Pin.AvBin32Fx4.dst  = dst;
   i->Pin.AvBin32Fx4.srcL = srcL;
   i->Pin.AvBin32Fx4.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvUn32Fx4 ( PPCAvFpOp op, HReg dst, HReg src ) {
   PPCInstr* i          = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag               = Pin_AvUn32Fx4;
   i->Pin.AvUn32Fx4.op  = op;
   i->Pin.AvUn32Fx4.dst = dst;
   i->Pin.AvUn32Fx4.src = src;
   return i;
}
PPCInstr* PPCInstr_AvPerm ( HReg dst, HReg srcL, HReg srcR, HReg ctl ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_AvPerm;
   i->Pin.AvPerm.dst  = dst;
   i->Pin.AvPerm.srcL = srcL;
   i->Pin.AvPerm.srcR = srcR;
   i->Pin.AvPerm.ctl  = ctl;
   return i;
}

PPCInstr* PPCInstr_AvSel ( HReg ctl, HReg dst, HReg srcL, HReg srcR ) {
   PPCInstr* i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag            = Pin_AvSel;
   i->Pin.AvSel.ctl  = ctl;
   i->Pin.AvSel.dst  = dst;
   i->Pin.AvSel.srcL = srcL;
   i->Pin.AvSel.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvSh ( Bool shLeft, HReg dst, PPCAMode* addr ) {
   PPCInstr*  i       = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_AvSh;
   i->Pin.AvSh.shLeft = shLeft;
   i->Pin.AvSh.dst    = dst;
   i->Pin.AvSh.addr   = addr;
   return i;
}
PPCInstr* PPCInstr_AvShlDbl ( UChar shift, HReg dst,
                              HReg srcL, HReg srcR ) {
   PPCInstr* i           = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                = Pin_AvShlDbl;
   i->Pin.AvShlDbl.shift = shift;
   i->Pin.AvShlDbl.dst   = dst;
   i->Pin.AvShlDbl.srcL  = srcL;
   i->Pin.AvShlDbl.srcR  = srcR;
   return i;
}
PPCInstr* PPCInstr_AvSplat ( UChar sz, HReg dst, PPCVI5s* src ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_AvSplat;
   i->Pin.AvSplat.sz  = sz;
   i->Pin.AvSplat.dst = dst;
   i->Pin.AvSplat.src = src;
   return i;
}
PPCInstr* PPCInstr_AvCMov ( PPCCondCode cond, HReg dst, HReg src ) {
   PPCInstr* i        = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag             = Pin_AvCMov;
   i->Pin.AvCMov.cond = cond;
   i->Pin.AvCMov.dst  = dst;
   i->Pin.AvCMov.src  = src;
   vassert(cond.test != Pct_ALWAYS);
   return i;
}
PPCInstr* PPCInstr_AvLdVSCR ( HReg src ) {
   PPCInstr* i         = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag              = Pin_AvLdVSCR;
   i->Pin.AvLdVSCR.src = src;
   return i;
}
PPCInstr* PPCInstr_AvCipherV128Unary ( PPCAvOp op, HReg dst, HReg src ) {
   PPCInstr* i              = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                   = Pin_AvCipherV128Unary;
   i->Pin.AvCipherV128Unary.op   = op;
   i->Pin.AvCipherV128Unary.dst  = dst;
   i->Pin.AvCipherV128Unary.src  = src;
   return i;
}
PPCInstr* PPCInstr_AvCipherV128Binary ( PPCAvOp op, HReg dst,
                                        HReg srcL, HReg srcR ) {
   PPCInstr* i              = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                   = Pin_AvCipherV128Binary;
   i->Pin.AvCipherV128Binary.op   = op;
   i->Pin.AvCipherV128Binary.dst  = dst;
   i->Pin.AvCipherV128Binary.srcL = srcL;
   i->Pin.AvCipherV128Binary.srcR = srcR;
   return i;
}
PPCInstr* PPCInstr_AvHashV128Binary ( PPCAvOp op, HReg dst,
                                      HReg src, PPCRI* s_field ) {
   PPCInstr* i              = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag                   = Pin_AvHashV128Binary;
   i->Pin.AvHashV128Binary.op  = op;
   i->Pin.AvHashV128Binary.dst = dst;
   i->Pin.AvHashV128Binary.src = src;
   i->Pin.AvHashV128Binary.s_field = s_field;
   return i;
}
PPCInstr* PPCInstr_AvBCDV128Trinary ( PPCAvOp op, HReg dst,
                                      HReg src1, HReg src2, PPCRI* ps ) {
   PPCInstr* i = LibVEX_Alloc(sizeof(PPCInstr));
   i->tag      = Pin_AvBCDV128Trinary;
   i->Pin.AvBCDV128Trinary.op   = op;
   i->Pin.AvBCDV128Trinary.dst  = dst;
   i->Pin.AvBCDV128Trinary.src1 = src1;
   i->Pin.AvBCDV128Trinary.src2 = src2;
   i->Pin.AvBCDV128Trinary.ps   = ps;
   return i;
}


/* Pretty Print instructions */
static void ppLoadImm ( HReg dst, ULong imm, Bool mode64 ) {
   vex_printf("li_word ");
   ppHRegPPC(dst);
   if (!mode64) {
      vex_printf(",0x%08x", (UInt)imm);
   } else {
      vex_printf(",0x%016llx", imm);
   }
}

static void ppMovReg ( HReg dst, HReg src ) {
   if (hregNumber(dst) != hregNumber(src)) {
      vex_printf("mr ");
      ppHRegPPC(dst);
      vex_printf(",");
      ppHRegPPC(src);
   }
}

void ppPPCInstr ( const PPCInstr* i, Bool mode64 )
{
   switch (i->tag) {
   case Pin_LI:
      ppLoadImm(i->Pin.LI.dst, i->Pin.LI.imm64, mode64);
      break;
   case Pin_Alu: {
      HReg   r_srcL  = i->Pin.Alu.srcL;
      PPCRH* rh_srcR = i->Pin.Alu.srcR;
      /* special-case "mr" */
      if (i->Pin.Alu.op == Palu_OR &&   // or Rd,Rs,Rs == mr Rd,Rs
          rh_srcR->tag == Prh_Reg &&
          sameHReg(rh_srcR->Prh.Reg.reg, r_srcL)) {
         vex_printf("mr ");
         ppHRegPPC(i->Pin.Alu.dst);
         vex_printf(",");
         ppHRegPPC(r_srcL);
         return;
      }
      /* special-case "li" */
      if (i->Pin.Alu.op == Palu_ADD &&   // addi Rd,0,imm == li Rd,imm
          rh_srcR->tag == Prh_Imm &&
          hregNumber(r_srcL) == 0) {
         vex_printf("li ");
         ppHRegPPC(i->Pin.Alu.dst);
         vex_printf(",");
         ppPPCRH(rh_srcR);
         return;
      }
      /* generic */
      vex_printf("%s ", showPPCAluOp(i->Pin.Alu.op,
                                     toBool(rh_srcR->tag == Prh_Imm)));
      ppHRegPPC(i->Pin.Alu.dst);
      vex_printf(",");
      ppHRegPPC(r_srcL);
      vex_printf(",");
      ppPPCRH(rh_srcR);
      return;
   }
   case Pin_Shft: {
      HReg   r_srcL  = i->Pin.Shft.srcL;
      PPCRH* rh_srcR = i->Pin.Shft.srcR;
      vex_printf("%s ", showPPCShftOp(i->Pin.Shft.op,
                                      toBool(rh_srcR->tag == Prh_Imm),
                                      i->Pin.Shft.sz32));
      ppHRegPPC(i->Pin.Shft.dst);
      vex_printf(",");
      ppHRegPPC(r_srcL);
      vex_printf(",");
      ppPPCRH(rh_srcR);
      return;
   }
   case Pin_AddSubC:
      vex_printf("%s%s ",
                 i->Pin.AddSubC.isAdd ? "add" : "sub",
                 i->Pin.AddSubC.setC ? "c" : "e");
      ppHRegPPC(i->Pin.AddSubC.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AddSubC.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AddSubC.srcR);
      return;
   case Pin_Cmp:
      vex_printf("%s%c%s %%cr%u,",
                 i->Pin.Cmp.syned ? "cmp" : "cmpl",
                 i->Pin.Cmp.sz32 ? 'w' : 'd',
                 i->Pin.Cmp.srcR->tag == Prh_Imm ? "i" : "",
                 i->Pin.Cmp.crfD);
      ppHRegPPC(i->Pin.Cmp.srcL);
      vex_printf(",");
      ppPPCRH(i->Pin.Cmp.srcR);
      return;
   case Pin_Unary:
      vex_printf("%s ", showPPCUnaryOp(i->Pin.Unary.op));
      ppHRegPPC(i->Pin.Unary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Unary.src);
      return;
   case Pin_MulL:
      vex_printf("mul%c%c%s ",
                 i->Pin.MulL.hi ? 'h' : 'l',
                 i->Pin.MulL.sz32 ? 'w' : 'd',
                 i->Pin.MulL.hi ? (i->Pin.MulL.syned ? "s" : "u") : "");
      ppHRegPPC(i->Pin.MulL.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.MulL.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.MulL.srcR);
      return;
   case Pin_Div:
      vex_printf("div%c%s%s ",
                 i->Pin.Div.sz32 ? 'w' : 'd',
                 i->Pin.Div.extended ? "e" : "",
                 i->Pin.Div.syned ? "" : "u");
      ppHRegPPC(i->Pin.Div.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Div.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.Div.srcR);
      return;
   case Pin_Call: {
      Int n;
      vex_printf("call: ");
      if (i->Pin.Call.cond.test != Pct_ALWAYS) {
         vex_printf("if (%s) ", showPPCCondCode(i->Pin.Call.cond));
      }
      vex_printf("{ ");
      ppLoadImm(hregPPC_GPR10(mode64), i->Pin.Call.target, mode64);
      vex_printf(" ; mtctr r10 ; bctrl [");
      for (n = 0; n < 32; n++) {
         if (i->Pin.Call.argiregs & (1<<n)) {
            vex_printf("r%d", n);
            if ((i->Pin.Call.argiregs >> n) > 1)
               vex_printf(",");
         }
      }
      vex_printf(",");
      ppRetLoc(i->Pin.Call.rloc);
      vex_printf("] }");
      break;
   }
   case Pin_XDirect:
      vex_printf("(xDirect) ");
      vex_printf("if (%s) { ",
                 showPPCCondCode(i->Pin.XDirect.cond));
      if (mode64) {
         vex_printf("imm64 r30,0x%llx; ", i->Pin.XDirect.dstGA);
         vex_printf("std r30,");
      } else {
         vex_printf("imm32 r30,0x%llx; ", i->Pin.XDirect.dstGA);
         vex_printf("stw r30,");
      }
      ppPPCAMode(i->Pin.XDirect.amCIA);
      vex_printf("; ");
      if (mode64) {
         vex_printf("imm64-fixed5 r30,$disp_cp_chain_me_to_%sEP; ",
                    i->Pin.XDirect.toFastEP ? "fast" : "slow");
      } else {
         vex_printf("imm32-fixed2 r30,$disp_cp_chain_me_to_%sEP; ",
                    i->Pin.XDirect.toFastEP ? "fast" : "slow");
      }
      vex_printf("mtctr r30; bctrl }");
      return;
   case Pin_XIndir:
      vex_printf("(xIndir) ");
      vex_printf("if (%s) { ",
                 showPPCCondCode(i->Pin.XIndir.cond));
      vex_printf("%s ", mode64 ? "std" : "stw");
      ppHRegPPC(i->Pin.XIndir.dstGA);
      vex_printf(",");
      ppPPCAMode(i->Pin.XIndir.amCIA);
      vex_printf("; ");
      vex_printf("imm%s r30,$disp_cp_xindir; ", mode64 ? "64" : "32");
      vex_printf("mtctr r30; bctr }");
      return;
   case Pin_XAssisted:
      vex_printf("(xAssisted) ");
      vex_printf("if (%s) { ",
                 showPPCCondCode(i->Pin.XAssisted.cond));
      vex_printf("%s ", mode64 ? "std" : "stw");
      ppHRegPPC(i->Pin.XAssisted.dstGA);
      vex_printf(",");
      ppPPCAMode(i->Pin.XAssisted.amCIA);
      vex_printf("; ");
      vex_printf("li r31,$IRJumpKind_to_TRCVAL(%d); ",                            
                 (Int)i->Pin.XAssisted.jk);
      vex_printf("imm%s r30,$disp_cp_xindir; ", mode64 ? "64" : "32");
      vex_printf("mtctr r30; bctr }");
      return;
   case Pin_CMov:
      vex_printf("cmov (%s) ", showPPCCondCode(i->Pin.CMov.cond));
      ppHRegPPC(i->Pin.CMov.dst);
      vex_printf(",");
      ppPPCRI(i->Pin.CMov.src);
      vex_printf(": ");
      if (i->Pin.CMov.cond.test != Pct_ALWAYS) {
         vex_printf("if (%s) ", showPPCCondCode(i->Pin.CMov.cond));
      }
      vex_printf("{ ");
      if (i->Pin.CMov.src->tag == Pri_Imm) {
         ppLoadImm(i->Pin.CMov.dst, i->Pin.CMov.src->Pri.Imm, mode64);
      } else {
         ppMovReg(i->Pin.CMov.dst, i->Pin.CMov.src->Pri.Reg);
      }
      vex_printf(" }");
      return;
   case Pin_Load: {
      Bool idxd = toBool(i->Pin.Load.src->tag == Pam_RR);
      UChar sz = i->Pin.Load.sz;
      HChar c_sz = sz==1 ? 'b' : sz==2 ? 'h' : sz==4 ? 'w' : 'd';
      vex_printf("l%c%s%s ", c_sz, sz==8 ? "" : "z", idxd ? "x" : "" );
      ppHRegPPC(i->Pin.Load.dst);
      vex_printf(",");
      ppPPCAMode(i->Pin.Load.src);
      return;
   }
   case Pin_LoadL:
      vex_printf("l%carx ", i->Pin.LoadL.sz==4 ? 'w' : 'd');
      ppHRegPPC(i->Pin.LoadL.dst);
      vex_printf(",%%r0,");
      ppHRegPPC(i->Pin.LoadL.src);
      return;
   case Pin_Store: {
      UChar sz = i->Pin.Store.sz;
      Bool idxd = toBool(i->Pin.Store.dst->tag == Pam_RR);
      HChar c_sz = sz==1 ? 'b' : sz==2 ? 'h' : sz==4 ? 'w' : /*8*/ 'd';
      vex_printf("st%c%s ", c_sz, idxd ? "x" : "" );
      ppHRegPPC(i->Pin.Store.src);
      vex_printf(",");
      ppPPCAMode(i->Pin.Store.dst);
      return;
   }
   case Pin_StoreC:
      vex_printf("st%ccx. ", i->Pin.StoreC.sz==4 ? 'w' : 'd');
      ppHRegPPC(i->Pin.StoreC.src);
      vex_printf(",%%r0,");
      ppHRegPPC(i->Pin.StoreC.dst);
      return;
   case Pin_Set: {
      PPCCondCode cc = i->Pin.Set.cond;
      vex_printf("set (%s),", showPPCCondCode(cc));
      ppHRegPPC(i->Pin.Set.dst);
      if (cc.test == Pct_ALWAYS) {
         vex_printf(": { li ");
         ppHRegPPC(i->Pin.Set.dst);
         vex_printf(",1 }");
      } else {
         vex_printf(": { mfcr r0 ; rlwinm ");
         ppHRegPPC(i->Pin.Set.dst);
         vex_printf(",r0,%u,31,31", cc.flag+1);
         if (cc.test == Pct_FALSE) {
            vex_printf("; xori ");
            ppHRegPPC(i->Pin.Set.dst);
            vex_printf(",");
            ppHRegPPC(i->Pin.Set.dst);
            vex_printf(",1");
         }
         vex_printf(" }");
      }
      return;
   }
   case Pin_MfCR:
      vex_printf("mfcr ");
      ppHRegPPC(i->Pin.MfCR.dst);
      break;
   case Pin_MFence:
      vex_printf("mfence (=sync)");
      return;

   case Pin_FpUnary:
      vex_printf("%s ", showPPCFpOp(i->Pin.FpUnary.op));
      ppHRegPPC(i->Pin.FpUnary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpUnary.src);
      return;
   case Pin_FpBinary:
      vex_printf("%s ", showPPCFpOp(i->Pin.FpBinary.op));
      ppHRegPPC(i->Pin.FpBinary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpBinary.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpBinary.srcR);
      return;
   case Pin_FpMulAcc:
      vex_printf("%s ", showPPCFpOp(i->Pin.FpMulAcc.op));
      ppHRegPPC(i->Pin.FpMulAcc.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpMulAcc.srcML);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpMulAcc.srcMR);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpMulAcc.srcAcc);
      return;
   case Pin_FpLdSt: {
      UChar sz = i->Pin.FpLdSt.sz;
      Bool idxd = toBool(i->Pin.FpLdSt.addr->tag == Pam_RR);
      if (i->Pin.FpLdSt.isLoad) {
         vex_printf("lf%c%s ",
                    (sz==4 ? 's' : 'd'),
                    idxd ? "x" : "" );
         ppHRegPPC(i->Pin.FpLdSt.reg);
         vex_printf(",");
         ppPPCAMode(i->Pin.FpLdSt.addr);
      } else {
         vex_printf("stf%c%s ",
                    (sz==4 ? 's' : 'd'),
                    idxd ? "x" : "" );
         ppHRegPPC(i->Pin.FpLdSt.reg);
         vex_printf(",");
         ppPPCAMode(i->Pin.FpLdSt.addr);
      }
      return;
   }
   case Pin_FpSTFIW:
      vex_printf("stfiwz ");
      ppHRegPPC(i->Pin.FpSTFIW.data);
      vex_printf(",0(");
      ppHRegPPC(i->Pin.FpSTFIW.addr);
      vex_printf(")");
      return;
   case Pin_FpRSP:
      vex_printf("frsp ");
      ppHRegPPC(i->Pin.FpRSP.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpRSP.src);
      return;
   case Pin_FpCftI: {
      const HChar* str = "fc?????";
      /* Note that "fcfids" is missing from below. That instruction would
       * satisfy the predicate:
       *    (i->Pin.FpCftI.fromI == True && i->Pin.FpCftI.int32 == False)
       * which would go into a final "else" clause to make this if-else
       * block balanced.  But we're able to implement fcfids by leveraging
       * the fcfid implementation, so it wasn't necessary to include it here.
       */
      if (i->Pin.FpCftI.fromI == False && i->Pin.FpCftI.int32 == False)
         if (i->Pin.FpCftI.syned == True)
            str = "fctid";
         else
            str = "fctidu";
      else if (i->Pin.FpCftI.fromI == False && i->Pin.FpCftI.int32 == True)
         if (i->Pin.FpCftI.syned == True)
            str = "fctiw";
         else
            str = "fctiwu";
      else if (i->Pin.FpCftI.fromI == True && i->Pin.FpCftI.int32 == False) {
         if (i->Pin.FpCftI.syned == True) {
            str = "fcfid";
         } else {
            if (i->Pin.FpCftI.flt64 == True)
               str = "fcfidu";
            else
               str = "fcfidus";
         }
      }
      vex_printf("%s ", str);
      ppHRegPPC(i->Pin.FpCftI.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpCftI.src);
      return;
   }
   case Pin_FpCMov:
      vex_printf("fpcmov (%s) ", showPPCCondCode(i->Pin.FpCMov.cond));
      ppHRegPPC(i->Pin.FpCMov.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpCMov.src);
      vex_printf(": ");
      vex_printf("if (fr_dst != fr_src) { ");
      if (i->Pin.FpCMov.cond.test != Pct_ALWAYS) {
         vex_printf("if (%s) { ", showPPCCondCode(i->Pin.FpCMov.cond));
      }
      vex_printf("fmr ");
      ppHRegPPC(i->Pin.FpCMov.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpCMov.src);
      if (i->Pin.FpCMov.cond.test != Pct_ALWAYS)
         vex_printf(" }");
      vex_printf(" }");
      return;
   case Pin_FpLdFPSCR:
      vex_printf("mtfsf 0xFF,");
      ppHRegPPC(i->Pin.FpLdFPSCR.src);
      vex_printf(",0, %s", i->Pin.FpLdFPSCR.dfp_rm ? "1" : "0");
      return;
   case Pin_FpCmp:
      vex_printf("fcmpo %%cr1,");
      ppHRegPPC(i->Pin.FpCmp.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpCmp.srcR);
      vex_printf("; mfcr ");
      ppHRegPPC(i->Pin.FpCmp.dst);
      vex_printf("; rlwinm ");
      ppHRegPPC(i->Pin.FpCmp.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.FpCmp.dst);
      vex_printf(",8,28,31");
      return;

   case Pin_RdWrLR:
      vex_printf("%s ", i->Pin.RdWrLR.wrLR ? "mtlr" : "mflr");
      ppHRegPPC(i->Pin.RdWrLR.gpr);
      return;

   case Pin_AvLdSt: {
      UChar  sz = i->Pin.AvLdSt.sz;
      const HChar* str_size;
      if (i->Pin.AvLdSt.addr->tag == Pam_IR) {
         ppLoadImm(hregPPC_GPR30(mode64),
                   i->Pin.AvLdSt.addr->Pam.IR.index, mode64);
         vex_printf(" ; ");
      }
      str_size = sz==1 ? "eb" : sz==2 ? "eh" : sz==4 ? "ew" : "";
      if (i->Pin.AvLdSt.isLoad)
         vex_printf("lv%sx ", str_size);
      else
         vex_printf("stv%sx ", str_size);
      ppHRegPPC(i->Pin.AvLdSt.reg);
      vex_printf(",");
      if (i->Pin.AvLdSt.addr->tag == Pam_IR)
         vex_printf("%%r30");
      else 
         ppHRegPPC(i->Pin.AvLdSt.addr->Pam.RR.index);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvLdSt.addr->Pam.RR.base);
      return;
   }
   case Pin_AvUnary:
      vex_printf("%s ", showPPCAvOp(i->Pin.AvUnary.op));
      ppHRegPPC(i->Pin.AvUnary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvUnary.src);
      return;
   case Pin_AvBinary:
      vex_printf("%s ", showPPCAvOp(i->Pin.AvBinary.op));
      ppHRegPPC(i->Pin.AvBinary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBinary.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBinary.srcR);
      return;
   case Pin_AvBin8x16:
      vex_printf("%s(b) ", showPPCAvOp(i->Pin.AvBin8x16.op));
      ppHRegPPC(i->Pin.AvBin8x16.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin8x16.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin8x16.srcR);
      return;
   case Pin_AvBin16x8:
      vex_printf("%s(h) ", showPPCAvOp(i->Pin.AvBin16x8.op));
      ppHRegPPC(i->Pin.AvBin16x8.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin16x8.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin16x8.srcR);
      return;
   case Pin_AvBin32x4:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvBin32x4.op));
      ppHRegPPC(i->Pin.AvBin32x4.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin32x4.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin32x4.srcR);
      return;
   case Pin_AvBin64x2:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvBin64x2.op));
      ppHRegPPC(i->Pin.AvBin64x2.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin64x2.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin64x2.srcR);
      return;
   case Pin_AvBin32Fx4:
      vex_printf("%s ", showPPCAvFpOp(i->Pin.AvBin32Fx4.op));
      ppHRegPPC(i->Pin.AvBin32Fx4.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin32Fx4.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBin32Fx4.srcR);
      return;
   case Pin_AvUn32Fx4:
      vex_printf("%s ", showPPCAvFpOp(i->Pin.AvUn32Fx4.op));
      ppHRegPPC(i->Pin.AvUn32Fx4.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvUn32Fx4.src);
      return;
   case Pin_AvPerm:
      vex_printf("vperm ");
      ppHRegPPC(i->Pin.AvPerm.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvPerm.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvPerm.srcR);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvPerm.ctl);
      return;

   case Pin_AvSel:
      vex_printf("vsel ");
      ppHRegPPC(i->Pin.AvSel.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvSel.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvSel.srcR);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvSel.ctl);
      return;

   case Pin_AvSh:
      /* This only generates the following instructions with RA
       * register number set to 0.
       */
      if (i->Pin.AvSh.addr->tag == Pam_IR) {
         ppLoadImm(hregPPC_GPR30(mode64),
                   i->Pin.AvSh.addr->Pam.IR.index, mode64);
         vex_printf(" ; ");
      }

      if (i->Pin.AvSh.shLeft)
         vex_printf("lvsl ");
      else
         vex_printf("lvsr ");

      ppHRegPPC(i->Pin.AvSh.dst);
      if (i->Pin.AvSh.addr->tag == Pam_IR)
         vex_printf("%%r30");
      else
         ppHRegPPC(i->Pin.AvSh.addr->Pam.RR.index);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvSh.addr->Pam.RR.base);
      return;

   case Pin_AvShlDbl:
      vex_printf("vsldoi ");
      ppHRegPPC(i->Pin.AvShlDbl.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvShlDbl.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvShlDbl.srcR);
      vex_printf(",%d", i->Pin.AvShlDbl.shift);
      return;

   case Pin_AvSplat: {
      UChar sz = i->Pin.AvSplat.sz;
      HChar ch_sz = toUChar( (sz == 8) ? 'b' : (sz == 16) ? 'h' : 'w' );
      vex_printf("vsplt%s%c ",
                 i->Pin.AvSplat.src->tag == Pvi_Imm ? "is" : "", ch_sz);
      ppHRegPPC(i->Pin.AvSplat.dst);
      vex_printf(",");
      ppPPCVI5s(i->Pin.AvSplat.src);
      if (i->Pin.AvSplat.src->tag == Pvi_Reg)
         vex_printf(", %d", (128/sz)-1);   /* louis lane */
      return;
   }

   case Pin_AvCMov:
      vex_printf("avcmov (%s) ", showPPCCondCode(i->Pin.AvCMov.cond));
      ppHRegPPC(i->Pin.AvCMov.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvCMov.src);
      vex_printf(": ");
      vex_printf("if (v_dst != v_src) { ");
      if (i->Pin.AvCMov.cond.test != Pct_ALWAYS) {
         vex_printf("if (%s) { ", showPPCCondCode(i->Pin.AvCMov.cond));
      }
      vex_printf("vmr ");
      ppHRegPPC(i->Pin.AvCMov.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvCMov.src);
      if (i->Pin.FpCMov.cond.test != Pct_ALWAYS)
         vex_printf(" }");
      vex_printf(" }");
      return;

   case Pin_AvLdVSCR:
      vex_printf("mtvscr ");
      ppHRegPPC(i->Pin.AvLdVSCR.src);
      return;

   case Pin_AvCipherV128Unary:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvCipherV128Unary.op));
      ppHRegPPC(i->Pin.AvCipherV128Unary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvCipherV128Unary.src);
      return;

   case Pin_AvCipherV128Binary:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvCipherV128Binary.op));
      ppHRegPPC(i->Pin.AvCipherV128Binary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvCipherV128Binary.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvCipherV128Binary.srcR);
      return;

   case Pin_AvHashV128Binary:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvHashV128Binary.op));
      ppHRegPPC(i->Pin.AvHashV128Binary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvHashV128Binary.src);
      vex_printf(",");
      ppPPCRI(i->Pin.AvHashV128Binary.s_field);
      return;

   case Pin_AvBCDV128Trinary:
      vex_printf("%s(w) ", showPPCAvOp(i->Pin.AvBCDV128Trinary.op));
      ppHRegPPC(i->Pin.AvBCDV128Trinary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBCDV128Trinary.src1);
      vex_printf(",");
      ppHRegPPC(i->Pin.AvBCDV128Trinary.src2);
      vex_printf(",");
      ppPPCRI(i->Pin.AvBCDV128Trinary.ps);
      return;

   case Pin_Dfp64Unary:
      vex_printf("%s ", showPPCFpOp(i->Pin.Dfp64Unary.op));
      ppHRegPPC(i->Pin.Dfp64Unary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp64Unary.src);
      return;

   case Pin_Dfp64Binary:
      vex_printf("%s ", showPPCFpOp(i->Pin.Dfp64Binary.op));
      ppHRegPPC(i->Pin.Dfp64Binary.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp64Binary.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp64Binary.srcR);
      return;

   case Pin_DfpShift:
      vex_printf("%s ", showPPCFpOp(i->Pin.DfpShift.op));
      ppHRegPPC(i->Pin.DfpShift.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpShift.src);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpShift.shift);
      return;

   case Pin_Dfp128Unary:
      vex_printf("%s ", showPPCFpOp(i->Pin.Dfp128Unary.op));
      ppHRegPPC(i->Pin.Dfp128Unary.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp128Unary.src_hi);
      return;

   case Pin_Dfp128Binary:
      vex_printf("%s ", showPPCFpOp(i->Pin.Dfp128Binary.op));
      ppHRegPPC(i->Pin.Dfp128Binary.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp128Binary.srcR_hi);
      return;

   case Pin_DfpShift128:
      vex_printf("%s ", showPPCFpOp(i->Pin.DfpShift128.op));
      ppHRegPPC(i->Pin.DfpShift128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpShift128.src_hi);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpShift128.shift);
      return;

   case Pin_DfpRound:
      vex_printf("drintx ");
      ppHRegPPC(i->Pin.DfpRound.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpRound.src);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpRound.r_rmc); /*  R in bit 3 and RMC in bits 2:0 */
      return;

   case Pin_DfpRound128:
      vex_printf("drintxq ");
      ppHRegPPC(i->Pin.DfpRound128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpRound128.src_hi);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpRound128.r_rmc); /*  R in bit 3 and RMC in bits 2:0 */
      return;

   case Pin_DfpQuantize:
      vex_printf("%s ", showPPCFpOp(i->Pin.DfpQuantize.op));
      ppHRegPPC(i->Pin.DfpQuantize.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpQuantize.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpQuantize.srcR);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpQuantize.rmc);
      return;

   case Pin_DfpQuantize128:
      /*  Dst is used to pass in left source and return result */
      vex_printf("dquaq ");
      ppHRegPPC(i->Pin.DfpQuantize128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpQuantize128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpQuantize128.src_hi);
      vex_printf(",");
      ppPPCRI(i->Pin.DfpQuantize128.rmc);
      return;

   case Pin_DfpD128toD64:
      vex_printf("%s ", showPPCFpOp(i->Pin.DfpD128toD64.op));
      ppHRegPPC(i->Pin.DfpD128toD64.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpD128toD64.src_hi);
      vex_printf(",");
      return;

   case Pin_DfpI64StoD128:
      vex_printf("%s ", showPPCFpOp(i->Pin.DfpI64StoD128.op));
      ppHRegPPC(i->Pin.DfpI64StoD128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.DfpI64StoD128.src);
      vex_printf(",");
      return;
   case Pin_ExtractExpD128:
      vex_printf("dxexq ");
      ppHRegPPC(i->Pin.ExtractExpD128.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.ExtractExpD128.src_hi);
      return;
   case Pin_InsertExpD128:
      vex_printf("diexq ");
      ppHRegPPC(i->Pin.InsertExpD128.dst_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.InsertExpD128.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.InsertExpD128.srcR_hi);
      return;
   case Pin_Dfp64Cmp:
      vex_printf("dcmpo %%cr1,");
      ppHRegPPC(i->Pin.Dfp64Cmp.srcL);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp64Cmp.srcR);
      vex_printf("; mfcr ");
      ppHRegPPC(i->Pin.Dfp64Cmp.dst);
      vex_printf("; rlwinm ");
      ppHRegPPC(i->Pin.Dfp64Cmp.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp64Cmp.dst);
      vex_printf(",8,28,31");
      return;
   case Pin_Dfp128Cmp:
      vex_printf("dcmpoq %%cr1,");
      ppHRegPPC(i->Pin.Dfp128Cmp.srcL_hi);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp128Cmp.srcR_hi);
      vex_printf("; mfcr ");
      ppHRegPPC(i->Pin.Dfp128Cmp.dst);
      vex_printf("; rlwinm ");
      ppHRegPPC(i->Pin.Dfp128Cmp.dst);
      vex_printf(",");
      ppHRegPPC(i->Pin.Dfp128Cmp.dst);
      vex_printf(",8,28,31");
      return;
   case Pin_EvCheck:
      /* Note that the counter dec is 32 bit even in 64-bit mode. */
      vex_printf("(evCheck) ");
      vex_printf("lwz r30,");
      ppPPCAMode(i->Pin.EvCheck.amCounter);
      vex_printf("; addic. r30,r30,-1; ");
      vex_printf("stw r30,");
      ppPPCAMode(i->Pin.EvCheck.amCounter);
      vex_printf("; bge nofail; lwz r30,");
      ppPPCAMode(i->Pin.EvCheck.amFailAddr);
      vex_printf("; mtctr r30; bctr; nofail:");
      return;
   case Pin_ProfInc:
      if (mode64) {
         vex_printf("(profInc) imm64-fixed5 r30,$NotKnownYet; ");
         vex_printf("ld r29,(r30); addi r29,r29,1; std r29,(r30)");
      } else {
         vex_printf("(profInc) imm32-fixed2 r30,$NotKnownYet; ");
         vex_printf("lwz r29,4(r30); addic. r29,r29,1; stw r29,4(r30)");
         vex_printf("lwz r29,0(r30); addze r29,r29; stw r29,0(r30)");
      }
      break;
   default:
      vex_printf("\nppPPCInstr: No such tag(%d)\n", (Int)i->tag);
      vpanic("ppPPCInstr");
   }
}

/* --------- Helpers for register allocation. --------- */

void getRegUsage_PPCInstr ( HRegUsage* u, const PPCInstr* i, Bool mode64 )
{
   initHRegUsage(u);
   switch (i->tag) {
   case Pin_LI:
      addHRegUse(u, HRmWrite, i->Pin.LI.dst);
      break;
   case Pin_Alu:
      addHRegUse(u, HRmRead,  i->Pin.Alu.srcL);
      addRegUsage_PPCRH(u,    i->Pin.Alu.srcR);
      addHRegUse(u, HRmWrite, i->Pin.Alu.dst);
      return;
   case Pin_Shft:
      addHRegUse(u, HRmRead,  i->Pin.Shft.srcL);
      addRegUsage_PPCRH(u,    i->Pin.Shft.srcR);
      addHRegUse(u, HRmWrite, i->Pin.Shft.dst);
      return;
   case Pin_AddSubC:
      addHRegUse(u, HRmWrite, i->Pin.AddSubC.dst);
      addHRegUse(u, HRmRead,  i->Pin.AddSubC.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AddSubC.srcR);
      return;
   case Pin_Cmp:
      addHRegUse(u, HRmRead, i->Pin.Cmp.srcL);
      addRegUsage_PPCRH(u,   i->Pin.Cmp.srcR);
      return;
   case Pin_Unary:
      addHRegUse(u, HRmWrite, i->Pin.Unary.dst);
      addHRegUse(u, HRmRead,  i->Pin.Unary.src);
      return;
   case Pin_MulL:
      addHRegUse(u, HRmWrite, i->Pin.MulL.dst);
      addHRegUse(u, HRmRead,  i->Pin.MulL.srcL);
      addHRegUse(u, HRmRead,  i->Pin.MulL.srcR);
      return;
   case Pin_Div:
      addHRegUse(u, HRmWrite, i->Pin.Div.dst);
      addHRegUse(u, HRmRead,  i->Pin.Div.srcL);
      addHRegUse(u, HRmRead,  i->Pin.Div.srcR);
      return;
   case Pin_Call: {
      UInt argir;
      /* This is a bit subtle. */
      /* First off, claim it trashes all the caller-saved regs
         which fall within the register allocator's jurisdiction.
         These I believe to be:
         mode32: r3 to r12
         mode64: r3 to r10
      */
      /* XXXXXXXXXXXXXXXXX BUG! This doesn't say anything about the FP
         or Altivec registers.  We get away with this ONLY because
         getAllocatableRegs_PPC gives the allocator callee-saved fp
         and Altivec regs, and no caller-save ones. */
      addHRegUse(u, HRmWrite, hregPPC_GPR3(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR4(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR5(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR6(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR7(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR8(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR9(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR10(mode64));
      if (!mode64) {
         addHRegUse(u, HRmWrite, hregPPC_GPR11(mode64));
         addHRegUse(u, HRmWrite, hregPPC_GPR12(mode64));
      }

      /* Now we have to state any parameter-carrying registers
         which might be read.  This depends on the argiregs field. */
      argir = i->Pin.Call.argiregs;
      if (argir &(1<<10)) addHRegUse(u, HRmRead, hregPPC_GPR10(mode64));
      if (argir & (1<<9)) addHRegUse(u, HRmRead, hregPPC_GPR9(mode64));
      if (argir & (1<<8)) addHRegUse(u, HRmRead, hregPPC_GPR8(mode64));
      if (argir & (1<<7)) addHRegUse(u, HRmRead, hregPPC_GPR7(mode64));
      if (argir & (1<<6)) addHRegUse(u, HRmRead, hregPPC_GPR6(mode64));
      if (argir & (1<<5)) addHRegUse(u, HRmRead, hregPPC_GPR5(mode64));
      if (argir & (1<<4)) addHRegUse(u, HRmRead, hregPPC_GPR4(mode64));
      if (argir & (1<<3)) addHRegUse(u, HRmRead, hregPPC_GPR3(mode64));

      vassert(0 == (argir & ~((1<<3)|(1<<4)|(1<<5)|(1<<6)
                              |(1<<7)|(1<<8)|(1<<9)|(1<<10))));

      /* Finally, there is the issue that the insn trashes a
         register because the literal target address has to be
         loaded into a register.  %r10 seems a suitable victim.
         (Can't use %r0, as some insns interpret it as value zero). */
      addHRegUse(u, HRmWrite, hregPPC_GPR10(mode64));
      /* Upshot of this is that the assembler really must use %r10,
         and no other, as a destination temporary. */
      return;
   }
   /* XDirect/XIndir/XAssisted are also a bit subtle.  They
      conditionally exit the block.  Hence we only need to list (1)
      the registers that they read, and (2) the registers that they
      write in the case where the block is not exited.  (2) is empty,
      hence only (1) is relevant here. */
   case Pin_XDirect:
      addRegUsage_PPCAMode(u, i->Pin.XDirect.amCIA);
      return;
   case Pin_XIndir:
      addHRegUse(u, HRmRead, i->Pin.XIndir.dstGA);
      addRegUsage_PPCAMode(u, i->Pin.XIndir.amCIA);
      return;
   case Pin_XAssisted:
      addHRegUse(u, HRmRead, i->Pin.XAssisted.dstGA);
      addRegUsage_PPCAMode(u, i->Pin.XAssisted.amCIA);
      return;
   case Pin_CMov:
      addRegUsage_PPCRI(u,  i->Pin.CMov.src);
      addHRegUse(u, HRmWrite, i->Pin.CMov.dst);
      return;
   case Pin_Load:
      addRegUsage_PPCAMode(u, i->Pin.Load.src);
      addHRegUse(u, HRmWrite, i->Pin.Load.dst);
      return;
   case Pin_LoadL:
      addHRegUse(u, HRmRead,  i->Pin.LoadL.src);
      addHRegUse(u, HRmWrite, i->Pin.LoadL.dst);
      return;
   case Pin_Store:
      addHRegUse(u, HRmRead,  i->Pin.Store.src);
      addRegUsage_PPCAMode(u, i->Pin.Store.dst);
      return;
   case Pin_StoreC:
      addHRegUse(u, HRmRead, i->Pin.StoreC.src);
      addHRegUse(u, HRmRead, i->Pin.StoreC.dst);
      return;
   case Pin_Set:
      addHRegUse(u, HRmWrite, i->Pin.Set.dst);
      return;
   case Pin_MfCR:
      addHRegUse(u, HRmWrite, i->Pin.MfCR.dst);
      return;
   case Pin_MFence:
      return;

   case Pin_FpUnary:
      addHRegUse(u, HRmWrite, i->Pin.FpUnary.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpUnary.src);
      return;
   case Pin_FpBinary:
      addHRegUse(u, HRmWrite, i->Pin.FpBinary.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpBinary.srcL);
      addHRegUse(u, HRmRead,  i->Pin.FpBinary.srcR);
      return;
   case Pin_FpMulAcc:
      addHRegUse(u, HRmWrite, i->Pin.FpMulAcc.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpMulAcc.srcML);
      addHRegUse(u, HRmRead,  i->Pin.FpMulAcc.srcMR);
      addHRegUse(u, HRmRead,  i->Pin.FpMulAcc.srcAcc);
      return;
   case Pin_FpLdSt:
      addHRegUse(u, (i->Pin.FpLdSt.isLoad ? HRmWrite : HRmRead),
                 i->Pin.FpLdSt.reg);
      addRegUsage_PPCAMode(u, i->Pin.FpLdSt.addr);
      return;
   case Pin_FpSTFIW:
      addHRegUse(u, HRmRead, i->Pin.FpSTFIW.addr);
      addHRegUse(u, HRmRead, i->Pin.FpSTFIW.data);
      return;
   case Pin_FpRSP:
      addHRegUse(u, HRmWrite, i->Pin.FpRSP.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpRSP.src);
      return;
   case Pin_FpCftI:
      addHRegUse(u, HRmWrite, i->Pin.FpCftI.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpCftI.src);
      return;
   case Pin_FpCMov:
      addHRegUse(u, HRmModify, i->Pin.FpCMov.dst);
      addHRegUse(u, HRmRead,   i->Pin.FpCMov.src);
      return;
   case Pin_FpLdFPSCR:
      addHRegUse(u, HRmRead, i->Pin.FpLdFPSCR.src);
      return;
   case Pin_FpCmp:
      addHRegUse(u, HRmWrite, i->Pin.FpCmp.dst);
      addHRegUse(u, HRmRead,  i->Pin.FpCmp.srcL);
      addHRegUse(u, HRmRead,  i->Pin.FpCmp.srcR);
      return;

   case Pin_RdWrLR:
      addHRegUse(u, (i->Pin.RdWrLR.wrLR ? HRmRead : HRmWrite),
                 i->Pin.RdWrLR.gpr);
      return;

   case Pin_AvLdSt:
      addHRegUse(u, (i->Pin.AvLdSt.isLoad ? HRmWrite : HRmRead),
                 i->Pin.AvLdSt.reg);
      if (i->Pin.AvLdSt.addr->tag == Pam_IR)
         addHRegUse(u, HRmWrite, hregPPC_GPR30(mode64));
      addRegUsage_PPCAMode(u, i->Pin.AvLdSt.addr);
      return;
   case Pin_AvUnary:
      addHRegUse(u, HRmWrite, i->Pin.AvUnary.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvUnary.src);
      return;
   case Pin_AvBinary:
      if (i->Pin.AvBinary.op == Pav_XOR
          && sameHReg(i->Pin.AvBinary.dst, i->Pin.AvBinary.srcL)
          && sameHReg(i->Pin.AvBinary.dst, i->Pin.AvBinary.srcR)) {
         /* reg-alloc needs to understand 'xor r,r,r' as a write of r */
         /* (as opposed to a rite of passage :-) */
         addHRegUse(u, HRmWrite, i->Pin.AvBinary.dst);
      } else {
         addHRegUse(u, HRmWrite, i->Pin.AvBinary.dst);
         addHRegUse(u, HRmRead,  i->Pin.AvBinary.srcL);
         addHRegUse(u, HRmRead,  i->Pin.AvBinary.srcR);
      }
      return;
   case Pin_AvBin8x16:
      addHRegUse(u, HRmWrite, i->Pin.AvBin8x16.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBin8x16.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvBin8x16.srcR);
      return;
   case Pin_AvBin16x8:
      addHRegUse(u, HRmWrite, i->Pin.AvBin16x8.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBin16x8.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvBin16x8.srcR);
      return;
   case Pin_AvBin32x4:
      addHRegUse(u, HRmWrite, i->Pin.AvBin32x4.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBin32x4.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvBin32x4.srcR);
      return;
   case Pin_AvBin64x2:
      addHRegUse(u, HRmWrite, i->Pin.AvBin64x2.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBin64x2.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvBin64x2.srcR);
      return;
   case Pin_AvBin32Fx4:
      addHRegUse(u, HRmWrite, i->Pin.AvBin32Fx4.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBin32Fx4.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvBin32Fx4.srcR);
      if (i->Pin.AvBin32Fx4.op == Pavfp_MULF)
         addHRegUse(u, HRmWrite, hregPPC_VR29());
      return;
   case Pin_AvUn32Fx4:
      addHRegUse(u, HRmWrite, i->Pin.AvUn32Fx4.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvUn32Fx4.src);
      return;
   case Pin_AvPerm:
      addHRegUse(u, HRmWrite, i->Pin.AvPerm.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvPerm.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvPerm.srcR);
      addHRegUse(u, HRmRead,  i->Pin.AvPerm.ctl);
      return;
   case Pin_AvSel:
      addHRegUse(u, HRmWrite, i->Pin.AvSel.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvSel.ctl);
      addHRegUse(u, HRmRead,  i->Pin.AvSel.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvSel.srcR);
      return;
   case Pin_AvSh:
      addHRegUse(u, HRmWrite, i->Pin.AvSh.dst);
      if (i->Pin.AvSh.addr->tag == Pam_IR)
         addHRegUse(u, HRmWrite, hregPPC_GPR30(mode64));
      addRegUsage_PPCAMode(u, i->Pin.AvSh.addr);
      return;
   case Pin_AvShlDbl:
      addHRegUse(u, HRmWrite, i->Pin.AvShlDbl.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvShlDbl.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvShlDbl.srcR);
      return;
   case Pin_AvSplat:
      addHRegUse(u, HRmWrite, i->Pin.AvSplat.dst);
      addRegUsage_PPCVI5s(u,  i->Pin.AvSplat.src);
      return;
   case Pin_AvCMov:
      addHRegUse(u, HRmModify, i->Pin.AvCMov.dst);
      addHRegUse(u, HRmRead,   i->Pin.AvCMov.src);
      return;
   case Pin_AvLdVSCR:
      addHRegUse(u, HRmRead, i->Pin.AvLdVSCR.src);
      return;
   case Pin_AvCipherV128Unary:
      addHRegUse(u, HRmWrite, i->Pin.AvCipherV128Unary.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvCipherV128Unary.src);
      return;
   case Pin_AvCipherV128Binary:
      addHRegUse(u, HRmWrite, i->Pin.AvCipherV128Binary.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvCipherV128Binary.srcL);
      addHRegUse(u, HRmRead,  i->Pin.AvCipherV128Binary.srcR);
      return;
   case Pin_AvHashV128Binary:
      addHRegUse(u, HRmWrite, i->Pin.AvHashV128Binary.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvHashV128Binary.src);
      addRegUsage_PPCRI(u,    i->Pin.AvHashV128Binary.s_field);
      return;
   case Pin_AvBCDV128Trinary:
      addHRegUse(u, HRmWrite, i->Pin.AvBCDV128Trinary.dst);
      addHRegUse(u, HRmRead,  i->Pin.AvBCDV128Trinary.src1);
      addHRegUse(u, HRmRead,  i->Pin.AvBCDV128Trinary.src2);
      addRegUsage_PPCRI(u,    i->Pin.AvBCDV128Trinary.ps);
      return;
   case Pin_Dfp64Unary:
      addHRegUse(u, HRmWrite, i->Pin.Dfp64Unary.dst);
      addHRegUse(u, HRmRead, i->Pin.Dfp64Unary.src);
      return;
   case Pin_Dfp64Binary:
      addHRegUse(u, HRmWrite, i->Pin.Dfp64Binary.dst);
      addHRegUse(u, HRmRead, i->Pin.Dfp64Binary.srcL);
      addHRegUse(u, HRmRead, i->Pin.Dfp64Binary.srcR);
      return;
   case Pin_DfpShift:
      addRegUsage_PPCRI(u,    i->Pin.DfpShift.shift);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift.src);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift.dst);
      return;
   case Pin_Dfp128Unary:
      addHRegUse(u, HRmWrite, i->Pin.Dfp128Unary.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.Dfp128Unary.dst_lo);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Unary.src_hi);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Unary.src_lo);
      return;
   case Pin_Dfp128Binary:
      addHRegUse(u, HRmWrite, i->Pin.Dfp128Binary.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.Dfp128Binary.dst_lo);
      addHRegUse(u, HRmRead, i->Pin.Dfp128Binary.srcR_hi);
      addHRegUse(u, HRmRead, i->Pin.Dfp128Binary.srcR_lo);
      return;
   case Pin_DfpRound:
      addHRegUse(u, HRmWrite, i->Pin.DfpRound.dst);
      addHRegUse(u, HRmRead,  i->Pin.DfpRound.src);
      return;
   case Pin_DfpRound128:
      addHRegUse(u, HRmWrite, i->Pin.DfpRound128.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpRound128.dst_lo);
      addHRegUse(u, HRmRead,  i->Pin.DfpRound128.src_hi);
      addHRegUse(u, HRmRead,  i->Pin.DfpRound128.src_lo);
      return;
   case Pin_DfpQuantize:
      addRegUsage_PPCRI(u,  i->Pin.DfpQuantize.rmc);
      addHRegUse(u, HRmWrite, i->Pin.DfpQuantize.dst);
      addHRegUse(u, HRmRead,  i->Pin.DfpQuantize.srcL);
      addHRegUse(u, HRmRead,  i->Pin.DfpQuantize.srcR);
      return;
   case Pin_DfpQuantize128:
      addHRegUse(u, HRmWrite, i->Pin.DfpQuantize128.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpQuantize128.dst_lo);
      addHRegUse(u, HRmRead,  i->Pin.DfpQuantize128.src_hi);
      addHRegUse(u, HRmRead,  i->Pin.DfpQuantize128.src_lo);
      return;
   case Pin_DfpShift128:
      addRegUsage_PPCRI(u,    i->Pin.DfpShift128.shift);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift128.src_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift128.src_lo);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift128.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpShift128.dst_lo);
      return;
   case Pin_DfpD128toD64:
      addHRegUse(u, HRmWrite, i->Pin.DfpD128toD64.src_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpD128toD64.src_lo);
      addHRegUse(u, HRmWrite, i->Pin.DfpD128toD64.dst);
      return;
   case Pin_DfpI64StoD128:
      addHRegUse(u, HRmWrite, i->Pin.DfpI64StoD128.src);
      addHRegUse(u, HRmWrite, i->Pin.DfpI64StoD128.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.DfpI64StoD128.dst_lo);
      return;
   case Pin_ExtractExpD128:
      addHRegUse(u, HRmWrite, i->Pin.ExtractExpD128.dst);
      addHRegUse(u, HRmRead,  i->Pin.ExtractExpD128.src_hi);
      addHRegUse(u, HRmRead,  i->Pin.ExtractExpD128.src_lo);
      return;
   case Pin_InsertExpD128:
      addHRegUse(u, HRmWrite, i->Pin.InsertExpD128.dst_hi);
      addHRegUse(u, HRmWrite, i->Pin.InsertExpD128.dst_lo);
      addHRegUse(u, HRmRead,  i->Pin.InsertExpD128.srcL);
      addHRegUse(u, HRmRead,  i->Pin.InsertExpD128.srcR_hi);
      addHRegUse(u, HRmRead,  i->Pin.InsertExpD128.srcR_lo);
      return;
   case Pin_Dfp64Cmp:
      addHRegUse(u, HRmWrite, i->Pin.Dfp64Cmp.dst);
      addHRegUse(u, HRmRead,  i->Pin.Dfp64Cmp.srcL);
      addHRegUse(u, HRmRead,  i->Pin.Dfp64Cmp.srcR);
      return;
   case Pin_Dfp128Cmp:
      addHRegUse(u, HRmWrite, i->Pin.Dfp128Cmp.dst);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Cmp.srcL_hi);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Cmp.srcL_lo);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Cmp.srcR_hi);
      addHRegUse(u, HRmRead,  i->Pin.Dfp128Cmp.srcR_lo);
      return;                                           
   case Pin_EvCheck:
      /* We expect both amodes only to mention the GSP (r31), so this
         is in fact pointless, since GSP isn't allocatable, but
         anyway.. */
      addRegUsage_PPCAMode(u, i->Pin.EvCheck.amCounter);
      addRegUsage_PPCAMode(u, i->Pin.EvCheck.amFailAddr);
      addHRegUse(u, HRmWrite, hregPPC_GPR30(mode64)); /* also unavail to RA */
      return;
   case Pin_ProfInc:
      addHRegUse(u, HRmWrite, hregPPC_GPR29(mode64));
      addHRegUse(u, HRmWrite, hregPPC_GPR30(mode64));
      return;
   default:
      ppPPCInstr(i, mode64);
      vpanic("getRegUsage_PPCInstr");
   }
}

/* local helper */
static void mapReg( HRegRemap* m, HReg* r )
{
   *r = lookupHRegRemap(m, *r);
}

void mapRegs_PPCInstr ( HRegRemap* m, PPCInstr* i, Bool mode64 )
{
   switch (i->tag) {
   case Pin_LI:
      mapReg(m, &i->Pin.LI.dst);
      return;
   case Pin_Alu:
      mapReg(m, &i->Pin.Alu.dst);
      mapReg(m, &i->Pin.Alu.srcL);
      mapRegs_PPCRH(m, i->Pin.Alu.srcR);
      return;
   case Pin_Shft:
      mapReg(m, &i->Pin.Shft.dst);
      mapReg(m, &i->Pin.Shft.srcL);
      mapRegs_PPCRH(m, i->Pin.Shft.srcR);
      return;
   case Pin_AddSubC:
      mapReg(m, &i->Pin.AddSubC.dst);
      mapReg(m, &i->Pin.AddSubC.srcL);
      mapReg(m, &i->Pin.AddSubC.srcR);
      return;
   case Pin_Cmp:
      mapReg(m, &i->Pin.Cmp.srcL);
      mapRegs_PPCRH(m, i->Pin.Cmp.srcR);
      return;
   case Pin_Unary:
      mapReg(m, &i->Pin.Unary.dst);
      mapReg(m, &i->Pin.Unary.src);
      return;
   case Pin_MulL:
      mapReg(m, &i->Pin.MulL.dst);
      mapReg(m, &i->Pin.MulL.srcL);
      mapReg(m, &i->Pin.MulL.srcR);
      return;
   case Pin_Div:
      mapReg(m, &i->Pin.Div.dst);
      mapReg(m, &i->Pin.Div.srcL);
      mapReg(m, &i->Pin.Div.srcR);
      return;
   case Pin_Call:
      return;
   case Pin_XDirect:
      mapRegs_PPCAMode(m, i->Pin.XDirect.amCIA);
      return;
   case Pin_XIndir:
      mapReg(m, &i->Pin.XIndir.dstGA);
      mapRegs_PPCAMode(m, i->Pin.XIndir.amCIA);
      return;
   case Pin_XAssisted:
      mapReg(m, &i->Pin.XAssisted.dstGA);
      mapRegs_PPCAMode(m, i->Pin.XAssisted.amCIA);
      return;
   case Pin_CMov:
      mapRegs_PPCRI(m, i->Pin.CMov.src);
      mapReg(m, &i->Pin.CMov.dst);
      return;
   case Pin_Load:
      mapRegs_PPCAMode(m, i->Pin.Load.src);
      mapReg(m, &i->Pin.Load.dst);
      return;
   case Pin_LoadL:
      mapReg(m, &i->Pin.LoadL.src);
      mapReg(m, &i->Pin.LoadL.dst);
      return;
   case Pin_Store:
      mapReg(m, &i->Pin.Store.src);
      mapRegs_PPCAMode(m, i->Pin.Store.dst);
      return;
   case Pin_StoreC:
      mapReg(m, &i->Pin.StoreC.src);
      mapReg(m, &i->Pin.StoreC.dst);
      return;
   case Pin_Set:
      mapReg(m, &i->Pin.Set.dst);
      return;
   case Pin_MfCR:
      mapReg(m, &i->Pin.MfCR.dst);
      return;
   case Pin_MFence:
      return;
   case Pin_FpUnary:
      mapReg(m, &i->Pin.FpUnary.dst);
      mapReg(m, &i->Pin.FpUnary.src);
      return;
   case Pin_FpBinary:
      mapReg(m, &i->Pin.FpBinary.dst);
      mapReg(m, &i->Pin.FpBinary.srcL);
      mapReg(m, &i->Pin.FpBinary.srcR);
      return;
   case Pin_FpMulAcc:
      mapReg(m, &i->Pin.FpMulAcc.dst);
      mapReg(m, &i->Pin.FpMulAcc.srcML);
      mapReg(m, &i->Pin.FpMulAcc.srcMR);
      mapReg(m, &i->Pin.FpMulAcc.srcAcc);
      return;
   case Pin_FpLdSt:
      mapReg(m, &i->Pin.FpLdSt.reg);
      mapRegs_PPCAMode(m, i->Pin.FpLdSt.addr);
      return;
   case Pin_FpSTFIW:
      mapReg(m, &i->Pin.FpSTFIW.addr);
      mapReg(m, &i->Pin.FpSTFIW.data);
      return;
   case Pin_FpRSP:
      mapReg(m, &i->Pin.FpRSP.dst);
      mapReg(m, &i->Pin.FpRSP.src);
      return;
   case Pin_FpCftI:
      mapReg(m, &i->Pin.FpCftI.dst);
      mapReg(m, &i->Pin.FpCftI.src);
      return;
   case Pin_FpCMov:
      mapReg(m, &i->Pin.FpCMov.dst);
      mapReg(m, &i->Pin.FpCMov.src);
      return;
   case Pin_FpLdFPSCR:
      mapReg(m, &i->Pin.FpLdFPSCR.src);
      return;
   case Pin_FpCmp:
      mapReg(m, &i->Pin.FpCmp.dst);
      mapReg(m, &i->Pin.FpCmp.srcL);
      mapReg(m, &i->Pin.FpCmp.srcR);
      return;
   case Pin_RdWrLR:
      mapReg(m, &i->Pin.RdWrLR.gpr);
      return;
   case Pin_AvLdSt:
      mapReg(m, &i->Pin.AvLdSt.reg);
      mapRegs_PPCAMode(m, i->Pin.AvLdSt.addr);
      return;
   case Pin_AvUnary:
      mapReg(m, &i->Pin.AvUnary.dst);
      mapReg(m, &i->Pin.AvUnary.src);
      return;
   case Pin_AvBinary:
      mapReg(m, &i->Pin.AvBinary.dst);
      mapReg(m, &i->Pin.AvBinary.srcL);
      mapReg(m, &i->Pin.AvBinary.srcR);
      return;
   case Pin_AvBin8x16:
      mapReg(m, &i->Pin.AvBin8x16.dst);
      mapReg(m, &i->Pin.AvBin8x16.srcL);
      mapReg(m, &i->Pin.AvBin8x16.srcR);
      return;
   case Pin_AvBin16x8:
      mapReg(m, &i->Pin.AvBin16x8.dst);
      mapReg(m, &i->Pin.AvBin16x8.srcL);
      mapReg(m, &i->Pin.AvBin16x8.srcR);
      return;
   case Pin_AvBin32x4:
      mapReg(m, &i->Pin.AvBin32x4.dst);
      mapReg(m, &i->Pin.AvBin32x4.srcL);
      mapReg(m, &i->Pin.AvBin32x4.srcR);
      return;
   case Pin_AvBin64x2:
      mapReg(m, &i->Pin.AvBin64x2.dst);
      mapReg(m, &i->Pin.AvBin64x2.srcL);
      mapReg(m, &i->Pin.AvBin64x2.srcR);
      return;
   case Pin_AvBin32Fx4:
      mapReg(m, &i->Pin.AvBin32Fx4.dst);
      mapReg(m, &i->Pin.AvBin32Fx4.srcL);
      mapReg(m, &i->Pin.AvBin32Fx4.srcR);
      return;
   case Pin_AvUn32Fx4:
      mapReg(m, &i->Pin.AvUn32Fx4.dst);
      mapReg(m, &i->Pin.AvUn32Fx4.src);
      return;
   case Pin_AvPerm:
      mapReg(m, &i->Pin.AvPerm.dst);
      mapReg(m, &i->Pin.AvPerm.srcL);
      mapReg(m, &i->Pin.AvPerm.srcR);
      mapReg(m, &i->Pin.AvPerm.ctl);
      return;
   case Pin_AvSel:
      mapReg(m, &i->Pin.AvSel.dst);
      mapReg(m, &i->Pin.AvSel.srcL);
      mapReg(m, &i->Pin.AvSel.srcR);
      mapReg(m, &i->Pin.AvSel.ctl);
      return;
   case Pin_AvSh:
      mapReg(m, &i->Pin.AvSh.dst);
      mapRegs_PPCAMode(m, i->Pin.AvSh.addr);
      return;
   case Pin_AvShlDbl:
      mapReg(m, &i->Pin.AvShlDbl.dst);
      mapReg(m, &i->Pin.AvShlDbl.srcL);
      mapReg(m, &i->Pin.AvShlDbl.srcR);
      return;
   case Pin_AvSplat:
      mapReg(m, &i->Pin.AvSplat.dst);
      mapRegs_PPCVI5s(m, i->Pin.AvSplat.src);
      return;
   case Pin_AvCMov:
     mapReg(m, &i->Pin.AvCMov.dst);
     mapReg(m, &i->Pin.AvCMov.src);
     return;
   case Pin_AvLdVSCR:
      mapReg(m, &i->Pin.AvLdVSCR.src);
      return;
   case Pin_AvCipherV128Unary:
      mapReg(m, &i->Pin.AvCipherV128Unary.dst);
      mapReg(m, &i->Pin.AvCipherV128Unary.src);
      return;
   case Pin_AvCipherV128Binary:
      mapReg(m, &i->Pin.AvCipherV128Binary.dst);
      mapReg(m, &i->Pin.AvCipherV128Binary.srcL);
      mapReg(m, &i->Pin.AvCipherV128Binary.srcR);
      return;
   case Pin_AvHashV128Binary:
      mapRegs_PPCRI(m, i->Pin.AvHashV128Binary.s_field);
      mapReg(m, &i->Pin.AvHashV128Binary.dst);
      mapReg(m, &i->Pin.AvHashV128Binary.src);
      return;
   case Pin_AvBCDV128Trinary:
      mapReg(m, &i->Pin.AvBCDV128Trinary.dst);
      mapReg(m, &i->Pin.AvBCDV128Trinary.src1);
      mapReg(m, &i->Pin.AvBCDV128Trinary.src2);
      mapRegs_PPCRI(m, i->Pin.AvBCDV128Trinary.ps);
      return;
   case Pin_Dfp64Unary:
      mapReg(m, &i->Pin.Dfp64Unary.dst);
      mapReg(m, &i->Pin.Dfp64Unary.src);
      return;
   case Pin_Dfp64Binary:
      mapReg(m, &i->Pin.Dfp64Binary.dst);
      mapReg(m, &i->Pin.Dfp64Binary.srcL);
      mapReg(m, &i->Pin.Dfp64Binary.srcR);
      return;
   case Pin_DfpShift:
      mapRegs_PPCRI(m, i->Pin.DfpShift.shift);
      mapReg(m, &i->Pin.DfpShift.src);
      mapReg(m, &i->Pin.DfpShift.dst);
      return;
   case Pin_Dfp128Unary:
      mapReg(m, &i->Pin.Dfp128Unary.dst_hi);
      mapReg(m, &i->Pin.Dfp128Unary.dst_lo);
      mapReg(m, &i->Pin.Dfp128Unary.src_hi);
      mapReg(m, &i->Pin.Dfp128Unary.src_lo);
     return;
   case Pin_Dfp128Binary:
      mapReg(m, &i->Pin.Dfp128Binary.dst_hi);
      mapReg(m, &i->Pin.Dfp128Binary.dst_lo);
      mapReg(m, &i->Pin.Dfp128Binary.srcR_hi);
      mapReg(m, &i->Pin.Dfp128Binary.srcR_lo);
      return;
   case Pin_DfpShift128:
      mapRegs_PPCRI(m, i->Pin.DfpShift128.shift);
      mapReg(m, &i->Pin.DfpShift128.src_hi);
      mapReg(m, &i->Pin.DfpShift128.src_lo);
      mapReg(m, &i->Pin.DfpShift128.dst_hi);
      mapReg(m, &i->Pin.DfpShift128.dst_lo);
      return;
   case Pin_DfpRound:
      mapReg(m, &i->Pin.DfpRound.dst);
      mapReg(m, &i->Pin.DfpRound.src);
      return;
   case Pin_DfpRound128:
      mapReg(m, &i->Pin.DfpRound128.dst_hi);
      mapReg(m, &i->Pin.DfpRound128.dst_lo);
      mapReg(m, &i->Pin.DfpRound128.src_hi);
      mapReg(m, &i->Pin.DfpRound128.src_lo);
      return;
   case Pin_DfpQuantize:
      mapRegs_PPCRI(m, i->Pin.DfpQuantize.rmc);
      mapReg(m, &i->Pin.DfpQuantize.dst);
      mapReg(m, &i->Pin.DfpQuantize.srcL);
      mapReg(m, &i->Pin.DfpQuantize.srcR);
      return;
   case Pin_DfpQuantize128:
      mapRegs_PPCRI(m, i->Pin.DfpQuantize128.rmc);
      mapReg(m, &i->Pin.DfpQuantize128.dst_hi);
      mapReg(m, &i->Pin.DfpQuantize128.dst_lo);
      mapReg(m, &i->Pin.DfpQuantize128.src_hi);
      mapReg(m, &i->Pin.DfpQuantize128.src_lo);
      return;
   case Pin_DfpD128toD64:
      mapReg(m, &i->Pin.DfpD128toD64.src_hi);
      mapReg(m, &i->Pin.DfpD128toD64.src_lo);
      mapReg(m, &i->Pin.DfpD128toD64.dst);
      return;
   case Pin_DfpI64StoD128:
      mapReg(m, &i->Pin.DfpI64StoD128.src);
      mapReg(m, &i->Pin.DfpI64StoD128.dst_hi);
      mapReg(m, &i->Pin.DfpI64StoD128.dst_lo);
      return;
   case Pin_ExtractExpD128:
      mapReg(m, &i->Pin.ExtractExpD128.dst);
      mapReg(m, &i->Pin.ExtractExpD128.src_hi);
      mapReg(m, &i->Pin.ExtractExpD128.src_lo);
      return;
   case Pin_InsertExpD128:
      mapReg(m, &i->Pin.InsertExpD128.dst_hi);
      mapReg(m, &i->Pin.InsertExpD128.dst_lo);
      mapReg(m, &i->Pin.InsertExpD128.srcL);
      mapReg(m, &i->Pin.InsertExpD128.srcR_hi);
      mapReg(m, &i->Pin.InsertExpD128.srcR_lo);
      return;
   case Pin_Dfp64Cmp:
      mapReg(m, &i->Pin.Dfp64Cmp.dst);
      mapReg(m, &i->Pin.Dfp64Cmp.srcL);
      mapReg(m, &i->Pin.Dfp64Cmp.srcR);
      return;
   case Pin_Dfp128Cmp:
      mapReg(m, &i->Pin.Dfp128Cmp.dst);
      mapReg(m, &i->Pin.Dfp128Cmp.srcL_hi);
      mapReg(m, &i->Pin.Dfp128Cmp.srcL_lo);
      mapReg(m, &i->Pin.Dfp128Cmp.srcR_hi);
      mapReg(m, &i->Pin.Dfp128Cmp.srcR_lo);
      return;
   case Pin_EvCheck:
      /* We expect both amodes only to mention the GSP (r31), so this
         is in fact pointless, since GSP isn't allocatable, but
         anyway.. */
      mapRegs_PPCAMode(m, i->Pin.EvCheck.amCounter);
      mapRegs_PPCAMode(m, i->Pin.EvCheck.amFailAddr);
      return;
   case Pin_ProfInc:
      /* hardwires r29 and r30 -- nothing to modify. */
      return;
   default:
      ppPPCInstr(i, mode64);
      vpanic("mapRegs_PPCInstr");
   }
}

/* Figure out if i represents a reg-reg move, and if so assign the
   source and destination to *src and *dst.  If in doubt say No.  Used
   by the register allocator to do move coalescing. 
*/
Bool isMove_PPCInstr ( const PPCInstr* i, HReg* src, HReg* dst )
{
   /* Moves between integer regs */
   if (i->tag == Pin_Alu) {
      // or Rd,Rs,Rs == mr Rd,Rs
      if (i->Pin.Alu.op != Palu_OR)
         return False;
      if (i->Pin.Alu.srcR->tag != Prh_Reg)
         return False;
      if (! sameHReg(i->Pin.Alu.srcR->Prh.Reg.reg, i->Pin.Alu.srcL))
         return False;
      *src = i->Pin.Alu.srcL;
      *dst = i->Pin.Alu.dst;
      return True;
   }
   /* Moves between FP regs */
   if (i->tag == Pin_FpUnary) {
      if (i->Pin.FpUnary.op != Pfp_MOV)
         return False;
      *src = i->Pin.FpUnary.src;
      *dst = i->Pin.FpUnary.dst;
      return True;
   }
   return False;
}


/* Generate ppc spill/reload instructions under the direction of the
   register allocator.  Note it's critical these don't write the
   condition codes. */

void genSpill_PPC ( /*OUT*/HInstr** i1, /*OUT*/HInstr** i2,
                    HReg rreg, Int offsetB, Bool mode64 )
{
   PPCAMode* am;
   vassert(!hregIsVirtual(rreg));
   *i1 = *i2 = NULL;
   am = PPCAMode_IR( offsetB, GuestStatePtr(mode64) );
   switch (hregClass(rreg)) {
      case HRcInt64:
         vassert(mode64);
         *i1 = PPCInstr_Store( 8, am, rreg, mode64 );
         return;
      case HRcInt32:
         vassert(!mode64);
         *i1 = PPCInstr_Store( 4, am, rreg, mode64 );
         return;
      case HRcFlt64:
         *i1 = PPCInstr_FpLdSt ( False/*store*/, 8, rreg, am );
         return;
      case HRcVec128:
         // XXX: GPR30 used as spill register to kludge AltiVec
         // AMode_IR
         *i1 = PPCInstr_AvLdSt ( False/*store*/, 16, rreg, am );
         return;
      default: 
         ppHRegClass(hregClass(rreg));
         vpanic("genSpill_PPC: unimplemented regclass");
   }
}

void genReload_PPC ( /*OUT*/HInstr** i1, /*OUT*/HInstr** i2,
                     HReg rreg, Int offsetB, Bool mode64 )
{
   PPCAMode* am;
   vassert(!hregIsVirtual(rreg));
   *i1 = *i2 = NULL;
   am = PPCAMode_IR( offsetB, GuestStatePtr(mode64) );
   switch (hregClass(rreg)) {
      case HRcInt64:
         vassert(mode64);
         *i1 = PPCInstr_Load( 8, rreg, am, mode64 );
         return;
      case HRcInt32:
         vassert(!mode64);
         *i1 = PPCInstr_Load( 4, rreg, am, mode64 );
         return;
      case HRcFlt64:
         *i1 = PPCInstr_FpLdSt ( True/*load*/, 8, rreg, am );
         return;
      case HRcVec128:
         // XXX: GPR30 used as spill register to kludge AltiVec AMode_IR
         *i1 = PPCInstr_AvLdSt ( True/*load*/, 16, rreg, am );
         return;
      default: 
         ppHRegClass(hregClass(rreg));
         vpanic("genReload_PPC: unimplemented regclass");
   }
}


/* --------- The ppc assembler (bleh.) --------- */

static UInt iregNo ( HReg r, Bool mode64 )
{
   UInt n;
   vassert(hregClass(r) == mode64 ? HRcInt64 : HRcInt32);
   vassert(!hregIsVirtual(r));
   n = hregNumber(r);
   vassert(n <= 32);
   return n;
}

static UInt fregNo ( HReg fr )
{
   UInt n;
   vassert(hregClass(fr) == HRcFlt64);
   vassert(!hregIsVirtual(fr));
   n = hregNumber(fr);
   vassert(n <= 32);
   return n;
}

static UInt vregNo ( HReg v )
{
   UInt n;
   vassert(hregClass(v) == HRcVec128);
   vassert(!hregIsVirtual(v));
   n = hregNumber(v);
   vassert(n <= 32);
   return n;
}

/* Emit an instruction ppc-endianly */
static UChar* emit32 ( UChar* p, UInt w32, VexEndness endness_host )
{
  if (endness_host == VexEndnessBE) {
    *p++ = toUChar((w32 >> 24) & 0x000000FF);
    *p++ = toUChar((w32 >> 16) & 0x000000FF);
    *p++ = toUChar((w32 >>  8) & 0x000000FF);
    *p++ = toUChar((w32)       & 0x000000FF);
  } else {
    *p++ = toUChar((w32)       & 0x000000FF);
    *p++ = toUChar((w32 >>  8) & 0x000000FF);
    *p++ = toUChar((w32 >> 16) & 0x000000FF);
    *p++ = toUChar((w32 >> 24) & 0x000000FF);
  }
   return p;
}

/* Fetch an instruction ppc-endianly */
static UInt fetch32 ( UChar* p, VexEndness endness_host )
{
   UInt w32 = 0;
   if (endness_host == VexEndnessBE) {
      w32 |= ((0xFF & (UInt)p[0]) << 24);
      w32 |= ((0xFF & (UInt)p[1]) << 16);
      w32 |= ((0xFF & (UInt)p[2]) <<  8);
      w32 |= ((0xFF & (UInt)p[3]) <<  0);
  } else {
      w32 |= ((0xFF & (UInt)p[3]) << 24);
      w32 |= ((0xFF & (UInt)p[2]) << 16);
      w32 |= ((0xFF & (UInt)p[1]) <<  8);
      w32 |= ((0xFF & (UInt)p[0]) <<  0);
  }
   return w32;
}

/* The following mkForm[...] functions refer to ppc instruction forms
   as per PPC32 p576
 */

static UChar* mkFormD ( UChar* p, UInt opc1,
                        UInt r1, UInt r2, UInt imm, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   imm = imm & 0xFFFF;
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) | (imm));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormMD ( UChar* p, UInt opc1, UInt r1, UInt r2,
                         UInt imm1, UInt imm2, UInt opc2,
                         VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(imm1 < 0x40);
   vassert(imm2 < 0x40);
   vassert(opc2 < 0x08);
   imm2 = ((imm2 & 0x1F) << 1) | (imm2 >> 5);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               ((imm1 & 0x1F)<<11) | (imm2<<5) |
               (opc2<<2) | ((imm1 >> 5)<<1));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormX ( UChar* p, UInt opc1, UInt r1, UInt r2,
                        UInt r3, UInt opc2, UInt b0, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(opc2 < 0x400);
   vassert(b0   < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (r3<<11) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormXO ( UChar* p, UInt opc1, UInt r1, UInt r2,
                         UInt r3, UInt b10, UInt opc2, UInt b0,
                         VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(b10  < 0x2);
   vassert(opc2 < 0x200);
   vassert(b0   < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (r3<<11) | (b10 << 10) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormXL ( UChar* p, UInt opc1, UInt f1, UInt f2,
                         UInt f3, UInt opc2, UInt b0, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(f1   < 0x20);
   vassert(f2   < 0x20);
   vassert(f3   < 0x20);
   vassert(opc2 < 0x400);
   vassert(b0   < 0x2);
   theInstr = ((opc1<<26) | (f1<<21) | (f2<<16) |
               (f3<<11) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

// Note: for split field ops, give mnemonic arg
static UChar* mkFormXFX ( UChar* p, UInt r1, UInt f2, UInt opc2,
                          VexEndness endness_host )
{
   UInt theInstr;
   vassert(r1   < 0x20);
   vassert(f2   < 0x20);
   vassert(opc2 < 0x400);
   switch (opc2) {
   case 144:  // mtcrf
      vassert(f2 < 0x100);
      f2 = f2 << 1;
      break;
   case 339:  // mfspr
   case 371:  // mftb
   case 467:  // mtspr
      vassert(f2 < 0x400);
      // re-arrange split field
      f2 = ((f2>>5) & 0x1F) | ((f2 & 0x1F)<<5);
      break;
   default: vpanic("mkFormXFX(ppch)");
   }
   theInstr = ((31<<26) | (r1<<21) | (f2<<11) | (opc2<<1));
   return emit32(p, theInstr, endness_host);
}

// Only used by mtfsf
static UChar* mkFormXFL ( UChar* p, UInt FM, UInt freg, UInt dfp_rm,
                          VexEndness endness_host )
{
   UInt theInstr;
   vassert(FM   < 0x100);
   vassert(freg < 0x20);
   theInstr = ((63<<26) | (FM<<17) | (dfp_rm<<16) | (freg<<11) | (711<<1));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormXS ( UChar* p, UInt opc1, UInt r1, UInt r2,
                         UInt imm, UInt opc2, UInt b0,
                         VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(imm  < 0x40);
   vassert(opc2 < 0x400);
   vassert(b0   < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               ((imm & 0x1F)<<11) | (opc2<<2) | ((imm>>5)<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}


#if 0
// 'b'
static UChar* mkFormI ( UChar* p, UInt LI, UInt AA, UInt LK,
                        VexEndness endness_host )
{
   UInt theInstr;
   vassert(LI  < 0x1000000);
   vassert(AA  < 0x2);
   vassert(LK  < 0x2);
   theInstr = ((18<<26) | (LI<<2) | (AA<<1) | (LK));
   return emit32(p, theInstr, endness_host);
}
#endif

// 'bc'
static UChar* mkFormB ( UChar* p, UInt BO, UInt BI,
                        UInt BD, UInt AA, UInt LK, VexEndness endness_host )
{
   UInt theInstr;
   vassert(BO  < 0x20);
   vassert(BI  < 0x20);
   vassert(BD  < 0x4000);
   vassert(AA  < 0x2);
   vassert(LK  < 0x2);
   theInstr = ((16<<26) | (BO<<21) | (BI<<16) |
               (BD<<2) | (AA<<1) | (LK));
   return emit32(p, theInstr, endness_host);
}

// rotates
static UChar* mkFormM ( UChar* p, UInt opc1, UInt r1, UInt r2,
                        UInt f3, UInt MB, UInt ME, UInt Rc,
                        VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(f3   < 0x20);
   vassert(MB   < 0x20);
   vassert(ME   < 0x20);
   vassert(Rc   < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (f3<<11) | (MB<<6) | (ME<<1) | (Rc));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormA ( UChar* p, UInt opc1, UInt r1, UInt r2,
                        UInt r3, UInt r4, UInt opc2, UInt b0,
                        VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(r4   < 0x20);
   vassert(opc2 < 0x20);
   vassert(b0   < 0x2 );
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) | (r3<<11) |
               (r4<<6) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormZ22 ( UChar* p, UInt opc1, UInt r1, UInt r2,
                          UInt constant, UInt opc2, UInt b0,
                          VexEndness endness_host)
{
   UInt theInstr;
   vassert(opc1     < 0x40);
   vassert(r1       < 0x20);
   vassert(r2       < 0x20);
   vassert(constant < 0x40);   /* 6 bit constant */
   vassert(opc2     < 0x200);  /* 9 bit field */
   vassert(b0       < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (constant<<10) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormZ23 ( UChar* p, UInt opc1, UInt r1, UInt r2,
                          UInt r3, UInt rmc, UInt opc2, UInt b0,
                          VexEndness endness_host)
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(rmc  < 0x4);
   vassert(opc2 < 0x100);
   vassert(b0   < 0x2);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (r3<<11) | (rmc<<9) | (opc2<<1) | (b0));
   return emit32(p, theInstr, endness_host);
}

static UChar* doAMode_IR ( UChar* p, UInt opc1, UInt rSD,
                           PPCAMode* am, Bool mode64, VexEndness endness_host )
{
   UInt rA, idx;
   vassert(am->tag == Pam_IR);
   vassert(am->Pam.IR.index < 0x10000);

   rA  = iregNo(am->Pam.IR.base, mode64);
   idx = am->Pam.IR.index;

   if (opc1 == 58 || opc1 == 62) { // ld/std: mode64 only
      vassert(mode64);
      /* stay sane with DS form: lowest 2 bits must be 00.  This
         should be guaranteed to us by iselWordExpr_AMode. */
      vassert(0 == (idx & 3));
   }
   p = mkFormD(p, opc1, rSD, rA, idx, endness_host);
   return p;
}

static UChar* doAMode_RR ( UChar* p, UInt opc1, UInt opc2,
                           UInt rSD, PPCAMode* am, Bool mode64,
                           VexEndness endness_host )
{
   UInt rA, rB;
   vassert(am->tag == Pam_RR);

   rA  = iregNo(am->Pam.RR.base, mode64);
   rB  = iregNo(am->Pam.RR.index, mode64);
   
   p = mkFormX(p, opc1, rSD, rA, rB, opc2, 0, endness_host);
   return p;
}


/* Load imm to r_dst */
static UChar* mkLoadImm ( UChar* p, UInt r_dst, ULong imm, Bool mode64,
                          VexEndness endness_host )
{
   vassert(r_dst < 0x20);

   if (!mode64) {
      /* In 32-bit mode, make sure the top 32 bits of imm are a sign
         extension of the bottom 32 bits, so that the range tests
         below work correctly. */
      UInt u32 = (UInt)imm;
      Int  s32 = (Int)u32;
      Long s64 = (Long)s32;
      imm = (ULong)s64;
   }

   if (imm >= 0xFFFFFFFFFFFF8000ULL || imm < 0x8000) {
      // sign-extendable from 16 bits

      // addi r_dst,0,imm  => li r_dst,imm
      p = mkFormD(p, 14, r_dst, 0, imm & 0xFFFF, endness_host);
   } else {
      if (imm >= 0xFFFFFFFF80000000ULL || imm < 0x80000000ULL) {
         // sign-extendable from 32 bits

         // addis r_dst,r0,(imm>>16) => lis r_dst, (imm>>16)
         p = mkFormD(p, 15, r_dst, 0, (imm>>16) & 0xFFFF, endness_host);
         // ori r_dst, r_dst, (imm & 0xFFFF)
         p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);
      } else {
         // full 64bit immediate load: 5 (five!) insns.
         vassert(mode64);

         // load high word

         // lis r_dst, (imm>>48) & 0xFFFF
         p = mkFormD(p, 15, r_dst, 0, (imm>>48) & 0xFFFF, endness_host);

         // ori r_dst, r_dst, (imm>>32) & 0xFFFF
         if ((imm>>32) & 0xFFFF)
	   p = mkFormD(p, 24, r_dst, r_dst, (imm>>32) & 0xFFFF, endness_host);
         
         // shift r_dst low word to high word => rldicr
         p = mkFormMD(p, 30, r_dst, r_dst, 32, 31, 1, endness_host);

         // load low word

         // oris r_dst, r_dst, (imm>>16) & 0xFFFF
         if ((imm>>16) & 0xFFFF)
            p = mkFormD(p, 25, r_dst, r_dst, (imm>>16) & 0xFFFF, endness_host);

         // ori r_dst, r_dst, (imm) & 0xFFFF
         if (imm & 0xFFFF)
            p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);
      }
   }
   return p;
}

/* A simplified version of mkLoadImm that always generates 2 or 5
   instructions (32 or 64 bits respectively) even if it could generate
   fewer.  This is needed for generating fixed sized patchable
   sequences. */
static UChar* mkLoadImm_EXACTLY2or5 ( UChar* p,
                                      UInt r_dst, ULong imm, Bool mode64,
                                      VexEndness endness_host )
{
   vassert(r_dst < 0x20);

   if (!mode64) {
      /* In 32-bit mode, make sure the top 32 bits of imm are a sign
         extension of the bottom 32 bits.  (Probably unnecessary.) */
      UInt u32 = (UInt)imm;
      Int  s32 = (Int)u32;
      Long s64 = (Long)s32;
      imm = (ULong)s64;
   }

   if (!mode64) {
      // addis r_dst,r0,(imm>>16) => lis r_dst, (imm>>16)
      p = mkFormD(p, 15, r_dst, 0, (imm>>16) & 0xFFFF, endness_host);
      // ori r_dst, r_dst, (imm & 0xFFFF)
      p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);

   } else {
      // full 64bit immediate load: 5 (five!) insns.

      // load high word
      // lis r_dst, (imm>>48) & 0xFFFF
      p = mkFormD(p, 15, r_dst, 0, (imm>>48) & 0xFFFF, endness_host);

      // ori r_dst, r_dst, (imm>>32) & 0xFFFF
      p = mkFormD(p, 24, r_dst, r_dst, (imm>>32) & 0xFFFF, endness_host);
         
      // shift r_dst low word to high word => rldicr
      p = mkFormMD(p, 30, r_dst, r_dst, 32, 31, 1, endness_host);

      // load low word
      // oris r_dst, r_dst, (imm>>16) & 0xFFFF
      p = mkFormD(p, 25, r_dst, r_dst, (imm>>16) & 0xFFFF, endness_host);

      // ori r_dst, r_dst, (imm) & 0xFFFF
      p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);
   }
   return p;
}

/* Checks whether the sequence of bytes at p was indeed created
   by mkLoadImm_EXACTLY2or5 with the given parameters. */
static Bool isLoadImm_EXACTLY2or5 ( UChar* p_to_check,
                                    UInt r_dst, ULong imm, Bool mode64,
                                    VexEndness endness_host )
{
   vassert(r_dst < 0x20);

   if (!mode64) {
      /* In 32-bit mode, make sure the top 32 bits of imm are a sign
         extension of the bottom 32 bits.  (Probably unnecessary.) */
      UInt u32 = (UInt)imm;
      Int  s32 = (Int)u32;
      Long s64 = (Long)s32;
      imm = (ULong)s64;
   }

   if (!mode64) {
      UInt   expect[2] = { 0, 0 };
      UChar* p         = (UChar*)&expect[0];
      // addis r_dst,r0,(imm>>16) => lis r_dst, (imm>>16)
      p = mkFormD(p, 15, r_dst, 0, (imm>>16) & 0xFFFF, endness_host);
      // ori r_dst, r_dst, (imm & 0xFFFF)
      p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);
      vassert(p == (UChar*)&expect[2]);

      return fetch32(p_to_check + 0, endness_host) == expect[0]
             && fetch32(p_to_check + 4, endness_host) == expect[1];

   } else {
      UInt   expect[5] = { 0, 0, 0, 0, 0 };
      UChar* p         = (UChar*)&expect[0];
      // full 64bit immediate load: 5 (five!) insns.

      // load high word
      // lis r_dst, (imm>>48) & 0xFFFF
      p = mkFormD(p, 15, r_dst, 0, (imm>>48) & 0xFFFF, endness_host);

      // ori r_dst, r_dst, (imm>>32) & 0xFFFF
      p = mkFormD(p, 24, r_dst, r_dst, (imm>>32) & 0xFFFF, endness_host);
         
      // shift r_dst low word to high word => rldicr
      p = mkFormMD(p, 30, r_dst, r_dst, 32, 31, 1, endness_host);

      // load low word
      // oris r_dst, r_dst, (imm>>16) & 0xFFFF
      p = mkFormD(p, 25, r_dst, r_dst, (imm>>16) & 0xFFFF, endness_host);

      // ori r_dst, r_dst, (imm) & 0xFFFF
      p = mkFormD(p, 24, r_dst, r_dst, imm & 0xFFFF, endness_host);

      vassert(p == (UChar*)&expect[5]);

      return fetch32(p_to_check + 0, endness_host) == expect[0]
             && fetch32(p_to_check + 4,  endness_host) == expect[1]
             && fetch32(p_to_check + 8,  endness_host) == expect[2]
             && fetch32(p_to_check + 12, endness_host) == expect[3]
             && fetch32(p_to_check + 16, endness_host) == expect[4];
   }
}


/* Generate a machine-word sized load or store.  Simplified version of
   the Pin_Load and Pin_Store cases below. */
static UChar* do_load_or_store_machine_word ( 
                 UChar* p, Bool isLoad,
                 UInt reg, PPCAMode* am, Bool mode64, VexEndness endness_host )
{
   if (isLoad) {
      UInt opc1, sz = mode64 ? 8 : 4;
      switch (am->tag) {
         case Pam_IR:
            if (mode64) {
               vassert(0 == (am->Pam.IR.index & 3));
            }
            switch (sz) {
               case 4:  opc1 = 32; vassert(!mode64); break;
               case 8:  opc1 = 58; vassert(mode64);  break;
               default: vassert(0);
            }
            p = doAMode_IR(p, opc1, reg, am, mode64, endness_host);
            break;
         case Pam_RR:
            /* we could handle this case, but we don't expect to ever
               need to. */
            vassert(0);
         default:
            vassert(0);
      }
   } else /*store*/ {
      UInt opc1, sz = mode64 ? 8 : 4;
      switch (am->tag) {
         case Pam_IR:
            if (mode64) {
               vassert(0 == (am->Pam.IR.index & 3));
            }
            switch (sz) {
               case 4:  opc1 = 36; vassert(!mode64); break;
               case 8:  opc1 = 62; vassert(mode64);  break;
               default: vassert(0);
            }
            p = doAMode_IR(p, opc1, reg, am, mode64, endness_host);
            break;
         case Pam_RR:
            /* we could handle this case, but we don't expect to ever
               need to. */
            vassert(0);
         default:
            vassert(0);
      }
   }
   return p;
}

/* Generate a 32-bit sized load or store.  Simplified version of
   do_load_or_store_machine_word above. */
static UChar* do_load_or_store_word32 ( 
                 UChar* p, Bool isLoad,
                 UInt reg, PPCAMode* am, Bool mode64, VexEndness endness_host )
{
   if (isLoad) {
      UInt opc1;
      switch (am->tag) {
         case Pam_IR:
            if (mode64) {
               vassert(0 == (am->Pam.IR.index & 3));
            }
            opc1 = 32;
            p = doAMode_IR(p, opc1, reg, am, mode64, endness_host);
            break;
         case Pam_RR:
            /* we could handle this case, but we don't expect to ever
               need to. */
            vassert(0);
         default:
            vassert(0);
      }
   } else /*store*/ {
      UInt opc1;
      switch (am->tag) {
         case Pam_IR:
            if (mode64) {
               vassert(0 == (am->Pam.IR.index & 3));
            }
            opc1 = 36;
            p = doAMode_IR(p, opc1, reg, am, mode64, endness_host);
            break;
         case Pam_RR:
            /* we could handle this case, but we don't expect to ever
               need to. */
            vassert(0);
         default:
            vassert(0);
      }
   }
   return p;
}

/* Move r_dst to r_src */
static UChar* mkMoveReg ( UChar* p, UInt r_dst, UInt r_src,
                          VexEndness endness_host )
{
   vassert(r_dst < 0x20);
   vassert(r_src < 0x20);

   if (r_dst != r_src) {
      /* or r_dst, r_src, r_src */
      p = mkFormX(p, 31, r_src, r_dst, r_src, 444, 0, endness_host );
   }
   return p;
}

static UChar* mkFormVX ( UChar* p, UInt opc1, UInt r1, UInt r2,
                         UInt r3, UInt opc2, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(opc2 < 0x800);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) | (r3<<11) | opc2);
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormVXI ( UChar* p, UInt opc1, UInt r1, UInt r2,
                          UInt r3, UInt opc2, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(opc2 < 0x27);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) | (r3<<11) | opc2<<1);
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormVXR ( UChar* p, UInt opc1, UInt r1, UInt r2,
                          UInt r3, UInt Rc, UInt opc2,
                          VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(Rc   < 0x2);
   vassert(opc2 < 0x400);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (r3<<11) | (Rc<<10) | opc2);
   return emit32(p, theInstr, endness_host);
}

static UChar* mkFormVA ( UChar* p, UInt opc1, UInt r1, UInt r2,
                         UInt r3, UInt r4, UInt opc2, VexEndness endness_host )
{
   UInt theInstr;
   vassert(opc1 < 0x40);
   vassert(r1   < 0x20);
   vassert(r2   < 0x20);
   vassert(r3   < 0x20);
   vassert(r4   < 0x20);
   vassert(opc2 < 0x40);
   theInstr = ((opc1<<26) | (r1<<21) | (r2<<16) |
               (r3<<11) | (r4<<6) | opc2);
   return emit32(p, theInstr, endness_host);
}


/* Emit an instruction into buf and return the number of bytes used.
   Note that buf is not the insn's final place, and therefore it is
   imperative to emit position-independent code.  If the emitted
   instruction was a profiler inc, set *is_profInc to True, else leave
   it unchanged.
*/
Int emit_PPCInstr ( /*MB_MOD*/Bool* is_profInc,
                    UChar* buf, Int nbuf, const PPCInstr* i, 
                    Bool mode64, VexEndness endness_host,
                    const void* disp_cp_chain_me_to_slowEP,
                    const void* disp_cp_chain_me_to_fastEP,
                    const void* disp_cp_xindir,
                    const void* disp_cp_xassisted)
{
   UChar* p = &buf[0];
   vassert(nbuf >= 32);

   if (0) {
      vex_printf("asm  ");ppPPCInstr(i, mode64); vex_printf("\n");
   }

   switch (i->tag) {

   case Pin_LI:
      p = mkLoadImm(p, iregNo(i->Pin.LI.dst, mode64),
                    i->Pin.LI.imm64, mode64, endness_host);
      goto done;

   case Pin_Alu: {
      PPCRH* srcR   = i->Pin.Alu.srcR;
      Bool   immR   = toBool(srcR->tag == Prh_Imm);
      UInt   r_dst  = iregNo(i->Pin.Alu.dst, mode64);
      UInt   r_srcL = iregNo(i->Pin.Alu.srcL, mode64);
      UInt   r_srcR = immR ? (-1)/*bogus*/ :
                             iregNo(srcR->Prh.Reg.reg, mode64);

      switch (i->Pin.Alu.op) {
      case Palu_ADD:
         if (immR) {
            /* addi (PPC32 p350) */
            vassert(srcR->Prh.Imm.syned);
            vassert(srcR->Prh.Imm.imm16 != 0x8000);
            p = mkFormD(p, 14, r_dst, r_srcL, srcR->Prh.Imm.imm16, endness_host);
         } else {
            /* add (PPC32 p347) */
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 266, 0, endness_host);
         }
         break;

      case Palu_SUB:
         if (immR) {
            /* addi (PPC32 p350), but with negated imm */
            vassert(srcR->Prh.Imm.syned);
            vassert(srcR->Prh.Imm.imm16 != 0x8000);
            p = mkFormD(p, 14, r_dst, r_srcL, (- srcR->Prh.Imm.imm16),
                        endness_host);
         } else {
            /* subf (PPC32 p537), with args the "wrong" way round */
            p = mkFormXO(p, 31, r_dst, r_srcR, r_srcL, 0, 40, 0, endness_host);
         }
         break;

      case Palu_AND:
         if (immR) {
            /* andi. (PPC32 p358) */
            vassert(!srcR->Prh.Imm.syned);
            p = mkFormD(p, 28, r_srcL, r_dst, srcR->Prh.Imm.imm16, endness_host);
         } else {
            /* and (PPC32 p356) */
            p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 28, 0, endness_host);
         }
         break;

      case Palu_OR:
         if (immR) {
            /* ori (PPC32 p497) */
            vassert(!srcR->Prh.Imm.syned);
            p = mkFormD(p, 24, r_srcL, r_dst, srcR->Prh.Imm.imm16, endness_host);
         } else {
            /* or (PPC32 p495) */
            p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 444, 0, endness_host);
         }
         break;

      case Palu_XOR:
         if (immR) {
            /* xori (PPC32 p550) */
            vassert(!srcR->Prh.Imm.syned);
            p = mkFormD(p, 26, r_srcL, r_dst, srcR->Prh.Imm.imm16, endness_host);
         } else {
            /* xor (PPC32 p549) */
            p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 316, 0, endness_host);
         }
         break;

      default:
         goto bad;
      }
      goto done;
   }

   case Pin_Shft: {
      PPCRH* srcR   = i->Pin.Shft.srcR;
      Bool   sz32   = i->Pin.Shft.sz32;
      Bool   immR   = toBool(srcR->tag == Prh_Imm);
      UInt   r_dst  = iregNo(i->Pin.Shft.dst, mode64);
      UInt   r_srcL = iregNo(i->Pin.Shft.srcL, mode64);
      UInt   r_srcR = immR ? (-1)/*bogus*/ :
                             iregNo(srcR->Prh.Reg.reg, mode64);
      if (!mode64)
         vassert(sz32);

      switch (i->Pin.Shft.op) {
      case Pshft_SHL:
         if (sz32) {
            if (immR) {
               /* rd = rs << n, 1 <= n <= 31
                  is
                  rlwinm rd,rs,n,0,31-n  (PPC32 p501)
               */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               vassert(n > 0 && n < 32);
               p = mkFormM(p, 21, r_srcL, r_dst, n, 0, 31-n, 0, endness_host);
            } else {
               /* slw (PPC32 p505) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 24, 0, endness_host);
            }
         } else {
            if (immR) {
               /* rd = rs << n, 1 <= n <= 63
                  is
                  rldicr rd,rs,n,63-n  (PPC64 p559)
               */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               vassert(n > 0 && n < 64);
               p = mkFormMD(p, 30, r_srcL, r_dst, n, 63-n, 1, endness_host);
            } else {
               /* sld (PPC64 p568) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 27, 0, endness_host);
            }
         }
         break;

      case Pshft_SHR:
         if (sz32) {
             if (immR) {
               /* rd = rs >>u n, 1 <= n <= 31
                  is
                  rlwinm rd,rs,32-n,n,31  (PPC32 p501)
               */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               vassert(n > 0 && n < 32);
               p = mkFormM(p, 21, r_srcL, r_dst, 32-n, n, 31, 0, endness_host);
            } else {
               /* srw (PPC32 p508) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 536, 0, endness_host);
            }
         } else {
            if (immR) {
               /* rd = rs >>u n, 1 <= n <= 63
                  is
                  rldicl rd,rs,64-n,n  (PPC64 p558)
               */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               vassert(n > 0 && n < 64);
               p = mkFormMD(p, 30, r_srcL, r_dst, 64-n, n, 0, endness_host);
            } else {
               /* srd (PPC64 p574) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 539, 0, endness_host);
            }
         }
         break;

      case Pshft_SAR:
         if (sz32) {
            if (immR) {
               /* srawi (PPC32 p507) */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               /* In 64-bit mode, we allow right shifts by zero bits
                  as that is a handy way to sign extend the lower 32
                  bits into the upper 32 bits. */
               if (mode64)
                  vassert(n >= 0 && n < 32);
               else 
                  vassert(n > 0 && n < 32);
               p = mkFormX(p, 31, r_srcL, r_dst, n, 824, 0, endness_host);
            } else {
               /* sraw (PPC32 p506) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 792, 0, endness_host);
            }
         } else {
            if (immR) {
               /* sradi (PPC64 p571) */
               UInt n = srcR->Prh.Imm.imm16;
               vassert(!srcR->Prh.Imm.syned);
               vassert(n > 0 && n < 64);
               p = mkFormXS(p, 31, r_srcL, r_dst, n, 413, 0, endness_host);
            } else {
               /* srad (PPC32 p570) */
               p = mkFormX(p, 31, r_srcL, r_dst, r_srcR, 794, 0, endness_host);
            }
         }
         break;

      default:
         goto bad;
      }
      goto done;
   }

   case Pin_AddSubC: {
      Bool isAdd  = i->Pin.AddSubC.isAdd;
      Bool setC   = i->Pin.AddSubC.setC;
      UInt r_srcL = iregNo(i->Pin.AddSubC.srcL, mode64);
      UInt r_srcR = iregNo(i->Pin.AddSubC.srcR, mode64);
      UInt r_dst  = iregNo(i->Pin.AddSubC.dst, mode64);
      
      if (isAdd) {
         if (setC) /* addc (PPC32 p348) */
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 10, 0, endness_host);
         else          /* adde (PPC32 p349) */
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 138, 0, endness_host);
      } else {
         /* subfX, with args the "wrong" way round */
         if (setC) /* subfc (PPC32 p538) */
            p = mkFormXO(p, 31, r_dst, r_srcR, r_srcL, 0, 8, 0, endness_host);
         else          /* subfe (PPC32 p539) */
            p = mkFormXO(p, 31, r_dst, r_srcR, r_srcL, 0, 136, 0, endness_host);
      }
      goto done;
   }

   case Pin_Cmp: {
      Bool syned  = i->Pin.Cmp.syned;
      Bool sz32   = i->Pin.Cmp.sz32;
      UInt fld1   = i->Pin.Cmp.crfD << 2;
      UInt r_srcL = iregNo(i->Pin.Cmp.srcL, mode64);
      UInt r_srcR, imm_srcR;
      PPCRH* srcR = i->Pin.Cmp.srcR;

      if (!mode64)        // cmp double word invalid for mode32
         vassert(sz32);      
      else if (!sz32)     // mode64 && cmp64: set L=1
         fld1 |= 1;
 
      switch (srcR->tag) {
      case Prh_Imm:
         vassert(syned == srcR->Prh.Imm.syned);
         imm_srcR = srcR->Prh.Imm.imm16;
         if (syned) {  // cmpw/di  (signed)   (PPC32 p368)
            vassert(imm_srcR != 0x8000);
            p = mkFormD(p, 11, fld1, r_srcL, imm_srcR, endness_host);
         } else {      // cmplw/di (unsigned) (PPC32 p370)
            p = mkFormD(p, 10, fld1, r_srcL, imm_srcR, endness_host);
         }
         break;
      case Prh_Reg:
         r_srcR = iregNo(srcR->Prh.Reg.reg, mode64);
         if (syned)  // cmpwi  (signed)   (PPC32 p367)
            p = mkFormX(p, 31, fld1, r_srcL, r_srcR, 0, 0, endness_host);
         else        // cmplwi (unsigned) (PPC32 p379)
            p = mkFormX(p, 31, fld1, r_srcL, r_srcR, 32, 0, endness_host);
         break;
      default: 
         goto bad;
      }        
      goto done;
   }

   case Pin_Unary: {
      UInt r_dst = iregNo(i->Pin.Unary.dst, mode64);
      UInt r_src = iregNo(i->Pin.Unary.src, mode64);

      switch (i->Pin.Unary.op) {
      case Pun_NOT:  // nor r_dst,r_src,r_src
         p = mkFormX(p, 31, r_src, r_dst, r_src, 124, 0, endness_host);
         break;
      case Pun_NEG:  // neg r_dst,r_src
         p = mkFormXO(p, 31, r_dst, r_src, 0, 0, 104, 0, endness_host);
         break;
      case Pun_CLZ32:  // cntlzw r_dst, r_src
         p = mkFormX(p, 31, r_src, r_dst, 0, 26, 0, endness_host);
         break;
      case Pun_CLZ64:  // cntlzd r_dst, r_src
         vassert(mode64);
         p = mkFormX(p, 31, r_src, r_dst, 0, 58, 0, endness_host);
         break;
      case Pun_EXTSW:  // extsw r_dst, r_src
         vassert(mode64);
         p = mkFormX(p, 31, r_src, r_dst, 0, 986, 0, endness_host);
         break;
      default: goto bad;
      }
      goto done;
   }

   case Pin_MulL: {
      Bool syned  = i->Pin.MulL.syned;
      Bool sz32   = i->Pin.MulL.sz32;
      UInt r_dst  = iregNo(i->Pin.MulL.dst, mode64);
      UInt r_srcL = iregNo(i->Pin.MulL.srcL, mode64);
      UInt r_srcR = iregNo(i->Pin.MulL.srcR, mode64);

      if (!mode64)
         vassert(sz32);

      if (i->Pin.MulL.hi) {
         // mul hi words, must consider sign
         if (sz32) {
            if (syned)  // mulhw r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 75, 0,
                            endness_host);
            else        // mulhwu r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 11, 0,
                            endness_host);
         } else {
            if (syned)  // mulhd r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 73, 0,
                            endness_host);
            else        // mulhdu r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 9, 0, endness_host);
         }
      } else {
         // mul low word, sign is irrelevant
         vassert(!i->Pin.MulL.syned);
         if (sz32)      // mullw r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 235, 0, endness_host);
         else           // mulld r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 233, 0, endness_host);
      }
      goto done;
   }

   case Pin_Div: {
      Bool syned  = i->Pin.Div.syned;
      Bool sz32   = i->Pin.Div.sz32;
      UInt r_dst  = iregNo(i->Pin.Div.dst, mode64);
      UInt r_srcL = iregNo(i->Pin.Div.srcL, mode64);
      UInt r_srcR = iregNo(i->Pin.Div.srcR, mode64);

      if (!mode64)
         vassert(sz32);

      if (i->Pin.Div.extended) {
         if (sz32) {
            if (syned)
               // divwe r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 427, 0,
                            endness_host);
            else
               // divweu r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 395, 0,
                            endness_host);
         } else {
            if (syned)
               // divde r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 425, 0,
                            endness_host);
            else
               // divdeu r_dst,r_srcL,r_srcR
               p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 393, 0,
                            endness_host);
         }
      } else if (sz32) {
         if (syned)  // divw r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 491, 0, endness_host);
         else        // divwu r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 459, 0, endness_host);
      } else {
         if (syned)  // divd r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 489, 0, endness_host);
         else        // divdu r_dst,r_srcL,r_srcR
            p = mkFormXO(p, 31, r_dst, r_srcL, r_srcR, 0, 457, 0, endness_host);
      }
      goto done;
   }

   case Pin_Call: {
      if (i->Pin.Call.cond.test != Pct_ALWAYS
          && i->Pin.Call.rloc.pri != RLPri_None) {
         /* The call might not happen (it isn't unconditional) and it
            returns a result.  In this case we will need to generate a
            control flow diamond to put 0x555..555 in the return
            register(s) in the case where the call doesn't happen.  If
            this ever becomes necessary, maybe copy code from the ARM
            equivalent.  Until that day, just give up. */
         goto bad;
      }
      PPCCondCode cond  = i->Pin.Call.cond;
      UInt        r_dst = 10;
      /* As per detailed comment for Pin_Call in
         getRegUsage_PPCInstr above, %r10 is used as an address temp */

      /* jump over the following insns if condition does not hold */
      UChar* ptmp = NULL;
      if (cond.test != Pct_ALWAYS) {
         /* jmp fwds if !condition */
         /* don't know how many bytes to jump over yet...
            make space for a jump instruction and fill in later. */
         ptmp = p; /* fill in this bit later */
         p += 4;                                          // p += 4
      }

      /* load target to r_dst */                          // p += 4|8|20
      p = mkLoadImm(p, r_dst, i->Pin.Call.target, mode64, endness_host);

      /* mtspr 9,r_dst => move r_dst to count register */
      p = mkFormXFX(p, r_dst, 9, 467, endness_host);               // p += 4
      
      /* bctrl => branch to count register (and save to lr) */
      p = mkFormXL(p, 19, Pct_ALWAYS, 0, 0, 528, 1, endness_host); // p += 4

      /* Fix up the conditional jump, if there was one. */
      if (cond.test != Pct_ALWAYS) {
         Int delta = p - ptmp;
         vassert(delta >= 16 && delta <= 32);
         /* bc !ct,cf,delta */
         mkFormB(ptmp, invertCondTest(cond.test),
                 cond.flag, (delta>>2), 0, 0, endness_host);
      }
      goto done;
   }

   case Pin_XDirect: {
      /* NB: what goes on here has to be very closely coordinated
         with the chainXDirect_PPC and unchainXDirect_PPC below. */
      /* We're generating chain-me requests here, so we need to be
            sure this is actually allowed -- no-redir translations
            can't use chain-me's.  Hence: */
      vassert(disp_cp_chain_me_to_slowEP != NULL);
      vassert(disp_cp_chain_me_to_fastEP != NULL);

      /* First off, if this is conditional, create a conditional jump
         over the rest of it.  Or at least, leave a space for it that
         we will shortly fill in. */
      UChar* ptmp = NULL;
      if (i->Pin.XDirect.cond.test != Pct_ALWAYS) {
         vassert(i->Pin.XDirect.cond.flag != Pcf_NONE);
         ptmp = p;
         p += 4;
      } else {
         vassert(i->Pin.XDirect.cond.flag == Pcf_NONE);
      }

      /* Update the guest CIA. */
      /* imm32/64 r30, dstGA */
      if (!mode64) vassert(0 == (((ULong)i->Pin.XDirect.dstGA) >> 32));
      p = mkLoadImm(p, /*r*/30, (ULong)i->Pin.XDirect.dstGA, mode64,
                    endness_host);
      /* stw/std r30, amCIA */
      p = do_load_or_store_machine_word(
             p, False/*!isLoad*/,
             /*r*/30, i->Pin.XDirect.amCIA, mode64, endness_host
          );

      /* --- FIRST PATCHABLE BYTE follows --- */
      /* VG_(disp_cp_chain_me_to_{slowEP,fastEP}) (where we're calling
         to) backs up the return address, so as to find the address of
         the first patchable byte.  So: don't change the number of
         instructions (32-bit: 4, 64-bit: 7) below. */
      /* imm32/64-fixed r30, VG_(disp_cp_chain_me_to_{slowEP,fastEP} */
      const void* disp_cp_chain_me
               = i->Pin.XDirect.toFastEP ? disp_cp_chain_me_to_fastEP 
                                         : disp_cp_chain_me_to_slowEP;
      p = mkLoadImm_EXACTLY2or5(
             p, /*r*/30, (Addr)disp_cp_chain_me, mode64, endness_host);
      /* mtctr r30 */
      p = mkFormXFX(p, /*r*/30, 9, 467, endness_host);
      /* bctrl */
      p = mkFormXL(p, 19, Pct_ALWAYS, 0, 0, 528, 1, endness_host);
      /* --- END of PATCHABLE BYTES --- */

      /* Fix up the conditional jump, if there was one. */
      if (i->Pin.XDirect.cond.test != Pct_ALWAYS) {
         Int delta = p - ptmp;
         vassert(delta >= 16 && delta <= 64 && 0 == (delta & 3));
         /* bc !ct,cf,delta */
         mkFormB(ptmp, invertCondTest(i->Pin.XDirect.cond.test),
                 i->Pin.XDirect.cond.flag, (delta>>2), 0, 0, endness_host);
      }
      goto done;
   }

   case Pin_XIndir: {
      /* We're generating transfers that could lead indirectly to a
         chain-me, so we need to be sure this is actually allowed --
         no-redir translations are not allowed to reach normal
         translations without going through the scheduler.  That means
         no XDirects or XIndirs out from no-redir translations.
         Hence: */
      vassert(disp_cp_xindir != NULL);

      /* First off, if this is conditional, create a conditional jump
         over the rest of it.  Or at least, leave a space for it that
         we will shortly fill in. */
      UChar* ptmp = NULL;
      if (i->Pin.XIndir.cond.test != Pct_ALWAYS) {
         vassert(i->Pin.XIndir.cond.flag != Pcf_NONE);
         ptmp = p;
         p += 4;
      } else {
         vassert(i->Pin.XIndir.cond.flag == Pcf_NONE);
      }

      /* Update the guest CIA. */
      /* stw/std r-dstGA, amCIA */
      p = do_load_or_store_machine_word(
             p, False/*!isLoad*/,
             iregNo(i->Pin.XIndir.dstGA, mode64),
             i->Pin.XIndir.amCIA, mode64, endness_host
          );

      /* imm32/64 r30, VG_(disp_cp_xindir) */
      p = mkLoadImm(p, /*r*/30, (ULong)(Addr)disp_cp_xindir, mode64,
                    endness_host);
      /* mtctr r30 */
      p = mkFormXFX(p, /*r*/30, 9, 467, endness_host);
      /* bctr */
      p = mkFormXL(p, 19, Pct_ALWAYS, 0, 0, 528, 0, endness_host);

      /* Fix up the conditional jump, if there was one. */
      if (i->Pin.XIndir.cond.test != Pct_ALWAYS) {
         Int delta = p - ptmp;
         vassert(delta >= 16 && delta <= 32 && 0 == (delta & 3));
         /* bc !ct,cf,delta */
         mkFormB(ptmp, invertCondTest(i->Pin.XIndir.cond.test),
                 i->Pin.XIndir.cond.flag, (delta>>2), 0, 0, endness_host);
      }
      goto done;
   }

   case Pin_XAssisted: {
      /* First off, if this is conditional, create a conditional jump
         over the rest of it.  Or at least, leave a space for it that
         we will shortly fill in. */
      UChar* ptmp = NULL;
      if (i->Pin.XAssisted.cond.test != Pct_ALWAYS) {
         vassert(i->Pin.XAssisted.cond.flag != Pcf_NONE);
         ptmp = p;
         p += 4;
      } else {
         vassert(i->Pin.XAssisted.cond.flag == Pcf_NONE);
      }

      /* Update the guest CIA. */
      /* stw/std r-dstGA, amCIA */
      p = do_load_or_store_machine_word(
             p, False/*!isLoad*/,
             iregNo(i->Pin.XIndir.dstGA, mode64),
             i->Pin.XIndir.amCIA, mode64, endness_host
          );

      /* imm32/64 r31, $magic_number */
      UInt trcval = 0;
      switch (i->Pin.XAssisted.jk) {
         case Ijk_ClientReq:   trcval = VEX_TRC_JMP_CLIENTREQ;   break;
         case Ijk_Sys_syscall: trcval = VEX_TRC_JMP_SYS_SYSCALL; break;
         //case Ijk_Sys_int128:  trcval = VEX_TRC_JMP_SYS_INT128;  break;
         //case Ijk_Yield:       trcval = VEX_TRC_JMP_YIELD;       break;
         case Ijk_EmWarn:      trcval = VEX_TRC_JMP_EMWARN;      break;
         case Ijk_EmFail:      trcval = VEX_TRC_JMP_EMFAIL;      break;
         //case Ijk_MapFail:     trcval = VEX_TRC_JMP_MAPFAIL;     break;
         case Ijk_NoDecode:    trcval = VEX_TRC_JMP_NODECODE;    break;
         case Ijk_InvalICache: trcval = VEX_TRC_JMP_INVALICACHE; break;
         case Ijk_NoRedir:     trcval = VEX_TRC_JMP_NOREDIR;     break;
         case Ijk_SigTRAP:     trcval = VEX_TRC_JMP_SIGTRAP;     break;
         //case Ijk_SigSEGV:     trcval = VEX_TRC_JMP_SIGSEGV;     break;
         case Ijk_SigBUS:        trcval = VEX_TRC_JMP_SIGBUS;    break;
         case Ijk_Boring:      trcval = VEX_TRC_JMP_BORING;      break;
         /* We don't expect to see the following being assisted. */
         //case Ijk_Ret:
         //case Ijk_Call:
         /* fallthrough */
         default: 
            ppIRJumpKind(i->Pin.XAssisted.jk);
            vpanic("emit_ARMInstr.Pin_XAssisted: unexpected jump kind");
      }
      vassert(trcval != 0);
      p = mkLoadImm(p, /*r*/31, trcval, mode64, endness_host);

      /* imm32/64 r30, VG_(disp_cp_xassisted) */
      p = mkLoadImm(p, /*r*/30,
                    (ULong)(Addr)disp_cp_xassisted, mode64,
                     endness_host);
      /* mtctr r30 */
      p = mkFormXFX(p, /*r*/30, 9, 467, endness_host);
      /* bctr */
      p = mkFormXL(p, 19, Pct_ALWAYS, 0, 0, 528, 0, endness_host);

      /* Fix up the conditional jump, if there was one. */
      if (i->Pin.XAssisted.cond.test != Pct_ALWAYS) {
         Int delta = p - ptmp;
         vassert(delta >= 16 && delta <= 32 && 0 == (delta & 3));
         /* bc !ct,cf,delta */
         mkFormB(ptmp, invertCondTest(i->Pin.XAssisted.cond.test),
                 i->Pin.XAssisted.cond.flag, (delta>>2), 0, 0, endness_host);
      }
      goto done;
   }

   case Pin_CMov: {
      UInt  r_dst, r_src;
      ULong imm_src;
      PPCCondCode cond;
      vassert(i->Pin.CMov.cond.test != Pct_ALWAYS);

      r_dst = iregNo(i->Pin.CMov.dst, mode64);
      cond = i->Pin.CMov.cond;

      /* branch (if cond fails) over move instrs */
      UChar* ptmp = NULL;
      if (cond.test != Pct_ALWAYS) {
         /* don't know how many bytes to jump over yet...
            make space for a jump instruction and fill in later. */
         ptmp = p; /* fill in this bit later */
         p += 4;
      }

      // cond true: move src => dst
      switch (i->Pin.CMov.src->tag) {
      case Pri_Imm:
         imm_src = i->Pin.CMov.src->Pri.Imm;
         p = mkLoadImm(p, r_dst, imm_src, mode64, endness_host);  // p += 4|8|20
         break;
      case Pri_Reg:
         r_src = iregNo(i->Pin.CMov.src->Pri.Reg, mode64);
         p = mkMoveReg(p, r_dst, r_src, endness_host);            // p += 4
         break;
      default: goto bad;
      }

      /* Fix up the conditional jump, if there was one. */
      if (cond.test != Pct_ALWAYS) {
         Int delta = p - ptmp;
         vassert(delta >= 8 && delta <= 24);
         /* bc !ct,cf,delta */
         mkFormB(ptmp, invertCondTest(cond.test),
                 cond.flag, (delta>>2), 0, 0, endness_host);
      }
      goto done;
   }

   case Pin_Load: {
      PPCAMode* am_addr = i->Pin.Load.src;
      UInt r_dst = iregNo(i->Pin.Load.dst, mode64);
      UInt opc1, opc2, sz = i->Pin.Load.sz;
      switch (am_addr->tag) {
      case Pam_IR:
         if (mode64 && (sz == 4 || sz == 8)) {
            /* should be guaranteed to us by iselWordExpr_AMode */
            vassert(0 == (am_addr->Pam.IR.index & 3));
         }
         switch(sz) {
            case 1:  opc1 = 34; break;
            case 2:  opc1 = 40; break;
            case 4:  opc1 = 32; break;
            case 8:  opc1 = 58; vassert(mode64); break;
            default: goto bad;
         }
         p = doAMode_IR(p, opc1, r_dst, am_addr, mode64, endness_host);
         goto done;
      case Pam_RR:
         switch(sz) {
            case 1:  opc2 = 87;  break;
            case 2:  opc2 = 279; break;
            case 4:  opc2 = 23;  break;
            case 8:  opc2 = 21; vassert(mode64); break;
            default: goto bad;
         }
         p = doAMode_RR(p, 31, opc2, r_dst, am_addr, mode64, endness_host);
         goto done;
      default:
         goto bad;
      }
   }

   case Pin_LoadL: {
      if (i->Pin.LoadL.sz == 4) {
         p = mkFormX(p, 31, iregNo(i->Pin.LoadL.dst, mode64),
                     0, iregNo(i->Pin.LoadL.src, mode64), 20, 0, endness_host);
         goto done;
      }
      if (i->Pin.LoadL.sz == 8 && mode64) {
         p = mkFormX(p, 31, iregNo(i->Pin.LoadL.dst, mode64),
                     0, iregNo(i->Pin.LoadL.src, mode64), 84, 0, endness_host);
         goto done;
      }
      goto bad;
   }

   case Pin_Set: {
      /* Make the destination register be 1 or 0, depending on whether
         the relevant condition holds. */
      UInt        r_dst = iregNo(i->Pin.Set.dst, mode64);
      PPCCondCode cond  = i->Pin.Set.cond;
      UInt rot_imm, r_tmp;

      if (cond.test == Pct_ALWAYS) {
         // Just load 1 to dst => li dst,1
         p = mkFormD(p, 14, r_dst, 0, 1, endness_host);
      } else {
         vassert(cond.flag != Pcf_NONE);
         rot_imm = 1 + cond.flag;
         r_tmp = 0;  // Not set in getAllocable, so no need to declare.

         // r_tmp = CR  => mfcr r_tmp
         p = mkFormX(p, 31, r_tmp, 0, 0, 19, 0, endness_host);

         // r_dst = flag (rotate left and mask)
         //  => rlwinm r_dst,r_tmp,rot_imm,31,31
         p = mkFormM(p, 21, r_tmp, r_dst, rot_imm, 31, 31, 0, endness_host);

         if (cond.test == Pct_FALSE) {
            // flip bit  => xori r_dst,r_dst,1
            p = mkFormD(p, 26, r_dst, r_dst, 1, endness_host);
         }
      }
      goto done;
   }

   case Pin_MfCR:
      // mfcr dst
      p = mkFormX(p, 31, iregNo(i->Pin.MfCR.dst, mode64), 0, 0, 19, 0,
                  endness_host);
      goto done;

   case Pin_MFence: {
      p = mkFormX(p, 31, 0, 0, 0, 598, 0, endness_host);   // sync, PPC32 p616
      // CAB: Should this be isync?
      //    p = mkFormXL(p, 19, 0, 0, 0, 150, 0);  // isync, PPC32 p467
      goto done;
   }

   case Pin_Store: {
      PPCAMode* am_addr = i->Pin.Store.dst;
      UInt r_src = iregNo(i->Pin.Store.src, mode64);
      UInt opc1, opc2, sz = i->Pin.Store.sz;
      switch (i->Pin.Store.dst->tag) {
      case Pam_IR:
         if (mode64 && (sz == 4 || sz == 8)) {
            /* should be guaranteed to us by iselWordExpr_AMode */
            vassert(0 == (am_addr->Pam.IR.index & 3));
         }
         switch(sz) {
         case 1: opc1 = 38; break;
         case 2: opc1 = 44; break;
         case 4: opc1 = 36; break;
         case 8: vassert(mode64);
                 opc1 = 62; break;
         default:
            goto bad;
         }
         p = doAMode_IR(p, opc1, r_src, am_addr, mode64, endness_host);
         goto done;
      case Pam_RR:
         switch(sz) {
         case 1: opc2 = 215; break;
         case 2: opc2 = 407; break;
         case 4: opc2 = 151; break;
         case 8: vassert(mode64);
                 opc2 = 149; break;
         default:
            goto bad;
         }
         p = doAMode_RR(p, 31, opc2, r_src, am_addr, mode64, endness_host);
         goto done;
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_StoreC: {
      if (i->Pin.StoreC.sz == 4) {
         p = mkFormX(p, 31, iregNo(i->Pin.StoreC.src, mode64),
                     0, iregNo(i->Pin.StoreC.dst, mode64), 150, 1, endness_host);
         goto done;
      }
      if (i->Pin.StoreC.sz == 8 && mode64) {
         p = mkFormX(p, 31, iregNo(i->Pin.StoreC.src, mode64),
                     0, iregNo(i->Pin.StoreC.dst, mode64), 214, 1, endness_host);
         goto done;
      }
      goto bad;
   }

   case Pin_FpUnary: {
      UInt fr_dst = fregNo(i->Pin.FpUnary.dst);
      UInt fr_src = fregNo(i->Pin.FpUnary.src);
      switch (i->Pin.FpUnary.op) {
      case Pfp_RSQRTE: // frsqrtre, PPC32 p424
         p = mkFormA( p, 63, fr_dst, 0, fr_src, 0, 26, 0, endness_host );
         break;
      case Pfp_RES:   // fres, PPC32 p421
         p = mkFormA( p, 59, fr_dst, 0, fr_src, 0, 24, 0, endness_host );
         break;
      case Pfp_SQRT:  // fsqrt, PPC32 p427
         p = mkFormA( p, 63, fr_dst, 0, fr_src, 0, 22, 0, endness_host );
         break;
      case Pfp_ABS:   // fabs, PPC32 p399
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 264, 0, endness_host);
         break;
      case Pfp_NEG:   // fneg, PPC32 p416
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 40, 0, endness_host);
         break;
      case Pfp_MOV:   // fmr, PPC32 p410
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 72, 0, endness_host);
         break;
      case Pfp_FRIM:  // frim, PPC ISA 2.05 p137
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 488, 0, endness_host);
         break;
      case Pfp_FRIP:  // frip, PPC ISA 2.05 p137
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 456, 0, endness_host);
         break;
      case Pfp_FRIN:  // frin, PPC ISA 2.05 p137
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 392, 0, endness_host);
         break;
      case Pfp_FRIZ:  // friz, PPC ISA 2.05 p137
         p = mkFormX(p, 63, fr_dst, 0, fr_src, 424, 0, endness_host);
         break;
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_FpBinary: {
      UInt fr_dst  = fregNo(i->Pin.FpBinary.dst);
      UInt fr_srcL = fregNo(i->Pin.FpBinary.srcL);
      UInt fr_srcR = fregNo(i->Pin.FpBinary.srcR);
      switch (i->Pin.FpBinary.op) {
      case Pfp_ADDD:   // fadd, PPC32 p400
         p = mkFormA( p, 63, fr_dst, fr_srcL, fr_srcR, 0, 21, 0, endness_host );
         break;
      case Pfp_ADDS:   // fadds, PPC32 p401
         p = mkFormA( p, 59, fr_dst, fr_srcL, fr_srcR, 0, 21, 0, endness_host );
         break;
      case Pfp_SUBD:   // fsub, PPC32 p429
         p = mkFormA( p, 63, fr_dst, fr_srcL, fr_srcR, 0, 20, 0, endness_host );
         break;
      case Pfp_SUBS:   // fsubs, PPC32 p430
         p = mkFormA( p, 59, fr_dst, fr_srcL, fr_srcR, 0, 20, 0, endness_host );
         break;
      case Pfp_MULD:   // fmul, PPC32 p413
         p = mkFormA( p, 63, fr_dst, fr_srcL, 0, fr_srcR, 25, 0, endness_host );
         break;
      case Pfp_MULS:   // fmuls, PPC32 p414
         p = mkFormA( p, 59, fr_dst, fr_srcL, 0, fr_srcR, 25, 0, endness_host );
         break;
      case Pfp_DIVD:   // fdiv, PPC32 p406
         p = mkFormA( p, 63, fr_dst, fr_srcL, fr_srcR, 0, 18, 0, endness_host );
         break;
      case Pfp_DIVS:   // fdivs, PPC32 p407
         p = mkFormA( p, 59, fr_dst, fr_srcL, fr_srcR, 0, 18, 0, endness_host );
         break;
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_FpMulAcc: {
      UInt fr_dst    = fregNo(i->Pin.FpMulAcc.dst);
      UInt fr_srcML  = fregNo(i->Pin.FpMulAcc.srcML);
      UInt fr_srcMR  = fregNo(i->Pin.FpMulAcc.srcMR);
      UInt fr_srcAcc = fregNo(i->Pin.FpMulAcc.srcAcc);
      switch (i->Pin.FpMulAcc.op) {
      case Pfp_MADDD:   // fmadd, PPC32 p408
         p = mkFormA( p, 63, fr_dst, fr_srcML, fr_srcAcc, fr_srcMR, 29, 0,
                      endness_host );
         break;
      case Pfp_MADDS:   // fmadds, PPC32 p409
         p = mkFormA( p, 59, fr_dst, fr_srcML, fr_srcAcc, fr_srcMR, 29, 0,
                      endness_host );
         break;
      case Pfp_MSUBD:   // fmsub, PPC32 p411
         p = mkFormA( p, 63, fr_dst, fr_srcML, fr_srcAcc, fr_srcMR, 28, 0,
                      endness_host );
         break;
      case Pfp_MSUBS:   // fmsubs, PPC32 p412
         p = mkFormA( p, 59, fr_dst, fr_srcML, fr_srcAcc, fr_srcMR, 28, 0,
                      endness_host );
         break;
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_FpLdSt: {
      PPCAMode* am_addr = i->Pin.FpLdSt.addr;
      UInt f_reg = fregNo(i->Pin.FpLdSt.reg);
      Bool idxd = toBool(i->Pin.FpLdSt.addr->tag == Pam_RR);
      UChar sz = i->Pin.FpLdSt.sz;
      UInt opc;
      vassert(sz == 4 || sz == 8);

      if (i->Pin.FpLdSt.isLoad) {   // Load from memory
         if (idxd) {  // lf[s|d]x, PPC32 p444|440
            opc = (sz == 4) ? 535 : 599;
            p = doAMode_RR(p, 31, opc, f_reg, am_addr, mode64, endness_host);
         } else {     // lf[s|d], PPC32 p441|437
            opc = (sz == 4) ? 48 : 50;
            p = doAMode_IR(p, opc, f_reg, am_addr, mode64, endness_host);
         }
      } else {                      // Store to memory
         if (idxd) { // stf[s|d]x, PPC32 p521|516
            opc = (sz == 4) ? 663 : 727;
            p = doAMode_RR(p, 31, opc, f_reg, am_addr, mode64, endness_host);
         } else {    // stf[s|d], PPC32 p518|513
            opc = (sz == 4) ? 52 : 54;
            p = doAMode_IR(p, opc, f_reg, am_addr, mode64, endness_host);
         }
      }
      goto done;
   }

   case Pin_FpSTFIW: {
      UInt ir_addr = iregNo(i->Pin.FpSTFIW.addr, mode64);
      UInt fr_data = fregNo(i->Pin.FpSTFIW.data);
      // stfiwx (store fp64[lo32] as int32), PPC32 p517
      // Use rA==0, so that EA == rB == ir_addr
      p = mkFormX(p, 31, fr_data, 0/*rA=0*/, ir_addr, 983, 0, endness_host);
      goto done;
   }

   case Pin_FpRSP: {
      UInt fr_dst = fregNo(i->Pin.FpRSP.dst);
      UInt fr_src = fregNo(i->Pin.FpRSP.src);
      // frsp, PPC32 p423
      p = mkFormX(p, 63, fr_dst, 0, fr_src, 12, 0, endness_host);
      goto done;
   }

   case Pin_FpCftI: {
      UInt fr_dst = fregNo(i->Pin.FpCftI.dst);
      UInt fr_src = fregNo(i->Pin.FpCftI.src);
      if (i->Pin.FpCftI.fromI == False && i->Pin.FpCftI.int32 == True) {
         if (i->Pin.FpCftI.syned == True) {
            // fctiw (conv f64 to i32), PPC32 p404
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 14, 0, endness_host);
            goto done;
         } else {
            // fctiwu (conv f64 to u32)
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 142, 0, endness_host);
            goto done;
         }
      }
      if (i->Pin.FpCftI.fromI == False && i->Pin.FpCftI.int32 == False) {
         if (i->Pin.FpCftI.syned == True) {
            // fctid (conv f64 to i64), PPC64 p437
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 814, 0, endness_host);
            goto done;
         } else {
            // fctidu (conv f64 to u64)
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 942, 0, endness_host);
            goto done;
         }
      }
      if (i->Pin.FpCftI.fromI == True && i->Pin.FpCftI.int32 == False) {
         if (i->Pin.FpCftI.syned == True) {
            // fcfid (conv i64 to f64), PPC64 p434
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 846, 0, endness_host);
            goto done;
         } else if (i->Pin.FpCftI.flt64 == True) {
            // fcfidu (conv u64 to f64)
            p = mkFormX(p, 63, fr_dst, 0, fr_src, 974, 0, endness_host);
            goto done;
         } else {
            // fcfidus (conv u64 to f32)
            p = mkFormX(p, 59, fr_dst, 0, fr_src, 974, 0, endness_host);
            goto done;
         }
      }
      goto bad;
   }

   case Pin_FpCMov: {
      UInt        fr_dst = fregNo(i->Pin.FpCMov.dst);
      UInt        fr_src = fregNo(i->Pin.FpCMov.src);
      PPCCondCode cc     = i->Pin.FpCMov.cond;

      if (fr_dst == fr_src) goto done;
      
      vassert(cc.test != Pct_ALWAYS);

      /* jmp fwds if !condition */
      if (cc.test != Pct_ALWAYS) {
         /* bc !ct,cf,n_bytes>>2 */
         p = mkFormB(p, invertCondTest(cc.test), cc.flag, 8>>2, 0, 0,
                     endness_host);
      }

      // fmr, PPC32 p410
      p = mkFormX(p, 63, fr_dst, 0, fr_src, 72, 0, endness_host);
      goto done;
   }

   case Pin_FpLdFPSCR: {
      UInt fr_src = fregNo(i->Pin.FpLdFPSCR.src);
      p = mkFormXFL(p, 0xFF, fr_src, i->Pin.FpLdFPSCR.dfp_rm, endness_host); // mtfsf, PPC32 p480
      goto done;
   }

   case Pin_FpCmp: {
      UChar crfD    = 1;
      UInt  r_dst   = iregNo(i->Pin.FpCmp.dst, mode64);
      UInt  fr_srcL = fregNo(i->Pin.FpCmp.srcL);
      UInt  fr_srcR = fregNo(i->Pin.FpCmp.srcR);
      vassert(crfD < 8);
      // fcmpo, PPC32 p402
      p = mkFormX(p, 63, crfD<<2, fr_srcL, fr_srcR, 32, 0, endness_host);

      // mfcr (mv CR to r_dst), PPC32 p467
      p = mkFormX(p, 31, r_dst, 0, 0, 19, 0, endness_host);
      
      // rlwinm r_dst,r_dst,8,28,31, PPC32 p501
      //  => rotate field 1 to bottomw of word, masking out upper 28
      p = mkFormM(p, 21, r_dst, r_dst, 8, 28, 31, 0, endness_host);
      goto done;
   }

   case Pin_RdWrLR: {
      UInt reg = iregNo(i->Pin.RdWrLR.gpr, mode64);
      /* wrLR==True ? mtlr r4 : mflr r4 */
      p = mkFormXFX(p, reg, 8, (i->Pin.RdWrLR.wrLR==True) ? 467 : 339,
                    endness_host);
      goto done;
   }


   /* AltiVec */
   case Pin_AvLdSt: {
      UInt opc2, v_reg, r_idx, r_base;
      UChar sz   = i->Pin.AvLdSt.sz;
      Bool  idxd = toBool(i->Pin.AvLdSt.addr->tag == Pam_RR);
      vassert(sz == 1 || sz == 2 || sz == 4 || sz == 16);

      v_reg  = vregNo(i->Pin.AvLdSt.reg);
      r_base = iregNo(i->Pin.AvLdSt.addr->Pam.RR.base, mode64);

      // Only have AltiVec AMode_RR: kludge AMode_IR
      if (!idxd) {
         r_idx = 30;                       // XXX: Using r30 as temp
         p = mkLoadImm(p, r_idx,
                       i->Pin.AvLdSt.addr->Pam.IR.index, mode64, endness_host);
      } else {
         r_idx  = iregNo(i->Pin.AvLdSt.addr->Pam.RR.index, mode64);
      }

      if (i->Pin.FpLdSt.isLoad) {  // Load from memory (1,2,4,16)
         opc2 = (sz==1) ?   7 : (sz==2) ?  39 : (sz==4) ?  71 : 103;
         p = mkFormX(p, 31, v_reg, r_idx, r_base, opc2, 0, endness_host);
      } else {                      // Store to memory (1,2,4,16)
         opc2 = (sz==1) ? 135 : (sz==2) ? 167 : (sz==4) ? 199 : 231;
         p = mkFormX(p, 31, v_reg, r_idx, r_base, opc2, 0, endness_host);
      }
      goto done;
   }

   case Pin_AvUnary: {
      UInt v_dst = vregNo(i->Pin.AvUnary.dst);
      UInt v_src = vregNo(i->Pin.AvUnary.src);
      UInt opc2;
      switch (i->Pin.AvUnary.op) {
      case Pav_MOV:       opc2 = 1156; break; // vor vD,vS,vS
      case Pav_NOT:       opc2 = 1284; break; // vnor vD,vS,vS
      case Pav_UNPCKH8S:  opc2 =  526; break; // vupkhsb
      case Pav_UNPCKH16S: opc2 =  590; break; // vupkhsh
      case Pav_UNPCKL8S:  opc2 =  654; break; // vupklsb
      case Pav_UNPCKL16S: opc2 =  718; break; // vupklsh
      case Pav_UNPCKHPIX: opc2 =  846; break; // vupkhpx
      case Pav_UNPCKLPIX: opc2 =  974; break; // vupklpx

      case Pav_ZEROCNTBYTE: opc2 = 1794; break; // vclzb
      case Pav_ZEROCNTHALF: opc2 = 1858; break; // vclzh
      case Pav_ZEROCNTWORD: opc2 = 1922; break; // vclzw
      case Pav_ZEROCNTDBL:  opc2 = 1986; break; // vclzd
      case Pav_BITMTXXPOSE: opc2 = 1292; break; // vgbbd
      default:
         goto bad;
      }
      switch (i->Pin.AvUnary.op) {
      case Pav_MOV:
      case Pav_NOT:
         p = mkFormVX( p, 4, v_dst, v_src, v_src, opc2, endness_host );
         break;
      default:
         p = mkFormVX( p, 4, v_dst, 0, v_src, opc2, endness_host );
         break;
      }
      goto done;
   }

   case Pin_AvBinary: {
      UInt v_dst  = vregNo(i->Pin.AvBinary.dst);
      UInt v_srcL = vregNo(i->Pin.AvBinary.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBinary.srcR);
      UInt opc2;
      if (i->Pin.AvBinary.op == Pav_SHL) {
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 1036, endness_host ); // vslo
         p = mkFormVX( p, 4, v_dst, v_dst,  v_srcR, 452, endness_host );  // vsl
         goto done;
      }
      if (i->Pin.AvBinary.op == Pav_SHR) {
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 1100, endness_host ); // vsro
         p = mkFormVX( p, 4, v_dst, v_dst,  v_srcR, 708, endness_host );  // vsr
         goto done;
      }
      switch (i->Pin.AvBinary.op) {
      /* Bitwise */
      case Pav_AND:       opc2 = 1028; break; // vand
      case Pav_OR:        opc2 = 1156; break; // vor
      case Pav_XOR:       opc2 = 1220; break; // vxor
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }

   case Pin_AvBin8x16: {
      UInt v_dst  = vregNo(i->Pin.AvBin8x16.dst);
      UInt v_srcL = vregNo(i->Pin.AvBin8x16.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBin8x16.srcR);
      UInt opc2;
      switch (i->Pin.AvBin8x16.op) {

      case Pav_ADDU:     opc2 =    0; break; // vaddubm
      case Pav_QADDU:    opc2 =  512; break; // vaddubs
      case Pav_QADDS:    opc2 =  768; break; // vaddsbs

      case Pav_SUBU:     opc2 = 1024; break; // vsububm
      case Pav_QSUBU:    opc2 = 1536; break; // vsububs
      case Pav_QSUBS:    opc2 = 1792; break; // vsubsbs

      case Pav_OMULU:   opc2 =    8; break; // vmuloub
      case Pav_OMULS:   opc2 =  264; break; // vmulosb
      case Pav_EMULU:   opc2 =  520; break; // vmuleub
      case Pav_EMULS:   opc2 =  776; break; // vmulesb

      case Pav_AVGU:     opc2 = 1026; break; // vavgub
      case Pav_AVGS:     opc2 = 1282; break; // vavgsb
      case Pav_MAXU:     opc2 =    2; break; // vmaxub
      case Pav_MAXS:     opc2 =  258; break; // vmaxsb
      case Pav_MINU:     opc2 =  514; break; // vminub
      case Pav_MINS:     opc2 =  770; break; // vminsb

      case Pav_CMPEQU:   opc2 =    6; break; // vcmpequb
      case Pav_CMPGTU:   opc2 =  518; break; // vcmpgtub
      case Pav_CMPGTS:   opc2 =  774; break; // vcmpgtsb

      case Pav_SHL:      opc2 =  260; break; // vslb
      case Pav_SHR:      opc2 =  516; break; // vsrb
      case Pav_SAR:      opc2 =  772; break; // vsrab
      case Pav_ROTL:     opc2 =    4; break; // vrlb

      case Pav_MRGHI:    opc2 =   12; break; // vmrghb
      case Pav_MRGLO:    opc2 =  268; break; // vmrglb

      case Pav_POLYMULADD: opc2 = 1032; break; // vpmsumb

      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }

   case Pin_AvBin16x8: {
      UInt v_dst  = vregNo(i->Pin.AvBin16x8.dst);
      UInt v_srcL = vregNo(i->Pin.AvBin16x8.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBin16x8.srcR);
      UInt opc2;
      switch (i->Pin.AvBin16x8.op) {

      case Pav_ADDU:    opc2 =   64; break; // vadduhm
      case Pav_QADDU:   opc2 =  576; break; // vadduhs
      case Pav_QADDS:   opc2 =  832; break; // vaddshs

      case Pav_SUBU:    opc2 = 1088; break; // vsubuhm
      case Pav_QSUBU:   opc2 = 1600; break; // vsubuhs
      case Pav_QSUBS:   opc2 = 1856; break; // vsubshs

      case Pav_OMULU:   opc2 =   72; break; // vmulouh
      case Pav_OMULS:   opc2 =  328; break; // vmulosh
      case Pav_EMULU:   opc2 =  584; break; // vmuleuh
      case Pav_EMULS:   opc2 =  840; break; // vmulesh

      case Pav_AVGU:    opc2 = 1090; break; // vavguh
      case Pav_AVGS:    opc2 = 1346; break; // vavgsh
      case Pav_MAXU:    opc2 =   66; break; // vmaxuh
      case Pav_MAXS:    opc2 =  322; break; // vmaxsh
      case Pav_MINS:    opc2 =  834; break; // vminsh
      case Pav_MINU:    opc2 =  578; break; // vminuh

      case Pav_CMPEQU:  opc2 =   70; break; // vcmpequh
      case Pav_CMPGTU:  opc2 =  582; break; // vcmpgtuh
      case Pav_CMPGTS:  opc2 =  838; break; // vcmpgtsh

      case Pav_SHL:     opc2 =  324; break; // vslh
      case Pav_SHR:     opc2 =  580; break; // vsrh
      case Pav_SAR:     opc2 =  836; break; // vsrah
      case Pav_ROTL:    opc2 =   68; break; // vrlh

      case Pav_PACKUU:  opc2 =   14; break; // vpkuhum
      case Pav_QPACKUU: opc2 =  142; break; // vpkuhus
      case Pav_QPACKSU: opc2 =  270; break; // vpkshus
      case Pav_QPACKSS: opc2 =  398; break; // vpkshss
      case Pav_PACKPXL: opc2 =  782; break; // vpkpx

      case Pav_MRGHI:   opc2 =   76; break; // vmrghh
      case Pav_MRGLO:   opc2 =  332; break; // vmrglh

      case Pav_POLYMULADD: opc2 = 1224; break; // vpmsumh

      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }

   case Pin_AvBin32x4: {
      UInt v_dst  = vregNo(i->Pin.AvBin32x4.dst);
      UInt v_srcL = vregNo(i->Pin.AvBin32x4.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBin32x4.srcR);
      UInt opc2;
      switch (i->Pin.AvBin32x4.op) {

      case Pav_ADDU:    opc2 =  128; break; // vadduwm
      case Pav_QADDU:   opc2 =  640; break; // vadduws
      case Pav_QADDS:   opc2 =  896; break; // vaddsws

      case Pav_SUBU:    opc2 = 1152; break; // vsubuwm
      case Pav_QSUBU:   opc2 = 1664; break; // vsubuws
      case Pav_QSUBS:   opc2 = 1920; break; // vsubsws

      case Pav_MULU:    opc2 =  137; break; // vmuluwm
      case Pav_OMULU:   opc2 =  136; break; // vmulouw
      case Pav_OMULS:   opc2 =  392; break; // vmulosw
      case Pav_EMULU:   opc2 =  648; break; // vmuleuw
      case Pav_EMULS:   opc2 =  904; break; // vmulesw

      case Pav_AVGU:    opc2 = 1154; break; // vavguw
      case Pav_AVGS:    opc2 = 1410; break; // vavgsw

      case Pav_MAXU:    opc2 =  130; break; // vmaxuw
      case Pav_MAXS:    opc2 =  386; break; // vmaxsw

      case Pav_MINS:    opc2 =  898; break; // vminsw
      case Pav_MINU:    opc2 =  642; break; // vminuw

      case Pav_CMPEQU:  opc2 =  134; break; // vcmpequw
      case Pav_CMPGTS:  opc2 =  902; break; // vcmpgtsw
      case Pav_CMPGTU:  opc2 =  646; break; // vcmpgtuw

      case Pav_SHL:     opc2 =  388; break; // vslw
      case Pav_SHR:     opc2 =  644; break; // vsrw
      case Pav_SAR:     opc2 =  900; break; // vsraw
      case Pav_ROTL:    opc2 =  132; break; // vrlw

      case Pav_PACKUU:  opc2 =   78; break; // vpkuwum
      case Pav_QPACKUU: opc2 =  206; break; // vpkuwus
      case Pav_QPACKSU: opc2 =  334; break; // vpkswus
      case Pav_QPACKSS: opc2 =  462; break; // vpkswss

      case Pav_MRGHI:   opc2 =  140; break; // vmrghw
      case Pav_MRGLO:   opc2 =  396; break; // vmrglw

      case Pav_CATODD:  opc2 = 1676; break; // vmrgow
      case Pav_CATEVEN: opc2 = 1932; break; // vmrgew

      case Pav_POLYMULADD: opc2 = 1160; break; // vpmsumw

      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }

   case Pin_AvBin64x2: {
      UInt v_dst  = vregNo(i->Pin.AvBin64x2.dst);
      UInt v_srcL = vregNo(i->Pin.AvBin64x2.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBin64x2.srcR);
      UInt opc2;
      switch (i->Pin.AvBin64x2.op) {
      case Pav_ADDU:    opc2 =  192; break; // vaddudm  vector double add
      case Pav_SUBU:    opc2 = 1216; break; // vsubudm  vector double add
      case Pav_MAXU:    opc2 =  194; break; // vmaxud   vector double max
      case Pav_MAXS:    opc2 =  450; break; // vmaxsd   vector double max
      case Pav_MINU:    opc2 =  706; break; // vminud   vector double min
      case Pav_MINS:    opc2 =  962; break; // vminsd   vector double min
      case Pav_CMPEQU:  opc2 =  199; break; // vcmpequd vector double compare
      case Pav_CMPGTU:  opc2 =  711; break; // vcmpgtud vector double compare
      case Pav_CMPGTS:  opc2 =  967; break; // vcmpgtsd vector double compare
      case Pav_SHL:     opc2 = 1476; break; // vsld
      case Pav_SHR:     opc2 = 1732; break; // vsrd
      case Pav_SAR:     opc2 =  964; break; // vsrad
      case Pav_ROTL:    opc2 =  196; break; // vrld
      case Pav_PACKUU:  opc2 = 1102; break; // vpkudum
      case Pav_QPACKUU: opc2 = 1230; break; // vpkudus, vpksdus (emulated)
      case Pav_QPACKSS: opc2 = 1486; break; // vpksdsm
      case Pav_MRGHI:   opc2 = 1614; break; // vmrghw
      case Pav_MRGLO:   opc2 = 1742; break; // vmrglw
      case Pav_POLYMULADD: opc2 = 1096; break; // vpmsumd
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }
   case Pin_AvCipherV128Unary: {
      UInt v_dst = vregNo(i->Pin.AvCipherV128Unary.dst);
      UInt v_src = vregNo(i->Pin.AvCipherV128Unary.src);
      UInt opc2;
      switch (i->Pin.AvCipherV128Unary.op) {
      case Pav_CIPHERSUBV128:   opc2 =  1480; break; // vsbox
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_src, 0, opc2, endness_host );
      goto done;
   }
   case Pin_AvCipherV128Binary: {
      UInt v_dst  = vregNo(i->Pin.AvCipherV128Binary.dst);
      UInt v_srcL = vregNo(i->Pin.AvCipherV128Binary.srcL);
      UInt v_srcR = vregNo(i->Pin.AvCipherV128Binary.srcR);
      UInt opc2;
      switch (i->Pin.AvCipherV128Binary.op) {
      case Pav_CIPHERV128:     opc2 =  1288; break; // vcipher
      case Pav_CIPHERLV128:    opc2 =  1289; break; // vcipherlast
      case Pav_NCIPHERV128:    opc2 =  1352; break; // vncipher
      case Pav_NCIPHERLV128:   opc2 =  1353; break; // vncipherlast
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, opc2, endness_host );
      goto done;
   }
   case Pin_AvHashV128Binary: {
      UInt v_dst = vregNo(i->Pin.AvHashV128Binary.dst);
      UInt v_src = vregNo(i->Pin.AvHashV128Binary.src);
      PPCRI* s_field = i->Pin.AvHashV128Binary.s_field;
      UInt opc2;
      switch (i->Pin.AvHashV128Binary.op) {
      case Pav_SHA256:   opc2 =  1666; break; // vshasigmaw
      case Pav_SHA512:   opc2 =  1730; break; // vshasigmad
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, v_src, s_field->Pri.Imm, opc2, endness_host );
      goto done;
   }
   case Pin_AvBCDV128Trinary: {
      UInt v_dst  = vregNo(i->Pin.AvBCDV128Trinary.dst);
      UInt v_src1 = vregNo(i->Pin.AvBCDV128Trinary.src1);
      UInt v_src2 = vregNo(i->Pin.AvBCDV128Trinary.src2);
      PPCRI* ps   = i->Pin.AvBCDV128Trinary.ps;
      UInt opc2;
      switch (i->Pin.AvBCDV128Trinary.op) {
      case Pav_BCDAdd:   opc2 =  1; break; // bcdadd
      case Pav_BCDSub:   opc2 = 65; break; // bcdsub
      default:
         goto bad;
      }
      p = mkFormVXR( p, 4, v_dst, v_src1, v_src2,
                     0x1, (ps->Pri.Imm << 9) | opc2, endness_host );
      goto done;
   }
   case Pin_AvBin32Fx4: {
      UInt v_dst  = vregNo(i->Pin.AvBin32Fx4.dst);
      UInt v_srcL = vregNo(i->Pin.AvBin32Fx4.srcL);
      UInt v_srcR = vregNo(i->Pin.AvBin32Fx4.srcR);
      switch (i->Pin.AvBin32Fx4.op) {

      case Pavfp_ADDF:
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 10, endness_host );   // vaddfp
         break;
      case Pavfp_SUBF:
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 74, endness_host );   // vsubfp
         break;
      case Pavfp_MAXF:
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 1034, endness_host ); // vmaxfp
         break;
      case Pavfp_MINF:
         p = mkFormVX( p, 4, v_dst, v_srcL, v_srcR, 1098, endness_host ); // vminfp
         break;

      case Pavfp_MULF: {
         /* Make a vmulfp from a vmaddfp:
            load -0.0 (0x8000_0000) to each 32-bit word of vB
            this makes the add a noop.
         */
         UInt vB = 29;  // XXX: Using v29 for temp do not change
                        // without also changing
                        // getRegUsage_PPCInstr
         UInt konst = 0x1F;

         // Better way to load -0.0 (0x80000000) ?
         // vspltisw vB,0x1F   (0x1F => each word of vB)
         p = mkFormVX( p, 4, vB, konst, 0, 908, endness_host );

         // vslw vB,vB,vB (each word of vB = (0x1F << 0x1F) = 0x80000000
         p = mkFormVX( p, 4, vB, vB, vB, 388, endness_host );

         // Finally, do the multiply:
         p = mkFormVA( p, 4, v_dst, v_srcL, vB, v_srcR, 46, endness_host );
         break;
      }
      case Pavfp_CMPEQF:  // vcmpeqfp
         p = mkFormVXR( p, 4, v_dst, v_srcL, v_srcR, 0, 198, endness_host);
         break;
      case Pavfp_CMPGTF:  // vcmpgtfp
         p = mkFormVXR( p, 4, v_dst, v_srcL, v_srcR, 0, 710, endness_host );
         break;
      case Pavfp_CMPGEF:  // vcmpgefp
         p = mkFormVXR( p, 4, v_dst, v_srcL, v_srcR, 0, 454, endness_host );
         break;

      default:
         goto bad;
      }
      goto done;
   }

   case Pin_AvUn32Fx4: {
      UInt v_dst = vregNo(i->Pin.AvUn32Fx4.dst);
      UInt v_src = vregNo(i->Pin.AvUn32Fx4.src);
      UInt opc2;
      switch (i->Pin.AvUn32Fx4.op) {
      case Pavfp_RCPF:    opc2 =  266; break; // vrefp
      case Pavfp_RSQRTF:  opc2 =  330; break; // vrsqrtefp
      case Pavfp_CVTU2F:  opc2 =  778; break; // vcfux
      case Pavfp_CVTS2F:  opc2 =  842; break; // vcfsx
      case Pavfp_QCVTF2U: opc2 =  906; break; // vctuxs
      case Pavfp_QCVTF2S: opc2 =  970; break; // vctsxs
      case Pavfp_ROUNDM:  opc2 =  714; break; // vrfim
      case Pavfp_ROUNDP:  opc2 =  650; break; // vrfip
      case Pavfp_ROUNDN:  opc2 =  522; break; // vrfin
      case Pavfp_ROUNDZ:  opc2 =  586; break; // vrfiz
      default:
         goto bad;
      }
      p = mkFormVX( p, 4, v_dst, 0, v_src, opc2, endness_host );
      goto done;
   }

   case Pin_AvPerm: {  // vperm
      UInt v_dst  = vregNo(i->Pin.AvPerm.dst);
      UInt v_srcL = vregNo(i->Pin.AvPerm.srcL);
      UInt v_srcR = vregNo(i->Pin.AvPerm.srcR);
      UInt v_ctl  = vregNo(i->Pin.AvPerm.ctl);
      p = mkFormVA( p, 4, v_dst, v_srcL, v_srcR, v_ctl, 43, endness_host );
      goto done;
   }

   case Pin_AvSel: {  // vsel
      UInt v_ctl  = vregNo(i->Pin.AvSel.ctl);
      UInt v_dst  = vregNo(i->Pin.AvSel.dst);
      UInt v_srcL = vregNo(i->Pin.AvSel.srcL);
      UInt v_srcR = vregNo(i->Pin.AvSel.srcR);
      p = mkFormVA( p, 4, v_dst, v_srcL, v_srcR, v_ctl, 42, endness_host );
      goto done;
   }

   case Pin_AvSh: {  // vsl or vsr
      UInt v_dst  = vregNo(i->Pin.AvSh.dst);
      Bool  idxd = toBool(i->Pin.AvSh.addr->tag == Pam_RR);
      UInt r_idx, r_base;

      r_base = iregNo(i->Pin.AvSh.addr->Pam.RR.base, mode64);

      if (!idxd) {
         r_idx = 30; // XXX: Using r30 as temp
         p = mkLoadImm(p, r_idx,
                       i->Pin.AvSh.addr->Pam.IR.index, mode64, endness_host);
      } else {
         r_idx  = iregNo(i->Pin.AvSh.addr->Pam.RR.index, mode64);
      }

      if (i->Pin.AvSh.shLeft)
         //vsl VRT,RA,RB
         p = mkFormVXI( p, 31, v_dst, r_idx, r_base, 6, endness_host );
      else
         //vsr VRT,RA,RB
         p = mkFormVXI( p, 31, v_dst, r_idx, r_base, 38, endness_host );
      goto done;
   }

   case Pin_AvShlDbl: {  // vsldoi
      UInt shift  = i->Pin.AvShlDbl.shift;
      UInt v_dst  = vregNo(i->Pin.AvShlDbl.dst);
      UInt v_srcL = vregNo(i->Pin.AvShlDbl.srcL);
      UInt v_srcR = vregNo(i->Pin.AvShlDbl.srcR);
      vassert(shift <= 0xF);
      p = mkFormVA( p, 4, v_dst, v_srcL, v_srcR, shift, 44, endness_host );
      goto done;
   }

   case Pin_AvSplat: { // vsplt(is)(b,h,w)
      UInt v_dst = vregNo(i->Pin.AvShlDbl.dst);
      UChar sz   = i->Pin.AvSplat.sz;
      UInt v_src, opc2;
      vassert(sz == 8 || sz == 16 || sz == 32);

      if (i->Pin.AvSplat.src->tag == Pvi_Imm) {
         Char simm5;
         opc2 = (sz == 8) ? 780 : (sz == 16) ? 844 : 908;   // 8,16,32
         /* expects 5-bit-signed-imm */
         simm5 = i->Pin.AvSplat.src->Pvi.Imm5s;
         vassert(simm5 >= -16 && simm5 <= 15);
         simm5 = simm5 & 0x1F;
         p = mkFormVX( p, 4, v_dst, (UInt)simm5, 0, opc2, endness_host );
      }
      else {  // Pri_Reg
         UInt lowest_lane;
         opc2 = (sz == 8) ? 524 : (sz == 16) ? 588 : 652;  // 8,16,32
         vassert(hregClass(i->Pin.AvSplat.src->Pvi.Reg) == HRcVec128);
         v_src = vregNo(i->Pin.AvSplat.src->Pvi.Reg);
         lowest_lane = (128/sz)-1;
         p = mkFormVX( p, 4, v_dst, lowest_lane, v_src, opc2, endness_host );
      }
      goto done;
   }

   case Pin_AvCMov: {
      UInt v_dst     = vregNo(i->Pin.AvCMov.dst);
      UInt v_src     = vregNo(i->Pin.AvCMov.src);
      PPCCondCode cc = i->Pin.AvCMov.cond;

      if (v_dst == v_src) goto done;
      
      vassert(cc.test != Pct_ALWAYS);

      /* jmp fwds 2 insns if !condition */
      if (cc.test != Pct_ALWAYS) {
         /* bc !ct,cf,n_bytes>>2 */
         p = mkFormB(p, invertCondTest(cc.test), cc.flag, 8>>2, 0, 0,
                     endness_host);
      }
      /* vmr */
      p = mkFormVX( p, 4, v_dst, v_src, v_src, 1156, endness_host );
      goto done;
   }

   case Pin_AvLdVSCR: {  // mtvscr
      UInt v_src = vregNo(i->Pin.AvLdVSCR.src);
      p = mkFormVX( p, 4, 0, 0, v_src, 1604, endness_host );
      goto done;
   }

   case Pin_Dfp64Unary: {
      UInt fr_dst = fregNo( i->Pin.FpUnary.dst );
      UInt fr_src = fregNo( i->Pin.FpUnary.src );

      switch (i->Pin.Dfp64Unary.op) {
      case Pfp_MOV: // fmr, PPC32 p410
         p = mkFormX( p, 63, fr_dst, 0, fr_src, 72, 0, endness_host );
         break;
      case Pfp_DCTDP:   // D32 to D64
         p = mkFormX( p, 59, fr_dst, 0, fr_src, 258, 0, endness_host );
         break;
      case Pfp_DRSP:    // D64 to D32
         p = mkFormX( p, 59, fr_dst, 0, fr_src, 770, 0, endness_host );
         break;
      case Pfp_DCFFIX:   // I64 to D64 conversion
         /* ONLY WORKS ON POWER7 */
         p = mkFormX( p, 59, fr_dst, 0, fr_src, 802, 0, endness_host );
         break;
      case Pfp_DCTFIX:   // D64 to I64 conversion
         p = mkFormX( p, 59, fr_dst, 0, fr_src, 290, 0, endness_host );
         break;
      case Pfp_DXEX:     // Extract exponent
         p = mkFormX( p, 59, fr_dst, 0, fr_src, 354, 0, endness_host );
         break;                                
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_Dfp64Binary: {
      UInt fr_dst = fregNo( i->Pin.Dfp64Binary.dst );
      UInt fr_srcL = fregNo( i->Pin.Dfp64Binary.srcL );
      UInt fr_srcR = fregNo( i->Pin.Dfp64Binary.srcR );
      switch (i->Pin.Dfp64Binary.op) {
      case Pfp_DFPADD: /* dadd, dfp add, use default RM from reg ignore mode
                        * from the Iop instruction. */
         p = mkFormX( p, 59, fr_dst, fr_srcL, fr_srcR, 2, 0, endness_host );
         break;
      case Pfp_DFPSUB: /* dsub, dfp subtract, use default RM from reg ignore
                        * mode from the Iop instruction. */
         p = mkFormX( p, 59, fr_dst, fr_srcL, fr_srcR, 514, 0, endness_host );
         break;
      case Pfp_DFPMUL: /* dmul, dfp multipy, use default RM from reg ignore
                        * mode from the Iop instruction. */
         p = mkFormX( p, 59, fr_dst, fr_srcL, fr_srcR, 34, 0, endness_host );
         break;
      case Pfp_DFPDIV: /* ddiv, dfp divide, use default RM from reg ignore
                        * mode from the Iop instruction. */
         p = mkFormX( p, 59, fr_dst, fr_srcL, fr_srcR, 546, 0, endness_host );
         break;
      case Pfp_DIEX:  /* diex, insert exponent */
         p = mkFormX( p, 59, fr_dst, fr_srcL, fr_srcR, 866, 0, endness_host );
         break;
      default:
         goto bad;
      }
      goto done;
   }

   case Pin_DfpShift: {
      UInt fr_src = fregNo(i->Pin.DfpShift.src);
      UInt fr_dst = fregNo(i->Pin.DfpShift.dst);
      UInt shift;

      shift =  i->Pin.DfpShift.shift->Pri.Imm;

      switch (i->Pin.DfpShift.op) {
      case Pfp_DSCLI:    /* dscli, DFP shift left by fr_srcR */
         p = mkFormZ22( p, 59, fr_dst, fr_src, shift,  66, 0, endness_host );
         break;
      case Pfp_DSCRI:    /* dscri, DFP shift right by fr_srcR */
         p = mkFormZ22( p, 59, fr_dst, fr_src, shift,  98, 0, endness_host );
         break;
      default:
         vex_printf("ERROR: emit_PPCInstr default case\n");
         goto bad;
      }
      goto done;
   }

   case Pin_ExtractExpD128: {
      UInt fr_dst   = fregNo(i->Pin.ExtractExpD128.dst);
      UInt fr_srcHi = fregNo(i->Pin.ExtractExpD128.src_hi);
      UInt fr_srcLo = fregNo(i->Pin.ExtractExpD128.src_lo);

      switch (i->Pin.ExtractExpD128.op) {
      case Pfp_DXEXQ:                                                          
         /* Setup the upper and lower registers of the source operand
          * register pair.
          */
         p = mkFormX( p, 63, 12, 0, fr_srcHi, 72, 0, endness_host );
         p = mkFormX( p, 63, 13, 0, fr_srcLo, 72, 0, endness_host );
         p = mkFormX( p, 63, 10, 0, 12, 354, 0, endness_host );

         /* The instruction will put the 64-bit result in
          * register 10.
          */
         p = mkFormX(p, 63, fr_dst, 0, 10,  72, 0, endness_host);
         break;
      default:
         vex_printf("Error: emit_PPCInstr case Pin_DfpExtractExp, case inst Default\n");
         goto bad;
      }
      goto done;
   }
   case Pin_Dfp128Unary: {
     UInt fr_dstHi = fregNo(i->Pin.Dfp128Unary.dst_hi);
     UInt fr_dstLo = fregNo(i->Pin.Dfp128Unary.dst_lo);
     UInt fr_srcLo = fregNo(i->Pin.Dfp128Unary.src_lo);

     /* Do instruction with 128-bit source operands in registers (10,11)       
      * and (12,13).                                                           
      */
     switch (i->Pin.Dfp128Unary.op) {
     case Pfp_DCTQPQ: // D64 to D128, srcLo holds 64 bit operand              
        p = mkFormX( p, 63, 12, 0, fr_srcLo, 72, 0, endness_host );

        p = mkFormX( p, 63, 10, 0, 12, 258, 0, endness_host );

        /* The instruction will put the 128-bit result in
         * registers (10,11).  Note, the operand in the instruction only
         * reference the first of the two registers in the pair.
         */
        p = mkFormX(p, 63, fr_dstHi, 0, 10,  72, 0, endness_host);
        p = mkFormX(p, 63, fr_dstLo, 0, 11,  72, 0, endness_host);
        break;
     default:
        vex_printf("Error: emit_PPCInstr case Pin_Dfp128Unary, case inst Default\
\n");
        goto bad;
     }
     goto done;
   }

   case Pin_Dfp128Binary: {
      /* dst is used to supply the  left source operand and return
       * the result.
       */
      UInt fr_dstHi = fregNo( i->Pin.Dfp128Binary.dst_hi );
      UInt fr_dstLo = fregNo( i->Pin.Dfp128Binary.dst_lo );
      UInt fr_srcRHi = fregNo( i->Pin.Dfp128Binary.srcR_hi );
      UInt fr_srcRLo = fregNo( i->Pin.Dfp128Binary.srcR_lo );

      /* Setup the upper and lower registers of the source operand
       * register pair.
       */
      p = mkFormX( p, 63, 10, 0, fr_dstHi, 72, 0, endness_host );
      p = mkFormX( p, 63, 11, 0, fr_dstLo, 72, 0, endness_host );
      p = mkFormX( p, 63, 12, 0, fr_srcRHi, 72, 0, endness_host );
      p = mkFormX( p, 63, 13, 0, fr_srcRLo, 72, 0, endness_host );

      /* Do instruction with 128-bit source operands in registers (10,11)
       * and (12,13).
       */
      switch (i->Pin.Dfp128Binary.op) {
      case Pfp_DFPADDQ:
         p = mkFormX( p, 63, 10, 10, 12, 2, 0, endness_host );
         break;
      case Pfp_DFPSUBQ:
         p = mkFormX( p, 63, 10, 10, 12, 514, 0, endness_host );
         break;
      case Pfp_DFPMULQ:
         p = mkFormX( p, 63, 10, 10, 12, 34, 0, endness_host );
         break;
      case Pfp_DFPDIVQ:
         p = mkFormX( p, 63, 10, 10, 12, 546, 0, endness_host );
         break;
      default:
         goto bad;
      }

      /* The instruction will put the 128-bit result in
       * registers (10,11).  Note, the operand in the instruction only
       * reference the first of the two registers in the pair.
       */
      p = mkFormX(p, 63, fr_dstHi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dstLo, 0, 11,  72, 0, endness_host);
      goto done;
   }

   case Pin_DfpShift128: {
      UInt fr_src_hi = fregNo(i->Pin.DfpShift128.src_hi);
      UInt fr_src_lo = fregNo(i->Pin.DfpShift128.src_lo);
      UInt fr_dst_hi = fregNo(i->Pin.DfpShift128.dst_hi);
      UInt fr_dst_lo = fregNo(i->Pin.DfpShift128.dst_lo);
      UInt shift;

      shift =  i->Pin.DfpShift128.shift->Pri.Imm;

      /* setup source operand in register 12, 13 pair */
      p = mkFormX(p, 63, 12, 0, fr_src_hi, 72, 0, endness_host);
      p = mkFormX(p, 63, 13, 0, fr_src_lo, 72, 0, endness_host);

      /* execute instruction putting result in register 10, 11 pair */
      switch (i->Pin.DfpShift128.op) {
      case Pfp_DSCLIQ:    /* dscliq, DFP shift left, fr_srcR is the integer
                           * shift amount.
                           */
         p = mkFormZ22( p, 63, 10, 12, shift,  66, 0, endness_host );
         break;
      case Pfp_DSCRIQ:    /* dscriq, DFP shift right, fr_srcR is the integer
                           * shift amount.
                           */
         p = mkFormZ22( p, 63, 10, 12, shift,  98, 0, endness_host );
         break;
      default:
         vex_printf("ERROR: emit_PPCInstr quad default case %d \n",
                    i->Pin.DfpShift128.op);
         goto bad;
      }

      /* The instruction put the 128-bit result in registers (10,11). 
       * Note, the operand in the instruction only reference the first of 
       * the two registers in the pair.
       */
      p = mkFormX(p, 63, fr_dst_hi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dst_lo, 0, 11,  72, 0, endness_host);
      goto done;
   }

   case Pin_DfpRound: {
      UInt fr_dst = fregNo(i->Pin.DfpRound.dst);
      UInt fr_src = fregNo(i->Pin.DfpRound.src);
      UInt r_rmc, r, rmc;

      r_rmc =  i->Pin.DfpRound.r_rmc->Pri.Imm;
      r = (r_rmc & 0x8) >> 3;
      rmc = r_rmc & 0x3;

      // drintx
      p = mkFormZ23(p, 59, fr_dst, r, fr_src, rmc, 99, 0, endness_host);
      goto done;
   }

   case Pin_DfpRound128: {
      UInt fr_dstHi = fregNo(i->Pin.DfpRound128.dst_hi);
      UInt fr_dstLo = fregNo(i->Pin.DfpRound128.dst_lo);
      UInt fr_srcHi = fregNo(i->Pin.DfpRound128.src_hi);
      UInt fr_srcLo = fregNo(i->Pin.DfpRound128.src_lo);
      UInt r_rmc, r, rmc;

      r_rmc =  i->Pin.DfpRound128.r_rmc->Pri.Imm;
      r = (r_rmc & 0x8) >> 3;
      rmc = r_rmc & 0x3;

      /* Setup the upper and lower registers of the source operand 
       * register pair.
       */
      p = mkFormX(p, 63, 12, 0, fr_srcHi, 72, 0, endness_host);
      p = mkFormX(p, 63, 13, 0, fr_srcLo, 72, 0, endness_host);

      /* Do drintx instruction with 128-bit source operands in 
       * registers (12,13).  
       */
      p = mkFormZ23(p, 63, 10, r, 12, rmc, 99, 0, endness_host);

      /* The instruction will put the 128-bit result in 
       * registers (10,11).  Note, the operand in the instruction only 
       * reference the first of the two registers in the pair.
       */
      p = mkFormX(p, 63, fr_dstHi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dstLo, 0, 11,  72, 0, endness_host);
      goto done;
   }

   case Pin_DfpQuantize: {
      UInt fr_dst  = fregNo(i->Pin.DfpQuantize.dst);
      UInt fr_srcL = fregNo(i->Pin.DfpQuantize.srcL);
      UInt fr_srcR = fregNo(i->Pin.DfpQuantize.srcR);
      UInt rmc;

      rmc =  i->Pin.DfpQuantize.rmc->Pri.Imm;

      switch (i->Pin.DfpQuantize.op) {
      case Pfp_DQUA:
         p = mkFormZ23(p, 59, fr_dst, fr_srcL, fr_srcR, rmc, 3, 0, endness_host);
         break;
      case Pfp_RRDTR:
         p = mkFormZ23(p, 59, fr_dst, fr_srcL, fr_srcR, rmc, 35, 0, endness_host);
         break;
      default:
         break;
      }
      goto done;
   }

   case Pin_DfpQuantize128: {
      UInt fr_dst_hi = fregNo(i->Pin.DfpQuantize128.dst_hi);
      UInt fr_dst_lo = fregNo(i->Pin.DfpQuantize128.dst_lo);
      UInt fr_src_hi = fregNo(i->Pin.DfpQuantize128.src_hi);
      UInt fr_src_lo = fregNo(i->Pin.DfpQuantize128.src_lo);
      UInt rmc;

      rmc =  i->Pin.DfpQuantize128.rmc->Pri.Imm;
      /* Setup the upper and lower registers of the source operand 
       * register pairs.  Note, left source operand passed in via the
       * dst register pair.
       */
      p = mkFormX(p, 63, 10, 0, fr_dst_hi, 72, 0, endness_host);
      p = mkFormX(p, 63, 11, 0, fr_dst_lo, 72, 0, endness_host);
      p = mkFormX(p, 63, 12, 0, fr_src_hi, 72, 0, endness_host);
      p = mkFormX(p, 63, 13, 0, fr_src_lo, 72, 0, endness_host);

      /* Do dquaq instruction with 128-bit source operands in 
       * registers (12,13).  
       */
      switch (i->Pin.DfpQuantize128.op) {
      case Pfp_DQUAQ:
         p = mkFormZ23(p, 63, 10, 10, 12, rmc, 3, 0, endness_host);
         break;
      case Pfp_DRRNDQ:
         p = mkFormZ23(p, 63, 10, 10, 12, rmc, 35, 0, endness_host);
         break;
      default:
         vpanic("Pin_DfpQuantize128: default case, couldn't find inst to issue \n");
         break;
      }

      /* The instruction will put the 128-bit result in 
       * registers (10,11).  Note, the operand in the instruction only 
       * reference the first of the two registers in the pair.
       */
      p = mkFormX(p, 63, fr_dst_hi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dst_lo, 0, 11,  72, 0, endness_host);
      goto done;
   }

   case Pin_DfpD128toD64: {
      UInt fr_dst   = fregNo( i->Pin.DfpD128toD64.dst );
      UInt fr_srcHi = fregNo( i->Pin.DfpD128toD64.src_hi );
      UInt fr_srcLo = fregNo( i->Pin.DfpD128toD64.src_lo );

      /* Setup the upper and lower registers of the source operand
       * register pair.
       */
      p = mkFormX( p, 63, 10, 0, fr_dst, 72, 0, endness_host );
      p = mkFormX( p, 63, 12, 0, fr_srcHi, 72, 0, endness_host );
      p = mkFormX( p, 63, 13, 0, fr_srcLo, 72, 0, endness_host );

      /* Do instruction with 128-bit source operands in registers (10,11) */
      switch (i->Pin.Dfp128Binary.op) {
      case Pfp_DRDPQ:
         p = mkFormX( p, 63, 10, 0, 12, 770, 0, endness_host );
         break;
      case Pfp_DCTFIXQ:
         p = mkFormX( p, 63, 10, 0, 12, 290, 0, endness_host );
         break;
      default:
         goto bad;
      }

      /* The instruction will put the 64-bit result in registers 10. */
      p = mkFormX(p, 63, fr_dst, 0, 10,  72, 0, endness_host);
      goto done;
   }

   case Pin_DfpI64StoD128: {
      UInt fr_dstHi = fregNo( i->Pin.DfpI64StoD128.dst_hi );
      UInt fr_dstLo = fregNo( i->Pin.DfpI64StoD128.dst_lo );
      UInt fr_src   = fregNo( i->Pin.DfpI64StoD128.src );

      switch (i->Pin.Dfp128Binary.op) {
      case Pfp_DCFFIXQ:
         p = mkFormX( p, 63, 10, 11, fr_src, 802, 0, endness_host );
         break;
      default:
         goto bad;
      }

      /* The instruction will put the 64-bit result in registers 10, 11. */
      p = mkFormX(p, 63, fr_dstHi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dstLo, 0, 11,  72, 0, endness_host);
      goto done;
   }

   case Pin_InsertExpD128: {
      UInt fr_dstHi  = fregNo(i->Pin.InsertExpD128.dst_hi);
      UInt fr_dstLo  = fregNo(i->Pin.InsertExpD128.dst_lo);
      UInt fr_srcL   = fregNo(i->Pin.InsertExpD128.srcL);
      UInt fr_srcRHi = fregNo(i->Pin.InsertExpD128.srcR_hi);
      UInt fr_srcRLo = fregNo(i->Pin.InsertExpD128.srcR_lo);

      /* The left operand is a single F64 value, the right is an F128
       * register pair.
       */
      p = mkFormX(p, 63, 10, 0, fr_srcL, 72, 0, endness_host);
      p = mkFormX(p, 63, 12, 0, fr_srcRHi, 72, 0, endness_host);
      p = mkFormX(p, 63, 13, 0, fr_srcRLo, 72, 0, endness_host);
      p = mkFormX(p, 63, 10, 10, 12, 866, 0, endness_host );

      /* The instruction will put the 128-bit result into
       * registers (10,11).  Note, the operand in the instruction only
       * reference the first of the two registers in the pair.
       */
      p = mkFormX(p, 63, fr_dstHi, 0, 10,  72, 0, endness_host);
      p = mkFormX(p, 63, fr_dstLo, 0, 11,  72, 0, endness_host);
      goto done;
   }                                                                           

   case Pin_Dfp64Cmp:{
      UChar crfD    = 1;
      UInt  r_dst   = iregNo(i->Pin.Dfp64Cmp.dst, mode64);
      UInt  fr_srcL = fregNo(i->Pin.Dfp64Cmp.srcL);
      UInt  fr_srcR = fregNo(i->Pin.Dfp64Cmp.srcR);
      vassert(crfD < 8);
      // dcmpo, dcmpu
      p = mkFormX(p, 59, crfD<<2, fr_srcL, fr_srcR, 130, 0, endness_host);

      // mfcr (mv CR to r_dst)
      p = mkFormX(p, 31, r_dst, 0, 0, 19, 0, endness_host);

      // rlwinm r_dst,r_dst,8,28,31
      //  => rotate field 1 to bottomw of word, masking out upper 28
      p = mkFormM(p, 21, r_dst, r_dst, 8, 28, 31, 0, endness_host);
      goto done;
   }

   case Pin_Dfp128Cmp: {
      UChar crfD       = 1;
      UInt  r_dst      = iregNo(i->Pin.Dfp128Cmp.dst, mode64);
      UInt  fr_srcL_hi = fregNo(i->Pin.Dfp128Cmp.srcL_hi);
      UInt  fr_srcL_lo = fregNo(i->Pin.Dfp128Cmp.srcL_lo);
      UInt  fr_srcR_hi = fregNo(i->Pin.Dfp128Cmp.srcR_hi);
      UInt  fr_srcR_lo = fregNo(i->Pin.Dfp128Cmp.srcR_lo);
      vassert(crfD < 8);
      // dcmpoq, dcmpuq
      /* Setup the upper and lower registers of the source operand
       * register pair.
       */
      p = mkFormX(p, 63, 10, 0, fr_srcL_hi, 72, 0, endness_host);
      p = mkFormX(p, 63, 11, 0, fr_srcL_lo, 72, 0, endness_host);
      p = mkFormX(p, 63, 12, 0, fr_srcR_hi, 72, 0, endness_host);
      p = mkFormX(p, 63, 13, 0, fr_srcR_lo, 72, 0, endness_host);

      p = mkFormX(p, 63, crfD<<2, 10, 12, 130, 0, endness_host);

      // mfcr (mv CR to r_dst)
      p = mkFormX(p, 31, r_dst, 0, 0, 19, 0, endness_host);

      // rlwinm r_dst,r_dst,8,28,31
      //  => rotate field 1 to bottomw of word, masking out upper 28
      p = mkFormM(p, 21, r_dst, r_dst, 8, 28, 31, 0, endness_host);
      goto done;
   }

   case Pin_EvCheck: {
      /* This requires a 32-bit dec/test in both 32- and 64-bit
         modes. */
      /* We generate:
            lwz     r30, amCounter
            addic.  r30, r30, -1
            stw     r30, amCounter
            bge     nofail
            lwz/ld  r30, amFailAddr
            mtctr   r30
            bctr
           nofail:
      */
      UChar* p0 = p;
      /* lwz r30, amCounter */
      p = do_load_or_store_word32(p, True/*isLoad*/, /*r*/30,
                                  i->Pin.EvCheck.amCounter, mode64,
                                  endness_host);
      /* addic. r30,r30,-1 */
      p = emit32(p, 0x37DEFFFF, endness_host);
      /* stw r30, amCounter */
      p = do_load_or_store_word32(p, False/*!isLoad*/, /*r*/30,
                                  i->Pin.EvCheck.amCounter, mode64,
                                  endness_host);
      /* bge nofail */
      p = emit32(p, 0x40800010, endness_host);
      /* lwz/ld r30, amFailAddr */
      p = do_load_or_store_machine_word(p, True/*isLoad*/, /*r*/30,
                                        i->Pin.EvCheck.amFailAddr, mode64,
                                        endness_host);
      /* mtctr r30 */
      p = mkFormXFX(p, /*r*/30, 9, 467, endness_host);
      /* bctr */
      p = mkFormXL(p, 19, Pct_ALWAYS, 0, 0, 528, 0, endness_host);
      /* nofail: */

      /* Crosscheck */
      vassert(evCheckSzB_PPC() == (UChar*)p - (UChar*)p0);
      goto done;
   }

   case Pin_ProfInc: {
      /* We generate:
               (ctrP is unknown now, so use 0x65556555(65556555) in the
               expectation that a later call to LibVEX_patchProfCtr
               will be used to fill in the immediate fields once the
               right value is known.)
            32-bit:
              imm32-exactly r30, 0x65556555
              lwz     r29, 4(r30)
              addic.  r29, r29, 1
              stw     r29, 4(r30)
              lwz     r29, 0(r30)
              addze   r29, r29
              stw     r29, 0(r30)
            64-bit:
              imm64-exactly r30, 0x6555655565556555
              ld      r29, 0(r30)
              addi    r29, r29, 1
              std     r29, 0(r30)
      */
      if (mode64) {
         p = mkLoadImm_EXACTLY2or5(
                p, /*r*/30, 0x6555655565556555ULL, True/*mode64*/, endness_host);
         p = emit32(p, 0xEBBE0000, endness_host);
         p = emit32(p, 0x3BBD0001, endness_host);
         p = emit32(p, 0xFBBE0000, endness_host);
      } else {
         p = mkLoadImm_EXACTLY2or5(
                p, /*r*/30, 0x65556555ULL, False/*!mode64*/, endness_host);
         p = emit32(p, 0x83BE0004, endness_host);
         p = emit32(p, 0x37BD0001, endness_host);
         p = emit32(p, 0x93BE0004, endness_host);
         p = emit32(p, 0x83BE0000, endness_host);
         p = emit32(p, 0x7FBD0194, endness_host);
         p = emit32(p, 0x93BE0000, endness_host);
      }
      /* Tell the caller .. */
      vassert(!(*is_profInc));
      *is_profInc = True;
      goto done;
   }

   default: 
      goto bad;
   }

  bad:
   vex_printf("\n=> ");
   ppPPCInstr(i, mode64);
   vpanic("emit_PPCInstr");
   /*NOTREACHED*/
   
  done:
   vassert(p - &buf[0] <= 64);
   return p - &buf[0];
}


/* How big is an event check?  See case for Pin_EvCheck in
   emit_PPCInstr just above.  That crosschecks what this returns, so
   we can tell if we're inconsistent. */
Int evCheckSzB_PPC (void)
{
  return 28;
}


/* NB: what goes on here has to be very closely coordinated with the
   emitInstr case for XDirect, above. */
VexInvalRange chainXDirect_PPC ( VexEndness endness_host,
                                 void* place_to_chain,
                                 const void* disp_cp_chain_me_EXPECTED,
                                 const void* place_to_jump_to,
                                 Bool  mode64 )
{
   if (mode64) {
      vassert((endness_host == VexEndnessBE) ||
              (endness_host == VexEndnessLE));
   } else {
      vassert(endness_host == VexEndnessBE);
   }

   /* What we're expecting to see is:
        imm32/64-fixed r30, disp_cp_chain_me_to_EXPECTED
        mtctr r30
        bctrl
      viz
        <8 or 20 bytes generated by mkLoadImm_EXACTLY2or5>
        7F C9 03 A6
        4E 80 04 21
   */
   UChar* p = (UChar*)place_to_chain;
   vassert(0 == (3 & (HWord)p));
   vassert(isLoadImm_EXACTLY2or5(p, /*r*/30,
                                 (Addr)disp_cp_chain_me_EXPECTED,
                                 mode64, endness_host));
   vassert(fetch32(p + (mode64 ? 20 : 8) + 0, endness_host) == 0x7FC903A6);
   vassert(fetch32(p + (mode64 ? 20 : 8) + 4, endness_host) == 0x4E800421);
   /* And what we want to change it to is:
        imm32/64-fixed r30, place_to_jump_to
        mtctr r30
        bctr
      viz
        <8 or 20 bytes generated by mkLoadImm_EXACTLY2or5>
        7F C9 03 A6
        4E 80 04 20
      The replacement has the same length as the original.
   */
   p = mkLoadImm_EXACTLY2or5(p, /*r*/30,
                             (Addr)place_to_jump_to, mode64, 
                             endness_host);
   p = emit32(p, 0x7FC903A6, endness_host);
   p = emit32(p, 0x4E800420, endness_host);

   Int len = p - (UChar*)place_to_chain;
   vassert(len == (mode64 ? 28 : 16)); /* stay sane */
   VexInvalRange vir = {(HWord)place_to_chain, len};
   return vir;
}


/* NB: what goes on here has to be very closely coordinated with the
   emitInstr case for XDirect, above. */
VexInvalRange unchainXDirect_PPC ( VexEndness endness_host,
                                   void* place_to_unchain,
                                   const void* place_to_jump_to_EXPECTED,
                                   const void* disp_cp_chain_me,
                                   Bool  mode64 )
{
   if (mode64) {
      vassert((endness_host == VexEndnessBE) ||
              (endness_host == VexEndnessLE));
   } else {
      vassert(endness_host == VexEndnessBE);
   }

   /* What we're expecting to see is:
        imm32/64-fixed r30, place_to_jump_to_EXPECTED
        mtctr r30
        bctr
      viz
        <8 or 20 bytes generated by mkLoadImm_EXACTLY2or5>
        7F C9 03 A6
        4E 80 04 20
   */
   UChar* p = (UChar*)place_to_unchain;
   vassert(0 == (3 & (HWord)p));
   vassert(isLoadImm_EXACTLY2or5(p, /*r*/30,
                                 (Addr)place_to_jump_to_EXPECTED,
                                 mode64, endness_host));
   vassert(fetch32(p + (mode64 ? 20 : 8) + 0, endness_host) == 0x7FC903A6);
   vassert(fetch32(p + (mode64 ? 20 : 8) + 4, endness_host) == 0x4E800420);
   /* And what we want to change it to is:
        imm32/64-fixed r30, disp_cp_chain_me
        mtctr r30
        bctrl
      viz
        <8 or 20 bytes generated by mkLoadImm_EXACTLY2or5>
        7F C9 03 A6
        4E 80 04 21
      The replacement has the same length as the original.
   */
   p = mkLoadImm_EXACTLY2or5(p, /*r*/30,
                             (Addr)disp_cp_chain_me, mode64, 
                             endness_host);
   p = emit32(p, 0x7FC903A6, endness_host);
   p = emit32(p, 0x4E800421, endness_host);

   Int len = p - (UChar*)place_to_unchain;
   vassert(len == (mode64 ? 28 : 16)); /* stay sane */
   VexInvalRange vir = {(HWord)place_to_unchain, len};
   return vir;
}


/* Patch the counter address into a profile inc point, as previously
   created by the Pin_ProfInc case for emit_PPCInstr. */
VexInvalRange patchProfInc_PPC ( VexEndness endness_host,
                                 void*  place_to_patch,
                                 const ULong* location_of_counter,
                                 Bool   mode64 )
{
   if (mode64) {
      vassert((endness_host == VexEndnessBE) ||
              (endness_host == VexEndnessLE));
   } else {
      vassert(endness_host == VexEndnessBE);
   }

   UChar* p = (UChar*)place_to_patch;
   vassert(0 == (3 & (HWord)p));

   Int len = 0;
   if (mode64) {
      vassert(isLoadImm_EXACTLY2or5(p, /*r*/30,
                                    0x6555655565556555ULL, True/*mode64*/,
                                    endness_host));
      vassert(fetch32(p + 20, endness_host) == 0xEBBE0000);
      vassert(fetch32(p + 24, endness_host) == 0x3BBD0001);
      vassert(fetch32(p + 28, endness_host) == 0xFBBE0000);
      p = mkLoadImm_EXACTLY2or5(p, /*r*/30,
                                (Addr)location_of_counter,
                                True/*mode64*/, endness_host);
      len = p - (UChar*)place_to_patch;
      vassert(len == 20);
   } else {
      vassert(isLoadImm_EXACTLY2or5(p, /*r*/30,
                                    0x65556555ULL, False/*!mode64*/, 
                                    endness_host));
      vassert(fetch32(p +  8, endness_host) == 0x83BE0004);
      vassert(fetch32(p + 12, endness_host) == 0x37BD0001);
      vassert(fetch32(p + 16, endness_host) == 0x93BE0004);
      vassert(fetch32(p + 20, endness_host) == 0x83BE0000);
      vassert(fetch32(p + 24, endness_host) == 0x7FBD0194);
      vassert(fetch32(p + 28, endness_host) == 0x93BE0000);
      p = mkLoadImm_EXACTLY2or5(p, /*r*/30,
                                (Addr)location_of_counter,
                                False/*!mode64*/, endness_host);
      len = p - (UChar*)place_to_patch;
      vassert(len == 8);
   }
   VexInvalRange vir = {(HWord)place_to_patch, len};
   return vir;
}


/*---------------------------------------------------------------*/
/*--- end                                     host_ppc_defs.c ---*/
/*---------------------------------------------------------------*/